| //===- MipsRelocator.cpp -----------------------------------------===// |
| // |
| // The MCLinker Project |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| #include "MipsRelocator.h" |
| #include "MipsRelocationFunctions.h" |
| |
| #include "mcld/IRBuilder.h" |
| #include "mcld/LinkerConfig.h" |
| #include "mcld/Object/ObjectBuilder.h" |
| #include "mcld/Support/MsgHandling.h" |
| #include "mcld/Target/OutputRelocSection.h" |
| #include "mcld/LD/ELFFileFormat.h" |
| |
| #include <llvm/ADT/Twine.h> |
| #include <llvm/Support/ELF.h> |
| |
| namespace mcld { |
| |
| //===----------------------------------------------------------------------===// |
| // MipsRelocationInfo |
| //===----------------------------------------------------------------------===// |
| class MipsRelocationInfo { |
| public: |
| static bool HasSubType(const Relocation& pParent, Relocation::Type pType) { |
| if (llvm::ELF::R_MIPS_NONE == pType) |
| return true; |
| |
| for (Relocation::Type type = pParent.type(); |
| llvm::ELF::R_MIPS_NONE != (type & 0xff); |
| type >>= 8) { |
| if ((type & 0xff) == pType) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| MipsRelocationInfo(Relocation& pParent, bool pIsRel) |
| : m_Parent(&pParent), |
| m_Type(pParent.type()), |
| m_Addend(pIsRel ? pParent.target() : pParent.addend()), |
| m_Symbol(pParent.symValue()), |
| m_Result(pParent.target()) {} |
| |
| bool isNone() const { return llvm::ELF::R_MIPS_NONE == type(); } |
| bool isFirst() const { return type() == (parent().type() & 0xff); } |
| bool isLast() const { return llvm::ELF::R_MIPS_NONE == (m_Type >> 8); } |
| |
| MipsRelocationInfo next() const { |
| return MipsRelocationInfo(*m_Parent, m_Type >> 8, result(), result()); |
| } |
| |
| const Relocation& parent() const { return *m_Parent; } |
| |
| Relocation& parent() { return *m_Parent; } |
| |
| Relocation::Type type() const { return m_Type & 0xff; } |
| |
| Relocation::DWord A() const { return m_Addend; } |
| |
| Relocation::DWord S() const { return m_Symbol; } |
| |
| Relocation::DWord P() const { return parent().place(); } |
| |
| Relocation::DWord result() const { return m_Result; } |
| |
| Relocation::DWord& result() { return m_Result; } |
| |
| private: |
| Relocation* m_Parent; |
| Relocation::Type m_Type; |
| Relocation::DWord m_Addend; |
| Relocation::DWord m_Symbol; |
| Relocation::DWord m_Result; |
| |
| MipsRelocationInfo(Relocation& pParent, Relocation::Type pType, |
| Relocation::DWord pResult, Relocation::DWord pAddend) |
| : m_Parent(&pParent), |
| m_Type(pType), |
| m_Addend(pAddend), |
| m_Symbol(0), |
| m_Result(pResult) {} |
| }; |
| |
| static void helper_PLT_init(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| assert(pParent.getSymPLTMap().lookUp(*rsym) == NULL && "PLT entry exists"); |
| |
| MipsGNULDBackend& backend = pParent.getTarget(); |
| PLTEntryBase* pltEntry = backend.getPLT().create(); |
| pParent.getSymPLTMap().record(*rsym, *pltEntry); |
| |
| assert(pParent.getSymGOTPLTMap().lookUp(*rsym) == NULL && |
| "PLT entry not exist, but DynRel entry exist!"); |
| Fragment* gotpltEntry = backend.getGOTPLT().create(); |
| pParent.getSymGOTPLTMap().record(*rsym, *gotpltEntry); |
| |
| Relocation* relEntry = backend.getRelPLT().create(); |
| relEntry->setType(llvm::ELF::R_MIPS_JUMP_SLOT); |
| relEntry->targetRef().assign(*gotpltEntry); |
| relEntry->setSymInfo(rsym); |
| } |
| |
| static Relocator::Address helper_get_PLT_address(ResolveInfo& pSym, |
| MipsRelocator& pParent) { |
| PLTEntryBase* plt_entry = pParent.getSymPLTMap().lookUp(pSym); |
| assert(plt_entry != NULL); |
| return pParent.getTarget().getPLT().addr() + plt_entry->getOffset(); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Relocation Functions and Tables |
| //===----------------------------------------------------------------------===// |
| DECL_MIPS_APPLY_RELOC_FUNCS |
| |
| /// the prototype of applying function |
| typedef Relocator::Result (*ApplyFunctionType)(MipsRelocationInfo&, |
| MipsRelocator& pParent); |
| |
| // the table entry of applying functions |
| struct ApplyFunctionTriple { |
| ApplyFunctionType func; |
| unsigned int type; |
| const char* name; |
| unsigned int size; |
| }; |
| |
| // declare the table of applying functions |
| static const ApplyFunctionTriple ApplyFunctions[] = { |
| DECL_MIPS_APPLY_RELOC_FUNC_PTRS}; |
| |
| //===----------------------------------------------------------------------===// |
| // MipsRelocator |
| //===----------------------------------------------------------------------===// |
| MipsRelocator::MipsRelocator(MipsGNULDBackend& pParent, |
| const LinkerConfig& pConfig) |
| : Relocator(pConfig), |
| m_Target(pParent), |
| m_pApplyingInput(NULL), |
| m_CurrentLo16Reloc(NULL) { |
| } |
| |
| Relocator::Result MipsRelocator::applyRelocation(Relocation& pReloc) { |
| // If m_CurrentLo16Reloc is not NULL we are processing |
| // postponed relocation. Otherwise check relocation type |
| // and postpone it for later handling. |
| if (m_CurrentLo16Reloc == NULL && isPostponed(pReloc)) { |
| postponeRelocation(pReloc); |
| return OK; |
| } |
| |
| for (MipsRelocationInfo info(pReloc, isRel()); !info.isNone(); |
| info = info.next()) { |
| if (info.type() >= sizeof(ApplyFunctions) / sizeof(ApplyFunctions[0])) |
| return Unknown; |
| |
| const ApplyFunctionTriple& triple = ApplyFunctions[info.type()]; |
| |
| Result res = triple.func(info, *this); |
| if (OK != res) |
| return res; |
| |
| if (info.isLast()) { |
| uint64_t mask = 0xFFFFFFFFFFFFFFFFULL >> (64 - triple.size); |
| pReloc.target() &= ~mask; |
| pReloc.target() |= info.result() & mask; |
| } |
| } |
| |
| return OK; |
| } |
| |
| const char* MipsRelocator::getName(Relocation::Type pType) const { |
| return ApplyFunctions[pType & 0xff].name; |
| } |
| |
| void MipsRelocator::scanRelocation(Relocation& pReloc, |
| IRBuilder& pBuilder, |
| Module& pModule, |
| LDSection& pSection, |
| Input& pInput) { |
| // rsym - The relocation target symbol |
| ResolveInfo* rsym = pReloc.symInfo(); |
| assert(rsym != NULL && |
| "ResolveInfo of relocation not set while scanRelocation"); |
| |
| // Skip relocation against _gp_disp |
| if (getTarget().getGpDispSymbol() != NULL && |
| rsym == getTarget().getGpDispSymbol()->resolveInfo()) |
| return; |
| |
| assert(pSection.getLink() != NULL); |
| if ((pSection.getLink()->flag() & llvm::ELF::SHF_ALLOC) == 0) |
| return; |
| |
| for (MipsRelocationInfo info(pReloc, isRel()); !info.isNone(); |
| info = info.next()) { |
| // We test isLocal or if pInputSym is not a dynamic symbol |
| // We assume -Bsymbolic to bind all symbols internaly via !rsym->isDyn() |
| // Don't put undef symbols into local entries. |
| if (isLocalReloc(*rsym)) |
| scanLocalReloc(info, pBuilder, pSection); |
| else |
| scanGlobalReloc(info, pBuilder, pSection); |
| |
| if (getTarget().needsLA25Stub(info.type(), info.parent().symInfo())) |
| getTarget().addNonPICBranchSym(pReloc.symInfo()); |
| } |
| |
| // Check if we should issue undefined reference |
| // for the relocation target symbol. |
| if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull()) |
| issueUndefRef(pReloc, pSection, pInput); |
| } |
| |
| bool MipsRelocator::initializeScan(Input& pInput) { |
| if (LinkerConfig::Object != config().codeGenType()) |
| getTarget().getGOT().initializeScan(pInput); |
| return true; |
| } |
| |
| bool MipsRelocator::finalizeScan(Input& pInput) { |
| if (LinkerConfig::Object != config().codeGenType()) |
| getTarget().getGOT().finalizeScan(pInput); |
| return true; |
| } |
| |
| bool MipsRelocator::initializeApply(Input& pInput) { |
| m_pApplyingInput = &pInput; |
| return true; |
| } |
| |
| bool MipsRelocator::finalizeApply(Input& pInput) { |
| m_pApplyingInput = NULL; |
| return true; |
| } |
| |
| void MipsRelocator::scanLocalReloc(MipsRelocationInfo& pReloc, |
| IRBuilder& pBuilder, |
| const LDSection& pSection) { |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| |
| switch (pReloc.type()) { |
| case llvm::ELF::R_MIPS_NONE: |
| case llvm::ELF::R_MIPS_16: |
| break; |
| case llvm::ELF::R_MIPS_32: |
| case llvm::ELF::R_MIPS_64: |
| if (pReloc.isFirst() && LinkerConfig::DynObj == config().codeGenType()) { |
| // TODO: (simon) The gold linker does not create an entry in .rel.dyn |
| // section if the symbol section flags contains SHF_EXECINSTR. |
| // 1. Find the reason of this condition. |
| // 2. Check this condition here. |
| getTarget().getRelDyn().reserveEntry(); |
| rsym->setReserved(rsym->reserved() | ReserveRel); |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| } |
| break; |
| case llvm::ELF::R_MIPS_REL32: |
| case llvm::ELF::R_MIPS_26: |
| case llvm::ELF::R_MIPS_HI16: |
| case llvm::ELF::R_MIPS_LO16: |
| case llvm::ELF::R_MIPS_SHIFT5: |
| case llvm::ELF::R_MIPS_SHIFT6: |
| case llvm::ELF::R_MIPS_SUB: |
| case llvm::ELF::R_MIPS_INSERT_A: |
| case llvm::ELF::R_MIPS_INSERT_B: |
| case llvm::ELF::R_MIPS_DELETE: |
| case llvm::ELF::R_MIPS_HIGHER: |
| case llvm::ELF::R_MIPS_HIGHEST: |
| case llvm::ELF::R_MIPS_SCN_DISP: |
| case llvm::ELF::R_MIPS_REL16: |
| case llvm::ELF::R_MIPS_ADD_IMMEDIATE: |
| case llvm::ELF::R_MIPS_PJUMP: |
| case llvm::ELF::R_MIPS_RELGOT: |
| case llvm::ELF::R_MIPS_JALR: |
| case llvm::ELF::R_MIPS_GLOB_DAT: |
| case llvm::ELF::R_MIPS_COPY: |
| case llvm::ELF::R_MIPS_JUMP_SLOT: |
| break; |
| case llvm::ELF::R_MIPS_GOT16: |
| case llvm::ELF::R_MIPS_CALL16: |
| case llvm::ELF::R_MIPS_GOT_HI16: |
| case llvm::ELF::R_MIPS_CALL_HI16: |
| case llvm::ELF::R_MIPS_GOT_LO16: |
| case llvm::ELF::R_MIPS_CALL_LO16: |
| case llvm::ELF::R_MIPS_GOT_DISP: |
| case llvm::ELF::R_MIPS_GOT_PAGE: |
| case llvm::ELF::R_MIPS_GOT_OFST: |
| if (getTarget() |
| .getGOT() |
| .reserveLocalEntry(*rsym, pReloc.type(), pReloc.A())) { |
| if (getTarget().getGOT().hasMultipleGOT()) |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| } |
| break; |
| case llvm::ELF::R_MIPS_GPREL32: |
| case llvm::ELF::R_MIPS_GPREL16: |
| case llvm::ELF::R_MIPS_LITERAL: |
| break; |
| case llvm::ELF::R_MIPS_TLS_GD: |
| getTarget().getGOT().reserveTLSGdEntry(*rsym); |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| break; |
| case llvm::ELF::R_MIPS_TLS_LDM: |
| getTarget().getGOT().reserveTLSLdmEntry(); |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| break; |
| case llvm::ELF::R_MIPS_TLS_GOTTPREL: |
| getTarget().getGOT().reserveTLSGotEntry(*rsym); |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| break; |
| case llvm::ELF::R_MIPS_TLS_DTPMOD32: |
| case llvm::ELF::R_MIPS_TLS_DTPREL32: |
| case llvm::ELF::R_MIPS_TLS_DTPMOD64: |
| case llvm::ELF::R_MIPS_TLS_DTPREL64: |
| case llvm::ELF::R_MIPS_TLS_DTPREL_HI16: |
| case llvm::ELF::R_MIPS_TLS_DTPREL_LO16: |
| case llvm::ELF::R_MIPS_TLS_TPREL32: |
| case llvm::ELF::R_MIPS_TLS_TPREL64: |
| case llvm::ELF::R_MIPS_TLS_TPREL_HI16: |
| case llvm::ELF::R_MIPS_TLS_TPREL_LO16: |
| break; |
| case llvm::ELF::R_MIPS_PC16: |
| case llvm::ELF::R_MIPS_PC32: |
| case llvm::ELF::R_MIPS_PC18_S3: |
| case llvm::ELF::R_MIPS_PC19_S2: |
| case llvm::ELF::R_MIPS_PC21_S2: |
| case llvm::ELF::R_MIPS_PC26_S2: |
| case llvm::ELF::R_MIPS_PCHI16: |
| case llvm::ELF::R_MIPS_PCLO16: |
| break; |
| default: |
| fatal(diag::unknown_relocation) << static_cast<int>(pReloc.type()) |
| << rsym->name(); |
| } |
| } |
| |
| void MipsRelocator::scanGlobalReloc(MipsRelocationInfo& pReloc, |
| IRBuilder& pBuilder, |
| const LDSection& pSection) { |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| bool hasPLT = rsym->reserved() & ReservePLT; |
| |
| switch (pReloc.type()) { |
| case llvm::ELF::R_MIPS_NONE: |
| case llvm::ELF::R_MIPS_INSERT_A: |
| case llvm::ELF::R_MIPS_INSERT_B: |
| case llvm::ELF::R_MIPS_DELETE: |
| case llvm::ELF::R_MIPS_TLS_DTPMOD64: |
| case llvm::ELF::R_MIPS_TLS_DTPREL64: |
| case llvm::ELF::R_MIPS_REL16: |
| case llvm::ELF::R_MIPS_ADD_IMMEDIATE: |
| case llvm::ELF::R_MIPS_PJUMP: |
| case llvm::ELF::R_MIPS_RELGOT: |
| case llvm::ELF::R_MIPS_TLS_TPREL64: |
| break; |
| case llvm::ELF::R_MIPS_32: |
| case llvm::ELF::R_MIPS_64: |
| if (pReloc.isFirst() && |
| getTarget().symbolNeedsDynRel(*rsym, hasPLT, true)) { |
| getTarget().getRelDyn().reserveEntry(); |
| rsym->setReserved(rsym->reserved() | ReserveRel); |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| if (!getTarget().symbolFinalValueIsKnown(*rsym)) |
| getTarget().getGOT().reserveGlobalEntry(*rsym); |
| } |
| break; |
| case llvm::ELF::R_MIPS_HI16: |
| case llvm::ELF::R_MIPS_LO16: |
| if (getTarget().symbolNeedsDynRel(*rsym, hasPLT, true) || |
| getTarget().symbolNeedsCopyReloc(pReloc.parent(), *rsym)) { |
| getTarget().getRelDyn().reserveEntry(); |
| LDSymbol& cpySym = defineSymbolforCopyReloc(pBuilder, *rsym); |
| addCopyReloc(*cpySym.resolveInfo()); |
| } |
| break; |
| case llvm::ELF::R_MIPS_GOT16: |
| case llvm::ELF::R_MIPS_CALL16: |
| case llvm::ELF::R_MIPS_GOT_DISP: |
| case llvm::ELF::R_MIPS_GOT_HI16: |
| case llvm::ELF::R_MIPS_CALL_HI16: |
| case llvm::ELF::R_MIPS_GOT_LO16: |
| case llvm::ELF::R_MIPS_CALL_LO16: |
| case llvm::ELF::R_MIPS_GOT_PAGE: |
| case llvm::ELF::R_MIPS_GOT_OFST: |
| if (getTarget().getGOT().reserveGlobalEntry(*rsym)) { |
| if (getTarget().getGOT().hasMultipleGOT()) |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| } |
| break; |
| case llvm::ELF::R_MIPS_LITERAL: |
| case llvm::ELF::R_MIPS_GPREL32: |
| fatal(diag::invalid_global_relocation) << static_cast<int>(pReloc.type()) |
| << rsym->name(); |
| break; |
| case llvm::ELF::R_MIPS_GPREL16: |
| break; |
| case llvm::ELF::R_MIPS_26: |
| // Create a PLT entry if the symbol requires it and does not have it. |
| if (getTarget().symbolNeedsPLT(*rsym) && !hasPLT) { |
| helper_PLT_init(pReloc, *this); |
| rsym->setReserved(rsym->reserved() | ReservePLT); |
| } |
| break; |
| case llvm::ELF::R_MIPS_16: |
| case llvm::ELF::R_MIPS_SHIFT5: |
| case llvm::ELF::R_MIPS_SHIFT6: |
| case llvm::ELF::R_MIPS_SUB: |
| case llvm::ELF::R_MIPS_HIGHER: |
| case llvm::ELF::R_MIPS_HIGHEST: |
| case llvm::ELF::R_MIPS_SCN_DISP: |
| break; |
| case llvm::ELF::R_MIPS_TLS_GD: |
| getTarget().getGOT().reserveTLSGdEntry(*rsym); |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| break; |
| case llvm::ELF::R_MIPS_TLS_LDM: |
| getTarget().getGOT().reserveTLSLdmEntry(); |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| break; |
| case llvm::ELF::R_MIPS_TLS_GOTTPREL: |
| getTarget().getGOT().reserveTLSGotEntry(*rsym); |
| getTarget().checkAndSetHasTextRel(*pSection.getLink()); |
| break; |
| case llvm::ELF::R_MIPS_TLS_DTPREL32: |
| case llvm::ELF::R_MIPS_TLS_DTPREL_HI16: |
| case llvm::ELF::R_MIPS_TLS_DTPREL_LO16: |
| case llvm::ELF::R_MIPS_TLS_TPREL32: |
| case llvm::ELF::R_MIPS_TLS_TPREL_HI16: |
| case llvm::ELF::R_MIPS_TLS_TPREL_LO16: |
| break; |
| case llvm::ELF::R_MIPS_REL32: |
| case llvm::ELF::R_MIPS_JALR: |
| case llvm::ELF::R_MIPS_PC16: |
| case llvm::ELF::R_MIPS_PC32: |
| case llvm::ELF::R_MIPS_PC18_S3: |
| case llvm::ELF::R_MIPS_PC19_S2: |
| case llvm::ELF::R_MIPS_PC21_S2: |
| case llvm::ELF::R_MIPS_PC26_S2: |
| case llvm::ELF::R_MIPS_PCHI16: |
| case llvm::ELF::R_MIPS_PCLO16: |
| break; |
| case llvm::ELF::R_MIPS_COPY: |
| case llvm::ELF::R_MIPS_GLOB_DAT: |
| case llvm::ELF::R_MIPS_JUMP_SLOT: |
| fatal(diag::dynamic_relocation) << static_cast<int>(pReloc.type()); |
| break; |
| default: |
| fatal(diag::unknown_relocation) << static_cast<int>(pReloc.type()) |
| << rsym->name(); |
| } |
| } |
| |
| bool MipsRelocator::isPostponed(const Relocation& pReloc) const { |
| if (isN64ABI()) |
| return false; |
| |
| if (MipsRelocationInfo::HasSubType(pReloc, llvm::ELF::R_MIPS_HI16) || |
| MipsRelocationInfo::HasSubType(pReloc, llvm::ELF::R_MIPS_PCHI16)) |
| return true; |
| |
| if (MipsRelocationInfo::HasSubType(pReloc, llvm::ELF::R_MIPS_GOT16) && |
| pReloc.symInfo()->isLocal()) |
| return true; |
| |
| return false; |
| } |
| |
| void MipsRelocator::addCopyReloc(ResolveInfo& pSym) { |
| Relocation& relEntry = *getTarget().getRelDyn().consumeEntry(); |
| relEntry.setType(llvm::ELF::R_MIPS_COPY); |
| assert(pSym.outSymbol()->hasFragRef()); |
| relEntry.targetRef().assign(*pSym.outSymbol()->fragRef()); |
| relEntry.setSymInfo(&pSym); |
| } |
| |
| LDSymbol& MipsRelocator::defineSymbolforCopyReloc(IRBuilder& pBuilder, |
| const ResolveInfo& pSym) { |
| // Get or create corresponding BSS LDSection |
| ELFFileFormat* fileFormat = getTarget().getOutputFormat(); |
| LDSection* bssSectHdr = ResolveInfo::ThreadLocal == pSym.type() |
| ? &fileFormat->getTBSS() |
| : &fileFormat->getBSS(); |
| |
| // Get or create corresponding BSS SectionData |
| SectionData* bssData = bssSectHdr->hasSectionData() |
| ? bssSectHdr->getSectionData() |
| : IRBuilder::CreateSectionData(*bssSectHdr); |
| |
| // 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, *bssData, addrAlign); |
| bssSectHdr->setSize(bssSectHdr->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* cpySym = 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()); |
| |
| // Output all other alias symbols if any |
| Module::AliasList* alias_list = pBuilder.getModule().getAliasList(pSym); |
| if (alias_list == NULL) |
| return *cpySym; |
| |
| for (Module::alias_iterator it = alias_list->begin(), ie = alias_list->end(); |
| it != ie; |
| ++it) { |
| const ResolveInfo* alias = *it; |
| if (alias == &pSym || !alias->isDyn()) |
| continue; |
| |
| pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>( |
| alias->name(), |
| (ResolveInfo::Type)alias->type(), |
| ResolveInfo::Define, |
| binding, |
| alias->size(), // size |
| 0x0, // value |
| FragmentRef::Create(*frag, 0x0), |
| (ResolveInfo::Visibility)alias->other()); |
| } |
| |
| return *cpySym; |
| } |
| |
| void MipsRelocator::postponeRelocation(Relocation& pReloc) { |
| ResolveInfo* rsym = pReloc.symInfo(); |
| m_PostponedRelocs[rsym].insert(&pReloc); |
| } |
| |
| void MipsRelocator::applyPostponedRelocations(MipsRelocationInfo& pLo16Reloc) { |
| m_CurrentLo16Reloc = &pLo16Reloc; |
| |
| ResolveInfo* rsym = pLo16Reloc.parent().symInfo(); |
| |
| RelocationSet& relocs = m_PostponedRelocs[rsym]; |
| for (RelocationSet::iterator it = relocs.begin(); it != relocs.end(); ++it) |
| (*it)->apply(*this); |
| |
| m_PostponedRelocs.erase(rsym); |
| |
| m_CurrentLo16Reloc = NULL; |
| } |
| |
| bool MipsRelocator::isGpDisp(const Relocation& pReloc) const { |
| return strcmp("_gp_disp", pReloc.symInfo()->name()) == 0; |
| } |
| |
| bool MipsRelocator::isRel() const { |
| return config().targets().is32Bits(); |
| } |
| |
| bool MipsRelocator::isLocalReloc(ResolveInfo& pSym) const { |
| if (pSym.isUndef()) |
| return false; |
| |
| return pSym.isLocal() || !getTarget().isDynamicSymbol(pSym) || !pSym.isDyn(); |
| } |
| |
| Relocator::Address MipsRelocator::getGPAddress() { |
| return getTarget().getGOT().getGPAddr(getApplyingInput()); |
| } |
| |
| Relocator::Address MipsRelocator::getTPOffset() { |
| return getTarget().getTPOffset(getApplyingInput()); |
| } |
| |
| Relocator::Address MipsRelocator::getDTPOffset() { |
| return getTarget().getDTPOffset(getApplyingInput()); |
| } |
| |
| Relocator::Address MipsRelocator::getGP0() { |
| return getTarget().getGP0(getApplyingInput()); |
| } |
| |
| Fragment& MipsRelocator::getLocalGOTEntry(MipsRelocationInfo& pReloc, |
| Relocation::DWord entryValue) { |
| // rsym - The relocation target symbol |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| MipsGOT& got = getTarget().getGOT(); |
| |
| assert(isLocalReloc(*rsym) && |
| "Attempt to get a global GOT entry for the local relocation"); |
| |
| Fragment* got_entry = got.lookupLocalEntry(rsym, entryValue); |
| |
| // Found a mapping, then return the mapped entry immediately. |
| if (got_entry != NULL) |
| return *got_entry; |
| |
| // Not found. |
| got_entry = got.consumeLocal(); |
| |
| if (got.isPrimaryGOTConsumed()) |
| setupRel32DynEntry(*FragmentRef::Create(*got_entry, 0), NULL); |
| else |
| got.setEntryValue(got_entry, entryValue); |
| |
| got.recordLocalEntry(rsym, entryValue, got_entry); |
| |
| return *got_entry; |
| } |
| |
| Fragment& MipsRelocator::getGlobalGOTEntry(MipsRelocationInfo& pReloc) { |
| // rsym - The relocation target symbol |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| MipsGOT& got = getTarget().getGOT(); |
| |
| assert(!isLocalReloc(*rsym) && |
| "Attempt to get a local GOT entry for the global relocation"); |
| |
| Fragment* got_entry = got.lookupGlobalEntry(rsym); |
| |
| // Found a mapping, then return the mapped entry immediately. |
| if (got_entry != NULL) |
| return *got_entry; |
| |
| // Not found. |
| got_entry = got.consumeGlobal(); |
| |
| if (got.isPrimaryGOTConsumed()) |
| setupRel32DynEntry(*FragmentRef::Create(*got_entry, 0), rsym); |
| else |
| got.setEntryValue(got_entry, pReloc.parent().symValue()); |
| |
| got.recordGlobalEntry(rsym, got_entry); |
| |
| return *got_entry; |
| } |
| |
| Fragment& MipsRelocator::getTLSGOTEntry(MipsRelocationInfo& pReloc) { |
| // rsym - The relocation target symbol |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| MipsGOT& got = getTarget().getGOT(); |
| |
| Fragment* modEntry = got.lookupTLSEntry(rsym, pReloc.type()); |
| |
| // Found a mapping, then return the mapped entry immediately. |
| if (modEntry != NULL) |
| return *modEntry; |
| |
| // Not found. |
| modEntry = got.consumeTLS(pReloc.type()); |
| setupTLSDynEntry(*modEntry, rsym, pReloc.type()); |
| got.recordTLSEntry(rsym, modEntry, pReloc.type()); |
| |
| return *modEntry; |
| } |
| |
| Relocator::Address MipsRelocator::getGOTOffset(MipsRelocationInfo& pReloc) { |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| MipsGOT& got = getTarget().getGOT(); |
| |
| if (isLocalReloc(*rsym)) { |
| uint64_t value = pReloc.S(); |
| |
| if (ResolveInfo::Section == rsym->type()) |
| value += pReloc.A(); |
| |
| return got.getGPRelOffset(getApplyingInput(), |
| getLocalGOTEntry(pReloc, value)); |
| } else { |
| return got.getGPRelOffset(getApplyingInput(), getGlobalGOTEntry(pReloc)); |
| } |
| } |
| |
| Relocator::Address MipsRelocator::getTLSGOTOffset(MipsRelocationInfo& pReloc) { |
| MipsGOT& got = getTarget().getGOT(); |
| return got.getGPRelOffset(getApplyingInput(), getTLSGOTEntry(pReloc)); |
| } |
| |
| void MipsRelocator::createDynRel(MipsRelocationInfo& pReloc) { |
| Relocator::DWord A = pReloc.A(); |
| Relocator::DWord S = pReloc.S(); |
| |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| |
| if (getTarget().isDynamicSymbol(*rsym)) { |
| setupRel32DynEntry(pReloc.parent().targetRef(), rsym); |
| // Don't add symbol value that will be resolved by the dynamic linker. |
| pReloc.result() = A; |
| } else { |
| setupRel32DynEntry(pReloc.parent().targetRef(), NULL); |
| pReloc.result() = A + S; |
| } |
| |
| if (!isLocalReloc(*rsym) && !getTarget().symbolFinalValueIsKnown(*rsym)) |
| getGlobalGOTEntry(pReloc); |
| } |
| |
| uint64_t MipsRelocator::calcAHL(const MipsRelocationInfo& pHiReloc) { |
| if (isN64ABI()) |
| return pHiReloc.A(); |
| |
| assert(m_CurrentLo16Reloc != NULL && |
| "There is no saved R_MIPS_LO16 relocation"); |
| |
| uint64_t AHI = pHiReloc.A() & 0xFFFF; |
| uint64_t ALO = m_CurrentLo16Reloc->A() & 0xFFFF; |
| uint64_t AHL = (AHI << 16) + int16_t(ALO); |
| |
| return AHL; |
| } |
| |
| bool MipsRelocator::isN64ABI() const { |
| return config().targets().is64Bits(); |
| } |
| |
| uint32_t MipsRelocator::getDebugStringOffset(Relocation& pReloc) const { |
| if (pReloc.type() != llvm::ELF::R_MIPS_32) |
| error(diag::unsupport_reloc_for_debug_string) |
| << getName(pReloc.type()) << "[email protected]"; |
| if (pReloc.symInfo()->type() == ResolveInfo::Section) |
| return pReloc.target() + pReloc.addend(); |
| else |
| return pReloc.symInfo()->outSymbol()->fragRef()->offset() + |
| pReloc.target() + pReloc.addend(); |
| } |
| |
| void MipsRelocator::applyDebugStringOffset(Relocation& pReloc, |
| uint32_t pOffset) { |
| pReloc.target() = pOffset; |
| } |
| |
| void MipsRelocator::setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym, |
| Relocation::Type pType) { |
| Relocation& relEntry = *getTarget().getRelDyn().consumeEntry(); |
| relEntry.setType(pType); |
| relEntry.targetRef() = pFragRef; |
| relEntry.setSymInfo(pSym); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Mips32Relocator |
| //===----------------------------------------------------------------------===// |
| Mips32Relocator::Mips32Relocator(Mips32GNULDBackend& pParent, |
| const LinkerConfig& pConfig) |
| : MipsRelocator(pParent, pConfig) { |
| } |
| |
| void Mips32Relocator::setupRel32DynEntry(FragmentRef& pFragRef, |
| ResolveInfo* pSym) { |
| setupRelDynEntry(pFragRef, pSym, llvm::ELF::R_MIPS_REL32); |
| } |
| |
| void Mips32Relocator::setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym, |
| Relocation::Type pType) { |
| pSym = pSym->isLocal() ? nullptr : pSym; |
| if (pType == llvm::ELF::R_MIPS_TLS_GD) { |
| FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0); |
| setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPMOD32); |
| FragmentRef& relFrag = *FragmentRef::Create(*pFrag.getNextNode(), 0); |
| setupRelDynEntry(relFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPREL32); |
| } else if (pType == llvm::ELF::R_MIPS_TLS_LDM) { |
| FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0); |
| setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPMOD32); |
| } else if (pType == llvm::ELF::R_MIPS_TLS_GOTTPREL) { |
| FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0); |
| setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_TPREL32); |
| } else { |
| llvm_unreachable("Unexpected relocation"); |
| } |
| } |
| |
| Relocator::Size Mips32Relocator::getSize(Relocation::Type pType) const { |
| return ApplyFunctions[pType & 0xff].size; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Mips64Relocator |
| //===----------------------------------------------------------------------===// |
| Mips64Relocator::Mips64Relocator(Mips64GNULDBackend& pParent, |
| const LinkerConfig& pConfig) |
| : MipsRelocator(pParent, pConfig) { |
| } |
| |
| void Mips64Relocator::setupRel32DynEntry(FragmentRef& pFragRef, |
| ResolveInfo* pSym) { |
| Relocation::Type type = llvm::ELF::R_MIPS_REL32 | llvm::ELF::R_MIPS_64 << 8; |
| setupRelDynEntry(pFragRef, pSym, type); |
| } |
| |
| void Mips64Relocator::setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym, |
| Relocation::Type pType) { |
| pSym = pSym->isLocal() ? nullptr : pSym; |
| if (pType == llvm::ELF::R_MIPS_TLS_GD) { |
| FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0); |
| setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPMOD64); |
| FragmentRef& relFrag = *FragmentRef::Create(*pFrag.getNextNode(), 0); |
| setupRelDynEntry(relFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPREL64); |
| } else if (pType == llvm::ELF::R_MIPS_TLS_LDM) { |
| FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0); |
| setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_DTPMOD64); |
| } else if (pType == llvm::ELF::R_MIPS_TLS_GOTTPREL) { |
| FragmentRef& modFrag = *FragmentRef::Create(pFrag, 0); |
| setupRelDynEntry(modFrag, pSym, llvm::ELF::R_MIPS_TLS_TPREL64); |
| } else { |
| llvm_unreachable("Unexpected relocation"); |
| } |
| } |
| |
| Relocator::Size Mips64Relocator::getSize(Relocation::Type pType) const { |
| if (((pType >> 16) & 0xff) != llvm::ELF::R_MIPS_NONE) |
| return ApplyFunctions[(pType >> 16) & 0xff].size; |
| if (((pType >> 8) & 0xff) != llvm::ELF::R_MIPS_NONE) |
| return ApplyFunctions[(pType >> 8) & 0xff].size; |
| return ApplyFunctions[pType & 0xff].size; |
| } |
| |
| //=========================================// |
| // Relocation functions implementation // |
| //=========================================// |
| |
| // R_MIPS_NONE and those unsupported/deprecated relocation type |
| static MipsRelocator::Result none(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_32: S + A |
| static MipsRelocator::Result abs32(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| |
| Relocator::DWord A = pReloc.A(); |
| Relocator::DWord S = pReloc.S(); |
| |
| LDSection& target_sect = |
| pReloc.parent().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 ((llvm::ELF::SHF_ALLOC & target_sect.flag()) == 0x0) { |
| pReloc.result() = S + A; |
| return Relocator::OK; |
| } |
| |
| if (rsym->reserved() & MipsRelocator::ReserveRel) { |
| pParent.createDynRel(pReloc); |
| return Relocator::OK; |
| } |
| |
| pReloc.result() = S + A; |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_26: |
| // local : ((A | ((P + 4) & 0x3F000000)) + S) >> 2 |
| // external: (sign–extend(A) + S) >> 2 |
| static MipsRelocator::Result rel26(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| |
| int32_t A = pParent.isN64ABI() ? pReloc.A() : (pReloc.A() & 0x03FFFFFF) << 2; |
| int32_t P = pReloc.P(); |
| int32_t S = rsym->reserved() & MipsRelocator::ReservePLT |
| ? helper_get_PLT_address(*rsym, pParent) |
| : pReloc.S(); |
| |
| if (rsym->isLocal()) |
| pReloc.result() = A | ((P + 4) & 0x3F000000); |
| else |
| pReloc.result() = signExtend<28>(A); |
| |
| pReloc.result() = (pReloc.result() + S) >> 2; |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_HI16: |
| // local/external: ((AHL + S) - (short)(AHL + S)) >> 16 |
| // _gp_disp : ((AHL + GP - P) - (short)(AHL + GP - P)) >> 16 |
| static MipsRelocator::Result hi16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| uint64_t AHL = pParent.calcAHL(pReloc); |
| |
| if (pParent.isGpDisp(pReloc.parent())) { |
| int32_t P = pReloc.P(); |
| int32_t GP = pParent.getGPAddress(); |
| pReloc.result() = ((AHL + GP - P) - (int16_t)(AHL + GP - P)) >> 16; |
| } else { |
| int32_t S = pReloc.S(); |
| if (pParent.isN64ABI()) |
| pReloc.result() = (pReloc.A() + S + 0x8000ull) >> 16; |
| else |
| pReloc.result() = ((AHL + S) - (int16_t)(AHL + S)) >> 16; |
| } |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_LO16: |
| // local/external: AHL + S |
| // _gp_disp : AHL + GP - P + 4 |
| static MipsRelocator::Result lo16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| // AHL is a combination of HI16 and LO16 addends. But R_MIPS_LO16 |
| // uses low 16 bits of the AHL. That is why we do not need R_MIPS_HI16 |
| // addend here. |
| int32_t AHL = (pReloc.A() & 0xFFFF); |
| |
| if (pParent.isGpDisp(pReloc.parent())) { |
| int32_t P = pReloc.P(); |
| int32_t GP = pParent.getGPAddress(); |
| pReloc.result() = AHL + GP - P + 4; |
| } else { |
| int32_t S = pReloc.S(); |
| pReloc.result() = AHL + S; |
| } |
| |
| pParent.applyPostponedRelocations(pReloc); |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_GPREL16: |
| // external: sign–extend(A) + S - GP |
| // local : sign–extend(A) + S + GP0 – GP |
| static MipsRelocator::Result gprel16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| // Remember to add the section offset to A. |
| uint64_t A = pReloc.A(); |
| uint64_t S = pReloc.S(); |
| uint64_t GP0 = pParent.getGP0(); |
| uint64_t GP = pParent.getGPAddress(); |
| |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| if (rsym->isLocal()) |
| pReloc.result() = A + S + GP0 - GP; |
| else |
| pReloc.result() = A + S - GP; |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_GOT16: |
| // local : G (calculate AHL and put high 16 bit to GOT) |
| // external: G |
| static MipsRelocator::Result got16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| if (pReloc.parent().symInfo()->isLocal()) { |
| int32_t AHL = pParent.calcAHL(pReloc); |
| int32_t S = pReloc.S(); |
| int32_t res = (AHL + S + 0x8000) & 0xFFFF0000; |
| |
| MipsGOT& got = pParent.getTarget().getGOT(); |
| |
| Fragment& got_entry = pParent.getLocalGOTEntry(pReloc, res); |
| |
| pReloc.result() = got.getGPRelOffset(pParent.getApplyingInput(), got_entry); |
| } else { |
| pReloc.result() = pParent.getGOTOffset(pReloc); |
| } |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_GOTHI16: |
| // external: (G - (short)G) >> 16 + A |
| static MipsRelocator::Result gothi16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| Relocator::Address G = pParent.getGOTOffset(pReloc); |
| int32_t A = pReloc.A(); |
| |
| pReloc.result() = (G - (int16_t)G) >> (16 + A); |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_GOTLO16: |
| // external: G & 0xffff |
| static MipsRelocator::Result gotlo16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| pReloc.result() = pParent.getGOTOffset(pReloc) & 0xffff; |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_SUB: |
| // external/local: S - A |
| static MipsRelocator::Result sub(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| uint64_t S = pReloc.S(); |
| uint64_t A = pReloc.A(); |
| |
| pReloc.result() = S - A; |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_CALL16: G |
| static MipsRelocator::Result call16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| pReloc.result() = pParent.getGOTOffset(pReloc); |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_GPREL32: A + S + GP0 - GP |
| static MipsRelocator::Result gprel32(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| // Remember to add the section offset to A. |
| uint64_t A = pReloc.A(); |
| uint64_t S = pReloc.S(); |
| uint64_t GP0 = pParent.getGP0(); |
| uint64_t GP = pParent.getGPAddress(); |
| |
| pReloc.result() = A + S + GP0 - GP; |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_64: S + A |
| static MipsRelocator::Result abs64(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| // FIXME (simon): Consider to merge with abs32() or use the same function |
| // but with another mask size. |
| ResolveInfo* rsym = pReloc.parent().symInfo(); |
| |
| Relocator::DWord A = pReloc.A(); |
| Relocator::DWord S = pReloc.S(); |
| |
| LDSection& target_sect = |
| pReloc.parent().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.result() = S + A; |
| return Relocator::OK; |
| } |
| |
| if (rsym->reserved() & MipsRelocator::ReserveRel) { |
| pParent.createDynRel(pReloc); |
| return Relocator::OK; |
| } |
| |
| pReloc.result() = S + A; |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_GOT_DISP / R_MIPS_GOT_PAGE: G |
| static MipsRelocator::Result gotdisp(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| pReloc.result() = pParent.getGOTOffset(pReloc); |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_GOT_OFST: |
| static MipsRelocator::Result gotoff(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| // FIXME (simon): Needs to be implemented. |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_JALR: |
| static MipsRelocator::Result jalr(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_PC16 |
| static MipsRelocator::Result pc16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| int64_t A = signExtend<18>(pReloc.A() << 2); |
| int64_t S = pReloc.S(); |
| int64_t P = pReloc.P(); |
| pReloc.result() = (A + S - P) >> 2; |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_PC32 |
| static MipsRelocator::Result pc32(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| int64_t A = pReloc.A(); |
| int64_t S = pReloc.S(); |
| int64_t P = pReloc.P(); |
| pReloc.result() = A + S - P; |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_PC18_S3 |
| static MipsRelocator::Result pc18_s3(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| int64_t A = signExtend<21>(pReloc.A() << 3); |
| int64_t S = pReloc.S(); |
| int64_t P = pReloc.P(); |
| pReloc.result() = (S + A - ((P | 7) ^ 7)) >> 3; |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_PC19_S2 |
| static MipsRelocator::Result pc19_s2(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| int64_t A = signExtend<21>(pReloc.A() << 2); |
| int64_t S = pReloc.S(); |
| int64_t P = pReloc.P(); |
| pReloc.result() = (A + S - P) >> 2; |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_PC21_S2 |
| static MipsRelocator::Result pc21_s2(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| int32_t A = signExtend<23>(pReloc.A() << 2); |
| int32_t S = pReloc.S(); |
| int32_t P = pReloc.P(); |
| pReloc.result() = (A + S - P) >> 2; |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_PC26_S2 |
| static MipsRelocator::Result pc26_s2(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| int64_t A = signExtend<28>(pReloc.A() << 2); |
| int64_t S = pReloc.S(); |
| int64_t P = pReloc.P(); |
| pReloc.result() = (A + S - P) >> 2; |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_PCHI16 |
| static MipsRelocator::Result pchi16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| uint64_t AHL = pParent.calcAHL(pReloc); |
| int64_t S = pReloc.S(); |
| int64_t P = pReloc.P(); |
| pReloc.result() = (S + AHL - P + 0x8000) >> 16; |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_PCLO16 |
| static MipsRelocator::Result pclo16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| int32_t AHL = pReloc.A() & 0xFFFF; |
| int64_t S = pReloc.S(); |
| int64_t P = pReloc.P(); |
| pReloc.result() = S + AHL - P; |
| pParent.applyPostponedRelocations(pReloc); |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_TLS_TPREL_HI16, R_MIPS_TLS_DTPREL_HI16 |
| // local/external: (A + S - TP Offset) >> 16 |
| // _gp_disp : (A + GP - P - TP Offset) >> 16 |
| static MipsRelocator::Result tlshi16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| uint64_t A = pReloc.A() & 0xFFFF; |
| if (pReloc.type() == llvm::ELF::R_MIPS_TLS_TPREL_HI16) |
| A -= pParent.getTPOffset(); |
| else if (pReloc.type() == llvm::ELF::R_MIPS_TLS_DTPREL_HI16) |
| A -= pParent.getDTPOffset(); |
| else |
| llvm_unreachable("Unexpected relocation"); |
| |
| if (pParent.isGpDisp(pReloc.parent())) |
| pReloc.result() = (A + pReloc.S() - pReloc.P() + 0x8000) >> 16; |
| else |
| pReloc.result() = (A + pReloc.S() + 0x8000) >> 16; |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_TLS_TPREL_LO16, R_MIPS_TLS_DTPREL_LO16 |
| // local/external: A + S - TP Offset |
| // _gp_disp : A + GP - P + 4 - TP Offset |
| static MipsRelocator::Result tlslo16(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| uint64_t A = pReloc.A() & 0xFFFF; |
| if (pReloc.type() == llvm::ELF::R_MIPS_TLS_TPREL_LO16) |
| A -= pParent.getTPOffset(); |
| else if (pReloc.type() == llvm::ELF::R_MIPS_TLS_DTPREL_LO16) |
| A -= pParent.getDTPOffset(); |
| else |
| llvm_unreachable("Unexpected relocation"); |
| |
| if (pParent.isGpDisp(pReloc.parent())) |
| pReloc.result() = A + pReloc.S() - pReloc.P() + 4; |
| else |
| pReloc.result() = A + pReloc.S(); |
| |
| return Relocator::OK; |
| } |
| |
| // R_MIPS_TLS_GD, R_MIPS_TLS_LDM |
| static MipsRelocator::Result tlsgot(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| pReloc.result() = pParent.getTLSGOTOffset(pReloc); |
| return Relocator::OK; |
| } |
| |
| static MipsRelocator::Result unsupported(MipsRelocationInfo& pReloc, |
| MipsRelocator& pParent) { |
| return Relocator::Unsupported; |
| } |
| |
| } // namespace mcld |
