rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/frameworks/compile/mclinker/lib/Target/AArch64/AArch64Relocator.cpp

733 lines
27 KiB
C++
Raw Blame History

//===- AArch64Relocator.cpp ----------------------------------------------===//
//
// The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "mcld/LinkerConfig.h"
#include "mcld/IRBuilder.h"
#include "mcld/Support/MsgHandling.h"
#include "mcld/LD/LDSymbol.h"
#include "mcld/LD/ELFFileFormat.h"
#include "mcld/Object/ObjectBuilder.h"
#include "AArch64Relocator.h"
#include "AArch64RelocationFunctions.h"
#include "AArch64RelocationHelpers.h"
#include <llvm/ADT/Twine.h>
#include <llvm/Support/DataTypes.h>
#include <llvm/Support/ELF.h>
#include <llvm/Support/Host.h>
namespace mcld {
//===----------------------------------------------------------------------===//
// Relocation Functions and Tables
//===----------------------------------------------------------------------===//
DECL_AARCH64_APPLY_RELOC_FUNCS
/// the prototype of applying function
typedef Relocator::Result (*ApplyFunctionType)(Relocation& pReloc,
AArch64Relocator& pParent);
// the table entry of applying functions
class ApplyFunctionEntry {
public:
ApplyFunctionEntry() {}
ApplyFunctionEntry(ApplyFunctionType pFunc,
const char* pName,
size_t pSize = 0)
: func(pFunc), name(pName), size(pSize) {}
ApplyFunctionType func;
const char* name;
size_t size;
};
typedef std::map<Relocator::Type, ApplyFunctionEntry> ApplyFunctionMap;
static const ApplyFunctionMap::value_type ApplyFunctionList[] = {
DECL_AARCH64_APPLY_RELOC_FUNC_PTRS(ApplyFunctionMap::value_type,
ApplyFunctionEntry)};
// declare the table of applying functions
static ApplyFunctionMap ApplyFunctions(ApplyFunctionList,
ApplyFunctionList +
sizeof(ApplyFunctionList) /
sizeof(ApplyFunctionList[0]));
//===----------------------------------------------------------------------===//
// AArch64Relocator
//===----------------------------------------------------------------------===//
AArch64Relocator::AArch64Relocator(AArch64GNULDBackend& pParent,
const LinkerConfig& pConfig)
: Relocator(pConfig), m_Target(pParent) {
}
AArch64Relocator::~AArch64Relocator() {
}
Relocator::Result AArch64Relocator::applyRelocation(Relocation& pRelocation) {
Relocation::Type type = pRelocation.type();
// valid types are 0x0, 0x100-1032, and R_AARCH64_REWRITE_INSN
if ((type < 0x100 || type > 1032) &&
(type != 0x0) &&
(type != R_AARCH64_REWRITE_INSN)) {
return Relocator::Unknown;
}
assert(ApplyFunctions.find(type) != ApplyFunctions.end());
return ApplyFunctions[type].func(pRelocation, *this);
}
const char* AArch64Relocator::getName(Relocator::Type pType) const {
assert(ApplyFunctions.find(pType) != ApplyFunctions.end());
return ApplyFunctions[pType].name;
}
Relocator::Size AArch64Relocator::getSize(Relocation::Type pType) const {
return ApplyFunctions[pType].size;
}
void AArch64Relocator::addCopyReloc(ResolveInfo& pSym) {
Relocation& rel_entry = *getTarget().getRelaDyn().create();
rel_entry.setType(llvm::ELF::R_AARCH64_COPY);
assert(pSym.outSymbol()->hasFragRef());
rel_entry.targetRef().assign(*pSym.outSymbol()->fragRef());
rel_entry.setSymInfo(&pSym);
}
/// defineSymbolForCopyReloc
/// For a symbol needing copy relocation, define a copy symbol in the BSS
/// section and all other reference to this symbol should refer to this
/// copy.
/// This is executed at scan relocation stage.
LDSymbol& AArch64Relocator::defineSymbolforCopyReloc(IRBuilder& pBuilder,
const ResolveInfo& pSym) {
// get or create corresponding BSS LDSection
LDSection* bss_sect_hdr = NULL;
ELFFileFormat* file_format = getTarget().getOutputFormat();
if (ResolveInfo::ThreadLocal == pSym.type())
bss_sect_hdr = &file_format->getTBSS();
else
bss_sect_hdr = &file_format->getBSS();
// get or create corresponding BSS SectionData
SectionData* bss_data = NULL;
if (bss_sect_hdr->hasSectionData())
bss_data = bss_sect_hdr->getSectionData();
else
bss_data = IRBuilder::CreateSectionData(*bss_sect_hdr);
// Determine the alignment by the symbol value
// FIXME: here we use the largest alignment
uint32_t addralign = config().targets().bitclass() / 8;
// allocate space in BSS for the copy symbol
Fragment* frag = new FillFragment(0x0, 1, pSym.size());
uint64_t size = ObjectBuilder::AppendFragment(*frag, *bss_data, addralign);
bss_sect_hdr->setSize(bss_sect_hdr->size() + size);
// change symbol binding to Global if it's a weak symbol
ResolveInfo::Binding binding = (ResolveInfo::Binding)pSym.binding();
if (binding == ResolveInfo::Weak)
binding = ResolveInfo::Global;
// Define the copy symbol in the bss section and resolve it
LDSymbol* cpy_sym = pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
pSym.name(),
(ResolveInfo::Type)pSym.type(),
ResolveInfo::Define,
binding,
pSym.size(), // size
0x0, // value
FragmentRef::Create(*frag, 0x0),
(ResolveInfo::Visibility)pSym.other());
return *cpy_sym;
}
void AArch64Relocator::scanLocalReloc(Relocation& pReloc,
const LDSection& pSection) {
// rsym - The relocation target symbol
ResolveInfo* rsym = pReloc.symInfo();
switch (pReloc.type()) {
case llvm::ELF::R_AARCH64_ABS64:
// If buiding PIC object (shared library or PIC executable),
// a dynamic relocations with RELATIVE type to this location is needed.
// Reserve an entry in .rel.dyn
if (config().isCodeIndep()) {
// set Rel bit
rsym->setReserved(rsym->reserved() | ReserveRel);
getTarget().checkAndSetHasTextRel(*pSection.getLink());
// set up the dyn rel directly
Relocation& reloc = helper_DynRela_init(rsym,
*pReloc.targetRef().frag(),
pReloc.targetRef().offset(),
llvm::ELF::R_AARCH64_RELATIVE,
*this);
getRelRelMap().record(pReloc, reloc);
}
return;
case llvm::ELF::R_AARCH64_ABS32:
case llvm::ELF::R_AARCH64_ABS16:
// If buiding PIC object (shared library or PIC executable),
// a dynamic relocations with RELATIVE type to this location is needed.
// Reserve an entry in .rel.dyn
if (config().isCodeIndep()) {
// set up the dyn rel directly
Relocation& reloc = helper_DynRela_init(rsym,
*pReloc.targetRef().frag(),
pReloc.targetRef().offset(),
pReloc.type(),
*this);
getRelRelMap().record(pReloc, reloc);
// set Rel bit
rsym->setReserved(rsym->reserved() | ReserveRel);
getTarget().checkAndSetHasTextRel(*pSection.getLink());
}
return;
case llvm::ELF::R_AARCH64_ADR_GOT_PAGE:
case llvm::ELF::R_AARCH64_LD64_GOT_LO12_NC: {
// Symbol needs GOT entry, reserve entry in .got
// return if we already create GOT for this symbol
if (rsym->reserved() & ReserveGOT)
return;
// If building PIC object, a dynamic relocation with
// type RELATIVE is needed to relocate this GOT entry.
if (config().isCodeIndep())
helper_GOT_init(pReloc, true, *this);
else
helper_GOT_init(pReloc, false, *this);
// set GOT bit
rsym->setReserved(rsym->reserved() | ReserveGOT);
return;
}
default:
break;
}
}
void AArch64Relocator::scanGlobalReloc(Relocation& pReloc,
IRBuilder& pBuilder,
const LDSection& pSection) {
// rsym - The relocation target symbol
ResolveInfo* rsym = pReloc.symInfo();
switch (pReloc.type()) {
case llvm::ELF::R_AARCH64_ABS64:
case llvm::ELF::R_AARCH64_ABS32:
case llvm::ELF::R_AARCH64_ABS16:
// Absolute relocation type, symbol may needs PLT entry or
// dynamic relocation entry
if (getTarget().symbolNeedsPLT(*rsym)) {
// create plt for this symbol if it does not have one
if (!(rsym->reserved() & ReservePLT)) {
// Symbol needs PLT entry, we need a PLT entry
// and the corresponding GOT and dynamic relocation entry
// in .got and .rel.plt.
helper_PLT_init(pReloc, *this);
// set PLT bit
rsym->setReserved(rsym->reserved() | ReservePLT);
}
}
if (getTarget()
.symbolNeedsDynRel(
*rsym, (rsym->reserved() & ReservePLT), true)) {
// symbol needs dynamic relocation entry, set up the dynrel entry
if (getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym);
addCopyReloc(*cpy_sym.resolveInfo());
} else {
// set Rel bit and the dyn rel
rsym->setReserved(rsym->reserved() | ReserveRel);
getTarget().checkAndSetHasTextRel(*pSection.getLink());
if (llvm::ELF::R_AARCH64_ABS64 == pReloc.type() &&
helper_use_relative_reloc(*rsym, *this)) {
Relocation& reloc =
helper_DynRela_init(rsym,
*pReloc.targetRef().frag(),
pReloc.targetRef().offset(),
llvm::ELF::R_AARCH64_RELATIVE,
*this);
getRelRelMap().record(pReloc, reloc);
} else {
Relocation& reloc = helper_DynRela_init(rsym,
*pReloc.targetRef().frag(),
pReloc.targetRef().offset(),
pReloc.type(),
*this);
getRelRelMap().record(pReloc, reloc);
}
}
}
return;
case llvm::ELF::R_AARCH64_PREL64:
case llvm::ELF::R_AARCH64_PREL32:
case llvm::ELF::R_AARCH64_PREL16:
if (getTarget().symbolNeedsPLT(*rsym) &&
LinkerConfig::DynObj != config().codeGenType()) {
// create plt for this symbol if it does not have one
if (!(rsym->reserved() & ReservePLT)) {
// Symbol needs PLT entry, we need a PLT entry
// and the corresponding GOT and dynamic relocation entry
// in .got and .rel.plt.
helper_PLT_init(pReloc, *this);
// set PLT bit
rsym->setReserved(rsym->reserved() | ReservePLT);
}
}
// Only PC relative relocation against dynamic symbol needs a
// dynamic relocation. Only dynamic copy relocation is allowed
// and PC relative relocation will be resolved to the local copy.
// All other dynamic relocations may lead to run-time relocation
// overflow.
if (getTarget().isDynamicSymbol(*rsym) &&
getTarget()
.symbolNeedsDynRel(
*rsym, (rsym->reserved() & ReservePLT), false) &&
getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym);
addCopyReloc(*cpy_sym.resolveInfo());
}
return;
case llvm::ELF::R_AARCH64_CONDBR19:
case llvm::ELF::R_AARCH64_JUMP26:
case llvm::ELF::R_AARCH64_CALL26: {
// return if we already create plt for this symbol
if (rsym->reserved() & ReservePLT)
return;
// if the symbol's value can be decided at link time, then no need plt
if (getTarget().symbolFinalValueIsKnown(*rsym))
return;
// if symbol is defined in the ouput file and it's not
// preemptible, no need plt
if (rsym->isDefine() && !rsym->isDyn() &&
!getTarget().isSymbolPreemptible(*rsym)) {
return;
}
// Symbol needs PLT entry, we need to reserve a PLT entry
// and the corresponding GOT and dynamic relocation entry
// in .got and .rel.plt.
helper_PLT_init(pReloc, *this);
// set PLT bit
rsym->setReserved(rsym->reserved() | ReservePLT);
return;
}
case llvm::ELF::R_AARCH64_ADR_PREL_LO21:
case llvm::ELF::R_AARCH64_ADR_PREL_PG_HI21:
case llvm::ELF::R_AARCH64_ADR_PREL_PG_HI21_NC:
if (getTarget()
.symbolNeedsDynRel(
*rsym, (rsym->reserved() & ReservePLT), false)) {
if (getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym);
addCopyReloc(*cpy_sym.resolveInfo());
}
}
if (getTarget().symbolNeedsPLT(*rsym)) {
// create plt for this symbol if it does not have one
if (!(rsym->reserved() & ReservePLT)) {
// Symbol needs PLT entry, we need a PLT entry
// and the corresponding GOT and dynamic relocation entry
// in .got and .rel.plt.
helper_PLT_init(pReloc, *this);
// set PLT bit
rsym->setReserved(rsym->reserved() | ReservePLT);
}
}
return;
case llvm::ELF::R_AARCH64_ADR_GOT_PAGE:
case llvm::ELF::R_AARCH64_LD64_GOT_LO12_NC: {
// Symbol needs GOT entry, reserve entry in .got
// return if we already create GOT for this symbol
if (rsym->reserved() & ReserveGOT)
return;
// if the symbol cannot be fully resolved at link time, then we need a
// dynamic relocation
if (!getTarget().symbolFinalValueIsKnown(*rsym))
helper_GOT_init(pReloc, true, *this);
else
helper_GOT_init(pReloc, false, *this);
// set GOT bit
rsym->setReserved(rsym->reserved() | ReserveGOT);
return;
}
default:
break;
}
}
void AArch64Relocator::scanRelocation(Relocation& pReloc,
IRBuilder& pBuilder,
Module& pModule,
LDSection& pSection,
Input& pInput) {
ResolveInfo* rsym = pReloc.symInfo();
assert(rsym != NULL &&
"ResolveInfo of relocation not set while scanRelocation");
assert(pSection.getLink() != NULL);
if ((pSection.getLink()->flag() & llvm::ELF::SHF_ALLOC) == 0)
return;
// Scan relocation type to determine if an GOT/PLT/Dynamic Relocation
// entries should be created.
// FIXME: Below judgements concern nothing about TLS related relocation
// rsym is local
if (rsym->isLocal())
scanLocalReloc(pReloc, pSection);
// rsym is external
else
scanGlobalReloc(pReloc, pBuilder, pSection);
// check if we shoule issue undefined reference for the relocation target
// symbol
if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull())
issueUndefRef(pReloc, pSection, pInput);
}
bool
AArch64Relocator::mayHaveFunctionPointerAccess(const Relocation& pReloc) const {
switch (pReloc.type()) {
case llvm::ELF::R_AARCH64_ADR_PREL_PG_HI21:
case llvm::ELF::R_AARCH64_ADR_PREL_PG_HI21_NC:
case llvm::ELF::R_AARCH64_ADD_ABS_LO12_NC:
case llvm::ELF::R_AARCH64_ADR_GOT_PAGE:
case llvm::ELF::R_AARCH64_LD64_GOT_LO12_NC: {
return true;
}
default: {
if (pReloc.symInfo()->isLocal()) {
// Do not fold any local symbols if building a shared object.
return (config().codeGenType() == LinkerConfig::DynObj);
} else {
// Do not fold any none global defualt symbols if building a shared
// object.
return ((config().codeGenType() == LinkerConfig::DynObj) &&
(pReloc.symInfo()->visibility() != ResolveInfo::Default));
}
}
}
return false;
}
uint32_t AArch64Relocator::getDebugStringOffset(Relocation& pReloc) const {
if (pReloc.type() != llvm::ELF::R_AARCH64_ABS32)
error(diag::unsupport_reloc_for_debug_string)
<< getName(pReloc.type()) << "mclinker@googlegroups.com";
if (pReloc.symInfo()->type() == ResolveInfo::Section)
return pReloc.target() + pReloc.addend();
else
return pReloc.symInfo()->outSymbol()->fragRef()->offset() +
pReloc.target() + pReloc.addend();
}
void AArch64Relocator::applyDebugStringOffset(Relocation& pReloc,
uint32_t pOffset) {
pReloc.target() = pOffset;
}
//===----------------------------------------------------------------------===//
// Each relocation function implementation
//===----------------------------------------------------------------------===//
// R_AARCH64_NONE
Relocator::Result none(Relocation& pReloc, AArch64Relocator& pParent) {
return Relocator::OK;
}
Relocator::Result unsupported(Relocation& pReloc, AArch64Relocator& pParent) {
return Relocator::Unsupported;
}
// R_AARCH64_ABS64: S + A
// R_AARCH64_ABS32: S + A
// R_AARCH64_ABS16: S + A
Relocator::Result abs(Relocation& pReloc, AArch64Relocator& pParent) {
ResolveInfo* rsym = pReloc.symInfo();
Relocator::DWord A = pReloc.target() + pReloc.addend();
Relocator::DWord S = pReloc.symValue();
Relocation* dyn_rel = pParent.getRelRelMap().lookUp(pReloc);
bool has_dyn_rel = (dyn_rel != NULL);
LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
// If the flag of target section is not ALLOC, we will not scan this
// relocation but perform static relocation. (e.g., applying .debug section)
if (0x0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
pReloc.target() = S + A;
return Relocator::OK;
}
// A local symbol may need RELATIVE Type dynamic relocation
if (rsym->isLocal() && has_dyn_rel) {
dyn_rel->setAddend(S + A);
}
// An external symbol may need PLT and dynamic relocation
if (!rsym->isLocal()) {
if (rsym->reserved() & AArch64Relocator::ReservePLT) {
S = helper_get_PLT_address(*rsym, pParent);
}
// If we generate a dynamic relocation (except R_AARCH64_64_RELATIVE)
// for a place, we should not perform static relocation on it
// in order to keep the addend store in the place correct.
if (has_dyn_rel) {
if (llvm::ELF::R_AARCH64_ABS64 == pReloc.type() &&
llvm::ELF::R_AARCH64_RELATIVE == dyn_rel->type()) {
dyn_rel->setAddend(S + A);
} else {
dyn_rel->setAddend(A);
return Relocator::OK;
}
}
}
// perform static relocation
pReloc.target() = S + A;
return Relocator::OK;
}
// R_AARCH64_PREL64: S + A - P
// R_AARCH64_PREL32: S + A - P
// R_AARCH64_PREL16: S + A - P
Relocator::Result rel(Relocation& pReloc, AArch64Relocator& pParent) {
ResolveInfo* rsym = pReloc.symInfo();
Relocator::Address S = pReloc.symValue();
Relocator::DWord A = pReloc.addend();
Relocator::DWord P = pReloc.place();
if (llvm::ELF::R_AARCH64_PREL64 != pReloc.type())
A += pReloc.target() & get_mask(pParent.getSize(pReloc.type()));
else
A += pReloc.target();
LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
// If the flag of target section is not ALLOC, we will not scan this
// relocation but perform static relocation. (e.g., applying .debug section)
if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
// if plt entry exists, the S value is the plt entry address
if (!rsym->isLocal()) {
if (rsym->reserved() & AArch64Relocator::ReservePLT) {
S = helper_get_PLT_address(*rsym, pParent);
}
}
}
Relocator::DWord X = S + A - P;
pReloc.target() = X;
if (llvm::ELF::R_AARCH64_PREL64 != pReloc.type() &&
helper_check_signed_overflow(X, pParent.getSize(pReloc.type())))
return Relocator::Overflow;
return Relocator::OK;
}
// R_AARCH64_ADD_ABS_LO12_NC: S + A
Relocator::Result add_abs_lo12(Relocation& pReloc, AArch64Relocator& pParent) {
Relocator::Address value = 0x0;
Relocator::Address S = pReloc.symValue();
Relocator::DWord A = pReloc.addend();
value = helper_get_page_offset(S + A);
pReloc.target() = helper_reencode_add_imm(pReloc.target(), value);
return Relocator::OK;
}
// R_AARCH64_ADR_PREL_LO21: S + A - P
Relocator::Result adr_prel_lo21(Relocation& pReloc, AArch64Relocator& pParent) {
ResolveInfo* rsym = pReloc.symInfo();
Relocator::Address S = pReloc.symValue();
// if plt entry exists, the S value is the plt entry address
if (rsym->reserved() & AArch64Relocator::ReservePLT) {
S = helper_get_PLT_address(*rsym, pParent);
}
Relocator::DWord A = pReloc.addend();
Relocator::DWord P = pReloc.place();
Relocator::DWord X = S + A - P;
pReloc.target() = helper_reencode_adr_imm(pReloc.target(), X);
return Relocator::OK;
}
// R_AARCH64_ADR_PREL_PG_HI21: ((PG(S + A) - PG(P)) >> 12)
// R_AARCH64_ADR_PREL_PG_HI21_NC: ((PG(S + A) - PG(P)) >> 12)
Relocator::Result adr_prel_pg_hi21(Relocation& pReloc,
AArch64Relocator& pParent) {
ResolveInfo* rsym = pReloc.symInfo();
Relocator::Address S = pReloc.symValue();
// if plt entry exists, the S value is the plt entry address
if (rsym->reserved() & AArch64Relocator::ReservePLT) {
S = helper_get_PLT_address(*rsym, pParent);
}
Relocator::DWord A = pReloc.addend();
Relocator::DWord P = pReloc.place();
Relocator::DWord X =
helper_get_page_address(S + A) - helper_get_page_address(P);
pReloc.target() = helper_reencode_adr_imm(pReloc.target(), (X >> 12));
return Relocator::OK;
}
// R_AARCH64_CALL26: S + A - P
// R_AARCH64_JUMP26: S + A - P
Relocator::Result call(Relocation& pReloc, AArch64Relocator& pParent) {
// If target is undefined weak symbol, we only need to jump to the
// next instruction unless it has PLT entry. Rewrite instruction
// to NOP.
if (pReloc.symInfo()->isWeak() && pReloc.symInfo()->isUndef() &&
!pReloc.symInfo()->isDyn() &&
!(pReloc.symInfo()->reserved() & AArch64Relocator::ReservePLT)) {
// change target to NOP
pReloc.target() = 0xd503201f;
return Relocator::OK;
}
Relocator::Address S = pReloc.symValue();
Relocator::DWord A = pReloc.addend();
Relocator::Address P = pReloc.place();
// S depends on PLT exists or not
if (pReloc.symInfo()->reserved() & AArch64Relocator::ReservePLT)
S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
Relocator::DWord X = S + A - P;
// TODO: check overflow..
pReloc.target() = helper_reencode_branch_offset_26(pReloc.target(), X >> 2);
return Relocator::OK;
}
// R_AARCH64_CONDBR19: S + A - P
Relocator::Result condbr(Relocation& pReloc, AArch64Relocator& pParent) {
// If target is undefined weak symbol, we only need to jump to the
// next instruction unless it has PLT entry. Rewrite instruction
// to NOP.
if (pReloc.symInfo()->isWeak() && pReloc.symInfo()->isUndef() &&
!pReloc.symInfo()->isDyn() &&
!(pReloc.symInfo()->reserved() & AArch64Relocator::ReservePLT)) {
// change target to NOP
pReloc.target() = 0xd503201f;
return Relocator::OK;
}
Relocator::Address S = pReloc.symValue();
Relocator::DWord A = pReloc.addend();
Relocator::Address P = pReloc.place();
// S depends on PLT exists or not
if (pReloc.symInfo()->reserved() & AArch64Relocator::ReservePLT)
S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
Relocator::DWord X = S + A - P;
// TODO: check overflow..
pReloc.target() = helper_reencode_cond_branch_ofs_19(pReloc.target(), X >> 2);
return Relocator::OK;
}
// R_AARCH64_ADR_GOT_PAGE: Page(G(GDAT(S+A))) - Page(P)
Relocator::Result adr_got_page(Relocation& pReloc, AArch64Relocator& pParent) {
if (!(pReloc.symInfo()->reserved() & AArch64Relocator::ReserveGOT)) {
return Relocator::BadReloc;
}
Relocator::Address GOT_S = helper_get_GOT_address(*pReloc.symInfo(), pParent);
Relocator::DWord A = pReloc.addend();
Relocator::Address P = pReloc.place();
Relocator::DWord X =
helper_get_page_address(GOT_S + A) - helper_get_page_address(P);
pReloc.target() = helper_reencode_adr_imm(pReloc.target(), (X >> 12));
// setup got entry value if needed
AArch64GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*pReloc.symInfo());
if (got_entry != NULL && AArch64Relocator::SymVal == got_entry->getValue())
got_entry->setValue(pReloc.symValue());
// setup relocation addend if needed
Relocation* dyn_rela = pParent.getRelRelMap().lookUp(pReloc);
if ((dyn_rela != NULL) && (AArch64Relocator::SymVal == dyn_rela->addend())) {
dyn_rela->setAddend(pReloc.symValue());
}
return Relocator::OK;
}
// R_AARCH64_LD64_GOT_LO12_NC: G(GDAT(S+A))
Relocator::Result ld64_got_lo12(Relocation& pReloc, AArch64Relocator& pParent) {
if (!(pReloc.symInfo()->reserved() & AArch64Relocator::ReserveGOT)) {
return Relocator::BadReloc;
}
Relocator::Address GOT_S = helper_get_GOT_address(*pReloc.symInfo(), pParent);
Relocator::DWord A = pReloc.addend();
Relocator::DWord X = helper_get_page_offset(GOT_S + A);
pReloc.target() = helper_reencode_ldst_pos_imm(pReloc.target(), (X >> 3));
// setup got entry value if needed
AArch64GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*pReloc.symInfo());
if (got_entry != NULL && AArch64Relocator::SymVal == got_entry->getValue())
got_entry->setValue(pReloc.symValue());
// setup relocation addend if needed
Relocation* dyn_rela = pParent.getRelRelMap().lookUp(pReloc);
if ((dyn_rela != NULL) && (AArch64Relocator::SymVal == dyn_rela->addend())) {
dyn_rela->setAddend(pReloc.symValue());
}
return Relocator::OK;
}
// R_AARCH64_LDST8_ABS_LO12_NC: S + A
// R_AARCH64_LDST16_ABS_LO12_NC: S + A
// R_AARCH64_LDST32_ABS_LO12_NC: S + A
// R_AARCH64_LDST64_ABS_LO12_NC: S + A
// R_AARCH64_LDST128_ABS_LO12_NC: S + A
Relocator::Result ldst_abs_lo12(Relocation& pReloc, AArch64Relocator& pParent) {
Relocator::Address S = pReloc.symValue();
Relocator::DWord A = pReloc.addend();
Relocator::DWord X = helper_get_page_offset(S + A);
switch (pReloc.type()) {
case llvm::ELF::R_AARCH64_LDST8_ABS_LO12_NC:
pReloc.target() = helper_reencode_ldst_pos_imm(pReloc.target(), X);
break;
case llvm::ELF::R_AARCH64_LDST16_ABS_LO12_NC:
pReloc.target() = helper_reencode_ldst_pos_imm(pReloc.target(), (X >> 1));
break;
case llvm::ELF::R_AARCH64_LDST32_ABS_LO12_NC:
pReloc.target() = helper_reencode_ldst_pos_imm(pReloc.target(), (X >> 2));
break;
case llvm::ELF::R_AARCH64_LDST64_ABS_LO12_NC:
pReloc.target() = helper_reencode_ldst_pos_imm(pReloc.target(), (X >> 3));
break;
case llvm::ELF::R_AARCH64_LDST128_ABS_LO12_NC:
pReloc.target() = helper_reencode_ldst_pos_imm(pReloc.target(), (X >> 4));
break;
default:
break;
}
return Relocator::OK;
}
} // namespace mcld
Reference in New Issue View Git Blame Copy Permalink