Useful C extensions (gcc specific)

You think that knowing ANSI C is enough? Well, okay, it's enough. But I found that some gcc extensions are very useful.

All gcc C extensions are listed in the manual.

Here are the extensions I use:

Labels as values
I remember the old assembler days, when you could jmp to to an address from an array. Nowadays in C, you can create an array of pointers to functions and call pointer from array. But jmp is faster and sometimes you don't want to create many small, almost useless functions.

In gcc you can use a trick that's called labels as values. It's like that:

int main(){
    int value  = 2;
    const void *labels[] = {&&val_0, &&val_1, &&val_2};
    goto *labels[value];
    val_0:
        printf("The value is 0\n");
        goto end;
    val_1:
        printf("The value is 1\n");
        goto end;
    val_2:
        printf("The value is 2\n");
        goto end;
    end:
    return(0);
}

Macros as functions
Here is a standard example of a macro with statements that returns a value. It's also a great example of typeof operator in gcc.

#define MAX(a,b)                    \
    ({                              \
    typeof (a) _a = (a);            \
    typeof (b) _b = (b);            \
    _a > _b ? _a : _b; })

Case ranges
Gcc allows to use ranges in case statement. In ANSI C you'd have to enumerate all the values. This code is much prettier:

int main(){
    int value  = 7;
    switch(value){
    case 0 ... 5:
        printf("The value is 0 - 5\n");
        break;
    case 6 ... 10:
        printf("The value is 6 - 10\n");
        break;
    default:
        printf("The value is ?\n");
    }
    return(0);
}

Likely
Have you ever wondered how does gcc convert if statement to assembler, how many branches are created by the compiler? For example here, how many jmp instructions processor must do in the foo() function?

int foo(int i){
    if(i == 0)
        return(1);
    return(2);
}

int main(){
    foo(0);
}

In this case you know more than a compiler. You know that all callings to the foo() are going to be with "0" as the parameter. You can suggest compiler to optimize this by using __builtin_expect and possibly reduce number of jumps.

int foo(int i){
    if(__builtin_expect(i == 0, 1))
        return(1);
    return(2);
}

There are often defined macros:

#define likely(x)    __builtin_expect(!!(x), 1)
#define unlikely(x)    __builtin_expect(!!(x), 0)

Vector extensions
This very powerful extension allows to use mmx/sse code in a portable way. Gcc would choose the best possible extensions during compile time. When you compile code without mmx/sse options, the binary will remain compatible with i386. The downside is that this extension doesn't allow to use all of the features of mmx/sse.

From my point of view the most important feature is to use the bitwise commands. For example this would do binary or on 128 bits:

typedef union{
    int v __attribute__ ((vector_size (16)));
    int i[4];
} __vec_int;


int main(){
    __vec_int a, b, c;
    a.i[0] = 1; a.i[1] = 1; a.i[2] = 1; a.i[3] = 1;
    b.i[0] = 1; b.i[1] = 2; b.i[2] = 3; b.i[3] = 4;
    
    /* do OR here on 128 bits */
    c.v = b.v | a.v;
    ...
}

Sometimes there is a need of using more advanced mmx commands than vector extensions allow. For example you may want to do four compares at a time. Unfortunately this code is specific for sse2 (-msse2).

int main(){
    __vec_int a,b;
    a.v = set_vec_int(1,2,3,4);
    b.v = set_vec_int(4,3,2,1);
    
    /* compare greater than on __m128i */
        __vec_int c;
        c.v = _mm_cmpgt_epi32(a.v, b.v);    /* 0xFFFFFFFF if gt, 0 else*/
    
    printf("a=[%i,%i,%i,%i]\n", a.s[0], a.s[1], a.s[2], a.s[3]);
    printf("b=[%i,%i,%i,%i]\n", b.s[0], b.s[1], b.s[2], b.s[3]);
    printf("c=[%u,%u,%u,%u]\n", c.s[0] ? 1 : 0, c.s[1] ? 1 : 0, c.s[2] ? 1 : 0, c.s[3] ? 1 : 0);
    
    return(0);
}

Command used here _mm_cmpgt_epi32 is ported from Intel compiler, the best documentation for this dialect I found on Microsoft sites. You may want to use gcc equivalent. By the way, don't forget that the sse2 registers (__m128i) must be aligned to 16 bytes (-mpreferred-stack-boundary=4).


Cache stuff
Sometimes it's possible to optimize code by prefetching data. It's quite simple to prefetch data to one line of cache:

__builtin_prefetch(&data[offset], 1); /* 0 - read only, 1 - rw */

On the other hand you may want to store the data without polluting the caches. If you only want to write data (and it's not currently loaded to cache) it could be faster than standard storing. I use this defs (oh. it's mmx specific):

#ifndef MMX
#define STORE(ptr, val)        \
    do{            \
        *(ptr) = (val);    \
    }while(0)
#else
#define STORE(ptr, val)        \
    do{            \
        _mm_stream_si32( (ptr), (val) );    \
    }while(0)

#endif

More?
There are more interesting extensions. Like advanced assembler operands or macros with variable number of arguments.