[Bug c/98313] New: Allow __attribute__((cleanup)) in types

[david at westcontrol dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98313

            Bug ID: 98313
           Summary: Allow __attribute__((cleanup)) in types
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c
          Assignee: unassigned at gcc dot gnu.org
          Reporter: david at westcontrol dot com
  Target Milestone: ---

The gcc __attribute__((cleanup)) feature can be useful for making the
equivalent of a C++ destructor in C code, as a way of ensuring resources are
freed even if you exit a function early with return.  Typical use-cases are
malloc'ed memory and locks.

In many situations, attaching the cleanup attribute to a type would give neater
code with fewer chances of error.  For example:

void indirect_free(void ** p)  {
    free(*p);
    *p = 0;
}

extern void do_something(int * p);

void foo(void) {
    void * p = malloc(16);
    do_something(p);
    free(p);
}

void foo2(void) {
    __attribute__((cleanup(indirect_free)))
    void * p = malloc(16);
    do_something(p);
}

Here, the cleanup attribute in "foo2" means you don't have to remember to free
p after calling do_something() - and if the function has multiple allocations,
this results in neater code with lower risk of bugs than a "traditional"
goto-based error handling.  But you still have to remember to put the cleanup
attribute on each relevant pointer.

If instead you had:

typedef __attribute__((cleanup(indirect_free))) void* auto_voidp;

auto_voidp auto_malloc(size_t size) {
    return malloc(size);
}


then your code could be:

void foo3(void) {
    void * p = auto_malloc(16);
    do_something(p);
}


It would not remove all possibilities of error - copying an auto_voidp here
could easily lead to double-free errors.  (But this is C, not C++ - we need to
leave /some/ fun for the people debugging the code...)


Basically, all I'd like here is that if you attach a cleanup attribute to a
type (struct, typedef, etc.), then the attribute is automatically applied to
any definitions of variables of that type.