Struct FuncValidator 

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

Validation context for a WebAssembly function.

This is a finalized validator which is ready to process a FunctionBody. This is created from the FuncToValidate::into_validator method.

Implementations

impl<T> FuncValidator<T>

where T: WasmModuleResources,

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

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<(), BinaryReaderError>

Reads the local definitions 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<(), BinaryReaderError>

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<(), BinaryReaderError>

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 visitor<'this, 'a>( &'this mut self, offset: usize, ) -> impl VisitOperator<'a, Output = Result<(), BinaryReaderError>> + ModuleArity + FrameStack + 'this

where 'a: 'this,

Get the operator visitor for the next operator in the function.

The returned visitor is intended to visit just one instruction at the offset.

Example

pub fn validate<R>(validator: &mut FuncValidator<R>, body: &FunctionBody<'_>) -> Result<()>
where R: WasmModuleResources
{
    let mut operator_reader = body.get_binary_reader_for_operators()?;
    while !operator_reader.eof() {
        let mut visitor = validator.visitor(operator_reader.original_position());
        operator_reader.visit_operator(&mut visitor)??;
    }
    operator_reader.finish_expression(&validator.visitor(operator_reader.original_position()))
}

pub fn simd_visitor<'this, 'a>( &'this mut self, offset: usize, ) -> impl VisitSimdOperator<'a> + ModuleArity + 'this

where 'a: 'this,

Same as FuncValidator::visitor except that the returned type implements the VisitSimdOperator trait as well.

pub fn features(&self) -> &WasmFeatures

Returns the Wasm features enabled for this validator.

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, depth: usize) -> Option<Option<ValType>>

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

• Returns None if the depth is out of bounds.
• Returns Some(None) if there is a value with unknown type at the given depth.

Note

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

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.

pub fn into_allocations(self) -> FuncValidatorAllocations

Consumes this validator and returns the underlying allocations that were used during the validation process.

The returned value here can be paired with FuncToValidate::into_validator to reuse the allocations already created by this validator.

Trait Implementations

impl<T> ModuleArity for FuncValidator<T>

where T: WasmModuleResources,

fn sub_type_at(&self, type_idx: u32) -> Option<&SubType>

Type with given index

fn tag_type_arity(&self, at: u32) -> Option<(u32, u32)>

Arity (param and result counts) of tag with given index

fn type_index_of_function(&self, func_idx: u32) -> Option<u32>

Type index of function with given index

fn func_type_of_cont_type(&self, cont_ty: &ContType) -> Option<&FuncType>

Function type for a given continuation type

fn sub_type_of_ref_type(&self, rt: &RefType) -> Option<&SubType>

Sub type for a given reference type

fn control_stack_height(&self) -> u32

Current height of control stack

fn label_block(&self, depth: u32) -> Option<(BlockType, FrameKind)>

BlockType and FrameKind of label with given index

fn sub_type_arity(&self, t: &SubType) -> Option<(u32, u32)>

Computes arity of given SubType

fn block_type_arity(&self, ty: BlockType) -> Option<(u32, u32)>

Computes arity of given BlockType