[LLVMdev] LLVM bytecode simulator/emulator?

[Robert L. Bocchino Jr.]

Hi,

I have done something like this.  I wrote a simple pass that  
instrumented LLVM instructions with external calls into a library of  
instrumentation functions (in my case, I was printing out a trace of  
dynamic load, store, and other data).  To analyze a program, I  
compiled the program to LLVM, ran the analyze pass on it, then linked  
the instrumented program with the library (also compiled to LLVM).   
To generate the trace, I just ran the instrumented program.  For  
something very simple, like counting dynamic instructions, you could  
dispense with the library and modify the LLVM directly to do the  
following:  declare a static global counter, initialize it to zero in  
main, and increment it after every LLVM instruction in the original  
program.

Rob

On Jul 13, 2006, at 10:26 PM, Kenneth Hoste wrote:

> Chris Lattner wrote:
>> On Thu, 13 Jul 2006, Kenneth Hoste wrote:
>>> After browsing through the docs, at a first glance I think I  
>>> should write a plugin for the 'analyze' tool. I think http:// 
>>> llvm.org/docs/WritingAnLLVMPass.html is where I should start from.
>>> The only problem I see now is that there doesn't seem to be a way  
>>> to get information on a single instruction while being able to  
>>> keep state over all instructions... Is that possible, and if it  
>>> is, can oyu tell me how (or where I can find an example of it?).
>> I don't really understand what you mean by this, but a ModulePass  
>> is fully general, it can do anything.  Can you explain what you're  
>> trying to do?
>
> The way we're characterizing programs now, is adding our own code  
> after every instruction. When that instruction gets executed (which  
> can happen several times, for example inside a loop), we update our  
> state. A simple example is counting the number of dynamic  
> instructions executed, or the instruction mix (% loads, %  
> stores, ...) in the dynamic execution.
> If I was able to do that using LLVM, we would have characteristics  
> on a higher level of abstraction. The documentation on the  
> BasicBlock pass mentions not to keep state over different basic  
> blocks, but I do want that. Also, I need a way to iterate over the  
> _dynamic_ instruction stream. Is there a way to do that?
>
> Example static vs dynamic:
>
> static:
> L: add x, y
>    sub y, z
>    jmpif z>100
>    mul x, z
>
> dynamic:
> add x, y
> sub y, z
> jmpif z>100
> add x, y
> sub y, z
> jmpif z>100
> ...
> jmpif z>100
> mul x, z
>
>
> If my problem still isn't clear, it's because I didn't explain it  
> well. Feel free to ask further questions. I'll look into the  
> documentation/examples today, to see if I can find some kind of  
> dynamic analysis.
>
> greetings,
>
> Kennneth
>
>
> -- 
> Statistics are like a bikini. What they reveal is suggestive, but  
> what they conceal is vital (Aaron Levenstein)
>
> Kenneth Hoste
> ELIS - Ghent University
> kenneth.hoste at elis.ugent.be
> http://www.elis.ugent.be/~kehoste
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev

Robert L. Bocchino Jr.
Ph.D. Student
University of Illinois, Urbana-Champaign

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20060714/09175395/attachment.html>