mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-26 07:29:55 +00:00
Modules and ModuleProviders. Because the "ModuleProvider" simply materializes GlobalValues now, and doesn't provide modules, it's renamed to "GVMaterializer". Code that used to need a ModuleProvider to materialize Functions can now materialize the Functions directly. Functions no longer use a magic linkage to record that they're materializable; they simply ask the GVMaterializer. Because the C ABI must never change, we can't remove LLVMModuleProviderRef or the functions that refer to it. Instead, because Module now exposes the same functionality ModuleProvider used to, we store a Module* in any LLVMModuleProviderRef and translate in the wrapper methods. The bindings to other languages still use the ModuleProvider concept. It would probably be worth some time to update them to follow the C++ more closely, but I don't intend to do it. Fixes http://llvm.org/PR5737 and http://llvm.org/PR5735. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@94686 91177308-0d34-0410-b5e6-96231b3b80d8
132 lines
4.4 KiB
C++
132 lines
4.4 KiB
C++
//===--- examples/Fibonacci/fibonacci.cpp - An example use of the JIT -----===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file 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.
|
|
//
|
|
// 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);
|
|
// }
|
|
//
|
|
// Once we have this, we compile the module via JIT, then execute the `fib'
|
|
// function and return result to a driver, i.e. to a "host program".
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/LLVMContext.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/Constants.h"
|
|
#include "llvm/Instructions.h"
|
|
#include "llvm/Analysis/Verifier.h"
|
|
#include "llvm/ExecutionEngine/JIT.h"
|
|
#include "llvm/ExecutionEngine/Interpreter.h"
|
|
#include "llvm/ExecutionEngine/GenericValue.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "llvm/Target/TargetSelect.h"
|
|
using namespace llvm;
|
|
|
|
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<Function>(M->getOrInsertFunction("fib", Type::getInt32Ty(Context),
|
|
Type::getInt32Ty(Context),
|
|
(Type *)0));
|
|
|
|
// Add a basic block to the function.
|
|
BasicBlock *BB = BasicBlock::Create(Context, "EntryBlock", FibF);
|
|
|
|
// Get pointers to the constants.
|
|
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.
|
|
ArgX->setName("AnArg"); // Give it a nice symbolic name for fun.
|
|
|
|
// Create the true_block.
|
|
BasicBlock *RetBB = BasicBlock::Create(Context, "return", FibF);
|
|
// Create an exit block.
|
|
BasicBlock* RecurseBB = BasicBlock::Create(Context, "recurse", FibF);
|
|
|
|
// 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
|
|
ReturnInst::Create(Context, One, RetBB);
|
|
|
|
// create fib(x-1)
|
|
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 = CallInst::Create(FibF, Sub, "fibx2", RecurseBB);
|
|
CallFibX2->setTailCall();
|
|
|
|
|
|
// fib(x-1)+fib(x-2)
|
|
Value *Sum = BinaryOperator::CreateAdd(CallFibX1, CallFibX2,
|
|
"addresult", RecurseBB);
|
|
|
|
// Create the return instruction and add it to the basic block
|
|
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", Context);
|
|
|
|
// We are about to create the "fib" function:
|
|
Function *FibF = CreateFibFunction(M, Context);
|
|
|
|
// Now we going to create JIT
|
|
std::string errStr;
|
|
ExecutionEngine *EE = EngineBuilder(M).setErrorStr(&errStr).setEngineKind(EngineKind::JIT).create();
|
|
|
|
if (!EE) {
|
|
errs() << argv[0] << ": Failed to construct ExecutionEngine: " << errStr << "\n";
|
|
return 1;
|
|
}
|
|
|
|
errs() << "verifying... ";
|
|
if (verifyModule(*M)) {
|
|
errs() << argv[0] << ": Error constructing function!\n";
|
|
return 1;
|
|
}
|
|
|
|
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<GenericValue> Args(1);
|
|
Args[0].IntVal = APInt(32, n);
|
|
GenericValue GV = EE->runFunction(FibF, Args);
|
|
|
|
// import result of execution
|
|
outs() << "Result: " << GV.IntVal << "\n";
|
|
return 0;
|
|
}
|