Re: Q: access to subprogram

[kenner@lab.ultra.nyu.edu (Richard Kenner)]

In article <xe1enmnmvjn.fsf@maneki-neko.cygnus.com> Mark Eichin <eichin@cygnus.com> writes:
>If I remember correctly, the other big reason is that reading
>externally generated rtl or tree structures would make non-Free
>frontends possible, and that would be a Bad Thing. This way anything
>that takes advantage of the backend needs to also be Free.

The other big reason for what?

What you state is true, but I don't see it having any relevance.

The RTL generated is always customized for a machine, so writing RTL
would not allow one to split off a backend into a separate program.
Tree structures are mostly machine-independent (but not fully, since
size information is encoded into them), but GCC does not operate by
forming a tree for a function and then compiling it (the interface
from the front end to the rest of the compiler is more procedural), so
"writing the tree" out is not meaningful since it never exists.

Some front-ends to GCC (most notably those for Fortran and Ada)
operate by generating a separate tree structure (usually in a
different format) for a function or file and then walking that tree by
making calls to GCC.  In such a case it indeed is somewhat possible to
write out such a tree and separate the front end from GCC.  I can't
speak for Fortran, but can say this is now impractical for Ada.  As
part of the bootstrap process, this used to be done, but there are now
numerous calls from the tree walk routines back into the Ada front
end.  Also, the tree is not machine-independent because sizes of
predefined types are machine-specific.  (Aside from the reason given
by Mark, it would also be inefficient to do this split due to the
amount of I/O required, so this is not only not easy but undesirable.)