GNU C Compiler Internals/GCC Hacks

Function overloading as in C++
This example was presented previously.

Invoke a block of code from a function as in Ruby
Linux implementation of lists allows to invoke a block of code on each element of the list:

pagelist.c:

list_for_each_prev(pos, head) { struct nfs_page *p = nfs_list_entry(pos); if (page_index(p->wb_page) < pg_idx) break; }

list_for_each_prev takes the code in the brackets as a parameter. The trick is to use a macro that rolls out to a for loop whose body becomes the code in the brackets. The goal of this project is to allow programmers to use code blocks in function calls.

Dereference function results when a structure is returned
C allows one to dereference the return value of a function if it is a pointer to a structure:

get_struct->field=0;

If the function returns the structure, not a pointer to it, then a compile-time error is generated:

get_struct.field=0; > request for member `field' in something not a structure or union

This extension addresses the problem of dereferencing structures that are return values.

Use functions to initialize a variable
When a variable is defined and initialized the initializers is constant. You will get an error if you try to use a function, no matter what this function is:

int getint { return 1; } int i=getint; > initializer element is not constant

When a variable is used the function it was initialized with is called.

Default values of function arguments as in C++
void func(int a=0) { printf("a=%d\n", a); } int main { func; } > syntax error before '=' token

Reference parameters as in C++
void test(int &a, int &b); int x,y; test(x,y);

Return address protection (RAD)
Rad

Repair of control-hijacking attacks (DIRA)
Dira

Array bounds checking using segmentation hardware (CASH)
Cash

Detecting interger overflows (DIVINE)
Divine

Develop in userland, install in kernel (DUSK)
Dusk

Dynamic Information Flow Tracking (GDIF)
Gdif

GCC switches in object file
GCC switches in object file

The -fstack-protector feature
GCC 4.1 implements a protection mechanism against buffer overflow attacks and exposes it to a programmer with a -fstack-protector option. This is an example of functionality that benefits from modular implementation because it has nothing to do with core functionality of the compiler. Does GCC have enough hooks to implement -fstack-protector module?