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 40 using namespace lld; 41 using namespace lld::elf; 42 43 std::vector<InputSectionBase *> elf::inputSections; 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 constraits. 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(); 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 = 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 = 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 an 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 PPC64 .toc . 443 auto *d = dyn_cast<Defined>(&sym); 444 if (!d) { 445 if (!sec->name.startswith(".debug") && 446 !sec->name.startswith(".zdebug") && sec->name != ".eh_frame" && 447 sec->name != ".gcc_except_table" && 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 && config->relocatable && 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 complier 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 } 490 } 491 } 492 493 // The ARM and AArch64 ABI handle pc-relative relocations to undefined weak 494 // references specially. The general rule is that the value of the symbol in 495 // this context is the address of the place P. A further special case is that 496 // branch relocations to an undefined weak reference resolve to the next 497 // instruction. 498 static uint32_t getARMUndefinedRelativeWeakVA(RelType type, uint32_t a, 499 uint32_t p) { 500 switch (type) { 501 // Unresolved branch relocations to weak references resolve to next 502 // instruction, this will be either 2 or 4 bytes on from P. 503 case R_ARM_THM_JUMP11: 504 return p + 2 + a; 505 case R_ARM_CALL: 506 case R_ARM_JUMP24: 507 case R_ARM_PC24: 508 case R_ARM_PLT32: 509 case R_ARM_PREL31: 510 case R_ARM_THM_JUMP19: 511 case R_ARM_THM_JUMP24: 512 return p + 4 + a; 513 case R_ARM_THM_CALL: 514 // We don't want an interworking BLX to ARM 515 return p + 5 + a; 516 // Unresolved non branch pc-relative relocations 517 // R_ARM_TARGET2 which can be resolved relatively is not present as it never 518 // targets a weak-reference. 519 case R_ARM_MOVW_PREL_NC: 520 case R_ARM_MOVT_PREL: 521 case R_ARM_REL32: 522 case R_ARM_THM_MOVW_PREL_NC: 523 case R_ARM_THM_MOVT_PREL: 524 return p + a; 525 } 526 llvm_unreachable("ARM pc-relative relocation expected\n"); 527 } 528 529 // The comment above getARMUndefinedRelativeWeakVA applies to this function. 530 static uint64_t getAArch64UndefinedRelativeWeakVA(uint64_t type, uint64_t a, 531 uint64_t p) { 532 switch (type) { 533 // Unresolved branch relocations to weak references resolve to next 534 // instruction, this is 4 bytes on from P. 535 case R_AARCH64_CALL26: 536 case R_AARCH64_CONDBR19: 537 case R_AARCH64_JUMP26: 538 case R_AARCH64_TSTBR14: 539 return p + 4 + a; 540 // Unresolved non branch pc-relative relocations 541 case R_AARCH64_PREL16: 542 case R_AARCH64_PREL32: 543 case R_AARCH64_PREL64: 544 case R_AARCH64_ADR_PREL_LO21: 545 case R_AARCH64_LD_PREL_LO19: 546 return p + a; 547 } 548 llvm_unreachable("AArch64 pc-relative relocation expected\n"); 549 } 550 551 // ARM SBREL relocations are of the form S + A - B where B is the static base 552 // The ARM ABI defines base to be "addressing origin of the output segment 553 // defining the symbol S". We defined the "addressing origin"/static base to be 554 // the base of the PT_LOAD segment containing the Sym. 555 // The procedure call standard only defines a Read Write Position Independent 556 // RWPI variant so in practice we should expect the static base to be the base 557 // of the RW segment. 558 static uint64_t getARMStaticBase(const Symbol &sym) { 559 OutputSection *os = sym.getOutputSection(); 560 if (!os || !os->ptLoad || !os->ptLoad->firstSec) 561 fatal("SBREL relocation to " + sym.getName() + " without static base"); 562 return os->ptLoad->firstSec->addr; 563 } 564 565 // For R_RISCV_PC_INDIRECT (R_RISCV_PCREL_LO12_{I,S}), the symbol actually 566 // points the corresponding R_RISCV_PCREL_HI20 relocation, and the target VA 567 // is calculated using PCREL_HI20's symbol. 568 // 569 // This function returns the R_RISCV_PCREL_HI20 relocation from 570 // R_RISCV_PCREL_LO12's symbol and addend. 571 static Relocation *getRISCVPCRelHi20(const Symbol *sym, uint64_t addend) { 572 const Defined *d = cast<Defined>(sym); 573 if (!d->section) { 574 error("R_RISCV_PCREL_LO12 relocation points to an absolute symbol: " + 575 sym->getName()); 576 return nullptr; 577 } 578 InputSection *isec = cast<InputSection>(d->section); 579 580 if (addend != 0) 581 warn("Non-zero addend in R_RISCV_PCREL_LO12 relocation to " + 582 isec->getObjMsg(d->value) + " is ignored"); 583 584 // Relocations are sorted by offset, so we can use std::equal_range to do 585 // binary search. 586 Relocation r; 587 r.offset = d->value; 588 auto range = 589 std::equal_range(isec->relocations.begin(), isec->relocations.end(), r, 590 [](const Relocation &lhs, const Relocation &rhs) { 591 return lhs.offset < rhs.offset; 592 }); 593 594 for (auto it = range.first; it != range.second; ++it) 595 if (it->type == R_RISCV_PCREL_HI20 || it->type == R_RISCV_GOT_HI20 || 596 it->type == R_RISCV_TLS_GD_HI20 || it->type == R_RISCV_TLS_GOT_HI20) 597 return &*it; 598 599 error("R_RISCV_PCREL_LO12 relocation points to " + isec->getObjMsg(d->value) + 600 " without an associated R_RISCV_PCREL_HI20 relocation"); 601 return nullptr; 602 } 603 604 // A TLS symbol's virtual address is relative to the TLS segment. Add a 605 // target-specific adjustment to produce a thread-pointer-relative offset. 606 static int64_t getTlsTpOffset(const Symbol &s) { 607 // On targets that support TLSDESC, _TLS_MODULE_BASE_@tpoff = 0. 608 if (&s == ElfSym::tlsModuleBase) 609 return 0; 610 611 switch (config->emachine) { 612 case EM_ARM: 613 case EM_AARCH64: 614 // Variant 1. The thread pointer points to a TCB with a fixed 2-word size, 615 // followed by a variable amount of alignment padding, followed by the TLS 616 // segment. 617 return s.getVA(0) + alignTo(config->wordsize * 2, Out::tlsPhdr->p_align); 618 case EM_386: 619 case EM_X86_64: 620 // Variant 2. The TLS segment is located just before the thread pointer. 621 return s.getVA(0) - alignTo(Out::tlsPhdr->p_memsz, Out::tlsPhdr->p_align); 622 case EM_PPC: 623 case EM_PPC64: 624 // The thread pointer points to a fixed offset from the start of the 625 // executable's TLS segment. An offset of 0x7000 allows a signed 16-bit 626 // offset to reach 0x1000 of TCB/thread-library data and 0xf000 of the 627 // program's TLS segment. 628 return s.getVA(0) - 0x7000; 629 case EM_RISCV: 630 return s.getVA(0); 631 default: 632 llvm_unreachable("unhandled Config->EMachine"); 633 } 634 } 635 636 static uint64_t getRelocTargetVA(const InputFile *file, RelType type, int64_t a, 637 uint64_t p, const Symbol &sym, RelExpr expr) { 638 switch (expr) { 639 case R_ABS: 640 case R_DTPREL: 641 case R_RELAX_TLS_LD_TO_LE_ABS: 642 case R_RELAX_GOT_PC_NOPIC: 643 case R_RISCV_ADD: 644 return sym.getVA(a); 645 case R_ADDEND: 646 return a; 647 case R_ARM_SBREL: 648 return sym.getVA(a) - getARMStaticBase(sym); 649 case R_GOT: 650 case R_RELAX_TLS_GD_TO_IE_ABS: 651 return sym.getGotVA() + a; 652 case R_GOTONLY_PC: 653 return in.got->getVA() + a - p; 654 case R_GOTPLTONLY_PC: 655 return in.gotPlt->getVA() + a - p; 656 case R_GOTREL: 657 case R_PPC64_RELAX_TOC: 658 return sym.getVA(a) - in.got->getVA(); 659 case R_GOTPLTREL: 660 return sym.getVA(a) - in.gotPlt->getVA(); 661 case R_GOTPLT: 662 case R_RELAX_TLS_GD_TO_IE_GOTPLT: 663 return sym.getGotVA() + a - in.gotPlt->getVA(); 664 case R_TLSLD_GOT_OFF: 665 case R_GOT_OFF: 666 case R_RELAX_TLS_GD_TO_IE_GOT_OFF: 667 return sym.getGotOffset() + a; 668 case R_AARCH64_GOT_PAGE_PC: 669 case R_AARCH64_RELAX_TLS_GD_TO_IE_PAGE_PC: 670 return getAArch64Page(sym.getGotVA() + a) - getAArch64Page(p); 671 case R_GOT_PC: 672 case R_RELAX_TLS_GD_TO_IE: 673 return sym.getGotVA() + a - p; 674 case R_HEXAGON_GOT: 675 return sym.getGotVA() - in.gotPlt->getVA(); 676 case R_MIPS_GOTREL: 677 return sym.getVA(a) - in.mipsGot->getGp(file); 678 case R_MIPS_GOT_GP: 679 return in.mipsGot->getGp(file) + a; 680 case R_MIPS_GOT_GP_PC: { 681 // R_MIPS_LO16 expression has R_MIPS_GOT_GP_PC type iif the target 682 // is _gp_disp symbol. In that case we should use the following 683 // formula for calculation "AHL + GP - P + 4". For details see p. 4-19 at 684 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf 685 // microMIPS variants of these relocations use slightly different 686 // expressions: AHL + GP - P + 3 for %lo() and AHL + GP - P - 1 for %hi() 687 // to correctly handle less-sugnificant bit of the microMIPS symbol. 688 uint64_t v = in.mipsGot->getGp(file) + a - p; 689 if (type == R_MIPS_LO16 || type == R_MICROMIPS_LO16) 690 v += 4; 691 if (type == R_MICROMIPS_LO16 || type == R_MICROMIPS_HI16) 692 v -= 1; 693 return v; 694 } 695 case R_MIPS_GOT_LOCAL_PAGE: 696 // If relocation against MIPS local symbol requires GOT entry, this entry 697 // should be initialized by 'page address'. This address is high 16-bits 698 // of sum the symbol's value and the addend. 699 return in.mipsGot->getVA() + in.mipsGot->getPageEntryOffset(file, sym, a) - 700 in.mipsGot->getGp(file); 701 case R_MIPS_GOT_OFF: 702 case R_MIPS_GOT_OFF32: 703 // In case of MIPS if a GOT relocation has non-zero addend this addend 704 // should be applied to the GOT entry content not to the GOT entry offset. 705 // That is why we use separate expression type. 706 return in.mipsGot->getVA() + in.mipsGot->getSymEntryOffset(file, sym, a) - 707 in.mipsGot->getGp(file); 708 case R_MIPS_TLSGD: 709 return in.mipsGot->getVA() + in.mipsGot->getGlobalDynOffset(file, sym) - 710 in.mipsGot->getGp(file); 711 case R_MIPS_TLSLD: 712 return in.mipsGot->getVA() + in.mipsGot->getTlsIndexOffset(file) - 713 in.mipsGot->getGp(file); 714 case R_AARCH64_PAGE_PC: { 715 uint64_t val = sym.isUndefWeak() ? p + a : sym.getVA(a); 716 return getAArch64Page(val) - getAArch64Page(p); 717 } 718 case R_RISCV_PC_INDIRECT: { 719 if (const Relocation *hiRel = getRISCVPCRelHi20(&sym, a)) 720 return getRelocTargetVA(file, hiRel->type, hiRel->addend, sym.getVA(), 721 *hiRel->sym, hiRel->expr); 722 return 0; 723 } 724 case R_PC: { 725 uint64_t dest; 726 if (sym.isUndefWeak()) { 727 // On ARM and AArch64 a branch to an undefined weak resolves to the 728 // next instruction, otherwise the place. 729 if (config->emachine == EM_ARM) 730 dest = getARMUndefinedRelativeWeakVA(type, a, p); 731 else if (config->emachine == EM_AARCH64) 732 dest = getAArch64UndefinedRelativeWeakVA(type, a, p); 733 else if (config->emachine == EM_PPC) 734 dest = p; 735 else 736 dest = sym.getVA(a); 737 } else { 738 dest = sym.getVA(a); 739 } 740 return dest - p; 741 } 742 case R_PLT: 743 return sym.getPltVA() + a; 744 case R_PLT_PC: 745 case R_PPC64_CALL_PLT: 746 return sym.getPltVA() + a - p; 747 case R_PPC32_PLTREL: 748 // R_PPC_PLTREL24 uses the addend (usually 0 or 0x8000) to indicate r30 749 // stores _GLOBAL_OFFSET_TABLE_ or .got2+0x8000. The addend is ignored for 750 // target VA compuation. 751 return sym.getPltVA() - p; 752 case R_PPC64_CALL: { 753 uint64_t symVA = sym.getVA(a); 754 // If we have an undefined weak symbol, we might get here with a symbol 755 // address of zero. That could overflow, but the code must be unreachable, 756 // so don't bother doing anything at all. 757 if (!symVA) 758 return 0; 759 760 // PPC64 V2 ABI describes two entry points to a function. The global entry 761 // point is used for calls where the caller and callee (may) have different 762 // TOC base pointers and r2 needs to be modified to hold the TOC base for 763 // the callee. For local calls the caller and callee share the same 764 // TOC base and so the TOC pointer initialization code should be skipped by 765 // branching to the local entry point. 766 return symVA - p + getPPC64GlobalEntryToLocalEntryOffset(sym.stOther); 767 } 768 case R_PPC64_TOCBASE: 769 return getPPC64TocBase() + a; 770 case R_RELAX_GOT_PC: 771 return sym.getVA(a) - p; 772 case R_RELAX_TLS_GD_TO_LE: 773 case R_RELAX_TLS_IE_TO_LE: 774 case R_RELAX_TLS_LD_TO_LE: 775 case R_TLS: 776 // It is not very clear what to return if the symbol is undefined. With 777 // --noinhibit-exec, even a non-weak undefined reference may reach here. 778 // Just return A, which matches R_ABS, and the behavior of some dynamic 779 // loaders. 780 if (sym.isUndefined()) 781 return a; 782 return getTlsTpOffset(sym) + a; 783 case R_RELAX_TLS_GD_TO_LE_NEG: 784 case R_NEG_TLS: 785 if (sym.isUndefined()) 786 return a; 787 return -getTlsTpOffset(sym) + a; 788 case R_SIZE: 789 return sym.getSize() + a; 790 case R_TLSDESC: 791 return in.got->getGlobalDynAddr(sym) + a; 792 case R_TLSDESC_PC: 793 return in.got->getGlobalDynAddr(sym) + a - p; 794 case R_AARCH64_TLSDESC_PAGE: 795 return getAArch64Page(in.got->getGlobalDynAddr(sym) + a) - 796 getAArch64Page(p); 797 case R_TLSGD_GOT: 798 return in.got->getGlobalDynOffset(sym) + a; 799 case R_TLSGD_GOTPLT: 800 return in.got->getVA() + in.got->getGlobalDynOffset(sym) + a - in.gotPlt->getVA(); 801 case R_TLSGD_PC: 802 return in.got->getGlobalDynAddr(sym) + a - p; 803 case R_TLSLD_GOTPLT: 804 return in.got->getVA() + in.got->getTlsIndexOff() + a - in.gotPlt->getVA(); 805 case R_TLSLD_GOT: 806 return in.got->getTlsIndexOff() + a; 807 case R_TLSLD_PC: 808 return in.got->getTlsIndexVA() + a - p; 809 default: 810 llvm_unreachable("invalid expression"); 811 } 812 } 813 814 // This function applies relocations to sections without SHF_ALLOC bit. 815 // Such sections are never mapped to memory at runtime. Debug sections are 816 // an example. Relocations in non-alloc sections are much easier to 817 // handle than in allocated sections because it will never need complex 818 // treatement such as GOT or PLT (because at runtime no one refers them). 819 // So, we handle relocations for non-alloc sections directly in this 820 // function as a performance optimization. 821 template <class ELFT, class RelTy> 822 void InputSection::relocateNonAlloc(uint8_t *buf, ArrayRef<RelTy> rels) { 823 const unsigned bits = sizeof(typename ELFT::uint) * 8; 824 825 for (const RelTy &rel : rels) { 826 RelType type = rel.getType(config->isMips64EL); 827 828 // GCC 8.0 or earlier have a bug that they emit R_386_GOTPC relocations 829 // against _GLOBAL_OFFSET_TABLE_ for .debug_info. The bug has been fixed 830 // in 2017 (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82630), but we 831 // need to keep this bug-compatible code for a while. 832 if (config->emachine == EM_386 && type == R_386_GOTPC) 833 continue; 834 835 uint64_t offset = getOffset(rel.r_offset); 836 uint8_t *bufLoc = buf + offset; 837 int64_t addend = getAddend<ELFT>(rel); 838 if (!RelTy::IsRela) 839 addend += target->getImplicitAddend(bufLoc, type); 840 841 Symbol &sym = getFile<ELFT>()->getRelocTargetSym(rel); 842 RelExpr expr = target->getRelExpr(type, sym, bufLoc); 843 if (expr == R_NONE) 844 continue; 845 846 if (expr != R_ABS && expr != R_DTPREL && expr != R_RISCV_ADD) { 847 std::string msg = getLocation<ELFT>(offset) + 848 ": has non-ABS relocation " + toString(type) + 849 " against symbol '" + toString(sym) + "'"; 850 if (expr != R_PC) { 851 error(msg); 852 return; 853 } 854 855 // If the control reaches here, we found a PC-relative relocation in a 856 // non-ALLOC section. Since non-ALLOC section is not loaded into memory 857 // at runtime, the notion of PC-relative doesn't make sense here. So, 858 // this is a usage error. However, GNU linkers historically accept such 859 // relocations without any errors and relocate them as if they were at 860 // address 0. For bug-compatibilty, we accept them with warnings. We 861 // know Steel Bank Common Lisp as of 2018 have this bug. 862 warn(msg); 863 target->relocateOne(bufLoc, type, 864 SignExtend64<bits>(sym.getVA(addend - offset))); 865 continue; 866 } 867 868 if (sym.isTls() && !Out::tlsPhdr) 869 target->relocateOne(bufLoc, type, 0); 870 else 871 target->relocateOne(bufLoc, type, SignExtend64<bits>(sym.getVA(addend))); 872 } 873 } 874 875 // This is used when '-r' is given. 876 // For REL targets, InputSection::copyRelocations() may store artificial 877 // relocations aimed to update addends. They are handled in relocateAlloc() 878 // for allocatable sections, and this function does the same for 879 // non-allocatable sections, such as sections with debug information. 880 static void relocateNonAllocForRelocatable(InputSection *sec, uint8_t *buf) { 881 const unsigned bits = config->is64 ? 64 : 32; 882 883 for (const Relocation &rel : sec->relocations) { 884 // InputSection::copyRelocations() adds only R_ABS relocations. 885 assert(rel.expr == R_ABS); 886 uint8_t *bufLoc = buf + rel.offset + sec->outSecOff; 887 uint64_t targetVA = SignExtend64(rel.sym->getVA(rel.addend), bits); 888 target->relocateOne(bufLoc, rel.type, targetVA); 889 } 890 } 891 892 template <class ELFT> 893 void InputSectionBase::relocate(uint8_t *buf, uint8_t *bufEnd) { 894 if (flags & SHF_EXECINSTR) 895 adjustSplitStackFunctionPrologues<ELFT>(buf, bufEnd); 896 897 if (flags & SHF_ALLOC) { 898 relocateAlloc(buf, bufEnd); 899 return; 900 } 901 902 auto *sec = cast<InputSection>(this); 903 if (config->relocatable) 904 relocateNonAllocForRelocatable(sec, buf); 905 else if (sec->areRelocsRela) 906 sec->relocateNonAlloc<ELFT>(buf, sec->template relas<ELFT>()); 907 else 908 sec->relocateNonAlloc<ELFT>(buf, sec->template rels<ELFT>()); 909 } 910 911 void InputSectionBase::relocateAlloc(uint8_t *buf, uint8_t *bufEnd) { 912 assert(flags & SHF_ALLOC); 913 const unsigned bits = config->wordsize * 8; 914 915 for (const Relocation &rel : relocations) { 916 uint64_t offset = rel.offset; 917 if (auto *sec = dyn_cast<InputSection>(this)) 918 offset += sec->outSecOff; 919 uint8_t *bufLoc = buf + offset; 920 RelType type = rel.type; 921 922 uint64_t addrLoc = getOutputSection()->addr + offset; 923 RelExpr expr = rel.expr; 924 uint64_t targetVA = SignExtend64( 925 getRelocTargetVA(file, type, rel.addend, addrLoc, *rel.sym, expr), 926 bits); 927 928 switch (expr) { 929 case R_RELAX_GOT_PC: 930 case R_RELAX_GOT_PC_NOPIC: 931 target->relaxGot(bufLoc, type, targetVA); 932 break; 933 case R_PPC64_RELAX_TOC: 934 if (!tryRelaxPPC64TocIndirection(type, rel, bufLoc)) 935 target->relocateOne(bufLoc, type, targetVA); 936 break; 937 case R_RELAX_TLS_IE_TO_LE: 938 target->relaxTlsIeToLe(bufLoc, type, targetVA); 939 break; 940 case R_RELAX_TLS_LD_TO_LE: 941 case R_RELAX_TLS_LD_TO_LE_ABS: 942 target->relaxTlsLdToLe(bufLoc, type, targetVA); 943 break; 944 case R_RELAX_TLS_GD_TO_LE: 945 case R_RELAX_TLS_GD_TO_LE_NEG: 946 target->relaxTlsGdToLe(bufLoc, type, targetVA); 947 break; 948 case R_AARCH64_RELAX_TLS_GD_TO_IE_PAGE_PC: 949 case R_RELAX_TLS_GD_TO_IE: 950 case R_RELAX_TLS_GD_TO_IE_ABS: 951 case R_RELAX_TLS_GD_TO_IE_GOT_OFF: 952 case R_RELAX_TLS_GD_TO_IE_GOTPLT: 953 target->relaxTlsGdToIe(bufLoc, type, targetVA); 954 break; 955 case R_PPC64_CALL: 956 // If this is a call to __tls_get_addr, it may be part of a TLS 957 // sequence that has been relaxed and turned into a nop. In this 958 // case, we don't want to handle it as a call. 959 if (read32(bufLoc) == 0x60000000) // nop 960 break; 961 962 // Patch a nop (0x60000000) to a ld. 963 if (rel.sym->needsTocRestore) { 964 if (bufLoc + 8 > bufEnd || read32(bufLoc + 4) != 0x60000000) { 965 error(getErrorLocation(bufLoc) + "call lacks nop, can't restore toc"); 966 break; 967 } 968 write32(bufLoc + 4, 0xe8410018); // ld %r2, 24(%r1) 969 } 970 target->relocateOne(bufLoc, type, targetVA); 971 break; 972 default: 973 target->relocateOne(bufLoc, type, targetVA); 974 break; 975 } 976 } 977 } 978 979 // For each function-defining prologue, find any calls to __morestack, 980 // and replace them with calls to __morestack_non_split. 981 static void switchMorestackCallsToMorestackNonSplit( 982 DenseSet<Defined *> &prologues, std::vector<Relocation *> &morestackCalls) { 983 984 // If the target adjusted a function's prologue, all calls to 985 // __morestack inside that function should be switched to 986 // __morestack_non_split. 987 Symbol *moreStackNonSplit = symtab->find("__morestack_non_split"); 988 if (!moreStackNonSplit) { 989 error("Mixing split-stack objects requires a definition of " 990 "__morestack_non_split"); 991 return; 992 } 993 994 // Sort both collections to compare addresses efficiently. 995 llvm::sort(morestackCalls, [](const Relocation *l, const Relocation *r) { 996 return l->offset < r->offset; 997 }); 998 std::vector<Defined *> functions(prologues.begin(), prologues.end()); 999 llvm::sort(functions, [](const Defined *l, const Defined *r) { 1000 return l->value < r->value; 1001 }); 1002 1003 auto it = morestackCalls.begin(); 1004 for (Defined *f : functions) { 1005 // Find the first call to __morestack within the function. 1006 while (it != morestackCalls.end() && (*it)->offset < f->value) 1007 ++it; 1008 // Adjust all calls inside the function. 1009 while (it != morestackCalls.end() && (*it)->offset < f->value + f->size) { 1010 (*it)->sym = moreStackNonSplit; 1011 ++it; 1012 } 1013 } 1014 } 1015 1016 static bool enclosingPrologueAttempted(uint64_t offset, 1017 const DenseSet<Defined *> &prologues) { 1018 for (Defined *f : prologues) 1019 if (f->value <= offset && offset < f->value + f->size) 1020 return true; 1021 return false; 1022 } 1023 1024 // If a function compiled for split stack calls a function not 1025 // compiled for split stack, then the caller needs its prologue 1026 // adjusted to ensure that the called function will have enough stack 1027 // available. Find those functions, and adjust their prologues. 1028 template <class ELFT> 1029 void InputSectionBase::adjustSplitStackFunctionPrologues(uint8_t *buf, 1030 uint8_t *end) { 1031 if (!getFile<ELFT>()->splitStack) 1032 return; 1033 DenseSet<Defined *> prologues; 1034 std::vector<Relocation *> morestackCalls; 1035 1036 for (Relocation &rel : relocations) { 1037 // Local symbols can't possibly be cross-calls, and should have been 1038 // resolved long before this line. 1039 if (rel.sym->isLocal()) 1040 continue; 1041 1042 // Ignore calls into the split-stack api. 1043 if (rel.sym->getName().startswith("__morestack")) { 1044 if (rel.sym->getName().equals("__morestack")) 1045 morestackCalls.push_back(&rel); 1046 continue; 1047 } 1048 1049 // A relocation to non-function isn't relevant. Sometimes 1050 // __morestack is not marked as a function, so this check comes 1051 // after the name check. 1052 if (rel.sym->type != STT_FUNC) 1053 continue; 1054 1055 // If the callee's-file was compiled with split stack, nothing to do. In 1056 // this context, a "Defined" symbol is one "defined by the binary currently 1057 // being produced". So an "undefined" symbol might be provided by a shared 1058 // library. It is not possible to tell how such symbols were compiled, so be 1059 // conservative. 1060 if (Defined *d = dyn_cast<Defined>(rel.sym)) 1061 if (InputSection *isec = cast_or_null<InputSection>(d->section)) 1062 if (!isec || !isec->getFile<ELFT>() || isec->getFile<ELFT>()->splitStack) 1063 continue; 1064 1065 if (enclosingPrologueAttempted(rel.offset, prologues)) 1066 continue; 1067 1068 if (Defined *f = getEnclosingFunction<ELFT>(rel.offset)) { 1069 prologues.insert(f); 1070 if (target->adjustPrologueForCrossSplitStack(buf + getOffset(f->value), 1071 end, f->stOther)) 1072 continue; 1073 if (!getFile<ELFT>()->someNoSplitStack) 1074 error(lld::toString(this) + ": " + f->getName() + 1075 " (with -fsplit-stack) calls " + rel.sym->getName() + 1076 " (without -fsplit-stack), but couldn't adjust its prologue"); 1077 } 1078 } 1079 1080 if (target->needsMoreStackNonSplit) 1081 switchMorestackCallsToMorestackNonSplit(prologues, morestackCalls); 1082 } 1083 1084 template <class ELFT> void InputSection::writeTo(uint8_t *buf) { 1085 if (type == SHT_NOBITS) 1086 return; 1087 1088 if (auto *s = dyn_cast<SyntheticSection>(this)) { 1089 s->writeTo(buf + outSecOff); 1090 return; 1091 } 1092 1093 // If -r or --emit-relocs is given, then an InputSection 1094 // may be a relocation section. 1095 if (type == SHT_RELA) { 1096 copyRelocations<ELFT>(buf + outSecOff, getDataAs<typename ELFT::Rela>()); 1097 return; 1098 } 1099 if (type == SHT_REL) { 1100 copyRelocations<ELFT>(buf + outSecOff, getDataAs<typename ELFT::Rel>()); 1101 return; 1102 } 1103 1104 // If -r is given, we may have a SHT_GROUP section. 1105 if (type == SHT_GROUP) { 1106 copyShtGroup<ELFT>(buf + outSecOff); 1107 return; 1108 } 1109 1110 // If this is a compressed section, uncompress section contents directly 1111 // to the buffer. 1112 if (uncompressedSize >= 0) { 1113 size_t size = uncompressedSize; 1114 if (Error e = zlib::uncompress(toStringRef(rawData), 1115 (char *)(buf + outSecOff), size)) 1116 fatal(toString(this) + 1117 ": uncompress failed: " + llvm::toString(std::move(e))); 1118 uint8_t *bufEnd = buf + outSecOff + size; 1119 relocate<ELFT>(buf, bufEnd); 1120 return; 1121 } 1122 1123 // Copy section contents from source object file to output file 1124 // and then apply relocations. 1125 memcpy(buf + outSecOff, data().data(), data().size()); 1126 uint8_t *bufEnd = buf + outSecOff + data().size(); 1127 relocate<ELFT>(buf, bufEnd); 1128 } 1129 1130 void InputSection::replace(InputSection *other) { 1131 alignment = std::max(alignment, other->alignment); 1132 1133 // When a section is replaced with another section that was allocated to 1134 // another partition, the replacement section (and its associated sections) 1135 // need to be placed in the main partition so that both partitions will be 1136 // able to access it. 1137 if (partition != other->partition) { 1138 partition = 1; 1139 for (InputSection *isec : dependentSections) 1140 isec->partition = 1; 1141 } 1142 1143 other->repl = repl; 1144 other->markDead(); 1145 } 1146 1147 template <class ELFT> 1148 EhInputSection::EhInputSection(ObjFile<ELFT> &f, 1149 const typename ELFT::Shdr &header, 1150 StringRef name) 1151 : InputSectionBase(f, header, name, InputSectionBase::EHFrame) {} 1152 1153 SyntheticSection *EhInputSection::getParent() const { 1154 return cast_or_null<SyntheticSection>(parent); 1155 } 1156 1157 // Returns the index of the first relocation that points to a region between 1158 // Begin and Begin+Size. 1159 template <class IntTy, class RelTy> 1160 static unsigned getReloc(IntTy begin, IntTy size, const ArrayRef<RelTy> &rels, 1161 unsigned &relocI) { 1162 // Start search from RelocI for fast access. That works because the 1163 // relocations are sorted in .eh_frame. 1164 for (unsigned n = rels.size(); relocI < n; ++relocI) { 1165 const RelTy &rel = rels[relocI]; 1166 if (rel.r_offset < begin) 1167 continue; 1168 1169 if (rel.r_offset < begin + size) 1170 return relocI; 1171 return -1; 1172 } 1173 return -1; 1174 } 1175 1176 // .eh_frame is a sequence of CIE or FDE records. 1177 // This function splits an input section into records and returns them. 1178 template <class ELFT> void EhInputSection::split() { 1179 if (areRelocsRela) 1180 split<ELFT>(relas<ELFT>()); 1181 else 1182 split<ELFT>(rels<ELFT>()); 1183 } 1184 1185 template <class ELFT, class RelTy> 1186 void EhInputSection::split(ArrayRef<RelTy> rels) { 1187 unsigned relI = 0; 1188 for (size_t off = 0, end = data().size(); off != end;) { 1189 size_t size = readEhRecordSize(this, off); 1190 pieces.emplace_back(off, this, size, getReloc(off, size, rels, relI)); 1191 // The empty record is the end marker. 1192 if (size == 4) 1193 break; 1194 off += size; 1195 } 1196 } 1197 1198 static size_t findNull(StringRef s, size_t entSize) { 1199 // Optimize the common case. 1200 if (entSize == 1) 1201 return s.find(0); 1202 1203 for (unsigned i = 0, n = s.size(); i != n; i += entSize) { 1204 const char *b = s.begin() + i; 1205 if (std::all_of(b, b + entSize, [](char c) { return c == 0; })) 1206 return i; 1207 } 1208 return StringRef::npos; 1209 } 1210 1211 SyntheticSection *MergeInputSection::getParent() const { 1212 return cast_or_null<SyntheticSection>(parent); 1213 } 1214 1215 // Split SHF_STRINGS section. Such section is a sequence of 1216 // null-terminated strings. 1217 void MergeInputSection::splitStrings(ArrayRef<uint8_t> data, size_t entSize) { 1218 size_t off = 0; 1219 bool isAlloc = flags & SHF_ALLOC; 1220 StringRef s = toStringRef(data); 1221 1222 while (!s.empty()) { 1223 size_t end = findNull(s, entSize); 1224 if (end == StringRef::npos) 1225 fatal(toString(this) + ": string is not null terminated"); 1226 size_t size = end + entSize; 1227 1228 pieces.emplace_back(off, xxHash64(s.substr(0, size)), !isAlloc); 1229 s = s.substr(size); 1230 off += size; 1231 } 1232 } 1233 1234 // Split non-SHF_STRINGS section. Such section is a sequence of 1235 // fixed size records. 1236 void MergeInputSection::splitNonStrings(ArrayRef<uint8_t> data, 1237 size_t entSize) { 1238 size_t size = data.size(); 1239 assert((size % entSize) == 0); 1240 bool isAlloc = flags & SHF_ALLOC; 1241 1242 for (size_t i = 0; i != size; i += entSize) 1243 pieces.emplace_back(i, xxHash64(data.slice(i, entSize)), !isAlloc); 1244 } 1245 1246 template <class ELFT> 1247 MergeInputSection::MergeInputSection(ObjFile<ELFT> &f, 1248 const typename ELFT::Shdr &header, 1249 StringRef name) 1250 : InputSectionBase(f, header, name, InputSectionBase::Merge) {} 1251 1252 MergeInputSection::MergeInputSection(uint64_t flags, uint32_t type, 1253 uint64_t entsize, ArrayRef<uint8_t> data, 1254 StringRef name) 1255 : InputSectionBase(nullptr, flags, type, entsize, /*Link*/ 0, /*Info*/ 0, 1256 /*Alignment*/ entsize, data, name, SectionBase::Merge) {} 1257 1258 // This function is called after we obtain a complete list of input sections 1259 // that need to be linked. This is responsible to split section contents 1260 // into small chunks for further processing. 1261 // 1262 // Note that this function is called from parallelForEach. This must be 1263 // thread-safe (i.e. no memory allocation from the pools). 1264 void MergeInputSection::splitIntoPieces() { 1265 assert(pieces.empty()); 1266 1267 if (flags & SHF_STRINGS) 1268 splitStrings(data(), entsize); 1269 else 1270 splitNonStrings(data(), entsize); 1271 } 1272 1273 SectionPiece *MergeInputSection::getSectionPiece(uint64_t offset) { 1274 if (this->data().size() <= offset) 1275 fatal(toString(this) + ": offset is outside the section"); 1276 1277 // If Offset is not at beginning of a section piece, it is not in the map. 1278 // In that case we need to do a binary search of the original section piece vector. 1279 auto it = partition_point( 1280 pieces, [=](SectionPiece p) { return p.inputOff <= offset; }); 1281 return &it[-1]; 1282 } 1283 1284 // Returns the offset in an output section for a given input offset. 1285 // Because contents of a mergeable section is not contiguous in output, 1286 // it is not just an addition to a base output offset. 1287 uint64_t MergeInputSection::getParentOffset(uint64_t offset) const { 1288 // If Offset is not at beginning of a section piece, it is not in the map. 1289 // In that case we need to search from the original section piece vector. 1290 const SectionPiece &piece = 1291 *(const_cast<MergeInputSection *>(this)->getSectionPiece (offset)); 1292 uint64_t addend = offset - piece.inputOff; 1293 return piece.outputOff + addend; 1294 } 1295 1296 template InputSection::InputSection(ObjFile<ELF32LE> &, const ELF32LE::Shdr &, 1297 StringRef); 1298 template InputSection::InputSection(ObjFile<ELF32BE> &, const ELF32BE::Shdr &, 1299 StringRef); 1300 template InputSection::InputSection(ObjFile<ELF64LE> &, const ELF64LE::Shdr &, 1301 StringRef); 1302 template InputSection::InputSection(ObjFile<ELF64BE> &, const ELF64BE::Shdr &, 1303 StringRef); 1304 1305 template std::string InputSectionBase::getLocation<ELF32LE>(uint64_t); 1306 template std::string InputSectionBase::getLocation<ELF32BE>(uint64_t); 1307 template std::string InputSectionBase::getLocation<ELF64LE>(uint64_t); 1308 template std::string InputSectionBase::getLocation<ELF64BE>(uint64_t); 1309 1310 template void InputSection::writeTo<ELF32LE>(uint8_t *); 1311 template void InputSection::writeTo<ELF32BE>(uint8_t *); 1312 template void InputSection::writeTo<ELF64LE>(uint8_t *); 1313 template void InputSection::writeTo<ELF64BE>(uint8_t *); 1314 1315 template MergeInputSection::MergeInputSection(ObjFile<ELF32LE> &, 1316 const ELF32LE::Shdr &, StringRef); 1317 template MergeInputSection::MergeInputSection(ObjFile<ELF32BE> &, 1318 const ELF32BE::Shdr &, StringRef); 1319 template MergeInputSection::MergeInputSection(ObjFile<ELF64LE> &, 1320 const ELF64LE::Shdr &, StringRef); 1321 template MergeInputSection::MergeInputSection(ObjFile<ELF64BE> &, 1322 const ELF64BE::Shdr &, StringRef); 1323 1324 template EhInputSection::EhInputSection(ObjFile<ELF32LE> &, 1325 const ELF32LE::Shdr &, StringRef); 1326 template EhInputSection::EhInputSection(ObjFile<ELF32BE> &, 1327 const ELF32BE::Shdr &, StringRef); 1328 template EhInputSection::EhInputSection(ObjFile<ELF64LE> &, 1329 const ELF64LE::Shdr &, StringRef); 1330 template EhInputSection::EhInputSection(ObjFile<ELF64BE> &, 1331 const ELF64BE::Shdr &, StringRef); 1332 1333 template void EhInputSection::split<ELF32LE>(); 1334 template void EhInputSection::split<ELF32BE>(); 1335 template void EhInputSection::split<ELF64LE>(); 1336 template void EhInputSection::split<ELF64BE>(); 1337