1 //===- Writer.cpp ---------------------------------------------------------===//
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
13 #include "InputFiles.h"
16 #include "SymbolTable.h"
18 #include "lld/Common/ErrorHandler.h"
19 #include "lld/Common/Memory.h"
20 #include "lld/Common/Timer.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/STLExtras.h"
23 #include "llvm/ADT/StringSwitch.h"
24 #include "llvm/Support/BinaryStreamReader.h"
25 #include "llvm/Support/Debug.h"
26 #include "llvm/Support/Endian.h"
27 #include "llvm/Support/FileOutputBuffer.h"
28 #include "llvm/Support/Parallel.h"
29 #include "llvm/Support/Path.h"
30 #include "llvm/Support/RandomNumberGenerator.h"
31 #include "llvm/Support/xxhash.h"
39 using namespace llvm::COFF;
40 using namespace llvm::object;
41 using namespace llvm::support;
42 using namespace llvm::support::endian;
44 using namespace lld::coff;
46 /* To re-generate DOSProgram:
47 $ cat > /tmp/DOSProgram.asm
52 ; Point ds:dx at the $-terminated string.
54 ; Int 21/AH=09h: Write string to standard output.
57 ; Int 21/AH=4Ch: Exit with return code (in AL).
61 db 'This program cannot be run in DOS mode.$'
63 $ nasm -fbin /tmp/DOSProgram.asm -o /tmp/DOSProgram.bin
64 $ xxd -i /tmp/DOSProgram.bin
66 static unsigned char DOSProgram[] = {
67 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c,
68 0xcd, 0x21, 0x54, 0x68, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72,
69 0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65,
70 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
71 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x24, 0x00, 0x00
73 static_assert(sizeof(DOSProgram) % 8 == 0,
74 "DOSProgram size must be multiple of 8");
76 static const int SectorSize = 512;
77 static const int DOSStubSize = sizeof(dos_header) + sizeof(DOSProgram);
78 static_assert(DOSStubSize % 8 == 0, "DOSStub size must be multiple of 8");
80 static const int NumberOfDataDirectory = 16;
84 class DebugDirectoryChunk : public Chunk {
86 DebugDirectoryChunk(const std::vector<Chunk *> &R, bool WriteRepro)
87 : Records(R), WriteRepro(WriteRepro) {}
89 size_t getSize() const override {
90 return (Records.size() + int(WriteRepro)) * sizeof(debug_directory);
93 void writeTo(uint8_t *B) const override {
94 auto *D = reinterpret_cast<debug_directory *>(B + OutputSectionOff);
96 for (const Chunk *Record : Records) {
97 OutputSection *OS = Record->getOutputSection();
98 uint64_t Offs = OS->getFileOff() + (Record->getRVA() - OS->getRVA());
99 fillEntry(D, COFF::IMAGE_DEBUG_TYPE_CODEVIEW, Record->getSize(),
100 Record->getRVA(), Offs);
105 // FIXME: The COFF spec allows either a 0-sized entry to just say
106 // "the timestamp field is really a hash", or a 4-byte size field
107 // followed by that many bytes containing a longer hash (with the
108 // lowest 4 bytes usually being the timestamp in little-endian order).
109 // Consider storing the full 8 bytes computed by xxHash64 here.
110 fillEntry(D, COFF::IMAGE_DEBUG_TYPE_REPRO, 0, 0, 0);
114 void setTimeDateStamp(uint32_t TimeDateStamp) {
115 for (support::ulittle32_t *TDS : TimeDateStamps)
116 *TDS = TimeDateStamp;
120 void fillEntry(debug_directory *D, COFF::DebugType DebugType, size_t Size,
121 uint64_t RVA, uint64_t Offs) const {
122 D->Characteristics = 0;
123 D->TimeDateStamp = 0;
127 D->SizeOfData = Size;
128 D->AddressOfRawData = RVA;
129 D->PointerToRawData = Offs;
131 TimeDateStamps.push_back(&D->TimeDateStamp);
134 mutable std::vector<support::ulittle32_t *> TimeDateStamps;
135 const std::vector<Chunk *> &Records;
139 class CVDebugRecordChunk : public Chunk {
141 size_t getSize() const override {
142 return sizeof(codeview::DebugInfo) + Config->PDBAltPath.size() + 1;
145 void writeTo(uint8_t *B) const override {
146 // Save off the DebugInfo entry to backfill the file signature (build id)
147 // in Writer::writeBuildId
148 BuildId = reinterpret_cast<codeview::DebugInfo *>(B + OutputSectionOff);
150 // variable sized field (PDB Path)
151 char *P = reinterpret_cast<char *>(B + OutputSectionOff + sizeof(*BuildId));
152 if (!Config->PDBAltPath.empty())
153 memcpy(P, Config->PDBAltPath.data(), Config->PDBAltPath.size());
154 P[Config->PDBAltPath.size()] = '\0';
157 mutable codeview::DebugInfo *BuildId = nullptr;
160 // The writer writes a SymbolTable result to a file.
163 Writer() : Buffer(errorHandler().OutputBuffer) {}
167 void createSections();
168 void createMiscChunks();
169 void createImportTables();
170 void appendImportThunks();
171 void locateImportTables(
172 std::map<std::pair<StringRef, uint32_t>, std::vector<Chunk *>> &Map);
173 void createExportTable();
174 void mergeSections();
175 void readRelocTargets();
176 void removeUnusedSections();
177 void assignAddresses();
178 void finalizeAddresses();
179 void removeEmptySections();
180 void createSymbolAndStringTable();
181 void openFile(StringRef OutputPath);
182 template <typename PEHeaderTy> void writeHeader();
183 void createSEHTable();
184 void createRuntimePseudoRelocs();
185 void insertCtorDtorSymbols();
186 void createGuardCFTables();
187 void markSymbolsForRVATable(ObjFile *File,
188 ArrayRef<SectionChunk *> SymIdxChunks,
189 SymbolRVASet &TableSymbols);
190 void maybeAddRVATable(SymbolRVASet TableSymbols, StringRef TableSym,
192 void setSectionPermissions();
193 void writeSections();
195 void sortExceptionTable();
196 void sortCRTSectionChunks(std::vector<Chunk *> &Chunks);
198 llvm::Optional<coff_symbol16> createSymbol(Defined *D);
199 size_t addEntryToStringTable(StringRef Str);
201 OutputSection *findSection(StringRef Name);
203 void addBaserelBlocks(std::vector<Baserel> &V);
205 uint32_t getSizeOfInitializedData();
206 std::map<StringRef, std::vector<DefinedImportData *>> binImports();
208 std::unique_ptr<FileOutputBuffer> &Buffer;
209 std::vector<OutputSection *> OutputSections;
210 std::vector<char> Strtab;
211 std::vector<llvm::object::coff_symbol16> OutputSymtab;
213 Chunk *ImportTableStart = nullptr;
214 uint64_t ImportTableSize = 0;
215 Chunk *IATStart = nullptr;
216 uint64_t IATSize = 0;
217 DelayLoadContents DelayIdata;
219 bool SetNoSEHCharacteristic = false;
221 DebugDirectoryChunk *DebugDirectory = nullptr;
222 std::vector<Chunk *> DebugRecords;
223 CVDebugRecordChunk *BuildId = nullptr;
224 ArrayRef<uint8_t> SectionTable;
227 uint32_t PointerToSymbolTable = 0;
228 uint64_t SizeOfImage;
229 uint64_t SizeOfHeaders;
231 OutputSection *TextSec;
232 OutputSection *RdataSec;
233 OutputSection *BuildidSec;
234 OutputSection *DataSec;
235 OutputSection *PdataSec;
236 OutputSection *IdataSec;
237 OutputSection *EdataSec;
238 OutputSection *DidatSec;
239 OutputSection *RsrcSec;
240 OutputSection *RelocSec;
241 OutputSection *CtorsSec;
242 OutputSection *DtorsSec;
244 // The first and last .pdata sections in the output file.
246 // We need to keep track of the location of .pdata in whichever section it
247 // gets merged into so that we can sort its contents and emit a correct data
248 // directory entry for the exception table. This is also the case for some
249 // other sections (such as .edata) but because the contents of those sections
250 // are entirely linker-generated we can keep track of their locations using
251 // the chunks that the linker creates. All .pdata chunks come from input
252 // files, so we need to keep track of them separately.
253 Chunk *FirstPdata = nullptr;
256 } // anonymous namespace
261 static Timer CodeLayoutTimer("Code Layout", Timer::root());
262 static Timer DiskCommitTimer("Commit Output File", Timer::root());
264 void writeResult() { Writer().run(); }
266 void OutputSection::addChunk(Chunk *C) {
268 C->setOutputSection(this);
271 void OutputSection::insertChunkAtStart(Chunk *C) {
272 Chunks.insert(Chunks.begin(), C);
273 C->setOutputSection(this);
276 void OutputSection::setPermissions(uint32_t C) {
277 Header.Characteristics &= ~PermMask;
278 Header.Characteristics |= C;
281 void OutputSection::merge(OutputSection *Other) {
282 for (Chunk *C : Other->Chunks)
283 C->setOutputSection(this);
284 Chunks.insert(Chunks.end(), Other->Chunks.begin(), Other->Chunks.end());
285 Other->Chunks.clear();
288 // Write the section header to a given buffer.
289 void OutputSection::writeHeaderTo(uint8_t *Buf) {
290 auto *Hdr = reinterpret_cast<coff_section *>(Buf);
292 if (StringTableOff) {
293 // If name is too long, write offset into the string table as a name.
294 sprintf(Hdr->Name, "/%d", StringTableOff);
296 assert(!Config->Debug || Name.size() <= COFF::NameSize ||
297 (Hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0);
298 strncpy(Hdr->Name, Name.data(),
299 std::min(Name.size(), (size_t)COFF::NameSize));
306 // Check whether the target address S is in range from a relocation
307 // of type RelType at address P.
308 static bool isInRange(uint16_t RelType, uint64_t S, uint64_t P, int Margin) {
309 assert(Config->Machine == ARMNT);
310 int64_t Diff = AbsoluteDifference(S, P + 4) + Margin;
312 case IMAGE_REL_ARM_BRANCH20T:
313 return isInt<21>(Diff);
314 case IMAGE_REL_ARM_BRANCH24T:
315 case IMAGE_REL_ARM_BLX23T:
316 return isInt<25>(Diff);
322 // Return the last thunk for the given target if it is in range,
323 // or create a new one.
324 static std::pair<Defined *, bool>
325 getThunk(DenseMap<uint64_t, Defined *> &LastThunks, Defined *Target, uint64_t P,
326 uint16_t Type, int Margin) {
327 Defined *&LastThunk = LastThunks[Target->getRVA()];
328 if (LastThunk && isInRange(Type, LastThunk->getRVA(), P, Margin))
329 return {LastThunk, false};
330 RangeExtensionThunk *C = make<RangeExtensionThunk>(Target);
331 Defined *D = make<DefinedSynthetic>("", C);
336 // This checks all relocations, and for any relocation which isn't in range
337 // it adds a thunk after the section chunk that contains the relocation.
338 // If the latest thunk for the specific target is in range, that is used
339 // instead of creating a new thunk. All range checks are done with the
340 // specified margin, to make sure that relocations that originally are in
341 // range, but only barely, also get thunks - in case other added thunks makes
342 // the target go out of range.
344 // After adding thunks, we verify that all relocations are in range (with
345 // no extra margin requirements). If this failed, we restart (throwing away
346 // the previously created thunks) and retry with a wider margin.
347 static bool createThunks(std::vector<Chunk *> &Chunks, int Margin) {
348 bool AddressesChanged = false;
349 DenseMap<uint64_t, Defined *> LastThunks;
350 size_t ThunksSize = 0;
351 // Recheck Chunks.size() each iteration, since we can insert more
353 for (size_t I = 0; I != Chunks.size(); ++I) {
354 SectionChunk *SC = dyn_cast_or_null<SectionChunk>(Chunks[I]);
357 size_t ThunkInsertionSpot = I + 1;
359 // Try to get a good enough estimate of where new thunks will be placed.
360 // Offset this by the size of the new thunks added so far, to make the
361 // estimate slightly better.
362 size_t ThunkInsertionRVA = SC->getRVA() + SC->getSize() + ThunksSize;
363 for (size_t J = 0, E = SC->Relocs.size(); J < E; ++J) {
364 const coff_relocation &Rel = SC->Relocs[J];
365 Symbol *&RelocTarget = SC->RelocTargets[J];
367 // The estimate of the source address P should be pretty accurate,
368 // but we don't know whether the target Symbol address should be
369 // offset by ThunkSize or not (or by some of ThunksSize but not all of
370 // it), giving us some uncertainty once we have added one thunk.
371 uint64_t P = SC->getRVA() + Rel.VirtualAddress + ThunksSize;
373 Defined *Sym = dyn_cast_or_null<Defined>(RelocTarget);
377 uint64_t S = Sym->getRVA();
379 if (isInRange(Rel.Type, S, P, Margin))
382 // If the target isn't in range, hook it up to an existing or new
386 std::tie(Thunk, WasNew) = getThunk(LastThunks, Sym, P, Rel.Type, Margin);
388 Chunk *ThunkChunk = Thunk->getChunk();
390 ThunkInsertionRVA); // Estimate of where it will be located.
391 Chunks.insert(Chunks.begin() + ThunkInsertionSpot, ThunkChunk);
392 ThunkInsertionSpot++;
393 ThunksSize += ThunkChunk->getSize();
394 ThunkInsertionRVA += ThunkChunk->getSize();
395 AddressesChanged = true;
400 return AddressesChanged;
403 // Verify that all relocations are in range, with no extra margin requirements.
404 static bool verifyRanges(const std::vector<Chunk *> Chunks) {
405 for (Chunk *C : Chunks) {
406 SectionChunk *SC = dyn_cast_or_null<SectionChunk>(C);
410 for (size_t J = 0, E = SC->Relocs.size(); J < E; ++J) {
411 const coff_relocation &Rel = SC->Relocs[J];
412 Symbol *RelocTarget = SC->RelocTargets[J];
414 Defined *Sym = dyn_cast_or_null<Defined>(RelocTarget);
418 uint64_t P = SC->getRVA() + Rel.VirtualAddress;
419 uint64_t S = Sym->getRVA();
421 if (!isInRange(Rel.Type, S, P, 0))
428 // Assign addresses and add thunks if necessary.
429 void Writer::finalizeAddresses() {
431 if (Config->Machine != ARMNT)
434 size_t OrigNumChunks = 0;
435 for (OutputSection *Sec : OutputSections) {
436 Sec->OrigChunks = Sec->Chunks;
437 OrigNumChunks += Sec->Chunks.size();
441 int Margin = 1024 * 100;
443 // First check whether we need thunks at all, or if the previous pass of
444 // adding them turned out ok.
445 bool RangesOk = true;
446 size_t NumChunks = 0;
447 for (OutputSection *Sec : OutputSections) {
448 if (!verifyRanges(Sec->Chunks)) {
452 NumChunks += Sec->Chunks.size();
456 log("Added " + Twine(NumChunks - OrigNumChunks) + " thunks with " +
457 "margin " + Twine(Margin) + " in " + Twine(Pass) + " passes");
462 fatal("adding thunks hasn't converged after " + Twine(Pass) + " passes");
465 // If the previous pass didn't work out, reset everything back to the
466 // original conditions before retrying with a wider margin. This should
467 // ideally never happen under real circumstances.
468 for (OutputSection *Sec : OutputSections) {
469 Sec->Chunks = Sec->OrigChunks;
470 for (Chunk *C : Sec->Chunks)
471 C->resetRelocTargets();
476 // Try adding thunks everywhere where it is needed, with a margin
477 // to avoid things going out of range due to the added thunks.
478 bool AddressesChanged = false;
479 for (OutputSection *Sec : OutputSections)
480 AddressesChanged |= createThunks(Sec->Chunks, Margin);
481 // If the verification above thought we needed thunks, we should have
483 assert(AddressesChanged);
485 // Recalculate the layout for the whole image (and verify the ranges at
486 // the start of the next round).
493 // The main function of the writer.
495 ScopedTimer T1(CodeLayoutTimer);
497 createImportTables();
500 appendImportThunks();
504 removeUnusedSections();
506 removeEmptySections();
507 setSectionPermissions();
508 createSymbolAndStringTable();
510 if (FileSize > UINT32_MAX)
511 fatal("image size (" + Twine(FileSize) + ") " +
512 "exceeds maximum allowable size (" + Twine(UINT32_MAX) + ")");
514 openFile(Config->OutputFile);
515 if (Config->is64()) {
516 writeHeader<pe32plus_header>();
518 writeHeader<pe32_header>();
521 sortExceptionTable();
525 if (!Config->PDBPath.empty() && Config->Debug) {
527 createPDB(Symtab, OutputSections, SectionTable, BuildId->BuildId);
531 writeMapFile(OutputSections);
533 ScopedTimer T2(DiskCommitTimer);
534 if (auto E = Buffer->commit())
535 fatal("failed to write the output file: " + toString(std::move(E)));
538 static StringRef getOutputSectionName(StringRef Name) {
539 StringRef S = Name.split('$').first;
541 // Treat a later period as a separator for MinGW, for sections like
543 return S.substr(0, S.find('.', 1));
547 static void sortBySectionOrder(std::vector<Chunk *> &Chunks) {
548 auto GetPriority = [](const Chunk *C) {
549 if (auto *Sec = dyn_cast<SectionChunk>(C))
551 return Config->Order.lookup(Sec->Sym->getName());
555 std::stable_sort(Chunks.begin(), Chunks.end(),
556 [=](const Chunk *A, const Chunk *B) {
557 return GetPriority(A) < GetPriority(B);
561 // Sort concrete section chunks from GNU import libraries.
563 // GNU binutils doesn't use short import files, but instead produces import
564 // libraries that consist of object files, with section chunks for the .idata$*
565 // sections. These are linked just as regular static libraries. Each import
566 // library consists of one header object, one object file for every imported
567 // symbol, and one trailer object. In order for the .idata tables/lists to
568 // be formed correctly, the section chunks within each .idata$* section need
569 // to be grouped by library, and sorted alphabetically within each library
570 // (which makes sure the header comes first and the trailer last).
571 static bool fixGnuImportChunks(
572 std::map<std::pair<StringRef, uint32_t>, std::vector<Chunk *>> &Map) {
573 uint32_t RDATA = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
575 // Make sure all .idata$* section chunks are mapped as RDATA in order to
576 // be sorted into the same sections as our own synthesized .idata chunks.
577 for (auto &Pair : Map) {
578 StringRef SectionName = Pair.first.first;
579 uint32_t OutChars = Pair.first.second;
580 if (!SectionName.startswith(".idata"))
582 if (OutChars == RDATA)
584 std::vector<Chunk *> &SrcVect = Pair.second;
585 std::vector<Chunk *> &DestVect = Map[{SectionName, RDATA}];
586 DestVect.insert(DestVect.end(), SrcVect.begin(), SrcVect.end());
590 bool HasIdata = false;
591 // Sort all .idata$* chunks, grouping chunks from the same library,
592 // with alphabetical ordering of the object fils within a library.
593 for (auto &Pair : Map) {
594 StringRef SectionName = Pair.first.first;
595 if (!SectionName.startswith(".idata"))
598 std::vector<Chunk *> &Chunks = Pair.second;
601 std::stable_sort(Chunks.begin(), Chunks.end(), [&](Chunk *S, Chunk *T) {
602 SectionChunk *SC1 = dyn_cast_or_null<SectionChunk>(S);
603 SectionChunk *SC2 = dyn_cast_or_null<SectionChunk>(T);
605 // if SC1, order them ascending. If SC2 or both null,
606 // S is not less than T.
607 return SC1 != nullptr;
609 // Make a string with "libraryname/objectfile" for sorting, achieving
610 // both grouping by library and sorting of objects within a library,
613 (SC1->File->ParentName + "/" + SC1->File->getName()).str();
615 (SC2->File->ParentName + "/" + SC2->File->getName()).str();
622 // Add generated idata chunks, for imported symbols and DLLs, and a
623 // terminator in .idata$2.
624 static void addSyntheticIdata(
625 IdataContents &Idata,
626 std::map<std::pair<StringRef, uint32_t>, std::vector<Chunk *>> &Map) {
627 uint32_t RDATA = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
630 // Add the .idata content in the right section groups, to allow
631 // chunks from other linked in object files to be grouped together.
632 // See Microsoft PE/COFF spec 5.4 for details.
633 auto Add = [&](StringRef N, std::vector<Chunk *> &V) {
634 std::vector<Chunk *> &DestVect = Map[{N, RDATA}];
635 DestVect.insert(DestVect.end(), V.begin(), V.end());
638 // The loader assumes a specific order of data.
639 // Add each type in the correct order.
640 Add(".idata$2", Idata.Dirs);
641 Add(".idata$4", Idata.Lookups);
642 Add(".idata$5", Idata.Addresses);
643 Add(".idata$6", Idata.Hints);
644 Add(".idata$7", Idata.DLLNames);
647 // Locate the first Chunk and size of the import directory list and the
649 void Writer::locateImportTables(
650 std::map<std::pair<StringRef, uint32_t>, std::vector<Chunk *>> &Map) {
651 uint32_t RDATA = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
652 std::vector<Chunk *> &ImportTables = Map[{".idata$2", RDATA}];
653 if (!ImportTables.empty())
654 ImportTableStart = ImportTables.front();
655 for (Chunk *C : ImportTables)
656 ImportTableSize += C->getSize();
658 std::vector<Chunk *> &IAT = Map[{".idata$5", RDATA}];
660 IATStart = IAT.front();
662 IATSize += C->getSize();
665 // Create output section objects and add them to OutputSections.
666 void Writer::createSections() {
667 // First, create the builtin sections.
668 const uint32_t DATA = IMAGE_SCN_CNT_INITIALIZED_DATA;
669 const uint32_t BSS = IMAGE_SCN_CNT_UNINITIALIZED_DATA;
670 const uint32_t CODE = IMAGE_SCN_CNT_CODE;
671 const uint32_t DISCARDABLE = IMAGE_SCN_MEM_DISCARDABLE;
672 const uint32_t R = IMAGE_SCN_MEM_READ;
673 const uint32_t W = IMAGE_SCN_MEM_WRITE;
674 const uint32_t X = IMAGE_SCN_MEM_EXECUTE;
676 SmallDenseMap<std::pair<StringRef, uint32_t>, OutputSection *> Sections;
677 auto CreateSection = [&](StringRef Name, uint32_t OutChars) {
678 OutputSection *&Sec = Sections[{Name, OutChars}];
680 Sec = make<OutputSection>(Name, OutChars);
681 OutputSections.push_back(Sec);
686 // Try to match the section order used by link.exe.
687 TextSec = CreateSection(".text", CODE | R | X);
688 CreateSection(".bss", BSS | R | W);
689 RdataSec = CreateSection(".rdata", DATA | R);
690 BuildidSec = CreateSection(".buildid", DATA | R);
691 DataSec = CreateSection(".data", DATA | R | W);
692 PdataSec = CreateSection(".pdata", DATA | R);
693 IdataSec = CreateSection(".idata", DATA | R);
694 EdataSec = CreateSection(".edata", DATA | R);
695 DidatSec = CreateSection(".didat", DATA | R);
696 RsrcSec = CreateSection(".rsrc", DATA | R);
697 RelocSec = CreateSection(".reloc", DATA | DISCARDABLE | R);
698 CtorsSec = CreateSection(".ctors", DATA | R | W);
699 DtorsSec = CreateSection(".dtors", DATA | R | W);
701 // Then bin chunks by name and output characteristics.
702 std::map<std::pair<StringRef, uint32_t>, std::vector<Chunk *>> Map;
703 for (Chunk *C : Symtab->getChunks()) {
704 auto *SC = dyn_cast<SectionChunk>(C);
705 if (SC && !SC->Live) {
707 SC->printDiscardedMessage();
710 Map[{C->getSectionName(), C->getOutputCharacteristics()}].push_back(C);
713 // Even in non MinGW cases, we might need to link against GNU import
715 bool HasIdata = fixGnuImportChunks(Map);
720 addSyntheticIdata(Idata, Map);
722 // Process an /order option.
723 if (!Config->Order.empty())
724 for (auto &Pair : Map)
725 sortBySectionOrder(Pair.second);
728 locateImportTables(Map);
730 // Then create an OutputSection for each section.
731 // '$' and all following characters in input section names are
732 // discarded when determining output section. So, .text$foo
733 // contributes to .text, for example. See PE/COFF spec 3.2.
734 for (auto &Pair : Map) {
735 StringRef Name = getOutputSectionName(Pair.first.first);
736 uint32_t OutChars = Pair.first.second;
738 if (Name == ".CRT") {
739 // In link.exe, there is a special case for the I386 target where .CRT
740 // sections are treated as if they have output characteristics DATA | R if
741 // their characteristics are DATA | R | W. This implements the same
742 // special case for all architectures.
745 log("Processing section " + Pair.first.first + " -> " + Name);
747 sortCRTSectionChunks(Pair.second);
750 OutputSection *Sec = CreateSection(Name, OutChars);
751 std::vector<Chunk *> &Chunks = Pair.second;
752 for (Chunk *C : Chunks)
756 // Finally, move some output sections to the end.
757 auto SectionOrder = [&](OutputSection *S) {
758 // Move DISCARDABLE (or non-memory-mapped) sections to the end of file because
759 // the loader cannot handle holes. Stripping can remove other discardable ones
760 // than .reloc, which is first of them (created early).
761 if (S->Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
763 // .rsrc should come at the end of the non-discardable sections because its
764 // size may change by the Win32 UpdateResources() function, causing
765 // subsequent sections to move (see https://crbug.com/827082).
770 std::stable_sort(OutputSections.begin(), OutputSections.end(),
771 [&](OutputSection *S, OutputSection *T) {
772 return SectionOrder(S) < SectionOrder(T);
776 void Writer::createMiscChunks() {
777 for (auto &P : MergeChunk::Instances)
778 RdataSec->addChunk(P.second);
780 // Create thunks for locally-dllimported symbols.
781 if (!Symtab->LocalImportChunks.empty()) {
782 for (Chunk *C : Symtab->LocalImportChunks)
783 RdataSec->addChunk(C);
786 // Create Debug Information Chunks
787 OutputSection *DebugInfoSec = Config->MinGW ? BuildidSec : RdataSec;
788 if (Config->Debug || Config->Repro) {
789 DebugDirectory = make<DebugDirectoryChunk>(DebugRecords, Config->Repro);
790 DebugInfoSec->addChunk(DebugDirectory);
794 // Make a CVDebugRecordChunk even when /DEBUG:CV is not specified. We
795 // output a PDB no matter what, and this chunk provides the only means of
796 // allowing a debugger to match a PDB and an executable. So we need it even
797 // if we're ultimately not going to write CodeView data to the PDB.
798 BuildId = make<CVDebugRecordChunk>();
799 DebugRecords.push_back(BuildId);
801 for (Chunk *C : DebugRecords)
802 DebugInfoSec->addChunk(C);
805 // Create SEH table. x86-only.
806 if (Config->Machine == I386)
809 // Create /guard:cf tables if requested.
810 if (Config->GuardCF != GuardCFLevel::Off)
811 createGuardCFTables();
814 createRuntimePseudoRelocs();
816 insertCtorDtorSymbols();
820 // Create .idata section for the DLL-imported symbol table.
821 // The format of this section is inherently Windows-specific.
822 // IdataContents class abstracted away the details for us,
823 // so we just let it create chunks and add them to the section.
824 void Writer::createImportTables() {
825 // Initialize DLLOrder so that import entries are ordered in
826 // the same order as in the command line. (That affects DLL
827 // initialization order, and this ordering is MSVC-compatible.)
828 for (ImportFile *File : ImportFile::Instances) {
832 std::string DLL = StringRef(File->DLLName).lower();
833 if (Config->DLLOrder.count(DLL) == 0)
834 Config->DLLOrder[DLL] = Config->DLLOrder.size();
836 if (File->ImpSym && !isa<DefinedImportData>(File->ImpSym))
837 fatal(toString(*File->ImpSym) + " was replaced");
838 DefinedImportData *ImpSym = cast_or_null<DefinedImportData>(File->ImpSym);
839 if (Config->DelayLoads.count(StringRef(File->DLLName).lower())) {
841 fatal("cannot delay-load " + toString(File) +
842 " due to import of data: " + toString(*ImpSym));
843 DelayIdata.add(ImpSym);
850 void Writer::appendImportThunks() {
851 if (ImportFile::Instances.empty())
854 for (ImportFile *File : ImportFile::Instances) {
861 if (!isa<DefinedImportThunk>(File->ThunkSym))
862 fatal(toString(*File->ThunkSym) + " was replaced");
863 DefinedImportThunk *Thunk = cast<DefinedImportThunk>(File->ThunkSym);
865 TextSec->addChunk(Thunk->getChunk());
868 if (!DelayIdata.empty()) {
869 Defined *Helper = cast<Defined>(Config->DelayLoadHelper);
870 DelayIdata.create(Helper);
871 for (Chunk *C : DelayIdata.getChunks())
872 DidatSec->addChunk(C);
873 for (Chunk *C : DelayIdata.getDataChunks())
874 DataSec->addChunk(C);
875 for (Chunk *C : DelayIdata.getCodeChunks())
876 TextSec->addChunk(C);
880 void Writer::createExportTable() {
881 if (Config->Exports.empty())
883 for (Chunk *C : Edata.Chunks)
884 EdataSec->addChunk(C);
887 void Writer::removeUnusedSections() {
888 // Remove sections that we can be sure won't get content, to avoid
889 // allocating space for their section headers.
890 auto IsUnused = [this](OutputSection *S) {
892 return false; // This section is populated later.
893 // MergeChunks have zero size at this point, as their size is finalized
894 // later. Only remove sections that have no Chunks at all.
895 return S->Chunks.empty();
897 OutputSections.erase(
898 std::remove_if(OutputSections.begin(), OutputSections.end(), IsUnused),
899 OutputSections.end());
902 // The Windows loader doesn't seem to like empty sections,
903 // so we remove them if any.
904 void Writer::removeEmptySections() {
905 auto IsEmpty = [](OutputSection *S) { return S->getVirtualSize() == 0; };
906 OutputSections.erase(
907 std::remove_if(OutputSections.begin(), OutputSections.end(), IsEmpty),
908 OutputSections.end());
910 for (OutputSection *Sec : OutputSections)
911 Sec->SectionIndex = Idx++;
914 size_t Writer::addEntryToStringTable(StringRef Str) {
915 assert(Str.size() > COFF::NameSize);
916 size_t OffsetOfEntry = Strtab.size() + 4; // +4 for the size field
917 Strtab.insert(Strtab.end(), Str.begin(), Str.end());
918 Strtab.push_back('\0');
919 return OffsetOfEntry;
922 Optional<coff_symbol16> Writer::createSymbol(Defined *Def) {
924 switch (Def->kind()) {
925 case Symbol::DefinedAbsoluteKind:
926 Sym.Value = Def->getRVA();
927 Sym.SectionNumber = IMAGE_SYM_ABSOLUTE;
929 case Symbol::DefinedSyntheticKind:
930 // Relative symbols are unrepresentable in a COFF symbol table.
933 // Don't write symbols that won't be written to the output to the symbol
935 Chunk *C = Def->getChunk();
938 OutputSection *OS = C->getOutputSection();
942 Sym.Value = Def->getRVA() - OS->getRVA();
943 Sym.SectionNumber = OS->SectionIndex;
948 StringRef Name = Def->getName();
949 if (Name.size() > COFF::NameSize) {
950 Sym.Name.Offset.Zeroes = 0;
951 Sym.Name.Offset.Offset = addEntryToStringTable(Name);
953 memset(Sym.Name.ShortName, 0, COFF::NameSize);
954 memcpy(Sym.Name.ShortName, Name.data(), Name.size());
957 if (auto *D = dyn_cast<DefinedCOFF>(Def)) {
958 COFFSymbolRef Ref = D->getCOFFSymbol();
959 Sym.Type = Ref.getType();
960 Sym.StorageClass = Ref.getStorageClass();
962 Sym.Type = IMAGE_SYM_TYPE_NULL;
963 Sym.StorageClass = IMAGE_SYM_CLASS_EXTERNAL;
965 Sym.NumberOfAuxSymbols = 0;
969 void Writer::createSymbolAndStringTable() {
970 // PE/COFF images are limited to 8 byte section names. Longer names can be
971 // supported by writing a non-standard string table, but this string table is
972 // not mapped at runtime and the long names will therefore be inaccessible.
973 // link.exe always truncates section names to 8 bytes, whereas binutils always
974 // preserves long section names via the string table. LLD adopts a hybrid
975 // solution where discardable sections have long names preserved and
976 // non-discardable sections have their names truncated, to ensure that any
977 // section which is mapped at runtime also has its name mapped at runtime.
978 for (OutputSection *Sec : OutputSections) {
979 if (Sec->Name.size() <= COFF::NameSize)
981 if ((Sec->Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0)
983 Sec->setStringTableOff(addEntryToStringTable(Sec->Name));
986 if (Config->DebugDwarf || Config->DebugSymtab) {
987 for (ObjFile *File : ObjFile::Instances) {
988 for (Symbol *B : File->getSymbols()) {
989 auto *D = dyn_cast_or_null<Defined>(B);
990 if (!D || D->WrittenToSymtab)
992 D->WrittenToSymtab = true;
994 if (Optional<coff_symbol16> Sym = createSymbol(D))
995 OutputSymtab.push_back(*Sym);
1000 if (OutputSymtab.empty() && Strtab.empty())
1003 // We position the symbol table to be adjacent to the end of the last section.
1004 uint64_t FileOff = FileSize;
1005 PointerToSymbolTable = FileOff;
1006 FileOff += OutputSymtab.size() * sizeof(coff_symbol16);
1007 FileOff += 4 + Strtab.size();
1008 FileSize = alignTo(FileOff, SectorSize);
1011 void Writer::mergeSections() {
1012 if (!PdataSec->Chunks.empty()) {
1013 FirstPdata = PdataSec->Chunks.front();
1014 LastPdata = PdataSec->Chunks.back();
1017 for (auto &P : Config->Merge) {
1018 StringRef ToName = P.second;
1019 if (P.first == ToName)
1023 if (!Names.insert(ToName).second)
1024 fatal("/merge: cycle found for section '" + P.first + "'");
1025 auto I = Config->Merge.find(ToName);
1026 if (I == Config->Merge.end())
1030 OutputSection *From = findSection(P.first);
1031 OutputSection *To = findSection(ToName);
1035 From->Name = ToName;
1042 // Visits all sections to initialize their relocation targets.
1043 void Writer::readRelocTargets() {
1044 for (OutputSection *Sec : OutputSections)
1045 for_each(parallel::par, Sec->Chunks.begin(), Sec->Chunks.end(),
1046 [&](Chunk *C) { C->readRelocTargets(); });
1049 // Visits all sections to assign incremental, non-overlapping RVAs and
1051 void Writer::assignAddresses() {
1052 SizeOfHeaders = DOSStubSize + sizeof(PEMagic) + sizeof(coff_file_header) +
1053 sizeof(data_directory) * NumberOfDataDirectory +
1054 sizeof(coff_section) * OutputSections.size();
1056 Config->is64() ? sizeof(pe32plus_header) : sizeof(pe32_header);
1057 SizeOfHeaders = alignTo(SizeOfHeaders, SectorSize);
1058 uint64_t RVA = PageSize; // The first page is kept unmapped.
1059 FileSize = SizeOfHeaders;
1061 for (OutputSection *Sec : OutputSections) {
1062 if (Sec == RelocSec)
1064 uint64_t RawSize = 0, VirtualSize = 0;
1065 Sec->Header.VirtualAddress = RVA;
1066 for (Chunk *C : Sec->Chunks) {
1067 VirtualSize = alignTo(VirtualSize, C->Alignment);
1068 C->setRVA(RVA + VirtualSize);
1069 C->OutputSectionOff = VirtualSize;
1070 C->finalizeContents();
1071 VirtualSize += C->getSize();
1073 RawSize = alignTo(VirtualSize, SectorSize);
1075 if (VirtualSize > UINT32_MAX)
1076 error("section larger than 4 GiB: " + Sec->Name);
1077 Sec->Header.VirtualSize = VirtualSize;
1078 Sec->Header.SizeOfRawData = RawSize;
1080 Sec->Header.PointerToRawData = FileSize;
1081 RVA += alignTo(VirtualSize, PageSize);
1082 FileSize += alignTo(RawSize, SectorSize);
1084 SizeOfImage = alignTo(RVA, PageSize);
1087 template <typename PEHeaderTy> void Writer::writeHeader() {
1088 // Write DOS header. For backwards compatibility, the first part of a PE/COFF
1089 // executable consists of an MS-DOS MZ executable. If the executable is run
1090 // under DOS, that program gets run (usually to just print an error message).
1091 // When run under Windows, the loader looks at AddressOfNewExeHeader and uses
1092 // the PE header instead.
1093 uint8_t *Buf = Buffer->getBufferStart();
1094 auto *DOS = reinterpret_cast<dos_header *>(Buf);
1095 Buf += sizeof(dos_header);
1096 DOS->Magic[0] = 'M';
1097 DOS->Magic[1] = 'Z';
1098 DOS->UsedBytesInTheLastPage = DOSStubSize % 512;
1099 DOS->FileSizeInPages = divideCeil(DOSStubSize, 512);
1100 DOS->HeaderSizeInParagraphs = sizeof(dos_header) / 16;
1102 DOS->AddressOfRelocationTable = sizeof(dos_header);
1103 DOS->AddressOfNewExeHeader = DOSStubSize;
1105 // Write DOS program.
1106 memcpy(Buf, DOSProgram, sizeof(DOSProgram));
1107 Buf += sizeof(DOSProgram);
1110 memcpy(Buf, PEMagic, sizeof(PEMagic));
1111 Buf += sizeof(PEMagic);
1113 // Write COFF header
1114 auto *COFF = reinterpret_cast<coff_file_header *>(Buf);
1115 Buf += sizeof(*COFF);
1116 COFF->Machine = Config->Machine;
1117 COFF->NumberOfSections = OutputSections.size();
1118 COFF->Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
1119 if (Config->LargeAddressAware)
1120 COFF->Characteristics |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
1121 if (!Config->is64())
1122 COFF->Characteristics |= IMAGE_FILE_32BIT_MACHINE;
1124 COFF->Characteristics |= IMAGE_FILE_DLL;
1125 if (!Config->Relocatable)
1126 COFF->Characteristics |= IMAGE_FILE_RELOCS_STRIPPED;
1127 COFF->SizeOfOptionalHeader =
1128 sizeof(PEHeaderTy) + sizeof(data_directory) * NumberOfDataDirectory;
1131 auto *PE = reinterpret_cast<PEHeaderTy *>(Buf);
1133 PE->Magic = Config->is64() ? PE32Header::PE32_PLUS : PE32Header::PE32;
1135 // If {Major,Minor}LinkerVersion is left at 0.0, then for some
1136 // reason signing the resulting PE file with Authenticode produces a
1137 // signature that fails to validate on Windows 7 (but is OK on 10).
1138 // Set it to 14.0, which is what VS2015 outputs, and which avoids
1140 PE->MajorLinkerVersion = 14;
1141 PE->MinorLinkerVersion = 0;
1143 PE->ImageBase = Config->ImageBase;
1144 PE->SectionAlignment = PageSize;
1145 PE->FileAlignment = SectorSize;
1146 PE->MajorImageVersion = Config->MajorImageVersion;
1147 PE->MinorImageVersion = Config->MinorImageVersion;
1148 PE->MajorOperatingSystemVersion = Config->MajorOSVersion;
1149 PE->MinorOperatingSystemVersion = Config->MinorOSVersion;
1150 PE->MajorSubsystemVersion = Config->MajorOSVersion;
1151 PE->MinorSubsystemVersion = Config->MinorOSVersion;
1152 PE->Subsystem = Config->Subsystem;
1153 PE->SizeOfImage = SizeOfImage;
1154 PE->SizeOfHeaders = SizeOfHeaders;
1155 if (!Config->NoEntry) {
1156 Defined *Entry = cast<Defined>(Config->Entry);
1157 PE->AddressOfEntryPoint = Entry->getRVA();
1158 // Pointer to thumb code must have the LSB set, so adjust it.
1159 if (Config->Machine == ARMNT)
1160 PE->AddressOfEntryPoint |= 1;
1162 PE->SizeOfStackReserve = Config->StackReserve;
1163 PE->SizeOfStackCommit = Config->StackCommit;
1164 PE->SizeOfHeapReserve = Config->HeapReserve;
1165 PE->SizeOfHeapCommit = Config->HeapCommit;
1166 if (Config->AppContainer)
1167 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_APPCONTAINER;
1168 if (Config->DynamicBase)
1169 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
1170 if (Config->HighEntropyVA)
1171 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA;
1172 if (!Config->AllowBind)
1173 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_BIND;
1174 if (Config->NxCompat)
1175 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
1176 if (!Config->AllowIsolation)
1177 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION;
1178 if (Config->GuardCF != GuardCFLevel::Off)
1179 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_GUARD_CF;
1180 if (Config->IntegrityCheck)
1181 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
1182 if (SetNoSEHCharacteristic)
1183 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_SEH;
1184 if (Config->TerminalServerAware)
1185 PE->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE;
1186 PE->NumberOfRvaAndSize = NumberOfDataDirectory;
1187 if (TextSec->getVirtualSize()) {
1188 PE->BaseOfCode = TextSec->getRVA();
1189 PE->SizeOfCode = TextSec->getRawSize();
1191 PE->SizeOfInitializedData = getSizeOfInitializedData();
1193 // Write data directory
1194 auto *Dir = reinterpret_cast<data_directory *>(Buf);
1195 Buf += sizeof(*Dir) * NumberOfDataDirectory;
1196 if (!Config->Exports.empty()) {
1197 Dir[EXPORT_TABLE].RelativeVirtualAddress = Edata.getRVA();
1198 Dir[EXPORT_TABLE].Size = Edata.getSize();
1200 if (ImportTableStart) {
1201 Dir[IMPORT_TABLE].RelativeVirtualAddress = ImportTableStart->getRVA();
1202 Dir[IMPORT_TABLE].Size = ImportTableSize;
1205 Dir[IAT].RelativeVirtualAddress = IATStart->getRVA();
1206 Dir[IAT].Size = IATSize;
1208 if (RsrcSec->getVirtualSize()) {
1209 Dir[RESOURCE_TABLE].RelativeVirtualAddress = RsrcSec->getRVA();
1210 Dir[RESOURCE_TABLE].Size = RsrcSec->getVirtualSize();
1213 Dir[EXCEPTION_TABLE].RelativeVirtualAddress = FirstPdata->getRVA();
1214 Dir[EXCEPTION_TABLE].Size =
1215 LastPdata->getRVA() + LastPdata->getSize() - FirstPdata->getRVA();
1217 if (RelocSec->getVirtualSize()) {
1218 Dir[BASE_RELOCATION_TABLE].RelativeVirtualAddress = RelocSec->getRVA();
1219 Dir[BASE_RELOCATION_TABLE].Size = RelocSec->getVirtualSize();
1221 if (Symbol *Sym = Symtab->findUnderscore("_tls_used")) {
1222 if (Defined *B = dyn_cast<Defined>(Sym)) {
1223 Dir[TLS_TABLE].RelativeVirtualAddress = B->getRVA();
1224 Dir[TLS_TABLE].Size = Config->is64()
1225 ? sizeof(object::coff_tls_directory64)
1226 : sizeof(object::coff_tls_directory32);
1229 if (DebugDirectory) {
1230 Dir[DEBUG_DIRECTORY].RelativeVirtualAddress = DebugDirectory->getRVA();
1231 Dir[DEBUG_DIRECTORY].Size = DebugDirectory->getSize();
1233 if (Symbol *Sym = Symtab->findUnderscore("_load_config_used")) {
1234 if (auto *B = dyn_cast<DefinedRegular>(Sym)) {
1235 SectionChunk *SC = B->getChunk();
1236 assert(B->getRVA() >= SC->getRVA());
1237 uint64_t OffsetInChunk = B->getRVA() - SC->getRVA();
1238 if (!SC->hasData() || OffsetInChunk + 4 > SC->getSize())
1239 fatal("_load_config_used is malformed");
1241 ArrayRef<uint8_t> SecContents = SC->getContents();
1242 uint32_t LoadConfigSize =
1243 *reinterpret_cast<const ulittle32_t *>(&SecContents[OffsetInChunk]);
1244 if (OffsetInChunk + LoadConfigSize > SC->getSize())
1245 fatal("_load_config_used is too large");
1246 Dir[LOAD_CONFIG_TABLE].RelativeVirtualAddress = B->getRVA();
1247 Dir[LOAD_CONFIG_TABLE].Size = LoadConfigSize;
1250 if (!DelayIdata.empty()) {
1251 Dir[DELAY_IMPORT_DESCRIPTOR].RelativeVirtualAddress =
1252 DelayIdata.getDirRVA();
1253 Dir[DELAY_IMPORT_DESCRIPTOR].Size = DelayIdata.getDirSize();
1256 // Write section table
1257 for (OutputSection *Sec : OutputSections) {
1258 Sec->writeHeaderTo(Buf);
1259 Buf += sizeof(coff_section);
1261 SectionTable = ArrayRef<uint8_t>(
1262 Buf - OutputSections.size() * sizeof(coff_section), Buf);
1264 if (OutputSymtab.empty() && Strtab.empty())
1267 COFF->PointerToSymbolTable = PointerToSymbolTable;
1268 uint32_t NumberOfSymbols = OutputSymtab.size();
1269 COFF->NumberOfSymbols = NumberOfSymbols;
1270 auto *SymbolTable = reinterpret_cast<coff_symbol16 *>(
1271 Buffer->getBufferStart() + COFF->PointerToSymbolTable);
1272 for (size_t I = 0; I != NumberOfSymbols; ++I)
1273 SymbolTable[I] = OutputSymtab[I];
1274 // Create the string table, it follows immediately after the symbol table.
1275 // The first 4 bytes is length including itself.
1276 Buf = reinterpret_cast<uint8_t *>(&SymbolTable[NumberOfSymbols]);
1277 write32le(Buf, Strtab.size() + 4);
1278 if (!Strtab.empty())
1279 memcpy(Buf + 4, Strtab.data(), Strtab.size());
1282 void Writer::openFile(StringRef Path) {
1284 FileOutputBuffer::create(Path, FileSize, FileOutputBuffer::F_executable),
1285 "failed to open " + Path);
1288 void Writer::createSEHTable() {
1289 // Set the no SEH characteristic on x86 binaries unless we find exception
1291 SetNoSEHCharacteristic = true;
1293 SymbolRVASet Handlers;
1294 for (ObjFile *File : ObjFile::Instances) {
1295 // FIXME: We should error here instead of earlier unless /safeseh:no was
1297 if (!File->hasSafeSEH())
1300 markSymbolsForRVATable(File, File->getSXDataChunks(), Handlers);
1303 // Remove the "no SEH" characteristic if all object files were built with
1304 // safeseh, we found some exception handlers, and there is a load config in
1306 SetNoSEHCharacteristic =
1307 Handlers.empty() || !Symtab->findUnderscore("_load_config_used");
1309 maybeAddRVATable(std::move(Handlers), "__safe_se_handler_table",
1310 "__safe_se_handler_count");
1313 // Add a symbol to an RVA set. Two symbols may have the same RVA, but an RVA set
1314 // cannot contain duplicates. Therefore, the set is uniqued by Chunk and the
1315 // symbol's offset into that Chunk.
1316 static void addSymbolToRVASet(SymbolRVASet &RVASet, Defined *S) {
1317 Chunk *C = S->getChunk();
1318 if (auto *SC = dyn_cast<SectionChunk>(C))
1319 C = SC->Repl; // Look through ICF replacement.
1320 uint32_t Off = S->getRVA() - (C ? C->getRVA() : 0);
1321 RVASet.insert({C, Off});
1324 // Given a symbol, add it to the GFIDs table if it is a live, defined, function
1325 // symbol in an executable section.
1326 static void maybeAddAddressTakenFunction(SymbolRVASet &AddressTakenSyms,
1328 auto *D = dyn_cast_or_null<DefinedCOFF>(S);
1330 // Ignore undefined symbols and references to non-functions (e.g. globals and
1333 D->getCOFFSymbol().getComplexType() != COFF::IMAGE_SYM_DTYPE_FUNCTION)
1336 // Mark the symbol as address taken if it's in an executable section.
1337 Chunk *RefChunk = D->getChunk();
1338 OutputSection *OS = RefChunk ? RefChunk->getOutputSection() : nullptr;
1339 if (OS && OS->Header.Characteristics & IMAGE_SCN_MEM_EXECUTE)
1340 addSymbolToRVASet(AddressTakenSyms, D);
1343 // Visit all relocations from all section contributions of this object file and
1344 // mark the relocation target as address-taken.
1345 static void markSymbolsWithRelocations(ObjFile *File,
1346 SymbolRVASet &UsedSymbols) {
1347 for (Chunk *C : File->getChunks()) {
1348 // We only care about live section chunks. Common chunks and other chunks
1349 // don't generally contain relocations.
1350 SectionChunk *SC = dyn_cast<SectionChunk>(C);
1351 if (!SC || !SC->Live)
1354 for (const coff_relocation &Reloc : SC->Relocs) {
1355 if (Config->Machine == I386 && Reloc.Type == COFF::IMAGE_REL_I386_REL32)
1356 // Ignore relative relocations on x86. On x86_64 they can't be ignored
1357 // since they're also used to compute absolute addresses.
1360 Symbol *Ref = SC->File->getSymbol(Reloc.SymbolTableIndex);
1361 maybeAddAddressTakenFunction(UsedSymbols, Ref);
1366 // Create the guard function id table. This is a table of RVAs of all
1367 // address-taken functions. It is sorted and uniqued, just like the safe SEH
1369 void Writer::createGuardCFTables() {
1370 SymbolRVASet AddressTakenSyms;
1371 SymbolRVASet LongJmpTargets;
1372 for (ObjFile *File : ObjFile::Instances) {
1373 // If the object was compiled with /guard:cf, the address taken symbols
1374 // are in .gfids$y sections, and the longjmp targets are in .gljmp$y
1375 // sections. If the object was not compiled with /guard:cf, we assume there
1376 // were no setjmp targets, and that all code symbols with relocations are
1377 // possibly address-taken.
1378 if (File->hasGuardCF()) {
1379 markSymbolsForRVATable(File, File->getGuardFidChunks(), AddressTakenSyms);
1380 markSymbolsForRVATable(File, File->getGuardLJmpChunks(), LongJmpTargets);
1382 markSymbolsWithRelocations(File, AddressTakenSyms);
1386 // Mark the image entry as address-taken.
1388 maybeAddAddressTakenFunction(AddressTakenSyms, Config->Entry);
1390 // Mark exported symbols in executable sections as address-taken.
1391 for (Export &E : Config->Exports)
1392 maybeAddAddressTakenFunction(AddressTakenSyms, E.Sym);
1394 // Ensure sections referenced in the gfid table are 16-byte aligned.
1395 for (const ChunkAndOffset &C : AddressTakenSyms)
1396 if (C.InputChunk->Alignment < 16)
1397 C.InputChunk->Alignment = 16;
1399 maybeAddRVATable(std::move(AddressTakenSyms), "__guard_fids_table",
1400 "__guard_fids_count");
1402 // Add the longjmp target table unless the user told us not to.
1403 if (Config->GuardCF == GuardCFLevel::Full)
1404 maybeAddRVATable(std::move(LongJmpTargets), "__guard_longjmp_table",
1405 "__guard_longjmp_count");
1407 // Set __guard_flags, which will be used in the load config to indicate that
1408 // /guard:cf was enabled.
1409 uint32_t GuardFlags = uint32_t(coff_guard_flags::CFInstrumented) |
1410 uint32_t(coff_guard_flags::HasFidTable);
1411 if (Config->GuardCF == GuardCFLevel::Full)
1412 GuardFlags |= uint32_t(coff_guard_flags::HasLongJmpTable);
1413 Symbol *FlagSym = Symtab->findUnderscore("__guard_flags");
1414 cast<DefinedAbsolute>(FlagSym)->setVA(GuardFlags);
1417 // Take a list of input sections containing symbol table indices and add those
1418 // symbols to an RVA table. The challenge is that symbol RVAs are not known and
1419 // depend on the table size, so we can't directly build a set of integers.
1420 void Writer::markSymbolsForRVATable(ObjFile *File,
1421 ArrayRef<SectionChunk *> SymIdxChunks,
1422 SymbolRVASet &TableSymbols) {
1423 for (SectionChunk *C : SymIdxChunks) {
1424 // Skip sections discarded by linker GC. This comes up when a .gfids section
1425 // is associated with something like a vtable and the vtable is discarded.
1426 // In this case, the associated gfids section is discarded, and we don't
1427 // mark the virtual member functions as address-taken by the vtable.
1431 // Validate that the contents look like symbol table indices.
1432 ArrayRef<uint8_t> Data = C->getContents();
1433 if (Data.size() % 4 != 0) {
1434 warn("ignoring " + C->getSectionName() +
1435 " symbol table index section in object " + toString(File));
1439 // Read each symbol table index and check if that symbol was included in the
1440 // final link. If so, add it to the table symbol set.
1441 ArrayRef<ulittle32_t> SymIndices(
1442 reinterpret_cast<const ulittle32_t *>(Data.data()), Data.size() / 4);
1443 ArrayRef<Symbol *> ObjSymbols = File->getSymbols();
1444 for (uint32_t SymIndex : SymIndices) {
1445 if (SymIndex >= ObjSymbols.size()) {
1446 warn("ignoring invalid symbol table index in section " +
1447 C->getSectionName() + " in object " + toString(File));
1450 if (Symbol *S = ObjSymbols[SymIndex]) {
1452 addSymbolToRVASet(TableSymbols, cast<Defined>(S));
1458 // Replace the absolute table symbol with a synthetic symbol pointing to
1459 // TableChunk so that we can emit base relocations for it and resolve section
1460 // relative relocations.
1461 void Writer::maybeAddRVATable(SymbolRVASet TableSymbols, StringRef TableSym,
1462 StringRef CountSym) {
1463 if (TableSymbols.empty())
1466 RVATableChunk *TableChunk = make<RVATableChunk>(std::move(TableSymbols));
1467 RdataSec->addChunk(TableChunk);
1469 Symbol *T = Symtab->findUnderscore(TableSym);
1470 Symbol *C = Symtab->findUnderscore(CountSym);
1471 replaceSymbol<DefinedSynthetic>(T, T->getName(), TableChunk);
1472 cast<DefinedAbsolute>(C)->setVA(TableChunk->getSize() / 4);
1475 // MinGW specific. Gather all relocations that are imported from a DLL even
1476 // though the code didn't expect it to, produce the table that the runtime
1477 // uses for fixing them up, and provide the synthetic symbols that the
1478 // runtime uses for finding the table.
1479 void Writer::createRuntimePseudoRelocs() {
1480 std::vector<RuntimePseudoReloc> Rels;
1482 for (Chunk *C : Symtab->getChunks()) {
1483 auto *SC = dyn_cast<SectionChunk>(C);
1484 if (!SC || !SC->Live)
1486 SC->getRuntimePseudoRelocs(Rels);
1490 log("Writing " + Twine(Rels.size()) + " runtime pseudo relocations");
1491 PseudoRelocTableChunk *Table = make<PseudoRelocTableChunk>(Rels);
1492 RdataSec->addChunk(Table);
1493 EmptyChunk *EndOfList = make<EmptyChunk>();
1494 RdataSec->addChunk(EndOfList);
1496 Symbol *HeadSym = Symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST__");
1497 Symbol *EndSym = Symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST_END__");
1498 replaceSymbol<DefinedSynthetic>(HeadSym, HeadSym->getName(), Table);
1499 replaceSymbol<DefinedSynthetic>(EndSym, EndSym->getName(), EndOfList);
1503 // The MinGW .ctors and .dtors lists have sentinels at each end;
1504 // a (uintptr_t)-1 at the start and a (uintptr_t)0 at the end.
1505 // There's a symbol pointing to the start sentinel pointer, __CTOR_LIST__
1506 // and __DTOR_LIST__ respectively.
1507 void Writer::insertCtorDtorSymbols() {
1508 AbsolutePointerChunk *CtorListHead = make<AbsolutePointerChunk>(-1);
1509 AbsolutePointerChunk *CtorListEnd = make<AbsolutePointerChunk>(0);
1510 AbsolutePointerChunk *DtorListHead = make<AbsolutePointerChunk>(-1);
1511 AbsolutePointerChunk *DtorListEnd = make<AbsolutePointerChunk>(0);
1512 CtorsSec->insertChunkAtStart(CtorListHead);
1513 CtorsSec->addChunk(CtorListEnd);
1514 DtorsSec->insertChunkAtStart(DtorListHead);
1515 DtorsSec->addChunk(DtorListEnd);
1517 Symbol *CtorListSym = Symtab->findUnderscore("__CTOR_LIST__");
1518 Symbol *DtorListSym = Symtab->findUnderscore("__DTOR_LIST__");
1519 replaceSymbol<DefinedSynthetic>(CtorListSym, CtorListSym->getName(),
1521 replaceSymbol<DefinedSynthetic>(DtorListSym, DtorListSym->getName(),
1525 // Handles /section options to allow users to overwrite
1526 // section attributes.
1527 void Writer::setSectionPermissions() {
1528 for (auto &P : Config->Section) {
1529 StringRef Name = P.first;
1530 uint32_t Perm = P.second;
1531 for (OutputSection *Sec : OutputSections)
1532 if (Sec->Name == Name)
1533 Sec->setPermissions(Perm);
1537 // Write section contents to a mmap'ed file.
1538 void Writer::writeSections() {
1539 // Record the number of sections to apply section index relocations
1540 // against absolute symbols. See applySecIdx in Chunks.cpp..
1541 DefinedAbsolute::NumOutputSections = OutputSections.size();
1543 uint8_t *Buf = Buffer->getBufferStart();
1544 for (OutputSection *Sec : OutputSections) {
1545 uint8_t *SecBuf = Buf + Sec->getFileOff();
1546 // Fill gaps between functions in .text with INT3 instructions
1547 // instead of leaving as NUL bytes (which can be interpreted as
1548 // ADD instructions).
1549 if (Sec->Header.Characteristics & IMAGE_SCN_CNT_CODE)
1550 memset(SecBuf, 0xCC, Sec->getRawSize());
1551 for_each(parallel::par, Sec->Chunks.begin(), Sec->Chunks.end(),
1552 [&](Chunk *C) { C->writeTo(SecBuf); });
1556 void Writer::writeBuildId() {
1557 // There are two important parts to the build ID.
1558 // 1) If building with debug info, the COFF debug directory contains a
1559 // timestamp as well as a Guid and Age of the PDB.
1560 // 2) In all cases, the PE COFF file header also contains a timestamp.
1561 // For reproducibility, instead of a timestamp we want to use a hash of the
1563 if (Config->Debug) {
1564 assert(BuildId && "BuildId is not set!");
1565 // BuildId->BuildId was filled in when the PDB was written.
1568 // At this point the only fields in the COFF file which remain unset are the
1569 // "timestamp" in the COFF file header, and the ones in the coff debug
1570 // directory. Now we can hash the file and write that hash to the various
1571 // timestamp fields in the file.
1572 StringRef OutputFileData(
1573 reinterpret_cast<const char *>(Buffer->getBufferStart()),
1574 Buffer->getBufferSize());
1576 uint32_t Timestamp = Config->Timestamp;
1578 bool GenerateSyntheticBuildId =
1579 Config->MinGW && Config->Debug && Config->PDBPath.empty();
1581 if (Config->Repro || GenerateSyntheticBuildId)
1582 Hash = xxHash64(OutputFileData);
1585 Timestamp = static_cast<uint32_t>(Hash);
1587 if (GenerateSyntheticBuildId) {
1588 // For MinGW builds without a PDB file, we still generate a build id
1589 // to allow associating a crash dump to the executable.
1590 BuildId->BuildId->PDB70.CVSignature = OMF::Signature::PDB70;
1591 BuildId->BuildId->PDB70.Age = 1;
1592 memcpy(BuildId->BuildId->PDB70.Signature, &Hash, 8);
1593 // xxhash only gives us 8 bytes, so put some fixed data in the other half.
1594 memcpy(&BuildId->BuildId->PDB70.Signature[8], "LLD PDB.", 8);
1598 DebugDirectory->setTimeDateStamp(Timestamp);
1600 uint8_t *Buf = Buffer->getBufferStart();
1601 Buf += DOSStubSize + sizeof(PEMagic);
1602 object::coff_file_header *CoffHeader =
1603 reinterpret_cast<coff_file_header *>(Buf);
1604 CoffHeader->TimeDateStamp = Timestamp;
1607 // Sort .pdata section contents according to PE/COFF spec 5.5.
1608 void Writer::sortExceptionTable() {
1611 // We assume .pdata contains function table entries only.
1612 auto BufAddr = [&](Chunk *C) {
1613 return Buffer->getBufferStart() + C->getOutputSection()->getFileOff() +
1614 C->getRVA() - C->getOutputSection()->getRVA();
1616 uint8_t *Begin = BufAddr(FirstPdata);
1617 uint8_t *End = BufAddr(LastPdata) + LastPdata->getSize();
1618 if (Config->Machine == AMD64) {
1619 struct Entry { ulittle32_t Begin, End, Unwind; };
1620 sort(parallel::par, (Entry *)Begin, (Entry *)End,
1621 [](const Entry &A, const Entry &B) { return A.Begin < B.Begin; });
1624 if (Config->Machine == ARMNT || Config->Machine == ARM64) {
1625 struct Entry { ulittle32_t Begin, Unwind; };
1626 sort(parallel::par, (Entry *)Begin, (Entry *)End,
1627 [](const Entry &A, const Entry &B) { return A.Begin < B.Begin; });
1630 errs() << "warning: don't know how to handle .pdata.\n";
1633 // The CRT section contains, among other things, the array of function
1634 // pointers that initialize every global variable that is not trivially
1635 // constructed. The CRT calls them one after the other prior to invoking
1638 // As per C++ spec, 3.6.2/2.3,
1639 // "Variables with ordered initialization defined within a single
1640 // translation unit shall be initialized in the order of their definitions
1641 // in the translation unit"
1643 // It is therefore critical to sort the chunks containing the function
1644 // pointers in the order that they are listed in the object file (top to
1645 // bottom), otherwise global objects might not be initialized in the
1647 void Writer::sortCRTSectionChunks(std::vector<Chunk *> &Chunks) {
1648 auto SectionChunkOrder = [](const Chunk *A, const Chunk *B) {
1649 auto SA = dyn_cast<SectionChunk>(A);
1650 auto SB = dyn_cast<SectionChunk>(B);
1651 assert(SA && SB && "Non-section chunks in CRT section!");
1653 StringRef SAObj = SA->File->MB.getBufferIdentifier();
1654 StringRef SBObj = SB->File->MB.getBufferIdentifier();
1656 return SAObj == SBObj && SA->getSectionNumber() < SB->getSectionNumber();
1658 std::stable_sort(Chunks.begin(), Chunks.end(), SectionChunkOrder);
1660 if (Config->Verbose) {
1661 for (auto &C : Chunks) {
1662 auto SC = dyn_cast<SectionChunk>(C);
1663 log(" " + SC->File->MB.getBufferIdentifier().str() +
1664 ", SectionID: " + Twine(SC->getSectionNumber()));
1669 OutputSection *Writer::findSection(StringRef Name) {
1670 for (OutputSection *Sec : OutputSections)
1671 if (Sec->Name == Name)
1676 uint32_t Writer::getSizeOfInitializedData() {
1678 for (OutputSection *S : OutputSections)
1679 if (S->Header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
1680 Res += S->getRawSize();
1684 // Add base relocations to .reloc section.
1685 void Writer::addBaserels() {
1686 if (!Config->Relocatable)
1688 RelocSec->Chunks.clear();
1689 std::vector<Baserel> V;
1690 for (OutputSection *Sec : OutputSections) {
1691 if (Sec->Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
1693 // Collect all locations for base relocations.
1694 for (Chunk *C : Sec->Chunks)
1696 // Add the addresses to .reloc section.
1698 addBaserelBlocks(V);
1703 // Add addresses to .reloc section. Note that addresses are grouped by page.
1704 void Writer::addBaserelBlocks(std::vector<Baserel> &V) {
1705 const uint32_t Mask = ~uint32_t(PageSize - 1);
1706 uint32_t Page = V[0].RVA & Mask;
1707 size_t I = 0, J = 1;
1708 for (size_t E = V.size(); J < E; ++J) {
1709 uint32_t P = V[J].RVA & Mask;
1712 RelocSec->addChunk(make<BaserelChunk>(Page, &V[I], &V[0] + J));
1718 RelocSec->addChunk(make<BaserelChunk>(Page, &V[I], &V[0] + J));