CbC/CbC_llvm: lld/ELF/Relocations.cpp comparison

comparison lld/ELF/Relocations.cpp @ 236:c4bab56944e8 llvm-original

LLVM 16

author	kono
date	Wed, 09 Nov 2022 17:45:10 +0900
parents	5f17cb93ff66
children	1f2b6ac9f198

comparison

equal deleted inserted replaced

-:70dce7da266c
+:c4bab56944e8
 //
 //===----------------------------------------------------------------------===//
 #include "Relocations.h"
 #include "Config.h"
+#include "InputFiles.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Thunks.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
-#include "lld/Common/Strings.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/Endian.h"
-#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::elf;
 static Optional<std::string> getLinkerScriptLocation(const Symbol &sym) {
-for (BaseCommand *base : script->sectionCommands)
+for (SectionCommand *cmd : script->sectionCommands)
-if (auto *cmd = dyn_cast<SymbolAssignment>(base))
+if (auto *assign = dyn_cast<SymbolAssignment>(cmd))
-if (cmd->sym == &sym)
+if (assign->sym == &sym)
-return cmd->location;
+return assign->location;
 return None;
 }
 static std::string getDefinedLocation(const Symbol &sym) {
 const char msg[] = "\n>>> defined in ";
 void elf::reportRangeError(uint8_t *loc, const Relocation &rel, const Twine &v,
 int64_t min, uint64_t max) {
 ErrorPlace errPlace = getErrorPlace(loc);
 std::string hint;
-if (rel.sym && !rel.sym->isLocal())
+if (rel.sym && !rel.sym->isSection())
-hint = "; references " + lld::toString(*rel.sym) +
+hint = "; references " + lld::toString(*rel.sym);
-getDefinedLocation(*rel.sym);
+if (!errPlace.srcLoc.empty())
+hint += "\n>>> referenced by " + errPlace.srcLoc;
+if (rel.sym && !rel.sym->isSection())
+hint += getDefinedLocation(*rel.sym);
 if (errPlace.isec && errPlace.isec->name.startswith(".debug"))
 hint += "; consider recompiling with -fdebug-types-section to reduce size "
 "of debug sections";
 errorOrWarn(errPlace.loc + msg + " is out of range: " + Twine(v) +
 " is not in [" + Twine(llvm::minIntN(n)) + ", " +
 Twine(llvm::maxIntN(n)) + "]" + hint);
 }
-namespace {
+// Build a bitmask with one bit set for each 64 subset of RelExpr.
-// Build a bitmask with one bit set for each RelExpr.
+static constexpr uint64_t buildMask() { return 0; }
-//
-// Constexpr function arguments can't be used in static asserts, so we
+template <typename... Tails>
-// use template arguments to build the mask.
+static constexpr uint64_t buildMask(int head, Tails... tails) {
-// But function template partial specializations don't exist (needed
+return (0 <= head && head < 64 ? uint64_t(1) << head : 0) |
-// for base case of the recursion), so we need a dummy struct.
+buildMask(tails...);
-template <RelExpr... Exprs> struct RelExprMaskBuilder {
+}
-static inline uint64_t build() { return 0; }
-};
-// Specialization for recursive case.
-template <RelExpr Head, RelExpr... Tail>
-struct RelExprMaskBuilder<Head, Tail...> {
-static inline uint64_t build() {
-static_assert(0 <= Head && Head < 64,
-"RelExpr is too large for 64-bit mask!");
-return (uint64_t(1) << Head) | RelExprMaskBuilder<Tail...>::build();
-}
-};
-} // namespace
 // Return true if `Expr` is one of `Exprs`.
-// There are fewer than 64 RelExpr's, so we can represent any set of
+// There are more than 64 but less than 128 RelExprs, so we divide the set of
-// RelExpr's as a constant bit mask and test for membership with a
+// exprs into [0, 64) and [64, 128) and represent each range as a constant
-// couple cheap bitwise operations.
+// 64-bit mask. Then we decide which mask to test depending on the value of
-template <RelExpr... Exprs> bool oneof(RelExpr expr) {
+// expr and use a simple shift and bitwise-and to test for membership.
-assert(0 <= expr && (int)expr < 64 &&
+template <RelExpr... Exprs> static bool oneof(RelExpr expr) {
-"RelExpr is too large for 64-bit mask!");
+assert(0 <= expr && (int)expr < 128 &&
-return (uint64_t(1) << expr) & RelExprMaskBuilder<Exprs...>::build();
+"RelExpr is too large for 128-bit mask!");
-}
+if (expr >= 64)
-// This function is similar to the `handleTlsRelocation`. MIPS does not
+return (uint64_t(1) << (expr - 64)) & buildMask((Exprs - 64)...);
-// support any relaxations for TLS relocations so by factoring out MIPS
+return (uint64_t(1) << expr) & buildMask(Exprs...);
-// handling in to the separate function we can simplify the code and do not
-// pollute other `handleTlsRelocation` by MIPS `ifs` statements.
-// Mips has a custom MipsGotSection that handles the writing of GOT entries
-// without dynamic relocations.
-static unsigned handleMipsTlsRelocation(RelType type, Symbol &sym,
-InputSectionBase &c, uint64_t offset,
-int64_t addend, RelExpr expr) {
-if (expr == R_MIPS_TLSLD) {
-in.mipsGot->addTlsIndex(*c.file);
-c.relocations.push_back({expr, type, offset, addend, &sym});
-return 1;
-}
-if (expr == R_MIPS_TLSGD) {
-in.mipsGot->addDynTlsEntry(*c.file, sym);
-c.relocations.push_back({expr, type, offset, addend, &sym});
-return 1;
-}
-return 0;
-}
-// Notes about General Dynamic and Local Dynamic TLS models below. They may
-// require the generation of a pair of GOT entries that have associated dynamic
-// relocations. The pair of GOT entries created are of the form GOT[e0] Module
-// Index (Used to find pointer to TLS block at run-time) GOT[e1] Offset of
-// symbol in TLS block.
-//
-// Returns the number of relocations processed.
-template <class ELFT>
-static unsigned
-handleTlsRelocation(RelType type, Symbol &sym, InputSectionBase &c,
-typename ELFT::uint offset, int64_t addend, RelExpr expr) {
-if (!sym.isTls())
-return 0;
-if (config->emachine == EM_MIPS)
-return handleMipsTlsRelocation(type, sym, c, offset, addend, expr);
-if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC>(
-expr) &&
-config->shared) {
-if (in.got->addDynTlsEntry(sym)) {
-uint64_t off = in.got->getGlobalDynOffset(sym);
-mainPart->relaDyn->addAddendOnlyRelocIfNonPreemptible(
-target->tlsDescRel, in.got, off, sym, target->tlsDescRel);
-}
-if (expr != R_TLSDESC_CALL)
-c.relocations.push_back({expr, type, offset, addend, &sym});
-return 1;
-}
-// ARM, Hexagon and RISC-V do not support GD/LD to IE/LE relaxation.  For
-// PPC64, if the file has missing R_PPC64_TLSGD/R_PPC64_TLSLD, disable
-// relaxation as well.
-bool toExecRelax = !config->shared && config->emachine != EM_ARM &&
-config->emachine != EM_HEXAGON &&
-config->emachine != EM_RISCV &&
-!c.file->ppc64DisableTLSRelax;
-// If we are producing an executable and the symbol is non-preemptable, it
-// must be defined and the code sequence can be relaxed to use Local-Exec.
-//
-// ARM and RISC-V do not support any relaxations for TLS relocations, however,
-// we can omit the DTPMOD dynamic relocations and resolve them at link time
-// because them are always 1. This may be necessary for static linking as
-// DTPMOD may not be expected at load time.
-bool isLocalInExecutable = !sym.isPreemptible && !config->shared;
-// Local Dynamic is for access to module local TLS variables, while still
-// being suitable for being dynamically loaded via dlopen. GOT[e0] is the
-// module index, with a special value of 0 for the current module. GOT[e1] is
-// unused. There only needs to be one module index entry.
-if (oneof<R_TLSLD_GOT, R_TLSLD_GOTPLT, R_TLSLD_PC, R_TLSLD_HINT>(
-expr)) {
-// Local-Dynamic relocs can be relaxed to Local-Exec.
-if (toExecRelax) {
-c.relocations.push_back(
-{target->adjustTlsExpr(type, R_RELAX_TLS_LD_TO_LE), type, offset,
-addend, &sym});
-return target->getTlsGdRelaxSkip(type);
-}
-if (expr == R_TLSLD_HINT)
-return 1;
-if (in.got->addTlsIndex()) {
-if (isLocalInExecutable)
-in.got->relocations.push_back(
-{R_ADDEND, target->symbolicRel, in.got->getTlsIndexOff(), 1, &sym});
-else
-mainPart->relaDyn->addReloc(
-{target->tlsModuleIndexRel, in.got, in.got->getTlsIndexOff()});
-}
-c.relocations.push_back({expr, type, offset, addend, &sym});
-return 1;
-}
-// Local-Dynamic relocs can be relaxed to Local-Exec.
-if (expr == R_DTPREL && toExecRelax) {
-c.relocations.push_back({target->adjustTlsExpr(type, R_RELAX_TLS_LD_TO_LE),
-type, offset, addend, &sym});
-return 1;
-}
-// Local-Dynamic sequence where offset of tls variable relative to dynamic
-// thread pointer is stored in the got. This cannot be relaxed to Local-Exec.
-if (expr == R_TLSLD_GOT_OFF) {
-if (!sym.isInGot()) {
-in.got->addEntry(sym);
-uint64_t off = sym.getGotOffset();
-in.got->relocations.push_back(
-{R_ABS, target->tlsOffsetRel, off, 0, &sym});
-}
-c.relocations.push_back({expr, type, offset, addend, &sym});
-return 1;
-}
-if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC,
-R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC>(expr)) {
-if (!toExecRelax) {
-if (in.got->addDynTlsEntry(sym)) {
-uint64_t off = in.got->getGlobalDynOffset(sym);
-if (isLocalInExecutable)
-// Write one to the GOT slot.
-in.got->relocations.push_back(
-{R_ADDEND, target->symbolicRel, off, 1, &sym});
-else
-mainPart->relaDyn->addSymbolReloc(target->tlsModuleIndexRel, in.got,
-off, sym);
-// If the symbol is preemptible we need the dynamic linker to write
-// the offset too.
-uint64_t offsetOff = off + config->wordsize;
-if (sym.isPreemptible)
-mainPart->relaDyn->addSymbolReloc(target->tlsOffsetRel, in.got,
-offsetOff, sym);
-else
-in.got->relocations.push_back(
-{R_ABS, target->tlsOffsetRel, offsetOff, 0, &sym});
-}
-c.relocations.push_back({expr, type, offset, addend, &sym});
-return 1;
-}
-// Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec
-// depending on the symbol being locally defined or not.
-if (sym.isPreemptible) {
-c.relocations.push_back(
-{target->adjustTlsExpr(type, R_RELAX_TLS_GD_TO_IE), type, offset,
-addend, &sym});
-if (!sym.isInGot()) {
-in.got->addEntry(sym);
-mainPart->relaDyn->addSymbolReloc(target->tlsGotRel, in.got,
-sym.getGotOffset(), sym);
-}
-} else {
-c.relocations.push_back(
-{target->adjustTlsExpr(type, R_RELAX_TLS_GD_TO_LE), type, offset,
-addend, &sym});
-}
-return target->getTlsGdRelaxSkip(type);
-}
-// Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally
-// defined.
-if (oneof<R_GOT, R_GOTPLT, R_GOT_PC, R_AARCH64_GOT_PAGE_PC, R_GOT_OFF,
-R_TLSIE_HINT>(expr) &&
-toExecRelax && isLocalInExecutable) {
-c.relocations.push_back({R_RELAX_TLS_IE_TO_LE, type, offset, addend, &sym});
-return 1;
-}
-if (expr == R_TLSIE_HINT)
-return 1;
-return 0;
 }
 static RelType getMipsPairType(RelType type, bool isLocal) {
 switch (type) {
 case R_MIPS_HI16:
 return isAbsolute(sym) || sym.isTls();
 }
 // Returns true if Expr refers a PLT entry.
 static bool needsPlt(RelExpr expr) {
-return oneof<R_PLT_PC, R_PPC32_PLTREL, R_PPC64_CALL_PLT, R_PLT>(expr);
+return oneof<R_PLT, R_PLT_PC, R_PLT_GOTPLT, R_PPC32_PLTREL, R_PPC64_CALL_PLT>(
+expr);
 }
 // Returns true if Expr refers a GOT entry. Note that this function
 // returns false for TLS variables even though they need GOT, because
 // TLS variables uses GOT differently than the regular variables.
 return oneof<R_PC, R_GOTREL, R_GOTPLTREL, R_MIPS_GOTREL, R_PPC64_CALL,
 R_PPC64_RELAX_TOC, R_AARCH64_PAGE_PC, R_RELAX_GOT_PC,
 R_RISCV_PC_INDIRECT, R_PPC64_RELAX_GOT_PC>(expr);
 }
-// Returns true if a given relocation can be computed at link-time.
-//
-// For instance, we know the offset from a relocation to its target at
-// link-time if the relocation is PC-relative and refers a
-// non-interposable function in the same executable. This function
-// will return true for such relocation.
-//
-// If this function returns false, that means we need to emit a
-// dynamic relocation so that the relocation will be fixed at load-time.
-static bool isStaticLinkTimeConstant(RelExpr e, RelType type, const Symbol &sym,
-InputSectionBase &s, uint64_t relOff) {
-// These expressions always compute a constant
-if (oneof<R_DTPREL, R_GOTPLT, R_GOT_OFF, R_TLSLD_GOT_OFF,
-R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOTREL, R_MIPS_GOT_OFF,
-R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC, R_MIPS_TLSGD,
-R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC, R_GOTPLTONLY_PC,
-R_PLT_PC, R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC, R_PPC32_PLTREL,
-R_PPC64_CALL_PLT, R_PPC64_RELAX_TOC, R_RISCV_ADD, R_TLSDESC_CALL,
-R_TLSDESC_PC, R_AARCH64_TLSDESC_PAGE, R_TLSLD_HINT, R_TLSIE_HINT,
-R_AARCH64_GOT_PAGE>(
-e))
-return true;
-// These never do, except if the entire file is position dependent or if
-// only the low bits are used.
-if (e == R_GOT || e == R_PLT || e == R_TLSDESC)
-return target->usesOnlyLowPageBits(type) || !config->isPic;
-if (sym.isPreemptible)
-return false;
-if (!config->isPic)
-return true;
-// The size of a non preemptible symbol is a constant.
-if (e == R_SIZE)
-return true;
-// For the target and the relocation, we want to know if they are
-// absolute or relative.
-bool absVal = isAbsoluteValue(sym);
-bool relE = isRelExpr(e);
-if (absVal && !relE)
-return true;
-if (!absVal && relE)
-return true;
-if (!absVal && !relE)
-return target->usesOnlyLowPageBits(type);
-assert(absVal && relE);
-// Allow R_PLT_PC (optimized to R_PC here) to a hidden undefined weak symbol
-// in PIC mode. This is a little strange, but it allows us to link function
-// calls to such symbols (e.g. glibc/stdlib/exit.c:__run_exit_handlers).
-// Normally such a call will be guarded with a comparison, which will load a
-// zero from the GOT.
-if (sym.isUndefWeak())
-return true;
-// We set the final symbols values for linker script defined symbols later.
-// They always can be computed as a link time constant.
-if (sym.scriptDefined)
-return true;
-error("relocation " + toString(type) + " cannot refer to absolute symbol: " +
-toString(sym) + getLocation(s, sym, relOff));
-return true;
-}
 static RelExpr toPlt(RelExpr expr) {
 switch (expr) {
 case R_PPC64_CALL:
 return R_PPC64_CALL_PLT;
 return R_PC;
 case R_PPC64_CALL_PLT:
 return R_PPC64_CALL;
 case R_PLT:
 return R_ABS;
+case R_PLT_GOTPLT:
+return R_GOTPLTREL;
 default:
 return expr;
 }
 }
 // Returns true if a given shared symbol is in a read-only segment in a DSO.
 template <class ELFT> static bool isReadOnly(SharedSymbol &ss) {
 using Elf_Phdr = typename ELFT::Phdr;
 // Determine if the symbol is read-only by scanning the DSO's program headers.
-const SharedFile &file = ss.getFile();
+const auto &file = cast<SharedFile>(*ss.file);
 for (const Elf_Phdr &phdr :
 check(file.template getObj<ELFT>().program_headers()))
 if ((phdr.p_type == ELF::PT_LOAD || phdr.p_type == ELF::PT_GNU_RELRO) &&
 !(phdr.p_flags & ELF::PF_W) && ss.value >= phdr.p_vaddr &&
 ss.value < phdr.p_vaddr + phdr.p_memsz)
 // Otherwise, they would refer to different places at runtime.
 template <class ELFT>
 static SmallSet<SharedSymbol *, 4> getSymbolsAt(SharedSymbol &ss) {
 using Elf_Sym = typename ELFT::Sym;
-SharedFile &file = ss.getFile();
+const auto &file = cast<SharedFile>(*ss.file);
 SmallSet<SharedSymbol *, 4> ret;
 for (const Elf_Sym &s : file.template getGlobalELFSyms<ELFT>()) {
 if (s.st_shndx == SHN_UNDEF || s.st_shndx == SHN_ABS ||
 s.getType() == STT_TLS || s.st_value != ss.value)
 continue;
 StringRef name = check(s.getName(file.getStringTable()));
-Symbol *sym = symtab->find(name);
+Symbol *sym = symtab.find(name);
 if (auto *alias = dyn_cast_or_null<SharedSymbol>(sym))
 ret.insert(alias);
 }
+// The loop does not check SHT_GNU_verneed, so ret does not contain
+// non-default version symbols. If ss has a non-default version, ret won't
+// contain ss. Just add ss unconditionally. If a non-default version alias is
+// separately copy relocated, it and ss will have different addresses.
+// Fortunately this case is impractical and fails with GNU ld as well.
+ret.insert(&ss);
 return ret;
 }
 // When a symbol is copy relocated or we create a canonical plt entry, it is
 // effectively a defined symbol. In the case of copy relocation the symbol is
 // in .bss and in the case of a canonical plt entry it is in .plt. This function
 // replaces the existing symbol with a Defined pointing to the appropriate
 // location.
-static void replaceWithDefined(Symbol &sym, SectionBase *sec, uint64_t value,
+static void replaceWithDefined(Symbol &sym, SectionBase &sec, uint64_t value,
 uint64_t size) {
 Symbol old = sym;
+Defined(sym.file, StringRef(), sym.binding, sym.stOther, sym.type, value,
-sym.replace(Defined{sym.file, sym.getName(), sym.binding, sym.stOther,
+size, &sec)
-sym.type, value, size, sec});
+.overwrite(sym);
-sym.pltIndex = old.pltIndex;
-sym.gotIndex = old.gotIndex;
 sym.verdefIndex = old.verdefIndex;
 sym.exportDynamic = true;
 sym.isUsedInRegularObj = true;
+// A copy relocated alias may need a GOT entry.
+sym.flags.store(old.flags.load(std::memory_order_relaxed) & NEEDS_GOT,
+std::memory_order_relaxed);
 }
 // Reserve space in .bss or .bss.rel.ro for copy relocation.
 //
 // The copy relocation is pretty much a hack. If you use a copy relocation
 make<BssSection>(isRO ? ".bss.rel.ro" : ".bss", symSize, ss.alignment);
 OutputSection *osec = (isRO ? in.bssRelRo : in.bss)->getParent();
 // At this point, sectionBases has been migrated to sections. Append sec to
 // sections.
-if (osec->sectionCommands.empty() ||
+if (osec->commands.empty() ||
-!isa<InputSectionDescription>(osec->sectionCommands.back()))
+!isa<InputSectionDescription>(osec->commands.back()))
-osec->sectionCommands.push_back(make<InputSectionDescription>(""));
+osec->commands.push_back(make<InputSectionDescription>(""));
-auto *isd = cast<InputSectionDescription>(osec->sectionCommands.back());
+auto *isd = cast<InputSectionDescription>(osec->commands.back());
 isd->sections.push_back(sec);
 osec->commitSection(sec);
 // Look through the DSO's dynamic symbol table for aliases and create a
 // dynamic symbol for each one. This causes the copy relocation to correctly
 // interpose any aliases.
 for (SharedSymbol *sym : getSymbolsAt<ELFT>(ss))
-replaceWithDefined(*sym, sec, 0, sym->size);
+replaceWithDefined(*sym, *sec, 0, sym->size);
-mainPart->relaDyn->addSymbolReloc(target->copyRel, sec, 0, ss);
+mainPart->relaDyn->addSymbolReloc(target->copyRel, *sec, 0, ss);
 }
+// .eh_frame sections are mergeable input sections, so their input
+// offsets are not linearly mapped to output section. For each input
+// offset, we need to find a section piece containing the offset and
+// add the piece's base address to the input offset to compute the
+// output offset. That isn't cheap.
+//
+// This class is to speed up the offset computation. When we process
+// relocations, we access offsets in the monotonically increasing
+// order. So we can optimize for that access pattern.
+//
+// For sections other than .eh_frame, this class doesn't do anything.
+namespace {
+class OffsetGetter {
+public:
+OffsetGetter() = default;
+explicit OffsetGetter(InputSectionBase &sec) {
+if (auto *eh = dyn_cast<EhInputSection>(&sec)) {
+cies = eh->cies;
+fdes = eh->fdes;
+i = cies.begin();
+j = fdes.begin();
+}
+}
+// Translates offsets in input sections to offsets in output sections.
+// Given offset must increase monotonically. We assume that Piece is
+// sorted by inputOff.
+uint64_t get(uint64_t off) {
+if (cies.empty())
+return off;
+while (j != fdes.end() && j->inputOff <= off)
+++j;
+auto it = j;
+if (j == fdes.begin() || j[-1].inputOff + j[-1].size <= off) {
+while (i != cies.end() && i->inputOff <= off)
+++i;
+if (i == cies.begin() || i[-1].inputOff + i[-1].size <= off)
+fatal(".eh_frame: relocation is not in any piece");
+it = i;
+}
+// Offset -1 means that the piece is dead (i.e. garbage collected).
+if (it[-1].outputOff == -1)
+return -1;
+return it[-1].outputOff + (off - it[-1].inputOff);
+}
+private:
+ArrayRef<EhSectionPiece> cies, fdes;
+ArrayRef<EhSectionPiece>::iterator i, j;
+};
+// This class encapsulates states needed to scan relocations for one
+// InputSectionBase.
+class RelocationScanner {
+public:
+template <class ELFT> void scanSection(InputSectionBase &s);
+private:
+InputSectionBase *sec;
+OffsetGetter getter;
+// End of relocations, used by Mips/PPC64.
+const void *end = nullptr;
+template <class RelTy> RelType getMipsN32RelType(RelTy *&rel) const;
+template <class ELFT, class RelTy>
+int64_t computeMipsAddend(const RelTy &rel, RelExpr expr, bool isLocal) const;
+bool isStaticLinkTimeConstant(RelExpr e, RelType type, const Symbol &sym,
+uint64_t relOff) const;
+void processAux(RelExpr expr, RelType type, uint64_t offset, Symbol &sym,
+int64_t addend) const;
+template <class ELFT, class RelTy> void scanOne(RelTy *&i);
+template <class ELFT, class RelTy> void scan(ArrayRef<RelTy> rels);
+};
+} // namespace
 // MIPS has an odd notion of "paired" relocations to calculate addends.
 // For example, if a relocation is of R_MIPS_HI16, there must be a
 // R_MIPS_LO16 relocation after that, and an addend is calculated using
 // the two relocations.
 template <class ELFT, class RelTy>
-static int64_t computeMipsAddend(const RelTy &rel, const RelTy *end,
+int64_t RelocationScanner::computeMipsAddend(const RelTy &rel, RelExpr expr,
-InputSectionBase &sec, RelExpr expr,
+bool isLocal) const {
-bool isLocal) {
 if (expr == R_MIPS_GOTREL && isLocal)
-return sec.getFile<ELFT>()->mipsGp0;
+return sec->getFile<ELFT>()->mipsGp0;
 // The ABI says that the paired relocation is used only for REL.
 // See p. 4-17 at ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
 if (RelTy::IsRela)
 return 0;
 RelType type = rel.getType(config->isMips64EL);
 uint32_t pairTy = getMipsPairType(type, isLocal);
 if (pairTy == R_MIPS_NONE)
 return 0;
-const uint8_t *buf = sec.data().data();
+const uint8_t *buf = sec->rawData.data();
 uint32_t symIndex = rel.getSymbol(config->isMips64EL);
 // To make things worse, paired relocations might not be contiguous in
 // the relocation table, so we need to do linear search. *sigh*
-for (const RelTy *ri = &rel; ri != end; ++ri)
+for (const RelTy *ri = &rel; ri != static_cast<const RelTy *>(end); ++ri)
 if (ri->getType(config->isMips64EL) == pairTy &&
 ri->getSymbol(config->isMips64EL) == symIndex)
 return target->getImplicitAddend(buf + ri->r_offset, pairTy);
 warn("can't find matching " + toString(pairTy) + " relocation for " +
 toString(type));
 return 0;
-}
-// Returns an addend of a given relocation. If it is RELA, an addend
-// is in a relocation itself. If it is REL, we need to read it from an
-// input section.
-template <class ELFT, class RelTy>
-static int64_t computeAddend(const RelTy &rel, const RelTy *end,
-InputSectionBase &sec, RelExpr expr,
-bool isLocal) {
-int64_t addend;
-RelType type = rel.getType(config->isMips64EL);
-if (RelTy::IsRela) {
-addend = getAddend<ELFT>(rel);
-} else {
-const uint8_t *buf = sec.data().data();
-addend = target->getImplicitAddend(buf + rel.r_offset, type);
-}
-if (config->emachine == EM_PPC64 && config->isPic && type == R_PPC64_TOC)
-addend += getPPC64TocBase();
-if (config->emachine == EM_MIPS)
-addend += computeMipsAddend<ELFT>(rel, end, sec, expr, isLocal);
-return addend;
 }
 // Custom error message if Sym is defined in a discarded section.
 template <class ELFT>
 static std::string maybeReportDiscarded(Undefined &sym) {
 auto *file = dyn_cast_or_null<ObjFile<ELFT>>(sym.file);
 if (!file || !sym.discardedSecIdx ||
 file->getSections()[sym.discardedSecIdx] != &InputSection::discarded)
 return "";
-ArrayRef<Elf_Shdr_Impl<ELFT>> objSections =
+ArrayRef<typename ELFT::Shdr> objSections =
-CHECK(file->getObj().sections(), file);
+file->template getELFShdrs<ELFT>();
 std::string msg;
 if (sym.type == ELF::STT_SECTION) {
 msg = "relocation refers to a discarded section: ";
 msg += CHECK(
 return msg;
 // If the discarded section is a COMDAT.
 StringRef signature = file->getShtGroupSignature(objSections, elfSec);
 if (const InputFile *prevailing =
-symtab->comdatGroups.lookup(CachedHashStringRef(signature)))
+symtab.comdatGroups.lookup(CachedHashStringRef(signature))) {
 msg += "\n>>> section group signature: " + signature.str() +
 "\n>>> prevailing definition is in " + toString(prevailing);
+if (sym.nonPrevailing) {
+msg += "\n>>> or the symbol in the prevailing group had STB_WEAK "
+"binding and the symbol in a non-prevailing group had STB_GLOBAL "
+"binding. Mixing groups with STB_WEAK and STB_GLOBAL binding "
+"signature is not supported";
+}
+}
 return msg;
 }
+namespace {
 // Undefined diagnostics are collected in a vector and emitted once all of
 // them are known, so that some postprocessing on the list of undefined symbols
 // can happen before lld emits diagnostics.
 struct UndefinedDiag {
-Symbol *sym;
+Undefined *sym;
 struct Loc {
 InputSectionBase *sec;
 uint64_t offset;
 };
 std::vector<Loc> locs;
 bool isWarning;
 };
-static std::vector<UndefinedDiag> undefs;
+std::vector<UndefinedDiag> undefs;
+std::mutex relocMutex;
+}
 // Check whether the definition name def is a mangled function name that matches
 // the reference name ref.
 static bool canSuggestExternCForCXX(StringRef ref, StringRef def) {
 llvm::ItaniumPartialDemangler d;
 }
 // Suggest an alternative spelling of an "undefined symbol" diagnostic. Returns
 // the suggested symbol, which is either in the symbol table, or in the same
 // file of sym.
-template <class ELFT>
 static const Symbol *getAlternativeSpelling(const Undefined &sym,
 std::string &pre_hint,
 std::string &post_hint) {
 DenseMap<StringRef, const Symbol *> map;
-if (auto *file = dyn_cast_or_null<ObjFile<ELFT>>(sym.file)) {
+if (sym.file && sym.file->kind() == InputFile::ObjKind) {
+auto *file = cast<ELFFileBase>(sym.file);
 // If sym is a symbol defined in a discarded section, maybeReportDiscarded()
 // will give an error. Don't suggest an alternative spelling.
 if (file && sym.discardedSecIdx != 0 &&
 file->getSections()[sym.discardedSecIdx] == &InputSection::discarded)
 return nullptr;
 // If defined locally.
 if (const Symbol *s = map.lookup(newName))
 return s;
 // If in the symbol table and not undefined.
-if (const Symbol *s = symtab->find(newName))
+if (const Symbol *s = symtab.find(newName))
 if (!s->isUndefined())
 return s;
 return nullptr;
 };
 // Case mismatch, e.g. Foo vs FOO.
 for (auto &it : map)
 if (name.equals_insensitive(it.first))
 return it.second;
-for (Symbol *sym : symtab->symbols())
+for (Symbol *sym : symtab.getSymbols())
 if (!sym->isUndefined() && name.equals_insensitive(sym->getName()))
 return sym;
 // The reference may be a mangled name while the definition is not. Suggest a
 // missing extern "C".
 if (canSuggestExternCForCXX(name, it.first)) {
 s = it.second;
 break;
 }
 if (!s)
-for (Symbol *sym : symtab->symbols())
+for (Symbol *sym : symtab.getSymbols())
 if (canSuggestExternCForCXX(name, sym->getName())) {
 s = sym;
 break;
 }
 if (s) {
 }
 return nullptr;
 }
-template <class ELFT>
 static void reportUndefinedSymbol(const UndefinedDiag &undef,
 bool correctSpelling) {
-Symbol &sym = *undef.sym;
+Undefined &sym = *undef.sym;
 auto visibility = [&]() -> std::string {
-switch (sym.visibility) {
+switch (sym.visibility()) {
 case STV_INTERNAL:
 return "internal ";
 case STV_HIDDEN:
 return "hidden ";
 case STV_PROTECTED:
 default:
 return "";
 }
 };
-std::string msg = maybeReportDiscarded<ELFT>(cast<Undefined>(sym));
+std::string msg;
+switch (config->ekind) {
+case ELF32LEKind:
+msg = maybeReportDiscarded<ELF32LE>(sym);
+break;
+case ELF32BEKind:
+msg = maybeReportDiscarded<ELF32BE>(sym);
+break;
+case ELF64LEKind:
+msg = maybeReportDiscarded<ELF64LE>(sym);
+break;
+case ELF64BEKind:
+msg = maybeReportDiscarded<ELF64BE>(sym);
+break;
+default:
+llvm_unreachable("");
+}
 if (msg.empty())
 msg = "undefined " + visibility() + "symbol: " + toString(sym);
 const size_t maxUndefReferences = 3;
 size_t i = 0;
 msg += ("\n>>> referenced " + Twine(undef.locs.size() - i) + " more times")
 .str();
 if (correctSpelling) {
 std::string pre_hint = ": ", post_hint;
-if (const Symbol *corrected = getAlternativeSpelling<ELFT>(
+if (const Symbol *corrected =
-cast<Undefined>(sym), pre_hint, post_hint)) {
+getAlternativeSpelling(sym, pre_hint, post_hint)) {
 msg += "\n>>> did you mean" + pre_hint + toString(*corrected) + post_hint;
 if (corrected->file)
 msg += "\n>>> defined in: " + toString(corrected->file);
 }
 }
 if (sym.getName().startswith("_ZTV"))
 msg +=
 "\n>>> the vtable symbol may be undefined because the class is missing "
 "its key function (see https://lld.llvm.org/missingkeyfunction)";
+if (config->gcSections && config->zStartStopGC &&
+sym.getName().startswith("__start_")) {
+msg += "\n>>> the encapsulation symbol needs to be retained under "
+"--gc-sections properly; consider -z nostart-stop-gc "
+"(see https://lld.llvm.org/ELF/start-stop-gc)";
+}
 if (undef.isWarning)
 warn(msg);
 else
 error(msg, ErrorTag::SymbolNotFound, {sym.getName()});
 }
-template <class ELFT> void elf::reportUndefinedSymbols() {
+void elf::reportUndefinedSymbols() {
 // Find the first "undefined symbol" diagnostic for each diagnostic, and
 // collect all "referenced from" lines at the first diagnostic.
 DenseMap<Symbol *, UndefinedDiag *> firstRef;
 for (UndefinedDiag &undef : undefs) {
 assert(undef.locs.size() == 1);
 } else
 firstRef[undef.sym] = &undef;
 }
 // Enable spell corrector for the first 2 diagnostics.
-for (auto it : enumerate(undefs))
+for (const auto &[i, undef] : llvm::enumerate(undefs))
-if (!it.value().locs.empty())
+if (!undef.locs.empty())
-reportUndefinedSymbol<ELFT>(it.value(), it.index() < 2);
+reportUndefinedSymbol(undef, i < 2);
 undefs.clear();
 }
 // Report an undefined symbol if necessary.
 // Returns true if the undefined symbol will produce an error message.
-static bool maybeReportUndefined(Symbol &sym, InputSectionBase &sec,
+static bool maybeReportUndefined(Undefined &sym, InputSectionBase &sec,
 uint64_t offset) {
-if (!sym.isUndefined())
+std::lock_guard<std::mutex> lock(relocMutex);
-return false;
 // If versioned, issue an error (even if the symbol is weak) because we don't
 // know the defining filename which is required to construct a Verneed entry.
-if (*sym.getVersionSuffix() == '@') {
+if (sym.hasVersionSuffix) {
 undefs.push_back({&sym, {{&sec, offset}}, false});
 return true;
 }
 if (sym.isWeak())
 return false;
-bool canBeExternal = !sym.isLocal() && sym.visibility == STV_DEFAULT;
+bool canBeExternal = !sym.isLocal() && sym.visibility() == STV_DEFAULT;
 if (config->unresolvedSymbols == UnresolvedPolicy::Ignore && canBeExternal)
 return false;
 // clang (as of 2019-06-12) / gcc (as of 8.2.1) PPC64 may emit a .rela.toc
 // which references a switch table in a discarded .rodata/.text section. The
 // allowed. Work around the bug.
 //
 // PPC32 .got2 is similar but cannot be fixed. Multiple .got2 is infeasible
 // because .LC0-.LTOC is not representable if the two labels are in different
 // .got2
-if (cast<Undefined>(sym).discardedSecIdx != 0 &&
+if (sym.discardedSecIdx != 0 && (sec.name == ".got2" || sec.name == ".toc"))
-(sec.name == ".got2" || sec.name == ".toc"))
 return false;
 bool isWarning =
 (config->unresolvedSymbols == UnresolvedPolicy::Warn && canBeExternal) ||
 config->noinhibitExec;
 // MIPS N32 ABI treats series of successive relocations with the same offset
 // as a single relocation. The similar approach used by N64 ABI, but this ABI
 // packs all relocations into the single relocation record. Here we emulate
 // this for the N32 ABI. Iterate over relocation with the same offset and put
 // theirs types into the single bit-set.
-template <class RelTy> static RelType getMipsN32RelType(RelTy *&rel, RelTy *end) {
+template <class RelTy>
+RelType RelocationScanner::getMipsN32RelType(RelTy *&rel) const {
 RelType type = 0;
 uint64_t offset = rel->r_offset;
 int n = 0;
-while (rel != end && rel->r_offset == offset)
+while (rel != static_cast<const RelTy *>(end) && rel->r_offset == offset)
 type |= (rel++)->getType(config->isMips64EL) << (8 * n++);
 return type;
 }
-// .eh_frame sections are mergeable input sections, so their input
+template <bool shard = false>
-// offsets are not linearly mapped to output section. For each input
+static void addRelativeReloc(InputSectionBase &isec, uint64_t offsetInSec,
-// offset, we need to find a section piece containing the offset and
-// add the piece's base address to the input offset to compute the
-// output offset. That isn't cheap.
-//
-// This class is to speed up the offset computation. When we process
-// relocations, we access offsets in the monotonically increasing
-// order. So we can optimize for that access pattern.
-//
-// For sections other than .eh_frame, this class doesn't do anything.
-namespace {
-class OffsetGetter {
-public:
-explicit OffsetGetter(InputSectionBase &sec) {
-if (auto *eh = dyn_cast<EhInputSection>(&sec))
-pieces = eh->pieces;
-}
-// Translates offsets in input sections to offsets in output sections.
-// Given offset must increase monotonically. We assume that Piece is
-// sorted by inputOff.
-uint64_t get(uint64_t off) {
-if (pieces.empty())
-return off;
-while (i != pieces.size() && pieces[i].inputOff + pieces[i].size <= off)
-++i;
-if (i == pieces.size())
-fatal(".eh_frame: relocation is not in any piece");
-// Pieces must be contiguous, so there must be no holes in between.
-assert(pieces[i].inputOff <= off && "Relocation not in any piece");
-// Offset -1 means that the piece is dead (i.e. garbage collected).
-if (pieces[i].outputOff == -1)
-return -1;
-return pieces[i].outputOff + off - pieces[i].inputOff;
-}
-private:
-ArrayRef<EhSectionPiece> pieces;
-size_t i = 0;
-};
-} // namespace
-static void addRelativeReloc(InputSectionBase *isec, uint64_t offsetInSec,
 Symbol &sym, int64_t addend, RelExpr expr,
 RelType type) {
-Partition &part = isec->getPartition();
+Partition &part = isec.getPartition();
 // Add a relative relocation. If relrDyn section is enabled, and the
 // relocation offset is guaranteed to be even, add the relocation to
 // the relrDyn section, otherwise add it to the relaDyn section.
 // relrDyn sections don't support odd offsets. Also, relrDyn sections
 // don't store the addend values, so we must write it to the relocated
 // address.
-if (part.relrDyn && isec->alignment >= 2 && offsetInSec % 2 == 0) {
+if (part.relrDyn && isec.alignment >= 2 && offsetInSec % 2 == 0) {
-isec->relocations.push_back({expr, type, offsetInSec, addend, &sym});
+isec.relocations.push_back({expr, type, offsetInSec, addend, &sym});
-part.relrDyn->relocs.push_back({isec, offsetInSec});
+if (shard)
+part.relrDyn->relocsVec[parallel::getThreadIndex()].push_back(
+{&isec, offsetInSec});
+else
+part.relrDyn->relocs.push_back({&isec, offsetInSec});
 return;
 }
-part.relaDyn->addRelativeReloc(target->relativeRel, isec, offsetInSec, sym,
+part.relaDyn->addRelativeReloc<shard>(target->relativeRel, isec, offsetInSec,
-addend, type, expr);
+sym, addend, type, expr);
 }
 template <class PltSection, class GotPltSection>
-static void addPltEntry(PltSection *plt, GotPltSection *gotPlt,
+static void addPltEntry(PltSection &plt, GotPltSection &gotPlt,
-RelocationBaseSection *rel, RelType type, Symbol &sym) {
+RelocationBaseSection &rel, RelType type, Symbol &sym) {
-plt->addEntry(sym);
+plt.addEntry(sym);
-gotPlt->addEntry(sym);
+gotPlt.addEntry(sym);
-rel->addReloc({type, gotPlt, sym.getGotPltOffset(),
+rel.addReloc({type, &gotPlt, sym.getGotPltOffset(),
 sym.isPreemptible ? DynamicReloc::AgainstSymbol
 : DynamicReloc::AddendOnlyWithTargetVA,
 sym, 0, R_ABS});
 }
 static void addGotEntry(Symbol &sym) {
 in.got->addEntry(sym);
-RelExpr expr = sym.isTls() ? R_TPREL : R_ABS;
 uint64_t off = sym.getGotOffset();
-// If a GOT slot value can be calculated at link-time, which is now,
+// If preemptible, emit a GLOB_DAT relocation.
-// we can just fill that out.
+if (sym.isPreemptible) {
-//
+mainPart->relaDyn->addReloc({target->gotRel, in.got.get(), off,
-// (We don't actually write a value to a GOT slot right now, but we
+DynamicReloc::AgainstSymbol, sym, 0, R_ABS});
-// add a static relocation to a Relocations vector so that
-// InputSection::relocate will do the work for us. We may be able
-// to just write a value now, but it is a TODO.)
-bool isLinkTimeConstant =
-!sym.isPreemptible && (!config->isPic || isAbsolute(sym));
-if (isLinkTimeConstant) {
-in.got->relocations.push_back({expr, target->symbolicRel, off, 0, &sym});
 return;
 }
-// Otherwise, we emit a dynamic relocation to .rel[a].dyn so that
+// Otherwise, the value is either a link-time constant or the load base
-// the GOT slot will be fixed at load-time.
+// plus a constant.
-if (!sym.isTls() && !sym.isPreemptible && config->isPic) {
+if (!config->isPic || isAbsolute(sym))
-addRelativeReloc(in.got, off, sym, 0, R_ABS, target->symbolicRel);
+in.got->relocations.push_back({R_ABS, target->symbolicRel, off, 0, &sym});
+else
+addRelativeReloc(*in.got, off, sym, 0, R_ABS, target->symbolicRel);
+}
+static void addTpOffsetGotEntry(Symbol &sym) {
+in.got->addEntry(sym);
+uint64_t off = sym.getGotOffset();
+if (!sym.isPreemptible && !config->isPic) {
+in.got->relocations.push_back({R_TPREL, target->symbolicRel, off, 0, &sym});
 return;
 }
 mainPart->relaDyn->addAddendOnlyRelocIfNonPreemptible(
-sym.isTls() ? target->tlsGotRel : target->gotRel, in.got, off, sym,
+target->tlsGotRel, *in.got, off, sym, target->symbolicRel);
-target->symbolicRel);
 }
 // Return true if we can define a symbol in the executable that
 // contains the value/function of a symbol defined in a shared
 // library.
 static bool canDefineSymbolInExecutable(Symbol &sym) {
 // If the symbol has default visibility the symbol defined in the
 // executable will preempt it.
 // Note that we want the visibility of the shared symbol itself, not
-// the visibility of the symbol in the output file we are producing. That is
+// the visibility of the symbol in the output file we are producing.
-// why we use Sym.stOther.
+if (!sym.dsoProtected)
-if ((sym.stOther & 0x3) == STV_DEFAULT)
 return true;
 // If we are allowed to break address equality of functions, defining
 // a plt entry will allow the program to call the function in the
 // .so, but the .so and the executable will no agree on the address
 // of the function. Similar logic for objects.
 return ((sym.isFunc() && config->ignoreFunctionAddressEquality) ||
 (sym.isObject() && config->ignoreDataAddressEquality));
+}
+// Returns true if a given relocation can be computed at link-time.
+// This only handles relocation types expected in processAux.
+//
+// For instance, we know the offset from a relocation to its target at
+// link-time if the relocation is PC-relative and refers a
+// non-interposable function in the same executable. This function
+// will return true for such relocation.
+//
+// If this function returns false, that means we need to emit a
+// dynamic relocation so that the relocation will be fixed at load-time.
+bool RelocationScanner::isStaticLinkTimeConstant(RelExpr e, RelType type,
+const Symbol &sym,
+uint64_t relOff) const {
+// These expressions always compute a constant
+if (oneof<R_GOTPLT, R_GOT_OFF, R_RELAX_HINT, R_MIPS_GOT_LOCAL_PAGE,
+R_MIPS_GOTREL, R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC,
+R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC, R_GOTPLTONLY_PC,
+R_PLT_PC, R_PLT_GOTPLT, R_PPC32_PLTREL, R_PPC64_CALL_PLT,
+R_PPC64_RELAX_TOC, R_RISCV_ADD, R_AARCH64_GOT_PAGE>(e))
+return true;
+// These never do, except if the entire file is position dependent or if
+// only the low bits are used.
+if (e == R_GOT || e == R_PLT)
+return target->usesOnlyLowPageBits(type) || !config->isPic;
+if (sym.isPreemptible)
+return false;
+if (!config->isPic)
+return true;
+// The size of a non preemptible symbol is a constant.
+if (e == R_SIZE)
+return true;
+// For the target and the relocation, we want to know if they are
+// absolute or relative.
+bool absVal = isAbsoluteValue(sym);
+bool relE = isRelExpr(e);
+if (absVal && !relE)
+return true;
+if (!absVal && relE)
+return true;
+if (!absVal && !relE)
+return target->usesOnlyLowPageBits(type);
+assert(absVal && relE);
+// Allow R_PLT_PC (optimized to R_PC here) to a hidden undefined weak symbol
+// in PIC mode. This is a little strange, but it allows us to link function
+// calls to such symbols (e.g. glibc/stdlib/exit.c:__run_exit_handlers).
+// Normally such a call will be guarded with a comparison, which will load a
+// zero from the GOT.
+if (sym.isUndefWeak())
+return true;
+// We set the final symbols values for linker script defined symbols later.
+// They always can be computed as a link time constant.
+if (sym.scriptDefined)
+return true;
+error("relocation " + toString(type) + " cannot refer to absolute symbol: " +
+toString(sym) + getLocation(*sec, sym, relOff));
+return true;
 }
 // The reason we have to do this early scan is as follows
 // * To mmap the output file, we need to know the size
 // * For that, we need to know how many dynamic relocs we will have.
 // This would have some drawbacks. For example, we would only know if .rela.dyn
 // is needed after applying relocations. If it is, it will go after rw and rx
 // sections. Given that it is ro, we will need an extra PT_LOAD. This
 // complicates things for the dynamic linker and means we would have to reserve
 // space for the extra PT_LOAD even if we end up not using it.
-template <class ELFT, class RelTy>
+void RelocationScanner::processAux(RelExpr expr, RelType type, uint64_t offset,
-static void processRelocAux(InputSectionBase &sec, RelExpr expr, RelType type,
+Symbol &sym, int64_t addend) const {
-uint64_t offset, Symbol &sym, const RelTy &rel,
+// If non-ifunc non-preemptible, change PLT to direct call and optimize GOT
-int64_t addend) {
+// indirection.
+const bool isIfunc = sym.isGnuIFunc();
+if (!sym.isPreemptible && (!isIfunc || config->zIfuncNoplt)) {
+if (expr != R_GOT_PC) {
+// The 0x8000 bit of r_addend of R_PPC_PLTREL24 is used to choose call
+// stub type. It should be ignored if optimized to R_PC.
+if (config->emachine == EM_PPC && expr == R_PPC32_PLTREL)
+addend &= ~0x8000;
+// R_HEX_GD_PLT_B22_PCREL (call a@GDPLT) is transformed into
+// call __tls_get_addr even if the symbol is non-preemptible.
+if (!(config->emachine == EM_HEXAGON &&
+(type == R_HEX_GD_PLT_B22_PCREL ||
+type == R_HEX_GD_PLT_B22_PCREL_X ||
+type == R_HEX_GD_PLT_B32_PCREL_X)))
+expr = fromPlt(expr);
+} else if (!isAbsoluteValue(sym)) {
+expr =
+target->adjustGotPcExpr(type, addend, sec->rawData.data() + offset);
+}
+}
+// We were asked not to generate PLT entries for ifuncs. Instead, pass the
+// direct relocation on through.
+if (LLVM_UNLIKELY(isIfunc) && config->zIfuncNoplt) {
+std::lock_guard<std::mutex> lock(relocMutex);
+sym.exportDynamic = true;
+mainPart->relaDyn->addSymbolReloc(type, *sec, offset, sym, addend, type);
+return;
+}
+if (needsGot(expr)) {
+if (config->emachine == EM_MIPS) {
+// MIPS ABI has special rules to process GOT entries and doesn't
+// require relocation entries for them. A special case is TLS
+// relocations. In that case dynamic loader applies dynamic
+// relocations to initialize TLS GOT entries.
+// See "Global Offset Table" in Chapter 5 in the following document
+// for detailed description:
+// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
+in.mipsGot->addEntry(*sec->file, sym, addend, expr);
+} else {
+sym.setFlags(NEEDS_GOT);
+}
+} else if (needsPlt(expr)) {
+sym.setFlags(NEEDS_PLT);
+} else if (LLVM_UNLIKELY(isIfunc)) {
+sym.setFlags(HAS_DIRECT_RELOC);
+}
 // If the relocation is known to be a link-time constant, we know no dynamic
 // relocation will be created, pass the control to relocateAlloc() or
 // relocateNonAlloc() to resolve it.
 //
 // The behavior of an undefined weak reference is implementation defined. For
 // The general expectation of -no-pie static linking is that there is no
 // dynamic relocation (except IRELATIVE). Emitting dynamic relocations for
 // -shared matches the spirit of its -z undefs default. -pie has freedom on
 // choices, and we choose dynamic relocations to be consistent with the
 // handling of GOT-generating relocations.
-if (isStaticLinkTimeConstant(expr, type, sym, sec, offset) ||
+if (isStaticLinkTimeConstant(expr, type, sym, offset) ||
 (!config->isPic && sym.isUndefWeak())) {
-sec.relocations.push_back({expr, type, offset, addend, &sym});
+sec->relocations.push_back({expr, type, offset, addend, &sym});
 return;
 }
-bool canWrite = (sec.flags & SHF_WRITE) || !config->zText;
+bool canWrite = (sec->flags & SHF_WRITE) || !config->zText;
 if (canWrite) {
 RelType rel = target->getDynRel(type);
 if (expr == R_GOT || (rel == target->symbolicRel && !sym.isPreemptible)) {
-addRelativeReloc(&sec, offset, sym, addend, expr, type);
+addRelativeReloc<true>(*sec, offset, sym, addend, expr, type);
 return;
 } else if (rel != 0) {
 if (config->emachine == EM_MIPS && rel == target->symbolicRel)
 rel = target->relativeRel;
-sec.getPartition().relaDyn->addSymbolReloc(rel, &sec, offset, sym, addend,
+std::lock_guard<std::mutex> lock(relocMutex);
-type);
+sec->getPartition().relaDyn->addSymbolReloc(rel, *sec, offset, sym,
+addend, type);
 // MIPS ABI turns using of GOT and dynamic relocations inside out.
 // While regular ABI uses dynamic relocations to fill up GOT entries
 // MIPS ABI requires dynamic linker to fills up GOT entries using
 // specially sorted dynamic symbol table. This affects even dynamic
 // dynamic linker performs symbol resolution, writes the symbol value
 // to the GOT entry and reads the GOT entry when it needs to perform
 // a dynamic relocation.
 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf p.4-19
 if (config->emachine == EM_MIPS)
-in.mipsGot->addEntry(*sec.file, sym, addend, expr);
+in.mipsGot->addEntry(*sec->file, sym, addend, expr);
 return;
 }
 }
 // When producing an executable, we can perform copy relocations (for
 // STT_OBJECT) and canonical PLT (for STT_FUNC).
 if (!config->shared) {
 if (!canDefineSymbolInExecutable(sym)) {
 errorOrWarn("cannot preempt symbol: " + toString(sym) +
-getLocation(sec, sym, offset));
+getLocation(*sec, sym, offset));
 return;
 }
 if (sym.isObject()) {
 // Produce a copy relocation.
 if (auto *ss = dyn_cast<SharedSymbol>(&sym)) {
 if (!config->zCopyreloc)
 error("unresolvable relocation " + toString(type) +
 " against symbol '" + toString(*ss) +
 "'; recompile with -fPIC or remove '-z nocopyreloc'" +
-getLocation(sec, sym, offset));
+getLocation(*sec, sym, offset));
-addCopyRelSymbol<ELFT>(*ss);
+sym.setFlags(NEEDS_COPY);
 }
-sec.relocations.push_back({expr, type, offset, addend, &sym});
+sec->relocations.push_back({expr, type, offset, addend, &sym});
 return;
 }
 // This handles a non PIC program call to function in a shared library. In
 // an ideal world, we could just report an error saying the relocation can
 //   the wrong ebx value.
 if (sym.isFunc()) {
 if (config->pie && config->emachine == EM_386)
 errorOrWarn("symbol '" + toString(sym) +
 "' cannot be preempted; recompile with -fPIE" +
-getLocation(sec, sym, offset));
+getLocation(*sec, sym, offset));
-if (!sym.isInPlt())
+sym.setFlags(NEEDS_COPY | NEEDS_PLT);
-addPltEntry(in.plt, in.gotPlt, in.relaPlt, target->pltRel, sym);
+sec->relocations.push_back({expr, type, offset, addend, &sym});
-if (!sym.isDefined()) {
-replaceWithDefined(
-sym, in.plt,
-target->pltHeaderSize + target->pltEntrySize * sym.pltIndex, 0);
-if (config->emachine == EM_PPC) {
-// PPC32 canonical PLT entries are at the beginning of .glink
-cast<Defined>(sym).value = in.plt->headerSize;
-in.plt->headerSize += 16;
-cast<PPC32GlinkSection>(in.plt)->canonical_plts.push_back(&sym);
-}
-}
-sym.needsPltAddr = true;
-sec.relocations.push_back({expr, type, offset, addend, &sym});
 return;
 }
 }
-if (config->isPic) {
+errorOrWarn("relocation " + toString(type) + " cannot be used against " +
-if (!canWrite && !isRelExpr(expr))
+(sym.getName().empty() ? "local symbol"
-errorOrWarn(
+: "symbol '" + toString(sym) + "'") +
-"can't create dynamic relocation " + toString(type) + " against " +
+"; recompile with -fPIC" + getLocation(*sec, sym, offset));
-(sym.getName().empty() ? "local symbol"
+}
-: "symbol: " + toString(sym)) +
-" in readonly segment; recompile object files with -fPIC "
+// This function is similar to the `handleTlsRelocation`. MIPS does not
-"or pass '-Wl,-z,notext' to allow text relocations in the output" +
+// support any relaxations for TLS relocations so by factoring out MIPS
-getLocation(sec, sym, offset));
+// handling in to the separate function we can simplify the code and do not
-else
+// pollute other `handleTlsRelocation` by MIPS `ifs` statements.
-errorOrWarn(
+// Mips has a custom MipsGotSection that handles the writing of GOT entries
-"relocation " + toString(type) + " cannot be used against " +
+// without dynamic relocations.
-(sym.getName().empty() ? "local symbol" : "symbol " + toString(sym)) +
+static unsigned handleMipsTlsRelocation(RelType type, Symbol &sym,
-"; recompile with -fPIC" + getLocation(sec, sym, offset));
+InputSectionBase &c, uint64_t offset,
-return;
+int64_t addend, RelExpr expr) {
-}
+if (expr == R_MIPS_TLSLD) {
+in.mipsGot->addTlsIndex(*c.file);
-errorOrWarn("symbol '" + toString(sym) + "' has no type" +
+c.relocations.push_back({expr, type, offset, addend, &sym});
-getLocation(sec, sym, offset));
+return 1;
 }
+if (expr == R_MIPS_TLSGD) {
-template <class ELFT, class RelTy>
+in.mipsGot->addDynTlsEntry(*c.file, sym);
-static void scanReloc(InputSectionBase &sec, OffsetGetter &getOffset, RelTy *&i,
+c.relocations.push_back({expr, type, offset, addend, &sym});
-RelTy *start, RelTy *end) {
+return 1;
+}
+return 0;
+}
+// Notes about General Dynamic and Local Dynamic TLS models below. They may
+// require the generation of a pair of GOT entries that have associated dynamic
+// relocations. The pair of GOT entries created are of the form GOT[e0] Module
+// Index (Used to find pointer to TLS block at run-time) GOT[e1] Offset of
+// symbol in TLS block.
+//
+// Returns the number of relocations processed.
+static unsigned handleTlsRelocation(RelType type, Symbol &sym,
+InputSectionBase &c, uint64_t offset,
+int64_t addend, RelExpr expr) {
+if (expr == R_TPREL || expr == R_TPREL_NEG) {
+if (config->shared) {
+errorOrWarn("relocation " + toString(type) + " against " + toString(sym) +
+" cannot be used with -shared" + getLocation(c, sym, offset));
+return 1;
+}
+return 0;
+}
+if (config->emachine == EM_MIPS)
+return handleMipsTlsRelocation(type, sym, c, offset, addend, expr);
+if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC,
+R_TLSDESC_GOTPLT>(expr) &&
+config->shared) {
+if (expr != R_TLSDESC_CALL) {
+sym.setFlags(NEEDS_TLSDESC);
+c.relocations.push_back({expr, type, offset, addend, &sym});
+}
+return 1;
+}
+// ARM, Hexagon and RISC-V do not support GD/LD to IE/LE relaxation.  For
+// PPC64, if the file has missing R_PPC64_TLSGD/R_PPC64_TLSLD, disable
+// relaxation as well.
+bool toExecRelax = !config->shared && config->emachine != EM_ARM &&
+config->emachine != EM_HEXAGON &&
+config->emachine != EM_RISCV &&
+!c.file->ppc64DisableTLSRelax;
+// If we are producing an executable and the symbol is non-preemptable, it
+// must be defined and the code sequence can be relaxed to use Local-Exec.
+//
+// ARM and RISC-V do not support any relaxations for TLS relocations, however,
+// we can omit the DTPMOD dynamic relocations and resolve them at link time
+// because them are always 1. This may be necessary for static linking as
+// DTPMOD may not be expected at load time.
+bool isLocalInExecutable = !sym.isPreemptible && !config->shared;
+// Local Dynamic is for access to module local TLS variables, while still
+// being suitable for being dynamically loaded via dlopen. GOT[e0] is the
+// module index, with a special value of 0 for the current module. GOT[e1] is
+// unused. There only needs to be one module index entry.
+if (oneof<R_TLSLD_GOT, R_TLSLD_GOTPLT, R_TLSLD_PC, R_TLSLD_HINT>(
+expr)) {
+// Local-Dynamic relocs can be relaxed to Local-Exec.
+if (toExecRelax) {
+c.relocations.push_back(
+{target->adjustTlsExpr(type, R_RELAX_TLS_LD_TO_LE), type, offset,
+addend, &sym});
+return target->getTlsGdRelaxSkip(type);
+}
+if (expr == R_TLSLD_HINT)
+return 1;
+ctx.needsTlsLd.store(true, std::memory_order_relaxed);
+c.relocations.push_back({expr, type, offset, addend, &sym});
+return 1;
+}
+// Local-Dynamic relocs can be relaxed to Local-Exec.
+if (expr == R_DTPREL) {
+if (toExecRelax)
+expr = target->adjustTlsExpr(type, R_RELAX_TLS_LD_TO_LE);
+c.relocations.push_back({expr, type, offset, addend, &sym});
+return 1;
+}
+// Local-Dynamic sequence where offset of tls variable relative to dynamic
+// thread pointer is stored in the got. This cannot be relaxed to Local-Exec.
+if (expr == R_TLSLD_GOT_OFF) {
+sym.setFlags(NEEDS_GOT_DTPREL);
+c.relocations.push_back({expr, type, offset, addend, &sym});
+return 1;
+}
+if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC,
+R_TLSDESC_GOTPLT, R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC>(expr)) {
+if (!toExecRelax) {
+sym.setFlags(NEEDS_TLSGD);
+c.relocations.push_back({expr, type, offset, addend, &sym});
+return 1;
+}
+// Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec
+// depending on the symbol being locally defined or not.
+if (sym.isPreemptible) {
+sym.setFlags(NEEDS_TLSGD_TO_IE);
+c.relocations.push_back(
+{target->adjustTlsExpr(type, R_RELAX_TLS_GD_TO_IE), type, offset,
+addend, &sym});
+} else {
+c.relocations.push_back(
+{target->adjustTlsExpr(type, R_RELAX_TLS_GD_TO_LE), type, offset,
+addend, &sym});
+}
+return target->getTlsGdRelaxSkip(type);
+}
+if (oneof<R_GOT, R_GOTPLT, R_GOT_PC, R_AARCH64_GOT_PAGE_PC, R_GOT_OFF,
+R_TLSIE_HINT>(expr)) {
+ctx.hasTlsIe.store(true, std::memory_order_relaxed);
+// Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally
+// defined.
+if (toExecRelax && isLocalInExecutable) {
+c.relocations.push_back(
+{R_RELAX_TLS_IE_TO_LE, type, offset, addend, &sym});
+} else if (expr != R_TLSIE_HINT) {
+sym.setFlags(NEEDS_TLSIE);
+// R_GOT needs a relative relocation for PIC on i386 and Hexagon.
+if (expr == R_GOT && config->isPic && !target->usesOnlyLowPageBits(type))
+addRelativeReloc<true>(c, offset, sym, addend, expr, type);
+else
+c.relocations.push_back({expr, type, offset, addend, &sym});
+}
+return 1;
+}
+return 0;
+}
+template <class ELFT, class RelTy> void RelocationScanner::scanOne(RelTy *&i) {
 const RelTy &rel = *i;
 uint32_t symIndex = rel.getSymbol(config->isMips64EL);
-Symbol &sym = sec.getFile<ELFT>()->getSymbol(symIndex);
+Symbol &sym = sec->getFile<ELFT>()->getSymbol(symIndex);
 RelType type;
-// Deal with MIPS oddity.
 if (config->mipsN32Abi) {
-type = getMipsN32RelType(i, end);
+type = getMipsN32RelType(i);
 } else {
 type = rel.getType(config->isMips64EL);
 ++i;
 }
 // Get an offset in an output section this relocation is applied to.
-uint64_t offset = getOffset.get(rel.r_offset);
+uint64_t offset = getter.get(rel.r_offset);
 if (offset == uint64_t(-1))
 return;
-// Error if the target symbol is undefined. Symbol index 0 may be used by
+RelExpr expr = target->getRelExpr(type, sym, sec->rawData.data() + offset);
-// marker relocations, e.g. R_*_NONE and R_ARM_V4BX. Don't error on them.
+int64_t addend =
-if (symIndex != 0 && maybeReportUndefined(sym, sec, rel.r_offset))
+RelTy::IsRela
-return;
+? getAddend<ELFT>(rel)
+: target->getImplicitAddend(sec->rawData.data() + rel.r_offset, type);
-const uint8_t *relocatedAddr = sec.data().begin() + rel.r_offset;
+if (LLVM_UNLIKELY(config->emachine == EM_MIPS))
-RelExpr expr = target->getRelExpr(type, sym, relocatedAddr);
+addend += computeMipsAddend<ELFT>(rel, expr, sym.isLocal());
+else if (config->emachine == EM_PPC64 && config->isPic && type == R_PPC64_TOC)
+addend += getPPC64TocBase();
 // Ignore R_*_NONE and other marker relocations.
 if (expr == R_NONE)
 return;
-// Read an addend.
+// Error if the target symbol is undefined. Symbol index 0 may be used by
-int64_t addend = computeAddend<ELFT>(rel, end, sec, expr, sym.isLocal());
+// marker relocations, e.g. R_*_NONE and R_ARM_V4BX. Don't error on them.
+if (sym.isUndefined() && symIndex != 0 &&
+maybeReportUndefined(cast<Undefined>(sym), *sec, offset))
+return;
 if (config->emachine == EM_PPC64) {
 // We can separate the small code model relocations into 2 categories:
 // 1) Those that access the compiler generated .toc sections.
 // 2) Those that access the linker allocated got entries.
 // lld allocates got entries to symbols on demand. Since we don't try to
 // sort the got entries in any way, we don't have to track which objects
 // have got-based small code model relocs. The .toc sections get placed
 // after the end of the linker allocated .got section and we do sort those
 // so sections addressed with small code model relocations come first.
-if (isPPC64SmallCodeModelTocReloc(type))
+if (type == R_PPC64_TOC16 || type == R_PPC64_TOC16_DS)
-sec.file->ppc64SmallCodeModelTocRelocs = true;
+sec->file->ppc64SmallCodeModelTocRelocs = true;
 // Record the TOC entry (.toc + addend) as not relaxable. See the comment in
 // InputSectionBase::relocateAlloc().
 if (type == R_PPC64_TOC16_LO && sym.isSection() && isa<Defined>(sym) &&
 cast<Defined>(sym).section->name == ".toc")
 if ((type == R_PPC64_TLSGD && expr == R_TLSDESC_CALL) ||
 (type == R_PPC64_TLSLD && expr == R_TLSLD_HINT)) {
 if (i == end) {
 errorOrWarn("R_PPC64_TLSGD/R_PPC64_TLSLD may not be the last "
 "relocation" +
-getLocation(sec, sym, offset));
+getLocation(*sec, sym, offset));
 return;
 }
 // Offset the 4-byte aligned R_PPC64_TLSGD by one byte in the NOTOC case,
 // so we can discern it later from the toc-case.
 if (i->getType(/*isMips64EL=*/false) == R_PPC64_REL24_NOTOC)
 ++offset;
 }
 }
-// Relax relocations.
-//
-// If we know that a PLT entry will be resolved within the same ELF module, we
-// can skip PLT access and directly jump to the destination function. For
-// example, if we are linking a main executable, all dynamic symbols that can
-// be resolved within the executable will actually be resolved that way at
-// runtime, because the main executable is always at the beginning of a search
-// list. We can leverage that fact.
-if (!sym.isPreemptible && (!sym.isGnuIFunc() || config->zIfuncNoplt)) {
-if (expr != R_GOT_PC) {
-// The 0x8000 bit of r_addend of R_PPC_PLTREL24 is used to choose call
-// stub type. It should be ignored if optimized to R_PC.
-if (config->emachine == EM_PPC && expr == R_PPC32_PLTREL)
-addend &= ~0x8000;
-// R_HEX_GD_PLT_B22_PCREL (call a@GDPLT) is transformed into
-// call __tls_get_addr even if the symbol is non-preemptible.
-if (!(config->emachine == EM_HEXAGON &&
-(type == R_HEX_GD_PLT_B22_PCREL ||
-type == R_HEX_GD_PLT_B22_PCREL_X ||
-type == R_HEX_GD_PLT_B32_PCREL_X)))
-expr = fromPlt(expr);
-} else if (!isAbsoluteValue(sym)) {
-expr = target->adjustGotPcExpr(type, addend, relocatedAddr);
-}
-}
 // If the relocation does not emit a GOT or GOTPLT entry but its computation
 // uses their addresses, we need GOT or GOTPLT to be created.
 //
-// The 4 types that relative GOTPLT are all x86 and x86-64 specific.
+// The 5 types that relative GOTPLT are all x86 and x86-64 specific.
-if (oneof<R_GOTPLTONLY_PC, R_GOTPLTREL, R_GOTPLT, R_TLSGD_GOTPLT>(expr)) {
+if (oneof<R_GOTPLTONLY_PC, R_GOTPLTREL, R_GOTPLT, R_PLT_GOTPLT,
-in.gotPlt->hasGotPltOffRel = true;
+R_TLSDESC_GOTPLT, R_TLSGD_GOTPLT>(expr)) {
-} else if (oneof<R_GOTONLY_PC, R_GOTREL, R_PPC64_TOCBASE, R_PPC64_RELAX_TOC>(
+in.gotPlt->hasGotPltOffRel.store(true, std::memory_order_relaxed);
-expr)) {
+} else if (oneof<R_GOTONLY_PC, R_GOTREL, R_PPC32_PLTREL, R_PPC64_TOCBASE,
-in.got->hasGotOffRel = true;
+R_PPC64_RELAX_TOC>(expr)) {
+in.got->hasGotOffRel.store(true, std::memory_order_relaxed);
 }
 // Process TLS relocations, including relaxing TLS relocations. Note that
-// R_TPREL and R_TPREL_NEG relocations are resolved in processRelocAux.
+// R_TPREL and R_TPREL_NEG relocations are resolved in processAux.
-if (expr == R_TPREL || expr == R_TPREL_NEG) {
+if (sym.isTls()) {
-if (config->shared) {
+if (unsigned processed =
-errorOrWarn("relocation " + toString(type) + " against " + toString(sym) +
+handleTlsRelocation(type, sym, *sec, offset, addend, expr)) {
-" cannot be used with -shared" +
+i += processed - 1;
-getLocation(sec, sym, offset));
 return;
 }
-} else if (unsigned processed = handleTlsRelocation<ELFT>(
+}
-type, sym, sec, offset, addend, expr)) {
-i += (processed - 1);
+processAux(expr, type, offset, sym, addend);
-return;
-}
-// We were asked not to generate PLT entries for ifuncs. Instead, pass the
-// direct relocation on through.
-if (sym.isGnuIFunc() && config->zIfuncNoplt) {
-sym.exportDynamic = true;
-mainPart->relaDyn->addSymbolReloc(type, &sec, offset, sym, addend, type);
-return;
-}
-// Non-preemptible ifuncs require special handling. First, handle the usual
-// case where the symbol isn't one of these.
-if (!sym.isGnuIFunc() || sym.isPreemptible) {
-// If a relocation needs PLT, we create PLT and GOTPLT slots for the symbol.
-if (needsPlt(expr) && !sym.isInPlt())
-addPltEntry(in.plt, in.gotPlt, in.relaPlt, target->pltRel, sym);
-// Create a GOT slot if a relocation needs GOT.
-if (needsGot(expr)) {
-if (config->emachine == EM_MIPS) {
-// MIPS ABI has special rules to process GOT entries and doesn't
-// require relocation entries for them. A special case is TLS
-// relocations. In that case dynamic loader applies dynamic
-// relocations to initialize TLS GOT entries.
-// See "Global Offset Table" in Chapter 5 in the following document
-// for detailed description:
-// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-in.mipsGot->addEntry(*sec.file, sym, addend, expr);
-} else if (!sym.isInGot()) {
-addGotEntry(sym);
-}
-}
-} else {
-// Handle a reference to a non-preemptible ifunc. These are special in a
-// few ways:
-//
-// - Unlike most non-preemptible symbols, non-preemptible ifuncs do not have
-//   a fixed value. But assuming that all references to the ifunc are
-//   GOT-generating or PLT-generating, the handling of an ifunc is
-//   relatively straightforward. We create a PLT entry in Iplt, which is
-//   usually at the end of .plt, which makes an indirect call using a
-//   matching GOT entry in igotPlt, which is usually at the end of .got.plt.
-//   The GOT entry is relocated using an IRELATIVE relocation in relaIplt,
-//   which is usually at the end of .rela.plt. Unlike most relocations in
-//   .rela.plt, which may be evaluated lazily without -z now, dynamic
-//   loaders evaluate IRELATIVE relocs eagerly, which means that for
-//   IRELATIVE relocs only, GOT-generating relocations can point directly to
-//   .got.plt without requiring a separate GOT entry.
-//
-// - Despite the fact that an ifunc does not have a fixed value, compilers
-//   that are not passed -fPIC will assume that they do, and will emit
-//   direct (non-GOT-generating, non-PLT-generating) relocations to the
-//   symbol. This means that if a direct relocation to the symbol is
-//   seen, the linker must set a value for the symbol, and this value must
-//   be consistent no matter what type of reference is made to the symbol.
-//   This can be done by creating a PLT entry for the symbol in the way
-//   described above and making it canonical, that is, making all references
-//   point to the PLT entry instead of the resolver. In lld we also store
-//   the address of the PLT entry in the dynamic symbol table, which means
-//   that the symbol will also have the same value in other modules.
-//   Because the value loaded from the GOT needs to be consistent with
-//   the value computed using a direct relocation, a non-preemptible ifunc
-//   may end up with two GOT entries, one in .got.plt that points to the
-//   address returned by the resolver and is used only by the PLT entry,
-//   and another in .got that points to the PLT entry and is used by
-//   GOT-generating relocations.
-//
-// - The fact that these symbols do not have a fixed value makes them an
-//   exception to the general rule that a statically linked executable does
-//   not require any form of dynamic relocation. To handle these relocations
-//   correctly, the IRELATIVE relocations are stored in an array which a
-//   statically linked executable's startup code must enumerate using the
-//   linker-defined symbols __rela?_iplt_{start,end}.
-if (!sym.isInPlt()) {
-// Create PLT and GOTPLT slots for the symbol.
-sym.isInIplt = true;
-// Create a copy of the symbol to use as the target of the IRELATIVE
-// relocation in the igotPlt. This is in case we make the PLT canonical
-// later, which would overwrite the original symbol.
-//
-// FIXME: Creating a copy of the symbol here is a bit of a hack. All
-// that's really needed to create the IRELATIVE is the section and value,
-// so ideally we should just need to copy those.
-auto *directSym = make<Defined>(cast<Defined>(sym));
-addPltEntry(in.iplt, in.igotPlt, in.relaIplt, target->iRelativeRel,
-*directSym);
-sym.pltIndex = directSym->pltIndex;
-}
-if (needsGot(expr)) {
-// Redirect GOT accesses to point to the Igot.
-//
-// This field is also used to keep track of whether we ever needed a GOT
-// entry. If we did and we make the PLT canonical later, we'll need to
-// create a GOT entry pointing to the PLT entry for Sym.
-sym.gotInIgot = true;
-} else if (!needsPlt(expr)) {
-// Make the ifunc's PLT entry canonical by changing the value of its
-// symbol to redirect all references to point to it.
-auto &d = cast<Defined>(sym);
-d.section = in.iplt;
-d.value = sym.pltIndex * target->ipltEntrySize;
-d.size = 0;
-// It's important to set the symbol type here so that dynamic loaders
-// don't try to call the PLT as if it were an ifunc resolver.
-d.type = STT_FUNC;
-if (sym.gotInIgot) {
-// We previously encountered a GOT generating reference that we
-// redirected to the Igot. Now that the PLT entry is canonical we must
-// clear the redirection to the Igot and add a GOT entry. As we've
-// changed the symbol type to STT_FUNC future GOT generating references
-// will naturally use this GOT entry.
-//
-// We don't need to worry about creating a MIPS GOT here because ifuncs
-// aren't a thing on MIPS.
-sym.gotInIgot = false;
-addGotEntry(sym);
-}
-}
-}
-processRelocAux<ELFT>(sec, expr, type, offset, sym, rel, addend);
 }
 // R_PPC64_TLSGD/R_PPC64_TLSLD is required to mark `bl __tls_get_addr` for
 // General Dynamic/Local Dynamic code sequences. If a GD/LD GOT relocation is
 // found but no R_PPC64_TLSGD/R_PPC64_TLSLD is seen, we assume that the
 "R_PPC64_TLSGD/R_PPC64_TLSLD relocations");
 }
 }
 template <class ELFT, class RelTy>
-static void scanRelocs(InputSectionBase &sec, ArrayRef<RelTy> rels) {
+void RelocationScanner::scan(ArrayRef<RelTy> rels) {
-OffsetGetter getOffset(sec);
+// Not all relocations end up in Sec->Relocations, but a lot do.
+sec->relocations.reserve(rels.size());
-// Not all relocations end up in Sec.Relocations, but a lot do.
-sec.relocations.reserve(rels.size());
 if (config->emachine == EM_PPC64)
-checkPPC64TLSRelax<RelTy>(sec, rels);
+checkPPC64TLSRelax<RelTy>(*sec, rels);
 // For EhInputSection, OffsetGetter expects the relocations to be sorted by
 // r_offset. In rare cases (.eh_frame pieces are reordered by a linker
 // script), the relocations may be unordered.
 SmallVector<RelTy, 0> storage;
 if (isa<EhInputSection>(sec))
 rels = sortRels(rels, storage);
-for (auto i = rels.begin(), end = rels.end(); i != end;)
+end = static_cast<const void *>(rels.end());
-scanReloc<ELFT>(sec, getOffset, i, rels.begin(), end);
+for (auto i = rels.begin(); i != end;)
+scanOne<ELFT>(i);
 // Sort relocations by offset for more efficient searching for
 // R_RISCV_PCREL_HI20 and R_PPC64_ADDR64.
 if (config->emachine == EM_RISCV ||
-(config->emachine == EM_PPC64 && sec.name == ".toc"))
+(config->emachine == EM_PPC64 && sec->name == ".toc"))
-llvm::stable_sort(sec.relocations,
+llvm::stable_sort(sec->relocations,
 [](const Relocation &lhs, const Relocation &rhs) {
 return lhs.offset < rhs.offset;
 });
 }
-template <class ELFT> void elf::scanRelocations(InputSectionBase &s) {
+template <class ELFT> void RelocationScanner::scanSection(InputSectionBase &s) {
-if (s.areRelocsRela)
+sec = &s;
-scanRelocs<ELFT>(s, s.relas<ELFT>());
+getter = OffsetGetter(s);
+const RelsOrRelas<ELFT> rels = s.template relsOrRelas<ELFT>();
+if (rels.areRelocsRel())
+scan<ELFT>(rels.rels);
 else
-scanRelocs<ELFT>(s, s.rels<ELFT>());
+scan<ELFT>(rels.relas);
+}
+template <class ELFT> void elf::scanRelocations() {
+// Scan all relocations. Each relocation goes through a series of tests to
+// determine if it needs special treatment, such as creating GOT, PLT,
+// copy relocations, etc. Note that relocations for non-alloc sections are
+// directly processed by InputSection::relocateNonAlloc.
+// Deterministic parallellism needs sorting relocations which is unsuitable
+// for -z nocombreloc. MIPS and PPC64 use global states which are not suitable
+// for parallelism.
+bool serial = !config->zCombreloc || config->emachine == EM_MIPS ||
+config->emachine == EM_PPC64;
+parallel::TaskGroup tg;
+for (ELFFileBase *f : ctx.objectFiles) {
+auto fn = [f]() {
+RelocationScanner scanner;
+for (InputSectionBase *s : f->getSections()) {
+if (s && s->kind() == SectionBase::Regular && s->isLive() &&
+(s->flags & SHF_ALLOC) &&
+!(s->type == SHT_ARM_EXIDX && config->emachine == EM_ARM))
+scanner.template scanSection<ELFT>(*s);
+}
+};
+if (serial)
+fn();
+else
+tg.execute(fn);
+}
+// Both the main thread and thread pool index 0 use getThreadIndex()==0. Be
+// careful that they don't concurrently run scanSections. When serial is
+// true, fn() has finished at this point, so running execute is safe.
+tg.execute([] {
+RelocationScanner scanner;
+for (Partition &part : partitions) {
+for (EhInputSection *sec : part.ehFrame->sections)
+scanner.template scanSection<ELFT>(*sec);
+if (part.armExidx && part.armExidx->isLive())
+for (InputSection *sec : part.armExidx->exidxSections)
+scanner.template scanSection<ELFT>(*sec);
+}
+});
+}
+static bool handleNonPreemptibleIfunc(Symbol &sym, uint16_t flags) {
+// Handle a reference to a non-preemptible ifunc. These are special in a
+// few ways:
+//
+// - Unlike most non-preemptible symbols, non-preemptible ifuncs do not have
+//   a fixed value. But assuming that all references to the ifunc are
+//   GOT-generating or PLT-generating, the handling of an ifunc is
+//   relatively straightforward. We create a PLT entry in Iplt, which is
+//   usually at the end of .plt, which makes an indirect call using a
+//   matching GOT entry in igotPlt, which is usually at the end of .got.plt.
+//   The GOT entry is relocated using an IRELATIVE relocation in relaIplt,
+//   which is usually at the end of .rela.plt. Unlike most relocations in
+//   .rela.plt, which may be evaluated lazily without -z now, dynamic
+//   loaders evaluate IRELATIVE relocs eagerly, which means that for
+//   IRELATIVE relocs only, GOT-generating relocations can point directly to
+//   .got.plt without requiring a separate GOT entry.
+//
+// - Despite the fact that an ifunc does not have a fixed value, compilers
+//   that are not passed -fPIC will assume that they do, and will emit
+//   direct (non-GOT-generating, non-PLT-generating) relocations to the
+//   symbol. This means that if a direct relocation to the symbol is
+//   seen, the linker must set a value for the symbol, and this value must
+//   be consistent no matter what type of reference is made to the symbol.
+//   This can be done by creating a PLT entry for the symbol in the way
+//   described above and making it canonical, that is, making all references
+//   point to the PLT entry instead of the resolver. In lld we also store
+//   the address of the PLT entry in the dynamic symbol table, which means
+//   that the symbol will also have the same value in other modules.
+//   Because the value loaded from the GOT needs to be consistent with
+//   the value computed using a direct relocation, a non-preemptible ifunc
+//   may end up with two GOT entries, one in .got.plt that points to the
+//   address returned by the resolver and is used only by the PLT entry,
+//   and another in .got that points to the PLT entry and is used by
+//   GOT-generating relocations.
+//
+// - The fact that these symbols do not have a fixed value makes them an
+//   exception to the general rule that a statically linked executable does
+//   not require any form of dynamic relocation. To handle these relocations
+//   correctly, the IRELATIVE relocations are stored in an array which a
+//   statically linked executable's startup code must enumerate using the
+//   linker-defined symbols __rela?_iplt_{start,end}.
+if (!sym.isGnuIFunc() || sym.isPreemptible || config->zIfuncNoplt)
+return false;
+// Skip unreferenced non-preemptible ifunc.
+if (!(flags & (NEEDS_GOT | NEEDS_PLT | HAS_DIRECT_RELOC)))
+return true;
+sym.isInIplt = true;
+// Create an Iplt and the associated IRELATIVE relocation pointing to the
+// original section/value pairs. For non-GOT non-PLT relocation case below, we
+// may alter section/value, so create a copy of the symbol to make
+// section/value fixed.
+auto *directSym = makeDefined(cast<Defined>(sym));
+directSym->allocateAux();
+addPltEntry(*in.iplt, *in.igotPlt, *in.relaIplt, target->iRelativeRel,
+*directSym);
+sym.allocateAux();
+symAux.back().pltIdx = symAux[directSym->auxIdx].pltIdx;
+if (flags & HAS_DIRECT_RELOC) {
+// Change the value to the IPLT and redirect all references to it.
+auto &d = cast<Defined>(sym);
+d.section = in.iplt.get();
+d.value = d.getPltIdx() * target->ipltEntrySize;
+d.size = 0;
+// It's important to set the symbol type here so that dynamic loaders
+// don't try to call the PLT as if it were an ifunc resolver.
+d.type = STT_FUNC;
+if (flags & NEEDS_GOT)
+addGotEntry(sym);
+} else if (flags & NEEDS_GOT) {
+// Redirect GOT accesses to point to the Igot.
+sym.gotInIgot = true;
+}
+return true;
+}
+void elf::postScanRelocations() {
+auto fn = [](Symbol &sym) {
+auto flags = sym.flags.load(std::memory_order_relaxed);
+if (handleNonPreemptibleIfunc(sym, flags))
+return;
+if (!sym.needsDynReloc())
+return;
+sym.allocateAux();
+if (flags & NEEDS_GOT)
+addGotEntry(sym);
+if (flags & NEEDS_PLT)
+addPltEntry(*in.plt, *in.gotPlt, *in.relaPlt, target->pltRel, sym);
+if (flags & NEEDS_COPY) {
+if (sym.isObject()) {
+invokeELFT(addCopyRelSymbol, cast<SharedSymbol>(sym));
+// NEEDS_COPY is cleared for sym and its aliases so that in
+// later iterations aliases won't cause redundant copies.
+assert(!sym.hasFlag(NEEDS_COPY));
+} else {
+assert(sym.isFunc() && sym.hasFlag(NEEDS_PLT));
+if (!sym.isDefined()) {
+replaceWithDefined(sym, *in.plt,
+target->pltHeaderSize +
+target->pltEntrySize * sym.getPltIdx(),
+0);
+sym.setFlags(NEEDS_COPY);
+if (config->emachine == EM_PPC) {
+// PPC32 canonical PLT entries are at the beginning of .glink
+cast<Defined>(sym).value = in.plt->headerSize;
+in.plt->headerSize += 16;
+cast<PPC32GlinkSection>(*in.plt).canonical_plts.push_back(&sym);
+}
+}
+}
+}
+if (!sym.isTls())
+return;
+bool isLocalInExecutable = !sym.isPreemptible && !config->shared;
+if (flags & NEEDS_TLSDESC) {
+in.got->addTlsDescEntry(sym);
+mainPart->relaDyn->addAddendOnlyRelocIfNonPreemptible(
+target->tlsDescRel, *in.got, in.got->getTlsDescOffset(sym), sym,
+target->tlsDescRel);
+}
+if (flags & NEEDS_TLSGD) {
+in.got->addDynTlsEntry(sym);
+uint64_t off = in.got->getGlobalDynOffset(sym);
+if (isLocalInExecutable)
+// Write one to the GOT slot.
+in.got->relocations.push_back(
+{R_ADDEND, target->symbolicRel, off, 1, &sym});
+else
+mainPart->relaDyn->addSymbolReloc(target->tlsModuleIndexRel, *in.got,
+off, sym);
+// If the symbol is preemptible we need the dynamic linker to write
+// the offset too.
+uint64_t offsetOff = off + config->wordsize;
+if (sym.isPreemptible)
+mainPart->relaDyn->addSymbolReloc(target->tlsOffsetRel, *in.got,
+offsetOff, sym);
+else
+in.got->relocations.push_back(
+{R_ABS, target->tlsOffsetRel, offsetOff, 0, &sym});
+}
+if (flags & NEEDS_TLSGD_TO_IE) {
+in.got->addEntry(sym);
+mainPart->relaDyn->addSymbolReloc(target->tlsGotRel, *in.got,
+sym.getGotOffset(), sym);
+}
+if (flags & NEEDS_GOT_DTPREL) {
+in.got->addEntry(sym);
+in.got->relocations.push_back(
+{R_ABS, target->tlsOffsetRel, sym.getGotOffset(), 0, &sym});
+}
+if ((flags & NEEDS_TLSIE) && !(flags & NEEDS_TLSGD_TO_IE))
+addTpOffsetGotEntry(sym);
+};
+if (ctx.needsTlsLd.load(std::memory_order_relaxed) && in.got->addTlsIndex()) {
+static Undefined dummy(nullptr, "", STB_LOCAL, 0, 0);
+if (config->shared)
+mainPart->relaDyn->addReloc(
+{target->tlsModuleIndexRel, in.got.get(), in.got->getTlsIndexOff()});
+else
+in.got->relocations.push_back(
+{R_ADDEND, target->symbolicRel, in.got->getTlsIndexOff(), 1, &dummy});
+}
+assert(symAux.size() == 1);
+for (Symbol *sym : symtab.getSymbols())
+fn(*sym);
+// Local symbols may need the aforementioned non-preemptible ifunc and GOT
+// handling. They don't need regular PLT.
+for (ELFFileBase *file : ctx.objectFiles)
+for (Symbol *sym : file->getLocalSymbols())
+fn(*sym);
 }
 static bool mergeCmp(const InputSection *a, const InputSection *b) {
 // std::merge requires a strict weak ordering.
 if (a->outSecOff < b->outSecOff)
 return true;
-if (a->outSecOff == b->outSecOff) {
+// FIXME dyn_cast<ThunkSection> is non-null for any SyntheticSection.
+if (a->outSecOff == b->outSecOff && a != b) {
 auto *ta = dyn_cast<ThunkSection>(a);
 auto *tb = dyn_cast<ThunkSection>(b);
 // Check if Thunk is immediately before any specific Target
 // InputSection for example Mips LA25 Thunks.
 ArrayRef<OutputSection *> outputSections,
 llvm::function_ref<void(OutputSection *, InputSectionDescription *)> fn) {
 for (OutputSection *os : outputSections) {
 if (!(os->flags & SHF_ALLOC) || !(os->flags & SHF_EXECINSTR))
 continue;
-for (BaseCommand *bc : os->sectionCommands)
+for (SectionCommand *bc : os->commands)
 if (auto *isd = dyn_cast<InputSectionDescription>(bc))
 fn(os, isd);
 }
 }
 [](const ThunkSection *a, const ThunkSection *b) {
 return a->outSecOff < b->outSecOff;
 });
 // Merge sorted vectors of Thunks and InputSections by outSecOff
-std::vector<InputSection *> tmp;
+SmallVector<InputSection *, 0> tmp;
 tmp.reserve(isd->sections.size() + newThunks.size());
 std::merge(isd->sections.begin(), isd->sections.end(),
 newThunks.begin(), newThunks.end(), std::back_inserter(tmp),
 mergeCmp);
 isd->sections = std::move(tmp);
 });
+}
+static int64_t getPCBias(RelType type) {
+if (config->emachine != EM_ARM)
+return 0;
+switch (type) {
+case R_ARM_THM_JUMP19:
+case R_ARM_THM_JUMP24:
+case R_ARM_THM_CALL:
+return 4;
+default:
+return 8;
+}
 }
 // Find or create a ThunkSection within the InputSectionDescription (ISD) that
 // is in range of Src. An ISD maps to a range of InputSections described by a
 // linker script section pattern such as { .text .text.* }.
 ThunkSection *ThunkCreator::getISDThunkSec(OutputSection *os,
 InputSection *isec,
 InputSectionDescription *isd,
 const Relocation &rel,
 uint64_t src) {
+// See the comment in getThunk for -pcBias below.
+const int64_t pcBias = getPCBias(rel.type);
 for (std::pair<ThunkSection *, uint32_t> tp : isd->thunkSections) {
 ThunkSection *ts = tp.first;
-uint64_t tsBase = os->addr + ts->outSecOff + rel.addend;
+uint64_t tsBase = os->addr + ts->outSecOff - pcBias;
-uint64_t tsLimit = tsBase + ts->getSize() + rel.addend;
+uint64_t tsLimit = tsBase + ts->getSize();
 if (target->inBranchRange(rel.type, src,
 (src > tsLimit) ? tsBase : tsLimit))
 return ts;
 }
 return ts;
 // Find InputSectionRange within Target Output Section (TOS) that the
 // InputSection (IS) that we need to precede is in.
 OutputSection *tos = isec->getParent();
-for (BaseCommand *bc : tos->sectionCommands) {
+for (SectionCommand *bc : tos->commands) {
 auto *isd = dyn_cast<InputSectionDescription>(bc);
 if (!isd || isd->sections.empty())
 continue;
 InputSection *first = isd->sections.front();
 if (source->partition != target->partition)
 return target->partition == 1;
 return true;
 }
-static int64_t getPCBias(RelType type) {
-if (config->emachine != EM_ARM)
-return 0;
-switch (type) {
-case R_ARM_THM_JUMP19:
-case R_ARM_THM_JUMP24:
-case R_ARM_THM_CALL:
-return 4;
-default:
-return 8;
-}
-}
 std::pair<Thunk *, bool> ThunkCreator::getThunk(InputSection *isec,
 Relocation &rel, uint64_t src) {
 std::vector<Thunk *> *thunkVec = nullptr;
 // Arm and Thumb have a PC Bias of 8 and 4 respectively, this is cancelled
 // out in the relocation addend. We compensate for the PC bias so that
 // an Arm and Thumb relocation to the same destination get the same keyAddend,
 // which is usually 0.
-int64_t keyAddend = rel.addend + getPCBias(rel.type);
+const int64_t pcBias = getPCBias(rel.type);
+const int64_t keyAddend = rel.addend + pcBias;
 // We use a ((section, offset), addend) pair to find the thunk position if
 // possible so that we create only one thunk for aliased symbols or ICFed
 // sections. There may be multiple relocations sharing the same (section,
 // offset + addend) pair. We may revert the relocation back to its original
 // non-Thunk target, so we cannot fold offset + addend.
 if (auto *d = dyn_cast<Defined>(rel.sym))
 if (!d->isInPlt() && d->section)
-thunkVec = &thunkedSymbolsBySectionAndAddend[{
+thunkVec = &thunkedSymbolsBySectionAndAddend[{{d->section, d->value},
-{d->section->repl, d->value}, keyAddend}];
+keyAddend}];
 if (!thunkVec)
 thunkVec = &thunkedSymbols[{rel.sym, keyAddend}];
 // Check existing Thunks for Sym to see if they can be reused
 for (Thunk *t : *thunkVec)
 if (isThunkSectionCompatible(isec, t->getThunkTargetSym()->section) &&
 t->isCompatibleWith(*isec, rel) &&
 target->inBranchRange(rel.type, src,
-t->getThunkTargetSym()->getVA(rel.addend)))
+t->getThunkTargetSym()->getVA(-pcBias)))
 return std::make_pair(t, false);
 // No existing compatible Thunk in range, create a new one
 Thunk *t = addThunk(*isec, rel);
 thunkVec->push_back(t);
 //
 // If return value is false then no more Thunks are needed, and createThunks has
 // made no changes. If the target requires range extension thunks, currently
 // ARM, then any future change in offset between caller and callee risks a
 // relocation out of range error.
-bool ThunkCreator::createThunks(ArrayRef<OutputSection *> outputSections) {
+bool ThunkCreator::createThunks(uint32_t pass,
+ArrayRef<OutputSection *> outputSections) {
+this->pass = pass;
 bool addressesChanged = false;
 if (pass == 0 && target->getThunkSectionSpacing())
 createInitialThunkSections(outputSections);
 for (auto &p : thunkedSections)
 addressesChanged |= p.second->assignOffsets();
 // Merge all created synthetic ThunkSections back into OutputSection
 mergeThunks(outputSections);
-++pass;
 return addressesChanged;
 }
 // The following aid in the conversion of call x@GDPLT to call __tls_get_addr
 // hexagonNeedsTLSSymbol scans for relocations would require a call to
 });
 return needTlsSymbol;
 }
 void elf::hexagonTLSSymbolUpdate(ArrayRef<OutputSection *> outputSections) {
-Symbol *sym = symtab->find("__tls_get_addr");
+Symbol *sym = symtab.find("__tls_get_addr");
 if (!sym)
 return;
 bool needEntry = true;
 forEachInputSectionDescription(
 outputSections, [&](OutputSection *os, InputSectionDescription *isd) {
 for (InputSection *isec : isd->sections)
 for (Relocation &rel : isec->relocations)
 if (rel.sym->type == llvm::ELF::STT_TLS && rel.expr == R_PLT_PC) {
 if (needEntry) {
-addPltEntry(in.plt, in.gotPlt, in.relaPlt, target->pltRel,
+sym->allocateAux();
+addPltEntry(*in.plt, *in.gotPlt, *in.relaPlt, target->pltRel,
 *sym);
 needEntry = false;
 }
 rel.sym = sym;
 }
 });
 }
-template void elf::scanRelocations<ELF32LE>(InputSectionBase &);
+template void elf::scanRelocations<ELF32LE>();
-template void elf::scanRelocations<ELF32BE>(InputSectionBase &);
+template void elf::scanRelocations<ELF32BE>();
-template void elf::scanRelocations<ELF64LE>(InputSectionBase &);
+template void elf::scanRelocations<ELF64LE>();
-template void elf::scanRelocations<ELF64BE>(InputSectionBase &);
+template void elf::scanRelocations<ELF64BE>();
-template void elf::reportUndefinedSymbols<ELF32LE>();
-template void elf::reportUndefinedSymbols<ELF32BE>();
-template void elf::reportUndefinedSymbols<ELF64LE>();
-template void elf::reportUndefinedSymbols<ELF64BE>();

Mercurial > hg > CbC > CbC_llvm

comparison lld/ELF/Relocations.cpp @ 236:c4bab56944e8 llvm-original