COFF: Process /merge flag as we create output sections.

[pcc]

Summary

With this we can merge builtin sections.

Depends on D45349

[ruiu]

lld/COFF/Writer.cpp

218–219 ↗

(On Diff #141267)

It is not obvious why only .pdata is handled in a special way. Can you add a comment?

406 ↗

(On Diff #141267)

auto -> OutputSection *

[pcc]

• Address review comments

[ruiu]

LGTM

lld/COFF/Writer.cpp

1178 ↗

(On Diff #141272)

BufAddr

lld/trunk/COFF/DLL.h

 };
 
 // Windows-specific.
 // EdataContents creates all chunks for the DLL export table.
 class EdataContents {
 public:
   EdataContents();
   std::vector<Chunk *> Chunks;
+
+  uint64_t getRVA() { return Chunks[0]->getRVA(); }
+  uint64_t getSize() {
+    return Chunks.back()->getRVA() + Chunks.back()->getSize() - getRVA();
+  }
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/trunk/COFF/DriverUtils.cpp

 
 // Parse a string of the form of "<from>=<to>".
 // Results are directly written to Config.
 void parseMerge(StringRef S) {
   StringRef From, To;
   std::tie(From, To) = S.split('=');
   if (From.empty() || To.empty())
     fatal("/merge: invalid argument: " + S);
+  if (From == ".rsrc" || To == ".rsrc")
+    fatal("/merge: cannot merge '.rsrc' with any section");
+  if (From == ".reloc" || To == ".reloc")
+    fatal("/merge: cannot merge '.reloc' with any section");
   auto Pair = Config->Merge.insert(std::make_pair(From, To));
   bool Inserted = Pair.second;
   if (!Inserted) {
     StringRef Existing = Pair.first->second;
     if (Existing != To)
       warn(S + ": already merged into " + Existing);
   }
 }

lld/trunk/COFF/Writer.cpp

private:
   uint64_t FileSize;
   uint32_t PointerToSymbolTable = 0;
   uint64_t SizeOfImage;
   uint64_t SizeOfHeaders;
 
   OutputSection *TextSec;
   OutputSection *RdataSec;
   OutputSection *DataSec;
-  OutputSection *PdataSec;
   OutputSection *IdataSec;
   OutputSection *EdataSec;
   OutputSection *DidatSec;
   OutputSection *RsrcSec;
   OutputSection *RelocSec;
+
+  // The first and last .pdata sections in the output file.
+  //
+  // We need to keep track of the location of .pdata in whichever section it
+  // gets merged into so that we can sort its contents and emit a correct data
+  // directory entry for the exception table. This is also the case for some
+  // other sections (such as .edata) but because the contents of those sections
+  // are entirely linker-generated we can keep track of their locations using
+  // the chunks that the linker creates. All .pdata chunks come from input
+  // files, so we need to keep track of them separately.
+  Chunk *FirstPdata = nullptr;
+  Chunk *LastPdata;
 };
 } // anonymous namespace
 
 namespace lld {
 namespace coff {
 
 static Timer CodeLayoutTimer("Code Layout", Timer::root());
 static Timer DiskCommitTimer("Commit Output File", Timer::root());
void Writer::run() {
 
   writeMapFile(OutputSections);
 
   ScopedTimer T2(DiskCommitTimer);
   if (auto E = Buffer->commit())
     fatal("failed to write the output file: " + toString(std::move(E)));
 }
 
-static StringRef getOutputSection(StringRef Name) {
+static StringRef getOutputSectionName(StringRef Name) {
   StringRef S = Name.split('$').first;
 
   // Treat a later period as a separator for MinGW, for sections like
   // ".ctors.01234".
-  S = S.substr(0, S.find('.', 1));
-
-  auto It = Config->Merge.find(S);
-  if (It == Config->Merge.end())
-    return S;
-  return It->second;
+  return S.substr(0, S.find('.', 1));
 }
 
 // For /order.
 static void sortBySectionOrder(std::vector<Chunk *> &Chunks) {
   auto GetPriority = [](const Chunk *C) {
     if (auto *Sec = dyn_cast<SectionChunk>(C))
       if (Sec->Sym)
         return Config->Order.lookup(Sec->Sym->getName());
void Writer::createSections() {
   const uint32_t CODE = IMAGE_SCN_CNT_CODE;
   const uint32_t DISCARDABLE = IMAGE_SCN_MEM_DISCARDABLE;
   const uint32_t R = IMAGE_SCN_MEM_READ;
   const uint32_t W = IMAGE_SCN_MEM_WRITE;
   const uint32_t X = IMAGE_SCN_MEM_EXECUTE;
 
   SmallDenseMap<StringRef, OutputSection *> Sections;
   auto CreateSection = [&](StringRef Name, uint32_t Perms) {
-    auto Sec = make<OutputSection>(Name);
-    Sec->addPermissions(Perms);
+    auto I = Config->Merge.find(Name);
+    if (I != Config->Merge.end())
+      Name = I->second;
+    OutputSection *&Sec = Sections[Name];
+    if (!Sec) {
+      Sec = make<OutputSection>(Name);
       OutputSections.push_back(Sec);
-    Sections[Name] = Sec;
+    }
+    Sec->addPermissions(Perms);
     return Sec;
   };
 
   // Try to match the section order used by link.exe.
   TextSec = CreateSection(".text", CODE | R | X);
   CreateSection(".bss", BSS | R | W);
   RdataSec = CreateSection(".rdata", DATA | R);
   DataSec = CreateSection(".data", DATA | R | W);
-  PdataSec = CreateSection(".pdata", DATA | R);
+  CreateSection(".pdata", DATA | R);
   IdataSec = CreateSection(".idata", DATA | R);
   EdataSec = CreateSection(".edata", DATA | R);
   DidatSec = CreateSection(".didat", DATA | R);
   RsrcSec = CreateSection(".rsrc", DATA | R);
   RelocSec = CreateSection(".reloc", DATA | DISCARDABLE | R);
 
   // Then bin chunks by name.
   std::map<StringRef, std::vector<Chunk *>> Map;
if (!Config->Order.empty())
     for (auto &Pair : Map)
       sortBySectionOrder(Pair.second);
 
   // Then create an OutputSection for each section.
   // '$' and all following characters in input section names are
   // discarded when determining output section. So, .text$foo
   // contributes to .text, for example. See PE/COFF spec 3.2.
   for (auto Pair : Map) {
-    StringRef Name = getOutputSection(Pair.first);
-    OutputSection *&Sec = Sections[Name];
-    if (!Sec) {
-      Sec = make<OutputSection>(Name);
-      OutputSections.push_back(Sec);
+    StringRef Name = getOutputSectionName(Pair.first);
+    if (Name == ".pdata") {
+      if (!FirstPdata)
+        FirstPdata = Pair.second.front();
+      LastPdata = Pair.second.back();
     }
+    OutputSection *Sec = CreateSection(Name, 0);
     std::vector<Chunk *> &Chunks = Pair.second;
     for (Chunk *C : Chunks) {
       Sec->addChunk(C);
       Sec->addPermissions(C->getPermissions());
     }
   }
 
   // Finally, move some output sections to the end.
if (TextSec->getVirtualSize()) {
     PE->BaseOfCode = TextSec->getRVA();
     PE->SizeOfCode = TextSec->getRawSize();
   }
   PE->SizeOfInitializedData = getSizeOfInitializedData();
 
   // Write data directory
   auto *Dir = reinterpret_cast<data_directory *>(Buf);
   Buf += sizeof(*Dir) * NumberfOfDataDirectory;
-  if (EdataSec->getVirtualSize()) {
-    Dir[EXPORT_TABLE].RelativeVirtualAddress = EdataSec->getRVA();
-    Dir[EXPORT_TABLE].Size = EdataSec->getVirtualSize();
+  if (!Config->Exports.empty()) {
+    Dir[EXPORT_TABLE].RelativeVirtualAddress = Edata.getRVA();
+    Dir[EXPORT_TABLE].Size = Edata.getSize();
   }
   if (!Idata.empty()) {
     Dir[IMPORT_TABLE].RelativeVirtualAddress = Idata.getDirRVA();
     Dir[IMPORT_TABLE].Size = Idata.getDirSize();
     Dir[IAT].RelativeVirtualAddress = Idata.getIATRVA();
     Dir[IAT].Size = Idata.getIATSize();
   }
   if (RsrcSec->getVirtualSize()) {
     Dir[RESOURCE_TABLE].RelativeVirtualAddress = RsrcSec->getRVA();
     Dir[RESOURCE_TABLE].Size = RsrcSec->getVirtualSize();
   }
-  if (PdataSec->getVirtualSize()) {
-    Dir[EXCEPTION_TABLE].RelativeVirtualAddress = PdataSec->getRVA();
-    Dir[EXCEPTION_TABLE].Size = PdataSec->getVirtualSize();
+  if (FirstPdata) {
+    Dir[EXCEPTION_TABLE].RelativeVirtualAddress = FirstPdata->getRVA();
+    Dir[EXCEPTION_TABLE].Size =
+        LastPdata->getRVA() + LastPdata->getSize() - FirstPdata->getRVA();
   }
   if (RelocSec->getVirtualSize()) {
     Dir[BASE_RELOCATION_TABLE].RelativeVirtualAddress = RelocSec->getRVA();
     Dir[BASE_RELOCATION_TABLE].Size = RelocSec->getVirtualSize();
   }
   if (Symbol *Sym = Symtab->findUnderscore("_tls_used")) {
     if (Defined *B = dyn_cast<Defined>(Sym)) {
       Dir[TLS_TABLE].RelativeVirtualAddress = B->getRVA();
void Writer::writeBuildId() {
   Buf += DOSStubSize + sizeof(PEMagic);
   object::coff_file_header *CoffHeader =
       reinterpret_cast<coff_file_header *>(Buf);
   CoffHeader->TimeDateStamp = Hash;
 }
 
 // Sort .pdata section contents according to PE/COFF spec 5.5.
 void Writer::sortExceptionTable() {
-  if (PdataSec->getVirtualSize() == 0)
+  if (!FirstPdata)
     return;
   // We assume .pdata contains function table entries only.
-  uint8_t *Begin = Buffer->getBufferStart() + PdataSec->getFileOff();
-  uint8_t *End = Begin + PdataSec->getVirtualSize();
+  auto BufAddr = [&](Chunk *C) {
+    return Buffer->getBufferStart() + C->getOutputSection()->getFileOff() +
+           C->getRVA() - C->getOutputSection()->getRVA();
+  };
+  uint8_t *Begin = BufAddr(FirstPdata);
+  uint8_t *End = BufAddr(LastPdata) + LastPdata->getSize();
   if (Config->Machine == AMD64) {
     struct Entry { ulittle32_t Begin, End, Unwind; };
     sort(parallel::par, (Entry *)Begin, (Entry *)End,
          [](const Entry &A, const Entry &B) { return A.Begin < B.Begin; });
     return;
   }
   if (Config->Machine == ARMNT || Config->Machine == ARM64) {
     struct Entry { ulittle32_t Begin, Unwind; };

lld/trunk/test/COFF/export32.test

 # RUN: yaml2obj < %s > %t.obj
 #
 # RUN: lld-link /out:%t.dll /dll %t.obj /export:exportfn1 /export:exportfn2
 # RUN: llvm-objdump -p %t.dll | FileCheck -check-prefix=CHECK1 %s
+#
+# RUN: lld-link /out:%t.dll /dll %t.obj /export:exportfn1 /export:exportfn2 /merge:.edata=.rdata
+# RUN: llvm-objdump -p %t.dll | FileCheck -check-prefix=CHECK1 %s
+# RUN: llvm-readobj -file-headers -sections %t.dll | FileCheck -check-prefix=HEADER-MERGE %s
 
 # CHECK1:      Export Table:
 # CHECK1:      DLL name: export32.test.tmp.dll
 # CHECK1:      Ordinal      RVA  Name
 # CHECK1-NEXT:       0        0
 # CHECK1-NEXT:       1   0x1008  exportfn1
 # CHECK1-NEXT:       2   0x1010  exportfn2
 
+# HEADER-MERGE: ExportTableRVA: 0x2000
+# HEADER-MERGE-NEXT: ExportTableSize: 0x7E
+# HEADER-MERGE: Name: .rdata
+# HEADER-MERGE-NEXT: VirtualSize: 0x7E
+# HEADER-MERGE-NEXT: VirtualAddress: 0x2000
+
 # RUN: lld-link /out:%t.dll /dll %t.obj /export:exportfn1,@5 \
 # RUN:   /export:exportfn2 /export:mangled
 # RUN: llvm-objdump -p %t.dll | FileCheck -check-prefix=CHECK2 %s
 
 # CHECK2:      Export Table:
 # CHECK2:      DLL name: export32.test.tmp.dll
 # CHECK2:      Ordinal      RVA  Name
 # CHECK2-NEXT:       0        0

lld/trunk/test/COFF/merge.test

 # RUN: yaml2obj < %s > %t.obj
 # RUN: lld-link /out:%t.exe /entry:main /subsystem:console /force \
 # RUN:   /merge:.foo=.abc /merge:.bar=.def %t.obj /debug
 # RUN: llvm-readobj -sections %t.exe | FileCheck %s
 
+# RUN: not lld-link /out:%t.exe /entry:main /subsystem:console /force \
+# RUN:   /merge:.rsrc=.foo %t.obj /debug 2>&1 | FileCheck --check-prefix=NO-RSRC %s
+# RUN: not lld-link /out:%t.exe /entry:main /subsystem:console /force \
+# RUN:   /merge:.foo=.rsrc %t.obj /debug 2>&1 | FileCheck --check-prefix=NO-RSRC %s
+# RUN: not lld-link /out:%t.exe /entry:main /subsystem:console /force \
+# RUN:   /merge:.reloc=.foo %t.obj /debug 2>&1 | FileCheck --check-prefix=NO-RELOC %s
+# RUN: not lld-link /out:%t.exe /entry:main /subsystem:console /force \
+# RUN:   /merge:.foo=.reloc %t.obj /debug 2>&1 | FileCheck --check-prefix=NO-RELOC %s
+
 # CHECK: Name: .def
 # CHECK: Name: .abc
 
+# NO-RSRC: /merge: cannot merge '.rsrc' with any section
+# NO-RELOC: /merge: cannot merge '.reloc' with any section
+
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: []
 sections:
   - Name:            .foo
     Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_READ, IMAGE_SCN_MEM_WRITE ]
     Alignment:       4

lld/trunk/test/COFF/unwind.test

 # RUN: yaml2obj < %s > %t.obj
 #
 # RUN: lld-link /out:%t.exe /entry:main %t.obj
 # RUN: llvm-readobj -file-headers %t.exe | FileCheck -check-prefix=HEADER %s
 # RUN: llvm-objdump -unwind-info %t.exe | FileCheck -check-prefix=UNWIND %s
 #
-# HEADER: ExceptionTableRVA: 0x2000
+# RUN: lld-link /merge:.pdata=.rdata /out:%t.exe /entry:main %t.obj
+# RUN: llvm-readobj -file-headers -sections %t.exe | FileCheck -check-prefix=HEADER-MERGE %s
+#
+# HEADER: ExceptionTableRVA: 0x3000
+#
+# FIXME: llvm-readobj currently does not understand files with .pdata merged
+# into .rdata. But we can at least check that the section headers look correct.
+#
+# HEADER-MERGE: ExceptionTableRVA: 0x2000
+# HEADER-MERGE-NEXT: ExceptionTableSize: 0x30
+# HEADER-MERGE: Name: .rdata
+# HEADER-MERGE-NEXT: VirtualSize: 0x34
+# HEADER-MERGE-NEXT: VirtualAddress: 0x2000
 #
 # UNWIND: Function Table:
 # UNWIND:   Start Address: 0x1000
 # UNWIND:   End Address: 0x101b
-# UNWIND:   Unwind Info Address: 0x3000
+# UNWIND:   Unwind Info Address: 0x4000
 # UNWIND:     Version: 1
 # UNWIND:     Flags: 1 UNW_ExceptionHandler
 # UNWIND:     Size of prolog: 18
 # UNWIND:     Number of Codes: 8
 # UNWIND:     Frame register: RBX
 # UNWIND:     Frame offset: 0
 # UNWIND:     Unwind Codes:
 # UNWIND:       0x12: UOP_SetFPReg
 # UNWIND:       0x0f: UOP_PushNonVol RBX
 # UNWIND:       0x0e: UOP_SaveXMM128 XMM8 [0x0000]
 # UNWIND:       0x09: UOP_SaveNonVol RSI [0x0010]
 # UNWIND:       0x04: UOP_AllocSmall 24
 # UNWIND:       0x00: UOP_PushMachFrame w/o error code
 # UNWIND: Function Table:
 # UNWIND:   Start Address: 0x1012
 # UNWIND:   End Address: 0x1012
-# UNWIND:   Unwind Info Address: 0x301c
+# UNWIND:   Unwind Info Address: 0x401c
 # UNWIND:     Version: 1
 # UNWIND:     Flags: 4 UNW_ChainInfo
 # UNWIND:     Size of prolog: 0
 # UNWIND:     Number of Codes: 0
 # UNWIND:     No frame pointer used
 # UNWIND: Function Table:
 # UNWIND:   Start Address: 0x101b
 # UNWIND:   End Address: 0x101c
-# UNWIND:   Unwind Info Address: 0x302c
+# UNWIND:   Unwind Info Address: 0x402c
 # UNWIND:     Version: 1
 # UNWIND:     Flags: 0
 # UNWIND:     Size of prolog: 0
 # UNWIND:     Number of Codes: 0
 # UNWIND:     No frame pointer used
 # UNWIND: Function Table:
 # UNWIND:   Start Address: 0x101c
 # UNWIND:   End Address: 0x1039
-# UNWIND:   Unwind Info Address: 0x3034
+# UNWIND:   Unwind Info Address: 0x4034
 # UNWIND:     Version: 1
 # UNWIND:     Flags: 0
 # UNWIND:     Size of prolog: 14
 # UNWIND:     Number of Codes: 6
 # UNWIND:     No frame pointer used
 # UNWIND:     Unwind Codes:
 # UNWIND:       0x0e: UOP_AllocLarge 8454128
 # UNWIND:       0x07: UOP_AllocLarge 8190
Relocations:
         SymbolName:      allocFunc
         Type:            IMAGE_REL_AMD64_ADDR32NB
       - VirtualAddress:  40
         SymbolName:      allocFunc
         Type:            IMAGE_REL_AMD64_ADDR32NB
       - VirtualAddress:  44
         SymbolName:      .xdata
         Type:            IMAGE_REL_AMD64_ADDR32NB
+  - Name:            .rdata
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_READ ]
+    Alignment:       4
+    SectionData:     00000000
 symbols:
   - Name:            .text
     Value:           0
     SectionNumber:   1
     SimpleType:      IMAGE_SYM_TYPE_NULL
     ComplexType:     IMAGE_SYM_DTYPE_NULL
     StorageClass:    IMAGE_SYM_CLASS_STATIC
     SectionDefinition: