[llvm] JITLink: Add initial SystemZ Support. (PR #144528)
Ulrich Weigand via llvm-commits
llvm-commits at lists.llvm.org
Tue Nov 11 02:38:25 PST 2025
================
@@ -0,0 +1,924 @@
+//=== systemz.h - Generic JITLink systemz 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 systemz objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_SYSTEMZ_H
+#define LLVM_EXECUTIONENGINE_JITLINK_SYSTEMZ_H
+
+#include "TableManager.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+using namespace llvm::support::endian;
+
+namespace llvm {
+namespace jitlink {
+namespace systemz {
+
+/// Represents systemz fixups and other systemz-specific edge kinds.
+enum EdgeKind_systemz : 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 plain 20-bit pointer value relocation.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target + Addend : uint20
+ ///
+ /// Errors:
+ /// - The target must reside in the low 20-bits of the address space,
+ /// otherwise an out-of-range error will be returned.
+ ///
+ Pointer20,
+
+ /// A plain 16-bit pointer value relocation.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target + Addend : uint16
+ ///
+ /// Errors:
+ /// - The target must reside in the low 16-bits of the address space,
+ /// otherwise an out-of-range error will be returned.
+ ///
+ Pointer16,
+
+ /// A plain 12-bit pointer value relocation.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target + Addend : uint12
+ ///
+ /// Errors:
+ /// - The target must reside in the low 12-bits of the address space,
+ /// otherwise an out-of-range error will be returned.
+ ///
+ Pointer12,
+
+ /// A plain 8-bit pointer value relocation.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target + Addend : uint8
+ ///
+ /// Errors:
+ /// - The target must reside in the low 8-bits of the address space,
+ /// otherwise an out-of-range error will be returned.
+ ///
+ Pointer8,
+
+ /// A 64-bit delta.
+ ///
+ /// Delta from the fixup to the target.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - Fixup + Addend : int64
+ ///
+ Delta64,
+
+ /// 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 16-bit delta.
+ ///
+ /// Delta from the fixup to the target.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - Fixup + Addend : int16
+ ///
+ /// Errors:
+ /// - The result of the fixup expression must fit into an int16, otherwise
+ /// an out-of-range error will be returned.
+ ///
+ Delta16,
+
+ /// A 32-bit delta.
+ ///
+ /// Delta from the fixup to the target.
+ ///
+ /// Fixup expression:
+ /// Fixup <- (Target - Fixup + Addend : int32) >> 1
+ ///
+ /// Errors:
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// fit into an int33, otherwise an out-of-range error will be returned.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// be multiple of 2, otherwise an alignment error will be returned.
+ ///
+ Delta32dbl,
+
+ /// A 24-bit delta.
+ ///
+ /// Delta from the fixup to the target.
+ ///
+ /// Fixup expression:
+ /// Fixup <- (Target - Fixup + Addend : int24) >> 1
+ ///
+ /// Errors:
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// fit into an int25, otherwise an out-of-range error will be returned.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// be multiple of 2, otherwise an alignment error will be returned.
+ ///
+ Delta24dbl,
+
+ /// A 16-bit delta.
+ ///
+ /// Delta from the fixup to the target.
+ ///
+ /// Fixup expression:
+ /// Fixup <- (Target - Fixup + Addend : int16) >> 1
+ ///
+ /// Errors:
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// fit into an int17, otherwise an out-of-range error will be returned.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// be multiple of 2, otherwise an alignment error will be returned.
+ ///
+ Delta16dbl,
+
+ /// A 12-bit delta.
+ ///
+ /// Delta from the fixup to the target.
+ ///
+ /// Fixup expression:
+ /// Fixup <- (Target - Fixup + Addend : int12) >> 1
+ ///
+ /// Errors:
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// fit into an int13, otherwise an out-of-range error will be returned.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// be multiple of 2, otherwise an alignment error will be returned.
+ ///
+ Delta12dbl,
+
+ /// A 64-bit negative delta.
+ ///
+ /// Delta from target back to the fixup.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Fixup - Target + Addend : int64
+ ///
+ NegDelta64,
+
+ /// 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 32-bit Delta shifted by 1.
+ ///
+ /// Delta from the fixup to the PLT slot for the target. This will lead to
+ /// creation of a PLT stub.
+ ///
+ /// Fixup expression:
+ /// Fixup <- (Target - Fixup + Addend) >> 1 : int32
+ ///
+ /// Errors:
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// fit into an int33, otherwise an out-of-range error will be returned.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// be multiple of 2, otherwise an alignment error will be returned.
+ ///
+ DeltaPLT32dbl,
+
+ /// A 24-bit Delta shifted by 1.
+ ///
+ /// Delta from the fixup to the PLT slot for the target. This will lead to
+ /// creation of a PLT stub.
+ ///
+ /// Fixup expression:
+ /// Fixup <- (Target - Fixup + Addend) >> 1 : int24
+ ///
+ /// Errors:
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// fit into an int25, otherwise an out-of-range error will be returned.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// be multiple of 2, otherwise an alignment error will be returned.
+ ///
+ DeltaPLT24dbl,
+
+ /// A 16-bit Delta shifted by 1.
+ ///
+ /// Delta from the fixup to the PLT slot for the target. This will lead to
+ /// creation of a PLT stub.
+ ///
+ /// Fixup expression:
+ /// Fixup <- (Target - Fixup + Addend) >> 1 : int16
+ ///
+ /// Errors:
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// fit into an int17, otherwise an out-of-range error will be returned.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// be multiple of 2, otherwise an alignment error will be returned.
+ ///
+ DeltaPLT16dbl,
+
+ /// A 12-bit Delta shifted by 1.
+ ///
+ /// Delta from the fixup to the PLT slot for the target. This will lead to
+ /// creation of a PLT stub.
+ ///
+ /// Fixup expression:
+ /// Fixup <- (Target - Fixup + Addend) >> 1 : int12
+ ///
+ /// Errors:
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// fit into an int13, otherwise an out-of-range error will be returned.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// be multiple of 2, otherwise an alignment error will be returned.
+ ///
+ DeltaPLT12dbl,
+
+ /// A 64-bit Delta.
+ ///
+ /// Delta from the fixup to the PLT slot for the target. This will lead to
+ /// creation of a PLT stub.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - Fixup + Addend : int64
+ ///
+ DeltaPLT64,
+
+ /// A 32-bit Delta.
+ ///
+ /// Delta from the fixup to the PLT slot for the target. This will lead to
+ /// creation of a PLT stub.
+ ///
+ /// 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.
+ ///
+ DeltaPLT32,
+
+ /// A 64-bit offset from GOT to PLT.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - GOTBase + Addend : int64
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ ///
+ Delta64PLTFromGOT,
+
+ /// A 32-bit offset from GOT to PLT.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - GOTBase + Addend : int32
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ /// - The result of the fixup expression must fit into an int32, otherwise
+ /// an out-of-range error will be returned.
+ ///
+ Delta32PLTFromGOT,
+
+ /// A 16-bit offset from GOT to PLT.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - GOTBase + Addend : int16
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ /// - The result of the fixup expression must fit into an int16, otherwise
+ /// an out-of-range error will be returned.
+ ///
+ Delta16PLTFromGOT,
+
+ /// A 64-bit offset from GOT.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - GOTBase + Addend : int64
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ ///
+ Delta64FromGOT,
+
+ /// A 32-bit offset from GOT.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - GOTBase + Addend : int32
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ /// - The result of the fixup expression must fit into an int32, otherwise
+ /// an out-of-range error will be returned.
+ ///
+ Delta32FromGOT,
+
+ /// A 16-bit offset from GOT.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - GOTBase + Addend : int16
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ /// - The result of the fixup expression must fit into an int16, otherwise
+ /// an out-of-range error will be returned.
+ ///
+ Delta16FromGOT,
+
+ /// A 20-bit offset from GOT.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - GOTBase + Addend : int20
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ /// - The result of the fixup expression must fit into an int16, otherwise
+ /// an out-of-range error will be returned.
+ ///
+ Delta20FromGOT,
+
+ /// A 12-bit offset from GOT.
+ ///
+ /// Fixup expression:
+ /// Fixup <- Target - GOTBase + Addend : int12
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ /// - The result of the fixup expression must fit into an int16, otherwise
+ /// an out-of-range error will be returned.
+ ///
+ Delta12FromGOT,
+
+ /// A GOT entry getter/constructor, transformed to Delta64FromGOT pointing
+ /// at the GOT entry for the original target.
+ ///
+ /// Indicates that this edge should be transformed into a Delta64FromGOT
+ /// 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 builder pass inserted by
+ /// default.
+ ///
+ /// Fixup expression:
+ /// NONE
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to handle edges of this kind prior to the fixup
+ ///
+ RequestGOTAndTransformToDelta64FromGOT,
+
+ /// A GOT entry getter/constructor, transformed to Delta32FromGOT pointing
+ /// at the GOT entry for the original target.
+ ///
+ /// Indicates that this edge should be transformed into a Delta32FromGOT
+ /// 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 builder pass inserted by
+ /// default.
+ ///
+ /// Fixup expression:
+ /// NONE
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to handle edges of this kind prior to the fixup
+ ///
+ RequestGOTAndTransformToDelta32FromGOT,
+
+ /// A GOT entry getter/constructor, transformed to Delta20FromGOT pointing
+ /// at the GOT entry for the original target.
+ ///
+ /// Indicates that this edge should be transformed into a Delta20FromGOT
+ /// 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 builder pass inserted by
+ /// default.
+ ///
+ /// Fixup expression:
+ /// NONE
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to handle edges of this kind prior to the fixup
+ ///
+ RequestGOTAndTransformToDelta20FromGOT,
+
+ /// A GOT entry getter/constructor, transformed to Delta16FromGOT pointing
+ /// at the GOT entry for the original target.
+ ///
+ /// Indicates that this edge should be transformed into a Delta16FromGOT
+ /// 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 builder pass inserted by
+ /// default.
+ ///
+ /// Fixup expression:
+ /// NONE
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to handle edges of this kind prior to the fixup
+ ///
+ RequestGOTAndTransformToDelta16FromGOT,
+
+ /// A GOT entry getter/constructor, transformed to Delta12FromGOT pointing
+ /// at the GOT entry for the original target.
+ ///
+ /// Indicates that this edge should be transformed into a Delta12FromGOT
+ /// 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 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.
+ ///
+ RequestGOTAndTransformToDelta12FromGOT,
+
+ /// A GOT entry getter/constructor, transformed to Delta32dbl pointing at
+ /// the GOT entry for the original target.
+ ///
+ /// Indicates that this edge should be transformed into a Delta32dbl 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 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.
+ ///
+ RequestGOTAndTransformToDelta32dbl,
+
+ /// A 32-bit Delta to GOT base.
+ ///
+ /// Fixup expression:
+ /// Fixup <- GOTBase - Fixup + Addend : int32
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ /// - The result of the fixup expression must fit into an int32, otherwise
+ /// an out-of-range error will be returned.
+ ///
+ Delta32GOTBase,
+
+ /// A 32-bit Delta to GOT base shifted by 1.
+ ///
+ /// Fixup expression:
+ /// Fixup <- (GOTBase - Fixup + Addend) >> 1 : int32
+ ///
+ /// Errors:
+ /// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
+ /// symbol was not been defined.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// fit into an int33, otherwise an out-of-range error will be returned.
+ /// - The result of the fixup expression before shifting right by 1 must
+ /// be multiple of 2, otherwise an alignment error will be returned.
+ ///
+ Delta32dblGOTBase,
+
+};
+
+/// Returns a string name for the given systemz edge. For debugging purposes
+/// only
+const char *getEdgeKindName(Edge::Kind K);
+
+/// Apply fixup expression for edge to block content.
+inline Error applyFixup(LinkGraph &G, Block &B, const Edge &E,
+ const Symbol *GOTSymbol) {
+ using namespace support;
+
+ char *BlockWorkingMem = B.getAlreadyMutableContent().data();
+ char *FixupPtr = BlockWorkingMem + E.getOffset();
+ orc::ExecutorAddr FixupAddress = B.getAddress() + E.getOffset();
+ int64_t S = E.getTarget().getAddress().getValue();
+ int64_t A = E.getAddend();
+ int64_t P = FixupAddress.getValue();
+ int64_t GOTBase = GOTSymbol ? GOTSymbol->getAddress().getValue() : 0;
+ Edge::Kind K = E.getKind();
+
+ DEBUG_WITH_TYPE("jitlink", {
+ dbgs() << " Applying fixup on " << G.getEdgeKindName(K)
+ << " edge, (S, A, P, .GOT.) = (" << formatv("{0:x}", S) << ", "
+ << formatv("{0:x}", A) << ", " << formatv("{0:x}", P) << ", "
+ << formatv("{0:x}", GOTBase) << ")\n";
+ });
+
+ const auto isAlignmentCorrect = [](uint64_t Value, int N) {
+ return (Value & (N - 1)) ? false : true;
+ };
+
+ switch (K) {
+ case Pointer64: {
+ uint64_t Value = S + A;
+ write64be(FixupPtr, Value);
+ break;
+ }
+ case Pointer32: {
+ uint64_t Value = S + A;
+ if (!LLVM_UNLIKELY(isUInt<32>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ write32be(FixupPtr, Value);
+ break;
+ }
+ case Pointer20: {
+ uint64_t Value = S + A;
+ if (!LLVM_UNLIKELY(isInt<20>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ write32be(FixupPtr, (read32be(FixupPtr) & 0xF00000FF) |
+ ((Value & 0xFFF) << 16) | ((Value & 0xFF000) >> 4));
+ break;
+ }
+ case Pointer16: {
+ uint64_t Value = S + A;
+ if (!LLVM_UNLIKELY(isUInt<16>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ write16be(FixupPtr, Value);
+ break;
+ }
+ case Pointer12: {
+ uint64_t Value = S + A;
+ if (!LLVM_UNLIKELY(isUInt<12>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ write16be(FixupPtr, (read16be(FixupPtr) & 0xF000) | Value);
+ break;
+ }
+ case Pointer8: {
+ uint64_t Value = S + A;
+ if (!LLVM_UNLIKELY(isUInt<8>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ *(uint8_t *)FixupPtr = Value;
+ break;
+ }
+ case Delta64:
+ case DeltaPLT64: {
+ int64_t Value = S + A - P;
+ write64be(FixupPtr, Value);
+ break;
+ }
+ case Delta32:
+ case DeltaPLT32: {
+ int64_t Value = S + A - P;
+ if (!LLVM_UNLIKELY(isInt<32>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ write32be(FixupPtr, Value);
+ break;
+ }
+ case Delta16: {
+ int64_t Value = S + A - P;
+ if (!LLVM_UNLIKELY(isInt<16>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ write16be(FixupPtr, Value);
+ break;
+ }
+ case NegDelta32: {
+ int64_t Value = P + A - S;
+ if (!LLVM_UNLIKELY(isInt<32>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ write32be(FixupPtr, Value);
+ break;
+ }
+ case Delta32dbl:
+ case DeltaPLT32dbl: {
+ int64_t Value = S + A - P;
+ if (!LLVM_UNLIKELY(isInt<33>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ if (!LLVM_UNLIKELY(isAlignmentCorrect(Value, 2)))
+ return makeAlignmentError(FixupAddress, Value, 2, E);
+ write32be(FixupPtr, Value >> 1);
+ break;
+ }
+ case Delta24dbl:
+ case DeltaPLT24dbl: {
+ int64_t Value = S + A - P;
+ if (!LLVM_UNLIKELY(isInt<25>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ if (!LLVM_UNLIKELY(isAlignmentCorrect(Value, 2)))
+ return makeAlignmentError(FixupAddress, Value, 2, E);
+ FixupPtr[0] = Value >> 17;
+ FixupPtr[1] = Value >> 9;
+ FixupPtr[2] = Value >> 1;
+ break;
+ }
+ case Delta16dbl:
+ case DeltaPLT16dbl: {
+ int64_t Value = S + A - P;
+ if (!LLVM_UNLIKELY(isInt<17>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ if (!LLVM_UNLIKELY(isAlignmentCorrect(Value, 2)))
+ return makeAlignmentError(FixupAddress, Value, 2, E);
+ write16be(FixupPtr, Value >> 1);
+ break;
+ }
+ case Delta12dbl:
+ case DeltaPLT12dbl: {
+ int64_t Value = S + A - P;
+ if (!LLVM_UNLIKELY(isInt<13>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ if (!LLVM_UNLIKELY(isAlignmentCorrect(Value, 2)))
+ return makeAlignmentError(FixupAddress, Value, 2, E);
+ write16be(FixupPtr,
+ (read16be(FixupPtr) & 0xF000) | ((Value >> 1) & 0x0FFF));
+ break;
+ }
+ case Delta32GOTBase: {
+ assert(GOTSymbol && "No GOT section symbol");
+ int64_t Value = GOTBase + A - P;
+ if (!LLVM_UNLIKELY(isInt<32>(Value)))
+ return makeTargetOutOfRangeError(G, B, E);
+ write32be(FixupPtr, Value);
+ break;
+ }
+ case Delta32dblGOTBase: {
+ assert(GOTSymbol && "No GOT section symbol");
+ int64_t Value = (GOTBase + A - P);
----------------
uweigand wrote:
One more set of unnecessary parentheses.
https://github.com/llvm/llvm-project/pull/144528
More information about the llvm-commits
mailing list