Enum cranelift_codegen::ir::instructions::InstructionFormat

pub enum InstructionFormat {
    Binary,
    InsertLane,
    BinaryImm,
    UnaryGlobalValue,
    RegSpill,
    FloatCompare,
    FloatCond,
    CopySpecial,
    Unary,
    IntCond,
    ExtractLane,
    TableAddr,
    BranchTableBase,
    IntCompare,
    Shuffle,
    BranchFloat,
    IntCompareImm,
    NullAry,
    BranchTable,
    UnaryConst,
    StackStore,
    Branch,
    Load,
    RegFill,
    StoreComplex,
    StackLoad,
    UnaryBool,
    FloatCondTrap,
    IntSelect,
    BranchIcmp,
    FuncAddr,
    BranchTableEntry,
    MultiAry,
    UnaryImm,
    Ternary,
    IndirectJump,
    CallIndirect,
    Trap,
    CondTrap,
    RegMove,
    HeapAddr,
    BranchInt,
    Call,
    Store,
    Jump,
    IntCondTrap,
    LoadComplex,
    UnaryIeee32,
    CopyToSsa,
    UnaryIeee64,
}

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)

InsertLane

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

BinaryImm

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

UnaryGlobalValue

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

RegSpill

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

FloatCompare

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

FloatCond

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

CopySpecial

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

Unary

Unary(imms=(), vals=1)

IntCond

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

ExtractLane

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

TableAddr

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

BranchTableBase

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

IntCompare

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

Shuffle

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

BranchFloat

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

IntCompareImm

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

NullAry

NullAry(imms=(), vals=0)

BranchTable

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

UnaryConst

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

StackStore

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

Branch

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

Load

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

RegFill

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

StoreComplex

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

StackLoad

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

UnaryBool

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

FloatCondTrap

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

IntSelect

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

BranchIcmp

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

FuncAddr

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

BranchTableEntry

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

MultiAry

MultiAry(imms=(), vals=0)

UnaryImm

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

Ternary

Ternary(imms=(), vals=3)

IndirectJump

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

CallIndirect

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

Trap

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

CondTrap

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

RegMove

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

HeapAddr

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

BranchInt

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

Call

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

Store

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

Jump

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

IntCondTrap

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

LoadComplex

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

UnaryIeee32

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

CopyToSsa

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

UnaryIeee64

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

Trait Implementations

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

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

Performs the conversion.

impl Debug for InstructionFormat

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

Formats the value using the given formatter.

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 Eq for InstructionFormat

impl Copy for InstructionFormat

impl StructuralPartialEq for InstructionFormat

impl StructuralEq for InstructionFormat

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.