[LLVMdev] API on JIT, code snippets

[Chris Lattner]

On Mon, 9 Aug 2004, Reid Spencer wrote:

> I don't know why the demo page at UIUC is unavailable but there is an enhanced

FWIW, the demo page has been fixed.  It was broken as a result of the
recent system upgrades and I guess noone noticed.

Sorry about that.

-Chris


> copy of it running on the mirror at http://llvm.x10sys.com/demo/ if you ever
> need it. Running it produced the following LLVM equivalent for the C code in
> your example.
>
> implementation   ; Functions:
>
> int %add1(int %x) {
> entry:
> 	%tmp.1 = add int %x, 1		; <int> [#uses=1]
> 	ret int %tmp.1
> }
>
> int %foo() {
> entry:
> 	ret int 11
> }
>
> Reid
> Valery A.Khamenya wrote:
>
> > 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
>
> _______________________________________________
> 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/