1 //===- InputSection.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 "InputSection.h" 10 #include "Config.h" 11 #include "EhFrame.h" 12 #include "InputFiles.h" 13 #include "LinkerScript.h" 14 #include "OutputSections.h" 15 #include "Relocations.h" 16 #include "SymbolTable.h" 17 #include "Symbols.h" 18 #include "SyntheticSections.h" 19 #include "Target.h" 20 #include "Thunks.h" 21 #include "lld/Common/ErrorHandler.h" 22 #include "lld/Common/Memory.h" 23 #include "llvm/Support/Compiler.h" 24 #include "llvm/Support/Compression.h" 25 #include "llvm/Support/Endian.h" 26 #include "llvm/Support/Threading.h" 27 #include "llvm/Support/xxhash.h" 28 #include <algorithm> 29 #include <mutex> 30 #include <set> 31 #include <vector> 32 33 using namespace llvm; 34 using namespace llvm::ELF; 35 using namespace llvm::object; 36 using namespace llvm::support; 37 using namespace llvm::support::endian; 38 using namespace llvm::sys; 39 using namespace lld; 40 using namespace lld::elf; 41 42 std::vector<InputSectionBase *> elf::inputSections; 43 DenseSet<std::pair<const Symbol *, uint64_t>> elf::ppc64noTocRelax; 44 45 // Returns a string to construct an error message. 46 std::string lld::toString(const InputSectionBase *sec) { 47 return (toString(sec->file) + ":(" + sec->name + ")").str(); 48 } 49 50 template <class ELFT> 51 static ArrayRef<uint8_t> getSectionContents(ObjFile<ELFT> &file, 52 const typename ELFT::Shdr &hdr) { 53 if (hdr.sh_type == SHT_NOBITS) 54 return makeArrayRef<uint8_t>(nullptr, hdr.sh_size); 55 return check(file.getObj().getSectionContents(&hdr)); 56 } 57 58 InputSectionBase::InputSectionBase(InputFile *file, uint64_t flags, 59 uint32_t type, uint64_t entsize, 60 uint32_t link, uint32_t info, 61 uint32_t alignment, ArrayRef<uint8_t> data, 62 StringRef name, Kind sectionKind) 63 : SectionBase(sectionKind, name, flags, entsize, alignment, type, info, 64 link), 65 file(file), rawData(data) { 66 // In order to reduce memory allocation, we assume that mergeable 67 // sections are smaller than 4 GiB, which is not an unreasonable 68 // assumption as of 2017. 69 if (sectionKind == SectionBase::Merge && rawData.size() > UINT32_MAX) 70 error(toString(this) + ": section too large"); 71 72 numRelocations = 0; 73 areRelocsRela = false; 74 75 // The ELF spec states that a value of 0 means the section has 76 // no alignment constraints. 77 uint32_t v = std::max<uint32_t>(alignment, 1); 78 if (!isPowerOf2_64(v)) 79 fatal(toString(this) + ": sh_addralign is not a power of 2"); 80 this->alignment = v; 81 82 // In ELF, each section can be compressed by zlib, and if compressed, 83 // section name may be mangled by appending "z" (e.g. ".zdebug_info"). 84 // If that's the case, demangle section name so that we can handle a 85 // section as if it weren't compressed. 86 if ((flags & SHF_COMPRESSED) || name.startswith(".zdebug")) { 87 if (!zlib::isAvailable()) 88 error(toString(file) + ": contains a compressed section, " + 89 "but zlib is not available"); 90 parseCompressedHeader(); 91 } 92 } 93 94 // Drop SHF_GROUP bit unless we are producing a re-linkable object file. 95 // SHF_GROUP is a marker that a section belongs to some comdat group. 96 // That flag doesn't make sense in an executable. 97 static uint64_t getFlags(uint64_t flags) { 98 flags &= ~(uint64_t)SHF_INFO_LINK; 99 if (!config->relocatable) 100 flags &= ~(uint64_t)SHF_GROUP; 101 return flags; 102 } 103 104 // GNU assembler 2.24 and LLVM 4.0.0's MC (the newest release as of 105 // March 2017) fail to infer section types for sections starting with 106 // ".init_array." or ".fini_array.". They set SHT_PROGBITS instead of 107 // SHF_INIT_ARRAY. As a result, the following assembler directive 108 // creates ".init_array.100" with SHT_PROGBITS, for example. 109 // 110 // .section .init_array.100, "aw" 111 // 112 // This function forces SHT_{INIT,FINI}_ARRAY so that we can handle 113 // incorrect inputs as if they were correct from the beginning. 114 static uint64_t getType(uint64_t type, StringRef name) { 115 if (type == SHT_PROGBITS && name.startswith(".init_array.")) 116 return SHT_INIT_ARRAY; 117 if (type == SHT_PROGBITS && name.startswith(".fini_array.")) 118 return SHT_FINI_ARRAY; 119 return type; 120 } 121 122 template <class ELFT> 123 InputSectionBase::InputSectionBase(ObjFile<ELFT> &file, 124 const typename ELFT::Shdr &hdr, 125 StringRef name, Kind sectionKind) 126 : InputSectionBase(&file, getFlags(hdr.sh_flags), 127 getType(hdr.sh_type, name), hdr.sh_entsize, hdr.sh_link, 128 hdr.sh_info, hdr.sh_addralign, 129 getSectionContents(file, hdr), name, sectionKind) { 130 // We reject object files having insanely large alignments even though 131 // they are allowed by the spec. I think 4GB is a reasonable limitation. 132 // We might want to relax this in the future. 133 if (hdr.sh_addralign > UINT32_MAX) 134 fatal(toString(&file) + ": section sh_addralign is too large"); 135 } 136 137 size_t InputSectionBase::getSize() const { 138 if (auto *s = dyn_cast<SyntheticSection>(this)) 139 return s->getSize(); 140 if (uncompressedSize >= 0) 141 return uncompressedSize; 142 return rawData.size() - bytesDropped; 143 } 144 145 void InputSectionBase::uncompress() const { 146 size_t size = uncompressedSize; 147 char *uncompressedBuf; 148 { 149 static std::mutex mu; 150 std::lock_guard<std::mutex> lock(mu); 151 uncompressedBuf = bAlloc.Allocate<char>(size); 152 } 153 154 if (Error e = zlib::uncompress(toStringRef(rawData), uncompressedBuf, size)) 155 fatal(toString(this) + 156 ": uncompress failed: " + llvm::toString(std::move(e))); 157 rawData = makeArrayRef((uint8_t *)uncompressedBuf, size); 158 uncompressedSize = -1; 159 } 160 161 uint64_t InputSectionBase::getOffsetInFile() const { 162 const uint8_t *fileStart = (const uint8_t *)file->mb.getBufferStart(); 163 const uint8_t *secStart = data().begin(); 164 return secStart - fileStart; 165 } 166 167 uint64_t SectionBase::getOffset(uint64_t offset) const { 168 switch (kind()) { 169 case Output: { 170 auto *os = cast<OutputSection>(this); 171 // For output sections we treat offset -1 as the end of the section. 172 return offset == uint64_t(-1) ? os->size : offset; 173 } 174 case Regular: 175 case Synthetic: 176 return cast<InputSection>(this)->getOffset(offset); 177 case EHFrame: 178 // The file crtbeginT.o has relocations pointing to the start of an empty 179 // .eh_frame that is known to be the first in the link. It does that to 180 // identify the start of the output .eh_frame. 181 return offset; 182 case Merge: 183 const MergeInputSection *ms = cast<MergeInputSection>(this); 184 if (InputSection *isec = ms->getParent()) 185 return isec->getOffset(ms->getParentOffset(offset)); 186 return ms->getParentOffset(offset); 187 } 188 llvm_unreachable("invalid section kind"); 189 } 190 191 uint64_t SectionBase::getVA(uint64_t offset) const { 192 const OutputSection *out = getOutputSection(); 193 return (out ? out->addr : 0) + getOffset(offset); 194 } 195 196 OutputSection *SectionBase::getOutputSection() { 197 InputSection *sec; 198 if (auto *isec = dyn_cast<InputSection>(this)) 199 sec = isec; 200 else if (auto *ms = dyn_cast<MergeInputSection>(this)) 201 sec = ms->getParent(); 202 else if (auto *eh = dyn_cast<EhInputSection>(this)) 203 sec = eh->getParent(); 204 else 205 return cast<OutputSection>(this); 206 return sec ? sec->getParent() : nullptr; 207 } 208 209 // When a section is compressed, `rawData` consists with a header followed 210 // by zlib-compressed data. This function parses a header to initialize 211 // `uncompressedSize` member and remove the header from `rawData`. 212 void InputSectionBase::parseCompressedHeader() { 213 using Chdr64 = typename ELF64LE::Chdr; 214 using Chdr32 = typename ELF32LE::Chdr; 215 216 // Old-style header 217 if (name.startswith(".zdebug")) { 218 if (!toStringRef(rawData).startswith("ZLIB")) { 219 error(toString(this) + ": corrupted compressed section header"); 220 return; 221 } 222 rawData = rawData.slice(4); 223 224 if (rawData.size() < 8) { 225 error(toString(this) + ": corrupted compressed section header"); 226 return; 227 } 228 229 uncompressedSize = read64be(rawData.data()); 230 rawData = rawData.slice(8); 231 232 // Restore the original section name. 233 // (e.g. ".zdebug_info" -> ".debug_info") 234 name = saver.save("." + name.substr(2)); 235 return; 236 } 237 238 assert(flags & SHF_COMPRESSED); 239 flags &= ~(uint64_t)SHF_COMPRESSED; 240 241 // New-style 64-bit header 242 if (config->is64) { 243 if (rawData.size() < sizeof(Chdr64)) { 244 error(toString(this) + ": corrupted compressed section"); 245 return; 246 } 247 248 auto *hdr = reinterpret_cast<const Chdr64 *>(rawData.data()); 249 if (hdr->ch_type != ELFCOMPRESS_ZLIB) { 250 error(toString(this) + ": unsupported compression type"); 251 return; 252 } 253 254 uncompressedSize = hdr->ch_size; 255 alignment = std::max<uint32_t>(hdr->ch_addralign, 1); 256 rawData = rawData.slice(sizeof(*hdr)); 257 return; 258 } 259 260 // New-style 32-bit header 261 if (rawData.size() < sizeof(Chdr32)) { 262 error(toString(this) + ": corrupted compressed section"); 263 return; 264 } 265 266 auto *hdr = reinterpret_cast<const Chdr32 *>(rawData.data()); 267 if (hdr->ch_type != ELFCOMPRESS_ZLIB) { 268 error(toString(this) + ": unsupported compression type"); 269 return; 270 } 271 272 uncompressedSize = hdr->ch_size; 273 alignment = std::max<uint32_t>(hdr->ch_addralign, 1); 274 rawData = rawData.slice(sizeof(*hdr)); 275 } 276 277 InputSection *InputSectionBase::getLinkOrderDep() const { 278 assert(link); 279 assert(flags & SHF_LINK_ORDER); 280 return cast<InputSection>(file->getSections()[link]); 281 } 282 283 // Find a function symbol that encloses a given location. 284 template <class ELFT> 285 Defined *InputSectionBase::getEnclosingFunction(uint64_t offset) { 286 for (Symbol *b : file->getSymbols()) 287 if (Defined *d = dyn_cast<Defined>(b)) 288 if (d->section == this && d->type == STT_FUNC && d->value <= offset && 289 offset < d->value + d->size) 290 return d; 291 return nullptr; 292 } 293 294 // Returns a source location string. Used to construct an error message. 295 template <class ELFT> 296 std::string InputSectionBase::getLocation(uint64_t offset) { 297 std::string secAndOffset = (name + "+0x" + utohexstr(offset)).str(); 298 299 // We don't have file for synthetic sections. 300 if (getFile<ELFT>() == nullptr) 301 return (config->outputFile + ":(" + secAndOffset + ")") 302 .str(); 303 304 // First check if we can get desired values from debugging information. 305 if (Optional<DILineInfo> info = getFile<ELFT>()->getDILineInfo(this, offset)) 306 return info->FileName + ":" + std::to_string(info->Line) + ":(" + 307 secAndOffset + ")"; 308 309 // File->sourceFile contains STT_FILE symbol that contains a 310 // source file name. If it's missing, we use an object file name. 311 std::string srcFile = std::string(getFile<ELFT>()->sourceFile); 312 if (srcFile.empty()) 313 srcFile = toString(file); 314 315 if (Defined *d = getEnclosingFunction<ELFT>(offset)) 316 return srcFile + ":(function " + toString(*d) + ": " + secAndOffset + ")"; 317 318 // If there's no symbol, print out the offset in the section. 319 return (srcFile + ":(" + secAndOffset + ")"); 320 } 321 322 // This function is intended to be used for constructing an error message. 323 // The returned message looks like this: 324 // 325 // foo.c:42 (/home/alice/possibly/very/long/path/foo.c:42) 326 // 327 // Returns an empty string if there's no way to get line info. 328 std::string InputSectionBase::getSrcMsg(const Symbol &sym, uint64_t offset) { 329 return file->getSrcMsg(sym, *this, offset); 330 } 331 332 // Returns a filename string along with an optional section name. This 333 // function is intended to be used for constructing an error 334 // message. The returned message looks like this: 335 // 336 // path/to/foo.o:(function bar) 337 // 338 // or 339 // 340 // path/to/foo.o:(function bar) in archive path/to/bar.a 341 std::string InputSectionBase::getObjMsg(uint64_t off) { 342 std::string filename = std::string(file->getName()); 343 344 std::string archive; 345 if (!file->archiveName.empty()) 346 archive = " in archive " + file->archiveName; 347 348 // Find a symbol that encloses a given location. 349 for (Symbol *b : file->getSymbols()) 350 if (auto *d = dyn_cast<Defined>(b)) 351 if (d->section == this && d->value <= off && off < d->value + d->size) 352 return filename + ":(" + toString(*d) + ")" + archive; 353 354 // If there's no symbol, print out the offset in the section. 355 return (filename + ":(" + name + "+0x" + utohexstr(off) + ")" + archive) 356 .str(); 357 } 358 359 InputSection InputSection::discarded(nullptr, 0, 0, 0, ArrayRef<uint8_t>(), ""); 360 361 InputSection::InputSection(InputFile *f, uint64_t flags, uint32_t type, 362 uint32_t alignment, ArrayRef<uint8_t> data, 363 StringRef name, Kind k) 364 : InputSectionBase(f, flags, type, 365 /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, alignment, data, 366 name, k) {} 367 368 template <class ELFT> 369 InputSection::InputSection(ObjFile<ELFT> &f, const typename ELFT::Shdr &header, 370 StringRef name) 371 : InputSectionBase(f, header, name, InputSectionBase::Regular) {} 372 373 bool InputSection::classof(const SectionBase *s) { 374 return s->kind() == SectionBase::Regular || 375 s->kind() == SectionBase::Synthetic; 376 } 377 378 OutputSection *InputSection::getParent() const { 379 return cast_or_null<OutputSection>(parent); 380 } 381 382 // Copy SHT_GROUP section contents. Used only for the -r option. 383 template <class ELFT> void InputSection::copyShtGroup(uint8_t *buf) { 384 // ELFT::Word is the 32-bit integral type in the target endianness. 385 using u32 = typename ELFT::Word; 386 ArrayRef<u32> from = getDataAs<u32>(); 387 auto *to = reinterpret_cast<u32 *>(buf); 388 389 // The first entry is not a section number but a flag. 390 *to++ = from[0]; 391 392 // Adjust section numbers because section numbers in an input object 393 // files are different in the output. 394 ArrayRef<InputSectionBase *> sections = file->getSections(); 395 for (uint32_t idx : from.slice(1)) 396 *to++ = sections[idx]->getOutputSection()->sectionIndex; 397 } 398 399 InputSectionBase *InputSection::getRelocatedSection() const { 400 if (!file || (type != SHT_RELA && type != SHT_REL)) 401 return nullptr; 402 ArrayRef<InputSectionBase *> sections = file->getSections(); 403 return sections[info]; 404 } 405 406 // This is used for -r and --emit-relocs. We can't use memcpy to copy 407 // relocations because we need to update symbol table offset and section index 408 // for each relocation. So we copy relocations one by one. 409 template <class ELFT, class RelTy> 410 void InputSection::copyRelocations(uint8_t *buf, ArrayRef<RelTy> rels) { 411 InputSectionBase *sec = getRelocatedSection(); 412 413 for (const RelTy &rel : rels) { 414 RelType type = rel.getType(config->isMips64EL); 415 const ObjFile<ELFT> *file = getFile<ELFT>(); 416 Symbol &sym = file->getRelocTargetSym(rel); 417 418 auto *p = reinterpret_cast<typename ELFT::Rela *>(buf); 419 buf += sizeof(RelTy); 420 421 if (RelTy::IsRela) 422 p->r_addend = getAddend<ELFT>(rel); 423 424 // Output section VA is zero for -r, so r_offset is an offset within the 425 // section, but for --emit-relocs it is a virtual address. 426 p->r_offset = sec->getVA(rel.r_offset); 427 p->setSymbolAndType(in.symTab->getSymbolIndex(&sym), type, 428 config->isMips64EL); 429 430 if (sym.type == STT_SECTION) { 431 // We combine multiple section symbols into only one per 432 // section. This means we have to update the addend. That is 433 // trivial for Elf_Rela, but for Elf_Rel we have to write to the 434 // section data. We do that by adding to the Relocation vector. 435 436 // .eh_frame is horribly special and can reference discarded sections. To 437 // avoid having to parse and recreate .eh_frame, we just replace any 438 // relocation in it pointing to discarded sections with R_*_NONE, which 439 // hopefully creates a frame that is ignored at runtime. Also, don't warn 440 // on .gcc_except_table and debug sections. 441 // 442 // See the comment in maybeReportUndefined for PPC32 .got2 and PPC64 .toc 443 auto *d = dyn_cast<Defined>(&sym); 444 if (!d) { 445 if (!isDebugSection(*sec) && sec->name != ".eh_frame" && 446 sec->name != ".gcc_except_table" && sec->name != ".got2" && 447 sec->name != ".toc") { 448 uint32_t secIdx = cast<Undefined>(sym).discardedSecIdx; 449 Elf_Shdr_Impl<ELFT> sec = 450 CHECK(file->getObj().sections(), file)[secIdx]; 451 warn("relocation refers to a discarded section: " + 452 CHECK(file->getObj().getSectionName(&sec), file) + 453 "\n>>> referenced by " + getObjMsg(p->r_offset)); 454 } 455 p->setSymbolAndType(0, 0, false); 456 continue; 457 } 458 SectionBase *section = d->section->repl; 459 if (!section->isLive()) { 460 p->setSymbolAndType(0, 0, false); 461 continue; 462 } 463 464 int64_t addend = getAddend<ELFT>(rel); 465 const uint8_t *bufLoc = sec->data().begin() + rel.r_offset; 466 if (!RelTy::IsRela) 467 addend = target->getImplicitAddend(bufLoc, type); 468 469 if (config->emachine == EM_MIPS && 470 target->getRelExpr(type, sym, bufLoc) == R_MIPS_GOTREL) { 471 // Some MIPS relocations depend on "gp" value. By default, 472 // this value has 0x7ff0 offset from a .got section. But 473 // relocatable files produced by a compiler or a linker 474 // might redefine this default value and we must use it 475 // for a calculation of the relocation result. When we 476 // generate EXE or DSO it's trivial. Generating a relocatable 477 // output is more difficult case because the linker does 478 // not calculate relocations in this mode and loses 479 // individual "gp" values used by each input object file. 480 // As a workaround we add the "gp" value to the relocation 481 // addend and save it back to the file. 482 addend += sec->getFile<ELFT>()->mipsGp0; 483 } 484 485 if (RelTy::IsRela) 486 p->r_addend = sym.getVA(addend) - section->getOutputSection()->addr; 487 else if (config->relocatable && type != target->noneRel) 488 sec->relocations.push_back({R_ABS, type, rel.r_offset, addend, &sym}); 489 } else if (config->emachine == EM_PPC && type == R_PPC_PLTREL24 && 490 p->r_addend >= 0x8000) { 491 // Similar to R_MIPS_GPREL{16,32}. If the addend of R_PPC_PLTREL24 492 // indicates that r30 is relative to the input section .got2 493 // (r_addend>=0x8000), after linking, r30 should be relative to the output 494 // section .got2 . To compensate for the shift, adjust r_addend by 495 // ppc32Got2OutSecOff. 496 p->r_addend += sec->file->ppc32Got2OutSecOff; 497 } 498 } 499 } 500 501 // The ARM and AArch64 ABI handle pc-relative relocations to undefined weak 502 // references specially. The general rule is that the value of the symbol in 503 // this context is the address of the place P. A further special case is that 504 // branch relocations to an undefined weak reference resolve to the next 505 // instruction. 506 static uint32_t getARMUndefinedRelativeWeakVA(RelType type, uint32_t a, 507 uint32_t p) { 508 switch (type) { 509 // Unresolved branch relocations to weak references resolve to next 510 // instruction, this will be either 2 or 4 bytes on from P. 511 case R_ARM_THM_JUMP11: 512 return p + 2 + a; 513 case R_ARM_CALL: 514 case R_ARM_JUMP24: 515 case R_ARM_PC24: 516 case R_ARM_PLT32: 517 case R_ARM_PREL31: 518 case R_ARM_THM_JUMP19: 519 case R_ARM_THM_JUMP24: 520 return p + 4 + a; 521 case R_ARM_THM_CALL: 522 // We don't want an interworking BLX to ARM 523 return p + 5 + a; 524 // Unresolved non branch pc-relative relocations 525 // R_ARM_TARGET2 which can be resolved relatively is not present as it never 526 // targets a weak-reference. 527 case R_ARM_MOVW_PREL_NC: 528 case R_ARM_MOVT_PREL: 529 case R_ARM_REL32: 530 case R_ARM_THM_ALU_PREL_11_0: 531 case R_ARM_THM_MOVW_PREL_NC: 532 case R_ARM_THM_MOVT_PREL: 533 case R_ARM_THM_PC12: 534 return p + a; 535 // p + a is unrepresentable as negative immediates can't be encoded. 536 case R_ARM_THM_PC8: 537 return p; 538 } 539 llvm_unreachable("ARM pc-relative relocation expected\n"); 540 } 541 542 // The comment above getARMUndefinedRelativeWeakVA applies to this function. 543 static uint64_t getAArch64UndefinedRelativeWeakVA(uint64_t type, uint64_t a, 544 uint64_t p) { 545 switch (type) { 546 // Unresolved branch relocations to weak references resolve to next 547 // instruction, this is 4 bytes on from P. 548 case R_AARCH64_CALL26: 549 case R_AARCH64_CONDBR19: 550 case R_AARCH64_JUMP26: 551 case R_AARCH64_TSTBR14: 552 return p + 4 + a; 553 // Unresolved non branch pc-relative relocations 554 case R_AARCH64_PREL16: 555 case R_AARCH64_PREL32: 556 case R_AARCH64_PREL64: 557 case R_AARCH64_ADR_PREL_LO21: 558 case R_AARCH64_LD_PREL_LO19: 559 case R_AARCH64_PLT32: 560 return p + a; 561 } 562 llvm_unreachable("AArch64 pc-relative relocation expected\n"); 563 } 564 565 // ARM SBREL relocations are of the form S + A - B where B is the static base 566 // The ARM ABI defines base to be "addressing origin of the output segment 567 // defining the symbol S". We defined the "addressing origin"/static base to be 568 // the base of the PT_LOAD segment containing the Sym. 569 // The procedure call standard only defines a Read Write Position Independent 570 // RWPI variant so in practice we should expect the static base to be the base 571 // of the RW segment. 572 static uint64_t getARMStaticBase(const Symbol &sym) { 573 OutputSection *os = sym.getOutputSection(); 574 if (!os || !os->ptLoad || !os->ptLoad->firstSec) 575 fatal("SBREL relocation to " + sym.getName() + " without static base"); 576 return os->ptLoad->firstSec->addr; 577 } 578 579 // For R_RISCV_PC_INDIRECT (R_RISCV_PCREL_LO12_{I,S}), the symbol actually 580 // points the corresponding R_RISCV_PCREL_HI20 relocation, and the target VA 581 // is calculated using PCREL_HI20's symbol. 582 // 583 // This function returns the R_RISCV_PCREL_HI20 relocation from 584 // R_RISCV_PCREL_LO12's symbol and addend. 585 static Relocation *getRISCVPCRelHi20(const Symbol *sym, uint64_t addend) { 586 const Defined *d = cast<Defined>(sym); 587 if (!d->section) { 588 error("R_RISCV_PCREL_LO12 relocation points to an absolute symbol: " + 589 sym->getName()); 590 return nullptr; 591 } 592 InputSection *isec = cast<InputSection>(d->section); 593 594 if (addend != 0) 595 warn("Non-zero addend in R_RISCV_PCREL_LO12 relocation to " + 596 isec->getObjMsg(d->value) + " is ignored"); 597 598 // Relocations are sorted by offset, so we can use std::equal_range to do 599 // binary search. 600 Relocation r; 601 r.offset = d->value; 602 auto range = 603 std::equal_range(isec->relocations.begin(), isec->relocations.end(), r, 604 [](const Relocation &lhs, const Relocation &rhs) { 605 return lhs.offset < rhs.offset; 606 }); 607 608 for (auto it = range.first; it != range.second; ++it) 609 if (it->type == R_RISCV_PCREL_HI20 || it->type == R_RISCV_GOT_HI20 || 610 it->type == R_RISCV_TLS_GD_HI20 || it->type == R_RISCV_TLS_GOT_HI20) 611 return &*it; 612 613 error("R_RISCV_PCREL_LO12 relocation points to " + isec->getObjMsg(d->value) + 614 " without an associated R_RISCV_PCREL_HI20 relocation"); 615 return nullptr; 616 } 617 618 // A TLS symbol's virtual address is relative to the TLS segment. Add a 619 // target-specific adjustment to produce a thread-pointer-relative offset. 620 static int64_t getTlsTpOffset(const Symbol &s) { 621 // On targets that support TLSDESC, _TLS_MODULE_BASE_@tpoff = 0. 622 if (&s == ElfSym::tlsModuleBase) 623 return 0; 624 625 // There are 2 TLS layouts. Among targets we support, x86 uses TLS Variant 2 626 // while most others use Variant 1. At run time TP will be aligned to p_align. 627 628 // Variant 1. TP will be followed by an optional gap (which is the size of 2 629 // pointers on ARM/AArch64, 0 on other targets), followed by alignment 630 // padding, then the static TLS blocks. The alignment padding is added so that 631 // (TP + gap + padding) is congruent to p_vaddr modulo p_align. 632 // 633 // Variant 2. Static TLS blocks, followed by alignment padding are placed 634 // before TP. The alignment padding is added so that (TP - padding - 635 // p_memsz) is congruent to p_vaddr modulo p_align. 636 PhdrEntry *tls = Out::tlsPhdr; 637 switch (config->emachine) { 638 // Variant 1. 639 case EM_ARM: 640 case EM_AARCH64: 641 return s.getVA(0) + config->wordsize * 2 + 642 ((tls->p_vaddr - config->wordsize * 2) & (tls->p_align - 1)); 643 case EM_MIPS: 644 case EM_PPC: 645 case EM_PPC64: 646 // Adjusted Variant 1. TP is placed with a displacement of 0x7000, which is 647 // to allow a signed 16-bit offset to reach 0x1000 of TCB/thread-library 648 // data and 0xf000 of the program's TLS segment. 649 return s.getVA(0) + (tls->p_vaddr & (tls->p_align - 1)) - 0x7000; 650 case EM_RISCV: 651 return s.getVA(0) + (tls->p_vaddr & (tls->p_align - 1)); 652 653 // Variant 2. 654 case EM_HEXAGON: 655 case EM_SPARCV9: 656 case EM_386: 657 case EM_X86_64: 658 return s.getVA(0) - tls->p_memsz - 659 ((-tls->p_vaddr - tls->p_memsz) & (tls->p_align - 1)); 660 default: 661 llvm_unreachable("unhandled Config->EMachine"); 662 } 663 } 664 665 uint64_t InputSectionBase::getRelocTargetVA(const InputFile *file, RelType type, 666 int64_t a, uint64_t p, 667 const Symbol &sym, RelExpr expr) { 668 switch (expr) { 669 case R_ABS: 670 case R_DTPREL: 671 case R_RELAX_TLS_LD_TO_LE_ABS: 672 case R_RELAX_GOT_PC_NOPIC: 673 case R_RISCV_ADD: 674 return sym.getVA(a); 675 case R_ADDEND: 676 return a; 677 case R_ARM_SBREL: 678 return sym.getVA(a) - getARMStaticBase(sym); 679 case R_GOT: 680 case R_RELAX_TLS_GD_TO_IE_ABS: 681 return sym.getGotVA() + a; 682 case R_GOTONLY_PC: 683 return in.got->getVA() + a - p; 684 case R_GOTPLTONLY_PC: 685 return in.gotPlt->getVA() + a - p; 686 case R_GOTREL: 687 case R_PPC64_RELAX_TOC: 688 return sym.getVA(a) - in.got->getVA(); 689 case R_GOTPLTREL: 690 return sym.getVA(a) - in.gotPlt->getVA(); 691 case R_GOTPLT: 692 case R_RELAX_TLS_GD_TO_IE_GOTPLT: 693 return sym.getGotVA() + a - in.gotPlt->getVA(); 694 case R_TLSLD_GOT_OFF: 695 case R_GOT_OFF: 696 case R_RELAX_TLS_GD_TO_IE_GOT_OFF: 697 return sym.getGotOffset() + a; 698 case R_AARCH64_GOT_PAGE_PC: 699 case R_AARCH64_RELAX_TLS_GD_TO_IE_PAGE_PC: 700 return getAArch64Page(sym.getGotVA() + a) - getAArch64Page(p); 701 case R_GOT_PC: 702 case R_RELAX_TLS_GD_TO_IE: 703 return sym.getGotVA() + a - p; 704 case R_MIPS_GOTREL: 705 return sym.getVA(a) - in.mipsGot->getGp(file); 706 case R_MIPS_GOT_GP: 707 return in.mipsGot->getGp(file) + a; 708 case R_MIPS_GOT_GP_PC: { 709 // R_MIPS_LO16 expression has R_MIPS_GOT_GP_PC type iif the target 710 // is _gp_disp symbol. In that case we should use the following 711 // formula for calculation "AHL + GP - P + 4". For details see p. 4-19 at 712 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf 713 // microMIPS variants of these relocations use slightly different 714 // expressions: AHL + GP - P + 3 for %lo() and AHL + GP - P - 1 for %hi() 715 // to correctly handle less-significant bit of the microMIPS symbol. 716 uint64_t v = in.mipsGot->getGp(file) + a - p; 717 if (type == R_MIPS_LO16 || type == R_MICROMIPS_LO16) 718 v += 4; 719 if (type == R_MICROMIPS_LO16 || type == R_MICROMIPS_HI16) 720 v -= 1; 721 return v; 722 } 723 case R_MIPS_GOT_LOCAL_PAGE: 724 // If relocation against MIPS local symbol requires GOT entry, this entry 725 // should be initialized by 'page address'. This address is high 16-bits 726 // of sum the symbol's value and the addend. 727 return in.mipsGot->getVA() + in.mipsGot->getPageEntryOffset(file, sym, a) - 728 in.mipsGot->getGp(file); 729 case R_MIPS_GOT_OFF: 730 case R_MIPS_GOT_OFF32: 731 // In case of MIPS if a GOT relocation has non-zero addend this addend 732 // should be applied to the GOT entry content not to the GOT entry offset. 733 // That is why we use separate expression type. 734 return in.mipsGot->getVA() + in.mipsGot->getSymEntryOffset(file, sym, a) - 735 in.mipsGot->getGp(file); 736 case R_MIPS_TLSGD: 737 return in.mipsGot->getVA() + in.mipsGot->getGlobalDynOffset(file, sym) - 738 in.mipsGot->getGp(file); 739 case R_MIPS_TLSLD: 740 return in.mipsGot->getVA() + in.mipsGot->getTlsIndexOffset(file) - 741 in.mipsGot->getGp(file); 742 case R_AARCH64_PAGE_PC: { 743 uint64_t val = sym.isUndefWeak() ? p + a : sym.getVA(a); 744 return getAArch64Page(val) - getAArch64Page(p); 745 } 746 case R_RISCV_PC_INDIRECT: { 747 if (const Relocation *hiRel = getRISCVPCRelHi20(&sym, a)) 748 return getRelocTargetVA(file, hiRel->type, hiRel->addend, sym.getVA(), 749 *hiRel->sym, hiRel->expr); 750 return 0; 751 } 752 case R_PC: 753 case R_ARM_PCA: { 754 uint64_t dest; 755 if (expr == R_ARM_PCA) 756 // Some PC relative ARM (Thumb) relocations align down the place. 757 p = p & 0xfffffffc; 758 if (sym.isUndefWeak()) { 759 // On ARM and AArch64 a branch to an undefined weak resolves to the 760 // next instruction, otherwise the place. 761 if (config->emachine == EM_ARM) 762 dest = getARMUndefinedRelativeWeakVA(type, a, p); 763 else if (config->emachine == EM_AARCH64) 764 dest = getAArch64UndefinedRelativeWeakVA(type, a, p); 765 else if (config->emachine == EM_PPC) 766 dest = p; 767 else 768 dest = sym.getVA(a); 769 } else { 770 dest = sym.getVA(a); 771 } 772 return dest - p; 773 } 774 case R_PLT: 775 return sym.getPltVA() + a; 776 case R_PLT_PC: 777 case R_PPC64_CALL_PLT: 778 return sym.getPltVA() + a - p; 779 case R_PPC32_PLTREL: 780 // R_PPC_PLTREL24 uses the addend (usually 0 or 0x8000) to indicate r30 781 // stores _GLOBAL_OFFSET_TABLE_ or .got2+0x8000. The addend is ignored for 782 // target VA computation. 783 return sym.getPltVA() - p; 784 case R_PPC64_CALL: { 785 uint64_t symVA = sym.getVA(a); 786 // If we have an undefined weak symbol, we might get here with a symbol 787 // address of zero. That could overflow, but the code must be unreachable, 788 // so don't bother doing anything at all. 789 if (!symVA) 790 return 0; 791 792 // PPC64 V2 ABI describes two entry points to a function. The global entry 793 // point is used for calls where the caller and callee (may) have different 794 // TOC base pointers and r2 needs to be modified to hold the TOC base for 795 // the callee. For local calls the caller and callee share the same 796 // TOC base and so the TOC pointer initialization code should be skipped by 797 // branching to the local entry point. 798 return symVA - p + getPPC64GlobalEntryToLocalEntryOffset(sym.stOther); 799 } 800 case R_PPC64_TOCBASE: 801 return getPPC64TocBase() + a; 802 case R_RELAX_GOT_PC: 803 return sym.getVA(a) - p; 804 case R_RELAX_TLS_GD_TO_LE: 805 case R_RELAX_TLS_IE_TO_LE: 806 case R_RELAX_TLS_LD_TO_LE: 807 case R_TLS: 808 // It is not very clear what to return if the symbol is undefined. With 809 // --noinhibit-exec, even a non-weak undefined reference may reach here. 810 // Just return A, which matches R_ABS, and the behavior of some dynamic 811 // loaders. 812 if (sym.isUndefined() || sym.isLazy()) 813 return a; 814 return getTlsTpOffset(sym) + a; 815 case R_RELAX_TLS_GD_TO_LE_NEG: 816 case R_NEG_TLS: 817 if (sym.isUndefined()) 818 return a; 819 return -getTlsTpOffset(sym) + a; 820 case R_SIZE: 821 return sym.getSize() + a; 822 case R_TLSDESC: 823 return in.got->getGlobalDynAddr(sym) + a; 824 case R_TLSDESC_PC: 825 return in.got->getGlobalDynAddr(sym) + a - p; 826 case R_AARCH64_TLSDESC_PAGE: 827 return getAArch64Page(in.got->getGlobalDynAddr(sym) + a) - 828 getAArch64Page(p); 829 case R_TLSGD_GOT: 830 return in.got->getGlobalDynOffset(sym) + a; 831 case R_TLSGD_GOTPLT: 832 return in.got->getVA() + in.got->getGlobalDynOffset(sym) + a - in.gotPlt->getVA(); 833 case R_TLSGD_PC: 834 return in.got->getGlobalDynAddr(sym) + a - p; 835 case R_TLSLD_GOTPLT: 836 return in.got->getVA() + in.got->getTlsIndexOff() + a - in.gotPlt->getVA(); 837 case R_TLSLD_GOT: 838 return in.got->getTlsIndexOff() + a; 839 case R_TLSLD_PC: 840 return in.got->getTlsIndexVA() + a - p; 841 default: 842 llvm_unreachable("invalid expression"); 843 } 844 } 845 846 // This function applies relocations to sections without SHF_ALLOC bit. 847 // Such sections are never mapped to memory at runtime. Debug sections are 848 // an example. Relocations in non-alloc sections are much easier to 849 // handle than in allocated sections because it will never need complex 850 // treatment such as GOT or PLT (because at runtime no one refers them). 851 // So, we handle relocations for non-alloc sections directly in this 852 // function as a performance optimization. 853 template <class ELFT, class RelTy> 854 void InputSection::relocateNonAlloc(uint8_t *buf, ArrayRef<RelTy> rels) { 855 const unsigned bits = sizeof(typename ELFT::uint) * 8; 856 const bool isDebug = isDebugSection(*this); 857 const bool isDebugLocOrRanges = 858 isDebug && (name == ".debug_loc" || name == ".debug_ranges"); 859 const bool isDebugLine = isDebug && name == ".debug_line"; 860 Optional<uint64_t> tombstone; 861 for (const auto &patAndValue : llvm::reverse(config->deadRelocInNonAlloc)) 862 if (patAndValue.first.match(this->name)) { 863 tombstone = patAndValue.second; 864 break; 865 } 866 867 for (const RelTy &rel : rels) { 868 RelType type = rel.getType(config->isMips64EL); 869 870 // GCC 8.0 or earlier have a bug that they emit R_386_GOTPC relocations 871 // against _GLOBAL_OFFSET_TABLE_ for .debug_info. The bug has been fixed 872 // in 2017 (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82630), but we 873 // need to keep this bug-compatible code for a while. 874 if (config->emachine == EM_386 && type == R_386_GOTPC) 875 continue; 876 877 uint64_t offset = getOffset(rel.r_offset); 878 uint8_t *bufLoc = buf + offset; 879 int64_t addend = getAddend<ELFT>(rel); 880 if (!RelTy::IsRela) 881 addend += target->getImplicitAddend(bufLoc, type); 882 883 Symbol &sym = getFile<ELFT>()->getRelocTargetSym(rel); 884 RelExpr expr = target->getRelExpr(type, sym, bufLoc); 885 if (expr == R_NONE) 886 continue; 887 888 if (expr == R_SIZE) { 889 target->relocateNoSym(bufLoc, type, 890 SignExtend64<bits>(sym.getSize() + addend)); 891 continue; 892 } 893 894 if (expr != R_ABS && expr != R_DTPREL && expr != R_RISCV_ADD) { 895 std::string msg = getLocation<ELFT>(offset) + 896 ": has non-ABS relocation " + toString(type) + 897 " against symbol '" + toString(sym) + "'"; 898 if (expr != R_PC && expr != R_ARM_PCA) { 899 error(msg); 900 return; 901 } 902 903 // If the control reaches here, we found a PC-relative relocation in a 904 // non-ALLOC section. Since non-ALLOC section is not loaded into memory 905 // at runtime, the notion of PC-relative doesn't make sense here. So, 906 // this is a usage error. However, GNU linkers historically accept such 907 // relocations without any errors and relocate them as if they were at 908 // address 0. For bug-compatibilty, we accept them with warnings. We 909 // know Steel Bank Common Lisp as of 2018 have this bug. 910 warn(msg); 911 target->relocateNoSym(bufLoc, type, 912 SignExtend64<bits>(sym.getVA(addend - offset))); 913 continue; 914 } 915 916 if (tombstone || 917 (isDebug && (type == target->symbolicRel || expr == R_DTPREL))) { 918 // Resolve relocations in .debug_* referencing (discarded symbols or ICF 919 // folded section symbols) to a tombstone value. Resolving to addend is 920 // unsatisfactory because the result address range may collide with a 921 // valid range of low address, or leave multiple CUs claiming ownership of 922 // the same range of code, which may confuse consumers. 923 // 924 // To address the problems, we use -1 as a tombstone value for most 925 // .debug_* sections. We have to ignore the addend because we don't want 926 // to resolve an address attribute (which may have a non-zero addend) to 927 // -1+addend (wrap around to a low address). 928 // 929 // R_DTPREL type relocations represent an offset into the dynamic thread 930 // vector. The computed value is st_value plus a non-negative offset. 931 // Negative values are invalid, so -1 can be used as the tombstone value. 932 // 933 // If the referenced symbol is discarded (made Undefined), or the 934 // section defining the referenced symbol is garbage collected, 935 // sym.getOutputSection() is nullptr. `ds->section->repl != ds->section` 936 // catches the ICF folded case. However, resolving a relocation in 937 // .debug_line to -1 would stop debugger users from setting breakpoints on 938 // the folded-in function, so exclude .debug_line. 939 // 940 // For pre-DWARF-v5 .debug_loc and .debug_ranges, -1 is a reserved value 941 // (base address selection entry), use 1 (which is used by GNU ld for 942 // .debug_ranges). 943 // 944 // TODO To reduce disruption, we use 0 instead of -1 as the tombstone 945 // value. Enable -1 in a future release. 946 auto *ds = dyn_cast<Defined>(&sym); 947 if (!sym.getOutputSection() || 948 (ds && ds->section->repl != ds->section && !isDebugLine)) { 949 // If -z dead-reloc-in-nonalloc= is specified, respect it. 950 const uint64_t value = tombstone ? SignExtend64<bits>(*tombstone) 951 : (isDebugLocOrRanges ? 1 : 0); 952 target->relocateNoSym(bufLoc, type, value); 953 continue; 954 } 955 } 956 target->relocateNoSym(bufLoc, type, SignExtend64<bits>(sym.getVA(addend))); 957 } 958 } 959 960 // This is used when '-r' is given. 961 // For REL targets, InputSection::copyRelocations() may store artificial 962 // relocations aimed to update addends. They are handled in relocateAlloc() 963 // for allocatable sections, and this function does the same for 964 // non-allocatable sections, such as sections with debug information. 965 static void relocateNonAllocForRelocatable(InputSection *sec, uint8_t *buf) { 966 const unsigned bits = config->is64 ? 64 : 32; 967 968 for (const Relocation &rel : sec->relocations) { 969 // InputSection::copyRelocations() adds only R_ABS relocations. 970 assert(rel.expr == R_ABS); 971 uint8_t *bufLoc = buf + rel.offset + sec->outSecOff; 972 uint64_t targetVA = SignExtend64(rel.sym->getVA(rel.addend), bits); 973 target->relocate(bufLoc, rel, targetVA); 974 } 975 } 976 977 template <class ELFT> 978 void InputSectionBase::relocate(uint8_t *buf, uint8_t *bufEnd) { 979 if (flags & SHF_EXECINSTR) 980 adjustSplitStackFunctionPrologues<ELFT>(buf, bufEnd); 981 982 if (flags & SHF_ALLOC) { 983 relocateAlloc(buf, bufEnd); 984 return; 985 } 986 987 auto *sec = cast<InputSection>(this); 988 if (config->relocatable) 989 relocateNonAllocForRelocatable(sec, buf); 990 else if (sec->areRelocsRela) 991 sec->relocateNonAlloc<ELFT>(buf, sec->template relas<ELFT>()); 992 else 993 sec->relocateNonAlloc<ELFT>(buf, sec->template rels<ELFT>()); 994 } 995 996 void InputSectionBase::relocateAlloc(uint8_t *buf, uint8_t *bufEnd) { 997 assert(flags & SHF_ALLOC); 998 const unsigned bits = config->wordsize * 8; 999 1000 for (const Relocation &rel : relocations) { 1001 if (rel.expr == R_NONE) 1002 continue; 1003 uint64_t offset = rel.offset; 1004 if (auto *sec = dyn_cast<InputSection>(this)) 1005 offset += sec->outSecOff; 1006 uint8_t *bufLoc = buf + offset; 1007 RelType type = rel.type; 1008 1009 uint64_t addrLoc = getOutputSection()->addr + offset; 1010 RelExpr expr = rel.expr; 1011 uint64_t targetVA = SignExtend64( 1012 getRelocTargetVA(file, type, rel.addend, addrLoc, *rel.sym, expr), 1013 bits); 1014 1015 switch (expr) { 1016 case R_RELAX_GOT_PC: 1017 case R_RELAX_GOT_PC_NOPIC: 1018 target->relaxGot(bufLoc, rel, targetVA); 1019 break; 1020 case R_PPC64_RELAX_TOC: 1021 // rel.sym refers to the STT_SECTION symbol associated to the .toc input 1022 // section. If an R_PPC64_TOC16_LO (.toc + addend) references the TOC 1023 // entry, there may be R_PPC64_TOC16_HA not paired with 1024 // R_PPC64_TOC16_LO_DS. Don't relax. This loses some relaxation 1025 // opportunities but is safe. 1026 if (ppc64noTocRelax.count({rel.sym, rel.addend}) || 1027 !tryRelaxPPC64TocIndirection(rel, bufLoc)) 1028 target->relocate(bufLoc, rel, targetVA); 1029 break; 1030 case R_RELAX_TLS_IE_TO_LE: 1031 target->relaxTlsIeToLe(bufLoc, rel, targetVA); 1032 break; 1033 case R_RELAX_TLS_LD_TO_LE: 1034 case R_RELAX_TLS_LD_TO_LE_ABS: 1035 target->relaxTlsLdToLe(bufLoc, rel, targetVA); 1036 break; 1037 case R_RELAX_TLS_GD_TO_LE: 1038 case R_RELAX_TLS_GD_TO_LE_NEG: 1039 target->relaxTlsGdToLe(bufLoc, rel, targetVA); 1040 break; 1041 case R_AARCH64_RELAX_TLS_GD_TO_IE_PAGE_PC: 1042 case R_RELAX_TLS_GD_TO_IE: 1043 case R_RELAX_TLS_GD_TO_IE_ABS: 1044 case R_RELAX_TLS_GD_TO_IE_GOT_OFF: 1045 case R_RELAX_TLS_GD_TO_IE_GOTPLT: 1046 target->relaxTlsGdToIe(bufLoc, rel, targetVA); 1047 break; 1048 case R_PPC64_CALL: 1049 // If this is a call to __tls_get_addr, it may be part of a TLS 1050 // sequence that has been relaxed and turned into a nop. In this 1051 // case, we don't want to handle it as a call. 1052 if (read32(bufLoc) == 0x60000000) // nop 1053 break; 1054 1055 // Patch a nop (0x60000000) to a ld. 1056 if (rel.sym->needsTocRestore) { 1057 // gcc/gfortran 5.4, 6.3 and earlier versions do not add nop for 1058 // recursive calls even if the function is preemptible. This is not 1059 // wrong in the common case where the function is not preempted at 1060 // runtime. Just ignore. 1061 if ((bufLoc + 8 > bufEnd || read32(bufLoc + 4) != 0x60000000) && 1062 rel.sym->file != file) { 1063 // Use substr(6) to remove the "__plt_" prefix. 1064 errorOrWarn(getErrorLocation(bufLoc) + "call to " + 1065 lld::toString(*rel.sym).substr(6) + 1066 " lacks nop, can't restore toc"); 1067 break; 1068 } 1069 write32(bufLoc + 4, 0xe8410018); // ld %r2, 24(%r1) 1070 } 1071 target->relocate(bufLoc, rel, targetVA); 1072 break; 1073 default: 1074 target->relocate(bufLoc, rel, targetVA); 1075 break; 1076 } 1077 } 1078 1079 // Apply jumpInstrMods. jumpInstrMods are created when the opcode of 1080 // a jmp insn must be modified to shrink the jmp insn or to flip the jmp 1081 // insn. This is primarily used to relax and optimize jumps created with 1082 // basic block sections. 1083 if (auto *sec = dyn_cast<InputSection>(this)) { 1084 for (const JumpInstrMod &jumpMod : jumpInstrMods) { 1085 uint64_t offset = jumpMod.offset + sec->outSecOff; 1086 uint8_t *bufLoc = buf + offset; 1087 target->applyJumpInstrMod(bufLoc, jumpMod.original, jumpMod.size); 1088 } 1089 } 1090 } 1091 1092 // For each function-defining prologue, find any calls to __morestack, 1093 // and replace them with calls to __morestack_non_split. 1094 static void switchMorestackCallsToMorestackNonSplit( 1095 DenseSet<Defined *> &prologues, std::vector<Relocation *> &morestackCalls) { 1096 1097 // If the target adjusted a function's prologue, all calls to 1098 // __morestack inside that function should be switched to 1099 // __morestack_non_split. 1100 Symbol *moreStackNonSplit = symtab->find("__morestack_non_split"); 1101 if (!moreStackNonSplit) { 1102 error("Mixing split-stack objects requires a definition of " 1103 "__morestack_non_split"); 1104 return; 1105 } 1106 1107 // Sort both collections to compare addresses efficiently. 1108 llvm::sort(morestackCalls, [](const Relocation *l, const Relocation *r) { 1109 return l->offset < r->offset; 1110 }); 1111 std::vector<Defined *> functions(prologues.begin(), prologues.end()); 1112 llvm::sort(functions, [](const Defined *l, const Defined *r) { 1113 return l->value < r->value; 1114 }); 1115 1116 auto it = morestackCalls.begin(); 1117 for (Defined *f : functions) { 1118 // Find the first call to __morestack within the function. 1119 while (it != morestackCalls.end() && (*it)->offset < f->value) 1120 ++it; 1121 // Adjust all calls inside the function. 1122 while (it != morestackCalls.end() && (*it)->offset < f->value + f->size) { 1123 (*it)->sym = moreStackNonSplit; 1124 ++it; 1125 } 1126 } 1127 } 1128 1129 static bool enclosingPrologueAttempted(uint64_t offset, 1130 const DenseSet<Defined *> &prologues) { 1131 for (Defined *f : prologues) 1132 if (f->value <= offset && offset < f->value + f->size) 1133 return true; 1134 return false; 1135 } 1136 1137 // If a function compiled for split stack calls a function not 1138 // compiled for split stack, then the caller needs its prologue 1139 // adjusted to ensure that the called function will have enough stack 1140 // available. Find those functions, and adjust their prologues. 1141 template <class ELFT> 1142 void InputSectionBase::adjustSplitStackFunctionPrologues(uint8_t *buf, 1143 uint8_t *end) { 1144 if (!getFile<ELFT>()->splitStack) 1145 return; 1146 DenseSet<Defined *> prologues; 1147 std::vector<Relocation *> morestackCalls; 1148 1149 for (Relocation &rel : relocations) { 1150 // Local symbols can't possibly be cross-calls, and should have been 1151 // resolved long before this line. 1152 if (rel.sym->isLocal()) 1153 continue; 1154 1155 // Ignore calls into the split-stack api. 1156 if (rel.sym->getName().startswith("__morestack")) { 1157 if (rel.sym->getName().equals("__morestack")) 1158 morestackCalls.push_back(&rel); 1159 continue; 1160 } 1161 1162 // A relocation to non-function isn't relevant. Sometimes 1163 // __morestack is not marked as a function, so this check comes 1164 // after the name check. 1165 if (rel.sym->type != STT_FUNC) 1166 continue; 1167 1168 // If the callee's-file was compiled with split stack, nothing to do. In 1169 // this context, a "Defined" symbol is one "defined by the binary currently 1170 // being produced". So an "undefined" symbol might be provided by a shared 1171 // library. It is not possible to tell how such symbols were compiled, so be 1172 // conservative. 1173 if (Defined *d = dyn_cast<Defined>(rel.sym)) 1174 if (InputSection *isec = cast_or_null<InputSection>(d->section)) 1175 if (!isec || !isec->getFile<ELFT>() || isec->getFile<ELFT>()->splitStack) 1176 continue; 1177 1178 if (enclosingPrologueAttempted(rel.offset, prologues)) 1179 continue; 1180 1181 if (Defined *f = getEnclosingFunction<ELFT>(rel.offset)) { 1182 prologues.insert(f); 1183 if (target->adjustPrologueForCrossSplitStack(buf + getOffset(f->value), 1184 end, f->stOther)) 1185 continue; 1186 if (!getFile<ELFT>()->someNoSplitStack) 1187 error(lld::toString(this) + ": " + f->getName() + 1188 " (with -fsplit-stack) calls " + rel.sym->getName() + 1189 " (without -fsplit-stack), but couldn't adjust its prologue"); 1190 } 1191 } 1192 1193 if (target->needsMoreStackNonSplit) 1194 switchMorestackCallsToMorestackNonSplit(prologues, morestackCalls); 1195 } 1196 1197 template <class ELFT> void InputSection::writeTo(uint8_t *buf) { 1198 if (type == SHT_NOBITS) 1199 return; 1200 1201 if (auto *s = dyn_cast<SyntheticSection>(this)) { 1202 s->writeTo(buf + outSecOff); 1203 return; 1204 } 1205 1206 // If -r or --emit-relocs is given, then an InputSection 1207 // may be a relocation section. 1208 if (type == SHT_RELA) { 1209 copyRelocations<ELFT>(buf + outSecOff, getDataAs<typename ELFT::Rela>()); 1210 return; 1211 } 1212 if (type == SHT_REL) { 1213 copyRelocations<ELFT>(buf + outSecOff, getDataAs<typename ELFT::Rel>()); 1214 return; 1215 } 1216 1217 // If -r is given, we may have a SHT_GROUP section. 1218 if (type == SHT_GROUP) { 1219 copyShtGroup<ELFT>(buf + outSecOff); 1220 return; 1221 } 1222 1223 // If this is a compressed section, uncompress section contents directly 1224 // to the buffer. 1225 if (uncompressedSize >= 0) { 1226 size_t size = uncompressedSize; 1227 if (Error e = zlib::uncompress(toStringRef(rawData), 1228 (char *)(buf + outSecOff), size)) 1229 fatal(toString(this) + 1230 ": uncompress failed: " + llvm::toString(std::move(e))); 1231 uint8_t *bufEnd = buf + outSecOff + size; 1232 relocate<ELFT>(buf, bufEnd); 1233 return; 1234 } 1235 1236 // Copy section contents from source object file to output file 1237 // and then apply relocations. 1238 memcpy(buf + outSecOff, data().data(), data().size()); 1239 uint8_t *bufEnd = buf + outSecOff + data().size(); 1240 relocate<ELFT>(buf, bufEnd); 1241 } 1242 1243 void InputSection::replace(InputSection *other) { 1244 alignment = std::max(alignment, other->alignment); 1245 1246 // When a section is replaced with another section that was allocated to 1247 // another partition, the replacement section (and its associated sections) 1248 // need to be placed in the main partition so that both partitions will be 1249 // able to access it. 1250 if (partition != other->partition) { 1251 partition = 1; 1252 for (InputSection *isec : dependentSections) 1253 isec->partition = 1; 1254 } 1255 1256 other->repl = repl; 1257 other->markDead(); 1258 } 1259 1260 template <class ELFT> 1261 EhInputSection::EhInputSection(ObjFile<ELFT> &f, 1262 const typename ELFT::Shdr &header, 1263 StringRef name) 1264 : InputSectionBase(f, header, name, InputSectionBase::EHFrame) {} 1265 1266 SyntheticSection *EhInputSection::getParent() const { 1267 return cast_or_null<SyntheticSection>(parent); 1268 } 1269 1270 // Returns the index of the first relocation that points to a region between 1271 // Begin and Begin+Size. 1272 template <class IntTy, class RelTy> 1273 static unsigned getReloc(IntTy begin, IntTy size, const ArrayRef<RelTy> &rels, 1274 unsigned &relocI) { 1275 // Start search from RelocI for fast access. That works because the 1276 // relocations are sorted in .eh_frame. 1277 for (unsigned n = rels.size(); relocI < n; ++relocI) { 1278 const RelTy &rel = rels[relocI]; 1279 if (rel.r_offset < begin) 1280 continue; 1281 1282 if (rel.r_offset < begin + size) 1283 return relocI; 1284 return -1; 1285 } 1286 return -1; 1287 } 1288 1289 // .eh_frame is a sequence of CIE or FDE records. 1290 // This function splits an input section into records and returns them. 1291 template <class ELFT> void EhInputSection::split() { 1292 if (areRelocsRela) 1293 split<ELFT>(relas<ELFT>()); 1294 else 1295 split<ELFT>(rels<ELFT>()); 1296 } 1297 1298 template <class ELFT, class RelTy> 1299 void EhInputSection::split(ArrayRef<RelTy> rels) { 1300 unsigned relI = 0; 1301 for (size_t off = 0, end = data().size(); off != end;) { 1302 size_t size = readEhRecordSize(this, off); 1303 pieces.emplace_back(off, this, size, getReloc(off, size, rels, relI)); 1304 // The empty record is the end marker. 1305 if (size == 4) 1306 break; 1307 off += size; 1308 } 1309 } 1310 1311 static size_t findNull(StringRef s, size_t entSize) { 1312 // Optimize the common case. 1313 if (entSize == 1) 1314 return s.find(0); 1315 1316 for (unsigned i = 0, n = s.size(); i != n; i += entSize) { 1317 const char *b = s.begin() + i; 1318 if (std::all_of(b, b + entSize, [](char c) { return c == 0; })) 1319 return i; 1320 } 1321 return StringRef::npos; 1322 } 1323 1324 SyntheticSection *MergeInputSection::getParent() const { 1325 return cast_or_null<SyntheticSection>(parent); 1326 } 1327 1328 // Split SHF_STRINGS section. Such section is a sequence of 1329 // null-terminated strings. 1330 void MergeInputSection::splitStrings(ArrayRef<uint8_t> data, size_t entSize) { 1331 size_t off = 0; 1332 bool isAlloc = flags & SHF_ALLOC; 1333 StringRef s = toStringRef(data); 1334 1335 while (!s.empty()) { 1336 size_t end = findNull(s, entSize); 1337 if (end == StringRef::npos) 1338 fatal(toString(this) + ": string is not null terminated"); 1339 size_t size = end + entSize; 1340 1341 pieces.emplace_back(off, xxHash64(s.substr(0, size)), !isAlloc); 1342 s = s.substr(size); 1343 off += size; 1344 } 1345 } 1346 1347 // Split non-SHF_STRINGS section. Such section is a sequence of 1348 // fixed size records. 1349 void MergeInputSection::splitNonStrings(ArrayRef<uint8_t> data, 1350 size_t entSize) { 1351 size_t size = data.size(); 1352 assert((size % entSize) == 0); 1353 bool isAlloc = flags & SHF_ALLOC; 1354 1355 for (size_t i = 0; i != size; i += entSize) 1356 pieces.emplace_back(i, xxHash64(data.slice(i, entSize)), !isAlloc); 1357 } 1358 1359 template <class ELFT> 1360 MergeInputSection::MergeInputSection(ObjFile<ELFT> &f, 1361 const typename ELFT::Shdr &header, 1362 StringRef name) 1363 : InputSectionBase(f, header, name, InputSectionBase::Merge) {} 1364 1365 MergeInputSection::MergeInputSection(uint64_t flags, uint32_t type, 1366 uint64_t entsize, ArrayRef<uint8_t> data, 1367 StringRef name) 1368 : InputSectionBase(nullptr, flags, type, entsize, /*Link*/ 0, /*Info*/ 0, 1369 /*Alignment*/ entsize, data, name, SectionBase::Merge) {} 1370 1371 // This function is called after we obtain a complete list of input sections 1372 // that need to be linked. This is responsible to split section contents 1373 // into small chunks for further processing. 1374 // 1375 // Note that this function is called from parallelForEach. This must be 1376 // thread-safe (i.e. no memory allocation from the pools). 1377 void MergeInputSection::splitIntoPieces() { 1378 assert(pieces.empty()); 1379 1380 if (flags & SHF_STRINGS) 1381 splitStrings(data(), entsize); 1382 else 1383 splitNonStrings(data(), entsize); 1384 } 1385 1386 SectionPiece *MergeInputSection::getSectionPiece(uint64_t offset) { 1387 if (this->data().size() <= offset) 1388 fatal(toString(this) + ": offset is outside the section"); 1389 1390 // If Offset is not at beginning of a section piece, it is not in the map. 1391 // In that case we need to do a binary search of the original section piece vector. 1392 auto it = partition_point( 1393 pieces, [=](SectionPiece p) { return p.inputOff <= offset; }); 1394 return &it[-1]; 1395 } 1396 1397 // Returns the offset in an output section for a given input offset. 1398 // Because contents of a mergeable section is not contiguous in output, 1399 // it is not just an addition to a base output offset. 1400 uint64_t MergeInputSection::getParentOffset(uint64_t offset) const { 1401 // If Offset is not at beginning of a section piece, it is not in the map. 1402 // In that case we need to search from the original section piece vector. 1403 const SectionPiece &piece = 1404 *(const_cast<MergeInputSection *>(this)->getSectionPiece (offset)); 1405 uint64_t addend = offset - piece.inputOff; 1406 return piece.outputOff + addend; 1407 } 1408 1409 template InputSection::InputSection(ObjFile<ELF32LE> &, const ELF32LE::Shdr &, 1410 StringRef); 1411 template InputSection::InputSection(ObjFile<ELF32BE> &, const ELF32BE::Shdr &, 1412 StringRef); 1413 template InputSection::InputSection(ObjFile<ELF64LE> &, const ELF64LE::Shdr &, 1414 StringRef); 1415 template InputSection::InputSection(ObjFile<ELF64BE> &, const ELF64BE::Shdr &, 1416 StringRef); 1417 1418 template std::string InputSectionBase::getLocation<ELF32LE>(uint64_t); 1419 template std::string InputSectionBase::getLocation<ELF32BE>(uint64_t); 1420 template std::string InputSectionBase::getLocation<ELF64LE>(uint64_t); 1421 template std::string InputSectionBase::getLocation<ELF64BE>(uint64_t); 1422 1423 template void InputSection::writeTo<ELF32LE>(uint8_t *); 1424 template void InputSection::writeTo<ELF32BE>(uint8_t *); 1425 template void InputSection::writeTo<ELF64LE>(uint8_t *); 1426 template void InputSection::writeTo<ELF64BE>(uint8_t *); 1427 1428 template MergeInputSection::MergeInputSection(ObjFile<ELF32LE> &, 1429 const ELF32LE::Shdr &, StringRef); 1430 template MergeInputSection::MergeInputSection(ObjFile<ELF32BE> &, 1431 const ELF32BE::Shdr &, StringRef); 1432 template MergeInputSection::MergeInputSection(ObjFile<ELF64LE> &, 1433 const ELF64LE::Shdr &, StringRef); 1434 template MergeInputSection::MergeInputSection(ObjFile<ELF64BE> &, 1435 const ELF64BE::Shdr &, StringRef); 1436 1437 template EhInputSection::EhInputSection(ObjFile<ELF32LE> &, 1438 const ELF32LE::Shdr &, StringRef); 1439 template EhInputSection::EhInputSection(ObjFile<ELF32BE> &, 1440 const ELF32BE::Shdr &, StringRef); 1441 template EhInputSection::EhInputSection(ObjFile<ELF64LE> &, 1442 const ELF64LE::Shdr &, StringRef); 1443 template EhInputSection::EhInputSection(ObjFile<ELF64BE> &, 1444 const ELF64BE::Shdr &, StringRef); 1445 1446 template void EhInputSection::split<ELF32LE>(); 1447 template void EhInputSection::split<ELF32BE>(); 1448 template void EhInputSection::split<ELF64LE>(); 1449 template void EhInputSection::split<ELF64BE>(); 1450