Struct wasmtime_environ::Module

pub struct Module {

    pub name: Option<String>,
    pub initializers: Vec<Initializer>,
    pub exports: IndexMap<String, EntityIndex>,
    pub start_func: Option<FuncIndex>,
    pub table_initializers: Vec<TableInitializer>,
    pub memory_initialization: MemoryInitialization,
    pub passive_elements: Vec<Box<[FuncIndex]>>,
    pub passive_elements_map: HashMap<ElemIndex, usize>,
    pub passive_data: Vec<Arc<[u8]>>,
    pub passive_data_map: HashMap<DataIndex, usize>,
    pub func_names: HashMap<FuncIndex, String>,
    pub types: PrimaryMap<TypeIndex, ModuleType>,
    pub num_imported_funcs: usize,
    pub num_imported_tables: usize,
    pub num_imported_memories: usize,
    pub num_imported_globals: usize,
    pub functions: PrimaryMap<FuncIndex, SignatureIndex>,
    pub table_plans: PrimaryMap<TableIndex, TablePlan>,
    pub memory_plans: PrimaryMap<MemoryIndex, MemoryPlan>,
    pub globals: PrimaryMap<GlobalIndex, Global>,
    pub instances: PrimaryMap<InstanceIndex, InstanceTypeIndex>,
    pub modules: PrimaryMap<ModuleIndex, ModuleTypeIndex>,
    pub possibly_exported_funcs: HashSet<DefinedFuncIndex>,
}

A translated WebAssembly module, excluding the function bodies and memory initializers.

Fields

name: Option<String>

The name of this wasm module, often found in the wasm file.

initializers: Vec<Initializer>

All import records, in the order they are declared in the module.

exports: IndexMap<String, EntityIndex>

Exported entities.

start_func: Option<FuncIndex>

The module “start” function, if present.

table_initializers: Vec<TableInitializer>

WebAssembly table initializers.

memory_initialization: MemoryInitialization

WebAssembly linear memory initializer.

passive_elements: Vec<Box<[FuncIndex]>>

WebAssembly passive elements.

passive_elements_map: HashMap<ElemIndex, usize>

The map from passive element index (element segment index space) to index in passive_elements.

passive_data: Vec<Arc<[u8]>>

WebAssembly passive data segments.

passive_data_map: HashMap<DataIndex, usize>

The map from passive data index (data segment index space) to index in passive_data.

func_names: HashMap<FuncIndex, String>

WebAssembly function names.

types: PrimaryMap<TypeIndex, ModuleType>

Types declared in the wasm module.

num_imported_funcs: usize

Number of imported or aliased functions in the module.

num_imported_tables: usize

Number of imported or aliased tables in the module.

num_imported_memories: usize

Number of imported or aliased memories in the module.

num_imported_globals: usize

Number of imported or aliased globals in the module.

functions: PrimaryMap<FuncIndex, SignatureIndex>

Types of functions, imported and local.

table_plans: PrimaryMap<TableIndex, TablePlan>

WebAssembly tables.

memory_plans: PrimaryMap<MemoryIndex, MemoryPlan>

WebAssembly linear memory plans.

globals: PrimaryMap<GlobalIndex, Global>

WebAssembly global variables.

instances: PrimaryMap<InstanceIndex, InstanceTypeIndex>

The type of each wasm instance this module defines.

modules: PrimaryMap<ModuleIndex, ModuleTypeIndex>

The type of each nested wasm module this module contains.

possibly_exported_funcs: HashSet<DefinedFuncIndex>

The set of defined functions within this module which are located in element segments.

Implementations

impl Module

pub fn new() -> Self

Allocates the module data structures.

pub fn get_passive_element(&self, index: ElemIndex) -> Option<&[FuncIndex]>

Get the given passive element, if it exists.

pub fn func_index(&self, defined_func: DefinedFuncIndex) -> FuncIndex

Convert a DefinedFuncIndex into a FuncIndex.

pub fn defined_func_index(&self, func: FuncIndex) -> Option<DefinedFuncIndex>

Convert a FuncIndex into a DefinedFuncIndex. Returns None if the index is an imported function.

pub fn is_imported_function(&self, index: FuncIndex) -> bool

Test whether the given function index is for an imported function.

pub fn table_index(&self, defined_table: DefinedTableIndex) -> TableIndex

Convert a DefinedTableIndex into a TableIndex.

pub fn defined_table_index(
    &self,
    table: TableIndex
) -> Option<DefinedTableIndex>

Convert a TableIndex into a DefinedTableIndex. Returns None if the index is an imported table.

pub fn is_imported_table(&self, index: TableIndex) -> bool

Test whether the given table index is for an imported table.

pub fn memory_index(&self, defined_memory: DefinedMemoryIndex) -> MemoryIndex

Convert a DefinedMemoryIndex into a MemoryIndex.

pub fn defined_memory_index(
    &self,
    memory: MemoryIndex
) -> Option<DefinedMemoryIndex>

Convert a MemoryIndex into a DefinedMemoryIndex. Returns None if the index is an imported memory.

pub fn is_imported_memory(&self, index: MemoryIndex) -> bool

Test whether the given memory index is for an imported memory.

pub fn global_index(&self, defined_global: DefinedGlobalIndex) -> GlobalIndex

Convert a DefinedGlobalIndex into a GlobalIndex.

pub fn defined_global_index(
    &self,
    global: GlobalIndex
) -> Option<DefinedGlobalIndex>

Convert a GlobalIndex into a DefinedGlobalIndex. Returns None if the index is an imported global.

pub fn is_imported_global(&self, index: GlobalIndex) -> bool

Test whether the given global index is for an imported global.

pub fn imports(&self) -> impl Iterator<Item = (&str, Option<&str>, EntityType)>

Returns an iterator of all the imports in this module, along with their module name, field name, and type that’s being imported.

pub fn type_of(&self, index: EntityIndex) -> EntityType

Returns the type of an item based on its index

Trait Implementations

impl Clone for Module

fn clone(&self) -> Module

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Module

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Module

fn default() -> Module

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Module

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for Module

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.