Struct wasmtime_environ::ModuleLocal

pub struct ModuleLocal {
    pub signatures: PrimaryMap<SignatureIndex, (WasmFuncType, Signature)>,
    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>,
}

Local information known about a wasm module, the bare minimum necessary to translate function bodies.

This is stored within a Module and it implements Hash, unlike Module, and is used as part of the cache key when we load compiled modules from the global cache.

Fields

signatures: PrimaryMap<SignatureIndex, (WasmFuncType, Signature)>

Unprocessed signatures exactly as provided by declare_signature().

num_imported_funcs: 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.

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.

Implementations

impl ModuleLocal

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 native_func_signature(&self, func_index: FuncIndex) -> &Signature

Convenience method for looking up the native signature of a compiled Wasm function.

pub fn wasm_func_type(&self, func_index: FuncIndex) -> &WasmFuncType

Convenience method for looking up the original Wasm signature of a function.

Trait Implementations

impl Debug for ModuleLocal

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModuleLocal

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

Deserialize this value from the given Serde deserializer.

impl Hash for ModuleLocal

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Serialize for ModuleLocal

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

Serialize this value into the given Serde serializer.