fibonacci.cpp revision 9132a2b81842b0e2b77703fab3e6fe7467f859bb
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 = 42 cast<Function>(M->getOrInsertFunction("fib", Type::Int32Ty, Type::Int32Ty, 43 (Type *)0)); 44 45 // Add a basic block to the function. 46 BasicBlock *BB = new BasicBlock("EntryBlock", FibF); 47 48 // Get pointers to the constants. 49 Value *One = ConstantInt::get(Type::Int32Ty, 1); 50 Value *Two = ConstantInt::get(Type::Int32Ty, 2); 51 52 // Get pointer to the integer argument of the add1 function... 53 Argument *ArgX = FibF->arg_begin(); // Get the arg. 54 ArgX->setName("AnArg"); // Give it a nice symbolic name for fun. 55 56 // Create the true_block. 57 BasicBlock *RetBB = new BasicBlock("return", FibF); 58 // Create an exit block. 59 BasicBlock* RecurseBB = new BasicBlock("recurse", FibF); 60 61 // Create the "if (arg < 2) goto exitbb" 62 Value *CondInst = new ICmpInst(ICmpInst::ICMP_SLE, ArgX, Two, "cond", BB); 63 new BranchInst(RetBB, RecurseBB, CondInst, BB); 64 65 // Create: ret int 1 66 new ReturnInst(One, RetBB); 67 68 // create fib(x-1) 69 Value *Sub = BinaryOperator::createSub(ArgX, One, "arg", RecurseBB); 70 CallInst *CallFibX1 = new CallInst(FibF, Sub, "fibx1", RecurseBB); 71 CallFibX1->setTailCall(); 72 73 // create fib(x-2) 74 Sub = BinaryOperator::createSub(ArgX, Two, "arg", RecurseBB); 75 CallInst *CallFibX2 = new CallInst(FibF, Sub, "fibx2", RecurseBB); 76 CallFibX2->setTailCall(); 77 78 79 // fib(x-1)+fib(x-2) 80 Value *Sum = BinaryOperator::createAdd(CallFibX1, CallFibX2, 81 "addresult", RecurseBB); 82 83 // Create the return instruction and add it to the basic block 84 new ReturnInst(Sum, RecurseBB); 85 86 return FibF; 87} 88 89 90int main(int argc, char **argv) { 91 int n = argc > 1 ? atol(argv[1]) : 24; 92 93 // Create some module to put our function into it. 94 Module *M = new Module("test"); 95 96 // We are about to create the "fib" function: 97 Function *FibF = CreateFibFunction(M); 98 99 // Now we going to create JIT 100 ExistingModuleProvider *MP = new ExistingModuleProvider(M); 101 ExecutionEngine *EE = ExecutionEngine::create(MP, false); 102 103 std::cerr << "verifying... "; 104 if (verifyModule(*M)) { 105 std::cerr << argv[0] << ": Error constructing function!\n"; 106 return 1; 107 } 108 109 std::cerr << "OK\n"; 110 std::cerr << "We just constructed this LLVM module:\n\n---------\n" << *M; 111 std::cerr << "---------\nstarting fibonacci(" << n << ") with JIT...\n"; 112 113 // Call the Fibonacci function with argument n: 114 std::vector<GenericValue> Args(1); 115 Args[0].IntVal = APInt(32, n); 116 GenericValue GV = EE->runFunction(FibF, Args); 117 118 // import result of execution 119 std::cout << "Result: " << GV.IntVal.toStringUnsigned(10) << "\n"; 120 return 0; 121} 122