From 06fd5bf4ea122960f0435449c2391ea4fe1ea2ca Mon Sep 17 00:00:00 2001 From: Rafael Espindola Date: Thu, 25 Apr 2013 03:47:41 +0000 Subject: Revert "Adding object caching support to MCJIT" This reverts commit 07f03923137a91e3cca5d7fc075a22f8c9baf33a. Looks like it broke the valgrind bot: http://lab.llvm.org:8011/builders/llvm-x86_64-linux-vg_leak/builds/649 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180249 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/MCJIT/MCJIT.cpp | 69 +++++++++---------------------------- lib/ExecutionEngine/MCJIT/MCJIT.h | 14 ++------ 2 files changed, 18 insertions(+), 65 deletions(-) (limited to 'lib') diff --git a/lib/ExecutionEngine/MCJIT/MCJIT.cpp b/lib/ExecutionEngine/MCJIT/MCJIT.cpp index 77ea07631c..fee10e1943 100644 --- a/lib/ExecutionEngine/MCJIT/MCJIT.cpp +++ b/lib/ExecutionEngine/MCJIT/MCJIT.cpp @@ -52,7 +52,7 @@ ExecutionEngine *MCJIT::createJIT(Module *M, MCJIT::MCJIT(Module *m, TargetMachine *tm, RTDyldMemoryManager *MM, bool AllocateGVsWithCode) : ExecutionEngine(m), TM(tm), Ctx(0), MemMgr(MM), Dyld(MM), - IsLoaded(false), M(m), ObjCache(0) { + isCompiled(false), M(m) { setDataLayout(TM->getDataLayout()); } @@ -64,11 +64,7 @@ MCJIT::~MCJIT() { delete TM; } -void MCJIT::setObjectCache(ObjectCache* NewCache) { - ObjCache = NewCache; -} - -ObjectBufferStream* MCJIT::emitObject(Module *m) { +void MCJIT::emitObject(Module *m) { /// Currently, MCJIT only supports a single module and the module passed to /// this function call is expected to be the contained module. The module /// is passed as a parameter here to prepare for multiple module support in @@ -81,63 +77,30 @@ ObjectBufferStream* MCJIT::emitObject(Module *m) { // FIXME: Track compilation state on a per-module basis when multiple modules // are supported. // Re-compilation is not supported - assert(!IsLoaded); + if (isCompiled) + return; PassManager PM; PM.add(new DataLayout(*TM->getDataLayout())); // The RuntimeDyld will take ownership of this shortly - OwningPtr CompiledObject(new ObjectBufferStream()); + OwningPtr Buffer(new ObjectBufferStream()); // Turn the machine code intermediate representation into bytes in memory // that may be executed. - if (TM->addPassesToEmitMC(PM, Ctx, CompiledObject->getOStream(), false)) { + if (TM->addPassesToEmitMC(PM, Ctx, Buffer->getOStream(), false)) { report_fatal_error("Target does not support MC emission!"); } // Initialize passes. PM.run(*m); // Flush the output buffer to get the generated code into memory - CompiledObject->flush(); - - // If we have an object cache, tell it about the new object. - // Note that we're using the compiled image, not the loaded image (as below). - if (ObjCache) { - ObjCache->notifyObjectCompiled(m, CompiledObject->getMemBuffer()); - } - - return CompiledObject.take(); -} - -void MCJIT::loadObject(Module *M) { - - // Get a thread lock to make sure we aren't trying to load multiple times - MutexGuard locked(lock); - - // FIXME: Track compilation state on a per-module basis when multiple modules - // are supported. - // Re-compilation is not supported - if (IsLoaded) - return; - - OwningPtr ObjectToLoad; - // Try to load the pre-compiled object from cache if possible - if (0 != ObjCache) { - OwningPtr PreCompiledObject(ObjCache->getObjectCopy(M)); - if (0 != PreCompiledObject.get()) - ObjectToLoad.reset(new ObjectBuffer(PreCompiledObject.take())); - } - - // If the cache did not contain a suitable object, compile the object - if (!ObjectToLoad) { - ObjectToLoad.reset(emitObject(M)); - assert(ObjectToLoad.get() && "Compilation did not produce an object."); - } + Buffer->flush(); // Load the object into the dynamic linker. // handing off ownership of the buffer - LoadedObject.reset(Dyld.loadObject(ObjectToLoad.take())); + LoadedObject.reset(Dyld.loadObject(Buffer.take())); if (!LoadedObject) report_fatal_error(Dyld.getErrorString()); @@ -150,7 +113,7 @@ void MCJIT::loadObject(Module *M) { NotifyObjectEmitted(*LoadedObject); // FIXME: Add support for per-module compilation state - IsLoaded = true; + isCompiled = true; } // FIXME: Add a parameter to identify which object is being finalized when @@ -159,10 +122,10 @@ void MCJIT::loadObject(Module *M) { // protection in the interface. void MCJIT::finalizeObject() { // If the module hasn't been compiled, just do that. - if (!IsLoaded) { - // If the call to Dyld.resolveRelocations() is removed from loadObject() + if (!isCompiled) { + // If the call to Dyld.resolveRelocations() is removed from emitObject() // we'll need to do that here. - loadObject(M); + emitObject(M); // Set page permissions. MemMgr->applyPermissions(); @@ -188,8 +151,8 @@ void *MCJIT::getPointerToFunction(Function *F) { // dies. // FIXME: Add support for per-module compilation state - if (!IsLoaded) - loadObject(M); + if (!isCompiled) + emitObject(M); if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) { bool AbortOnFailure = !F->hasExternalWeakLinkage(); @@ -321,8 +284,8 @@ GenericValue MCJIT::runFunction(Function *F, void *MCJIT::getPointerToNamedFunction(const std::string &Name, bool AbortOnFailure) { // FIXME: Add support for per-module compilation state - if (!IsLoaded) - loadObject(M); + if (!isCompiled) + emitObject(M); if (!isSymbolSearchingDisabled() && MemMgr) { void *ptr = MemMgr->getPointerToNamedFunction(Name, false); diff --git a/lib/ExecutionEngine/MCJIT/MCJIT.h b/lib/ExecutionEngine/MCJIT/MCJIT.h index 8c4bf6e1db..283a8e5281 100644 --- a/lib/ExecutionEngine/MCJIT/MCJIT.h +++ b/lib/ExecutionEngine/MCJIT/MCJIT.h @@ -12,7 +12,6 @@ #include "llvm/ADT/SmallVector.h" #include "llvm/ExecutionEngine/ExecutionEngine.h" -#include "llvm/ExecutionEngine/ObjectCache.h" #include "llvm/ExecutionEngine/RuntimeDyld.h" #include "llvm/PassManager.h" @@ -35,23 +34,16 @@ class MCJIT : public ExecutionEngine { SmallVector EventListeners; // FIXME: Add support for multiple modules - bool IsLoaded; + bool isCompiled; Module *M; OwningPtr LoadedObject; - // An optional ObjectCache to be notified of compiled objects and used to - // perform lookup of pre-compiled code to avoid re-compilation. - ObjectCache *ObjCache; - public: ~MCJIT(); /// @name ExecutionEngine interface implementation /// @{ - /// Sets the object manager that MCJIT should use to avoid compilation. - virtual void setObjectCache(ObjectCache *manager); - virtual void finalizeObject(); virtual void *getPointerToBasicBlock(BasicBlock *BB); @@ -110,9 +102,7 @@ protected: /// this function call is expected to be the contained module. The module /// is passed as a parameter here to prepare for multiple module support in /// the future. - ObjectBufferStream* emitObject(Module *M); - - void loadObject(Module *M); + void emitObject(Module *M); void NotifyObjectEmitted(const ObjectImage& Obj); void NotifyFreeingObject(const ObjectImage& Obj); -- cgit v1.2.3