[LLD] [COFF] Allow automatic dllimport from gnu import libraries

[mstorsjo]

Summary

Don't assume that the IAT chunk will be a DefinedImportData, it can just as well be a DefinedRegular for gnu import libraries.

[mstorsjo]

Ping

[ruiu]

LGTM

lld/trunk/COFF/Chunks.cpp

 // MinGW specific.
 // Append information to the provided vector about all relocations that
 // need to be handled at runtime as runtime pseudo relocations (references
 // to a module local variable, which turned out to actually need to be
 // imported from another DLL).
 void SectionChunk::getRuntimePseudoRelocs(
     std::vector<RuntimePseudoReloc> &Res) {
   for (const coff_relocation &Rel : Relocs) {
-    auto *Target = dyn_cast_or_null<DefinedImportData>(
-        File->getSymbol(Rel.SymbolTableIndex));
+    auto *Target =
+        dyn_cast_or_null<Defined>(File->getSymbol(Rel.SymbolTableIndex));
     if (!Target || !Target->IsRuntimePseudoReloc)
       continue;
     int SizeInBits = getRuntimePseudoRelocSize(Rel.Type);
     if (SizeInBits == 0) {
       error("unable to automatically import from " + Target->getName() +
             " with relocation type " +
             File->getCOFFObj()->getRelocationTypeName(Rel.Type) + " in " +
             toString(File));

lld/trunk/COFF/SymbolTable.cpp

for (auto &I : SymMap) {
     L->PendingArchiveLoad = true;
     L->File->addMember(&L->Sym);
   }
 }
 
 bool SymbolTable::handleMinGWAutomaticImport(Symbol *Sym, StringRef Name) {
   if (Name.startswith("__imp_"))
     return false;
-  DefinedImportData *Imp =
-      dyn_cast_or_null<DefinedImportData>(find(("__imp_" + Name).str()));
+  Defined *Imp = dyn_cast_or_null<Defined>(find(("__imp_" + Name).str()));
   if (!Imp)
     return false;
 
-  log("Automatically importing " + Name + " from " + Imp->getDLLName());
-
   // Replace the reference directly to a variable with a reference
   // to the import address table instead. This obviously isn't right,
   // but we mark the symbol as IsRuntimePseudoReloc, and a later pass
   // will add runtime pseudo relocations for every relocation against
   // this Symbol. The runtime pseudo relocation framework expects the
   // reference itself to point at the IAT entry.
-  Sym->replaceKeepingName(Imp, sizeof(DefinedImportData));
-  cast<DefinedImportData>(Sym)->IsRuntimePseudoReloc = true;
+  size_t ImpSize = 0;
+  if (isa<DefinedImportData>(Imp)) {
+    log("Automatically importing " + Name + " from " +
+        cast<DefinedImportData>(Imp)->getDLLName());
+    ImpSize = sizeof(DefinedImportData);
+  } else if (isa<DefinedRegular>(Imp)) {
+    log("Automatically importing " + Name + " from " +
+        toString(cast<DefinedRegular>(Imp)->File));
+    ImpSize = sizeof(DefinedRegular);
+  } else {
+    warn("unable to automatically import " + Name + " from " + Imp->getName() +
+         " from " + toString(cast<DefinedRegular>(Imp)->File) +
+         "; unexpected symbol type");
+    return false;
+  }
+  Sym->replaceKeepingName(Imp, ImpSize);
+  Sym->IsRuntimePseudoReloc = true;
 
   // There may exist symbols named .refptr.<name> which only consist
   // of a single pointer to <name>. If it turns out <name> is
   // automatically imported, we don't need to keep the .refptr.<name>
   // pointer at all, but redirect all accesses to it to the IAT entry
   // for __imp_<name> instead, and drop the whole .refptr.<name> chunk.
   DefinedRegular *Refptr =
       dyn_cast_or_null<DefinedRegular>(find((".refptr." + Name).str()));
   size_t PtrSize = Config->is64() ? 8 : 4;
   if (Refptr && Refptr->getChunk()->getSize() == PtrSize) {
     SectionChunk *SC = dyn_cast_or_null<SectionChunk>(Refptr->getChunk());
     if (SC && SC->Relocs.size() == 1 && *SC->symbols().begin() == Sym) {
       log("Replacing .refptr." + Name + " with " + Imp->getName());
       Refptr->getChunk()->Live = false;
-      Refptr->replaceKeepingName(Imp, sizeof(DefinedImportData));
+      Refptr->replaceKeepingName(Imp, ImpSize);
     }
   }
   return true;
 }
 
 void SymbolTable::reportRemainingUndefines() {
   SmallPtrSet<Symbol *, 8> Undefs;
   DenseMap<Symbol *, Symbol *> LocalImports;

lld/trunk/COFF/Symbols.h

public:
   // after calling markLive.
   bool isLive() const;
 
 protected:
   friend SymbolTable;
   explicit Symbol(Kind K, StringRef N = "")
       : SymbolKind(K), IsExternal(true), IsCOMDAT(false),
         WrittenToSymtab(false), PendingArchiveLoad(false), IsGCRoot(false),
-        Name(N) {}
+        IsRuntimePseudoReloc(false), Name(N) {}
 
   const unsigned SymbolKind : 8;
   unsigned IsExternal : 1;
 
   // This bit is used by the \c DefinedRegular subclass.
   unsigned IsCOMDAT : 1;
 
 public:
   // This bit is used by Writer::createSymbolAndStringTable() to prevent
   // symbols from being written to the symbol table more than once.
   unsigned WrittenToSymtab : 1;
 
   // True if this symbol was referenced by a regular (non-bitcode) object.
   unsigned IsUsedInRegularObj : 1;
 
   // True if we've seen both a lazy and an undefined symbol with this symbol
   // name, which means that we have enqueued an archive member load and should
   // not load any more archive members to resolve the same symbol.
   unsigned PendingArchiveLoad : 1;
 
   /// True if we've already added this symbol to the list of GC roots.
   unsigned IsGCRoot : 1;
 
+  unsigned IsRuntimePseudoReloc : 1;
+
 protected:
   StringRef Name;
 };
 
 // The base class for any defined symbols, including absolute symbols,
 // etc.
 class Defined : public Symbol {
 public:
public:
   Chunk *getChunk() { return File->Location; }
   void setLocation(Chunk *AddressTable) { File->Location = AddressTable; }
 
   StringRef getDLLName() { return File->DLLName; }
   StringRef getExternalName() { return File->ExternalName; }
   uint16_t getOrdinal() { return File->Hdr->OrdinalHint; }
 
   ImportFile *File;
-
-  bool IsRuntimePseudoReloc = false;
 };
 
 // This class represents a symbol for a jump table entry which jumps
 // to a function in a DLL. Linker are supposed to create such symbols
 // without "__imp_" prefix for all function symbols exported from
 // DLLs, so that you can call DLL functions as regular functions with
 // a regular name. A function pointer is given as a DefinedImportData.
 class DefinedImportThunk : public Defined {

lld/trunk/test/COFF/Inputs/gnu-implib-data.s

+        .global         __imp_data
+
+        # The data that is emitted into .idata$7 here is isn't needed for
+        # the import data structures, but we need to emit something which
+        # produces a relocation against _head_test_lib, to pull in the
+        # header and trailer objects.
+
+        .section        .idata$7
+        .rva            _head_test_lib
+
+        .section        .idata$5
+__imp_data:
+        .rva            .Lhint_name
+        .long           0
+
+        .section        .idata$4
+        .rva            .Lhint_name
+        .long           0
+
+        .section        .idata$6
+.Lhint_name:
+        .short          0
+        .asciz          "data"

lld/trunk/test/COFF/autoimport-gnu-implib.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -triple=x86_64-windows-gnu %p/Inputs/gnu-implib-head.s -filetype=obj -o %t-dabcdh.o
+# RUN: llvm-mc -triple=x86_64-windows-gnu %p/Inputs/gnu-implib-data.s -filetype=obj -o %t-dabcds00000.o
+# RUN: llvm-mc -triple=x86_64-windows-gnu %p/Inputs/gnu-implib-tail.s -filetype=obj -o %t-dabcdt.o
+# RUN: rm -f %t-implib.a
+# RUN: llvm-ar rcs %t-implib.a %t-dabcdh.o %t-dabcds00000.o %t-dabcdt.o
+
+# RUN: llvm-mc -triple=x86_64-windows-gnu %s -filetype=obj -o %t.obj
+# RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-implib.a -verbose
+
+# RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
+
+# IMPORTS: Import {
+# IMPORTS-NEXT: Name: foo.dll
+# IMPORTS-NEXT: ImportLookupTableRVA:
+# IMPORTS-NEXT: ImportAddressTableRVA:
+# IMPORTS-NEXT: Symbol: data (0)
+# IMPORTS-NEXT: }
+
+    .global main
+    .text
+main:
+    movl data(%rip), %eax
+    ret
+    .data