llvm dev - Feb 2010 - [LLVMdev] Using LLVM to generate x86 dynamically in memory

Hi.  I'm very new to LLVM, and have read some of the documentation online. 
Before I invest too much time, however, in learning about LLVM, I'd like to
know if it can be used for my purpose.  We currently have a critical runtime
component that evaluates expressions via interpretation.  The bytecode that we
generate goes through various optimization phases similarly to that of
optimizing language compilers (although definitely not as complete) before being
evaluated at runtime.  For quite some time now we have been thinking about
getting away from interpretation all-together and generating native code
directly.

 

What I'd like to know is:

 

1) Is there an LLVM backend library that can take either a) a C source program
in memory or b) an LLVM program in memory, as input and generate x86
instructions in memory?

 

2) HOw "light-weight" would a mechanism like this be?  I suppose that
depends on what optimizations we decided to apply during this code-gen phase.

 

What we plan to do is invoke this in-memory compiler to generate the x86
instructions, and then ship them at runtime to our new expression evaluation
engine that will simply set a function pointer to it and execute.

 

I heard of a compiler called TinyCC that basically has a library (libtcc) that
can be invoked at runtime to generate x86 instructions directly from a C program
stored in memory.  That's what I would like, but with the aggressive opts
provided in the LLVM infrastructure.  Thanks so much for your time...

 

- Shasank
 		 	   		  
_________________________________________________________________
Your E-mail and More On-the-Go. Get Windows Live Hotmail Free.
http://clk.atdmt.com/GBL/go/201469229/direct/01/
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20100202/06975262/attachment.html>

On Feb 2, 2010, at 3:05 PM, Shasank Chavan wrote:
> Hi.  I'm very new to LLVM, and have read some of the documentation
online.  Before I invest too much time, however, in learning about LLVM, I'd
like to know if it can be used for my purpose.  We currently have a critical
runtime component that evaluates expressions via interpretation.  The bytecode
that we generate goes through various optimization phases similarly to that of
optimizing language compilers (although definitely not as complete) before being
evaluated at runtime.  For quite some time now we have been thinking about
getting away from interpretation all-together and generating native code
directly.
>  
> What I'd like to know is:
>  
> 1) Is there an LLVM backend library that can take either a) a C source
program in memory or b) an LLVM program in memory, as input and generate x86
instructions in memory?
LLVM does support a Just-In-Time (JIT) compiler interface, which is what it
sounds like you're looking for. I would suggest looking more deeply into the
llvm documentation at llvm.org, paying particular attention to JIT references
and the lli utility.


>  
> 2) HOw "light-weight" would a mechanism like this be?  I suppose
that depends on what optimizations we decided to apply during this code-gen
phase.
>  
It does indeed vary quite a bit. I suspect your best bet will be to create some
test programs, or just use some of the examples from the llvm source tree, and
look at the footprint and compare to what your needs are.
> What we plan to do is invoke this in-memory compiler to generate the x86
instructions, and then ship them at runtime to our new expression evaluation
engine that will simply set a function pointer to it and execute.
>  
> I heard of a compiler called TinyCC that basically has a library (libtcc)
that can be invoked at runtime to generate x86 instructions directly from a C
program stored in memory.  That's what I would like, but with the aggressive
opts provided in the LLVM infrastructure.  Thanks so much for your time...
>  
> - Shasank
> 
> Your E-mail and More On-the-Go. Get Windows Live Hotmail Free. Sign up
now._______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev

Hi Jim.  Thanks for your speedy response.  I'm not entirely sure if a JIT is
what I'm looking for.  I'm basically looking for a dll with an interface
that takes a C program as input and compiles and optimizes it to native x86
instructions in an in-memory buffer.  I don't want the dll the execute it,
and I don't particularly want to translate our expressions into LLVM bitcode
(although I can if the rest of the pieces are there).  Also, I briefly read up
on lli.  This looks like a separate process will have to be spawned to invoke
the JIT to execute programs in LLVM bytecode.  This will definitely incur an
overhead penalty that we wouldn't want to pay.  Thanks in advance for your
response.

 

- Shasank

 

BTW - I was doing some google searching just now on the topic again, and i was
surprised to see how fast google had already found the log of this previous
conversation recorded at uiuc. ;).

 

 

 


 
> Subject: Re: [LLVMdev] Using LLVM to generate x86 dynamically in memory
> From: grosbach at apple.com
> Date: Tue, 2 Feb 2010 15:24:23 -0800
> CC: shanko_chavano at hotmail.com
> To: llvmdev at cs.uiuc.edu
> 
> 
> On Feb 2, 2010, at 3:05 PM, Shasank Chavan wrote:
> 
> > Hi. I'm very new to LLVM, and have read some of the documentation
online. Before I invest too much time, however, in learning about LLVM, I'd
like to know if it can be used for my purpose. We currently have a critical
runtime component that evaluates expressions via interpretation. The bytecode
that we generate goes through various optimization phases similarly to that of
optimizing language compilers (although definitely not as complete) before being
evaluated at runtime. For quite some time now we have been thinking about
getting away from interpretation all-together and generating native code
directly.
> > 
> > What I'd like to know is:
> > 
> > 1) Is there an LLVM backend library that can take either a) a C source
program in memory or b) an LLVM program in memory, as input and generate x86
instructions in memory?
> 
> LLVM does support a Just-In-Time (JIT) compiler interface, which is what it
sounds like you're looking for. I would suggest looking more deeply into the
llvm documentation at llvm.org, paying particular attention to JIT references
and the lli utility.
> 
> 
> 
> > 
> > 2) HOw "light-weight" would a mechanism like this be? I
suppose that depends on what optimizations we decided to apply during this
code-gen phase.
> > 
> 
> It does indeed vary quite a bit. I suspect your best bet will be to create
some test programs, or just use some of the examples from the llvm source tree,
and look at the footprint and compare to what your needs are.
> 
> > What we plan to do is invoke this in-memory compiler to generate the
x86 instructions, and then ship them at runtime to our new expression evaluation
engine that will simply set a function pointer to it and execute.
> > 
> > I heard of a compiler called TinyCC that basically has a library
(libtcc) that can be invoked at runtime to generate x86 instructions directly
from a C program stored in memory. That's what I would like, but with the
aggressive opts provided in the LLVM infrastructure. Thanks so much for your
time...
> > 
> > - Shasank
> > 
> > Your E-mail and More On-the-Go. Get Windows Live Hotmail Free. Sign up
now._______________________________________________
> > LLVM Developers mailing list
> > LLVMdev at cs.uiuc.edu http://llvm.cs.uiuc.edu
> > http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
> 
 		 	   		  
_________________________________________________________________
Hotmail: Trusted email with Microsoft’s powerful SPAM protection.
http://clk.atdmt.com/GBL/go/201469226/direct/01/
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20100202/b211dbe3/attachment.html>