Struct Mem 

pub struct Mem {
    pub base: Option<Operand>,
    pub index: Option<Operand>,
    pub scale: u8,
    pub disp: i32,
    pub symbol: Option<Symbol>,
}

A memory addressing mode as a caller writes one down.

The difference from Amode is that the registers are here rather than in the operand vector, which is what crate::InstBuilder::mem fixes. Keeping the two apart is what lets the operand indices in an Amode be an invariant of the builder rather than something every caller has to get right.

Fields

base: Option<Operand>

The base register, which the instruction reads.

index: Option<Operand>

The index register, which the instruction reads.

scale: u8

What the index is multiplied by.

disp: i32

The constant added to the address.

symbol: Option<Symbol>

The symbol the address is relative to.

Implementations

impl Mem

pub const fn at(base: Operand) -> Self

The address in that register.

pub const fn of(symbol: Symbol) -> Self

The address of that symbol.

pub const fn indexed(self, index: Operand, scale: u8) -> Self

The same address with an index register scaled by that much.

pub const fn plus(self, disp: i32) -> Self

The same address, that many bytes along.

Trait Implementations

impl Clone for Mem

fn clone(&self) -> Mem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Mem

impl Debug for Mem

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

Formats the value using the given formatter.

impl Default for Mem

fn default() -> Mem

Returns the “default value” for a type.

impl Eq for Mem

impl PartialEq for Mem

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Mem