Struct wasmer_vm::ModuleInfo

pub struct ModuleInfo {

    pub id: ModuleId,
    pub name: Option<String>,
    pub imports: IndexMap<ImportKey, ImportIndex, RandomState>,
    pub exports: IndexMap<String, ExportIndex, RandomState>,
    pub start_function: Option<FunctionIndex>,
    pub table_initializers: Vec<TableInitializer, Global>,
    pub passive_elements: HashMap<ElemIndex, Box<[FunctionIndex], Global>, RandomState>,
    pub passive_data: HashMap<DataIndex, Box<[u8], Global>, RandomState>,
    pub global_initializers: PrimaryMap<LocalGlobalIndex, GlobalInit>,
    pub function_names: HashMap<FunctionIndex, String, RandomState>,
    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, RandomState>,
    pub custom_sections_data: PrimaryMap<CustomSectionIndex, Box<[u8], Global>>,
    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. 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

name: Option<String>

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

imports: IndexMap<ImportKey, ImportIndex, RandomState>

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, RandomState>

Exported entities.

start_function: Option<FunctionIndex>

The module “start” function, if present.

table_initializers: Vec<TableInitializer, Global>

WebAssembly table initializers.

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

WebAssembly passive elements.

passive_data: HashMap<DataIndex, Box<[u8], Global>, RandomState>

WebAssembly passive data segments.

global_initializers: PrimaryMap<LocalGlobalIndex, GlobalInit>

WebAssembly global initializers.

function_names: HashMap<FunctionIndex, String, RandomState>

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, RandomState>

Custom sections in the module.

custom_sections_data: PrimaryMap<CustomSectionIndex, Box<[u8], Global>>

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() -> ModuleInfo

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, Global>

Get the exported signatures of the module

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

Get the export types of the module

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

Get the import types of the module

pub fn custom_sections<'a>(
    &'a self,
    name: &'a str
) -> impl Iterator<Item = Box<[u8], Global>> + '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: <ModuleInfo as Archive>::Resolver,
    out: *mut <ModuleInfo as Archive>::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<(), Error>

Formats the value using the given formatter.

impl Default for ModuleInfo

fn default() -> ModuleInfo

Returns the “default value” for a type.

impl<D> Deserialize<ModuleInfo, D> for <ModuleInfo as Archive>::Archivedwhere
    D: Fallible + SharedDeserializeRegistry + ?Sized,

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

Deserializes using the given deserializer

impl Display for ModuleInfo

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

Formats the value using the given formatter.

impl From<ArchivableModuleInfo> for ModuleInfo

fn from(it: ArchivableModuleInfo) -> ModuleInfo

Converts to this type from the input type.

impl PartialEq<ModuleInfo> for ModuleInfo

fn eq(&self, other: &ModuleInfo) -> 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> Serialize<S> for ModuleInfowhere
    S: Serializer + SharedSerializeRegistry + ScratchSpace + ?Sized,

fn serialize(
    &self,
    serializer: &mut S
) -> Result<<ModuleInfo as Archive>::Resolver, <S as Fallible>::Error>

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

impl Eq for ModuleInfo