| //= loongarch.h - Generic JITLink loongarch edge kinds, utilities -*- 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 |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Generic utilities for graphs representing loongarch objects. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_EXECUTIONENGINE_JITLINK_LOONGARCH_H |
| #define LLVM_EXECUTIONENGINE_JITLINK_LOONGARCH_H |
| |
| #include "TableManager.h" |
| #include "llvm/ExecutionEngine/JITLink/JITLink.h" |
| #include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h" |
| |
| namespace llvm { |
| namespace jitlink { |
| namespace loongarch { |
| |
| /// Represents loongarch fixups. |
| enum EdgeKind_loongarch : Edge::Kind { |
| /// A plain 64-bit pointer value relocation. |
| /// |
| /// Fixup expression: |
| /// Fixup <- Target + Addend : uint64 |
| /// |
| Pointer64 = Edge::FirstRelocation, |
| |
| /// A plain 32-bit pointer value relocation. |
| /// |
| /// Fixup expression: |
| /// Fixup <- Target + Addend : uint32 |
| /// |
| /// Errors: |
| /// - The target must reside in the low 32-bits of the address space, |
| /// otherwise an out-of-range error will be returned. |
| /// |
| Pointer32, |
| |
| /// A 26-bit PC-relative branch. |
| /// |
| /// Represents a PC-relative call or branch to a target within +/-128Mb. The |
| /// target must be 4-byte aligned. |
| /// |
| /// Fixup expression: |
| /// Fixup <- (Target - Fixup + Addend) >> 2 : int26 |
| /// |
| /// Notes: |
| /// The '26' in the name refers to the number operand bits and follows the |
| /// naming convention used by the corresponding ELF relocations. Since the low |
| /// two bits must be zero (because of the 4-byte alignment of the target) the |
| /// operand is effectively a signed 28-bit number. |
| /// |
| /// Errors: |
| /// - The result of the unshifted part of the fixup expression must be |
| /// 4-byte aligned otherwise an alignment error will be returned. |
| /// - The result of the fixup expression must fit into an int26 otherwise an |
| /// out-of-range error will be returned. |
| /// |
| Branch26PCRel, |
| |
| /// A 32-bit delta. |
| /// |
| /// Delta from the fixup to the target. |
| /// |
| /// Fixup expression: |
| /// Fixup <- Target - Fixup + Addend : int32 |
| /// |
| /// Errors: |
| /// - The result of the fixup expression must fit into an int32, otherwise |
| /// an out-of-range error will be returned. |
| /// |
| Delta32, |
| |
| /// A 32-bit negative delta. |
| /// |
| /// Delta from the target back to the fixup. |
| /// |
| /// Fixup expression: |
| /// Fixup <- Fixup - Target + Addend : int32 |
| /// |
| /// Errors: |
| /// - The result of the fixup expression must fit into an int32, otherwise |
| /// an out-of-range error will be returned. |
| /// |
| NegDelta32, |
| |
| /// A 64-bit delta. |
| /// |
| /// Delta from the fixup to the target. |
| /// |
| /// Fixup expression: |
| /// Fixup <- Target - Fixup + Addend : int64 |
| /// |
| Delta64, |
| |
| /// The signed 20-bit delta from the fixup page to the page containing the |
| /// target. |
| /// |
| /// Fixup expression: |
| /// Fixup <- (((Target + Addend + ((Target + Addend) & 0x800)) & ~0xfff) |
| // - (Fixup & ~0xfff)) >> 12 : int20 |
| /// |
| /// Notes: |
| /// For PCALAU12I fixups. |
| /// |
| /// Errors: |
| /// - The result of the fixup expression must fit into an int20 otherwise an |
| /// out-of-range error will be returned. |
| /// |
| Page20, |
| |
| /// The 12-bit offset of the target within its page. |
| /// |
| /// Typically used to fix up ADDI/LD_W/LD_D immediates. |
| /// |
| /// Fixup expression: |
| /// Fixup <- ((Target + Addend) >> Shift) & 0xfff : int12 |
| /// |
| PageOffset12, |
| |
| /// A GOT entry getter/constructor, transformed to Page20 pointing at the GOT |
| /// entry for the original target. |
| /// |
| /// Indicates that this edge should be transformed into a Page20 targeting |
| /// the GOT entry for the edge's current target, maintaining the same addend. |
| /// A GOT entry for the target should be created if one does not already |
| /// exist. |
| /// |
| /// Edges of this kind are usually handled by a GOT/PLT builder pass inserted |
| /// by default. |
| /// |
| /// Fixup expression: |
| /// NONE |
| /// |
| /// Errors: |
| /// - *ASSERTION* Failure to handle edges of this kind prior to the fixup |
| /// phase will result in an assert/unreachable during the fixup phase. |
| /// |
| RequestGOTAndTransformToPage20, |
| |
| /// A GOT entry getter/constructor, transformed to Pageoffset12 pointing at |
| /// the GOT entry for the original target. |
| /// |
| /// Indicates that this edge should be transformed into a PageOffset12 |
| /// targeting the GOT entry for the edge's current target, maintaining the |
| /// same addend. A GOT entry for the target should be created if one does not |
| /// already exist. |
| /// |
| /// Edges of this kind are usually handled by a GOT/PLT builder pass inserted |
| /// by default. |
| /// |
| /// Fixup expression: |
| /// NONE |
| /// |
| RequestGOTAndTransformToPageOffset12, |
| }; |
| |
| /// Returns a string name for the given loongarch edge. For debugging purposes |
| /// only. |
| const char *getEdgeKindName(Edge::Kind K); |
| |
| // Returns extract bits Val[Hi:Lo]. |
| inline uint32_t extractBits(uint32_t Val, unsigned Hi, unsigned Lo) { |
| return (Val & (((1UL << (Hi + 1)) - 1))) >> Lo; |
| } |
| |
| /// Apply fixup expression for edge to block content. |
| inline Error applyFixup(LinkGraph &G, Block &B, const Edge &E) { |
| using namespace support; |
| |
| char *BlockWorkingMem = B.getAlreadyMutableContent().data(); |
| char *FixupPtr = BlockWorkingMem + E.getOffset(); |
| uint64_t FixupAddress = (B.getAddress() + E.getOffset()).getValue(); |
| uint64_t TargetAddress = E.getTarget().getAddress().getValue(); |
| int64_t Addend = E.getAddend(); |
| |
| switch (E.getKind()) { |
| case Pointer64: |
| *(ulittle64_t *)FixupPtr = TargetAddress + Addend; |
| break; |
| case Pointer32: { |
| uint64_t Value = TargetAddress + Addend; |
| if (Value > std::numeric_limits<uint32_t>::max()) |
| return makeTargetOutOfRangeError(G, B, E); |
| *(ulittle32_t *)FixupPtr = Value; |
| break; |
| } |
| case Branch26PCRel: { |
| int64_t Value = TargetAddress - FixupAddress + Addend; |
| |
| if (!isInt<28>(Value)) |
| return makeTargetOutOfRangeError(G, B, E); |
| |
| if (!isShiftedInt<26, 2>(Value)) |
| return makeAlignmentError(orc::ExecutorAddr(FixupAddress), Value, 4, E); |
| |
| uint32_t RawInstr = *(little32_t *)FixupPtr; |
| uint32_t Imm = static_cast<uint32_t>(Value >> 2); |
| uint32_t Imm15_0 = extractBits(Imm, /*Hi=*/15, /*Lo=*/0) << 10; |
| uint32_t Imm25_16 = extractBits(Imm, /*Hi=*/25, /*Lo=*/16); |
| *(little32_t *)FixupPtr = RawInstr | Imm15_0 | Imm25_16; |
| break; |
| } |
| case Delta32: { |
| int64_t Value = TargetAddress - FixupAddress + Addend; |
| |
| if (!isInt<32>(Value)) |
| return makeTargetOutOfRangeError(G, B, E); |
| *(little32_t *)FixupPtr = Value; |
| break; |
| } |
| case NegDelta32: { |
| int64_t Value = FixupAddress - TargetAddress + Addend; |
| if (!isInt<32>(Value)) |
| return makeTargetOutOfRangeError(G, B, E); |
| *(little32_t *)FixupPtr = Value; |
| break; |
| } |
| case Delta64: |
| *(little64_t *)FixupPtr = TargetAddress - FixupAddress + Addend; |
| break; |
| case Page20: { |
| uint64_t Target = TargetAddress + Addend; |
| uint64_t TargetPage = |
| (Target + (Target & 0x800)) & ~static_cast<uint64_t>(0xfff); |
| uint64_t PCPage = FixupAddress & ~static_cast<uint64_t>(0xfff); |
| |
| int64_t PageDelta = TargetPage - PCPage; |
| if (!isInt<32>(PageDelta)) |
| return makeTargetOutOfRangeError(G, B, E); |
| |
| uint32_t RawInstr = *(little32_t *)FixupPtr; |
| uint32_t Imm31_12 = extractBits(PageDelta, /*Hi=*/31, /*Lo=*/12) << 5; |
| *(little32_t *)FixupPtr = RawInstr | Imm31_12; |
| break; |
| } |
| case PageOffset12: { |
| uint64_t TargetOffset = (TargetAddress + Addend) & 0xfff; |
| |
| uint32_t RawInstr = *(ulittle32_t *)FixupPtr; |
| uint32_t Imm11_0 = TargetOffset << 10; |
| *(ulittle32_t *)FixupPtr = RawInstr | Imm11_0; |
| break; |
| } |
| default: |
| return make_error<JITLinkError>( |
| "In graph " + G.getName() + ", section " + B.getSection().getName() + |
| " unsupported edge kind " + getEdgeKindName(E.getKind())); |
| } |
| |
| return Error::success(); |
| } |
| |
| /// loongarch null pointer content. |
| extern const char NullPointerContent[8]; |
| inline ArrayRef<char> getGOTEntryBlockContent(LinkGraph &G) { |
| return {reinterpret_cast<const char *>(NullPointerContent), |
| G.getPointerSize()}; |
| } |
| |
| /// loongarch stub content. |
| /// |
| /// Contains the instruction sequence for an indirect jump via an in-memory |
| /// pointer: |
| /// pcalau12i $t8, %page20(ptr) |
| /// ld.[w/d] $t8, %pageoff12(ptr) |
| /// jr $t8 |
| constexpr size_t StubEntrySize = 12; |
| extern const uint8_t LA64StubContent[StubEntrySize]; |
| extern const uint8_t LA32StubContent[StubEntrySize]; |
| inline ArrayRef<char> getStubBlockContent(LinkGraph &G) { |
| auto StubContent = |
| G.getPointerSize() == 8 ? LA64StubContent : LA32StubContent; |
| return {reinterpret_cast<const char *>(StubContent), StubEntrySize}; |
| } |
| |
| /// Creates a new pointer block in the given section and returns an |
| /// Anonymous symobl pointing to it. |
| /// |
| /// If InitialTarget is given then an Pointer64 relocation will be added to the |
| /// block pointing at InitialTarget. |
| /// |
| /// The pointer block will have the following default values: |
| /// alignment: PointerSize |
| /// alignment-offset: 0 |
| inline Symbol &createAnonymousPointer(LinkGraph &G, Section &PointerSection, |
| Symbol *InitialTarget = nullptr, |
| uint64_t InitialAddend = 0) { |
| auto &B = G.createContentBlock(PointerSection, getGOTEntryBlockContent(G), |
| orc::ExecutorAddr(), G.getPointerSize(), 0); |
| if (InitialTarget) |
| B.addEdge(G.getPointerSize() == 8 ? Pointer64 : Pointer32, 0, |
| *InitialTarget, InitialAddend); |
| return G.addAnonymousSymbol(B, 0, G.getPointerSize(), false, false); |
| } |
| |
| /// Create a jump stub that jumps via the pointer at the given symbol and |
| /// an anonymous symbol pointing to it. Return the anonymous symbol. |
| inline Symbol &createAnonymousPointerJumpStub(LinkGraph &G, |
| Section &StubSection, |
| Symbol &PointerSymbol) { |
| Block &StubContentBlock = G.createContentBlock( |
| StubSection, getStubBlockContent(G), orc::ExecutorAddr(), 4, 0); |
| StubContentBlock.addEdge(Page20, 0, PointerSymbol, 0); |
| StubContentBlock.addEdge(PageOffset12, 4, PointerSymbol, 0); |
| return G.addAnonymousSymbol(StubContentBlock, 0, StubEntrySize, true, false); |
| } |
| |
| /// Global Offset Table Builder. |
| class GOTTableManager : public TableManager<GOTTableManager> { |
| public: |
| static StringRef getSectionName() { return "$__GOT"; } |
| |
| bool visitEdge(LinkGraph &G, Block *B, Edge &E) { |
| Edge::Kind KindToSet = Edge::Invalid; |
| switch (E.getKind()) { |
| case RequestGOTAndTransformToPage20: |
| KindToSet = Page20; |
| break; |
| case RequestGOTAndTransformToPageOffset12: |
| KindToSet = PageOffset12; |
| break; |
| default: |
| return false; |
| } |
| assert(KindToSet != Edge::Invalid && |
| "Fell through switch, but no new kind to set"); |
| DEBUG_WITH_TYPE("jitlink", { |
| dbgs() << " Fixing " << G.getEdgeKindName(E.getKind()) << " edge at " |
| << B->getFixupAddress(E) << " (" << B->getAddress() << " + " |
| << formatv("{0:x}", E.getOffset()) << ")\n"; |
| }); |
| E.setKind(KindToSet); |
| E.setTarget(getEntryForTarget(G, E.getTarget())); |
| return true; |
| } |
| |
| Symbol &createEntry(LinkGraph &G, Symbol &Target) { |
| return createAnonymousPointer(G, getGOTSection(G), &Target); |
| } |
| |
| private: |
| Section &getGOTSection(LinkGraph &G) { |
| if (!GOTSection) |
| GOTSection = &G.createSection(getSectionName(), |
| orc::MemProt::Read | orc::MemProt::Exec); |
| return *GOTSection; |
| } |
| |
| Section *GOTSection = nullptr; |
| }; |
| |
| /// Procedure Linkage Table Builder. |
| class PLTTableManager : public TableManager<PLTTableManager> { |
| public: |
| PLTTableManager(GOTTableManager &GOT) : GOT(GOT) {} |
| |
| static StringRef getSectionName() { return "$__STUBS"; } |
| |
| bool visitEdge(LinkGraph &G, Block *B, Edge &E) { |
| if (E.getKind() == Branch26PCRel && !E.getTarget().isDefined()) { |
| DEBUG_WITH_TYPE("jitlink", { |
| dbgs() << " Fixing " << G.getEdgeKindName(E.getKind()) << " edge at " |
| << B->getFixupAddress(E) << " (" << B->getAddress() << " + " |
| << formatv("{0:x}", E.getOffset()) << ")\n"; |
| }); |
| E.setTarget(getEntryForTarget(G, E.getTarget())); |
| return true; |
| } |
| return false; |
| } |
| |
| Symbol &createEntry(LinkGraph &G, Symbol &Target) { |
| return createAnonymousPointerJumpStub(G, getStubsSection(G), |
| GOT.getEntryForTarget(G, Target)); |
| } |
| |
| public: |
| Section &getStubsSection(LinkGraph &G) { |
| if (!StubsSection) |
| StubsSection = &G.createSection(getSectionName(), |
| orc::MemProt::Read | orc::MemProt::Exec); |
| return *StubsSection; |
| } |
| |
| GOTTableManager &GOT; |
| Section *StubsSection = nullptr; |
| }; |
| |
| } // namespace loongarch |
| } // namespace jitlink |
| } // namespace llvm |
| |
| #endif |