10b57cec5SDimitry Andric //===- Writer.cpp ---------------------------------------------------------===// 20b57cec5SDimitry Andric // 30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information. 50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 60b57cec5SDimitry Andric // 70b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 80b57cec5SDimitry Andric 90b57cec5SDimitry Andric #include "Writer.h" 100b57cec5SDimitry Andric #include "AArch64ErrataFix.h" 1185868e8aSDimitry Andric #include "ARMErrataFix.h" 120b57cec5SDimitry Andric #include "CallGraphSort.h" 130b57cec5SDimitry Andric #include "Config.h" 140b57cec5SDimitry Andric #include "LinkerScript.h" 150b57cec5SDimitry Andric #include "MapFile.h" 160b57cec5SDimitry Andric #include "OutputSections.h" 170b57cec5SDimitry Andric #include "Relocations.h" 180b57cec5SDimitry Andric #include "SymbolTable.h" 190b57cec5SDimitry Andric #include "Symbols.h" 200b57cec5SDimitry Andric #include "SyntheticSections.h" 210b57cec5SDimitry Andric #include "Target.h" 22fe6060f1SDimitry Andric #include "lld/Common/Arrays.h" 23*04eeddc0SDimitry Andric #include "lld/Common/CommonLinkerContext.h" 240b57cec5SDimitry Andric #include "lld/Common/Filesystem.h" 250b57cec5SDimitry Andric #include "lld/Common/Strings.h" 260b57cec5SDimitry Andric #include "llvm/ADT/StringMap.h" 270b57cec5SDimitry Andric #include "llvm/ADT/StringSwitch.h" 285ffd83dbSDimitry Andric #include "llvm/Support/Parallel.h" 290b57cec5SDimitry Andric #include "llvm/Support/RandomNumberGenerator.h" 300b57cec5SDimitry Andric #include "llvm/Support/SHA1.h" 315ffd83dbSDimitry Andric #include "llvm/Support/TimeProfiler.h" 320b57cec5SDimitry Andric #include "llvm/Support/xxhash.h" 330b57cec5SDimitry Andric #include <climits> 340b57cec5SDimitry Andric 355ffd83dbSDimitry Andric #define DEBUG_TYPE "lld" 365ffd83dbSDimitry Andric 370b57cec5SDimitry Andric using namespace llvm; 380b57cec5SDimitry Andric using namespace llvm::ELF; 390b57cec5SDimitry Andric using namespace llvm::object; 400b57cec5SDimitry Andric using namespace llvm::support; 410b57cec5SDimitry Andric using namespace llvm::support::endian; 425ffd83dbSDimitry Andric using namespace lld; 435ffd83dbSDimitry Andric using namespace lld::elf; 440b57cec5SDimitry Andric 450b57cec5SDimitry Andric namespace { 460b57cec5SDimitry Andric // The writer writes a SymbolTable result to a file. 470b57cec5SDimitry Andric template <class ELFT> class Writer { 480b57cec5SDimitry Andric public: 49e8d8bef9SDimitry Andric LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 50e8d8bef9SDimitry Andric 510b57cec5SDimitry Andric Writer() : buffer(errorHandler().outputBuffer) {} 520b57cec5SDimitry Andric 530b57cec5SDimitry Andric void run(); 540b57cec5SDimitry Andric 550b57cec5SDimitry Andric private: 560b57cec5SDimitry Andric void copyLocalSymbols(); 570b57cec5SDimitry Andric void addSectionSymbols(); 580b57cec5SDimitry Andric void sortSections(); 590b57cec5SDimitry Andric void resolveShfLinkOrder(); 600b57cec5SDimitry Andric void finalizeAddressDependentContent(); 615ffd83dbSDimitry Andric void optimizeBasicBlockJumps(); 620b57cec5SDimitry Andric void sortInputSections(); 630b57cec5SDimitry Andric void finalizeSections(); 640b57cec5SDimitry Andric void checkExecuteOnly(); 650b57cec5SDimitry Andric void setReservedSymbolSections(); 660b57cec5SDimitry Andric 67*04eeddc0SDimitry Andric SmallVector<PhdrEntry *, 0> createPhdrs(Partition &part); 680b57cec5SDimitry Andric void addPhdrForSection(Partition &part, unsigned shType, unsigned pType, 690b57cec5SDimitry Andric unsigned pFlags); 700b57cec5SDimitry Andric void assignFileOffsets(); 710b57cec5SDimitry Andric void assignFileOffsetsBinary(); 720b57cec5SDimitry Andric void setPhdrs(Partition &part); 730b57cec5SDimitry Andric void checkSections(); 740b57cec5SDimitry Andric void fixSectionAlignments(); 750b57cec5SDimitry Andric void openFile(); 760b57cec5SDimitry Andric void writeTrapInstr(); 770b57cec5SDimitry Andric void writeHeader(); 780b57cec5SDimitry Andric void writeSections(); 790b57cec5SDimitry Andric void writeSectionsBinary(); 800b57cec5SDimitry Andric void writeBuildId(); 810b57cec5SDimitry Andric 820b57cec5SDimitry Andric std::unique_ptr<FileOutputBuffer> &buffer; 830b57cec5SDimitry Andric 840b57cec5SDimitry Andric void addRelIpltSymbols(); 850b57cec5SDimitry Andric void addStartEndSymbols(); 860b57cec5SDimitry Andric void addStartStopSymbols(OutputSection *sec); 870b57cec5SDimitry Andric 880b57cec5SDimitry Andric uint64_t fileSize; 890b57cec5SDimitry Andric uint64_t sectionHeaderOff; 900b57cec5SDimitry Andric }; 910b57cec5SDimitry Andric } // anonymous namespace 920b57cec5SDimitry Andric 930b57cec5SDimitry Andric static bool needsInterpSection() { 9455e4f9d5SDimitry Andric return !config->relocatable && !config->shared && 9555e4f9d5SDimitry Andric !config->dynamicLinker.empty() && script->needsInterpSection(); 960b57cec5SDimitry Andric } 970b57cec5SDimitry Andric 985ffd83dbSDimitry Andric template <class ELFT> void elf::writeResult() { 995ffd83dbSDimitry Andric Writer<ELFT>().run(); 1000b57cec5SDimitry Andric } 1010b57cec5SDimitry Andric 102*04eeddc0SDimitry Andric static void removeEmptyPTLoad(SmallVector<PhdrEntry *, 0> &phdrs) { 1035ffd83dbSDimitry Andric auto it = std::stable_partition( 1045ffd83dbSDimitry Andric phdrs.begin(), phdrs.end(), [&](const PhdrEntry *p) { 1055ffd83dbSDimitry Andric if (p->p_type != PT_LOAD) 1065ffd83dbSDimitry Andric return true; 1075ffd83dbSDimitry Andric if (!p->firstSec) 1085ffd83dbSDimitry Andric return false; 1095ffd83dbSDimitry Andric uint64_t size = p->lastSec->addr + p->lastSec->size - p->firstSec->addr; 1105ffd83dbSDimitry Andric return size != 0; 1115ffd83dbSDimitry Andric }); 1125ffd83dbSDimitry Andric 1135ffd83dbSDimitry Andric // Clear OutputSection::ptLoad for sections contained in removed 1145ffd83dbSDimitry Andric // segments. 1155ffd83dbSDimitry Andric DenseSet<PhdrEntry *> removed(it, phdrs.end()); 1165ffd83dbSDimitry Andric for (OutputSection *sec : outputSections) 1175ffd83dbSDimitry Andric if (removed.count(sec->ptLoad)) 1185ffd83dbSDimitry Andric sec->ptLoad = nullptr; 1195ffd83dbSDimitry Andric phdrs.erase(it, phdrs.end()); 1205ffd83dbSDimitry Andric } 1215ffd83dbSDimitry Andric 1225ffd83dbSDimitry Andric void elf::copySectionsIntoPartitions() { 123*04eeddc0SDimitry Andric SmallVector<InputSectionBase *, 0> newSections; 1240b57cec5SDimitry Andric for (unsigned part = 2; part != partitions.size() + 1; ++part) { 1250b57cec5SDimitry Andric for (InputSectionBase *s : inputSections) { 1260b57cec5SDimitry Andric if (!(s->flags & SHF_ALLOC) || !s->isLive()) 1270b57cec5SDimitry Andric continue; 1280b57cec5SDimitry Andric InputSectionBase *copy; 1290b57cec5SDimitry Andric if (s->type == SHT_NOTE) 1300b57cec5SDimitry Andric copy = make<InputSection>(cast<InputSection>(*s)); 1310b57cec5SDimitry Andric else if (auto *es = dyn_cast<EhInputSection>(s)) 1320b57cec5SDimitry Andric copy = make<EhInputSection>(*es); 1330b57cec5SDimitry Andric else 1340b57cec5SDimitry Andric continue; 1350b57cec5SDimitry Andric copy->partition = part; 1360b57cec5SDimitry Andric newSections.push_back(copy); 1370b57cec5SDimitry Andric } 1380b57cec5SDimitry Andric } 1390b57cec5SDimitry Andric 1400b57cec5SDimitry Andric inputSections.insert(inputSections.end(), newSections.begin(), 1410b57cec5SDimitry Andric newSections.end()); 1420b57cec5SDimitry Andric } 1430b57cec5SDimitry Andric 1445ffd83dbSDimitry Andric void elf::combineEhSections() { 145e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Combine EH sections"); 1460b57cec5SDimitry Andric for (InputSectionBase *&s : inputSections) { 1470b57cec5SDimitry Andric // Ignore dead sections and the partition end marker (.part.end), 1480b57cec5SDimitry Andric // whose partition number is out of bounds. 1490b57cec5SDimitry Andric if (!s->isLive() || s->partition == 255) 1500b57cec5SDimitry Andric continue; 1510b57cec5SDimitry Andric 1520b57cec5SDimitry Andric Partition &part = s->getPartition(); 1530b57cec5SDimitry Andric if (auto *es = dyn_cast<EhInputSection>(s)) { 15485868e8aSDimitry Andric part.ehFrame->addSection(es); 1550b57cec5SDimitry Andric s = nullptr; 1560b57cec5SDimitry Andric } else if (s->kind() == SectionBase::Regular && part.armExidx && 1570b57cec5SDimitry Andric part.armExidx->addSection(cast<InputSection>(s))) { 1580b57cec5SDimitry Andric s = nullptr; 1590b57cec5SDimitry Andric } 1600b57cec5SDimitry Andric } 1610b57cec5SDimitry Andric 162349cc55cSDimitry Andric llvm::erase_value(inputSections, nullptr); 1630b57cec5SDimitry Andric } 1640b57cec5SDimitry Andric 1650b57cec5SDimitry Andric static Defined *addOptionalRegular(StringRef name, SectionBase *sec, 166349cc55cSDimitry Andric uint64_t val, uint8_t stOther = STV_HIDDEN) { 1670b57cec5SDimitry Andric Symbol *s = symtab->find(name); 1680b57cec5SDimitry Andric if (!s || s->isDefined()) 1690b57cec5SDimitry Andric return nullptr; 1700b57cec5SDimitry Andric 171349cc55cSDimitry Andric s->resolve(Defined{/*file=*/nullptr, name, STB_GLOBAL, stOther, STT_NOTYPE, 172349cc55cSDimitry Andric val, 1730b57cec5SDimitry Andric /*size=*/0, sec}); 1740b57cec5SDimitry Andric return cast<Defined>(s); 1750b57cec5SDimitry Andric } 1760b57cec5SDimitry Andric 1770b57cec5SDimitry Andric static Defined *addAbsolute(StringRef name) { 1780b57cec5SDimitry Andric Symbol *sym = symtab->addSymbol(Defined{nullptr, name, STB_GLOBAL, STV_HIDDEN, 1790b57cec5SDimitry Andric STT_NOTYPE, 0, 0, nullptr}); 1800b57cec5SDimitry Andric return cast<Defined>(sym); 1810b57cec5SDimitry Andric } 1820b57cec5SDimitry Andric 1830b57cec5SDimitry Andric // The linker is expected to define some symbols depending on 1840b57cec5SDimitry Andric // the linking result. This function defines such symbols. 1855ffd83dbSDimitry Andric void elf::addReservedSymbols() { 1860b57cec5SDimitry Andric if (config->emachine == EM_MIPS) { 1870b57cec5SDimitry Andric // Define _gp for MIPS. st_value of _gp symbol will be updated by Writer 1880b57cec5SDimitry Andric // so that it points to an absolute address which by default is relative 1890b57cec5SDimitry Andric // to GOT. Default offset is 0x7ff0. 1900b57cec5SDimitry Andric // See "Global Data Symbols" in Chapter 6 in the following document: 1910b57cec5SDimitry Andric // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf 1920b57cec5SDimitry Andric ElfSym::mipsGp = addAbsolute("_gp"); 1930b57cec5SDimitry Andric 1940b57cec5SDimitry Andric // On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between 1950b57cec5SDimitry Andric // start of function and 'gp' pointer into GOT. 1960b57cec5SDimitry Andric if (symtab->find("_gp_disp")) 1970b57cec5SDimitry Andric ElfSym::mipsGpDisp = addAbsolute("_gp_disp"); 1980b57cec5SDimitry Andric 1990b57cec5SDimitry Andric // The __gnu_local_gp is a magic symbol equal to the current value of 'gp' 2000b57cec5SDimitry Andric // pointer. This symbol is used in the code generated by .cpload pseudo-op 2010b57cec5SDimitry Andric // in case of using -mno-shared option. 2020b57cec5SDimitry Andric // https://sourceware.org/ml/binutils/2004-12/msg00094.html 2030b57cec5SDimitry Andric if (symtab->find("__gnu_local_gp")) 2040b57cec5SDimitry Andric ElfSym::mipsLocalGp = addAbsolute("__gnu_local_gp"); 2050b57cec5SDimitry Andric } else if (config->emachine == EM_PPC) { 2060b57cec5SDimitry Andric // glibc *crt1.o has a undefined reference to _SDA_BASE_. Since we don't 2070b57cec5SDimitry Andric // support Small Data Area, define it arbitrarily as 0. 2080b57cec5SDimitry Andric addOptionalRegular("_SDA_BASE_", nullptr, 0, STV_HIDDEN); 2095ffd83dbSDimitry Andric } else if (config->emachine == EM_PPC64) { 2105ffd83dbSDimitry Andric addPPC64SaveRestore(); 2110b57cec5SDimitry Andric } 2120b57cec5SDimitry Andric 2130b57cec5SDimitry Andric // The Power Architecture 64-bit v2 ABI defines a TableOfContents (TOC) which 2140b57cec5SDimitry Andric // combines the typical ELF GOT with the small data sections. It commonly 2150b57cec5SDimitry Andric // includes .got .toc .sdata .sbss. The .TOC. symbol replaces both 2160b57cec5SDimitry Andric // _GLOBAL_OFFSET_TABLE_ and _SDA_BASE_ from the 32-bit ABI. It is used to 2170b57cec5SDimitry Andric // represent the TOC base which is offset by 0x8000 bytes from the start of 2180b57cec5SDimitry Andric // the .got section. 2190b57cec5SDimitry Andric // We do not allow _GLOBAL_OFFSET_TABLE_ to be defined by input objects as the 2200b57cec5SDimitry Andric // correctness of some relocations depends on its value. 2210b57cec5SDimitry Andric StringRef gotSymName = 2220b57cec5SDimitry Andric (config->emachine == EM_PPC64) ? ".TOC." : "_GLOBAL_OFFSET_TABLE_"; 2230b57cec5SDimitry Andric 2240b57cec5SDimitry Andric if (Symbol *s = symtab->find(gotSymName)) { 2250b57cec5SDimitry Andric if (s->isDefined()) { 2260b57cec5SDimitry Andric error(toString(s->file) + " cannot redefine linker defined symbol '" + 2270b57cec5SDimitry Andric gotSymName + "'"); 2280b57cec5SDimitry Andric return; 2290b57cec5SDimitry Andric } 2300b57cec5SDimitry Andric 2310b57cec5SDimitry Andric uint64_t gotOff = 0; 2320b57cec5SDimitry Andric if (config->emachine == EM_PPC64) 2330b57cec5SDimitry Andric gotOff = 0x8000; 2340b57cec5SDimitry Andric 2350b57cec5SDimitry Andric s->resolve(Defined{/*file=*/nullptr, gotSymName, STB_GLOBAL, STV_HIDDEN, 2360b57cec5SDimitry Andric STT_NOTYPE, gotOff, /*size=*/0, Out::elfHeader}); 2370b57cec5SDimitry Andric ElfSym::globalOffsetTable = cast<Defined>(s); 2380b57cec5SDimitry Andric } 2390b57cec5SDimitry Andric 2400b57cec5SDimitry Andric // __ehdr_start is the location of ELF file headers. Note that we define 2410b57cec5SDimitry Andric // this symbol unconditionally even when using a linker script, which 2420b57cec5SDimitry Andric // differs from the behavior implemented by GNU linker which only define 2430b57cec5SDimitry Andric // this symbol if ELF headers are in the memory mapped segment. 2440b57cec5SDimitry Andric addOptionalRegular("__ehdr_start", Out::elfHeader, 0, STV_HIDDEN); 2450b57cec5SDimitry Andric 2460b57cec5SDimitry Andric // __executable_start is not documented, but the expectation of at 2470b57cec5SDimitry Andric // least the Android libc is that it points to the ELF header. 2480b57cec5SDimitry Andric addOptionalRegular("__executable_start", Out::elfHeader, 0, STV_HIDDEN); 2490b57cec5SDimitry Andric 2500b57cec5SDimitry Andric // __dso_handle symbol is passed to cxa_finalize as a marker to identify 2510b57cec5SDimitry Andric // each DSO. The address of the symbol doesn't matter as long as they are 2520b57cec5SDimitry Andric // different in different DSOs, so we chose the start address of the DSO. 2530b57cec5SDimitry Andric addOptionalRegular("__dso_handle", Out::elfHeader, 0, STV_HIDDEN); 2540b57cec5SDimitry Andric 255480093f4SDimitry Andric // If linker script do layout we do not need to create any standard symbols. 2560b57cec5SDimitry Andric if (script->hasSectionsCommand) 2570b57cec5SDimitry Andric return; 2580b57cec5SDimitry Andric 2590b57cec5SDimitry Andric auto add = [](StringRef s, int64_t pos) { 2600b57cec5SDimitry Andric return addOptionalRegular(s, Out::elfHeader, pos, STV_DEFAULT); 2610b57cec5SDimitry Andric }; 2620b57cec5SDimitry Andric 2630b57cec5SDimitry Andric ElfSym::bss = add("__bss_start", 0); 2640b57cec5SDimitry Andric ElfSym::end1 = add("end", -1); 2650b57cec5SDimitry Andric ElfSym::end2 = add("_end", -1); 2660b57cec5SDimitry Andric ElfSym::etext1 = add("etext", -1); 2670b57cec5SDimitry Andric ElfSym::etext2 = add("_etext", -1); 2680b57cec5SDimitry Andric ElfSym::edata1 = add("edata", -1); 2690b57cec5SDimitry Andric ElfSym::edata2 = add("_edata", -1); 2700b57cec5SDimitry Andric } 2710b57cec5SDimitry Andric 2720b57cec5SDimitry Andric static OutputSection *findSection(StringRef name, unsigned partition = 1) { 2734824e7fdSDimitry Andric for (SectionCommand *cmd : script->sectionCommands) 2744824e7fdSDimitry Andric if (auto *sec = dyn_cast<OutputSection>(cmd)) 2750b57cec5SDimitry Andric if (sec->name == name && sec->partition == partition) 2760b57cec5SDimitry Andric return sec; 2770b57cec5SDimitry Andric return nullptr; 2780b57cec5SDimitry Andric } 2790b57cec5SDimitry Andric 2805ffd83dbSDimitry Andric template <class ELFT> void elf::createSyntheticSections() { 2810b57cec5SDimitry Andric // Initialize all pointers with NULL. This is needed because 2820b57cec5SDimitry Andric // you can call lld::elf::main more than once as a library. 2834824e7fdSDimitry Andric Out::tlsPhdr = nullptr; 2844824e7fdSDimitry Andric Out::preinitArray = nullptr; 2854824e7fdSDimitry Andric Out::initArray = nullptr; 2864824e7fdSDimitry Andric Out::finiArray = nullptr; 2870b57cec5SDimitry Andric 28885868e8aSDimitry Andric // Add the .interp section first because it is not a SyntheticSection. 28985868e8aSDimitry Andric // The removeUnusedSyntheticSections() function relies on the 29085868e8aSDimitry Andric // SyntheticSections coming last. 29185868e8aSDimitry Andric if (needsInterpSection()) { 29285868e8aSDimitry Andric for (size_t i = 1; i <= partitions.size(); ++i) { 29385868e8aSDimitry Andric InputSection *sec = createInterpSection(); 29485868e8aSDimitry Andric sec->partition = i; 29585868e8aSDimitry Andric inputSections.push_back(sec); 29685868e8aSDimitry Andric } 29785868e8aSDimitry Andric } 29885868e8aSDimitry Andric 2990eae32dcSDimitry Andric auto add = [](SyntheticSection &sec) { inputSections.push_back(&sec); }; 3000b57cec5SDimitry Andric 301*04eeddc0SDimitry Andric in.shStrTab = std::make_unique<StringTableSection>(".shstrtab", false); 3020b57cec5SDimitry Andric 3030b57cec5SDimitry Andric Out::programHeaders = make<OutputSection>("", 0, SHF_ALLOC); 3040b57cec5SDimitry Andric Out::programHeaders->alignment = config->wordsize; 3050b57cec5SDimitry Andric 3060b57cec5SDimitry Andric if (config->strip != StripPolicy::All) { 307*04eeddc0SDimitry Andric in.strTab = std::make_unique<StringTableSection>(".strtab", false); 308*04eeddc0SDimitry Andric in.symTab = std::make_unique<SymbolTableSection<ELFT>>(*in.strTab); 309*04eeddc0SDimitry Andric in.symTabShndx = std::make_unique<SymtabShndxSection>(); 3100b57cec5SDimitry Andric } 3110b57cec5SDimitry Andric 312*04eeddc0SDimitry Andric in.bss = std::make_unique<BssSection>(".bss", 0, 1); 3130eae32dcSDimitry Andric add(*in.bss); 3140b57cec5SDimitry Andric 3150b57cec5SDimitry Andric // If there is a SECTIONS command and a .data.rel.ro section name use name 3160b57cec5SDimitry Andric // .data.rel.ro.bss so that we match in the .data.rel.ro output section. 3170b57cec5SDimitry Andric // This makes sure our relro is contiguous. 3180b57cec5SDimitry Andric bool hasDataRelRo = 3190b57cec5SDimitry Andric script->hasSectionsCommand && findSection(".data.rel.ro", 0); 320*04eeddc0SDimitry Andric in.bssRelRo = std::make_unique<BssSection>( 321*04eeddc0SDimitry Andric hasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1); 3220eae32dcSDimitry Andric add(*in.bssRelRo); 3230b57cec5SDimitry Andric 3240b57cec5SDimitry Andric // Add MIPS-specific sections. 3250b57cec5SDimitry Andric if (config->emachine == EM_MIPS) { 3260b57cec5SDimitry Andric if (!config->shared && config->hasDynSymTab) { 327*04eeddc0SDimitry Andric in.mipsRldMap = std::make_unique<MipsRldMapSection>(); 3280eae32dcSDimitry Andric add(*in.mipsRldMap); 3290b57cec5SDimitry Andric } 3300b57cec5SDimitry Andric if (auto *sec = MipsAbiFlagsSection<ELFT>::create()) 3310eae32dcSDimitry Andric add(*sec); 3320b57cec5SDimitry Andric if (auto *sec = MipsOptionsSection<ELFT>::create()) 3330eae32dcSDimitry Andric add(*sec); 3340b57cec5SDimitry Andric if (auto *sec = MipsReginfoSection<ELFT>::create()) 3350eae32dcSDimitry Andric add(*sec); 3360b57cec5SDimitry Andric } 3370b57cec5SDimitry Andric 33885868e8aSDimitry Andric StringRef relaDynName = config->isRela ? ".rela.dyn" : ".rel.dyn"; 33985868e8aSDimitry Andric 3400b57cec5SDimitry Andric for (Partition &part : partitions) { 3410eae32dcSDimitry Andric auto add = [&](SyntheticSection &sec) { 3420eae32dcSDimitry Andric sec.partition = part.getNumber(); 3430eae32dcSDimitry Andric inputSections.push_back(&sec); 3440b57cec5SDimitry Andric }; 3450b57cec5SDimitry Andric 3460b57cec5SDimitry Andric if (!part.name.empty()) { 347*04eeddc0SDimitry Andric part.elfHeader = std::make_unique<PartitionElfHeaderSection<ELFT>>(); 3480b57cec5SDimitry Andric part.elfHeader->name = part.name; 3490eae32dcSDimitry Andric add(*part.elfHeader); 3500b57cec5SDimitry Andric 351*04eeddc0SDimitry Andric part.programHeaders = 352*04eeddc0SDimitry Andric std::make_unique<PartitionProgramHeadersSection<ELFT>>(); 3530eae32dcSDimitry Andric add(*part.programHeaders); 3540b57cec5SDimitry Andric } 3550b57cec5SDimitry Andric 3560b57cec5SDimitry Andric if (config->buildId != BuildIdKind::None) { 357*04eeddc0SDimitry Andric part.buildId = std::make_unique<BuildIdSection>(); 3580eae32dcSDimitry Andric add(*part.buildId); 3590b57cec5SDimitry Andric } 3600b57cec5SDimitry Andric 361*04eeddc0SDimitry Andric part.dynStrTab = std::make_unique<StringTableSection>(".dynstr", true); 362*04eeddc0SDimitry Andric part.dynSymTab = 363*04eeddc0SDimitry Andric std::make_unique<SymbolTableSection<ELFT>>(*part.dynStrTab); 364*04eeddc0SDimitry Andric part.dynamic = std::make_unique<DynamicSection<ELFT>>(); 36585868e8aSDimitry Andric if (config->androidPackDynRelocs) 36685868e8aSDimitry Andric part.relaDyn = 367*04eeddc0SDimitry Andric std::make_unique<AndroidPackedRelocationSection<ELFT>>(relaDynName); 368*04eeddc0SDimitry Andric else 369*04eeddc0SDimitry Andric part.relaDyn = std::make_unique<RelocationSection<ELFT>>( 370*04eeddc0SDimitry Andric relaDynName, config->zCombreloc); 3710b57cec5SDimitry Andric 3720b57cec5SDimitry Andric if (config->hasDynSymTab) { 3730eae32dcSDimitry Andric add(*part.dynSymTab); 3740b57cec5SDimitry Andric 375*04eeddc0SDimitry Andric part.verSym = std::make_unique<VersionTableSection>(); 3760eae32dcSDimitry Andric add(*part.verSym); 3770b57cec5SDimitry Andric 37885868e8aSDimitry Andric if (!namedVersionDefs().empty()) { 379*04eeddc0SDimitry Andric part.verDef = std::make_unique<VersionDefinitionSection>(); 3800eae32dcSDimitry Andric add(*part.verDef); 3810b57cec5SDimitry Andric } 3820b57cec5SDimitry Andric 383*04eeddc0SDimitry Andric part.verNeed = std::make_unique<VersionNeedSection<ELFT>>(); 3840eae32dcSDimitry Andric add(*part.verNeed); 3850b57cec5SDimitry Andric 3860b57cec5SDimitry Andric if (config->gnuHash) { 387*04eeddc0SDimitry Andric part.gnuHashTab = std::make_unique<GnuHashTableSection>(); 3880eae32dcSDimitry Andric add(*part.gnuHashTab); 3890b57cec5SDimitry Andric } 3900b57cec5SDimitry Andric 3910b57cec5SDimitry Andric if (config->sysvHash) { 392*04eeddc0SDimitry Andric part.hashTab = std::make_unique<HashTableSection>(); 3930eae32dcSDimitry Andric add(*part.hashTab); 3940b57cec5SDimitry Andric } 3950b57cec5SDimitry Andric 3960eae32dcSDimitry Andric add(*part.dynamic); 3970eae32dcSDimitry Andric add(*part.dynStrTab); 3980eae32dcSDimitry Andric add(*part.relaDyn); 3990b57cec5SDimitry Andric } 4000b57cec5SDimitry Andric 4010b57cec5SDimitry Andric if (config->relrPackDynRelocs) { 402*04eeddc0SDimitry Andric part.relrDyn = std::make_unique<RelrSection<ELFT>>(); 4030eae32dcSDimitry Andric add(*part.relrDyn); 4040b57cec5SDimitry Andric } 4050b57cec5SDimitry Andric 4060b57cec5SDimitry Andric if (!config->relocatable) { 4070b57cec5SDimitry Andric if (config->ehFrameHdr) { 408*04eeddc0SDimitry Andric part.ehFrameHdr = std::make_unique<EhFrameHeader>(); 4090eae32dcSDimitry Andric add(*part.ehFrameHdr); 4100b57cec5SDimitry Andric } 411*04eeddc0SDimitry Andric part.ehFrame = std::make_unique<EhFrameSection>(); 4120eae32dcSDimitry Andric add(*part.ehFrame); 4130b57cec5SDimitry Andric } 4140b57cec5SDimitry Andric 4150b57cec5SDimitry Andric if (config->emachine == EM_ARM && !config->relocatable) { 4160b57cec5SDimitry Andric // The ARMExidxsyntheticsection replaces all the individual .ARM.exidx 4170b57cec5SDimitry Andric // InputSections. 418*04eeddc0SDimitry Andric part.armExidx = std::make_unique<ARMExidxSyntheticSection>(); 4190eae32dcSDimitry Andric add(*part.armExidx); 4200b57cec5SDimitry Andric } 4210b57cec5SDimitry Andric } 4220b57cec5SDimitry Andric 4230b57cec5SDimitry Andric if (partitions.size() != 1) { 4240b57cec5SDimitry Andric // Create the partition end marker. This needs to be in partition number 255 4250b57cec5SDimitry Andric // so that it is sorted after all other partitions. It also has other 4260b57cec5SDimitry Andric // special handling (see createPhdrs() and combineEhSections()). 427*04eeddc0SDimitry Andric in.partEnd = 428*04eeddc0SDimitry Andric std::make_unique<BssSection>(".part.end", config->maxPageSize, 1); 4290b57cec5SDimitry Andric in.partEnd->partition = 255; 4300eae32dcSDimitry Andric add(*in.partEnd); 4310b57cec5SDimitry Andric 432*04eeddc0SDimitry Andric in.partIndex = std::make_unique<PartitionIndexSection>(); 433*04eeddc0SDimitry Andric addOptionalRegular("__part_index_begin", in.partIndex.get(), 0); 434*04eeddc0SDimitry Andric addOptionalRegular("__part_index_end", in.partIndex.get(), 4350b57cec5SDimitry Andric in.partIndex->getSize()); 4360eae32dcSDimitry Andric add(*in.partIndex); 4370b57cec5SDimitry Andric } 4380b57cec5SDimitry Andric 4390b57cec5SDimitry Andric // Add .got. MIPS' .got is so different from the other archs, 4400b57cec5SDimitry Andric // it has its own class. 4410b57cec5SDimitry Andric if (config->emachine == EM_MIPS) { 442*04eeddc0SDimitry Andric in.mipsGot = std::make_unique<MipsGotSection>(); 4430eae32dcSDimitry Andric add(*in.mipsGot); 4440b57cec5SDimitry Andric } else { 445*04eeddc0SDimitry Andric in.got = std::make_unique<GotSection>(); 4460eae32dcSDimitry Andric add(*in.got); 4470b57cec5SDimitry Andric } 4480b57cec5SDimitry Andric 4490b57cec5SDimitry Andric if (config->emachine == EM_PPC) { 450*04eeddc0SDimitry Andric in.ppc32Got2 = std::make_unique<PPC32Got2Section>(); 4510eae32dcSDimitry Andric add(*in.ppc32Got2); 4520b57cec5SDimitry Andric } 4530b57cec5SDimitry Andric 4540b57cec5SDimitry Andric if (config->emachine == EM_PPC64) { 455*04eeddc0SDimitry Andric in.ppc64LongBranchTarget = std::make_unique<PPC64LongBranchTargetSection>(); 4560eae32dcSDimitry Andric add(*in.ppc64LongBranchTarget); 4570b57cec5SDimitry Andric } 4580b57cec5SDimitry Andric 459*04eeddc0SDimitry Andric in.gotPlt = std::make_unique<GotPltSection>(); 4600eae32dcSDimitry Andric add(*in.gotPlt); 461*04eeddc0SDimitry Andric in.igotPlt = std::make_unique<IgotPltSection>(); 4620eae32dcSDimitry Andric add(*in.igotPlt); 4630b57cec5SDimitry Andric 4640b57cec5SDimitry Andric // _GLOBAL_OFFSET_TABLE_ is defined relative to either .got.plt or .got. Treat 4650b57cec5SDimitry Andric // it as a relocation and ensure the referenced section is created. 4660b57cec5SDimitry Andric if (ElfSym::globalOffsetTable && config->emachine != EM_MIPS) { 4670b57cec5SDimitry Andric if (target->gotBaseSymInGotPlt) 4680b57cec5SDimitry Andric in.gotPlt->hasGotPltOffRel = true; 4690b57cec5SDimitry Andric else 4700b57cec5SDimitry Andric in.got->hasGotOffRel = true; 4710b57cec5SDimitry Andric } 4720b57cec5SDimitry Andric 4730b57cec5SDimitry Andric if (config->gdbIndex) 4740eae32dcSDimitry Andric add(*GdbIndexSection::create<ELFT>()); 4750b57cec5SDimitry Andric 4760b57cec5SDimitry Andric // We always need to add rel[a].plt to output if it has entries. 4770b57cec5SDimitry Andric // Even for static linking it can contain R_[*]_IRELATIVE relocations. 478*04eeddc0SDimitry Andric in.relaPlt = std::make_unique<RelocationSection<ELFT>>( 4790b57cec5SDimitry Andric config->isRela ? ".rela.plt" : ".rel.plt", /*sort=*/false); 4800eae32dcSDimitry Andric add(*in.relaPlt); 4810b57cec5SDimitry Andric 48285868e8aSDimitry Andric // The relaIplt immediately follows .rel[a].dyn to ensure that the IRelative 48385868e8aSDimitry Andric // relocations are processed last by the dynamic loader. We cannot place the 48485868e8aSDimitry Andric // iplt section in .rel.dyn when Android relocation packing is enabled because 48585868e8aSDimitry Andric // that would cause a section type mismatch. However, because the Android 48685868e8aSDimitry Andric // dynamic loader reads .rel.plt after .rel.dyn, we can get the desired 48785868e8aSDimitry Andric // behaviour by placing the iplt section in .rel.plt. 488*04eeddc0SDimitry Andric in.relaIplt = std::make_unique<RelocationSection<ELFT>>( 48985868e8aSDimitry Andric config->androidPackDynRelocs ? in.relaPlt->name : relaDynName, 4900b57cec5SDimitry Andric /*sort=*/false); 4910eae32dcSDimitry Andric add(*in.relaIplt); 4920b57cec5SDimitry Andric 493480093f4SDimitry Andric if ((config->emachine == EM_386 || config->emachine == EM_X86_64) && 494480093f4SDimitry Andric (config->andFeatures & GNU_PROPERTY_X86_FEATURE_1_IBT)) { 495*04eeddc0SDimitry Andric in.ibtPlt = std::make_unique<IBTPltSection>(); 4960eae32dcSDimitry Andric add(*in.ibtPlt); 497480093f4SDimitry Andric } 498480093f4SDimitry Andric 499*04eeddc0SDimitry Andric if (config->emachine == EM_PPC) 500*04eeddc0SDimitry Andric in.plt = std::make_unique<PPC32GlinkSection>(); 501*04eeddc0SDimitry Andric else 502*04eeddc0SDimitry Andric in.plt = std::make_unique<PltSection>(); 5030eae32dcSDimitry Andric add(*in.plt); 504*04eeddc0SDimitry Andric in.iplt = std::make_unique<IpltSection>(); 5050eae32dcSDimitry Andric add(*in.iplt); 5060b57cec5SDimitry Andric 5070b57cec5SDimitry Andric if (config->andFeatures) 5080eae32dcSDimitry Andric add(*make<GnuPropertySection>()); 5090b57cec5SDimitry Andric 5100b57cec5SDimitry Andric // .note.GNU-stack is always added when we are creating a re-linkable 5110b57cec5SDimitry Andric // object file. Other linkers are using the presence of this marker 5120b57cec5SDimitry Andric // section to control the executable-ness of the stack area, but that 5130b57cec5SDimitry Andric // is irrelevant these days. Stack area should always be non-executable 5140b57cec5SDimitry Andric // by default. So we emit this section unconditionally. 5150b57cec5SDimitry Andric if (config->relocatable) 5160eae32dcSDimitry Andric add(*make<GnuStackSection>()); 5170b57cec5SDimitry Andric 5180b57cec5SDimitry Andric if (in.symTab) 5190eae32dcSDimitry Andric add(*in.symTab); 5200b57cec5SDimitry Andric if (in.symTabShndx) 5210eae32dcSDimitry Andric add(*in.symTabShndx); 5220eae32dcSDimitry Andric add(*in.shStrTab); 5230b57cec5SDimitry Andric if (in.strTab) 5240eae32dcSDimitry Andric add(*in.strTab); 5250b57cec5SDimitry Andric } 5260b57cec5SDimitry Andric 5270b57cec5SDimitry Andric // The main function of the writer. 5280b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::run() { 5290b57cec5SDimitry Andric copyLocalSymbols(); 5300b57cec5SDimitry Andric 5310b57cec5SDimitry Andric if (config->copyRelocs) 5320b57cec5SDimitry Andric addSectionSymbols(); 5330b57cec5SDimitry Andric 5340b57cec5SDimitry Andric // Now that we have a complete set of output sections. This function 5350b57cec5SDimitry Andric // completes section contents. For example, we need to add strings 5360b57cec5SDimitry Andric // to the string table, and add entries to .got and .plt. 5370b57cec5SDimitry Andric // finalizeSections does that. 5380b57cec5SDimitry Andric finalizeSections(); 5390b57cec5SDimitry Andric checkExecuteOnly(); 5400b57cec5SDimitry Andric 541349cc55cSDimitry Andric // If --compressed-debug-sections is specified, compress .debug_* sections. 542349cc55cSDimitry Andric // Do it right now because it changes the size of output sections. 5430b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 5440b57cec5SDimitry Andric sec->maybeCompress<ELFT>(); 5450b57cec5SDimitry Andric 54669660011SDimitry Andric if (script->hasSectionsCommand) 5470b57cec5SDimitry Andric script->allocateHeaders(mainPart->phdrs); 5480b57cec5SDimitry Andric 5490b57cec5SDimitry Andric // Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a 5500b57cec5SDimitry Andric // 0 sized region. This has to be done late since only after assignAddresses 5510b57cec5SDimitry Andric // we know the size of the sections. 5520b57cec5SDimitry Andric for (Partition &part : partitions) 5530b57cec5SDimitry Andric removeEmptyPTLoad(part.phdrs); 5540b57cec5SDimitry Andric 5550b57cec5SDimitry Andric if (!config->oFormatBinary) 5560b57cec5SDimitry Andric assignFileOffsets(); 5570b57cec5SDimitry Andric else 5580b57cec5SDimitry Andric assignFileOffsetsBinary(); 5590b57cec5SDimitry Andric 5600b57cec5SDimitry Andric for (Partition &part : partitions) 5610b57cec5SDimitry Andric setPhdrs(part); 5620b57cec5SDimitry Andric 5630b57cec5SDimitry Andric 564349cc55cSDimitry Andric // Handle --print-map(-M)/--Map, --why-extract=, --cref and 565349cc55cSDimitry Andric // --print-archive-stats=. Dump them before checkSections() because the files 566349cc55cSDimitry Andric // may be useful in case checkSections() or openFile() fails, for example, due 567349cc55cSDimitry Andric // to an erroneous file size. 5684824e7fdSDimitry Andric writeMapAndCref(); 569349cc55cSDimitry Andric writeWhyExtract(); 5705ffd83dbSDimitry Andric writeArchiveStats(); 5715ffd83dbSDimitry Andric 5720b57cec5SDimitry Andric if (config->checkSections) 5730b57cec5SDimitry Andric checkSections(); 5740b57cec5SDimitry Andric 5750b57cec5SDimitry Andric // It does not make sense try to open the file if we have error already. 5760b57cec5SDimitry Andric if (errorCount()) 5770b57cec5SDimitry Andric return; 578e8d8bef9SDimitry Andric 579e8d8bef9SDimitry Andric { 580e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Write output file"); 5810b57cec5SDimitry Andric // Write the result down to a file. 5820b57cec5SDimitry Andric openFile(); 5830b57cec5SDimitry Andric if (errorCount()) 5840b57cec5SDimitry Andric return; 5850b57cec5SDimitry Andric 5860b57cec5SDimitry Andric if (!config->oFormatBinary) { 58785868e8aSDimitry Andric if (config->zSeparate != SeparateSegmentKind::None) 5880b57cec5SDimitry Andric writeTrapInstr(); 5890b57cec5SDimitry Andric writeHeader(); 5900b57cec5SDimitry Andric writeSections(); 5910b57cec5SDimitry Andric } else { 5920b57cec5SDimitry Andric writeSectionsBinary(); 5930b57cec5SDimitry Andric } 5940b57cec5SDimitry Andric 5950b57cec5SDimitry Andric // Backfill .note.gnu.build-id section content. This is done at last 5960b57cec5SDimitry Andric // because the content is usually a hash value of the entire output file. 5970b57cec5SDimitry Andric writeBuildId(); 5980b57cec5SDimitry Andric if (errorCount()) 5990b57cec5SDimitry Andric return; 6000b57cec5SDimitry Andric 6010b57cec5SDimitry Andric if (auto e = buffer->commit()) 6020b57cec5SDimitry Andric error("failed to write to the output file: " + toString(std::move(e))); 6030b57cec5SDimitry Andric } 604e8d8bef9SDimitry Andric } 6050b57cec5SDimitry Andric 6065ffd83dbSDimitry Andric template <class ELFT, class RelTy> 6075ffd83dbSDimitry Andric static void markUsedLocalSymbolsImpl(ObjFile<ELFT> *file, 6085ffd83dbSDimitry Andric llvm::ArrayRef<RelTy> rels) { 6095ffd83dbSDimitry Andric for (const RelTy &rel : rels) { 6105ffd83dbSDimitry Andric Symbol &sym = file->getRelocTargetSym(rel); 6115ffd83dbSDimitry Andric if (sym.isLocal()) 6125ffd83dbSDimitry Andric sym.used = true; 6135ffd83dbSDimitry Andric } 6145ffd83dbSDimitry Andric } 6155ffd83dbSDimitry Andric 6165ffd83dbSDimitry Andric // The function ensures that the "used" field of local symbols reflects the fact 6175ffd83dbSDimitry Andric // that the symbol is used in a relocation from a live section. 6185ffd83dbSDimitry Andric template <class ELFT> static void markUsedLocalSymbols() { 6195ffd83dbSDimitry Andric // With --gc-sections, the field is already filled. 6205ffd83dbSDimitry Andric // See MarkLive<ELFT>::resolveReloc(). 6215ffd83dbSDimitry Andric if (config->gcSections) 6225ffd83dbSDimitry Andric return; 6235ffd83dbSDimitry Andric // Without --gc-sections, the field is initialized with "true". 6245ffd83dbSDimitry Andric // Drop the flag first and then rise for symbols referenced in relocations. 6250eae32dcSDimitry Andric for (ELFFileBase *file : objectFiles) { 6265ffd83dbSDimitry Andric ObjFile<ELFT> *f = cast<ObjFile<ELFT>>(file); 6275ffd83dbSDimitry Andric for (Symbol *b : f->getLocalSymbols()) 6285ffd83dbSDimitry Andric b->used = false; 6295ffd83dbSDimitry Andric for (InputSectionBase *s : f->getSections()) { 6305ffd83dbSDimitry Andric InputSection *isec = dyn_cast_or_null<InputSection>(s); 6315ffd83dbSDimitry Andric if (!isec) 6325ffd83dbSDimitry Andric continue; 6335ffd83dbSDimitry Andric if (isec->type == SHT_REL) 6345ffd83dbSDimitry Andric markUsedLocalSymbolsImpl(f, isec->getDataAs<typename ELFT::Rel>()); 6355ffd83dbSDimitry Andric else if (isec->type == SHT_RELA) 6365ffd83dbSDimitry Andric markUsedLocalSymbolsImpl(f, isec->getDataAs<typename ELFT::Rela>()); 6375ffd83dbSDimitry Andric } 6385ffd83dbSDimitry Andric } 6395ffd83dbSDimitry Andric } 6405ffd83dbSDimitry Andric 6410b57cec5SDimitry Andric static bool shouldKeepInSymtab(const Defined &sym) { 6420b57cec5SDimitry Andric if (sym.isSection()) 6430b57cec5SDimitry Andric return false; 6440b57cec5SDimitry Andric 6455ffd83dbSDimitry Andric // If --emit-reloc or -r is given, preserve symbols referenced by relocations 6465ffd83dbSDimitry Andric // from live sections. 6475ffd83dbSDimitry Andric if (config->copyRelocs && sym.used) 6480b57cec5SDimitry Andric return true; 6490b57cec5SDimitry Andric 6505ffd83dbSDimitry Andric // Exclude local symbols pointing to .ARM.exidx sections. 6515ffd83dbSDimitry Andric // They are probably mapping symbols "$d", which are optional for these 6525ffd83dbSDimitry Andric // sections. After merging the .ARM.exidx sections, some of these symbols 6535ffd83dbSDimitry Andric // may become dangling. The easiest way to avoid the issue is not to add 6545ffd83dbSDimitry Andric // them to the symbol table from the beginning. 6555ffd83dbSDimitry Andric if (config->emachine == EM_ARM && sym.section && 6565ffd83dbSDimitry Andric sym.section->type == SHT_ARM_EXIDX) 6575ffd83dbSDimitry Andric return false; 6585ffd83dbSDimitry Andric 6595ffd83dbSDimitry Andric if (config->discard == DiscardPolicy::None) 6600b57cec5SDimitry Andric return true; 6615ffd83dbSDimitry Andric if (config->discard == DiscardPolicy::All) 6625ffd83dbSDimitry Andric return false; 6630b57cec5SDimitry Andric 6640b57cec5SDimitry Andric // In ELF assembly .L symbols are normally discarded by the assembler. 6650b57cec5SDimitry Andric // If the assembler fails to do so, the linker discards them if 6660b57cec5SDimitry Andric // * --discard-locals is used. 6670b57cec5SDimitry Andric // * The symbol is in a SHF_MERGE section, which is normally the reason for 6680b57cec5SDimitry Andric // the assembler keeping the .L symbol. 669349cc55cSDimitry Andric if (sym.getName().startswith(".L") && 670349cc55cSDimitry Andric (config->discard == DiscardPolicy::Locals || 671349cc55cSDimitry Andric (sym.section && (sym.section->flags & SHF_MERGE)))) 6720b57cec5SDimitry Andric return false; 673349cc55cSDimitry Andric return true; 6740b57cec5SDimitry Andric } 6750b57cec5SDimitry Andric 6760b57cec5SDimitry Andric static bool includeInSymtab(const Symbol &b) { 6770b57cec5SDimitry Andric if (auto *d = dyn_cast<Defined>(&b)) { 6780b57cec5SDimitry Andric // Always include absolute symbols. 6790b57cec5SDimitry Andric SectionBase *sec = d->section; 6800b57cec5SDimitry Andric if (!sec) 6810b57cec5SDimitry Andric return true; 6820b57cec5SDimitry Andric 6830b57cec5SDimitry Andric // Exclude symbols pointing to garbage-collected sections. 6840b57cec5SDimitry Andric if (isa<InputSectionBase>(sec) && !sec->isLive()) 6850b57cec5SDimitry Andric return false; 6860b57cec5SDimitry Andric 6870b57cec5SDimitry Andric if (auto *s = dyn_cast<MergeInputSection>(sec)) 6880b57cec5SDimitry Andric if (!s->getSectionPiece(d->value)->live) 6890b57cec5SDimitry Andric return false; 6900b57cec5SDimitry Andric return true; 6910b57cec5SDimitry Andric } 6920b57cec5SDimitry Andric return b.used; 6930b57cec5SDimitry Andric } 6940b57cec5SDimitry Andric 6950b57cec5SDimitry Andric // Local symbols are not in the linker's symbol table. This function scans 6960b57cec5SDimitry Andric // each object file's symbol table to copy local symbols to the output. 6970b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::copyLocalSymbols() { 6980b57cec5SDimitry Andric if (!in.symTab) 6990b57cec5SDimitry Andric return; 700e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Add local symbols"); 7015ffd83dbSDimitry Andric if (config->copyRelocs && config->discard != DiscardPolicy::None) 7025ffd83dbSDimitry Andric markUsedLocalSymbols<ELFT>(); 7030eae32dcSDimitry Andric for (ELFFileBase *file : objectFiles) { 7040eae32dcSDimitry Andric for (Symbol *b : file->getLocalSymbols()) { 7055ffd83dbSDimitry Andric assert(b->isLocal() && "should have been caught in initializeSymbols()"); 7060b57cec5SDimitry Andric auto *dr = dyn_cast<Defined>(b); 7070b57cec5SDimitry Andric 7080b57cec5SDimitry Andric // No reason to keep local undefined symbol in symtab. 7090b57cec5SDimitry Andric if (!dr) 7100b57cec5SDimitry Andric continue; 7110eae32dcSDimitry Andric if (includeInSymtab(*b) && shouldKeepInSymtab(*dr)) 7120b57cec5SDimitry Andric in.symTab->addSymbol(b); 7130b57cec5SDimitry Andric } 7140b57cec5SDimitry Andric } 7150b57cec5SDimitry Andric } 7160b57cec5SDimitry Andric 7170b57cec5SDimitry Andric // Create a section symbol for each output section so that we can represent 7180b57cec5SDimitry Andric // relocations that point to the section. If we know that no relocation is 7190b57cec5SDimitry Andric // referring to a section (that happens if the section is a synthetic one), we 7200b57cec5SDimitry Andric // don't create a section symbol for that section. 7210b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::addSectionSymbols() { 7224824e7fdSDimitry Andric for (SectionCommand *cmd : script->sectionCommands) { 7234824e7fdSDimitry Andric auto *sec = dyn_cast<OutputSection>(cmd); 7240b57cec5SDimitry Andric if (!sec) 7250b57cec5SDimitry Andric continue; 7264824e7fdSDimitry Andric auto i = llvm::find_if(sec->commands, [](SectionCommand *cmd) { 7274824e7fdSDimitry Andric if (auto *isd = dyn_cast<InputSectionDescription>(cmd)) 7280b57cec5SDimitry Andric return !isd->sections.empty(); 7290b57cec5SDimitry Andric return false; 7300b57cec5SDimitry Andric }); 7314824e7fdSDimitry Andric if (i == sec->commands.end()) 7320b57cec5SDimitry Andric continue; 73385868e8aSDimitry Andric InputSectionBase *isec = cast<InputSectionDescription>(*i)->sections[0]; 7340b57cec5SDimitry Andric 7350b57cec5SDimitry Andric // Relocations are not using REL[A] section symbols. 7360b57cec5SDimitry Andric if (isec->type == SHT_REL || isec->type == SHT_RELA) 7370b57cec5SDimitry Andric continue; 7380b57cec5SDimitry Andric 7390b57cec5SDimitry Andric // Unlike other synthetic sections, mergeable output sections contain data 7400b57cec5SDimitry Andric // copied from input sections, and there may be a relocation pointing to its 741349cc55cSDimitry Andric // contents if -r or --emit-reloc is given. 7420b57cec5SDimitry Andric if (isa<SyntheticSection>(isec) && !(isec->flags & SHF_MERGE)) 7430b57cec5SDimitry Andric continue; 7440b57cec5SDimitry Andric 745e8d8bef9SDimitry Andric // Set the symbol to be relative to the output section so that its st_value 746e8d8bef9SDimitry Andric // equals the output section address. Note, there may be a gap between the 747e8d8bef9SDimitry Andric // start of the output section and isec. 7480eae32dcSDimitry Andric in.symTab->addSymbol( 7490eae32dcSDimitry Andric makeDefined(isec->file, "", STB_LOCAL, /*stOther=*/0, STT_SECTION, 7500eae32dcSDimitry Andric /*value=*/0, /*size=*/0, isec->getOutputSection())); 7510b57cec5SDimitry Andric } 7520b57cec5SDimitry Andric } 7530b57cec5SDimitry Andric 7540b57cec5SDimitry Andric // Today's loaders have a feature to make segments read-only after 7550b57cec5SDimitry Andric // processing dynamic relocations to enhance security. PT_GNU_RELRO 7560b57cec5SDimitry Andric // is defined for that. 7570b57cec5SDimitry Andric // 7580b57cec5SDimitry Andric // This function returns true if a section needs to be put into a 7590b57cec5SDimitry Andric // PT_GNU_RELRO segment. 7600b57cec5SDimitry Andric static bool isRelroSection(const OutputSection *sec) { 7610b57cec5SDimitry Andric if (!config->zRelro) 7620b57cec5SDimitry Andric return false; 7630b57cec5SDimitry Andric 7640b57cec5SDimitry Andric uint64_t flags = sec->flags; 7650b57cec5SDimitry Andric 7660b57cec5SDimitry Andric // Non-allocatable or non-writable sections don't need RELRO because 7670b57cec5SDimitry Andric // they are not writable or not even mapped to memory in the first place. 7680b57cec5SDimitry Andric // RELRO is for sections that are essentially read-only but need to 7690b57cec5SDimitry Andric // be writable only at process startup to allow dynamic linker to 7700b57cec5SDimitry Andric // apply relocations. 7710b57cec5SDimitry Andric if (!(flags & SHF_ALLOC) || !(flags & SHF_WRITE)) 7720b57cec5SDimitry Andric return false; 7730b57cec5SDimitry Andric 7740b57cec5SDimitry Andric // Once initialized, TLS data segments are used as data templates 7750b57cec5SDimitry Andric // for a thread-local storage. For each new thread, runtime 7760b57cec5SDimitry Andric // allocates memory for a TLS and copy templates there. No thread 7770b57cec5SDimitry Andric // are supposed to use templates directly. Thus, it can be in RELRO. 7780b57cec5SDimitry Andric if (flags & SHF_TLS) 7790b57cec5SDimitry Andric return true; 7800b57cec5SDimitry Andric 7810b57cec5SDimitry Andric // .init_array, .preinit_array and .fini_array contain pointers to 7820b57cec5SDimitry Andric // functions that are executed on process startup or exit. These 7830b57cec5SDimitry Andric // pointers are set by the static linker, and they are not expected 7840b57cec5SDimitry Andric // to change at runtime. But if you are an attacker, you could do 7850b57cec5SDimitry Andric // interesting things by manipulating pointers in .fini_array, for 7860b57cec5SDimitry Andric // example. So they are put into RELRO. 7870b57cec5SDimitry Andric uint32_t type = sec->type; 7880b57cec5SDimitry Andric if (type == SHT_INIT_ARRAY || type == SHT_FINI_ARRAY || 7890b57cec5SDimitry Andric type == SHT_PREINIT_ARRAY) 7900b57cec5SDimitry Andric return true; 7910b57cec5SDimitry Andric 7920b57cec5SDimitry Andric // .got contains pointers to external symbols. They are resolved by 7930b57cec5SDimitry Andric // the dynamic linker when a module is loaded into memory, and after 7940b57cec5SDimitry Andric // that they are not expected to change. So, it can be in RELRO. 7950b57cec5SDimitry Andric if (in.got && sec == in.got->getParent()) 7960b57cec5SDimitry Andric return true; 7970b57cec5SDimitry Andric 7980b57cec5SDimitry Andric // .toc is a GOT-ish section for PowerPC64. Their contents are accessed 7990b57cec5SDimitry Andric // through r2 register, which is reserved for that purpose. Since r2 is used 8000b57cec5SDimitry Andric // for accessing .got as well, .got and .toc need to be close enough in the 8010b57cec5SDimitry Andric // virtual address space. Usually, .toc comes just after .got. Since we place 8020b57cec5SDimitry Andric // .got into RELRO, .toc needs to be placed into RELRO too. 8030b57cec5SDimitry Andric if (sec->name.equals(".toc")) 8040b57cec5SDimitry Andric return true; 8050b57cec5SDimitry Andric 8060b57cec5SDimitry Andric // .got.plt contains pointers to external function symbols. They are 8070b57cec5SDimitry Andric // by default resolved lazily, so we usually cannot put it into RELRO. 8080b57cec5SDimitry Andric // However, if "-z now" is given, the lazy symbol resolution is 8090b57cec5SDimitry Andric // disabled, which enables us to put it into RELRO. 8100b57cec5SDimitry Andric if (sec == in.gotPlt->getParent()) 8110b57cec5SDimitry Andric return config->zNow; 8120b57cec5SDimitry Andric 8130b57cec5SDimitry Andric // .dynamic section contains data for the dynamic linker, and 8140b57cec5SDimitry Andric // there's no need to write to it at runtime, so it's better to put 8150b57cec5SDimitry Andric // it into RELRO. 8160b57cec5SDimitry Andric if (sec->name == ".dynamic") 8170b57cec5SDimitry Andric return true; 8180b57cec5SDimitry Andric 8190b57cec5SDimitry Andric // Sections with some special names are put into RELRO. This is a 8200b57cec5SDimitry Andric // bit unfortunate because section names shouldn't be significant in 8210b57cec5SDimitry Andric // ELF in spirit. But in reality many linker features depend on 8220b57cec5SDimitry Andric // magic section names. 8230b57cec5SDimitry Andric StringRef s = sec->name; 8240b57cec5SDimitry Andric return s == ".data.rel.ro" || s == ".bss.rel.ro" || s == ".ctors" || 8250b57cec5SDimitry Andric s == ".dtors" || s == ".jcr" || s == ".eh_frame" || 8265ffd83dbSDimitry Andric s == ".fini_array" || s == ".init_array" || 8275ffd83dbSDimitry Andric s == ".openbsd.randomdata" || s == ".preinit_array"; 8280b57cec5SDimitry Andric } 8290b57cec5SDimitry Andric 8300b57cec5SDimitry Andric // We compute a rank for each section. The rank indicates where the 8310b57cec5SDimitry Andric // section should be placed in the file. Instead of using simple 8320b57cec5SDimitry Andric // numbers (0,1,2...), we use a series of flags. One for each decision 8330b57cec5SDimitry Andric // point when placing the section. 8340b57cec5SDimitry Andric // Using flags has two key properties: 8350b57cec5SDimitry Andric // * It is easy to check if a give branch was taken. 8360b57cec5SDimitry Andric // * It is easy two see how similar two ranks are (see getRankProximity). 8370b57cec5SDimitry Andric enum RankFlags { 8380b57cec5SDimitry Andric RF_NOT_ADDR_SET = 1 << 27, 8390b57cec5SDimitry Andric RF_NOT_ALLOC = 1 << 26, 8400b57cec5SDimitry Andric RF_PARTITION = 1 << 18, // Partition number (8 bits) 8410b57cec5SDimitry Andric RF_NOT_PART_EHDR = 1 << 17, 8420b57cec5SDimitry Andric RF_NOT_PART_PHDR = 1 << 16, 8430b57cec5SDimitry Andric RF_NOT_INTERP = 1 << 15, 8440b57cec5SDimitry Andric RF_NOT_NOTE = 1 << 14, 8450b57cec5SDimitry Andric RF_WRITE = 1 << 13, 8460b57cec5SDimitry Andric RF_EXEC_WRITE = 1 << 12, 8470b57cec5SDimitry Andric RF_EXEC = 1 << 11, 8480b57cec5SDimitry Andric RF_RODATA = 1 << 10, 8490b57cec5SDimitry Andric RF_NOT_RELRO = 1 << 9, 8500b57cec5SDimitry Andric RF_NOT_TLS = 1 << 8, 8510b57cec5SDimitry Andric RF_BSS = 1 << 7, 8520b57cec5SDimitry Andric RF_PPC_NOT_TOCBSS = 1 << 6, 8530b57cec5SDimitry Andric RF_PPC_TOCL = 1 << 5, 8540b57cec5SDimitry Andric RF_PPC_TOC = 1 << 4, 8550b57cec5SDimitry Andric RF_PPC_GOT = 1 << 3, 8560b57cec5SDimitry Andric RF_PPC_BRANCH_LT = 1 << 2, 8570b57cec5SDimitry Andric RF_MIPS_GPREL = 1 << 1, 8580b57cec5SDimitry Andric RF_MIPS_NOT_GOT = 1 << 0 8590b57cec5SDimitry Andric }; 8600b57cec5SDimitry Andric 8610b57cec5SDimitry Andric static unsigned getSectionRank(const OutputSection *sec) { 8620b57cec5SDimitry Andric unsigned rank = sec->partition * RF_PARTITION; 8630b57cec5SDimitry Andric 8640b57cec5SDimitry Andric // We want to put section specified by -T option first, so we 8650b57cec5SDimitry Andric // can start assigning VA starting from them later. 8660b57cec5SDimitry Andric if (config->sectionStartMap.count(sec->name)) 8670b57cec5SDimitry Andric return rank; 8680b57cec5SDimitry Andric rank |= RF_NOT_ADDR_SET; 8690b57cec5SDimitry Andric 8700b57cec5SDimitry Andric // Allocatable sections go first to reduce the total PT_LOAD size and 8710b57cec5SDimitry Andric // so debug info doesn't change addresses in actual code. 8720b57cec5SDimitry Andric if (!(sec->flags & SHF_ALLOC)) 8730b57cec5SDimitry Andric return rank | RF_NOT_ALLOC; 8740b57cec5SDimitry Andric 8750b57cec5SDimitry Andric if (sec->type == SHT_LLVM_PART_EHDR) 8760b57cec5SDimitry Andric return rank; 8770b57cec5SDimitry Andric rank |= RF_NOT_PART_EHDR; 8780b57cec5SDimitry Andric 8790b57cec5SDimitry Andric if (sec->type == SHT_LLVM_PART_PHDR) 8800b57cec5SDimitry Andric return rank; 8810b57cec5SDimitry Andric rank |= RF_NOT_PART_PHDR; 8820b57cec5SDimitry Andric 8830b57cec5SDimitry Andric // Put .interp first because some loaders want to see that section 8840b57cec5SDimitry Andric // on the first page of the executable file when loaded into memory. 8850b57cec5SDimitry Andric if (sec->name == ".interp") 8860b57cec5SDimitry Andric return rank; 8870b57cec5SDimitry Andric rank |= RF_NOT_INTERP; 8880b57cec5SDimitry Andric 8890b57cec5SDimitry Andric // Put .note sections (which make up one PT_NOTE) at the beginning so that 8900b57cec5SDimitry Andric // they are likely to be included in a core file even if core file size is 8910b57cec5SDimitry Andric // limited. In particular, we want a .note.gnu.build-id and a .note.tag to be 8920b57cec5SDimitry Andric // included in a core to match core files with executables. 8930b57cec5SDimitry Andric if (sec->type == SHT_NOTE) 8940b57cec5SDimitry Andric return rank; 8950b57cec5SDimitry Andric rank |= RF_NOT_NOTE; 8960b57cec5SDimitry Andric 8970b57cec5SDimitry Andric // Sort sections based on their access permission in the following 8980b57cec5SDimitry Andric // order: R, RX, RWX, RW. This order is based on the following 8990b57cec5SDimitry Andric // considerations: 9000b57cec5SDimitry Andric // * Read-only sections come first such that they go in the 9010b57cec5SDimitry Andric // PT_LOAD covering the program headers at the start of the file. 9020b57cec5SDimitry Andric // * Read-only, executable sections come next. 9030b57cec5SDimitry Andric // * Writable, executable sections follow such that .plt on 9040b57cec5SDimitry Andric // architectures where it needs to be writable will be placed 9050b57cec5SDimitry Andric // between .text and .data. 9060b57cec5SDimitry Andric // * Writable sections come last, such that .bss lands at the very 9070b57cec5SDimitry Andric // end of the last PT_LOAD. 9080b57cec5SDimitry Andric bool isExec = sec->flags & SHF_EXECINSTR; 9090b57cec5SDimitry Andric bool isWrite = sec->flags & SHF_WRITE; 9100b57cec5SDimitry Andric 9110b57cec5SDimitry Andric if (isExec) { 9120b57cec5SDimitry Andric if (isWrite) 9130b57cec5SDimitry Andric rank |= RF_EXEC_WRITE; 9140b57cec5SDimitry Andric else 9150b57cec5SDimitry Andric rank |= RF_EXEC; 9160b57cec5SDimitry Andric } else if (isWrite) { 9170b57cec5SDimitry Andric rank |= RF_WRITE; 9180b57cec5SDimitry Andric } else if (sec->type == SHT_PROGBITS) { 9190b57cec5SDimitry Andric // Make non-executable and non-writable PROGBITS sections (e.g .rodata 9200b57cec5SDimitry Andric // .eh_frame) closer to .text. They likely contain PC or GOT relative 9210b57cec5SDimitry Andric // relocations and there could be relocation overflow if other huge sections 9220b57cec5SDimitry Andric // (.dynstr .dynsym) were placed in between. 9230b57cec5SDimitry Andric rank |= RF_RODATA; 9240b57cec5SDimitry Andric } 9250b57cec5SDimitry Andric 9260b57cec5SDimitry Andric // Place RelRo sections first. After considering SHT_NOBITS below, the 9270b57cec5SDimitry Andric // ordering is PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss), 9280b57cec5SDimitry Andric // where | marks where page alignment happens. An alternative ordering is 9290b57cec5SDimitry Andric // PT_LOAD(.data | PT_GNU_RELRO( .data.rel.ro .bss.rel.ro) | .bss), but it may 9300b57cec5SDimitry Andric // waste more bytes due to 2 alignment places. 9310b57cec5SDimitry Andric if (!isRelroSection(sec)) 9320b57cec5SDimitry Andric rank |= RF_NOT_RELRO; 9330b57cec5SDimitry Andric 9340b57cec5SDimitry Andric // If we got here we know that both A and B are in the same PT_LOAD. 9350b57cec5SDimitry Andric 9360b57cec5SDimitry Andric // The TLS initialization block needs to be a single contiguous block in a R/W 9370b57cec5SDimitry Andric // PT_LOAD, so stick TLS sections directly before the other RelRo R/W 9380b57cec5SDimitry Andric // sections. Since p_filesz can be less than p_memsz, place NOBITS sections 9390b57cec5SDimitry Andric // after PROGBITS. 9400b57cec5SDimitry Andric if (!(sec->flags & SHF_TLS)) 9410b57cec5SDimitry Andric rank |= RF_NOT_TLS; 9420b57cec5SDimitry Andric 9430b57cec5SDimitry Andric // Within TLS sections, or within other RelRo sections, or within non-RelRo 9440b57cec5SDimitry Andric // sections, place non-NOBITS sections first. 9450b57cec5SDimitry Andric if (sec->type == SHT_NOBITS) 9460b57cec5SDimitry Andric rank |= RF_BSS; 9470b57cec5SDimitry Andric 9480b57cec5SDimitry Andric // Some architectures have additional ordering restrictions for sections 9490b57cec5SDimitry Andric // within the same PT_LOAD. 9500b57cec5SDimitry Andric if (config->emachine == EM_PPC64) { 9510b57cec5SDimitry Andric // PPC64 has a number of special SHT_PROGBITS+SHF_ALLOC+SHF_WRITE sections 9520b57cec5SDimitry Andric // that we would like to make sure appear is a specific order to maximize 9530b57cec5SDimitry Andric // their coverage by a single signed 16-bit offset from the TOC base 9540b57cec5SDimitry Andric // pointer. Conversely, the special .tocbss section should be first among 9550b57cec5SDimitry Andric // all SHT_NOBITS sections. This will put it next to the loaded special 9560b57cec5SDimitry Andric // PPC64 sections (and, thus, within reach of the TOC base pointer). 9570b57cec5SDimitry Andric StringRef name = sec->name; 9580b57cec5SDimitry Andric if (name != ".tocbss") 9590b57cec5SDimitry Andric rank |= RF_PPC_NOT_TOCBSS; 9600b57cec5SDimitry Andric 9610b57cec5SDimitry Andric if (name == ".toc1") 9620b57cec5SDimitry Andric rank |= RF_PPC_TOCL; 9630b57cec5SDimitry Andric 9640b57cec5SDimitry Andric if (name == ".toc") 9650b57cec5SDimitry Andric rank |= RF_PPC_TOC; 9660b57cec5SDimitry Andric 9670b57cec5SDimitry Andric if (name == ".got") 9680b57cec5SDimitry Andric rank |= RF_PPC_GOT; 9690b57cec5SDimitry Andric 9700b57cec5SDimitry Andric if (name == ".branch_lt") 9710b57cec5SDimitry Andric rank |= RF_PPC_BRANCH_LT; 9720b57cec5SDimitry Andric } 9730b57cec5SDimitry Andric 9740b57cec5SDimitry Andric if (config->emachine == EM_MIPS) { 9750b57cec5SDimitry Andric // All sections with SHF_MIPS_GPREL flag should be grouped together 9760b57cec5SDimitry Andric // because data in these sections is addressable with a gp relative address. 9770b57cec5SDimitry Andric if (sec->flags & SHF_MIPS_GPREL) 9780b57cec5SDimitry Andric rank |= RF_MIPS_GPREL; 9790b57cec5SDimitry Andric 9800b57cec5SDimitry Andric if (sec->name != ".got") 9810b57cec5SDimitry Andric rank |= RF_MIPS_NOT_GOT; 9820b57cec5SDimitry Andric } 9830b57cec5SDimitry Andric 9840b57cec5SDimitry Andric return rank; 9850b57cec5SDimitry Andric } 9860b57cec5SDimitry Andric 9874824e7fdSDimitry Andric static bool compareSections(const SectionCommand *aCmd, 9884824e7fdSDimitry Andric const SectionCommand *bCmd) { 9890b57cec5SDimitry Andric const OutputSection *a = cast<OutputSection>(aCmd); 9900b57cec5SDimitry Andric const OutputSection *b = cast<OutputSection>(bCmd); 9910b57cec5SDimitry Andric 9920b57cec5SDimitry Andric if (a->sortRank != b->sortRank) 9930b57cec5SDimitry Andric return a->sortRank < b->sortRank; 9940b57cec5SDimitry Andric 9950b57cec5SDimitry Andric if (!(a->sortRank & RF_NOT_ADDR_SET)) 9960b57cec5SDimitry Andric return config->sectionStartMap.lookup(a->name) < 9970b57cec5SDimitry Andric config->sectionStartMap.lookup(b->name); 9980b57cec5SDimitry Andric return false; 9990b57cec5SDimitry Andric } 10000b57cec5SDimitry Andric 10010b57cec5SDimitry Andric void PhdrEntry::add(OutputSection *sec) { 10020b57cec5SDimitry Andric lastSec = sec; 10030b57cec5SDimitry Andric if (!firstSec) 10040b57cec5SDimitry Andric firstSec = sec; 10050b57cec5SDimitry Andric p_align = std::max(p_align, sec->alignment); 10060b57cec5SDimitry Andric if (p_type == PT_LOAD) 10070b57cec5SDimitry Andric sec->ptLoad = this; 10080b57cec5SDimitry Andric } 10090b57cec5SDimitry Andric 10100b57cec5SDimitry Andric // The beginning and the ending of .rel[a].plt section are marked 10110b57cec5SDimitry Andric // with __rel[a]_iplt_{start,end} symbols if it is a statically linked 10120b57cec5SDimitry Andric // executable. The runtime needs these symbols in order to resolve 10130b57cec5SDimitry Andric // all IRELATIVE relocs on startup. For dynamic executables, we don't 10140b57cec5SDimitry Andric // need these symbols, since IRELATIVE relocs are resolved through GOT 10150b57cec5SDimitry Andric // and PLT. For details, see http://www.airs.com/blog/archives/403. 10160b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() { 1017fe6060f1SDimitry Andric if (config->relocatable || config->isPic) 10180b57cec5SDimitry Andric return; 10190b57cec5SDimitry Andric 10200b57cec5SDimitry Andric // By default, __rela_iplt_{start,end} belong to a dummy section 0 10210b57cec5SDimitry Andric // because .rela.plt might be empty and thus removed from output. 10220b57cec5SDimitry Andric // We'll override Out::elfHeader with In.relaIplt later when we are 10230b57cec5SDimitry Andric // sure that .rela.plt exists in output. 10240b57cec5SDimitry Andric ElfSym::relaIpltStart = addOptionalRegular( 10250b57cec5SDimitry Andric config->isRela ? "__rela_iplt_start" : "__rel_iplt_start", 1026349cc55cSDimitry Andric Out::elfHeader, 0, STV_HIDDEN); 10270b57cec5SDimitry Andric 10280b57cec5SDimitry Andric ElfSym::relaIpltEnd = addOptionalRegular( 10290b57cec5SDimitry Andric config->isRela ? "__rela_iplt_end" : "__rel_iplt_end", 1030349cc55cSDimitry Andric Out::elfHeader, 0, STV_HIDDEN); 10310b57cec5SDimitry Andric } 10320b57cec5SDimitry Andric 10330b57cec5SDimitry Andric // This function generates assignments for predefined symbols (e.g. _end or 10340b57cec5SDimitry Andric // _etext) and inserts them into the commands sequence to be processed at the 10350b57cec5SDimitry Andric // appropriate time. This ensures that the value is going to be correct by the 10360b57cec5SDimitry Andric // time any references to these symbols are processed and is equivalent to 10370b57cec5SDimitry Andric // defining these symbols explicitly in the linker script. 10380b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() { 10390b57cec5SDimitry Andric if (ElfSym::globalOffsetTable) { 10400b57cec5SDimitry Andric // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention usually 10410b57cec5SDimitry Andric // to the start of the .got or .got.plt section. 1042*04eeddc0SDimitry Andric InputSection *sec = in.gotPlt.get(); 10430b57cec5SDimitry Andric if (!target->gotBaseSymInGotPlt) 1044*04eeddc0SDimitry Andric sec = in.mipsGot.get() ? cast<InputSection>(in.mipsGot.get()) 1045*04eeddc0SDimitry Andric : cast<InputSection>(in.got.get()); 1046*04eeddc0SDimitry Andric ElfSym::globalOffsetTable->section = sec; 10470b57cec5SDimitry Andric } 10480b57cec5SDimitry Andric 104985868e8aSDimitry Andric // .rela_iplt_{start,end} mark the start and the end of in.relaIplt. 10500b57cec5SDimitry Andric if (ElfSym::relaIpltStart && in.relaIplt->isNeeded()) { 1051*04eeddc0SDimitry Andric ElfSym::relaIpltStart->section = in.relaIplt.get(); 1052*04eeddc0SDimitry Andric ElfSym::relaIpltEnd->section = in.relaIplt.get(); 10530b57cec5SDimitry Andric ElfSym::relaIpltEnd->value = in.relaIplt->getSize(); 10540b57cec5SDimitry Andric } 10550b57cec5SDimitry Andric 10560b57cec5SDimitry Andric PhdrEntry *last = nullptr; 10570b57cec5SDimitry Andric PhdrEntry *lastRO = nullptr; 10580b57cec5SDimitry Andric 10590b57cec5SDimitry Andric for (Partition &part : partitions) { 10600b57cec5SDimitry Andric for (PhdrEntry *p : part.phdrs) { 10610b57cec5SDimitry Andric if (p->p_type != PT_LOAD) 10620b57cec5SDimitry Andric continue; 10630b57cec5SDimitry Andric last = p; 10640b57cec5SDimitry Andric if (!(p->p_flags & PF_W)) 10650b57cec5SDimitry Andric lastRO = p; 10660b57cec5SDimitry Andric } 10670b57cec5SDimitry Andric } 10680b57cec5SDimitry Andric 10690b57cec5SDimitry Andric if (lastRO) { 10700b57cec5SDimitry Andric // _etext is the first location after the last read-only loadable segment. 10710b57cec5SDimitry Andric if (ElfSym::etext1) 10720b57cec5SDimitry Andric ElfSym::etext1->section = lastRO->lastSec; 10730b57cec5SDimitry Andric if (ElfSym::etext2) 10740b57cec5SDimitry Andric ElfSym::etext2->section = lastRO->lastSec; 10750b57cec5SDimitry Andric } 10760b57cec5SDimitry Andric 10770b57cec5SDimitry Andric if (last) { 10780b57cec5SDimitry Andric // _edata points to the end of the last mapped initialized section. 10790b57cec5SDimitry Andric OutputSection *edata = nullptr; 10800b57cec5SDimitry Andric for (OutputSection *os : outputSections) { 10810b57cec5SDimitry Andric if (os->type != SHT_NOBITS) 10820b57cec5SDimitry Andric edata = os; 10830b57cec5SDimitry Andric if (os == last->lastSec) 10840b57cec5SDimitry Andric break; 10850b57cec5SDimitry Andric } 10860b57cec5SDimitry Andric 10870b57cec5SDimitry Andric if (ElfSym::edata1) 10880b57cec5SDimitry Andric ElfSym::edata1->section = edata; 10890b57cec5SDimitry Andric if (ElfSym::edata2) 10900b57cec5SDimitry Andric ElfSym::edata2->section = edata; 10910b57cec5SDimitry Andric 10920b57cec5SDimitry Andric // _end is the first location after the uninitialized data region. 10930b57cec5SDimitry Andric if (ElfSym::end1) 10940b57cec5SDimitry Andric ElfSym::end1->section = last->lastSec; 10950b57cec5SDimitry Andric if (ElfSym::end2) 10960b57cec5SDimitry Andric ElfSym::end2->section = last->lastSec; 10970b57cec5SDimitry Andric } 10980b57cec5SDimitry Andric 10990b57cec5SDimitry Andric if (ElfSym::bss) 11000b57cec5SDimitry Andric ElfSym::bss->section = findSection(".bss"); 11010b57cec5SDimitry Andric 11020b57cec5SDimitry Andric // Setup MIPS _gp_disp/__gnu_local_gp symbols which should 11030b57cec5SDimitry Andric // be equal to the _gp symbol's value. 11040b57cec5SDimitry Andric if (ElfSym::mipsGp) { 11050b57cec5SDimitry Andric // Find GP-relative section with the lowest address 11060b57cec5SDimitry Andric // and use this address to calculate default _gp value. 11070b57cec5SDimitry Andric for (OutputSection *os : outputSections) { 11080b57cec5SDimitry Andric if (os->flags & SHF_MIPS_GPREL) { 11090b57cec5SDimitry Andric ElfSym::mipsGp->section = os; 11100b57cec5SDimitry Andric ElfSym::mipsGp->value = 0x7ff0; 11110b57cec5SDimitry Andric break; 11120b57cec5SDimitry Andric } 11130b57cec5SDimitry Andric } 11140b57cec5SDimitry Andric } 11150b57cec5SDimitry Andric } 11160b57cec5SDimitry Andric 11170b57cec5SDimitry Andric // We want to find how similar two ranks are. 11180b57cec5SDimitry Andric // The more branches in getSectionRank that match, the more similar they are. 11190b57cec5SDimitry Andric // Since each branch corresponds to a bit flag, we can just use 11200b57cec5SDimitry Andric // countLeadingZeros. 11210b57cec5SDimitry Andric static int getRankProximityAux(OutputSection *a, OutputSection *b) { 11220b57cec5SDimitry Andric return countLeadingZeros(a->sortRank ^ b->sortRank); 11230b57cec5SDimitry Andric } 11240b57cec5SDimitry Andric 11254824e7fdSDimitry Andric static int getRankProximity(OutputSection *a, SectionCommand *b) { 11260b57cec5SDimitry Andric auto *sec = dyn_cast<OutputSection>(b); 11270b57cec5SDimitry Andric return (sec && sec->hasInputSections) ? getRankProximityAux(a, sec) : -1; 11280b57cec5SDimitry Andric } 11290b57cec5SDimitry Andric 11300b57cec5SDimitry Andric // When placing orphan sections, we want to place them after symbol assignments 11310b57cec5SDimitry Andric // so that an orphan after 11320b57cec5SDimitry Andric // begin_foo = .; 11330b57cec5SDimitry Andric // foo : { *(foo) } 11340b57cec5SDimitry Andric // end_foo = .; 11350b57cec5SDimitry Andric // doesn't break the intended meaning of the begin/end symbols. 11360b57cec5SDimitry Andric // We don't want to go over sections since findOrphanPos is the 11370b57cec5SDimitry Andric // one in charge of deciding the order of the sections. 11380b57cec5SDimitry Andric // We don't want to go over changes to '.', since doing so in 11390b57cec5SDimitry Andric // rx_sec : { *(rx_sec) } 11400b57cec5SDimitry Andric // . = ALIGN(0x1000); 11410b57cec5SDimitry Andric // /* The RW PT_LOAD starts here*/ 11420b57cec5SDimitry Andric // rw_sec : { *(rw_sec) } 11430b57cec5SDimitry Andric // would mean that the RW PT_LOAD would become unaligned. 11444824e7fdSDimitry Andric static bool shouldSkip(SectionCommand *cmd) { 11450b57cec5SDimitry Andric if (auto *assign = dyn_cast<SymbolAssignment>(cmd)) 11460b57cec5SDimitry Andric return assign->name != "."; 11470b57cec5SDimitry Andric return false; 11480b57cec5SDimitry Andric } 11490b57cec5SDimitry Andric 11500b57cec5SDimitry Andric // We want to place orphan sections so that they share as much 11510b57cec5SDimitry Andric // characteristics with their neighbors as possible. For example, if 11520b57cec5SDimitry Andric // both are rw, or both are tls. 1153*04eeddc0SDimitry Andric static SmallVectorImpl<SectionCommand *>::iterator 1154*04eeddc0SDimitry Andric findOrphanPos(SmallVectorImpl<SectionCommand *>::iterator b, 1155*04eeddc0SDimitry Andric SmallVectorImpl<SectionCommand *>::iterator e) { 11560b57cec5SDimitry Andric OutputSection *sec = cast<OutputSection>(*e); 11570b57cec5SDimitry Andric 11580b57cec5SDimitry Andric // Find the first element that has as close a rank as possible. 11594824e7fdSDimitry Andric auto i = std::max_element(b, e, [=](SectionCommand *a, SectionCommand *b) { 11600b57cec5SDimitry Andric return getRankProximity(sec, a) < getRankProximity(sec, b); 11610b57cec5SDimitry Andric }); 11620b57cec5SDimitry Andric if (i == e) 11630b57cec5SDimitry Andric return e; 1164349cc55cSDimitry Andric auto foundSec = dyn_cast<OutputSection>(*i); 1165349cc55cSDimitry Andric if (!foundSec) 1166349cc55cSDimitry Andric return e; 11670b57cec5SDimitry Andric 11680b57cec5SDimitry Andric // Consider all existing sections with the same proximity. 11690b57cec5SDimitry Andric int proximity = getRankProximity(sec, *i); 1170349cc55cSDimitry Andric unsigned sortRank = sec->sortRank; 1171349cc55cSDimitry Andric if (script->hasPhdrsCommands() || !script->memoryRegions.empty()) 1172349cc55cSDimitry Andric // Prevent the orphan section to be placed before the found section. If 1173349cc55cSDimitry Andric // custom program headers are defined, that helps to avoid adding it to a 1174349cc55cSDimitry Andric // previous segment and changing flags of that segment, for example, making 1175349cc55cSDimitry Andric // a read-only segment writable. If memory regions are defined, an orphan 1176349cc55cSDimitry Andric // section should continue the same region as the found section to better 1177349cc55cSDimitry Andric // resemble the behavior of GNU ld. 1178349cc55cSDimitry Andric sortRank = std::max(sortRank, foundSec->sortRank); 11790b57cec5SDimitry Andric for (; i != e; ++i) { 11800b57cec5SDimitry Andric auto *curSec = dyn_cast<OutputSection>(*i); 11810b57cec5SDimitry Andric if (!curSec || !curSec->hasInputSections) 11820b57cec5SDimitry Andric continue; 11830b57cec5SDimitry Andric if (getRankProximity(sec, curSec) != proximity || 1184349cc55cSDimitry Andric sortRank < curSec->sortRank) 11850b57cec5SDimitry Andric break; 11860b57cec5SDimitry Andric } 11870b57cec5SDimitry Andric 11884824e7fdSDimitry Andric auto isOutputSecWithInputSections = [](SectionCommand *cmd) { 11890b57cec5SDimitry Andric auto *os = dyn_cast<OutputSection>(cmd); 11900b57cec5SDimitry Andric return os && os->hasInputSections; 11910b57cec5SDimitry Andric }; 1192*04eeddc0SDimitry Andric auto j = 1193*04eeddc0SDimitry Andric std::find_if(std::make_reverse_iterator(i), std::make_reverse_iterator(b), 11940b57cec5SDimitry Andric isOutputSecWithInputSections); 11950b57cec5SDimitry Andric i = j.base(); 11960b57cec5SDimitry Andric 11970b57cec5SDimitry Andric // As a special case, if the orphan section is the last section, put 11980b57cec5SDimitry Andric // it at the very end, past any other commands. 11990b57cec5SDimitry Andric // This matches bfd's behavior and is convenient when the linker script fully 12000b57cec5SDimitry Andric // specifies the start of the file, but doesn't care about the end (the non 12010b57cec5SDimitry Andric // alloc sections for example). 12020b57cec5SDimitry Andric auto nextSec = std::find_if(i, e, isOutputSecWithInputSections); 12030b57cec5SDimitry Andric if (nextSec == e) 12040b57cec5SDimitry Andric return e; 12050b57cec5SDimitry Andric 12060b57cec5SDimitry Andric while (i != e && shouldSkip(*i)) 12070b57cec5SDimitry Andric ++i; 12080b57cec5SDimitry Andric return i; 12090b57cec5SDimitry Andric } 12100b57cec5SDimitry Andric 12115ffd83dbSDimitry Andric // Adds random priorities to sections not already in the map. 12125ffd83dbSDimitry Andric static void maybeShuffle(DenseMap<const InputSectionBase *, int> &order) { 1213fe6060f1SDimitry Andric if (config->shuffleSections.empty()) 12145ffd83dbSDimitry Andric return; 12155ffd83dbSDimitry Andric 12160eae32dcSDimitry Andric SmallVector<InputSectionBase *, 0> matched, sections = inputSections; 1217fe6060f1SDimitry Andric matched.reserve(sections.size()); 1218fe6060f1SDimitry Andric for (const auto &patAndSeed : config->shuffleSections) { 1219fe6060f1SDimitry Andric matched.clear(); 1220fe6060f1SDimitry Andric for (InputSectionBase *sec : sections) 1221fe6060f1SDimitry Andric if (patAndSeed.first.match(sec->name)) 1222fe6060f1SDimitry Andric matched.push_back(sec); 1223fe6060f1SDimitry Andric const uint32_t seed = patAndSeed.second; 1224fe6060f1SDimitry Andric if (seed == UINT32_MAX) { 1225fe6060f1SDimitry Andric // If --shuffle-sections <section-glob>=-1, reverse the section order. The 1226fe6060f1SDimitry Andric // section order is stable even if the number of sections changes. This is 1227fe6060f1SDimitry Andric // useful to catch issues like static initialization order fiasco 1228fe6060f1SDimitry Andric // reliably. 1229fe6060f1SDimitry Andric std::reverse(matched.begin(), matched.end()); 1230fe6060f1SDimitry Andric } else { 1231fe6060f1SDimitry Andric std::mt19937 g(seed ? seed : std::random_device()()); 1232fe6060f1SDimitry Andric llvm::shuffle(matched.begin(), matched.end(), g); 1233fe6060f1SDimitry Andric } 1234fe6060f1SDimitry Andric size_t i = 0; 1235fe6060f1SDimitry Andric for (InputSectionBase *&sec : sections) 1236fe6060f1SDimitry Andric if (patAndSeed.first.match(sec->name)) 1237fe6060f1SDimitry Andric sec = matched[i++]; 1238fe6060f1SDimitry Andric } 1239fe6060f1SDimitry Andric 12405ffd83dbSDimitry Andric // Existing priorities are < 0, so use priorities >= 0 for the missing 12415ffd83dbSDimitry Andric // sections. 1242fe6060f1SDimitry Andric int prio = 0; 1243fe6060f1SDimitry Andric for (InputSectionBase *sec : sections) { 1244fe6060f1SDimitry Andric if (order.try_emplace(sec, prio).second) 1245fe6060f1SDimitry Andric ++prio; 12465ffd83dbSDimitry Andric } 12475ffd83dbSDimitry Andric } 12485ffd83dbSDimitry Andric 12490b57cec5SDimitry Andric // Builds section order for handling --symbol-ordering-file. 12500b57cec5SDimitry Andric static DenseMap<const InputSectionBase *, int> buildSectionOrder() { 12510b57cec5SDimitry Andric DenseMap<const InputSectionBase *, int> sectionOrder; 1252349cc55cSDimitry Andric // Use the rarely used option --call-graph-ordering-file to sort sections. 12530b57cec5SDimitry Andric if (!config->callGraphProfile.empty()) 12540b57cec5SDimitry Andric return computeCallGraphProfileOrder(); 12550b57cec5SDimitry Andric 12560b57cec5SDimitry Andric if (config->symbolOrderingFile.empty()) 12570b57cec5SDimitry Andric return sectionOrder; 12580b57cec5SDimitry Andric 12590b57cec5SDimitry Andric struct SymbolOrderEntry { 12600b57cec5SDimitry Andric int priority; 12610b57cec5SDimitry Andric bool present; 12620b57cec5SDimitry Andric }; 12630b57cec5SDimitry Andric 12640b57cec5SDimitry Andric // Build a map from symbols to their priorities. Symbols that didn't 12650b57cec5SDimitry Andric // appear in the symbol ordering file have the lowest priority 0. 12660b57cec5SDimitry Andric // All explicitly mentioned symbols have negative (higher) priorities. 1267*04eeddc0SDimitry Andric DenseMap<CachedHashStringRef, SymbolOrderEntry> symbolOrder; 12680b57cec5SDimitry Andric int priority = -config->symbolOrderingFile.size(); 12690b57cec5SDimitry Andric for (StringRef s : config->symbolOrderingFile) 1270*04eeddc0SDimitry Andric symbolOrder.insert({CachedHashStringRef(s), {priority++, false}}); 12710b57cec5SDimitry Andric 12720b57cec5SDimitry Andric // Build a map from sections to their priorities. 12730b57cec5SDimitry Andric auto addSym = [&](Symbol &sym) { 1274*04eeddc0SDimitry Andric auto it = symbolOrder.find(CachedHashStringRef(sym.getName())); 12750b57cec5SDimitry Andric if (it == symbolOrder.end()) 12760b57cec5SDimitry Andric return; 12770b57cec5SDimitry Andric SymbolOrderEntry &ent = it->second; 12780b57cec5SDimitry Andric ent.present = true; 12790b57cec5SDimitry Andric 12800b57cec5SDimitry Andric maybeWarnUnorderableSymbol(&sym); 12810b57cec5SDimitry Andric 12820b57cec5SDimitry Andric if (auto *d = dyn_cast<Defined>(&sym)) { 12830b57cec5SDimitry Andric if (auto *sec = dyn_cast_or_null<InputSectionBase>(d->section)) { 12840eae32dcSDimitry Andric int &priority = sectionOrder[cast<InputSectionBase>(sec)]; 12850b57cec5SDimitry Andric priority = std::min(priority, ent.priority); 12860b57cec5SDimitry Andric } 12870b57cec5SDimitry Andric } 12880b57cec5SDimitry Andric }; 12890b57cec5SDimitry Andric 12900b57cec5SDimitry Andric // We want both global and local symbols. We get the global ones from the 12910b57cec5SDimitry Andric // symbol table and iterate the object files for the local ones. 1292480093f4SDimitry Andric for (Symbol *sym : symtab->symbols()) 12930b57cec5SDimitry Andric addSym(*sym); 12940b57cec5SDimitry Andric 12950eae32dcSDimitry Andric for (ELFFileBase *file : objectFiles) 1296*04eeddc0SDimitry Andric for (Symbol *sym : file->getLocalSymbols()) 12970b57cec5SDimitry Andric addSym(*sym); 12980b57cec5SDimitry Andric 12990b57cec5SDimitry Andric if (config->warnSymbolOrdering) 13000b57cec5SDimitry Andric for (auto orderEntry : symbolOrder) 13010b57cec5SDimitry Andric if (!orderEntry.second.present) 1302*04eeddc0SDimitry Andric warn("symbol ordering file: no such symbol: " + orderEntry.first.val()); 13030b57cec5SDimitry Andric 13040b57cec5SDimitry Andric return sectionOrder; 13050b57cec5SDimitry Andric } 13060b57cec5SDimitry Andric 13070b57cec5SDimitry Andric // Sorts the sections in ISD according to the provided section order. 13080b57cec5SDimitry Andric static void 13090b57cec5SDimitry Andric sortISDBySectionOrder(InputSectionDescription *isd, 13100b57cec5SDimitry Andric const DenseMap<const InputSectionBase *, int> &order) { 1311*04eeddc0SDimitry Andric SmallVector<InputSection *, 0> unorderedSections; 1312*04eeddc0SDimitry Andric SmallVector<std::pair<InputSection *, int>, 0> orderedSections; 13130b57cec5SDimitry Andric uint64_t unorderedSize = 0; 13140b57cec5SDimitry Andric 13150b57cec5SDimitry Andric for (InputSection *isec : isd->sections) { 13160b57cec5SDimitry Andric auto i = order.find(isec); 13170b57cec5SDimitry Andric if (i == order.end()) { 13180b57cec5SDimitry Andric unorderedSections.push_back(isec); 13190b57cec5SDimitry Andric unorderedSize += isec->getSize(); 13200b57cec5SDimitry Andric continue; 13210b57cec5SDimitry Andric } 13220b57cec5SDimitry Andric orderedSections.push_back({isec, i->second}); 13230b57cec5SDimitry Andric } 132485868e8aSDimitry Andric llvm::sort(orderedSections, llvm::less_second()); 13250b57cec5SDimitry Andric 13260b57cec5SDimitry Andric // Find an insertion point for the ordered section list in the unordered 13270b57cec5SDimitry Andric // section list. On targets with limited-range branches, this is the mid-point 13280b57cec5SDimitry Andric // of the unordered section list. This decreases the likelihood that a range 13290b57cec5SDimitry Andric // extension thunk will be needed to enter or exit the ordered region. If the 13300b57cec5SDimitry Andric // ordered section list is a list of hot functions, we can generally expect 13310b57cec5SDimitry Andric // the ordered functions to be called more often than the unordered functions, 13320b57cec5SDimitry Andric // making it more likely that any particular call will be within range, and 13330b57cec5SDimitry Andric // therefore reducing the number of thunks required. 13340b57cec5SDimitry Andric // 13350b57cec5SDimitry Andric // For example, imagine that you have 8MB of hot code and 32MB of cold code. 13360b57cec5SDimitry Andric // If the layout is: 13370b57cec5SDimitry Andric // 13380b57cec5SDimitry Andric // 8MB hot 13390b57cec5SDimitry Andric // 32MB cold 13400b57cec5SDimitry Andric // 13410b57cec5SDimitry Andric // only the first 8-16MB of the cold code (depending on which hot function it 13420b57cec5SDimitry Andric // is actually calling) can call the hot code without a range extension thunk. 13430b57cec5SDimitry Andric // However, if we use this layout: 13440b57cec5SDimitry Andric // 13450b57cec5SDimitry Andric // 16MB cold 13460b57cec5SDimitry Andric // 8MB hot 13470b57cec5SDimitry Andric // 16MB cold 13480b57cec5SDimitry Andric // 13490b57cec5SDimitry Andric // both the last 8-16MB of the first block of cold code and the first 8-16MB 13500b57cec5SDimitry Andric // of the second block of cold code can call the hot code without a thunk. So 13510b57cec5SDimitry Andric // we effectively double the amount of code that could potentially call into 13520b57cec5SDimitry Andric // the hot code without a thunk. 13530b57cec5SDimitry Andric size_t insPt = 0; 13540b57cec5SDimitry Andric if (target->getThunkSectionSpacing() && !orderedSections.empty()) { 13550b57cec5SDimitry Andric uint64_t unorderedPos = 0; 13560b57cec5SDimitry Andric for (; insPt != unorderedSections.size(); ++insPt) { 13570b57cec5SDimitry Andric unorderedPos += unorderedSections[insPt]->getSize(); 13580b57cec5SDimitry Andric if (unorderedPos > unorderedSize / 2) 13590b57cec5SDimitry Andric break; 13600b57cec5SDimitry Andric } 13610b57cec5SDimitry Andric } 13620b57cec5SDimitry Andric 13630b57cec5SDimitry Andric isd->sections.clear(); 13640b57cec5SDimitry Andric for (InputSection *isec : makeArrayRef(unorderedSections).slice(0, insPt)) 13650b57cec5SDimitry Andric isd->sections.push_back(isec); 13660b57cec5SDimitry Andric for (std::pair<InputSection *, int> p : orderedSections) 13670b57cec5SDimitry Andric isd->sections.push_back(p.first); 13680b57cec5SDimitry Andric for (InputSection *isec : makeArrayRef(unorderedSections).slice(insPt)) 13690b57cec5SDimitry Andric isd->sections.push_back(isec); 13700b57cec5SDimitry Andric } 13710b57cec5SDimitry Andric 13720b57cec5SDimitry Andric static void sortSection(OutputSection *sec, 13730b57cec5SDimitry Andric const DenseMap<const InputSectionBase *, int> &order) { 13740b57cec5SDimitry Andric StringRef name = sec->name; 13750b57cec5SDimitry Andric 13765ffd83dbSDimitry Andric // Never sort these. 13775ffd83dbSDimitry Andric if (name == ".init" || name == ".fini") 13785ffd83dbSDimitry Andric return; 13795ffd83dbSDimitry Andric 1380e8d8bef9SDimitry Andric // IRelative relocations that usually live in the .rel[a].dyn section should 1381fe6060f1SDimitry Andric // be processed last by the dynamic loader. To achieve that we add synthetic 1382fe6060f1SDimitry Andric // sections in the required order from the beginning so that the in.relaIplt 1383e8d8bef9SDimitry Andric // section is placed last in an output section. Here we just do not apply 1384e8d8bef9SDimitry Andric // sorting for an output section which holds the in.relaIplt section. 1385e8d8bef9SDimitry Andric if (in.relaIplt->getParent() == sec) 1386e8d8bef9SDimitry Andric return; 1387e8d8bef9SDimitry Andric 13885ffd83dbSDimitry Andric // Sort input sections by priority using the list provided by 13895ffd83dbSDimitry Andric // --symbol-ordering-file or --shuffle-sections=. This is a least significant 13905ffd83dbSDimitry Andric // digit radix sort. The sections may be sorted stably again by a more 13915ffd83dbSDimitry Andric // significant key. 13925ffd83dbSDimitry Andric if (!order.empty()) 13934824e7fdSDimitry Andric for (SectionCommand *b : sec->commands) 13945ffd83dbSDimitry Andric if (auto *isd = dyn_cast<InputSectionDescription>(b)) 13955ffd83dbSDimitry Andric sortISDBySectionOrder(isd, order); 13965ffd83dbSDimitry Andric 1397349cc55cSDimitry Andric if (script->hasSectionsCommand) 1398349cc55cSDimitry Andric return; 1399349cc55cSDimitry Andric 14000b57cec5SDimitry Andric if (name == ".init_array" || name == ".fini_array") { 14010b57cec5SDimitry Andric sec->sortInitFini(); 1402349cc55cSDimitry Andric } else if (name == ".ctors" || name == ".dtors") { 14030b57cec5SDimitry Andric sec->sortCtorsDtors(); 1404349cc55cSDimitry Andric } else if (config->emachine == EM_PPC64 && name == ".toc") { 14050b57cec5SDimitry Andric // .toc is allocated just after .got and is accessed using GOT-relative 14060b57cec5SDimitry Andric // relocations. Object files compiled with small code model have an 14070b57cec5SDimitry Andric // addressable range of [.got, .got + 0xFFFC] for GOT-relative relocations. 1408349cc55cSDimitry Andric // To reduce the risk of relocation overflow, .toc contents are sorted so 1409349cc55cSDimitry Andric // that sections having smaller relocation offsets are at beginning of .toc 14104824e7fdSDimitry Andric assert(sec->commands.size() == 1); 14114824e7fdSDimitry Andric auto *isd = cast<InputSectionDescription>(sec->commands[0]); 14120b57cec5SDimitry Andric llvm::stable_sort(isd->sections, 14130b57cec5SDimitry Andric [](const InputSection *a, const InputSection *b) -> bool { 14140b57cec5SDimitry Andric return a->file->ppc64SmallCodeModelTocRelocs && 14150b57cec5SDimitry Andric !b->file->ppc64SmallCodeModelTocRelocs; 14160b57cec5SDimitry Andric }); 14170b57cec5SDimitry Andric } 14180b57cec5SDimitry Andric } 14190b57cec5SDimitry Andric 14200b57cec5SDimitry Andric // If no layout was provided by linker script, we want to apply default 14210b57cec5SDimitry Andric // sorting for special input sections. This also handles --symbol-ordering-file. 14220b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::sortInputSections() { 14230b57cec5SDimitry Andric // Build the order once since it is expensive. 14240b57cec5SDimitry Andric DenseMap<const InputSectionBase *, int> order = buildSectionOrder(); 14255ffd83dbSDimitry Andric maybeShuffle(order); 14264824e7fdSDimitry Andric for (SectionCommand *cmd : script->sectionCommands) 14274824e7fdSDimitry Andric if (auto *sec = dyn_cast<OutputSection>(cmd)) 14280b57cec5SDimitry Andric sortSection(sec, order); 14290b57cec5SDimitry Andric } 14300b57cec5SDimitry Andric 14310b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::sortSections() { 1432e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Sort sections"); 14330b57cec5SDimitry Andric script->adjustSectionsBeforeSorting(); 14340b57cec5SDimitry Andric 14350b57cec5SDimitry Andric // Don't sort if using -r. It is not necessary and we want to preserve the 14360b57cec5SDimitry Andric // relative order for SHF_LINK_ORDER sections. 14370b57cec5SDimitry Andric if (config->relocatable) 14380b57cec5SDimitry Andric return; 14390b57cec5SDimitry Andric 14400b57cec5SDimitry Andric sortInputSections(); 14410b57cec5SDimitry Andric 14424824e7fdSDimitry Andric for (SectionCommand *cmd : script->sectionCommands) { 14434824e7fdSDimitry Andric auto *os = dyn_cast<OutputSection>(cmd); 14440b57cec5SDimitry Andric if (!os) 14450b57cec5SDimitry Andric continue; 14460b57cec5SDimitry Andric os->sortRank = getSectionRank(os); 14470b57cec5SDimitry Andric } 14480b57cec5SDimitry Andric 14490b57cec5SDimitry Andric if (!script->hasSectionsCommand) { 14500b57cec5SDimitry Andric // We know that all the OutputSections are contiguous in this case. 14514824e7fdSDimitry Andric auto isSection = [](SectionCommand *cmd) { 14524824e7fdSDimitry Andric return isa<OutputSection>(cmd); 14534824e7fdSDimitry Andric }; 14540b57cec5SDimitry Andric std::stable_sort( 14550b57cec5SDimitry Andric llvm::find_if(script->sectionCommands, isSection), 14560b57cec5SDimitry Andric llvm::find_if(llvm::reverse(script->sectionCommands), isSection).base(), 14570b57cec5SDimitry Andric compareSections); 14585ffd83dbSDimitry Andric 14595ffd83dbSDimitry Andric // Process INSERT commands. From this point onwards the order of 14605ffd83dbSDimitry Andric // script->sectionCommands is fixed. 14615ffd83dbSDimitry Andric script->processInsertCommands(); 14620b57cec5SDimitry Andric return; 14630b57cec5SDimitry Andric } 14640b57cec5SDimitry Andric 14655ffd83dbSDimitry Andric script->processInsertCommands(); 14665ffd83dbSDimitry Andric 14670b57cec5SDimitry Andric // Orphan sections are sections present in the input files which are 14680b57cec5SDimitry Andric // not explicitly placed into the output file by the linker script. 14690b57cec5SDimitry Andric // 14700b57cec5SDimitry Andric // The sections in the linker script are already in the correct 14710b57cec5SDimitry Andric // order. We have to figuere out where to insert the orphan 14720b57cec5SDimitry Andric // sections. 14730b57cec5SDimitry Andric // 14740b57cec5SDimitry Andric // The order of the sections in the script is arbitrary and may not agree with 14750b57cec5SDimitry Andric // compareSections. This means that we cannot easily define a strict weak 14760b57cec5SDimitry Andric // ordering. To see why, consider a comparison of a section in the script and 14770b57cec5SDimitry Andric // one not in the script. We have a two simple options: 14780b57cec5SDimitry Andric // * Make them equivalent (a is not less than b, and b is not less than a). 14790b57cec5SDimitry Andric // The problem is then that equivalence has to be transitive and we can 14800b57cec5SDimitry Andric // have sections a, b and c with only b in a script and a less than c 14810b57cec5SDimitry Andric // which breaks this property. 14820b57cec5SDimitry Andric // * Use compareSectionsNonScript. Given that the script order doesn't have 14830b57cec5SDimitry Andric // to match, we can end up with sections a, b, c, d where b and c are in the 14840b57cec5SDimitry Andric // script and c is compareSectionsNonScript less than b. In which case d 14850b57cec5SDimitry Andric // can be equivalent to c, a to b and d < a. As a concrete example: 14860b57cec5SDimitry Andric // .a (rx) # not in script 14870b57cec5SDimitry Andric // .b (rx) # in script 14880b57cec5SDimitry Andric // .c (ro) # in script 14890b57cec5SDimitry Andric // .d (ro) # not in script 14900b57cec5SDimitry Andric // 14910b57cec5SDimitry Andric // The way we define an order then is: 14920b57cec5SDimitry Andric // * Sort only the orphan sections. They are in the end right now. 14930b57cec5SDimitry Andric // * Move each orphan section to its preferred position. We try 14940b57cec5SDimitry Andric // to put each section in the last position where it can share 14950b57cec5SDimitry Andric // a PT_LOAD. 14960b57cec5SDimitry Andric // 14970b57cec5SDimitry Andric // There is some ambiguity as to where exactly a new entry should be 14980b57cec5SDimitry Andric // inserted, because Commands contains not only output section 14990b57cec5SDimitry Andric // commands but also other types of commands such as symbol assignment 15000b57cec5SDimitry Andric // expressions. There's no correct answer here due to the lack of the 15010b57cec5SDimitry Andric // formal specification of the linker script. We use heuristics to 15020b57cec5SDimitry Andric // determine whether a new output command should be added before or 15030b57cec5SDimitry Andric // after another commands. For the details, look at shouldSkip 15040b57cec5SDimitry Andric // function. 15050b57cec5SDimitry Andric 15060b57cec5SDimitry Andric auto i = script->sectionCommands.begin(); 15070b57cec5SDimitry Andric auto e = script->sectionCommands.end(); 15084824e7fdSDimitry Andric auto nonScriptI = std::find_if(i, e, [](SectionCommand *cmd) { 15094824e7fdSDimitry Andric if (auto *sec = dyn_cast<OutputSection>(cmd)) 15100b57cec5SDimitry Andric return sec->sectionIndex == UINT32_MAX; 15110b57cec5SDimitry Andric return false; 15120b57cec5SDimitry Andric }); 15130b57cec5SDimitry Andric 15140b57cec5SDimitry Andric // Sort the orphan sections. 15150b57cec5SDimitry Andric std::stable_sort(nonScriptI, e, compareSections); 15160b57cec5SDimitry Andric 15170b57cec5SDimitry Andric // As a horrible special case, skip the first . assignment if it is before any 15180b57cec5SDimitry Andric // section. We do this because it is common to set a load address by starting 15190b57cec5SDimitry Andric // the script with ". = 0xabcd" and the expectation is that every section is 15200b57cec5SDimitry Andric // after that. 15210b57cec5SDimitry Andric auto firstSectionOrDotAssignment = 15224824e7fdSDimitry Andric std::find_if(i, e, [](SectionCommand *cmd) { return !shouldSkip(cmd); }); 15230b57cec5SDimitry Andric if (firstSectionOrDotAssignment != e && 15240b57cec5SDimitry Andric isa<SymbolAssignment>(**firstSectionOrDotAssignment)) 15250b57cec5SDimitry Andric ++firstSectionOrDotAssignment; 15260b57cec5SDimitry Andric i = firstSectionOrDotAssignment; 15270b57cec5SDimitry Andric 15280b57cec5SDimitry Andric while (nonScriptI != e) { 15290b57cec5SDimitry Andric auto pos = findOrphanPos(i, nonScriptI); 15300b57cec5SDimitry Andric OutputSection *orphan = cast<OutputSection>(*nonScriptI); 15310b57cec5SDimitry Andric 15320b57cec5SDimitry Andric // As an optimization, find all sections with the same sort rank 15330b57cec5SDimitry Andric // and insert them with one rotate. 15340b57cec5SDimitry Andric unsigned rank = orphan->sortRank; 15354824e7fdSDimitry Andric auto end = std::find_if(nonScriptI + 1, e, [=](SectionCommand *cmd) { 15360b57cec5SDimitry Andric return cast<OutputSection>(cmd)->sortRank != rank; 15370b57cec5SDimitry Andric }); 15380b57cec5SDimitry Andric std::rotate(pos, nonScriptI, end); 15390b57cec5SDimitry Andric nonScriptI = end; 15400b57cec5SDimitry Andric } 15410b57cec5SDimitry Andric 15420b57cec5SDimitry Andric script->adjustSectionsAfterSorting(); 15430b57cec5SDimitry Andric } 15440b57cec5SDimitry Andric 15450b57cec5SDimitry Andric static bool compareByFilePosition(InputSection *a, InputSection *b) { 1546e8d8bef9SDimitry Andric InputSection *la = a->flags & SHF_LINK_ORDER ? a->getLinkOrderDep() : nullptr; 1547e8d8bef9SDimitry Andric InputSection *lb = b->flags & SHF_LINK_ORDER ? b->getLinkOrderDep() : nullptr; 1548e8d8bef9SDimitry Andric // SHF_LINK_ORDER sections with non-zero sh_link are ordered before 1549e8d8bef9SDimitry Andric // non-SHF_LINK_ORDER sections and SHF_LINK_ORDER sections with zero sh_link. 1550e8d8bef9SDimitry Andric if (!la || !lb) 1551e8d8bef9SDimitry Andric return la && !lb; 15520b57cec5SDimitry Andric OutputSection *aOut = la->getParent(); 15530b57cec5SDimitry Andric OutputSection *bOut = lb->getParent(); 15540b57cec5SDimitry Andric 15550b57cec5SDimitry Andric if (aOut != bOut) 15565ffd83dbSDimitry Andric return aOut->addr < bOut->addr; 15570b57cec5SDimitry Andric return la->outSecOff < lb->outSecOff; 15580b57cec5SDimitry Andric } 15590b57cec5SDimitry Andric 15600b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::resolveShfLinkOrder() { 1561e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Resolve SHF_LINK_ORDER"); 15620b57cec5SDimitry Andric for (OutputSection *sec : outputSections) { 15630b57cec5SDimitry Andric if (!(sec->flags & SHF_LINK_ORDER)) 15640b57cec5SDimitry Andric continue; 15650b57cec5SDimitry Andric 156685868e8aSDimitry Andric // The ARM.exidx section use SHF_LINK_ORDER, but we have consolidated 156785868e8aSDimitry Andric // this processing inside the ARMExidxsyntheticsection::finalizeContents(). 156885868e8aSDimitry Andric if (!config->relocatable && config->emachine == EM_ARM && 156985868e8aSDimitry Andric sec->type == SHT_ARM_EXIDX) 157085868e8aSDimitry Andric continue; 157185868e8aSDimitry Andric 1572e8d8bef9SDimitry Andric // Link order may be distributed across several InputSectionDescriptions. 1573e8d8bef9SDimitry Andric // Sorting is performed separately. 15740b57cec5SDimitry Andric std::vector<InputSection **> scriptSections; 15750b57cec5SDimitry Andric std::vector<InputSection *> sections; 15764824e7fdSDimitry Andric for (SectionCommand *cmd : sec->commands) { 15774824e7fdSDimitry Andric auto *isd = dyn_cast<InputSectionDescription>(cmd); 1578e8d8bef9SDimitry Andric if (!isd) 1579e8d8bef9SDimitry Andric continue; 1580e8d8bef9SDimitry Andric bool hasLinkOrder = false; 1581e8d8bef9SDimitry Andric scriptSections.clear(); 1582e8d8bef9SDimitry Andric sections.clear(); 15830b57cec5SDimitry Andric for (InputSection *&isec : isd->sections) { 1584e8d8bef9SDimitry Andric if (isec->flags & SHF_LINK_ORDER) { 158585868e8aSDimitry Andric InputSection *link = isec->getLinkOrderDep(); 1586e8d8bef9SDimitry Andric if (link && !link->getParent()) 158785868e8aSDimitry Andric error(toString(isec) + ": sh_link points to discarded section " + 158885868e8aSDimitry Andric toString(link)); 1589e8d8bef9SDimitry Andric hasLinkOrder = true; 15900b57cec5SDimitry Andric } 1591e8d8bef9SDimitry Andric scriptSections.push_back(&isec); 1592e8d8bef9SDimitry Andric sections.push_back(isec); 15930b57cec5SDimitry Andric } 1594e8d8bef9SDimitry Andric if (hasLinkOrder && errorCount() == 0) { 15950b57cec5SDimitry Andric llvm::stable_sort(sections, compareByFilePosition); 1596e8d8bef9SDimitry Andric for (int i = 0, n = sections.size(); i != n; ++i) 15970b57cec5SDimitry Andric *scriptSections[i] = sections[i]; 15980b57cec5SDimitry Andric } 15990b57cec5SDimitry Andric } 1600e8d8bef9SDimitry Andric } 1601e8d8bef9SDimitry Andric } 16020b57cec5SDimitry Andric 16035ffd83dbSDimitry Andric static void finalizeSynthetic(SyntheticSection *sec) { 1604e8d8bef9SDimitry Andric if (sec && sec->isNeeded() && sec->getParent()) { 1605e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Finalize synthetic sections", sec->name); 16065ffd83dbSDimitry Andric sec->finalizeContents(); 16075ffd83dbSDimitry Andric } 1608e8d8bef9SDimitry Andric } 16095ffd83dbSDimitry Andric 16100b57cec5SDimitry Andric // We need to generate and finalize the content that depends on the address of 16110b57cec5SDimitry Andric // InputSections. As the generation of the content may also alter InputSection 16120b57cec5SDimitry Andric // addresses we must converge to a fixed point. We do that here. See the comment 16130b57cec5SDimitry Andric // in Writer<ELFT>::finalizeSections(). 16140b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::finalizeAddressDependentContent() { 1615e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Finalize address dependent content"); 16160b57cec5SDimitry Andric ThunkCreator tc; 16170b57cec5SDimitry Andric AArch64Err843419Patcher a64p; 161885868e8aSDimitry Andric ARMErr657417Patcher a32p; 16190b57cec5SDimitry Andric script->assignAddresses(); 16205ffd83dbSDimitry Andric // .ARM.exidx and SHF_LINK_ORDER do not require precise addresses, but they 16215ffd83dbSDimitry Andric // do require the relative addresses of OutputSections because linker scripts 16225ffd83dbSDimitry Andric // can assign Virtual Addresses to OutputSections that are not monotonically 16235ffd83dbSDimitry Andric // increasing. 16245ffd83dbSDimitry Andric for (Partition &part : partitions) 1625*04eeddc0SDimitry Andric finalizeSynthetic(part.armExidx.get()); 16265ffd83dbSDimitry Andric resolveShfLinkOrder(); 16275ffd83dbSDimitry Andric 16285ffd83dbSDimitry Andric // Converts call x@GDPLT to call __tls_get_addr 16295ffd83dbSDimitry Andric if (config->emachine == EM_HEXAGON) 16305ffd83dbSDimitry Andric hexagonTLSSymbolUpdate(outputSections); 16310b57cec5SDimitry Andric 163285868e8aSDimitry Andric int assignPasses = 0; 163385868e8aSDimitry Andric for (;;) { 163485868e8aSDimitry Andric bool changed = target->needsThunks && tc.createThunks(outputSections); 163585868e8aSDimitry Andric 163685868e8aSDimitry Andric // With Thunk Size much smaller than branch range we expect to 1637e8d8bef9SDimitry Andric // converge quickly; if we get to 15 something has gone wrong. 1638e8d8bef9SDimitry Andric if (changed && tc.pass >= 15) { 163985868e8aSDimitry Andric error("thunk creation not converged"); 164085868e8aSDimitry Andric break; 164185868e8aSDimitry Andric } 16420b57cec5SDimitry Andric 16430b57cec5SDimitry Andric if (config->fixCortexA53Errata843419) { 16440b57cec5SDimitry Andric if (changed) 16450b57cec5SDimitry Andric script->assignAddresses(); 16460b57cec5SDimitry Andric changed |= a64p.createFixes(); 16470b57cec5SDimitry Andric } 164885868e8aSDimitry Andric if (config->fixCortexA8) { 164985868e8aSDimitry Andric if (changed) 165085868e8aSDimitry Andric script->assignAddresses(); 165185868e8aSDimitry Andric changed |= a32p.createFixes(); 165285868e8aSDimitry Andric } 16530b57cec5SDimitry Andric 16540b57cec5SDimitry Andric if (in.mipsGot) 16550b57cec5SDimitry Andric in.mipsGot->updateAllocSize(); 16560b57cec5SDimitry Andric 16570b57cec5SDimitry Andric for (Partition &part : partitions) { 16580b57cec5SDimitry Andric changed |= part.relaDyn->updateAllocSize(); 16590b57cec5SDimitry Andric if (part.relrDyn) 16600b57cec5SDimitry Andric changed |= part.relrDyn->updateAllocSize(); 16610b57cec5SDimitry Andric } 16620b57cec5SDimitry Andric 166385868e8aSDimitry Andric const Defined *changedSym = script->assignAddresses(); 166485868e8aSDimitry Andric if (!changed) { 166585868e8aSDimitry Andric // Some symbols may be dependent on section addresses. When we break the 166685868e8aSDimitry Andric // loop, the symbol values are finalized because a previous 166785868e8aSDimitry Andric // assignAddresses() finalized section addresses. 166885868e8aSDimitry Andric if (!changedSym) 166985868e8aSDimitry Andric break; 167085868e8aSDimitry Andric if (++assignPasses == 5) { 167185868e8aSDimitry Andric errorOrWarn("assignment to symbol " + toString(*changedSym) + 167285868e8aSDimitry Andric " does not converge"); 167385868e8aSDimitry Andric break; 167485868e8aSDimitry Andric } 167585868e8aSDimitry Andric } 16760b57cec5SDimitry Andric } 16775ffd83dbSDimitry Andric 1678*04eeddc0SDimitry Andric if (config->relocatable) 1679*04eeddc0SDimitry Andric for (OutputSection *sec : outputSections) 1680*04eeddc0SDimitry Andric sec->addr = 0; 1681*04eeddc0SDimitry Andric 16825ffd83dbSDimitry Andric // If addrExpr is set, the address may not be a multiple of the alignment. 16835ffd83dbSDimitry Andric // Warn because this is error-prone. 16844824e7fdSDimitry Andric for (SectionCommand *cmd : script->sectionCommands) 16855ffd83dbSDimitry Andric if (auto *os = dyn_cast<OutputSection>(cmd)) 16865ffd83dbSDimitry Andric if (os->addr % os->alignment != 0) 16875ffd83dbSDimitry Andric warn("address (0x" + Twine::utohexstr(os->addr) + ") of section " + 16885ffd83dbSDimitry Andric os->name + " is not a multiple of alignment (" + 16895ffd83dbSDimitry Andric Twine(os->alignment) + ")"); 16900b57cec5SDimitry Andric } 16910b57cec5SDimitry Andric 1692fe6060f1SDimitry Andric // If Input Sections have been shrunk (basic block sections) then 16935ffd83dbSDimitry Andric // update symbol values and sizes associated with these sections. With basic 16945ffd83dbSDimitry Andric // block sections, input sections can shrink when the jump instructions at 16955ffd83dbSDimitry Andric // the end of the section are relaxed. 16965ffd83dbSDimitry Andric static void fixSymbolsAfterShrinking() { 16975ffd83dbSDimitry Andric for (InputFile *File : objectFiles) { 16985ffd83dbSDimitry Andric parallelForEach(File->getSymbols(), [&](Symbol *Sym) { 16995ffd83dbSDimitry Andric auto *def = dyn_cast<Defined>(Sym); 17005ffd83dbSDimitry Andric if (!def) 17015ffd83dbSDimitry Andric return; 17025ffd83dbSDimitry Andric 17035ffd83dbSDimitry Andric const SectionBase *sec = def->section; 17045ffd83dbSDimitry Andric if (!sec) 17055ffd83dbSDimitry Andric return; 17065ffd83dbSDimitry Andric 17070eae32dcSDimitry Andric const InputSectionBase *inputSec = dyn_cast<InputSectionBase>(sec); 17085ffd83dbSDimitry Andric if (!inputSec || !inputSec->bytesDropped) 17095ffd83dbSDimitry Andric return; 17105ffd83dbSDimitry Andric 17115ffd83dbSDimitry Andric const size_t OldSize = inputSec->data().size(); 17125ffd83dbSDimitry Andric const size_t NewSize = OldSize - inputSec->bytesDropped; 17135ffd83dbSDimitry Andric 17145ffd83dbSDimitry Andric if (def->value > NewSize && def->value <= OldSize) { 17155ffd83dbSDimitry Andric LLVM_DEBUG(llvm::dbgs() 17165ffd83dbSDimitry Andric << "Moving symbol " << Sym->getName() << " from " 17175ffd83dbSDimitry Andric << def->value << " to " 17185ffd83dbSDimitry Andric << def->value - inputSec->bytesDropped << " bytes\n"); 17195ffd83dbSDimitry Andric def->value -= inputSec->bytesDropped; 17205ffd83dbSDimitry Andric return; 17215ffd83dbSDimitry Andric } 17225ffd83dbSDimitry Andric 17235ffd83dbSDimitry Andric if (def->value + def->size > NewSize && def->value <= OldSize && 17245ffd83dbSDimitry Andric def->value + def->size <= OldSize) { 17255ffd83dbSDimitry Andric LLVM_DEBUG(llvm::dbgs() 17265ffd83dbSDimitry Andric << "Shrinking symbol " << Sym->getName() << " from " 17275ffd83dbSDimitry Andric << def->size << " to " << def->size - inputSec->bytesDropped 17285ffd83dbSDimitry Andric << " bytes\n"); 17295ffd83dbSDimitry Andric def->size -= inputSec->bytesDropped; 17305ffd83dbSDimitry Andric } 17315ffd83dbSDimitry Andric }); 17325ffd83dbSDimitry Andric } 17335ffd83dbSDimitry Andric } 17345ffd83dbSDimitry Andric 17355ffd83dbSDimitry Andric // If basic block sections exist, there are opportunities to delete fall thru 17365ffd83dbSDimitry Andric // jumps and shrink jump instructions after basic block reordering. This 17375ffd83dbSDimitry Andric // relaxation pass does that. It is only enabled when --optimize-bb-jumps 17385ffd83dbSDimitry Andric // option is used. 17395ffd83dbSDimitry Andric template <class ELFT> void Writer<ELFT>::optimizeBasicBlockJumps() { 17405ffd83dbSDimitry Andric assert(config->optimizeBBJumps); 17415ffd83dbSDimitry Andric 17425ffd83dbSDimitry Andric script->assignAddresses(); 17435ffd83dbSDimitry Andric // For every output section that has executable input sections, this 17445ffd83dbSDimitry Andric // does the following: 17455ffd83dbSDimitry Andric // 1. Deletes all direct jump instructions in input sections that 17465ffd83dbSDimitry Andric // jump to the following section as it is not required. 17475ffd83dbSDimitry Andric // 2. If there are two consecutive jump instructions, it checks 17485ffd83dbSDimitry Andric // if they can be flipped and one can be deleted. 1749*04eeddc0SDimitry Andric for (OutputSection *osec : outputSections) { 1750*04eeddc0SDimitry Andric if (!(osec->flags & SHF_EXECINSTR)) 17515ffd83dbSDimitry Andric continue; 1752*04eeddc0SDimitry Andric SmallVector<InputSection *, 0> sections = getInputSections(*osec); 1753*04eeddc0SDimitry Andric size_t numDeleted = 0; 17545ffd83dbSDimitry Andric // Delete all fall through jump instructions. Also, check if two 17555ffd83dbSDimitry Andric // consecutive jump instructions can be flipped so that a fall 17565ffd83dbSDimitry Andric // through jmp instruction can be deleted. 1757*04eeddc0SDimitry Andric for (size_t i = 0, e = sections.size(); i != e; ++i) { 17585ffd83dbSDimitry Andric InputSection *next = i + 1 < sections.size() ? sections[i + 1] : nullptr; 1759*04eeddc0SDimitry Andric InputSection &sec = *sections[i]; 1760*04eeddc0SDimitry Andric numDeleted += target->deleteFallThruJmpInsn(sec, sec.file, next); 1761*04eeddc0SDimitry Andric } 17625ffd83dbSDimitry Andric if (numDeleted > 0) { 17635ffd83dbSDimitry Andric script->assignAddresses(); 17645ffd83dbSDimitry Andric LLVM_DEBUG(llvm::dbgs() 17655ffd83dbSDimitry Andric << "Removing " << numDeleted << " fall through jumps\n"); 17665ffd83dbSDimitry Andric } 17675ffd83dbSDimitry Andric } 17685ffd83dbSDimitry Andric 17695ffd83dbSDimitry Andric fixSymbolsAfterShrinking(); 17705ffd83dbSDimitry Andric 1771*04eeddc0SDimitry Andric for (OutputSection *osec : outputSections) 1772*04eeddc0SDimitry Andric for (InputSection *is : getInputSections(*osec)) 17735ffd83dbSDimitry Andric is->trim(); 17745ffd83dbSDimitry Andric } 17750b57cec5SDimitry Andric 17760b57cec5SDimitry Andric // In order to allow users to manipulate linker-synthesized sections, 17770b57cec5SDimitry Andric // we had to add synthetic sections to the input section list early, 17780b57cec5SDimitry Andric // even before we make decisions whether they are needed. This allows 17790b57cec5SDimitry Andric // users to write scripts like this: ".mygot : { .got }". 17800b57cec5SDimitry Andric // 17810b57cec5SDimitry Andric // Doing it has an unintended side effects. If it turns out that we 17820b57cec5SDimitry Andric // don't need a .got (for example) at all because there's no 17830b57cec5SDimitry Andric // relocation that needs a .got, we don't want to emit .got. 17840b57cec5SDimitry Andric // 17850b57cec5SDimitry Andric // To deal with the above problem, this function is called after 17860b57cec5SDimitry Andric // scanRelocations is called to remove synthetic sections that turn 17870b57cec5SDimitry Andric // out to be empty. 17880b57cec5SDimitry Andric static void removeUnusedSyntheticSections() { 17890b57cec5SDimitry Andric // All input synthetic sections that can be empty are placed after 1790fe6060f1SDimitry Andric // all regular ones. Reverse iterate to find the first synthetic section 1791fe6060f1SDimitry Andric // after a non-synthetic one which will be our starting point. 1792fe6060f1SDimitry Andric auto start = std::find_if(inputSections.rbegin(), inputSections.rend(), 1793fe6060f1SDimitry Andric [](InputSectionBase *s) { 1794fe6060f1SDimitry Andric return !isa<SyntheticSection>(s); 1795fe6060f1SDimitry Andric }) 1796fe6060f1SDimitry Andric .base(); 1797fe6060f1SDimitry Andric 17984824e7fdSDimitry Andric // Remove unused synthetic sections from inputSections; 17994824e7fdSDimitry Andric DenseSet<InputSectionBase *> unused; 18004824e7fdSDimitry Andric auto end = 18014824e7fdSDimitry Andric std::remove_if(start, inputSections.end(), [&](InputSectionBase *s) { 18024824e7fdSDimitry Andric auto *sec = cast<SyntheticSection>(s); 18034824e7fdSDimitry Andric if (sec->getParent() && sec->isNeeded()) 1804fe6060f1SDimitry Andric return false; 18054824e7fdSDimitry Andric unused.insert(sec); 18064824e7fdSDimitry Andric return true; 1807fe6060f1SDimitry Andric }); 1808fe6060f1SDimitry Andric inputSections.erase(end, inputSections.end()); 18094824e7fdSDimitry Andric 18104824e7fdSDimitry Andric // Remove unused synthetic sections from the corresponding input section 18114824e7fdSDimitry Andric // description and orphanSections. 18124824e7fdSDimitry Andric for (auto *sec : unused) 18134824e7fdSDimitry Andric if (OutputSection *osec = cast<SyntheticSection>(sec)->getParent()) 18144824e7fdSDimitry Andric for (SectionCommand *cmd : osec->commands) 18154824e7fdSDimitry Andric if (auto *isd = dyn_cast<InputSectionDescription>(cmd)) 18164824e7fdSDimitry Andric llvm::erase_if(isd->sections, [&](InputSection *isec) { 18174824e7fdSDimitry Andric return unused.count(isec); 18184824e7fdSDimitry Andric }); 18194824e7fdSDimitry Andric llvm::erase_if(script->orphanSections, [&](const InputSectionBase *sec) { 18204824e7fdSDimitry Andric return unused.count(sec); 18214824e7fdSDimitry Andric }); 18220b57cec5SDimitry Andric } 18230b57cec5SDimitry Andric 18240b57cec5SDimitry Andric // Create output section objects and add them to OutputSections. 18250b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::finalizeSections() { 18260b57cec5SDimitry Andric Out::preinitArray = findSection(".preinit_array"); 18270b57cec5SDimitry Andric Out::initArray = findSection(".init_array"); 18280b57cec5SDimitry Andric Out::finiArray = findSection(".fini_array"); 18290b57cec5SDimitry Andric 18300b57cec5SDimitry Andric // The linker needs to define SECNAME_start, SECNAME_end and SECNAME_stop 18310b57cec5SDimitry Andric // symbols for sections, so that the runtime can get the start and end 18320b57cec5SDimitry Andric // addresses of each section by section name. Add such symbols. 18330b57cec5SDimitry Andric if (!config->relocatable) { 18340b57cec5SDimitry Andric addStartEndSymbols(); 18354824e7fdSDimitry Andric for (SectionCommand *cmd : script->sectionCommands) 18364824e7fdSDimitry Andric if (auto *sec = dyn_cast<OutputSection>(cmd)) 18370b57cec5SDimitry Andric addStartStopSymbols(sec); 18380b57cec5SDimitry Andric } 18390b57cec5SDimitry Andric 18400b57cec5SDimitry Andric // Add _DYNAMIC symbol. Unlike GNU gold, our _DYNAMIC symbol has no type. 18410b57cec5SDimitry Andric // It should be okay as no one seems to care about the type. 18420b57cec5SDimitry Andric // Even the author of gold doesn't remember why gold behaves that way. 18430b57cec5SDimitry Andric // https://sourceware.org/ml/binutils/2002-03/msg00360.html 18440b57cec5SDimitry Andric if (mainPart->dynamic->parent) 1845*04eeddc0SDimitry Andric symtab->addSymbol( 1846*04eeddc0SDimitry Andric Defined{/*file=*/nullptr, "_DYNAMIC", STB_WEAK, STV_HIDDEN, STT_NOTYPE, 1847*04eeddc0SDimitry Andric /*value=*/0, /*size=*/0, mainPart->dynamic.get()}); 18480b57cec5SDimitry Andric 18490b57cec5SDimitry Andric // Define __rel[a]_iplt_{start,end} symbols if needed. 18500b57cec5SDimitry Andric addRelIpltSymbols(); 18510b57cec5SDimitry Andric 185285868e8aSDimitry Andric // RISC-V's gp can address +/- 2 KiB, set it to .sdata + 0x800. This symbol 185385868e8aSDimitry Andric // should only be defined in an executable. If .sdata does not exist, its 185485868e8aSDimitry Andric // value/section does not matter but it has to be relative, so set its 185585868e8aSDimitry Andric // st_shndx arbitrarily to 1 (Out::elfHeader). 185685868e8aSDimitry Andric if (config->emachine == EM_RISCV && !config->shared) { 185785868e8aSDimitry Andric OutputSection *sec = findSection(".sdata"); 18580b57cec5SDimitry Andric ElfSym::riscvGlobalPointer = 185985868e8aSDimitry Andric addOptionalRegular("__global_pointer$", sec ? sec : Out::elfHeader, 1860349cc55cSDimitry Andric 0x800, STV_DEFAULT); 186185868e8aSDimitry Andric } 18620b57cec5SDimitry Andric 1863349cc55cSDimitry Andric if (config->emachine == EM_386 || config->emachine == EM_X86_64) { 18640b57cec5SDimitry Andric // On targets that support TLSDESC, _TLS_MODULE_BASE_ is defined in such a 18650b57cec5SDimitry Andric // way that: 18660b57cec5SDimitry Andric // 18670b57cec5SDimitry Andric // 1) Without relaxation: it produces a dynamic TLSDESC relocation that 18680b57cec5SDimitry Andric // computes 0. 18690b57cec5SDimitry Andric // 2) With LD->LE relaxation: _TLS_MODULE_BASE_@tpoff = 0 (lowest address in 18700b57cec5SDimitry Andric // the TLS block). 18710b57cec5SDimitry Andric // 18720b57cec5SDimitry Andric // 2) is special cased in @tpoff computation. To satisfy 1), we define it as 18730b57cec5SDimitry Andric // an absolute symbol of zero. This is different from GNU linkers which 18740b57cec5SDimitry Andric // define _TLS_MODULE_BASE_ relative to the first TLS section. 18750b57cec5SDimitry Andric Symbol *s = symtab->find("_TLS_MODULE_BASE_"); 18760b57cec5SDimitry Andric if (s && s->isUndefined()) { 18770b57cec5SDimitry Andric s->resolve(Defined{/*file=*/nullptr, s->getName(), STB_GLOBAL, STV_HIDDEN, 18780b57cec5SDimitry Andric STT_TLS, /*value=*/0, 0, 18790b57cec5SDimitry Andric /*section=*/nullptr}); 18800b57cec5SDimitry Andric ElfSym::tlsModuleBase = cast<Defined>(s); 18810b57cec5SDimitry Andric } 18820b57cec5SDimitry Andric } 18830b57cec5SDimitry Andric 1884e8d8bef9SDimitry Andric { 1885e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Finalize .eh_frame"); 18860b57cec5SDimitry Andric // This responsible for splitting up .eh_frame section into 18870b57cec5SDimitry Andric // pieces. The relocation scan uses those pieces, so this has to be 18880b57cec5SDimitry Andric // earlier. 18890b57cec5SDimitry Andric for (Partition &part : partitions) 1890*04eeddc0SDimitry Andric finalizeSynthetic(part.ehFrame.get()); 1891e8d8bef9SDimitry Andric } 18920b57cec5SDimitry Andric 1893*04eeddc0SDimitry Andric if (config->hasDynSymTab) { 1894*04eeddc0SDimitry Andric parallelForEach(symtab->symbols(), [](Symbol *sym) { 1895480093f4SDimitry Andric sym->isPreemptible = computeIsPreemptible(*sym); 1896*04eeddc0SDimitry Andric }); 1897*04eeddc0SDimitry Andric } 189885868e8aSDimitry Andric 189985868e8aSDimitry Andric // Change values of linker-script-defined symbols from placeholders (assigned 190085868e8aSDimitry Andric // by declareSymbols) to actual definitions. 190185868e8aSDimitry Andric script->processSymbolAssignments(); 19020b57cec5SDimitry Andric 1903e8d8bef9SDimitry Andric { 1904e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Scan relocations"); 1905e8d8bef9SDimitry Andric // Scan relocations. This must be done after every symbol is declared so 1906e8d8bef9SDimitry Andric // that we can correctly decide if a dynamic relocation is needed. This is 1907e8d8bef9SDimitry Andric // called after processSymbolAssignments() because it needs to know whether 1908e8d8bef9SDimitry Andric // a linker-script-defined symbol is absolute. 19095ffd83dbSDimitry Andric ppc64noTocRelax.clear(); 19100b57cec5SDimitry Andric if (!config->relocatable) { 1911*04eeddc0SDimitry Andric // Scan all relocations. Each relocation goes through a series of tests to 1912*04eeddc0SDimitry Andric // determine if it needs special treatment, such as creating GOT, PLT, 1913*04eeddc0SDimitry Andric // copy relocations, etc. Note that relocations for non-alloc sections are 1914*04eeddc0SDimitry Andric // directly processed by InputSection::relocateNonAlloc. 1915*04eeddc0SDimitry Andric for (InputSectionBase *sec : inputSections) 1916*04eeddc0SDimitry Andric if (sec->isLive() && isa<InputSection>(sec) && (sec->flags & SHF_ALLOC)) 1917*04eeddc0SDimitry Andric scanRelocations<ELFT>(*sec); 1918*04eeddc0SDimitry Andric for (Partition &part : partitions) { 1919*04eeddc0SDimitry Andric for (EhInputSection *sec : part.ehFrame->sections) 1920*04eeddc0SDimitry Andric scanRelocations<ELFT>(*sec); 1921*04eeddc0SDimitry Andric if (part.armExidx && part.armExidx->isLive()) 1922*04eeddc0SDimitry Andric for (InputSection *sec : part.armExidx->exidxSections) 1923*04eeddc0SDimitry Andric scanRelocations<ELFT>(*sec); 1924*04eeddc0SDimitry Andric } 1925*04eeddc0SDimitry Andric 19260b57cec5SDimitry Andric reportUndefinedSymbols<ELFT>(); 19270eae32dcSDimitry Andric postScanRelocations(); 19280b57cec5SDimitry Andric } 1929e8d8bef9SDimitry Andric } 19300b57cec5SDimitry Andric 19310b57cec5SDimitry Andric if (in.plt && in.plt->isNeeded()) 19320b57cec5SDimitry Andric in.plt->addSymbols(); 19330b57cec5SDimitry Andric if (in.iplt && in.iplt->isNeeded()) 19340b57cec5SDimitry Andric in.iplt->addSymbols(); 19350b57cec5SDimitry Andric 1936e8d8bef9SDimitry Andric if (config->unresolvedSymbolsInShlib != UnresolvedPolicy::Ignore) { 1937fe6060f1SDimitry Andric auto diagnose = 1938fe6060f1SDimitry Andric config->unresolvedSymbolsInShlib == UnresolvedPolicy::ReportError 1939fe6060f1SDimitry Andric ? errorOrWarn 1940fe6060f1SDimitry Andric : warn; 19410b57cec5SDimitry Andric // Error on undefined symbols in a shared object, if all of its DT_NEEDED 1942480093f4SDimitry Andric // entries are seen. These cases would otherwise lead to runtime errors 19430b57cec5SDimitry Andric // reported by the dynamic linker. 19440b57cec5SDimitry Andric // 19450b57cec5SDimitry Andric // ld.bfd traces all DT_NEEDED to emulate the logic of the dynamic linker to 19460b57cec5SDimitry Andric // catch more cases. That is too much for us. Our approach resembles the one 19470b57cec5SDimitry Andric // used in ld.gold, achieves a good balance to be useful but not too smart. 1948fe6060f1SDimitry Andric for (SharedFile *file : sharedFiles) { 1949fe6060f1SDimitry Andric bool allNeededIsKnown = 19500b57cec5SDimitry Andric llvm::all_of(file->dtNeeded, [&](StringRef needed) { 1951*04eeddc0SDimitry Andric return symtab->soNames.count(CachedHashStringRef(needed)); 19520b57cec5SDimitry Andric }); 1953fe6060f1SDimitry Andric if (!allNeededIsKnown) 1954fe6060f1SDimitry Andric continue; 1955fe6060f1SDimitry Andric for (Symbol *sym : file->requiredSymbols) 19560b57cec5SDimitry Andric if (sym->isUndefined() && !sym->isWeak()) 1957fe6060f1SDimitry Andric diagnose(toString(file) + ": undefined reference to " + 19585ffd83dbSDimitry Andric toString(*sym) + " [--no-allow-shlib-undefined]"); 19590b57cec5SDimitry Andric } 1960e8d8bef9SDimitry Andric } 19610b57cec5SDimitry Andric 1962e8d8bef9SDimitry Andric { 1963e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Add symbols to symtabs"); 19640b57cec5SDimitry Andric // Now that we have defined all possible global symbols including linker- 19650b57cec5SDimitry Andric // synthesized ones. Visit all symbols to give the finishing touches. 1966480093f4SDimitry Andric for (Symbol *sym : symtab->symbols()) { 19670eae32dcSDimitry Andric if (!sym->isUsedInRegularObj || !includeInSymtab(*sym)) 1968480093f4SDimitry Andric continue; 1969*04eeddc0SDimitry Andric if (!config->relocatable) 1970*04eeddc0SDimitry Andric sym->binding = sym->computeBinding(); 19710b57cec5SDimitry Andric if (in.symTab) 19720b57cec5SDimitry Andric in.symTab->addSymbol(sym); 19730b57cec5SDimitry Andric 19740b57cec5SDimitry Andric if (sym->includeInDynsym()) { 19750b57cec5SDimitry Andric partitions[sym->partition - 1].dynSymTab->addSymbol(sym); 19760b57cec5SDimitry Andric if (auto *file = dyn_cast_or_null<SharedFile>(sym->file)) 19770b57cec5SDimitry Andric if (file->isNeeded && !sym->isUndefined()) 19780b57cec5SDimitry Andric addVerneed(sym); 19790b57cec5SDimitry Andric } 1980480093f4SDimitry Andric } 19810b57cec5SDimitry Andric 1982e8d8bef9SDimitry Andric // We also need to scan the dynamic relocation tables of the other 1983e8d8bef9SDimitry Andric // partitions and add any referenced symbols to the partition's dynsym. 19840b57cec5SDimitry Andric for (Partition &part : MutableArrayRef<Partition>(partitions).slice(1)) { 19850b57cec5SDimitry Andric DenseSet<Symbol *> syms; 19860b57cec5SDimitry Andric for (const SymbolTableEntry &e : part.dynSymTab->getSymbols()) 19870b57cec5SDimitry Andric syms.insert(e.sym); 19880b57cec5SDimitry Andric for (DynamicReloc &reloc : part.relaDyn->relocs) 1989fe6060f1SDimitry Andric if (reloc.sym && reloc.needsDynSymIndex() && 1990fe6060f1SDimitry Andric syms.insert(reloc.sym).second) 19910b57cec5SDimitry Andric part.dynSymTab->addSymbol(reloc.sym); 19920b57cec5SDimitry Andric } 1993e8d8bef9SDimitry Andric } 19940b57cec5SDimitry Andric 19950b57cec5SDimitry Andric if (in.mipsGot) 19960b57cec5SDimitry Andric in.mipsGot->build(); 19970b57cec5SDimitry Andric 19980b57cec5SDimitry Andric removeUnusedSyntheticSections(); 19995ffd83dbSDimitry Andric script->diagnoseOrphanHandling(); 20000b57cec5SDimitry Andric 20010b57cec5SDimitry Andric sortSections(); 20020b57cec5SDimitry Andric 20034824e7fdSDimitry Andric // Create a list of OutputSections, assign sectionIndex, and populate 20044824e7fdSDimitry Andric // in.shStrTab. 20054824e7fdSDimitry Andric for (SectionCommand *cmd : script->sectionCommands) 20064824e7fdSDimitry Andric if (auto *osec = dyn_cast<OutputSection>(cmd)) { 20074824e7fdSDimitry Andric outputSections.push_back(osec); 20084824e7fdSDimitry Andric osec->sectionIndex = outputSections.size(); 20094824e7fdSDimitry Andric osec->shName = in.shStrTab->addString(osec->name); 20104824e7fdSDimitry Andric } 20110b57cec5SDimitry Andric 20120b57cec5SDimitry Andric // Prefer command line supplied address over other constraints. 20130b57cec5SDimitry Andric for (OutputSection *sec : outputSections) { 20140b57cec5SDimitry Andric auto i = config->sectionStartMap.find(sec->name); 20150b57cec5SDimitry Andric if (i != config->sectionStartMap.end()) 20160b57cec5SDimitry Andric sec->addrExpr = [=] { return i->second; }; 20170b57cec5SDimitry Andric } 20180b57cec5SDimitry Andric 20195ffd83dbSDimitry Andric // With the outputSections available check for GDPLT relocations 20205ffd83dbSDimitry Andric // and add __tls_get_addr symbol if needed. 20215ffd83dbSDimitry Andric if (config->emachine == EM_HEXAGON && hexagonNeedsTLSSymbol(outputSections)) { 20225ffd83dbSDimitry Andric Symbol *sym = symtab->addSymbol(Undefined{ 20235ffd83dbSDimitry Andric nullptr, "__tls_get_addr", STB_GLOBAL, STV_DEFAULT, STT_NOTYPE}); 20245ffd83dbSDimitry Andric sym->isPreemptible = true; 20255ffd83dbSDimitry Andric partitions[0].dynSymTab->addSymbol(sym); 20265ffd83dbSDimitry Andric } 20275ffd83dbSDimitry Andric 20280b57cec5SDimitry Andric // This is a bit of a hack. A value of 0 means undef, so we set it 20290b57cec5SDimitry Andric // to 1 to make __ehdr_start defined. The section number is not 20300b57cec5SDimitry Andric // particularly relevant. 20310b57cec5SDimitry Andric Out::elfHeader->sectionIndex = 1; 20324824e7fdSDimitry Andric Out::elfHeader->size = sizeof(typename ELFT::Ehdr); 20330b57cec5SDimitry Andric 20340b57cec5SDimitry Andric // Binary and relocatable output does not have PHDRS. 20350b57cec5SDimitry Andric // The headers have to be created before finalize as that can influence the 20360b57cec5SDimitry Andric // image base and the dynamic section on mips includes the image base. 20370b57cec5SDimitry Andric if (!config->relocatable && !config->oFormatBinary) { 20380b57cec5SDimitry Andric for (Partition &part : partitions) { 20390b57cec5SDimitry Andric part.phdrs = script->hasPhdrsCommands() ? script->createPhdrs() 20400b57cec5SDimitry Andric : createPhdrs(part); 20410b57cec5SDimitry Andric if (config->emachine == EM_ARM) { 20420b57cec5SDimitry Andric // PT_ARM_EXIDX is the ARM EHABI equivalent of PT_GNU_EH_FRAME 20430b57cec5SDimitry Andric addPhdrForSection(part, SHT_ARM_EXIDX, PT_ARM_EXIDX, PF_R); 20440b57cec5SDimitry Andric } 20450b57cec5SDimitry Andric if (config->emachine == EM_MIPS) { 20460b57cec5SDimitry Andric // Add separate segments for MIPS-specific sections. 20470b57cec5SDimitry Andric addPhdrForSection(part, SHT_MIPS_REGINFO, PT_MIPS_REGINFO, PF_R); 20480b57cec5SDimitry Andric addPhdrForSection(part, SHT_MIPS_OPTIONS, PT_MIPS_OPTIONS, PF_R); 20490b57cec5SDimitry Andric addPhdrForSection(part, SHT_MIPS_ABIFLAGS, PT_MIPS_ABIFLAGS, PF_R); 20500b57cec5SDimitry Andric } 20510b57cec5SDimitry Andric } 20520b57cec5SDimitry Andric Out::programHeaders->size = sizeof(Elf_Phdr) * mainPart->phdrs.size(); 20530b57cec5SDimitry Andric 20540b57cec5SDimitry Andric // Find the TLS segment. This happens before the section layout loop so that 20550b57cec5SDimitry Andric // Android relocation packing can look up TLS symbol addresses. We only need 20560b57cec5SDimitry Andric // to care about the main partition here because all TLS symbols were moved 20570b57cec5SDimitry Andric // to the main partition (see MarkLive.cpp). 20580b57cec5SDimitry Andric for (PhdrEntry *p : mainPart->phdrs) 20590b57cec5SDimitry Andric if (p->p_type == PT_TLS) 20600b57cec5SDimitry Andric Out::tlsPhdr = p; 20610b57cec5SDimitry Andric } 20620b57cec5SDimitry Andric 20630b57cec5SDimitry Andric // Some symbols are defined in term of program headers. Now that we 20640b57cec5SDimitry Andric // have the headers, we can find out which sections they point to. 20650b57cec5SDimitry Andric setReservedSymbolSections(); 20660b57cec5SDimitry Andric 2067e8d8bef9SDimitry Andric { 2068e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Finalize synthetic sections"); 2069e8d8bef9SDimitry Andric 2070*04eeddc0SDimitry Andric finalizeSynthetic(in.bss.get()); 2071*04eeddc0SDimitry Andric finalizeSynthetic(in.bssRelRo.get()); 2072*04eeddc0SDimitry Andric finalizeSynthetic(in.symTabShndx.get()); 2073*04eeddc0SDimitry Andric finalizeSynthetic(in.shStrTab.get()); 2074*04eeddc0SDimitry Andric finalizeSynthetic(in.strTab.get()); 2075*04eeddc0SDimitry Andric finalizeSynthetic(in.got.get()); 2076*04eeddc0SDimitry Andric finalizeSynthetic(in.mipsGot.get()); 2077*04eeddc0SDimitry Andric finalizeSynthetic(in.igotPlt.get()); 2078*04eeddc0SDimitry Andric finalizeSynthetic(in.gotPlt.get()); 2079*04eeddc0SDimitry Andric finalizeSynthetic(in.relaIplt.get()); 2080*04eeddc0SDimitry Andric finalizeSynthetic(in.relaPlt.get()); 2081*04eeddc0SDimitry Andric finalizeSynthetic(in.plt.get()); 2082*04eeddc0SDimitry Andric finalizeSynthetic(in.iplt.get()); 2083*04eeddc0SDimitry Andric finalizeSynthetic(in.ppc32Got2.get()); 2084*04eeddc0SDimitry Andric finalizeSynthetic(in.partIndex.get()); 20850b57cec5SDimitry Andric 20860b57cec5SDimitry Andric // Dynamic section must be the last one in this list and dynamic 20870b57cec5SDimitry Andric // symbol table section (dynSymTab) must be the first one. 20880b57cec5SDimitry Andric for (Partition &part : partitions) { 2089*04eeddc0SDimitry Andric finalizeSynthetic(part.dynSymTab.get()); 2090*04eeddc0SDimitry Andric finalizeSynthetic(part.gnuHashTab.get()); 2091*04eeddc0SDimitry Andric finalizeSynthetic(part.hashTab.get()); 2092*04eeddc0SDimitry Andric finalizeSynthetic(part.verDef.get()); 2093*04eeddc0SDimitry Andric finalizeSynthetic(part.relaDyn.get()); 2094*04eeddc0SDimitry Andric finalizeSynthetic(part.relrDyn.get()); 2095*04eeddc0SDimitry Andric finalizeSynthetic(part.ehFrameHdr.get()); 2096*04eeddc0SDimitry Andric finalizeSynthetic(part.verSym.get()); 2097*04eeddc0SDimitry Andric finalizeSynthetic(part.verNeed.get()); 2098*04eeddc0SDimitry Andric finalizeSynthetic(part.dynamic.get()); 20990b57cec5SDimitry Andric } 2100e8d8bef9SDimitry Andric } 21010b57cec5SDimitry Andric 21020b57cec5SDimitry Andric if (!script->hasSectionsCommand && !config->relocatable) 21030b57cec5SDimitry Andric fixSectionAlignments(); 21040b57cec5SDimitry Andric 21050b57cec5SDimitry Andric // This is used to: 21060b57cec5SDimitry Andric // 1) Create "thunks": 21070b57cec5SDimitry Andric // Jump instructions in many ISAs have small displacements, and therefore 21080b57cec5SDimitry Andric // they cannot jump to arbitrary addresses in memory. For example, RISC-V 21090b57cec5SDimitry Andric // JAL instruction can target only +-1 MiB from PC. It is a linker's 21100b57cec5SDimitry Andric // responsibility to create and insert small pieces of code between 21110b57cec5SDimitry Andric // sections to extend the ranges if jump targets are out of range. Such 21120b57cec5SDimitry Andric // code pieces are called "thunks". 21130b57cec5SDimitry Andric // 21140b57cec5SDimitry Andric // We add thunks at this stage. We couldn't do this before this point 21150b57cec5SDimitry Andric // because this is the earliest point where we know sizes of sections and 21160b57cec5SDimitry Andric // their layouts (that are needed to determine if jump targets are in 21170b57cec5SDimitry Andric // range). 21180b57cec5SDimitry Andric // 21190b57cec5SDimitry Andric // 2) Update the sections. We need to generate content that depends on the 21200b57cec5SDimitry Andric // address of InputSections. For example, MIPS GOT section content or 21210b57cec5SDimitry Andric // android packed relocations sections content. 21220b57cec5SDimitry Andric // 21230b57cec5SDimitry Andric // 3) Assign the final values for the linker script symbols. Linker scripts 21240b57cec5SDimitry Andric // sometimes using forward symbol declarations. We want to set the correct 21250b57cec5SDimitry Andric // values. They also might change after adding the thunks. 21260b57cec5SDimitry Andric finalizeAddressDependentContent(); 2127*04eeddc0SDimitry Andric 2128*04eeddc0SDimitry Andric // All information needed for OutputSection part of Map file is available. 21295ffd83dbSDimitry Andric if (errorCount()) 21305ffd83dbSDimitry Andric return; 21310b57cec5SDimitry Andric 2132e8d8bef9SDimitry Andric { 2133e8d8bef9SDimitry Andric llvm::TimeTraceScope timeScope("Finalize synthetic sections"); 2134e8d8bef9SDimitry Andric // finalizeAddressDependentContent may have added local symbols to the 2135e8d8bef9SDimitry Andric // static symbol table. 2136*04eeddc0SDimitry Andric finalizeSynthetic(in.symTab.get()); 2137*04eeddc0SDimitry Andric finalizeSynthetic(in.ppc64LongBranchTarget.get()); 2138e8d8bef9SDimitry Andric } 21390b57cec5SDimitry Andric 21405ffd83dbSDimitry Andric // Relaxation to delete inter-basic block jumps created by basic block 21415ffd83dbSDimitry Andric // sections. Run after in.symTab is finalized as optimizeBasicBlockJumps 21425ffd83dbSDimitry Andric // can relax jump instructions based on symbol offset. 21435ffd83dbSDimitry Andric if (config->optimizeBBJumps) 21445ffd83dbSDimitry Andric optimizeBasicBlockJumps(); 21455ffd83dbSDimitry Andric 21460b57cec5SDimitry Andric // Fill other section headers. The dynamic table is finalized 21470b57cec5SDimitry Andric // at the end because some tags like RELSZ depend on result 21480b57cec5SDimitry Andric // of finalizing other sections. 21490b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 21500b57cec5SDimitry Andric sec->finalize(); 21510b57cec5SDimitry Andric } 21520b57cec5SDimitry Andric 21530b57cec5SDimitry Andric // Ensure data sections are not mixed with executable sections when 2154349cc55cSDimitry Andric // --execute-only is used. --execute-only make pages executable but not 2155349cc55cSDimitry Andric // readable. 21560b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::checkExecuteOnly() { 21570b57cec5SDimitry Andric if (!config->executeOnly) 21580b57cec5SDimitry Andric return; 21590b57cec5SDimitry Andric 2160*04eeddc0SDimitry Andric for (OutputSection *osec : outputSections) 2161*04eeddc0SDimitry Andric if (osec->flags & SHF_EXECINSTR) 2162*04eeddc0SDimitry Andric for (InputSection *isec : getInputSections(*osec)) 21630b57cec5SDimitry Andric if (!(isec->flags & SHF_EXECINSTR)) 2164*04eeddc0SDimitry Andric error("cannot place " + toString(isec) + " into " + 2165*04eeddc0SDimitry Andric toString(osec->name) + 2166*04eeddc0SDimitry Andric ": --execute-only does not support intermingling data and code"); 21670b57cec5SDimitry Andric } 21680b57cec5SDimitry Andric 21690b57cec5SDimitry Andric // The linker is expected to define SECNAME_start and SECNAME_end 21700b57cec5SDimitry Andric // symbols for a few sections. This function defines them. 21710b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::addStartEndSymbols() { 21720b57cec5SDimitry Andric // If a section does not exist, there's ambiguity as to how we 21730b57cec5SDimitry Andric // define _start and _end symbols for an init/fini section. Since 21740b57cec5SDimitry Andric // the loader assume that the symbols are always defined, we need to 21750b57cec5SDimitry Andric // always define them. But what value? The loader iterates over all 21760b57cec5SDimitry Andric // pointers between _start and _end to run global ctors/dtors, so if 21770b57cec5SDimitry Andric // the section is empty, their symbol values don't actually matter 21780b57cec5SDimitry Andric // as long as _start and _end point to the same location. 21790b57cec5SDimitry Andric // 21800b57cec5SDimitry Andric // That said, we don't want to set the symbols to 0 (which is 21810b57cec5SDimitry Andric // probably the simplest value) because that could cause some 21820b57cec5SDimitry Andric // program to fail to link due to relocation overflow, if their 21830b57cec5SDimitry Andric // program text is above 2 GiB. We use the address of the .text 21840b57cec5SDimitry Andric // section instead to prevent that failure. 21850b57cec5SDimitry Andric // 2186480093f4SDimitry Andric // In rare situations, the .text section may not exist. If that's the 21870b57cec5SDimitry Andric // case, use the image base address as a last resort. 21880b57cec5SDimitry Andric OutputSection *Default = findSection(".text"); 21890b57cec5SDimitry Andric if (!Default) 21900b57cec5SDimitry Andric Default = Out::elfHeader; 21910b57cec5SDimitry Andric 21920b57cec5SDimitry Andric auto define = [=](StringRef start, StringRef end, OutputSection *os) { 2193349cc55cSDimitry Andric if (os && !script->isDiscarded(os)) { 21940b57cec5SDimitry Andric addOptionalRegular(start, os, 0); 21950b57cec5SDimitry Andric addOptionalRegular(end, os, -1); 21960b57cec5SDimitry Andric } else { 21970b57cec5SDimitry Andric addOptionalRegular(start, Default, 0); 21980b57cec5SDimitry Andric addOptionalRegular(end, Default, 0); 21990b57cec5SDimitry Andric } 22000b57cec5SDimitry Andric }; 22010b57cec5SDimitry Andric 22020b57cec5SDimitry Andric define("__preinit_array_start", "__preinit_array_end", Out::preinitArray); 22030b57cec5SDimitry Andric define("__init_array_start", "__init_array_end", Out::initArray); 22040b57cec5SDimitry Andric define("__fini_array_start", "__fini_array_end", Out::finiArray); 22050b57cec5SDimitry Andric 22060b57cec5SDimitry Andric if (OutputSection *sec = findSection(".ARM.exidx")) 22070b57cec5SDimitry Andric define("__exidx_start", "__exidx_end", sec); 22080b57cec5SDimitry Andric } 22090b57cec5SDimitry Andric 22100b57cec5SDimitry Andric // If a section name is valid as a C identifier (which is rare because of 22110b57cec5SDimitry Andric // the leading '.'), linkers are expected to define __start_<secname> and 22120b57cec5SDimitry Andric // __stop_<secname> symbols. They are at beginning and end of the section, 22130b57cec5SDimitry Andric // respectively. This is not requested by the ELF standard, but GNU ld and 22140b57cec5SDimitry Andric // gold provide the feature, and used by many programs. 22150b57cec5SDimitry Andric template <class ELFT> 22160b57cec5SDimitry Andric void Writer<ELFT>::addStartStopSymbols(OutputSection *sec) { 22170b57cec5SDimitry Andric StringRef s = sec->name; 22180b57cec5SDimitry Andric if (!isValidCIdentifier(s)) 22190b57cec5SDimitry Andric return; 2220*04eeddc0SDimitry Andric addOptionalRegular(saver().save("__start_" + s), sec, 0, 22215ffd83dbSDimitry Andric config->zStartStopVisibility); 2222*04eeddc0SDimitry Andric addOptionalRegular(saver().save("__stop_" + s), sec, -1, 22235ffd83dbSDimitry Andric config->zStartStopVisibility); 22240b57cec5SDimitry Andric } 22250b57cec5SDimitry Andric 22260b57cec5SDimitry Andric static bool needsPtLoad(OutputSection *sec) { 2227fe6060f1SDimitry Andric if (!(sec->flags & SHF_ALLOC)) 22280b57cec5SDimitry Andric return false; 22290b57cec5SDimitry Andric 22300b57cec5SDimitry Andric // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is 22310b57cec5SDimitry Andric // responsible for allocating space for them, not the PT_LOAD that 22320b57cec5SDimitry Andric // contains the TLS initialization image. 22330b57cec5SDimitry Andric if ((sec->flags & SHF_TLS) && sec->type == SHT_NOBITS) 22340b57cec5SDimitry Andric return false; 22350b57cec5SDimitry Andric return true; 22360b57cec5SDimitry Andric } 22370b57cec5SDimitry Andric 22380b57cec5SDimitry Andric // Linker scripts are responsible for aligning addresses. Unfortunately, most 22390b57cec5SDimitry Andric // linker scripts are designed for creating two PT_LOADs only, one RX and one 22400b57cec5SDimitry Andric // RW. This means that there is no alignment in the RO to RX transition and we 22410b57cec5SDimitry Andric // cannot create a PT_LOAD there. 22420b57cec5SDimitry Andric static uint64_t computeFlags(uint64_t flags) { 22430b57cec5SDimitry Andric if (config->omagic) 22440b57cec5SDimitry Andric return PF_R | PF_W | PF_X; 22450b57cec5SDimitry Andric if (config->executeOnly && (flags & PF_X)) 22460b57cec5SDimitry Andric return flags & ~PF_R; 22470b57cec5SDimitry Andric if (config->singleRoRx && !(flags & PF_W)) 22480b57cec5SDimitry Andric return flags | PF_X; 22490b57cec5SDimitry Andric return flags; 22500b57cec5SDimitry Andric } 22510b57cec5SDimitry Andric 22520b57cec5SDimitry Andric // Decide which program headers to create and which sections to include in each 22530b57cec5SDimitry Andric // one. 22540b57cec5SDimitry Andric template <class ELFT> 2255*04eeddc0SDimitry Andric SmallVector<PhdrEntry *, 0> Writer<ELFT>::createPhdrs(Partition &part) { 2256*04eeddc0SDimitry Andric SmallVector<PhdrEntry *, 0> ret; 22570b57cec5SDimitry Andric auto addHdr = [&](unsigned type, unsigned flags) -> PhdrEntry * { 22580b57cec5SDimitry Andric ret.push_back(make<PhdrEntry>(type, flags)); 22590b57cec5SDimitry Andric return ret.back(); 22600b57cec5SDimitry Andric }; 22610b57cec5SDimitry Andric 22620b57cec5SDimitry Andric unsigned partNo = part.getNumber(); 22630b57cec5SDimitry Andric bool isMain = partNo == 1; 22640b57cec5SDimitry Andric 226585868e8aSDimitry Andric // Add the first PT_LOAD segment for regular output sections. 226685868e8aSDimitry Andric uint64_t flags = computeFlags(PF_R); 226785868e8aSDimitry Andric PhdrEntry *load = nullptr; 226885868e8aSDimitry Andric 226985868e8aSDimitry Andric // nmagic or omagic output does not have PT_PHDR, PT_INTERP, or the readonly 227085868e8aSDimitry Andric // PT_LOAD. 227185868e8aSDimitry Andric if (!config->nmagic && !config->omagic) { 227285868e8aSDimitry Andric // The first phdr entry is PT_PHDR which describes the program header 227385868e8aSDimitry Andric // itself. 22740b57cec5SDimitry Andric if (isMain) 22750b57cec5SDimitry Andric addHdr(PT_PHDR, PF_R)->add(Out::programHeaders); 22760b57cec5SDimitry Andric else 22770b57cec5SDimitry Andric addHdr(PT_PHDR, PF_R)->add(part.programHeaders->getParent()); 22780b57cec5SDimitry Andric 22790b57cec5SDimitry Andric // PT_INTERP must be the second entry if exists. 22800b57cec5SDimitry Andric if (OutputSection *cmd = findSection(".interp", partNo)) 22810b57cec5SDimitry Andric addHdr(PT_INTERP, cmd->getPhdrFlags())->add(cmd); 22820b57cec5SDimitry Andric 22830b57cec5SDimitry Andric // Add the headers. We will remove them if they don't fit. 22840b57cec5SDimitry Andric // In the other partitions the headers are ordinary sections, so they don't 22850b57cec5SDimitry Andric // need to be added here. 22860b57cec5SDimitry Andric if (isMain) { 22870b57cec5SDimitry Andric load = addHdr(PT_LOAD, flags); 22880b57cec5SDimitry Andric load->add(Out::elfHeader); 22890b57cec5SDimitry Andric load->add(Out::programHeaders); 22900b57cec5SDimitry Andric } 229185868e8aSDimitry Andric } 22920b57cec5SDimitry Andric 22930b57cec5SDimitry Andric // PT_GNU_RELRO includes all sections that should be marked as 2294480093f4SDimitry Andric // read-only by dynamic linker after processing relocations. 22950b57cec5SDimitry Andric // Current dynamic loaders only support one PT_GNU_RELRO PHDR, give 22960b57cec5SDimitry Andric // an error message if more than one PT_GNU_RELRO PHDR is required. 22970b57cec5SDimitry Andric PhdrEntry *relRo = make<PhdrEntry>(PT_GNU_RELRO, PF_R); 22980b57cec5SDimitry Andric bool inRelroPhdr = false; 22990b57cec5SDimitry Andric OutputSection *relroEnd = nullptr; 23000b57cec5SDimitry Andric for (OutputSection *sec : outputSections) { 23010b57cec5SDimitry Andric if (sec->partition != partNo || !needsPtLoad(sec)) 23020b57cec5SDimitry Andric continue; 23030b57cec5SDimitry Andric if (isRelroSection(sec)) { 23040b57cec5SDimitry Andric inRelroPhdr = true; 23050b57cec5SDimitry Andric if (!relroEnd) 23060b57cec5SDimitry Andric relRo->add(sec); 23070b57cec5SDimitry Andric else 23080b57cec5SDimitry Andric error("section: " + sec->name + " is not contiguous with other relro" + 23090b57cec5SDimitry Andric " sections"); 23100b57cec5SDimitry Andric } else if (inRelroPhdr) { 23110b57cec5SDimitry Andric inRelroPhdr = false; 23120b57cec5SDimitry Andric relroEnd = sec; 23130b57cec5SDimitry Andric } 23140b57cec5SDimitry Andric } 23150b57cec5SDimitry Andric 23160b57cec5SDimitry Andric for (OutputSection *sec : outputSections) { 23170b57cec5SDimitry Andric if (!needsPtLoad(sec)) 23180b57cec5SDimitry Andric continue; 23190b57cec5SDimitry Andric 23200b57cec5SDimitry Andric // Normally, sections in partitions other than the current partition are 23210b57cec5SDimitry Andric // ignored. But partition number 255 is a special case: it contains the 23220b57cec5SDimitry Andric // partition end marker (.part.end). It needs to be added to the main 23230b57cec5SDimitry Andric // partition so that a segment is created for it in the main partition, 23240b57cec5SDimitry Andric // which will cause the dynamic loader to reserve space for the other 23250b57cec5SDimitry Andric // partitions. 23260b57cec5SDimitry Andric if (sec->partition != partNo) { 23270b57cec5SDimitry Andric if (isMain && sec->partition == 255) 23280b57cec5SDimitry Andric addHdr(PT_LOAD, computeFlags(sec->getPhdrFlags()))->add(sec); 23290b57cec5SDimitry Andric continue; 23300b57cec5SDimitry Andric } 23310b57cec5SDimitry Andric 23320b57cec5SDimitry Andric // Segments are contiguous memory regions that has the same attributes 23330b57cec5SDimitry Andric // (e.g. executable or writable). There is one phdr for each segment. 23340b57cec5SDimitry Andric // Therefore, we need to create a new phdr when the next section has 23350b57cec5SDimitry Andric // different flags or is loaded at a discontiguous address or memory 23360b57cec5SDimitry Andric // region using AT or AT> linker script command, respectively. At the same 23370b57cec5SDimitry Andric // time, we don't want to create a separate load segment for the headers, 23380b57cec5SDimitry Andric // even if the first output section has an AT or AT> attribute. 23390b57cec5SDimitry Andric uint64_t newFlags = computeFlags(sec->getPhdrFlags()); 23405ffd83dbSDimitry Andric bool sameLMARegion = 23415ffd83dbSDimitry Andric load && !sec->lmaExpr && sec->lmaRegion == load->firstSec->lmaRegion; 23425ffd83dbSDimitry Andric if (!(load && newFlags == flags && sec != relroEnd && 23435ffd83dbSDimitry Andric sec->memRegion == load->firstSec->memRegion && 23445ffd83dbSDimitry Andric (sameLMARegion || load->lastSec == Out::programHeaders))) { 23450b57cec5SDimitry Andric load = addHdr(PT_LOAD, newFlags); 23460b57cec5SDimitry Andric flags = newFlags; 23470b57cec5SDimitry Andric } 23480b57cec5SDimitry Andric 23490b57cec5SDimitry Andric load->add(sec); 23500b57cec5SDimitry Andric } 23510b57cec5SDimitry Andric 23520b57cec5SDimitry Andric // Add a TLS segment if any. 23530b57cec5SDimitry Andric PhdrEntry *tlsHdr = make<PhdrEntry>(PT_TLS, PF_R); 23540b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 23550b57cec5SDimitry Andric if (sec->partition == partNo && sec->flags & SHF_TLS) 23560b57cec5SDimitry Andric tlsHdr->add(sec); 23570b57cec5SDimitry Andric if (tlsHdr->firstSec) 23580b57cec5SDimitry Andric ret.push_back(tlsHdr); 23590b57cec5SDimitry Andric 23600b57cec5SDimitry Andric // Add an entry for .dynamic. 23610b57cec5SDimitry Andric if (OutputSection *sec = part.dynamic->getParent()) 23620b57cec5SDimitry Andric addHdr(PT_DYNAMIC, sec->getPhdrFlags())->add(sec); 23630b57cec5SDimitry Andric 23640b57cec5SDimitry Andric if (relRo->firstSec) 23650b57cec5SDimitry Andric ret.push_back(relRo); 23660b57cec5SDimitry Andric 23670b57cec5SDimitry Andric // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr. 23680b57cec5SDimitry Andric if (part.ehFrame->isNeeded() && part.ehFrameHdr && 23690b57cec5SDimitry Andric part.ehFrame->getParent() && part.ehFrameHdr->getParent()) 23700b57cec5SDimitry Andric addHdr(PT_GNU_EH_FRAME, part.ehFrameHdr->getParent()->getPhdrFlags()) 23710b57cec5SDimitry Andric ->add(part.ehFrameHdr->getParent()); 23720b57cec5SDimitry Andric 23730b57cec5SDimitry Andric // PT_OPENBSD_RANDOMIZE is an OpenBSD-specific feature. That makes 23740b57cec5SDimitry Andric // the dynamic linker fill the segment with random data. 23750b57cec5SDimitry Andric if (OutputSection *cmd = findSection(".openbsd.randomdata", partNo)) 23760b57cec5SDimitry Andric addHdr(PT_OPENBSD_RANDOMIZE, cmd->getPhdrFlags())->add(cmd); 23770b57cec5SDimitry Andric 2378480093f4SDimitry Andric if (config->zGnustack != GnuStackKind::None) { 23790b57cec5SDimitry Andric // PT_GNU_STACK is a special section to tell the loader to make the 23800b57cec5SDimitry Andric // pages for the stack non-executable. If you really want an executable 23810b57cec5SDimitry Andric // stack, you can pass -z execstack, but that's not recommended for 23820b57cec5SDimitry Andric // security reasons. 23830b57cec5SDimitry Andric unsigned perm = PF_R | PF_W; 2384480093f4SDimitry Andric if (config->zGnustack == GnuStackKind::Exec) 23850b57cec5SDimitry Andric perm |= PF_X; 23860b57cec5SDimitry Andric addHdr(PT_GNU_STACK, perm)->p_memsz = config->zStackSize; 2387480093f4SDimitry Andric } 23880b57cec5SDimitry Andric 23890b57cec5SDimitry Andric // PT_OPENBSD_WXNEEDED is a OpenBSD-specific header to mark the executable 23900b57cec5SDimitry Andric // is expected to perform W^X violations, such as calling mprotect(2) or 23910b57cec5SDimitry Andric // mmap(2) with PROT_WRITE | PROT_EXEC, which is prohibited by default on 23920b57cec5SDimitry Andric // OpenBSD. 23930b57cec5SDimitry Andric if (config->zWxneeded) 23940b57cec5SDimitry Andric addHdr(PT_OPENBSD_WXNEEDED, PF_X); 23950b57cec5SDimitry Andric 2396480093f4SDimitry Andric if (OutputSection *cmd = findSection(".note.gnu.property", partNo)) 2397480093f4SDimitry Andric addHdr(PT_GNU_PROPERTY, PF_R)->add(cmd); 2398480093f4SDimitry Andric 23990b57cec5SDimitry Andric // Create one PT_NOTE per a group of contiguous SHT_NOTE sections with the 24000b57cec5SDimitry Andric // same alignment. 24010b57cec5SDimitry Andric PhdrEntry *note = nullptr; 24020b57cec5SDimitry Andric for (OutputSection *sec : outputSections) { 24030b57cec5SDimitry Andric if (sec->partition != partNo) 24040b57cec5SDimitry Andric continue; 24050b57cec5SDimitry Andric if (sec->type == SHT_NOTE && (sec->flags & SHF_ALLOC)) { 24060b57cec5SDimitry Andric if (!note || sec->lmaExpr || note->lastSec->alignment != sec->alignment) 24070b57cec5SDimitry Andric note = addHdr(PT_NOTE, PF_R); 24080b57cec5SDimitry Andric note->add(sec); 24090b57cec5SDimitry Andric } else { 24100b57cec5SDimitry Andric note = nullptr; 24110b57cec5SDimitry Andric } 24120b57cec5SDimitry Andric } 24130b57cec5SDimitry Andric return ret; 24140b57cec5SDimitry Andric } 24150b57cec5SDimitry Andric 24160b57cec5SDimitry Andric template <class ELFT> 24170b57cec5SDimitry Andric void Writer<ELFT>::addPhdrForSection(Partition &part, unsigned shType, 24180b57cec5SDimitry Andric unsigned pType, unsigned pFlags) { 24190b57cec5SDimitry Andric unsigned partNo = part.getNumber(); 24200b57cec5SDimitry Andric auto i = llvm::find_if(outputSections, [=](OutputSection *cmd) { 24210b57cec5SDimitry Andric return cmd->partition == partNo && cmd->type == shType; 24220b57cec5SDimitry Andric }); 24230b57cec5SDimitry Andric if (i == outputSections.end()) 24240b57cec5SDimitry Andric return; 24250b57cec5SDimitry Andric 24260b57cec5SDimitry Andric PhdrEntry *entry = make<PhdrEntry>(pType, pFlags); 24270b57cec5SDimitry Andric entry->add(*i); 24280b57cec5SDimitry Andric part.phdrs.push_back(entry); 24290b57cec5SDimitry Andric } 24300b57cec5SDimitry Andric 243185868e8aSDimitry Andric // Place the first section of each PT_LOAD to a different page (of maxPageSize). 243285868e8aSDimitry Andric // This is achieved by assigning an alignment expression to addrExpr of each 243385868e8aSDimitry Andric // such section. 24340b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::fixSectionAlignments() { 243585868e8aSDimitry Andric const PhdrEntry *prev; 243685868e8aSDimitry Andric auto pageAlign = [&](const PhdrEntry *p) { 243785868e8aSDimitry Andric OutputSection *cmd = p->firstSec; 24385ffd83dbSDimitry Andric if (!cmd) 24395ffd83dbSDimitry Andric return; 24405ffd83dbSDimitry Andric cmd->alignExpr = [align = cmd->alignment]() { return align; }; 24415ffd83dbSDimitry Andric if (!cmd->addrExpr) { 244285868e8aSDimitry Andric // Prefer advancing to align(dot, maxPageSize) + dot%maxPageSize to avoid 244385868e8aSDimitry Andric // padding in the file contents. 244485868e8aSDimitry Andric // 244585868e8aSDimitry Andric // When -z separate-code is used we must not have any overlap in pages 244685868e8aSDimitry Andric // between an executable segment and a non-executable segment. We align to 244785868e8aSDimitry Andric // the next maximum page size boundary on transitions between executable 244885868e8aSDimitry Andric // and non-executable segments. 244985868e8aSDimitry Andric // 245085868e8aSDimitry Andric // SHT_LLVM_PART_EHDR marks the start of a partition. The partition 245185868e8aSDimitry Andric // sections will be extracted to a separate file. Align to the next 245285868e8aSDimitry Andric // maximum page size boundary so that we can find the ELF header at the 245385868e8aSDimitry Andric // start. We cannot benefit from overlapping p_offset ranges with the 245485868e8aSDimitry Andric // previous segment anyway. 245585868e8aSDimitry Andric if (config->zSeparate == SeparateSegmentKind::Loadable || 245685868e8aSDimitry Andric (config->zSeparate == SeparateSegmentKind::Code && prev && 245785868e8aSDimitry Andric (prev->p_flags & PF_X) != (p->p_flags & PF_X)) || 245885868e8aSDimitry Andric cmd->type == SHT_LLVM_PART_EHDR) 245985868e8aSDimitry Andric cmd->addrExpr = [] { 24600b57cec5SDimitry Andric return alignTo(script->getDot(), config->maxPageSize); 24610b57cec5SDimitry Andric }; 246285868e8aSDimitry Andric // PT_TLS is at the start of the first RW PT_LOAD. If `p` includes PT_TLS, 246385868e8aSDimitry Andric // it must be the RW. Align to p_align(PT_TLS) to make sure 246485868e8aSDimitry Andric // p_vaddr(PT_LOAD)%p_align(PT_LOAD) = 0. Otherwise, if 246585868e8aSDimitry Andric // sh_addralign(.tdata) < sh_addralign(.tbss), we will set p_align(PT_TLS) 246685868e8aSDimitry Andric // to sh_addralign(.tbss), while p_vaddr(PT_TLS)=p_vaddr(PT_LOAD) may not 246785868e8aSDimitry Andric // be congruent to 0 modulo p_align(PT_TLS). 246885868e8aSDimitry Andric // 246985868e8aSDimitry Andric // Technically this is not required, but as of 2019, some dynamic loaders 247085868e8aSDimitry Andric // don't handle p_vaddr%p_align != 0 correctly, e.g. glibc (i386 and 247185868e8aSDimitry Andric // x86-64) doesn't make runtime address congruent to p_vaddr modulo 247285868e8aSDimitry Andric // p_align for dynamic TLS blocks (PR/24606), FreeBSD rtld has the same 247385868e8aSDimitry Andric // bug, musl (TLS Variant 1 architectures) before 1.1.23 handled TLS 247485868e8aSDimitry Andric // blocks correctly. We need to keep the workaround for a while. 247585868e8aSDimitry Andric else if (Out::tlsPhdr && Out::tlsPhdr->firstSec == p->firstSec) 247685868e8aSDimitry Andric cmd->addrExpr = [] { 247785868e8aSDimitry Andric return alignTo(script->getDot(), config->maxPageSize) + 247885868e8aSDimitry Andric alignTo(script->getDot() % config->maxPageSize, 247985868e8aSDimitry Andric Out::tlsPhdr->p_align); 248085868e8aSDimitry Andric }; 248185868e8aSDimitry Andric else 248285868e8aSDimitry Andric cmd->addrExpr = [] { 248385868e8aSDimitry Andric return alignTo(script->getDot(), config->maxPageSize) + 248485868e8aSDimitry Andric script->getDot() % config->maxPageSize; 248585868e8aSDimitry Andric }; 248685868e8aSDimitry Andric } 24870b57cec5SDimitry Andric }; 24880b57cec5SDimitry Andric 24890b57cec5SDimitry Andric for (Partition &part : partitions) { 249085868e8aSDimitry Andric prev = nullptr; 24910b57cec5SDimitry Andric for (const PhdrEntry *p : part.phdrs) 249285868e8aSDimitry Andric if (p->p_type == PT_LOAD && p->firstSec) { 249385868e8aSDimitry Andric pageAlign(p); 249485868e8aSDimitry Andric prev = p; 249585868e8aSDimitry Andric } 24960b57cec5SDimitry Andric } 24970b57cec5SDimitry Andric } 24980b57cec5SDimitry Andric 24990b57cec5SDimitry Andric // Compute an in-file position for a given section. The file offset must be the 25000b57cec5SDimitry Andric // same with its virtual address modulo the page size, so that the loader can 25010b57cec5SDimitry Andric // load executables without any address adjustment. 25020b57cec5SDimitry Andric static uint64_t computeFileOffset(OutputSection *os, uint64_t off) { 25030b57cec5SDimitry Andric // The first section in a PT_LOAD has to have congruent offset and address 250485868e8aSDimitry Andric // modulo the maximum page size. 250585868e8aSDimitry Andric if (os->ptLoad && os->ptLoad->firstSec == os) 250685868e8aSDimitry Andric return alignTo(off, os->ptLoad->p_align, os->addr); 25070b57cec5SDimitry Andric 25080b57cec5SDimitry Andric // File offsets are not significant for .bss sections other than the first one 2509349cc55cSDimitry Andric // in a PT_LOAD/PT_TLS. By convention, we keep section offsets monotonically 25100b57cec5SDimitry Andric // increasing rather than setting to zero. 2511349cc55cSDimitry Andric if (os->type == SHT_NOBITS && 2512349cc55cSDimitry Andric (!Out::tlsPhdr || Out::tlsPhdr->firstSec != os)) 25130b57cec5SDimitry Andric return off; 25140b57cec5SDimitry Andric 25150b57cec5SDimitry Andric // If the section is not in a PT_LOAD, we just have to align it. 25160b57cec5SDimitry Andric if (!os->ptLoad) 25170b57cec5SDimitry Andric return alignTo(off, os->alignment); 25180b57cec5SDimitry Andric 25190b57cec5SDimitry Andric // If two sections share the same PT_LOAD the file offset is calculated 25200b57cec5SDimitry Andric // using this formula: Off2 = Off1 + (VA2 - VA1). 25210b57cec5SDimitry Andric OutputSection *first = os->ptLoad->firstSec; 25220b57cec5SDimitry Andric return first->offset + os->addr - first->addr; 25230b57cec5SDimitry Andric } 25240b57cec5SDimitry Andric 25250b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::assignFileOffsetsBinary() { 2526e8d8bef9SDimitry Andric // Compute the minimum LMA of all non-empty non-NOBITS sections as minAddr. 2527e8d8bef9SDimitry Andric auto needsOffset = [](OutputSection &sec) { 2528e8d8bef9SDimitry Andric return sec.type != SHT_NOBITS && (sec.flags & SHF_ALLOC) && sec.size > 0; 2529e8d8bef9SDimitry Andric }; 2530e8d8bef9SDimitry Andric uint64_t minAddr = UINT64_MAX; 25310b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 2532e8d8bef9SDimitry Andric if (needsOffset(*sec)) { 2533e8d8bef9SDimitry Andric sec->offset = sec->getLMA(); 2534e8d8bef9SDimitry Andric minAddr = std::min(minAddr, sec->offset); 2535e8d8bef9SDimitry Andric } 2536e8d8bef9SDimitry Andric 2537e8d8bef9SDimitry Andric // Sections are laid out at LMA minus minAddr. 2538e8d8bef9SDimitry Andric fileSize = 0; 2539e8d8bef9SDimitry Andric for (OutputSection *sec : outputSections) 2540e8d8bef9SDimitry Andric if (needsOffset(*sec)) { 2541e8d8bef9SDimitry Andric sec->offset -= minAddr; 2542e8d8bef9SDimitry Andric fileSize = std::max(fileSize, sec->offset + sec->size); 2543e8d8bef9SDimitry Andric } 25440b57cec5SDimitry Andric } 25450b57cec5SDimitry Andric 25460b57cec5SDimitry Andric static std::string rangeToString(uint64_t addr, uint64_t len) { 25470b57cec5SDimitry Andric return "[0x" + utohexstr(addr) + ", 0x" + utohexstr(addr + len - 1) + "]"; 25480b57cec5SDimitry Andric } 25490b57cec5SDimitry Andric 25500b57cec5SDimitry Andric // Assign file offsets to output sections. 25510b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::assignFileOffsets() { 25524824e7fdSDimitry Andric Out::programHeaders->offset = Out::elfHeader->size; 25534824e7fdSDimitry Andric uint64_t off = Out::elfHeader->size + Out::programHeaders->size; 25540b57cec5SDimitry Andric 25550b57cec5SDimitry Andric PhdrEntry *lastRX = nullptr; 25560b57cec5SDimitry Andric for (Partition &part : partitions) 25570b57cec5SDimitry Andric for (PhdrEntry *p : part.phdrs) 25580b57cec5SDimitry Andric if (p->p_type == PT_LOAD && (p->p_flags & PF_X)) 25590b57cec5SDimitry Andric lastRX = p; 25600b57cec5SDimitry Andric 2561e8d8bef9SDimitry Andric // Layout SHF_ALLOC sections before non-SHF_ALLOC sections. A non-SHF_ALLOC 2562e8d8bef9SDimitry Andric // will not occupy file offsets contained by a PT_LOAD. 25630b57cec5SDimitry Andric for (OutputSection *sec : outputSections) { 2564e8d8bef9SDimitry Andric if (!(sec->flags & SHF_ALLOC)) 2565e8d8bef9SDimitry Andric continue; 25664824e7fdSDimitry Andric off = computeFileOffset(sec, off); 25674824e7fdSDimitry Andric sec->offset = off; 25684824e7fdSDimitry Andric if (sec->type != SHT_NOBITS) 25694824e7fdSDimitry Andric off += sec->size; 25700b57cec5SDimitry Andric 25710b57cec5SDimitry Andric // If this is a last section of the last executable segment and that 25720b57cec5SDimitry Andric // segment is the last loadable segment, align the offset of the 25730b57cec5SDimitry Andric // following section to avoid loading non-segments parts of the file. 257485868e8aSDimitry Andric if (config->zSeparate != SeparateSegmentKind::None && lastRX && 257585868e8aSDimitry Andric lastRX->lastSec == sec) 25764824e7fdSDimitry Andric off = alignTo(off, config->maxPageSize); 25770b57cec5SDimitry Andric } 25784824e7fdSDimitry Andric for (OutputSection *osec : outputSections) 25794824e7fdSDimitry Andric if (!(osec->flags & SHF_ALLOC)) { 25804824e7fdSDimitry Andric osec->offset = alignTo(off, osec->alignment); 25814824e7fdSDimitry Andric off = osec->offset + osec->size; 25824824e7fdSDimitry Andric } 25830b57cec5SDimitry Andric 25840b57cec5SDimitry Andric sectionHeaderOff = alignTo(off, config->wordsize); 25850b57cec5SDimitry Andric fileSize = sectionHeaderOff + (outputSections.size() + 1) * sizeof(Elf_Shdr); 25860b57cec5SDimitry Andric 25870b57cec5SDimitry Andric // Our logic assumes that sections have rising VA within the same segment. 25880b57cec5SDimitry Andric // With use of linker scripts it is possible to violate this rule and get file 25890b57cec5SDimitry Andric // offset overlaps or overflows. That should never happen with a valid script 25900b57cec5SDimitry Andric // which does not move the location counter backwards and usually scripts do 25910b57cec5SDimitry Andric // not do that. Unfortunately, there are apps in the wild, for example, Linux 25920b57cec5SDimitry Andric // kernel, which control segment distribution explicitly and move the counter 25930b57cec5SDimitry Andric // backwards, so we have to allow doing that to support linking them. We 25940b57cec5SDimitry Andric // perform non-critical checks for overlaps in checkSectionOverlap(), but here 25950b57cec5SDimitry Andric // we want to prevent file size overflows because it would crash the linker. 25960b57cec5SDimitry Andric for (OutputSection *sec : outputSections) { 25970b57cec5SDimitry Andric if (sec->type == SHT_NOBITS) 25980b57cec5SDimitry Andric continue; 25990b57cec5SDimitry Andric if ((sec->offset > fileSize) || (sec->offset + sec->size > fileSize)) 26000b57cec5SDimitry Andric error("unable to place section " + sec->name + " at file offset " + 26010b57cec5SDimitry Andric rangeToString(sec->offset, sec->size) + 26020b57cec5SDimitry Andric "; check your linker script for overflows"); 26030b57cec5SDimitry Andric } 26040b57cec5SDimitry Andric } 26050b57cec5SDimitry Andric 26060b57cec5SDimitry Andric // Finalize the program headers. We call this function after we assign 26070b57cec5SDimitry Andric // file offsets and VAs to all sections. 26080b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::setPhdrs(Partition &part) { 26090b57cec5SDimitry Andric for (PhdrEntry *p : part.phdrs) { 26100b57cec5SDimitry Andric OutputSection *first = p->firstSec; 26110b57cec5SDimitry Andric OutputSection *last = p->lastSec; 26120b57cec5SDimitry Andric 26130b57cec5SDimitry Andric if (first) { 26140b57cec5SDimitry Andric p->p_filesz = last->offset - first->offset; 26150b57cec5SDimitry Andric if (last->type != SHT_NOBITS) 26160b57cec5SDimitry Andric p->p_filesz += last->size; 26170b57cec5SDimitry Andric 26180b57cec5SDimitry Andric p->p_memsz = last->addr + last->size - first->addr; 26190b57cec5SDimitry Andric p->p_offset = first->offset; 26200b57cec5SDimitry Andric p->p_vaddr = first->addr; 26210b57cec5SDimitry Andric 26220b57cec5SDimitry Andric // File offsets in partitions other than the main partition are relative 26230b57cec5SDimitry Andric // to the offset of the ELF headers. Perform that adjustment now. 26240b57cec5SDimitry Andric if (part.elfHeader) 26250b57cec5SDimitry Andric p->p_offset -= part.elfHeader->getParent()->offset; 26260b57cec5SDimitry Andric 26270b57cec5SDimitry Andric if (!p->hasLMA) 26280b57cec5SDimitry Andric p->p_paddr = first->getLMA(); 26290b57cec5SDimitry Andric } 26300b57cec5SDimitry Andric 263185868e8aSDimitry Andric if (p->p_type == PT_GNU_RELRO) { 26320b57cec5SDimitry Andric p->p_align = 1; 263385868e8aSDimitry Andric // musl/glibc ld.so rounds the size down, so we need to round up 26340b57cec5SDimitry Andric // to protect the last page. This is a no-op on FreeBSD which always 26350b57cec5SDimitry Andric // rounds up. 263685868e8aSDimitry Andric p->p_memsz = alignTo(p->p_offset + p->p_memsz, config->commonPageSize) - 263785868e8aSDimitry Andric p->p_offset; 26380b57cec5SDimitry Andric } 26390b57cec5SDimitry Andric } 26400b57cec5SDimitry Andric } 26410b57cec5SDimitry Andric 26420b57cec5SDimitry Andric // A helper struct for checkSectionOverlap. 26430b57cec5SDimitry Andric namespace { 26440b57cec5SDimitry Andric struct SectionOffset { 26450b57cec5SDimitry Andric OutputSection *sec; 26460b57cec5SDimitry Andric uint64_t offset; 26470b57cec5SDimitry Andric }; 26480b57cec5SDimitry Andric } // namespace 26490b57cec5SDimitry Andric 26500b57cec5SDimitry Andric // Check whether sections overlap for a specific address range (file offsets, 2651480093f4SDimitry Andric // load and virtual addresses). 26520b57cec5SDimitry Andric static void checkOverlap(StringRef name, std::vector<SectionOffset> §ions, 26530b57cec5SDimitry Andric bool isVirtualAddr) { 26540b57cec5SDimitry Andric llvm::sort(sections, [=](const SectionOffset &a, const SectionOffset &b) { 26550b57cec5SDimitry Andric return a.offset < b.offset; 26560b57cec5SDimitry Andric }); 26570b57cec5SDimitry Andric 26580b57cec5SDimitry Andric // Finding overlap is easy given a vector is sorted by start position. 26590b57cec5SDimitry Andric // If an element starts before the end of the previous element, they overlap. 26600b57cec5SDimitry Andric for (size_t i = 1, end = sections.size(); i < end; ++i) { 26610b57cec5SDimitry Andric SectionOffset a = sections[i - 1]; 26620b57cec5SDimitry Andric SectionOffset b = sections[i]; 26630b57cec5SDimitry Andric if (b.offset >= a.offset + a.sec->size) 26640b57cec5SDimitry Andric continue; 26650b57cec5SDimitry Andric 26660b57cec5SDimitry Andric // If both sections are in OVERLAY we allow the overlapping of virtual 26670b57cec5SDimitry Andric // addresses, because it is what OVERLAY was designed for. 26680b57cec5SDimitry Andric if (isVirtualAddr && a.sec->inOverlay && b.sec->inOverlay) 26690b57cec5SDimitry Andric continue; 26700b57cec5SDimitry Andric 26710b57cec5SDimitry Andric errorOrWarn("section " + a.sec->name + " " + name + 26720b57cec5SDimitry Andric " range overlaps with " + b.sec->name + "\n>>> " + a.sec->name + 26730b57cec5SDimitry Andric " range is " + rangeToString(a.offset, a.sec->size) + "\n>>> " + 26740b57cec5SDimitry Andric b.sec->name + " range is " + 26750b57cec5SDimitry Andric rangeToString(b.offset, b.sec->size)); 26760b57cec5SDimitry Andric } 26770b57cec5SDimitry Andric } 26780b57cec5SDimitry Andric 26790b57cec5SDimitry Andric // Check for overlapping sections and address overflows. 26800b57cec5SDimitry Andric // 26810b57cec5SDimitry Andric // In this function we check that none of the output sections have overlapping 26820b57cec5SDimitry Andric // file offsets. For SHF_ALLOC sections we also check that the load address 26830b57cec5SDimitry Andric // ranges and the virtual address ranges don't overlap 26840b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::checkSections() { 26850b57cec5SDimitry Andric // First, check that section's VAs fit in available address space for target. 26860b57cec5SDimitry Andric for (OutputSection *os : outputSections) 26870b57cec5SDimitry Andric if ((os->addr + os->size < os->addr) || 26880b57cec5SDimitry Andric (!ELFT::Is64Bits && os->addr + os->size > UINT32_MAX)) 26890b57cec5SDimitry Andric errorOrWarn("section " + os->name + " at 0x" + utohexstr(os->addr) + 26900b57cec5SDimitry Andric " of size 0x" + utohexstr(os->size) + 26910b57cec5SDimitry Andric " exceeds available address space"); 26920b57cec5SDimitry Andric 26930b57cec5SDimitry Andric // Check for overlapping file offsets. In this case we need to skip any 26940b57cec5SDimitry Andric // section marked as SHT_NOBITS. These sections don't actually occupy space in 26950b57cec5SDimitry Andric // the file so Sec->Offset + Sec->Size can overlap with others. If --oformat 26960b57cec5SDimitry Andric // binary is specified only add SHF_ALLOC sections are added to the output 26970b57cec5SDimitry Andric // file so we skip any non-allocated sections in that case. 26980b57cec5SDimitry Andric std::vector<SectionOffset> fileOffs; 26990b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 27000b57cec5SDimitry Andric if (sec->size > 0 && sec->type != SHT_NOBITS && 27010b57cec5SDimitry Andric (!config->oFormatBinary || (sec->flags & SHF_ALLOC))) 27020b57cec5SDimitry Andric fileOffs.push_back({sec, sec->offset}); 27030b57cec5SDimitry Andric checkOverlap("file", fileOffs, false); 27040b57cec5SDimitry Andric 27050b57cec5SDimitry Andric // When linking with -r there is no need to check for overlapping virtual/load 27060b57cec5SDimitry Andric // addresses since those addresses will only be assigned when the final 27070b57cec5SDimitry Andric // executable/shared object is created. 27080b57cec5SDimitry Andric if (config->relocatable) 27090b57cec5SDimitry Andric return; 27100b57cec5SDimitry Andric 27110b57cec5SDimitry Andric // Checking for overlapping virtual and load addresses only needs to take 27120b57cec5SDimitry Andric // into account SHF_ALLOC sections since others will not be loaded. 27130b57cec5SDimitry Andric // Furthermore, we also need to skip SHF_TLS sections since these will be 27140b57cec5SDimitry Andric // mapped to other addresses at runtime and can therefore have overlapping 27150b57cec5SDimitry Andric // ranges in the file. 27160b57cec5SDimitry Andric std::vector<SectionOffset> vmas; 27170b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 27180b57cec5SDimitry Andric if (sec->size > 0 && (sec->flags & SHF_ALLOC) && !(sec->flags & SHF_TLS)) 27190b57cec5SDimitry Andric vmas.push_back({sec, sec->addr}); 27200b57cec5SDimitry Andric checkOverlap("virtual address", vmas, true); 27210b57cec5SDimitry Andric 27220b57cec5SDimitry Andric // Finally, check that the load addresses don't overlap. This will usually be 27230b57cec5SDimitry Andric // the same as the virtual addresses but can be different when using a linker 27240b57cec5SDimitry Andric // script with AT(). 27250b57cec5SDimitry Andric std::vector<SectionOffset> lmas; 27260b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 27270b57cec5SDimitry Andric if (sec->size > 0 && (sec->flags & SHF_ALLOC) && !(sec->flags & SHF_TLS)) 27280b57cec5SDimitry Andric lmas.push_back({sec, sec->getLMA()}); 27290b57cec5SDimitry Andric checkOverlap("load address", lmas, false); 27300b57cec5SDimitry Andric } 27310b57cec5SDimitry Andric 27320b57cec5SDimitry Andric // The entry point address is chosen in the following ways. 27330b57cec5SDimitry Andric // 27340b57cec5SDimitry Andric // 1. the '-e' entry command-line option; 27350b57cec5SDimitry Andric // 2. the ENTRY(symbol) command in a linker control script; 27360b57cec5SDimitry Andric // 3. the value of the symbol _start, if present; 27370b57cec5SDimitry Andric // 4. the number represented by the entry symbol, if it is a number; 2738349cc55cSDimitry Andric // 5. the address 0. 27390b57cec5SDimitry Andric static uint64_t getEntryAddr() { 27400b57cec5SDimitry Andric // Case 1, 2 or 3 27410b57cec5SDimitry Andric if (Symbol *b = symtab->find(config->entry)) 27420b57cec5SDimitry Andric return b->getVA(); 27430b57cec5SDimitry Andric 27440b57cec5SDimitry Andric // Case 4 27450b57cec5SDimitry Andric uint64_t addr; 27460b57cec5SDimitry Andric if (to_integer(config->entry, addr)) 27470b57cec5SDimitry Andric return addr; 27480b57cec5SDimitry Andric 27490b57cec5SDimitry Andric // Case 5 27500b57cec5SDimitry Andric if (config->warnMissingEntry) 27510b57cec5SDimitry Andric warn("cannot find entry symbol " + config->entry + 27520b57cec5SDimitry Andric "; not setting start address"); 27530b57cec5SDimitry Andric return 0; 27540b57cec5SDimitry Andric } 27550b57cec5SDimitry Andric 27560b57cec5SDimitry Andric static uint16_t getELFType() { 27570b57cec5SDimitry Andric if (config->isPic) 27580b57cec5SDimitry Andric return ET_DYN; 27590b57cec5SDimitry Andric if (config->relocatable) 27600b57cec5SDimitry Andric return ET_REL; 27610b57cec5SDimitry Andric return ET_EXEC; 27620b57cec5SDimitry Andric } 27630b57cec5SDimitry Andric 27640b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::writeHeader() { 27650b57cec5SDimitry Andric writeEhdr<ELFT>(Out::bufferStart, *mainPart); 27660b57cec5SDimitry Andric writePhdrs<ELFT>(Out::bufferStart + sizeof(Elf_Ehdr), *mainPart); 27670b57cec5SDimitry Andric 27680b57cec5SDimitry Andric auto *eHdr = reinterpret_cast<Elf_Ehdr *>(Out::bufferStart); 27690b57cec5SDimitry Andric eHdr->e_type = getELFType(); 27700b57cec5SDimitry Andric eHdr->e_entry = getEntryAddr(); 27710b57cec5SDimitry Andric eHdr->e_shoff = sectionHeaderOff; 27720b57cec5SDimitry Andric 27730b57cec5SDimitry Andric // Write the section header table. 27740b57cec5SDimitry Andric // 27750b57cec5SDimitry Andric // The ELF header can only store numbers up to SHN_LORESERVE in the e_shnum 27760b57cec5SDimitry Andric // and e_shstrndx fields. When the value of one of these fields exceeds 27770b57cec5SDimitry Andric // SHN_LORESERVE ELF requires us to put sentinel values in the ELF header and 27780b57cec5SDimitry Andric // use fields in the section header at index 0 to store 27790b57cec5SDimitry Andric // the value. The sentinel values and fields are: 27800b57cec5SDimitry Andric // e_shnum = 0, SHdrs[0].sh_size = number of sections. 27810b57cec5SDimitry Andric // e_shstrndx = SHN_XINDEX, SHdrs[0].sh_link = .shstrtab section index. 27820b57cec5SDimitry Andric auto *sHdrs = reinterpret_cast<Elf_Shdr *>(Out::bufferStart + eHdr->e_shoff); 27830b57cec5SDimitry Andric size_t num = outputSections.size() + 1; 27840b57cec5SDimitry Andric if (num >= SHN_LORESERVE) 27850b57cec5SDimitry Andric sHdrs->sh_size = num; 27860b57cec5SDimitry Andric else 27870b57cec5SDimitry Andric eHdr->e_shnum = num; 27880b57cec5SDimitry Andric 27890b57cec5SDimitry Andric uint32_t strTabIndex = in.shStrTab->getParent()->sectionIndex; 27900b57cec5SDimitry Andric if (strTabIndex >= SHN_LORESERVE) { 27910b57cec5SDimitry Andric sHdrs->sh_link = strTabIndex; 27920b57cec5SDimitry Andric eHdr->e_shstrndx = SHN_XINDEX; 27930b57cec5SDimitry Andric } else { 27940b57cec5SDimitry Andric eHdr->e_shstrndx = strTabIndex; 27950b57cec5SDimitry Andric } 27960b57cec5SDimitry Andric 27970b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 27980b57cec5SDimitry Andric sec->writeHeaderTo<ELFT>(++sHdrs); 27990b57cec5SDimitry Andric } 28000b57cec5SDimitry Andric 28010b57cec5SDimitry Andric // Open a result file. 28020b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::openFile() { 28030b57cec5SDimitry Andric uint64_t maxSize = config->is64 ? INT64_MAX : UINT32_MAX; 28040b57cec5SDimitry Andric if (fileSize != size_t(fileSize) || maxSize < fileSize) { 2805e8d8bef9SDimitry Andric std::string msg; 2806e8d8bef9SDimitry Andric raw_string_ostream s(msg); 2807e8d8bef9SDimitry Andric s << "output file too large: " << Twine(fileSize) << " bytes\n" 2808e8d8bef9SDimitry Andric << "section sizes:\n"; 2809e8d8bef9SDimitry Andric for (OutputSection *os : outputSections) 2810e8d8bef9SDimitry Andric s << os->name << ' ' << os->size << "\n"; 2811e8d8bef9SDimitry Andric error(s.str()); 28120b57cec5SDimitry Andric return; 28130b57cec5SDimitry Andric } 28140b57cec5SDimitry Andric 28150b57cec5SDimitry Andric unlinkAsync(config->outputFile); 28160b57cec5SDimitry Andric unsigned flags = 0; 28170b57cec5SDimitry Andric if (!config->relocatable) 2818480093f4SDimitry Andric flags |= FileOutputBuffer::F_executable; 2819480093f4SDimitry Andric if (!config->mmapOutputFile) 2820480093f4SDimitry Andric flags |= FileOutputBuffer::F_no_mmap; 28210b57cec5SDimitry Andric Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr = 28220b57cec5SDimitry Andric FileOutputBuffer::create(config->outputFile, fileSize, flags); 28230b57cec5SDimitry Andric 28240b57cec5SDimitry Andric if (!bufferOrErr) { 28250b57cec5SDimitry Andric error("failed to open " + config->outputFile + ": " + 28260b57cec5SDimitry Andric llvm::toString(bufferOrErr.takeError())); 28270b57cec5SDimitry Andric return; 28280b57cec5SDimitry Andric } 28290b57cec5SDimitry Andric buffer = std::move(*bufferOrErr); 28300b57cec5SDimitry Andric Out::bufferStart = buffer->getBufferStart(); 28310b57cec5SDimitry Andric } 28320b57cec5SDimitry Andric 28330b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::writeSectionsBinary() { 28340b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 28350b57cec5SDimitry Andric if (sec->flags & SHF_ALLOC) 28360b57cec5SDimitry Andric sec->writeTo<ELFT>(Out::bufferStart + sec->offset); 28370b57cec5SDimitry Andric } 28380b57cec5SDimitry Andric 28390b57cec5SDimitry Andric static void fillTrap(uint8_t *i, uint8_t *end) { 28400b57cec5SDimitry Andric for (; i + 4 <= end; i += 4) 28410b57cec5SDimitry Andric memcpy(i, &target->trapInstr, 4); 28420b57cec5SDimitry Andric } 28430b57cec5SDimitry Andric 28440b57cec5SDimitry Andric // Fill the last page of executable segments with trap instructions 28450b57cec5SDimitry Andric // instead of leaving them as zero. Even though it is not required by any 28460b57cec5SDimitry Andric // standard, it is in general a good thing to do for security reasons. 28470b57cec5SDimitry Andric // 28480b57cec5SDimitry Andric // We'll leave other pages in segments as-is because the rest will be 28490b57cec5SDimitry Andric // overwritten by output sections. 28500b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::writeTrapInstr() { 28510b57cec5SDimitry Andric for (Partition &part : partitions) { 28520b57cec5SDimitry Andric // Fill the last page. 28530b57cec5SDimitry Andric for (PhdrEntry *p : part.phdrs) 28540b57cec5SDimitry Andric if (p->p_type == PT_LOAD && (p->p_flags & PF_X)) 2855*04eeddc0SDimitry Andric fillTrap(Out::bufferStart + 2856*04eeddc0SDimitry Andric alignDown(p->firstSec->offset + p->p_filesz, 4), 28570b57cec5SDimitry Andric Out::bufferStart + alignTo(p->firstSec->offset + p->p_filesz, 28584824e7fdSDimitry Andric config->maxPageSize)); 28590b57cec5SDimitry Andric 28600b57cec5SDimitry Andric // Round up the file size of the last segment to the page boundary iff it is 28610b57cec5SDimitry Andric // an executable segment to ensure that other tools don't accidentally 28620b57cec5SDimitry Andric // trim the instruction padding (e.g. when stripping the file). 28630b57cec5SDimitry Andric PhdrEntry *last = nullptr; 28640b57cec5SDimitry Andric for (PhdrEntry *p : part.phdrs) 28650b57cec5SDimitry Andric if (p->p_type == PT_LOAD) 28660b57cec5SDimitry Andric last = p; 28670b57cec5SDimitry Andric 28680b57cec5SDimitry Andric if (last && (last->p_flags & PF_X)) 28690b57cec5SDimitry Andric last->p_memsz = last->p_filesz = 28704824e7fdSDimitry Andric alignTo(last->p_filesz, config->maxPageSize); 28710b57cec5SDimitry Andric } 28720b57cec5SDimitry Andric } 28730b57cec5SDimitry Andric 28740b57cec5SDimitry Andric // Write section contents to a mmap'ed file. 28750b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::writeSections() { 28760eae32dcSDimitry Andric llvm::TimeTraceScope timeScope("Write sections"); 28770eae32dcSDimitry Andric 2878349cc55cSDimitry Andric // In -r or --emit-relocs mode, write the relocation sections first as in 28790b57cec5SDimitry Andric // ELf_Rel targets we might find out that we need to modify the relocated 28800b57cec5SDimitry Andric // section while doing it. 28810b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 28820b57cec5SDimitry Andric if (sec->type == SHT_REL || sec->type == SHT_RELA) 28830b57cec5SDimitry Andric sec->writeTo<ELFT>(Out::bufferStart + sec->offset); 28840b57cec5SDimitry Andric 28850b57cec5SDimitry Andric for (OutputSection *sec : outputSections) 28860b57cec5SDimitry Andric if (sec->type != SHT_REL && sec->type != SHT_RELA) 28870b57cec5SDimitry Andric sec->writeTo<ELFT>(Out::bufferStart + sec->offset); 28880b57cec5SDimitry Andric 2889fe6060f1SDimitry Andric // Finally, check that all dynamic relocation addends were written correctly. 2890fe6060f1SDimitry Andric if (config->checkDynamicRelocs && config->writeAddends) { 2891fe6060f1SDimitry Andric for (OutputSection *sec : outputSections) 2892fe6060f1SDimitry Andric if (sec->type == SHT_REL || sec->type == SHT_RELA) 2893fe6060f1SDimitry Andric sec->checkDynRelAddends(Out::bufferStart); 28940b57cec5SDimitry Andric } 28950b57cec5SDimitry Andric } 28960b57cec5SDimitry Andric 28970b57cec5SDimitry Andric // Computes a hash value of Data using a given hash function. 28980b57cec5SDimitry Andric // In order to utilize multiple cores, we first split data into 1MB 28990b57cec5SDimitry Andric // chunks, compute a hash for each chunk, and then compute a hash value 29000b57cec5SDimitry Andric // of the hash values. 29010b57cec5SDimitry Andric static void 29020b57cec5SDimitry Andric computeHash(llvm::MutableArrayRef<uint8_t> hashBuf, 29030b57cec5SDimitry Andric llvm::ArrayRef<uint8_t> data, 29040b57cec5SDimitry Andric std::function<void(uint8_t *dest, ArrayRef<uint8_t> arr)> hashFn) { 29050b57cec5SDimitry Andric std::vector<ArrayRef<uint8_t>> chunks = split(data, 1024 * 1024); 2906*04eeddc0SDimitry Andric const size_t hashesSize = chunks.size() * hashBuf.size(); 2907*04eeddc0SDimitry Andric std::unique_ptr<uint8_t[]> hashes(new uint8_t[hashesSize]); 29080b57cec5SDimitry Andric 29090b57cec5SDimitry Andric // Compute hash values. 29100b57cec5SDimitry Andric parallelForEachN(0, chunks.size(), [&](size_t i) { 2911*04eeddc0SDimitry Andric hashFn(hashes.get() + i * hashBuf.size(), chunks[i]); 29120b57cec5SDimitry Andric }); 29130b57cec5SDimitry Andric 29140b57cec5SDimitry Andric // Write to the final output buffer. 2915*04eeddc0SDimitry Andric hashFn(hashBuf.data(), makeArrayRef(hashes.get(), hashesSize)); 29160b57cec5SDimitry Andric } 29170b57cec5SDimitry Andric 29180b57cec5SDimitry Andric template <class ELFT> void Writer<ELFT>::writeBuildId() { 29190b57cec5SDimitry Andric if (!mainPart->buildId || !mainPart->buildId->getParent()) 29200b57cec5SDimitry Andric return; 29210b57cec5SDimitry Andric 29220b57cec5SDimitry Andric if (config->buildId == BuildIdKind::Hexstring) { 29230b57cec5SDimitry Andric for (Partition &part : partitions) 29240b57cec5SDimitry Andric part.buildId->writeBuildId(config->buildIdVector); 29250b57cec5SDimitry Andric return; 29260b57cec5SDimitry Andric } 29270b57cec5SDimitry Andric 29280b57cec5SDimitry Andric // Compute a hash of all sections of the output file. 29290b57cec5SDimitry Andric size_t hashSize = mainPart->buildId->hashSize; 2930*04eeddc0SDimitry Andric std::unique_ptr<uint8_t[]> buildId(new uint8_t[hashSize]); 2931*04eeddc0SDimitry Andric MutableArrayRef<uint8_t> output(buildId.get(), hashSize); 2932*04eeddc0SDimitry Andric llvm::ArrayRef<uint8_t> input{Out::bufferStart, size_t(fileSize)}; 29330b57cec5SDimitry Andric 29340b57cec5SDimitry Andric switch (config->buildId) { 29350b57cec5SDimitry Andric case BuildIdKind::Fast: 2936*04eeddc0SDimitry Andric computeHash(output, input, [](uint8_t *dest, ArrayRef<uint8_t> arr) { 29370b57cec5SDimitry Andric write64le(dest, xxHash64(arr)); 29380b57cec5SDimitry Andric }); 29390b57cec5SDimitry Andric break; 29400b57cec5SDimitry Andric case BuildIdKind::Md5: 2941*04eeddc0SDimitry Andric computeHash(output, input, [&](uint8_t *dest, ArrayRef<uint8_t> arr) { 29420b57cec5SDimitry Andric memcpy(dest, MD5::hash(arr).data(), hashSize); 29430b57cec5SDimitry Andric }); 29440b57cec5SDimitry Andric break; 29450b57cec5SDimitry Andric case BuildIdKind::Sha1: 2946*04eeddc0SDimitry Andric computeHash(output, input, [&](uint8_t *dest, ArrayRef<uint8_t> arr) { 29470b57cec5SDimitry Andric memcpy(dest, SHA1::hash(arr).data(), hashSize); 29480b57cec5SDimitry Andric }); 29490b57cec5SDimitry Andric break; 29500b57cec5SDimitry Andric case BuildIdKind::Uuid: 2951*04eeddc0SDimitry Andric if (auto ec = llvm::getRandomBytes(buildId.get(), hashSize)) 29520b57cec5SDimitry Andric error("entropy source failure: " + ec.message()); 29530b57cec5SDimitry Andric break; 29540b57cec5SDimitry Andric default: 29550b57cec5SDimitry Andric llvm_unreachable("unknown BuildIdKind"); 29560b57cec5SDimitry Andric } 29570b57cec5SDimitry Andric for (Partition &part : partitions) 2958*04eeddc0SDimitry Andric part.buildId->writeBuildId(output); 29590b57cec5SDimitry Andric } 29600b57cec5SDimitry Andric 29615ffd83dbSDimitry Andric template void elf::createSyntheticSections<ELF32LE>(); 29625ffd83dbSDimitry Andric template void elf::createSyntheticSections<ELF32BE>(); 29635ffd83dbSDimitry Andric template void elf::createSyntheticSections<ELF64LE>(); 29645ffd83dbSDimitry Andric template void elf::createSyntheticSections<ELF64BE>(); 296585868e8aSDimitry Andric 29665ffd83dbSDimitry Andric template void elf::writeResult<ELF32LE>(); 29675ffd83dbSDimitry Andric template void elf::writeResult<ELF32BE>(); 29685ffd83dbSDimitry Andric template void elf::writeResult<ELF64LE>(); 29695ffd83dbSDimitry Andric template void elf::writeResult<ELF64BE>(); 2970