| //===- Target.h -------------------------------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLD_ELF_TARGET_H |
| #define LLD_ELF_TARGET_H |
| |
| #include "InputSection.h" |
| #include "lld/Common/ErrorHandler.h" |
| #include "llvm/Object/ELF.h" |
| #include "llvm/Support/MathExtras.h" |
| #include <array> |
| |
| namespace lld { |
| std::string toString(elf::RelType type); |
| |
| namespace elf { |
| class Defined; |
| class InputFile; |
| class Symbol; |
| |
| class TargetInfo { |
| public: |
| virtual uint32_t calcEFlags() const { return 0; } |
| virtual RelExpr getRelExpr(RelType type, const Symbol &s, |
| const uint8_t *loc) const = 0; |
| virtual RelType getDynRel(RelType type) const { return 0; } |
| virtual void writeGotPltHeader(uint8_t *buf) const {} |
| virtual void writeGotHeader(uint8_t *buf) const {} |
| virtual void writeGotPlt(uint8_t *buf, const Symbol &s) const {}; |
| virtual void writeIgotPlt(uint8_t *buf, const Symbol &s) const; |
| virtual int64_t getImplicitAddend(const uint8_t *buf, RelType type) const; |
| virtual int getTlsGdRelaxSkip(RelType type) const { return 1; } |
| |
| // If lazy binding is supported, the first entry of the PLT has code |
| // to call the dynamic linker to resolve PLT entries the first time |
| // they are called. This function writes that code. |
| virtual void writePltHeader(uint8_t *buf) const {} |
| |
| virtual void writePlt(uint8_t *buf, uint64_t gotEntryAddr, |
| uint64_t pltEntryAddr, int32_t index, |
| unsigned relOff) const {} |
| virtual void addPltHeaderSymbols(InputSection &isec) const {} |
| virtual void addPltSymbols(InputSection &isec, uint64_t off) const {} |
| |
| // Returns true if a relocation only uses the low bits of a value such that |
| // all those bits are in the same page. For example, if the relocation |
| // only uses the low 12 bits in a system with 4k pages. If this is true, the |
| // bits will always have the same value at runtime and we don't have to emit |
| // a dynamic relocation. |
| virtual bool usesOnlyLowPageBits(RelType type) const; |
| |
| // Decide whether a Thunk is needed for the relocation from File |
| // targeting S. |
| virtual bool needsThunk(RelExpr expr, RelType relocType, |
| const InputFile *file, uint64_t branchAddr, |
| const Symbol &s) const; |
| |
| // On systems with range extensions we place collections of Thunks at |
| // regular spacings that enable the majority of branches reach the Thunks. |
| // a value of 0 means range extension thunks are not supported. |
| virtual uint32_t getThunkSectionSpacing() const { return 0; } |
| |
| // The function with a prologue starting at Loc was compiled with |
| // -fsplit-stack and it calls a function compiled without. Adjust the prologue |
| // to do the right thing. See https://gcc.gnu.org/wiki/SplitStacks. |
| // The symbols st_other flags are needed on PowerPC64 for determining the |
| // offset to the split-stack prologue. |
| virtual bool adjustPrologueForCrossSplitStack(uint8_t *loc, uint8_t *end, |
| uint8_t stOther) const; |
| |
| // Return true if we can reach dst from src with RelType type. |
| virtual bool inBranchRange(RelType type, uint64_t src, |
| uint64_t dst) const; |
| |
| virtual void relocateOne(uint8_t *loc, RelType type, uint64_t val) const = 0; |
| |
| virtual ~TargetInfo(); |
| |
| unsigned defaultCommonPageSize = 4096; |
| unsigned defaultMaxPageSize = 4096; |
| |
| uint64_t getImageBase() const; |
| |
| // True if _GLOBAL_OFFSET_TABLE_ is relative to .got.plt, false if .got. |
| bool gotBaseSymInGotPlt = true; |
| |
| RelType copyRel; |
| RelType gotRel; |
| RelType noneRel; |
| RelType pltRel; |
| RelType relativeRel; |
| RelType iRelativeRel; |
| RelType symbolicRel; |
| RelType tlsDescRel; |
| RelType tlsGotRel; |
| RelType tlsModuleIndexRel; |
| RelType tlsOffsetRel; |
| unsigned pltEntrySize; |
| unsigned pltHeaderSize; |
| |
| // At least on x86_64 positions 1 and 2 are used by the first plt entry |
| // to support lazy loading. |
| unsigned gotPltHeaderEntriesNum = 3; |
| |
| // On PPC ELF V2 abi, the first entry in the .got is the .TOC. |
| unsigned gotHeaderEntriesNum = 0; |
| |
| bool needsThunks = false; |
| |
| // A 4-byte field corresponding to one or more trap instructions, used to pad |
| // executable OutputSections. |
| std::array<uint8_t, 4> trapInstr; |
| |
| // If a target needs to rewrite calls to __morestack to instead call |
| // __morestack_non_split when a split-stack enabled caller calls a |
| // non-split-stack callee this will return true. Otherwise returns false. |
| bool needsMoreStackNonSplit = true; |
| |
| virtual RelExpr adjustRelaxExpr(RelType type, const uint8_t *data, |
| RelExpr expr) const; |
| virtual void relaxGot(uint8_t *loc, RelType type, uint64_t val) const; |
| virtual void relaxTlsGdToIe(uint8_t *loc, RelType type, uint64_t val) const; |
| virtual void relaxTlsGdToLe(uint8_t *loc, RelType type, uint64_t val) const; |
| virtual void relaxTlsIeToLe(uint8_t *loc, RelType type, uint64_t val) const; |
| virtual void relaxTlsLdToLe(uint8_t *loc, RelType type, uint64_t val) const; |
| |
| protected: |
| // On FreeBSD x86_64 the first page cannot be mmaped. |
| // On Linux that is controled by vm.mmap_min_addr. At least on some x86_64 |
| // installs that is 65536, so the first 15 pages cannot be used. |
| // Given that, the smallest value that can be used in here is 0x10000. |
| uint64_t defaultImageBase = 0x10000; |
| }; |
| |
| TargetInfo *getAArch64TargetInfo(); |
| TargetInfo *getAMDGPUTargetInfo(); |
| TargetInfo *getARMTargetInfo(); |
| TargetInfo *getAVRTargetInfo(); |
| TargetInfo *getHexagonTargetInfo(); |
| TargetInfo *getMSP430TargetInfo(); |
| TargetInfo *getPPC64TargetInfo(); |
| TargetInfo *getPPCTargetInfo(); |
| TargetInfo *getRISCVTargetInfo(); |
| TargetInfo *getSPARCV9TargetInfo(); |
| TargetInfo *getX86TargetInfo(); |
| TargetInfo *getX86_64TargetInfo(); |
| template <class ELFT> TargetInfo *getMipsTargetInfo(); |
| |
| struct ErrorPlace { |
| InputSectionBase *isec; |
| std::string loc; |
| }; |
| |
| // Returns input section and corresponding source string for the given location. |
| ErrorPlace getErrorPlace(const uint8_t *loc); |
| |
| static inline std::string getErrorLocation(const uint8_t *loc) { |
| return getErrorPlace(loc).loc; |
| } |
| |
| void writePPC32GlinkSection(uint8_t *buf, size_t numEntries); |
| |
| bool tryRelaxPPC64TocIndirection(RelType type, const Relocation &rel, |
| uint8_t *bufLoc); |
| unsigned getPPCDFormOp(unsigned secondaryOp); |
| |
| // In the PowerPC64 Elf V2 abi a function can have 2 entry points. The first |
| // is a global entry point (GEP) which typically is used to initialize the TOC |
| // pointer in general purpose register 2. The second is a local entry |
| // point (LEP) which bypasses the TOC pointer initialization code. The |
| // offset between GEP and LEP is encoded in a function's st_other flags. |
| // This function will return the offset (in bytes) from the global entry-point |
| // to the local entry-point. |
| unsigned getPPC64GlobalEntryToLocalEntryOffset(uint8_t stOther); |
| |
| // Returns true if a relocation is a small code model relocation that accesses |
| // the .toc section. |
| bool isPPC64SmallCodeModelTocReloc(RelType type); |
| |
| uint64_t getPPC64TocBase(); |
| uint64_t getAArch64Page(uint64_t expr); |
| |
| extern const TargetInfo *target; |
| TargetInfo *getTarget(); |
| |
| template <class ELFT> bool isMipsPIC(const Defined *sym); |
| |
| static inline void reportRangeError(uint8_t *loc, RelType type, const Twine &v, |
| int64_t min, uint64_t max) { |
| ErrorPlace errPlace = getErrorPlace(loc); |
| StringRef hint; |
| if (errPlace.isec && errPlace.isec->name.startswith(".debug")) |
| hint = "; consider recompiling with -fdebug-types-section to reduce size " |
| "of debug sections"; |
| |
| errorOrWarn(errPlace.loc + "relocation " + lld::toString(type) + |
| " out of range: " + v.str() + " is not in [" + Twine(min).str() + |
| ", " + Twine(max).str() + "]" + hint); |
| } |
| |
| // Make sure that V can be represented as an N bit signed integer. |
| inline void checkInt(uint8_t *loc, int64_t v, int n, RelType type) { |
| if (v != llvm::SignExtend64(v, n)) |
| reportRangeError(loc, type, Twine(v), llvm::minIntN(n), llvm::maxIntN(n)); |
| } |
| |
| // Make sure that V can be represented as an N bit unsigned integer. |
| inline void checkUInt(uint8_t *loc, uint64_t v, int n, RelType type) { |
| if ((v >> n) != 0) |
| reportRangeError(loc, type, Twine(v), 0, llvm::maxUIntN(n)); |
| } |
| |
| // Make sure that V can be represented as an N bit signed or unsigned integer. |
| inline void checkIntUInt(uint8_t *loc, uint64_t v, int n, RelType type) { |
| // For the error message we should cast V to a signed integer so that error |
| // messages show a small negative value rather than an extremely large one |
| if (v != (uint64_t)llvm::SignExtend64(v, n) && (v >> n) != 0) |
| reportRangeError(loc, type, Twine((int64_t)v), llvm::minIntN(n), |
| llvm::maxUIntN(n)); |
| } |
| |
| inline void checkAlignment(uint8_t *loc, uint64_t v, int n, RelType type) { |
| if ((v & (n - 1)) != 0) |
| error(getErrorLocation(loc) + "improper alignment for relocation " + |
| lld::toString(type) + ": 0x" + llvm::utohexstr(v) + |
| " is not aligned to " + Twine(n) + " bytes"); |
| } |
| |
| // Endianness-aware read/write. |
| inline uint16_t read16(const void *p) { |
| return llvm::support::endian::read16(p, config->endianness); |
| } |
| |
| inline uint32_t read32(const void *p) { |
| return llvm::support::endian::read32(p, config->endianness); |
| } |
| |
| inline uint64_t read64(const void *p) { |
| return llvm::support::endian::read64(p, config->endianness); |
| } |
| |
| inline void write16(void *p, uint16_t v) { |
| llvm::support::endian::write16(p, v, config->endianness); |
| } |
| |
| inline void write32(void *p, uint32_t v) { |
| llvm::support::endian::write32(p, v, config->endianness); |
| } |
| |
| inline void write64(void *p, uint64_t v) { |
| llvm::support::endian::write64(p, v, config->endianness); |
| } |
| } // namespace elf |
| } // namespace lld |
| |
| #endif |