--- /dev/null
+##===- projects/HowToUseJIT/Makefile -----------------------*- Makefile -*-===##
+#
+# The LLVM Compiler Infrastructure
+#
+# This file was developed by Valery A. Khamenya and is distributed under
+# the University of Illinois Open Source License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+LEVEL = ../../..
+TOOLNAME = Fibonacci
+USEDLIBS = lli-jit lli-interpreter codegen executionengine x86 selectiondag \
+ scalaropts analysis.a transformutils.a bcreader target.a vmcore \
+ support.a
+
+include $(LEVEL)/Makefile.common
--- /dev/null
+//===--- fibonacci.cpp - An example use of the JIT ----------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Valery A. Khamenya and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This small program provides an example of how to build quickly a small
+// module with function Fibonacci and execute it with the JIT.
+//
+// This simple example shows as well 30% speed up with LLVM 1.3
+// in comparison to gcc 3.3.3 at AMD Athlon XP 1500+ .
+//
+// (Modified from HowToUseJIT.cpp and Stacker/lib/compiler/StackerCompiler.cpp)
+//
+//===------------------------------------------------------------------------===
+// Goal:
+// The goal of this snippet is to create in the memory
+// the LLVM module consisting of one function as follow:
+//
+// int fib(int x) {
+// if(x<=2) return 1;
+// return fib(x-1)+fib(x-2);
+// }
+//
+// then compile the module via JIT, then execute the `fib'
+// function and return result to a driver, i.e. to a "host program".
+//
+
+#include <iostream>
+
+#include <llvm/Module.h>
+#include <llvm/DerivedTypes.h>
+#include <llvm/Constants.h>
+#include <llvm/Instructions.h>
+#include <llvm/ModuleProvider.h>
+#include <llvm/Analysis/Verifier.h>
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/GenericValue.h"
+
+
+using namespace llvm;
+
+int main(int argc, char**argv) {
+
+ int n = argc > 1 ? atol(argv[1]) : 44;
+
+ // Create some module to put our function into it.
+ Module *M = new Module("test");
+
+
+ // We are about to create the "fib" function:
+ Function *FibF;
+
+ {
+ // first create type for the single argument of fib function:
+ // the type is 'int ()'
+ std::vector<const Type*> ArgT(1);
+ ArgT[0] = Type::IntTy;
+
+ // now create full type of the "fib" function:
+ FunctionType *FibT = FunctionType::get(Type::IntTy, // type of result
+ ArgT,
+ /*not vararg*/false);
+
+ // Now create the fib 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.)
+ FibF = new Function(FibT,
+ Function::ExternalLinkage, // maybe too much
+ "fib", M);
+
+ // Add a basic block to the function... (again, it automatically inserts
+ // because of the last argument.)
+ BasicBlock *BB = new BasicBlock("EntryBlock of fib function", FibF);
+
+ // Get pointers to the constants ...
+ Value *One = ConstantSInt::get(Type::IntTy, 1);
+ Value *Two = ConstantSInt::get(Type::IntTy, 2);
+
+ // Get pointers to the integer argument of the add1 function...
+ assert(FibF->abegin() != FibF->aend()); // Make sure there's an arg
+
+ Argument &ArgX = FibF->afront(); // Get the arg
+ ArgX.setName("AnArg"); // Give it a nice symbolic name for fun.
+
+ SetCondInst* CondInst
+ = new SetCondInst( Instruction::SetLE,
+ &ArgX, Two );
+
+ BB->getInstList().push_back(CondInst);
+
+ // Create the true_block
+ BasicBlock* true_bb = new BasicBlock("arg<=2");
+
+
+ // Create the return instruction and add it
+ // to the basic block for true case:
+ true_bb->getInstList().push_back(new ReturnInst(One));
+
+ // Create an exit block
+ BasicBlock* exit_bb = new BasicBlock("arg>2");
+
+ {
+
+ // create fib(x-1)
+ CallInst* CallFibX1;
+ {
+ // Create the sub instruction... does not insert...
+ Instruction *Sub
+ = BinaryOperator::create(Instruction::Sub, &ArgX, One,
+ "arg");
+
+ exit_bb->getInstList().push_back(Sub);
+
+ CallFibX1 = new CallInst(FibF, Sub, "fib(x-1)");
+ exit_bb->getInstList().push_back(CallFibX1);
+
+ }
+
+ // create fib(x-2)
+ CallInst* CallFibX2;
+ {
+ // Create the sub instruction... does not insert...
+ Instruction * Sub
+ = BinaryOperator::create(Instruction::Sub, &ArgX, Two,
+ "arg");
+
+ exit_bb->getInstList().push_back(Sub);
+ CallFibX2 = new CallInst(FibF, Sub, "fib(x-2)");
+ exit_bb->getInstList().push_back(CallFibX2);
+
+ }
+
+ // Create the add instruction... does not insert...
+ Instruction *Add =
+ BinaryOperator::create(Instruction::Add,
+ CallFibX1, CallFibX2, "addresult");
+
+ // explicitly insert it into the basic block...
+ exit_bb->getInstList().push_back(Add);
+
+ // Create the return instruction and add it to the basic block
+ exit_bb->getInstList().push_back(new ReturnInst(Add));
+ }
+
+ // Create a branch on the SetCond
+ BranchInst* br_inst =
+ new BranchInst( true_bb, exit_bb, CondInst );
+
+ BB->getInstList().push_back( br_inst );
+ FibF->getBasicBlockList().push_back(true_bb);
+ FibF->getBasicBlockList().push_back(exit_bb);
+ }
+
+ // Now we going to create JIT
+ ExistingModuleProvider* MP = new ExistingModuleProvider(M);
+ ExecutionEngine* EE = ExecutionEngine::create( MP, false );
+
+ // Call the `foo' function with argument n:
+ std::vector<GenericValue> args(1);
+ args[0].IntVal = n;
+
+
+ std::clog << "verifying... ";
+ if (verifyModule(*M)) {
+ std::cerr << argv[0]
+ << ": assembly parsed, but does not verify as correct!\n";
+ return 1;
+ }
+ else
+ std::clog << "OK\n";
+
+
+ std::clog << "We just constructed this LLVM module:\n\n---------\n" << *M;
+ std::clog << "---------\nstarting fibonacci("
+ << n << ") with JIT...\n" << std::flush;
+
+ GenericValue gv = EE->runFunction(FibF, args);
+
+ // import result of execution:
+ std::cout << "Result: " << gv.IntVal << std:: endl;
+
+ return 0;
+}
--- /dev/null
+##===- projects/HowToUseJIT/Makefile -----------------------*- Makefile -*-===##
+#
+# The LLVM Compiler Infrastructure
+#
+# This file was developed by Valery A. Khamenya and is distributed under
+# the University of Illinois Open Source License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+LEVEL = ../../..
+TOOLNAME = Fibonacci
+USEDLIBS = lli-jit lli-interpreter codegen executionengine x86 selectiondag \
+ scalaropts analysis.a transformutils.a bcreader target.a vmcore \
+ support.a
+
+include $(LEVEL)/Makefile.common
--- /dev/null
+//===--- fibonacci.cpp - An example use of the JIT ----------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Valery A. Khamenya and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This small program provides an example of how to build quickly a small
+// module with function Fibonacci and execute it with the JIT.
+//
+// This simple example shows as well 30% speed up with LLVM 1.3
+// in comparison to gcc 3.3.3 at AMD Athlon XP 1500+ .
+//
+// (Modified from HowToUseJIT.cpp and Stacker/lib/compiler/StackerCompiler.cpp)
+//
+//===------------------------------------------------------------------------===
+// Goal:
+// The goal of this snippet is to create in the memory
+// the LLVM module consisting of one function as follow:
+//
+// int fib(int x) {
+// if(x<=2) return 1;
+// return fib(x-1)+fib(x-2);
+// }
+//
+// then compile the module via JIT, then execute the `fib'
+// function and return result to a driver, i.e. to a "host program".
+//
+
+#include <iostream>
+
+#include <llvm/Module.h>
+#include <llvm/DerivedTypes.h>
+#include <llvm/Constants.h>
+#include <llvm/Instructions.h>
+#include <llvm/ModuleProvider.h>
+#include <llvm/Analysis/Verifier.h>
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/GenericValue.h"
+
+
+using namespace llvm;
+
+int main(int argc, char**argv) {
+
+ int n = argc > 1 ? atol(argv[1]) : 44;
+
+ // Create some module to put our function into it.
+ Module *M = new Module("test");
+
+
+ // We are about to create the "fib" function:
+ Function *FibF;
+
+ {
+ // first create type for the single argument of fib function:
+ // the type is 'int ()'
+ std::vector<const Type*> ArgT(1);
+ ArgT[0] = Type::IntTy;
+
+ // now create full type of the "fib" function:
+ FunctionType *FibT = FunctionType::get(Type::IntTy, // type of result
+ ArgT,
+ /*not vararg*/false);
+
+ // Now create the fib 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.)
+ FibF = new Function(FibT,
+ Function::ExternalLinkage, // maybe too much
+ "fib", M);
+
+ // Add a basic block to the function... (again, it automatically inserts
+ // because of the last argument.)
+ BasicBlock *BB = new BasicBlock("EntryBlock of fib function", FibF);
+
+ // Get pointers to the constants ...
+ Value *One = ConstantSInt::get(Type::IntTy, 1);
+ Value *Two = ConstantSInt::get(Type::IntTy, 2);
+
+ // Get pointers to the integer argument of the add1 function...
+ assert(FibF->abegin() != FibF->aend()); // Make sure there's an arg
+
+ Argument &ArgX = FibF->afront(); // Get the arg
+ ArgX.setName("AnArg"); // Give it a nice symbolic name for fun.
+
+ SetCondInst* CondInst
+ = new SetCondInst( Instruction::SetLE,
+ &ArgX, Two );
+
+ BB->getInstList().push_back(CondInst);
+
+ // Create the true_block
+ BasicBlock* true_bb = new BasicBlock("arg<=2");
+
+
+ // Create the return instruction and add it
+ // to the basic block for true case:
+ true_bb->getInstList().push_back(new ReturnInst(One));
+
+ // Create an exit block
+ BasicBlock* exit_bb = new BasicBlock("arg>2");
+
+ {
+
+ // create fib(x-1)
+ CallInst* CallFibX1;
+ {
+ // Create the sub instruction... does not insert...
+ Instruction *Sub
+ = BinaryOperator::create(Instruction::Sub, &ArgX, One,
+ "arg");
+
+ exit_bb->getInstList().push_back(Sub);
+
+ CallFibX1 = new CallInst(FibF, Sub, "fib(x-1)");
+ exit_bb->getInstList().push_back(CallFibX1);
+
+ }
+
+ // create fib(x-2)
+ CallInst* CallFibX2;
+ {
+ // Create the sub instruction... does not insert...
+ Instruction * Sub
+ = BinaryOperator::create(Instruction::Sub, &ArgX, Two,
+ "arg");
+
+ exit_bb->getInstList().push_back(Sub);
+ CallFibX2 = new CallInst(FibF, Sub, "fib(x-2)");
+ exit_bb->getInstList().push_back(CallFibX2);
+
+ }
+
+ // Create the add instruction... does not insert...
+ Instruction *Add =
+ BinaryOperator::create(Instruction::Add,
+ CallFibX1, CallFibX2, "addresult");
+
+ // explicitly insert it into the basic block...
+ exit_bb->getInstList().push_back(Add);
+
+ // Create the return instruction and add it to the basic block
+ exit_bb->getInstList().push_back(new ReturnInst(Add));
+ }
+
+ // Create a branch on the SetCond
+ BranchInst* br_inst =
+ new BranchInst( true_bb, exit_bb, CondInst );
+
+ BB->getInstList().push_back( br_inst );
+ FibF->getBasicBlockList().push_back(true_bb);
+ FibF->getBasicBlockList().push_back(exit_bb);
+ }
+
+ // Now we going to create JIT
+ ExistingModuleProvider* MP = new ExistingModuleProvider(M);
+ ExecutionEngine* EE = ExecutionEngine::create( MP, false );
+
+ // Call the `foo' function with argument n:
+ std::vector<GenericValue> args(1);
+ args[0].IntVal = n;
+
+
+ std::clog << "verifying... ";
+ if (verifyModule(*M)) {
+ std::cerr << argv[0]
+ << ": assembly parsed, but does not verify as correct!\n";
+ return 1;
+ }
+ else
+ std::clog << "OK\n";
+
+
+ std::clog << "We just constructed this LLVM module:\n\n---------\n" << *M;
+ std::clog << "---------\nstarting fibonacci("
+ << n << ") with JIT...\n" << std::flush;
+
+ GenericValue gv = EE->runFunction(FibF, args);
+
+ // import result of execution:
+ std::cout << "Result: " << gv.IntVal << std:: endl;
+
+ return 0;
+}
projects / oota-llvm.git / commitdiff