[LLVMdev] API on JIT, code snippets

[Chris Lattner]

On Mon, 9 Aug 2004, Reid Spencer wrote:

> Attached are three files: "valery.cpp" which contains your original, "reid.cpp"
> which contains corrections to most of the FIXME items and "diffs" which shows
> the differences between them.  The differences should be instructive on what to
> do.  You were really, really close .. just a few details changing.  The code in
> "reid.cpp" compiles but I haven't tested it. I'll leave that to you.

Cool, thanks Reid!

> There is only one remaining item that I don't know how to do. After
> ExecutionEngine::runFunction, you want to extract the result int value from the
> function. The runFunction method returns a GenericValue but I don't see an
> obvious way to get an actual value from this class.

I'm not Misha, but if you have a GenericValue that is an int, just use
GV.IntVal to get at it.  GenericValue is just a union (defined in
include/llvm/ExecutionEngine/GenericValue.h), which can represent any
first-class value that LLVM functions can return.

-Chris

> > Reid wrote:
> >
> >
> >>I have to agree with Misha on this. None of us knows "everything" about
> >>LLVM and as you can see, Misha responded three hours before I did :).
> >>Asking questions here is encouraged, so please feel free to post them on
> >>LLVMdev. We'll always help where we can.
> >
> >
> > well, OK :)
> >
> > Please find the attachment with the first approach to
> > such an example i've meant. This snippet is based on
> > ModuleMaker as you could see.
> >
> > You will find "FIXME!" at positions where I fail to find
> > answer in 10-15 minutes. Code is compilable at least.
> >
> > So... PING!
> > Who gives PONG?
> > :)
> >
> > --
> > Valery.
> >
> >
> > ------------------------------------------------------------------------
> >
> > /*
> > Goal:
> >   The goal of this snippet is to create in the memory
> >   the LLVM module consisting of two functions as follow:
> >
> >
> > int add1(int x) {
> >   return x+1;
> > }
> >
> > int foo() {
> >   return add1(10);
> > }
> >
> >
> > then compile the module via JIT, then execute the `foo'
> > function and return result to a driver, i.e. to a "host program".
> >
> > Some remarks and questions:
> >
> > - could we invoke some code using noname functions too?
> >   e.g. evaluate "foo()+foo()" without fears to introduce
> >   conflict of temporary function name with some real
> >   existing function name?
> >
> > - it would be nice to copy-paste here a LLVM code of the
> >   above given C-portion, ...but see the next comment :)
> >
> > - http://llvm.cs.uiuc.edu/demo/index.cgi is the shortest way
> >   to obtain LLVM code :) but it is down:
> >   "The demo page is currently unavailable.
> >   [tools: ( gccas llvm-dis gccld ) failed sanity check]"
> >   LOL
> >
> >
> > */
> >
> > #include <iostream>
> >
> > #include <llvm/Module.h>
> > #include <llvm/DerivedTypes.h>
> > #include <llvm/Constants.h>
> > #include <llvm/Instructions.h>
> > #include <llvm/ModuleProvider.h>
> >
> > #include "llvm/ExecutionEngine/ExecutionEngine.h"
> > #include "llvm/ExecutionEngine/GenericValue.h"
> >
> >
> > using namespace llvm;
> >
> > int main() {
> >
> >   // Create some module to put our function into it.
> >   Module *M = new Module("test");
> >
> >
> >   // We are about to create the add1 function:
> >   Function *Add1F;
> >
> >   {
> >     // first create type for the single argument of add1 function:
> >     // the type is 'int ()'
> >     std::vector<const Type*> ArgT(1);
> >     ArgT[0] = Type::IntTy;
> >
> >     // now create full type of the add1 function:
> >     FunctionType *Add1T = FunctionType::get(Type::IntTy, // type of result: int ()'
> > 					    ArgT,
> > 					    /*not vararg*/false);
> >
> >     // Now create the add1 function entry and
> >     // insert this entry into module M
> >     // (By passing a module as the last parameter to the Function constructor,
> >     // it automatically gets appended to the Module.)
> >     Function *Add1F = new Function(Add1T,
> > 				   Function::ExternalLinkage, // maybe too much
> > 				   "add1", M);
> >
> >     // Add a basic block to the function... (again, it automatically inserts
> >     // because of the last argument.)
> >     BasicBlock *BB = new BasicBlock("EntryBlock of add1 function", Add1F);
> >
> >     // Get pointers to the constant `1'...
> >     Value *One = ConstantSInt::get(Type::IntTy, 1);
> >
> >     // Get pointers to the integer argument of the add1 function...
> >     Value *ArgX = 0; // FIXME!!
> >
> >
> >     // Create the add instruction... does not insert...
> >     Instruction *Add = BinaryOperator::create(Instruction::Add, One, ArgX,
> > 					      "addresult");
> >
> >     // explicitly insert it into the basic block...
> >     BB->getInstList().push_back(Add);
> >
> >     // Create the return instruction and add it to the basic block
> >     BB->getInstList().push_back(new ReturnInst(Add));
> >
> >     // function add1 is ready
> >   }
> >
> >
> >   // now we going to create function `foo':
> >   Function *Foo;
> >
> >   {
> >     // Create the foo function type:
> >     FunctionType *FooT =
> >       FunctionType::get(Type::IntTy, // result has type: 'int ()'
> > 			std::vector<const Type*>(), // no arguments
> > 			/*not vararg*/false);
> >
> >     // create the entry for function `foo' and insert
> >     // this entry into module M:
> >     Function *FooF =
> >       new Function(FooT,
> > 		   Function::ExternalLinkage, // too wide?
> > 		   "foo", M);
> >
> >     // Add a basic block to the FooF function...
> >     BasicBlock *BB = new BasicBlock("EntryBlock of add1 function", FooF);
> >
> >     // Get pointers to the constant `10'...
> >     Value *Ten = ConstantSInt::get(Type::IntTy, 10);
> >
> >     // Put the argument Ten on stack and make call:
> >     // ...
> >     Instruction *Add1CallRes = 0; // FIXME!!!
> >
> >     // Create the return instruction and add it to the basic block
> >     BB->getInstList().push_back(new ReturnInst(Add1CallRes));
> >
> >   }
> >
> >   // Now we going to create JIT ??
> >   // FIXME!
> >
> >
> >   // compile M module ??
> >   // FIXME!
> >
> >   // create Execution Engine ??
> >   ModuleProvider *MP = 0;
> >   ExecutionEngine *EE = ExecutionEngine::create(MP, true);
> >
> >   // Call the `foo' function with no arguments:
> >   std::vector<GenericValue> noargs;
> >   GenericValue gv = EE->runFunction(Foo, noargs);
> >
> >   // import result of execution:
> >   // FIXME!
> > }
> >
> >
> > ------------------------------------------------------------------------
> >
> > _______________________________________________
> > LLVM Developers mailing list
> > LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> > http://mail.cs.uiuc.edu/mailman/listinfo/llvmdev
>
>

-Chris

-- 
http://llvm.cs.uiuc.edu/
http://nondot.org/sabre/