/// Types that qualify as Wasm validation database. /// /// # Note /// /// The `wasmparser` crate provides a builtin validation framework but allows /// users of this crate to also feed the parsed Wasm into their own data /// structure while parsing and also validate at the same time without /// the need of an additional parsing or validation step or copying data around. pubtrait WasmModuleResources { /// Returns the table at given index if any. /// /// The table element type must be canonicalized. fn table_at(&self, at: u32) -> Option<TableType>;
/// Returns the linear memory at given index. fn memory_at(&self, at: u32) -> Option<MemoryType>;
/// Returns the tag at given index. /// /// The tag's function type must be canonicalized. fn tag_at(&self, at: u32) -> Option<&FuncType>;
/// Returns the global variable at given index. /// /// The global's value type must be canonicalized. fn global_at(&self, at: u32) -> Option<GlobalType>;
/// Returns the `SubType` associated with the given type index. /// /// The sub type must be canonicalized. fn sub_type_at(&self, type_index: u32) -> Option<&SubType>;
/// Returns the `SubType` associated with the given core type id. fn sub_type_at_id(&self, id: CoreTypeId) -> &SubType;
/// Returns the type ID associated with the given function index. fn type_id_of_function(&self, func_idx: u32) -> Option<CoreTypeId>;
/// Returns the type index associated with the given function index. fn type_index_of_function(&self, func_index: u32) -> Option<u32>;
/// Returns the element type at the given index. /// /// The `RefType` must be canonicalized. fn element_type_at(&self, at: u32) -> Option<RefType>;
/// Is `a` a subtype of `b`? fn is_subtype(&self, a: ValType, b: ValType) -> bool;
/// Is the given reference type `shared`? /// /// While abstract heap types do carry along a `shared` flag, concrete heap /// types do not. This function resolves those concrete heap types to /// determine `shared`-ness. fn is_shared(&self, ty: RefType) -> bool;
/// Check and canonicalize a value type. /// /// This will validate that `t` is valid under the `features` provided and /// then additionally validate the structure of `t`. For example any type /// references that `t` makes are validated and canonicalized. fn check_value_type(
&self,
t: &mut ValType,
features: &WasmFeatures,
offset: usize,
) -> Result<(), BinaryReaderError> {
features
.check_value_type(*t)
.map_err(|s| BinaryReaderError::new(s, offset))?; match t {
ValType::Ref(r) => self.check_ref_type(r, offset),
ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 | ValType::V128 => Ok(()),
}
}
/// Checks that a `HeapType` is valid and then additionally place it in its /// canonical form. /// /// Similar to `check_value_type` but for heap types. fn check_heap_type(
&self,
heap_type: &mut HeapType,
offset: usize,
) -> Result<(), BinaryReaderError>;
/// Get the top type for the given heap type. fn top_type(&self, heap_type: &HeapType) -> HeapType;
/// Returns the number of elements. fn element_count(&self) -> u32;
/// Returns the number of bytes in the Wasm data section. fn data_count(&self) -> Option<u32>;
/// Returns whether the function index is referenced in the module anywhere /// outside of the start/function sections. fn is_function_referenced(&self, idx: u32) -> bool;
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
