Enum RelocationKind

#[repr(u8)]
pub enum RelocationKind {
    Abs4 = 0,
    Abs8 = 1,
    X86PCRel4 = 2,
    X86PCRel8 = 3,
    X86CallPCRel4 = 4,
    X86CallPLTRel4 = 5,
    X86GOTPCRel4 = 6,
    Aarch64AdrPrelLo21 = 7,
    Aarch64AdrPrelPgHi21 = 8,
    Aarch64AddAbsLo12Nc = 9,
    Aarch64Ldst128AbsLo12Nc = 10,
    Aarch64Ldst64AbsLo12Nc = 11,
    Arm32Call = 12,
    Arm64Call = 13,
    Arm64Movw0 = 14,
    Arm64Movw1 = 15,
    Arm64Movw2 = 16,
    Arm64Movw3 = 17,
    RiscvPCRelHi20 = 18,
    RiscvPCRelLo12I = 19,
    RiscvCall = 20,
    LArchAbsHi20 = 21,
    LArchAbsLo12 = 22,
    LArchAbs64Hi12 = 23,
    LArchAbs64Lo20 = 24,
    ElfX86_64TlsGd = 25,
}

Relocation kinds for every ISA.

Variants

Abs4 = 0

absolute 4-byte

Abs8 = 1

absolute 8-byte

X86PCRel4 = 2

x86 PC-relative 4-byte

X86PCRel8 = 3

x86 PC-relative 8-byte

X86CallPCRel4 = 4

x86 call to PC-relative 4-byte

X86CallPLTRel4 = 5

x86 call to PLT-relative 4-byte

X86GOTPCRel4 = 6

x86 GOT PC-relative 4-byte

Aarch64AdrPrelLo21 = 7

R_AARCH64_ADR_PREL_LO21

Aarch64AdrPrelPgHi21 = 8

R_AARCH64_ADR_PREL_PG_HI21

Aarch64AddAbsLo12Nc = 9

R_AARCH64_ADD_ABS_LO12_NC

Aarch64Ldst128AbsLo12Nc = 10

R_AARCH64_LDST128_ABS_LO12_NC

Aarch64Ldst64AbsLo12Nc = 11

R_AARCH64_LDST64_ABS_LO12_NC

Arm32Call = 12

Arm32 call target

Arm64Call = 13

Arm64 call target

Arm64Movw0 = 14

Arm64 movk/z part 0

Arm64Movw1 = 15

Arm64 movk/z part 1

Arm64Movw2 = 16

Arm64 movk/z part 2

Arm64Movw3 = 17

Arm64 movk/z part 3

RiscvPCRelHi20 = 18

RISC-V PC-relative high 20bit

RiscvPCRelLo12I = 19

RISC-V PC-relative low 12bit, I-type

RiscvCall = 20

RISC-V call target

LArchAbsHi20 = 21

LoongArch absolute high 20bit

LArchAbsLo12 = 22

LoongArch absolute low 12bit

LArchAbs64Hi12 = 23

LoongArch absolute high 12bit

LArchAbs64Lo20 = 24

LoongArch absolute low 20bit

ElfX86_64TlsGd = 25

Elf x86_64 32 bit signed PC relative offset to two GOT entries for GD symbol.

Trait Implementations

impl Archive for RelocationKind

type Archived = ArchivedRelocationKind

The archived representation of this type.

type Resolver = RelocationKindResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for RelocationKind

fn clone(&self) -> RelocationKind

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RelocationKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<RelocationKind, __D> for Archived<RelocationKind>

fn deserialize( &self, deserializer: &mut __D, ) -> Result<RelocationKind, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Display for RelocationKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Display trait implementation drops the arch, since its used in contexts where the arch is already unambiguous, e.g. clif syntax with isa specified. In other contexts, use Debug.

impl PartialEq<ArchivedRelocationKind> for RelocationKind

fn eq(&self, other: &ArchivedRelocationKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<RelocationKind> for ArchivedRelocationKind

fn eq(&self, other: &RelocationKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for RelocationKind

fn eq(&self, other: &RelocationKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<__S: Fallible + ?Sized> Serialize<__S> for RelocationKind

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Copy for RelocationKind

impl Eq for RelocationKind

impl StructuralPartialEq for RelocationKind