unique_ptrify a bunch of stuff through RuntimeDyld::loadObject

[oota-llvm.git] / lib / ExecutionEngine / MCJIT / MCJIT.cpp

diff --git a/lib/ExecutionEngine/MCJIT/MCJIT.cpp b/lib/ExecutionEngine/MCJIT/MCJIT.cpp
index b114d487daa39abb27eb6312f2b3fed0fe06a709..f6c3c18a4fd7d5d33afa9283fdce8f414458de50 100644 (file)
--- a/lib/ExecutionEngine/MCJIT/MCJIT.cpp
+++ b/lib/ExecutionEngine/MCJIT/MCJIT.cpp
@@ -46,20 +46,20 @@ extern "C" void LLVMLinkInMCJIT() {
 ExecutionEngine *MCJIT::createJIT(std::unique_ptr<Module> M,
                                   std::string *ErrorStr,
                                   RTDyldMemoryManager *MemMgr,
-                                  TargetMachine *TM) {
+                                  std::unique_ptr<TargetMachine> TM) {
   // Try to register the program as a source of symbols to resolve against.
   //
   // FIXME: Don't do this here.
   sys::DynamicLibrary::LoadLibraryPermanently(nullptr, nullptr);
 
-  return new MCJIT(std::move(M), TM,
+  return new MCJIT(std::move(M), std::move(TM),
                    MemMgr ? MemMgr : new SectionMemoryManager());
 }
 
-MCJIT::MCJIT(std::unique_ptr<Module> M, TargetMachine *tm,
+MCJIT::MCJIT(std::unique_ptr<Module> M, std::unique_ptr<TargetMachine> tm,
              RTDyldMemoryManager *MM)
-    : ExecutionEngine(std::move(M)), TM(tm), Ctx(nullptr), MemMgr(this, MM),
-      Dyld(&MemMgr), ObjCache(nullptr) {
+    : ExecutionEngine(std::move(M)), TM(std::move(tm)), Ctx(nullptr),
+      MemMgr(this, MM), Dyld(&MemMgr), ObjCache(nullptr) {
   // FIXME: We are managing our modules, so we do not want the base class
   // ExecutionEngine to manage them as well. To avoid double destruction
   // of the first (and only) module added in ExecutionEngine constructor
@@ -82,19 +82,11 @@ MCJIT::~MCJIT() {
 
   Dyld.deregisterEHFrames();
 
-  LoadedObjectList::iterator it, end;
-  for (it = LoadedObjects.begin(), end = LoadedObjects.end(); it != end; ++it) {
-    ObjectImage *Obj = *it;
-    if (Obj) {
+  for (auto &Obj : LoadedObjects)
+    if (Obj)
       NotifyFreeingObject(*Obj);
-      delete Obj;
-    }
-  }
-  LoadedObjects.clear();
 
   Archives.clear();
-
-  delete TM;
 }
 
 void MCJIT::addModule(std::unique_ptr<Module> M) {
@@ -108,11 +100,11 @@ bool MCJIT::removeModule(Module *M) {
 }
 
 void MCJIT::addObjectFile(std::unique_ptr<object::ObjectFile> Obj) {
-  ObjectImage *LoadedObject = Dyld.loadObject(std::move(Obj));
+  std::unique_ptr<ObjectImage> LoadedObject = Dyld.loadObject(std::move(Obj));
   if (!LoadedObject || Dyld.hasError())
     report_fatal_error(Dyld.getErrorString());
 
-  LoadedObjects.push_back(LoadedObject);
+  LoadedObjects.push_back(std::move(LoadedObject));
 
   NotifyObjectEmitted(*LoadedObject);
 }
@@ -185,9 +177,10 @@ void MCJIT::generateCodeForModule(Module *M) {
   std::unique_ptr<ObjectBuffer> ObjectToLoad;
   // Try to load the pre-compiled object from cache if possible
   if (ObjCache) {
-    std::unique_ptr<MemoryBuffer> PreCompiledObject(ObjCache->getObject(M));
-    if (PreCompiledObject.get())
-      ObjectToLoad.reset(new ObjectBuffer(PreCompiledObject.release()));
+    if (std::unique_ptr<MemoryBuffer> PreCompiledObject =
+            ObjCache->getObject(M))
+      ObjectToLoad =
+          llvm::make_unique<ObjectBuffer>(std::move(PreCompiledObject));
   }
 
   // If the cache did not contain a suitable object, compile the object
@@ -198,8 +191,8 @@ void MCJIT::generateCodeForModule(Module *M) {
 
   // Load the object into the dynamic linker.
   // MCJIT now owns the ObjectImage pointer (via its LoadedObjects list).
-  ObjectImage *LoadedObject = Dyld.loadObject(ObjectToLoad.release());
-  LoadedObjects.push_back(LoadedObject);
+  std::unique_ptr<ObjectImage> LoadedObject =
+      Dyld.loadObject(std::move(ObjectToLoad));
   if (!LoadedObject)
     report_fatal_error(Dyld.getErrorString());
 
@@ -208,6 +201,8 @@ void MCJIT::generateCodeForModule(Module *M) {
 
   NotifyObjectEmitted(*LoadedObject);
 
+  LoadedObjects.push_back(std::move(LoadedObject));
+
   OwnedModules.markModuleAsLoaded(M);
 }
 
@@ -565,10 +560,8 @@ void MCJIT::NotifyObjectEmitted(const ObjectImage& Obj) {
 }
 void MCJIT::NotifyFreeingObject(const ObjectImage& Obj) {
   MutexGuard locked(lock);
-  for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) {
-    JITEventListener *L = EventListeners[I];
+  for (JITEventListener *L : EventListeners)
     L->NotifyFreeingObject(Obj);
-  }
 }
 
 uint64_t LinkingMemoryManager::getSymbolAddress(const std::string &Name) {