diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h index 3ec2641cada..ad0a738426e 100644 --- a/include/llvm/ExecutionEngine/ExecutionEngine.h +++ b/include/llvm/ExecutionEngine/ExecutionEngine.h @@ -12,8 +12,8 @@ // //===----------------------------------------------------------------------===// -#ifndef EXECUTION_ENGINE_H -#define EXECUTION_ENGINE_H +#ifndef LLVM_EXECUTION_ENGINE_H +#define LLVM_EXECUTION_ENGINE_H #include #include @@ -34,6 +34,7 @@ class ModuleProvider; class TargetData; class Type; class MutexGuard; +class JITMemoryManager; class ExecutionEngineState { private: @@ -90,18 +91,36 @@ public: /// any of those classes. sys::Mutex lock; // Used to make this class and subclasses thread-safe - ExecutionEngine(ModuleProvider *P); - ExecutionEngine(Module *M); + //===----------------------------------------------------------------------===// + // ExecutionEngine Startup + //===----------------------------------------------------------------------===// + virtual ~ExecutionEngine(); - const TargetData *getTargetData() const { return TD; } - + /// create - This is the factory method for creating an execution engine which + /// is appropriate for the current machine. This takes ownership of the + /// module provider. + static ExecutionEngine *create(ModuleProvider *MP, + bool ForceInterpreter = false, + std::string *ErrorStr = 0); + + /// create - This is the factory method for creating an execution engine which + /// is appropriate for the current machine. This takes ownership of the + /// module. + static ExecutionEngine *create(Module *M); + + /// addModuleProvider - Add a ModuleProvider to the list of modules that we /// can JIT from. Note that this takes ownership of the ModuleProvider: when /// the ExecutionEngine is destroyed, it destroys the MP as well. void addModuleProvider(ModuleProvider *P) { Modules.push_back(P); } + + //===----------------------------------------------------------------------===// + + const TargetData *getTargetData() const { return TD; } + /// removeModuleProvider - Remove a ModuleProvider from the list of modules. /// Release module from ModuleProvider. @@ -112,18 +131,6 @@ public: /// general code. Function *FindFunctionNamed(const char *FnName); - /// create - This is the factory method for creating an execution engine which - /// is appropriate for the current machine. This takes ownership of the - /// module provider. - static ExecutionEngine *create(ModuleProvider *MP, - bool ForceInterpreter = false, - std::string *ErrorStr = 0); - - /// create - This is the factory method for creating an execution engine which - /// is appropriate for the current machine. This takes ownership of the - /// module. - static ExecutionEngine *create(Module *M); - /// runFunction - Execute the specified function with the specified arguments, /// and return the result. /// @@ -233,6 +240,8 @@ public: } protected: + ExecutionEngine(ModuleProvider *P); + void emitGlobals(); // EmitGlobalVariable - This method emits the specified global variable to the diff --git a/lib/ExecutionEngine/ExecutionEngine.cpp b/lib/ExecutionEngine/ExecutionEngine.cpp index cc3cc38305b..02b94cc1fdb 100644 --- a/lib/ExecutionEngine/ExecutionEngine.cpp +++ b/lib/ExecutionEngine/ExecutionEngine.cpp @@ -39,12 +39,6 @@ ExecutionEngine::ExecutionEngine(ModuleProvider *P) : LazyFunctionCreator(0) { assert(P && "ModuleProvider is null?"); } -ExecutionEngine::ExecutionEngine(Module *M) : LazyFunctionCreator(0) { - LazyCompilationDisabled = false; - assert(M && "Module is null?"); - Modules.push_back(new ExistingModuleProvider(M)); -} - ExecutionEngine::~ExecutionEngine() { clearAllGlobalMappings(); for (unsigned i = 0, e = Modules.size(); i != e; ++i) diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.cpp b/lib/ExecutionEngine/Interpreter/Interpreter.cpp index 3a156bf51c3..65ca01210a4 100644 --- a/lib/ExecutionEngine/Interpreter/Interpreter.cpp +++ b/lib/ExecutionEngine/Interpreter/Interpreter.cpp @@ -33,26 +33,18 @@ namespace llvm { /// ExecutionEngine *Interpreter::create(ModuleProvider *MP, std::string* ErrStr) { // Tell this ModuleProvide to materialize and release the module - Module *M = MP->releaseModule(ErrStr); - if (!M) + if (!MP->materializeModule(ErrStr)) // We got an error, just return 0 return 0; - // This is a bit nasty, but the ExecutionEngine won't be able to delete the - // module due to use/def issues if we don't delete this MP here. Below we - // construct a new Interpreter with the Module we just got. This creates a - // new ExistingModuleProvider in the EE instance. Consequently, MP is left - // dangling and it contains references into the module which cause problems - // when the module is deleted via the ExistingModuleProvide via EE. - delete MP; - - return new Interpreter(M); + return new Interpreter(MP); } //===----------------------------------------------------------------------===// // Interpreter ctor - Initialize stuff // -Interpreter::Interpreter(Module *M) : ExecutionEngine(M), TD(M) { +Interpreter::Interpreter(ModuleProvider *M) + : ExecutionEngine(M), TD(M->getModule()) { memset(&ExitValue.Untyped, 0, sizeof(ExitValue.Untyped)); setTargetData(&TD); diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h index 9ad837c31b4..3c5d4b1256d 100644 --- a/lib/ExecutionEngine/Interpreter/Interpreter.h +++ b/lib/ExecutionEngine/Interpreter/Interpreter.h @@ -94,7 +94,7 @@ class Interpreter : public ExecutionEngine, public InstVisitor { std::vector AtExitHandlers; public: - explicit Interpreter(Module *M); + explicit Interpreter(ModuleProvider *M); ~Interpreter(); /// runAtExitHandlers - Run any functions registered by the program's calls to diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp index 5b04124cd05..b5994975025 100644 --- a/lib/ExecutionEngine/JIT/JIT.cpp +++ b/lib/ExecutionEngine/JIT/JIT.cpp @@ -66,7 +66,7 @@ JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji) setTargetData(TM.getTargetData()); // Initialize MCE - MCE = createEmitter(*this); + MCE = createEmitter(*this, 0); // Add target data MutexGuard locked(lock); diff --git a/lib/ExecutionEngine/JIT/JIT.h b/lib/ExecutionEngine/JIT/JIT.h index 5a3d6614dbc..64537409170 100644 --- a/lib/ExecutionEngine/JIT/JIT.h +++ b/lib/ExecutionEngine/JIT/JIT.h @@ -121,7 +121,7 @@ public: /// getCodeEmitter - Return the code emitter this JIT is emitting into. MachineCodeEmitter *getCodeEmitter() const { return MCE; } private: - static MachineCodeEmitter *createEmitter(JIT &J); + static MachineCodeEmitter *createEmitter(JIT &J, JITMemoryManager *JMM); void runJITOnFunction (Function *F); }; diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp index d08bf0b3cb8..a1b4b005c2a 100644 --- a/lib/ExecutionEngine/JIT/JITEmitter.cpp +++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp @@ -312,8 +312,8 @@ namespace { /// Resolver - This contains info about the currently resolved functions. JITResolver Resolver; public: - JITEmitter(JIT &jit) : Resolver(jit) { - MemMgr = JITMemoryManager::CreateDefaultMemManager(); + JITEmitter(JIT &jit, JITMemoryManager *JMM) : Resolver(jit) { + MemMgr = JMM ? JMM : JITMemoryManager::CreateDefaultMemManager(); if (jit.getJITInfo().needsGOT()) { MemMgr->AllocateGOT(); DOUT << "JIT is managing a GOT\n"; @@ -637,8 +637,8 @@ intptr_t JITEmitter::getJumpTableEntryAddress(unsigned Index) const { // Public interface to this file //===----------------------------------------------------------------------===// -MachineCodeEmitter *JIT::createEmitter(JIT &jit) { - return new JITEmitter(jit); +MachineCodeEmitter *JIT::createEmitter(JIT &jit, JITMemoryManager *JMM) { + return new JITEmitter(jit, JMM); } // getPointerToNamedFunction - This function is used as a global wrapper to