InputSection.cpp revision 350467
1//===- InputSection.cpp ---------------------------------------------------===// 2// 3// The LLVM Linker 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "InputSection.h" 11#include "Config.h" 12#include "EhFrame.h" 13#include "InputFiles.h" 14#include "LinkerScript.h" 15#include "OutputSections.h" 16#include "Relocations.h" 17#include "SymbolTable.h" 18#include "Symbols.h" 19#include "SyntheticSections.h" 20#include "Target.h" 21#include "Thunks.h" 22#include "lld/Common/ErrorHandler.h" 23#include "lld/Common/Memory.h" 24#include "llvm/Support/Compiler.h" 25#include "llvm/Support/Compression.h" 26#include "llvm/Support/Endian.h" 27#include "llvm/Support/Threading.h" 28#include "llvm/Support/xxhash.h" 29#include <algorithm> 30#include <mutex> 31#include <set> 32#include <vector> 33 34using namespace llvm; 35using namespace llvm::ELF; 36using namespace llvm::object; 37using namespace llvm::support; 38using namespace llvm::support::endian; 39using namespace llvm::sys; 40 41using namespace lld; 42using namespace lld::elf; 43 44std::vector<InputSectionBase *> elf::InputSections; 45 46// Returns a string to construct an error message. 47std::string lld::toString(const InputSectionBase *Sec) { 48 return (toString(Sec->File) + ":(" + Sec->Name + ")").str(); 49} 50 51template <class ELFT> 52static ArrayRef<uint8_t> getSectionContents(ObjFile<ELFT> &File, 53 const typename ELFT::Shdr &Hdr) { 54 if (Hdr.sh_type == SHT_NOBITS) 55 return makeArrayRef<uint8_t>(nullptr, Hdr.sh_size); 56 return check(File.getObj().getSectionContents(&Hdr)); 57} 58 59InputSectionBase::InputSectionBase(InputFile *File, uint64_t Flags, 60 uint32_t Type, uint64_t Entsize, 61 uint32_t Link, uint32_t Info, 62 uint32_t Alignment, ArrayRef<uint8_t> Data, 63 StringRef Name, Kind SectionKind) 64 : SectionBase(SectionKind, Name, Flags, Entsize, Alignment, Type, Info, 65 Link), 66 File(File), RawData(Data) { 67 // In order to reduce memory allocation, we assume that mergeable 68 // sections are smaller than 4 GiB, which is not an unreasonable 69 // assumption as of 2017. 70 if (SectionKind == SectionBase::Merge && RawData.size() > UINT32_MAX) 71 error(toString(this) + ": section too large"); 72 73 NumRelocations = 0; 74 AreRelocsRela = false; 75 76 // The ELF spec states that a value of 0 means the section has 77 // no alignment constraits. 78 uint32_t V = std::max<uint64_t>(Alignment, 1); 79 if (!isPowerOf2_64(V)) 80 fatal(toString(File) + ": section sh_addralign is not a power of 2"); 81 this->Alignment = V; 82 83 // In ELF, each section can be compressed by zlib, and if compressed, 84 // section name may be mangled by appending "z" (e.g. ".zdebug_info"). 85 // If that's the case, demangle section name so that we can handle a 86 // section as if it weren't compressed. 87 if ((Flags & SHF_COMPRESSED) || Name.startswith(".zdebug")) { 88 if (!zlib::isAvailable()) 89 error(toString(File) + ": contains a compressed section, " + 90 "but zlib is not available"); 91 parseCompressedHeader(); 92 } 93} 94 95// Drop SHF_GROUP bit unless we are producing a re-linkable object file. 96// SHF_GROUP is a marker that a section belongs to some comdat group. 97// That flag doesn't make sense in an executable. 98static uint64_t getFlags(uint64_t Flags) { 99 Flags &= ~(uint64_t)SHF_INFO_LINK; 100 if (!Config->Relocatable) 101 Flags &= ~(uint64_t)SHF_GROUP; 102 return Flags; 103} 104 105// GNU assembler 2.24 and LLVM 4.0.0's MC (the newest release as of 106// March 2017) fail to infer section types for sections starting with 107// ".init_array." or ".fini_array.". They set SHT_PROGBITS instead of 108// SHF_INIT_ARRAY. As a result, the following assembler directive 109// creates ".init_array.100" with SHT_PROGBITS, for example. 110// 111// .section .init_array.100, "aw" 112// 113// This function forces SHT_{INIT,FINI}_ARRAY so that we can handle 114// incorrect inputs as if they were correct from the beginning. 115static uint64_t getType(uint64_t Type, StringRef Name) { 116 if (Type == SHT_PROGBITS && Name.startswith(".init_array.")) 117 return SHT_INIT_ARRAY; 118 if (Type == SHT_PROGBITS && Name.startswith(".fini_array.")) 119 return SHT_FINI_ARRAY; 120 return Type; 121} 122 123template <class ELFT> 124InputSectionBase::InputSectionBase(ObjFile<ELFT> &File, 125 const typename ELFT::Shdr &Hdr, 126 StringRef Name, Kind SectionKind) 127 : InputSectionBase(&File, getFlags(Hdr.sh_flags), 128 getType(Hdr.sh_type, Name), Hdr.sh_entsize, Hdr.sh_link, 129 Hdr.sh_info, Hdr.sh_addralign, 130 getSectionContents(File, Hdr), Name, SectionKind) { 131 // We reject object files having insanely large alignments even though 132 // they are allowed by the spec. I think 4GB is a reasonable limitation. 133 // We might want to relax this in the future. 134 if (Hdr.sh_addralign > UINT32_MAX) 135 fatal(toString(&File) + ": section sh_addralign is too large"); 136} 137 138size_t InputSectionBase::getSize() const { 139 if (auto *S = dyn_cast<SyntheticSection>(this)) 140 return S->getSize(); 141 if (UncompressedSize >= 0) 142 return UncompressedSize; 143 return RawData.size(); 144} 145 146void InputSectionBase::uncompress() const { 147 size_t Size = UncompressedSize; 148 UncompressedBuf.reset(new char[Size]); 149 150 if (Error E = 151 zlib::uncompress(toStringRef(RawData), UncompressedBuf.get(), Size)) 152 fatal(toString(this) + 153 ": uncompress failed: " + llvm::toString(std::move(E))); 154 RawData = makeArrayRef((uint8_t *)UncompressedBuf.get(), Size); 155} 156 157uint64_t InputSectionBase::getOffsetInFile() const { 158 const uint8_t *FileStart = (const uint8_t *)File->MB.getBufferStart(); 159 const uint8_t *SecStart = data().begin(); 160 return SecStart - FileStart; 161} 162 163uint64_t SectionBase::getOffset(uint64_t Offset) const { 164 switch (kind()) { 165 case Output: { 166 auto *OS = cast<OutputSection>(this); 167 // For output sections we treat offset -1 as the end of the section. 168 return Offset == uint64_t(-1) ? OS->Size : Offset; 169 } 170 case Regular: 171 case Synthetic: 172 return cast<InputSection>(this)->getOffset(Offset); 173 case EHFrame: 174 // The file crtbeginT.o has relocations pointing to the start of an empty 175 // .eh_frame that is known to be the first in the link. It does that to 176 // identify the start of the output .eh_frame. 177 return Offset; 178 case Merge: 179 const MergeInputSection *MS = cast<MergeInputSection>(this); 180 if (InputSection *IS = MS->getParent()) 181 return IS->getOffset(MS->getParentOffset(Offset)); 182 return MS->getParentOffset(Offset); 183 } 184 llvm_unreachable("invalid section kind"); 185} 186 187uint64_t SectionBase::getVA(uint64_t Offset) const { 188 const OutputSection *Out = getOutputSection(); 189 return (Out ? Out->Addr : 0) + getOffset(Offset); 190} 191 192OutputSection *SectionBase::getOutputSection() { 193 InputSection *Sec; 194 if (auto *IS = dyn_cast<InputSection>(this)) 195 Sec = IS; 196 else if (auto *MS = dyn_cast<MergeInputSection>(this)) 197 Sec = MS->getParent(); 198 else if (auto *EH = dyn_cast<EhInputSection>(this)) 199 Sec = EH->getParent(); 200 else 201 return cast<OutputSection>(this); 202 return Sec ? Sec->getParent() : nullptr; 203} 204 205// When a section is compressed, `RawData` consists with a header followed 206// by zlib-compressed data. This function parses a header to initialize 207// `UncompressedSize` member and remove the header from `RawData`. 208void InputSectionBase::parseCompressedHeader() { 209 typedef typename ELF64LE::Chdr Chdr64; 210 typedef typename ELF32LE::Chdr Chdr32; 211 212 // Old-style header 213 if (Name.startswith(".zdebug")) { 214 if (!toStringRef(RawData).startswith("ZLIB")) { 215 error(toString(this) + ": corrupted compressed section header"); 216 return; 217 } 218 RawData = RawData.slice(4); 219 220 if (RawData.size() < 8) { 221 error(toString(this) + ": corrupted compressed section header"); 222 return; 223 } 224 225 UncompressedSize = read64be(RawData.data()); 226 RawData = RawData.slice(8); 227 228 // Restore the original section name. 229 // (e.g. ".zdebug_info" -> ".debug_info") 230 Name = Saver.save("." + Name.substr(2)); 231 return; 232 } 233 234 assert(Flags & SHF_COMPRESSED); 235 Flags &= ~(uint64_t)SHF_COMPRESSED; 236 237 // New-style 64-bit header 238 if (Config->Is64) { 239 if (RawData.size() < sizeof(Chdr64)) { 240 error(toString(this) + ": corrupted compressed section"); 241 return; 242 } 243 244 auto *Hdr = reinterpret_cast<const Chdr64 *>(RawData.data()); 245 if (Hdr->ch_type != ELFCOMPRESS_ZLIB) { 246 error(toString(this) + ": unsupported compression type"); 247 return; 248 } 249 250 UncompressedSize = Hdr->ch_size; 251 Alignment = std::max<uint64_t>(Hdr->ch_addralign, 1); 252 RawData = RawData.slice(sizeof(*Hdr)); 253 return; 254 } 255 256 // New-style 32-bit header 257 if (RawData.size() < sizeof(Chdr32)) { 258 error(toString(this) + ": corrupted compressed section"); 259 return; 260 } 261 262 auto *Hdr = reinterpret_cast<const Chdr32 *>(RawData.data()); 263 if (Hdr->ch_type != ELFCOMPRESS_ZLIB) { 264 error(toString(this) + ": unsupported compression type"); 265 return; 266 } 267 268 UncompressedSize = Hdr->ch_size; 269 Alignment = std::max<uint64_t>(Hdr->ch_addralign, 1); 270 RawData = RawData.slice(sizeof(*Hdr)); 271} 272 273InputSection *InputSectionBase::getLinkOrderDep() const { 274 assert(Link); 275 assert(Flags & SHF_LINK_ORDER); 276 return cast<InputSection>(File->getSections()[Link]); 277} 278 279// Find a function symbol that encloses a given location. 280template <class ELFT> 281Defined *InputSectionBase::getEnclosingFunction(uint64_t Offset) { 282 for (Symbol *B : File->getSymbols()) 283 if (Defined *D = dyn_cast<Defined>(B)) 284 if (D->Section == this && D->Type == STT_FUNC && D->Value <= Offset && 285 Offset < D->Value + D->Size) 286 return D; 287 return nullptr; 288} 289 290// Returns a source location string. Used to construct an error message. 291template <class ELFT> 292std::string InputSectionBase::getLocation(uint64_t Offset) { 293 std::string SecAndOffset = (Name + "+0x" + utohexstr(Offset)).str(); 294 295 // We don't have file for synthetic sections. 296 if (getFile<ELFT>() == nullptr) 297 return (Config->OutputFile + ":(" + SecAndOffset + ")") 298 .str(); 299 300 // First check if we can get desired values from debugging information. 301 if (Optional<DILineInfo> Info = getFile<ELFT>()->getDILineInfo(this, Offset)) 302 return Info->FileName + ":" + std::to_string(Info->Line) + ":(" + 303 SecAndOffset + ")"; 304 305 // File->SourceFile contains STT_FILE symbol that contains a 306 // source file name. If it's missing, we use an object file name. 307 std::string SrcFile = getFile<ELFT>()->SourceFile; 308 if (SrcFile.empty()) 309 SrcFile = toString(File); 310 311 if (Defined *D = getEnclosingFunction<ELFT>(Offset)) 312 return SrcFile + ":(function " + toString(*D) + ": " + SecAndOffset + ")"; 313 314 // If there's no symbol, print out the offset in the section. 315 return (SrcFile + ":(" + SecAndOffset + ")"); 316} 317 318// This function is intended to be used for constructing an error message. 319// The returned message looks like this: 320// 321// foo.c:42 (/home/alice/possibly/very/long/path/foo.c:42) 322// 323// Returns an empty string if there's no way to get line info. 324std::string InputSectionBase::getSrcMsg(const Symbol &Sym, uint64_t Offset) { 325 return File->getSrcMsg(Sym, *this, Offset); 326} 327 328// Returns a filename string along with an optional section name. This 329// function is intended to be used for constructing an error 330// message. The returned message looks like this: 331// 332// path/to/foo.o:(function bar) 333// 334// or 335// 336// path/to/foo.o:(function bar) in archive path/to/bar.a 337std::string InputSectionBase::getObjMsg(uint64_t Off) { 338 std::string Filename = File->getName(); 339 340 std::string Archive; 341 if (!File->ArchiveName.empty()) 342 Archive = " in archive " + File->ArchiveName; 343 344 // Find a symbol that encloses a given location. 345 for (Symbol *B : File->getSymbols()) 346 if (auto *D = dyn_cast<Defined>(B)) 347 if (D->Section == this && D->Value <= Off && Off < D->Value + D->Size) 348 return Filename + ":(" + toString(*D) + ")" + Archive; 349 350 // If there's no symbol, print out the offset in the section. 351 return (Filename + ":(" + Name + "+0x" + utohexstr(Off) + ")" + Archive) 352 .str(); 353} 354 355InputSection InputSection::Discarded(nullptr, 0, 0, 0, ArrayRef<uint8_t>(), ""); 356 357InputSection::InputSection(InputFile *F, uint64_t Flags, uint32_t Type, 358 uint32_t Alignment, ArrayRef<uint8_t> Data, 359 StringRef Name, Kind K) 360 : InputSectionBase(F, Flags, Type, 361 /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Alignment, Data, 362 Name, K) {} 363 364template <class ELFT> 365InputSection::InputSection(ObjFile<ELFT> &F, const typename ELFT::Shdr &Header, 366 StringRef Name) 367 : InputSectionBase(F, Header, Name, InputSectionBase::Regular) {} 368 369bool InputSection::classof(const SectionBase *S) { 370 return S->kind() == SectionBase::Regular || 371 S->kind() == SectionBase::Synthetic; 372} 373 374OutputSection *InputSection::getParent() const { 375 return cast_or_null<OutputSection>(Parent); 376} 377 378// Copy SHT_GROUP section contents. Used only for the -r option. 379template <class ELFT> void InputSection::copyShtGroup(uint8_t *Buf) { 380 // ELFT::Word is the 32-bit integral type in the target endianness. 381 typedef typename ELFT::Word u32; 382 ArrayRef<u32> From = getDataAs<u32>(); 383 auto *To = reinterpret_cast<u32 *>(Buf); 384 385 // The first entry is not a section number but a flag. 386 *To++ = From[0]; 387 388 // Adjust section numbers because section numbers in an input object 389 // files are different in the output. 390 ArrayRef<InputSectionBase *> Sections = File->getSections(); 391 for (uint32_t Idx : From.slice(1)) 392 *To++ = Sections[Idx]->getOutputSection()->SectionIndex; 393} 394 395InputSectionBase *InputSection::getRelocatedSection() const { 396 if (!File || (Type != SHT_RELA && Type != SHT_REL)) 397 return nullptr; 398 ArrayRef<InputSectionBase *> Sections = File->getSections(); 399 return Sections[Info]; 400} 401 402// This is used for -r and --emit-relocs. We can't use memcpy to copy 403// relocations because we need to update symbol table offset and section index 404// for each relocation. So we copy relocations one by one. 405template <class ELFT, class RelTy> 406void InputSection::copyRelocations(uint8_t *Buf, ArrayRef<RelTy> Rels) { 407 InputSectionBase *Sec = getRelocatedSection(); 408 409 for (const RelTy &Rel : Rels) { 410 RelType Type = Rel.getType(Config->IsMips64EL); 411 Symbol &Sym = getFile<ELFT>()->getRelocTargetSym(Rel); 412 413 auto *P = reinterpret_cast<typename ELFT::Rela *>(Buf); 414 Buf += sizeof(RelTy); 415 416 if (RelTy::IsRela) 417 P->r_addend = getAddend<ELFT>(Rel); 418 419 // Output section VA is zero for -r, so r_offset is an offset within the 420 // section, but for --emit-relocs it is an virtual address. 421 P->r_offset = Sec->getVA(Rel.r_offset); 422 P->setSymbolAndType(In.SymTab->getSymbolIndex(&Sym), Type, 423 Config->IsMips64EL); 424 425 if (Sym.Type == STT_SECTION) { 426 // We combine multiple section symbols into only one per 427 // section. This means we have to update the addend. That is 428 // trivial for Elf_Rela, but for Elf_Rel we have to write to the 429 // section data. We do that by adding to the Relocation vector. 430 431 // .eh_frame is horribly special and can reference discarded sections. To 432 // avoid having to parse and recreate .eh_frame, we just replace any 433 // relocation in it pointing to discarded sections with R_*_NONE, which 434 // hopefully creates a frame that is ignored at runtime. 435 auto *D = dyn_cast<Defined>(&Sym); 436 if (!D) { 437 error("STT_SECTION symbol should be defined"); 438 continue; 439 } 440 SectionBase *Section = D->Section->Repl; 441 if (!Section->Live) { 442 P->setSymbolAndType(0, 0, false); 443 continue; 444 } 445 446 int64_t Addend = getAddend<ELFT>(Rel); 447 const uint8_t *BufLoc = Sec->data().begin() + Rel.r_offset; 448 if (!RelTy::IsRela) 449 Addend = Target->getImplicitAddend(BufLoc, Type); 450 451 if (Config->EMachine == EM_MIPS && Config->Relocatable && 452 Target->getRelExpr(Type, Sym, BufLoc) == R_MIPS_GOTREL) { 453 // Some MIPS relocations depend on "gp" value. By default, 454 // this value has 0x7ff0 offset from a .got section. But 455 // relocatable files produced by a complier or a linker 456 // might redefine this default value and we must use it 457 // for a calculation of the relocation result. When we 458 // generate EXE or DSO it's trivial. Generating a relocatable 459 // output is more difficult case because the linker does 460 // not calculate relocations in this mode and loses 461 // individual "gp" values used by each input object file. 462 // As a workaround we add the "gp" value to the relocation 463 // addend and save it back to the file. 464 Addend += Sec->getFile<ELFT>()->MipsGp0; 465 } 466 467 if (RelTy::IsRela) 468 P->r_addend = Sym.getVA(Addend) - Section->getOutputSection()->Addr; 469 else if (Config->Relocatable) 470 Sec->Relocations.push_back({R_ABS, Type, Rel.r_offset, Addend, &Sym}); 471 } 472 } 473} 474 475// The ARM and AArch64 ABI handle pc-relative relocations to undefined weak 476// references specially. The general rule is that the value of the symbol in 477// this context is the address of the place P. A further special case is that 478// branch relocations to an undefined weak reference resolve to the next 479// instruction. 480static uint32_t getARMUndefinedRelativeWeakVA(RelType Type, uint32_t A, 481 uint32_t P) { 482 switch (Type) { 483 // Unresolved branch relocations to weak references resolve to next 484 // instruction, this will be either 2 or 4 bytes on from P. 485 case R_ARM_THM_JUMP11: 486 return P + 2 + A; 487 case R_ARM_CALL: 488 case R_ARM_JUMP24: 489 case R_ARM_PC24: 490 case R_ARM_PLT32: 491 case R_ARM_PREL31: 492 case R_ARM_THM_JUMP19: 493 case R_ARM_THM_JUMP24: 494 return P + 4 + A; 495 case R_ARM_THM_CALL: 496 // We don't want an interworking BLX to ARM 497 return P + 5 + A; 498 // Unresolved non branch pc-relative relocations 499 // R_ARM_TARGET2 which can be resolved relatively is not present as it never 500 // targets a weak-reference. 501 case R_ARM_MOVW_PREL_NC: 502 case R_ARM_MOVT_PREL: 503 case R_ARM_REL32: 504 case R_ARM_THM_MOVW_PREL_NC: 505 case R_ARM_THM_MOVT_PREL: 506 return P + A; 507 } 508 llvm_unreachable("ARM pc-relative relocation expected\n"); 509} 510 511// The comment above getARMUndefinedRelativeWeakVA applies to this function. 512static uint64_t getAArch64UndefinedRelativeWeakVA(uint64_t Type, uint64_t A, 513 uint64_t P) { 514 switch (Type) { 515 // Unresolved branch relocations to weak references resolve to next 516 // instruction, this is 4 bytes on from P. 517 case R_AARCH64_CALL26: 518 case R_AARCH64_CONDBR19: 519 case R_AARCH64_JUMP26: 520 case R_AARCH64_TSTBR14: 521 return P + 4 + A; 522 // Unresolved non branch pc-relative relocations 523 case R_AARCH64_PREL16: 524 case R_AARCH64_PREL32: 525 case R_AARCH64_PREL64: 526 case R_AARCH64_ADR_PREL_LO21: 527 case R_AARCH64_LD_PREL_LO19: 528 return P + A; 529 } 530 llvm_unreachable("AArch64 pc-relative relocation expected\n"); 531} 532 533// ARM SBREL relocations are of the form S + A - B where B is the static base 534// The ARM ABI defines base to be "addressing origin of the output segment 535// defining the symbol S". We defined the "addressing origin"/static base to be 536// the base of the PT_LOAD segment containing the Sym. 537// The procedure call standard only defines a Read Write Position Independent 538// RWPI variant so in practice we should expect the static base to be the base 539// of the RW segment. 540static uint64_t getARMStaticBase(const Symbol &Sym) { 541 OutputSection *OS = Sym.getOutputSection(); 542 if (!OS || !OS->PtLoad || !OS->PtLoad->FirstSec) 543 fatal("SBREL relocation to " + Sym.getName() + " without static base"); 544 return OS->PtLoad->FirstSec->Addr; 545} 546 547// For R_RISCV_PC_INDIRECT (R_RISCV_PCREL_LO12_{I,S}), the symbol actually 548// points the corresponding R_RISCV_PCREL_HI20 relocation, and the target VA 549// is calculated using PCREL_HI20's symbol. 550// 551// This function returns the R_RISCV_PCREL_HI20 relocation from 552// R_RISCV_PCREL_LO12's symbol and addend. 553static Relocation *getRISCVPCRelHi20(const Symbol *Sym, uint64_t Addend) { 554 const Defined *D = cast<Defined>(Sym); 555 InputSection *IS = cast<InputSection>(D->Section); 556 557 if (Addend != 0) 558 warn("Non-zero addend in R_RISCV_PCREL_LO12 relocation to " + 559 IS->getObjMsg(D->Value) + " is ignored"); 560 561 // Relocations are sorted by offset, so we can use std::equal_range to do 562 // binary search. 563 auto Range = std::equal_range(IS->Relocations.begin(), IS->Relocations.end(), 564 D->Value, RelocationOffsetComparator{}); 565 for (auto It = std::get<0>(Range); It != std::get<1>(Range); ++It) 566 if (isRelExprOneOf<R_PC>(It->Expr)) 567 return &*It; 568 569 error("R_RISCV_PCREL_LO12 relocation points to " + IS->getObjMsg(D->Value) + 570 " without an associated R_RISCV_PCREL_HI20 relocation"); 571 return nullptr; 572} 573 574// A TLS symbol's virtual address is relative to the TLS segment. Add a 575// target-specific adjustment to produce a thread-pointer-relative offset. 576static int64_t getTlsTpOffset() { 577 switch (Config->EMachine) { 578 case EM_ARM: 579 case EM_AARCH64: 580 // Variant 1. The thread pointer points to a TCB with a fixed 2-word size, 581 // followed by a variable amount of alignment padding, followed by the TLS 582 // segment. 583 return alignTo(Config->Wordsize * 2, Out::TlsPhdr->p_align); 584 case EM_386: 585 case EM_X86_64: 586 // Variant 2. The TLS segment is located just before the thread pointer. 587 return -Out::TlsPhdr->p_memsz; 588 case EM_PPC64: 589 // The thread pointer points to a fixed offset from the start of the 590 // executable's TLS segment. An offset of 0x7000 allows a signed 16-bit 591 // offset to reach 0x1000 of TCB/thread-library data and 0xf000 of the 592 // program's TLS segment. 593 return -0x7000; 594 default: 595 llvm_unreachable("unhandled Config->EMachine"); 596 } 597} 598 599static uint64_t getRelocTargetVA(const InputFile *File, RelType Type, int64_t A, 600 uint64_t P, const Symbol &Sym, RelExpr Expr) { 601 switch (Expr) { 602 case R_INVALID: 603 return 0; 604 case R_ABS: 605 case R_RELAX_TLS_LD_TO_LE_ABS: 606 case R_RELAX_GOT_PC_NOPIC: 607 return Sym.getVA(A); 608 case R_ADDEND: 609 return A; 610 case R_ARM_SBREL: 611 return Sym.getVA(A) - getARMStaticBase(Sym); 612 case R_GOT: 613 case R_RELAX_TLS_GD_TO_IE_ABS: 614 return Sym.getGotVA() + A; 615 case R_GOTONLY_PC: 616 return In.Got->getVA() + A - P; 617 case R_GOTONLY_PC_FROM_END: 618 return In.Got->getVA() + A - P + In.Got->getSize(); 619 case R_GOTREL: 620 return Sym.getVA(A) - In.Got->getVA(); 621 case R_GOTREL_FROM_END: 622 return Sym.getVA(A) - In.Got->getVA() - In.Got->getSize(); 623 case R_GOT_FROM_END: 624 case R_RELAX_TLS_GD_TO_IE_END: 625 return Sym.getGotOffset() + A - In.Got->getSize(); 626 case R_TLSLD_GOT_OFF: 627 case R_GOT_OFF: 628 case R_RELAX_TLS_GD_TO_IE_GOT_OFF: 629 return Sym.getGotOffset() + A; 630 case R_AARCH64_GOT_PAGE_PC: 631 case R_AARCH64_RELAX_TLS_GD_TO_IE_PAGE_PC: 632 return getAArch64Page(Sym.getGotVA() + A) - getAArch64Page(P); 633 case R_GOT_PC: 634 case R_RELAX_TLS_GD_TO_IE: 635 return Sym.getGotVA() + A - P; 636 case R_HEXAGON_GOT: 637 return Sym.getGotVA() - In.GotPlt->getVA(); 638 case R_MIPS_GOTREL: 639 return Sym.getVA(A) - In.MipsGot->getGp(File); 640 case R_MIPS_GOT_GP: 641 return In.MipsGot->getGp(File) + A; 642 case R_MIPS_GOT_GP_PC: { 643 // R_MIPS_LO16 expression has R_MIPS_GOT_GP_PC type iif the target 644 // is _gp_disp symbol. In that case we should use the following 645 // formula for calculation "AHL + GP - P + 4". For details see p. 4-19 at 646 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf 647 // microMIPS variants of these relocations use slightly different 648 // expressions: AHL + GP - P + 3 for %lo() and AHL + GP - P - 1 for %hi() 649 // to correctly handle less-sugnificant bit of the microMIPS symbol. 650 uint64_t V = In.MipsGot->getGp(File) + A - P; 651 if (Type == R_MIPS_LO16 || Type == R_MICROMIPS_LO16) 652 V += 4; 653 if (Type == R_MICROMIPS_LO16 || Type == R_MICROMIPS_HI16) 654 V -= 1; 655 return V; 656 } 657 case R_MIPS_GOT_LOCAL_PAGE: 658 // If relocation against MIPS local symbol requires GOT entry, this entry 659 // should be initialized by 'page address'. This address is high 16-bits 660 // of sum the symbol's value and the addend. 661 return In.MipsGot->getVA() + In.MipsGot->getPageEntryOffset(File, Sym, A) - 662 In.MipsGot->getGp(File); 663 case R_MIPS_GOT_OFF: 664 case R_MIPS_GOT_OFF32: 665 // In case of MIPS if a GOT relocation has non-zero addend this addend 666 // should be applied to the GOT entry content not to the GOT entry offset. 667 // That is why we use separate expression type. 668 return In.MipsGot->getVA() + In.MipsGot->getSymEntryOffset(File, Sym, A) - 669 In.MipsGot->getGp(File); 670 case R_MIPS_TLSGD: 671 return In.MipsGot->getVA() + In.MipsGot->getGlobalDynOffset(File, Sym) - 672 In.MipsGot->getGp(File); 673 case R_MIPS_TLSLD: 674 return In.MipsGot->getVA() + In.MipsGot->getTlsIndexOffset(File) - 675 In.MipsGot->getGp(File); 676 case R_AARCH64_PAGE_PC: { 677 uint64_t Val = Sym.isUndefWeak() ? P + A : Sym.getVA(A); 678 return getAArch64Page(Val) - getAArch64Page(P); 679 } 680 case R_RISCV_PC_INDIRECT: { 681 if (const Relocation *HiRel = getRISCVPCRelHi20(&Sym, A)) 682 return getRelocTargetVA(File, HiRel->Type, HiRel->Addend, Sym.getVA(), 683 *HiRel->Sym, HiRel->Expr); 684 return 0; 685 } 686 case R_PC: { 687 uint64_t Dest; 688 if (Sym.isUndefWeak()) { 689 // On ARM and AArch64 a branch to an undefined weak resolves to the 690 // next instruction, otherwise the place. 691 if (Config->EMachine == EM_ARM) 692 Dest = getARMUndefinedRelativeWeakVA(Type, A, P); 693 else if (Config->EMachine == EM_AARCH64) 694 Dest = getAArch64UndefinedRelativeWeakVA(Type, A, P); 695 else 696 Dest = Sym.getVA(A); 697 } else { 698 Dest = Sym.getVA(A); 699 } 700 return Dest - P; 701 } 702 case R_PLT: 703 return Sym.getPltVA() + A; 704 case R_PLT_PC: 705 case R_PPC_CALL_PLT: 706 return Sym.getPltVA() + A - P; 707 case R_PPC_CALL: { 708 uint64_t SymVA = Sym.getVA(A); 709 // If we have an undefined weak symbol, we might get here with a symbol 710 // address of zero. That could overflow, but the code must be unreachable, 711 // so don't bother doing anything at all. 712 if (!SymVA) 713 return 0; 714 715 // PPC64 V2 ABI describes two entry points to a function. The global entry 716 // point is used for calls where the caller and callee (may) have different 717 // TOC base pointers and r2 needs to be modified to hold the TOC base for 718 // the callee. For local calls the caller and callee share the same 719 // TOC base and so the TOC pointer initialization code should be skipped by 720 // branching to the local entry point. 721 return SymVA - P + getPPC64GlobalEntryToLocalEntryOffset(Sym.StOther); 722 } 723 case R_PPC_TOC: 724 return getPPC64TocBase() + A; 725 case R_RELAX_GOT_PC: 726 return Sym.getVA(A) - P; 727 case R_RELAX_TLS_GD_TO_LE: 728 case R_RELAX_TLS_IE_TO_LE: 729 case R_RELAX_TLS_LD_TO_LE: 730 case R_TLS: 731 // A weak undefined TLS symbol resolves to the base of the TLS 732 // block, i.e. gets a value of zero. If we pass --gc-sections to 733 // lld and .tbss is not referenced, it gets reclaimed and we don't 734 // create a TLS program header. Therefore, we resolve this 735 // statically to zero. 736 if (Sym.isTls() && Sym.isUndefWeak()) 737 return 0; 738 return Sym.getVA(A) + getTlsTpOffset(); 739 case R_RELAX_TLS_GD_TO_LE_NEG: 740 case R_NEG_TLS: 741 return Out::TlsPhdr->p_memsz - Sym.getVA(A); 742 case R_SIZE: 743 return Sym.getSize() + A; 744 case R_TLSDESC: 745 return In.Got->getGlobalDynAddr(Sym) + A; 746 case R_AARCH64_TLSDESC_PAGE: 747 return getAArch64Page(In.Got->getGlobalDynAddr(Sym) + A) - 748 getAArch64Page(P); 749 case R_TLSGD_GOT: 750 return In.Got->getGlobalDynOffset(Sym) + A; 751 case R_TLSGD_GOT_FROM_END: 752 return In.Got->getGlobalDynOffset(Sym) + A - In.Got->getSize(); 753 case R_TLSGD_PC: 754 return In.Got->getGlobalDynAddr(Sym) + A - P; 755 case R_TLSLD_GOT_FROM_END: 756 return In.Got->getTlsIndexOff() + A - In.Got->getSize(); 757 case R_TLSLD_GOT: 758 return In.Got->getTlsIndexOff() + A; 759 case R_TLSLD_PC: 760 return In.Got->getTlsIndexVA() + A - P; 761 default: 762 llvm_unreachable("invalid expression"); 763 } 764} 765 766// This function applies relocations to sections without SHF_ALLOC bit. 767// Such sections are never mapped to memory at runtime. Debug sections are 768// an example. Relocations in non-alloc sections are much easier to 769// handle than in allocated sections because it will never need complex 770// treatement such as GOT or PLT (because at runtime no one refers them). 771// So, we handle relocations for non-alloc sections directly in this 772// function as a performance optimization. 773template <class ELFT, class RelTy> 774void InputSection::relocateNonAlloc(uint8_t *Buf, ArrayRef<RelTy> Rels) { 775 const unsigned Bits = sizeof(typename ELFT::uint) * 8; 776 777 for (const RelTy &Rel : Rels) { 778 RelType Type = Rel.getType(Config->IsMips64EL); 779 780 // GCC 8.0 or earlier have a bug that they emit R_386_GOTPC relocations 781 // against _GLOBAL_OFFSET_TABLE_ for .debug_info. The bug has been fixed 782 // in 2017 (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82630), but we 783 // need to keep this bug-compatible code for a while. 784 if (Config->EMachine == EM_386 && Type == R_386_GOTPC) 785 continue; 786 787 uint64_t Offset = getOffset(Rel.r_offset); 788 uint8_t *BufLoc = Buf + Offset; 789 int64_t Addend = getAddend<ELFT>(Rel); 790 if (!RelTy::IsRela) 791 Addend += Target->getImplicitAddend(BufLoc, Type); 792 793 Symbol &Sym = getFile<ELFT>()->getRelocTargetSym(Rel); 794 RelExpr Expr = Target->getRelExpr(Type, Sym, BufLoc); 795 if (Expr == R_NONE) 796 continue; 797 798 if (Expr != R_ABS) { 799 std::string Msg = getLocation<ELFT>(Offset) + 800 ": has non-ABS relocation " + toString(Type) + 801 " against symbol '" + toString(Sym) + "'"; 802 if (Expr != R_PC) { 803 error(Msg); 804 return; 805 } 806 807 // If the control reaches here, we found a PC-relative relocation in a 808 // non-ALLOC section. Since non-ALLOC section is not loaded into memory 809 // at runtime, the notion of PC-relative doesn't make sense here. So, 810 // this is a usage error. However, GNU linkers historically accept such 811 // relocations without any errors and relocate them as if they were at 812 // address 0. For bug-compatibilty, we accept them with warnings. We 813 // know Steel Bank Common Lisp as of 2018 have this bug. 814 warn(Msg); 815 Target->relocateOne(BufLoc, Type, 816 SignExtend64<Bits>(Sym.getVA(Addend - Offset))); 817 continue; 818 } 819 820 if (Sym.isTls() && !Out::TlsPhdr) 821 Target->relocateOne(BufLoc, Type, 0); 822 else 823 Target->relocateOne(BufLoc, Type, SignExtend64<Bits>(Sym.getVA(Addend))); 824 } 825} 826 827// This is used when '-r' is given. 828// For REL targets, InputSection::copyRelocations() may store artificial 829// relocations aimed to update addends. They are handled in relocateAlloc() 830// for allocatable sections, and this function does the same for 831// non-allocatable sections, such as sections with debug information. 832static void relocateNonAllocForRelocatable(InputSection *Sec, uint8_t *Buf) { 833 const unsigned Bits = Config->Is64 ? 64 : 32; 834 835 for (const Relocation &Rel : Sec->Relocations) { 836 // InputSection::copyRelocations() adds only R_ABS relocations. 837 assert(Rel.Expr == R_ABS); 838 uint8_t *BufLoc = Buf + Rel.Offset + Sec->OutSecOff; 839 uint64_t TargetVA = SignExtend64(Rel.Sym->getVA(Rel.Addend), Bits); 840 Target->relocateOne(BufLoc, Rel.Type, TargetVA); 841 } 842} 843 844template <class ELFT> 845void InputSectionBase::relocate(uint8_t *Buf, uint8_t *BufEnd) { 846 if (Flags & SHF_EXECINSTR) 847 adjustSplitStackFunctionPrologues<ELFT>(Buf, BufEnd); 848 849 if (Flags & SHF_ALLOC) { 850 relocateAlloc(Buf, BufEnd); 851 return; 852 } 853 854 auto *Sec = cast<InputSection>(this); 855 if (Config->Relocatable) 856 relocateNonAllocForRelocatable(Sec, Buf); 857 else if (Sec->AreRelocsRela) 858 Sec->relocateNonAlloc<ELFT>(Buf, Sec->template relas<ELFT>()); 859 else 860 Sec->relocateNonAlloc<ELFT>(Buf, Sec->template rels<ELFT>()); 861} 862 863void InputSectionBase::relocateAlloc(uint8_t *Buf, uint8_t *BufEnd) { 864 assert(Flags & SHF_ALLOC); 865 const unsigned Bits = Config->Wordsize * 8; 866 867 for (const Relocation &Rel : Relocations) { 868 uint64_t Offset = Rel.Offset; 869 if (auto *Sec = dyn_cast<InputSection>(this)) 870 Offset += Sec->OutSecOff; 871 uint8_t *BufLoc = Buf + Offset; 872 RelType Type = Rel.Type; 873 874 uint64_t AddrLoc = getOutputSection()->Addr + Offset; 875 RelExpr Expr = Rel.Expr; 876 uint64_t TargetVA = SignExtend64( 877 getRelocTargetVA(File, Type, Rel.Addend, AddrLoc, *Rel.Sym, Expr), 878 Bits); 879 880 switch (Expr) { 881 case R_RELAX_GOT_PC: 882 case R_RELAX_GOT_PC_NOPIC: 883 Target->relaxGot(BufLoc, TargetVA); 884 break; 885 case R_RELAX_TLS_IE_TO_LE: 886 Target->relaxTlsIeToLe(BufLoc, Type, TargetVA); 887 break; 888 case R_RELAX_TLS_LD_TO_LE: 889 case R_RELAX_TLS_LD_TO_LE_ABS: 890 Target->relaxTlsLdToLe(BufLoc, Type, TargetVA); 891 break; 892 case R_RELAX_TLS_GD_TO_LE: 893 case R_RELAX_TLS_GD_TO_LE_NEG: 894 Target->relaxTlsGdToLe(BufLoc, Type, TargetVA); 895 break; 896 case R_AARCH64_RELAX_TLS_GD_TO_IE_PAGE_PC: 897 case R_RELAX_TLS_GD_TO_IE: 898 case R_RELAX_TLS_GD_TO_IE_ABS: 899 case R_RELAX_TLS_GD_TO_IE_GOT_OFF: 900 case R_RELAX_TLS_GD_TO_IE_END: 901 Target->relaxTlsGdToIe(BufLoc, Type, TargetVA); 902 break; 903 case R_PPC_CALL: 904 // If this is a call to __tls_get_addr, it may be part of a TLS 905 // sequence that has been relaxed and turned into a nop. In this 906 // case, we don't want to handle it as a call. 907 if (read32(BufLoc) == 0x60000000) // nop 908 break; 909 910 // Patch a nop (0x60000000) to a ld. 911 if (Rel.Sym->NeedsTocRestore) { 912 if (BufLoc + 8 > BufEnd || read32(BufLoc + 4) != 0x60000000) { 913 error(getErrorLocation(BufLoc) + "call lacks nop, can't restore toc"); 914 break; 915 } 916 write32(BufLoc + 4, 0xe8410018); // ld %r2, 24(%r1) 917 } 918 Target->relocateOne(BufLoc, Type, TargetVA); 919 break; 920 default: 921 Target->relocateOne(BufLoc, Type, TargetVA); 922 break; 923 } 924 } 925} 926 927// For each function-defining prologue, find any calls to __morestack, 928// and replace them with calls to __morestack_non_split. 929static void switchMorestackCallsToMorestackNonSplit( 930 DenseSet<Defined *> &Prologues, std::vector<Relocation *> &MorestackCalls) { 931 932 // If the target adjusted a function's prologue, all calls to 933 // __morestack inside that function should be switched to 934 // __morestack_non_split. 935 Symbol *MoreStackNonSplit = Symtab->find("__morestack_non_split"); 936 if (!MoreStackNonSplit) { 937 error("Mixing split-stack objects requires a definition of " 938 "__morestack_non_split"); 939 return; 940 } 941 942 // Sort both collections to compare addresses efficiently. 943 llvm::sort(MorestackCalls, [](const Relocation *L, const Relocation *R) { 944 return L->Offset < R->Offset; 945 }); 946 std::vector<Defined *> Functions(Prologues.begin(), Prologues.end()); 947 llvm::sort(Functions, [](const Defined *L, const Defined *R) { 948 return L->Value < R->Value; 949 }); 950 951 auto It = MorestackCalls.begin(); 952 for (Defined *F : Functions) { 953 // Find the first call to __morestack within the function. 954 while (It != MorestackCalls.end() && (*It)->Offset < F->Value) 955 ++It; 956 // Adjust all calls inside the function. 957 while (It != MorestackCalls.end() && (*It)->Offset < F->Value + F->Size) { 958 (*It)->Sym = MoreStackNonSplit; 959 ++It; 960 } 961 } 962} 963 964static bool enclosingPrologueAttempted(uint64_t Offset, 965 const DenseSet<Defined *> &Prologues) { 966 for (Defined *F : Prologues) 967 if (F->Value <= Offset && Offset < F->Value + F->Size) 968 return true; 969 return false; 970} 971 972// If a function compiled for split stack calls a function not 973// compiled for split stack, then the caller needs its prologue 974// adjusted to ensure that the called function will have enough stack 975// available. Find those functions, and adjust their prologues. 976template <class ELFT> 977void InputSectionBase::adjustSplitStackFunctionPrologues(uint8_t *Buf, 978 uint8_t *End) { 979 if (!getFile<ELFT>()->SplitStack) 980 return; 981 DenseSet<Defined *> Prologues; 982 std::vector<Relocation *> MorestackCalls; 983 984 for (Relocation &Rel : Relocations) { 985 // Local symbols can't possibly be cross-calls, and should have been 986 // resolved long before this line. 987 if (Rel.Sym->isLocal()) 988 continue; 989 990 // Ignore calls into the split-stack api. 991 if (Rel.Sym->getName().startswith("__morestack")) { 992 if (Rel.Sym->getName().equals("__morestack")) 993 MorestackCalls.push_back(&Rel); 994 continue; 995 } 996 997 // A relocation to non-function isn't relevant. Sometimes 998 // __morestack is not marked as a function, so this check comes 999 // after the name check. 1000 if (Rel.Sym->Type != STT_FUNC) 1001 continue; 1002 1003 // If the callee's-file was compiled with split stack, nothing to do. In 1004 // this context, a "Defined" symbol is one "defined by the binary currently 1005 // being produced". So an "undefined" symbol might be provided by a shared 1006 // library. It is not possible to tell how such symbols were compiled, so be 1007 // conservative. 1008 if (Defined *D = dyn_cast<Defined>(Rel.Sym)) 1009 if (InputSection *IS = cast_or_null<InputSection>(D->Section)) 1010 if (!IS || !IS->getFile<ELFT>() || IS->getFile<ELFT>()->SplitStack) 1011 continue; 1012 1013 if (enclosingPrologueAttempted(Rel.Offset, Prologues)) 1014 continue; 1015 1016 if (Defined *F = getEnclosingFunction<ELFT>(Rel.Offset)) { 1017 Prologues.insert(F); 1018 if (Target->adjustPrologueForCrossSplitStack(Buf + getOffset(F->Value), 1019 End, F->StOther)) 1020 continue; 1021 if (!getFile<ELFT>()->SomeNoSplitStack) 1022 error(lld::toString(this) + ": " + F->getName() + 1023 " (with -fsplit-stack) calls " + Rel.Sym->getName() + 1024 " (without -fsplit-stack), but couldn't adjust its prologue"); 1025 } 1026 } 1027 1028 if (Target->NeedsMoreStackNonSplit) 1029 switchMorestackCallsToMorestackNonSplit(Prologues, MorestackCalls); 1030} 1031 1032template <class ELFT> void InputSection::writeTo(uint8_t *Buf) { 1033 if (Type == SHT_NOBITS) 1034 return; 1035 1036 if (auto *S = dyn_cast<SyntheticSection>(this)) { 1037 S->writeTo(Buf + OutSecOff); 1038 return; 1039 } 1040 1041 // If -r or --emit-relocs is given, then an InputSection 1042 // may be a relocation section. 1043 if (Type == SHT_RELA) { 1044 copyRelocations<ELFT>(Buf + OutSecOff, getDataAs<typename ELFT::Rela>()); 1045 return; 1046 } 1047 if (Type == SHT_REL) { 1048 copyRelocations<ELFT>(Buf + OutSecOff, getDataAs<typename ELFT::Rel>()); 1049 return; 1050 } 1051 1052 // If -r is given, we may have a SHT_GROUP section. 1053 if (Type == SHT_GROUP) { 1054 copyShtGroup<ELFT>(Buf + OutSecOff); 1055 return; 1056 } 1057 1058 // If this is a compressed section, uncompress section contents directly 1059 // to the buffer. 1060 if (UncompressedSize >= 0 && !UncompressedBuf) { 1061 size_t Size = UncompressedSize; 1062 if (Error E = zlib::uncompress(toStringRef(RawData), 1063 (char *)(Buf + OutSecOff), Size)) 1064 fatal(toString(this) + 1065 ": uncompress failed: " + llvm::toString(std::move(E))); 1066 uint8_t *BufEnd = Buf + OutSecOff + Size; 1067 relocate<ELFT>(Buf, BufEnd); 1068 return; 1069 } 1070 1071 // Copy section contents from source object file to output file 1072 // and then apply relocations. 1073 memcpy(Buf + OutSecOff, data().data(), data().size()); 1074 uint8_t *BufEnd = Buf + OutSecOff + data().size(); 1075 relocate<ELFT>(Buf, BufEnd); 1076} 1077 1078void InputSection::replace(InputSection *Other) { 1079 Alignment = std::max(Alignment, Other->Alignment); 1080 Other->Repl = Repl; 1081 Other->Live = false; 1082} 1083 1084template <class ELFT> 1085EhInputSection::EhInputSection(ObjFile<ELFT> &F, 1086 const typename ELFT::Shdr &Header, 1087 StringRef Name) 1088 : InputSectionBase(F, Header, Name, InputSectionBase::EHFrame) {} 1089 1090SyntheticSection *EhInputSection::getParent() const { 1091 return cast_or_null<SyntheticSection>(Parent); 1092} 1093 1094// Returns the index of the first relocation that points to a region between 1095// Begin and Begin+Size. 1096template <class IntTy, class RelTy> 1097static unsigned getReloc(IntTy Begin, IntTy Size, const ArrayRef<RelTy> &Rels, 1098 unsigned &RelocI) { 1099 // Start search from RelocI for fast access. That works because the 1100 // relocations are sorted in .eh_frame. 1101 for (unsigned N = Rels.size(); RelocI < N; ++RelocI) { 1102 const RelTy &Rel = Rels[RelocI]; 1103 if (Rel.r_offset < Begin) 1104 continue; 1105 1106 if (Rel.r_offset < Begin + Size) 1107 return RelocI; 1108 return -1; 1109 } 1110 return -1; 1111} 1112 1113// .eh_frame is a sequence of CIE or FDE records. 1114// This function splits an input section into records and returns them. 1115template <class ELFT> void EhInputSection::split() { 1116 if (AreRelocsRela) 1117 split<ELFT>(relas<ELFT>()); 1118 else 1119 split<ELFT>(rels<ELFT>()); 1120} 1121 1122template <class ELFT, class RelTy> 1123void EhInputSection::split(ArrayRef<RelTy> Rels) { 1124 unsigned RelI = 0; 1125 for (size_t Off = 0, End = data().size(); Off != End;) { 1126 size_t Size = readEhRecordSize(this, Off); 1127 Pieces.emplace_back(Off, this, Size, getReloc(Off, Size, Rels, RelI)); 1128 // The empty record is the end marker. 1129 if (Size == 4) 1130 break; 1131 Off += Size; 1132 } 1133} 1134 1135static size_t findNull(StringRef S, size_t EntSize) { 1136 // Optimize the common case. 1137 if (EntSize == 1) 1138 return S.find(0); 1139 1140 for (unsigned I = 0, N = S.size(); I != N; I += EntSize) { 1141 const char *B = S.begin() + I; 1142 if (std::all_of(B, B + EntSize, [](char C) { return C == 0; })) 1143 return I; 1144 } 1145 return StringRef::npos; 1146} 1147 1148SyntheticSection *MergeInputSection::getParent() const { 1149 return cast_or_null<SyntheticSection>(Parent); 1150} 1151 1152// Split SHF_STRINGS section. Such section is a sequence of 1153// null-terminated strings. 1154void MergeInputSection::splitStrings(ArrayRef<uint8_t> Data, size_t EntSize) { 1155 size_t Off = 0; 1156 bool IsAlloc = Flags & SHF_ALLOC; 1157 StringRef S = toStringRef(Data); 1158 1159 while (!S.empty()) { 1160 size_t End = findNull(S, EntSize); 1161 if (End == StringRef::npos) 1162 fatal(toString(this) + ": string is not null terminated"); 1163 size_t Size = End + EntSize; 1164 1165 Pieces.emplace_back(Off, xxHash64(S.substr(0, Size)), !IsAlloc); 1166 S = S.substr(Size); 1167 Off += Size; 1168 } 1169} 1170 1171// Split non-SHF_STRINGS section. Such section is a sequence of 1172// fixed size records. 1173void MergeInputSection::splitNonStrings(ArrayRef<uint8_t> Data, 1174 size_t EntSize) { 1175 size_t Size = Data.size(); 1176 assert((Size % EntSize) == 0); 1177 bool IsAlloc = Flags & SHF_ALLOC; 1178 1179 for (size_t I = 0; I != Size; I += EntSize) 1180 Pieces.emplace_back(I, xxHash64(Data.slice(I, EntSize)), !IsAlloc); 1181} 1182 1183template <class ELFT> 1184MergeInputSection::MergeInputSection(ObjFile<ELFT> &F, 1185 const typename ELFT::Shdr &Header, 1186 StringRef Name) 1187 : InputSectionBase(F, Header, Name, InputSectionBase::Merge) {} 1188 1189MergeInputSection::MergeInputSection(uint64_t Flags, uint32_t Type, 1190 uint64_t Entsize, ArrayRef<uint8_t> Data, 1191 StringRef Name) 1192 : InputSectionBase(nullptr, Flags, Type, Entsize, /*Link*/ 0, /*Info*/ 0, 1193 /*Alignment*/ Entsize, Data, Name, SectionBase::Merge) {} 1194 1195// This function is called after we obtain a complete list of input sections 1196// that need to be linked. This is responsible to split section contents 1197// into small chunks for further processing. 1198// 1199// Note that this function is called from parallelForEach. This must be 1200// thread-safe (i.e. no memory allocation from the pools). 1201void MergeInputSection::splitIntoPieces() { 1202 assert(Pieces.empty()); 1203 1204 if (Flags & SHF_STRINGS) 1205 splitStrings(data(), Entsize); 1206 else 1207 splitNonStrings(data(), Entsize); 1208} 1209 1210SectionPiece *MergeInputSection::getSectionPiece(uint64_t Offset) { 1211 if (this->data().size() <= Offset) 1212 fatal(toString(this) + ": offset is outside the section"); 1213 1214 // If Offset is not at beginning of a section piece, it is not in the map. 1215 // In that case we need to do a binary search of the original section piece vector. 1216 auto It2 = 1217 llvm::upper_bound(Pieces, Offset, [](uint64_t Offset, SectionPiece P) { 1218 return Offset < P.InputOff; 1219 }); 1220 return &It2[-1]; 1221} 1222 1223// Returns the offset in an output section for a given input offset. 1224// Because contents of a mergeable section is not contiguous in output, 1225// it is not just an addition to a base output offset. 1226uint64_t MergeInputSection::getParentOffset(uint64_t Offset) const { 1227 // If Offset is not at beginning of a section piece, it is not in the map. 1228 // In that case we need to search from the original section piece vector. 1229 const SectionPiece &Piece = 1230 *(const_cast<MergeInputSection *>(this)->getSectionPiece (Offset)); 1231 uint64_t Addend = Offset - Piece.InputOff; 1232 return Piece.OutputOff + Addend; 1233} 1234 1235template InputSection::InputSection(ObjFile<ELF32LE> &, const ELF32LE::Shdr &, 1236 StringRef); 1237template InputSection::InputSection(ObjFile<ELF32BE> &, const ELF32BE::Shdr &, 1238 StringRef); 1239template InputSection::InputSection(ObjFile<ELF64LE> &, const ELF64LE::Shdr &, 1240 StringRef); 1241template InputSection::InputSection(ObjFile<ELF64BE> &, const ELF64BE::Shdr &, 1242 StringRef); 1243 1244template std::string InputSectionBase::getLocation<ELF32LE>(uint64_t); 1245template std::string InputSectionBase::getLocation<ELF32BE>(uint64_t); 1246template std::string InputSectionBase::getLocation<ELF64LE>(uint64_t); 1247template std::string InputSectionBase::getLocation<ELF64BE>(uint64_t); 1248 1249template void InputSection::writeTo<ELF32LE>(uint8_t *); 1250template void InputSection::writeTo<ELF32BE>(uint8_t *); 1251template void InputSection::writeTo<ELF64LE>(uint8_t *); 1252template void InputSection::writeTo<ELF64BE>(uint8_t *); 1253 1254template MergeInputSection::MergeInputSection(ObjFile<ELF32LE> &, 1255 const ELF32LE::Shdr &, StringRef); 1256template MergeInputSection::MergeInputSection(ObjFile<ELF32BE> &, 1257 const ELF32BE::Shdr &, StringRef); 1258template MergeInputSection::MergeInputSection(ObjFile<ELF64LE> &, 1259 const ELF64LE::Shdr &, StringRef); 1260template MergeInputSection::MergeInputSection(ObjFile<ELF64BE> &, 1261 const ELF64BE::Shdr &, StringRef); 1262 1263template EhInputSection::EhInputSection(ObjFile<ELF32LE> &, 1264 const ELF32LE::Shdr &, StringRef); 1265template EhInputSection::EhInputSection(ObjFile<ELF32BE> &, 1266 const ELF32BE::Shdr &, StringRef); 1267template EhInputSection::EhInputSection(ObjFile<ELF64LE> &, 1268 const ELF64LE::Shdr &, StringRef); 1269template EhInputSection::EhInputSection(ObjFile<ELF64BE> &, 1270 const ELF64BE::Shdr &, StringRef); 1271 1272template void EhInputSection::split<ELF32LE>(); 1273template void EhInputSection::split<ELF32BE>(); 1274template void EhInputSection::split<ELF64LE>(); 1275template void EhInputSection::split<ELF64BE>(); 1276