X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=examples%2FFibonacci%2Ffibonacci.cpp;h=ecb49eb92e1ac9b3f41e7edd47d1f799c5cc0cd4;hp=cd35417fb3e8270d1da55aa867f620b161a7fe8b;hb=HEAD;hpb=34bd70de3c344034b82dc9a964a6b6893efa3e82 diff --git a/examples/Fibonacci/fibonacci.cpp b/examples/Fibonacci/fibonacci.cpp index cd35417fb3e..ecb49eb92e1 100644 --- a/examples/Fibonacci/fibonacci.cpp +++ b/examples/Fibonacci/fibonacci.cpp @@ -2,8 +2,8 @@ // // 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 file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -23,92 +23,106 @@ // //===----------------------------------------------------------------------===// -#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/JIT.h" -#include "llvm/ExecutionEngine/Interpreter.h" +#include "llvm/IR/Verifier.h" #include "llvm/ExecutionEngine/GenericValue.h" -#include +#include "llvm/ExecutionEngine/Interpreter.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/DerivedTypes.h" +#include "llvm/IR/Instructions.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/IR/Module.h" +#include "llvm/Support/TargetSelect.h" +#include "llvm/Support/raw_ostream.h" + using namespace llvm; -static Function *CreateFibFunction(Module *M) { - // Create the fib function and insert it into module M. This function is said +static Function *CreateFibFunction(Module *M, LLVMContext &Context) { + // Create the fib function and insert it into module M. This function is said // to return an int and take an int parameter. Function *FibF = - cast(M->getOrInsertFunction("fib", Type::Int32Ty, Type::Int32Ty, - (Type *)0)); + cast(M->getOrInsertFunction("fib", Type::getInt32Ty(Context), + Type::getInt32Ty(Context), + nullptr)); // Add a basic block to the function. - BasicBlock *BB = new BasicBlock("EntryBlock", FibF); + BasicBlock *BB = BasicBlock::Create(Context, "EntryBlock", FibF); // Get pointers to the constants. - Value *One = ConstantInt::get(Type::Int32Ty, 1); - Value *Two = ConstantInt::get(Type::Int32Ty, 2); + Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1); + Value *Two = ConstantInt::get(Type::getInt32Ty(Context), 2); // Get pointer to the integer argument of the add1 function... - Argument *ArgX = FibF->arg_begin(); // Get the arg. + Argument *ArgX = &*FibF->arg_begin(); // Get the arg. ArgX->setName("AnArg"); // Give it a nice symbolic name for fun. // Create the true_block. - BasicBlock *RetBB = new BasicBlock("return", FibF); + BasicBlock *RetBB = BasicBlock::Create(Context, "return", FibF); // Create an exit block. - BasicBlock* RecurseBB = new BasicBlock("recurse", FibF); + BasicBlock* RecurseBB = BasicBlock::Create(Context, "recurse", FibF); - // Create the "if (arg < 2) goto exitbb" - Value *CondInst = new ICmpInst(ICmpInst::ICMP_SLE, ArgX, Two, "cond", BB); - new BranchInst(RetBB, RecurseBB, CondInst, BB); + // Create the "if (arg <= 2) goto exitbb" + Value *CondInst = new ICmpInst(*BB, ICmpInst::ICMP_SLE, ArgX, Two, "cond"); + BranchInst::Create(RetBB, RecurseBB, CondInst, BB); // Create: ret int 1 - new ReturnInst(One, RetBB); + ReturnInst::Create(Context, One, RetBB); // create fib(x-1) - Value *Sub = BinaryOperator::createSub(ArgX, One, "arg", RecurseBB); - CallInst *CallFibX1 = new CallInst(FibF, Sub, "fibx1", RecurseBB); + Value *Sub = BinaryOperator::CreateSub(ArgX, One, "arg", RecurseBB); + CallInst *CallFibX1 = CallInst::Create(FibF, Sub, "fibx1", RecurseBB); CallFibX1->setTailCall(); // create fib(x-2) - Sub = BinaryOperator::createSub(ArgX, Two, "arg", RecurseBB); - CallInst *CallFibX2 = new CallInst(FibF, Sub, "fibx2", RecurseBB); + Sub = BinaryOperator::CreateSub(ArgX, Two, "arg", RecurseBB); + CallInst *CallFibX2 = CallInst::Create(FibF, Sub, "fibx2", RecurseBB); CallFibX2->setTailCall(); // fib(x-1)+fib(x-2) - Value *Sum = BinaryOperator::createAdd(CallFibX1, CallFibX2, + Value *Sum = BinaryOperator::CreateAdd(CallFibX1, CallFibX2, "addresult", RecurseBB); // Create the return instruction and add it to the basic block - new ReturnInst(Sum, RecurseBB); + ReturnInst::Create(Context, Sum, RecurseBB); return FibF; } - int main(int argc, char **argv) { int n = argc > 1 ? atol(argv[1]) : 24; + InitializeNativeTarget(); + LLVMContext Context; + // Create some module to put our function into it. - Module *M = new Module("test"); + std::unique_ptr Owner(new Module("test", Context)); + Module *M = Owner.get(); // We are about to create the "fib" function: - Function *FibF = CreateFibFunction(M); + Function *FibF = CreateFibFunction(M, Context); // Now we going to create JIT - ExistingModuleProvider *MP = new ExistingModuleProvider(M); - ExecutionEngine *EE = ExecutionEngine::create(MP, false); + std::string errStr; + ExecutionEngine *EE = + EngineBuilder(std::move(Owner)) + .setErrorStr(&errStr) + .create(); + + if (!EE) { + errs() << argv[0] << ": Failed to construct ExecutionEngine: " << errStr + << "\n"; + return 1; + } - std::cerr << "verifying... "; + errs() << "verifying... "; if (verifyModule(*M)) { - std::cerr << argv[0] << ": Error constructing function!\n"; + errs() << argv[0] << ": Error constructing function!\n"; return 1; } - std::cerr << "OK\n"; - std::cerr << "We just constructed this LLVM module:\n\n---------\n" << *M; - std::cerr << "---------\nstarting fibonacci(" << n << ") with JIT...\n"; + errs() << "OK\n"; + errs() << "We just constructed this LLVM module:\n\n---------\n" << *M; + errs() << "---------\nstarting fibonacci(" << n << ") with JIT...\n"; // Call the Fibonacci function with argument n: std::vector Args(1); @@ -116,6 +130,7 @@ int main(int argc, char **argv) { GenericValue GV = EE->runFunction(FibF, Args); // import result of execution - std::cout << "Result: " << GV.IntVal.toString(10) << "\n"; + outs() << "Result: " << GV.IntVal << "\n"; + return 0; }