//===- MipsRelocator.h --------------------------------------------===//
//
// The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef TARGET_MIPS_MIPSRELOCATOR_H_
#define TARGET_MIPS_MIPSRELOCATOR_H_
#include "mcld/LD/Relocator.h"
#include "mcld/Support/GCFactory.h"
#include "mcld/Target/KeyEntryMap.h"
#include "MipsLDBackend.h"
#include <llvm/ADT/DenseMapInfo.h>
namespace mcld {
class MipsRelocationInfo;
/** \class MipsRelocator
* \brief MipsRelocator creates and destroys the Mips relocations.
*/
class MipsRelocator : public Relocator {
public:
enum ReservedEntryType {
None = 0, // no reserved entry
ReserveRel = 1, // reserve a dynamic relocation entry
ReserveGot = 2, // reserve a GOT entry
ReservePLT = 4 // reserve a PLT entry
};
typedef KeyEntryMap<ResolveInfo, PLTEntryBase> SymPLTMap;
typedef KeyEntryMap<ResolveInfo, Fragment> SymGOTPLTMap;
public:
MipsRelocator(MipsGNULDBackend& pParent, const LinkerConfig& pConfig);
/// scanRelocation - determine the empty entries are needed or not and
/// create the empty entries if needed.
/// For Mips, the GOT, GP, and dynamic relocation entries are check to create.
void scanRelocation(Relocation& pReloc,
IRBuilder& pBuilder,
Module& pModule,
LDSection& pSection,
Input& pInput);
/// initializeScan - do initialization before scan relocations in pInput
/// @return - return true for initialization success
bool initializeScan(Input& pInput);
/// finalizeScan - do finalization after scan relocations in pInput
/// @return - return true for finalization success
bool finalizeScan(Input& pInput);
/// initializeApply - do initialization before apply relocations in pInput
/// @return - return true for initialization success
bool initializeApply(Input& pInput);
/// finalizeApply - do finalization after apply relocations in pInput
/// @return - return true for finalization success
bool finalizeApply(Input& pInput);
Result applyRelocation(Relocation& pReloc);
/// getDebugStringOffset - get the offset from the relocation target. This is
/// used to get the debug string offset.
uint32_t getDebugStringOffset(Relocation& pReloc) const;
/// applyDebugStringOffset - apply the relocation target to specific offset.
/// This is used to set the debug string offset.
void applyDebugStringOffset(Relocation& pReloc, uint32_t pOffset);
const Input& getApplyingInput() const { return *m_pApplyingInput; }
MipsGNULDBackend& getTarget() { return m_Target; }
const MipsGNULDBackend& getTarget() const { return m_Target; }
/// postponeRelocation - save R_MIPS_LO16 paired relocations
/// like R_MISP_HI16 and R_MIPS_GOT16 for a future processing.
void postponeRelocation(Relocation& pReloc);
/// applyPostponedRelocations - apply all postponed relocations
/// paired with the R_MIPS_LO16 one.
void applyPostponedRelocations(MipsRelocationInfo& pLo16Reloc);
/// isGpDisp - return true if relocation is against _gp_disp symbol.
bool isGpDisp(const Relocation& pReloc) const;
/// getGPAddress - return address of _gp symbol.
Address getGPAddress();
/// getTPOffset - return TP_OFFSET against the SHF_TLS
/// section in the processing input.
Address getTPOffset();
/// getDTPOffset - return DTP_OFFSET against the SHF_TLS
/// section in the processing input.
Address getDTPOffset();
/// getGP0 - the gp value used to create the relocatable objects
/// in the processing input.
Address getGP0();
/// getLocalGOTEntry - initialize and return a local GOT entry
/// for this relocation.
Fragment& getLocalGOTEntry(MipsRelocationInfo& pReloc,
Relocation::DWord entryValue);
/// getGlobalGOTEntry - initialize and return a global GOT entry
/// for this relocation.
Fragment& getGlobalGOTEntry(MipsRelocationInfo& pReloc);
/// getTLSGOTEntry - initialize and return a TLS GOT entry
/// for this relocation.
Fragment& getTLSGOTEntry(MipsRelocationInfo& pReloc);
/// getGOTOffset - return offset of corresponded GOT entry.
Address getGOTOffset(MipsRelocationInfo& pReloc);
/// getTLSGOTOffset - return offset of corresponded TLS GOT entry.
Address getTLSGOTOffset(MipsRelocationInfo& pReloc);
/// createDynRel - initialize dynamic relocation for the relocation.
void createDynRel(MipsRelocationInfo& pReloc);
/// calcAHL - calculate combined addend used
/// by R_MIPS_HI16 and R_MIPS_GOT16 relocations.
uint64_t calcAHL(const MipsRelocationInfo& pHiReloc);
/// isN64ABI - check current ABI
bool isN64ABI() const;
const char* getName(Relocation::Type pType) const;
const SymPLTMap& getSymPLTMap() const { return m_SymPLTMap; }
SymPLTMap& getSymPLTMap() { return m_SymPLTMap; }
const SymGOTPLTMap& getSymGOTPLTMap() const { return m_SymGOTPLTMap; }
SymGOTPLTMap& getSymGOTPLTMap() { return m_SymGOTPLTMap; }
protected:
/// setupRelDynEntry - create dynamic relocation entry.
virtual void setupRel32DynEntry(FragmentRef& pFragRef, ResolveInfo* pSym) = 0;
/// setupTLSDynEntry - create DTPMOD / DTPREL relocation entries
virtual void setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym,
Relocation::Type pType) = 0;
/// isLocalReloc - handle relocation as a local symbol
bool isLocalReloc(ResolveInfo& pSym) const;
/// setupRelDynEntry - create dynamic relocation entry with specified type.
void setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym,
Relocation::Type pType);
private:
typedef llvm::DenseSet<Relocation*> RelocationSet;
typedef llvm::DenseMap<const ResolveInfo*, RelocationSet> SymRelocSetMap;
private:
MipsGNULDBackend& m_Target;
SymPLTMap m_SymPLTMap;
SymGOTPLTMap m_SymGOTPLTMap;
Input* m_pApplyingInput;
SymRelocSetMap m_PostponedRelocs;
MipsRelocationInfo* m_CurrentLo16Reloc;
private:
void scanLocalReloc(MipsRelocationInfo& pReloc,
IRBuilder& pBuilder,
const LDSection& pSection);
void scanGlobalReloc(MipsRelocationInfo& pReloc,
IRBuilder& pBuilder,
const LDSection& pSection);
/// isPostponed - relocation applying needs to be postponed.
bool isPostponed(const Relocation& pReloc) const;
/// addCopyReloc - add a copy relocation into .rel.dyn for pSym
/// @param pSym - A resolved copy symbol that defined in BSS section
void addCopyReloc(ResolveInfo& pSym);
/// defineSymbolforCopyReloc - allocate a space in BSS section and
/// and force define the copy of pSym to BSS section
/// @return the output LDSymbol of the copy symbol
LDSymbol& defineSymbolforCopyReloc(IRBuilder& pBuilder,
const ResolveInfo& pSym);
/// isRel - returns true if REL relocation record format is expected
bool isRel() const;
};
/** \class Mips32Relocator
* \brief Mips32Relocator creates and destroys the Mips 32-bit relocations.
*/
class Mips32Relocator : public MipsRelocator {
public:
Mips32Relocator(Mips32GNULDBackend& pParent, const LinkerConfig& pConfig);
private:
// MipsRelocator
void setupRel32DynEntry(FragmentRef& pFragRef, ResolveInfo* pSym);
void setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym,
Relocation::Type pType);
Size getSize(Relocation::Type pType) const;
};
/** \class Mips64Relocator
* \brief Mips64Relocator creates and destroys the Mips 64-bit relocations.
*/
class Mips64Relocator : public MipsRelocator {
public:
Mips64Relocator(Mips64GNULDBackend& pParent, const LinkerConfig& pConfig);
private:
// MipsRelocator
void setupRel32DynEntry(FragmentRef& pFragRef, ResolveInfo* pSym);
void setupTLSDynEntry(Fragment& pFrag, ResolveInfo* pSym,
Relocation::Type pType);
Size getSize(Relocation::Type pType) const;
};
} // namespace mcld
#endif // TARGET_MIPS_MIPSRELOCATOR_H_