1 //===- Writer.cpp ---------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "Writer.h" 10 #include "AArch64ErrataFix.h" 11 #include "ARMErrataFix.h" 12 #include "CallGraphSort.h" 13 #include "Config.h" 14 #include "InputFiles.h" 15 #include "LinkerScript.h" 16 #include "MapFile.h" 17 #include "OutputSections.h" 18 #include "Relocations.h" 19 #include "SymbolTable.h" 20 #include "Symbols.h" 21 #include "SyntheticSections.h" 22 #include "Target.h" 23 #include "lld/Common/Arrays.h" 24 #include "lld/Common/CommonLinkerContext.h" 25 #include "lld/Common/Filesystem.h" 26 #include "lld/Common/Strings.h" 27 #include "llvm/ADT/StringMap.h" 28 #include "llvm/Support/BLAKE3.h" 29 #include "llvm/Support/Parallel.h" 30 #include "llvm/Support/RandomNumberGenerator.h" 31 #include "llvm/Support/TimeProfiler.h" 32 #include "llvm/Support/xxhash.h" 33 #include <climits> 34 35 #define DEBUG_TYPE "lld" 36 37 using namespace llvm; 38 using namespace llvm::ELF; 39 using namespace llvm::object; 40 using namespace llvm::support; 41 using namespace llvm::support::endian; 42 using namespace lld; 43 using namespace lld::elf; 44 45 namespace { 46 // The writer writes a SymbolTable result to a file. 47 template <class ELFT> class Writer { 48 public: 49 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 50 51 Writer() : buffer(errorHandler().outputBuffer) {} 52 53 void run(); 54 55 private: 56 void copyLocalSymbols(); 57 void addSectionSymbols(); 58 void sortSections(); 59 void resolveShfLinkOrder(); 60 void finalizeAddressDependentContent(); 61 void optimizeBasicBlockJumps(); 62 void sortInputSections(); 63 void finalizeSections(); 64 void checkExecuteOnly(); 65 void setReservedSymbolSections(); 66 67 SmallVector<PhdrEntry *, 0> createPhdrs(Partition &part); 68 void addPhdrForSection(Partition &part, unsigned shType, unsigned pType, 69 unsigned pFlags); 70 void assignFileOffsets(); 71 void assignFileOffsetsBinary(); 72 void setPhdrs(Partition &part); 73 void checkSections(); 74 void fixSectionAlignments(); 75 void openFile(); 76 void writeTrapInstr(); 77 void writeHeader(); 78 void writeSections(); 79 void writeSectionsBinary(); 80 void writeBuildId(); 81 82 std::unique_ptr<FileOutputBuffer> &buffer; 83 84 void addRelIpltSymbols(); 85 void addStartEndSymbols(); 86 void addStartStopSymbols(OutputSection &osec); 87 88 uint64_t fileSize; 89 uint64_t sectionHeaderOff; 90 }; 91 } // anonymous namespace 92 93 static bool needsInterpSection() { 94 return !config->relocatable && !config->shared && 95 !config->dynamicLinker.empty() && script->needsInterpSection(); 96 } 97 98 template <class ELFT> void elf::writeResult() { 99 Writer<ELFT>().run(); 100 } 101 102 static void removeEmptyPTLoad(SmallVector<PhdrEntry *, 0> &phdrs) { 103 auto it = std::stable_partition( 104 phdrs.begin(), phdrs.end(), [&](const PhdrEntry *p) { 105 if (p->p_type != PT_LOAD) 106 return true; 107 if (!p->firstSec) 108 return false; 109 uint64_t size = p->lastSec->addr + p->lastSec->size - p->firstSec->addr; 110 return size != 0; 111 }); 112 113 // Clear OutputSection::ptLoad for sections contained in removed 114 // segments. 115 DenseSet<PhdrEntry *> removed(it, phdrs.end()); 116 for (OutputSection *sec : outputSections) 117 if (removed.count(sec->ptLoad)) 118 sec->ptLoad = nullptr; 119 phdrs.erase(it, phdrs.end()); 120 } 121 122 void elf::copySectionsIntoPartitions() { 123 SmallVector<InputSectionBase *, 0> newSections; 124 const size_t ehSize = ctx.ehInputSections.size(); 125 for (unsigned part = 2; part != partitions.size() + 1; ++part) { 126 for (InputSectionBase *s : ctx.inputSections) { 127 if (!(s->flags & SHF_ALLOC) || !s->isLive() || s->type != SHT_NOTE) 128 continue; 129 auto *copy = make<InputSection>(cast<InputSection>(*s)); 130 copy->partition = part; 131 newSections.push_back(copy); 132 } 133 for (size_t i = 0; i != ehSize; ++i) { 134 assert(ctx.ehInputSections[i]->isLive()); 135 auto *copy = make<EhInputSection>(*ctx.ehInputSections[i]); 136 copy->partition = part; 137 ctx.ehInputSections.push_back(copy); 138 } 139 } 140 141 ctx.inputSections.insert(ctx.inputSections.end(), newSections.begin(), 142 newSections.end()); 143 } 144 145 static Defined *addOptionalRegular(StringRef name, SectionBase *sec, 146 uint64_t val, uint8_t stOther = STV_HIDDEN) { 147 Symbol *s = symtab.find(name); 148 if (!s || s->isDefined() || s->isCommon()) 149 return nullptr; 150 151 s->resolve(Defined{nullptr, StringRef(), STB_GLOBAL, stOther, STT_NOTYPE, val, 152 /*size=*/0, sec}); 153 s->isUsedInRegularObj = true; 154 return cast<Defined>(s); 155 } 156 157 static Defined *addAbsolute(StringRef name) { 158 Symbol *sym = symtab.addSymbol(Defined{nullptr, name, STB_GLOBAL, STV_HIDDEN, 159 STT_NOTYPE, 0, 0, nullptr}); 160 sym->isUsedInRegularObj = true; 161 return cast<Defined>(sym); 162 } 163 164 // The linker is expected to define some symbols depending on 165 // the linking result. This function defines such symbols. 166 void elf::addReservedSymbols() { 167 if (config->emachine == EM_MIPS) { 168 // Define _gp for MIPS. st_value of _gp symbol will be updated by Writer 169 // so that it points to an absolute address which by default is relative 170 // to GOT. Default offset is 0x7ff0. 171 // See "Global Data Symbols" in Chapter 6 in the following document: 172 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf 173 ElfSym::mipsGp = addAbsolute("_gp"); 174 175 // On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between 176 // start of function and 'gp' pointer into GOT. 177 if (symtab.find("_gp_disp")) 178 ElfSym::mipsGpDisp = addAbsolute("_gp_disp"); 179 180 // The __gnu_local_gp is a magic symbol equal to the current value of 'gp' 181 // pointer. This symbol is used in the code generated by .cpload pseudo-op 182 // in case of using -mno-shared option. 183 // https://sourceware.org/ml/binutils/2004-12/msg00094.html 184 if (symtab.find("__gnu_local_gp")) 185 ElfSym::mipsLocalGp = addAbsolute("__gnu_local_gp"); 186 } else if (config->emachine == EM_PPC) { 187 // glibc *crt1.o has a undefined reference to _SDA_BASE_. Since we don't 188 // support Small Data Area, define it arbitrarily as 0. 189 addOptionalRegular("_SDA_BASE_", nullptr, 0, STV_HIDDEN); 190 } else if (config->emachine == EM_PPC64) { 191 addPPC64SaveRestore(); 192 } 193 194 // The Power Architecture 64-bit v2 ABI defines a TableOfContents (TOC) which 195 // combines the typical ELF GOT with the small data sections. It commonly 196 // includes .got .toc .sdata .sbss. The .TOC. symbol replaces both 197 // _GLOBAL_OFFSET_TABLE_ and _SDA_BASE_ from the 32-bit ABI. It is used to 198 // represent the TOC base which is offset by 0x8000 bytes from the start of 199 // the .got section. 200 // We do not allow _GLOBAL_OFFSET_TABLE_ to be defined by input objects as the 201 // correctness of some relocations depends on its value. 202 StringRef gotSymName = 203 (config->emachine == EM_PPC64) ? ".TOC." : "_GLOBAL_OFFSET_TABLE_"; 204 205 if (Symbol *s = symtab.find(gotSymName)) { 206 if (s->isDefined()) { 207 error(toString(s->file) + " cannot redefine linker defined symbol '" + 208 gotSymName + "'"); 209 return; 210 } 211 212 uint64_t gotOff = 0; 213 if (config->emachine == EM_PPC64) 214 gotOff = 0x8000; 215 216 s->resolve(Defined{/*file=*/nullptr, StringRef(), STB_GLOBAL, STV_HIDDEN, 217 STT_NOTYPE, gotOff, /*size=*/0, Out::elfHeader}); 218 ElfSym::globalOffsetTable = cast<Defined>(s); 219 } 220 221 // __ehdr_start is the location of ELF file headers. Note that we define 222 // this symbol unconditionally even when using a linker script, which 223 // differs from the behavior implemented by GNU linker which only define 224 // this symbol if ELF headers are in the memory mapped segment. 225 addOptionalRegular("__ehdr_start", Out::elfHeader, 0, STV_HIDDEN); 226 227 // __executable_start is not documented, but the expectation of at 228 // least the Android libc is that it points to the ELF header. 229 addOptionalRegular("__executable_start", Out::elfHeader, 0, STV_HIDDEN); 230 231 // __dso_handle symbol is passed to cxa_finalize as a marker to identify 232 // each DSO. The address of the symbol doesn't matter as long as they are 233 // different in different DSOs, so we chose the start address of the DSO. 234 addOptionalRegular("__dso_handle", Out::elfHeader, 0, STV_HIDDEN); 235 236 // If linker script do layout we do not need to create any standard symbols. 237 if (script->hasSectionsCommand) 238 return; 239 240 auto add = [](StringRef s, int64_t pos) { 241 return addOptionalRegular(s, Out::elfHeader, pos, STV_DEFAULT); 242 }; 243 244 ElfSym::bss = add("__bss_start", 0); 245 ElfSym::end1 = add("end", -1); 246 ElfSym::end2 = add("_end", -1); 247 ElfSym::etext1 = add("etext", -1); 248 ElfSym::etext2 = add("_etext", -1); 249 ElfSym::edata1 = add("edata", -1); 250 ElfSym::edata2 = add("_edata", -1); 251 } 252 253 static OutputSection *findSection(StringRef name, unsigned partition = 1) { 254 for (SectionCommand *cmd : script->sectionCommands) 255 if (auto *osd = dyn_cast<OutputDesc>(cmd)) 256 if (osd->osec.name == name && osd->osec.partition == partition) 257 return &osd->osec; 258 return nullptr; 259 } 260 261 template <class ELFT> void elf::createSyntheticSections() { 262 // Initialize all pointers with NULL. This is needed because 263 // you can call lld::elf::main more than once as a library. 264 Out::tlsPhdr = nullptr; 265 Out::preinitArray = nullptr; 266 Out::initArray = nullptr; 267 Out::finiArray = nullptr; 268 269 // Add the .interp section first because it is not a SyntheticSection. 270 // The removeUnusedSyntheticSections() function relies on the 271 // SyntheticSections coming last. 272 if (needsInterpSection()) { 273 for (size_t i = 1; i <= partitions.size(); ++i) { 274 InputSection *sec = createInterpSection(); 275 sec->partition = i; 276 ctx.inputSections.push_back(sec); 277 } 278 } 279 280 auto add = [](SyntheticSection &sec) { ctx.inputSections.push_back(&sec); }; 281 282 in.shStrTab = std::make_unique<StringTableSection>(".shstrtab", false); 283 284 Out::programHeaders = make<OutputSection>("", 0, SHF_ALLOC); 285 Out::programHeaders->addralign = config->wordsize; 286 287 if (config->strip != StripPolicy::All) { 288 in.strTab = std::make_unique<StringTableSection>(".strtab", false); 289 in.symTab = std::make_unique<SymbolTableSection<ELFT>>(*in.strTab); 290 in.symTabShndx = std::make_unique<SymtabShndxSection>(); 291 } 292 293 in.bss = std::make_unique<BssSection>(".bss", 0, 1); 294 add(*in.bss); 295 296 // If there is a SECTIONS command and a .data.rel.ro section name use name 297 // .data.rel.ro.bss so that we match in the .data.rel.ro output section. 298 // This makes sure our relro is contiguous. 299 bool hasDataRelRo = script->hasSectionsCommand && findSection(".data.rel.ro"); 300 in.bssRelRo = std::make_unique<BssSection>( 301 hasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1); 302 add(*in.bssRelRo); 303 304 // Add MIPS-specific sections. 305 if (config->emachine == EM_MIPS) { 306 if (!config->shared && config->hasDynSymTab) { 307 in.mipsRldMap = std::make_unique<MipsRldMapSection>(); 308 add(*in.mipsRldMap); 309 } 310 if ((in.mipsAbiFlags = MipsAbiFlagsSection<ELFT>::create())) 311 add(*in.mipsAbiFlags); 312 if ((in.mipsOptions = MipsOptionsSection<ELFT>::create())) 313 add(*in.mipsOptions); 314 if ((in.mipsReginfo = MipsReginfoSection<ELFT>::create())) 315 add(*in.mipsReginfo); 316 } 317 318 StringRef relaDynName = config->isRela ? ".rela.dyn" : ".rel.dyn"; 319 320 const unsigned threadCount = config->threadCount; 321 for (Partition &part : partitions) { 322 auto add = [&](SyntheticSection &sec) { 323 sec.partition = part.getNumber(); 324 ctx.inputSections.push_back(&sec); 325 }; 326 327 if (!part.name.empty()) { 328 part.elfHeader = std::make_unique<PartitionElfHeaderSection<ELFT>>(); 329 part.elfHeader->name = part.name; 330 add(*part.elfHeader); 331 332 part.programHeaders = 333 std::make_unique<PartitionProgramHeadersSection<ELFT>>(); 334 add(*part.programHeaders); 335 } 336 337 if (config->buildId != BuildIdKind::None) { 338 part.buildId = std::make_unique<BuildIdSection>(); 339 add(*part.buildId); 340 } 341 342 part.dynStrTab = std::make_unique<StringTableSection>(".dynstr", true); 343 part.dynSymTab = 344 std::make_unique<SymbolTableSection<ELFT>>(*part.dynStrTab); 345 part.dynamic = std::make_unique<DynamicSection<ELFT>>(); 346 347 if (config->emachine == EM_AARCH64 && 348 config->androidMemtagMode != ELF::NT_MEMTAG_LEVEL_NONE) { 349 part.memtagAndroidNote = std::make_unique<MemtagAndroidNote>(); 350 add(*part.memtagAndroidNote); 351 } 352 353 if (config->androidPackDynRelocs) 354 part.relaDyn = std::make_unique<AndroidPackedRelocationSection<ELFT>>( 355 relaDynName, threadCount); 356 else 357 part.relaDyn = std::make_unique<RelocationSection<ELFT>>( 358 relaDynName, config->zCombreloc, threadCount); 359 360 if (config->hasDynSymTab) { 361 add(*part.dynSymTab); 362 363 part.verSym = std::make_unique<VersionTableSection>(); 364 add(*part.verSym); 365 366 if (!namedVersionDefs().empty()) { 367 part.verDef = std::make_unique<VersionDefinitionSection>(); 368 add(*part.verDef); 369 } 370 371 part.verNeed = std::make_unique<VersionNeedSection<ELFT>>(); 372 add(*part.verNeed); 373 374 if (config->gnuHash) { 375 part.gnuHashTab = std::make_unique<GnuHashTableSection>(); 376 add(*part.gnuHashTab); 377 } 378 379 if (config->sysvHash) { 380 part.hashTab = std::make_unique<HashTableSection>(); 381 add(*part.hashTab); 382 } 383 384 add(*part.dynamic); 385 add(*part.dynStrTab); 386 add(*part.relaDyn); 387 } 388 389 if (config->relrPackDynRelocs) { 390 part.relrDyn = std::make_unique<RelrSection<ELFT>>(threadCount); 391 add(*part.relrDyn); 392 } 393 394 if (!config->relocatable) { 395 if (config->ehFrameHdr) { 396 part.ehFrameHdr = std::make_unique<EhFrameHeader>(); 397 add(*part.ehFrameHdr); 398 } 399 part.ehFrame = std::make_unique<EhFrameSection>(); 400 add(*part.ehFrame); 401 402 if (config->emachine == EM_ARM) { 403 // This section replaces all the individual .ARM.exidx InputSections. 404 part.armExidx = std::make_unique<ARMExidxSyntheticSection>(); 405 add(*part.armExidx); 406 } 407 } 408 409 if (!config->packageMetadata.empty()) { 410 part.packageMetadataNote = std::make_unique<PackageMetadataNote>(); 411 add(*part.packageMetadataNote); 412 } 413 } 414 415 if (partitions.size() != 1) { 416 // Create the partition end marker. This needs to be in partition number 255 417 // so that it is sorted after all other partitions. It also has other 418 // special handling (see createPhdrs() and combineEhSections()). 419 in.partEnd = 420 std::make_unique<BssSection>(".part.end", config->maxPageSize, 1); 421 in.partEnd->partition = 255; 422 add(*in.partEnd); 423 424 in.partIndex = std::make_unique<PartitionIndexSection>(); 425 addOptionalRegular("__part_index_begin", in.partIndex.get(), 0); 426 addOptionalRegular("__part_index_end", in.partIndex.get(), 427 in.partIndex->getSize()); 428 add(*in.partIndex); 429 } 430 431 // Add .got. MIPS' .got is so different from the other archs, 432 // it has its own class. 433 if (config->emachine == EM_MIPS) { 434 in.mipsGot = std::make_unique<MipsGotSection>(); 435 add(*in.mipsGot); 436 } else { 437 in.got = std::make_unique<GotSection>(); 438 add(*in.got); 439 } 440 441 if (config->emachine == EM_PPC) { 442 in.ppc32Got2 = std::make_unique<PPC32Got2Section>(); 443 add(*in.ppc32Got2); 444 } 445 446 if (config->emachine == EM_PPC64) { 447 in.ppc64LongBranchTarget = std::make_unique<PPC64LongBranchTargetSection>(); 448 add(*in.ppc64LongBranchTarget); 449 } 450 451 in.gotPlt = std::make_unique<GotPltSection>(); 452 add(*in.gotPlt); 453 in.igotPlt = std::make_unique<IgotPltSection>(); 454 add(*in.igotPlt); 455 456 // _GLOBAL_OFFSET_TABLE_ is defined relative to either .got.plt or .got. Treat 457 // it as a relocation and ensure the referenced section is created. 458 if (ElfSym::globalOffsetTable && config->emachine != EM_MIPS) { 459 if (target->gotBaseSymInGotPlt) 460 in.gotPlt->hasGotPltOffRel = true; 461 else 462 in.got->hasGotOffRel = true; 463 } 464 465 if (config->gdbIndex) 466 add(*GdbIndexSection::create<ELFT>()); 467 468 // We always need to add rel[a].plt to output if it has entries. 469 // Even for static linking it can contain R_[*]_IRELATIVE relocations. 470 in.relaPlt = std::make_unique<RelocationSection<ELFT>>( 471 config->isRela ? ".rela.plt" : ".rel.plt", /*sort=*/false, 472 /*threadCount=*/1); 473 add(*in.relaPlt); 474 475 // The relaIplt immediately follows .rel[a].dyn to ensure that the IRelative 476 // relocations are processed last by the dynamic loader. We cannot place the 477 // iplt section in .rel.dyn when Android relocation packing is enabled because 478 // that would cause a section type mismatch. However, because the Android 479 // dynamic loader reads .rel.plt after .rel.dyn, we can get the desired 480 // behaviour by placing the iplt section in .rel.plt. 481 in.relaIplt = std::make_unique<RelocationSection<ELFT>>( 482 config->androidPackDynRelocs ? in.relaPlt->name : relaDynName, 483 /*sort=*/false, /*threadCount=*/1); 484 add(*in.relaIplt); 485 486 if ((config->emachine == EM_386 || config->emachine == EM_X86_64) && 487 (config->andFeatures & GNU_PROPERTY_X86_FEATURE_1_IBT)) { 488 in.ibtPlt = std::make_unique<IBTPltSection>(); 489 add(*in.ibtPlt); 490 } 491 492 if (config->emachine == EM_PPC) 493 in.plt = std::make_unique<PPC32GlinkSection>(); 494 else 495 in.plt = std::make_unique<PltSection>(); 496 add(*in.plt); 497 in.iplt = std::make_unique<IpltSection>(); 498 add(*in.iplt); 499 500 if (config->andFeatures) 501 add(*make<GnuPropertySection>()); 502 503 // .note.GNU-stack is always added when we are creating a re-linkable 504 // object file. Other linkers are using the presence of this marker 505 // section to control the executable-ness of the stack area, but that 506 // is irrelevant these days. Stack area should always be non-executable 507 // by default. So we emit this section unconditionally. 508 if (config->relocatable) 509 add(*make<GnuStackSection>()); 510 511 if (in.symTab) 512 add(*in.symTab); 513 if (in.symTabShndx) 514 add(*in.symTabShndx); 515 add(*in.shStrTab); 516 if (in.strTab) 517 add(*in.strTab); 518 } 519 520 // The main function of the writer. 521 template <class ELFT> void Writer<ELFT>::run() { 522 copyLocalSymbols(); 523 524 if (config->copyRelocs) 525 addSectionSymbols(); 526 527 // Now that we have a complete set of output sections. This function 528 // completes section contents. For example, we need to add strings 529 // to the string table, and add entries to .got and .plt. 530 // finalizeSections does that. 531 finalizeSections(); 532 checkExecuteOnly(); 533 534 // If --compressed-debug-sections is specified, compress .debug_* sections. 535 // Do it right now because it changes the size of output sections. 536 for (OutputSection *sec : outputSections) 537 sec->maybeCompress<ELFT>(); 538 539 if (script->hasSectionsCommand) 540 script->allocateHeaders(mainPart->phdrs); 541 542 // Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a 543 // 0 sized region. This has to be done late since only after assignAddresses 544 // we know the size of the sections. 545 for (Partition &part : partitions) 546 removeEmptyPTLoad(part.phdrs); 547 548 if (!config->oFormatBinary) 549 assignFileOffsets(); 550 else 551 assignFileOffsetsBinary(); 552 553 for (Partition &part : partitions) 554 setPhdrs(part); 555 556 // Handle --print-map(-M)/--Map and --cref. Dump them before checkSections() 557 // because the files may be useful in case checkSections() or openFile() 558 // fails, for example, due to an erroneous file size. 559 writeMapAndCref(); 560 561 if (config->checkSections) 562 checkSections(); 563 564 // It does not make sense try to open the file if we have error already. 565 if (errorCount()) 566 return; 567 568 { 569 llvm::TimeTraceScope timeScope("Write output file"); 570 // Write the result down to a file. 571 openFile(); 572 if (errorCount()) 573 return; 574 575 if (!config->oFormatBinary) { 576 if (config->zSeparate != SeparateSegmentKind::None) 577 writeTrapInstr(); 578 writeHeader(); 579 writeSections(); 580 } else { 581 writeSectionsBinary(); 582 } 583 584 // Backfill .note.gnu.build-id section content. This is done at last 585 // because the content is usually a hash value of the entire output file. 586 writeBuildId(); 587 if (errorCount()) 588 return; 589 590 if (auto e = buffer->commit()) 591 fatal("failed to write output '" + buffer->getPath() + 592 "': " + toString(std::move(e))); 593 } 594 } 595 596 template <class ELFT, class RelTy> 597 static void markUsedLocalSymbolsImpl(ObjFile<ELFT> *file, 598 llvm::ArrayRef<RelTy> rels) { 599 for (const RelTy &rel : rels) { 600 Symbol &sym = file->getRelocTargetSym(rel); 601 if (sym.isLocal()) 602 sym.used = true; 603 } 604 } 605 606 // The function ensures that the "used" field of local symbols reflects the fact 607 // that the symbol is used in a relocation from a live section. 608 template <class ELFT> static void markUsedLocalSymbols() { 609 // With --gc-sections, the field is already filled. 610 // See MarkLive<ELFT>::resolveReloc(). 611 if (config->gcSections) 612 return; 613 for (ELFFileBase *file : ctx.objectFiles) { 614 ObjFile<ELFT> *f = cast<ObjFile<ELFT>>(file); 615 for (InputSectionBase *s : f->getSections()) { 616 InputSection *isec = dyn_cast_or_null<InputSection>(s); 617 if (!isec) 618 continue; 619 if (isec->type == SHT_REL) 620 markUsedLocalSymbolsImpl(f, isec->getDataAs<typename ELFT::Rel>()); 621 else if (isec->type == SHT_RELA) 622 markUsedLocalSymbolsImpl(f, isec->getDataAs<typename ELFT::Rela>()); 623 } 624 } 625 } 626 627 static bool shouldKeepInSymtab(const Defined &sym) { 628 if (sym.isSection()) 629 return false; 630 631 // If --emit-reloc or -r is given, preserve symbols referenced by relocations 632 // from live sections. 633 if (sym.used && config->copyRelocs) 634 return true; 635 636 // Exclude local symbols pointing to .ARM.exidx sections. 637 // They are probably mapping symbols "$d", which are optional for these 638 // sections. After merging the .ARM.exidx sections, some of these symbols 639 // may become dangling. The easiest way to avoid the issue is not to add 640 // them to the symbol table from the beginning. 641 if (config->emachine == EM_ARM && sym.section && 642 sym.section->type == SHT_ARM_EXIDX) 643 return false; 644 645 if (config->discard == DiscardPolicy::None) 646 return true; 647 if (config->discard == DiscardPolicy::All) 648 return false; 649 650 // In ELF assembly .L symbols are normally discarded by the assembler. 651 // If the assembler fails to do so, the linker discards them if 652 // * --discard-locals is used. 653 // * The symbol is in a SHF_MERGE section, which is normally the reason for 654 // the assembler keeping the .L symbol. 655 if (sym.getName().startswith(".L") && 656 (config->discard == DiscardPolicy::Locals || 657 (sym.section && (sym.section->flags & SHF_MERGE)))) 658 return false; 659 return true; 660 } 661 662 static bool includeInSymtab(const Symbol &b) { 663 if (auto *d = dyn_cast<Defined>(&b)) { 664 // Always include absolute symbols. 665 SectionBase *sec = d->section; 666 if (!sec) 667 return true; 668 669 if (auto *s = dyn_cast<MergeInputSection>(sec)) 670 return s->getSectionPiece(d->value).live; 671 return sec->isLive(); 672 } 673 return b.used || !config->gcSections; 674 } 675 676 // Local symbols are not in the linker's symbol table. This function scans 677 // each object file's symbol table to copy local symbols to the output. 678 template <class ELFT> void Writer<ELFT>::copyLocalSymbols() { 679 if (!in.symTab) 680 return; 681 llvm::TimeTraceScope timeScope("Add local symbols"); 682 if (config->copyRelocs && config->discard != DiscardPolicy::None) 683 markUsedLocalSymbols<ELFT>(); 684 for (ELFFileBase *file : ctx.objectFiles) { 685 for (Symbol *b : file->getLocalSymbols()) { 686 assert(b->isLocal() && "should have been caught in initializeSymbols()"); 687 auto *dr = dyn_cast<Defined>(b); 688 689 // No reason to keep local undefined symbol in symtab. 690 if (!dr) 691 continue; 692 if (includeInSymtab(*b) && shouldKeepInSymtab(*dr)) 693 in.symTab->addSymbol(b); 694 } 695 } 696 } 697 698 // Create a section symbol for each output section so that we can represent 699 // relocations that point to the section. If we know that no relocation is 700 // referring to a section (that happens if the section is a synthetic one), we 701 // don't create a section symbol for that section. 702 template <class ELFT> void Writer<ELFT>::addSectionSymbols() { 703 for (SectionCommand *cmd : script->sectionCommands) { 704 auto *osd = dyn_cast<OutputDesc>(cmd); 705 if (!osd) 706 continue; 707 OutputSection &osec = osd->osec; 708 InputSectionBase *isec = nullptr; 709 // Iterate over all input sections and add a STT_SECTION symbol if any input 710 // section may be a relocation target. 711 for (SectionCommand *cmd : osec.commands) { 712 auto *isd = dyn_cast<InputSectionDescription>(cmd); 713 if (!isd) 714 continue; 715 for (InputSectionBase *s : isd->sections) { 716 // Relocations are not using REL[A] section symbols. 717 if (s->type == SHT_REL || s->type == SHT_RELA) 718 continue; 719 720 // Unlike other synthetic sections, mergeable output sections contain 721 // data copied from input sections, and there may be a relocation 722 // pointing to its contents if -r or --emit-reloc is given. 723 if (isa<SyntheticSection>(s) && !(s->flags & SHF_MERGE)) 724 continue; 725 726 isec = s; 727 break; 728 } 729 } 730 if (!isec) 731 continue; 732 733 // Set the symbol to be relative to the output section so that its st_value 734 // equals the output section address. Note, there may be a gap between the 735 // start of the output section and isec. 736 in.symTab->addSymbol(makeDefined(isec->file, "", STB_LOCAL, /*stOther=*/0, 737 STT_SECTION, 738 /*value=*/0, /*size=*/0, &osec)); 739 } 740 } 741 742 // Today's loaders have a feature to make segments read-only after 743 // processing dynamic relocations to enhance security. PT_GNU_RELRO 744 // is defined for that. 745 // 746 // This function returns true if a section needs to be put into a 747 // PT_GNU_RELRO segment. 748 static bool isRelroSection(const OutputSection *sec) { 749 if (!config->zRelro) 750 return false; 751 if (sec->relro) 752 return true; 753 754 uint64_t flags = sec->flags; 755 756 // Non-allocatable or non-writable sections don't need RELRO because 757 // they are not writable or not even mapped to memory in the first place. 758 // RELRO is for sections that are essentially read-only but need to 759 // be writable only at process startup to allow dynamic linker to 760 // apply relocations. 761 if (!(flags & SHF_ALLOC) || !(flags & SHF_WRITE)) 762 return false; 763 764 // Once initialized, TLS data segments are used as data templates 765 // for a thread-local storage. For each new thread, runtime 766 // allocates memory for a TLS and copy templates there. No thread 767 // are supposed to use templates directly. Thus, it can be in RELRO. 768 if (flags & SHF_TLS) 769 return true; 770 771 // .init_array, .preinit_array and .fini_array contain pointers to 772 // functions that are executed on process startup or exit. These 773 // pointers are set by the static linker, and they are not expected 774 // to change at runtime. But if you are an attacker, you could do 775 // interesting things by manipulating pointers in .fini_array, for 776 // example. So they are put into RELRO. 777 uint32_t type = sec->type; 778 if (type == SHT_INIT_ARRAY || type == SHT_FINI_ARRAY || 779 type == SHT_PREINIT_ARRAY) 780 return true; 781 782 // .got contains pointers to external symbols. They are resolved by 783 // the dynamic linker when a module is loaded into memory, and after 784 // that they are not expected to change. So, it can be in RELRO. 785 if (in.got && sec == in.got->getParent()) 786 return true; 787 788 // .toc is a GOT-ish section for PowerPC64. Their contents are accessed 789 // through r2 register, which is reserved for that purpose. Since r2 is used 790 // for accessing .got as well, .got and .toc need to be close enough in the 791 // virtual address space. Usually, .toc comes just after .got. Since we place 792 // .got into RELRO, .toc needs to be placed into RELRO too. 793 if (sec->name.equals(".toc")) 794 return true; 795 796 // .got.plt contains pointers to external function symbols. They are 797 // by default resolved lazily, so we usually cannot put it into RELRO. 798 // However, if "-z now" is given, the lazy symbol resolution is 799 // disabled, which enables us to put it into RELRO. 800 if (sec == in.gotPlt->getParent()) 801 return config->zNow; 802 803 // .dynamic section contains data for the dynamic linker, and 804 // there's no need to write to it at runtime, so it's better to put 805 // it into RELRO. 806 if (sec->name == ".dynamic") 807 return true; 808 809 // Sections with some special names are put into RELRO. This is a 810 // bit unfortunate because section names shouldn't be significant in 811 // ELF in spirit. But in reality many linker features depend on 812 // magic section names. 813 StringRef s = sec->name; 814 return s == ".data.rel.ro" || s == ".bss.rel.ro" || s == ".ctors" || 815 s == ".dtors" || s == ".jcr" || s == ".eh_frame" || 816 s == ".fini_array" || s == ".init_array" || 817 s == ".openbsd.randomdata" || s == ".preinit_array"; 818 } 819 820 // We compute a rank for each section. The rank indicates where the 821 // section should be placed in the file. Instead of using simple 822 // numbers (0,1,2...), we use a series of flags. One for each decision 823 // point when placing the section. 824 // Using flags has two key properties: 825 // * It is easy to check if a give branch was taken. 826 // * It is easy two see how similar two ranks are (see getRankProximity). 827 enum RankFlags { 828 RF_NOT_ADDR_SET = 1 << 27, 829 RF_NOT_ALLOC = 1 << 26, 830 RF_PARTITION = 1 << 18, // Partition number (8 bits) 831 RF_NOT_PART_EHDR = 1 << 17, 832 RF_NOT_PART_PHDR = 1 << 16, 833 RF_NOT_INTERP = 1 << 15, 834 RF_NOT_NOTE = 1 << 14, 835 RF_WRITE = 1 << 13, 836 RF_EXEC_WRITE = 1 << 12, 837 RF_EXEC = 1 << 11, 838 RF_RODATA = 1 << 10, 839 RF_NOT_RELRO = 1 << 9, 840 RF_NOT_TLS = 1 << 8, 841 RF_BSS = 1 << 7, 842 RF_PPC_NOT_TOCBSS = 1 << 6, 843 RF_PPC_TOCL = 1 << 5, 844 RF_PPC_TOC = 1 << 4, 845 RF_PPC_GOT = 1 << 3, 846 RF_PPC_BRANCH_LT = 1 << 2, 847 RF_MIPS_GPREL = 1 << 1, 848 RF_MIPS_NOT_GOT = 1 << 0 849 }; 850 851 static unsigned getSectionRank(const OutputSection &osec) { 852 unsigned rank = osec.partition * RF_PARTITION; 853 854 // We want to put section specified by -T option first, so we 855 // can start assigning VA starting from them later. 856 if (config->sectionStartMap.count(osec.name)) 857 return rank; 858 rank |= RF_NOT_ADDR_SET; 859 860 // Allocatable sections go first to reduce the total PT_LOAD size and 861 // so debug info doesn't change addresses in actual code. 862 if (!(osec.flags & SHF_ALLOC)) 863 return rank | RF_NOT_ALLOC; 864 865 if (osec.type == SHT_LLVM_PART_EHDR) 866 return rank; 867 rank |= RF_NOT_PART_EHDR; 868 869 if (osec.type == SHT_LLVM_PART_PHDR) 870 return rank; 871 rank |= RF_NOT_PART_PHDR; 872 873 // Put .interp first because some loaders want to see that section 874 // on the first page of the executable file when loaded into memory. 875 if (osec.name == ".interp") 876 return rank; 877 rank |= RF_NOT_INTERP; 878 879 // Put .note sections (which make up one PT_NOTE) at the beginning so that 880 // they are likely to be included in a core file even if core file size is 881 // limited. In particular, we want a .note.gnu.build-id and a .note.tag to be 882 // included in a core to match core files with executables. 883 if (osec.type == SHT_NOTE) 884 return rank; 885 rank |= RF_NOT_NOTE; 886 887 // Sort sections based on their access permission in the following 888 // order: R, RX, RWX, RW. This order is based on the following 889 // considerations: 890 // * Read-only sections come first such that they go in the 891 // PT_LOAD covering the program headers at the start of the file. 892 // * Read-only, executable sections come next. 893 // * Writable, executable sections follow such that .plt on 894 // architectures where it needs to be writable will be placed 895 // between .text and .data. 896 // * Writable sections come last, such that .bss lands at the very 897 // end of the last PT_LOAD. 898 bool isExec = osec.flags & SHF_EXECINSTR; 899 bool isWrite = osec.flags & SHF_WRITE; 900 901 if (isExec) { 902 if (isWrite) 903 rank |= RF_EXEC_WRITE; 904 else 905 rank |= RF_EXEC; 906 } else if (isWrite) { 907 rank |= RF_WRITE; 908 } else if (osec.type == SHT_PROGBITS) { 909 // Make non-executable and non-writable PROGBITS sections (e.g .rodata 910 // .eh_frame) closer to .text. They likely contain PC or GOT relative 911 // relocations and there could be relocation overflow if other huge sections 912 // (.dynstr .dynsym) were placed in between. 913 rank |= RF_RODATA; 914 } 915 916 // Place RelRo sections first. After considering SHT_NOBITS below, the 917 // ordering is PT_LOAD(PT_GNU_RELRO(.data.rel.ro .bss.rel.ro) | .data .bss), 918 // where | marks where page alignment happens. An alternative ordering is 919 // PT_LOAD(.data | PT_GNU_RELRO( .data.rel.ro .bss.rel.ro) | .bss), but it may 920 // waste more bytes due to 2 alignment places. 921 if (!isRelroSection(&osec)) 922 rank |= RF_NOT_RELRO; 923 924 // If we got here we know that both A and B are in the same PT_LOAD. 925 926 // The TLS initialization block needs to be a single contiguous block in a R/W 927 // PT_LOAD, so stick TLS sections directly before the other RelRo R/W 928 // sections. Since p_filesz can be less than p_memsz, place NOBITS sections 929 // after PROGBITS. 930 if (!(osec.flags & SHF_TLS)) 931 rank |= RF_NOT_TLS; 932 933 // Within TLS sections, or within other RelRo sections, or within non-RelRo 934 // sections, place non-NOBITS sections first. 935 if (osec.type == SHT_NOBITS) 936 rank |= RF_BSS; 937 938 // Some architectures have additional ordering restrictions for sections 939 // within the same PT_LOAD. 940 if (config->emachine == EM_PPC64) { 941 // PPC64 has a number of special SHT_PROGBITS+SHF_ALLOC+SHF_WRITE sections 942 // that we would like to make sure appear is a specific order to maximize 943 // their coverage by a single signed 16-bit offset from the TOC base 944 // pointer. Conversely, the special .tocbss section should be first among 945 // all SHT_NOBITS sections. This will put it next to the loaded special 946 // PPC64 sections (and, thus, within reach of the TOC base pointer). 947 StringRef name = osec.name; 948 if (name != ".tocbss") 949 rank |= RF_PPC_NOT_TOCBSS; 950 951 if (name == ".toc1") 952 rank |= RF_PPC_TOCL; 953 954 if (name == ".toc") 955 rank |= RF_PPC_TOC; 956 957 if (name == ".got") 958 rank |= RF_PPC_GOT; 959 960 if (name == ".branch_lt") 961 rank |= RF_PPC_BRANCH_LT; 962 } 963 964 if (config->emachine == EM_MIPS) { 965 // All sections with SHF_MIPS_GPREL flag should be grouped together 966 // because data in these sections is addressable with a gp relative address. 967 if (osec.flags & SHF_MIPS_GPREL) 968 rank |= RF_MIPS_GPREL; 969 970 if (osec.name != ".got") 971 rank |= RF_MIPS_NOT_GOT; 972 } 973 974 return rank; 975 } 976 977 static bool compareSections(const SectionCommand *aCmd, 978 const SectionCommand *bCmd) { 979 const OutputSection *a = &cast<OutputDesc>(aCmd)->osec; 980 const OutputSection *b = &cast<OutputDesc>(bCmd)->osec; 981 982 if (a->sortRank != b->sortRank) 983 return a->sortRank < b->sortRank; 984 985 if (!(a->sortRank & RF_NOT_ADDR_SET)) 986 return config->sectionStartMap.lookup(a->name) < 987 config->sectionStartMap.lookup(b->name); 988 return false; 989 } 990 991 void PhdrEntry::add(OutputSection *sec) { 992 lastSec = sec; 993 if (!firstSec) 994 firstSec = sec; 995 p_align = std::max(p_align, sec->addralign); 996 if (p_type == PT_LOAD) 997 sec->ptLoad = this; 998 } 999 1000 // The beginning and the ending of .rel[a].plt section are marked 1001 // with __rel[a]_iplt_{start,end} symbols if it is a statically linked 1002 // executable. The runtime needs these symbols in order to resolve 1003 // all IRELATIVE relocs on startup. For dynamic executables, we don't 1004 // need these symbols, since IRELATIVE relocs are resolved through GOT 1005 // and PLT. For details, see http://www.airs.com/blog/archives/403. 1006 template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() { 1007 if (config->isPic) 1008 return; 1009 1010 // By default, __rela_iplt_{start,end} belong to a dummy section 0 1011 // because .rela.plt might be empty and thus removed from output. 1012 // We'll override Out::elfHeader with In.relaIplt later when we are 1013 // sure that .rela.plt exists in output. 1014 ElfSym::relaIpltStart = addOptionalRegular( 1015 config->isRela ? "__rela_iplt_start" : "__rel_iplt_start", 1016 Out::elfHeader, 0, STV_HIDDEN); 1017 1018 ElfSym::relaIpltEnd = addOptionalRegular( 1019 config->isRela ? "__rela_iplt_end" : "__rel_iplt_end", 1020 Out::elfHeader, 0, STV_HIDDEN); 1021 } 1022 1023 // This function generates assignments for predefined symbols (e.g. _end or 1024 // _etext) and inserts them into the commands sequence to be processed at the 1025 // appropriate time. This ensures that the value is going to be correct by the 1026 // time any references to these symbols are processed and is equivalent to 1027 // defining these symbols explicitly in the linker script. 1028 template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() { 1029 if (ElfSym::globalOffsetTable) { 1030 // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention usually 1031 // to the start of the .got or .got.plt section. 1032 InputSection *sec = in.gotPlt.get(); 1033 if (!target->gotBaseSymInGotPlt) 1034 sec = in.mipsGot ? cast<InputSection>(in.mipsGot.get()) 1035 : cast<InputSection>(in.got.get()); 1036 ElfSym::globalOffsetTable->section = sec; 1037 } 1038 1039 // .rela_iplt_{start,end} mark the start and the end of in.relaIplt. 1040 if (ElfSym::relaIpltStart && in.relaIplt->isNeeded()) { 1041 ElfSym::relaIpltStart->section = in.relaIplt.get(); 1042 ElfSym::relaIpltEnd->section = in.relaIplt.get(); 1043 ElfSym::relaIpltEnd->value = in.relaIplt->getSize(); 1044 } 1045 1046 PhdrEntry *last = nullptr; 1047 PhdrEntry *lastRO = nullptr; 1048 1049 for (Partition &part : partitions) { 1050 for (PhdrEntry *p : part.phdrs) { 1051 if (p->p_type != PT_LOAD) 1052 continue; 1053 last = p; 1054 if (!(p->p_flags & PF_W)) 1055 lastRO = p; 1056 } 1057 } 1058 1059 if (lastRO) { 1060 // _etext is the first location after the last read-only loadable segment. 1061 if (ElfSym::etext1) 1062 ElfSym::etext1->section = lastRO->lastSec; 1063 if (ElfSym::etext2) 1064 ElfSym::etext2->section = lastRO->lastSec; 1065 } 1066 1067 if (last) { 1068 // _edata points to the end of the last mapped initialized section. 1069 OutputSection *edata = nullptr; 1070 for (OutputSection *os : outputSections) { 1071 if (os->type != SHT_NOBITS) 1072 edata = os; 1073 if (os == last->lastSec) 1074 break; 1075 } 1076 1077 if (ElfSym::edata1) 1078 ElfSym::edata1->section = edata; 1079 if (ElfSym::edata2) 1080 ElfSym::edata2->section = edata; 1081 1082 // _end is the first location after the uninitialized data region. 1083 if (ElfSym::end1) 1084 ElfSym::end1->section = last->lastSec; 1085 if (ElfSym::end2) 1086 ElfSym::end2->section = last->lastSec; 1087 } 1088 1089 if (ElfSym::bss) 1090 ElfSym::bss->section = findSection(".bss"); 1091 1092 // Setup MIPS _gp_disp/__gnu_local_gp symbols which should 1093 // be equal to the _gp symbol's value. 1094 if (ElfSym::mipsGp) { 1095 // Find GP-relative section with the lowest address 1096 // and use this address to calculate default _gp value. 1097 for (OutputSection *os : outputSections) { 1098 if (os->flags & SHF_MIPS_GPREL) { 1099 ElfSym::mipsGp->section = os; 1100 ElfSym::mipsGp->value = 0x7ff0; 1101 break; 1102 } 1103 } 1104 } 1105 } 1106 1107 // We want to find how similar two ranks are. 1108 // The more branches in getSectionRank that match, the more similar they are. 1109 // Since each branch corresponds to a bit flag, we can just use 1110 // countLeadingZeros. 1111 static int getRankProximity(OutputSection *a, SectionCommand *b) { 1112 auto *osd = dyn_cast<OutputDesc>(b); 1113 return (osd && osd->osec.hasInputSections) 1114 ? countLeadingZeros(a->sortRank ^ osd->osec.sortRank) 1115 : -1; 1116 } 1117 1118 // When placing orphan sections, we want to place them after symbol assignments 1119 // so that an orphan after 1120 // begin_foo = .; 1121 // foo : { *(foo) } 1122 // end_foo = .; 1123 // doesn't break the intended meaning of the begin/end symbols. 1124 // We don't want to go over sections since findOrphanPos is the 1125 // one in charge of deciding the order of the sections. 1126 // We don't want to go over changes to '.', since doing so in 1127 // rx_sec : { *(rx_sec) } 1128 // . = ALIGN(0x1000); 1129 // /* The RW PT_LOAD starts here*/ 1130 // rw_sec : { *(rw_sec) } 1131 // would mean that the RW PT_LOAD would become unaligned. 1132 static bool shouldSkip(SectionCommand *cmd) { 1133 if (auto *assign = dyn_cast<SymbolAssignment>(cmd)) 1134 return assign->name != "."; 1135 return false; 1136 } 1137 1138 // We want to place orphan sections so that they share as much 1139 // characteristics with their neighbors as possible. For example, if 1140 // both are rw, or both are tls. 1141 static SmallVectorImpl<SectionCommand *>::iterator 1142 findOrphanPos(SmallVectorImpl<SectionCommand *>::iterator b, 1143 SmallVectorImpl<SectionCommand *>::iterator e) { 1144 OutputSection *sec = &cast<OutputDesc>(*e)->osec; 1145 1146 // Find the first element that has as close a rank as possible. 1147 auto i = std::max_element(b, e, [=](SectionCommand *a, SectionCommand *b) { 1148 return getRankProximity(sec, a) < getRankProximity(sec, b); 1149 }); 1150 if (i == e) 1151 return e; 1152 if (!isa<OutputDesc>(*i)) 1153 return e; 1154 auto foundSec = &cast<OutputDesc>(*i)->osec; 1155 1156 // Consider all existing sections with the same proximity. 1157 int proximity = getRankProximity(sec, *i); 1158 unsigned sortRank = sec->sortRank; 1159 if (script->hasPhdrsCommands() || !script->memoryRegions.empty()) 1160 // Prevent the orphan section to be placed before the found section. If 1161 // custom program headers are defined, that helps to avoid adding it to a 1162 // previous segment and changing flags of that segment, for example, making 1163 // a read-only segment writable. If memory regions are defined, an orphan 1164 // section should continue the same region as the found section to better 1165 // resemble the behavior of GNU ld. 1166 sortRank = std::max(sortRank, foundSec->sortRank); 1167 for (; i != e; ++i) { 1168 auto *curSecDesc = dyn_cast<OutputDesc>(*i); 1169 if (!curSecDesc || !curSecDesc->osec.hasInputSections) 1170 continue; 1171 if (getRankProximity(sec, curSecDesc) != proximity || 1172 sortRank < curSecDesc->osec.sortRank) 1173 break; 1174 } 1175 1176 auto isOutputSecWithInputSections = [](SectionCommand *cmd) { 1177 auto *osd = dyn_cast<OutputDesc>(cmd); 1178 return osd && osd->osec.hasInputSections; 1179 }; 1180 auto j = 1181 std::find_if(std::make_reverse_iterator(i), std::make_reverse_iterator(b), 1182 isOutputSecWithInputSections); 1183 i = j.base(); 1184 1185 // As a special case, if the orphan section is the last section, put 1186 // it at the very end, past any other commands. 1187 // This matches bfd's behavior and is convenient when the linker script fully 1188 // specifies the start of the file, but doesn't care about the end (the non 1189 // alloc sections for example). 1190 auto nextSec = std::find_if(i, e, isOutputSecWithInputSections); 1191 if (nextSec == e) 1192 return e; 1193 1194 while (i != e && shouldSkip(*i)) 1195 ++i; 1196 return i; 1197 } 1198 1199 // Adds random priorities to sections not already in the map. 1200 static void maybeShuffle(DenseMap<const InputSectionBase *, int> &order) { 1201 if (config->shuffleSections.empty()) 1202 return; 1203 1204 SmallVector<InputSectionBase *, 0> matched, sections = ctx.inputSections; 1205 matched.reserve(sections.size()); 1206 for (const auto &patAndSeed : config->shuffleSections) { 1207 matched.clear(); 1208 for (InputSectionBase *sec : sections) 1209 if (patAndSeed.first.match(sec->name)) 1210 matched.push_back(sec); 1211 const uint32_t seed = patAndSeed.second; 1212 if (seed == UINT32_MAX) { 1213 // If --shuffle-sections <section-glob>=-1, reverse the section order. The 1214 // section order is stable even if the number of sections changes. This is 1215 // useful to catch issues like static initialization order fiasco 1216 // reliably. 1217 std::reverse(matched.begin(), matched.end()); 1218 } else { 1219 std::mt19937 g(seed ? seed : std::random_device()()); 1220 llvm::shuffle(matched.begin(), matched.end(), g); 1221 } 1222 size_t i = 0; 1223 for (InputSectionBase *&sec : sections) 1224 if (patAndSeed.first.match(sec->name)) 1225 sec = matched[i++]; 1226 } 1227 1228 // Existing priorities are < 0, so use priorities >= 0 for the missing 1229 // sections. 1230 int prio = 0; 1231 for (InputSectionBase *sec : sections) { 1232 if (order.try_emplace(sec, prio).second) 1233 ++prio; 1234 } 1235 } 1236 1237 // Builds section order for handling --symbol-ordering-file. 1238 static DenseMap<const InputSectionBase *, int> buildSectionOrder() { 1239 DenseMap<const InputSectionBase *, int> sectionOrder; 1240 // Use the rarely used option --call-graph-ordering-file to sort sections. 1241 if (!config->callGraphProfile.empty()) 1242 return computeCallGraphProfileOrder(); 1243 1244 if (config->symbolOrderingFile.empty()) 1245 return sectionOrder; 1246 1247 struct SymbolOrderEntry { 1248 int priority; 1249 bool present; 1250 }; 1251 1252 // Build a map from symbols to their priorities. Symbols that didn't 1253 // appear in the symbol ordering file have the lowest priority 0. 1254 // All explicitly mentioned symbols have negative (higher) priorities. 1255 DenseMap<CachedHashStringRef, SymbolOrderEntry> symbolOrder; 1256 int priority = -config->symbolOrderingFile.size(); 1257 for (StringRef s : config->symbolOrderingFile) 1258 symbolOrder.insert({CachedHashStringRef(s), {priority++, false}}); 1259 1260 // Build a map from sections to their priorities. 1261 auto addSym = [&](Symbol &sym) { 1262 auto it = symbolOrder.find(CachedHashStringRef(sym.getName())); 1263 if (it == symbolOrder.end()) 1264 return; 1265 SymbolOrderEntry &ent = it->second; 1266 ent.present = true; 1267 1268 maybeWarnUnorderableSymbol(&sym); 1269 1270 if (auto *d = dyn_cast<Defined>(&sym)) { 1271 if (auto *sec = dyn_cast_or_null<InputSectionBase>(d->section)) { 1272 int &priority = sectionOrder[cast<InputSectionBase>(sec)]; 1273 priority = std::min(priority, ent.priority); 1274 } 1275 } 1276 }; 1277 1278 // We want both global and local symbols. We get the global ones from the 1279 // symbol table and iterate the object files for the local ones. 1280 for (Symbol *sym : symtab.getSymbols()) 1281 addSym(*sym); 1282 1283 for (ELFFileBase *file : ctx.objectFiles) 1284 for (Symbol *sym : file->getLocalSymbols()) 1285 addSym(*sym); 1286 1287 if (config->warnSymbolOrdering) 1288 for (auto orderEntry : symbolOrder) 1289 if (!orderEntry.second.present) 1290 warn("symbol ordering file: no such symbol: " + orderEntry.first.val()); 1291 1292 return sectionOrder; 1293 } 1294 1295 // Sorts the sections in ISD according to the provided section order. 1296 static void 1297 sortISDBySectionOrder(InputSectionDescription *isd, 1298 const DenseMap<const InputSectionBase *, int> &order, 1299 bool executableOutputSection) { 1300 SmallVector<InputSection *, 0> unorderedSections; 1301 SmallVector<std::pair<InputSection *, int>, 0> orderedSections; 1302 uint64_t unorderedSize = 0; 1303 uint64_t totalSize = 0; 1304 1305 for (InputSection *isec : isd->sections) { 1306 if (executableOutputSection) 1307 totalSize += isec->getSize(); 1308 auto i = order.find(isec); 1309 if (i == order.end()) { 1310 unorderedSections.push_back(isec); 1311 unorderedSize += isec->getSize(); 1312 continue; 1313 } 1314 orderedSections.push_back({isec, i->second}); 1315 } 1316 llvm::sort(orderedSections, llvm::less_second()); 1317 1318 // Find an insertion point for the ordered section list in the unordered 1319 // section list. On targets with limited-range branches, this is the mid-point 1320 // of the unordered section list. This decreases the likelihood that a range 1321 // extension thunk will be needed to enter or exit the ordered region. If the 1322 // ordered section list is a list of hot functions, we can generally expect 1323 // the ordered functions to be called more often than the unordered functions, 1324 // making it more likely that any particular call will be within range, and 1325 // therefore reducing the number of thunks required. 1326 // 1327 // For example, imagine that you have 8MB of hot code and 32MB of cold code. 1328 // If the layout is: 1329 // 1330 // 8MB hot 1331 // 32MB cold 1332 // 1333 // only the first 8-16MB of the cold code (depending on which hot function it 1334 // is actually calling) can call the hot code without a range extension thunk. 1335 // However, if we use this layout: 1336 // 1337 // 16MB cold 1338 // 8MB hot 1339 // 16MB cold 1340 // 1341 // both the last 8-16MB of the first block of cold code and the first 8-16MB 1342 // of the second block of cold code can call the hot code without a thunk. So 1343 // we effectively double the amount of code that could potentially call into 1344 // the hot code without a thunk. 1345 // 1346 // The above is not necessary if total size of input sections in this "isd" 1347 // is small. Note that we assume all input sections are executable if the 1348 // output section is executable (which is not always true but supposed to 1349 // cover most cases). 1350 size_t insPt = 0; 1351 if (executableOutputSection && !orderedSections.empty() && 1352 target->getThunkSectionSpacing() && 1353 totalSize >= target->getThunkSectionSpacing()) { 1354 uint64_t unorderedPos = 0; 1355 for (; insPt != unorderedSections.size(); ++insPt) { 1356 unorderedPos += unorderedSections[insPt]->getSize(); 1357 if (unorderedPos > unorderedSize / 2) 1358 break; 1359 } 1360 } 1361 1362 isd->sections.clear(); 1363 for (InputSection *isec : ArrayRef(unorderedSections).slice(0, insPt)) 1364 isd->sections.push_back(isec); 1365 for (std::pair<InputSection *, int> p : orderedSections) 1366 isd->sections.push_back(p.first); 1367 for (InputSection *isec : ArrayRef(unorderedSections).slice(insPt)) 1368 isd->sections.push_back(isec); 1369 } 1370 1371 static void sortSection(OutputSection &osec, 1372 const DenseMap<const InputSectionBase *, int> &order) { 1373 StringRef name = osec.name; 1374 1375 // Never sort these. 1376 if (name == ".init" || name == ".fini") 1377 return; 1378 1379 // IRelative relocations that usually live in the .rel[a].dyn section should 1380 // be processed last by the dynamic loader. To achieve that we add synthetic 1381 // sections in the required order from the beginning so that the in.relaIplt 1382 // section is placed last in an output section. Here we just do not apply 1383 // sorting for an output section which holds the in.relaIplt section. 1384 if (in.relaIplt->getParent() == &osec) 1385 return; 1386 1387 // Sort input sections by priority using the list provided by 1388 // --symbol-ordering-file or --shuffle-sections=. This is a least significant 1389 // digit radix sort. The sections may be sorted stably again by a more 1390 // significant key. 1391 if (!order.empty()) 1392 for (SectionCommand *b : osec.commands) 1393 if (auto *isd = dyn_cast<InputSectionDescription>(b)) 1394 sortISDBySectionOrder(isd, order, osec.flags & SHF_EXECINSTR); 1395 1396 if (script->hasSectionsCommand) 1397 return; 1398 1399 if (name == ".init_array" || name == ".fini_array") { 1400 osec.sortInitFini(); 1401 } else if (name == ".ctors" || name == ".dtors") { 1402 osec.sortCtorsDtors(); 1403 } else if (config->emachine == EM_PPC64 && name == ".toc") { 1404 // .toc is allocated just after .got and is accessed using GOT-relative 1405 // relocations. Object files compiled with small code model have an 1406 // addressable range of [.got, .got + 0xFFFC] for GOT-relative relocations. 1407 // To reduce the risk of relocation overflow, .toc contents are sorted so 1408 // that sections having smaller relocation offsets are at beginning of .toc 1409 assert(osec.commands.size() == 1); 1410 auto *isd = cast<InputSectionDescription>(osec.commands[0]); 1411 llvm::stable_sort(isd->sections, 1412 [](const InputSection *a, const InputSection *b) -> bool { 1413 return a->file->ppc64SmallCodeModelTocRelocs && 1414 !b->file->ppc64SmallCodeModelTocRelocs; 1415 }); 1416 } 1417 } 1418 1419 // If no layout was provided by linker script, we want to apply default 1420 // sorting for special input sections. This also handles --symbol-ordering-file. 1421 template <class ELFT> void Writer<ELFT>::sortInputSections() { 1422 // Build the order once since it is expensive. 1423 DenseMap<const InputSectionBase *, int> order = buildSectionOrder(); 1424 maybeShuffle(order); 1425 for (SectionCommand *cmd : script->sectionCommands) 1426 if (auto *osd = dyn_cast<OutputDesc>(cmd)) 1427 sortSection(osd->osec, order); 1428 } 1429 1430 template <class ELFT> void Writer<ELFT>::sortSections() { 1431 llvm::TimeTraceScope timeScope("Sort sections"); 1432 1433 // Don't sort if using -r. It is not necessary and we want to preserve the 1434 // relative order for SHF_LINK_ORDER sections. 1435 if (config->relocatable) { 1436 script->adjustOutputSections(); 1437 return; 1438 } 1439 1440 sortInputSections(); 1441 1442 for (SectionCommand *cmd : script->sectionCommands) 1443 if (auto *osd = dyn_cast<OutputDesc>(cmd)) 1444 osd->osec.sortRank = getSectionRank(osd->osec); 1445 if (!script->hasSectionsCommand) { 1446 // We know that all the OutputSections are contiguous in this case. 1447 auto isSection = [](SectionCommand *cmd) { return isa<OutputDesc>(cmd); }; 1448 std::stable_sort( 1449 llvm::find_if(script->sectionCommands, isSection), 1450 llvm::find_if(llvm::reverse(script->sectionCommands), isSection).base(), 1451 compareSections); 1452 } 1453 1454 // Process INSERT commands and update output section attributes. From this 1455 // point onwards the order of script->sectionCommands is fixed. 1456 script->processInsertCommands(); 1457 script->adjustOutputSections(); 1458 1459 if (!script->hasSectionsCommand) 1460 return; 1461 1462 // Orphan sections are sections present in the input files which are 1463 // not explicitly placed into the output file by the linker script. 1464 // 1465 // The sections in the linker script are already in the correct 1466 // order. We have to figuere out where to insert the orphan 1467 // sections. 1468 // 1469 // The order of the sections in the script is arbitrary and may not agree with 1470 // compareSections. This means that we cannot easily define a strict weak 1471 // ordering. To see why, consider a comparison of a section in the script and 1472 // one not in the script. We have a two simple options: 1473 // * Make them equivalent (a is not less than b, and b is not less than a). 1474 // The problem is then that equivalence has to be transitive and we can 1475 // have sections a, b and c with only b in a script and a less than c 1476 // which breaks this property. 1477 // * Use compareSectionsNonScript. Given that the script order doesn't have 1478 // to match, we can end up with sections a, b, c, d where b and c are in the 1479 // script and c is compareSectionsNonScript less than b. In which case d 1480 // can be equivalent to c, a to b and d < a. As a concrete example: 1481 // .a (rx) # not in script 1482 // .b (rx) # in script 1483 // .c (ro) # in script 1484 // .d (ro) # not in script 1485 // 1486 // The way we define an order then is: 1487 // * Sort only the orphan sections. They are in the end right now. 1488 // * Move each orphan section to its preferred position. We try 1489 // to put each section in the last position where it can share 1490 // a PT_LOAD. 1491 // 1492 // There is some ambiguity as to where exactly a new entry should be 1493 // inserted, because Commands contains not only output section 1494 // commands but also other types of commands such as symbol assignment 1495 // expressions. There's no correct answer here due to the lack of the 1496 // formal specification of the linker script. We use heuristics to 1497 // determine whether a new output command should be added before or 1498 // after another commands. For the details, look at shouldSkip 1499 // function. 1500 1501 auto i = script->sectionCommands.begin(); 1502 auto e = script->sectionCommands.end(); 1503 auto nonScriptI = std::find_if(i, e, [](SectionCommand *cmd) { 1504 if (auto *osd = dyn_cast<OutputDesc>(cmd)) 1505 return osd->osec.sectionIndex == UINT32_MAX; 1506 return false; 1507 }); 1508 1509 // Sort the orphan sections. 1510 std::stable_sort(nonScriptI, e, compareSections); 1511 1512 // As a horrible special case, skip the first . assignment if it is before any 1513 // section. We do this because it is common to set a load address by starting 1514 // the script with ". = 0xabcd" and the expectation is that every section is 1515 // after that. 1516 auto firstSectionOrDotAssignment = 1517 std::find_if(i, e, [](SectionCommand *cmd) { return !shouldSkip(cmd); }); 1518 if (firstSectionOrDotAssignment != e && 1519 isa<SymbolAssignment>(**firstSectionOrDotAssignment)) 1520 ++firstSectionOrDotAssignment; 1521 i = firstSectionOrDotAssignment; 1522 1523 while (nonScriptI != e) { 1524 auto pos = findOrphanPos(i, nonScriptI); 1525 OutputSection *orphan = &cast<OutputDesc>(*nonScriptI)->osec; 1526 1527 // As an optimization, find all sections with the same sort rank 1528 // and insert them with one rotate. 1529 unsigned rank = orphan->sortRank; 1530 auto end = std::find_if(nonScriptI + 1, e, [=](SectionCommand *cmd) { 1531 return cast<OutputDesc>(cmd)->osec.sortRank != rank; 1532 }); 1533 std::rotate(pos, nonScriptI, end); 1534 nonScriptI = end; 1535 } 1536 1537 script->adjustSectionsAfterSorting(); 1538 } 1539 1540 static bool compareByFilePosition(InputSection *a, InputSection *b) { 1541 InputSection *la = a->flags & SHF_LINK_ORDER ? a->getLinkOrderDep() : nullptr; 1542 InputSection *lb = b->flags & SHF_LINK_ORDER ? b->getLinkOrderDep() : nullptr; 1543 // SHF_LINK_ORDER sections with non-zero sh_link are ordered before 1544 // non-SHF_LINK_ORDER sections and SHF_LINK_ORDER sections with zero sh_link. 1545 if (!la || !lb) 1546 return la && !lb; 1547 OutputSection *aOut = la->getParent(); 1548 OutputSection *bOut = lb->getParent(); 1549 1550 if (aOut != bOut) 1551 return aOut->addr < bOut->addr; 1552 return la->outSecOff < lb->outSecOff; 1553 } 1554 1555 template <class ELFT> void Writer<ELFT>::resolveShfLinkOrder() { 1556 llvm::TimeTraceScope timeScope("Resolve SHF_LINK_ORDER"); 1557 for (OutputSection *sec : outputSections) { 1558 if (!(sec->flags & SHF_LINK_ORDER)) 1559 continue; 1560 1561 // The ARM.exidx section use SHF_LINK_ORDER, but we have consolidated 1562 // this processing inside the ARMExidxsyntheticsection::finalizeContents(). 1563 if (!config->relocatable && config->emachine == EM_ARM && 1564 sec->type == SHT_ARM_EXIDX) 1565 continue; 1566 1567 // Link order may be distributed across several InputSectionDescriptions. 1568 // Sorting is performed separately. 1569 SmallVector<InputSection **, 0> scriptSections; 1570 SmallVector<InputSection *, 0> sections; 1571 for (SectionCommand *cmd : sec->commands) { 1572 auto *isd = dyn_cast<InputSectionDescription>(cmd); 1573 if (!isd) 1574 continue; 1575 bool hasLinkOrder = false; 1576 scriptSections.clear(); 1577 sections.clear(); 1578 for (InputSection *&isec : isd->sections) { 1579 if (isec->flags & SHF_LINK_ORDER) { 1580 InputSection *link = isec->getLinkOrderDep(); 1581 if (link && !link->getParent()) 1582 error(toString(isec) + ": sh_link points to discarded section " + 1583 toString(link)); 1584 hasLinkOrder = true; 1585 } 1586 scriptSections.push_back(&isec); 1587 sections.push_back(isec); 1588 } 1589 if (hasLinkOrder && errorCount() == 0) { 1590 llvm::stable_sort(sections, compareByFilePosition); 1591 for (int i = 0, n = sections.size(); i != n; ++i) 1592 *scriptSections[i] = sections[i]; 1593 } 1594 } 1595 } 1596 } 1597 1598 static void finalizeSynthetic(SyntheticSection *sec) { 1599 if (sec && sec->isNeeded() && sec->getParent()) { 1600 llvm::TimeTraceScope timeScope("Finalize synthetic sections", sec->name); 1601 sec->finalizeContents(); 1602 } 1603 } 1604 1605 // We need to generate and finalize the content that depends on the address of 1606 // InputSections. As the generation of the content may also alter InputSection 1607 // addresses we must converge to a fixed point. We do that here. See the comment 1608 // in Writer<ELFT>::finalizeSections(). 1609 template <class ELFT> void Writer<ELFT>::finalizeAddressDependentContent() { 1610 llvm::TimeTraceScope timeScope("Finalize address dependent content"); 1611 ThunkCreator tc; 1612 AArch64Err843419Patcher a64p; 1613 ARMErr657417Patcher a32p; 1614 script->assignAddresses(); 1615 // .ARM.exidx and SHF_LINK_ORDER do not require precise addresses, but they 1616 // do require the relative addresses of OutputSections because linker scripts 1617 // can assign Virtual Addresses to OutputSections that are not monotonically 1618 // increasing. 1619 for (Partition &part : partitions) 1620 finalizeSynthetic(part.armExidx.get()); 1621 resolveShfLinkOrder(); 1622 1623 // Converts call x@GDPLT to call __tls_get_addr 1624 if (config->emachine == EM_HEXAGON) 1625 hexagonTLSSymbolUpdate(outputSections); 1626 1627 uint32_t pass = 0, assignPasses = 0; 1628 for (;;) { 1629 bool changed = target->needsThunks ? tc.createThunks(pass, outputSections) 1630 : target->relaxOnce(pass); 1631 ++pass; 1632 1633 // With Thunk Size much smaller than branch range we expect to 1634 // converge quickly; if we get to 15 something has gone wrong. 1635 if (changed && pass >= 15) { 1636 error(target->needsThunks ? "thunk creation not converged" 1637 : "relaxation not converged"); 1638 break; 1639 } 1640 1641 if (config->fixCortexA53Errata843419) { 1642 if (changed) 1643 script->assignAddresses(); 1644 changed |= a64p.createFixes(); 1645 } 1646 if (config->fixCortexA8) { 1647 if (changed) 1648 script->assignAddresses(); 1649 changed |= a32p.createFixes(); 1650 } 1651 1652 if (in.mipsGot) 1653 in.mipsGot->updateAllocSize(); 1654 1655 for (Partition &part : partitions) { 1656 changed |= part.relaDyn->updateAllocSize(); 1657 if (part.relrDyn) 1658 changed |= part.relrDyn->updateAllocSize(); 1659 } 1660 1661 const Defined *changedSym = script->assignAddresses(); 1662 if (!changed) { 1663 // Some symbols may be dependent on section addresses. When we break the 1664 // loop, the symbol values are finalized because a previous 1665 // assignAddresses() finalized section addresses. 1666 if (!changedSym) 1667 break; 1668 if (++assignPasses == 5) { 1669 errorOrWarn("assignment to symbol " + toString(*changedSym) + 1670 " does not converge"); 1671 break; 1672 } 1673 } 1674 } 1675 if (!config->relocatable && config->emachine == EM_RISCV) 1676 riscvFinalizeRelax(pass); 1677 1678 if (config->relocatable) 1679 for (OutputSection *sec : outputSections) 1680 sec->addr = 0; 1681 1682 // If addrExpr is set, the address may not be a multiple of the alignment. 1683 // Warn because this is error-prone. 1684 for (SectionCommand *cmd : script->sectionCommands) 1685 if (auto *osd = dyn_cast<OutputDesc>(cmd)) { 1686 OutputSection *osec = &osd->osec; 1687 if (osec->addr % osec->addralign != 0) 1688 warn("address (0x" + Twine::utohexstr(osec->addr) + ") of section " + 1689 osec->name + " is not a multiple of alignment (" + 1690 Twine(osec->addralign) + ")"); 1691 } 1692 } 1693 1694 // If Input Sections have been shrunk (basic block sections) then 1695 // update symbol values and sizes associated with these sections. With basic 1696 // block sections, input sections can shrink when the jump instructions at 1697 // the end of the section are relaxed. 1698 static void fixSymbolsAfterShrinking() { 1699 for (InputFile *File : ctx.objectFiles) { 1700 parallelForEach(File->getSymbols(), [&](Symbol *Sym) { 1701 auto *def = dyn_cast<Defined>(Sym); 1702 if (!def) 1703 return; 1704 1705 const SectionBase *sec = def->section; 1706 if (!sec) 1707 return; 1708 1709 const InputSectionBase *inputSec = dyn_cast<InputSectionBase>(sec); 1710 if (!inputSec || !inputSec->bytesDropped) 1711 return; 1712 1713 const size_t OldSize = inputSec->content().size(); 1714 const size_t NewSize = OldSize - inputSec->bytesDropped; 1715 1716 if (def->value > NewSize && def->value <= OldSize) { 1717 LLVM_DEBUG(llvm::dbgs() 1718 << "Moving symbol " << Sym->getName() << " from " 1719 << def->value << " to " 1720 << def->value - inputSec->bytesDropped << " bytes\n"); 1721 def->value -= inputSec->bytesDropped; 1722 return; 1723 } 1724 1725 if (def->value + def->size > NewSize && def->value <= OldSize && 1726 def->value + def->size <= OldSize) { 1727 LLVM_DEBUG(llvm::dbgs() 1728 << "Shrinking symbol " << Sym->getName() << " from " 1729 << def->size << " to " << def->size - inputSec->bytesDropped 1730 << " bytes\n"); 1731 def->size -= inputSec->bytesDropped; 1732 } 1733 }); 1734 } 1735 } 1736 1737 // If basic block sections exist, there are opportunities to delete fall thru 1738 // jumps and shrink jump instructions after basic block reordering. This 1739 // relaxation pass does that. It is only enabled when --optimize-bb-jumps 1740 // option is used. 1741 template <class ELFT> void Writer<ELFT>::optimizeBasicBlockJumps() { 1742 assert(config->optimizeBBJumps); 1743 SmallVector<InputSection *, 0> storage; 1744 1745 script->assignAddresses(); 1746 // For every output section that has executable input sections, this 1747 // does the following: 1748 // 1. Deletes all direct jump instructions in input sections that 1749 // jump to the following section as it is not required. 1750 // 2. If there are two consecutive jump instructions, it checks 1751 // if they can be flipped and one can be deleted. 1752 for (OutputSection *osec : outputSections) { 1753 if (!(osec->flags & SHF_EXECINSTR)) 1754 continue; 1755 ArrayRef<InputSection *> sections = getInputSections(*osec, storage); 1756 size_t numDeleted = 0; 1757 // Delete all fall through jump instructions. Also, check if two 1758 // consecutive jump instructions can be flipped so that a fall 1759 // through jmp instruction can be deleted. 1760 for (size_t i = 0, e = sections.size(); i != e; ++i) { 1761 InputSection *next = i + 1 < sections.size() ? sections[i + 1] : nullptr; 1762 InputSection &sec = *sections[i]; 1763 numDeleted += target->deleteFallThruJmpInsn(sec, sec.file, next); 1764 } 1765 if (numDeleted > 0) { 1766 script->assignAddresses(); 1767 LLVM_DEBUG(llvm::dbgs() 1768 << "Removing " << numDeleted << " fall through jumps\n"); 1769 } 1770 } 1771 1772 fixSymbolsAfterShrinking(); 1773 1774 for (OutputSection *osec : outputSections) 1775 for (InputSection *is : getInputSections(*osec, storage)) 1776 is->trim(); 1777 } 1778 1779 // In order to allow users to manipulate linker-synthesized sections, 1780 // we had to add synthetic sections to the input section list early, 1781 // even before we make decisions whether they are needed. This allows 1782 // users to write scripts like this: ".mygot : { .got }". 1783 // 1784 // Doing it has an unintended side effects. If it turns out that we 1785 // don't need a .got (for example) at all because there's no 1786 // relocation that needs a .got, we don't want to emit .got. 1787 // 1788 // To deal with the above problem, this function is called after 1789 // scanRelocations is called to remove synthetic sections that turn 1790 // out to be empty. 1791 static void removeUnusedSyntheticSections() { 1792 // All input synthetic sections that can be empty are placed after 1793 // all regular ones. Reverse iterate to find the first synthetic section 1794 // after a non-synthetic one which will be our starting point. 1795 auto start = 1796 llvm::find_if(llvm::reverse(ctx.inputSections), [](InputSectionBase *s) { 1797 return !isa<SyntheticSection>(s); 1798 }).base(); 1799 1800 // Remove unused synthetic sections from ctx.inputSections; 1801 DenseSet<InputSectionBase *> unused; 1802 auto end = 1803 std::remove_if(start, ctx.inputSections.end(), [&](InputSectionBase *s) { 1804 auto *sec = cast<SyntheticSection>(s); 1805 if (sec->getParent() && sec->isNeeded()) 1806 return false; 1807 unused.insert(sec); 1808 return true; 1809 }); 1810 ctx.inputSections.erase(end, ctx.inputSections.end()); 1811 1812 // Remove unused synthetic sections from the corresponding input section 1813 // description and orphanSections. 1814 for (auto *sec : unused) 1815 if (OutputSection *osec = cast<SyntheticSection>(sec)->getParent()) 1816 for (SectionCommand *cmd : osec->commands) 1817 if (auto *isd = dyn_cast<InputSectionDescription>(cmd)) 1818 llvm::erase_if(isd->sections, [&](InputSection *isec) { 1819 return unused.count(isec); 1820 }); 1821 llvm::erase_if(script->orphanSections, [&](const InputSectionBase *sec) { 1822 return unused.count(sec); 1823 }); 1824 } 1825 1826 // Create output section objects and add them to OutputSections. 1827 template <class ELFT> void Writer<ELFT>::finalizeSections() { 1828 if (!config->relocatable) { 1829 Out::preinitArray = findSection(".preinit_array"); 1830 Out::initArray = findSection(".init_array"); 1831 Out::finiArray = findSection(".fini_array"); 1832 1833 // The linker needs to define SECNAME_start, SECNAME_end and SECNAME_stop 1834 // symbols for sections, so that the runtime can get the start and end 1835 // addresses of each section by section name. Add such symbols. 1836 addStartEndSymbols(); 1837 for (SectionCommand *cmd : script->sectionCommands) 1838 if (auto *osd = dyn_cast<OutputDesc>(cmd)) 1839 addStartStopSymbols(osd->osec); 1840 1841 // Add _DYNAMIC symbol. Unlike GNU gold, our _DYNAMIC symbol has no type. 1842 // It should be okay as no one seems to care about the type. 1843 // Even the author of gold doesn't remember why gold behaves that way. 1844 // https://sourceware.org/ml/binutils/2002-03/msg00360.html 1845 if (mainPart->dynamic->parent) { 1846 Symbol *s = symtab.addSymbol(Defined{ 1847 /*file=*/nullptr, "_DYNAMIC", STB_WEAK, STV_HIDDEN, STT_NOTYPE, 1848 /*value=*/0, /*size=*/0, mainPart->dynamic.get()}); 1849 s->isUsedInRegularObj = true; 1850 } 1851 1852 // Define __rel[a]_iplt_{start,end} symbols if needed. 1853 addRelIpltSymbols(); 1854 1855 // RISC-V's gp can address +/- 2 KiB, set it to .sdata + 0x800. This symbol 1856 // should only be defined in an executable. If .sdata does not exist, its 1857 // value/section does not matter but it has to be relative, so set its 1858 // st_shndx arbitrarily to 1 (Out::elfHeader). 1859 if (config->emachine == EM_RISCV && !config->shared) { 1860 OutputSection *sec = findSection(".sdata"); 1861 addOptionalRegular("__global_pointer$", sec ? sec : Out::elfHeader, 0x800, 1862 STV_DEFAULT); 1863 } 1864 1865 if (config->emachine == EM_386 || config->emachine == EM_X86_64) { 1866 // On targets that support TLSDESC, _TLS_MODULE_BASE_ is defined in such a 1867 // way that: 1868 // 1869 // 1) Without relaxation: it produces a dynamic TLSDESC relocation that 1870 // computes 0. 1871 // 2) With LD->LE relaxation: _TLS_MODULE_BASE_@tpoff = 0 (lowest address 1872 // in the TLS block). 1873 // 1874 // 2) is special cased in @tpoff computation. To satisfy 1), we define it 1875 // as an absolute symbol of zero. This is different from GNU linkers which 1876 // define _TLS_MODULE_BASE_ relative to the first TLS section. 1877 Symbol *s = symtab.find("_TLS_MODULE_BASE_"); 1878 if (s && s->isUndefined()) { 1879 s->resolve(Defined{/*file=*/nullptr, StringRef(), STB_GLOBAL, 1880 STV_HIDDEN, STT_TLS, /*value=*/0, 0, 1881 /*section=*/nullptr}); 1882 ElfSym::tlsModuleBase = cast<Defined>(s); 1883 } 1884 } 1885 1886 // This responsible for splitting up .eh_frame section into 1887 // pieces. The relocation scan uses those pieces, so this has to be 1888 // earlier. 1889 { 1890 llvm::TimeTraceScope timeScope("Finalize .eh_frame"); 1891 for (Partition &part : partitions) 1892 finalizeSynthetic(part.ehFrame.get()); 1893 } 1894 1895 if (config->hasDynSymTab) { 1896 parallelForEach(symtab.getSymbols(), [](Symbol *sym) { 1897 sym->isPreemptible = computeIsPreemptible(*sym); 1898 }); 1899 } 1900 } 1901 1902 // Change values of linker-script-defined symbols from placeholders (assigned 1903 // by declareSymbols) to actual definitions. 1904 script->processSymbolAssignments(); 1905 1906 if (!config->relocatable) { 1907 llvm::TimeTraceScope timeScope("Scan relocations"); 1908 // Scan relocations. This must be done after every symbol is declared so 1909 // that we can correctly decide if a dynamic relocation is needed. This is 1910 // called after processSymbolAssignments() because it needs to know whether 1911 // a linker-script-defined symbol is absolute. 1912 ppc64noTocRelax.clear(); 1913 scanRelocations<ELFT>(); 1914 reportUndefinedSymbols(); 1915 postScanRelocations(); 1916 1917 if (in.plt && in.plt->isNeeded()) 1918 in.plt->addSymbols(); 1919 if (in.iplt && in.iplt->isNeeded()) 1920 in.iplt->addSymbols(); 1921 1922 if (config->unresolvedSymbolsInShlib != UnresolvedPolicy::Ignore) { 1923 auto diagnose = 1924 config->unresolvedSymbolsInShlib == UnresolvedPolicy::ReportError 1925 ? errorOrWarn 1926 : warn; 1927 // Error on undefined symbols in a shared object, if all of its DT_NEEDED 1928 // entries are seen. These cases would otherwise lead to runtime errors 1929 // reported by the dynamic linker. 1930 // 1931 // ld.bfd traces all DT_NEEDED to emulate the logic of the dynamic linker 1932 // to catch more cases. That is too much for us. Our approach resembles 1933 // the one used in ld.gold, achieves a good balance to be useful but not 1934 // too smart. 1935 for (SharedFile *file : ctx.sharedFiles) { 1936 bool allNeededIsKnown = 1937 llvm::all_of(file->dtNeeded, [&](StringRef needed) { 1938 return symtab.soNames.count(CachedHashStringRef(needed)); 1939 }); 1940 if (!allNeededIsKnown) 1941 continue; 1942 for (Symbol *sym : file->requiredSymbols) 1943 if (sym->isUndefined() && !sym->isWeak()) 1944 diagnose("undefined reference due to --no-allow-shlib-undefined: " + 1945 toString(*sym) + "\n>>> referenced by " + toString(file)); 1946 } 1947 } 1948 } 1949 1950 { 1951 llvm::TimeTraceScope timeScope("Add symbols to symtabs"); 1952 // Now that we have defined all possible global symbols including linker- 1953 // synthesized ones. Visit all symbols to give the finishing touches. 1954 for (Symbol *sym : symtab.getSymbols()) { 1955 if (!sym->isUsedInRegularObj || !includeInSymtab(*sym)) 1956 continue; 1957 if (!config->relocatable) 1958 sym->binding = sym->computeBinding(); 1959 if (in.symTab) 1960 in.symTab->addSymbol(sym); 1961 1962 if (sym->includeInDynsym()) { 1963 partitions[sym->partition - 1].dynSymTab->addSymbol(sym); 1964 if (auto *file = dyn_cast_or_null<SharedFile>(sym->file)) 1965 if (file->isNeeded && !sym->isUndefined()) 1966 addVerneed(sym); 1967 } 1968 } 1969 1970 // We also need to scan the dynamic relocation tables of the other 1971 // partitions and add any referenced symbols to the partition's dynsym. 1972 for (Partition &part : MutableArrayRef<Partition>(partitions).slice(1)) { 1973 DenseSet<Symbol *> syms; 1974 for (const SymbolTableEntry &e : part.dynSymTab->getSymbols()) 1975 syms.insert(e.sym); 1976 for (DynamicReloc &reloc : part.relaDyn->relocs) 1977 if (reloc.sym && reloc.needsDynSymIndex() && 1978 syms.insert(reloc.sym).second) 1979 part.dynSymTab->addSymbol(reloc.sym); 1980 } 1981 } 1982 1983 if (in.mipsGot) 1984 in.mipsGot->build(); 1985 1986 removeUnusedSyntheticSections(); 1987 script->diagnoseOrphanHandling(); 1988 1989 sortSections(); 1990 1991 // Create a list of OutputSections, assign sectionIndex, and populate 1992 // in.shStrTab. 1993 for (SectionCommand *cmd : script->sectionCommands) 1994 if (auto *osd = dyn_cast<OutputDesc>(cmd)) { 1995 OutputSection *osec = &osd->osec; 1996 outputSections.push_back(osec); 1997 osec->sectionIndex = outputSections.size(); 1998 osec->shName = in.shStrTab->addString(osec->name); 1999 } 2000 2001 // Prefer command line supplied address over other constraints. 2002 for (OutputSection *sec : outputSections) { 2003 auto i = config->sectionStartMap.find(sec->name); 2004 if (i != config->sectionStartMap.end()) 2005 sec->addrExpr = [=] { return i->second; }; 2006 } 2007 2008 // With the outputSections available check for GDPLT relocations 2009 // and add __tls_get_addr symbol if needed. 2010 if (config->emachine == EM_HEXAGON && hexagonNeedsTLSSymbol(outputSections)) { 2011 Symbol *sym = symtab.addSymbol(Undefined{ 2012 nullptr, "__tls_get_addr", STB_GLOBAL, STV_DEFAULT, STT_NOTYPE}); 2013 sym->isPreemptible = true; 2014 partitions[0].dynSymTab->addSymbol(sym); 2015 } 2016 2017 // This is a bit of a hack. A value of 0 means undef, so we set it 2018 // to 1 to make __ehdr_start defined. The section number is not 2019 // particularly relevant. 2020 Out::elfHeader->sectionIndex = 1; 2021 Out::elfHeader->size = sizeof(typename ELFT::Ehdr); 2022 2023 // Binary and relocatable output does not have PHDRS. 2024 // The headers have to be created before finalize as that can influence the 2025 // image base and the dynamic section on mips includes the image base. 2026 if (!config->relocatable && !config->oFormatBinary) { 2027 for (Partition &part : partitions) { 2028 part.phdrs = script->hasPhdrsCommands() ? script->createPhdrs() 2029 : createPhdrs(part); 2030 if (config->emachine == EM_ARM) { 2031 // PT_ARM_EXIDX is the ARM EHABI equivalent of PT_GNU_EH_FRAME 2032 addPhdrForSection(part, SHT_ARM_EXIDX, PT_ARM_EXIDX, PF_R); 2033 } 2034 if (config->emachine == EM_MIPS) { 2035 // Add separate segments for MIPS-specific sections. 2036 addPhdrForSection(part, SHT_MIPS_REGINFO, PT_MIPS_REGINFO, PF_R); 2037 addPhdrForSection(part, SHT_MIPS_OPTIONS, PT_MIPS_OPTIONS, PF_R); 2038 addPhdrForSection(part, SHT_MIPS_ABIFLAGS, PT_MIPS_ABIFLAGS, PF_R); 2039 } 2040 } 2041 Out::programHeaders->size = sizeof(Elf_Phdr) * mainPart->phdrs.size(); 2042 2043 // Find the TLS segment. This happens before the section layout loop so that 2044 // Android relocation packing can look up TLS symbol addresses. We only need 2045 // to care about the main partition here because all TLS symbols were moved 2046 // to the main partition (see MarkLive.cpp). 2047 for (PhdrEntry *p : mainPart->phdrs) 2048 if (p->p_type == PT_TLS) 2049 Out::tlsPhdr = p; 2050 } 2051 2052 // Some symbols are defined in term of program headers. Now that we 2053 // have the headers, we can find out which sections they point to. 2054 setReservedSymbolSections(); 2055 2056 { 2057 llvm::TimeTraceScope timeScope("Finalize synthetic sections"); 2058 2059 finalizeSynthetic(in.bss.get()); 2060 finalizeSynthetic(in.bssRelRo.get()); 2061 finalizeSynthetic(in.symTabShndx.get()); 2062 finalizeSynthetic(in.shStrTab.get()); 2063 finalizeSynthetic(in.strTab.get()); 2064 finalizeSynthetic(in.got.get()); 2065 finalizeSynthetic(in.mipsGot.get()); 2066 finalizeSynthetic(in.igotPlt.get()); 2067 finalizeSynthetic(in.gotPlt.get()); 2068 finalizeSynthetic(in.relaIplt.get()); 2069 finalizeSynthetic(in.relaPlt.get()); 2070 finalizeSynthetic(in.plt.get()); 2071 finalizeSynthetic(in.iplt.get()); 2072 finalizeSynthetic(in.ppc32Got2.get()); 2073 finalizeSynthetic(in.partIndex.get()); 2074 2075 // Dynamic section must be the last one in this list and dynamic 2076 // symbol table section (dynSymTab) must be the first one. 2077 for (Partition &part : partitions) { 2078 if (part.relaDyn) { 2079 part.relaDyn->mergeRels(); 2080 // Compute DT_RELACOUNT to be used by part.dynamic. 2081 part.relaDyn->partitionRels(); 2082 finalizeSynthetic(part.relaDyn.get()); 2083 } 2084 if (part.relrDyn) { 2085 part.relrDyn->mergeRels(); 2086 finalizeSynthetic(part.relrDyn.get()); 2087 } 2088 2089 finalizeSynthetic(part.dynSymTab.get()); 2090 finalizeSynthetic(part.gnuHashTab.get()); 2091 finalizeSynthetic(part.hashTab.get()); 2092 finalizeSynthetic(part.verDef.get()); 2093 finalizeSynthetic(part.ehFrameHdr.get()); 2094 finalizeSynthetic(part.verSym.get()); 2095 finalizeSynthetic(part.verNeed.get()); 2096 finalizeSynthetic(part.dynamic.get()); 2097 } 2098 } 2099 2100 if (!script->hasSectionsCommand && !config->relocatable) 2101 fixSectionAlignments(); 2102 2103 // This is used to: 2104 // 1) Create "thunks": 2105 // Jump instructions in many ISAs have small displacements, and therefore 2106 // they cannot jump to arbitrary addresses in memory. For example, RISC-V 2107 // JAL instruction can target only +-1 MiB from PC. It is a linker's 2108 // responsibility to create and insert small pieces of code between 2109 // sections to extend the ranges if jump targets are out of range. Such 2110 // code pieces are called "thunks". 2111 // 2112 // We add thunks at this stage. We couldn't do this before this point 2113 // because this is the earliest point where we know sizes of sections and 2114 // their layouts (that are needed to determine if jump targets are in 2115 // range). 2116 // 2117 // 2) Update the sections. We need to generate content that depends on the 2118 // address of InputSections. For example, MIPS GOT section content or 2119 // android packed relocations sections content. 2120 // 2121 // 3) Assign the final values for the linker script symbols. Linker scripts 2122 // sometimes using forward symbol declarations. We want to set the correct 2123 // values. They also might change after adding the thunks. 2124 finalizeAddressDependentContent(); 2125 2126 // All information needed for OutputSection part of Map file is available. 2127 if (errorCount()) 2128 return; 2129 2130 { 2131 llvm::TimeTraceScope timeScope("Finalize synthetic sections"); 2132 // finalizeAddressDependentContent may have added local symbols to the 2133 // static symbol table. 2134 finalizeSynthetic(in.symTab.get()); 2135 finalizeSynthetic(in.ppc64LongBranchTarget.get()); 2136 } 2137 2138 // Relaxation to delete inter-basic block jumps created by basic block 2139 // sections. Run after in.symTab is finalized as optimizeBasicBlockJumps 2140 // can relax jump instructions based on symbol offset. 2141 if (config->optimizeBBJumps) 2142 optimizeBasicBlockJumps(); 2143 2144 // Fill other section headers. The dynamic table is finalized 2145 // at the end because some tags like RELSZ depend on result 2146 // of finalizing other sections. 2147 for (OutputSection *sec : outputSections) 2148 sec->finalize(); 2149 } 2150 2151 // Ensure data sections are not mixed with executable sections when 2152 // --execute-only is used. --execute-only make pages executable but not 2153 // readable. 2154 template <class ELFT> void Writer<ELFT>::checkExecuteOnly() { 2155 if (!config->executeOnly) 2156 return; 2157 2158 SmallVector<InputSection *, 0> storage; 2159 for (OutputSection *osec : outputSections) 2160 if (osec->flags & SHF_EXECINSTR) 2161 for (InputSection *isec : getInputSections(*osec, storage)) 2162 if (!(isec->flags & SHF_EXECINSTR)) 2163 error("cannot place " + toString(isec) + " into " + 2164 toString(osec->name) + 2165 ": --execute-only does not support intermingling data and code"); 2166 } 2167 2168 // The linker is expected to define SECNAME_start and SECNAME_end 2169 // symbols for a few sections. This function defines them. 2170 template <class ELFT> void Writer<ELFT>::addStartEndSymbols() { 2171 // If a section does not exist, there's ambiguity as to how we 2172 // define _start and _end symbols for an init/fini section. Since 2173 // the loader assume that the symbols are always defined, we need to 2174 // always define them. But what value? The loader iterates over all 2175 // pointers between _start and _end to run global ctors/dtors, so if 2176 // the section is empty, their symbol values don't actually matter 2177 // as long as _start and _end point to the same location. 2178 // 2179 // That said, we don't want to set the symbols to 0 (which is 2180 // probably the simplest value) because that could cause some 2181 // program to fail to link due to relocation overflow, if their 2182 // program text is above 2 GiB. We use the address of the .text 2183 // section instead to prevent that failure. 2184 // 2185 // In rare situations, the .text section may not exist. If that's the 2186 // case, use the image base address as a last resort. 2187 OutputSection *Default = findSection(".text"); 2188 if (!Default) 2189 Default = Out::elfHeader; 2190 2191 auto define = [=](StringRef start, StringRef end, OutputSection *os) { 2192 if (os && !script->isDiscarded(os)) { 2193 addOptionalRegular(start, os, 0); 2194 addOptionalRegular(end, os, -1); 2195 } else { 2196 addOptionalRegular(start, Default, 0); 2197 addOptionalRegular(end, Default, 0); 2198 } 2199 }; 2200 2201 define("__preinit_array_start", "__preinit_array_end", Out::preinitArray); 2202 define("__init_array_start", "__init_array_end", Out::initArray); 2203 define("__fini_array_start", "__fini_array_end", Out::finiArray); 2204 2205 if (OutputSection *sec = findSection(".ARM.exidx")) 2206 define("__exidx_start", "__exidx_end", sec); 2207 } 2208 2209 // If a section name is valid as a C identifier (which is rare because of 2210 // the leading '.'), linkers are expected to define __start_<secname> and 2211 // __stop_<secname> symbols. They are at beginning and end of the section, 2212 // respectively. This is not requested by the ELF standard, but GNU ld and 2213 // gold provide the feature, and used by many programs. 2214 template <class ELFT> 2215 void Writer<ELFT>::addStartStopSymbols(OutputSection &osec) { 2216 StringRef s = osec.name; 2217 if (!isValidCIdentifier(s)) 2218 return; 2219 addOptionalRegular(saver().save("__start_" + s), &osec, 0, 2220 config->zStartStopVisibility); 2221 addOptionalRegular(saver().save("__stop_" + s), &osec, -1, 2222 config->zStartStopVisibility); 2223 } 2224 2225 static bool needsPtLoad(OutputSection *sec) { 2226 if (!(sec->flags & SHF_ALLOC)) 2227 return false; 2228 2229 // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is 2230 // responsible for allocating space for them, not the PT_LOAD that 2231 // contains the TLS initialization image. 2232 if ((sec->flags & SHF_TLS) && sec->type == SHT_NOBITS) 2233 return false; 2234 return true; 2235 } 2236 2237 // Linker scripts are responsible for aligning addresses. Unfortunately, most 2238 // linker scripts are designed for creating two PT_LOADs only, one RX and one 2239 // RW. This means that there is no alignment in the RO to RX transition and we 2240 // cannot create a PT_LOAD there. 2241 static uint64_t computeFlags(uint64_t flags) { 2242 if (config->omagic) 2243 return PF_R | PF_W | PF_X; 2244 if (config->executeOnly && (flags & PF_X)) 2245 return flags & ~PF_R; 2246 if (config->singleRoRx && !(flags & PF_W)) 2247 return flags | PF_X; 2248 return flags; 2249 } 2250 2251 // Decide which program headers to create and which sections to include in each 2252 // one. 2253 template <class ELFT> 2254 SmallVector<PhdrEntry *, 0> Writer<ELFT>::createPhdrs(Partition &part) { 2255 SmallVector<PhdrEntry *, 0> ret; 2256 auto addHdr = [&](unsigned type, unsigned flags) -> PhdrEntry * { 2257 ret.push_back(make<PhdrEntry>(type, flags)); 2258 return ret.back(); 2259 }; 2260 2261 unsigned partNo = part.getNumber(); 2262 bool isMain = partNo == 1; 2263 2264 // Add the first PT_LOAD segment for regular output sections. 2265 uint64_t flags = computeFlags(PF_R); 2266 PhdrEntry *load = nullptr; 2267 2268 // nmagic or omagic output does not have PT_PHDR, PT_INTERP, or the readonly 2269 // PT_LOAD. 2270 if (!config->nmagic && !config->omagic) { 2271 // The first phdr entry is PT_PHDR which describes the program header 2272 // itself. 2273 if (isMain) 2274 addHdr(PT_PHDR, PF_R)->add(Out::programHeaders); 2275 else 2276 addHdr(PT_PHDR, PF_R)->add(part.programHeaders->getParent()); 2277 2278 // PT_INTERP must be the second entry if exists. 2279 if (OutputSection *cmd = findSection(".interp", partNo)) 2280 addHdr(PT_INTERP, cmd->getPhdrFlags())->add(cmd); 2281 2282 // Add the headers. We will remove them if they don't fit. 2283 // In the other partitions the headers are ordinary sections, so they don't 2284 // need to be added here. 2285 if (isMain) { 2286 load = addHdr(PT_LOAD, flags); 2287 load->add(Out::elfHeader); 2288 load->add(Out::programHeaders); 2289 } 2290 } 2291 2292 // PT_GNU_RELRO includes all sections that should be marked as 2293 // read-only by dynamic linker after processing relocations. 2294 // Current dynamic loaders only support one PT_GNU_RELRO PHDR, give 2295 // an error message if more than one PT_GNU_RELRO PHDR is required. 2296 PhdrEntry *relRo = make<PhdrEntry>(PT_GNU_RELRO, PF_R); 2297 bool inRelroPhdr = false; 2298 OutputSection *relroEnd = nullptr; 2299 for (OutputSection *sec : outputSections) { 2300 if (sec->partition != partNo || !needsPtLoad(sec)) 2301 continue; 2302 if (isRelroSection(sec)) { 2303 inRelroPhdr = true; 2304 if (!relroEnd) 2305 relRo->add(sec); 2306 else 2307 error("section: " + sec->name + " is not contiguous with other relro" + 2308 " sections"); 2309 } else if (inRelroPhdr) { 2310 inRelroPhdr = false; 2311 relroEnd = sec; 2312 } 2313 } 2314 2315 for (OutputSection *sec : outputSections) { 2316 if (!needsPtLoad(sec)) 2317 continue; 2318 2319 // Normally, sections in partitions other than the current partition are 2320 // ignored. But partition number 255 is a special case: it contains the 2321 // partition end marker (.part.end). It needs to be added to the main 2322 // partition so that a segment is created for it in the main partition, 2323 // which will cause the dynamic loader to reserve space for the other 2324 // partitions. 2325 if (sec->partition != partNo) { 2326 if (isMain && sec->partition == 255) 2327 addHdr(PT_LOAD, computeFlags(sec->getPhdrFlags()))->add(sec); 2328 continue; 2329 } 2330 2331 // Segments are contiguous memory regions that has the same attributes 2332 // (e.g. executable or writable). There is one phdr for each segment. 2333 // Therefore, we need to create a new phdr when the next section has 2334 // different flags or is loaded at a discontiguous address or memory 2335 // region using AT or AT> linker script command, respectively. At the same 2336 // time, we don't want to create a separate load segment for the headers, 2337 // even if the first output section has an AT or AT> attribute. 2338 uint64_t newFlags = computeFlags(sec->getPhdrFlags()); 2339 bool sameLMARegion = 2340 load && !sec->lmaExpr && sec->lmaRegion == load->firstSec->lmaRegion; 2341 if (!(load && newFlags == flags && sec != relroEnd && 2342 sec->memRegion == load->firstSec->memRegion && 2343 (sameLMARegion || load->lastSec == Out::programHeaders))) { 2344 load = addHdr(PT_LOAD, newFlags); 2345 flags = newFlags; 2346 } 2347 2348 load->add(sec); 2349 } 2350 2351 // Add a TLS segment if any. 2352 PhdrEntry *tlsHdr = make<PhdrEntry>(PT_TLS, PF_R); 2353 for (OutputSection *sec : outputSections) 2354 if (sec->partition == partNo && sec->flags & SHF_TLS) 2355 tlsHdr->add(sec); 2356 if (tlsHdr->firstSec) 2357 ret.push_back(tlsHdr); 2358 2359 // Add an entry for .dynamic. 2360 if (OutputSection *sec = part.dynamic->getParent()) 2361 addHdr(PT_DYNAMIC, sec->getPhdrFlags())->add(sec); 2362 2363 if (relRo->firstSec) 2364 ret.push_back(relRo); 2365 2366 // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr. 2367 if (part.ehFrame->isNeeded() && part.ehFrameHdr && 2368 part.ehFrame->getParent() && part.ehFrameHdr->getParent()) 2369 addHdr(PT_GNU_EH_FRAME, part.ehFrameHdr->getParent()->getPhdrFlags()) 2370 ->add(part.ehFrameHdr->getParent()); 2371 2372 // PT_OPENBSD_RANDOMIZE is an OpenBSD-specific feature. That makes 2373 // the dynamic linker fill the segment with random data. 2374 if (OutputSection *cmd = findSection(".openbsd.randomdata", partNo)) 2375 addHdr(PT_OPENBSD_RANDOMIZE, cmd->getPhdrFlags())->add(cmd); 2376 2377 if (config->zGnustack != GnuStackKind::None) { 2378 // PT_GNU_STACK is a special section to tell the loader to make the 2379 // pages for the stack non-executable. If you really want an executable 2380 // stack, you can pass -z execstack, but that's not recommended for 2381 // security reasons. 2382 unsigned perm = PF_R | PF_W; 2383 if (config->zGnustack == GnuStackKind::Exec) 2384 perm |= PF_X; 2385 addHdr(PT_GNU_STACK, perm)->p_memsz = config->zStackSize; 2386 } 2387 2388 // PT_OPENBSD_WXNEEDED is a OpenBSD-specific header to mark the executable 2389 // is expected to perform W^X violations, such as calling mprotect(2) or 2390 // mmap(2) with PROT_WRITE | PROT_EXEC, which is prohibited by default on 2391 // OpenBSD. 2392 if (config->zWxneeded) 2393 addHdr(PT_OPENBSD_WXNEEDED, PF_X); 2394 2395 if (OutputSection *cmd = findSection(".note.gnu.property", partNo)) 2396 addHdr(PT_GNU_PROPERTY, PF_R)->add(cmd); 2397 2398 // Create one PT_NOTE per a group of contiguous SHT_NOTE sections with the 2399 // same alignment. 2400 PhdrEntry *note = nullptr; 2401 for (OutputSection *sec : outputSections) { 2402 if (sec->partition != partNo) 2403 continue; 2404 if (sec->type == SHT_NOTE && (sec->flags & SHF_ALLOC)) { 2405 if (!note || sec->lmaExpr || note->lastSec->addralign != sec->addralign) 2406 note = addHdr(PT_NOTE, PF_R); 2407 note->add(sec); 2408 } else { 2409 note = nullptr; 2410 } 2411 } 2412 return ret; 2413 } 2414 2415 template <class ELFT> 2416 void Writer<ELFT>::addPhdrForSection(Partition &part, unsigned shType, 2417 unsigned pType, unsigned pFlags) { 2418 unsigned partNo = part.getNumber(); 2419 auto i = llvm::find_if(outputSections, [=](OutputSection *cmd) { 2420 return cmd->partition == partNo && cmd->type == shType; 2421 }); 2422 if (i == outputSections.end()) 2423 return; 2424 2425 PhdrEntry *entry = make<PhdrEntry>(pType, pFlags); 2426 entry->add(*i); 2427 part.phdrs.push_back(entry); 2428 } 2429 2430 // Place the first section of each PT_LOAD to a different page (of maxPageSize). 2431 // This is achieved by assigning an alignment expression to addrExpr of each 2432 // such section. 2433 template <class ELFT> void Writer<ELFT>::fixSectionAlignments() { 2434 const PhdrEntry *prev; 2435 auto pageAlign = [&](const PhdrEntry *p) { 2436 OutputSection *cmd = p->firstSec; 2437 if (!cmd) 2438 return; 2439 cmd->alignExpr = [align = cmd->addralign]() { return align; }; 2440 if (!cmd->addrExpr) { 2441 // Prefer advancing to align(dot, maxPageSize) + dot%maxPageSize to avoid 2442 // padding in the file contents. 2443 // 2444 // When -z separate-code is used we must not have any overlap in pages 2445 // between an executable segment and a non-executable segment. We align to 2446 // the next maximum page size boundary on transitions between executable 2447 // and non-executable segments. 2448 // 2449 // SHT_LLVM_PART_EHDR marks the start of a partition. The partition 2450 // sections will be extracted to a separate file. Align to the next 2451 // maximum page size boundary so that we can find the ELF header at the 2452 // start. We cannot benefit from overlapping p_offset ranges with the 2453 // previous segment anyway. 2454 if (config->zSeparate == SeparateSegmentKind::Loadable || 2455 (config->zSeparate == SeparateSegmentKind::Code && prev && 2456 (prev->p_flags & PF_X) != (p->p_flags & PF_X)) || 2457 cmd->type == SHT_LLVM_PART_EHDR) 2458 cmd->addrExpr = [] { 2459 return alignToPowerOf2(script->getDot(), config->maxPageSize); 2460 }; 2461 // PT_TLS is at the start of the first RW PT_LOAD. If `p` includes PT_TLS, 2462 // it must be the RW. Align to p_align(PT_TLS) to make sure 2463 // p_vaddr(PT_LOAD)%p_align(PT_LOAD) = 0. Otherwise, if 2464 // sh_addralign(.tdata) < sh_addralign(.tbss), we will set p_align(PT_TLS) 2465 // to sh_addralign(.tbss), while p_vaddr(PT_TLS)=p_vaddr(PT_LOAD) may not 2466 // be congruent to 0 modulo p_align(PT_TLS). 2467 // 2468 // Technically this is not required, but as of 2019, some dynamic loaders 2469 // don't handle p_vaddr%p_align != 0 correctly, e.g. glibc (i386 and 2470 // x86-64) doesn't make runtime address congruent to p_vaddr modulo 2471 // p_align for dynamic TLS blocks (PR/24606), FreeBSD rtld has the same 2472 // bug, musl (TLS Variant 1 architectures) before 1.1.23 handled TLS 2473 // blocks correctly. We need to keep the workaround for a while. 2474 else if (Out::tlsPhdr && Out::tlsPhdr->firstSec == p->firstSec) 2475 cmd->addrExpr = [] { 2476 return alignToPowerOf2(script->getDot(), config->maxPageSize) + 2477 alignToPowerOf2(script->getDot() % config->maxPageSize, 2478 Out::tlsPhdr->p_align); 2479 }; 2480 else 2481 cmd->addrExpr = [] { 2482 return alignToPowerOf2(script->getDot(), config->maxPageSize) + 2483 script->getDot() % config->maxPageSize; 2484 }; 2485 } 2486 }; 2487 2488 for (Partition &part : partitions) { 2489 prev = nullptr; 2490 for (const PhdrEntry *p : part.phdrs) 2491 if (p->p_type == PT_LOAD && p->firstSec) { 2492 pageAlign(p); 2493 prev = p; 2494 } 2495 } 2496 } 2497 2498 // Compute an in-file position for a given section. The file offset must be the 2499 // same with its virtual address modulo the page size, so that the loader can 2500 // load executables without any address adjustment. 2501 static uint64_t computeFileOffset(OutputSection *os, uint64_t off) { 2502 // The first section in a PT_LOAD has to have congruent offset and address 2503 // modulo the maximum page size. 2504 if (os->ptLoad && os->ptLoad->firstSec == os) 2505 return alignTo(off, os->ptLoad->p_align, os->addr); 2506 2507 // File offsets are not significant for .bss sections other than the first one 2508 // in a PT_LOAD/PT_TLS. By convention, we keep section offsets monotonically 2509 // increasing rather than setting to zero. 2510 if (os->type == SHT_NOBITS && 2511 (!Out::tlsPhdr || Out::tlsPhdr->firstSec != os)) 2512 return off; 2513 2514 // If the section is not in a PT_LOAD, we just have to align it. 2515 if (!os->ptLoad) 2516 return alignToPowerOf2(off, os->addralign); 2517 2518 // If two sections share the same PT_LOAD the file offset is calculated 2519 // using this formula: Off2 = Off1 + (VA2 - VA1). 2520 OutputSection *first = os->ptLoad->firstSec; 2521 return first->offset + os->addr - first->addr; 2522 } 2523 2524 template <class ELFT> void Writer<ELFT>::assignFileOffsetsBinary() { 2525 // Compute the minimum LMA of all non-empty non-NOBITS sections as minAddr. 2526 auto needsOffset = [](OutputSection &sec) { 2527 return sec.type != SHT_NOBITS && (sec.flags & SHF_ALLOC) && sec.size > 0; 2528 }; 2529 uint64_t minAddr = UINT64_MAX; 2530 for (OutputSection *sec : outputSections) 2531 if (needsOffset(*sec)) { 2532 sec->offset = sec->getLMA(); 2533 minAddr = std::min(minAddr, sec->offset); 2534 } 2535 2536 // Sections are laid out at LMA minus minAddr. 2537 fileSize = 0; 2538 for (OutputSection *sec : outputSections) 2539 if (needsOffset(*sec)) { 2540 sec->offset -= minAddr; 2541 fileSize = std::max(fileSize, sec->offset + sec->size); 2542 } 2543 } 2544 2545 static std::string rangeToString(uint64_t addr, uint64_t len) { 2546 return "[0x" + utohexstr(addr) + ", 0x" + utohexstr(addr + len - 1) + "]"; 2547 } 2548 2549 // Assign file offsets to output sections. 2550 template <class ELFT> void Writer<ELFT>::assignFileOffsets() { 2551 Out::programHeaders->offset = Out::elfHeader->size; 2552 uint64_t off = Out::elfHeader->size + Out::programHeaders->size; 2553 2554 PhdrEntry *lastRX = nullptr; 2555 for (Partition &part : partitions) 2556 for (PhdrEntry *p : part.phdrs) 2557 if (p->p_type == PT_LOAD && (p->p_flags & PF_X)) 2558 lastRX = p; 2559 2560 // Layout SHF_ALLOC sections before non-SHF_ALLOC sections. A non-SHF_ALLOC 2561 // will not occupy file offsets contained by a PT_LOAD. 2562 for (OutputSection *sec : outputSections) { 2563 if (!(sec->flags & SHF_ALLOC)) 2564 continue; 2565 off = computeFileOffset(sec, off); 2566 sec->offset = off; 2567 if (sec->type != SHT_NOBITS) 2568 off += sec->size; 2569 2570 // If this is a last section of the last executable segment and that 2571 // segment is the last loadable segment, align the offset of the 2572 // following section to avoid loading non-segments parts of the file. 2573 if (config->zSeparate != SeparateSegmentKind::None && lastRX && 2574 lastRX->lastSec == sec) 2575 off = alignToPowerOf2(off, config->maxPageSize); 2576 } 2577 for (OutputSection *osec : outputSections) 2578 if (!(osec->flags & SHF_ALLOC)) { 2579 osec->offset = alignToPowerOf2(off, osec->addralign); 2580 off = osec->offset + osec->size; 2581 } 2582 2583 sectionHeaderOff = alignToPowerOf2(off, config->wordsize); 2584 fileSize = sectionHeaderOff + (outputSections.size() + 1) * sizeof(Elf_Shdr); 2585 2586 // Our logic assumes that sections have rising VA within the same segment. 2587 // With use of linker scripts it is possible to violate this rule and get file 2588 // offset overlaps or overflows. That should never happen with a valid script 2589 // which does not move the location counter backwards and usually scripts do 2590 // not do that. Unfortunately, there are apps in the wild, for example, Linux 2591 // kernel, which control segment distribution explicitly and move the counter 2592 // backwards, so we have to allow doing that to support linking them. We 2593 // perform non-critical checks for overlaps in checkSectionOverlap(), but here 2594 // we want to prevent file size overflows because it would crash the linker. 2595 for (OutputSection *sec : outputSections) { 2596 if (sec->type == SHT_NOBITS) 2597 continue; 2598 if ((sec->offset > fileSize) || (sec->offset + sec->size > fileSize)) 2599 error("unable to place section " + sec->name + " at file offset " + 2600 rangeToString(sec->offset, sec->size) + 2601 "; check your linker script for overflows"); 2602 } 2603 } 2604 2605 // Finalize the program headers. We call this function after we assign 2606 // file offsets and VAs to all sections. 2607 template <class ELFT> void Writer<ELFT>::setPhdrs(Partition &part) { 2608 for (PhdrEntry *p : part.phdrs) { 2609 OutputSection *first = p->firstSec; 2610 OutputSection *last = p->lastSec; 2611 2612 if (first) { 2613 p->p_filesz = last->offset - first->offset; 2614 if (last->type != SHT_NOBITS) 2615 p->p_filesz += last->size; 2616 2617 p->p_memsz = last->addr + last->size - first->addr; 2618 p->p_offset = first->offset; 2619 p->p_vaddr = first->addr; 2620 2621 // File offsets in partitions other than the main partition are relative 2622 // to the offset of the ELF headers. Perform that adjustment now. 2623 if (part.elfHeader) 2624 p->p_offset -= part.elfHeader->getParent()->offset; 2625 2626 if (!p->hasLMA) 2627 p->p_paddr = first->getLMA(); 2628 } 2629 2630 if (p->p_type == PT_GNU_RELRO) { 2631 p->p_align = 1; 2632 // musl/glibc ld.so rounds the size down, so we need to round up 2633 // to protect the last page. This is a no-op on FreeBSD which always 2634 // rounds up. 2635 p->p_memsz = 2636 alignToPowerOf2(p->p_offset + p->p_memsz, config->commonPageSize) - 2637 p->p_offset; 2638 } 2639 } 2640 } 2641 2642 // A helper struct for checkSectionOverlap. 2643 namespace { 2644 struct SectionOffset { 2645 OutputSection *sec; 2646 uint64_t offset; 2647 }; 2648 } // namespace 2649 2650 // Check whether sections overlap for a specific address range (file offsets, 2651 // load and virtual addresses). 2652 static void checkOverlap(StringRef name, std::vector<SectionOffset> §ions, 2653 bool isVirtualAddr) { 2654 llvm::sort(sections, [=](const SectionOffset &a, const SectionOffset &b) { 2655 return a.offset < b.offset; 2656 }); 2657 2658 // Finding overlap is easy given a vector is sorted by start position. 2659 // If an element starts before the end of the previous element, they overlap. 2660 for (size_t i = 1, end = sections.size(); i < end; ++i) { 2661 SectionOffset a = sections[i - 1]; 2662 SectionOffset b = sections[i]; 2663 if (b.offset >= a.offset + a.sec->size) 2664 continue; 2665 2666 // If both sections are in OVERLAY we allow the overlapping of virtual 2667 // addresses, because it is what OVERLAY was designed for. 2668 if (isVirtualAddr && a.sec->inOverlay && b.sec->inOverlay) 2669 continue; 2670 2671 errorOrWarn("section " + a.sec->name + " " + name + 2672 " range overlaps with " + b.sec->name + "\n>>> " + a.sec->name + 2673 " range is " + rangeToString(a.offset, a.sec->size) + "\n>>> " + 2674 b.sec->name + " range is " + 2675 rangeToString(b.offset, b.sec->size)); 2676 } 2677 } 2678 2679 // Check for overlapping sections and address overflows. 2680 // 2681 // In this function we check that none of the output sections have overlapping 2682 // file offsets. For SHF_ALLOC sections we also check that the load address 2683 // ranges and the virtual address ranges don't overlap 2684 template <class ELFT> void Writer<ELFT>::checkSections() { 2685 // First, check that section's VAs fit in available address space for target. 2686 for (OutputSection *os : outputSections) 2687 if ((os->addr + os->size < os->addr) || 2688 (!ELFT::Is64Bits && os->addr + os->size > uint64_t(UINT32_MAX) + 1)) 2689 errorOrWarn("section " + os->name + " at 0x" + utohexstr(os->addr) + 2690 " of size 0x" + utohexstr(os->size) + 2691 " exceeds available address space"); 2692 2693 // Check for overlapping file offsets. In this case we need to skip any 2694 // section marked as SHT_NOBITS. These sections don't actually occupy space in 2695 // the file so Sec->Offset + Sec->Size can overlap with others. If --oformat 2696 // binary is specified only add SHF_ALLOC sections are added to the output 2697 // file so we skip any non-allocated sections in that case. 2698 std::vector<SectionOffset> fileOffs; 2699 for (OutputSection *sec : outputSections) 2700 if (sec->size > 0 && sec->type != SHT_NOBITS && 2701 (!config->oFormatBinary || (sec->flags & SHF_ALLOC))) 2702 fileOffs.push_back({sec, sec->offset}); 2703 checkOverlap("file", fileOffs, false); 2704 2705 // When linking with -r there is no need to check for overlapping virtual/load 2706 // addresses since those addresses will only be assigned when the final 2707 // executable/shared object is created. 2708 if (config->relocatable) 2709 return; 2710 2711 // Checking for overlapping virtual and load addresses only needs to take 2712 // into account SHF_ALLOC sections since others will not be loaded. 2713 // Furthermore, we also need to skip SHF_TLS sections since these will be 2714 // mapped to other addresses at runtime and can therefore have overlapping 2715 // ranges in the file. 2716 std::vector<SectionOffset> vmas; 2717 for (OutputSection *sec : outputSections) 2718 if (sec->size > 0 && (sec->flags & SHF_ALLOC) && !(sec->flags & SHF_TLS)) 2719 vmas.push_back({sec, sec->addr}); 2720 checkOverlap("virtual address", vmas, true); 2721 2722 // Finally, check that the load addresses don't overlap. This will usually be 2723 // the same as the virtual addresses but can be different when using a linker 2724 // script with AT(). 2725 std::vector<SectionOffset> lmas; 2726 for (OutputSection *sec : outputSections) 2727 if (sec->size > 0 && (sec->flags & SHF_ALLOC) && !(sec->flags & SHF_TLS)) 2728 lmas.push_back({sec, sec->getLMA()}); 2729 checkOverlap("load address", lmas, false); 2730 } 2731 2732 // The entry point address is chosen in the following ways. 2733 // 2734 // 1. the '-e' entry command-line option; 2735 // 2. the ENTRY(symbol) command in a linker control script; 2736 // 3. the value of the symbol _start, if present; 2737 // 4. the number represented by the entry symbol, if it is a number; 2738 // 5. the address 0. 2739 static uint64_t getEntryAddr() { 2740 // Case 1, 2 or 3 2741 if (Symbol *b = symtab.find(config->entry)) 2742 return b->getVA(); 2743 2744 // Case 4 2745 uint64_t addr; 2746 if (to_integer(config->entry, addr)) 2747 return addr; 2748 2749 // Case 5 2750 if (config->warnMissingEntry) 2751 warn("cannot find entry symbol " + config->entry + 2752 "; not setting start address"); 2753 return 0; 2754 } 2755 2756 static uint16_t getELFType() { 2757 if (config->isPic) 2758 return ET_DYN; 2759 if (config->relocatable) 2760 return ET_REL; 2761 return ET_EXEC; 2762 } 2763 2764 template <class ELFT> void Writer<ELFT>::writeHeader() { 2765 writeEhdr<ELFT>(Out::bufferStart, *mainPart); 2766 writePhdrs<ELFT>(Out::bufferStart + sizeof(Elf_Ehdr), *mainPart); 2767 2768 auto *eHdr = reinterpret_cast<Elf_Ehdr *>(Out::bufferStart); 2769 eHdr->e_type = getELFType(); 2770 eHdr->e_entry = getEntryAddr(); 2771 eHdr->e_shoff = sectionHeaderOff; 2772 2773 // Write the section header table. 2774 // 2775 // The ELF header can only store numbers up to SHN_LORESERVE in the e_shnum 2776 // and e_shstrndx fields. When the value of one of these fields exceeds 2777 // SHN_LORESERVE ELF requires us to put sentinel values in the ELF header and 2778 // use fields in the section header at index 0 to store 2779 // the value. The sentinel values and fields are: 2780 // e_shnum = 0, SHdrs[0].sh_size = number of sections. 2781 // e_shstrndx = SHN_XINDEX, SHdrs[0].sh_link = .shstrtab section index. 2782 auto *sHdrs = reinterpret_cast<Elf_Shdr *>(Out::bufferStart + eHdr->e_shoff); 2783 size_t num = outputSections.size() + 1; 2784 if (num >= SHN_LORESERVE) 2785 sHdrs->sh_size = num; 2786 else 2787 eHdr->e_shnum = num; 2788 2789 uint32_t strTabIndex = in.shStrTab->getParent()->sectionIndex; 2790 if (strTabIndex >= SHN_LORESERVE) { 2791 sHdrs->sh_link = strTabIndex; 2792 eHdr->e_shstrndx = SHN_XINDEX; 2793 } else { 2794 eHdr->e_shstrndx = strTabIndex; 2795 } 2796 2797 for (OutputSection *sec : outputSections) 2798 sec->writeHeaderTo<ELFT>(++sHdrs); 2799 } 2800 2801 // Open a result file. 2802 template <class ELFT> void Writer<ELFT>::openFile() { 2803 uint64_t maxSize = config->is64 ? INT64_MAX : UINT32_MAX; 2804 if (fileSize != size_t(fileSize) || maxSize < fileSize) { 2805 std::string msg; 2806 raw_string_ostream s(msg); 2807 s << "output file too large: " << Twine(fileSize) << " bytes\n" 2808 << "section sizes:\n"; 2809 for (OutputSection *os : outputSections) 2810 s << os->name << ' ' << os->size << "\n"; 2811 error(s.str()); 2812 return; 2813 } 2814 2815 unlinkAsync(config->outputFile); 2816 unsigned flags = 0; 2817 if (!config->relocatable) 2818 flags |= FileOutputBuffer::F_executable; 2819 if (!config->mmapOutputFile) 2820 flags |= FileOutputBuffer::F_no_mmap; 2821 Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr = 2822 FileOutputBuffer::create(config->outputFile, fileSize, flags); 2823 2824 if (!bufferOrErr) { 2825 error("failed to open " + config->outputFile + ": " + 2826 llvm::toString(bufferOrErr.takeError())); 2827 return; 2828 } 2829 buffer = std::move(*bufferOrErr); 2830 Out::bufferStart = buffer->getBufferStart(); 2831 } 2832 2833 template <class ELFT> void Writer<ELFT>::writeSectionsBinary() { 2834 parallel::TaskGroup tg; 2835 for (OutputSection *sec : outputSections) 2836 if (sec->flags & SHF_ALLOC) 2837 sec->writeTo<ELFT>(Out::bufferStart + sec->offset, tg); 2838 } 2839 2840 static void fillTrap(uint8_t *i, uint8_t *end) { 2841 for (; i + 4 <= end; i += 4) 2842 memcpy(i, &target->trapInstr, 4); 2843 } 2844 2845 // Fill the last page of executable segments with trap instructions 2846 // instead of leaving them as zero. Even though it is not required by any 2847 // standard, it is in general a good thing to do for security reasons. 2848 // 2849 // We'll leave other pages in segments as-is because the rest will be 2850 // overwritten by output sections. 2851 template <class ELFT> void Writer<ELFT>::writeTrapInstr() { 2852 for (Partition &part : partitions) { 2853 // Fill the last page. 2854 for (PhdrEntry *p : part.phdrs) 2855 if (p->p_type == PT_LOAD && (p->p_flags & PF_X)) 2856 fillTrap(Out::bufferStart + 2857 alignDown(p->firstSec->offset + p->p_filesz, 4), 2858 Out::bufferStart + 2859 alignToPowerOf2(p->firstSec->offset + p->p_filesz, 2860 config->maxPageSize)); 2861 2862 // Round up the file size of the last segment to the page boundary iff it is 2863 // an executable segment to ensure that other tools don't accidentally 2864 // trim the instruction padding (e.g. when stripping the file). 2865 PhdrEntry *last = nullptr; 2866 for (PhdrEntry *p : part.phdrs) 2867 if (p->p_type == PT_LOAD) 2868 last = p; 2869 2870 if (last && (last->p_flags & PF_X)) 2871 last->p_memsz = last->p_filesz = 2872 alignToPowerOf2(last->p_filesz, config->maxPageSize); 2873 } 2874 } 2875 2876 // Write section contents to a mmap'ed file. 2877 template <class ELFT> void Writer<ELFT>::writeSections() { 2878 llvm::TimeTraceScope timeScope("Write sections"); 2879 2880 { 2881 // In -r or --emit-relocs mode, write the relocation sections first as in 2882 // ELf_Rel targets we might find out that we need to modify the relocated 2883 // section while doing it. 2884 parallel::TaskGroup tg; 2885 for (OutputSection *sec : outputSections) 2886 if (sec->type == SHT_REL || sec->type == SHT_RELA) 2887 sec->writeTo<ELFT>(Out::bufferStart + sec->offset, tg); 2888 } 2889 { 2890 parallel::TaskGroup tg; 2891 for (OutputSection *sec : outputSections) 2892 if (sec->type != SHT_REL && sec->type != SHT_RELA) 2893 sec->writeTo<ELFT>(Out::bufferStart + sec->offset, tg); 2894 } 2895 2896 // Finally, check that all dynamic relocation addends were written correctly. 2897 if (config->checkDynamicRelocs && config->writeAddends) { 2898 for (OutputSection *sec : outputSections) 2899 if (sec->type == SHT_REL || sec->type == SHT_RELA) 2900 sec->checkDynRelAddends(Out::bufferStart); 2901 } 2902 } 2903 2904 // Computes a hash value of Data using a given hash function. 2905 // In order to utilize multiple cores, we first split data into 1MB 2906 // chunks, compute a hash for each chunk, and then compute a hash value 2907 // of the hash values. 2908 static void 2909 computeHash(llvm::MutableArrayRef<uint8_t> hashBuf, 2910 llvm::ArrayRef<uint8_t> data, 2911 std::function<void(uint8_t *dest, ArrayRef<uint8_t> arr)> hashFn) { 2912 std::vector<ArrayRef<uint8_t>> chunks = split(data, 1024 * 1024); 2913 const size_t hashesSize = chunks.size() * hashBuf.size(); 2914 std::unique_ptr<uint8_t[]> hashes(new uint8_t[hashesSize]); 2915 2916 // Compute hash values. 2917 parallelFor(0, chunks.size(), [&](size_t i) { 2918 hashFn(hashes.get() + i * hashBuf.size(), chunks[i]); 2919 }); 2920 2921 // Write to the final output buffer. 2922 hashFn(hashBuf.data(), ArrayRef(hashes.get(), hashesSize)); 2923 } 2924 2925 template <class ELFT> void Writer<ELFT>::writeBuildId() { 2926 if (!mainPart->buildId || !mainPart->buildId->getParent()) 2927 return; 2928 2929 if (config->buildId == BuildIdKind::Hexstring) { 2930 for (Partition &part : partitions) 2931 part.buildId->writeBuildId(config->buildIdVector); 2932 return; 2933 } 2934 2935 // Compute a hash of all sections of the output file. 2936 size_t hashSize = mainPart->buildId->hashSize; 2937 std::unique_ptr<uint8_t[]> buildId(new uint8_t[hashSize]); 2938 MutableArrayRef<uint8_t> output(buildId.get(), hashSize); 2939 llvm::ArrayRef<uint8_t> input{Out::bufferStart, size_t(fileSize)}; 2940 2941 // Fedora introduced build ID as "approximation of true uniqueness across all 2942 // binaries that might be used by overlapping sets of people". It does not 2943 // need some security goals that some hash algorithms strive to provide, e.g. 2944 // (second-)preimage and collision resistance. In practice people use 'md5' 2945 // and 'sha1' just for different lengths. Implement them with the more 2946 // efficient BLAKE3. 2947 switch (config->buildId) { 2948 case BuildIdKind::Fast: 2949 computeHash(output, input, [](uint8_t *dest, ArrayRef<uint8_t> arr) { 2950 write64le(dest, xxHash64(arr)); 2951 }); 2952 break; 2953 case BuildIdKind::Md5: 2954 computeHash(output, input, [&](uint8_t *dest, ArrayRef<uint8_t> arr) { 2955 memcpy(dest, BLAKE3::hash<16>(arr).data(), hashSize); 2956 }); 2957 break; 2958 case BuildIdKind::Sha1: 2959 computeHash(output, input, [&](uint8_t *dest, ArrayRef<uint8_t> arr) { 2960 memcpy(dest, BLAKE3::hash<20>(arr).data(), hashSize); 2961 }); 2962 break; 2963 case BuildIdKind::Uuid: 2964 if (auto ec = llvm::getRandomBytes(buildId.get(), hashSize)) 2965 error("entropy source failure: " + ec.message()); 2966 break; 2967 default: 2968 llvm_unreachable("unknown BuildIdKind"); 2969 } 2970 for (Partition &part : partitions) 2971 part.buildId->writeBuildId(output); 2972 } 2973 2974 template void elf::createSyntheticSections<ELF32LE>(); 2975 template void elf::createSyntheticSections<ELF32BE>(); 2976 template void elf::createSyntheticSections<ELF64LE>(); 2977 template void elf::createSyntheticSections<ELF64BE>(); 2978 2979 template void elf::writeResult<ELF32LE>(); 2980 template void elf::writeResult<ELF32BE>(); 2981 template void elf::writeResult<ELF64LE>(); 2982 template void elf::writeResult<ELF64BE>(); 2983