6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-10-20 09:24:58 +00:00
Code Issues Projects Releases Wiki Activity

add a new ExecutionEngine::createJIT which can be used if you only want

Browse Source 
to create a JIT.  This lets you specify JIT-specific configuration items
like the JITMemoryManager to use.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44647 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2007-12-06 01:34:04 +00:00
parent 9f2f142d25
commit 34c9433004
4 changed files with 41 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/llvm/ExecutionEngine/ExecutionEngine.h
View File

@ -108,6 +108,14 @@ public:
/// is appropriate for the current machine. This takes ownership of the
/// module.
static ExecutionEngine *create(Module *M);
/// createJIT - This is the factory method for creating a JIT for the current
/// machine, it does not fall back to the interpreter. This takes ownership
/// of the ModuleProvider and JITMemoryManager if successful.
static ExecutionEngine *createJIT(ModuleProvider *MP,
std::string *ErrorStr = 0,
JITMemoryManager *JMM = 0);
/// addModuleProvider - Add a ModuleProvider to the list of modules that we

21
lib/ExecutionEngine/JIT/JIT.cpp
View File

@ -61,12 +61,29 @@ namespace llvm {
}
}
JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji)
/// createJIT - This is the factory method for creating a JIT for the current
/// machine, it does not fall back to the interpreter. This takes ownership
/// of the module provider.
ExecutionEngine *ExecutionEngine::createJIT(ModuleProvider *MP,
std::string *ErrorStr,
JITMemoryManager *JMM) {
ExecutionEngine *EE = JIT::createJIT(MP, ErrorStr, JMM);
if (!EE) return 0;
// Make sure we can resolve symbols in the program as well. The zero arg
// to the function tells DynamicLibrary to load the program, not a library.
sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr);
return EE;
}
JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji,
JITMemoryManager *JMM)
: ExecutionEngine(MP), TM(tm), TJI(tji), jitstate(MP) {
setTargetData(TM.getTargetData());
// Initialize MCE
MCE = createEmitter(*this, 0);
MCE = createEmitter(*this, JMM);
// Add target data
MutexGuard locked(lock);

11
lib/ExecutionEngine/JIT/JIT.h
View File

@ -56,7 +56,8 @@ class JIT : public ExecutionEngine {
JITState jitstate;
JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji);
JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji,
JITMemoryManager *JMM);
public:
~JIT();
@ -71,7 +72,9 @@ public:
/// create - Create an return a new JIT compiler if there is one available
/// for the current target. Otherwise, return null.
///
static ExecutionEngine *create(ModuleProvider *MP, std::string* = 0);
static ExecutionEngine *create(ModuleProvider *MP, std::string *Err) {
return createJIT(MP, Err, 0);
}
/// run - Start execution with the specified function and arguments.
///
@ -120,6 +123,10 @@ public:
/// getCodeEmitter - Return the code emitter this JIT is emitting into.
MachineCodeEmitter *getCodeEmitter() const { return MCE; }
static ExecutionEngine *createJIT(ModuleProvider *MP, std::string *Err,
JITMemoryManager *JMM);
private:
static MachineCodeEmitter *createEmitter(JIT &J, JITMemoryManager *JMM);
void runJITOnFunction (Function *F);

9
lib/ExecutionEngine/JIT/TargetSelect.cpp
View File

@ -36,10 +36,11 @@ MAttrs("mattr",
cl::desc("Target specific attributes (-mattr=help for details)"),
cl::value_desc("a1,+a2,-a3,..."));
/// create - Create an return a new JIT compiler if there is one available
/// for the current target. Otherwise, return null.
/// createInternal - Create an return a new JIT compiler if there is one
/// available for the current target. Otherwise, return null.
///
ExecutionEngine *JIT::create(ModuleProvider *MP, std::string *ErrorStr) {
ExecutionEngine *JIT::createJIT(ModuleProvider *MP, std::string *ErrorStr,
JITMemoryManager *JMM) {
const TargetMachineRegistry::entry *TheArch = MArch;
if (TheArch == 0) {
std::string Error;
@ -71,7 +72,7 @@ ExecutionEngine *JIT::create(ModuleProvider *MP, std::string *ErrorStr) {
// If the target supports JIT code generation, return a new JIT now.
if (TargetJITInfo *TJ = Target->getJITInfo())
return new JIT(MP, *Target, *TJ);
return new JIT(MP, *Target, *TJ, JMM);
if (ErrorStr)
*ErrorStr = "target does not support JIT code generation";