[ORC] Remove EHFrameRegistrar, use allocation actions for eh-frame registration.

This simplifies resource management, and should improve performance for most use
cases.

Author: lhames

llvm/include/llvm/ExecutionEngine/JITLink/EHFrameSupport.h

@@ -83,35 +83,9 @@ class EHFrameCFIBlockInspector {
   };
 };
 
-/// Supports registration/deregistration of EH-frames in a target process.
-class EHFrameRegistrar {
-public:
-  virtual ~EHFrameRegistrar();
-  virtual Error registerEHFrames(orc::ExecutorAddrRange EHFrameSection) = 0;
-  virtual Error deregisterEHFrames(orc::ExecutorAddrRange EHFrameSection) = 0;
-};
-
-/// Registers / Deregisters EH-frames in the current process.
-class InProcessEHFrameRegistrar final : public EHFrameRegistrar {
-public:
-  Error registerEHFrames(orc::ExecutorAddrRange EHFrameSection) override;
-
-  Error deregisterEHFrames(orc::ExecutorAddrRange EHFrameSection) override;
-};
-
-using StoreFrameRangeFunction = std::function<void(
-    orc::ExecutorAddr EHFrameSectionAddr, size_t EHFrameSectionSize)>;
-
-/// Creates a pass that records the address and size of the EH frame section.
-/// If no eh-frame section is found then the address and size will both be given
-/// as zero.
-///
-/// Authors of JITLinkContexts can use this function to register a post-fixup
-/// pass that records the range of the eh-frame section. This range can
-/// be used after finalization to register and deregister the frame.
-LinkGraphPassFunction
-createEHFrameRecorderPass(const Triple &TT,
-                          StoreFrameRangeFunction StoreFrameRange);
+/// Returns a pointer to the DWARF eh-frame section if the graph contains a
+/// non-empty one, otherwise returns null.
+Section *getEHFrameSection(LinkGraph &G);
 
 } // end namespace jitlink
 } // end namespace llvm

llvm/include/llvm/ExecutionEngine/Orc/EHFrameRegistrationPlugin.h

@@ -19,37 +19,38 @@
 #include <mutex>
 #include <vector>
 
-namespace llvm {
-
-namespace jitlink {
-class EHFrameRegistrar;
-} // namespace jitlink
-
-namespace orc {
+namespace llvm::orc {
 
+/// Adds AllocationActions to register and deregister eh-frame sections in the
+/// absence of native Platform support.
 class EHFrameRegistrationPlugin : public LinkGraphLinkingLayer::Plugin {
 public:
-  EHFrameRegistrationPlugin(
-      ExecutionSession &ES,
-      std::unique_ptr<jitlink::EHFrameRegistrar> Registrar);
+  static Expected<std::unique_ptr<EHFrameRegistrationPlugin>>
+  Create(ExecutionSession &ES);
+
+  EHFrameRegistrationPlugin(ExecutionSession &ES, ExecutorAddr RegisterEHFrame,
+                            ExecutorAddr DeregisterEHFrame)
+      : ES(ES), RegisterEHFrame(RegisterEHFrame),
+        DeregisterEHFrame(DeregisterEHFrame) {}
+
   void modifyPassConfig(MaterializationResponsibility &MR,
                         jitlink::LinkGraph &G,
                         jitlink::PassConfiguration &PassConfig) override;
-  Error notifyEmitted(MaterializationResponsibility &MR) override;
-  Error notifyFailed(MaterializationResponsibility &MR) override;
-  Error notifyRemovingResources(JITDylib &JD, ResourceKey K) override;
+  Error notifyFailed(MaterializationResponsibility &MR) override {
+    return Error::success();
+  }
+  Error notifyRemovingResources(JITDylib &JD, ResourceKey K) override {
+    return Error::success();
+  }
   void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey,
-                                   ResourceKey SrcKey) override;
+                                   ResourceKey SrcKey) override {}
 
 private:
-  std::mutex EHFramePluginMutex;
   ExecutionSession &ES;
-  std::unique_ptr<jitlink::EHFrameRegistrar> Registrar;
-  DenseMap<MaterializationResponsibility *, ExecutorAddrRange> InProcessLinks;
-  DenseMap<ResourceKey, std::vector<ExecutorAddrRange>> EHFrameRanges;
+  ExecutorAddr RegisterEHFrame;
+  ExecutorAddr DeregisterEHFrame;
 };
 
-} // end namespace orc
-} // end namespace llvm
+} // namespace llvm::orc
 
 #endif // LLVM_EXECUTIONENGINE_ORC_EHFRAMEREGISTRATIONPLUGIN_H

llvm/include/llvm/ExecutionEngine/Orc/EPCEHFrameRegistrar.h

@@ -639,20 +639,6 @@ Error EHFrameNullTerminator::operator()(LinkGraph &G) {
   return Error::success();
 }
 
-EHFrameRegistrar::~EHFrameRegistrar() = default;
-
-Error InProcessEHFrameRegistrar::registerEHFrames(
-    orc::ExecutorAddrRange EHFrameSection) {
-  return orc::registerEHFrameSection(EHFrameSection.Start.toPtr<void *>(),
-                                     EHFrameSection.size());
-}
-
-Error InProcessEHFrameRegistrar::deregisterEHFrames(
-    orc::ExecutorAddrRange EHFrameSection) {
-  return orc::deregisterEHFrameSection(EHFrameSection.Start.toPtr<void *>(),
-                                       EHFrameSection.size());
-}
-
 EHFrameCFIBlockInspector EHFrameCFIBlockInspector::FromEdgeScan(Block &B) {
   if (B.edges_empty())
     return EHFrameCFIBlockInspector(nullptr);
@@ -678,36 +664,24 @@ EHFrameCFIBlockInspector::EHFrameCFIBlockInspector(Edge &CIEEdge,
                                                    Edge *LSDAEdge)
     : CIEEdge(&CIEEdge), PCBeginEdge(&PCBeginEdge), LSDAEdge(LSDAEdge) {}
 
-LinkGraphPassFunction
-createEHFrameRecorderPass(const Triple &TT,
-                          StoreFrameRangeFunction StoreRangeAddress) {
+Section *getEHFrameSection(LinkGraph &G) {
   const char *EHFrameSectionName = nullptr;
-  if (TT.getObjectFormat() == Triple::MachO)
+  switch (G.getTargetTriple().getObjectFormat()) {
+  case Triple::MachO:
     EHFrameSectionName = "__TEXT,__eh_frame";
-  else
+    break;
+  case Triple::ELF:
     EHFrameSectionName = ".eh_frame";
+    break;
+  default:
+    return nullptr;
+  }
 
-  auto RecordEHFrame =
-      [EHFrameSectionName,
-       StoreFrameRange = std::move(StoreRangeAddress)](LinkGraph &G) -> Error {
-    // Search for a non-empty eh-frame and record the address of the first
-    // symbol in it.
-    orc::ExecutorAddr Addr;
-    size_t Size = 0;
-    if (auto *S = G.findSectionByName(EHFrameSectionName)) {
-      auto R = SectionRange(*S);
-      Addr = R.getStart();
-      Size = R.getSize();
-    }
-    if (!Addr && Size != 0)
-      return make_error<JITLinkError>(
-          StringRef(EHFrameSectionName) +
-          " section can not have zero address with non-zero size");
-    StoreFrameRange(Addr, Size);
-    return Error::success();
-  };
+  if (auto *S = G.findSectionByName(EHFrameSectionName))
+    if (!S->empty())
+      return S;
 
-  return RecordEHFrame;
+  return nullptr;
 }
 
 } // end namespace jitlink

llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp

@@ -18,7 +18,6 @@ add_llvm_component_library(LLVMOrcJIT
   EHFrameRegistrationPlugin.cpp
   EPCDynamicLibrarySearchGenerator.cpp
   EPCDebugObjectRegistrar.cpp
-  EPCEHFrameRegistrar.cpp
   EPCGenericDylibManager.cpp
   EPCGenericJITLinkMemoryManager.cpp
   EPCGenericRTDyldMemoryManager.cpp

llvm/lib/ExecutionEngine/Orc/CMakeLists.txt

@@ -10,21 +10,34 @@
 
 #include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
 #include "llvm/ExecutionEngine/Orc/Shared/MachOObjectFormat.h"
+#include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"
 
 #define DEBUG_TYPE "orc"
 
 using namespace llvm::jitlink;
 
 namespace llvm::orc {
 
-EHFrameRegistrationPlugin::EHFrameRegistrationPlugin(
-    ExecutionSession &ES, std::unique_ptr<EHFrameRegistrar> Registrar)
-    : ES(ES), Registrar(std::move(Registrar)) {}
+Expected<std::unique_ptr<EHFrameRegistrationPlugin>>
+EHFrameRegistrationPlugin::Create(ExecutionSession &ES) {
+  // Lookup addresseses of the registration/deregistration functions in the
+  // bootstrap map.
+  ExecutorAddr RegisterEHFrameSectionWrapper;
+  ExecutorAddr DeregisterEHFrameSectionWrapper;
+  if (auto Err = ES.getExecutorProcessControl().getBootstrapSymbols(
+          {{RegisterEHFrameSectionWrapper,
+            rt::RegisterEHFrameSectionWrapperName},
+           {DeregisterEHFrameSectionWrapper,
+            rt::DeregisterEHFrameSectionWrapperName}}))
+    return std::move(Err);
+
+  return std::make_unique<EHFrameRegistrationPlugin>(
+      ES, RegisterEHFrameSectionWrapper, DeregisterEHFrameSectionWrapper);
+}
 
 void EHFrameRegistrationPlugin::modifyPassConfig(
     MaterializationResponsibility &MR, LinkGraph &LG,
     PassConfiguration &PassConfig) {
-
   if (LG.getTargetTriple().isOSBinFormatMachO())
     PassConfig.PrePrunePasses.insert(
         PassConfig.PrePrunePasses.begin(), [](LinkGraph &G) {
@@ -33,92 +46,20 @@ void EHFrameRegistrationPlugin::modifyPassConfig(
           return Error::success();
         });
 
-  PassConfig.PostFixupPasses.push_back(createEHFrameRecorderPass(
-      LG.getTargetTriple(), [this, &MR](ExecutorAddr Addr, size_t Size) {
-        if (Addr) {
-          std::lock_guard<std::mutex> Lock(EHFramePluginMutex);
-          assert(!InProcessLinks.count(&MR) &&
-                 "Link for MR already being tracked?");
-          InProcessLinks[&MR] = {Addr, Size};
-        }
-      }));
-}
-
-Error EHFrameRegistrationPlugin::notifyEmitted(
-    MaterializationResponsibility &MR) {
-
-  ExecutorAddrRange EmittedRange;
-  {
-    std::lock_guard<std::mutex> Lock(EHFramePluginMutex);
-
-    auto EHFrameRangeItr = InProcessLinks.find(&MR);
-    if (EHFrameRangeItr == InProcessLinks.end())
-      return Error::success();
-
-    EmittedRange = EHFrameRangeItr->second;
-    assert(EmittedRange.Start && "eh-frame addr to register can not be null");
-    InProcessLinks.erase(EHFrameRangeItr);
-  }
-
-  if (auto Err = MR.withResourceKeyDo(
-          [&](ResourceKey K) { EHFrameRanges[K].push_back(EmittedRange); }))
-    return Err;
-
-  return Registrar->registerEHFrames(EmittedRange);
-}
-
-Error EHFrameRegistrationPlugin::notifyFailed(
-    MaterializationResponsibility &MR) {
-  std::lock_guard<std::mutex> Lock(EHFramePluginMutex);
-  InProcessLinks.erase(&MR);
-  return Error::success();
-}
-
-Error EHFrameRegistrationPlugin::notifyRemovingResources(JITDylib &JD,
-                                                         ResourceKey K) {
-  std::vector<ExecutorAddrRange> RangesToRemove;
-
-  ES.runSessionLocked([&] {
-    auto I = EHFrameRanges.find(K);
-    if (I != EHFrameRanges.end()) {
-      RangesToRemove = std::move(I->second);
-      EHFrameRanges.erase(I);
+  PassConfig.PostFixupPasses.push_back([this](LinkGraph &G) -> Error {
+    if (auto *EHFrame = getEHFrameSection(G)) {
+      using namespace shared;
+      auto R = SectionRange(*EHFrame).getRange();
+      G.allocActions().push_back(
+          {cantFail(
+               WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddrRange>>(
+                   RegisterEHFrame, R)),
+           cantFail(
+               WrapperFunctionCall::Create<SPSArgList<SPSExecutorAddrRange>>(
+                   DeregisterEHFrame, R))});
     }
+    return Error::success();
   });
-
-  Error Err = Error::success();
-  while (!RangesToRemove.empty()) {
-    auto RangeToRemove = RangesToRemove.back();
-    RangesToRemove.pop_back();
-    assert(RangeToRemove.Start && "Untracked eh-frame range must not be null");
-    Err = joinErrors(std::move(Err),
-                     Registrar->deregisterEHFrames(RangeToRemove));
-  }
-
-  return Err;
-}
-
-void EHFrameRegistrationPlugin::notifyTransferringResources(
-    JITDylib &JD, ResourceKey DstKey, ResourceKey SrcKey) {
-  auto SI = EHFrameRanges.find(SrcKey);
-  if (SI == EHFrameRanges.end())
-    return;
-
-  auto DI = EHFrameRanges.find(DstKey);
-  if (DI != EHFrameRanges.end()) {
-    auto &SrcRanges = SI->second;
-    auto &DstRanges = DI->second;
-    DstRanges.reserve(DstRanges.size() + SrcRanges.size());
-    for (auto &SrcRange : SrcRanges)
-      DstRanges.push_back(std::move(SrcRange));
-    EHFrameRanges.erase(SI);
-  } else {
-    // We need to move SrcKey's ranges over without invalidating the SI
-    // iterator.
-    auto Tmp = std::move(SI->second);
-    EHFrameRanges.erase(SI);
-    EHFrameRanges[DstKey] = std::move(Tmp);
-  }
 }
 
 } // namespace llvm::orc