New GCC takes 19x as long to compile my program (compared to old GCC), plus void** patch suggestion

[Elmar Krieger]

Dear all,

while I fully understand that GCC's steadily advancing optimization 
capabilities can't be 'for free', the latest versions have become almost 
unusably slow for me:

With simple optimization -O, compiling a certain C source file (~60000 
lines) now takes 4.5 minutes, while older GCCs did it in 14 seconds 
(that's 19x as long, requiring a cup of coffee after each code change). 
(Core i7 CPU).

For completeness, these are the GCC versions:

Slow with 264 seconds:

i686-linux-android-gcc (GCC) 4.6.x-google 20120106 (prerelease)
Copyright (C) 2011 Free Software Foundation, Inc.

Fast with 14 seconds:

i386-mingw32msvc-gcc (GCC) 3.2.3 (mingw special 20030504-1)
Copyright (C) 2002 Free Software Foundation, Inc.

The slowdown is not the same with other files, so I'm essentially sure 
that this specific source file has some 'feature' that catches GCC at 
the wrong leg. This raises my hopes that one of the GCC experts wants to 
take a look at it. The code is confidential, but if you agree on one 
expert to have a look, I'll provide it privately (please contact elmar 
_at_ cmbi.ru.nl). Could be related to the fact that this particular 
source file contains the application's main loop, a single large 
function with 28000 lines.


One other thing I just thought of: GCC has a history of very smart 
extensions to C that allow to write faster and more elegant code. If I 
look at my code, there are mostly two sources of 'dirty hacks' left. One 
that could be fixed easily is the 'void** pointer problem', that 
clutters my code with nasty explicit type casts:

A simple example is the function freesetnull, that frees a pointer and 
sets it NULL (ptradd is a pointer address):

void freesetnull(void **ptradd)
{ free(*ptradd);
   *ptradd=NULL; }

Unfortunately, this function cannot be used in practice, because calling 
it yields an error:

error: passing argument 1 of ‘freesetnull’ from incompatible pointer type
note: expected ‘void **’ but argument is of type ‘char **’
[or whatever pointer you want to free]


If I understand correctly from a Usenet discussion, the reason for this 
error is that the C standard allows pointers to have different sizes (so 
sizeof(void*) might be larger than sizeof(int*) or so).

To get rid of this error, I need to sacrifice type safety and clutter my 
code with explicit casts, e.g.

void freesetnull(void *ptradd)
{ free(*(void**)ptradd);
   *(void**)ptradd=NULL; }

But since I've never seen such an exotic architecture with different 
pointer sizes and am 100% certain that my application will never run on 
such an architecture, I feel the strong need to sit down and contribute 
a GCC patch that turns this error into a warning that can be disabled 
(on mainstream architectures where all pointers have the same size).

To me, that just looks like a remnant from the ancient past that hinders 
the future. On the other hand, my feeling tells me that this patch would 
not be accepted, that's why I'm asking for my chances in advance ;-)

Best regards and many thanks,
Elmar