Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//= 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