Struct Function

pub struct Function {
    pub abi: Option<Abi>,
    pub backtrace: Backtrace,
    pub control: ControlStack,
    pub env: Env,
    pub locals: Locals,
    pub masm: MacroAssembler,
    pub table: JumpTable,
    pub ty: FuncType,
    pub is_main: bool,
}

The code generation abstraction.

Fields

abi: Option<Abi>

Abi of this function,

backtrace: Backtrace

The backtrace.

control: ControlStack

Control stack frames.

env: Env

WASM environment.

locals: Locals

The defined locals for a function.

masm: MacroAssembler

The macro assembler.

table: JumpTable

The jump table.

ty: FuncType

The function type.

is_main: bool

If this function is the main function.

Implementations

impl Function

pub fn new( env: Env, ty: FuncType, abi: Option<Abi>, is_main: bool, ) -> Result<Self>

Create a new code generator.

pub fn emit_locals( &mut self, locals: &mut LocalsReader<'_>, validator: &mut FuncValidator<ValidatorResources>, ) -> Result<()>

Emit function locals

1. the function parameters.
2. function body locals.

NOTE: we don’t care about the original offset of the locals. bcz we will serialize the locals to an index map anyway.

pub fn emit_operators( &mut self, ops: &mut OperatorsReader<'_>, validator: &mut FuncValidator<ValidatorResources>, ) -> Result<()>

Emit function operators.

pub fn finish(self, jump_table: &mut JumpTable, pc: u16) -> Result<Buffer>

Finish code generation.

impl Function

pub fn _call_indirect( &mut self, _type_index: u32, _table_index: u32, _table_byte: u8, ) -> Result<()>

The call indirect instruction calls a function indirectly
through an operand indexing into a table.

pub fn _call(&mut self, index: u32) -> Result<()>

Calls a function specified by its index.

This function determines whether the function is an external import or an internal function. If it is an external function, it will call the call_imported method. Otherwise, it will call the call_internal method to handle the internal function call.

Panics

If an attempt is made to call an external function internally, this function will panic.

fn call_internal(&mut self, index: u32) -> Result<()>

Calls an internal function specified by its index.

This function handles the mechanics of calling an internal function, including:

• Checking for recursion and returning an error if detected.
• Recording the current program counter (PC) to manage the return address.
• Adjusting the stack to accommodate parameters and the return address.
• Storing parameters in memory and registering the call index in the jump table.

Errors

Returns an error if recursion is detected or if the function index is invalid.

fn call_imported(&mut self, index: u32) -> Result<()>

Calls an imported function specified by its index.

This function retrieves the imported function from the environment and executes it. It handles various host functions and ensures that the correct operations are performed based on the function type.

Errors

Returns an error if the imported function is not found or if an unsupported host function is encountered.

impl Function

pub fn _if(&mut self, blockty: BlockType) -> Result<()>

The beginning of an if construct with an implicit block.

pub fn _block(&mut self, blockty: BlockType) -> Result<()>

The begeinning of a block construct. A sequence of instructions with a label at the end.

pub fn _loop(&mut self, blockty: BlockType) -> Result<()>

A block with a label which may be used to form loops.

pub fn _else(&mut self) -> Result<()>

Marks an else block of an if.

pub fn _select(&mut self) -> Result<()>

The select instruction selects one of its first two operands based on whether its third oprand is zero or not.

STACK: [cond, val2, val1] -> [val1] if cond is non-zero, [val2] otherwise.

pub fn _br(&mut self, _depth: u32) -> Result<()>

Branch to a given label in an enclosing construct.

Performs an unconditional branch.

pub fn _br_if(&mut self, depth: u32) -> Result<()>

Performs a conditional branch if i32 is non-zero.

Conditional branch to a given label in an enclosing construct.

pub fn _br_table(&mut self, _table: BrTable<'_>) -> Result<()>

A jump table which jumps to a label in an enclosing construct.

Performs an indirect branch through an operand indexing into the label vector that is an immediate to the instruction, or to the default target if the operand is out of bounds.

pub fn _end(&mut self) -> Result<()>

Handle the end of instructions for different situations.

• End of control flow operators.
• End of function.
• End of program.

pub fn _unreachable(&mut self) -> Result<()>

Mark as invalid for now.

TODO: recheck this implementation, if it is okay, provide more docs.

pub fn _nop(&mut self) -> Result<()>

Perform nothing in EVM bytecode.

pub(crate) fn handle_frame_popping( &mut self, frame: ControlStackFrame, ) -> Result<()>

Handle the popping of a frame.

TODO: validate stack IO for all frames (#59)

impl Function

pub fn _local_get(&mut self, local_index: u32) -> Result<()>

This instruction gets the value of a variable.

pub fn _local_set(&mut self, local_index: u32) -> Result<()>

This instruction sets the value of a variable.

pub fn _local_tee(&mut self, index: u32) -> Result<()>

This _local_tee is like _local_set, but it also returns the value on the stack.

pub fn _global_get(&mut self, _: u32) -> Result<()>

This instruction gets the value of a variable.

pub fn _global_set(&mut self, _: u32) -> Result<()>

This instruction sets the value of a variable.

fn _local_get_calldata(&mut self, local_index: usize) -> Result<()>

Local get from calldata.

fn _local_get_var(&mut self, local_index: usize) -> Result<()>

Local get for variables.

impl Function

fn data(&mut self) -> Result<(i32, i32)>

Parse log data from the bytecode.

WASM example:

i32.const 1048576   ;; offset
i32.const 4         ;; 4 bytes

pub fn log(&mut self, count: usize) -> Result<()>

Log a message with topics.

pub fn revert(&mut self, count: usize) -> Result<()>

Revert with message.

Trait Implementations

impl VisitOperator<'_> for Function

type Output = Result<(), Error>

The result type of the visitor.

fn visit_try_table(&mut self, try_table: TryTable) -> Self::Output

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

fn visit_throw_ref(&mut self) -> Self::Output

fn visit_try(&mut self, blockty: BlockType) -> Self::Output

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

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

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

fn visit_catch_all(&mut self) -> Self::Output

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

fn visit_return_call_indirect( &mut self, type_index: u32, table_index: u32, ) -> Self::Output

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

fn visit_ref_null(&mut self, hty: HeapType) -> Self::Output

fn visit_ref_is_null(&mut self) -> Self::Output

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

fn visit_ref_eq(&mut self) -> Self::Output

fn visit_i32_extend8_s(&mut self) -> Self::Output

fn visit_i32_extend16_s(&mut self) -> Self::Output

fn visit_i64_extend8_s(&mut self) -> Self::Output

fn visit_i64_extend16_s(&mut self) -> Self::Output

fn visit_i64_extend32_s(&mut self) -> Self::Output

fn visit_struct_new(&mut self, struct_type_index: u32) -> Self::Output

fn visit_struct_new_default(&mut self, struct_type_index: u32) -> Self::Output

fn visit_struct_get( &mut self, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_get_s( &mut self, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_get_u( &mut self, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_struct_set( &mut self, struct_type_index: u32, field_index: u32, ) -> Self::Output

fn visit_array_new(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_new_default(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_new_fixed( &mut self, array_type_index: u32, array_size: u32, ) -> Self::Output

fn visit_array_new_data( &mut self, array_type_index: u32, array_data_index: u32, ) -> Self::Output

fn visit_array_new_elem( &mut self, array_type_index: u32, array_elem_index: u32, ) -> Self::Output

fn visit_array_get(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_get_s(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_get_u(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_set(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_len(&mut self) -> Self::Output

fn visit_array_fill(&mut self, array_type_index: u32) -> Self::Output

fn visit_array_copy( &mut self, array_type_index_dst: u32, array_type_index_src: u32, ) -> Self::Output

fn visit_array_init_data( &mut self, array_type_index: u32, array_data_index: u32, ) -> Self::Output

fn visit_array_init_elem( &mut self, array_type_index: u32, array_elem_index: u32, ) -> Self::Output

fn visit_ref_test_non_null(&mut self, hty: HeapType) -> Self::Output

fn visit_ref_test_nullable(&mut self, hty: HeapType) -> Self::Output

fn visit_ref_cast_non_null(&mut self, hty: HeapType) -> Self::Output

fn visit_ref_cast_nullable(&mut self, hty: HeapType) -> Self::Output

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

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

fn visit_any_convert_extern(&mut self) -> Self::Output

fn visit_extern_convert_any(&mut self) -> Self::Output

fn visit_ref_i31(&mut self) -> Self::Output

fn visit_i31_get_s(&mut self) -> Self::Output

fn visit_i31_get_u(&mut self) -> Self::Output

fn visit_i32_trunc_sat_f32_s(&mut self) -> Self::Output

fn visit_i32_trunc_sat_f32_u(&mut self) -> Self::Output

fn visit_i32_trunc_sat_f64_s(&mut self) -> Self::Output

fn visit_i32_trunc_sat_f64_u(&mut self) -> Self::Output

fn visit_i64_trunc_sat_f32_s(&mut self) -> Self::Output

fn visit_i64_trunc_sat_f32_u(&mut self) -> Self::Output

fn visit_i64_trunc_sat_f64_s(&mut self) -> Self::Output

fn visit_i64_trunc_sat_f64_u(&mut self) -> Self::Output

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

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

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

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

fn visit_table_init(&mut self, elem_index: u32, table: u32) -> Self::Output

fn visit_elem_drop(&mut self, elem_index: u32) -> Self::Output

fn visit_table_copy(&mut self, dst_table: u32, src_table: u32) -> Self::Output

fn visit_table_fill(&mut self, table: u32) -> Self::Output

fn visit_table_get(&mut self, table: u32) -> Self::Output

fn visit_table_set(&mut self, table: u32) -> Self::Output

fn visit_table_grow(&mut self, table: u32) -> Self::Output

fn visit_table_size(&mut self, table: u32) -> Self::Output

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

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

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

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

fn visit_atomic_fence(&mut self) -> Self::Output

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn visit_i8x16_swizzle(&mut self) -> Self::Output

fn visit_i8x16_splat(&mut self) -> Self::Output

fn visit_i16x8_splat(&mut self) -> Self::Output

fn visit_i32x4_splat(&mut self) -> Self::Output

fn visit_i64x2_splat(&mut self) -> Self::Output

fn visit_f32x4_splat(&mut self) -> Self::Output

fn visit_f64x2_splat(&mut self) -> Self::Output

fn visit_i8x16_eq(&mut self) -> Self::Output

fn visit_i8x16_ne(&mut self) -> Self::Output

fn visit_i8x16_lt_s(&mut self) -> Self::Output

fn visit_i8x16_lt_u(&mut self) -> Self::Output

fn visit_i8x16_gt_s(&mut self) -> Self::Output

fn visit_i8x16_gt_u(&mut self) -> Self::Output

fn visit_i8x16_le_s(&mut self) -> Self::Output

fn visit_i8x16_le_u(&mut self) -> Self::Output

fn visit_i8x16_ge_s(&mut self) -> Self::Output

fn visit_i8x16_ge_u(&mut self) -> Self::Output

fn visit_i16x8_eq(&mut self) -> Self::Output

fn visit_i16x8_ne(&mut self) -> Self::Output

fn visit_i16x8_lt_s(&mut self) -> Self::Output

fn visit_i16x8_lt_u(&mut self) -> Self::Output

fn visit_i16x8_gt_s(&mut self) -> Self::Output

fn visit_i16x8_gt_u(&mut self) -> Self::Output

fn visit_i16x8_le_s(&mut self) -> Self::Output

fn visit_i16x8_le_u(&mut self) -> Self::Output

fn visit_i16x8_ge_s(&mut self) -> Self::Output

fn visit_i16x8_ge_u(&mut self) -> Self::Output

fn visit_i32x4_eq(&mut self) -> Self::Output

fn visit_i32x4_ne(&mut self) -> Self::Output

fn visit_i32x4_lt_s(&mut self) -> Self::Output

fn visit_i32x4_lt_u(&mut self) -> Self::Output

fn visit_i32x4_gt_s(&mut self) -> Self::Output

fn visit_i32x4_gt_u(&mut self) -> Self::Output

fn visit_i32x4_le_s(&mut self) -> Self::Output

fn visit_i32x4_le_u(&mut self) -> Self::Output

fn visit_i32x4_ge_s(&mut self) -> Self::Output

fn visit_i32x4_ge_u(&mut self) -> Self::Output

fn visit_i64x2_eq(&mut self) -> Self::Output

fn visit_i64x2_ne(&mut self) -> Self::Output

fn visit_i64x2_lt_s(&mut self) -> Self::Output

fn visit_i64x2_gt_s(&mut self) -> Self::Output

fn visit_i64x2_le_s(&mut self) -> Self::Output

fn visit_i64x2_ge_s(&mut self) -> Self::Output

fn visit_f32x4_eq(&mut self) -> Self::Output

fn visit_f32x4_ne(&mut self) -> Self::Output

fn visit_f32x4_lt(&mut self) -> Self::Output

fn visit_f32x4_gt(&mut self) -> Self::Output

fn visit_f32x4_le(&mut self) -> Self::Output

fn visit_f32x4_ge(&mut self) -> Self::Output

fn visit_f64x2_eq(&mut self) -> Self::Output

fn visit_f64x2_ne(&mut self) -> Self::Output

fn visit_f64x2_lt(&mut self) -> Self::Output

fn visit_f64x2_gt(&mut self) -> Self::Output

fn visit_f64x2_le(&mut self) -> Self::Output

fn visit_f64x2_ge(&mut self) -> Self::Output

fn visit_v128_not(&mut self) -> Self::Output

fn visit_v128_and(&mut self) -> Self::Output

fn visit_v128_andnot(&mut self) -> Self::Output

fn visit_v128_or(&mut self) -> Self::Output

fn visit_v128_xor(&mut self) -> Self::Output

fn visit_v128_bitselect(&mut self) -> Self::Output

fn visit_v128_any_true(&mut self) -> Self::Output

fn visit_i8x16_abs(&mut self) -> Self::Output

fn visit_i8x16_neg(&mut self) -> Self::Output

fn visit_i8x16_popcnt(&mut self) -> Self::Output

fn visit_i8x16_all_true(&mut self) -> Self::Output

fn visit_i8x16_bitmask(&mut self) -> Self::Output

fn visit_i8x16_narrow_i16x8_s(&mut self) -> Self::Output

fn visit_i8x16_narrow_i16x8_u(&mut self) -> Self::Output

fn visit_i8x16_shl(&mut self) -> Self::Output

fn visit_i8x16_shr_s(&mut self) -> Self::Output

fn visit_i8x16_shr_u(&mut self) -> Self::Output

fn visit_i8x16_add(&mut self) -> Self::Output

fn visit_i8x16_add_sat_s(&mut self) -> Self::Output

fn visit_i8x16_add_sat_u(&mut self) -> Self::Output

fn visit_i8x16_sub(&mut self) -> Self::Output

fn visit_i8x16_sub_sat_s(&mut self) -> Self::Output

fn visit_i8x16_sub_sat_u(&mut self) -> Self::Output

fn visit_i8x16_min_s(&mut self) -> Self::Output

fn visit_i8x16_min_u(&mut self) -> Self::Output

fn visit_i8x16_max_s(&mut self) -> Self::Output

fn visit_i8x16_max_u(&mut self) -> Self::Output

fn visit_i8x16_avgr_u(&mut self) -> Self::Output

fn visit_i16x8_extadd_pairwise_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extadd_pairwise_i8x16_u(&mut self) -> Self::Output

fn visit_i16x8_abs(&mut self) -> Self::Output

fn visit_i16x8_neg(&mut self) -> Self::Output

fn visit_i16x8_q15mulr_sat_s(&mut self) -> Self::Output

fn visit_i16x8_all_true(&mut self) -> Self::Output

fn visit_i16x8_bitmask(&mut self) -> Self::Output

fn visit_i16x8_narrow_i32x4_s(&mut self) -> Self::Output

fn visit_i16x8_narrow_i32x4_u(&mut self) -> Self::Output

fn visit_i16x8_extend_low_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extend_high_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extend_low_i8x16_u(&mut self) -> Self::Output

fn visit_i16x8_extend_high_i8x16_u(&mut self) -> Self::Output

fn visit_i16x8_shl(&mut self) -> Self::Output

fn visit_i16x8_shr_s(&mut self) -> Self::Output

fn visit_i16x8_shr_u(&mut self) -> Self::Output

fn visit_i16x8_add(&mut self) -> Self::Output

fn visit_i16x8_add_sat_s(&mut self) -> Self::Output

fn visit_i16x8_add_sat_u(&mut self) -> Self::Output

fn visit_i16x8_sub(&mut self) -> Self::Output

fn visit_i16x8_sub_sat_s(&mut self) -> Self::Output

fn visit_i16x8_sub_sat_u(&mut self) -> Self::Output

fn visit_i16x8_mul(&mut self) -> Self::Output

fn visit_i16x8_min_s(&mut self) -> Self::Output

fn visit_i16x8_min_u(&mut self) -> Self::Output

fn visit_i16x8_max_s(&mut self) -> Self::Output

fn visit_i16x8_max_u(&mut self) -> Self::Output

fn visit_i16x8_avgr_u(&mut self) -> Self::Output

fn visit_i16x8_extmul_low_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extmul_high_i8x16_s(&mut self) -> Self::Output

fn visit_i16x8_extmul_low_i8x16_u(&mut self) -> Self::Output

fn visit_i16x8_extmul_high_i8x16_u(&mut self) -> Self::Output

fn visit_i32x4_extadd_pairwise_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extadd_pairwise_i16x8_u(&mut self) -> Self::Output

fn visit_i32x4_abs(&mut self) -> Self::Output

fn visit_i32x4_neg(&mut self) -> Self::Output

fn visit_i32x4_all_true(&mut self) -> Self::Output

fn visit_i32x4_bitmask(&mut self) -> Self::Output

fn visit_i32x4_extend_low_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extend_high_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extend_low_i16x8_u(&mut self) -> Self::Output

fn visit_i32x4_extend_high_i16x8_u(&mut self) -> Self::Output

fn visit_i32x4_shl(&mut self) -> Self::Output

fn visit_i32x4_shr_s(&mut self) -> Self::Output

fn visit_i32x4_shr_u(&mut self) -> Self::Output

fn visit_i32x4_add(&mut self) -> Self::Output

fn visit_i32x4_sub(&mut self) -> Self::Output

fn visit_i32x4_mul(&mut self) -> Self::Output

fn visit_i32x4_min_s(&mut self) -> Self::Output

fn visit_i32x4_min_u(&mut self) -> Self::Output

fn visit_i32x4_max_s(&mut self) -> Self::Output

fn visit_i32x4_max_u(&mut self) -> Self::Output

fn visit_i32x4_dot_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extmul_low_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extmul_high_i16x8_s(&mut self) -> Self::Output

fn visit_i32x4_extmul_low_i16x8_u(&mut self) -> Self::Output

fn visit_i32x4_extmul_high_i16x8_u(&mut self) -> Self::Output

fn visit_i64x2_abs(&mut self) -> Self::Output

fn visit_i64x2_neg(&mut self) -> Self::Output

fn visit_i64x2_all_true(&mut self) -> Self::Output

fn visit_i64x2_bitmask(&mut self) -> Self::Output

fn visit_i64x2_extend_low_i32x4_s(&mut self) -> Self::Output

fn visit_i64x2_extend_high_i32x4_s(&mut self) -> Self::Output

fn visit_i64x2_extend_low_i32x4_u(&mut self) -> Self::Output

fn visit_i64x2_extend_high_i32x4_u(&mut self) -> Self::Output

fn visit_i64x2_shl(&mut self) -> Self::Output

fn visit_i64x2_shr_s(&mut self) -> Self::Output

fn visit_i64x2_shr_u(&mut self) -> Self::Output

fn visit_i64x2_add(&mut self) -> Self::Output

fn visit_i64x2_sub(&mut self) -> Self::Output

fn visit_i64x2_mul(&mut self) -> Self::Output

fn visit_i64x2_extmul_low_i32x4_s(&mut self) -> Self::Output

fn visit_i64x2_extmul_high_i32x4_s(&mut self) -> Self::Output

fn visit_i64x2_extmul_low_i32x4_u(&mut self) -> Self::Output

fn visit_i64x2_extmul_high_i32x4_u(&mut self) -> Self::Output

fn visit_f32x4_ceil(&mut self) -> Self::Output

fn visit_f32x4_floor(&mut self) -> Self::Output

fn visit_f32x4_trunc(&mut self) -> Self::Output

fn visit_f32x4_nearest(&mut self) -> Self::Output

fn visit_f32x4_abs(&mut self) -> Self::Output

fn visit_f32x4_neg(&mut self) -> Self::Output

fn visit_f32x4_sqrt(&mut self) -> Self::Output

fn visit_f32x4_add(&mut self) -> Self::Output

fn visit_f32x4_sub(&mut self) -> Self::Output

fn visit_f32x4_mul(&mut self) -> Self::Output

fn visit_f32x4_div(&mut self) -> Self::Output

fn visit_f32x4_min(&mut self) -> Self::Output

fn visit_f32x4_max(&mut self) -> Self::Output

fn visit_f32x4_pmin(&mut self) -> Self::Output

fn visit_f32x4_pmax(&mut self) -> Self::Output

fn visit_f64x2_ceil(&mut self) -> Self::Output

fn visit_f64x2_floor(&mut self) -> Self::Output

fn visit_f64x2_trunc(&mut self) -> Self::Output

fn visit_f64x2_nearest(&mut self) -> Self::Output

fn visit_f64x2_abs(&mut self) -> Self::Output

fn visit_f64x2_neg(&mut self) -> Self::Output

fn visit_f64x2_sqrt(&mut self) -> Self::Output

fn visit_f64x2_add(&mut self) -> Self::Output

fn visit_f64x2_sub(&mut self) -> Self::Output

fn visit_f64x2_mul(&mut self) -> Self::Output

fn visit_f64x2_div(&mut self) -> Self::Output

fn visit_f64x2_min(&mut self) -> Self::Output

fn visit_f64x2_max(&mut self) -> Self::Output

fn visit_f64x2_pmin(&mut self) -> Self::Output

fn visit_f64x2_pmax(&mut self) -> Self::Output

fn visit_i32x4_trunc_sat_f32x4_s(&mut self) -> Self::Output

fn visit_i32x4_trunc_sat_f32x4_u(&mut self) -> Self::Output

fn visit_f32x4_convert_i32x4_s(&mut self) -> Self::Output

fn visit_f32x4_convert_i32x4_u(&mut self) -> Self::Output

fn visit_i32x4_trunc_sat_f64x2_s_zero(&mut self) -> Self::Output

fn visit_i32x4_trunc_sat_f64x2_u_zero(&mut self) -> Self::Output

fn visit_f64x2_convert_low_i32x4_s(&mut self) -> Self::Output

fn visit_f64x2_convert_low_i32x4_u(&mut self) -> Self::Output

fn visit_f32x4_demote_f64x2_zero(&mut self) -> Self::Output

fn visit_f64x2_promote_low_f32x4(&mut self) -> Self::Output

fn visit_i8x16_relaxed_swizzle(&mut self) -> Self::Output

fn visit_i32x4_relaxed_trunc_f32x4_s(&mut self) -> Self::Output

fn visit_i32x4_relaxed_trunc_f32x4_u(&mut self) -> Self::Output

fn visit_i32x4_relaxed_trunc_f64x2_s_zero(&mut self) -> Self::Output

fn visit_i32x4_relaxed_trunc_f64x2_u_zero(&mut self) -> Self::Output

fn visit_f32x4_relaxed_madd(&mut self) -> Self::Output

fn visit_f32x4_relaxed_nmadd(&mut self) -> Self::Output

fn visit_f64x2_relaxed_madd(&mut self) -> Self::Output

fn visit_f64x2_relaxed_nmadd(&mut self) -> Self::Output

fn visit_i8x16_relaxed_laneselect(&mut self) -> Self::Output

fn visit_i16x8_relaxed_laneselect(&mut self) -> Self::Output

fn visit_i32x4_relaxed_laneselect(&mut self) -> Self::Output

fn visit_i64x2_relaxed_laneselect(&mut self) -> Self::Output

fn visit_f32x4_relaxed_min(&mut self) -> Self::Output

fn visit_f32x4_relaxed_max(&mut self) -> Self::Output

fn visit_f64x2_relaxed_min(&mut self) -> Self::Output

fn visit_f64x2_relaxed_max(&mut self) -> Self::Output

fn visit_i16x8_relaxed_q15mulr_s(&mut self) -> Self::Output

fn visit_i16x8_relaxed_dot_i8x16_i7x16_s(&mut self) -> Self::Output

fn visit_i32x4_relaxed_dot_i8x16_i7x16_add_s(&mut self) -> Self::Output

fn visit_call_ref(&mut self, type_index: u32) -> Self::Output

fn visit_return_call_ref(&mut self, type_index: u32) -> Self::Output

fn visit_ref_as_non_null(&mut self) -> Self::Output

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

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

fn visit_i32_add(&mut self) -> Self::Output

fn visit_i64_add(&mut self) -> Self::Output

fn visit_f32_add(&mut self) -> Self::Output

fn visit_f64_add(&mut self) -> Self::Output

fn visit_i32_sub(&mut self) -> Self::Output

fn visit_i64_sub(&mut self) -> Self::Output

fn visit_f32_sub(&mut self) -> Self::Output

fn visit_f64_sub(&mut self) -> Self::Output

fn visit_i32_mul(&mut self) -> Self::Output

fn visit_i64_mul(&mut self) -> Self::Output

fn visit_f32_mul(&mut self) -> Self::Output

fn visit_f64_mul(&mut self) -> Self::Output

fn visit_i32_eq(&mut self) -> Self::Output

fn visit_i64_eq(&mut self) -> Self::Output

fn visit_f32_eq(&mut self) -> Self::Output

fn visit_f64_eq(&mut self) -> Self::Output

fn visit_i32_ne(&mut self) -> Self::Output

fn visit_i64_ne(&mut self) -> Self::Output

fn visit_f32_ne(&mut self) -> Self::Output

fn visit_f64_ne(&mut self) -> Self::Output

fn visit_i32_div_s(&mut self) -> Self::Output

fn visit_i64_div_s(&mut self) -> Self::Output

fn visit_i32_div_u(&mut self) -> Self::Output

fn visit_i64_div_u(&mut self) -> Self::Output

fn visit_f32_div(&mut self) -> Self::Output

fn visit_f64_div(&mut self) -> Self::Output

fn visit_i32_lt_s(&mut self) -> Self::Output

fn visit_i64_lt_s(&mut self) -> Self::Output

fn visit_i32_lt_u(&mut self) -> Self::Output

fn visit_i64_lt_u(&mut self) -> Self::Output

fn visit_f32_lt(&mut self) -> Self::Output

fn visit_f64_lt(&mut self) -> Self::Output

fn visit_i32_gt_s(&mut self) -> Self::Output

fn visit_i64_gt_s(&mut self) -> Self::Output

fn visit_i32_gt_u(&mut self) -> Self::Output

fn visit_i64_gt_u(&mut self) -> Self::Output

fn visit_f32_gt(&mut self) -> Self::Output

fn visit_f64_gt(&mut self) -> Self::Output

fn visit_i32_ge_s(&mut self) -> Self::Output

fn visit_i64_ge_s(&mut self) -> Self::Output

fn visit_i32_ge_u(&mut self) -> Self::Output

fn visit_i64_ge_u(&mut self) -> Self::Output

fn visit_f32_ge(&mut self) -> Self::Output

fn visit_f64_ge(&mut self) -> Self::Output

fn visit_i32_le_s(&mut self) -> Self::Output

fn visit_i64_le_s(&mut self) -> Self::Output

fn visit_i32_le_u(&mut self) -> Self::Output

fn visit_i64_le_u(&mut self) -> Self::Output

fn visit_f32_le(&mut self) -> Self::Output

fn visit_f64_le(&mut self) -> Self::Output

fn visit_i32_and(&mut self) -> Self::Output

fn visit_i64_and(&mut self) -> Self::Output

fn visit_i32_clz(&mut self) -> Self::Output

fn visit_i64_clz(&mut self) -> Self::Output

fn visit_i32_ctz(&mut self) -> Self::Output

fn visit_i64_ctz(&mut self) -> Self::Output

fn visit_i32_eqz(&mut self) -> Self::Output

fn visit_i64_eqz(&mut self) -> Self::Output

fn visit_i32_or(&mut self) -> Self::Output

fn visit_i64_or(&mut self) -> Self::Output

fn visit_i32_popcnt(&mut self) -> Self::Output

fn visit_i64_popcnt(&mut self) -> Self::Output

fn visit_i32_rotl(&mut self) -> Self::Output

fn visit_i64_rotl(&mut self) -> Self::Output

fn visit_i32_rotr(&mut self) -> Self::Output

fn visit_i64_rotr(&mut self) -> Self::Output

fn visit_i32_shl(&mut self) -> Self::Output

fn visit_i64_shl(&mut self) -> Self::Output

fn visit_i32_xor(&mut self) -> Self::Output

fn visit_i64_xor(&mut self) -> Self::Output

fn visit_i32_shr_s(&mut self) -> Self::Output

fn visit_i64_shr_s(&mut self) -> Self::Output

fn visit_i32_shr_u(&mut self) -> Self::Output

fn visit_i64_shr_u(&mut self) -> Self::Output

fn visit_i32_trunc_f32_s(&mut self) -> Self::Output

fn visit_i64_trunc_f32_s(&mut self) -> Self::Output

fn visit_i32_trunc_f32_u(&mut self) -> Self::Output

fn visit_i64_trunc_f32_u(&mut self) -> Self::Output

fn visit_i32_trunc_f64_s(&mut self) -> Self::Output

fn visit_i64_trunc_f64_s(&mut self) -> Self::Output

fn visit_i32_trunc_f64_u(&mut self) -> Self::Output

fn visit_i64_trunc_f64_u(&mut self) -> Self::Output

fn visit_f32_abs(&mut self) -> Self::Output

fn visit_f64_abs(&mut self) -> Self::Output

fn visit_f32_ceil(&mut self) -> Self::Output

fn visit_f64_ceil(&mut self) -> Self::Output

fn visit_f32_copysign(&mut self) -> Self::Output

fn visit_f64_copysign(&mut self) -> Self::Output

fn visit_f32_floor(&mut self) -> Self::Output

fn visit_f64_floor(&mut self) -> Self::Output

fn visit_f32_max(&mut self) -> Self::Output

fn visit_f64_max(&mut self) -> Self::Output

fn visit_f32_min(&mut self) -> Self::Output

fn visit_f64_min(&mut self) -> Self::Output

fn visit_f32_nearest(&mut self) -> Self::Output

fn visit_f64_nearest(&mut self) -> Self::Output

fn visit_f32_neg(&mut self) -> Self::Output

fn visit_f64_neg(&mut self) -> Self::Output

fn visit_f32_sqrt(&mut self) -> Self::Output

fn visit_f64_sqrt(&mut self) -> Self::Output

fn visit_f32_convert_i32_s(&mut self) -> Self::Output

fn visit_f64_convert_i32_s(&mut self) -> Self::Output

fn visit_f32_convert_i32_u(&mut self) -> Self::Output

fn visit_f64_convert_i32_u(&mut self) -> Self::Output

fn visit_f32_convert_i64_s(&mut self) -> Self::Output

fn visit_f64_convert_i64_s(&mut self) -> Self::Output

fn visit_f32_convert_i64_u(&mut self) -> Self::Output

fn visit_f64_convert_i64_u(&mut self) -> Self::Output

fn visit_f32_trunc(&mut self) -> Self::Output

fn visit_f64_trunc(&mut self) -> Self::Output

fn visit_i32_rem_s(&mut self) -> Self::Output

fn visit_i64_rem_s(&mut self) -> Self::Output

fn visit_i32_rem_u(&mut self) -> Self::Output

fn visit_i64_rem_u(&mut self) -> Self::Output

fn visit_i32_load(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_load(&mut self, _arg: MemArg) -> Self::Output

fn visit_f32_load(&mut self, _arg: MemArg) -> Self::Output

fn visit_f64_load(&mut self, _arg: MemArg) -> Self::Output

fn visit_i32_load8_s(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_load8_s(&mut self, _arg: MemArg) -> Self::Output

fn visit_i32_load8_u(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_load8_u(&mut self, _arg: MemArg) -> Self::Output

fn visit_i32_load16_s(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_load16_s(&mut self, _arg: MemArg) -> Self::Output

fn visit_i32_load16_u(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_load16_u(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_load32_s(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_load32_u(&mut self, _arg: MemArg) -> Self::Output

fn visit_i32_store8(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_store8(&mut self, _arg: MemArg) -> Self::Output

fn visit_i32_store16(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_store16(&mut self, _arg: MemArg) -> Self::Output

fn visit_i32_store(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_store(&mut self, _arg: MemArg) -> Self::Output

fn visit_f32_store(&mut self, _arg: MemArg) -> Self::Output

fn visit_f64_store(&mut self, _arg: MemArg) -> Self::Output

fn visit_i64_store32(&mut self, _arg: MemArg) -> Self::Output

fn visit_drop(&mut self) -> Self::Output

fn visit_memory_grow(&mut self, mem: u32, mem_byte: u8) -> Self::Output

fn visit_memory_size(&mut self, mem: u32, mem_byte: u8) -> Self::Output

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

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

fn visit_f32_const(&mut self, value: Ieee32) -> Self::Output

fn visit_f64_const(&mut self, value: Ieee64) -> Self::Output

fn visit_i32_wrap_i64(&mut self) -> Self::Output

fn visit_i64_extend_i32_s(&mut self) -> Self::Output

fn visit_i64_extend_i32_u(&mut self) -> Self::Output

fn visit_f32_demote_f64(&mut self) -> Self::Output

fn visit_f64_promote_f32(&mut self) -> Self::Output

fn visit_i32_reinterpret_f32(&mut self) -> Self::Output

fn visit_i64_reinterpret_f64(&mut self) -> Self::Output

fn visit_f32_reinterpret_i32(&mut self) -> Self::Output

fn visit_f64_reinterpret_i64(&mut self) -> Self::Output

fn visit_return(&mut self) -> Self::Output

fn visit_else(&mut self) -> Self::Output

fn visit_select(&mut self) -> Self::Output

fn visit_end(&mut self) -> Self::Output

fn visit_nop(&mut self) -> Self::Output

fn visit_unreachable(&mut self) -> Self::Output

fn visit_if(&mut self, blockty: BlockType) -> Self::Output

fn visit_block(&mut self, blockty: BlockType) -> Self::Output

fn visit_loop(&mut self, blockty: BlockType) -> Self::Output

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

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

fn visit_br_table(&mut self, table: BrTable<'_>) -> Self::Output

fn visit_local_get(&mut self, local_index: u32) -> Self::Output

fn visit_local_set(&mut self, local_index: u32) -> Self::Output

fn visit_local_tee(&mut self, local_index: u32) -> Self::Output

fn visit_global_get(&mut self, global_index: u32) -> Self::Output

fn visit_global_set(&mut self, global_index: u32) -> Self::Output

fn visit_call(&mut self, func_index: u32) -> Self::Output

fn visit_call_indirect( &mut self, type_index: u32, table_index: u32, table_byte: u8, ) -> Self::Output

fn visit_operator(&mut self, op: &Operator<'a>) -> Self::Output

Visits the [Operator] op using the given offset.