Struct wasmparser::FuncValidator

pub struct FuncValidator<T> { /* private fields */ }

Validation context for a WebAssembly function.

This structure is created by Validator::code_section_entry and is created per-function in a WebAssembly module. This structure is suitable for sending to other threads while the original Validator continues processing other functions.

Implementations

impl<T: WasmModuleResources> FuncValidator<T>

pub fn new(
    index: u32,
    ty: u32,
    offset: usize,
    resources: T,
    features: &WasmFeatures
) -> Result<FuncValidator<T>>

Creates a new FuncValidator.

The returned FuncValidator can be used to validate a function with the type ty specified. The resources indicate what the containing module has for the function to use, and the features configure what WebAssembly proposals are enabled for this function.

The returned validator can be used to then parse a FunctionBody, for example, to read locals and validate operators.

pub fn validate(&mut self, body: &FunctionBody<'_>) -> Result<()>

Convenience function to validate an entire function’s body.

You may not end up using this in final implementations because you’ll often want to interleave validation with parsing.

pub fn read_locals(&mut self, reader: &mut BinaryReader<'_>) -> Result<()>

Reads the local defintions from the given BinaryReader, often sourced from a FunctionBody.

This function will automatically advance the BinaryReader forward, leaving reading operators up to the caller afterwards.

pub fn define_locals(
    &mut self,
    offset: usize,
    count: u32,
    ty: ValType
) -> Result<()>

Defines locals into this validator.

This should be used if the application is already reading local definitions and there’s no need to re-parse the function again.

pub fn op(&mut self, offset: usize, operator: &Operator<'_>) -> Result<()>

Validates the next operator in a function.

This functions is expected to be called once-per-operator in a WebAssembly function. Each operator’s offset in the original binary and the operator itself are passed to this function to provide more useful error messages.

pub fn finish(&mut self, offset: usize) -> Result<()>

Function that must be called after the last opcode has been processed.

This will validate that the function was properly terminated with the end opcode. If this function is not called then the function will not be properly validated.

The offset provided to this function will be used as a position for an error if validation fails.

pub fn resources(&self) -> &T

Returns the underlying module resources that this validator is using.

pub fn index(&self) -> u32

The index of the function within the module’s function index space that is being validated.

pub fn len_locals(&self) -> u32

Returns the number of defined local variables in the function.

pub fn get_local_type(&self, index: u32) -> Option<ValType>

Returns the type of the local variable at the given index if any.

pub fn operand_stack_height(&self) -> u32

Get the current height of the operand stack.

This returns the height of the whole operand stack for this function, not just for the current control frame.

pub fn get_operand_type(&self, index: usize) -> Option<Option<ValType>>

Returns the optional value type of the value operand at the given index from the top of the operand stack.

Returns None if the index is out of bounds.

pub fn control_stack_height(&self) -> u32

Returns the number of frames on the control flow stack.

This returns the height of the whole control stack for this function, not just for the current control frame.

pub fn get_control_frame(&self, depth: usize) -> Option<&Frame>

Returns a shared reference to the control flow Frame of the control flow stack at the given depth if any.

Returns None if the depth is out of bounds.

Note

A depth of 0 will refer to the last frame on the stack.

Trait Implementations

impl<'a, T> VisitOperator<'a> for FuncValidator<T> where
    T: WasmModuleResources, 

type Output = Result<(), BinaryReaderError>

The result type of the visitor.

fn visit_unreachable(&mut self, offset: usize) -> Result<()>

fn visit_nop(&mut self, offset: usize) -> Result<()>

fn visit_block(&mut self, offset: usize, ty: BlockType) -> Result<()>

fn visit_loop(&mut self, offset: usize, ty: BlockType) -> Result<()>

fn visit_if(&mut self, offset: usize, ty: BlockType) -> Result<()>

fn visit_else(&mut self, offset: usize) -> Result<()>

fn visit_try(&mut self, offset: usize, ty: BlockType) -> Result<()>

fn visit_catch(&mut self, offset: usize, index: u32) -> Result<()>

fn visit_throw(&mut self, offset: usize, index: u32) -> Result<()>

fn visit_rethrow(&mut self, offset: usize, relative_depth: u32) -> Result<()>

fn visit_end(&mut self, offset: usize) -> Result<()>

fn visit_br(&mut self, offset: usize, relative_depth: u32) -> Result<()>

fn visit_br_if(&mut self, offset: usize, relative_depth: u32) -> Result<()>

fn visit_br_table(&mut self, offset: usize, table: BrTable<'a>) -> Result<()>

fn visit_return(&mut self, offset: usize) -> Result<()>

fn visit_call(&mut self, offset: usize, function_index: u32) -> Result<()>

fn visit_call_indirect(
    &mut self,
    offset: usize,
    index: u32,
    table_index: u32,
    table_byte: u8
) -> Result<()>

fn visit_return_call(&mut self, offset: usize, function_index: u32) -> Result<()>

fn visit_return_call_indirect(
    &mut self,
    offset: usize,
    index: u32,
    table_index: u32
) -> Result<()>

fn visit_delegate(&mut self, offset: usize, relative_depth: u32) -> Result<()>

fn visit_catch_all(&mut self, offset: usize) -> Result<()>

fn visit_drop(&mut self, offset: usize) -> Result<()>

fn visit_select(&mut self, offset: usize) -> Result<()>

fn visit_typed_select(&mut self, offset: usize, ty: ValType) -> Result<()>

fn visit_local_get(&mut self, offset: usize, local_index: u32) -> Result<()>

fn visit_local_set(&mut self, offset: usize, local_index: u32) -> Result<()>

fn visit_local_tee(&mut self, offset: usize, local_index: u32) -> Result<()>

fn visit_global_get(&mut self, offset: usize, global_index: u32) -> Result<()>

fn visit_global_set(&mut self, offset: usize, global_index: u32) -> Result<()>

fn visit_i32_load(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_load(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_f32_load(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_f64_load(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_load8_s(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_load8_u(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_load16_s(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_load16_u(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_load8_s(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_load8_u(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_load16_s(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_load16_u(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_load32_s(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_load32_u(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_store(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_store(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_f32_store(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_f64_store(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_store8(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_store16(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_store8(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_store16(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_store32(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_memory_size(
    &mut self,
    offset: usize,
    mem: u32,
    mem_byte: u8
) -> Result<()>

fn visit_memory_grow(
    &mut self,
    offset: usize,
    mem: u32,
    mem_byte: u8
) -> Result<()>

fn visit_i32_const(&mut self, offset: usize, value: i32) -> Result<()>

fn visit_i64_const(&mut self, offset: usize, value: i64) -> Result<()>

fn visit_f32_const(&mut self, offset: usize, value: Ieee32) -> Result<()>

fn visit_f64_const(&mut self, offset: usize, value: Ieee64) -> Result<()>

fn visit_ref_null(&mut self, offset: usize, ty: ValType) -> Result<()>

fn visit_ref_is_null(&mut self, offset: usize) -> Result<()>

fn visit_ref_func(&mut self, offset: usize, function_index: u32) -> Result<()>

fn visit_i32_eqz(&mut self, offset: usize) -> Result<()>

fn visit_i32_eq(&mut self, offset: usize) -> Result<()>

fn visit_i32_ne(&mut self, offset: usize) -> Result<()>

fn visit_i32_lt_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_lt_u(&mut self, offset: usize) -> Result<()>

fn visit_i32_gt_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_gt_u(&mut self, offset: usize) -> Result<()>

fn visit_i32_le_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_le_u(&mut self, offset: usize) -> Result<()>

fn visit_i32_ge_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_ge_u(&mut self, offset: usize) -> Result<()>

fn visit_i64_eqz(&mut self, offset: usize) -> Result<()>

fn visit_i64_eq(&mut self, offset: usize) -> Result<()>

fn visit_i64_ne(&mut self, offset: usize) -> Result<()>

fn visit_i64_lt_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_lt_u(&mut self, offset: usize) -> Result<()>

fn visit_i64_gt_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_gt_u(&mut self, offset: usize) -> Result<()>

fn visit_i64_le_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_le_u(&mut self, offset: usize) -> Result<()>

fn visit_i64_ge_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_ge_u(&mut self, offset: usize) -> Result<()>

fn visit_f32_eq(&mut self, offset: usize) -> Result<()>

fn visit_f32_ne(&mut self, offset: usize) -> Result<()>

fn visit_f32_lt(&mut self, offset: usize) -> Result<()>

fn visit_f32_gt(&mut self, offset: usize) -> Result<()>

fn visit_f32_le(&mut self, offset: usize) -> Result<()>

fn visit_f32_ge(&mut self, offset: usize) -> Result<()>

fn visit_f64_eq(&mut self, offset: usize) -> Result<()>

fn visit_f64_ne(&mut self, offset: usize) -> Result<()>

fn visit_f64_lt(&mut self, offset: usize) -> Result<()>

fn visit_f64_gt(&mut self, offset: usize) -> Result<()>

fn visit_f64_le(&mut self, offset: usize) -> Result<()>

fn visit_f64_ge(&mut self, offset: usize) -> Result<()>

fn visit_i32_clz(&mut self, offset: usize) -> Result<()>

fn visit_i32_ctz(&mut self, offset: usize) -> Result<()>

fn visit_i32_popcnt(&mut self, offset: usize) -> Result<()>

fn visit_i32_add(&mut self, offset: usize) -> Result<()>

fn visit_i32_sub(&mut self, offset: usize) -> Result<()>

fn visit_i32_mul(&mut self, offset: usize) -> Result<()>

fn visit_i32_div_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_div_u(&mut self, offset: usize) -> Result<()>

fn visit_i32_rem_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_rem_u(&mut self, offset: usize) -> Result<()>

fn visit_i32_and(&mut self, offset: usize) -> Result<()>

fn visit_i32_or(&mut self, offset: usize) -> Result<()>

fn visit_i32_xor(&mut self, offset: usize) -> Result<()>

fn visit_i32_shl(&mut self, offset: usize) -> Result<()>

fn visit_i32_shr_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_shr_u(&mut self, offset: usize) -> Result<()>

fn visit_i32_rotl(&mut self, offset: usize) -> Result<()>

fn visit_i32_rotr(&mut self, offset: usize) -> Result<()>

fn visit_i64_clz(&mut self, offset: usize) -> Result<()>

fn visit_i64_ctz(&mut self, offset: usize) -> Result<()>

fn visit_i64_popcnt(&mut self, offset: usize) -> Result<()>

fn visit_i64_add(&mut self, offset: usize) -> Result<()>

fn visit_i64_sub(&mut self, offset: usize) -> Result<()>

fn visit_i64_mul(&mut self, offset: usize) -> Result<()>

fn visit_i64_div_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_div_u(&mut self, offset: usize) -> Result<()>

fn visit_i64_rem_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_rem_u(&mut self, offset: usize) -> Result<()>

fn visit_i64_and(&mut self, offset: usize) -> Result<()>

fn visit_i64_or(&mut self, offset: usize) -> Result<()>

fn visit_i64_xor(&mut self, offset: usize) -> Result<()>

fn visit_i64_shl(&mut self, offset: usize) -> Result<()>

fn visit_i64_shr_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_shr_u(&mut self, offset: usize) -> Result<()>

fn visit_i64_rotl(&mut self, offset: usize) -> Result<()>

fn visit_i64_rotr(&mut self, offset: usize) -> Result<()>

fn visit_f32_abs(&mut self, offset: usize) -> Result<()>

fn visit_f32_neg(&mut self, offset: usize) -> Result<()>

fn visit_f32_ceil(&mut self, offset: usize) -> Result<()>

fn visit_f32_floor(&mut self, offset: usize) -> Result<()>

fn visit_f32_trunc(&mut self, offset: usize) -> Result<()>

fn visit_f32_nearest(&mut self, offset: usize) -> Result<()>

fn visit_f32_sqrt(&mut self, offset: usize) -> Result<()>

fn visit_f32_add(&mut self, offset: usize) -> Result<()>

fn visit_f32_sub(&mut self, offset: usize) -> Result<()>

fn visit_f32_mul(&mut self, offset: usize) -> Result<()>

fn visit_f32_div(&mut self, offset: usize) -> Result<()>

fn visit_f32_min(&mut self, offset: usize) -> Result<()>

fn visit_f32_max(&mut self, offset: usize) -> Result<()>

fn visit_f32_copysign(&mut self, offset: usize) -> Result<()>

fn visit_f64_abs(&mut self, offset: usize) -> Result<()>

fn visit_f64_neg(&mut self, offset: usize) -> Result<()>

fn visit_f64_ceil(&mut self, offset: usize) -> Result<()>

fn visit_f64_floor(&mut self, offset: usize) -> Result<()>

fn visit_f64_trunc(&mut self, offset: usize) -> Result<()>

fn visit_f64_nearest(&mut self, offset: usize) -> Result<()>

fn visit_f64_sqrt(&mut self, offset: usize) -> Result<()>

fn visit_f64_add(&mut self, offset: usize) -> Result<()>

fn visit_f64_sub(&mut self, offset: usize) -> Result<()>

fn visit_f64_mul(&mut self, offset: usize) -> Result<()>

fn visit_f64_div(&mut self, offset: usize) -> Result<()>

fn visit_f64_min(&mut self, offset: usize) -> Result<()>

fn visit_f64_max(&mut self, offset: usize) -> Result<()>

fn visit_f64_copysign(&mut self, offset: usize) -> Result<()>

fn visit_i32_wrap_i64(&mut self, offset: usize) -> Result<()>

fn visit_i32_trunc_f32s(&mut self, offset: usize) -> Result<()>

fn visit_i32_trunc_f32u(&mut self, offset: usize) -> Result<()>

fn visit_i32_trunc_f64s(&mut self, offset: usize) -> Result<()>

fn visit_i32_trunc_f64u(&mut self, offset: usize) -> Result<()>

fn visit_i64_extend_i32s(&mut self, offset: usize) -> Result<()>

fn visit_i64_extend_i32u(&mut self, offset: usize) -> Result<()>

fn visit_i64_trunc_f32s(&mut self, offset: usize) -> Result<()>

fn visit_i64_trunc_f32u(&mut self, offset: usize) -> Result<()>

fn visit_i64_trunc_f64s(&mut self, offset: usize) -> Result<()>

fn visit_i64_trunc_f64u(&mut self, offset: usize) -> Result<()>

fn visit_f32_convert_i32s(&mut self, offset: usize) -> Result<()>

fn visit_f32_convert_i32u(&mut self, offset: usize) -> Result<()>

fn visit_f32_convert_i64s(&mut self, offset: usize) -> Result<()>

fn visit_f32_convert_i64u(&mut self, offset: usize) -> Result<()>

fn visit_f32_demote_f64(&mut self, offset: usize) -> Result<()>

fn visit_f64_convert_i32_s(&mut self, offset: usize) -> Result<()>

fn visit_f64_convert_i32_u(&mut self, offset: usize) -> Result<()>

fn visit_f64_convert_i64_s(&mut self, offset: usize) -> Result<()>

fn visit_f64_convert_i64_u(&mut self, offset: usize) -> Result<()>

fn visit_f64_promote_f32(&mut self, offset: usize) -> Result<()>

fn visit_i32_reinterpret_f32(&mut self, offset: usize) -> Result<()>

fn visit_i64_reinterpret_f64(&mut self, offset: usize) -> Result<()>

fn visit_f32_reinterpret_i32(&mut self, offset: usize) -> Result<()>

fn visit_f64_reinterpret_i64(&mut self, offset: usize) -> Result<()>

fn visit_i32_extend8_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_extend16_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_extend8_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_extend16_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_extend32_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_trunc_sat_f32_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_trunc_sat_f32_u(&mut self, offset: usize) -> Result<()>

fn visit_i32_trunc_sat_f64_s(&mut self, offset: usize) -> Result<()>

fn visit_i32_trunc_sat_f64_u(&mut self, offset: usize) -> Result<()>

fn visit_i64_trunc_sat_f32_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_trunc_sat_f32_u(&mut self, offset: usize) -> Result<()>

fn visit_i64_trunc_sat_f64_s(&mut self, offset: usize) -> Result<()>

fn visit_i64_trunc_sat_f64_u(&mut self, offset: usize) -> Result<()>

fn visit_memory_init(
    &mut self,
    offset: usize,
    segment: u32,
    mem: u32
) -> Result<()>

fn visit_data_drop(&mut self, offset: usize, segment: u32) -> Result<()>

fn visit_memory_copy(&mut self, offset: usize, dst: u32, src: u32) -> Result<()>

fn visit_memory_fill(&mut self, offset: usize, mem: u32) -> Result<()>

fn visit_table_init(
    &mut self,
    offset: usize,
    segment: u32,
    table: u32
) -> Result<()>

fn visit_elem_drop(&mut self, offset: usize, segment: u32) -> Result<()>

fn visit_table_copy(
    &mut self,
    offset: usize,
    dst_table: u32,
    src_table: u32
) -> Result<()>

fn visit_table_fill(&mut self, offset: usize, table: u32) -> Result<()>

fn visit_table_get(&mut self, offset: usize, table: u32) -> Result<()>

fn visit_table_set(&mut self, offset: usize, table: u32) -> Result<()>

fn visit_table_grow(&mut self, offset: usize, table: u32) -> Result<()>

fn visit_table_size(&mut self, offset: usize, table: u32) -> Result<()>

fn visit_memory_atomic_notify(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_memory_atomic_wait32(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_memory_atomic_wait64(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_atomic_fence(&mut self, offset: usize, flags: u8) -> Result<()>

fn visit_i32_atomic_load(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_atomic_load(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_atomic_load8_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_load16_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_load8_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_load16_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_load32_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_store(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_atomic_store(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_atomic_store8(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_atomic_store16(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_store8(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_atomic_store16(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_store32(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw_add(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw_add(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw8_add_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw16_add_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw8_add_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw16_add_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw32_add_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw_sub(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw_sub(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw8_sub_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw16_sub_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw8_sub_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw16_sub_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw32_sub_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw_and(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw_and(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw8_and_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw16_and_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw8_and_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw16_and_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw32_and_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw_or(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i64_atomic_rmw_or(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_i32_atomic_rmw8_or_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw16_or_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw8_or_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw16_or_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw32_or_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw_xor(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw_xor(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw8_xor_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw16_xor_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw8_xor_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw16_xor_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw32_xor_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw_xchg(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw_xchg(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw8_xchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw16_xchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw8_xchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw16_xchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw32_xchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw_cmpxchg(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw_cmpxchg(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw8_cmpxchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i32_atomic_rmw16_cmpxchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw8_cmpxchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw16_cmpxchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_i64_atomic_rmw32_cmpxchg_u(
    &mut self,
    offset: usize,
    memarg: MemArg
) -> Result<()>

fn visit_v128_load(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load8x8_s(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load8x8_u(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load16x4_s(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load16x4_u(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load32x2_s(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load32x2_u(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load8_splat(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load16_splat(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load32_splat(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load64_splat(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load32_zero(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load64_zero(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_store(&mut self, offset: usize, memarg: MemArg) -> Result<()>

fn visit_v128_load8_lane(
    &mut self,
    offset: usize,
    memarg: MemArg,
    lane: u8
) -> Result<()>

fn visit_v128_load16_lane(
    &mut self,
    offset: usize,
    memarg: MemArg,
    lane: u8
) -> Result<()>

fn visit_v128_load32_lane(
    &mut self,
    offset: usize,
    memarg: MemArg,
    lane: u8
) -> Result<()>

fn visit_v128_load64_lane(
    &mut self,
    offset: usize,
    memarg: MemArg,
    lane: u8
) -> Result<()>

fn visit_v128_store8_lane(
    &mut self,
    offset: usize,
    memarg: MemArg,
    lane: u8
) -> Result<()>

fn visit_v128_store16_lane(
    &mut self,
    offset: usize,
    memarg: MemArg,
    lane: u8
) -> Result<()>

fn visit_v128_store32_lane(
    &mut self,
    offset: usize,
    memarg: MemArg,
    lane: u8
) -> Result<()>

fn visit_v128_store64_lane(
    &mut self,
    offset: usize,
    memarg: MemArg,
    lane: u8
) -> Result<()>

fn visit_v128_const(&mut self, offset: usize, value: V128) -> Result<()>

fn visit_i8x16_shuffle(&mut self, offset: usize, lanes: [u8; 16]) -> Result<()>

fn visit_i8x16_extract_lane_s(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i8x16_extract_lane_u(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i8x16_replace_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i16x8_extract_lane_s(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i16x8_extract_lane_u(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i16x8_replace_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i32x4_extract_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i32x4_replace_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i64x2_extract_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i64x2_replace_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_f32x4_extract_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_f32x4_replace_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_f64x2_extract_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_f64x2_replace_lane(&mut self, offset: usize, lane: u8) -> Result<()>

fn visit_i8x16_swizzle(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_splat(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_splat(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_splat(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_splat(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_splat(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_splat(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_eq(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_ne(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_lt_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_lt_u(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_gt_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_gt_u(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_le_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_le_u(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_ge_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_ge_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_eq(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_ne(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_lt_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_lt_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_gt_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_gt_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_le_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_le_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_ge_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_ge_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_eq(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_ne(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_lt_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_lt_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_gt_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_gt_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_le_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_le_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_ge_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_ge_u(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_eq(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_ne(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_lt_s(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_gt_s(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_le_s(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_ge_s(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_eq(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_ne(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_lt(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_gt(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_le(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_ge(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_eq(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_ne(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_lt(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_gt(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_le(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_ge(&mut self, offset: usize) -> Result<()>

fn visit_v128_not(&mut self, offset: usize) -> Result<()>

fn visit_v128_and(&mut self, offset: usize) -> Result<()>

fn visit_v128_andnot(&mut self, offset: usize) -> Result<()>

fn visit_v128_or(&mut self, offset: usize) -> Result<()>

fn visit_v128_xor(&mut self, offset: usize) -> Result<()>

fn visit_v128_bitselect(&mut self, offset: usize) -> Result<()>

fn visit_v128_any_true(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_abs(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_neg(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_popcnt(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_all_true(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_bitmask(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_narrow_i16x8_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_narrow_i16x8_u(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_shl(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_shr_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_shr_u(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_add(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_add_sat_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_add_sat_u(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_sub(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_sub_sat_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_sub_sat_u(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_min_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_min_u(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_max_s(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_max_u(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_avgr_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extadd_pairwise_i8x16_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extadd_pairwise_i8x16_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_abs(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_neg(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_q15mulr_sat_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_all_true(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_bitmask(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_narrow_i32x4_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_narrow_i32x4_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extend_low_i8x16_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extend_high_i8x16_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extend_low_i8x16_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extend_high_i8x16_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_shl(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_shr_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_shr_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_add(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_add_sat_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_add_sat_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_sub(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_sub_sat_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_sub_sat_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_mul(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_min_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_min_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_max_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_max_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_avgr_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extmul_low_i8x16_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extmul_high_i8x16_s(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extmul_low_i8x16_u(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_extmul_high_i8x16_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extadd_pairwise_i16x8_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extadd_pairwise_i16x8_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_abs(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_neg(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_all_true(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_bitmask(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extend_low_i16x8_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extend_high_i16x8_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extend_low_i16x8_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extend_high_i16x8_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_shl(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_shr_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_shr_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_add(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_sub(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_mul(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_min_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_min_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_max_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_max_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_dot_i16x8_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extmul_low_i16x8_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extmul_high_i16x8_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extmul_low_i16x8_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_extmul_high_i16x8_u(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_abs(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_neg(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_all_true(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_bitmask(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_extend_low_i32x4_s(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_extend_high_i32x4_s(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_extend_low_i32x4_u(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_extend_high_i32x4_u(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_shl(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_shr_s(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_shr_u(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_add(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_sub(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_mul(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_extmul_low_i32x4_s(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_extmul_high_i32x4_s(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_extmul_low_i32x4_u(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_extmul_high_i32x4_u(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_ceil(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_floor(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_trunc(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_nearest(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_abs(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_neg(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_sqrt(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_add(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_sub(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_mul(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_div(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_min(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_max(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_pmin(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_pmax(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_ceil(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_floor(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_trunc(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_nearest(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_abs(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_neg(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_sqrt(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_add(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_sub(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_mul(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_div(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_min(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_max(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_pmin(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_pmax(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_trunc_sat_f32x4_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_trunc_sat_f32x4_u(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_convert_i32x4_s(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_convert_i32x4_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_trunc_sat_f64x2_s_zero(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_trunc_sat_f64x2_u_zero(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_convert_low_i32x4_s(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_convert_low_i32x4_u(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_demote_f64x2_zero(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_promote_low_f32x4(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_relaxed_swizzle(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_relaxed_trunc_sat_f32x4_s(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_relaxed_trunc_sat_f32x4_u(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_relaxed_trunc_sat_f64x2_s_zero(
    &mut self,
    offset: usize
) -> Result<()>

fn visit_i32x4_relaxed_trunc_sat_f64x2_u_zero(
    &mut self,
    offset: usize
) -> Result<()>

fn visit_f32x4_fma(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_fms(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_fma(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_fms(&mut self, offset: usize) -> Result<()>

fn visit_i8x16_laneselect(&mut self, offset: usize) -> Result<()>

fn visit_i16x8_laneselect(&mut self, offset: usize) -> Result<()>

fn visit_i32x4_laneselect(&mut self, offset: usize) -> Result<()>

fn visit_i64x2_laneselect(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_relaxed_min(&mut self, offset: usize) -> Result<()>

fn visit_f32x4_relaxed_max(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_relaxed_min(&mut self, offset: usize) -> Result<()>

fn visit_f64x2_relaxed_max(&mut self, offset: usize) -> Result<()>

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

Visits the Operator op using the given offset.