COFF: Don't create unnecessary thunks.

[pcc]

Summary

A thunk is only needed if a relocation points to the undecorated
import name.

[ruiu]

LGTM

lld/trunk/COFF/InputFiles.h

private:
   std::vector<Symbol *> Symbols;
 };
 
 // This type represents import library members that contain DLL names
 // and symbols exported from the DLLs. See Microsoft PE/COFF spec. 7
 // for details about the format.
 class ImportFile : public InputFile {
 public:
-  explicit ImportFile(MemoryBufferRef M)
-      : InputFile(ImportKind, M), Live(!Config->DoGC) {}
+  explicit ImportFile(MemoryBufferRef M) : InputFile(ImportKind, M) {}
 
   static bool classof(const InputFile *F) { return F->kind() == ImportKind; }
 
   static std::vector<ImportFile *> Instances;
 
   DefinedImportData *ImpSym = nullptr;
   DefinedImportThunk *ThunkSym = nullptr;
   std::string DLLName;
 
 private:
   void parse() override;
 
 public:
   StringRef ExternalName;
   const coff_import_header *Hdr;
   Chunk *Location = nullptr;
 
   // We want to eliminate dllimported symbols if no one actually refers them.
-  // This "Live" bit is used to keep track of which import library members
+  // These "Live" bits are used to keep track of which import library members
   // are actually in use.
   //
   // If the Live bit is turned off by MarkLive, Writer will ignore dllimported
-  // symbols provided by this import library member.
-  bool Live;
+  // symbols provided by this import library member. We also track whether the
+  // imported symbol is used separately from whether the thunk is used in order
+  // to avoid creating unnecessary thunks.
+  bool Live = !Config->DoGC;
+  bool ThunkLive = !Config->DoGC;
 };
 
 // Used for LTO.
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
   ArrayRef<Symbol *> getSymbols() { return Symbols; }

lld/trunk/COFF/MarkLive.cpp

void markLive(ArrayRef<Chunk *> Chunks) {
   };
 
   auto AddSym = [&](Symbol *B) {
     if (auto *Sym = dyn_cast<DefinedRegular>(B))
       Enqueue(Sym->getChunk());
     else if (auto *Sym = dyn_cast<DefinedImportData>(B))
       Sym->File->Live = true;
     else if (auto *Sym = dyn_cast<DefinedImportThunk>(B))
-      Sym->WrappedSym->File->Live = true;
+      Sym->WrappedSym->File->Live = Sym->WrappedSym->File->ThunkLive = true;
   };
 
   // Add GC root chunks.
   for (Symbol *B : Config->GCRoot)
     AddSym(B);
 
   while (!Worklist.empty()) {
     SectionChunk *SC = Worklist.pop_back_val();

lld/trunk/COFF/Symbols.cpp

 }
 
 bool Symbol::isLive() const {
   if (auto *R = dyn_cast<DefinedRegular>(this))
     return R->getChunk()->isLive();
   if (auto *Imp = dyn_cast<DefinedImportData>(this))
     return Imp->File->Live;
   if (auto *Imp = dyn_cast<DefinedImportThunk>(this))
-    return Imp->WrappedSym->File->Live;
+    return Imp->WrappedSym->File->ThunkLive;
   // Assume any other kind of symbol is live.
   return true;
 }
 
 COFFSymbolRef DefinedCOFF::getCOFFSymbol() {
   size_t SymSize = cast<ObjFile>(File)->getCOFFObj()->getSymbolTableEntrySize();
   if (SymSize == sizeof(coff_symbol16))
     return COFFSymbolRef(reinterpret_cast<const coff_symbol16 *>(Sym));

lld/trunk/COFF/Writer.cpp

void Writer::createImportTables() {
   // initialization order, and this ordering is MSVC-compatible.)
   for (ImportFile *File : ImportFile::Instances) {
     if (!File->Live)
       continue;
 
     std::string DLL = StringRef(File->DLLName).lower();
     if (Config->DLLOrder.count(DLL) == 0)
       Config->DLLOrder[DLL] = Config->DLLOrder.size();
-  }
-
-  for (ImportFile *File : ImportFile::Instances) {
-    if (!File->Live)
-      continue;
 
     if (DefinedImportThunk *Thunk = File->ThunkSym)
+      if (File->ThunkLive)
         TextSec->addChunk(Thunk->getChunk());
 
     if (Config->DelayLoads.count(StringRef(File->DLLName).lower())) {
       if (!File->ThunkSym)
         fatal("cannot delay-load " + toString(File) +
               " due to import of data: " + toString(*File->ImpSym));
       DelayIdata.add(File->ImpSym);
     } else {
       Idata.add(File->ImpSym);

lld/trunk/test/COFF/delayimports-armnt.yaml

 # IMPORT-NEXT:   Attributes: 0x1
 # IMPORT-NEXT:   ModuleHandle: 0x3000
 # IMPORT-NEXT:   ImportAddressTable: 0x3008
 # IMPORT-NEXT:   ImportNameTable: 0x2040
 # IMPORT-NEXT:   BoundDelayImportTable: 0x0
 # IMPORT-NEXT:   UnloadDelayImportTable: 0x0
 # IMPORT-NEXT:   Import {
 # IMPORT-NEXT:     Symbol: function (0)
-# IMPORT-NEXT:     Address: 0x401019
+# IMPORT-NEXT:     Address: 0x40100D
 # IMPORT-NEXT:   }
 # IMPORT-NEXT: }
 #
 # BASEREL:      BaseReloc [
 # BASEREL-NEXT:   Entry {
 # BASEREL-NEXT:     Type: ARM_MOV32(T)
 # BASEREL-NEXT:     Address: 0x1000
 # BASEREL-NEXT:   }
 # BASEREL-NEXT:   Entry {
 # BASEREL-NEXT:     Type: ARM_MOV32(T)
 # BASEREL-NEXT:     Address: 0x100C
 # BASEREL-NEXT:   }
 # BASEREL-NEXT:   Entry {
 # BASEREL-NEXT:     Type: ARM_MOV32(T)
-# BASEREL-NEXT:     Address: 0x1018
+# BASEREL-NEXT:     Address: 0x1022
 # BASEREL-NEXT:   }
 # BASEREL-NEXT:   Entry {
-# BASEREL-NEXT:     Type: ARM_MOV32(T)
-# BASEREL-NEXT:     Address: 0x102E
+# BASEREL-NEXT:     Type: ABSOLUTE
+# BASEREL-NEXT:     Address: 0x1000
 # BASEREL-NEXT:   }
 # BASEREL-NEXT:   Entry {
 # BASEREL-NEXT:     Type: HIGHLOW
 # BASEREL-NEXT:     Address: 0x3008
 # BASEREL-NEXT:   }
 # BASEREL-NEXT:   Entry {
 # BASEREL-NEXT:     Type: ABSOLUTE
 # BASEREL-NEXT:     Address: 0x3000
 # BASEREL-NEXT:   }
 # BASEREL-NEXT: ]
 #
-# DISASM:      401018:       43 f2 08 0c     movw r12, #12296
-# DISASM-NEXT: 40101c:       c0 f2 40 0c     movt    r12, #64
-# DISASM-NEXT: 401020:       2d e9 0f 48     push.w  {r0, r1, r2, r3, r11, lr}
-# DISASM-NEXT: 401024:       0d f2 10 0b     addw    r11, sp, #16
-# DISASM-NEXT: 401028:       2d ed 10 0b     vpush   {d0, d1, d2, d3, d4, d5, d6, d7}
-# DISASM-NEXT: 40102c:       61 46           mov     r1, r12
-# DISASM-NEXT: 40102e:       42 f2 00 00     movw r0, #8192
-# DISASM-NEXT: 401032:       c0 f2 40 00     movt    r0, #64
-# DISASM-NEXT: 401036:       ff f7 e3 ff     bl      #-58
-# DISASM-NEXT: 40103a:       84 46           mov     r12, r0
-# DISASM-NEXT: 40103c:       bd ec 10 0b     vpop    {d0, d1, d2, d3, d4, d5, d6, d7}
-# DISASM-NEXT: 401040:       bd e8 0f 48     pop.w   {r0, r1, r2, r3, r11, lr}
-# DISASM-NEXT: 401044:       60 47           bx      r12
+# DISASM:      40100c:       43 f2 08 0c     movw r12, #12296
+# DISASM-NEXT:               c0 f2 40 0c     movt    r12, #64
+# DISASM-NEXT:               2d e9 0f 48     push.w  {r0, r1, r2, r3, r11, lr}
+# DISASM-NEXT:               0d f2 10 0b     addw    r11, sp, #16
+# DISASM-NEXT:               2d ed 10 0b     vpush   {d0, d1, d2, d3, d4, d5, d6, d7}
+# DISASM-NEXT:               61 46           mov     r1, r12
+# DISASM-NEXT:               42 f2 00 00     movw r0, #8192
+# DISASM-NEXT:               c0 f2 40 00     movt    r0, #64
+# DISASM-NEXT:               ff f7 e9 ff     bl      #-46
+# DISASM-NEXT:               84 46           mov     r12, r0
+# DISASM-NEXT:               bd ec 10 0b     vpop    {d0, d1, d2, d3, d4, d5, d6, d7}
+# DISASM-NEXT:               bd e8 0f 48     pop.w   {r0, r1, r2, r3, r11, lr}
+# DISASM-NEXT:               60 47           bx      r12
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_ARMNT
   Characteristics: [  ]
 sections:
   - Name:            .text
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_PURGEABLE, IMAGE_SCN_MEM_16BIT, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]