RuntimeDyld: allow using custom implementation

[evgeny777]

Summary

This patch allows using custom binary format implementation or tweak behavior in existing ones by deriving a class from RuntimeDyldELF and friends. I personally need this to be able to move jitted code to a different memory location.

[evgeny777]

Found a different way of doing this

include/llvm/ExecutionEngine/RuntimeDyld.h

virtual void notifyObjectLoaded(RuntimeDyld &RTDyld,
                                     const object::ObjectFile &Obj) {}
 
   private:
     virtual void anchor();
 
     bool FinalizationLocked = false;
   };
 
+  typedef std::function<std::unique_ptr<RuntimeDyldImpl>(
+      const object::ObjectFile &O)>
+      DyldImplCreateFtor;
+
   /// \brief Construct a RuntimeDyld instance.
-  RuntimeDyld(MemoryManager &MemMgr, JITSymbolResolver &Resolver);
+  RuntimeDyld(MemoryManager &MemMgr, JITSymbolResolver &Resolver,
+              DyldImplCreateFtor = nullptr);
   RuntimeDyld(const RuntimeDyld &) = delete;
   void operator=(const RuntimeDyld &) = delete;
   ~RuntimeDyld();
 
   /// Add the referenced object file to the list of objects to be loaded and
   /// relocated.
   std::unique_ptr<LoadedObjectInfo> loadObject(const object::ObjectFile &O);
 
public:
   ///   outer instances.
   ///
   /// ** Recursive finalization occurs when one RuntimeDyld instances needs the
   ///   address of a symbol owned by some other instance in order to apply
   ///   relocations.
   ///
   void finalizeWithMemoryManagerLocking();
 
+  /// Gets pointer to implementation
+  RuntimeDyldImpl *getImpl();
+
 private:
   // RuntimeDyldImpl is the actual class. RuntimeDyld is just the public
   // interface.
   std::unique_ptr<RuntimeDyldImpl> Dyld;
+  DyldImplCreateFtor DyldCreator;
   MemoryManager &MemMgr;
   JITSymbolResolver &Resolver;
   bool ProcessAllSections;
   RuntimeDyldCheckerImpl *Checker;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_RUNTIMEDYLD_H

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

uint64_t RuntimeDyld::LoadedObjectInfo::getSectionLoadAddress(
 
   return 0;
 }
 
 void RuntimeDyld::MemoryManager::anchor() {}
 void JITSymbolResolver::anchor() {}
 
 RuntimeDyld::RuntimeDyld(RuntimeDyld::MemoryManager &MemMgr,
-                         JITSymbolResolver &Resolver)
-    : MemMgr(MemMgr), Resolver(Resolver) {
+                         JITSymbolResolver &Resolver,
+                         DyldImplCreateFtor DyldCreator)
+    : DyldCreator(DyldCreator), MemMgr(MemMgr), Resolver(Resolver) {
   // FIXME: There's a potential issue lurking here if a single instance of
   // RuntimeDyld is used to load multiple objects.  The current implementation
   // associates a single memory manager with a RuntimeDyld instance.  Even
   // though the public class spawns a new 'impl' instance for each load,
   // they share a single memory manager.  This can become a problem when page
   // permissions are applied.
   Dyld = nullptr;
   ProcessAllSections = false;
createRuntimeDyldMachO(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM,
   Dyld->setProcessAllSections(ProcessAllSections);
   Dyld->setRuntimeDyldChecker(Checker);
   return Dyld;
 }
 
 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
 RuntimeDyld::loadObject(const ObjectFile &Obj) {
   if (!Dyld) {
-    if (Obj.isELF())
+    if (DyldCreator)
+      Dyld = DyldCreator(Obj);
+    else if (Obj.isELF())
       Dyld =
           createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()),
                                MemMgr, Resolver, ProcessAllSections, Checker);
     else if (Obj.isMachO())
       Dyld = createRuntimeDyldMachO(
                static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
                ProcessAllSections, Checker);
     else if (Obj.isCOFF())
void RuntimeDyld::finalizeWithMemoryManagerLocking() {
   resolveRelocations();
   registerEHFrames();
   if (!MemoryFinalizationLocked) {
     MemMgr.finalizeMemory();
     MemMgr.FinalizationLocked = false;
   }
 }
 
+RuntimeDyldImpl *RuntimeDyld::getImpl() { return Dyld.get(); }
+
 void RuntimeDyld::registerEHFrames() {
   if (Dyld)
     Dyld->registerEHFrames();
 }
 
 void RuntimeDyld::deregisterEHFrames() {
   if (Dyld)
     Dyld->deregisterEHFrames();
 }
 
 } // end namespace llvm