Merge IAT and ILT.

[ruiu]

Summary

Previously, LLD-produced executables had IAT (Import Address Table) and
ILT (Import Lookup Table) as separate chunks of data, although their
contents are identical. My interpretation of the COFF spec when I wrote
the COFF linker is that they need to be separate tables even though they
are the same.

But Peter found that the Windows loader is fine with executables in
which IAT and ILT are merged. This is a patch to merge IAT and ILT.
I confirmed that an lld-link self-hosted with this patch works fine.

Fixes https://bugs.llvm.org/show_bug.cgi?id=33064

[pcc]

Please add a comment somewhere explaining why we can merge them.

lld/COFF/DLL.cpp

430 ↗

(On Diff #99463)

I think you could simplify this further by removing the LookupTab field.

[ruiu]

• Updated as per pcc's comments.

[pcc]

LGTM

[rnk]

I ended up reverting this in rL304584 because it caused http://crbug.com/729077.

lld/trunk/COFF/DLL.h

public:
   uint64_t getIATRVA() { return Addresses[0]->getRVA(); }
   uint64_t getIATSize();
 
 private:
   void create();
 
   std::vector<DefinedImportData *> Imports;
   std::vector<Chunk *> Dirs;
-  std::vector<Chunk *> Lookups;
   std::vector<Chunk *> Addresses;
   std::vector<Chunk *> Hints;
   std::vector<Chunk *> DLLNames;
 };
 
 // Windows-specific.
 // DelayLoadContents creates all chunks for the delay-load DLL import table.
 class DelayLoadContents {

lld/trunk/COFF/DLL.cpp

 // A chunk for the import descriptor table.
 class ImportDirectoryChunk : public Chunk {
 public:
   explicit ImportDirectoryChunk(Chunk *N) : DLLName(N) {}
   size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); }
 
   void writeTo(uint8_t *Buf) const override {
     auto *E = (coff_import_directory_table_entry *)(Buf + OutputSectionOff);
-    E->ImportLookupTableRVA = LookupTab->getRVA();
     E->NameRVA = DLLName->getRVA();
+
+    // The import descriptor table contains two pointers to
+    // the tables describing dllimported symbols. But the
+    // Windows loader actually uses only one. So we create
+    // only one table and set both fields to its address.
+    E->ImportLookupTableRVA = AddressTab->getRVA();
     E->ImportAddressTableRVA = AddressTab->getRVA();
   }
 
   Chunk *DLLName;
-  Chunk *LookupTab;
   Chunk *AddressTab;
 };
 
 // A chunk representing null terminator in the import table.
 // Contents of this chunk is always null bytes.
 class NullChunk : public Chunk {
 public:
   explicit NullChunk(size_t N) : Size(N) {}

 // See Microsoft PE/COFF spec 5.4 for details.
 std::vector<Chunk *> IdataContents::getChunks() {
   create();
 
   // The loader assumes a specific order of data.
   // Add each type in the correct order.
   std::vector<Chunk *> V;
   V.insert(V.end(), Dirs.begin(), Dirs.end());
-  V.insert(V.end(), Lookups.begin(), Lookups.end());
   V.insert(V.end(), Addresses.begin(), Addresses.end());
   V.insert(V.end(), Hints.begin(), Hints.end());
   V.insert(V.end(), DLLNames.begin(), DLLNames.end());
   return V;
 }
 
 void IdataContents::create() {
   std::vector<std::vector<DefinedImportData *>> V = binImports(Imports);
 
   // Create .idata contents for each DLL.
   for (std::vector<DefinedImportData *> &Syms : V) {
     // Create lookup and address tables. If they have external names,
     // we need to create HintName chunks to store the names.
     // If they don't (if they are import-by-ordinals), we store only
     // ordinal values to the table.
-    size_t Base = Lookups.size();
+    size_t Base = Addresses.size();
     for (DefinedImportData *S : Syms) {
       uint16_t Ord = S->getOrdinal();
       if (S->getExternalName().empty()) {
-        Lookups.push_back(make<OrdinalOnlyChunk>(Ord));
         Addresses.push_back(make<OrdinalOnlyChunk>(Ord));
         continue;
       }
       auto *C = make<HintNameChunk>(S->getExternalName(), Ord);
-      Lookups.push_back(make<LookupChunk>(C));
       Addresses.push_back(make<LookupChunk>(C));
       Hints.push_back(C);
     }
     // Terminate with null values.
-    Lookups.push_back(make<NullChunk>(ptrSize()));
     Addresses.push_back(make<NullChunk>(ptrSize()));
 
     for (int I = 0, E = Syms.size(); I < E; ++I)
       Syms[I]->setLocation(Addresses[Base + I]);
 
     // Create the import table header.
     DLLNames.push_back(make<StringChunk>(Syms[0]->getDLLName()));
     auto *Dir = make<ImportDirectoryChunk>(DLLNames.back());
-    Dir->LookupTab = Lookups[Base];
     Dir->AddressTab = Addresses[Base];
     Dirs.push_back(Dir);
   }
   // Add null terminator.
   Dirs.push_back(make<NullChunk>(sizeof(ImportDirectoryTableEntry)));
 }
 
 std::vector<Chunk *> DelayLoadContents::getChunks() {

lld/trunk/test/COFF/armnt-imports.test

 # RUN: yaml2obj < %s > %t.obj
 # RUN: lld-link /out:%t.exe /subsystem:console %t.obj \
 # RUN:   /entry:mainCRTStartup %p/Inputs/library.lib
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck %s
 
 # CHECK: Import {
 # CHECK:   Name: library.dll
 # CHECK:   ImportLookupTableRVA: 0x2028
-# CHECK:   ImportAddressTableRVA: 0x2030
+# CHECK:   ImportAddressTableRVA: 0x2028
 # CHECK:   Symbol: function (0)
 # CHECK: }
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_ARMNT
   Characteristics: [  ]
 sections:

lld/trunk/test/COFF/hello32.test

 HEADER-NEXT:     GlobalPtrRVA: 0x0
 HEADER-NEXT:     GlobalPtrSize: 0x0
 HEADER-NEXT:     TLSTableRVA: 0x0
 HEADER-NEXT:     TLSTableSize: 0x0
 HEADER-NEXT:     LoadConfigTableRVA: 0x0
 HEADER-NEXT:     LoadConfigTableSize: 0x0
 HEADER-NEXT:     BoundImportRVA: 0x0
 HEADER-NEXT:     BoundImportSize: 0x0
-HEADER-NEXT:     IATRVA: 0x3034
+HEADER-NEXT:     IATRVA: 0x3028
 HEADER-NEXT:     IATSize: 0xC
 HEADER-NEXT:     DelayImportDescriptorRVA: 0x0
 HEADER-NEXT:     DelayImportDescriptorSize: 0x0
 HEADER-NEXT:     CLRRuntimeHeaderRVA: 0x0
 HEADER-NEXT:     CLRRuntimeHeaderSize: 0x0
 HEADER-NEXT:     ReservedRVA: 0x0
 HEADER-NEXT:     ReservedSize: 0x0
 HEADER-NEXT:   }

 HEADER-NEXT: }
 
 IMPORTS: Format: COFF-i386
 IMPORTS: Arch: i386
 IMPORTS: AddressSize: 32bit
 IMPORTS: Import {
 IMPORTS:   Name: std32.dll
 IMPORTS:   ImportLookupTableRVA: 0x3028
-IMPORTS:   ImportAddressTableRVA: 0x3034
+IMPORTS:   ImportAddressTableRVA: 0x3028
 IMPORTS:   Symbol: ExitProcess (0)
 IMPORTS:   Symbol: MessageBoxA (1)
 IMPORTS: }
 
 BASEREL: BaseReloc [
 BASEREL:   Entry {
 BASEREL:     Type: HIGHLOW
 BASEREL:     Address: 0x2005
 BASEREL:   }
 BASEREL:   Entry {
 BASEREL:     Type: HIGHLOW
 BASEREL:     Address: 0x200C
 BASEREL:   }
 BASEREL: ]

lld/trunk/test/COFF/imports.test

 TEXT-NEXT: movq    $0, %rcx
 TEXT-NEXT: leaq    -4108(%rip), %rdx
 TEXT-NEXT: leaq    -4121(%rip), %r8
 TEXT-NEXT: movl    $0, %r9d
 TEXT-NEXT: callq   60
 TEXT-NEXT: movl    $0, %ecx
 TEXT-NEXT: callq   18
 TEXT-NEXT: callq   29
-TEXT:      jmpq    *4098(%rip)
-TEXT:      jmpq    *4090(%rip)
-TEXT:      jmpq    *4082(%rip)
+TEXT:      jmpq    *4066(%rip)
+TEXT:      jmpq    *4058(%rip)
+TEXT:      jmpq    *4050(%rip)
 
 IMPORT:      Import {
 IMPORT-NEXT:   Name: std64.dll
 IMPORT-NEXT:   ImportLookupTableRVA: 0x3028
-IMPORT-NEXT:   ImportAddressTableRVA: 0x3048
+IMPORT-NEXT:   ImportAddressTableRVA: 0x3028
 IMPORT-NEXT:   Symbol: ExitProcess (0)
 IMPORT-NEXT:   Symbol:  (50)
 IMPORT-NEXT:   Symbol: MessageBoxA (1)
 IMPORT-NEXT: }