6024e5c395
clang 20.0.0 (based on r547379) from build 12806354. Bug: http://b/379133546 Test: N/A Change-Id: I2eb8938af55d809de674be63cb30cf27e801862b Upstream-Commit: ad834e67b1105d15ef907f6255d4c96e8e733f57
435 lines
14 KiB
C++
435 lines
14 KiB
C++
//=== i386.h - Generic JITLink i386 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 i386 objects.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_EXECUTIONENGINE_JITLINK_I386_H
|
|
#define LLVM_EXECUTIONENGINE_JITLINK_I386_H
|
|
|
|
#include "llvm/ExecutionEngine/JITLink/JITLink.h"
|
|
#include "llvm/ExecutionEngine/JITLink/TableManager.h"
|
|
|
|
namespace llvm::jitlink::i386 {
|
|
/// Represets i386 fixups
|
|
enum EdgeKind_i386 : Edge::Kind {
|
|
|
|
/// None
|
|
None = 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 32-bit PC-relative relocation.
|
|
///
|
|
/// Represents a data/control flow instruction using PC-relative addressing
|
|
/// to a target.
|
|
///
|
|
/// The fixup expression for this kind includes an implicit offset to account
|
|
/// for the PC (unlike the Delta edges) so that a PCRel32 with a target
|
|
/// T and addend zero is a call/branch to the start (offset zero) of T.
|
|
///
|
|
/// Fixup expression:
|
|
/// Fixup <- Target - (Fixup + 4) + Addend : int32
|
|
///
|
|
/// Errors:
|
|
/// - The result of the fixup expression must fit into an int32, otherwise
|
|
/// an out-of-range error will be returned.
|
|
///
|
|
PCRel32,
|
|
|
|
/// 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 16-bit PC-relative relocation.
|
|
///
|
|
/// Represents a data/control flow instruction using PC-relative addressing
|
|
/// to a target.
|
|
///
|
|
/// The fixup expression for this kind includes an implicit offset to account
|
|
/// for the PC (unlike the Delta edges) so that a PCRel16 with a target
|
|
/// T and addend zero is a call/branch to the start (offset zero) of T.
|
|
///
|
|
/// Fixup expression:
|
|
/// Fixup <- Target - (Fixup + 4) + Addend : int16
|
|
///
|
|
/// Errors:
|
|
/// - The result of the fixup expression must fit into an int16, otherwise
|
|
/// an out-of-range error will be returned.
|
|
///
|
|
PCRel16,
|
|
|
|
/// A 32-bit delta.
|
|
///
|
|
/// Delta from the fixup to the target.
|
|
///
|
|
/// Fixup expression:
|
|
/// Fixup <- Target - Fixup + Addend : int64
|
|
///
|
|
/// 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 GOT delta.
|
|
///
|
|
/// Delta from the global offset table to the target.
|
|
///
|
|
/// Fixup expression:
|
|
/// Fixup <- Target - GOTSymbol + Addend : int32
|
|
///
|
|
/// Errors:
|
|
/// - *ASSERTION* Failure to a null pointer GOTSymbol, which the GOT section
|
|
/// symbol was not been defined.
|
|
Delta32FromGOT,
|
|
|
|
/// A GOT entry offset within GOT 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
|
|
/// phase will result in an assert/unreachable during the fixup phase
|
|
RequestGOTAndTransformToDelta32FromGOT,
|
|
|
|
/// A 32-bit PC-relative branch.
|
|
///
|
|
/// Represents a PC-relative call or branch to a target. This can be used to
|
|
/// identify, record, and/or patch call sites.
|
|
///
|
|
/// The fixup expression for this kind includes an implicit offset to account
|
|
/// for the PC (unlike the Delta edges) so that a Branch32PCRel with a target
|
|
/// T and addend zero is a call/branch to the start (offset zero) of T.
|
|
///
|
|
/// Fixup expression:
|
|
/// Fixup <- Target - (Fixup + 4) + Addend : int32
|
|
///
|
|
/// Errors:
|
|
/// - The result of the fixup expression must fit into an int32, otherwise
|
|
/// an out-of-range error will be returned.
|
|
///
|
|
BranchPCRel32,
|
|
|
|
/// A 32-bit PC-relative branch to a pointer jump stub.
|
|
///
|
|
/// The target of this relocation should be a pointer jump stub of the form:
|
|
///
|
|
/// \code{.s}
|
|
/// .text
|
|
/// jmp *tgtptr
|
|
/// ; ...
|
|
///
|
|
/// .data
|
|
/// tgtptr:
|
|
/// .quad 0
|
|
/// \endcode
|
|
///
|
|
/// This edge kind has the same fixup expression as BranchPCRel32, but further
|
|
/// identifies the call/branch as being to a pointer jump stub. For edges of
|
|
/// this kind the jump stub should not be bypassed (use
|
|
/// BranchPCRel32ToPtrJumpStubBypassable for that), but the pointer location
|
|
/// target may be recorded to allow manipulation at runtime.
|
|
///
|
|
/// Fixup expression:
|
|
/// Fixup <- Target - Fixup + Addend - 4 : int32
|
|
///
|
|
/// Errors:
|
|
/// - The result of the fixup expression must fit into an int32, otherwise
|
|
/// an out-of-range error will be returned.
|
|
///
|
|
BranchPCRel32ToPtrJumpStub,
|
|
|
|
/// A relaxable version of BranchPCRel32ToPtrJumpStub.
|
|
///
|
|
/// The edge kind has the same fixup expression as BranchPCRel32ToPtrJumpStub,
|
|
/// but identifies the call/branch as being to a pointer jump stub that may be
|
|
/// bypassed with a direct jump to the ultimate target if the ultimate target
|
|
/// is within range of the fixup location.
|
|
///
|
|
/// Fixup expression:
|
|
/// Fixup <- Target - Fixup + Addend - 4: int32
|
|
///
|
|
/// Errors:
|
|
/// - The result of the fixup expression must fit into an int32, otherwise
|
|
/// an out-of-range error will be returned.
|
|
///
|
|
BranchPCRel32ToPtrJumpStubBypassable,
|
|
};
|
|
|
|
/// Returns a string name for the given i386 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 i386;
|
|
using namespace llvm::support;
|
|
|
|
char *BlockWorkingMem = B.getAlreadyMutableContent().data();
|
|
char *FixupPtr = BlockWorkingMem + E.getOffset();
|
|
auto FixupAddress = B.getAddress() + E.getOffset();
|
|
|
|
switch (E.getKind()) {
|
|
case i386::None: {
|
|
break;
|
|
}
|
|
|
|
case i386::Pointer32: {
|
|
uint32_t Value = E.getTarget().getAddress().getValue() + E.getAddend();
|
|
*(ulittle32_t *)FixupPtr = Value;
|
|
break;
|
|
}
|
|
|
|
case i386::PCRel32: {
|
|
int32_t Value =
|
|
E.getTarget().getAddress() - (FixupAddress + 4) + E.getAddend();
|
|
*(little32_t *)FixupPtr = Value;
|
|
break;
|
|
}
|
|
|
|
case i386::Pointer16: {
|
|
uint32_t Value = E.getTarget().getAddress().getValue() + E.getAddend();
|
|
if (LLVM_LIKELY(isUInt<16>(Value)))
|
|
*(ulittle16_t *)FixupPtr = Value;
|
|
else
|
|
return makeTargetOutOfRangeError(G, B, E);
|
|
break;
|
|
}
|
|
|
|
case i386::PCRel16: {
|
|
int32_t Value =
|
|
E.getTarget().getAddress() - (FixupAddress + 4) + E.getAddend();
|
|
if (LLVM_LIKELY(isInt<16>(Value)))
|
|
*(little16_t *)FixupPtr = Value;
|
|
else
|
|
return makeTargetOutOfRangeError(G, B, E);
|
|
break;
|
|
}
|
|
|
|
case i386::Delta32: {
|
|
int32_t Value = E.getTarget().getAddress() - FixupAddress + E.getAddend();
|
|
*(little32_t *)FixupPtr = Value;
|
|
break;
|
|
}
|
|
|
|
case i386::Delta32FromGOT: {
|
|
assert(GOTSymbol && "No GOT section symbol");
|
|
int32_t Value =
|
|
E.getTarget().getAddress() - GOTSymbol->getAddress() + E.getAddend();
|
|
*(little32_t *)FixupPtr = Value;
|
|
break;
|
|
}
|
|
|
|
case i386::BranchPCRel32:
|
|
case i386::BranchPCRel32ToPtrJumpStub:
|
|
case i386::BranchPCRel32ToPtrJumpStubBypassable: {
|
|
int32_t Value =
|
|
E.getTarget().getAddress() - (FixupAddress + 4) + E.getAddend();
|
|
*(little32_t *)FixupPtr = Value;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return make_error<JITLinkError>(
|
|
"In graph " + G.getName() + ", section " + B.getSection().getName() +
|
|
" unsupported edge kind " + getEdgeKindName(E.getKind()));
|
|
}
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
/// i386 pointer size.
|
|
constexpr uint32_t PointerSize = 4;
|
|
|
|
/// i386 null pointer content.
|
|
extern const char NullPointerContent[PointerSize];
|
|
|
|
/// i386 pointer jump stub content.
|
|
///
|
|
/// Contains the instruction sequence for an indirect jump via an in-memory
|
|
/// pointer:
|
|
/// jmpq *ptr
|
|
extern const char PointerJumpStubContent[6];
|
|
|
|
/// Creates a new pointer block in the given section and returns an anonymous
|
|
/// symbol pointing to it.
|
|
///
|
|
/// If InitialTarget is given then an Pointer32 relocation will be added to the
|
|
/// block pointing at InitialTarget.
|
|
///
|
|
/// The pointer block will have the following default values:
|
|
/// alignment: 32-bit
|
|
/// alignment-offset: 0
|
|
/// address: highest allowable (~7U)
|
|
inline Symbol &createAnonymousPointer(LinkGraph &G, Section &PointerSection,
|
|
Symbol *InitialTarget = nullptr,
|
|
uint64_t InitialAddend = 0) {
|
|
auto &B = G.createContentBlock(PointerSection, NullPointerContent,
|
|
orc::ExecutorAddr(), 8, 0);
|
|
if (InitialTarget)
|
|
B.addEdge(Pointer32, 0, *InitialTarget, InitialAddend);
|
|
return G.addAnonymousSymbol(B, 0, PointerSize, false, false);
|
|
}
|
|
|
|
/// Create a jump stub block that jumps via the pointer at the given symbol.
|
|
///
|
|
/// The stub block will have the following default values:
|
|
/// alignment: 8-bit
|
|
/// alignment-offset: 0
|
|
/// address: highest allowable: (~5U)
|
|
inline Block &createPointerJumpStubBlock(LinkGraph &G, Section &StubSection,
|
|
Symbol &PointerSymbol) {
|
|
auto &B = G.createContentBlock(StubSection, PointerJumpStubContent,
|
|
orc::ExecutorAddr(), 8, 0);
|
|
B.addEdge(Pointer32,
|
|
// Offset is 2 because the the first 2 bytes of the
|
|
// jump stub block are {0xff, 0x25} -- an indirect absolute
|
|
// jump.
|
|
2, PointerSymbol, 0);
|
|
return B;
|
|
}
|
|
|
|
/// Create a jump stub that jumps via the pointer at the given symbol and
|
|
/// an anonymous symbol pointing to it. Return the anonymous symbol.
|
|
///
|
|
/// The stub block will be created by createPointerJumpStubBlock.
|
|
inline Symbol &createAnonymousPointerJumpStub(LinkGraph &G,
|
|
Section &StubSection,
|
|
Symbol &PointerSymbol) {
|
|
return G.addAnonymousSymbol(
|
|
createPointerJumpStubBlock(G, StubSection, PointerSymbol), 0, 6, 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 i386::Delta32FromGOT: {
|
|
// we need to make sure that the GOT section exists, but don't otherwise
|
|
// need to fix up this edge
|
|
getGOTSection(G);
|
|
return false;
|
|
}
|
|
case i386::RequestGOTAndTransformToDelta32FromGOT:
|
|
KindToSet = i386::Delta32FromGOT;
|
|
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);
|
|
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() == i386::BranchPCRel32 && !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";
|
|
});
|
|
// Set the edge kind to Branch32ToPtrJumpStubBypassable to enable it to
|
|
// be optimized when the target is in-range.
|
|
E.setKind(i386::BranchPCRel32ToPtrJumpStubBypassable);
|
|
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 (!PLTSection)
|
|
PLTSection = &G.createSection(getSectionName(),
|
|
orc::MemProt::Read | orc::MemProt::Exec);
|
|
return *PLTSection;
|
|
}
|
|
|
|
GOTTableManager &GOT;
|
|
Section *PLTSection = nullptr;
|
|
};
|
|
|
|
/// Optimize the GOT and Stub relocations if the edge target address is in range
|
|
/// 1. PCRel32GOTLoadRelaxable. For this edge kind, if the target is in range,
|
|
/// then replace GOT load with lea. (THIS IS UNIMPLEMENTED RIGHT NOW!)
|
|
/// 2. BranchPCRel32ToPtrJumpStubRelaxable. For this edge kind, if the target is
|
|
/// in range, replace a indirect jump by plt stub with a direct jump to the
|
|
/// target
|
|
Error optimizeGOTAndStubAccesses(LinkGraph &G);
|
|
|
|
} // namespace llvm::jitlink::i386
|
|
|
|
#endif // LLVM_EXECUTIONENGINE_JITLINK_I386_H
|