Source-to-Source compilers?

Hello everyone,
I have a "one-million dollars" question... and I am really interested
in your opinion.


I am working in the optimization of parallel applications for multi-
core architectures. We don't want to auto-parallelize code but take a
parallel application (mainly written in C/C++ or Fortran) and produce
the optimized version via application of transformations.


Now most of these transformation should be done at source level, so
our need is for something able to do source-to-source compilation. As
now, the only tools that fulfill our requirements are 2.


ROSE (http://www.rosecompiler.org/) is a source-to-source compiler
which aims to work with C/C++ and Fortran code. The use the EDG
frontend for C and C++ and for Fortran they are still working on the
frontend. On the paper ROSE is a nice tool but when it comes to the
practice is really painful. A lot of bugs, it is extremely slow... and
most of the time works on a very simple code examples... it's not
ready for production code. The nice thing about rose is that it
implements some common transformations (like loop-tiling...) and it
seems to catch a lot of interest in the research area.


On the other side we have the LLVM project. One option is to use Clang
and exploit the parsing and rewriting capabilities to have a source-to-
source compiler. Actually I am really impressed by the design and
implementation of Clang but it has some drawback. Clang works very
well with C but it's not ready for C++ and Clang doesn't support
Fortran at all :( Furthermore in Clang there are no transformations
available because all the optimizations are meant to be done at the
LLVM bytecode level. However if you go down to the bytecode level you
lose the capability of produce readable source code as output. :
( Another way to solve the problem, could be the use of the gcc
frontend of LLVM and writing transformations at bytecode level (the
LLVM already implements several transformations). This solution would
give us the ability to work with C/C++ and Fortran production codes...
but the conversion into bytecode lacks some original information which
makes the application of some transformations quite difficult (for
example all the OpenMP pragmas are lost in this translation).


So, what else? GCC? Open64? I've heard that it is very painful to work
with these tools and we have not years to spent just trying to
understand how the tool work. Can you suggest something else? Anyone
of you have experience with some of the tools I've mentioned? Is it
really possible that in 2009 this is the most the world has to offer?


thanks, S. Pellegrini

Return to the comp.compilers page.
Search the comp.compilers archives again.