Enum cranelift_codegen::ir::instructions::InstructionData

pub enum InstructionData {
    Unary {
        opcode: Opcode,
        arg: Value,
    },
    UnaryImm {
        opcode: Opcode,
        imm: Imm64,
    },
    UnaryIeee32 {
        opcode: Opcode,
        imm: Ieee32,
    },
    UnaryIeee64 {
        opcode: Opcode,
        imm: Ieee64,
    },
    UnaryBool {
        opcode: Opcode,
        imm: bool,
    },
    UnaryGlobalValue {
        opcode: Opcode,
        global_value: GlobalValue,
    },
    Binary {
        opcode: Opcode,
        args: [Value; 2],
    },
    BinaryImm {
        opcode: Opcode,
        arg: Value,
        imm: Imm64,
    },
    Ternary {
        opcode: Opcode,
        args: [Value; 3],
    },
    MultiAry {
        opcode: Opcode,
        args: ValueList,
    },
    NullAry {
        opcode: Opcode,
    },
    InsertLane {
        opcode: Opcode,
        args: [Value; 2],
        lane: Uimm8,
    },
    ExtractLane {
        opcode: Opcode,
        arg: Value,
        lane: Uimm8,
    },
    IntCompare {
        opcode: Opcode,
        args: [Value; 2],
        cond: IntCC,
    },
    IntCompareImm {
        opcode: Opcode,
        arg: Value,
        cond: IntCC,
        imm: Imm64,
    },
    IntCond {
        opcode: Opcode,
        arg: Value,
        cond: IntCC,
    },
    FloatCompare {
        opcode: Opcode,
        args: [Value; 2],
        cond: FloatCC,
    },
    FloatCond {
        opcode: Opcode,
        arg: Value,
        cond: FloatCC,
    },
    IntSelect {
        opcode: Opcode,
        args: [Value; 3],
        cond: IntCC,
    },
    Jump {
        opcode: Opcode,
        args: ValueList,
        destination: Ebb,
    },
    Branch {
        opcode: Opcode,
        args: ValueList,
        destination: Ebb,
    },
    BranchInt {
        opcode: Opcode,
        args: ValueList,
        cond: IntCC,
        destination: Ebb,
    },
    BranchFloat {
        opcode: Opcode,
        args: ValueList,
        cond: FloatCC,
        destination: Ebb,
    },
    BranchIcmp {
        opcode: Opcode,
        args: ValueList,
        cond: IntCC,
        destination: Ebb,
    },
    BranchTable {
        opcode: Opcode,
        arg: Value,
        destination: Ebb,
        table: JumpTable,
    },
    BranchTableEntry {
        opcode: Opcode,
        args: [Value; 2],
        imm: Uimm8,
        table: JumpTable,
    },
    BranchTableBase {
        opcode: Opcode,
        table: JumpTable,
    },
    IndirectJump {
        opcode: Opcode,
        arg: Value,
        table: JumpTable,
    },
    Call {
        opcode: Opcode,
        args: ValueList,
        func_ref: FuncRef,
    },
    CallIndirect {
        opcode: Opcode,
        args: ValueList,
        sig_ref: SigRef,
    },
    FuncAddr {
        opcode: Opcode,
        func_ref: FuncRef,
    },
    Load {
        opcode: Opcode,
        arg: Value,
        flags: MemFlags,
        offset: Offset32,
    },
    LoadComplex {
        opcode: Opcode,
        args: ValueList,
        flags: MemFlags,
        offset: Offset32,
    },
    Store {
        opcode: Opcode,
        args: [Value; 2],
        flags: MemFlags,
        offset: Offset32,
    },
    StoreComplex {
        opcode: Opcode,
        args: ValueList,
        flags: MemFlags,
        offset: Offset32,
    },
    StackLoad {
        opcode: Opcode,
        stack_slot: StackSlot,
        offset: Offset32,
    },
    StackStore {
        opcode: Opcode,
        arg: Value,
        stack_slot: StackSlot,
        offset: Offset32,
    },
    HeapAddr {
        opcode: Opcode,
        arg: Value,
        heap: Heap,
        imm: Uimm32,
    },
    TableAddr {
        opcode: Opcode,
        arg: Value,
        table: Table,
        offset: Offset32,
    },
    RegMove {
        opcode: Opcode,
        arg: Value,
        src: RegUnit,
        dst: RegUnit,
    },
    CopySpecial {
        opcode: Opcode,
        src: RegUnit,
        dst: RegUnit,
    },
    RegSpill {
        opcode: Opcode,
        arg: Value,
        src: RegUnit,
        dst: StackSlot,
    },
    RegFill {
        opcode: Opcode,
        arg: Value,
        src: StackSlot,
        dst: RegUnit,
    },
    Trap {
        opcode: Opcode,
        code: TrapCode,
    },
    CondTrap {
        opcode: Opcode,
        arg: Value,
        code: TrapCode,
    },
    IntCondTrap {
        opcode: Opcode,
        arg: Value,
        cond: IntCC,
        code: TrapCode,
    },
    FloatCondTrap {
        opcode: Opcode,
        arg: Value,
        cond: FloatCC,
        code: TrapCode,
    },
}

Variants

Unary

Fields of Unary

opcode: Opcodearg: Value

UnaryImm

Fields of UnaryImm

opcode: Opcodeimm: Imm64

UnaryIeee32

Fields of UnaryIeee32

opcode: Opcodeimm: Ieee32

UnaryIeee64

Fields of UnaryIeee64

opcode: Opcodeimm: Ieee64

UnaryBool

Fields of UnaryBool

opcode: Opcodeimm: bool

UnaryGlobalValue

Fields of UnaryGlobalValue

opcode: Opcodeglobal_value: GlobalValue

Binary

Fields of Binary

opcode: Opcodeargs: [Value; 2]

BinaryImm

Fields of BinaryImm

opcode: Opcodearg: Valueimm: Imm64

Ternary

Fields of Ternary

opcode: Opcodeargs: [Value; 3]

MultiAry

Fields of MultiAry

opcode: Opcodeargs: ValueList

NullAry

Fields of NullAry

opcode: Opcode

InsertLane

Fields of InsertLane

opcode: Opcodeargs: [Value; 2]lane: Uimm8

ExtractLane

Fields of ExtractLane

opcode: Opcodearg: Valuelane: Uimm8

IntCompare

Fields of IntCompare

opcode: Opcodeargs: [Value; 2]cond: IntCC

IntCompareImm

Fields of IntCompareImm

opcode: Opcodearg: Valuecond: IntCCimm: Imm64

IntCond

Fields of IntCond

opcode: Opcodearg: Valuecond: IntCC

FloatCompare

Fields of FloatCompare

opcode: Opcodeargs: [Value; 2]cond: FloatCC

FloatCond

Fields of FloatCond

opcode: Opcodearg: Valuecond: FloatCC

IntSelect

Fields of IntSelect

opcode: Opcodeargs: [Value; 3]cond: IntCC

Jump

Fields of Jump

opcode: Opcodeargs: ValueListdestination: Ebb

Branch

Fields of Branch

opcode: Opcodeargs: ValueListdestination: Ebb

BranchInt

Fields of BranchInt

opcode: Opcodeargs: ValueListcond: IntCCdestination: Ebb

BranchFloat

Fields of BranchFloat

opcode: Opcodeargs: ValueListcond: FloatCCdestination: Ebb

BranchIcmp

Fields of BranchIcmp

opcode: Opcodeargs: ValueListcond: IntCCdestination: Ebb

BranchTable

Fields of BranchTable

opcode: Opcodearg: Valuedestination: Ebbtable: JumpTable

BranchTableEntry

Fields of BranchTableEntry

opcode: Opcodeargs: [Value; 2]imm: Uimm8table: JumpTable

BranchTableBase

Fields of BranchTableBase

opcode: Opcodetable: JumpTable

IndirectJump

Fields of IndirectJump

opcode: Opcodearg: Valuetable: JumpTable

Call

Fields of Call

opcode: Opcodeargs: ValueListfunc_ref: FuncRef

CallIndirect

Fields of CallIndirect

opcode: Opcodeargs: ValueListsig_ref: SigRef

FuncAddr

Fields of FuncAddr

opcode: Opcodefunc_ref: FuncRef

Load

Fields of Load

opcode: Opcodearg: Valueflags: MemFlagsoffset: Offset32

LoadComplex

Fields of LoadComplex

opcode: Opcodeargs: ValueListflags: MemFlagsoffset: Offset32

Store

Fields of Store

opcode: Opcodeargs: [Value; 2]flags: MemFlagsoffset: Offset32

StoreComplex

Fields of StoreComplex

opcode: Opcodeargs: ValueListflags: MemFlagsoffset: Offset32

StackLoad

Fields of StackLoad

opcode: Opcodestack_slot: StackSlotoffset: Offset32

StackStore

Fields of StackStore

opcode: Opcodearg: Valuestack_slot: StackSlotoffset: Offset32

HeapAddr

Fields of HeapAddr

opcode: Opcodearg: Valueheap: Heapimm: Uimm32

TableAddr

Fields of TableAddr

opcode: Opcodearg: Valuetable: Tableoffset: Offset32

RegMove

Fields of RegMove

opcode: Opcodearg: Valuesrc: RegUnitdst: RegUnit

CopySpecial

Fields of CopySpecial

opcode: Opcodesrc: RegUnitdst: RegUnit

RegSpill

Fields of RegSpill

opcode: Opcodearg: Valuesrc: RegUnitdst: StackSlot

RegFill

Fields of RegFill

opcode: Opcodearg: Valuesrc: StackSlotdst: RegUnit

Trap

Fields of Trap

opcode: Opcodecode: TrapCode

CondTrap

Fields of CondTrap

opcode: Opcodearg: Valuecode: TrapCode

IntCondTrap

Fields of IntCondTrap

opcode: Opcodearg: Valuecond: IntCCcode: TrapCode

FloatCondTrap

Fields of FloatCondTrap

opcode: Opcodearg: Valuecond: FloatCCcode: TrapCode

Methods

impl InstructionData

pub fn opcode(&self) -> Opcode

Get the opcode of this instruction.

pub fn typevar_operand(&self, pool: &ValueListPool) -> Option<Value>

Get the controlling type variable operand.

pub fn arguments<'a>(&'a self, pool: &'a ValueListPool) -> &[Value]

Get the value arguments to this instruction.

pub fn arguments_mut<'a>(
    &'a mut self,
    pool: &'a mut ValueListPool
) -> &mut [Value]

Get mutable references to the value arguments to this instruction.

pub fn take_value_list(&mut self) -> Option<ValueList>

Take out the value list with all the value arguments and return it.

This leaves the value list in the instruction empty. Use put_value_list to put the value list back.

pub fn put_value_list(&mut self, vlist: ValueList)

Put back a value list.

After removing a value list with take_value_list(), use this method to put it back. It is required that this instruction has a format that accepts a value list, and that the existing value list is empty. This avoids leaking list pool memory.

pub fn eq(&self, other: &Self, pool: &ValueListPool) -> bool

Compare two InstructionData for equality.

This operation requires a reference to a ValueListPool to determine if the contents of any ValueLists are equal.

pub fn hash<H: Hasher>(&self, state: &mut H, pool: &ValueListPool)

Hash an InstructionData.

This operation requires a reference to a ValueListPool to hash the contents of any ValueLists.

impl InstructionData

Analyzing an instruction.

Avoid large matches on instruction formats by using the methods defined here to examine instructions.

pub fn analyze_branch<'a>(&'a self, pool: &'a ValueListPool) -> BranchInfo<'a>

Return information about the destination of a branch or jump instruction.

Any instruction that can transfer control to another EBB reveals its possible destinations here.

pub fn branch_destination(&self) -> Option<Ebb>

Get the single destination of this branch instruction, if it is a single destination branch or jump.

Multi-destination branches like br_table return None.

pub fn branch_destination_mut(&mut self) -> Option<&mut Ebb>

Get a mutable reference to the single destination of this branch instruction, if it is a single destination branch or jump.

Multi-destination branches like br_table return None.

pub fn analyze_call<'a>(&'a self, pool: &'a ValueListPool) -> CallInfo<'a>

Return information about a call instruction.

Any instruction that can call another function reveals its call signature here.

Trait Implementations

impl Debug for InstructionData

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

Performs the conversion.

impl Clone for InstructionData

fn clone(&self) -> InstructionData

Returns a copy of the value.

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

Performs copy-assignment from source.