mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-11-02 07:11:49 +00:00
f0356fe140
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
125 lines
4.1 KiB
C++
125 lines
4.1 KiB
C++
//===-- examples/HowToUseJIT/HowToUseJIT.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 quickly build a small
|
|
// module with two functions and execute it with the JIT.
|
|
//
|
|
// Goal:
|
|
// The goal of this snippet is to create in the memory
|
|
// the LLVM module consisting of two functions as follow:
|
|
//
|
|
// int add1(int x) {
|
|
// return x+1;
|
|
// }
|
|
//
|
|
// int foo() {
|
|
// return add1(10);
|
|
// }
|
|
//
|
|
// then compile the module via JIT, then execute the `foo'
|
|
// function and return result to a driver, i.e. to a "host program".
|
|
//
|
|
// Some remarks and questions:
|
|
//
|
|
// - could we invoke some code using noname functions too?
|
|
// e.g. evaluate "foo()+foo()" without fears to introduce
|
|
// conflict of temporary function name with some real
|
|
// existing function name?
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/LLVMContext.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/Constants.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/Instructions.h"
|
|
#include "llvm/ExecutionEngine/JIT.h"
|
|
#include "llvm/ExecutionEngine/Interpreter.h"
|
|
#include "llvm/ExecutionEngine/GenericValue.h"
|
|
#include "llvm/Target/TargetSelect.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
using namespace llvm;
|
|
|
|
int main() {
|
|
|
|
InitializeNativeTarget();
|
|
|
|
LLVMContext Context;
|
|
|
|
// Create some module to put our function into it.
|
|
Module *M = new Module("test", Context);
|
|
|
|
// Create the add1 function entry and insert this entry into module M. The
|
|
// function will have a return type of "int" and take an argument of "int".
|
|
// The '0' terminates the list of argument types.
|
|
Function *Add1F =
|
|
cast<Function>(M->getOrInsertFunction("add1", Type::getInt32Ty(Context),
|
|
Type::getInt32Ty(Context),
|
|
(Type *)0));
|
|
|
|
// Add a basic block to the function. As before, it automatically inserts
|
|
// because of the last argument.
|
|
BasicBlock *BB = BasicBlock::Create(Context, "EntryBlock", Add1F);
|
|
|
|
// Get pointers to the constant `1'.
|
|
Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1);
|
|
|
|
// Get pointers to the integer argument of the add1 function...
|
|
assert(Add1F->arg_begin() != Add1F->arg_end()); // Make sure there's an arg
|
|
Argument *ArgX = Add1F->arg_begin(); // Get the arg
|
|
ArgX->setName("AnArg"); // Give it a nice symbolic name for fun.
|
|
|
|
// Create the add instruction, inserting it into the end of BB.
|
|
Instruction *Add = BinaryOperator::CreateAdd(One, ArgX, "addresult", BB);
|
|
|
|
// Create the return instruction and add it to the basic block
|
|
ReturnInst::Create(Context, Add, BB);
|
|
|
|
// Now, function add1 is ready.
|
|
|
|
|
|
// Now we going to create function `foo', which returns an int and takes no
|
|
// arguments.
|
|
Function *FooF =
|
|
cast<Function>(M->getOrInsertFunction("foo", Type::getInt32Ty(Context),
|
|
(Type *)0));
|
|
|
|
// Add a basic block to the FooF function.
|
|
BB = BasicBlock::Create(Context, "EntryBlock", FooF);
|
|
|
|
// Get pointers to the constant `10'.
|
|
Value *Ten = ConstantInt::get(Type::getInt32Ty(Context), 10);
|
|
|
|
// Pass Ten to the call call:
|
|
CallInst *Add1CallRes = CallInst::Create(Add1F, Ten, "add1", BB);
|
|
Add1CallRes->setTailCall(true);
|
|
|
|
// Create the return instruction and add it to the basic block.
|
|
ReturnInst::Create(Context, Add1CallRes, BB);
|
|
|
|
// Now we create the JIT.
|
|
ExecutionEngine* EE = EngineBuilder(M).create();
|
|
|
|
outs() << "We just constructed this LLVM module:\n\n" << *M;
|
|
outs() << "\n\nRunning foo: ";
|
|
outs().flush();
|
|
|
|
// Call the `foo' function with no arguments:
|
|
std::vector<GenericValue> noargs;
|
|
GenericValue gv = EE->runFunction(FooF, noargs);
|
|
|
|
// Import result of execution:
|
|
outs() << "Result: " << gv.IntVal << "\n";
|
|
EE->freeMachineCodeForFunction(FooF);
|
|
delete EE;
|
|
llvm_shutdown();
|
|
return 0;
|
|
}
|