Enum InstructionFormat

pub enum InstructionFormat {
    AtomicCas,
    AtomicRmw,
    Binary,
    BinaryImm64,
    BinaryImm8,
    BranchTable,
    Brif,
    Call,
    CallIndirect,
    CondTrap,
    DynamicStackLoad,
    DynamicStackStore,
    FloatCompare,
    FuncAddr,
    IntAddTrap,
    IntCompare,
    IntCompareImm,
    Jump,
    Load,
    LoadNoOffset,
    MultiAry,
    NullAry,
    Shuffle,
    StackLoad,
    StackStore,
    Store,
    StoreNoOffset,
    Ternary,
    TernaryImm8,
    Trap,
    Unary,
    UnaryConst,
    UnaryGlobalValue,
    UnaryIeee32,
    UnaryIeee64,
    UnaryImm,
}

An instruction format

Every opcode has a corresponding instruction format which is represented by both the InstructionFormat and the InstructionData enums.

Variants

AtomicCas

AtomicCas(imms=(flags: ir::MemFlags), vals=3, blocks=0)

AtomicRmw

AtomicRmw(imms=(flags: ir::MemFlags, op: ir::AtomicRmwOp), vals=2, blocks=0)

Binary

Binary(imms=(), vals=2, blocks=0)

BinaryImm64

BinaryImm64(imms=(imm: ir::immediates::Imm64), vals=1, blocks=0)

BinaryImm8

BinaryImm8(imms=(imm: ir::immediates::Uimm8), vals=1, blocks=0)

BranchTable

BranchTable(imms=(table: ir::JumpTable), vals=1, blocks=0)

Brif

Brif(imms=(), vals=1, blocks=2)

Call

Call(imms=(func_ref: ir::FuncRef), vals=0, blocks=0)

CallIndirect

CallIndirect(imms=(sig_ref: ir::SigRef), vals=1, blocks=0)

CondTrap

CondTrap(imms=(code: ir::TrapCode), vals=1, blocks=0)

DynamicStackLoad

DynamicStackLoad(imms=(dynamic_stack_slot: ir::DynamicStackSlot), vals=0, blocks=0)

DynamicStackStore

DynamicStackStore(imms=(dynamic_stack_slot: ir::DynamicStackSlot), vals=1, blocks=0)

FloatCompare

FloatCompare(imms=(cond: ir::condcodes::FloatCC), vals=2, blocks=0)

FuncAddr

FuncAddr(imms=(func_ref: ir::FuncRef), vals=0, blocks=0)

IntAddTrap

IntAddTrap(imms=(code: ir::TrapCode), vals=2, blocks=0)

IntCompare

IntCompare(imms=(cond: ir::condcodes::IntCC), vals=2, blocks=0)

IntCompareImm

IntCompareImm(imms=(cond: ir::condcodes::IntCC, imm: ir::immediates::Imm64), vals=1, blocks=0)

Jump

Jump(imms=(), vals=0, blocks=1)

Load

Load(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=1, blocks=0)

LoadNoOffset

LoadNoOffset(imms=(flags: ir::MemFlags), vals=1, blocks=0)

MultiAry

MultiAry(imms=(), vals=0, blocks=0)

NullAry

NullAry(imms=(), vals=0, blocks=0)

Shuffle

Shuffle(imms=(imm: ir::Immediate), vals=2, blocks=0)

StackLoad

StackLoad(imms=(stack_slot: ir::StackSlot, offset: ir::immediates::Offset32), vals=0, blocks=0)

StackStore

StackStore(imms=(stack_slot: ir::StackSlot, offset: ir::immediates::Offset32), vals=1, blocks=0)

Store

Store(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=2, blocks=0)

StoreNoOffset

StoreNoOffset(imms=(flags: ir::MemFlags), vals=2, blocks=0)

Ternary

Ternary(imms=(), vals=3, blocks=0)

TernaryImm8

TernaryImm8(imms=(imm: ir::immediates::Uimm8), vals=2, blocks=0)

Trap

Trap(imms=(code: ir::TrapCode), vals=0, blocks=0)

Unary

Unary(imms=(), vals=1, blocks=0)

UnaryConst

UnaryConst(imms=(constant_handle: ir::Constant), vals=0, blocks=0)

UnaryGlobalValue

UnaryGlobalValue(imms=(global_value: ir::GlobalValue), vals=0, blocks=0)

UnaryIeee32

UnaryIeee32(imms=(imm: ir::immediates::Ieee32), vals=0, blocks=0)

UnaryIeee64

UnaryIeee64(imms=(imm: ir::immediates::Ieee64), vals=0, blocks=0)

UnaryImm

UnaryImm(imms=(imm: ir::immediates::Imm64), vals=0, blocks=0)

Trait Implementations

impl Clone for InstructionFormat

fn clone(&self) -> InstructionFormat

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InstructionFormat

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

Formats the value using the given formatter.

impl<'a> From<&'a InstructionData> for InstructionFormat

fn from(inst: &'a InstructionData) -> Self

Converts to this type from the input type.

impl PartialEq for InstructionFormat

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for InstructionFormat

impl Eq for InstructionFormat

impl StructuralPartialEq for InstructionFormat