Struct wasmer_types::ModuleInfo

pub struct ModuleInfo {

    pub id: ModuleId,
    pub hash: Option<ModuleHash>,
    pub name: Option<String>,
    pub imports: IndexMap<ImportKey, 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, Box<[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, Box<[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.

IMPORTANT: since this struct will be serialized as part of the compiled module artifact, if you change this struct, do not forget to update MetadataHeader::version to make sure we don’t break compatibility between versions.

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. It’s not skipped in rkyv, but that is okay, because even though it’s skipped in bincode/serde it’s still deserialized back as a garbage number, and later override from computed by the process

hash: Option<ModuleHash>

hash of the module

name: Option<String>

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

imports: IndexMap<ImportKey, 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, Box<[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, Box<[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 hash(&self) -> Option<ModuleHash>

Returns the module hash if available

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(&self) -> ExportsIterator<impl Iterator<Item = ExportType> + '_>

Get the export types of the module

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

Get the import types of the module

pub fn custom_sections<'a>( &'a self, name: &'a str, ) -> impl Iterator<Item = Box<[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(&self) -> impl Iterator<Item = FunctionType> + '_

Get the imported function types of the module.

Trait Implementations

impl Archive for ModuleInfo

type Archived = <ArchivableModuleInfo as Archive>::Archived

The archived representation of this type.

type Resolver = <ArchivableModuleInfo as Archive>::Resolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for ModuleInfo

fn clone(&self) -> ModuleInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ModuleInfo

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

Formats the value using the given formatter.

impl Default for ModuleInfo

fn default() -> ModuleInfo

Returns the “default value” for a type.

impl<D: Fallible + ?Sized + SharedDeserializeRegistry> Deserialize<ModuleInfo, D> for Archived<ModuleInfo>

fn deserialize(&self, deserializer: &mut D) -> Result<ModuleInfo, D::Error>

Deserializes using the given deserializer

impl Display for ModuleInfo

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

Formats the value using the given formatter.

impl PartialEq for ModuleInfo

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: Serializer + SharedSerializeRegistry + ScratchSpace + ?Sized> Serialize<S> for ModuleInfo

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Eq for ModuleInfo