[JITLink] Pass ObjectFile in NotifyLoaded() for JITEventListener support

[sgraenitz]

Summary

Quick hack to pass ObjectFiles back to the ObjectLinkingLayer so NotifyLoaded() can include them. This may be one way to support JITEventListeners with JITLink. For more info please find my post-commit comment here: https://reviews.llvm.org/D58704#1476841

[lhames]

This looks good, but I think we should hand back ownership of the MemoryBuffer instead, and drop the ObjectFile: The MemoryBuffer start address can serve as a stable key, and the ObjectFile can be re-created from the buffer if the client requires. This will allow us to avoid any coupling between JITLink's interface and libObject's, which will make refactoring easier when we want to move JITLink on to a libObject successor (which I think we will eventually).

[sgraenitz]

Ok I see, as long as the original MemoryBuffer exists, we can recreate an identical ObjectFile on the client side. Currently it gets deleted together with JITLinkContext when returning from jitLink().

After notifyResolved(), JITLinkContext deals with the Allocation and doesn't use its MemoryBuffer anymore right? Also, at this point NotifyLoaded is called currently. If so, we may:

1. either hand out ownership with the notification (not sure that's a good idea) and delete the (potentially moved-from) MemoryBuffer pointer here;
2. or pass it "back" to ObjectLinkingLayer (ObjectResources?) and hand out a MemBufferRef in NotifyLoaded instead (sounds more sane to me).

What do you think?

[sgraenitz]

For illustration: pass ownership to ObjectLinkingLayer and hand out a MemBufferRef in NotifyLoaded

[lhames]

Hi Stefan. I removed these callbacks when I added ObjectLinkingLayer::Plugin in order to tidy things up temporarily, but I think they’re still useful. I would be inclined to add two callbacks back in:

(1) NotifyLoaded — To be called as soon as we load an object (mostly useful for debugging)
(2) NotifyEmitted — To be called after we’ve fixed up and locked down the allocated memory, but before we call emit on the MaterializationResponsibility.

I would hand back ownership in the latter. Some clients like to be able to hold on to the buffer after the JIT is done with it.

[sgraenitz]

Ok, I went with MCJIT for now. Will leave this here for future reference.

llvm/include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h

 
 class ObjectLinkingLayerJITLinkContext;
 
 class ObjectLinkingLayer : public ObjectLayer {
   friend class ObjectLinkingLayerJITLinkContext;
 
 public:
   /// Function object for receiving object-loaded notifications.
-  using NotifyLoadedFunction = std::function<void(VModuleKey)>;
+  using NotifyLoadedFunction = std::function<void(VModuleKey, MemoryBufferRef)>;
 
   /// Function object for receiving finalization notifications.
   using NotifyEmittedFunction = std::function<void(VModuleKey)>;
 
   /// Function object for modifying PassConfiguration objects.
   using ModifyPassConfigFunction =
       std::function<void(const Triple &TT, jitlink::PassConfiguration &Config)>;
 
public:
     ObjectResources &operator=(ObjectResources &&Other);
     ~ObjectResources();
 
   private:
     AllocPtr Alloc;
     JITTargetAddress EHFrameAddr = 0;
   };
 
+  void notifyLoaded(VModuleKey K, std::unique_ptr<MemoryBuffer> O) {
+    ObjBuffers.push_back(std::move(O)); // FIXME: avoid deletion
+
+    if (NotifyLoaded)
+      NotifyLoaded(K, ObjBuffers.back()->getMemBufferRef());
+  }
+
   void notifyFinalized(ObjectResources OR) {
     ObjResources.push_back(std::move(OR));
   }
 
   mutable std::mutex LayerMutex;
   jitlink::JITLinkMemoryManager &MemMgr;
   NotifyLoadedFunction NotifyLoaded;
   NotifyEmittedFunction NotifyEmitted;
   ModifyPassConfigFunction ModifyPassConfig;
   bool OverrideObjectFlags = false;
   bool AutoClaimObjectSymbols = false;
   std::vector<ObjectResources> ObjResources;
+  std::vector<std::unique_ptr<MemoryBuffer>> ObjBuffers; // FIXME: add to ObjResources?
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_OBJECTLINKINGLAYER_H

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

for (auto *A : G.absolute_atoms())
         }
       }
 
     if (!ExtraSymbolsToClaim.empty())
       if (auto Err = MR.defineMaterializing(ExtraSymbolsToClaim))
         return notifyFailed(std::move(Err));
 
     MR.resolve(InternedResult);
-
-    if (Layer.NotifyLoaded)
-      Layer.NotifyLoaded(MR.getVModuleKey());
+    Layer.notifyLoaded(MR.getVModuleKey(), std::move(ObjBuffer));
   }
 
   void notifyFinalized(
       std::unique_ptr<JITLinkMemoryManager::Allocation> A) override {
 
     if (EHFrameAddr) {
       // If there is an eh-frame then try to register it.
       if (auto Err = registerEHFrameSection((void *)EHFrameAddr)) {