RE01 Rice Brian T. EM2
Mon, 4 Jan 1999 13:15:20 +0300
> David> If you consider this just 'some level of translation' and
> David> 'some other level of translation', it may make a bit more
> David> sense. Imagine using a 'lisp -> C' compiler (which exists
> David> TODAY). In Tunes, we would hope that even after the
> David> translation, you could go in and change the C code, and see
> David> the change reflected in the lisp code. The translations are
> David> not just 'one shot' operations, but instead they are links
> David> between two different representations of the same piece of
> David> functionality.
> Translating Lisp to C looks alright to me, but modifying the generated
> C scares me. And I don't think that it is possible to to compute
> change in the lisp source for any change you can make in the C
> corresponding source. Because they do not handle the same concepts. C
> is lower level than Lisp. You can write equivalent programs in C and
> Lisp, but I doubt that you can compute a Lisp source equivalent to a
> C source in a reasonable amount of time. And I don't see why I would
> want to do it.
yes. it sounds like you would be asking the system to find an inverse
translation function on whole pieces of target code that would be meaningful
to the original source. that's asking a bit much, probably.
> I'd rather have an open compiler to which I can add optimization rules
> than build hand crafted otpimisations for every functions.
exactly. perhaps if the system, while compiling, created a system of links
between source, intermediate, and assembled code, then the
'hand-optimizations' could be used to teach the compiler 'by example' how to
optimize in some more general case. of course, this would require an
extensive understanding by the software of the compilation process. also,
there would be cases where the general case of the hand-optimization would
not be worth the effort, but if we allow the system to analyze the effects
of adding compilation techniques, then it could filter those out where
necessary, based on predicted time-constraints for the various kinds of
compilation (i.e. single-pass vs. fully-optimized).