Struct Reloc 

#[non_exhaustive]
pub struct Reloc {
    pub offset: usize,
    pub kind: RelocKind,
    pub symbol: String,
    pub addend: i64,
}

A place in the code that refers to a symbol defined elsewhere (declared with Emitter::declare_external): the bytes at offset receive the value kind computes from the symbol’s address and addend. The bytes hold zero until a linker patches them.

Examples

use backend_lang::mir::Function;
use backend_lang::x86_64::{op, Emitter, RelocKind, SYSV};

let mut f = Function::new("f", &SYSV);
f.omit_frame_pointer();
let b = f.block()?;
let puts = f.symbol("puts")?;
f.push(b, op::CALL, &[puts.into()])?;
f.push(b, op::RET, &[])?;
let mut e = Emitter::new();
e.declare_external("puts")?;
e.function(&f)?;
let p = e.finish()?;
let r = &p.relocations()[0];
assert_eq!((r.kind, r.symbol.as_str(), r.addend), (RelocKind::Call32, "puts", -4));
// The field follows the `call` opcode and holds zero until linked.
assert_eq!(p.bytes()[r.offset - 1..r.offset + 4], [0xE8, 0, 0, 0, 0]);

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: usize

Where the patched bytes start, from the start of the code.

kind: RelocKind

What is computed.

symbol: String

The symbol whose address is used.

addend: i64

The constant added to the address.

Implementations

impl Reloc

pub fn new(offset: usize, kind: RelocKind, symbol: &str, addend: i64) -> Reloc

A relocation at offset of kind against symbol plus addend.

Examples

use backend_lang::x86_64::{Reloc, RelocKind};

let r = Reloc::new(8, RelocKind::Abs64, "table", 16);
assert_eq!(r.addend, 16);

Trait Implementations

impl Clone for Reloc

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Reloc

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

Formats the value using the given formatter.

impl Eq for Reloc

impl Hash for Reloc

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 Reloc

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Reloc