CbC/CbC_llvm: lld/ELF/Writer.cpp comparison

comparison lld/ELF/Writer.cpp @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 #include "Relocations.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
+#include "lld/Common/Arrays.h"
 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 namespace {
 // The writer writes a SymbolTable result to a file.
 template <class ELFT> class Writer {
 public:
+LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
 Writer() : buffer(errorHandler().outputBuffer) {}
-using Elf_Shdr = typename ELFT::Shdr;
-using Elf_Ehdr = typename ELFT::Ehdr;
-using Elf_Phdr = typename ELFT::Phdr;
 void run();
 private:
 void copyLocalSymbols();
 // sortISDBySectionOrder().
 // ".text.unknown" means the hotness of the section is unknown. When
 // SampleFDO is used, if a function doesn't have sample, it could be very
 // cold or it could be a new function never being sampled. Those functions
 // will be kept in the ".text.unknown" section.
+// ".text.split." holds symbols which are split out from functions in other
+// input sections. For example, with -fsplit-machine-functions, placing the
+// cold parts in .text.split instead of .text.unlikely mitigates against poor
+// profile inaccuracy. Techniques such as hugepage remapping can make
+// conservative decisions at the section granularity.
 if (config->zKeepTextSectionPrefix)
 for (StringRef v : {".text.hot.", ".text.unknown.", ".text.unlikely.",
-".text.startup.", ".text.exit."})
+".text.startup.", ".text.exit.", ".text.split."})
 if (isSectionPrefix(v, s->name))
 return v.drop_back();
 for (StringRef v :
 {".text.", ".rodata.", ".data.rel.ro.", ".data.", ".bss.rel.ro.",
 return !config->relocatable && !config->shared &&
 !config->dynamicLinker.empty() && script->needsInterpSection();
 }
 template <class ELFT> void elf::writeResult() {
-llvm::TimeTraceScope timeScope("Write output file");
 Writer<ELFT>().run();
 }
 static void removeEmptyPTLoad(std::vector<PhdrEntry *> &phdrs) {
 auto it = std::stable_partition(
 inputSections.insert(inputSections.end(), newSections.begin(),
 newSections.end());
 }
 void elf::combineEhSections() {
+llvm::TimeTraceScope timeScope("Combine EH sections");
 for (InputSectionBase *&s : inputSections) {
 // Ignore dead sections and the partition end marker (.part.end),
 // whose partition number is out of bounds.
 if (!s->isLive() || s->partition == 255)
 continue;
 ElfSym::mipsLocalGp = addAbsolute("__gnu_local_gp");
 } else if (config->emachine == EM_PPC) {
 // glibc *crt1.o has a undefined reference to _SDA_BASE_. Since we don't
 // support Small Data Area, define it arbitrarily as 0.
 addOptionalRegular("_SDA_BASE_", nullptr, 0, STV_HIDDEN);
+} else if (config->emachine == EM_PPC64) {
+addPPC64SaveRestore();
 }
 // The Power Architecture 64-bit v2 ABI defines a TableOfContents (TOC) which
 // combines the typical ELF GOT with the small data sections. It commonly
 // includes .got .toc .sdata .sbss. The .TOC. symbol replaces both
 checkSections();
 // It does not make sense try to open the file if we have error already.
 if (errorCount())
 return;
-// Write the result down to a file.
-openFile();
+{
-if (errorCount())
+llvm::TimeTraceScope timeScope("Write output file");
-return;
+// Write the result down to a file.
+openFile();
-if (!config->oFormatBinary) {
+if (errorCount())
-if (config->zSeparate != SeparateSegmentKind::None)
+return;
-writeTrapInstr();
-writeHeader();
+if (!config->oFormatBinary) {
-writeSections();
+if (config->zSeparate != SeparateSegmentKind::None)
-} else {
+writeTrapInstr();
-writeSectionsBinary();
+writeHeader();
-}
+writeSections();
+} else {
-// Backfill .note.gnu.build-id section content. This is done at last
+writeSectionsBinary();
-// because the content is usually a hash value of the entire output file.
+}
-writeBuildId();
-if (errorCount())
+// Backfill .note.gnu.build-id section content. This is done at last
-return;
+// because the content is usually a hash value of the entire output file.
+writeBuildId();
-if (auto e = buffer->commit())
+if (errorCount())
-error("failed to write to the output file: " + toString(std::move(e)));
+return;
+if (auto e = buffer->commit())
+error("failed to write to the output file: " + toString(std::move(e)));
+}
 }
 template <class ELFT, class RelTy>
 static void markUsedLocalSymbolsImpl(ObjFile<ELFT> *file,
 llvm::ArrayRef<RelTy> rels) {
 // Local symbols are not in the linker's symbol table. This function scans
 // each object file's symbol table to copy local symbols to the output.
 template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
 if (!in.symTab)
 return;
+llvm::TimeTraceScope timeScope("Add local symbols");
 if (config->copyRelocs && config->discard != DiscardPolicy::None)
 markUsedLocalSymbols<ELFT>();
 for (InputFile *file : objectFiles) {
 ObjFile<ELFT> *f = cast<ObjFile<ELFT>>(file);
 for (Symbol *b : f->getLocalSymbols()) {
-if (!b->isLocal())
+assert(b->isLocal() && "should have been caught in initializeSymbols()");
-fatal(toString(f) +
-": broken object: getLocalSymbols returns a non-local symbol");
 auto *dr = dyn_cast<Defined>(b);
 // No reason to keep local undefined symbol in symtab.
 if (!dr)
 continue;
 // copied from input sections, and there may be a relocation pointing to its
 // contents if -r or -emit-reloc are given.
 if (isa<SyntheticSection>(isec) && !(isec->flags & SHF_MERGE))
 continue;
+// Set the symbol to be relative to the output section so that its st_value
+// equals the output section address. Note, there may be a gap between the
+// start of the output section and isec.
 auto *sym =
 make<Defined>(isec->file, "", STB_LOCAL, /*stOther=*/0, STT_SECTION,
-/*value=*/0, /*size=*/0, isec);
+/*value=*/0, /*size=*/0, isec->getOutputSection());
 in.symTab->addSymbol(sym);
 }
 }
 // Today's loaders have a feature to make segments read-only after
 return i;
 }
 // Adds random priorities to sections not already in the map.
 static void maybeShuffle(DenseMap<const InputSectionBase *, int> &order) {
-if (!config->shuffleSectionSeed)
+if (config->shuffleSections.empty())
 return;
-std::vector<int> priorities(inputSections.size() - order.size());
+std::vector<InputSectionBase *> matched, sections = inputSections;
+matched.reserve(sections.size());
+for (const auto &patAndSeed : config->shuffleSections) {
+matched.clear();
+for (InputSectionBase *sec : sections)
+if (patAndSeed.first.match(sec->name))
+matched.push_back(sec);
+const uint32_t seed = patAndSeed.second;
+if (seed == UINT32_MAX) {
+// If --shuffle-sections <section-glob>=-1, reverse the section order. The
+// section order is stable even if the number of sections changes. This is
+// useful to catch issues like static initialization order fiasco
+// reliably.
+std::reverse(matched.begin(), matched.end());
+} else {
+std::mt19937 g(seed ? seed : std::random_device()());
+llvm::shuffle(matched.begin(), matched.end(), g);
+}
+size_t i = 0;
+for (InputSectionBase *&sec : sections)
+if (patAndSeed.first.match(sec->name))
+sec = matched[i++];
+}
 // Existing priorities are < 0, so use priorities >= 0 for the missing
 // sections.
-int curPrio = 0;
+int prio = 0;
-for (int &prio : priorities)
+for (InputSectionBase *sec : sections) {
-prio = curPrio++;
+if (order.try_emplace(sec, prio).second)
-uint32_t seed = *config->shuffleSectionSeed;
+++prio;
-std::mt19937 g(seed ? seed : std::random_device()());
-llvm::shuffle(priorities.begin(), priorities.end(), g);
-int prioIndex = 0;
-for (InputSectionBase *sec : inputSections) {
-if (order.try_emplace(sec, priorities[prioIndex]).second)
-++prioIndex;
 }
 }
 // Builds section order for handling --symbol-ordering-file.
 static DenseMap<const InputSectionBase *, int> buildSectionOrder() {
 for (Symbol *sym : symtab->symbols())
 if (!sym->isLazy())
 addSym(*sym);
 for (InputFile *file : objectFiles)
-for (Symbol *sym : file->getSymbols())
+for (Symbol *sym : file->getSymbols()) {
-if (sym->isLocal())
+if (!sym->isLocal())
-addSym(*sym);
+break;
+addSym(*sym);
+}
 if (config->warnSymbolOrdering)
 for (auto orderEntry : symbolOrder)
 if (!orderEntry.second.present)
 warn("symbol ordering file: no such symbol: " + orderEntry.first);
 // Never sort these.
 if (name == ".init" || name == ".fini")
 return;
+// IRelative relocations that usually live in the .rel[a].dyn section should
+// be processed last by the dynamic loader. To achieve that we add synthetic
+// sections in the required order from the beginning so that the in.relaIplt
+// section is placed last in an output section. Here we just do not apply
+// sorting for an output section which holds the in.relaIplt section.
+if (in.relaIplt->getParent() == sec)
+return;
 // Sort input sections by priority using the list provided by
 // --symbol-ordering-file or --shuffle-sections=. This is a least significant
 // digit radix sort. The sections may be sorted stably again by a more
 // significant key.
 if (!order.empty())
 if (auto *sec = dyn_cast<OutputSection>(base))
 sortSection(sec, order);
 }
 template <class ELFT> void Writer<ELFT>::sortSections() {
+llvm::TimeTraceScope timeScope("Sort sections");
 script->adjustSectionsBeforeSorting();
 // Don't sort if using -r. It is not necessary and we want to preserve the
 // relative order for SHF_LINK_ORDER sections.
 if (config->relocatable)
 script->adjustSectionsAfterSorting();
 }
 static bool compareByFilePosition(InputSection *a, InputSection *b) {
-InputSection *la = a->getLinkOrderDep();
+InputSection *la = a->flags & SHF_LINK_ORDER ? a->getLinkOrderDep() : nullptr;
-InputSection *lb = b->getLinkOrderDep();
+InputSection *lb = b->flags & SHF_LINK_ORDER ? b->getLinkOrderDep() : nullptr;
+// SHF_LINK_ORDER sections with non-zero sh_link are ordered before
+// non-SHF_LINK_ORDER sections and SHF_LINK_ORDER sections with zero sh_link.
+if (!la || !lb)
+return la && !lb;
 OutputSection *aOut = la->getParent();
 OutputSection *bOut = lb->getParent();
 if (aOut != bOut)
 return aOut->addr < bOut->addr;
 return la->outSecOff < lb->outSecOff;
 }
 template <class ELFT> void Writer<ELFT>::resolveShfLinkOrder() {
+llvm::TimeTraceScope timeScope("Resolve SHF_LINK_ORDER");
 for (OutputSection *sec : outputSections) {
 if (!(sec->flags & SHF_LINK_ORDER))
 continue;
 // The ARM.exidx section use SHF_LINK_ORDER, but we have consolidated
 // this processing inside the ARMExidxsyntheticsection::finalizeContents().
 if (!config->relocatable && config->emachine == EM_ARM &&
 sec->type == SHT_ARM_EXIDX)
 continue;
-// Link order may be distributed across several InputSectionDescriptions
+// Link order may be distributed across several InputSectionDescriptions.
-// but sort must consider them all at once.
+// Sorting is performed separately.
 std::vector<InputSection **> scriptSections;
 std::vector<InputSection *> sections;
-bool started = false, stopped = false;
 for (BaseCommand *base : sec->sectionCommands) {
-if (auto *isd = dyn_cast<InputSectionDescription>(base)) {
+auto *isd = dyn_cast<InputSectionDescription>(base);
-for (InputSection *&isec : isd->sections) {
+if (!isd)
-if (!(isec->flags & SHF_LINK_ORDER)) {
+continue;
-if (started)
+bool hasLinkOrder = false;
-stopped = true;
+scriptSections.clear();
-} else if (stopped) {
+sections.clear();
-error(toString(isec) + ": SHF_LINK_ORDER sections in " + sec->name +
+for (InputSection *&isec : isd->sections) {
-" are not contiguous");
+if (isec->flags & SHF_LINK_ORDER) {
-} else {
+InputSection *link = isec->getLinkOrderDep();
-started = true;
+if (link && !link->getParent())
+error(toString(isec) + ": sh_link points to discarded section " +
-scriptSections.push_back(&isec);
+toString(link));
-sections.push_back(isec);
+hasLinkOrder = true;
-InputSection *link = isec->getLinkOrderDep();
-if (!link->getParent())
-error(toString(isec) + ": sh_link points to discarded section " +
-toString(link));
-}
 }
-} else if (started) {
+scriptSections.push_back(&isec);
-stopped = true;
+sections.push_back(isec);
 }
-}
+if (hasLinkOrder && errorCount() == 0) {
+llvm::stable_sort(sections, compareByFilePosition);
-if (errorCount())
+for (int i = 0, n = sections.size(); i != n; ++i)
-continue;
+*scriptSections[i] = sections[i];
+}
-llvm::stable_sort(sections, compareByFilePosition);
+}
-for (int i = 0, n = sections.size(); i < n; ++i)
-*scriptSections[i] = sections[i];
 }
 }
 static void finalizeSynthetic(SyntheticSection *sec) {
-if (sec && sec->isNeeded() && sec->getParent())
+if (sec && sec->isNeeded() && sec->getParent()) {
+llvm::TimeTraceScope timeScope("Finalize synthetic sections", sec->name);
 sec->finalizeContents();
+}
 }
 // We need to generate and finalize the content that depends on the address of
 // InputSections. As the generation of the content may also alter InputSection
 // addresses we must converge to a fixed point. We do that here. See the comment
 // in Writer<ELFT>::finalizeSections().
 template <class ELFT> void Writer<ELFT>::finalizeAddressDependentContent() {
+llvm::TimeTraceScope timeScope("Finalize address dependent content");
 ThunkCreator tc;
 AArch64Err843419Patcher a64p;
 ARMErr657417Patcher a32p;
 script->assignAddresses();
 // .ARM.exidx and SHF_LINK_ORDER do not require precise addresses, but they
 int assignPasses = 0;
 for (;;) {
 bool changed = target->needsThunks && tc.createThunks(outputSections);
 // With Thunk Size much smaller than branch range we expect to
-// converge quickly; if we get to 10 something has gone wrong.
+// converge quickly; if we get to 15 something has gone wrong.
-if (changed && tc.pass >= 10) {
+if (changed && tc.pass >= 15) {
 error("thunk creation not converged");
 break;
 }
 if (config->fixCortexA53Errata843419) {
 warn("address (0x" + Twine::utohexstr(os->addr) + ") of section " +
 os->name + " is not a multiple of alignment (" +
 Twine(os->alignment) + ")");
 }
-// If Input Sections have been shrinked (basic block sections) then
+// If Input Sections have been shrunk (basic block sections) then
 // update symbol values and sizes associated with these sections.  With basic
 // block sections, input sections can shrink when the jump instructions at
 // the end of the section are relaxed.
 static void fixSymbolsAfterShrinking() {
 for (InputFile *File : objectFiles) {
 /*section=*/nullptr});
 ElfSym::tlsModuleBase = cast<Defined>(s);
 }
 }
-// This responsible for splitting up .eh_frame section into
+{
-// pieces. The relocation scan uses those pieces, so this has to be
+llvm::TimeTraceScope timeScope("Finalize .eh_frame");
-// earlier.
+// This responsible for splitting up .eh_frame section into
-for (Partition &part : partitions)
+// pieces. The relocation scan uses those pieces, so this has to be
-finalizeSynthetic(part.ehFrame);
+// earlier.
+for (Partition &part : partitions)
+finalizeSynthetic(part.ehFrame);
+}
 for (Symbol *sym : symtab->symbols())
 sym->isPreemptible = computeIsPreemptible(*sym);
 // Change values of linker-script-defined symbols from placeholders (assigned
 // by declareSymbols) to actual definitions.
 script->processSymbolAssignments();
-// Scan relocations. This must be done after every symbol is declared so that
+{
-// we can correctly decide if a dynamic relocation is needed. This is called
+llvm::TimeTraceScope timeScope("Scan relocations");
-// after processSymbolAssignments() because it needs to know whether a
+// Scan relocations. This must be done after every symbol is declared so
-// linker-script-defined symbol is absolute.
+// that we can correctly decide if a dynamic relocation is needed. This is
-ppc64noTocRelax.clear();
+// called after processSymbolAssignments() because it needs to know whether
-if (!config->relocatable) {
+// a linker-script-defined symbol is absolute.
-forEachRelSec(scanRelocations<ELFT>);
+ppc64noTocRelax.clear();
-reportUndefinedSymbols<ELFT>();
+if (!config->relocatable) {
+forEachRelSec(scanRelocations<ELFT>);
+reportUndefinedSymbols<ELFT>();
+}
 }
 if (in.plt && in.plt->isNeeded())
 in.plt->addSymbols();
 if (in.iplt && in.iplt->isNeeded())
 in.iplt->addSymbols();
-if (!config->allowShlibUndefined) {
+if (config->unresolvedSymbolsInShlib != UnresolvedPolicy::Ignore) {
+auto diagnose =
+config->unresolvedSymbolsInShlib == UnresolvedPolicy::ReportError
+? errorOrWarn
+: warn;
 // Error on undefined symbols in a shared object, if all of its DT_NEEDED
 // entries are seen. These cases would otherwise lead to runtime errors
 // reported by the dynamic linker.
 //
 // ld.bfd traces all DT_NEEDED to emulate the logic of the dynamic linker to
 // catch more cases. That is too much for us. Our approach resembles the one
 // used in ld.gold, achieves a good balance to be useful but not too smart.
-for (SharedFile *file : sharedFiles)
+for (SharedFile *file : sharedFiles) {
-file->allNeededIsKnown =
+bool allNeededIsKnown =
 llvm::all_of(file->dtNeeded, [&](StringRef needed) {
 return symtab->soNames.count(needed);
 });
+if (!allNeededIsKnown)
-for (Symbol *sym : symtab->symbols())
+continue;
-if (sym->isUndefined() && !sym->isWeak())
+for (Symbol *sym : file->requiredSymbols)
-if (auto *f = dyn_cast_or_null<SharedFile>(sym->file))
+if (sym->isUndefined() && !sym->isWeak())
-if (f->allNeededIsKnown)
+diagnose(toString(file) + ": undefined reference to " +
-error(toString(f) + ": undefined reference to " + toString(*sym));
+toString(*sym) + " [--no-allow-shlib-undefined]");
 }
+}
-// Now that we have defined all possible global symbols including linker-
-// synthesized ones. Visit all symbols to give the finishing touches.
+{
-for (Symbol *sym : symtab->symbols()) {
+llvm::TimeTraceScope timeScope("Add symbols to symtabs");
-if (!includeInSymtab(*sym))
+// Now that we have defined all possible global symbols including linker-
-continue;
+// synthesized ones. Visit all symbols to give the finishing touches.
-if (in.symTab)
+for (Symbol *sym : symtab->symbols()) {
-in.symTab->addSymbol(sym);
+if (!includeInSymtab(*sym))
+continue;
-if (sym->includeInDynsym()) {
+if (in.symTab)
-partitions[sym->partition - 1].dynSymTab->addSymbol(sym);
+in.symTab->addSymbol(sym);
-if (auto *file = dyn_cast_or_null<SharedFile>(sym->file))
-if (file->isNeeded && !sym->isUndefined())
+if (sym->includeInDynsym()) {
-addVerneed(sym);
+partitions[sym->partition - 1].dynSymTab->addSymbol(sym);
-}
+if (auto *file = dyn_cast_or_null<SharedFile>(sym->file))
-}
+if (file->isNeeded && !sym->isUndefined())
+addVerneed(sym);
-// We also need to scan the dynamic relocation tables of the other partitions
+}
-// and add any referenced symbols to the partition's dynsym.
+}
-for (Partition &part : MutableArrayRef<Partition>(partitions).slice(1)) {
-DenseSet<Symbol *> syms;
+// We also need to scan the dynamic relocation tables of the other
-for (const SymbolTableEntry &e : part.dynSymTab->getSymbols())
+// partitions and add any referenced symbols to the partition's dynsym.
-syms.insert(e.sym);
+for (Partition &part : MutableArrayRef<Partition>(partitions).slice(1)) {
-for (DynamicReloc &reloc : part.relaDyn->relocs)
+DenseSet<Symbol *> syms;
-if (reloc.sym && !reloc.useSymVA && syms.insert(reloc.sym).second)
+for (const SymbolTableEntry &e : part.dynSymTab->getSymbols())
-part.dynSymTab->addSymbol(reloc.sym);
+syms.insert(e.sym);
+for (DynamicReloc &reloc : part.relaDyn->relocs)
+if (reloc.sym && !reloc.useSymVA && syms.insert(reloc.sym).second)
+part.dynSymTab->addSymbol(reloc.sym);
+}
 }
 // Do not proceed if there was an undefined symbol.
 if (errorCount())
 return;
 // Some symbols are defined in term of program headers. Now that we
 // have the headers, we can find out which sections they point to.
 setReservedSymbolSections();
-finalizeSynthetic(in.bss);
+{
-finalizeSynthetic(in.bssRelRo);
+llvm::TimeTraceScope timeScope("Finalize synthetic sections");
-finalizeSynthetic(in.symTabShndx);
-finalizeSynthetic(in.shStrTab);
+finalizeSynthetic(in.bss);
-finalizeSynthetic(in.strTab);
+finalizeSynthetic(in.bssRelRo);
-finalizeSynthetic(in.got);
+finalizeSynthetic(in.symTabShndx);
-finalizeSynthetic(in.mipsGot);
+finalizeSynthetic(in.shStrTab);
-finalizeSynthetic(in.igotPlt);
+finalizeSynthetic(in.strTab);
-finalizeSynthetic(in.gotPlt);
+finalizeSynthetic(in.got);
-finalizeSynthetic(in.relaIplt);
+finalizeSynthetic(in.mipsGot);
-finalizeSynthetic(in.relaPlt);
+finalizeSynthetic(in.igotPlt);
-finalizeSynthetic(in.plt);
+finalizeSynthetic(in.gotPlt);
-finalizeSynthetic(in.iplt);
+finalizeSynthetic(in.relaIplt);
-finalizeSynthetic(in.ppc32Got2);
+finalizeSynthetic(in.relaPlt);
-finalizeSynthetic(in.partIndex);
+finalizeSynthetic(in.plt);
+finalizeSynthetic(in.iplt);
-// Dynamic section must be the last one in this list and dynamic
+finalizeSynthetic(in.ppc32Got2);
-// symbol table section (dynSymTab) must be the first one.
+finalizeSynthetic(in.partIndex);
-for (Partition &part : partitions) {
-finalizeSynthetic(part.dynSymTab);
+// Dynamic section must be the last one in this list and dynamic
-finalizeSynthetic(part.gnuHashTab);
+// symbol table section (dynSymTab) must be the first one.
-finalizeSynthetic(part.hashTab);
+for (Partition &part : partitions) {
-finalizeSynthetic(part.verDef);
+finalizeSynthetic(part.dynSymTab);
-finalizeSynthetic(part.relaDyn);
+finalizeSynthetic(part.gnuHashTab);
-finalizeSynthetic(part.relrDyn);
+finalizeSynthetic(part.hashTab);
-finalizeSynthetic(part.ehFrameHdr);
+finalizeSynthetic(part.verDef);
-finalizeSynthetic(part.verSym);
+finalizeSynthetic(part.relaDyn);
-finalizeSynthetic(part.verNeed);
+finalizeSynthetic(part.relrDyn);
-finalizeSynthetic(part.dynamic);
+finalizeSynthetic(part.ehFrameHdr);
+finalizeSynthetic(part.verSym);
+finalizeSynthetic(part.verNeed);
+finalizeSynthetic(part.dynamic);
+}
 }
 if (!script->hasSectionsCommand && !config->relocatable)
 fixSectionAlignments();
 //    values. They also might change after adding the thunks.
 finalizeAddressDependentContent();
 if (errorCount())
 return;
-// finalizeAddressDependentContent may have added local symbols to the static symbol table.
+{
-finalizeSynthetic(in.symTab);
+llvm::TimeTraceScope timeScope("Finalize synthetic sections");
-finalizeSynthetic(in.ppc64LongBranchTarget);
+// finalizeAddressDependentContent may have added local symbols to the
+// static symbol table.
+finalizeSynthetic(in.symTab);
+finalizeSynthetic(in.ppc64LongBranchTarget);
+}
 // Relaxation to delete inter-basic block jumps created by basic block
 // sections. Run after in.symTab is finalized as optimizeBasicBlockJumps
 // can relax jump instructions based on symbol offset.
 if (config->optimizeBBJumps)
 template <class ELFT>
 void Writer<ELFT>::addStartStopSymbols(OutputSection *sec) {
 StringRef s = sec->name;
 if (!isValidCIdentifier(s))
 return;
-addOptionalRegular(saver.save("__start_" + s), sec, 0, STV_PROTECTED);
+addOptionalRegular(saver.save("__start_" + s), sec, 0,
-addOptionalRegular(saver.save("__stop_" + s), sec, -1, STV_PROTECTED);
+config->zStartStopVisibility);
+addOptionalRegular(saver.save("__stop_" + s), sec, -1,
+config->zStartStopVisibility);
 }
 static bool needsPtLoad(OutputSection *sec) {
 if (!(sec->flags & SHF_ALLOC) || sec->noload)
 return false;
 relroEnd = sec;
 }
 }
 for (OutputSection *sec : outputSections) {
-if (!(sec->flags & SHF_ALLOC))
-break;
 if (!needsPtLoad(sec))
 continue;
 // Normally, sections in partitions other than the current partition are
 // ignored. But partition number 255 is a special case: it contains the
 return off;
 return off + os->size;
 }
 template <class ELFT> void Writer<ELFT>::assignFileOffsetsBinary() {
-uint64_t off = 0;
+// Compute the minimum LMA of all non-empty non-NOBITS sections as minAddr.
+auto needsOffset = [](OutputSection &sec) {
+return sec.type != SHT_NOBITS && (sec.flags & SHF_ALLOC) && sec.size > 0;
+};
+uint64_t minAddr = UINT64_MAX;
 for (OutputSection *sec : outputSections)
-if (sec->flags & SHF_ALLOC)
+if (needsOffset(*sec)) {
-off = setFileOffset(sec, off);
+sec->offset = sec->getLMA();
-fileSize = alignTo(off, config->wordsize);
+minAddr = std::min(minAddr, sec->offset);
+}
+// Sections are laid out at LMA minus minAddr.
+fileSize = 0;
+for (OutputSection *sec : outputSections)
+if (needsOffset(*sec)) {
+sec->offset -= minAddr;
+fileSize = std::max(fileSize, sec->offset + sec->size);
+}
 }
 static std::string rangeToString(uint64_t addr, uint64_t len) {
 return "[0x" + utohexstr(addr) + ", 0x" + utohexstr(addr + len - 1) + "]";
 }
 for (Partition &part : partitions)
 for (PhdrEntry *p : part.phdrs)
 if (p->p_type == PT_LOAD && (p->p_flags & PF_X))
 lastRX = p;
+// Layout SHF_ALLOC sections before non-SHF_ALLOC sections. A non-SHF_ALLOC
+// will not occupy file offsets contained by a PT_LOAD.
 for (OutputSection *sec : outputSections) {
+if (!(sec->flags & SHF_ALLOC))
+continue;
 off = setFileOffset(sec, off);
 // If this is a last section of the last executable segment and that
 // segment is the last loadable segment, align the offset of the
 // following section to avoid loading non-segments parts of the file.
 if (config->zSeparate != SeparateSegmentKind::None && lastRX &&
 lastRX->lastSec == sec)
 off = alignTo(off, config->commonPageSize);
 }
+for (OutputSection *sec : outputSections)
+if (!(sec->flags & SHF_ALLOC))
+off = setFileOffset(sec, off);
 sectionHeaderOff = alignTo(off, config->wordsize);
 fileSize = sectionHeaderOff + (outputSections.size() + 1) * sizeof(Elf_Shdr);
 // Our logic assumes that sections have rising VA within the same segment.
 // Open a result file.
 template <class ELFT> void Writer<ELFT>::openFile() {
 uint64_t maxSize = config->is64 ? INT64_MAX : UINT32_MAX;
 if (fileSize != size_t(fileSize) || maxSize < fileSize) {
-error("output file too large: " + Twine(fileSize) + " bytes");
+std::string msg;
+raw_string_ostream s(msg);
+s << "output file too large: " << Twine(fileSize) << " bytes\n"
+<< "section sizes:\n";
+for (OutputSection *os : outputSections)
+s << os->name << ' ' << os->size << "\n";
+error(s.str());
 return;
 }
 unlinkAsync(config->outputFile);
 unsigned flags = 0;
 sec->writeTo<ELFT>(Out::bufferStart + sec->offset);
 for (OutputSection *sec : outputSections)
 if (sec->type != SHT_REL && sec->type != SHT_RELA)
 sec->writeTo<ELFT>(Out::bufferStart + sec->offset);
-}
-// Split one uint8 array into small pieces of uint8 arrays.
-static std::vector<ArrayRef<uint8_t>> split(ArrayRef<uint8_t> arr,
-size_t chunkSize) {
-std::vector<ArrayRef<uint8_t>> ret;
-while (arr.size() > chunkSize) {
-ret.push_back(arr.take_front(chunkSize));
-arr = arr.drop_front(chunkSize);
-}
-if (!arr.empty())
-ret.push_back(arr);
-return ret;
 }
 // Computes a hash value of Data using a given hash function.
 // In order to utilize multiple cores, we first split data into 1MB
 // chunks, compute a hash for each chunk, and then compute a hash value

Mercurial > hg > CbC > CbC_llvm

comparison lld/ELF/Writer.cpp @ 207:2e18cbf3894f