Struct Relocation 

#[non_exhaustive]
pub struct Relocation {
    pub offset: u64,
    pub kind: RelocationKind,
    pub target: RelocationTarget,
    pub addend: i64,
}

A place in a section to patch: the bytes at offset receive the value kind computes from the address of target plus addend.

The addend is always explicit, whatever format the relocation is written in.

Examples

use object_lang::{Relocation, RelocationKind, RelocationTarget, SymbolId, X86_64Reloc};

// `call callee` is e8 followed by a 32-bit displacement from the next instruction.
let reloc = Relocation::new(1, X86_64Reloc::Plt32, RelocationTarget::Symbol(target), -4);
assert_eq!(reloc.kind, RelocationKind::X86_64(X86_64Reloc::Plt32));
assert_eq!(reloc.addend, -4);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

offset: u64

Where the patched bytes start, as an offset within the section.

kind: RelocationKind

How the bytes are computed and how many are patched.

target: RelocationTarget

The symbol or section whose address is used.

addend: i64

A constant added to the target’s address.

Implementations

impl Relocation

pub fn new( offset: u64, kind: impl Into<RelocationKind>, target: RelocationTarget, addend: i64, ) -> Self

A relocation at offset of kind, against target, with addend.

Examples

use object_lang::{Aarch64Reloc, Relocation, RelocationTarget};

let r = Relocation::new(8, Aarch64Reloc::Abs64, RelocationTarget::Section(data), 16);
assert_eq!((r.offset, r.addend), (8, 16));

Trait Implementations

impl Clone for Relocation

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 Relocation

impl Debug for Relocation

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

Formats the value using the given formatter.

impl Eq for Relocation

impl Hash for Relocation

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 Relocation

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Relocation