[LLD] [COFF] Provide __CTOR_LIST__ and __DTOR_LIST__ symbols for MinGW

[mstorsjo]

Summary

MinGW uses these kind of list terminator symbols for traversing the constructor/destructor lists. These list terminators are actual pointers entries in the lists, with the values 0 and (uintptr_t)-1 (instead of just symbols pointing to the start/end of the list).

(This mechanism exists in both the mingw-w64 crt startup code and in libgcc; normally the mingw-w64 one is used, but a DLL build of libgcc uses the libgcc one. Therefore it's not trivial to change the mechanism without lots of cross-project synchronization and potentially invalidating some combinations of old/new versions of them.)

When mingw-w64 has been used with lld so far, the CRT startup object files have so far provided these symbols, ending up with different, incompatible builds of the CRT startup object files depending on whether binutils or lld are going to be used.

In order to avoid the need of different configuration of the CRT startup object files depending on what linker to be used, provide these symbols in lld instead. (Mingw-w64 checks at build time whether the linker provides these symbols or not.) This unifies this particular detail between the two linkers.

This does disallow the use of the very latest lld with older versions of mingw-w64 (the configure check for the list was added recently; earlier it simply checked whether the CRT was built with gcc or clang), and requires rebuilding the mingw-w64 CRT. But the number of users of lld+mingw still is low enough that such a change should be tolerable, and unifies this aspect of the toolchains, easing interoperability between the toolchains for the future.

The actual test for this feature is added in ctors_dtors_priority.s, but a number of other tests that checked absolute output addresses are updated.

This is one out of two missing features to make ld.lld a fully working drop-in replacement for ld.bfd in existing mingw sysroots.

[ruiu]

COFF/Chunks.h

483 ↗

(On Diff #165358)

... but should be okay since the data is small?

If so, I'd add that to the comment.

COFF/Writer.cpp

1392 ↗

(On Diff #165358)

I'd explain the structure of .ctors and .dtors here. E.g. They have to start with a null pointer and end with a (void *)-1, so we add these sentinels in this function.

1408 ↗

(On Diff #165358)

Looks like CustomDataChunk is a bit over-designed, because we are using it only to represent a single-word data chunk. Instead of generalizing it, you could define a chunk that takes an integer and handle it as a pointer-size data. Then you can eliminate std::vector from this function.

[mstorsjo]

Applied @ruiu's suggestions.

[ruiu]

LGTM

lld/trunk/COFF/Chunks.h

public:
   Defined *Sym;
   SectionChunk *Target;
   uint32_t TargetOffset;
   // The Flags field contains the size of the relocation, in bits. No other
   // flags are currently defined.
   int Flags;
 };
 
+// MinGW specific. A Chunk that contains one pointer-sized absolute value.
+class AbsolutePointerChunk : public Chunk {
+public:
+  AbsolutePointerChunk(uint64_t Value) : Value(Value) {
+    Alignment = getSize();
+  }
+  size_t getSize() const override;
+  void writeTo(uint8_t *Buf) const override;
+
+private:
+  uint64_t Value;
+};
+
 void applyMOV32T(uint8_t *Off, uint32_t V);
 void applyBranch24T(uint8_t *Off, int32_t V);
 
 } // namespace coff
 } // namespace lld
 
 namespace llvm {
 template <>
 struct DenseMapInfo<lld::coff::ChunkAndOffset>
     : lld::coff::ChunkAndOffset::DenseMapInfo {};
 }
 
 #endif

lld/trunk/COFF/Chunks.cpp

 size_t MergeChunk::getSize() const {
   return Builder.getSize();
 }
 
 void MergeChunk::writeTo(uint8_t *Buf) const {
   Builder.write(Buf + OutputSectionOff);
 }
 
+// MinGW specific.
+size_t AbsolutePointerChunk::getSize() const {
+  return Config->is64() ? 8 : 4;
+}
+
+void AbsolutePointerChunk::writeTo(uint8_t *Buf) const {
+  if (Config->is64()) {
+    write64le(Buf + OutputSectionOff, Value);
+  } else {
+    write32le(Buf + OutputSectionOff, Value);
+  }
+}
+
 } // namespace coff
 } // namespace lld

lld/trunk/COFF/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   Symtab->addAbsolute(mangle("__guard_longjmp_count"), 0);
   Symtab->addAbsolute(mangle("__guard_longjmp_table"), 0);
   // Needed for MSVC 2017 15.5 CRT.
   Symtab->addAbsolute(mangle("__enclave_config"), 0);
 
   if (Config->MinGW) {
     Symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST__"), 0);
     Symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST_END__"), 0);
+    Symtab->addAbsolute(mangle("__CTOR_LIST__"), 0);
+    Symtab->addAbsolute(mangle("__DTOR_LIST__"), 0);
   }
 
   // This code may add new undefined symbols to the link, which may enqueue more
   // symbol resolution tasks, so we need to continue executing tasks until we
   // converge.
   do {
     // Windows specific -- if entry point is not found,
     // search for its mangled names.

lld/trunk/COFF/Writer.h

 // creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and RVAs.
 class OutputSection {
 public:
   OutputSection(llvm::StringRef N, uint32_t Chars) : Name(N) {
     Header.Characteristics = Chars;
   }
   void addChunk(Chunk *C);
+  void insertChunkAtStart(Chunk *C);
   void merge(OutputSection *Other);
   ArrayRef<Chunk *> getChunks() { return Chunks; }
   void addPermissions(uint32_t C);
   void setPermissions(uint32_t C);
   uint64_t getRVA() { return Header.VirtualAddress; }
   uint64_t getFileOff() { return Header.PointerToRawData; }
   void writeHeaderTo(uint8_t *Buf);
 

lld/trunk/COFF/Writer.cpp

private:
   void mergeSections();
   void assignAddresses();
   void removeEmptySections();
   void createSymbolAndStringTable();
   void openFile(StringRef OutputPath);
   template <typename PEHeaderTy> void writeHeader();
   void createSEHTable();
   void createRuntimePseudoRelocs();
+  void insertCtorDtorSymbols();
   void createGuardCFTables();
   void markSymbolsForRVATable(ObjFile *File,
                               ArrayRef<SectionChunk *> SymIdxChunks,
                               SymbolRVASet &TableSymbols);
   void maybeAddRVATable(SymbolRVASet TableSymbols, StringRef TableSym,
                         StringRef CountSym);
   void setSectionPermissions();
   void writeSections();
private:
   OutputSection *BuildidSec;
   OutputSection *DataSec;
   OutputSection *PdataSec;
   OutputSection *IdataSec;
   OutputSection *EdataSec;
   OutputSection *DidatSec;
   OutputSection *RsrcSec;
   OutputSection *RelocSec;
+  OutputSection *CtorsSec;
+  OutputSection *DtorsSec;
 
   // 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

 
 void writeResult() { Writer().run(); }
 
 void OutputSection::addChunk(Chunk *C) {
   Chunks.push_back(C);
   C->setOutputSection(this);
 }
 
+void OutputSection::insertChunkAtStart(Chunk *C) {
+  Chunks.insert(Chunks.begin(), C);
+  C->setOutputSection(this);
+}
+
 void OutputSection::setPermissions(uint32_t C) {
   Header.Characteristics &= ~PermMask;
   Header.Characteristics |= C;
 }
 
 void OutputSection::merge(OutputSection *Other) {
   for (Chunk *C : Other->Chunks)
     C->setOutputSection(this);
void Writer::createSections() {
   BuildidSec = CreateSection(".buildid", DATA | R);
   DataSec = CreateSection(".data", DATA | R | W);
   PdataSec = 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);
+  CtorsSec = CreateSection(".ctors", DATA | R | W);
+  DtorsSec = CreateSection(".dtors", DATA | R | W);
 
   // Then bin chunks by name and output characteristics.
   std::map<std::pair<StringRef, uint32_t>, std::vector<Chunk *>> Map;
   for (Chunk *C : Symtab->getChunks()) {
     auto *SC = dyn_cast<SectionChunk>(C);
     if (SC && !SC->Live) {
       if (Config->Verbose)
         SC->printDiscardedMessage();
void Writer::createMiscChunks() {
   // Create SEH table. x86-only.
   if (Config->Machine == I386)
     createSEHTable();
 
   // Create /guard:cf tables if requested.
   if (Config->GuardCF != GuardCFLevel::Off)
     createGuardCFTables();
 
-  if (Config->MinGW)
+  if (Config->MinGW) {
     createRuntimePseudoRelocs();
+
+    insertCtorDtorSymbols();
+  }
 }
 
 // Create .idata section for the DLL-imported symbol table.
 // The format of this section is inherently Windows-specific.
 // IdataContents class abstracted away the details for us,
 // so we just let it create chunks and add them to the section.
 void Writer::createImportTables() {
   if (ImportFile::Instances.empty())
void Writer::createRuntimePseudoRelocs() {
   RdataSec->addChunk(EndOfList);
 
   Symbol *HeadSym = Symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST__");
   Symbol *EndSym = Symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST_END__");
   replaceSymbol<DefinedSynthetic>(HeadSym, HeadSym->getName(), Table);
   replaceSymbol<DefinedSynthetic>(EndSym, EndSym->getName(), EndOfList);
 }
 
+// MinGW specific.
+// The MinGW .ctors and .dtors lists have sentinels at each end;
+// a (uintptr_t)-1 at the start and a (uintptr_t)0 at the end.
+// There's a symbol pointing to the start sentinel pointer, __CTOR_LIST__
+// and __DTOR_LIST__ respectively.
+void Writer::insertCtorDtorSymbols() {
+  AbsolutePointerChunk *CtorListHead = make<AbsolutePointerChunk>(-1);
+  AbsolutePointerChunk *CtorListEnd = make<AbsolutePointerChunk>(0);
+  AbsolutePointerChunk *DtorListHead = make<AbsolutePointerChunk>(-1);
+  AbsolutePointerChunk *DtorListEnd = make<AbsolutePointerChunk>(0);
+  CtorsSec->insertChunkAtStart(CtorListHead);
+  CtorsSec->addChunk(CtorListEnd);
+  DtorsSec->insertChunkAtStart(DtorListHead);
+  DtorsSec->addChunk(DtorListEnd);
+
+  Symbol *CtorListSym = Symtab->findUnderscore("__CTOR_LIST__");
+  Symbol *DtorListSym = Symtab->findUnderscore("__DTOR_LIST__");
+  replaceSymbol<DefinedSynthetic>(CtorListSym, CtorListSym->getName(),
+                                  CtorListHead);
+  replaceSymbol<DefinedSynthetic>(DtorListSym, DtorListSym->getName(),
+                                  DtorListHead);
+}
+
 // Handles /section options to allow users to overwrite
 // section attributes.
 void Writer::setSectionPermissions() {
   for (auto &P : Config->Section) {
     StringRef Name = P.first;
     uint32_t Perm = P.second;
     for (OutputSection *Sec : OutputSections)
       if (Sec->Name == Name)

lld/trunk/test/COFF/associative-comdat-mingw.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -triple=x86_64-windows-gnu %s -filetype=obj -o %t1.obj
 # RUN: llvm-mc -triple=x86_64-windows-gnu %S/Inputs/associative-comdat-mingw-2.s -filetype=obj -o %t2.obj
 
 # RUN: lld-link -lldmingw -entry:main %t1.obj %t2.obj -out:%t.gc.exe -verbose
 # RUN: llvm-readobj -sections %t.gc.exe | FileCheck %s
 
 # CHECK: Sections [
 # CHECK:   Section {
 # CHECK:     Number: 2
 # CHECK-LABEL:     Name: .rdata (2E 72 64 61 74 61 00 00)
 #             This is the critical check to show that only *one* definition of
-#             .xdata$foo was retained. This *must* be 4.
+#             .xdata$foo was retained. This *must* be 0x24 (0x4 for the .xdata
+#             section and 0x20 for the .ctors/.dtors headers/ends).
 #             Make sure that no other .xdata sections get included, which would
 #             increase the size here.
-# CHECK-NEXT:     VirtualSize: 0x4
+# CHECK-NEXT:     VirtualSize: 0x24
 
         .text
         .def            main;
         .scl            2;
         .type           32;
         .endef
         .globl          main
         .p2align        4, 0x90

lld/trunk/test/COFF/autoimport-arm-data.s

 # REQUIRES: arm
 
 # RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.thumb\n.text\nDllMainCRTStartup:\nbx lr\n.data\nvariable:\n.long 42" > %t-lib.s
 # RUN: llvm-mc -triple=armv7-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
 # RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
 
 # RUN: llvm-mc -triple=armv7-windows-gnu %s -filetype=obj -o %t.obj
 # RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib -verbose
 
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
 
 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-arm-data.s.tmp-lib.dll
-# IMPORTS-NEXT: ImportLookupTableRVA: 0x2040
-# IMPORTS-NEXT: ImportAddressTableRVA: 0x2048
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x2050
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x2058
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
-# First runtime pseudo reloc, with import from 0x2048,
+# First runtime pseudo reloc, with import from 0x2058,
 # applied at 0x3000, with a size of 32 bits.
 # CONTENTS: Contents of section .rdata:
-# CONTENTS:  402000 00000000 00000000 01000000 48200000
+# CONTENTS:  402000 00000000 00000000 01000000 58200000
 # CONTENTS:  402010 00300000 20000000
-# ptr: pointing at the IAT RVA at 0x2048
+# ptr: pointing at the IAT RVA at 0x2058
 # relocs: pointing at the runtime pseudo reloc list at
 # 0x2000 - 0x2018.
 # CONTENTS: Contents of section .data:
-# CONTENTS:  403000 48204000 00204000 18204000
+# CONTENTS:  403000 58204000 00204000 18204000
 
     .global main
     .text
     .thumb
 main:
     bx lr
     .data
 ptr:
     .long variable
 relocs:
     .long __RUNTIME_PSEUDO_RELOC_LIST__
     .long __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/autoimport-arm64-data.s

 # REQUIRES: aarch64
 
 # RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.text\nDllMainCRTStartup:\nret\n.data\nvariable:\n.long 42" > %t-lib.s
 # RUN: llvm-mc -triple=aarch64-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
 # RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
 
 # RUN: llvm-mc -triple=aarch64-windows-gnu %s -filetype=obj -o %t.obj
 # RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib -verbose
 
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
 
 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-arm64-data.s.tmp-lib.dll
-# IMPORTS-NEXT: ImportLookupTableRVA: 0x2040
-# IMPORTS-NEXT: ImportAddressTableRVA: 0x2050
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x2060
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x2070
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
-# First runtime pseudo reloc, with import from 0x2050,
+# First runtime pseudo reloc, with import from 0x2070,
 # applied at 0x3000, with a size of 32 bits.
 # CONTENTS: Contents of section .rdata:
-# CONTENTS:  140002000 00000000 00000000 01000000 50200000
+# CONTENTS:  140002000 00000000 00000000 01000000 70200000
 # CONTENTS:  140002010 00300000 40000000
-# ptr: pointing at the IAT RVA at 0x2050
+# ptr: pointing at the IAT RVA at 0x2070
 # relocs: pointing at the runtime pseudo reloc list at
 # 0x2000 - 0x2018.
 # CONTENTS: Contents of section .data:
-# CONTENTS:  140003000 50200040 01000000 00200040 01000000
+# CONTENTS:  140003000 70200040 01000000 00200040 01000000
 # CONTENTS:  140003010 18200040 01000000
 
     .global main
     .text
 main:
     ret
     .data
 ptr:
     .quad variable
 relocs:
     .quad __RUNTIME_PSEUDO_RELOC_LIST__
     .quad __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/autoimport-list-ptrs.s

 # REQUIRES: x86
 
 # 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 -verbose
 
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
 
 # Even if we didn't actually write any pseudo relocations,
 # check that the synthetic pointers still are set to a non-null value
 # CONTENTS: Contents of section .data:
-# CONTENTS:  140002000 00200040 01000000 00200040 01000000
+# CONTENTS:  140003000 00200040 01000000 00200040 01000000
 
     .global main
     .text
 main:
     retq
     .data
 relocs:
     .quad __RUNTIME_PSEUDO_RELOC_LIST__
     .quad __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/autoimport-refptr.s

 # REQUIRES: x86
 
 # RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.text\nDllMainCRTStartup:\nret\n.data\nvariable:\n.long 42" > %t-lib.s
 # RUN: llvm-mc -triple=x86_64-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
 # RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
 
 # 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-lib.lib -verbose
 
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=DISASM %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
 
 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-refptr.s.tmp-lib.dll
-# IMPORTS-NEXT: ImportLookupTableRVA: 0x2030
-# IMPORTS-NEXT: ImportAddressTableRVA: 0x2040
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x2050
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x2060
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # DISASM: Disassembly of section .text:
 # DISASM: .text:
-# Relative offset at 0x1002 pointing at the IAT at 0x2040
-# DISASM: 140001000:      48 8b 05 39 10 00 00    movq    4153(%rip), %rax
+# Relative offset at 0x1002 pointing at the IAT at 0x2060
+# DISASM: 140001000:      48 8b 05 59 10 00 00    movq    4185(%rip), %rax
 # DISASM: 140001007:      8b 00   movl    (%rax), %eax
 # Relative offset at 0x100b pointing at the .refptr.localvar stub at
 # 0x2000
 # DISASM: 140001009:      48 8b 0d f0 0f 00 00    movq    4080(%rip), %rcx
 # DISASM: 140001010:      03 01   addl    (%rcx), %eax
 # DISASM: 140001012:      c3      retq
 
 # relocs: pointing at an empty list of runtime pseudo relocs.

lld/trunk/test/COFF/autoimport-x86.s

 # REQUIRES: x86
 
 # RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.text\nDllMainCRTStartup:\nret\n.data\nvariable:\n.long 42" > %t-lib.s
 # RUN: llvm-mc -triple=x86_64-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
 # RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
 
 # 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-lib.lib -verbose
 
 # RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=DISASM %s
 # RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
 
 # IMPORTS: Import {
 # IMPORTS-NEXT: Name: autoimport-x86.s.tmp-lib.dll
-# IMPORTS-NEXT: ImportLookupTableRVA: 0x2050
-# IMPORTS-NEXT: ImportAddressTableRVA: 0x2060
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x2070
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x2080
 # IMPORTS-NEXT: Symbol: variable (0)
 # IMPORTS-NEXT: }
 
 # DISASM: Disassembly of section .text:
 # DISASM: .text:
-# Relative offset at 0x1002 pointing at the IAT at 0x2060.
-# DISASM: 140001000:      8b 05 5a 10 00 00       movl    4186(%rip), %eax
+# Relative offset at 0x1002 pointing at the IAT at 0x2080.
+# DISASM: 140001000:      8b 05 7a 10 00 00       movl    4218(%rip), %eax
 # DISASM: 140001006:      c3      retq
 
 # Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
-# First runtime pseudo reloc, with import from 0x2060,
+# First runtime pseudo reloc, with import from 0x2080,
 # applied at 0x1002, with a size of 32 bits.
-# Second runtime pseudo reloc, with import from 0x2060,
+# Second runtime pseudo reloc, with import from 0x2080,
 # applied at 0x3000, with a size of 64 bits.
 # CONTENTS: Contents of section .rdata:
-# CONTENTS:  140002000 00000000 00000000 01000000 60200000
-# CONTENTS:  140002010 02100000 20000000 60200000 00300000
+# CONTENTS:  140002000 00000000 00000000 01000000 80200000
+# CONTENTS:  140002010 02100000 20000000 80200000 00300000
 # CONTENTS:  140002020 40000000
-# ptr: pointing at the IAT RVA at 0x2060
+# ptr: pointing at the IAT RVA at 0x2080
 # relocs: pointing at the runtime pseudo reloc list at
 # 0x2000 - 0x2024.
 # CONTENTS: Contents of section .data:
-# CONTENTS:  140003000 60200040 01000000 00200040 01000000
+# CONTENTS:  140003000 80200040 01000000 00200040 01000000
 # CONTENTS:  140003010 24200040 01000000
 
     .global main
     .text
 main:
     movl variable(%rip), %eax
     ret
     .data
 ptr:
     .quad variable
 relocs:
     .quad __RUNTIME_PSEUDO_RELOC_LIST__
     .quad __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/common-replacement.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -triple=x86_64-windows-gnu %s -filetype=obj -o %t1.obj
 # RUN: llvm-mc -triple=x86_64-windows-gnu %S/Inputs/common-replacement.s -filetype=obj -o %t2.obj
 
 # RUN: lld-link -lldmingw -entry:main %t1.obj %t2.obj -out:%t.exe -verbose 2>&1 \
 # RUN:   | FileCheck -check-prefix VERBOSE %s
 # RUN: llvm-readobj -s %t.exe | FileCheck -check-prefix SECTIONS %s
 
 # VERBOSE: -aligncomm:"foo",2
 
 # As long as the .comm symbol is replaced with actual data, RawDataSize
 # below should be nonzero.
 
 # SECTIONS:         Name: .data (2E 64 61 74 61 00 00 00)
 # SECTIONS-NEXT:    VirtualSize: 0x8
-# SECTIONS-NEXT:    VirtualAddress: 0x2000
+# SECTIONS-NEXT:    VirtualAddress: 0x3000
 # SECTIONS-NEXT:    RawDataSize: 512
 
 
         .text
         .def            main;
         .scl            2;
         .type           32;
         .endef

lld/trunk/test/COFF/ctors_dtors_priority.s

 # REQUIRES: x86
 # RUN: llvm-mc -triple=x86_64-windows-gnu -filetype=obj -o %t.obj %s
 # RUN: lld-link -lldmingw -entry:main %t.obj -out:%t.exe
 # RUN: llvm-objdump -s %t.exe | FileCheck %s
 
 .globl main
 main:
   nop
 
+# Check that these symbols point at the right spots.
+.data
+  .quad __CTOR_LIST__
+  .quad __DTOR_LIST__
+
 .section .ctors.00005, "w"
   .quad 2
 .section .ctors, "w"
   .quad 1
 .section .ctors.00100, "w"
   .quad 3
 
 .section .dtors, "w"
   .quad 4
 .section .dtors.00100, "w"
   .quad 6
 .section .dtors.00005, "w"
   .quad 5
 
 # Also test that the .CRT section is merged into .rdata
 
 .section .CRT$XCA, "dw"
   .quad 7
   .quad 8
 
 # CHECK:      Contents of section .rdata:
 # CHECK-NEXT: 140002000 07000000 00000000 08000000 00000000
-# CHECK-NEXT: 140002010 01000000 00000000 02000000 00000000
-# CHECK-NEXT: 140002020 03000000 00000000 04000000 00000000
-# CHECK-NEXT: 140002030 05000000 00000000 06000000 00000000
+# CHECK-NEXT: 140002010 ffffffff ffffffff 01000000 00000000
+# CHECK-NEXT: 140002020 02000000 00000000 03000000 00000000
+# CHECK-NEXT: 140002030 00000000 00000000 ffffffff ffffffff
+# CHECK-NEXT: 140002040 04000000 00000000 05000000 00000000
+# CHECK-NEXT: 140002050 06000000 00000000 00000000 00000000
+# __CTOR_LIST__ pointing at 0x140002010 and
+# __DTOR_LIST__ pointing at 0x140002038.
+# CHECK-NEXT: Contents of section .data:
+# CHECK-NEXT: 140003000 10200040 01000000 38200040 01000000

lld/trunk/test/COFF/debug-reloc.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -triple=x86_64-windows-gnu %s -filetype=obj -o %t.obj
 
 # RUN: lld-link -lldmingw -debug:dwarf -out:%t.exe -entry:mainfunc -subsystem:console %t.obj
 # RUN: llvm-readobj -sections %t.exe | FileCheck %s -check-prefix SECTIONS
 # RUN: llvm-readobj -coff-basereloc %t.exe | FileCheck %s -check-prefix RELOCS
 # RUN: llvm-readobj -file-headers %t.exe | FileCheck %s -check-prefix HEADERS
 # RUN: llvm-readobj -coff-debug-directory %t.exe | FileCheck %s -check-prefix DEBUG
 
-# SECTIONS:         Number: 2
+# SECTIONS:         Number: 3
 # SECTIONS-NEXT:    Name: .buildid (2E 62 75 69 6C 64 69 64)
 # SECTIONS-NEXT:    VirtualSize: 0x35
-# SECTIONS-NEXT:    VirtualAddress: 0x2000
-# SECTIONS:         Number: 3
+# SECTIONS-NEXT:    VirtualAddress: 0x3000
+# SECTIONS:         Number: 4
 # SECTIONS-NEXT:    Name: .data (2E 64 61 74 61 00 00 00)
 # SECTIONS-NEXT:    VirtualSize: 0x8
-# SECTIONS-NEXT:    VirtualAddress: 0x3000
+# SECTIONS-NEXT:    VirtualAddress: 0x4000
 
 # RELOCS:      BaseReloc [
 # RELOCS-NEXT:   Entry {
 # RELOCS-NEXT:     Type: DIR64
-# RELOCS-NEXT:     Address: 0x3000
+# RELOCS-NEXT:     Address: 0x4000
 # RELOCS-NEXT:   }
 # RELOCS-NEXT:   Entry {
 # RELOCS-NEXT:     Type: ABSOLUTE
-# RELOCS-NEXT:     Address: 0x3000
+# RELOCS-NEXT:     Address: 0x4000
 # RELOCS-NEXT:   }
 # RELOCS-NEXT: ]
 
-# HEADERS:     DebugRVA: 0x2000
+# HEADERS:     DebugRVA: 0x3000
 # HEADERS:     DebugSize: 0x1C
 
 # DEBUG: DebugDirectory [
 # DEBUG:   DebugEntry {
 # DEBUG:     Type: CodeView (0x2)
 # DEBUG:     SizeOfData: 0x19
-# DEBUG:     AddressOfRawData: 0x201C
-# DEBUG:     PointerToRawData: 0x61C
+# DEBUG:     AddressOfRawData: 0x301C
+# DEBUG:     PointerToRawData: 0x81C
 
   .text
   .def   mainfunc;
   .scl  2;
   .type 32;
   .endef
   .globl  mainfunc
 mainfunc: