Enum RelocationKind 

#[non_exhaustive]
pub enum RelocationKind {
    X86_64(X86_64Reloc),
    Aarch64(Aarch64Reloc),
}

How a relocation patches its bytes: an architecture-specific kind.

Kinds are named for what they compute, not for one format’s numbering, so each writer maps them to its own relocation types. Build one from the architecture enum with From.

Examples

use object_lang::{Aarch64Reloc, Architecture, RelocationKind, X86_64Reloc};

let x = RelocationKind::from(X86_64Reloc::Abs64);
let a = RelocationKind::from(Aarch64Reloc::AdrPrelPgHi21);
assert_eq!(x.architecture(), Architecture::X86_64);
assert_eq!(a.architecture(), Architecture::Aarch64);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

X86_64(X86_64Reloc)

An x86-64 relocation.

Aarch64(Aarch64Reloc)

An AArch64 relocation.

Implementations

impl RelocationKind

pub const fn architecture(self) -> Architecture

The architecture this kind belongs to. An object may only carry relocations of its own architecture.

Examples

use object_lang::{Architecture, RelocationKind, X86_64Reloc};

assert_eq!(RelocationKind::from(X86_64Reloc::Plt32).architecture(), Architecture::X86_64);

pub const fn size(self) -> u64

The number of bytes the relocation patches, starting at its offset.

Examples

use object_lang::{Aarch64Reloc, RelocationKind, X86_64Reloc};

assert_eq!(RelocationKind::from(X86_64Reloc::Abs64).size(), 8);
assert_eq!(RelocationKind::from(X86_64Reloc::Plt32).size(), 4);
assert_eq!(RelocationKind::from(Aarch64Reloc::Call26).size(), 4);

pub const fn is_instruction(self) -> bool

Whether the relocation patches an instruction’s immediate field rather than a plain data word. AArch64 instructions are 4-byte aligned, so such a relocation’s offset must be a multiple of 4.

Examples

use object_lang::{Aarch64Reloc, RelocationKind, X86_64Reloc};

assert!(RelocationKind::from(Aarch64Reloc::AddAbsLo12Nc).is_instruction());
assert!(!RelocationKind::from(Aarch64Reloc::Prel32).is_instruction());
assert!(!RelocationKind::from(X86_64Reloc::Pc32).is_instruction());

Trait Implementations

impl Clone for RelocationKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RelocationKind

impl Debug for RelocationKind

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

Formats the value using the given formatter.

impl Eq for RelocationKind

impl From<Aarch64Reloc> for RelocationKind

fn from(kind: Aarch64Reloc) -> Self

Converts to this type from the input type.

impl From<X86_64Reloc> for RelocationKind

fn from(kind: X86_64Reloc) -> Self

Converts to this type from the input type.

impl Hash for RelocationKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RelocationKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RelocationKind