Enum cranelift_codegen::ir::instructions::InstructionFormat

pub enum InstructionFormat {
    Binary,
    BinaryImm,
    Branch,
    BranchFloat,
    BranchIcmp,
    BranchInt,
    BranchTable,
    BranchTableBase,
    BranchTableEntry,
    Call,
    CallIndirect,
    CondTrap,
    CopySpecial,
    CopyToSsa,
    ExtractLane,
    FloatCompare,
    FloatCond,
    FloatCondTrap,
    FuncAddr,
    HeapAddr,
    IndirectJump,
    InsertLane,
    IntCompare,
    IntCompareImm,
    IntCond,
    IntCondTrap,
    IntSelect,
    Jump,
    Load,
    LoadComplex,
    MultiAry,
    NullAry,
    RegFill,
    RegMove,
    RegSpill,
    Shuffle,
    StackLoad,
    StackStore,
    Store,
    StoreComplex,
    TableAddr,
    Ternary,
    Trap,
    Unary,
    UnaryBool,
    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

Binary

Binary(imms=(), vals=2)

BinaryImm

BinaryImm(imms=(imm: ir::immediates::Imm64), vals=1)

Branch

Branch(imms=(destination: ir::Block), vals=1)

BranchFloat

BranchFloat(imms=(cond: ir::condcodes::FloatCC, destination: ir::Block), vals=1)

BranchIcmp

BranchIcmp(imms=(cond: ir::condcodes::IntCC, destination: ir::Block), vals=2)

BranchInt

BranchInt(imms=(cond: ir::condcodes::IntCC, destination: ir::Block), vals=1)

BranchTable

BranchTable(imms=(destination: ir::Block, table: ir::JumpTable), vals=1)

BranchTableBase

BranchTableBase(imms=(table: ir::JumpTable), vals=0)

BranchTableEntry

BranchTableEntry(imms=(imm: ir::immediates::Uimm8, table: ir::JumpTable), vals=2)

Call

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

CallIndirect

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

CondTrap

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

CopySpecial

CopySpecial(imms=(src: isa::RegUnit, dst: isa::RegUnit), vals=0)

CopyToSsa

CopyToSsa(imms=(src: isa::RegUnit), vals=0)

ExtractLane

ExtractLane(imms=(lane: ir::immediates::Uimm8), vals=1)

FloatCompare

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

FloatCond

FloatCond(imms=(cond: ir::condcodes::FloatCC), vals=1)

FloatCondTrap

FloatCondTrap(imms=(cond: ir::condcodes::FloatCC, code: ir::TrapCode), vals=1)

FuncAddr

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

HeapAddr

HeapAddr(imms=(heap: ir::Heap, imm: ir::immediates::Uimm32), vals=1)

IndirectJump

IndirectJump(imms=(table: ir::JumpTable), vals=1)

InsertLane

InsertLane(imms=(lane: ir::immediates::Uimm8), vals=2)

IntCompare

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

IntCompareImm

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

IntCond

IntCond(imms=(cond: ir::condcodes::IntCC), vals=1)

IntCondTrap

IntCondTrap(imms=(cond: ir::condcodes::IntCC, code: ir::TrapCode), vals=1)

IntSelect

IntSelect(imms=(cond: ir::condcodes::IntCC), vals=3)

Jump

Jump(imms=(destination: ir::Block), vals=0)

Load

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

LoadComplex

LoadComplex(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=0)

MultiAry

MultiAry(imms=(), vals=0)

NullAry

NullAry(imms=(), vals=0)

RegFill

RegFill(imms=(src: ir::StackSlot, dst: isa::RegUnit), vals=1)

RegMove

RegMove(imms=(src: isa::RegUnit, dst: isa::RegUnit), vals=1)

RegSpill

RegSpill(imms=(src: isa::RegUnit, dst: ir::StackSlot), vals=1)

Shuffle

Shuffle(imms=(mask: ir::Immediate), vals=2)

StackLoad

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

StackStore

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

Store

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

StoreComplex

StoreComplex(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=1)

TableAddr

TableAddr(imms=(table: ir::Table, offset: ir::immediates::Offset32), vals=1)

Ternary

Ternary(imms=(), vals=3)

Trap

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

Unary

Unary(imms=(), vals=1)

UnaryBool

UnaryBool(imms=(imm: bool), vals=0)

UnaryConst

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

UnaryGlobalValue

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

UnaryIeee32

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

UnaryIeee64

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

UnaryImm

UnaryImm(imms=(imm: ir::immediates::Imm64), vals=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 Copy for InstructionFormat

impl Debug for InstructionFormat

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

Formats the value using the given formatter.

impl Eq for InstructionFormat

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

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

Performs the conversion.

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 ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl StructuralEq for InstructionFormat

impl StructuralPartialEq for InstructionFormat