6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-21 02:24:22 +00:00
Code Issues Projects Releases Wiki Activity

Make it possible to create multiple JIT instances at the same time, by removing

Browse Source 
the global TheJIT and TheJITResolver variables.  Lazy compilation is supported
by a global map from a stub address to the JITResolver that knows how to
compile it.

Patch by Olivier Meurant!


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@95837 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jeffrey Yasskin
2010-02-11 01:07:39 +00:00
parent 09eeac9f5f
commit 40966a7c68
5 changed files with 297 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
unittests/ExecutionEngine/JIT/MultiJITTest.cpp Normal file
View File

@ -0,0 +1,164 @@
//===- MultiJITTest.cpp - Unit tests for instantiating multiple JITs ------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "gtest/gtest.h"
#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/Assembly/Parser.h"
#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/ExecutionEngine/JIT.h"
#include "llvm/Support/SourceMgr.h"
#include <vector>
using namespace llvm;
namespace {
bool LoadAssemblyInto(Module *M, const char *assembly) {
SMDiagnostic Error;
bool success =
NULL != ParseAssemblyString(assembly, M, Error, M->getContext());
std::string errMsg;
raw_string_ostream os(errMsg);
Error.Print("", os);
EXPECT_TRUE(success) << os.str();
return success;
}
void createModule1(LLVMContext &Context1, Module *&M1, Function *&FooF1) {
M1 = new Module("test1", Context1);
LoadAssemblyInto(M1,
"define i32 @add1(i32 %ArgX1) { "
"entry: "
" %addresult = add i32 1, %ArgX1 "
" ret i32 %addresult "
"} "
" "
"define i32 @foo1() { "
"entry: "
" %add1 = call i32 @add1(i32 10) "
" ret i32 %add1 "
"} ");
FooF1 = M1->getFunction("foo1");
}
void createModule2(LLVMContext &Context2, Module *&M2, Function *&FooF2) {
M2 = new Module("test2", Context2);
LoadAssemblyInto(M2,
"define i32 @add2(i32 %ArgX2) { "
"entry: "
" %addresult = add i32 2, %ArgX2 "
" ret i32 %addresult "
"} "
" "
"define i32 @foo2() { "
"entry: "
" %add2 = call i32 @add2(i32 10) "
" ret i32 %add2 "
"} ");
FooF2 = M2->getFunction("foo2");
}
TEST(MultiJitTest, EagerMode) {
LLVMContext Context1;
Module *M1 = 0;
Function *FooF1 = 0;
createModule1(Context1, M1, FooF1);
LLVMContext Context2;
Module *M2 = 0;
Function *FooF2 = 0;
createModule2(Context2, M2, FooF2);
// Now we create the JIT in eager mode
OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
EE1->DisableLazyCompilation(true);
OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
EE2->DisableLazyCompilation(true);
// Call the `foo' function with no arguments:
std::vector<GenericValue> noargs;
GenericValue gv1 = EE1->runFunction(FooF1, noargs);
GenericValue gv2 = EE2->runFunction(FooF2, noargs);
// Import result of execution:
EXPECT_EQ(gv1.IntVal, 11);
EXPECT_EQ(gv2.IntVal, 12);
EE1->freeMachineCodeForFunction(FooF1);
EE2->freeMachineCodeForFunction(FooF2);
}
TEST(MultiJitTest, LazyMode) {
LLVMContext Context1;
Module *M1 = 0;
Function *FooF1 = 0;
createModule1(Context1, M1, FooF1);
LLVMContext Context2;
Module *M2 = 0;
Function *FooF2 = 0;
createModule2(Context2, M2, FooF2);
// Now we create the JIT in lazy mode
OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
EE1->DisableLazyCompilation(false);
OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
EE2->DisableLazyCompilation(false);
// Call the `foo' function with no arguments:
std::vector<GenericValue> noargs;
GenericValue gv1 = EE1->runFunction(FooF1, noargs);
GenericValue gv2 = EE2->runFunction(FooF2, noargs);
// Import result of execution:
EXPECT_EQ(gv1.IntVal, 11);
EXPECT_EQ(gv2.IntVal, 12);
EE1->freeMachineCodeForFunction(FooF1);
EE2->freeMachineCodeForFunction(FooF2);
}
extern "C" {
extern void *getPointerToNamedFunction(const char *Name);
}
TEST(MultiJitTest, JitPool) {
LLVMContext Context1;
Module *M1 = 0;
Function *FooF1 = 0;
createModule1(Context1, M1, FooF1);
LLVMContext Context2;
Module *M2 = 0;
Function *FooF2 = 0;
createModule2(Context2, M2, FooF2);
// Now we create two JITs
OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
Function *F1 = EE1->FindFunctionNamed("foo1");
void *foo1 = EE1->getPointerToFunction(F1);
Function *F2 = EE2->FindFunctionNamed("foo2");
void *foo2 = EE2->getPointerToFunction(F2);
// Function in M1
EXPECT_EQ(getPointerToNamedFunction("foo1"), foo1);
// Function in M2
EXPECT_EQ(getPointerToNamedFunction("foo2"), foo2);
// Symbol search
EXPECT_EQ((intptr_t)getPointerToNamedFunction("getPointerToNamedFunction"),
(intptr_t)&getPointerToNamedFunction);
}
} // anonymous namespace