[JITLink][NFC] Add TableManager to replace PerGraph...Builder pass

[StephenFan]

Summary

This patch add a TableManager which reponsible for fixing edges that need entries to reference the target symbol and constructing such entries.

In the past, the PerGraphGOTAndPLTStubsBuilder pass was used to build GOT and PLT entry, and the PerGraphTLSInfoEntryBuilder pass was used to build TLSInfo entry. By generalizing the behavior of building entry, I added a TableManager which could be reused when built GOT, PLT and TLSInfo entries.

If this patch makes sense and can be accepted, I will apply the TableManager to other targets(MachO_x86_64, MachO_arm64, ELF_riscv), and delete the file PerGraphGOTAndPLTStubsBuilder.h

[StephenFan]

clang-format

[lhames]

LGTM.

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

212–215

I really like how this pattern worked out. Very neat!

llvm/lib/ExecutionEngine/JITLink/TableManager.h

24–44

It's just occurred to me that this is a kind of visitor pattern.

I think it makes sense to move these functions into their JITLink.h and rename them to visitEdge (from tryEdgeFixer) and visitExistingEdges (from runFixersOnGraph). The fixEdge method should be renamed to visitEdge and we should document that visitEdge should return 'true' (if the edge should be considered "dealt with", or 'false' (if we want the edge to also be acted on by any subsequent visitors).

These changes could be made either before you land the patch, or afterwards in-tree. Whichever you prefer.

[StephenFan]

Address @lhames 's comments

1. Move functions in TableManager.h to JITLink.h
2. Rename these functions to make them looks like visitor pattern

[StephenFan]

clang-format

[StephenFan]

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

1686 ↗

(On Diff #375800)

I use gcc to compile llvm-project. And this function will cause the defined but not used[-Wunused-function] warning. Is there ways to suppress this warning ?

[lhames]

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

1686 ↗

(On Diff #375800)

That sounds like a broken warning. I would ignore it.

[StephenFan]

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

1686 ↗

(On Diff #375800)

I tried to land this patch, but broke builds on some bots. See e.g. https://lab.llvm.org/buildbot#builders/77/builds/10218

[StephenFan]

Change to static inline

[StephenFan]

rebase.

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/Endian.h"
 
 #include "DefineExternalSectionStartAndEndSymbols.h"
 #include "EHFrameSupportImpl.h"
 #include "ELFLinkGraphBuilder.h"
 #include "JITLinkGeneric.h"
 #include "PerGraphGOTAndPLTStubsBuilder.h"
-#include "PerGraphTLSInfoEntryBuilder.h"
+#include "TableManager.h"
 
 #define DEBUG_TYPE "jitlink"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 using namespace llvm::jitlink::ELF_x86_64_Edges;
 
 namespace {
 
 constexpr StringRef ELFGOTSectionName = "$__GOT";
 constexpr StringRef ELFGOTSymbolName = "_GLOBAL_OFFSET_TABLE_";
 constexpr StringRef ELFTLSInfoSectionName = "$__TLSINFO";
 
-class PerGraphTLSInfoBuilder_ELF_x86_64
-    : public PerGraphTLSInfoEntryBuilder<PerGraphTLSInfoBuilder_ELF_x86_64> {
-public:
-  static const uint8_t TLSInfoEntryContent[16];
-  using PerGraphTLSInfoEntryBuilder<
-      PerGraphTLSInfoBuilder_ELF_x86_64>::PerGraphTLSInfoEntryBuilder;
-
-  bool isTLSEdgeToFix(Edge &E) {
-    return E.getKind() == x86_64::RequestTLSDescInGOTAndTransformToDelta32;
-  }
-
-  Symbol &createTLSInfoEntry(Symbol &Target) {
-    // the TLS Info entry's key value will be written by the fixTLVSectionByName
-    // pass, so create mutable content.
-    auto &TLSInfoEntry = G.createMutableContentBlock(
-        getTLSInfoSection(), G.allocateContent(getTLSInfoEntryContent()), 0, 8,
-        0);
-    TLSInfoEntry.addEdge(x86_64::Pointer64, 8, Target, 0);
-    return G.addAnonymousSymbol(TLSInfoEntry, 0, 16, false, false);
-  }
-
-  void fixTLSEdge(Edge &E, Symbol &Target) {
-    if (E.getKind() == x86_64::RequestTLSDescInGOTAndTransformToDelta32) {
-      E.setTarget(Target);
-      E.setKind(x86_64::Delta32);
-    }
-  }
-
-  Section &getTLSInfoSection() const {
-    if (!TLSInfoSection)
-      TLSInfoSection =
-          &G.createSection(ELFTLSInfoSectionName, sys::Memory::MF_READ);
-    return *TLSInfoSection;
-  }
-
-private:
-  ArrayRef<char> getTLSInfoEntryContent() {
-    return {reinterpret_cast<const char *>(TLSInfoEntryContent),
-            sizeof(TLSInfoEntryContent)};
-  }
-
-  mutable Section *TLSInfoSection = nullptr;
-};
-
-const uint8_t PerGraphTLSInfoBuilder_ELF_x86_64::TLSInfoEntryContent[16] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*pthread key */
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  /*data address*/
-};
-
-class PerGraphGOTAndPLTStubsBuilder_ELF_x86_64
-    : public PerGraphGOTAndPLTStubsBuilder<
-          PerGraphGOTAndPLTStubsBuilder_ELF_x86_64> {
+class GOTTableManager_ELF_x86_64
+    : public TableManager<GOTTableManager_ELF_x86_64> {
 public:
   static const uint8_t NullGOTEntryContent[8];
-  static const uint8_t StubContent[6];
 
-  using PerGraphGOTAndPLTStubsBuilder<
-      PerGraphGOTAndPLTStubsBuilder_ELF_x86_64>::PerGraphGOTAndPLTStubsBuilder;
+  // Nice name for table
+  StringRef getTableName() { return "GOT"; }
 
-  bool isGOTEdgeToFix(Edge &E) const {
-    if (E.getKind() == x86_64::Delta64FromGOT) {
-      // We need to make sure that the GOT section exists, but don't otherwise
-      // need to fix up this edge.
-      getGOTSection();
+  bool fixEdgeKind(LinkGraph &G, Block *B, Edge &E) {
+    Edge::Kind KindToSet = E.getKind();
+    switch (E.getKind()) {
+    case x86_64::Delta64FromGOT: {
+      // we need to make sure that the GOT section exists, but don't otherwise
+      // need to fix up this edge
+      getGOTSection(G);
       return false;
     }
-    return E.getKind() == x86_64::RequestGOTAndTransformToDelta32 ||
-           E.getKind() == x86_64::RequestGOTAndTransformToDelta64 ||
-           E.getKind() ==
-               x86_64::RequestGOTAndTransformToPCRel32GOTLoadREXRelaxable ||
-           E.getKind() == x86_64::RequestGOTAndTransformToDelta64FromGOT ||
-           E.getKind() ==
-               x86_64::RequestGOTAndTransformToPCRel32GOTLoadRelaxable;
-  }
-
-  Symbol &createGOTEntry(Symbol &Target) {
-    auto &GOTEntryBlock = G.createContentBlock(
-        getGOTSection(), getGOTEntryBlockContent(), 0, 8, 0);
-    GOTEntryBlock.addEdge(x86_64::Pointer64, 0, Target, 0);
-    return G.addAnonymousSymbol(GOTEntryBlock, 0, 8, false, false);
-  }
-
-  void fixGOTEdge(Edge &E, Symbol &GOTEntry) {
-    // If this is a PCRel32GOT/PCRel64GOT then change it to an ordinary
-    // PCRel32/PCRel64. If it is a PCRel32GOTLoad then leave it as-is for now:
-    // We will use the kind to check for GOT optimization opportunities in the
-    // optimizeMachO_x86_64_GOTAndStubs pass below.
-    // If it's a GOT64 leave it as is.
-    switch (E.getKind()) {
     case x86_64::RequestGOTAndTransformToPCRel32GOTLoadREXRelaxable:
-      E.setKind(x86_64::PCRel32GOTLoadREXRelaxable);
+      KindToSet = x86_64::PCRel32GOTLoadREXRelaxable;
       break;
     case x86_64::RequestGOTAndTransformToPCRel32GOTLoadRelaxable:
-      E.setKind(x86_64::PCRel32GOTLoadRelaxable);
+      KindToSet = x86_64::PCRel32GOTLoadRelaxable;
       break;
     case x86_64::RequestGOTAndTransformToDelta64:
-      E.setKind(x86_64::Delta64);
+      KindToSet = x86_64::Delta64;
       break;
     case x86_64::RequestGOTAndTransformToDelta64FromGOT:
-      E.setKind(x86_64::Delta64FromGOT);
+      KindToSet = x86_64::Delta64FromGOT;
       break;
     case x86_64::RequestGOTAndTransformToDelta32:
-      E.setKind(x86_64::Delta32);
+      KindToSet = x86_64::Delta32;
       break;
     default:
-      llvm_unreachable("Unexpected GOT edge kind");
+      return false;
     }
-
-    E.setTarget(GOTEntry);
-    // Leave the edge addend as-is.
+    LLVM_DEBUG({
+      dbgs() << "  Fixing " << G.getEdgeKindName(E.getKind()) << " edge at "
+             << formatv("{0:x}", B->getFixupAddress(E)) << " ("
+             << formatv("{0:x}", B->getAddress()) << " + "
+             << formatv("{0:x}", E.getOffset()) << ")\n";
+    });
+    E.setKind(KindToSet);
+    return true;
   }
 
-  bool isExternalBranchEdge(Edge &E) {
-    return E.getKind() == x86_64::BranchPCRel32 && !E.getTarget().isDefined();
+  Symbol &createEntry(LinkGraph &G, Symbol &Target) {
+    auto &GOTEntryBlock = G.createContentBlock(
+        getGOTSection(G), getGOTEntryBlockContent(), 0, 8, 0);
+    GOTEntryBlock.addEdge(x86_64::Pointer64, 0, Target, 0);
+    return G.addAnonymousSymbol(GOTEntryBlock, 0, 8, false, false);
   }
 
-  Symbol &createPLTStub(Symbol &Target) {
-    auto &StubContentBlock =
-        G.createContentBlock(getStubsSection(), getStubBlockContent(), 0, 1, 0);
-    // Re-use GOT entries for stub targets.
-    auto &GOTEntrySymbol = getGOTEntry(Target);
-    StubContentBlock.addEdge(x86_64::Delta32, 2, GOTEntrySymbol, -4);
-    return G.addAnonymousSymbol(StubContentBlock, 0, 6, true, false);
+private:
+  Section &getGOTSection(LinkGraph &G) {
+    if (!GOTSection)
+      GOTSection = &G.createSection(ELFGOTSectionName, sys::Memory::MF_READ);
+    return *GOTSection;
+  }
+  ArrayRef<char> getGOTEntryBlockContent() const {
+    return {reinterpret_cast<const char *>(NullGOTEntryContent),
+            sizeof(NullGOTEntryContent)};
   }
+  Section *GOTSection = nullptr;
+};
+const uint8_t GOTTableManager_ELF_x86_64::NullGOTEntryContent[8] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+class PLTTableManager_ELF_x86_64
+    : public TableManager<PLTTableManager_ELF_x86_64> {
+public:
+  PLTTableManager_ELF_x86_64(GOTTableManager_ELF_x86_64 &GOTTable)
+      : GOTTable(GOTTable) {}
 
-  void fixPLTEdge(Edge &E, Symbol &Stub) {
-    assert(E.getKind() == x86_64::BranchPCRel32 && "Not a Branch32 edge?");
+  StringRef getTableName() { return "PLT"; }
 
-    // Set the edge kind to Branch32ToPtrJumpStubBypassable to enable it to be
-    // optimized when the target is in-range.
+  static const uint8_t StubContent[6];
+  bool fixEdgeKind(LinkGraph &G, Block *B, Edge &E) {
+    if (E.getKind() == x86_64::BranchPCRel32 && !E.getTarget().isDefined()) {
+      LLVM_DEBUG({
+        dbgs() << "  Fixing " << G.getEdgeKindName(E.getKind()) << " edge at "
+               << formatv("{0:x}", B->getFixupAddress(E)) << " ("
+               << formatv("{0:x}", B->getAddress()) << " + "
+               << formatv("{0:x}", E.getOffset()) << ")\n";
+      });
+      // Set the edge kind to Branch32ToPtrJumpStubBypassable to enable it to
+      // be optimized when the target is in-range.
       E.setKind(x86_64::BranchPCRel32ToPtrJumpStubBypassable);
-    E.setTarget(Stub);
+      return true;
+    }
+    return false;
   }
 
-private:
-  Section &getGOTSection() const {
-    if (!GOTSection)
-      GOTSection = &G.createSection(ELFGOTSectionName, sys::Memory::MF_READ);
-    return *GOTSection;
+  Symbol &createEntry(LinkGraph &G, Symbol &Target) {
+    auto &StubContentBlock = G.createContentBlock(
+        getStubsSection(G), getStubBlockContent(), 0, 1, 0);
+    // Re-use GOT entries for stub targets.
+    auto &GOTEntrySymbol = GOTTable.getEntryForTarget(G, Target);
+    StubContentBlock.addEdge(x86_64::Delta32, 2, GOTEntrySymbol, -4);
+    return G.addAnonymousSymbol(StubContentBlock, 0, 6, true, false);
   }
 
-  Section &getStubsSection() const {
+private:
+  Section &getStubsSection(LinkGraph &G) {
     if (!StubsSection) {
       auto StubsProt = static_cast<sys::Memory::ProtectionFlags>(
           sys::Memory::MF_READ | sys::Memory::MF_EXEC);
       StubsSection = &G.createSection("$__STUBS", StubsProt);
     }
     return *StubsSection;
   }
 
-  ArrayRef<char> getGOTEntryBlockContent() {
-    return {reinterpret_cast<const char *>(NullGOTEntryContent),
-            sizeof(NullGOTEntryContent)};
-  }
-
   ArrayRef<char> getStubBlockContent() {
     return {reinterpret_cast<const char *>(StubContent), sizeof(StubContent)};
   }
 
-  mutable Section *GOTSection = nullptr;
-  mutable Section *StubsSection = nullptr;
+  Section *StubsSection = nullptr;
+  GOTTableManager_ELF_x86_64 &GOTTable;
 };
+const uint8_t PLTTableManager_ELF_x86_64::StubContent[6] = {0xFF, 0x25, 0x00,
+                                                            0x00, 0x00, 0x00};
 
-} // namespace
+class TLSInfoTableManager_ELF_x86_64
+    : public TableManager<TLSInfoTableManager_ELF_x86_64> {
+public:
+  static const uint8_t TLSInfoEntryContent[16];
 
-const uint8_t PerGraphGOTAndPLTStubsBuilder_ELF_x86_64::NullGOTEntryContent[8] =
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-const uint8_t PerGraphGOTAndPLTStubsBuilder_ELF_x86_64::StubContent[6] = {
-    0xFF, 0x25, 0x00, 0x00, 0x00, 0x00};
+  StringRef getTableName() { return "TLSInfo"; }
+
+  bool fixEdgeKind(LinkGraph &G, Block *B, Edge &E) {
+    if (E.getKind() == x86_64::RequestTLSDescInGOTAndTransformToDelta32) {
+      LLVM_DEBUG({
+        dbgs() << "  Fixing " << G.getEdgeKindName(E.getKind()) << " edge at "
+               << formatv("{0:x}", B->getFixupAddress(E)) << " ("
+               << formatv("{0:x}", B->getAddress()) << " + "
+               << formatv("{0:x}", E.getOffset()) << ")\n";
+      });
+      E.setKind(x86_64::Delta32);
+      return true;
+    }
+    return false;
+  }
+
+  Symbol &createEntry(LinkGraph &G, Symbol &Target) {
+    // the TLS Info entry's key value will be written by the fixTLVSectionByName
+    // pass, so create mutable content.
+    auto &TLSInfoEntry = G.createMutableContentBlock(
+        getTLSInfoSection(G), G.allocateContent(getTLSInfoEntryContent()), 0, 8,
+        0);
+    TLSInfoEntry.addEdge(x86_64::Pointer64, 8, Target, 0);
+    return G.addAnonymousSymbol(TLSInfoEntry, 0, 16, false, false);
+  }
+
+private:
+  Section &getTLSInfoSection(LinkGraph &G) {
+    if (!TLSInfoTable)
+      TLSInfoTable =
+          &G.createSection(ELFTLSInfoSectionName, sys::Memory::MF_READ);
+    return *TLSInfoTable;
+  }
+
+  ArrayRef<char> getTLSInfoEntryContent() const {
+    return {reinterpret_cast<const char *>(TLSInfoEntryContent),
+            sizeof(TLSInfoEntryContent)};
+  }
+
+  Section *TLSInfoTable = nullptr;
+};
+
+const uint8_t TLSInfoTableManager_ELF_x86_64::TLSInfoEntryContent[16] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*pthread key */
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  /*data address*/
+};
+
+Error buildTables_ELF_x86_64(LinkGraph &G) {
+  GOTTableManager_ELF_x86_64 GOT;
+  PLTTableManager_ELF_x86_64 PLT(GOT);
+  TLSInfoTableManager_ELF_x86_64 TLSInfo;
+  runFixersOnGraph(G, GOT, PLT, TLSInfo);
+  return Error::success();
+}
+} // namespace
 
 static const char *getELFX86_64RelocName(uint32_t Type) {
   switch (Type) {
 #define ELF_RELOC(Name, Number)                                                \
   case Number:                                                                 \
     return #Name;
 #include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
 #undef ELF_RELOC
if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
 
     // Construct a JITLinker and run the link function.
     // Add a mark-live pass.
     if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))
       Config.PrePrunePasses.push_back(std::move(MarkLive));
     else
       Config.PrePrunePasses.push_back(markAllSymbolsLive);
 
-    // Add an in-place GOT/Stubs pass.
-
-    Config.PostPrunePasses.push_back(PerGraphTLSInfoBuilder_ELF_x86_64::asPass);
-    Config.PostPrunePasses.push_back(
-        PerGraphGOTAndPLTStubsBuilder_ELF_x86_64::asPass);
+    // Add an in-place GOT/Stubs/TLSInfoEntry build pass.
+    Config.PostPrunePasses.push_back(buildTables_ELF_x86_64);
 
     // Resolve any external section start / end symbols.
     Config.PostAllocationPasses.push_back(
         createDefineExternalSectionStartAndEndSymbolsPass(
             identifyELFSectionStartAndEndSymbols));
 
     // Add GOT/Stubs optimizer pass.
     Config.PreFixupPasses.push_back(x86_64::optimize_x86_64_GOTAndStubs);

llvm/lib/ExecutionEngine/JITLink/PerGraphTLSInfoEntryBuilder.h

-//===---------------- PerGraphTLSInfoEntryBuilder.h -------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Construct Thread local storage info entry for each graph.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_EXECUTIONENGINE_JITLINK_PERGRAPHTLSINFOENTRYBUILDER_H
-#define LLVM_EXECUTIONENGINE_JITLINK_PERGRAPHTLSINFOENTRYBUILDER_H
-
-#include "llvm/ExecutionEngine/JITLink/JITLink.h"
-#include "llvm/Support/Debug.h"
-
-#define DEBUG_TYPE "jitlink"
-namespace llvm {
-namespace jitlink {
-
-template <typename BuilderImplT> class PerGraphTLSInfoEntryBuilder {
-public:
-  PerGraphTLSInfoEntryBuilder(LinkGraph &G) : G(G) {}
-  static Error asPass(LinkGraph &G) { return BuilderImplT(G).run(); }
-
-  Error run() {
-    LLVM_DEBUG(dbgs() << "Running Per-Graph TLS Info entry builder:\n ");
-
-    std::vector<Block *> Worklist(G.blocks().begin(), G.blocks().end());
-
-    for (auto *B : Worklist)
-      for (auto &E : B->edges()) {
-        if (impl().isTLSEdgeToFix(E)) {
-          LLVM_DEBUG({
-            dbgs() << "  Fixing " << G.getEdgeKindName(E.getKind())
-                   << " edge at " << formatv("{0:x}", B->getFixupAddress(E))
-                   << " (" << formatv("{0:x}", B->getAddress()) << " + "
-                   << formatv("{0:x}", E.getOffset()) << ")\n";
-          });
-          impl().fixTLSEdge(E, getTLSInfoEntry(E.getTarget()));
-        }
-      }
-    return Error::success();
-  }
-
-protected:
-  LinkGraph &G;
-
-  Symbol &getTLSInfoEntry(Symbol &Target) {
-    assert(Target.hasName() && "TLS edge cannot point to anonymous target");
-    auto TLSInfoEntryI = TLSInfoEntries.find(Target.getName());
-    if (TLSInfoEntryI == TLSInfoEntries.end()) {
-      auto &TLSInfoEntry = impl().createTLSInfoEntry(Target);
-      LLVM_DEBUG({
-        dbgs() << "    Created TLS Info entry for " << Target.getName() << ": "
-               << TLSInfoEntry << "\n";
-      });
-      TLSInfoEntryI =
-          TLSInfoEntries.insert(std::make_pair(Target.getName(), &TLSInfoEntry))
-              .first;
-    }
-    assert(TLSInfoEntryI != TLSInfoEntries.end() &&
-           "Could not get TLSInfo symbol");
-    LLVM_DEBUG({
-      dbgs() << "    Using TLS Info entry" << *TLSInfoEntryI->second << "\n";
-    });
-    return *TLSInfoEntryI->second;
-  }
-
-private:
-  DenseMap<StringRef, Symbol *> TLSInfoEntries;
-  BuilderImplT &impl() { return static_cast<BuilderImplT &>(*this); }
-};
-} // namespace jitlink
-} // namespace llvm
-#endif

llvm/lib/ExecutionEngine/JITLink/TableManager.h

+//===---------------------- TableManager.h ----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Fix edge for edge that needs an entry to reference the target symbol
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_TABLEMANAGER_H
+#define LLVM_EXECUTIONENGINE_JITLINK_TABLEMANAGER_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/Support/Debug.h"
+
+#define DEBUG_TYPE "jitlink"
+
+namespace llvm {
+namespace jitlink {
+
+static void tryEdgeFixer(LinkGraph &G, Block *B, Edge &E) {}
+
+template <typename FixerT, typename... FixerTs>
+static void tryEdgeFixer(LinkGraph &G, Block *B, Edge &E, FixerT &&Fixer,
+                         FixerTs &&...Fixers) {
+  if (!Fixer.fixEdge(G, B, E))
+    tryEdgeFixer(G, B, E, std::forward<FixerTs>(Fixers)...);
+}
+
+template <typename... FixerTs>
+void runFixersOnGraph(LinkGraph &G, FixerTs &&...Fixers) {
+  LLVM_DEBUG(dbgs() << "Running edge fixers on graph:\n");
+
+  // We're going to be adding new blocks, but we don't want to iterate over
+  // the new ones, so build a worklist.
+  std::vector<Block *> Worklist(G.blocks().begin(), G.blocks().end());
+
+  for (auto *B : Worklist)
+    for (auto &E : B->edges())
+      tryEdgeFixer(G, B, E, std::forward<FixerTs>(Fixers)...);
+}
+
+/// Table like section manager
+template <typename TableManagerImplT> class TableManager {
+public:
+  /// Fix edge, return true if the edge was fixed, otherwise false
+  ///
+  /// Fixs edge kind for edges that needs a entry(GOT entry, PLT stubs ...) to
+  /// reference the target symbol. And constructs this entry in graph, then
+  /// change the edge's target symbol to this constructed entry.
+  bool fixEdge(LinkGraph &G, Block *B, Edge &E) {
+    if (impl().fixEdgeKind(G, B, E)) {
+      fixTarget(G, E);
+      return true;
+    }
+    return false;
+  }
+
+  /// Return the constructed entry
+  ///
+  /// Use parameter G to construct the entry for target symbol
+  Symbol &getEntryForTarget(LinkGraph &G, Symbol &Target) {
+    assert(Target.hasName() && "Edge cannot point to anonymous target");
+
+    auto EntryI = Entries.find(Target.getName());
+
+    // Build the entry if it doesn't exist.
+    if (EntryI == Entries.end()) {
+      auto &Entry = impl().createEntry(G, Target);
+      LLVM_DEBUG({
+        dbgs() << "    Created" << impl().getTableName() << "entry for "
+               << Target.getName() << ": " << Entry << "\n";
+      });
+      EntryI = Entries.insert(std::make_pair(Target.getName(), &Entry)).first;
+    }
+
+    assert(EntryI != Entries.end() && "Could not get entry symbol");
+    LLVM_DEBUG({
+      dbgs() << "    Using " << impl().getTableName() << " entry "
+             << *EntryI->second << "\n";
+    });
+    return *EntryI->second;
+  }
+
+private:
+  void fixTarget(LinkGraph &G, Edge &E) {
+    E.setTarget(getEntryForTarget(G, E.getTarget()));
+  }
+
+  TableManagerImplT &impl() { return static_cast<TableManagerImplT &>(*this); }
+  DenseMap<StringRef, Symbol *> Entries;
+};
+
+} // namespace jitlink
+} // namespace llvm
+
+#endif