fibonacci.cpp revision afebb449283ada1b44f423e698b30672606fdc54
1//===--- examples/Fibonacci/fibonacci.cpp - An example use of the JIT -----===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by Valery A. Khamenya and is distributed under the 6// University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This small program provides an example of how to build quickly a small module 11// with function Fibonacci and execute it with the JIT. 12// 13// The goal of this snippet is to create in the memory the LLVM module 14// consisting of one function as follow: 15// 16// int fib(int x) { 17// if(x<=2) return 1; 18// return fib(x-1)+fib(x-2); 19// } 20// 21// Once we have this, we compile the module via JIT, then execute the `fib' 22// function and return result to a driver, i.e. to a "host program". 23// 24//===----------------------------------------------------------------------===// 25 26#include "llvm/Module.h" 27#include "llvm/DerivedTypes.h" 28#include "llvm/Constants.h" 29#include "llvm/Instructions.h" 30#include "llvm/ModuleProvider.h" 31#include "llvm/Analysis/Verifier.h" 32#include "llvm/ExecutionEngine/JIT.h" 33#include "llvm/ExecutionEngine/Interpreter.h" 34#include "llvm/ExecutionEngine/GenericValue.h" 35#include <iostream> 36using namespace llvm; 37 38static Function *CreateFibFunction(Module *M) { 39 // Create the fib function and insert it into module M. This function is said 40 // to return an int and take an int parameter. 41 Function *FibF = M->getOrInsertFunction("fib", Type::IntTy, Type::IntTy, 42 (Type *)0); 43 44 // Add a basic block to the function. 45 BasicBlock *BB = new BasicBlock("EntryBlock", FibF); 46 47 // Get pointers to the constants. 48 Value *One = ConstantSInt::get(Type::IntTy, 1); 49 Value *Two = ConstantSInt::get(Type::IntTy, 2); 50 51 // Get pointer to the integer argument of the add1 function... 52 Argument *ArgX = FibF->arg_begin(); // Get the arg. 53 ArgX->setName("AnArg"); // Give it a nice symbolic name for fun. 54 55 // Create the true_block. 56 BasicBlock *RetBB = new BasicBlock("return", FibF); 57 // Create an exit block. 58 BasicBlock* RecurseBB = new BasicBlock("recurse", FibF); 59 60 // Create the "if (arg < 2) goto exitbb" 61 Value *CondInst = BinaryOperator::createSetLE(ArgX, Two, "cond", BB); 62 new BranchInst(RetBB, RecurseBB, CondInst, BB); 63 64 // Create: ret int 1 65 new ReturnInst(One, RetBB); 66 67 // create fib(x-1) 68 Value *Sub = BinaryOperator::createSub(ArgX, One, "arg", RecurseBB); 69 CallInst *CallFibX1 = new CallInst(FibF, Sub, "fibx1", RecurseBB); 70 CallFibX1->setTailCall(); 71 72 // create fib(x-2) 73 Sub = BinaryOperator::createSub(ArgX, Two, "arg", RecurseBB); 74 CallInst *CallFibX2 = new CallInst(FibF, Sub, "fibx2", RecurseBB); 75 CallFibX2->setTailCall(); 76 77 78 // fib(x-1)+fib(x-2) 79 Value *Sum = BinaryOperator::createAdd(CallFibX1, CallFibX2, 80 "addresult", RecurseBB); 81 82 // Create the return instruction and add it to the basic block 83 new ReturnInst(Sum, RecurseBB); 84 85 return FibF; 86} 87 88 89int main(int argc, char **argv) { 90 int n = argc > 1 ? atol(argv[1]) : 24; 91 92 // Create some module to put our function into it. 93 Module *M = new Module("test"); 94 95 // We are about to create the "fib" function: 96 Function *FibF = CreateFibFunction(M); 97 98 // Now we going to create JIT 99 ExistingModuleProvider *MP = new ExistingModuleProvider(M); 100 ExecutionEngine *EE = ExecutionEngine::create(MP, false); 101 102 std::cerr << "verifying... "; 103 if (verifyModule(*M)) { 104 std::cerr << argv[0] << ": Error constructing function!\n"; 105 return 1; 106 } 107 108 std::cerr << "OK\n"; 109 std::cerr << "We just constructed this LLVM module:\n\n---------\n" << *M; 110 std::cerr << "---------\nstarting fibonacci(" << n << ") with JIT...\n"; 111 112 // Call the Fibonacci function with argument n: 113 std::vector<GenericValue> Args(1); 114 Args[0].IntVal = n; 115 GenericValue GV = EE->runFunction(FibF, Args); 116 117 // import result of execution 118 std::cout << "Result: " << GV.IntVal << "\n"; 119 return 0; 120} 121