[JITLink][COFF] Implement dllimport stubs.

[sunho]

Summary

Implements dllimport stubs using GOT table manager. Benefit of using GOT table manager is that we can just reuse jitlink-check architecture.

[sunho]

rebase

[lhames]

Otherwise LGTM.

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

145–151

What prompted this change?

I assume IMAGE_SCN_MEM_READ is specified on most sections, or you'd have seen this blow up already. Should we turn Read on by default for all sections, or only for some subset?

225–248

This might be worth lifting out into its own method.

[sunho]

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

145–151

I was getting "Illegal memory protection flag specified" error in getWindowsProtectionFlags. I thought it was None flag just supplied as it is but it might be with some interesting combination like W + X. I'll check again.

225–248

I reallized the same when I was writing SECREL patch and splitted off into additional method in that patch.

[sunho]

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

225–248

I meant directive parser patch

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;
private:
 
   static uint64_t getSectionAddress(const object::COFFObjectFile &Obj,
                                     const object::coff_section *Section);
   static uint64_t getSectionSize(const object::COFFObjectFile &Obj,
                                  const object::coff_section *Section);
   static bool isComdatSection(const object::coff_section *Section);
   static unsigned getPointerSize(const object::COFFObjectFile &Obj);
   static support::endianness getEndianness(const object::COFFObjectFile &Obj);
+  static StringRef getDLLImportStubPrefix() { return "__imp_"; }
   StringRef getCOFFSectionName(COFFSectionIndex SectionIndex,
                                const object::coff_section *Sec,
                                object::COFFSymbolRef Sym);
 
   const object::COFFObjectFile &Obj;
   std::unique_ptr<LinkGraph> G;
 
   Section *CommonSection = nullptr;

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

for (COFFSectionIndex SecIndex = 1;
     // FIXME: Skip debug info sections
 
     LLVM_DEBUG({
       dbgs() << "    "
              << "Creating section for \"" << SectionName << "\"\n";
     });
 
     // Get the section's memory protection flags.
-    MemProt Prot = MemProt::None;
+    MemProt Prot = MemProt::Read;
     if ((*Sec)->Characteristics & COFF::IMAGE_SCN_MEM_EXECUTE)
       Prot |= MemProt::Exec;
     if ((*Sec)->Characteristics & COFF::IMAGE_SCN_MEM_READ)
       Prot |= MemProt::Read;
     if ((*Sec)->Characteristics & COFF::IMAGE_SCN_MEM_WRITE)
       Prot |= MemProt::Write;
 
     // Look for existing sections first.
     auto *GraphSec = G->findSectionByName(SectionName);
     if (!GraphSec)
       GraphSec = &G->createSection(SectionName, Prot);
     if (GraphSec->getMemProt() != Prot)
       return make_error<JITLinkError>("MemProt should match");
 
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()) {
+      auto CreateExternalSymbol = [&](StringRef SymbolName) {
+        if (!ExternalSymbols.count(SymbolName))
+          ExternalSymbols[SymbolName] = &G->addExternalSymbol(
+              SymbolName, Sym->getValue(), Linkage::Strong);
+
         LLVM_DEBUG({
           dbgs() << "    " << SymIndex
                  << ": Creating external graph symbol for COFF symbol \""
                  << SymbolName << "\" in "
                  << getCOFFSectionName(SectionIndex, Sec, *Sym)
                  << " (index: " << SectionIndex << ") \n";
         });
-      if (!ExternalSymbols.count(SymbolName))
-        ExternalSymbols[SymbolName] =
-            &G->addExternalSymbol(SymbolName, Sym->getValue(), Linkage::Strong);
-      GSym = ExternalSymbols[SymbolName];
+        return ExternalSymbols[SymbolName];
+      };
+      if (SymbolName.startswith(getDLLImportStubPrefix())) {
+        if (Sym->getValue() != 0)
+          return make_error<JITLinkError>(
+              "DLL import symbol has non-zero offset");
+
+        auto ExternalSym = CreateExternalSymbol(
+            SymbolName.drop_front(getDLLImportStubPrefix().size()));
+        GSym = &createDLLImportEntry(SymbolName, *ExternalSym);
+      } else
+        GSym = CreateExternalSymbol(SymbolName);
     } 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_DEBUG({
     dbgs() << "      " << *Target << "\n";
   });
   PendingComdatExport = None;
   return Target;
 }
 
 } // namespace jitlink
 } // namespace llvm
 No newline at end of file

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>(
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/test/ExecutionEngine/JITLink/X86/COFF_x86-64_small_pic_relocations.s

# 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)
+
 # Local named data/func that is used in conjunction with other test cases
   .text
   .def named_func;
   .scl 2;
   .type 32;
   .endef
   .globl named_func
   .p2align 4, 0x90
 named_func:
   retq
 
   .data
   .p2align 3
 named_data:
   .quad 53