GCC IMA & general future proposal

[Kenneth Zadeck]

There are significant advantages to do doing a fair amount of 
optimization while you still have only a single file before you dump the 
il to the object file.

1) The techniques that one would use for a single file are different 
than those that one can consider over an entire program.  There are 
significant power vs scaling tradeoffs in algorithm selection.  For 
instance at the single file level, almost all of the algorithms one 
would use are flow sensitive.  At the link level almost all of the 
techniques will have to be flow insensitive.

2) The more of the computation time you are able to push to the earlier 
compiler, the better the user experience will be, especially in the late 
debugging and change cycle.  Anytime anything changes, you are starting 
the link level from scratch, in a development only one module changes, 
having pushed most of the heavy lifting to the earlier compile will be a 
big win.  While some of the compiler will surely be common between the 
link level and the front level, you have to assume that there are going 
to be a lot of differences. 

I would also point out that a significant number of people are not going 
to be able to use the full power of the link level stuff, so putting all 
smarts there may not be the best plan.  Programs that require dynamic 
libraries or that dynamicly load modules (like operating systems) may 
not work with this without significant engineering on their build 
scripts to describe where the boundaries are and what can pass over 
them.  The structure stuff that is being done at Apple is based on a 
completely closed world assumption that the only library is the standard 
c library.  Fine for benchmarks and the compiler, but may not be so good 
for a big gooey applications.

I should point out that the intel compiler is a bad example to base 
anything on.  It is simply a marketing tool to sell more processors and 
as such is designed to make benchmarks run particularly well on intel 
hardware.  Anything else is not so good.  Remember that this is the 
compiler that generates delibertly bad code to be used when you run on 
an amd chip.
It detects the cpu model and refuses to use any vector instructions even 
though it knows the amd chips have them.  As such, they have guaranteed 
that no one will use the compiler for anything except benchmarking. The 
ibm compiler is a better model.  This is the compiler that is used to 
develop all ibm applications.

Kenny

Geoff Keating wrote:

> I've put a quick draft of my idea of what the future of GCC should 
> look like at
>
> <http://www.geoffk.org/gcc/future/gccfuture.html>
>
> It's short, but has a complicated diagram.  It is intended for 
> discussion at the meeting in a few hours.