Enum cranelift_codegen::ir::instructions::InstructionFormat

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

An instruction format

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

Variants

Unary

Unary(imms=(), vals=1)

UnaryImm

UnaryImm(imms=(imm: imm64), vals=0)

UnaryIeee32

UnaryIeee32(imms=(imm: ieee32), vals=0)

UnaryIeee64

UnaryIeee64(imms=(imm: ieee64), vals=0)

UnaryBool

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

UnaryGlobalValue

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

Binary

Binary(imms=(), vals=2)

BinaryImm

BinaryImm(imms=(imm: imm64), vals=1)

Ternary

Ternary(imms=(), vals=3)

MultiAry

MultiAry(imms=(), vals=0)

NullAry

NullAry(imms=(), vals=0)

InsertLane

InsertLane(imms=(lane: uimm8), vals=2)

ExtractLane

ExtractLane(imms=(lane: uimm8), vals=1)

IntCompare

IntCompare(imms=(cond: intcc), vals=2)

IntCompareImm

IntCompareImm(imms=(cond: intcc, imm: imm64), vals=1)

IntCond

IntCond(imms=(cond: intcc), vals=1)

FloatCompare

FloatCompare(imms=(cond: floatcc), vals=2)

FloatCond

FloatCond(imms=(cond: floatcc), vals=1)

IntSelect

IntSelect(imms=(cond: intcc), vals=3)

Jump

Jump(imms=(destination: ebb), vals=0)

Branch

Branch(imms=(destination: ebb), vals=1)

BranchInt

BranchInt(imms=(cond: intcc, destination: ebb), vals=1)

BranchFloat

BranchFloat(imms=(cond: floatcc, destination: ebb), vals=1)

BranchIcmp

BranchIcmp(imms=(cond: intcc, destination: ebb), vals=2)

BranchTable

BranchTable(imms=(destination: ebb, table: jump_table), vals=1)

BranchTableEntry

BranchTableEntry(imms=(imm: uimm8, table: jump_table), vals=2)

BranchTableBase

BranchTableBase(imms=(table: jump_table), vals=0)

IndirectJump

IndirectJump(imms=(table: jump_table), vals=1)

Call

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

CallIndirect

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

FuncAddr

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

Load

Load(imms=(flags: memflags, offset: offset32), vals=1)

LoadComplex

LoadComplex(imms=(flags: memflags, offset: offset32), vals=0)

Store

Store(imms=(flags: memflags, offset: offset32), vals=2)

StoreComplex

StoreComplex(imms=(flags: memflags, offset: offset32), vals=1)

StackLoad

StackLoad(imms=(stack_slot: stack_slot, offset: offset32), vals=0)

StackStore

StackStore(imms=(stack_slot: stack_slot, offset: offset32), vals=1)

HeapAddr

HeapAddr(imms=(heap: heap, imm: uimm32), vals=1)

TableAddr

TableAddr(imms=(table: table, offset: offset32), vals=1)

RegMove

RegMove(imms=(src: regunit, dst: regunit), vals=1)

CopySpecial

CopySpecial(imms=(src: regunit, dst: regunit), vals=0)

RegSpill

RegSpill(imms=(src: regunit, dst: stack_slot), vals=1)

RegFill

RegFill(imms=(src: stack_slot, dst: regunit), vals=1)

Trap

Trap(imms=(code: trapcode), vals=0)

CondTrap

CondTrap(imms=(code: trapcode), vals=1)

IntCondTrap

IntCondTrap(imms=(cond: intcc, code: trapcode), vals=1)

FloatCondTrap

FloatCondTrap(imms=(cond: floatcc, code: trapcode), vals=1)

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