[JITLink] Add missing vtable anchors

[sgraenitz]

Summary

This patch fixes the following missing symbols when linking JITLink in a shared library:

$ llvm-objdump -t libMyShared.so | grep _ZTVN4llvm7jitlink
0000000000000000         *UND*  0000000000000000 _ZTVN4llvm7jitlink25InProcessEHFrameRegistrarE
0000000000000000         *UND*  0000000000000000 _ZTVN4llvm7jitlink16EHFrameRegistrarE
0000000000000000         *UND*  0000000000000000 _ZTVN4llvm7jitlink14JITLinkContextE
0000000000000000         *UND*  0000000000000000 _ZTVN4llvm7jitlink22InProcessMemoryManagerE
0000000000000000         *UND*  0000000000000000 _ZTVN4llvm7jitlink20JITLinkMemoryManagerE

These symbols exist in the static lib, e.g.:

$ llvm-objdump -t lib/libLLVMJITLink.a | grep _ZTVN4llvm7jitlink25InProcessEHFrameRegistrarE
0000000000000038 g     O .data.rel.ro   0000000000000038 _ZTVN4llvm7jitlink25InProcessEHFrameRegistrarE

[sgraenitz]

All modified classes have out-of-line virtual methods (or at least dtors) already. Nevertheless, without these additional anchors the vtable symbols appear to be missing from libMyShared.so. Eventually, I am not certain why this is necessary. I don't see similar issues for libLLVMOrcJIT.a and they are built and linked the same way.

[sgraenitz]

Scratch that. It turned out to be some side-effect of link order. I still don't quite get it, but the anchors are not necessary. Sorry for the noise.

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

private:
   union {
     Edge *PersonalityEdge;
     Edge *LSDAEdge;
   };
 };
 
 /// Supports registration/deregistration of EH-frames in a target process.
 class EHFrameRegistrar {
+  virtual void anchor();
+
 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 {
+  void anchor() override;
+
 public:
   Error registerEHFrames(orc::ExecutorAddrRange EHFrameSection) override;
 
   Error deregisterEHFrames(orc::ExecutorAddrRange EHFrameSection) override;
 };
 
 using StoreFrameRangeFunction = std::function<void(
     orc::ExecutorAddr EHFrameSectionAddr, size_t EHFrameSectionSize)>;

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

public:
   virtual LinkGraphPassFunction getMarkLivePass(const Triple &TT) const;
 
   /// Called by JITLink to modify the pass pipeline prior to linking.
   /// The default version performs no modification.
   virtual Error modifyPassConfig(LinkGraph &G, PassConfiguration &Config);
 
 private:
   const JITLinkDylib *JD = nullptr;
+
+  virtual void anchor();
 };
 
 /// Marks all symbols in a graph live. This can be used as a default,
 /// conservative mark-live implementation.
 Error markAllSymbolsLive(LinkGraph &G);
 
 /// Create an out of range error for the given edge in the given block.
 Error makeTargetOutOfRangeError(const LinkGraph &G, const Block &B,

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

public:
   }
 
   /// Convenience function for blocking deallocation of a single alloc.
   Error deallocate(FinalizedAlloc Alloc) {
     std::vector<FinalizedAlloc> Allocs;
     Allocs.push_back(std::move(Alloc));
     return deallocate(std::move(Allocs));
   }
+
+private:
+  virtual void anchor();
 };
 
 /// BasicLayout simplifies the implementation of JITLinkMemoryManagers.
 ///
 /// BasicLayout groups Sections into Segments based on their memory protection
 /// and deallocation policies. JITLinkMemoryManagers can construct a BasicLayout
 /// from a Graph, and then assign working memory and addresses to each of the
 /// Segments. These addreses will be mapped back onto the Graph blocks in
struct FinalizedAllocInfo {
     sys::MemoryBlock StandardSegments;
     std::vector<orc::shared::WrapperFunctionCall> DeallocActions;
   };
 
   FinalizedAlloc createFinalizedAlloc(
       sys::MemoryBlock StandardSegments,
       std::vector<orc::shared::WrapperFunctionCall> DeallocActions);
 
+  void anchor() override;
+
   uint64_t PageSize;
   std::mutex FinalizedAllocsMutex;
   RecyclingAllocator<BumpPtrAllocator, FinalizedAllocInfo> FinalizedAllocInfos;
 };
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_JITLINKMEMORYMANAGER_H

llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp

Error EHFrameNullTerminator::operator()(LinkGraph &G) {
 
   auto &NullTerminatorBlock =
       G.createContentBlock(*EHFrame, NullTerminatorBlockContent,
                            orc::ExecutorAddr(~uint64_t(4)), 1, 0);
   G.addAnonymousSymbol(NullTerminatorBlock, 0, 4, false, true);
   return Error::success();
 }
 
+void EHFrameRegistrar::anchor() {}
+void InProcessEHFrameRegistrar::anchor() {}
+
 EHFrameRegistrar::~EHFrameRegistrar() = default;
 
 Error InProcessEHFrameRegistrar::registerEHFrames(
     orc::ExecutorAddrRange EHFrameSection) {
   return orc::registerEHFrameSection(EHFrameSection.Start.toPtr<void *>(),
                                      EHFrameSection.size());
 }
 

llvm/lib/ExecutionEngine/JITLink/JITLink.cpp

case SymbolLookupFlags::RequiredSymbol:
     return OS << "RequiredSymbol";
   case SymbolLookupFlags::WeaklyReferencedSymbol:
     return OS << "WeaklyReferencedSymbol";
   }
   llvm_unreachable("Unrecognized lookup flags");
 }
 
 void JITLinkAsyncLookupContinuation::anchor() {}
+void JITLinkContext::anchor() {}
 
 JITLinkContext::~JITLinkContext() = default;
 
 bool JITLinkContext::shouldAddDefaultTargetPasses(const Triple &TT) const {
   return true;
 }
 
 LinkGraphPassFunction JITLinkContext::getMarkLivePass(const Triple &TT) const {

llvm/lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp

 
 #define DEBUG_TYPE "jitlink"
 
 using namespace llvm;
 
 namespace llvm {
 namespace jitlink {
 
+void JITLinkMemoryManager::anchor() {}
 JITLinkMemoryManager::~JITLinkMemoryManager() = default;
 JITLinkMemoryManager::InFlightAlloc::~InFlightAlloc() = default;
 
 BasicLayout::BasicLayout(LinkGraph &G) : G(G) {
 
   for (auto &Sec : G.sections()) {
     // Skip empty sections, and sections with NoAlloc lifetime policies.
     if (Sec.blocks().empty() ||

 
 SimpleSegmentAlloc::SimpleSegmentAlloc(
     std::unique_ptr<LinkGraph> G,
     orc::AllocGroupSmallMap<Block *> ContentBlocks,
     std::unique_ptr<JITLinkMemoryManager::InFlightAlloc> Alloc)
     : G(std::move(G)), ContentBlocks(std::move(ContentBlocks)),
       Alloc(std::move(Alloc)) {}
 
+void InProcessMemoryManager::anchor() {}
+
 class InProcessMemoryManager::IPInFlightAlloc
     : public JITLinkMemoryManager::InFlightAlloc {
 public:
   IPInFlightAlloc(InProcessMemoryManager &MemMgr, LinkGraph &G, BasicLayout BL,
                   sys::MemoryBlock StandardSegments,
                   sys::MemoryBlock FinalizationSegments)
       : MemMgr(MemMgr), G(&G), BL(std::move(BL)),
         StandardSegments(std::move(StandardSegments)),