[LLVMdev] LLVM vs Java bytecode vs C for (IR)

[Lucas S]

Hi All,

My name is Lucas, I am a student from ETH Zurich.

I would like to know what is the advantage of  LLVM as Intermediate
representation
over Java bytecode and C.

Let me explain what I am looking for.

I am starting a project which will re-write or modify the current Eiffel
compiler. The main
goal is to provide enough flexibility to enable Dynamic class loading,
modular compilation,
reflexion and so on.

I wanted to modify the current compiler but my professor wants to re-write
it. If I really
have to rewrite the compiler I don't want to use C as the intermediate
language, we already
have three good compilers for that. While making some research I found C-- ,
CIIL and then
LLVM. After reading some of the papers I decided to suggest it to my
professor.

He then asked me how easier is it to generate LLVM bytecode rather than C
code and
why not use Java bytecode instead?

I've read a brief comparison between LLVM and JVM presented in [1]. and of
all capabilities
presented, #4 is interesting but not that convincing I think. #1 is one of
the main advantages,
However, the main reason the new compiler is being written is that the
current one is so
optimized for performance that it has lost a lot of flexibility. So the new
compiler by design will
be slower, and I am not sure if it could compete with the current one. I am
still not sure if
LLVM is what I am looking for. if so how can I defend it against C or Java
bytecode?


Thanks in advance,
Lucas S Silva

[1] LLVM:Compilation Framework for Lifelong Program Analysis &
Transformation
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20070722/ab7051a3/attachment.html>