[JITLink][COFF] Use DLLImportDefinitionGenerator for creating PLT stubs.

[sunho]

Summary

Uses DLLImportDefinitionGenerator for creating PLT stubs. It removes previous approach for dllimport stub creation which can't deal with jump thunks.

[lhames]

LGTM. Thanks @sunho.

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h

protected:
   COFFLinkGraphBuilder(const object::COFFObjectFile &Obj, Triple TT,
                        LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
 
   LinkGraph &getGraph() const { return *G; }
 
   const object::COFFObjectFile &getObject() const { return Obj; }
 
   virtual Error addRelocations() = 0;
-  virtual Symbol &createDLLImportEntry(StringRef StubName, Symbol &Target) = 0;
 
   Error graphifySections();
   Error graphifySymbols();
 
   void setGraphSymbol(COFFSectionIndex SecIndex, COFFSymbolIndex SymIndex,
                       Symbol &Sym) {
     assert(!GraphSymbols[SymIndex] && "Duplicate symbol at index");
     GraphSymbols[SymIndex] = &Sym;

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

for (COFFSymbolIndex SymIndex = 0;
     if (Sym->isFileRecord())
       LLVM_DEBUG({
         dbgs() << "    " << SymIndex << ": Skipping FileRecord symbol \""
                << SymbolName << "\" in "
                << getCOFFSectionName(SectionIndex, Sec, *Sym)
                << " (index: " << SectionIndex << ") \n";
       });
     else if (Sym->isUndefined()) {
-      if (SymbolName.startswith(getDLLImportStubPrefix())) {
-        if (Sym->getValue() != 0)
-          return make_error<JITLinkError>(
-              "DLL import symbol has non-zero offset");
-
-        auto ExternalSym = createExternalSymbol(
-            SymIndex, SymbolName.drop_front(getDLLImportStubPrefix().size()),
-            *Sym, Sec);
-        GSym = &createDLLImportEntry(SymbolName, *ExternalSym);
-      } else
-        GSym = createExternalSymbol(SymIndex, SymbolName, *Sym, Sec);
     } else if (Sym->isWeakExternal()) {
       auto *WeakExternal = Sym->getAux<object::coff_aux_weak_external>();
       COFFSymbolIndex TagIndex = WeakExternal->TagIndex;
       uint32_t Characteristics = WeakExternal->Characteristics;
       WeakExternalRequests.push_back(
           {SymIndex, TagIndex, Characteristics, SymbolName});
     } else {
       Expected<jitlink::Symbol *> NewGSym =

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

Error addRelocations() override {
     for (const auto &RelSect : sections())
       if (Error Err = COFFLinkGraphBuilder::forEachRelocation(
               RelSect, this, &COFFLinkGraphBuilder_x86_64::addSingleRelocation))
         return Err;
 
     return Error::success();
   }
 
-  Symbol &createDLLImportEntry(StringRef StubName, Symbol &Target) override {
-    auto &Sym = DLLImportTable.getEntryForTarget(getGraph(), Target);
-    Sym.setName(StubName);
-    return Sym;
-  }
-
   Error addSingleRelocation(const object::RelocationRef &Rel,
                             const object::SectionRef &FixupSect,
                             Block &BlockToFix) {
     const object::coff_relocation *COFFRel = getObject().getCOFFRelocation(Rel);
     auto SymbolIt = Rel.getSymbol();
     if (SymbolIt == getObject().symbol_end()) {
       return make_error<StringError>(
           formatv("Invalid symbol index in relocation entry. "
LLVM_DEBUG({
       dbgs() << "\n";
     });
 
     BlockToFix.addEdge(std::move(GE));
 
     return Error::success();
   }
 
-  x86_64::GOTTableManager DLLImportTable;
-
 public:
   COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, const Triple T)
       : COFFLinkGraphBuilder(Obj, std::move(T), getCOFFX86RelocationKindName) {}
 };
 
 class COFFLinkGraphLowering_x86_64 {
 public:
   // Lowers COFF x86_64 specific edges to generic x86_64 edges.

llvm/lib/ExecutionEngine/Orc/COFFPlatform.cpp

COFFPlatform::Create(ExecutionSession &ES, ObjectLinkingLayer &ObjLinkingLayer,
   // Create default aliases if the caller didn't supply any.
   if (!RuntimeAliases)
     RuntimeAliases = standardPlatformAliases(ES);
 
   // Define the aliases.
   if (auto Err = PlatformJD.define(symbolAliases(std::move(*RuntimeAliases))))
     return std::move(Err);
 
+  auto &HostFuncJD = ES.createBareJITDylib("$<PlatformRuntimeHostFuncJD>");
+
   // Add JIT-dispatch function support symbols.
-  if (auto Err = PlatformJD.define(absoluteSymbols(
+  if (auto Err = HostFuncJD.define(absoluteSymbols(
           {{ES.intern("__orc_rt_jit_dispatch"),
             {EPC.getJITDispatchInfo().JITDispatchFunction.getValue(),
              JITSymbolFlags::Exported}},
            {ES.intern("__orc_rt_jit_dispatch_ctx"),
             {EPC.getJITDispatchInfo().JITDispatchContext.getValue(),
              JITSymbolFlags::Exported}}})))
     return std::move(Err);
 
   // Create a generator for the ORC runtime archive.
   auto OrcRuntimeArchiveGenerator =
       StaticLibraryDefinitionGenerator::Load(ObjLinkingLayer, OrcRuntimePath);
   if (!OrcRuntimeArchiveGenerator)
     return OrcRuntimeArchiveGenerator.takeError();
+  PlatformJD.addToLinkOrder(HostFuncJD);
 
   // Create the instance.
   Error Err = Error::success();
   auto P = std::unique_ptr<COFFPlatform>(new COFFPlatform(
       ES, ObjLinkingLayer, PlatformJD, std::move(*OrcRuntimeArchiveGenerator),
       std::move(LoadDynLibrary), VCRuntimePath, Err));
   if (Err)
     return std::move(Err);
if (!ImportedLibs)
       return ImportedLibs.takeError();
     for (auto &Lib : *ImportedLibs)
       if (auto Err = LoadDynLibrary(JD, Lib))
         return Err;
     if (auto Err = VCRuntimeBootstrap->initializeStaticVCRuntime(JD))
       return Err;
   }
 
+  JD.addGenerator(DLLImportDefinitionGenerator::Create(ES, ObjLinkingLayer));
   return Error::success();
 }
 
 Error COFFPlatform::teardownJITDylib(JITDylib &JD) {
   std::lock_guard<std::mutex> Lock(PlatformMutex);
   auto I = JITDylibToHeaderAddr.find(&JD);
   if (I != JITDylibToHeaderAddr.end()) {
     assert(HeaderAddrToJITDylib.count(I->second) &&

llvm/test/ExecutionEngine/JITLink/X86/COFF_x86-64_small_pic_relocations.s

 # RUN: rm -rf %t && mkdir -p %t
 # RUN: llvm-mc -triple=x86_64-windows-msvc -relax-relocations=false \
 # RUN:   -position-independent -filetype=obj -o %t/coff_sm_reloc.o %s
 # RUN: llvm-jitlink -noexec \
 # RUN:              -slab-allocate 100Kb -slab-address 0xfff00000 -slab-page-size 4096 \
 # RUN:              -abs external_data=0xdeadbeef \
-# RUN:              -abs extern_out_of_range32=0x7fff00000000 \
 # RUN:              -check %s %t/coff_sm_reloc.o
 
   .text
 
   .def main;
   .scl 2;
   .type 32;
   .endef
# jitlink-check: decode_operand(test_rel32_data, 4) = named_data - next_pc(test_rel32_data)
   .scl 2;
   .type 32;
   .endef
   .globl test_rel32_data
   .p2align 4, 0x90
 test_rel32_data:
     leaq named_data(%rip), %rax
 
-# Check a dllimport stub for target out of reach is created as a GOT entry.
-# jitlink-check: decode_operand(test_call_dllimport, 3) = \
-# jitlink-check:     got_addr(coff_sm_reloc.o, extern_out_of_range32) - \
-# jitlink-check:        next_pc(test_call_dllimport)
-# jitlink-check: *{8}(got_addr(coff_sm_reloc.o, extern_out_of_range32)) = \
-# jitlink-check:     extern_out_of_range32
-  .def test_call_dllimport;
-  .scl 2;
-  .type 32;
-  .endef
-  .globl test_call_dllimport
-  .p2align 4, 0x90
-test_call_dllimport:
-  callq *__imp_extern_out_of_range32(%rip)
-
 # Check IMAGE_REL_AMD64_ADDR64 sets address of symbol to the fixup position.
 # jitlink-check: *{8}(test_addr64) = named_data
   .text
   .def named_func;
   .scl 2;
   .type 32;
   .endef
   .globl test_addr64