Enum InstructionData

pub enum InstructionData {
    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,
    },
    BranchTable {
        opcode: Opcode,
        arg: Value,
        table: JumpTable,
    },
    Brif {
        opcode: Opcode,
        arg: Value,
        blocks: [BlockCall; 2],
    },
    Call {
        opcode: Opcode,
        args: ValueList,
        func_ref: FuncRef,
    },
    CallIndirect {
        opcode: Opcode,
        args: ValueList,
        sig_ref: SigRef,
    },
    CondTrap {
        opcode: Opcode,
        arg: Value,
        code: TrapCode,
    },
    DynamicStackLoad {
        opcode: Opcode,
        dynamic_stack_slot: DynamicStackSlot,
    },
    DynamicStackStore {
        opcode: Opcode,
        arg: Value,
        dynamic_stack_slot: DynamicStackSlot,
    },
    FloatCompare {
        opcode: Opcode,
        args: [Value; 2],
        cond: FloatCC,
    },
    FuncAddr {
        opcode: Opcode,
        func_ref: FuncRef,
    },
    IntAddTrap {
        opcode: Opcode,
        args: [Value; 2],
        code: TrapCode,
    },
    IntCompare {
        opcode: Opcode,
        args: [Value; 2],
        cond: IntCC,
    },
    IntCompareImm {
        opcode: Opcode,
        arg: Value,
        cond: IntCC,
        imm: Imm64,
    },
    Jump {
        opcode: Opcode,
        destination: BlockCall,
    },
    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,
    },
    Ternary {
        opcode: Opcode,
        args: [Value; 3],
    },
    TernaryImm8 {
        opcode: Opcode,
        args: [Value; 2],
        imm: Uimm8,
    },
    Trap {
        opcode: Opcode,
        code: TrapCode,
    },
    Unary {
        opcode: Opcode,
        arg: Value,
    },
    UnaryConst {
        opcode: Opcode,
        constant_handle: Constant,
    },
    UnaryGlobalValue {
        opcode: Opcode,
        global_value: GlobalValue,
    },
    UnaryIeee16 {
        opcode: Opcode,
        imm: Ieee16,
    },
    UnaryIeee32 {
        opcode: Opcode,
        imm: Ieee32,
    },
    UnaryIeee64 {
        opcode: Opcode,
        imm: Ieee64,
    },
    UnaryImm {
        opcode: Opcode,
        imm: Imm64,
    },
}

Variants

AtomicCas

Fields

opcode: Opcode

args: [Value; 3]

flags: MemFlags

AtomicRmw

Fields

opcode: Opcode

args: [Value; 2]

flags: MemFlags

op: AtomicRmwOp

Binary

Fields

opcode: Opcode

args: [Value; 2]

BinaryImm64

Fields

opcode: Opcode

arg: Value

imm: Imm64

BinaryImm8

Fields

opcode: Opcode

arg: Value

imm: Uimm8

BranchTable

Fields

opcode: Opcode

arg: Value

table: JumpTable

Brif

Fields

opcode: Opcode

arg: Value

blocks: [BlockCall; 2]

Call

Fields

opcode: Opcode

args: ValueList

func_ref: FuncRef

CallIndirect

Fields

opcode: Opcode

args: ValueList

sig_ref: SigRef

CondTrap

Fields

opcode: Opcode

arg: Value

code: TrapCode

DynamicStackLoad

Fields

opcode: Opcode

dynamic_stack_slot: DynamicStackSlot

DynamicStackStore

Fields

opcode: Opcode

arg: Value

dynamic_stack_slot: DynamicStackSlot

FloatCompare

Fields

opcode: Opcode

args: [Value; 2]

cond: FloatCC

FuncAddr

Fields

opcode: Opcode

func_ref: FuncRef

IntAddTrap

Fields

opcode: Opcode

args: [Value; 2]

code: TrapCode

IntCompare

Fields

opcode: Opcode

args: [Value; 2]

cond: IntCC

IntCompareImm

Fields

opcode: Opcode

arg: Value

cond: IntCC

imm: Imm64

Jump

Fields

opcode: Opcode

destination: BlockCall

Load

Fields

opcode: Opcode

arg: Value

flags: MemFlags

offset: Offset32

LoadNoOffset

Fields

opcode: Opcode

arg: Value

flags: MemFlags

MultiAry

Fields

opcode: Opcode

args: ValueList

NullAry

Fields

opcode: Opcode

Shuffle

Fields

opcode: Opcode

args: [Value; 2]

imm: Immediate

StackLoad

Fields

opcode: Opcode

stack_slot: StackSlot

offset: Offset32

StackStore

Fields

opcode: Opcode

arg: Value

stack_slot: StackSlot

offset: Offset32

Store

Fields

opcode: Opcode

args: [Value; 2]

flags: MemFlags

offset: Offset32

StoreNoOffset

Fields

opcode: Opcode

args: [Value; 2]

flags: MemFlags

Ternary

Fields

opcode: Opcode

args: [Value; 3]

TernaryImm8

Fields

opcode: Opcode

args: [Value; 2]

imm: Uimm8

Trap

Fields

opcode: Opcode

code: TrapCode

Unary

Fields

opcode: Opcode

arg: Value

UnaryConst

Fields

opcode: Opcode

constant_handle: Constant

UnaryGlobalValue

Fields

opcode: Opcode

global_value: GlobalValue

UnaryIeee16

Fields

opcode: Opcode

imm: Ieee16

UnaryIeee32

Fields

opcode: Opcode

imm: Ieee32

UnaryIeee64

Fields

opcode: Opcode

imm: Ieee64

UnaryImm

Fields

opcode: Opcode

imm: Imm64

Implementations

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) -> &'a [Value]

Get the value arguments to this instruction.

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

Get mutable references to the value arguments to this instruction.

pub fn eq<F: Fn(Value) -> Value>( &self, other: &Self, pool: &ValueListPool, mapper: F, ) -> bool

Compare two InstructionData for equality.

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

This operation takes a closure that is allowed to map each argument value to some other value before the instructions are compared. This allows various forms of canonicalization.

pub fn hash<H: Hasher, F: Fn(Value) -> Value>( &self, state: &mut H, pool: &ValueListPool, mapper: F, )

Hash an InstructionData.

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

This operation takes a closure that is allowed to map each argument value to some other value before it is hashed. This allows various forms of canonicalization.

pub fn deep_clone(&self, pool: &mut ValueListPool) -> Self

Deep-clone an InstructionData, including any referenced lists.

This operation requires a reference to a ValueListPool to clone the ValueLists.

impl InstructionData

Analyzing an instruction.

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

pub fn branch_destination<'a>( &'a self, jump_tables: &'a JumpTables, ) -> &'a [BlockCall]

Get the destinations of this instruction, if it’s a branch.

br_table returns the empty slice.

pub fn branch_destination_mut<'a>( &'a mut self, jump_tables: &'a mut JumpTables, ) -> &'a mut [BlockCall]

Get a mutable slice of the destinations of this instruction, if it’s a branch.

br_table returns the empty slice.

pub fn map_values( &mut self, pool: &mut ValueListPool, jump_tables: &mut JumpTables, f: impl FnMut(Value) -> Value, )

Replace the values used in this instruction according to the given function.

pub fn trap_code(&self) -> Option<TrapCode>

If this is a trapping instruction, get its trap code. Otherwise, return None.

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.

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.

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.

pub fn atomic_rmw_op(&self) -> Option<AtomicRmwOp>

If this is an atomic read/modify/write instruction, return its subopcode.

pub fn load_store_offset(&self) -> Option<i32>

If this is a load/store instruction, returns its immediate offset.

pub fn memflags(&self) -> Option<MemFlags>

If this is a load/store instruction, return its memory flags.

pub fn stack_slot(&self) -> Option<StackSlot>

If this instruction references a stack slot, return it

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

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

Converts to this type from the input type.

impl Hash for InstructionData

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for InstructionData

fn eq(&self, other: &InstructionData) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for InstructionData

impl Eq for InstructionData

impl StructuralPartialEq for InstructionData