//===- 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 #include #include #include 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 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( 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