Revising the MCJIT ObjectCache interface to allow subclasses to avoid retaining references to returned objects

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@185221 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 14 insertions, 25 deletions

diff --git a/include/llvm/ExecutionEngine/ObjectCache.h b/include/llvm/ExecutionEngine/ObjectCache.h
index 0bee861..aa200fb 100644
--- a/include/llvm/ExecutionEngine/ObjectCache.h
+++ b/include/llvm/ExecutionEngine/ObjectCache.h
@@ -30,23 +30,9 @@ public:
 
   /// getObjectCopy - Returns a pointer to a newly allocated MemoryBuffer that
   /// contains the object which corresponds with Module M, or 0 if an object is
-  /// not available. The caller owns the MemoryBuffer returned by this function.
-  MemoryBuffer* getObjectCopy(const Module* M) {
-    const MemoryBuffer* Obj = getObject(M);
-    if (Obj)
-      return MemoryBuffer::getMemBufferCopy(Obj->getBuffer());
-    else
-      return 0;
-  }
-
-protected:
-  /// getObject - Returns a pointer to a MemoryBuffer that contains an object
-  /// that corresponds with Module M, or 0 if an object is not available.
-  /// The pointer returned by this function is not suitable for loading because
-  /// the memory is read-only and owned by the ObjectCache. To retrieve an
-  /// owning pointer to a MemoryBuffer (which is suitable for calling
-  /// RuntimeDyld::loadObject() with) use getObjectCopy() instead.
-  virtual const MemoryBuffer* getObject(const Module* M) = 0;
+  /// not available. The caller owns both the MemoryBuffer returned by this
+  /// and the memory it references.
+  virtual MemoryBuffer* getObject(const Module* M) = 0;
 };
 
 }
diff --git a/lib/ExecutionEngine/MCJIT/MCJIT.cpp b/lib/ExecutionEngine/MCJIT/MCJIT.cpp
index e861938..09dd924 100644
--- a/lib/ExecutionEngine/MCJIT/MCJIT.cpp
+++ b/lib/ExecutionEngine/MCJIT/MCJIT.cpp
@@ -129,7 +129,7 @@ void MCJIT::loadObject(Module *M) {
   OwningPtr<ObjectBuffer> ObjectToLoad;
   // Try to load the pre-compiled object from cache if possible
   if (0 != ObjCache) {
-    OwningPtr<MemoryBuffer> PreCompiledObject(ObjCache->getObjectCopy(M));
+    OwningPtr<MemoryBuffer> PreCompiledObject(ObjCache->getObject(M));
     if (0 != PreCompiledObject.get())
       ObjectToLoad.reset(new ObjectBuffer(PreCompiledObject.take()));
   }
diff --git a/unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp b/unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
index 32fc292..2cc045b 100644
--- a/unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
+++ b/unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
@@ -45,6 +45,16 @@ public:
     ObjMap[ModuleID] = copyBuffer(Obj);
   }
 
+  virtual MemoryBuffer* getObject(const Module* M) {
+    const MemoryBuffer* BufferFound = getObjectInternal(M);
+    ModulesLookedUp.insert(M->getModuleIdentifier());
+    if (!BufferFound)
+      return NULL;
+    // Our test cache wants to maintain ownership of its object buffers
+    // so we make a copy here for the execution engine.
+    return MemoryBuffer::getMemBufferCopy(BufferFound->getBuffer());
+  }
+
   // Test-harness-specific functions
   bool wereDuplicatesInserted() { return DuplicateInserted; }
 
@@ -62,13 +72,6 @@ public:
     return it->second;
   }
 
-protected:
-  virtual const MemoryBuffer* getObject(const Module* M) {
-    const MemoryBuffer* BufferFound = getObjectInternal(M);
-    ModulesLookedUp.insert(M->getModuleIdentifier());
-    return BufferFound;
-  }
-
 private:
   MemoryBuffer *copyBuffer(const MemoryBuffer *Buf) {
     // Create a local copy of the buffer.