2016-05-25 04:24:43 +08:00
|
|
|
//===- Relocations.cpp ----------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Linker
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2016-06-08 20:29:29 +08:00
|
|
|
// This file contains platform-independent functions to process relocations.
|
2016-05-25 04:24:43 +08:00
|
|
|
// I'll describe the overview of this file here.
|
|
|
|
//
|
|
|
|
// Simple relocations are easy to handle for the linker. For example,
|
|
|
|
// for R_X86_64_PC64 relocs, the linker just has to fix up locations
|
|
|
|
// with the relative offsets to the target symbols. It would just be
|
|
|
|
// reading records from relocation sections and applying them to output.
|
|
|
|
//
|
|
|
|
// But not all relocations are that easy to handle. For example, for
|
|
|
|
// R_386_GOTOFF relocs, the linker has to create new GOT entries for
|
|
|
|
// symbols if they don't exist, and fix up locations with GOT entry
|
|
|
|
// offsets from the beginning of GOT section. So there is more than
|
|
|
|
// fixing addresses in relocation processing.
|
|
|
|
//
|
|
|
|
// ELF defines a large number of complex relocations.
|
|
|
|
//
|
|
|
|
// The functions in this file analyze relocations and do whatever needs
|
|
|
|
// to be done. It includes, but not limited to, the following.
|
|
|
|
//
|
|
|
|
// - create GOT/PLT entries
|
|
|
|
// - create new relocations in .dynsym to let the dynamic linker resolve
|
|
|
|
// them at runtime (since ELF supports dynamic linking, not all
|
|
|
|
// relocations can be resolved at link-time)
|
|
|
|
// - create COPY relocs and reserve space in .bss
|
|
|
|
// - replace expensive relocs (in terms of runtime cost) with cheap ones
|
|
|
|
// - error out infeasible combinations such as PIC and non-relative relocs
|
|
|
|
//
|
|
|
|
// Note that the functions in this file don't actually apply relocations
|
|
|
|
// because it doesn't know about the output file nor the output file buffer.
|
|
|
|
// It instead stores Relocation objects to InputSection's Relocations
|
|
|
|
// vector to let it apply later in InputSection::writeTo.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "Relocations.h"
|
|
|
|
#include "Config.h"
|
|
|
|
#include "OutputSections.h"
|
|
|
|
#include "SymbolTable.h"
|
|
|
|
#include "Target.h"
|
2016-07-09 00:10:27 +08:00
|
|
|
#include "Thunks.h"
|
2016-10-06 17:45:04 +08:00
|
|
|
#include "Strings.h"
|
2016-05-25 04:24:43 +08:00
|
|
|
|
|
|
|
#include "llvm/Support/Endian.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::ELF;
|
|
|
|
using namespace llvm::object;
|
|
|
|
using namespace llvm::support::endian;
|
|
|
|
|
|
|
|
namespace lld {
|
|
|
|
namespace elf {
|
|
|
|
|
|
|
|
static bool refersToGotEntry(RelExpr Expr) {
|
2016-06-20 05:39:37 +08:00
|
|
|
return Expr == R_GOT || Expr == R_GOT_OFF || Expr == R_MIPS_GOT_LOCAL_PAGE ||
|
2016-10-21 15:22:30 +08:00
|
|
|
Expr == R_MIPS_GOT_OFF || Expr == R_MIPS_GOT_OFF32 ||
|
|
|
|
Expr == R_MIPS_TLSGD || Expr == R_MIPS_TLSLD ||
|
|
|
|
Expr == R_GOT_PAGE_PC || Expr == R_GOT_PC || Expr == R_GOT_FROM_END ||
|
|
|
|
Expr == R_TLSGD || Expr == R_TLSGD_PC || Expr == R_TLSDESC ||
|
|
|
|
Expr == R_TLSDESC_PAGE;
|
2016-05-25 04:24:43 +08:00
|
|
|
}
|
|
|
|
|
2016-05-28 12:49:57 +08:00
|
|
|
static bool isPreemptible(const SymbolBody &Body, uint32_t Type) {
|
|
|
|
// In case of MIPS GP-relative relocations always resolve to a definition
|
|
|
|
// in a regular input file, ignoring the one-definition rule. So we,
|
|
|
|
// for example, should not attempt to create a dynamic relocation even
|
|
|
|
// if the target symbol is preemptible. There are two two MIPS GP-relative
|
|
|
|
// relocations R_MIPS_GPREL16 and R_MIPS_GPREL32. But only R_MIPS_GPREL16
|
|
|
|
// can be against a preemptible symbol.
|
2016-06-10 20:26:09 +08:00
|
|
|
// To get MIPS relocation type we apply 0xff mask. In case of O32 ABI all
|
2016-05-28 12:49:57 +08:00
|
|
|
// relocation types occupy eight bit. In case of N64 ABI we extract first
|
|
|
|
// relocation from 3-in-1 packet because only the first relocation can
|
|
|
|
// be against a real symbol.
|
2016-06-10 20:26:09 +08:00
|
|
|
if (Config->EMachine == EM_MIPS && (Type & 0xff) == R_MIPS_GPREL16)
|
2016-05-28 12:49:57 +08:00
|
|
|
return false;
|
|
|
|
return Body.isPreemptible();
|
|
|
|
}
|
|
|
|
|
2016-09-23 21:54:48 +08:00
|
|
|
// This function is similar to the `handleTlsRelocation`. ARM and MIPS do not
|
|
|
|
// support any relaxations for TLS relocations so by factoring out ARM and MIPS
|
|
|
|
// handling in to the separate function we can simplify the code and do not
|
|
|
|
// pollute `handleTlsRelocation` by ARM and MIPS `ifs` statements.
|
|
|
|
// FIXME: The ARM implementation always adds the module index dynamic
|
|
|
|
// relocation even for non-preemptible symbols in applications. For static
|
|
|
|
// linking support we must either resolve the module index relocation at static
|
|
|
|
// link time, or hard code the module index (1) for the application in the GOT.
|
2016-06-23 23:26:31 +08:00
|
|
|
template <class ELFT>
|
2016-09-23 21:54:48 +08:00
|
|
|
static unsigned handleNoRelaxTlsRelocation(uint32_t Type, SymbolBody &Body,
|
|
|
|
InputSectionBase<ELFT> &C,
|
|
|
|
typename ELFT::uint Offset,
|
|
|
|
typename ELFT::uint Addend,
|
|
|
|
RelExpr Expr) {
|
|
|
|
if (Expr == R_MIPS_TLSLD || Expr == R_TLSLD_PC) {
|
|
|
|
if (Out<ELFT>::Got->addTlsIndex() &&
|
|
|
|
(Config->Pic || Config->EMachine == EM_ARM))
|
2016-06-23 23:26:31 +08:00
|
|
|
Out<ELFT>::RelaDyn->addReloc({Target->TlsModuleIndexRel, Out<ELFT>::Got,
|
|
|
|
Out<ELFT>::Got->getTlsIndexOff(), false,
|
|
|
|
nullptr, 0});
|
2016-09-08 04:37:34 +08:00
|
|
|
C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
|
2016-06-23 23:26:31 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2016-09-23 21:54:48 +08:00
|
|
|
typedef typename ELFT::uint uintX_t;
|
2016-06-23 23:26:31 +08:00
|
|
|
if (Target->isTlsGlobalDynamicRel(Type)) {
|
2016-09-23 21:54:48 +08:00
|
|
|
if (Out<ELFT>::Got->addDynTlsEntry(Body) &&
|
|
|
|
(Body.isPreemptible() || Config->EMachine == EM_ARM)) {
|
2016-06-23 23:26:31 +08:00
|
|
|
uintX_t Off = Out<ELFT>::Got->getGlobalDynOffset(Body);
|
|
|
|
Out<ELFT>::RelaDyn->addReloc(
|
|
|
|
{Target->TlsModuleIndexRel, Out<ELFT>::Got, Off, false, &Body, 0});
|
2016-09-23 21:54:48 +08:00
|
|
|
if (Body.isPreemptible())
|
|
|
|
Out<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, Out<ELFT>::Got,
|
|
|
|
Off + (uintX_t)sizeof(uintX_t), false,
|
|
|
|
&Body, 0});
|
2016-06-23 23:26:31 +08:00
|
|
|
}
|
2016-09-08 04:37:34 +08:00
|
|
|
C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
|
2016-06-23 23:26:31 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-05-25 04:24:43 +08:00
|
|
|
// Returns the number of relocations processed.
|
|
|
|
template <class ELFT>
|
|
|
|
static unsigned handleTlsRelocation(uint32_t Type, SymbolBody &Body,
|
|
|
|
InputSectionBase<ELFT> &C,
|
|
|
|
typename ELFT::uint Offset,
|
|
|
|
typename ELFT::uint Addend, RelExpr Expr) {
|
2016-10-26 20:36:56 +08:00
|
|
|
if (!(C.Flags & SHF_ALLOC))
|
2016-05-25 04:24:43 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!Body.isTls())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
typedef typename ELFT::uint uintX_t;
|
2016-06-03 03:49:53 +08:00
|
|
|
|
2016-09-23 21:54:48 +08:00
|
|
|
if (Config->EMachine == EM_MIPS || Config->EMachine == EM_ARM)
|
|
|
|
return handleNoRelaxTlsRelocation<ELFT>(Type, Body, C, Offset, Addend,
|
|
|
|
Expr);
|
2016-06-23 23:26:31 +08:00
|
|
|
|
2016-10-20 17:59:26 +08:00
|
|
|
if ((Expr == R_TLSDESC || Expr == R_TLSDESC_PAGE || Expr == R_TLSDESC_CALL) &&
|
2016-06-03 03:49:53 +08:00
|
|
|
Config->Shared) {
|
|
|
|
if (Out<ELFT>::Got->addDynTlsEntry(Body)) {
|
|
|
|
uintX_t Off = Out<ELFT>::Got->getGlobalDynOffset(Body);
|
|
|
|
Out<ELFT>::RelaDyn->addReloc(
|
|
|
|
{Target->TlsDescRel, Out<ELFT>::Got, Off, false, &Body, 0});
|
|
|
|
}
|
2016-10-20 17:59:26 +08:00
|
|
|
if (Expr != R_TLSDESC_CALL)
|
2016-09-08 04:37:34 +08:00
|
|
|
C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
|
2016-06-03 03:49:53 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-05-25 04:24:43 +08:00
|
|
|
if (Expr == R_TLSLD_PC || Expr == R_TLSLD) {
|
|
|
|
// Local-Dynamic relocs can be relaxed to Local-Exec.
|
|
|
|
if (!Config->Shared) {
|
|
|
|
C.Relocations.push_back(
|
2016-09-08 04:37:34 +08:00
|
|
|
{R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Body});
|
2016-05-25 04:24:43 +08:00
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
if (Out<ELFT>::Got->addTlsIndex())
|
|
|
|
Out<ELFT>::RelaDyn->addReloc({Target->TlsModuleIndexRel, Out<ELFT>::Got,
|
|
|
|
Out<ELFT>::Got->getTlsIndexOff(), false,
|
|
|
|
nullptr, 0});
|
2016-09-08 04:37:34 +08:00
|
|
|
C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
|
2016-05-25 04:24:43 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Local-Dynamic relocs can be relaxed to Local-Exec.
|
|
|
|
if (Target->isTlsLocalDynamicRel(Type) && !Config->Shared) {
|
|
|
|
C.Relocations.push_back(
|
2016-09-08 04:37:34 +08:00
|
|
|
{R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Body});
|
2016-05-25 04:24:43 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-10-20 17:59:26 +08:00
|
|
|
if (Expr == R_TLSDESC_PAGE || Expr == R_TLSDESC || Expr == R_TLSDESC_CALL ||
|
2016-06-03 03:49:53 +08:00
|
|
|
Target->isTlsGlobalDynamicRel(Type)) {
|
2016-05-25 04:24:43 +08:00
|
|
|
if (Config->Shared) {
|
|
|
|
if (Out<ELFT>::Got->addDynTlsEntry(Body)) {
|
|
|
|
uintX_t Off = Out<ELFT>::Got->getGlobalDynOffset(Body);
|
|
|
|
Out<ELFT>::RelaDyn->addReloc(
|
|
|
|
{Target->TlsModuleIndexRel, Out<ELFT>::Got, Off, false, &Body, 0});
|
2016-06-09 05:31:59 +08:00
|
|
|
|
|
|
|
// If the symbol is preemptible we need the dynamic linker to write
|
|
|
|
// the offset too.
|
2016-06-10 20:26:39 +08:00
|
|
|
if (isPreemptible(Body, Type))
|
2016-06-09 05:31:59 +08:00
|
|
|
Out<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, Out<ELFT>::Got,
|
|
|
|
Off + (uintX_t)sizeof(uintX_t), false,
|
|
|
|
&Body, 0});
|
2016-05-25 04:24:43 +08:00
|
|
|
}
|
2016-09-08 04:37:34 +08:00
|
|
|
C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
|
2016-05-25 04:24:43 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec
|
|
|
|
// depending on the symbol being locally defined or not.
|
2016-05-28 12:49:57 +08:00
|
|
|
if (isPreemptible(Body, Type)) {
|
2016-05-25 04:24:43 +08:00
|
|
|
C.Relocations.push_back(
|
2016-06-05 07:22:34 +08:00
|
|
|
{Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_IE), Type,
|
2016-09-08 04:37:34 +08:00
|
|
|
Offset, Addend, &Body});
|
2016-05-25 04:24:43 +08:00
|
|
|
if (!Body.isInGot()) {
|
|
|
|
Out<ELFT>::Got->addEntry(Body);
|
|
|
|
Out<ELFT>::RelaDyn->addReloc({Target->TlsGotRel, Out<ELFT>::Got,
|
|
|
|
Body.getGotOffset<ELFT>(), false, &Body,
|
|
|
|
0});
|
|
|
|
}
|
2016-06-05 07:33:31 +08:00
|
|
|
return Target->TlsGdRelaxSkip;
|
2016-05-25 04:24:43 +08:00
|
|
|
}
|
|
|
|
C.Relocations.push_back(
|
2016-09-08 04:37:34 +08:00
|
|
|
{Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_LE), Type,
|
2016-06-05 07:22:34 +08:00
|
|
|
Offset, Addend, &Body});
|
2016-06-05 07:04:39 +08:00
|
|
|
return Target->TlsGdRelaxSkip;
|
2016-05-25 04:24:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally
|
|
|
|
// defined.
|
|
|
|
if (Target->isTlsInitialExecRel(Type) && !Config->Shared &&
|
2016-05-28 12:49:57 +08:00
|
|
|
!isPreemptible(Body, Type)) {
|
2016-05-25 04:24:43 +08:00
|
|
|
C.Relocations.push_back(
|
2016-09-08 04:37:34 +08:00
|
|
|
{R_RELAX_TLS_IE_TO_LE, Type, Offset, Addend, &Body});
|
2016-05-25 04:24:43 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <endianness E> static int16_t readSignedLo16(const uint8_t *Loc) {
|
|
|
|
return read32<E>(Loc) & 0xffff;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class RelTy>
|
|
|
|
static uint32_t getMipsPairType(const RelTy *Rel, const SymbolBody &Sym) {
|
|
|
|
switch (Rel->getType(Config->Mips64EL)) {
|
|
|
|
case R_MIPS_HI16:
|
|
|
|
return R_MIPS_LO16;
|
|
|
|
case R_MIPS_GOT16:
|
|
|
|
return Sym.isLocal() ? R_MIPS_LO16 : R_MIPS_NONE;
|
|
|
|
case R_MIPS_PCHI16:
|
|
|
|
return R_MIPS_PCLO16;
|
|
|
|
case R_MICROMIPS_HI16:
|
|
|
|
return R_MICROMIPS_LO16;
|
|
|
|
default:
|
|
|
|
return R_MIPS_NONE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT, class RelTy>
|
|
|
|
static int32_t findMipsPairedAddend(const uint8_t *Buf, const uint8_t *BufLoc,
|
|
|
|
SymbolBody &Sym, const RelTy *Rel,
|
|
|
|
const RelTy *End) {
|
|
|
|
uint32_t SymIndex = Rel->getSymbol(Config->Mips64EL);
|
|
|
|
uint32_t Type = getMipsPairType(Rel, Sym);
|
|
|
|
|
|
|
|
// Some MIPS relocations use addend calculated from addend of the relocation
|
|
|
|
// itself and addend of paired relocation. ABI requires to compute such
|
|
|
|
// combined addend in case of REL relocation record format only.
|
|
|
|
// See p. 4-17 at ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
|
|
|
|
if (RelTy::IsRela || Type == R_MIPS_NONE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (const RelTy *RI = Rel; RI != End; ++RI) {
|
|
|
|
if (RI->getType(Config->Mips64EL) != Type)
|
|
|
|
continue;
|
|
|
|
if (RI->getSymbol(Config->Mips64EL) != SymIndex)
|
|
|
|
continue;
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
return ((read32<E>(BufLoc) & 0xffff) << 16) +
|
|
|
|
readSignedLo16<E>(Buf + RI->r_offset);
|
|
|
|
}
|
2016-09-30 05:00:23 +08:00
|
|
|
warn("can't find matching " + getRelName(Type) + " relocation for " +
|
2016-10-20 16:36:42 +08:00
|
|
|
getRelName(Rel->getType(Config->Mips64EL)));
|
2016-05-25 04:24:43 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// True if non-preemptable symbol always has the same value regardless of where
|
|
|
|
// the DSO is loaded.
|
|
|
|
template <class ELFT> static bool isAbsolute(const SymbolBody &Body) {
|
|
|
|
if (Body.isUndefined())
|
|
|
|
return !Body.isLocal() && Body.symbol()->isWeak();
|
|
|
|
if (const auto *DR = dyn_cast<DefinedRegular<ELFT>>(&Body))
|
|
|
|
return DR->Section == nullptr; // Absolute symbol.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-10-28 01:28:56 +08:00
|
|
|
template <class ELFT> static bool isAbsoluteValue(const SymbolBody &Body) {
|
|
|
|
return isAbsolute<ELFT>(Body) || Body.isTls();
|
|
|
|
}
|
|
|
|
|
2016-05-25 04:24:43 +08:00
|
|
|
static bool needsPlt(RelExpr Expr) {
|
2016-06-05 03:11:14 +08:00
|
|
|
return Expr == R_PLT_PC || Expr == R_PPC_PLT_OPD || Expr == R_PLT ||
|
2016-07-09 00:10:27 +08:00
|
|
|
Expr == R_PLT_PAGE_PC || Expr == R_THUNK_PLT_PC;
|
2016-05-25 04:24:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// True if this expression is of the form Sym - X, where X is a position in the
|
|
|
|
// file (PC, or GOT for example).
|
|
|
|
static bool isRelExpr(RelExpr Expr) {
|
2016-09-06 21:57:15 +08:00
|
|
|
return Expr == R_PC || Expr == R_GOTREL || Expr == R_GOTREL_FROM_END ||
|
|
|
|
Expr == R_PAGE_PC || Expr == R_RELAX_GOT_PC || Expr == R_THUNK_PC ||
|
|
|
|
Expr == R_THUNK_PLT_PC;
|
2016-05-25 04:24:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
|
|
|
|
const SymbolBody &Body) {
|
|
|
|
// These expressions always compute a constant
|
|
|
|
if (E == R_SIZE || E == R_GOT_FROM_END || E == R_GOT_OFF ||
|
2016-10-21 15:22:30 +08:00
|
|
|
E == R_MIPS_GOT_LOCAL_PAGE || E == R_MIPS_GOT_OFF ||
|
|
|
|
E == R_MIPS_GOT_OFF32 || E == R_MIPS_TLSGD || E == R_GOT_PAGE_PC ||
|
|
|
|
E == R_GOT_PC || E == R_PLT_PC || E == R_TLSGD_PC || E == R_TLSGD ||
|
|
|
|
E == R_PPC_PLT_OPD || E == R_TLSDESC_CALL || E == R_TLSDESC_PAGE ||
|
|
|
|
E == R_HINT || E == R_THUNK_PC || E == R_THUNK_PLT_PC)
|
2016-05-25 04:24:43 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// These never do, except if the entire file is position dependent or if
|
|
|
|
// only the low bits are used.
|
2016-06-03 03:49:53 +08:00
|
|
|
if (E == R_GOT || E == R_PLT || E == R_TLSDESC)
|
2016-05-25 04:24:43 +08:00
|
|
|
return Target->usesOnlyLowPageBits(Type) || !Config->Pic;
|
|
|
|
|
2016-05-28 12:49:57 +08:00
|
|
|
if (isPreemptible(Body, Type))
|
2016-05-25 04:24:43 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!Config->Pic)
|
|
|
|
return true;
|
|
|
|
|
2016-10-28 01:28:56 +08:00
|
|
|
bool AbsVal = isAbsoluteValue<ELFT>(Body);
|
2016-05-25 04:24:43 +08:00
|
|
|
bool RelE = isRelExpr(E);
|
|
|
|
if (AbsVal && !RelE)
|
|
|
|
return true;
|
|
|
|
if (!AbsVal && RelE)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Relative relocation to an absolute value. This is normally unrepresentable,
|
|
|
|
// but if the relocation refers to a weak undefined symbol, we allow it to
|
|
|
|
// resolve to the image base. This is a little strange, but it allows us to
|
|
|
|
// link function calls to such symbols. Normally such a call will be guarded
|
|
|
|
// with a comparison, which will load a zero from the GOT.
|
|
|
|
if (AbsVal && RelE) {
|
|
|
|
if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak())
|
|
|
|
return true;
|
2016-06-08 20:22:26 +08:00
|
|
|
error("relocation " + getRelName(Type) +
|
|
|
|
" cannot refer to absolute symbol " + Body.getName());
|
2016-05-25 04:24:43 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Target->usesOnlyLowPageBits(Type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static RelExpr toPlt(RelExpr Expr) {
|
|
|
|
if (Expr == R_PPC_OPD)
|
|
|
|
return R_PPC_PLT_OPD;
|
|
|
|
if (Expr == R_PC)
|
|
|
|
return R_PLT_PC;
|
2016-06-05 03:11:14 +08:00
|
|
|
if (Expr == R_PAGE_PC)
|
|
|
|
return R_PLT_PAGE_PC;
|
2016-05-25 04:24:43 +08:00
|
|
|
if (Expr == R_ABS)
|
|
|
|
return R_PLT;
|
|
|
|
return Expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static RelExpr fromPlt(RelExpr Expr) {
|
|
|
|
// We decided not to use a plt. Optimize a reference to the plt to a
|
|
|
|
// reference to the symbol itself.
|
|
|
|
if (Expr == R_PLT_PC)
|
|
|
|
return R_PC;
|
|
|
|
if (Expr == R_PPC_PLT_OPD)
|
|
|
|
return R_PPC_OPD;
|
|
|
|
if (Expr == R_PLT)
|
|
|
|
return R_ABS;
|
|
|
|
return Expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> static uint32_t getAlignment(SharedSymbol<ELFT> *SS) {
|
|
|
|
typedef typename ELFT::uint uintX_t;
|
|
|
|
|
2016-07-17 11:11:46 +08:00
|
|
|
uintX_t SecAlign = SS->file()->getSection(SS->Sym)->sh_addralign;
|
2016-05-25 04:24:43 +08:00
|
|
|
uintX_t SymValue = SS->Sym.st_value;
|
|
|
|
int TrailingZeros =
|
|
|
|
std::min(countTrailingZeros(SecAlign), countTrailingZeros(SymValue));
|
|
|
|
return 1 << TrailingZeros;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reserve space in .bss for copy relocation.
|
|
|
|
template <class ELFT> static void addCopyRelSymbol(SharedSymbol<ELFT> *SS) {
|
|
|
|
typedef typename ELFT::uint uintX_t;
|
|
|
|
typedef typename ELFT::Sym Elf_Sym;
|
|
|
|
|
|
|
|
// Copy relocation against zero-sized symbol doesn't make sense.
|
|
|
|
uintX_t SymSize = SS->template getSize<ELFT>();
|
|
|
|
if (SymSize == 0)
|
2016-08-19 05:55:23 +08:00
|
|
|
fatal("cannot create a copy relocation for symbol " + SS->getName());
|
2016-05-25 04:24:43 +08:00
|
|
|
|
2016-06-17 09:18:46 +08:00
|
|
|
uintX_t Alignment = getAlignment(SS);
|
|
|
|
uintX_t Off = alignTo(Out<ELFT>::Bss->getSize(), Alignment);
|
2016-05-25 04:24:43 +08:00
|
|
|
Out<ELFT>::Bss->setSize(Off + SymSize);
|
2016-06-17 09:18:46 +08:00
|
|
|
Out<ELFT>::Bss->updateAlignment(Alignment);
|
2016-05-25 04:24:43 +08:00
|
|
|
uintX_t Shndx = SS->Sym.st_shndx;
|
|
|
|
uintX_t Value = SS->Sym.st_value;
|
|
|
|
// 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.
|
2016-11-04 04:48:57 +08:00
|
|
|
for (const Elf_Sym &S : SS->file()->getGlobalSymbols()) {
|
2016-05-25 04:24:43 +08:00
|
|
|
if (S.st_shndx != Shndx || S.st_value != Value)
|
|
|
|
continue;
|
|
|
|
auto *Alias = dyn_cast_or_null<SharedSymbol<ELFT>>(
|
2016-07-17 11:11:46 +08:00
|
|
|
Symtab<ELFT>::X->find(check(S.getName(SS->file()->getStringTable()))));
|
2016-05-25 04:24:43 +08:00
|
|
|
if (!Alias)
|
|
|
|
continue;
|
|
|
|
Alias->OffsetInBss = Off;
|
|
|
|
Alias->NeedsCopyOrPltAddr = true;
|
|
|
|
Alias->symbol()->IsUsedInRegularObj = true;
|
|
|
|
}
|
|
|
|
Out<ELFT>::RelaDyn->addReloc(
|
|
|
|
{Target->CopyRel, Out<ELFT>::Bss, SS->OffsetInBss, false, SS, 0});
|
|
|
|
}
|
|
|
|
|
2016-08-19 05:55:23 +08:00
|
|
|
template <class ELFT>
|
2016-08-23 03:01:53 +08:00
|
|
|
static StringRef getSymbolName(const elf::ObjectFile<ELFT> &File,
|
|
|
|
SymbolBody &Body) {
|
|
|
|
if (Body.isLocal() && Body.getNameOffset())
|
|
|
|
return File.getStringTable().data() + Body.getNameOffset();
|
|
|
|
if (!Body.isLocal())
|
|
|
|
return Body.getName();
|
|
|
|
return "";
|
2016-08-19 05:55:23 +08:00
|
|
|
}
|
|
|
|
|
2016-05-25 04:24:43 +08:00
|
|
|
template <class ELFT>
|
|
|
|
static RelExpr adjustExpr(const elf::ObjectFile<ELFT> &File, SymbolBody &Body,
|
2016-05-25 22:31:37 +08:00
|
|
|
bool IsWrite, RelExpr Expr, uint32_t Type,
|
2016-06-17 23:01:50 +08:00
|
|
|
const uint8_t *Data) {
|
2016-05-28 12:49:57 +08:00
|
|
|
bool Preemptible = isPreemptible(Body, Type);
|
2016-05-25 22:31:37 +08:00
|
|
|
if (Body.isGnuIFunc()) {
|
2016-05-25 04:24:43 +08:00
|
|
|
Expr = toPlt(Expr);
|
2016-05-25 22:31:37 +08:00
|
|
|
} else if (!Preemptible) {
|
|
|
|
if (needsPlt(Expr))
|
|
|
|
Expr = fromPlt(Expr);
|
2016-10-28 01:28:56 +08:00
|
|
|
if (Expr == R_GOT_PC && !isAbsoluteValue<ELFT>(Body))
|
2016-06-17 23:01:50 +08:00
|
|
|
Expr = Target->adjustRelaxExpr(Type, Data, Expr);
|
2016-05-25 22:31:37 +08:00
|
|
|
}
|
2016-07-09 00:10:27 +08:00
|
|
|
Expr = Target->getThunkExpr(Expr, Type, File, Body);
|
2016-05-25 04:24:43 +08:00
|
|
|
|
|
|
|
if (IsWrite || isStaticLinkTimeConstant<ELFT>(Expr, Type, Body))
|
|
|
|
return Expr;
|
|
|
|
|
|
|
|
// This relocation would require the dynamic linker to write a value to read
|
|
|
|
// only memory. We can hack around it if we are producing an executable and
|
|
|
|
// the refered symbol can be preemepted to refer to the executable.
|
|
|
|
if (Config->Shared || (Config->Pic && !isRelExpr(Expr))) {
|
2016-08-23 03:01:53 +08:00
|
|
|
StringRef Name = getSymbolName(File, Body);
|
2016-10-20 16:36:42 +08:00
|
|
|
error("can't create dynamic relocation " + getRelName(Type) + " against " +
|
|
|
|
(Name.empty() ? "readonly segment" : "symbol " + Name));
|
2016-05-25 04:24:43 +08:00
|
|
|
return Expr;
|
|
|
|
}
|
|
|
|
if (Body.getVisibility() != STV_DEFAULT) {
|
2016-08-19 05:55:23 +08:00
|
|
|
error("cannot preempt symbol " + Body.getName());
|
2016-05-25 04:24:43 +08:00
|
|
|
return Expr;
|
|
|
|
}
|
|
|
|
if (Body.isObject()) {
|
|
|
|
// Produce a copy relocation.
|
|
|
|
auto *B = cast<SharedSymbol<ELFT>>(&Body);
|
|
|
|
if (!B->needsCopy())
|
|
|
|
addCopyRelSymbol(B);
|
|
|
|
return Expr;
|
|
|
|
}
|
|
|
|
if (Body.isFunc()) {
|
|
|
|
// 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
|
|
|
|
// overflow at runtime. In the real world with glibc, crt1.o has a
|
|
|
|
// R_X86_64_PC32 pointing to libc.so.
|
|
|
|
//
|
|
|
|
// The general idea on how to handle such cases is to create a PLT entry and
|
|
|
|
// use that as the function value.
|
|
|
|
//
|
|
|
|
// For the static linking part, we just return a plt expr and everything
|
|
|
|
// else will use the the PLT entry as the address.
|
|
|
|
//
|
|
|
|
// The remaining problem is making sure pointer equality still works. We
|
|
|
|
// need the help of the dynamic linker for that. We let it know that we have
|
|
|
|
// a direct reference to a so symbol by creating an undefined symbol with a
|
|
|
|
// non zero st_value. Seeing that, the dynamic linker resolves the symbol to
|
|
|
|
// the value of the symbol we created. This is true even for got entries, so
|
|
|
|
// pointer equality is maintained. To avoid an infinite loop, the only entry
|
|
|
|
// that points to the real function is a dedicated got entry used by the
|
|
|
|
// plt. That is identified by special relocation types (R_X86_64_JUMP_SLOT,
|
|
|
|
// R_386_JMP_SLOT, etc).
|
|
|
|
Body.NeedsCopyOrPltAddr = true;
|
|
|
|
return toPlt(Expr);
|
|
|
|
}
|
2016-08-19 05:55:23 +08:00
|
|
|
error("symbol " + Body.getName() + " is missing type");
|
2016-05-25 04:24:43 +08:00
|
|
|
|
|
|
|
return Expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT, class RelTy>
|
|
|
|
static typename ELFT::uint computeAddend(const elf::ObjectFile<ELFT> &File,
|
|
|
|
const uint8_t *SectionData,
|
|
|
|
const RelTy *End, const RelTy &RI,
|
|
|
|
RelExpr Expr, SymbolBody &Body) {
|
|
|
|
typedef typename ELFT::uint uintX_t;
|
|
|
|
|
|
|
|
uint32_t Type = RI.getType(Config->Mips64EL);
|
|
|
|
uintX_t Addend = getAddend<ELFT>(RI);
|
|
|
|
const uint8_t *BufLoc = SectionData + RI.r_offset;
|
|
|
|
if (!RelTy::IsRela)
|
|
|
|
Addend += Target->getImplicitAddend(BufLoc, Type);
|
|
|
|
if (Config->EMachine == EM_MIPS) {
|
|
|
|
Addend += findMipsPairedAddend<ELFT>(SectionData, BufLoc, Body, &RI, End);
|
|
|
|
if (Type == R_MIPS_LO16 && Expr == R_PC)
|
|
|
|
// R_MIPS_LO16 expression has R_PC type iif the target is _gp_disp
|
|
|
|
// symbol. In that case we should use the following formula for
|
|
|
|
// calculation "AHL + GP - P + 4". Let's add 4 right here.
|
|
|
|
// For details see p. 4-19 at
|
|
|
|
// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
|
|
|
|
Addend += 4;
|
|
|
|
if (Expr == R_GOTREL) {
|
|
|
|
Addend -= MipsGPOffset;
|
|
|
|
if (Body.isLocal())
|
|
|
|
Addend += File.getMipsGp0();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (Config->Pic && Config->EMachine == EM_PPC64 && Type == R_PPC64_TOC)
|
|
|
|
Addend += getPPC64TocBase();
|
|
|
|
return Addend;
|
|
|
|
}
|
|
|
|
|
2016-10-26 19:07:09 +08:00
|
|
|
// Find symbol that encloses given offset. Used for error reporting.
|
|
|
|
template <class ELFT>
|
|
|
|
static DefinedRegular<ELFT> *getSymbolAt(InputSectionBase<ELFT> *S,
|
|
|
|
typename ELFT::uint Offset) {
|
|
|
|
for (SymbolBody *B : S->getFile()->getSymbols())
|
|
|
|
if (auto *D = dyn_cast<DefinedRegular<ELFT>>(B))
|
|
|
|
if (D->Value <= Offset && D->Value + D->Size > Offset && D->Section == S)
|
|
|
|
return D;
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
2016-11-09 04:30:19 +08:00
|
|
|
std::string getLocation(InputSectionBase<ELFT> &S, typename ELFT::uint Offset) {
|
2016-10-26 19:07:09 +08:00
|
|
|
ObjectFile<ELFT> *File = S.getFile();
|
|
|
|
|
|
|
|
// First check if we can get desired values from debugging information.
|
2016-11-03 02:42:13 +08:00
|
|
|
std::string LineInfo = File->getLineInfo(&S, Offset);
|
2016-10-26 19:07:09 +08:00
|
|
|
if (!LineInfo.empty())
|
|
|
|
return LineInfo;
|
|
|
|
|
2016-11-09 04:30:19 +08:00
|
|
|
// File->SourceFile contains STT_FILE symbol contents which is a
|
|
|
|
// filename. Compilers usually create STT_FILE symbols. If it's
|
|
|
|
// missing, we use an actual filename.
|
2016-10-26 19:07:09 +08:00
|
|
|
std::string SrcFile = File->SourceFile;
|
|
|
|
if (SrcFile.empty())
|
2016-11-09 04:30:19 +08:00
|
|
|
SrcFile = getFilename(File);
|
2016-10-26 19:07:09 +08:00
|
|
|
|
2016-10-27 04:26:29 +08:00
|
|
|
// Find a symbol at a given location.
|
2016-10-27 04:27:38 +08:00
|
|
|
DefinedRegular<ELFT> *Encl = getSymbolAt(&S, Offset);
|
|
|
|
if (Encl && Encl->Type == STT_FUNC) {
|
|
|
|
StringRef Func = getSymbolName(*File, *Encl);
|
2016-10-27 02:28:06 +08:00
|
|
|
return SrcFile + " (function " + maybeDemangle(Func) + ")";
|
2016-10-26 19:07:09 +08:00
|
|
|
}
|
|
|
|
|
2016-10-27 04:26:29 +08:00
|
|
|
// If there's no symbol, print out the offset instead of a symbol name.
|
2016-10-26 19:07:09 +08:00
|
|
|
return (SrcFile + " (" + S.Name + "+0x" + Twine::utohexstr(Offset) + ")")
|
|
|
|
.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
static void reportUndefined(SymbolBody &Sym, InputSectionBase<ELFT> &S,
|
|
|
|
typename ELFT::uint Offset) {
|
2016-10-06 17:45:04 +08:00
|
|
|
if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (Config->Shared && Sym.symbol()->Visibility == STV_DEFAULT &&
|
|
|
|
Config->UnresolvedSymbols != UnresolvedPolicy::NoUndef)
|
|
|
|
return;
|
|
|
|
|
2016-11-09 04:30:19 +08:00
|
|
|
std::string Msg = getLocation(S, Offset) + ": undefined symbol '" +
|
2016-10-27 02:28:06 +08:00
|
|
|
maybeDemangle(Sym.getName()) + "'";
|
2016-10-06 17:45:04 +08:00
|
|
|
|
|
|
|
if (Config->UnresolvedSymbols == UnresolvedPolicy::Warn)
|
|
|
|
warn(Msg);
|
|
|
|
else
|
|
|
|
error(Msg);
|
|
|
|
}
|
|
|
|
|
2016-11-06 06:58:01 +08:00
|
|
|
template <class RelTy>
|
|
|
|
static std::pair<uint32_t, uint32_t>
|
|
|
|
mergeMipsN32RelTypes(uint32_t Type, uint32_t Offset, RelTy *I, RelTy *E) {
|
|
|
|
// 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.
|
|
|
|
uint32_t Processed = 0;
|
|
|
|
for (; I != E && Offset == I->r_offset; ++I) {
|
|
|
|
++Processed;
|
|
|
|
Type |= I->getType(Config->Mips64EL) << (8 * Processed);
|
|
|
|
}
|
|
|
|
return std::make_pair(Type, Processed);
|
|
|
|
}
|
|
|
|
|
2016-05-25 04:24:43 +08:00
|
|
|
// 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.
|
|
|
|
// It might be possible to avoid this by outputting the file with write:
|
|
|
|
// * Write the allocated output sections, computing addresses.
|
|
|
|
// * Apply relocations, recording which ones require a dynamic reloc.
|
|
|
|
// * Write the dynamic relocations.
|
|
|
|
// * Write the rest of the file.
|
|
|
|
// 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>
|
2016-05-25 11:40:02 +08:00
|
|
|
static void scanRelocs(InputSectionBase<ELFT> &C, ArrayRef<RelTy> Rels) {
|
2016-05-25 04:24:43 +08:00
|
|
|
typedef typename ELFT::uint uintX_t;
|
|
|
|
|
2016-10-26 20:36:56 +08:00
|
|
|
bool IsWrite = C.Flags & SHF_WRITE;
|
2016-05-25 04:24:43 +08:00
|
|
|
|
|
|
|
auto AddDyn = [=](const DynamicReloc<ELFT> &Reloc) {
|
|
|
|
Out<ELFT>::RelaDyn->addReloc(Reloc);
|
|
|
|
};
|
|
|
|
|
|
|
|
const elf::ObjectFile<ELFT> &File = *C.getFile();
|
2016-09-12 21:13:53 +08:00
|
|
|
ArrayRef<uint8_t> SectionData = C.Data;
|
2016-05-25 04:24:43 +08:00
|
|
|
const uint8_t *Buf = SectionData.begin();
|
2016-07-20 19:47:50 +08:00
|
|
|
|
2016-07-22 05:15:32 +08:00
|
|
|
ArrayRef<EhSectionPiece> Pieces;
|
|
|
|
if (auto *Eh = dyn_cast<EhInputSection<ELFT>>(&C))
|
|
|
|
Pieces = Eh->Pieces;
|
|
|
|
|
|
|
|
ArrayRef<EhSectionPiece>::iterator PieceI = Pieces.begin();
|
|
|
|
ArrayRef<EhSectionPiece>::iterator PieceE = Pieces.end();
|
2016-07-20 19:47:50 +08:00
|
|
|
|
2016-05-25 04:24:43 +08:00
|
|
|
for (auto I = Rels.begin(), E = Rels.end(); I != E; ++I) {
|
|
|
|
const RelTy &RI = *I;
|
|
|
|
SymbolBody &Body = File.getRelocTargetSym(RI);
|
|
|
|
uint32_t Type = RI.getType(Config->Mips64EL);
|
|
|
|
|
2016-11-06 06:58:01 +08:00
|
|
|
if (Config->MipsN32Abi) {
|
|
|
|
uint32_t Processed;
|
|
|
|
std::tie(Type, Processed) =
|
|
|
|
mergeMipsN32RelTypes(Type, RI.r_offset, I + 1, E);
|
|
|
|
I += Processed;
|
|
|
|
}
|
|
|
|
|
2016-10-20 16:36:42 +08:00
|
|
|
// We only report undefined symbols if they are referenced somewhere in the
|
|
|
|
// code.
|
2016-10-06 17:45:04 +08:00
|
|
|
if (!Body.isLocal() && Body.isUndefined() && !Body.symbol()->isWeak())
|
2016-10-26 19:07:09 +08:00
|
|
|
reportUndefined(Body, C, RI.r_offset);
|
2016-10-06 17:45:04 +08:00
|
|
|
|
2016-05-25 04:24:43 +08:00
|
|
|
RelExpr Expr = Target->getRelExpr(Type, Body);
|
2016-05-28 12:49:57 +08:00
|
|
|
bool Preemptible = isPreemptible(Body, Type);
|
2016-06-17 23:42:36 +08:00
|
|
|
Expr = adjustExpr(File, Body, IsWrite, Expr, Type, Buf + RI.r_offset);
|
2016-05-25 04:24:43 +08:00
|
|
|
if (HasError)
|
|
|
|
continue;
|
|
|
|
|
2016-06-23 12:33:42 +08:00
|
|
|
// Skip a relocation that points to a dead piece
|
2016-07-20 19:47:50 +08:00
|
|
|
// in a eh_frame section.
|
|
|
|
while (PieceI != PieceE &&
|
|
|
|
(PieceI->InputOff + PieceI->size() <= RI.r_offset))
|
|
|
|
++PieceI;
|
2016-07-21 01:58:07 +08:00
|
|
|
|
|
|
|
// Compute the offset of this section in the output section. We do it here
|
|
|
|
// to try to compute it only once.
|
|
|
|
uintX_t Offset;
|
|
|
|
if (PieceI != PieceE) {
|
|
|
|
assert(PieceI->InputOff <= RI.r_offset && "Relocation not in any piece");
|
2016-10-20 18:55:58 +08:00
|
|
|
if (PieceI->OutputOff == -1)
|
2016-07-21 01:58:07 +08:00
|
|
|
continue;
|
|
|
|
Offset = PieceI->OutputOff + RI.r_offset - PieceI->InputOff;
|
|
|
|
} else {
|
2016-08-19 23:46:28 +08:00
|
|
|
Offset = RI.r_offset;
|
2016-07-21 01:58:07 +08:00
|
|
|
}
|
2016-06-17 23:42:36 +08:00
|
|
|
|
2016-05-25 04:24:43 +08:00
|
|
|
// This relocation does not require got entry, but it is relative to got and
|
|
|
|
// needs it to be created. Here we request for that.
|
2016-09-01 07:24:11 +08:00
|
|
|
if (Expr == R_GOTONLY_PC || Expr == R_GOTONLY_PC_FROM_END ||
|
|
|
|
Expr == R_GOTREL || Expr == R_GOTREL_FROM_END || Expr == R_PPC_TOC)
|
2016-05-25 04:24:43 +08:00
|
|
|
Out<ELFT>::Got->HasGotOffRel = true;
|
|
|
|
|
|
|
|
uintX_t Addend = computeAddend(File, Buf, E, RI, Expr, Body);
|
|
|
|
|
2016-07-21 01:58:07 +08:00
|
|
|
if (unsigned Processed =
|
|
|
|
handleTlsRelocation<ELFT>(Type, Body, C, Offset, Addend, Expr)) {
|
2016-05-25 04:24:43 +08:00
|
|
|
I += (Processed - 1);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2016-10-20 17:59:26 +08:00
|
|
|
// Ignore "hint" and TLS Descriptor call relocation because they are
|
|
|
|
// only markers for relaxation.
|
|
|
|
if (Expr == R_HINT || Expr == R_TLSDESC_CALL)
|
2016-06-03 03:49:53 +08:00
|
|
|
continue;
|
|
|
|
|
2016-07-09 00:10:27 +08:00
|
|
|
if (needsPlt(Expr) || Expr == R_THUNK_ABS || Expr == R_THUNK_PC ||
|
|
|
|
Expr == R_THUNK_PLT_PC || refersToGotEntry(Expr) ||
|
2016-05-28 12:49:57 +08:00
|
|
|
!isPreemptible(Body, Type)) {
|
2016-05-25 04:24:43 +08:00
|
|
|
// If the relocation points to something in the file, we can process it.
|
|
|
|
bool Constant = isStaticLinkTimeConstant<ELFT>(Expr, Type, Body);
|
|
|
|
|
|
|
|
// If the output being produced is position independent, the final value
|
|
|
|
// is still not known. In that case we still need some help from the
|
|
|
|
// dynamic linker. We can however do better than just copying the incoming
|
|
|
|
// relocation. We can process some of it and and just ask the dynamic
|
|
|
|
// linker to add the load address.
|
|
|
|
if (!Constant)
|
2016-07-21 01:58:07 +08:00
|
|
|
AddDyn({Target->RelativeRel, &C, Offset, true, &Body, Addend});
|
2016-05-25 04:24:43 +08:00
|
|
|
|
|
|
|
// If the produced value is a constant, we just remember to write it
|
|
|
|
// when outputting this section. We also have to do it if the format
|
|
|
|
// uses Elf_Rel, since in that case the written value is the addend.
|
|
|
|
if (Constant || !RelTy::IsRela)
|
2016-09-08 04:37:34 +08:00
|
|
|
C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
|
2016-05-25 04:24:43 +08:00
|
|
|
} else {
|
|
|
|
// We don't know anything about the finaly symbol. Just ask the dynamic
|
|
|
|
// linker to handle the relocation for us.
|
2016-07-21 01:58:07 +08:00
|
|
|
AddDyn({Target->getDynRel(Type), &C, Offset, false, &Body, Addend});
|
2016-05-25 04:24:43 +08:00
|
|
|
// 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
|
|
|
|
// relocations against symbols which do not require GOT entries
|
|
|
|
// creation explicitly, i.e. do not have any GOT-relocations. So if
|
|
|
|
// a preemptible symbol has a dynamic relocation we anyway have
|
|
|
|
// to create a GOT entry for it.
|
|
|
|
// If a non-preemptible symbol has a dynamic relocation against it,
|
|
|
|
// dynamic linker takes it st_value, adds offset and writes down
|
|
|
|
// result of the dynamic relocation. In case of preemptible symbol
|
|
|
|
// 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
|
2016-06-20 05:39:37 +08:00
|
|
|
if (Config->EMachine == EM_MIPS)
|
|
|
|
Out<ELFT>::Got->addMipsEntry(Body, Addend, Expr);
|
2016-05-25 04:24:43 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// At this point we are done with the relocated position. Some relocations
|
|
|
|
// also require us to create a got or plt entry.
|
|
|
|
|
|
|
|
// If a relocation needs PLT, we create a PLT and a GOT slot for the symbol.
|
|
|
|
if (needsPlt(Expr)) {
|
|
|
|
if (Body.isInPlt())
|
|
|
|
continue;
|
|
|
|
Out<ELFT>::Plt->addEntry(Body);
|
|
|
|
|
|
|
|
uint32_t Rel;
|
|
|
|
if (Body.isGnuIFunc() && !Preemptible)
|
|
|
|
Rel = Target->IRelativeRel;
|
|
|
|
else
|
|
|
|
Rel = Target->PltRel;
|
|
|
|
|
|
|
|
Out<ELFT>::GotPlt->addEntry(Body);
|
|
|
|
Out<ELFT>::RelaPlt->addReloc({Rel, Out<ELFT>::GotPlt,
|
|
|
|
Body.getGotPltOffset<ELFT>(), !Preemptible,
|
|
|
|
&Body, 0});
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (refersToGotEntry(Expr)) {
|
2016-06-20 05:39:37 +08:00
|
|
|
if (Config->EMachine == EM_MIPS) {
|
2016-09-08 17:07:12 +08:00
|
|
|
// 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.
|
2016-05-25 04:24:43 +08:00
|
|
|
// 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
|
2016-06-20 05:39:37 +08:00
|
|
|
Out<ELFT>::Got->addMipsEntry(Body, Addend, Expr);
|
2016-09-08 17:07:19 +08:00
|
|
|
if (Body.isTls() && Body.isPreemptible())
|
2016-06-23 23:26:31 +08:00
|
|
|
AddDyn({Target->TlsGotRel, Out<ELFT>::Got, Body.getGotOffset<ELFT>(),
|
2016-09-08 17:07:19 +08:00
|
|
|
false, &Body, 0});
|
2016-06-20 05:39:37 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Body.isInGot())
|
2016-05-25 04:24:43 +08:00
|
|
|
continue;
|
|
|
|
|
2016-06-20 05:39:37 +08:00
|
|
|
Out<ELFT>::Got->addEntry(Body);
|
2016-05-25 04:24:43 +08:00
|
|
|
if (Preemptible || (Config->Pic && !isAbsolute<ELFT>(Body))) {
|
|
|
|
uint32_t DynType;
|
|
|
|
if (Body.isTls())
|
|
|
|
DynType = Target->TlsGotRel;
|
|
|
|
else if (Preemptible)
|
|
|
|
DynType = Target->GotRel;
|
|
|
|
else
|
|
|
|
DynType = Target->RelativeRel;
|
|
|
|
AddDyn({DynType, Out<ELFT>::Got, Body.getGotOffset<ELFT>(),
|
|
|
|
!Preemptible, &Body, 0});
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void scanRelocations(InputSectionBase<ELFT> &S,
|
|
|
|
const typename ELFT::Shdr &RelSec) {
|
2016-11-04 04:44:50 +08:00
|
|
|
ELFFile<ELFT> EObj = S.getFile()->getObj();
|
2016-05-25 04:24:43 +08:00
|
|
|
if (RelSec.sh_type == SHT_RELA)
|
2016-11-04 03:07:44 +08:00
|
|
|
scanRelocs(S, check(EObj.relas(&RelSec)));
|
2016-05-25 04:24:43 +08:00
|
|
|
else
|
2016-11-04 03:07:44 +08:00
|
|
|
scanRelocs(S, check(EObj.rels(&RelSec)));
|
2016-05-25 04:24:43 +08:00
|
|
|
}
|
|
|
|
|
2016-07-21 01:58:07 +08:00
|
|
|
template <class ELFT, class RelTy>
|
|
|
|
static void createThunks(InputSectionBase<ELFT> &C, ArrayRef<RelTy> Rels) {
|
|
|
|
const elf::ObjectFile<ELFT> &File = *C.getFile();
|
|
|
|
for (const RelTy &Rel : Rels) {
|
|
|
|
SymbolBody &Body = File.getRelocTargetSym(Rel);
|
|
|
|
uint32_t Type = Rel.getType(Config->Mips64EL);
|
|
|
|
RelExpr Expr = Target->getRelExpr(Type, Body);
|
|
|
|
if (!isPreemptible(Body, Type) && needsPlt(Expr))
|
|
|
|
Expr = fromPlt(Expr);
|
|
|
|
Expr = Target->getThunkExpr(Expr, Type, File, Body);
|
|
|
|
// Some targets might require creation of thunks for relocations.
|
|
|
|
// Now we support only MIPS which requires LA25 thunk to call PIC
|
|
|
|
// code from non-PIC one, and ARM which requires interworking.
|
|
|
|
if (Expr == R_THUNK_ABS || Expr == R_THUNK_PC || Expr == R_THUNK_PLT_PC) {
|
|
|
|
auto *Sec = cast<InputSection<ELFT>>(&C);
|
|
|
|
addThunk<ELFT>(Type, Body, *Sec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void createThunks(InputSectionBase<ELFT> &S,
|
|
|
|
const typename ELFT::Shdr &RelSec) {
|
2016-11-04 04:44:50 +08:00
|
|
|
ELFFile<ELFT> EObj = S.getFile()->getObj();
|
2016-07-21 01:58:07 +08:00
|
|
|
if (RelSec.sh_type == SHT_RELA)
|
2016-11-04 03:07:44 +08:00
|
|
|
createThunks(S, check(EObj.relas(&RelSec)));
|
2016-07-21 01:58:07 +08:00
|
|
|
else
|
2016-11-04 03:07:44 +08:00
|
|
|
createThunks(S, check(EObj.rels(&RelSec)));
|
2016-07-21 01:58:07 +08:00
|
|
|
}
|
2016-05-25 04:24:43 +08:00
|
|
|
|
|
|
|
template void scanRelocations<ELF32LE>(InputSectionBase<ELF32LE> &,
|
|
|
|
const ELF32LE::Shdr &);
|
|
|
|
template void scanRelocations<ELF32BE>(InputSectionBase<ELF32BE> &,
|
|
|
|
const ELF32BE::Shdr &);
|
|
|
|
template void scanRelocations<ELF64LE>(InputSectionBase<ELF64LE> &,
|
|
|
|
const ELF64LE::Shdr &);
|
|
|
|
template void scanRelocations<ELF64BE>(InputSectionBase<ELF64BE> &,
|
|
|
|
const ELF64BE::Shdr &);
|
2016-07-21 01:58:07 +08:00
|
|
|
|
|
|
|
template void createThunks<ELF32LE>(InputSectionBase<ELF32LE> &,
|
|
|
|
const ELF32LE::Shdr &);
|
|
|
|
template void createThunks<ELF32BE>(InputSectionBase<ELF32BE> &,
|
|
|
|
const ELF32BE::Shdr &);
|
|
|
|
template void createThunks<ELF64LE>(InputSectionBase<ELF64LE> &,
|
|
|
|
const ELF64LE::Shdr &);
|
|
|
|
template void createThunks<ELF64BE>(InputSectionBase<ELF64BE> &,
|
|
|
|
const ELF64BE::Shdr &);
|
2016-11-09 00:26:32 +08:00
|
|
|
|
2016-11-09 04:30:19 +08:00
|
|
|
template std::string getLocation<ELF32LE>(InputSectionBase<ELF32LE> &S,
|
2016-11-09 00:26:32 +08:00
|
|
|
uint32_t Offset);
|
2016-11-09 04:30:19 +08:00
|
|
|
template std::string getLocation<ELF32BE>(InputSectionBase<ELF32BE> &S,
|
2016-11-09 00:26:32 +08:00
|
|
|
uint32_t Offset);
|
2016-11-09 04:30:19 +08:00
|
|
|
template std::string getLocation<ELF64LE>(InputSectionBase<ELF64LE> &S,
|
2016-11-09 00:26:32 +08:00
|
|
|
uint64_t Offset);
|
2016-11-09 04:30:19 +08:00
|
|
|
template std::string getLocation<ELF64BE>(InputSectionBase<ELF64BE> &S,
|
2016-11-09 00:26:32 +08:00
|
|
|
uint64_t Offset);
|
2016-05-25 04:24:43 +08:00
|
|
|
}
|
|
|
|
}
|