Allow to integrate OrcJIT with JitEventListeners

[anarazel]

Summary

See #31521

Contained-Commits:

[ORC] Extend object layer callbacks so JITEventListener can be supported.

Currently the RTDyldObjectLinkingLayer makes it hard to support
JITEventListeners. Which in turn means debugging and profiling JIT
generated code hard.

Supporting JITEventListeners at minimum requries a freed
callback (added).

As listeners expect the ObjectFile to be passed as well, an adaptor
between RTDyldObjectLinkingLayer and JITEventListeners would currently
need to also maintain ObjectFiles for all loaded modules. To make that
less awkward extend the callbacks to pass the ObjectFile to both
Finalized and Freed callbacks. That requires extending the lifetime
of the object file when callbacks are present.

[ORC] Add ability [un]register JITEventListener on C Orc stack.

[ORC][C-API] Expose LLVMOrc{Unr,R}egisterJITEventListener().

[C-API] Add functions to create GDB, Intel, Oprofile event listeners.

Intel and Oprofile were done blindly, I don't have the environment to
build them.

[anarazel]

Ping? I'm using this functionality in postgres's new JIT support. It'd be cool if it were merged so we can make sure the released version of Postgres is going to use the right API, even if LLVM has to be patched for it to be available in older releases.

We're using it both for debugging and profiling support (see https://reviews.llvm.org/D44892).

[anarazel]

Ping? @lhames unfortunately you're probably the only one to review this?

include/llvm-c/ExecutionEngine.h

187

Create is wrong for at least GDB which essentially is a singleton, but I don' tthink it's helpful to deviate from the underlying name.

include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h

167

This isn't pretty, but I don't quite see a good alternative.

lib/ExecutionEngine/Orc/OrcCBindingsStack.h

428

This ain't algorithmically efficient, but I can't see enough listeners being registered for that to matter.

[lhames]

Looks good to me! (Sorry for the belated reply!)

include/llvm-c/ExecutionEngine.h

LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
   void *Opaque,
   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
   LLVMMemoryManagerDestroyCallback Destroy);
 
 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
 
+/*===-- JIT Event Listener functions -------------------------------------===*/
+
+LLVMJITEventListenerRef LLVMCreateGDBRegistrationListener(void);
+LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void);
+LLVMJITEventListenerRef LLVMCreateOprofileJITEventListener(void);
+
 /**
  * @}
  */
 
 #ifdef __cplusplus
 }
 #endif /* defined(__cplusplus) */
 
 #endif

include/llvm-c/OrcBindings.h

LLVMOrcErrorCode LLVMOrcGetSymbolAddress(LLVMOrcJITStackRef JITStack,
                                          LLVMOrcTargetAddress *RetAddr,
                                          const char *SymbolName);
 
 /**
  * Dispose of an ORC JIT stack.
  */
 LLVMOrcErrorCode LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack);
 
+/**
+ * Register a JIT Event Listener.
+ *
+ * A NULL listener is ignored.
+ */
+void LLVMOrcRegisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L);
+
+/**
+ * Unegister a JIT Event Listener.
+ *
+ * A NULL listener is ignored.
+ */
+void LLVMOrcUnregisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L);
+
 #ifdef __cplusplus
 }
 #endif /* extern "C" */
 
 #endif /* LLVM_C_ORCBINDINGS_H */

include/llvm-c/Types.h

 typedef struct LLVMOpaqueDiagnosticInfo *LLVMDiagnosticInfoRef;
 
 /**
  * @see llvm::Comdat
  */
 typedef struct LLVMComdat *LLVMComdatRef;
 
 /**
+ * @see llvm::JITEventListener
+ */
+typedef struct LLVMOpaqueJITEventListener *LLVMJITEventListenerRef;
+
+/**
  * @}
  */
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif

include/llvm/ExecutionEngine/JITEventListener.h

 // This file defines the JITEventListener interface, which lets users get
 // callbacks when significant events happen during the JIT compilation process.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_JITEVENTLISTENER_H
 #define LLVM_EXECUTIONENGINE_JITEVENTLISTENER_H
 
+#include "llvm-c/ExecutionEngine.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/IR/DebugLoc.h"
+#include "llvm/Support/CBindingWrapping.h"
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 
 class IntelJITEventsWrapper;
 class MachineFunction;
 class OProfileWrapper;
static JITEventListener *createOProfileJITEventListener(
     return nullptr;
   }
 #endif // USE_OPROFILE
 
 private:
   virtual void anchor();
 };
 
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(JITEventListener, LLVMJITEventListenerRef)
+
 } // end namespace llvm
 
+#ifndef LLVM_USE_INTEL_JITEVENTS
+LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void) {
+  return nullptr;
+}
+#endif
+
+#ifndef LLVM_USE_OPROFILE
+LLVMJITEventListenerRef LLVMCreateOProfileJITEventListener(void) {
+  return nullptr;
+}
+#endif
+
 #endif // LLVM_EXECUTIONENGINE_JITEVENTLISTENER_H

include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h

public:
   using RTDyldObjectLinkingLayerBase::ObjectPtr;
 
   /// @brief Functor for receiving object-loaded notifications.
   using NotifyLoadedFtor =
       std::function<void(VModuleKey, const object::ObjectFile &Obj,
                          const RuntimeDyld::LoadedObjectInfo &)>;
 
   /// @brief Functor for receiving finalization notifications.
-  using NotifyFinalizedFtor = std::function<void(VModuleKey)>;
+  using NotifyFinalizedFtor =
+      std::function<void(VModuleKey, const object::ObjectFile &Obj,
+                         const RuntimeDyld::LoadedObjectInfo &)>;
+
+  /// @brief Functor for receiving deallocation notifications.
+  using NotifyFreedFtor = std::function<void(VModuleKey, const object::ObjectFile &Obj)>;
 
 private:
   using OwnedObject = object::OwningBinary<object::ObjectFile>;
 
   template <typename MemoryManagerPtrT>
   class ConcreteLinkedObject : public LinkedObject {
   public:
     ConcreteLinkedObject(RTDyldObjectLinkingLayer &Parent, VModuleKey K,
                          OwnedObject Obj, MemoryManagerPtrT MemMgr,
                          std::shared_ptr<SymbolResolver> Resolver,
                          bool ProcessAllSections)
-        : MemMgr(std::move(MemMgr)),
+        : K(std::move(K)),
+          Parent(Parent),
+          MemMgr(std::move(MemMgr)),
           PFC(llvm::make_unique<PreFinalizeContents>(
-              Parent, std::move(K), std::move(Obj), std::move(Resolver),
+              std::move(Obj), std::move(Resolver),
               ProcessAllSections)) {
       buildInitialSymbolTable(PFC->Obj);
     }
 
     ~ConcreteLinkedObject() override {
+      if (this->Parent.NotifyFreed)
+        this->Parent.NotifyFreed(K, *ObjForNotify.getBinary());
+
       MemMgr->deregisterEHFrames();
     }
 
     Error finalize() override {
       assert(PFC && "mapSectionAddress called on finalized LinkedObject");
 
-      JITSymbolResolverAdapter ResolverAdapter(PFC->Parent.ES, *PFC->Resolver);
+      JITSymbolResolverAdapter ResolverAdapter(Parent.ES, *PFC->Resolver);
       PFC->RTDyld = llvm::make_unique<RuntimeDyld>(*MemMgr, ResolverAdapter);
       PFC->RTDyld->setProcessAllSections(PFC->ProcessAllSections);
 
       Finalized = true;
 
       std::unique_ptr<RuntimeDyld::LoadedObjectInfo> Info =
           PFC->RTDyld->loadObject(*PFC->Obj.getBinary());
 
       // Copy the symbol table out of the RuntimeDyld instance.
       {
         auto SymTab = PFC->RTDyld->getSymbolTable();
         for (auto &KV : SymTab)
           SymbolTable[KV.first] = KV.second;
       }
 
-      if (PFC->Parent.NotifyLoaded)
-        PFC->Parent.NotifyLoaded(PFC->K, *PFC->Obj.getBinary(), *Info);
+      if (Parent.NotifyLoaded)
+        Parent.NotifyLoaded(K, *PFC->Obj.getBinary(), *Info);
 
       PFC->RTDyld->finalizeWithMemoryManagerLocking();
 
       if (PFC->RTDyld->hasError())
         return make_error<StringError>(PFC->RTDyld->getErrorString(),
                                        inconvertibleErrorCode());
 
-      if (PFC->Parent.NotifyFinalized)
-        PFC->Parent.NotifyFinalized(PFC->K);
+      if (Parent.NotifyFinalized)
+        Parent.NotifyFinalized(K, *PFC->Obj.getBinary(), *Info);
 
       // Release resources.
+      if (this->Parent.NotifyFreed)
+        ObjForNotify = std::move(PFC->Obj); // needed for callback
       PFC = nullptr;
       return Error::success();
     }
 
     JITSymbol::GetAddressFtor getSymbolMaterializer(std::string Name) override {
       return [this, Name]() -> Expected<JITTargetAddress> {
         // The symbol may be materialized between the creation of this lambda
         // and its execution, so we need to double check.
void buildInitialSymbolTable(const OwnedObject &Obj) {
         SymbolTable.insert(
           std::make_pair(*SymbolName, JITEvaluatedSymbol(0, Flags)));
       }
     }
 
     // Contains the information needed prior to finalization: the object files,
     // memory manager, resolver, and flags needed for RuntimeDyld.
     struct PreFinalizeContents {
-      PreFinalizeContents(RTDyldObjectLinkingLayer &Parent, VModuleKey K,
-                          OwnedObject Obj,
+      PreFinalizeContents(OwnedObject Obj,
                           std::shared_ptr<SymbolResolver> Resolver,
                           bool ProcessAllSections)
-          : Parent(Parent), K(std::move(K)), Obj(std::move(Obj)),
+          : Obj(std::move(Obj)),
             Resolver(std::move(Resolver)),
             ProcessAllSections(ProcessAllSections) {}
 
-      RTDyldObjectLinkingLayer &Parent;
-      VModuleKey K;
       OwnedObject Obj;
       std::shared_ptr<SymbolResolver> Resolver;
       bool ProcessAllSections;
       std::unique_ptr<RuntimeDyld> RTDyld;
     };
 
+    VModuleKey K;
+    RTDyldObjectLinkingLayer &Parent;
     MemoryManagerPtrT MemMgr;
+    OwnedObject ObjForNotify;
     std::unique_ptr<PreFinalizeContents> PFC;
   };
 
   template <typename MemoryManagerPtrT>
   std::unique_ptr<ConcreteLinkedObject<MemoryManagerPtrT>>
   createLinkedObject(RTDyldObjectLinkingLayer &Parent, VModuleKey K,
                      OwnedObject Obj, MemoryManagerPtrT MemMgr,
                      std::shared_ptr<SymbolResolver> Resolver,
public:
 
   using ResourcesGetter = std::function<Resources(VModuleKey)>;
 
   /// @brief Construct an ObjectLinkingLayer with the given NotifyLoaded,
   ///        and NotifyFinalized functors.
   RTDyldObjectLinkingLayer(
       ExecutionSession &ES, ResourcesGetter GetResources,
       NotifyLoadedFtor NotifyLoaded = NotifyLoadedFtor(),
-      NotifyFinalizedFtor NotifyFinalized = NotifyFinalizedFtor())
+      NotifyFinalizedFtor NotifyFinalized = NotifyFinalizedFtor(),
+      NotifyFreedFtor NotifyFreed = NotifyFreedFtor())
       : ES(ES), GetResources(std::move(GetResources)),
         NotifyLoaded(std::move(NotifyLoaded)),
-        NotifyFinalized(std::move(NotifyFinalized)), ProcessAllSections(false) {
+        NotifyFinalized(std::move(NotifyFinalized)),
+        NotifyFreed(std::move(NotifyFreed)),
+        ProcessAllSections(false) {
   }
 
   /// @brief Set the 'ProcessAllSections' flag.
   ///
   /// If set to true, all sections in each object file will be allocated using
   /// the memory manager, rather than just the sections required for execution.
   ///
   /// This is kludgy, and may be removed in the future.

 
 private:
   ExecutionSession &ES;
 
   std::map<VModuleKey, std::unique_ptr<LinkedObject>> LinkedObjects;
   ResourcesGetter GetResources;
   NotifyLoadedFtor NotifyLoaded;
   NotifyFinalizedFtor NotifyFinalized;
+  NotifyFreedFtor NotifyFreed;
   bool ProcessAllSections = false;
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_RTDYLDOBJECTLINKINGLAYER_H

lib/ExecutionEngine/GDBRegistrationListener.cpp

 //===----- GDBRegistrationListener.cpp - Registers objects with GDB -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm-c/ExecutionEngine.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ExecutionEngine/JITEventListener.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/MutexGuard.h"

 
 namespace llvm {
 
 JITEventListener* JITEventListener::createGDBRegistrationListener() {
   return &*GDBRegListener;
 }
 
 } // namespace llvm
+
+LLVMJITEventListenerRef LLVMCreateGDBRegistrationListener(void)
+{
+  return wrap(JITEventListener::createGDBRegistrationListener());
+}

lib/ExecutionEngine/IntelJITEvents/IntelJITEventListener.cpp

 //===-- IntelJITEventListener.cpp - Tell Intel profiler about JITed code --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a JITEventListener object to tell Intel(R) VTune(TM)
 // Amplifier XE 2011 about JITted functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IntelJITEventsWrapper.h"
+#include "llvm-c/ExecutionEngine.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/ExecutionEngine/JITEventListener.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Function.h"

 // for testing
 JITEventListener *JITEventListener::createIntelJITEventListener(
                                       IntelJITEventsWrapper* TestImpl) {
   return new IntelJITEventListener(TestImpl);
 }
 
 } // namespace llvm
 
+LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void)
+{
+  return wrap(JITEventListener::createIntelJITEventListener());
+}

lib/ExecutionEngine/OProfileJIT/OProfileJITEventListener.cpp

 //===-- OProfileJITEventListener.cpp - Tell OProfile about JITted code ----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a JITEventListener object that uses OProfileWrapper to tell
 // oprofile about JITted functions, including source line information.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm-c/ExecutionEngine.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Config/config.h"
 #include "llvm/ExecutionEngine/JITEventListener.h"
 #include "llvm/ExecutionEngine/OProfileWrapper.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/Object/ObjectFile.h"

 
 namespace llvm {
 JITEventListener *JITEventListener::createOProfileJITEventListener() {
   return new OProfileJITEventListener(llvm::make_unique<OProfileWrapper>());
 }
 
 } // namespace llvm
 
+LLVMJITEventListenerRef LLVMCreateOProfileJITEventListener(void)
+{
+  return wrap(JITEventListener::createOProfileJITEventListener());
+}

lib/ExecutionEngine/Orc/OrcCBindings.cpp

 //===----------- OrcCBindings.cpp - C bindings for the Orc APIs -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OrcCBindingsStack.h"
 #include "llvm-c/OrcBindings.h"
+#include "llvm/ExecutionEngine/JITEventListener.h"
 
 using namespace llvm;
 
 LLVMOrcJITStackRef LLVMOrcCreateInstance(LLVMTargetMachineRef TM) {
   TargetMachine *TM2(unwrap(TM));
 
   Triple T(TM2->getTargetTriple());
 

 }
 
 LLVMOrcErrorCode LLVMOrcDisposeInstance(LLVMOrcJITStackRef JITStack) {
   auto *J = unwrap(JITStack);
   auto Err = J->shutdown();
   delete J;
   return Err;
 }
+
+void LLVMOrcRegisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L)
+{
+  unwrap(JITStack)->RegisterJITEventListener(unwrap(L));
+}
+
+void LLVMOrcUnregisterJITEventListener(LLVMOrcJITStackRef JITStack, LLVMJITEventListenerRef L)
+{
+  unwrap(JITStack)->UnregisterJITEventListener(unwrap(L));
+}

lib/ExecutionEngine/Orc/OrcCBindingsStack.h

 #ifndef LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H
 #define LLVM_LIB_EXECUTIONENGINE_ORC_ORCCBINDINGSSTACK_H
 
 #include "llvm-c/OrcBindings.h"
 #include "llvm-c/TargetMachine.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/JITEventListener.h"
 #include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
 #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
OrcCBindingsStack(TargetMachine &TM,
                     [this](orc::VModuleKey K) {
                       auto ResolverI = Resolvers.find(K);
                       assert(ResolverI != Resolvers.end() &&
                              "No resolver for module K");
                       auto Resolver = std::move(ResolverI->second);
                       Resolvers.erase(ResolverI);
                       return ObjLayerT::Resources{
                           std::make_shared<SectionMemoryManager>(), Resolver};
-                    }),
+                    },
+        nullptr,
+        [this](orc::VModuleKey K, const object::ObjectFile &Obj, const RuntimeDyld::LoadedObjectInfo &LoadedObjInfo) {
+          this->notifyFinalized(K, Obj, LoadedObjInfo);
+        },
+        [this](orc::VModuleKey K, const object::ObjectFile &Obj) {
+          this->notifyFreed(K, Obj);
+        }),
         CompileLayer(ObjectLayer, orc::SimpleCompiler(TM)),
         CODLayer(ES, CompileLayer,
                  [this](orc::VModuleKey K) {
                    auto ResolverI = Resolvers.find(K);
                    assert(ResolverI != Resolvers.end() &&
                           "No resolver for module K");
                    return ResolverI->second;
                  },
LLVMOrcErrorCode findSymbolAddress(JITTargetAddress &RetAddr,
     }
     // Otherwise we had a successful lookup but got a null result. We already
     // set RetAddr to '0' above, so just return success.
     return LLVMOrcErrSuccess;
   }
 
   const std::string &getErrorMessage() const { return ErrMsg; }
 
+  void RegisterJITEventListener(JITEventListener *L) {
+    if (!L)
+      return;
+    EventListeners.push_back(L);
+  }
+
+  void UnregisterJITEventListener(JITEventListener *L) {
+    if (!L)
+      return;
+
+    auto I = find(reverse(EventListeners), L);
+    if (I != EventListeners.rend()) {
+      std::swap(*I, EventListeners.back());
+      EventListeners.pop_back();
+    }
+  }
+
 private:
 
   LLVMOrcErrorCode mapError(Error Err) {
     LLVMOrcErrorCode Result = LLVMOrcErrSuccess;
     handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
       // Handler of last resort.
       Result = LLVMOrcErrGeneric;
       ErrMsg = "";
       raw_string_ostream ErrStream(ErrMsg);
       EIB.log(ErrStream);
     });
     return Result;
   }
 
   void reportError(Error Err) {
     // FIXME: Report errors on the execution session.
     logAllUnhandledErrors(std::move(Err), errs(), "ORC error: ");
   };
 
+  void notifyFinalized(orc::VModuleKey K,
+           const object::ObjectFile &Obj,
+           const RuntimeDyld::LoadedObjectInfo &LoadedObjInfo) {
+    for (auto &Listener : EventListeners)
+      Listener->NotifyObjectEmitted(Obj, LoadedObjInfo);
+  }
+
+  void notifyFreed(orc::VModuleKey K, const object::ObjectFile &Obj) {
+    for (auto &Listener : EventListeners)
+      Listener->NotifyFreeingObject(Obj);
+  }
+
   orc::SymbolStringPool SSP;
   orc::ExecutionSession ES;
 
+  std::vector<JITEventListener *> EventListeners;
+
   DataLayout DL;
   SectionMemoryManager CCMgrMemMgr;
 
   std::unique_ptr<orc::IndirectStubsManager> IndirectStubsMgr;
 
   std::unique_ptr<CompileCallbackMgr> CCMgr;
   ObjLayerT ObjectLayer;
   CompileLayerT CompileLayer;

lib/ExecutionEngine/Orc/OrcMCJITReplacement.h

private:
   private:
     OrcMCJITReplacement &M;
   };
 
   class NotifyFinalizedT {
   public:
     NotifyFinalizedT(OrcMCJITReplacement &M) : M(M) {}
 
-    void operator()(VModuleKey K) { M.UnfinalizedSections.erase(K); }
+    void operator()(VModuleKey K, const object::ObjectFile &Obj,
+                    const RuntimeDyld::LoadedObjectInfo &Info) {
+      M.UnfinalizedSections.erase(K);
+    }
 
   private:
     OrcMCJITReplacement &M;
   };
 
   std::string mangle(StringRef Name) {
     std::string MangledName;
     {