Enum cranelift_codegen::ir::instructions::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,
    TableAddr,
    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=(destination: ir::Block, 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)

TableAddr

TableAddr(imms=(table: ir::Table, offset: ir::immediates::Offset32), vals=1, 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<InstructionFormat> for InstructionFormat

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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 StructuralEq for InstructionFormat

impl StructuralPartialEq for InstructionFormat