Struct wasmer_vm::ModuleInfo

pub struct ModuleInfo {
    pub id: ModuleId,
    pub name: Option<String>,
    pub imports: IndexMap<(String, String, u32), ImportIndex>,
    pub exports: IndexMap<String, ExportIndex>,
    pub start_function: Option<FunctionIndex>,
    pub table_initializers: Vec<TableInitializer>,
    pub passive_elements: HashMap<ElemIndex, Box<[FunctionIndex]>>,
    pub passive_data: HashMap<DataIndex, Arc<[u8]>>,
    pub global_initializers: PrimaryMap<LocalGlobalIndex, GlobalInit>,
    pub function_names: HashMap<FunctionIndex, String>,
    pub signatures: PrimaryMap<SignatureIndex, FunctionType>,
    pub functions: PrimaryMap<FunctionIndex, SignatureIndex>,
    pub tables: PrimaryMap<TableIndex, TableType>,
    pub memories: PrimaryMap<MemoryIndex, MemoryType>,
    pub globals: PrimaryMap<GlobalIndex, GlobalType>,
    pub custom_sections: IndexMap<String, CustomSectionIndex>,
    pub custom_sections_data: PrimaryMap<CustomSectionIndex, Arc<[u8]>>,
    pub num_imported_functions: usize,
    pub num_imported_tables: usize,
    pub num_imported_memories: usize,
    pub num_imported_globals: usize,
}

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

Fields

id: ModuleId

A unique identifier (within this process) for this module.

We skip serialization/deserialization of this field, as it should be computed by the process.

name: Option<String>

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

imports: IndexMap<(String, String, u32), ImportIndex>

Imported entities with the (module, field, index_of_the_import)

Keeping the index_of_the_import is important, as there can be two same references to the same import, and we don't want to confuse them.

exports: IndexMap<String, ExportIndex>

Exported entities.

start_function: Option<FunctionIndex>

The module "start" function, if present.

table_initializers: Vec<TableInitializer>

WebAssembly table initializers.

passive_elements: HashMap<ElemIndex, Box<[FunctionIndex]>>

WebAssembly passive elements.

passive_data: HashMap<DataIndex, Arc<[u8]>>

WebAssembly passive data segments.

global_initializers: PrimaryMap<LocalGlobalIndex, GlobalInit>

WebAssembly global initializers.

function_names: HashMap<FunctionIndex, String>

WebAssembly function names.

signatures: PrimaryMap<SignatureIndex, FunctionType>

WebAssembly function signatures.

functions: PrimaryMap<FunctionIndex, SignatureIndex>

WebAssembly functions (imported and local).

tables: PrimaryMap<TableIndex, TableType>

WebAssembly tables (imported and local).

memories: PrimaryMap<MemoryIndex, MemoryType>

WebAssembly linear memories (imported and local).

globals: PrimaryMap<GlobalIndex, GlobalType>

WebAssembly global variables (imported and local).

custom_sections: IndexMap<String, CustomSectionIndex>

Custom sections in the module.

custom_sections_data: PrimaryMap<CustomSectionIndex, Arc<[u8]>>

The data for each CustomSection in the module.

num_imported_functions: usize

Number of imported functions in the module.

num_imported_tables: usize

Number of imported tables in the module.

num_imported_memories: usize

Number of imported memories in the module.

num_imported_globals: usize

Number of imported globals in the module.

Implementations

impl ModuleInfo

pub fn new() -> Self

Allocates the module data structures.

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

Get the given passive element, if it exists.

pub fn exported_signatures(&self) -> Vec<FunctionType>

Get the exported signatures of the module

pub fn exports<'a>(
    &'a self
) -> ExportsIterator<impl Iterator<Item = ExportType> + 'a>

Get the export types of the module

pub fn imports<'a>(
    &'a self
) -> ImportsIterator<impl Iterator<Item = ImportType> + 'a>

Get the export types of the module

pub fn custom_sections<'a>(
    &'a self,
    name: &'a str
) -> impl Iterator<Item = Arc<[u8]>> + 'a

Get the custom sections of the module given a name.

pub fn func_index(&self, local_func: LocalFunctionIndex) -> FunctionIndex

Convert a LocalFunctionIndex into a FunctionIndex.

pub fn local_func_index(
    &self,
    func: FunctionIndex
) -> Option<LocalFunctionIndex>

Convert a FunctionIndex into a LocalFunctionIndex. Returns None if the index is an imported function.

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

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

pub fn table_index(&self, local_table: LocalTableIndex) -> TableIndex

Convert a LocalTableIndex into a TableIndex.

pub fn local_table_index(&self, table: TableIndex) -> Option<LocalTableIndex>

Convert a TableIndex into a LocalTableIndex. 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, local_memory: LocalMemoryIndex) -> MemoryIndex

Convert a LocalMemoryIndex into a MemoryIndex.

pub fn local_memory_index(
    &self,
    memory: MemoryIndex
) -> Option<LocalMemoryIndex>

Convert a MemoryIndex into a LocalMemoryIndex. 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, local_global: LocalGlobalIndex) -> GlobalIndex

Convert a LocalGlobalIndex into a GlobalIndex.

pub fn local_global_index(
    &self,
    global: GlobalIndex
) -> Option<LocalGlobalIndex>

Convert a GlobalIndex into a LocalGlobalIndex. 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 name(&self) -> String

Get the Module name

pub fn imported_function_types<'a>(
    &'a self
) -> impl Iterator<Item = FunctionType> + 'a

Get the imported function types of the module.

Trait Implementations

impl Debug for ModuleInfo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModuleInfo

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

Deserialize this value from the given Serde deserializer.

impl Display for ModuleInfo

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

Formats the value using the given formatter.

impl Serialize for ModuleInfo

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

Serialize this value into the given Serde serializer.