This is the mail archive of the mailing list for the GCC project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

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

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_ 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,

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]