Enum cranelift_codegen::ir::instructions::InstructionData
source · [−]pub enum InstructionData {
Show 44 variants
AtomicCas {
opcode: Opcode,
args: [Value; 3],
flags: MemFlags,
},
AtomicRmw {
opcode: Opcode,
args: [Value; 2],
flags: MemFlags,
op: AtomicRmwOp,
},
Binary {
opcode: Opcode,
args: [Value; 2],
},
BinaryImm64 {
opcode: Opcode,
arg: Value,
imm: Imm64,
},
BinaryImm8 {
opcode: Opcode,
arg: Value,
imm: Uimm8,
},
Branch {
opcode: Opcode,
args: ValueList,
destination: Block,
},
BranchFloat {
opcode: Opcode,
args: ValueList,
cond: FloatCC,
destination: Block,
},
BranchIcmp {
opcode: Opcode,
args: ValueList,
cond: IntCC,
destination: Block,
},
BranchInt {
opcode: Opcode,
args: ValueList,
cond: IntCC,
destination: Block,
},
BranchTable {
opcode: Opcode,
arg: Value,
destination: Block,
table: JumpTable,
},
Call {
opcode: Opcode,
args: ValueList,
func_ref: FuncRef,
},
CallIndirect {
opcode: Opcode,
args: ValueList,
sig_ref: SigRef,
},
CondTrap {
opcode: Opcode,
arg: Value,
code: TrapCode,
},
FloatCompare {
opcode: Opcode,
args: [Value; 2],
cond: FloatCC,
},
FloatCond {
opcode: Opcode,
arg: Value,
cond: FloatCC,
},
FloatCondTrap {
opcode: Opcode,
arg: Value,
cond: FloatCC,
code: TrapCode,
},
FuncAddr {
opcode: Opcode,
func_ref: FuncRef,
},
HeapAddr {
opcode: Opcode,
arg: Value,
heap: Heap,
imm: Uimm32,
},
IntCompare {
opcode: Opcode,
args: [Value; 2],
cond: IntCC,
},
IntCompareImm {
opcode: Opcode,
arg: Value,
cond: IntCC,
imm: Imm64,
},
IntCond {
opcode: Opcode,
arg: Value,
cond: IntCC,
},
IntCondTrap {
opcode: Opcode,
arg: Value,
cond: IntCC,
code: TrapCode,
},
IntSelect {
opcode: Opcode,
args: [Value; 3],
cond: IntCC,
},
Jump {
opcode: Opcode,
args: ValueList,
destination: Block,
},
Load {
opcode: Opcode,
arg: Value,
flags: MemFlags,
offset: Offset32,
},
LoadNoOffset {
opcode: Opcode,
arg: Value,
flags: MemFlags,
},
MultiAry {
opcode: Opcode,
args: ValueList,
},
NullAry {
opcode: Opcode,
},
Shuffle {
opcode: Opcode,
args: [Value; 2],
imm: Immediate,
},
StackLoad {
opcode: Opcode,
stack_slot: StackSlot,
offset: Offset32,
},
StackStore {
opcode: Opcode,
arg: Value,
stack_slot: StackSlot,
offset: Offset32,
},
Store {
opcode: Opcode,
args: [Value; 2],
flags: MemFlags,
offset: Offset32,
},
StoreNoOffset {
opcode: Opcode,
args: [Value; 2],
flags: MemFlags,
},
TableAddr {
opcode: Opcode,
arg: Value,
table: Table,
offset: Offset32,
},
Ternary {
opcode: Opcode,
args: [Value; 3],
},
TernaryImm8 {
opcode: Opcode,
args: [Value; 2],
imm: Uimm8,
},
Trap {
opcode: Opcode,
code: TrapCode,
},
Unary {
opcode: Opcode,
arg: Value,
},
UnaryBool {
opcode: Opcode,
imm: bool,
},
UnaryConst {
opcode: Opcode,
constant_handle: Constant,
},
UnaryGlobalValue {
opcode: Opcode,
global_value: GlobalValue,
},
UnaryIeee32 {
opcode: Opcode,
imm: Ieee32,
},
UnaryIeee64 {
opcode: Opcode,
imm: Ieee64,
},
UnaryImm {
opcode: Opcode,
imm: Imm64,
},
}Variants
AtomicCas
AtomicRmw
Binary
BinaryImm64
BinaryImm8
Branch
BranchFloat
BranchIcmp
BranchInt
BranchTable
Call
CallIndirect
CondTrap
FloatCompare
FloatCond
FloatCondTrap
FuncAddr
HeapAddr
IntCompare
IntCompareImm
IntCond
IntCondTrap
IntSelect
Jump
Load
LoadNoOffset
MultiAry
NullAry
Fields
opcode: OpcodeShuffle
StackLoad
StackStore
Store
StoreNoOffset
TableAddr
Ternary
TernaryImm8
Trap
Unary
UnaryBool
UnaryConst
UnaryGlobalValue
UnaryIeee32
UnaryIeee64
UnaryImm
Implementations
sourceimpl InstructionData
impl InstructionData
sourcepub fn typevar_operand(&self, pool: &ValueListPool) -> Option<Value>
pub fn typevar_operand(&self, pool: &ValueListPool) -> Option<Value>
Get the controlling type variable operand.
sourcepub fn arguments<'a>(&'a self, pool: &'a ValueListPool) -> &[Value]
pub fn arguments<'a>(&'a self, pool: &'a ValueListPool) -> &[Value]
Get the value arguments to this instruction.
sourcepub fn arguments_mut<'a>(
&'a mut self,
pool: &'a mut ValueListPool
) -> &mut [Value]
pub fn arguments_mut<'a>(
&'a mut self,
pool: &'a mut ValueListPool
) -> &mut [Value]
Get mutable references to the value arguments to this instruction.
sourcepub fn take_value_list(&mut self) -> Option<ValueList>
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.
sourcepub fn put_value_list(&mut self, vlist: ValueList)
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.
sourcepub fn eq(&self, other: &Self, pool: &ValueListPool) -> bool
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.
sourcepub fn hash<H: Hasher>(&self, state: &mut H, pool: &ValueListPool)
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.
sourceimpl InstructionData
impl InstructionData
Analyzing an instruction.
Avoid large matches on instruction formats by using the methods defined here to examine instructions.
sourcepub fn analyze_branch<'a>(&'a self, pool: &'a ValueListPool) -> BranchInfo<'a>
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 block reveals its possible destinations here.
sourcepub fn branch_destination(&self) -> Option<Block>
pub fn branch_destination(&self) -> Option<Block>
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.
sourcepub fn branch_destination_mut(&mut self) -> Option<&mut Block>
pub fn branch_destination_mut(&mut self) -> Option<&mut Block>
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.
sourcepub fn imm_value(&self) -> Option<DataValue>
pub fn imm_value(&self) -> Option<DataValue>
Return the value of an immediate if the instruction has one or None otherwise. Only
immediate values are considered, not global values, constant handles, condition codes, etc.
sourcepub fn trap_code(&self) -> Option<TrapCode>
pub fn trap_code(&self) -> Option<TrapCode>
If this is a trapping instruction, get its trap code. Otherwise, return
None.
sourcepub fn cond_code(&self) -> Option<IntCC>
pub fn cond_code(&self) -> Option<IntCC>
If this is a control-flow instruction depending on an integer condition, gets its
condition. Otherwise, return None.
sourcepub fn fp_cond_code(&self) -> Option<FloatCC>
pub fn fp_cond_code(&self) -> Option<FloatCC>
If this is a control-flow instruction depending on a floating-point condition, gets its
condition. Otherwise, return None.
sourcepub fn trap_code_mut(&mut self) -> Option<&mut TrapCode>
pub fn trap_code_mut(&mut self) -> Option<&mut TrapCode>
If this is a trapping instruction, get an exclusive reference to its
trap code. Otherwise, return None.
sourcepub fn atomic_rmw_op(&self) -> Option<AtomicRmwOp>
pub fn atomic_rmw_op(&self) -> Option<AtomicRmwOp>
If this is an atomic read/modify/write instruction, return its subopcode.
sourcepub fn load_store_offset(&self) -> Option<i32>
pub fn load_store_offset(&self) -> Option<i32>
If this is a load/store instruction, returns its immediate offset.
sourcepub fn memflags(&self) -> Option<MemFlags>
pub fn memflags(&self) -> Option<MemFlags>
If this is a load/store instruction, return its memory flags.
sourcepub fn stack_slot(&self) -> Option<StackSlot>
pub fn stack_slot(&self) -> Option<StackSlot>
If this instruction references a stack slot, return it
sourcepub fn analyze_call<'a>(&'a self, pool: &'a ValueListPool) -> CallInfo<'a>
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
sourceimpl Clone for InstructionData
impl Clone for InstructionData
sourcefn clone(&self) -> InstructionData
fn clone(&self) -> InstructionData
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
sourceimpl Debug for InstructionData
impl Debug for InstructionData
sourceimpl<'a> From<&'a InstructionData> for InstructionFormat
impl<'a> From<&'a InstructionData> for InstructionFormat
sourcefn from(inst: &'a InstructionData) -> Self
fn from(inst: &'a InstructionData) -> Self
Converts to this type from the input type.
Auto Trait Implementations
impl RefUnwindSafe for InstructionData
impl Send for InstructionData
impl Sync for InstructionData
impl Unpin for InstructionData
impl UnwindSafe for InstructionData
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more