Trait Opcode

pub trait Opcode<'a>: Inject<'a> {
    // Provided methods
    fn call(&mut self, idx: FunctionID) -> &mut Self { ... }
    fn return_stmt(&mut self) -> &mut Self { ... }
    fn nop(&mut self) -> &mut Self { ... }
    fn unreachable(&mut self) -> &mut Self { ... }
    fn if_stmt(&mut self, block_type: BlockType) -> &mut Self { ... }
    fn else_stmt(&mut self) -> &mut Self { ... }
    fn end(&mut self) -> &mut Self { ... }
    fn block(&mut self, block_type: BlockType) -> &mut Self { ... }
    fn loop_stmt(&mut self, block_type: BlockType) -> &mut Self { ... }
    fn br(&mut self, relative_depth: u32) -> &mut Self { ... }
    fn br_if(&mut self, relative_depth: u32) -> &mut Self { ... }
    fn local_get(&mut self, idx: LocalID) -> &mut Self { ... }
    fn local_set(&mut self, idx: LocalID) -> &mut Self { ... }
    fn local_tee(&mut self, idx: LocalID) -> &mut Self { ... }
    fn i32_const(&mut self, value: i32) -> &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_signed(&mut self) -> &mut Self { ... }
    fn i32_div_unsigned(&mut self) -> &mut Self { ... }
    fn i32_rem_unsigned(&mut self) -> &mut Self { ... }
    fn i32_rem_signed(&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_signed(&mut self) -> &mut Self { ... }
    fn i32_shr_unsigned(&mut self) -> &mut Self { ... }
    fn i32_rotl(&mut self) -> &mut Self { ... }
    fn i32_rotr(&mut self) -> &mut Self { ... }
    fn i32_eq(&mut self) -> &mut Self { ... }
    fn i32_eqz(&mut self) -> &mut Self { ... }
    fn i32_ne(&mut self) -> &mut Self { ... }
    fn i32_lt_unsigned(&mut self) -> &mut Self { ... }
    fn i32_lt_signed(&mut self) -> &mut Self { ... }
    fn i32_gt_unsigned(&mut self) -> &mut Self { ... }
    fn i32_gt_signed(&mut self) -> &mut Self { ... }
    fn i32_lte_unsigned(&mut self) -> &mut Self { ... }
    fn i32_lte_signed(&mut self) -> &mut Self { ... }
    fn i32_gte_unsigned(&mut self) -> &mut Self { ... }
    fn i32_gte_signed(&mut self) -> &mut Self { ... }
    fn i32_wrap_i64(&mut self) -> &mut Self { ... }
    fn i32_extend_8s(&mut self) -> &mut Self { ... }
    fn i32_extend_16s(&mut self) -> &mut Self { ... }
    fn i32_trunc_f32s(&mut self) -> &mut Self { ... }
    fn i32_trunc_f32u(&mut self) -> &mut Self { ... }
    fn i32_trunc_f64s(&mut self) -> &mut Self { ... }
    fn i32_trunc_f64u(&mut self) -> &mut Self { ... }
    fn i32_reinterpret_f32(&mut self) -> &mut Self { ... }
    fn i64_const(&mut self, value: i64) -> &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_signed(&mut self) -> &mut Self { ... }
    fn i64_div_unsigned(&mut self) -> &mut Self { ... }
    fn i64_rem_unsigned(&mut self) -> &mut Self { ... }
    fn i64_rem_signed(&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_signed(&mut self) -> &mut Self { ... }
    fn i64_shr_unsigned(&mut self) -> &mut Self { ... }
    fn i64_rotl(&mut self) -> &mut Self { ... }
    fn i64_rotr(&mut self) -> &mut Self { ... }
    fn i64_eq(&mut self) -> &mut Self { ... }
    fn i64_eqz(&mut self) -> &mut Self { ... }
    fn i64_ne(&mut self) -> &mut Self { ... }
    fn i64_lt_unsigned(&mut self) -> &mut Self { ... }
    fn i64_lt_signed(&mut self) -> &mut Self { ... }
    fn i64_gt_unsigned(&mut self) -> &mut Self { ... }
    fn i64_gt_signed(&mut self) -> &mut Self { ... }
    fn i64_lte_unsigned(&mut self) -> &mut Self { ... }
    fn i64_lte_signed(&mut self) -> &mut Self { ... }
    fn i64_gte_unsigned(&mut self) -> &mut Self { ... }
    fn i64_gte_signed(&mut self) -> &mut Self { ... }
    fn i64_extend_i32u(&mut self) -> &mut Self { ... }
    fn i64_extend_i32s(&mut self) -> &mut Self { ... }
    fn i64_trunc_f32s(&mut self) -> &mut Self { ... }
    fn i64_trunc_f32u(&mut self) -> &mut Self { ... }
    fn i64_trunc_f64s(&mut self) -> &mut Self { ... }
    fn i64_trunc_f64u(&mut self) -> &mut Self { ... }
    fn i64_reinterpret_f64(&mut self) -> &mut Self { ... }
    fn f32_const(&mut self, val: f32) -> &mut Self { ... }
    fn f32_abs(&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_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_eq(&mut self) -> &mut Self { ... }
    fn f32_ne(&mut self) -> &mut Self { ... }
    fn f32_gt(&mut self) -> &mut Self { ... }
    fn f32_ge(&mut self) -> &mut Self { ... }
    fn f32_lt(&mut self) -> &mut Self { ... }
    fn f32_le(&mut self) -> &mut Self { ... }
    fn f32_convert_i32s(&mut self) -> &mut Self { ... }
    fn f32_convert_i32u(&mut self) -> &mut Self { ... }
    fn f32_convert_i64s(&mut self) -> &mut Self { ... }
    fn f32_convert_i64u(&mut self) -> &mut Self { ... }
    fn f32_demote_f64(&mut self) -> &mut Self { ... }
    fn f32_reinterpret_i32(&mut self) -> &mut Self { ... }
    fn f32_copysign(&mut self) -> &mut Self { ... }
    fn f64_const(&mut self, val: f64) -> &mut Self { ... }
    fn f64_abs(&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_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_eq(&mut self) -> &mut Self { ... }
    fn f64_ne(&mut self) -> &mut Self { ... }
    fn f64_gt(&mut self) -> &mut Self { ... }
    fn f64_ge(&mut self) -> &mut Self { ... }
    fn f64_lt(&mut self) -> &mut Self { ... }
    fn f64_le(&mut self) -> &mut Self { ... }
    fn f64_reinterpret_i64(&mut self) -> &mut Self { ... }
    fn f64_promote_f32(&mut self) -> &mut Self { ... }
    fn f64_convert_i32s(&mut self) -> &mut Self { ... }
    fn f64_convert_i32u(&mut self) -> &mut Self { ... }
    fn f64_convert_i64s(&mut self) -> &mut Self { ... }
    fn f64_convert_i64u(&mut self) -> &mut Self { ... }
    fn f64_copysign(&mut self) -> &mut Self { ... }
    fn memory_init(&mut self, data_index: u32, mem: u32) -> &mut Self { ... }
    fn memory_size(&mut self, mem: u32) -> &mut Self { ... }
    fn memory_grow(&mut self, mem: u32) -> &mut Self { ... }
    fn memory_fill(&mut self, mem: u32) -> &mut Self { ... }
    fn memory_copy(&mut self, dst_mem: u32, src_mem: u32) -> &mut Self { ... }
    fn memory_discard(&mut self, mem: u32) -> &mut Self { ... }
    fn data_drop(&mut self, data_index: u32) -> &mut Self { ... }
    fn drop(&mut self) -> &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 i32_load(&mut self, memarg: MemArg) -> &mut Self { ... }
    fn i32_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_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 i64_load(&mut self, memarg: MemArg) -> &mut Self { ... }
    fn i64_store(&mut self, memarg: MemArg) -> &mut Self { ... }
    fn f32_load(&mut self, memarg: MemArg) -> &mut Self { ... }
    fn f32_store(&mut self, memarg: MemArg) -> &mut Self { ... }
    fn f64_load(&mut self, memarg: MemArg) -> &mut Self { ... }
    fn f64_store(&mut self, memarg: MemArg) -> &mut Self { ... }
    fn global_get(&mut self, idx: GlobalID) -> &mut Self { ... }
    fn global_set(&mut self, idx: GlobalID) -> &mut Self { ... }
    fn ref_null(&mut self, heap_type: HeapType) -> &mut Self { ... }
    fn ref_is_null(&mut self) -> &mut Self { ... }
    fn ref_func(&mut self, function_index: u32) -> &mut Self { ... }
    fn ref_eq(&mut self) -> &mut Self { ... }
    fn ref_as_non_null(&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_dest: 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 ref_test(&mut self, heap_type: HeapType) -> &mut Self { ... }
    fn ref_test_null(&mut self, heap_type: HeapType) -> &mut Self { ... }
    fn ref_cast(&mut self, heap_type: HeapType) -> &mut Self { ... }
    fn ref_cast_null(&mut self, heap_type: HeapType) -> &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 { ... }
}

Defines injection behaviour. Takes a wasmparser::Operator and instructions are defined here.

Provided Methods

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

Inject a call instruction

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

Inject a return statement

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

Inject a no op instruction

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

Inject an unreachable instruction

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

Inject an if statement

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

Inject an else statement

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

Inject an end statement. Indicates the end of the current scope

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

Inject a block statement. Indicates the start of a block

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

Inject a loop statement

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

Inject a break statement

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

Inject a conditional break statement

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

Inject a local.get

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

Inject a local.set

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

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

Inject an i32.const instruction

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

Inject an i32.add instruction

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

Inject an i32.sub instruction

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

Inject an i32.mul instruction

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

Inject an i32.divs instruction

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

Inject an i32.divu instruction

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

Inject an i32.remu instruction

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

Inject an i32.rems instruction

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

Inject an i32.and instruction

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

Inject an i32.or instruction

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

Inject an i32.xor instruction

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

Inject an i32.shl instruction

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

Inject an i32.shrs instruction

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

Inject an i32.shru instruction

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

Inject an i32.rotl instruction

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

Inject and i32.rotr instruction

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

Inject an i32.eq instruction

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

Inject an i32.eqz instruction

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

Inject an i32.ne instruction

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

Inject an i32.ltu instruction

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

Inject an i32.lts instruction

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

Inject an i32.gtu instruction

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

Inject an i32.gts instruction

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

Inject an i32.lteu instruction

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

Inject an i32.ltes instruction

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

Inject an i32.gteu instruction

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

Inject an i32.gtes instruction

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

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

Inject a i32.extend_8s instruction

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

Inject a i32.extend_16s instruction

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

Inject a i32.trunc_f32s instruction

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

Inject a i32.trunc_f32u instruction

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

Inject a i32.trunc_f64s instruction

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

Inject a i32.trunc_f64u instruction

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

Inject a i32.reinterpret_f32 instruction

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

Inject an i64.const

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

Inject an i64.add instruction

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

Inject an i64.sub instruction

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

Inject an i64.mul instruction

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

Inject an i64.divs instruction

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

Inject an i64.divu instruction

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

Inject an i64.remu instruction

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

Inject an i64.rems instruction

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

Inject an i64.and instruction

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

Inject an i64.or instruction

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

Inject an i64.xor instruction

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

Inject an i64.shl instruction

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

Inject an i64.shrs instruction

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

Inject an i64.shru instruction

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

Inject an i64.rotl instruction

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

Inject an i64.rotr instruction

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

Inject an i64.eq instruction

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

Inject an i64.eqz instruction

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

Inject an i64.ne instruction

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

Inject an i64.ltu instruction

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

Inject an i64.lts instruction

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

Inject an i64.gtu instruction

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

Inject an i64.gts instruction

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

Inject an i64.lteu instruction

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

Inject an i64.ltes instruction

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

Inject an i64.gteu instruction

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

Inject an i64.gtes instruction

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

Inject a i64.extend_i32_u instruction

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

Inject a i64.extend_i32_s instruction

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

Inject a i64.trunc_f32s instruction

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

Inject a i64.trunc_f32u instruction

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

Inject a i64.trunc_f64s instruction

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

Inject a i64.trunc_f64u instruction

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

Inject a i64.reinterpret_f64 instruction

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

Inject a f32.const instruction

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

Inject a f32.abs instruction

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

Inject a f32.ceil instruction

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

Inject a f32.floor instruction

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

Inject a f32.trunc instruction

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

Inject a f32.sqrt instruction

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

Inject a f32.add instruction

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

Inject a f32.sub instruction

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

Inject a f32.mul instruction

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

Inject a f32.div instruction

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

Inject a f32.min instruction

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

Inject a f32.max instruction

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

Inject a f32.eq instruction

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

Inject a f32.ne instruction

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

Inject a f32.gt instruction

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

Inject a f32.ge instruction

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

Inject a f32.lt instruction

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

Inject a f32.le instruction

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

Inject a f32_convert_i32s instruction

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

Inject a f32_convert_i32u instruction

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

Inject a f32_convert_i64s instruction

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

Inject a f32_convert_i64u instruction

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

Inject a f32_demote_f64 instruction

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

Inject a f32.reinterpret_i32 instruction

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

Inject a f32.copysign instruction

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

Inject a f64.const instruction

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

Inject a f64.abs instruction

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

Inject a f64.ceil instruction

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

Inject a f64.floor instruction

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

Inject a f64.trunc instruction

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

Inject a f64.sqrt instruction

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

Inject a f64.add instruction

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

Inject a f64.sub instruction

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

Inject a f64.mul instruction

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

Inject a f64.div instruction

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

Inject a f64.min instruction

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

Inject a f64.max instruction

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

Inject a f64.eq instruction

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

Inject a f64.ne instruction

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

Inject a f64.gt instruction

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

Inject a f64.ge instruction

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

Inject a f64.lt instruction

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

Inject a f64.le instruction

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

Inject a f64_reinterpret_i64 instruction

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

Inject a f64_promote_f32 instruction

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

Inject a f64_convert_i32s instruction

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

Inject a f64_convert_i32u instruction

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

Inject a f64_convert_i64s instruction

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

Inject a f64_convert_i64u instruction

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

Inject a f64.copysign instruction

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

Inject a memory.init instruction

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

Inject a memory.size instruction

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

Inject a memory.grow instruction

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

Inject a memory.fill instruction

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

Inject a memory.copy instruction

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

Inject a memory.discard instruction

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

Inject a data drop instruction

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

Inject a drop instruction

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

load 1 byte and sign-extend i8 to i32

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

load 1 byte and zero-extend i8 to i32

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

load 2 bytes and sign-extend i16 to i32

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

load 2 bytes and zero-extend i16 to i32

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

load 4 bytes as i32

fn i32_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_load8_s(&mut self, memarg: MemArg) -> &mut Self

load 1 byte and sign-extend i8 to i64

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

load 1 byte and zero-extend i8 to i64

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

load 2 bytes and sign-extend i16 to i64

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

load 2 bytes and zero-extend i16 to i64

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

load 4 bytes and sign-extend i32 to i64

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

load 4 bytes and zero-extend i32 to i64

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

load 4 bytes as i64

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

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

load 4 bytes as f32

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

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

load 8 bytes as f64

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

Inject an f64_store instruction

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

Inject a global.get

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

Inject a global.set

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

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

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

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

fn ref_as_non_null(&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_dest: 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 ref_test(&mut self, heap_type: HeapType) -> &mut Self

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

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

fn ref_cast_null(&mut self, heap_type: HeapType) -> &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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a> Opcode<'a> for FunctionBuilder<'a>

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

impl<'b> Opcode<'b> for FunctionModifier<'_, 'b>

impl<'b> Opcode<'b> for ComponentIterator<'_, 'b>