Struct ModuleIterator 

pub struct ModuleIterator<'a, 'b> {
    pub module: &'a mut Module<'b>,
    /* private fields */
}

Iterator for a Module.

Fields

module: &'a mut Module<'b>

The Module to Iterate

Implementations

impl<'a, 'b> ModuleIterator<'a, 'b>

pub fn new(module: &'a mut Module<'b>, skip_funcs: &Vec<FunctionID>) -> Self

Creates a new ModuleIterator

pub fn curr_op_owned(&self) -> Option<Operator<'b>>

Trait Implementations

impl AddLocal for ModuleIterator<'_, '_>

fn add_local(&mut self, val_type: DataType) -> LocalID

Adds a local and in the current function and returns its ID note: the implementors of this trait will keep track of the location, i.e. which function, where this local is added

impl<'b> Inject<'b> for ModuleIterator<'_, 'b>

fn inject(&mut self, instr: Operator<'b>)

Injects an Operator at the current location

Example

use wirm::ir::module::Module;
use wirm::iterator::module_iterator::ModuleIterator;
use wasmparser::Operator;
use wirm::ir::types::{Location};
use wirm::iterator::iterator_trait::{IteratingInstrumenter, Iterator};
use wirm::opcode::{Instrumenter, Opcode};

let file = "path_to_file";
let buff = wat::parse_file(file).expect("couldn't convert the input wat to Wasm");
// Must use `parse_only_module` here as we are only concerned about a Module and not a module that is inside a Component
let mut module = Module::parse(&buff, false, false).expect("Unable to parse");
let mut module_it = ModuleIterator::new(&mut module, &vec![]);

// Everytime there is a `call 1` instruction we want to inject an `i32.const 0`
let interested = Operator::Call { function_index: 1 };

loop {
    let op = module_it.curr_op();
    let instr_mode = module_it.curr_instrument_mode();

    if let Location::Module {
        func_idx,
        instr_idx,
    } = module_it.curr_loc().0
    {
        if *module_it.curr_op().unwrap() == interested {
            module_it.before().i32_const(1);
        }
        if module_it.next().is_none() {
            break;
        };
    } else {
        // Ensures we only get the location of a module while parsing a component
        panic!("Should've gotten Module Location!");
    }
}

fn inject_all(&mut self, instrs: &[Operator<'a>]) -> &mut Self

Inject multiple operators at the current location

impl<'a> InjectAt<'a> for ModuleIterator<'_, 'a>

fn inject_at( &mut self, idx: usize, mode: InstrumentationMode, instr: Operator<'a>, )

Inject an Instruction at a given Location with a given InstrumentationMode

impl<'a> Instrumenter<'a> for ModuleIterator<'_, 'a>

fn finish_instr(&mut self)

Can be called after finishing some instrumentation to reset the mode.

fn curr_instrument_mode(&self) -> Option<InstrumentationMode>

Returns the Instrumentation at the current Location

fn set_instrument_mode_at(&mut self, mode: InstrumentationMode, loc: Location)

Sets the type of Instrumentation Type of the specified location

fn curr_func_instrument_mode(&self) -> &Option<FuncInstrMode>

Get the InstrumentType of the current function

fn set_func_instrument_mode(&mut self, mode: FuncInstrMode)

Sets the type of Instrumentation Type of the current function

fn curr_instr_len(&self) -> usize

fn clear_instr_at(&mut self, loc: Location, mode: InstrumentationMode)

Clears the instruction at a given Location

fn add_instr_at(&mut self, loc: Location, instr: Operator<'a>)

Splice a new instruction into a specific location

fn empty_alternate_at(&mut self, loc: Location) -> &mut Self

Injects an empty InstrumentationMode Alternate at a given location

fn empty_block_alt_at(&mut self, loc: Location) -> &mut Self

Injects an empty block alternate at a given location

fn append_tag_at(&mut self, data: Vec<u8>, loc: Location) -> &mut Self

fn func_entry(&mut self) -> &mut Self

Mark the current function to InstrumentFuncEntry

fn func_exit(&mut self) -> &mut Self

Mark the current function to InstrumentFuncExit

fn before_at(&mut self, loc: Location) -> &mut Self

Injects an Instruction with InstrumentationMode Before at a given location

fn after_at(&mut self, loc: Location) -> &mut Self

Injects an Instruction with InstrumentationMode After at a given location

fn alternate_at(&mut self, loc: Location) -> &mut Self

Injects an Instruction with InstrumentationMode Alternate at a given location

fn semantic_after_at(&mut self, loc: Location) -> &mut Self

Injects a Semantic After at a given location

fn block_entry_at(&mut self, loc: Location) -> &mut Self

Injects a block entry at a given location

fn block_exit_at(&mut self, loc: Location) -> &mut Self

Injects a block exit at a given location

fn block_alt_at(&mut self, loc: Location) -> &mut Self

Injects a block alternate at a given location

impl<'a> IteratingInstrumenter<'a> for ModuleIterator<'_, 'a>

fn add_global(&mut self, global: Global) -> GlobalID

Adds a global to the current module and returns the Global ID

fn set_instrument_mode(&mut self, mode: InstrumentationMode)

Sets the type of Instrumentation Type of the current location

fn append_to_tag(&mut self, data: Vec<u8>)

Appends the passed data to the tag of the current location.

fn alternate(&mut self) -> &mut Self

Mark the current location to InstrumentAlternate

fn empty_alternate(&mut self) -> &mut Self

Insert an empty alt at the current location Effectively removes the instruction

fn before(&mut self) -> &mut Self

Mark the current location to InstrumentBefore

fn after(&mut self) -> &mut Self

Mark the current location to InstrumentAfter

fn semantic_after(&mut self) -> &mut Self

Mark the current location to InstrumentSemanticAfter

fn block_entry(&mut self) -> &mut Self

Mark the current location to InstrumentBlockEntry

fn block_exit(&mut self) -> &mut Self

Mark the current location to InstrumentBlockExit

fn block_alt(&mut self) -> &mut Self

Mark the current location to InstrumentBlockAlt

fn empty_block_alt(&mut self) -> &mut Self

Insert an empty alt block at the current location Effectively removes the block

impl<'a> Iterator for ModuleIterator<'_, 'a>

fn reset(&mut self)

Resets the Module Iterator

fn next(&mut self) -> Option<&Operator<'_>>

Goes to the next instruction and returns the instruction

fn curr_loc(&self) -> (Location, bool)

Returns the Current Location as a Location and a bool value that says whether the location is at the end of the function.

fn curr_op(&self) -> Option<&Operator<'_>>

Returns the current instruction

impl<'a> MacroOpcode<'a> for ModuleIterator<'_, 'a>

fn u32_const(&mut self, value: u32) -> &mut Self

Reinterpret a u32 as i32 and inject an i32.const.

fn u64_const(&mut self, value: u64) -> &mut Self

Reinterpret a u64 as i64 and inject an i64.const.

impl<'a> Opcode<'a> for ModuleIterator<'_, 'a>

fn unreachable(&mut self) -> &mut Self

fn nop(&mut self) -> &mut Self

fn end(&mut self) -> &mut Self

fn br(&mut self, relative_depth: u32) -> &mut Self

fn br_if(&mut self, relative_depth: u32) -> &mut Self

fn call(&mut self, function_index: FunctionID) -> &mut Self

fn call_indirect( &mut self, type_index: TypeID, table_index: TableID, ) -> &mut Self

fn drop(&mut self) -> &mut Self

fn select(&mut self) -> &mut Self

fn local_get(&mut self, local_index: LocalID) -> &mut Self

fn local_set(&mut self, local_index: LocalID) -> &mut Self

fn local_tee(&mut self, local_index: LocalID) -> &mut Self

fn global_get(&mut self, global_index: GlobalID) -> &mut Self

fn global_set(&mut self, global_index: GlobalID) -> &mut Self

fn i32_load(&mut self, memarg: MemArg) -> &mut Self

fn i64_load(&mut self, memarg: MemArg) -> &mut Self

fn f32_load(&mut self, memarg: MemArg) -> &mut Self

fn f64_load(&mut self, memarg: MemArg) -> &mut Self

fn i32_load8_s(&mut self, memarg: MemArg) -> &mut Self

fn i32_load8_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_load16_s(&mut self, memarg: MemArg) -> &mut Self

fn i32_load16_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_load8_s(&mut self, memarg: MemArg) -> &mut Self

fn i64_load8_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_load16_s(&mut self, memarg: MemArg) -> &mut Self

fn i64_load16_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_load32_s(&mut self, memarg: MemArg) -> &mut Self

fn i64_load32_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_store(&mut self, memarg: MemArg) -> &mut Self

fn i64_store(&mut self, memarg: MemArg) -> &mut Self

fn f32_store(&mut self, memarg: MemArg) -> &mut Self

fn f64_store(&mut self, memarg: MemArg) -> &mut Self

fn i32_store8(&mut self, memarg: MemArg) -> &mut Self

fn i32_store16(&mut self, memarg: MemArg) -> &mut Self

fn i64_store8(&mut self, memarg: MemArg) -> &mut Self

fn i64_store16(&mut self, memarg: MemArg) -> &mut Self

fn i64_store32(&mut self, memarg: MemArg) -> &mut Self

fn memory_size(&mut self, mem: MemoryID) -> &mut Self

fn memory_grow(&mut self, mem: MemoryID) -> &mut Self

fn i32_const(&mut self, value: i32) -> &mut Self

fn i64_const(&mut self, value: i64) -> &mut Self

fn i32_eqz(&mut self) -> &mut Self

fn i32_eq(&mut self) -> &mut Self

fn i32_ne(&mut self) -> &mut Self

fn i32_lt_s(&mut self) -> &mut Self

fn i32_lt_u(&mut self) -> &mut Self

fn i32_gt_s(&mut self) -> &mut Self

fn i32_gt_u(&mut self) -> &mut Self

fn i32_le_s(&mut self) -> &mut Self

fn i32_le_u(&mut self) -> &mut Self

fn i32_ge_s(&mut self) -> &mut Self

fn i32_ge_u(&mut self) -> &mut Self

fn i64_eqz(&mut self) -> &mut Self

fn i64_eq(&mut self) -> &mut Self

fn i64_ne(&mut self) -> &mut Self

fn i64_lt_s(&mut self) -> &mut Self

fn i64_lt_u(&mut self) -> &mut Self

fn i64_gt_s(&mut self) -> &mut Self

fn i64_gt_u(&mut self) -> &mut Self

fn i64_le_s(&mut self) -> &mut Self

fn i64_le_u(&mut self) -> &mut Self

fn i64_ge_s(&mut self) -> &mut Self

fn i64_ge_u(&mut self) -> &mut Self

fn f32_eq(&mut self) -> &mut Self

fn f32_ne(&mut self) -> &mut Self

fn f32_lt(&mut self) -> &mut Self

fn f32_gt(&mut self) -> &mut Self

fn f32_le(&mut self) -> &mut Self

fn f32_ge(&mut self) -> &mut Self

fn f64_eq(&mut self) -> &mut Self

fn f64_ne(&mut self) -> &mut Self

fn f64_lt(&mut self) -> &mut Self

fn f64_gt(&mut self) -> &mut Self

fn f64_le(&mut self) -> &mut Self

fn f64_ge(&mut self) -> &mut Self

fn i32_clz(&mut self) -> &mut Self

fn i32_ctz(&mut self) -> &mut Self

fn i32_popcnt(&mut self) -> &mut Self

fn i32_add(&mut self) -> &mut Self

fn i32_sub(&mut self) -> &mut Self

fn i32_mul(&mut self) -> &mut Self

fn i32_div_s(&mut self) -> &mut Self

fn i32_div_u(&mut self) -> &mut Self

fn i32_rem_s(&mut self) -> &mut Self

fn i32_rem_u(&mut self) -> &mut Self

fn i32_and(&mut self) -> &mut Self

fn i32_or(&mut self) -> &mut Self

fn i32_xor(&mut self) -> &mut Self

fn i32_shl(&mut self) -> &mut Self

fn i32_shr_s(&mut self) -> &mut Self

fn i32_shr_u(&mut self) -> &mut Self

fn i32_rotl(&mut self) -> &mut Self

fn i32_rotr(&mut self) -> &mut Self

fn i64_clz(&mut self) -> &mut Self

fn i64_ctz(&mut self) -> &mut Self

fn i64_popcnt(&mut self) -> &mut Self

fn i64_add(&mut self) -> &mut Self

fn i64_sub(&mut self) -> &mut Self

fn i64_mul(&mut self) -> &mut Self

fn i64_div_s(&mut self) -> &mut Self

fn i64_div_u(&mut self) -> &mut Self

fn i64_rem_s(&mut self) -> &mut Self

fn i64_rem_u(&mut self) -> &mut Self

fn i64_and(&mut self) -> &mut Self

fn i64_or(&mut self) -> &mut Self

fn i64_xor(&mut self) -> &mut Self

fn i64_shl(&mut self) -> &mut Self

fn i64_shr_s(&mut self) -> &mut Self

fn i64_shr_u(&mut self) -> &mut Self

fn i64_rotl(&mut self) -> &mut Self

fn i64_rotr(&mut self) -> &mut Self

fn f32_abs(&mut self) -> &mut Self

fn f32_neg(&mut self) -> &mut Self

fn f32_ceil(&mut self) -> &mut Self

fn f32_floor(&mut self) -> &mut Self

fn f32_trunc(&mut self) -> &mut Self

fn f32_nearest(&mut self) -> &mut Self

fn f32_sqrt(&mut self) -> &mut Self

fn f32_add(&mut self) -> &mut Self

fn f32_sub(&mut self) -> &mut Self

fn f32_mul(&mut self) -> &mut Self

fn f32_div(&mut self) -> &mut Self

fn f32_min(&mut self) -> &mut Self

fn f32_max(&mut self) -> &mut Self

fn f32_copysign(&mut self) -> &mut Self

fn f64_abs(&mut self) -> &mut Self

fn f64_neg(&mut self) -> &mut Self

fn f64_ceil(&mut self) -> &mut Self

fn f64_floor(&mut self) -> &mut Self

fn f64_trunc(&mut self) -> &mut Self

fn f64_nearest(&mut self) -> &mut Self

fn f64_sqrt(&mut self) -> &mut Self

fn f64_add(&mut self) -> &mut Self

fn f64_sub(&mut self) -> &mut Self

fn f64_mul(&mut self) -> &mut Self

fn f64_div(&mut self) -> &mut Self

fn f64_min(&mut self) -> &mut Self

fn f64_max(&mut self) -> &mut Self

fn f64_copysign(&mut self) -> &mut Self

fn i32_wrap_i64(&mut self) -> &mut Self

fn i32_trunc_f32_s(&mut self) -> &mut Self

fn i32_trunc_f32_u(&mut self) -> &mut Self

fn i32_trunc_f64_s(&mut self) -> &mut Self

fn i32_trunc_f64_u(&mut self) -> &mut Self

fn i64_extend_i32_s(&mut self) -> &mut Self

fn i64_extend_i32_u(&mut self) -> &mut Self

fn i64_trunc_f32_s(&mut self) -> &mut Self

fn i64_trunc_f32_u(&mut self) -> &mut Self

fn i64_trunc_f64_s(&mut self) -> &mut Self

fn i64_trunc_f64_u(&mut self) -> &mut Self

fn f32_convert_i32_s(&mut self) -> &mut Self

fn f32_convert_i32_u(&mut self) -> &mut Self

fn f32_convert_i64_s(&mut self) -> &mut Self

fn f32_convert_i64_u(&mut self) -> &mut Self

fn f32_demote_f64(&mut self) -> &mut Self

fn f64_convert_i32_s(&mut self) -> &mut Self

fn f64_convert_i32_u(&mut self) -> &mut Self

fn f64_convert_i64_s(&mut self) -> &mut Self

fn f64_convert_i64_u(&mut self) -> &mut Self

fn f64_promote_f32(&mut self) -> &mut Self

fn i32_reinterpret_f32(&mut self) -> &mut Self

fn i64_reinterpret_f64(&mut self) -> &mut Self

fn f32_reinterpret_i32(&mut self) -> &mut Self

fn f64_reinterpret_i64(&mut self) -> &mut Self

fn i32_extend8_s(&mut self) -> &mut Self

fn i32_extend16_s(&mut self) -> &mut Self

fn i64_extend8_s(&mut self) -> &mut Self

fn i64_extend16_s(&mut self) -> &mut Self

fn i64_extend32_s(&mut self) -> &mut Self

fn ref_eq(&mut self) -> &mut Self

fn struct_new(&mut self, struct_type_index: TypeID) -> &mut Self

fn struct_new_default(&mut self, struct_type_index: TypeID) -> &mut Self

fn struct_get( &mut self, struct_type_index: TypeID, field_index: FieldID, ) -> &mut Self

fn struct_get_s( &mut self, struct_type_index: TypeID, field_index: FieldID, ) -> &mut Self

fn struct_get_u( &mut self, struct_type_index: TypeID, field_index: FieldID, ) -> &mut Self

fn struct_set( &mut self, struct_type_index: TypeID, field_index: FieldID, ) -> &mut Self

fn array_new(&mut self, array_type_index: TypeID) -> &mut Self

fn array_new_default(&mut self, array_type_index: TypeID) -> &mut Self

fn array_new_fixed( &mut self, array_type_index: TypeID, array_size: u32, ) -> &mut Self

fn array_new_data( &mut self, array_type_index: TypeID, array_data_index: DataSegmentID, ) -> &mut Self

fn array_new_elem( &mut self, array_type_index: TypeID, array_elem_index: ElementID, ) -> &mut Self

fn array_get(&mut self, array_type_index: TypeID) -> &mut Self

fn array_get_s(&mut self, array_type_index: TypeID) -> &mut Self

fn array_get_u(&mut self, array_type_index: TypeID) -> &mut Self

fn array_set(&mut self, array_type_index: TypeID) -> &mut Self

fn array_len(&mut self) -> &mut Self

fn array_fill(&mut self, array_type_index: TypeID) -> &mut Self

fn array_copy( &mut self, array_type_index_dst: TypeID, array_type_index_src: TypeID, ) -> &mut Self

fn array_init_data( &mut self, array_type_index: TypeID, array_data_index: DataSegmentID, ) -> &mut Self

fn array_init_elem( &mut self, array_type_index: TypeID, array_elem_index: ElementID, ) -> &mut Self

fn any_convert_extern(&mut self) -> &mut Self

fn extern_convert_any(&mut self) -> &mut Self

fn ref_i31(&mut self) -> &mut Self

fn i31_get_s(&mut self) -> &mut Self

fn i31_get_u(&mut self) -> &mut Self

fn struct_new_desc(&mut self, struct_type_index: TypeID) -> &mut Self

fn struct_new_default_desc(&mut self, struct_type_index: TypeID) -> &mut Self

fn ref_get_desc(&mut self, type_index: TypeID) -> &mut Self

fn i32_trunc_sat_f32_s(&mut self) -> &mut Self

fn i32_trunc_sat_f32_u(&mut self) -> &mut Self

fn i32_trunc_sat_f64_s(&mut self) -> &mut Self

fn i32_trunc_sat_f64_u(&mut self) -> &mut Self

fn i64_trunc_sat_f32_s(&mut self) -> &mut Self

fn i64_trunc_sat_f32_u(&mut self) -> &mut Self

fn i64_trunc_sat_f64_s(&mut self) -> &mut Self

fn i64_trunc_sat_f64_u(&mut self) -> &mut Self

fn memory_init(&mut self, data_index: DataSegmentID, mem: MemoryID) -> &mut Self

fn data_drop(&mut self, data_index: DataSegmentID) -> &mut Self

fn memory_copy(&mut self, dst_mem: MemoryID, src_mem: MemoryID) -> &mut Self

fn memory_fill(&mut self, mem: MemoryID) -> &mut Self

fn table_init(&mut self, elem_index: ElementID, table: TableID) -> &mut Self

fn elem_drop(&mut self, elem_index: ElementID) -> &mut Self

fn table_copy(&mut self, dst_table: TableID, src_table: TableID) -> &mut Self

fn ref_is_null(&mut self) -> &mut Self

fn ref_func(&mut self, function_index: FunctionID) -> &mut Self

fn table_fill(&mut self, table: TableID) -> &mut Self

fn table_get(&mut self, table: TableID) -> &mut Self

fn table_set(&mut self, table: TableID) -> &mut Self

fn table_grow(&mut self, table: TableID) -> &mut Self

fn table_size(&mut self, table: TableID) -> &mut Self

fn return_call(&mut self, function_index: FunctionID) -> &mut Self

fn return_call_indirect( &mut self, type_index: TypeID, table_index: TableID, ) -> &mut Self

fn memory_discard(&mut self, mem: MemoryID) -> &mut Self

fn memory_atomic_notify(&mut self, memarg: MemArg) -> &mut Self

fn memory_atomic_wait32(&mut self, memarg: MemArg) -> &mut Self

fn memory_atomic_wait64(&mut self, memarg: MemArg) -> &mut Self

fn atomic_fence(&mut self) -> &mut Self

fn i32_atomic_load(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_load(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_load8_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_load16_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_load8_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_load16_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_load32_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_store(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_store(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_store8(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_store16(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_store8(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_store16(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_store32(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw_add(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw_add(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw8_add_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw16_add_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw8_add_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw16_add_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw32_add_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw_sub(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw_sub(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw8_sub_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw16_sub_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw8_sub_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw16_sub_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw32_sub_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw_and(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw_and(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw8_and_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw16_and_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw8_and_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw16_and_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw32_and_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw_or(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw_or(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw8_or_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw16_or_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw8_or_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw16_or_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw32_or_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw_xor(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw_xor(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw8_xor_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw16_xor_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw8_xor_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw16_xor_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw32_xor_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw_xchg(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw_xchg(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw8_xchg_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw16_xchg_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw8_xchg_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw16_xchg_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw32_xchg_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw_cmpxchg(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw_cmpxchg(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw8_cmpxchg_u(&mut self, memarg: MemArg) -> &mut Self

fn i32_atomic_rmw16_cmpxchg_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw8_cmpxchg_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw16_cmpxchg_u(&mut self, memarg: MemArg) -> &mut Self

fn i64_atomic_rmw32_cmpxchg_u(&mut self, memarg: MemArg) -> &mut Self

fn v128_load(&mut self, memarg: MemArg) -> &mut Self

fn v128_load8x8_s(&mut self, memarg: MemArg) -> &mut Self

fn v128_load8x8_u(&mut self, memarg: MemArg) -> &mut Self

fn v128_load16x4_s(&mut self, memarg: MemArg) -> &mut Self

fn v128_load16x4_u(&mut self, memarg: MemArg) -> &mut Self

fn v128_load32x2_s(&mut self, memarg: MemArg) -> &mut Self

fn v128_load32x2_u(&mut self, memarg: MemArg) -> &mut Self

fn v128_load8_splat(&mut self, memarg: MemArg) -> &mut Self

fn v128_load16_splat(&mut self, memarg: MemArg) -> &mut Self

fn v128_load32_splat(&mut self, memarg: MemArg) -> &mut Self

fn v128_load64_splat(&mut self, memarg: MemArg) -> &mut Self

fn v128_load32_zero(&mut self, memarg: MemArg) -> &mut Self

fn v128_load64_zero(&mut self, memarg: MemArg) -> &mut Self

fn v128_store(&mut self, memarg: MemArg) -> &mut Self

fn v128_load8_lane(&mut self, memarg: MemArg, lane: u8) -> &mut Self

fn v128_load16_lane(&mut self, memarg: MemArg, lane: u8) -> &mut Self

fn v128_load32_lane(&mut self, memarg: MemArg, lane: u8) -> &mut Self

fn v128_load64_lane(&mut self, memarg: MemArg, lane: u8) -> &mut Self

fn v128_store8_lane(&mut self, memarg: MemArg, lane: u8) -> &mut Self

fn v128_store16_lane(&mut self, memarg: MemArg, lane: u8) -> &mut Self

fn v128_store32_lane(&mut self, memarg: MemArg, lane: u8) -> &mut Self

fn v128_store64_lane(&mut self, memarg: MemArg, lane: u8) -> &mut Self

fn v128_const(&mut self, value: V128) -> &mut Self

fn i8x16_shuffle(&mut self, lanes: [u8; 16]) -> &mut Self

fn i8x16_extract_lane_s(&mut self, lane: u8) -> &mut Self

fn i8x16_extract_lane_u(&mut self, lane: u8) -> &mut Self

fn i8x16_replace_lane(&mut self, lane: u8) -> &mut Self

fn i16x8_extract_lane_s(&mut self, lane: u8) -> &mut Self

fn i16x8_extract_lane_u(&mut self, lane: u8) -> &mut Self

fn i16x8_replace_lane(&mut self, lane: u8) -> &mut Self

fn i32x4_extract_lane(&mut self, lane: u8) -> &mut Self

fn i32x4_replace_lane(&mut self, lane: u8) -> &mut Self

fn i64x2_extract_lane(&mut self, lane: u8) -> &mut Self

fn i64x2_replace_lane(&mut self, lane: u8) -> &mut Self

fn f32x4_extract_lane(&mut self, lane: u8) -> &mut Self

fn f32x4_replace_lane(&mut self, lane: u8) -> &mut Self

fn f64x2_extract_lane(&mut self, lane: u8) -> &mut Self

fn f64x2_replace_lane(&mut self, lane: u8) -> &mut Self

fn i8x16_swizzle(&mut self) -> &mut Self

fn i8x16_splat(&mut self) -> &mut Self

fn i16x8_splat(&mut self) -> &mut Self

fn i32x4_splat(&mut self) -> &mut Self

fn i64x2_splat(&mut self) -> &mut Self

fn f32x4_splat(&mut self) -> &mut Self

fn f64x2_splat(&mut self) -> &mut Self

fn i8x16_eq(&mut self) -> &mut Self

fn i8x16_ne(&mut self) -> &mut Self

fn i8x16_lt_s(&mut self) -> &mut Self

fn i8x16_lt_u(&mut self) -> &mut Self

fn i8x16_gt_s(&mut self) -> &mut Self

fn i8x16_gt_u(&mut self) -> &mut Self

fn i8x16_le_s(&mut self) -> &mut Self

fn i8x16_le_u(&mut self) -> &mut Self

fn i8x16_ge_s(&mut self) -> &mut Self

fn i8x16_ge_u(&mut self) -> &mut Self

fn i16x8_eq(&mut self) -> &mut Self

fn i16x8_ne(&mut self) -> &mut Self

fn i16x8_lt_s(&mut self) -> &mut Self

fn i16x8_lt_u(&mut self) -> &mut Self

fn i16x8_gt_s(&mut self) -> &mut Self

fn i16x8_gt_u(&mut self) -> &mut Self

fn i16x8_le_s(&mut self) -> &mut Self

fn i16x8_le_u(&mut self) -> &mut Self

fn i16x8_ge_s(&mut self) -> &mut Self

fn i16x8_ge_u(&mut self) -> &mut Self

fn i32x4_eq(&mut self) -> &mut Self

fn i32x4_ne(&mut self) -> &mut Self

fn i32x4_lt_s(&mut self) -> &mut Self

fn i32x4_lt_u(&mut self) -> &mut Self

fn i32x4_gt_s(&mut self) -> &mut Self

fn i32x4_gt_u(&mut self) -> &mut Self

fn i32x4_le_s(&mut self) -> &mut Self

fn i32x4_le_u(&mut self) -> &mut Self

fn i32x4_ge_s(&mut self) -> &mut Self

fn i32x4_ge_u(&mut self) -> &mut Self

fn i64x2_eq(&mut self) -> &mut Self

fn i64x2_ne(&mut self) -> &mut Self

fn i64x2_lt_s(&mut self) -> &mut Self

fn i64x2_gt_s(&mut self) -> &mut Self

fn i64x2_le_s(&mut self) -> &mut Self

fn i64x2_ge_s(&mut self) -> &mut Self

fn f32x4_eq(&mut self) -> &mut Self

fn f32x4_ne(&mut self) -> &mut Self

fn f32x4_lt(&mut self) -> &mut Self

fn f32x4_gt(&mut self) -> &mut Self

fn f32x4_le(&mut self) -> &mut Self

fn f32x4_ge(&mut self) -> &mut Self

fn f64x2_eq(&mut self) -> &mut Self

fn f64x2_ne(&mut self) -> &mut Self

fn f64x2_lt(&mut self) -> &mut Self

fn f64x2_gt(&mut self) -> &mut Self

fn f64x2_le(&mut self) -> &mut Self

fn f64x2_ge(&mut self) -> &mut Self

fn v128_not(&mut self) -> &mut Self

fn v128_and(&mut self) -> &mut Self

fn v128_and_not(&mut self) -> &mut Self

fn v128_or(&mut self) -> &mut Self

fn v128_xor(&mut self) -> &mut Self

fn v128_bitselect(&mut self) -> &mut Self

fn v128_any_true(&mut self) -> &mut Self

fn i8x16_abs(&mut self) -> &mut Self

fn i8x16_neg(&mut self) -> &mut Self

fn i8x16_popcnt(&mut self) -> &mut Self

fn i8x16_all_true(&mut self) -> &mut Self

fn i8x16_bitmask(&mut self) -> &mut Self

fn i8x16_narrow_i16x8_s(&mut self) -> &mut Self

fn i8x16_narrow_i16x8_u(&mut self) -> &mut Self

fn i8x16_shl(&mut self) -> &mut Self

fn i8x16_shr_s(&mut self) -> &mut Self

fn i8x16_shr_u(&mut self) -> &mut Self

fn i8x16_add(&mut self) -> &mut Self

fn i8x16_add_sat_s(&mut self) -> &mut Self

fn i8x16_add_sat_u(&mut self) -> &mut Self

fn i8x16_sub(&mut self) -> &mut Self

fn i8x16_sub_sat_s(&mut self) -> &mut Self

fn i8x16_sub_sat_u(&mut self) -> &mut Self

fn i8x16_min_s(&mut self) -> &mut Self

fn i8x16_min_u(&mut self) -> &mut Self

fn i8x16_max_s(&mut self) -> &mut Self

fn i8x16_max_u(&mut self) -> &mut Self

fn i8x16_avgr_u(&mut self) -> &mut Self

fn i16x8_ext_add_pairwise_i8x16_s(&mut self) -> &mut Self

fn i16x8_ext_add_pairwise_i8x16_u(&mut self) -> &mut Self

fn i16x8_abs(&mut self) -> &mut Self

fn i16x8_neg(&mut self) -> &mut Self

fn i16x8_q15_mulr_sat_s(&mut self) -> &mut Self

fn i16x8_all_true(&mut self) -> &mut Self

fn i16x8_bitmask(&mut self) -> &mut Self

fn i16x8_narrow_i32x4_s(&mut self) -> &mut Self

fn i16x8_narrow_i32x4_u(&mut self) -> &mut Self

fn i16x8_extend_low_i8x16_s(&mut self) -> &mut Self

fn i16x8_extend_high_i8x16_s(&mut self) -> &mut Self

fn i16x8_extend_low_i8x16_u(&mut self) -> &mut Self

fn i16x8_extend_high_i8x16_u(&mut self) -> &mut Self

fn i16x8_shl(&mut self) -> &mut Self

fn i16x8_shr_s(&mut self) -> &mut Self

fn i16x8_shr_u(&mut self) -> &mut Self

fn i16x8_add(&mut self) -> &mut Self

fn i16x8_add_sat_s(&mut self) -> &mut Self

fn i16x8_add_sat_u(&mut self) -> &mut Self

fn i16x8_sub(&mut self) -> &mut Self

fn i16x8_sub_sat_s(&mut self) -> &mut Self

fn i16x8_sub_sat_u(&mut self) -> &mut Self

fn i16x8_mul(&mut self) -> &mut Self

fn i16x8_min_s(&mut self) -> &mut Self

fn i16x8_min_u(&mut self) -> &mut Self

fn i16x8_max_s(&mut self) -> &mut Self

fn i16x8_max_u(&mut self) -> &mut Self

fn i16x8_avgr_u(&mut self) -> &mut Self

fn i16x8_ext_mul_low_i8x16_s(&mut self) -> &mut Self

fn i16x8_ext_mul_high_i8x16_s(&mut self) -> &mut Self

fn i16x8_ext_mul_low_i8x16_u(&mut self) -> &mut Self

fn i16x8_ext_mul_high_i8x16_u(&mut self) -> &mut Self

fn i32x4_ext_add_pairwise_i16x8_s(&mut self) -> &mut Self

fn i32x4_ext_add_pairwise_i16x8_u(&mut self) -> &mut Self

fn i32x4_abs(&mut self) -> &mut Self

fn i32x4_neg(&mut self) -> &mut Self

fn i32x4_all_true(&mut self) -> &mut Self

fn i32x4_bitmask(&mut self) -> &mut Self

fn i32x4_extend_low_i16x8_s(&mut self) -> &mut Self

fn i32x4_extend_high_i16x8_s(&mut self) -> &mut Self

fn i32x4_extend_low_i16x8_u(&mut self) -> &mut Self

fn i32x4_extend_high_i16x8_u(&mut self) -> &mut Self

fn i32x4_shl(&mut self) -> &mut Self

fn i32x4_shr_s(&mut self) -> &mut Self

fn i32x4_shr_u(&mut self) -> &mut Self

fn i32x4_add(&mut self) -> &mut Self

fn i32x4_sub(&mut self) -> &mut Self

fn i32x4_mul(&mut self) -> &mut Self

fn i32x4_min_s(&mut self) -> &mut Self

fn i32x4_min_u(&mut self) -> &mut Self

fn i32x4_max_s(&mut self) -> &mut Self

fn i32x4_max_u(&mut self) -> &mut Self

fn i32x4_dot_i16x8_s(&mut self) -> &mut Self

fn i32x4_ext_mul_low_i16x8_s(&mut self) -> &mut Self

fn i32x4_ext_mul_high_i16x8_s(&mut self) -> &mut Self

fn i32x4_ext_mul_low_i16x8_u(&mut self) -> &mut Self

fn i32x4_ext_mul_high_i16x8_u(&mut self) -> &mut Self

fn i64x2_abs(&mut self) -> &mut Self

fn i64x2_neg(&mut self) -> &mut Self

fn i64x2_all_true(&mut self) -> &mut Self

fn i64x2_bitmask(&mut self) -> &mut Self

fn i64x2_extend_low_i32x4_s(&mut self) -> &mut Self

fn i64x2_extend_high_i32x4_s(&mut self) -> &mut Self

fn i64x2_extend_low_i32x4_u(&mut self) -> &mut Self

fn i64x2_extend_high_i32x4_u(&mut self) -> &mut Self

fn i64x2_shl(&mut self) -> &mut Self

fn i64x2_shr_s(&mut self) -> &mut Self

fn i64x2_shr_u(&mut self) -> &mut Self

fn i64x2_add(&mut self) -> &mut Self

fn i64x2_sub(&mut self) -> &mut Self

fn i64x2_mul(&mut self) -> &mut Self

fn i64x2_ext_mul_low_i32x4_s(&mut self) -> &mut Self

fn i64x2_ext_mul_high_i32x4_s(&mut self) -> &mut Self

fn i64x2_ext_mul_low_i32x4_u(&mut self) -> &mut Self

fn i64x2_ext_mul_high_i32x4_u(&mut self) -> &mut Self

fn f32x4_ceil(&mut self) -> &mut Self

fn f32x4_floor(&mut self) -> &mut Self

fn f32x4_trunc(&mut self) -> &mut Self

fn f32x4_nearest(&mut self) -> &mut Self

fn f32x4_abs(&mut self) -> &mut Self

fn f32x4_neg(&mut self) -> &mut Self

fn f32x4_sqrt(&mut self) -> &mut Self

fn f32x4_add(&mut self) -> &mut Self

fn f32x4_sub(&mut self) -> &mut Self

fn f32x4_mul(&mut self) -> &mut Self

fn f32x4_div(&mut self) -> &mut Self

fn f32x4_min(&mut self) -> &mut Self

fn f32x4_max(&mut self) -> &mut Self

fn f32x4_p_min(&mut self) -> &mut Self

fn f32x4_p_max(&mut self) -> &mut Self

fn f64x2_ceil(&mut self) -> &mut Self

fn f64x2_floor(&mut self) -> &mut Self

fn f64x2_trunc(&mut self) -> &mut Self

fn f64x2_nearest(&mut self) -> &mut Self

fn f64x2_abs(&mut self) -> &mut Self

fn f64x2_neg(&mut self) -> &mut Self

fn f64x2_sqrt(&mut self) -> &mut Self

fn f64x2_add(&mut self) -> &mut Self

fn f64x2_sub(&mut self) -> &mut Self

fn f64x2_mul(&mut self) -> &mut Self

fn f64x2_div(&mut self) -> &mut Self

fn f64x2_min(&mut self) -> &mut Self

fn f64x2_max(&mut self) -> &mut Self

fn f64x2_p_min(&mut self) -> &mut Self

fn f64x2_p_max(&mut self) -> &mut Self

fn i32x4_trunc_sat_f32x4_s(&mut self) -> &mut Self

fn i32x4_trunc_sat_f32x4_u(&mut self) -> &mut Self

fn f32x4_convert_i32x4_s(&mut self) -> &mut Self

fn f32x4_convert_i32x4_u(&mut self) -> &mut Self

fn i32x4_trunc_sat_f64x2_s_zero(&mut self) -> &mut Self

fn i32x4_trunc_sat_f64x2_u_zero(&mut self) -> &mut Self

fn f64x2_convert_low_i32x4_s(&mut self) -> &mut Self

fn f64x2_convert_low_i32x4_u(&mut self) -> &mut Self

fn f32x4_demote_f64x2_zero(&mut self) -> &mut Self

fn f64x2_promote_low_f32x4(&mut self) -> &mut Self

fn i8x16_relaxed_swizzle(&mut self) -> &mut Self

fn i32x4_relaxed_trunc_f32x4_s(&mut self) -> &mut Self

fn i32x4_relaxed_trunc_f32x4_u(&mut self) -> &mut Self

fn i32x4_relaxed_trunc_f64x2_s_zero(&mut self) -> &mut Self

fn i32x4_relaxed_trunc_f64x2_u_zero(&mut self) -> &mut Self

fn f32x4_relaxed_madd(&mut self) -> &mut Self

fn f32x4_relaxed_nmadd(&mut self) -> &mut Self

fn f64x2_relaxed_madd(&mut self) -> &mut Self

fn f64x2_relaxed_nmadd(&mut self) -> &mut Self

fn i8x16_relaxed_laneselect(&mut self) -> &mut Self

fn i16x8_relaxed_laneselect(&mut self) -> &mut Self

fn i32x4_relaxed_laneselect(&mut self) -> &mut Self

fn i64x2_relaxed_laneselect(&mut self) -> &mut Self

fn f32x4_relaxed_min(&mut self) -> &mut Self

fn f32x4_relaxed_max(&mut self) -> &mut Self

fn f64x2_relaxed_min(&mut self) -> &mut Self

fn f64x2_relaxed_max(&mut self) -> &mut Self

fn i16x8_relaxed_q15mulr_s(&mut self) -> &mut Self

fn i16x8_relaxed_dot_i8x16_i7x16_s(&mut self) -> &mut Self

fn i32x4_relaxed_dot_i8x16_i7x16_add_s(&mut self) -> &mut Self

fn throw(&mut self, tag_index: u32) -> &mut Self

fn throw_ref(&mut self) -> &mut Self

fn catch(&mut self, tag_index: u32) -> &mut Self

fn rethrow(&mut self, relative_depth: u32) -> &mut Self

fn delegate(&mut self, relative_depth: u32) -> &mut Self

fn catch_all(&mut self) -> &mut Self

fn call_ref(&mut self, type_index: TypeID) -> &mut Self

fn return_call_ref(&mut self, type_index: TypeID) -> &mut Self

fn ref_as_non_null(&mut self) -> &mut Self

fn br_on_null(&mut self, relative_depth: u32) -> &mut Self

fn br_on_non_null(&mut self, relative_depth: u32) -> &mut Self

fn i64_add128(&mut self) -> &mut Self

fn i64_sub128(&mut self) -> &mut Self

fn i64_mul_wide_s(&mut self) -> &mut Self

fn i64_mul_wide_u(&mut self) -> &mut Self

fn block(&mut self, block_type: BlockType) -> &mut Self

Inject a block instruction.

fn loop_stmt(&mut self, block_type: BlockType) -> &mut Self

Inject a loop instruction (loop is a Rust keyword; use loop_stmt).

fn if_stmt(&mut self, block_type: BlockType) -> &mut Self

Inject an if instruction (if is a Rust keyword; use if_stmt).

fn else_stmt(&mut self) -> &mut Self

Inject an else instruction (else is a Rust keyword; use else_stmt).

fn return_stmt(&mut self) -> &mut Self

Inject a return instruction (return is a Rust keyword; use return_stmt).

fn f32_const(&mut self, val: f32) -> &mut Self

Inject an f32.const instruction from a Rust f32.

fn f64_const(&mut self, val: f64) -> &mut Self

Inject an f64.const instruction from a Rust f64.

fn br_table( &mut self, default: u32, labels: impl IntoIterator<Item = u32>, ) -> &mut Self

Inject a br_table instruction with the given target labels and default.

fn ref_null(&mut self, heap_type: HeapType) -> &mut Self

Inject a ref.null instruction using wirm’s HeapType.

fn ref_test(&mut self, heap_type: HeapType) -> &mut Self

Inject a ref.test (non-null) instruction.

fn ref_test_null(&mut self, heap_type: HeapType) -> &mut Self

Inject a ref.test null (nullable) instruction.

fn ref_cast(&mut self, heap_type: HeapType) -> &mut Self

Inject a ref.cast (non-null) instruction.

fn ref_cast_null(&mut self, heap_type: HeapType) -> &mut Self

Inject a ref.cast null (nullable) instruction.

fn ref_cast_desc(&mut self, heap_type: HeapType) -> &mut Self

Inject a ref.cast_desc (non-null) instruction. Custom-descriptors proposal.

fn ref_cast_desc_null(&mut self, heap_type: HeapType) -> &mut Self

Inject a ref.cast_desc null (nullable) instruction. Custom-descriptors proposal.

fn typed_select(&mut self, ty: ValType) -> &mut Self

Inject a select instruction annotated with a single value type.

fn typed_select_multi(&mut self, tys: Vec<ValType>) -> &mut Self

Inject a select instruction annotated with multiple value types.

fn br_on_cast( &mut self, relative_depth: u32, from_ref_type: RefType, to_ref_type: RefType, ) -> &mut Self

Inject a br_on_cast instruction.

fn br_on_cast_fail( &mut self, relative_depth: u32, from_ref_type: RefType, to_ref_type: RefType, ) -> &mut Self

Inject a br_on_cast_fail instruction.

fn br_on_cast_desc( &mut self, relative_depth: u32, from_ref_type: RefType, to_ref_type: RefType, ) -> &mut Self

Inject a br_on_cast_desc instruction. Custom-descriptors proposal.

fn br_on_cast_desc_fail( &mut self, relative_depth: u32, from_ref_type: RefType, to_ref_type: RefType, ) -> &mut Self

Inject a br_on_cast_desc_fail instruction. Custom-descriptors proposal.

fn try_table(&mut self, ty: BlockType, catches: Vec<Catch>) -> &mut Self

Inject a try_table instruction with the given block type and catch clauses.

fn try_stmt(&mut self, block_type: BlockType) -> &mut Self

Inject a legacy try instruction (try is a Rust keyword; use try_stmt). Superseded by try_table in the exception-handling proposal.