Index: COFF/Writer.h =================================================================== --- COFF/Writer.h +++ COFF/Writer.h @@ -23,6 +23,20 @@ void writeResult(); +class OutputSection; + +// UnmergedSection represents all unmerged yet sections contributing to the +// output file, including synthetic ones. +class UnmergedSection { +public: + UnmergedSection(llvm::StringRef N, uint32_t Chars) + : Name(N), Characteristics(Chars) {} + llvm::StringRef Name; + unsigned Characteristics; + std::vector Chunks; + OutputSection *TargetSection = nullptr; +}; + // OutputSection represents a section in an output file. It's a // container of chunks. OutputSection and Chunk are 1:N relationship. // Chunks cannot belong to more than one OutputSections. The writer @@ -36,7 +50,6 @@ void addChunk(Chunk *C); void insertChunkAtStart(Chunk *C); void merge(OutputSection *Other); - void addPermissions(uint32_t C); void setPermissions(uint32_t C); uint64_t getRVA() { return Header.VirtualAddress; } uint64_t getFileOff() { return Header.PointerToRawData; } @@ -69,7 +82,7 @@ uint32_t StringTableOff = 0; }; -} -} +} // namespace coff +} // namespace lld #endif Index: COFF/Writer.cpp =================================================================== --- COFF/Writer.cpp +++ COFF/Writer.cpp @@ -157,6 +157,22 @@ mutable codeview::DebugInfo *BuildId = nullptr; }; +struct NameAndChars { + NameAndChars(StringRef SN, uint32_t C) + : SectionName(SN), Characteristics(C) { } + StringRef SectionName; + uint32_t Characteristics = 0; // llvm.COFF.SectionCharacteristics + + bool operator<(const NameAndChars &NC) const { + int C = SectionName.compare(NC.SectionName); + if (C == 1) + return false; + if (C == 0 && Characteristics >= NC.Characteristics) + return false; + return true; + } +}; + // The writer writes a SymbolTable result to a file. class Writer { public: @@ -168,8 +184,7 @@ void createMiscChunks(); void createImportTables(); void appendImportThunks(); - void locateImportTables( - std::map, std::vector> &Map); + void locateImportTables(); void createExportTable(); void mergeSections(); void readRelocTargets(); @@ -194,6 +209,9 @@ void writeBuildId(); void sortExceptionTable(); void sortCRTSectionChunks(std::vector &Chunks); + void addSyntheticIdata(); + bool fixGnuImportChunks(); + UnmergedSection *createUnmergedSection(StringRef Name, uint32_t OutChars); llvm::Optional createSymbol(Defined *D); size_t addEntryToStringTable(StringRef Str); @@ -203,9 +221,9 @@ void addBaserelBlocks(std::vector &V); uint32_t getSizeOfInitializedData(); - std::map> binImports(); std::unique_ptr &Buffer; + std::map UnmergedSections; std::vector OutputSections; std::vector Strtab; std::vector OutputSymtab; @@ -568,34 +586,31 @@ // be formed correctly, the section chunks within each .idata$* section need // to be grouped by library, and sorted alphabetically within each library // (which makes sure the header comes first and the trailer last). -static bool fixGnuImportChunks( - std::map, std::vector> &Map) { +bool Writer::fixGnuImportChunks() { uint32_t RDATA = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ; // Make sure all .idata$* section chunks are mapped as RDATA in order to // be sorted into the same sections as our own synthesized .idata chunks. - for (auto &Pair : Map) { - StringRef SectionName = Pair.first.first; - uint32_t OutChars = Pair.first.second; - if (!SectionName.startswith(".idata")) + for (auto &Pair : UnmergedSections) { + UnmergedSection *USec = Pair.second; + if (!USec->Name.startswith(".idata")) continue; - if (OutChars == RDATA) + if (USec->Characteristics == RDATA) continue; - std::vector &SrcVect = Pair.second; - std::vector &DestVect = Map[{SectionName, RDATA}]; - DestVect.insert(DestVect.end(), SrcVect.begin(), SrcVect.end()); - SrcVect.clear(); + UnmergedSection *RDataSec = createUnmergedSection(USec->Name, RDATA); + RDataSec->Chunks.insert(RDataSec->Chunks.end(), USec->Chunks.begin(), USec->Chunks.end()); + USec->Chunks.clear(); } bool HasIdata = false; // Sort all .idata$* chunks, grouping chunks from the same library, // with alphabetical ordering of the object fils within a library. - for (auto &Pair : Map) { - StringRef SectionName = Pair.first.first; - if (!SectionName.startswith(".idata")) + for (auto &Pair : UnmergedSections) { + UnmergedSection *USec = Pair.second; + if (!USec->Name.startswith(".idata")) continue; - std::vector &Chunks = Pair.second; + std::vector &Chunks = USec->Chunks; if (!Chunks.empty()) HasIdata = true; std::stable_sort(Chunks.begin(), Chunks.end(), [&](Chunk *S, Chunk *T) { @@ -621,9 +636,7 @@ // Add generated idata chunks, for imported symbols and DLLs, and a // terminator in .idata$2. -static void addSyntheticIdata( - IdataContents &Idata, - std::map, std::vector> &Map) { +void Writer::addSyntheticIdata() { uint32_t RDATA = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ; Idata.create(); @@ -631,8 +644,8 @@ // chunks from other linked in object files to be grouped together. // See Microsoft PE/COFF spec 5.4 for details. auto Add = [&](StringRef N, std::vector &V) { - std::vector &DestVect = Map[{N, RDATA}]; - DestVect.insert(DestVect.end(), V.begin(), V.end()); + UnmergedSection *USec = createUnmergedSection(N, RDATA); + USec->Chunks.insert(USec->Chunks.end(), V.begin(), V.end()); }; // The loader assumes a specific order of data. @@ -646,20 +659,21 @@ // Locate the first Chunk and size of the import directory list and the // IAT. -void Writer::locateImportTables( - std::map, std::vector> &Map) { +void Writer::locateImportTables() { uint32_t RDATA = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ; - std::vector &ImportTables = Map[{".idata$2", RDATA}]; - if (!ImportTables.empty()) - ImportTableStart = ImportTables.front(); - for (Chunk *C : ImportTables) - ImportTableSize += C->getSize(); - - std::vector &IAT = Map[{".idata$5", RDATA}]; - if (!IAT.empty()) - IATStart = IAT.front(); - for (Chunk *C : IAT) - IATSize += C->getSize(); + if (UnmergedSection *ImportDirs = UnmergedSections[{".idata$2", RDATA}]) { + if (!ImportDirs->Chunks.empty()) + ImportTableStart = ImportDirs->Chunks.front(); + for (Chunk *C : ImportDirs->Chunks) + ImportTableSize += C->getSize(); + } + + if (UnmergedSection *ImportAddresses = UnmergedSections[{".idata$5", RDATA}]) { + if (!ImportAddresses->Chunks.empty()) + IATStart = ImportAddresses->Chunks.front(); + for (Chunk *C : ImportAddresses->Chunks) + IATSize += C->getSize(); + } } // Create output section objects and add them to OutputSections. @@ -673,9 +687,9 @@ const uint32_t W = IMAGE_SCN_MEM_WRITE; const uint32_t X = IMAGE_SCN_MEM_EXECUTE; - SmallDenseMap, OutputSection *> Sections; - auto CreateSection = [&](StringRef Name, uint32_t OutChars) { - OutputSection *&Sec = Sections[{Name, OutChars}]; + std::map OutSectionsMap; + auto CreateOutSection = [&](StringRef Name, uint32_t OutChars) { + OutputSection *&Sec = OutSectionsMap[{Name, OutChars}]; if (!Sec) { Sec = make(Name, OutChars); OutputSections.push_back(Sec); @@ -684,22 +698,21 @@ }; // 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); - 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); + TextSec = CreateOutSection(".text", CODE | R | X); + CreateOutSection(".bss", BSS | R | W); + RdataSec = CreateOutSection(".rdata", DATA | R); + BuildidSec = CreateOutSection(".buildid", DATA | R); + DataSec = CreateOutSection(".data", DATA | R | W); + PdataSec = CreateOutSection(".pdata", DATA | R); + IdataSec = CreateOutSection(".idata", DATA | R); + EdataSec = CreateOutSection(".edata", DATA | R); + DidatSec = CreateOutSection(".didat", DATA | R); + RsrcSec = CreateOutSection(".rsrc", DATA | R); + RelocSec = CreateOutSection(".reloc", DATA | DISCARDABLE | R); + CtorsSec = CreateOutSection(".ctors", DATA | R | W); + DtorsSec = CreateOutSection(".dtors", DATA | R | W); // Then bin chunks by name and output characteristics. - std::map, std::vector> Map; for (Chunk *C : Symtab->getChunks()) { auto *SC = dyn_cast(C); if (SC && !SC->Live) { @@ -707,33 +720,36 @@ SC->printDiscardedMessage(); continue; } - Map[{C->getSectionName(), C->getOutputCharacteristics()}].push_back(C); + UnmergedSection *USec = createUnmergedSection( + C->getSectionName(), C->getOutputCharacteristics()); + USec->Chunks.push_back(C); } // Even in non MinGW cases, we might need to link against GNU import // libraries. - bool HasIdata = fixGnuImportChunks(Map); + bool HasIdata = fixGnuImportChunks(); if (!Idata.empty()) HasIdata = true; if (HasIdata) - addSyntheticIdata(Idata, Map); + addSyntheticIdata(); // Process an /order option. if (!Config->Order.empty()) - for (auto &Pair : Map) - sortBySectionOrder(Pair.second); + for (auto &Pair : UnmergedSections) + sortBySectionOrder(Pair.second->Chunks); if (HasIdata) - locateImportTables(Map); + locateImportTables(); // 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 = getOutputSectionName(Pair.first.first); - uint32_t OutChars = Pair.first.second; + for (auto &Pair : UnmergedSections) { + UnmergedSection *USec = Pair.second; + StringRef Name = getOutputSectionName(USec->Name); + uint32_t OutChars = USec->Characteristics; if (Name == ".CRT") { // In link.exe, there is a special case for the I386 target where .CRT @@ -742,14 +758,13 @@ // special case for all architectures. OutChars = DATA | R; - log("Processing section " + Pair.first.first + " -> " + Name); + log("Processing section " + USec->Name + " -> " + Name); - sortCRTSectionChunks(Pair.second); + sortCRTSectionChunks(USec->Chunks); } - OutputSection *Sec = CreateSection(Name, OutChars); - std::vector &Chunks = Pair.second; - for (Chunk *C : Chunks) + OutputSection *Sec = CreateOutSection(Name, OutChars); + for (Chunk *C : USec->Chunks) Sec->addChunk(C); } @@ -1717,3 +1732,12 @@ return; RelocSec->addChunk(make(Page, &V[I], &V[0] + J)); } + +UnmergedSection *Writer::createUnmergedSection(StringRef Name, + uint32_t OutChars) { + UnmergedSection *&USec = UnmergedSections[{Name, OutChars}]; + if (!USec) { + USec = make(Name, OutChars); + } + return USec; +}