Enum Operand 

#[non_exhaustive]
pub enum Operand {
    Reg(Reg),
    Imm(i64),
    Mem(Mem),
    Slot {
        slot: StackSlot,
        offset: i32,
    },
    Symbol(Symbol),
    Cond(CondCode),
    Block(BlockCall),
}

One operand of a machine instruction.

Which shapes an operand position takes is the instruction’s OperandRule; Function::push checks them.

Examples

use backend_lang::mir::{Mem, Operand};
use backend_lang::x86_64::RDI;

let ops = [
    Operand::Reg(RDI.into()),
    Operand::Imm(-1),
    Operand::Mem(Mem::base(RDI.into()).with_disp(8)),
];
assert!(matches!(ops[1], Operand::Imm(-1)));

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.

Reg(Reg)

A register, virtual or physical.

Imm(i64)

An immediate: a signed value of the operation’s width.

Mem(Mem)

Memory at an address computed from registers.

Slot

Memory in a stack slot, offset bytes into it.

Fields

slot: StackSlot

The slot.

offset: i32

Bytes from the slot’s start.

Symbol(Symbol)

A function, by name: a direct call target, or (as a memory operand of lea) the function’s address.

Cond(CondCode)

A condition code.

Block(BlockCall)

A branch target with arguments.

Implementations

impl Operand

pub const fn slot(slot: StackSlot) -> Operand

The stack slot itself (offset 0): the form block parameters, branch arguments, and copies use.

Examples

use backend_lang::mir::{Operand, StackSlot};

let s = StackSlot::new(2);
assert_eq!(Operand::slot(s), Operand::Slot { slot: s, offset: 0 });

pub const fn reg(&self) -> Option<Reg>

The register, if this is a register operand.

Examples

use backend_lang::mir::Operand;
use backend_lang::x86_64::RAX;

assert_eq!(Operand::from(RAX).reg(), Some(RAX.into()));
assert_eq!(Operand::Imm(0).reg(), None);

pub const fn is_mem(&self) -> bool

Whether the operand is memory: an address or a stack slot.

Examples

use backend_lang::mir::{Mem, Operand, StackSlot};

assert!(Operand::slot(StackSlot::new(0)).is_mem());
assert!(Operand::Mem(Mem::absolute(0)).is_mem());
assert!(!Operand::Imm(0).is_mem());

Trait Implementations

impl Clone for Operand

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 Operand

impl Debug for Operand

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

Formats the value using the given formatter.

impl Eq for Operand

impl From<BlockCall> for Operand

fn from(b: BlockCall) -> Operand

Converts to this type from the input type.

impl From<CondCode> for Operand

fn from(c: CondCode) -> Operand

Converts to this type from the input type.

impl From<Mem> for Operand

fn from(m: Mem) -> Operand

Converts to this type from the input type.

impl From<PReg> for Operand

fn from(r: PReg) -> Operand

Converts to this type from the input type.

impl From<Reg> for Operand

fn from(r: Reg) -> Operand

Converts to this type from the input type.

impl From<Symbol> for Operand

fn from(s: Symbol) -> Operand

Converts to this type from the input type.

impl Hash for Operand

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 Operand

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Operand