Struct Instance 

#[repr(C)]
pub(crate) struct Instance {

    module: Arc<ModuleInfo>,
    context: *mut StoreObjects,
    offsets: VMOffsets,
    memories: BoxedSlice<LocalMemoryIndex, InternalStoreHandle<VMMemory>>,
    tables: BoxedSlice<LocalTableIndex, InternalStoreHandle<VMTable>>,
    globals: BoxedSlice<LocalGlobalIndex, InternalStoreHandle<VMGlobal>>,
    tags: BoxedSlice<TagIndex, InternalStoreHandle<VMTag>>,
    functions: BoxedSlice<LocalFunctionIndex, FunctionBodyPtr>,
    function_call_trampolines: BoxedSlice<SignatureIndex, VMTrampoline>,
    passive_elements: RefCell<HashMap<ElemIndex, Box<[Option<VMFuncRef>]>>>,
    passive_data: RefCell<HashMap<DataIndex, Option<Arc<[u8]>>>>,
    funcrefs: BoxedSlice<LocalFunctionIndex, VMCallerCheckedAnyfunc>,
    imported_funcrefs: BoxedSlice<FunctionIndex, NonNull<VMCallerCheckedAnyfunc>>,
    vmctx: VMContext,
}

A WebAssembly instance.

The type is dynamically-sized. Indeed, the vmctx field can contain various data. That’s why the type has a C representation to ensure that the vmctx field is last. See the documentation of the vmctx field to learn more.

Fields

module: Arc<ModuleInfo>

The ModuleInfo this Instance was instantiated from.

context: *mut StoreObjects

Pointer to the object store of the context owning this instance.

offsets: VMOffsets

Offsets in the vmctx region.

memories: BoxedSlice<LocalMemoryIndex, InternalStoreHandle<VMMemory>>

WebAssembly linear memory data.

tables: BoxedSlice<LocalTableIndex, InternalStoreHandle<VMTable>>

WebAssembly table data.

globals: BoxedSlice<LocalGlobalIndex, InternalStoreHandle<VMGlobal>>

WebAssembly global data.

tags: BoxedSlice<TagIndex, InternalStoreHandle<VMTag>>

WebAssembly tag data. Notably, this stores all tags, not just local ones.

functions: BoxedSlice<LocalFunctionIndex, FunctionBodyPtr>

Pointers to functions in executable memory.

function_call_trampolines: BoxedSlice<SignatureIndex, VMTrampoline>

Pointers to function call trampolines in executable memory.

passive_elements: RefCell<HashMap<ElemIndex, Box<[Option<VMFuncRef>]>>>

Passive elements in this instantiation. As elem.drops happen, these entries get removed.

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

Per-instance view of the module’s passive data segments.

A None entry (dropped) or a missing entry is treated as an empty slice.

The bytes are shared with the module via Arc (no per-instance copy). data.drop replaces an entry’s value with None to mark the segment unusable for subsequent memory.init on this instance, without affecting the shared module bytes or any other instance.

funcrefs: BoxedSlice<LocalFunctionIndex, VMCallerCheckedAnyfunc>

Mapping of function indices to their func ref backing data. VMFuncRefs will point to elements here for functions defined by this instance.

imported_funcrefs: BoxedSlice<FunctionIndex, NonNull<VMCallerCheckedAnyfunc>>

Mapping of function indices to their func ref backing data. VMFuncRefs will point to elements here for functions imported by this instance.

vmctx: VMContext

Additional context used by compiled WebAssembly code. This field is last, and represents a dynamically-sized array that extends beyond the nominal end of the struct (similar to a flexible array member).

Implementations

impl Instance

unsafe fn vmctx_plus_offset<T>(&self, offset: u32) -> *mut T

Helper function to access various locations offset from our *mut VMContext object.

fn module(&self) -> &Arc<ModuleInfo>

pub(crate) fn module_ref(&self) -> &ModuleInfo

pub(crate) fn context(&self) -> &StoreObjects

pub(crate) fn context_mut(&mut self) -> &mut StoreObjects

fn offsets(&self) -> &VMOffsets

Offsets in the vmctx region.

fn imported_function(&self, index: FunctionIndex) -> &VMFunctionImport

Return the indexed VMFunctionImport.

fn imported_functions_ptr(&self) -> *mut VMFunctionImport

Return a pointer to the VMFunctionImports.

fn imported_table(&self, index: TableIndex) -> &VMTableImport

Return the index VMTableImport.

fn imported_tables_ptr(&self) -> *mut VMTableImport

Return a pointer to the VMTableImportss.

fn imported_memory(&self, index: MemoryIndex) -> &VMMemoryImport

Return the indexed VMMemoryImport.

fn imported_memories_ptr(&self) -> *mut VMMemoryImport

Return a pointer to the VMMemoryImports.

fn imported_global(&self, index: GlobalIndex) -> &VMGlobalImport

Return the indexed VMGlobalImport.

fn imported_globals_ptr(&self) -> *mut VMGlobalImport

Return a pointer to the VMGlobalImports.

pub(crate) fn shared_tag_ptr(&self, index: TagIndex) -> &VMSharedTagIndex

Return the indexed VMSharedTagIndex.

pub(crate) fn shared_tags_ptr(&self) -> *mut VMSharedTagIndex

Return a pointer to the VMSharedTagIndexs.

fn table(&self, index: LocalTableIndex) -> VMTableDefinition

Return the indexed VMTableDefinition.

fn set_table(&self, index: LocalTableIndex, table: &VMTableDefinition)

Updates the value for a defined table to VMTableDefinition.

fn table_ptr(&self, index: LocalTableIndex) -> NonNull<VMTableDefinition>

Return the indexed VMTableDefinition.

fn tables_ptr(&self) -> *mut VMTableDefinition

Return a pointer to the VMTableDefinitions.

fn fixed_funcref_table_ptr( &self, index: LocalTableIndex, ) -> Option<NonNull<VMCallerCheckedAnyfunc>>

fn sync_fixed_funcref_table_element( &self, table_index: LocalTableIndex, index: u32, funcref: Option<VMFuncRef>, )

fn sync_fixed_funcref_table(&self, table_index: LocalTableIndex)

fn sync_fixed_funcref_table_by_index(&self, table_index: TableIndex)

fn get_memory(&self, index: MemoryIndex) -> VMMemoryDefinition

Get a locally defined or imported memory.

fn memory(&self, index: LocalMemoryIndex) -> VMMemoryDefinition

Return the indexed VMMemoryDefinition.

fn set_memory(&self, index: LocalMemoryIndex, mem: &VMMemoryDefinition)

Set the indexed memory to VMMemoryDefinition.

fn memory_ptr(&self, index: LocalMemoryIndex) -> NonNull<VMMemoryDefinition>

Return the indexed VMMemoryDefinition.

fn memories_ptr(&self) -> *mut VMMemoryDefinition

Return a pointer to the VMMemoryDefinitions.

fn get_vmmemory(&self, index: MemoryIndex) -> &VMMemory

Get a locally defined or imported memory.

fn get_vmmemory_mut(&mut self, index: MemoryIndex) -> &mut VMMemory

Get a locally defined or imported memory.

fn get_local_vmmemory_mut( &mut self, local_index: LocalMemoryIndex, ) -> &mut VMMemory

Get a locally defined memory as mutable.

fn global(&self, index: LocalGlobalIndex) -> VMGlobalDefinition

Return the indexed VMGlobalDefinition.

fn set_global(&self, index: LocalGlobalIndex, global: &VMGlobalDefinition)

Set the indexed global to VMGlobalDefinition.

fn global_ptr(&self, index: LocalGlobalIndex) -> NonNull<VMGlobalDefinition>

Return the indexed VMGlobalDefinition.

fn globals_ptr(&self) -> *mut VMGlobalDefinition

Return a pointer to the VMGlobalDefinitions.

fn builtin_functions_ptr(&self) -> *mut VMBuiltinFunctionsArray

Return a pointer to the VMBuiltinFunctionsArray.

fn vmctx(&self) -> &VMContext

Return a reference to the vmctx used by compiled wasm code.

fn vmctx_ptr(&self) -> *mut VMContext

Return a raw pointer to the vmctx used by compiled wasm code.

fn invoke_start_function( &self, config: &VMConfig, trap_handler: Option<*const TrapHandlerFn<'static>>, ) -> Result<(), Trap>

Invoke the WebAssembly start function of the instance, if one is present.

pub(crate) fn vmctx_offset() -> isize

Return the offset from the vmctx pointer to its containing Instance.

pub(crate) fn table_index(&self, table: &VMTableDefinition) -> LocalTableIndex

Return the table index for the given VMTableDefinition.

pub(crate) fn memory_index( &self, memory: &VMMemoryDefinition, ) -> LocalMemoryIndex

Return the memory index for the given VMMemoryDefinition.

pub(crate) fn memory_grow<IntoPages>( &mut self, memory_index: LocalMemoryIndex, delta: IntoPages, ) -> Result<Pages, MemoryError>

where IntoPages: Into<Pages>,

Grow memory by the specified amount of pages.

Returns None if memory can’t be grown by the specified amount of pages.

pub(crate) unsafe fn imported_memory_grow<IntoPages>( &mut self, memory_index: MemoryIndex, delta: IntoPages, ) -> Result<Pages, MemoryError>

where IntoPages: Into<Pages>,

Grow imported memory by the specified amount of pages.

Returns None if memory can’t be grown by the specified amount of pages.

Safety

This and imported_memory_size are currently unsafe because they dereference the memory import’s pointers.

pub(crate) fn memory_size(&self, memory_index: LocalMemoryIndex) -> Pages

Returns the number of allocated wasm pages.

pub(crate) unsafe fn imported_memory_size( &self, memory_index: MemoryIndex, ) -> Pages

Returns the number of allocated wasm pages in an imported memory.

Safety

This and imported_memory_grow are currently unsafe because they dereference the memory import’s pointers.

pub(crate) fn table_size(&self, table_index: LocalTableIndex) -> u32

Returns the number of elements in a given table.

pub(crate) unsafe fn imported_table_size(&self, table_index: TableIndex) -> u32

Returns the number of elements in a given imported table.

Safety

table_index must be a valid, imported table index.

pub(crate) fn table_grow( &mut self, table_index: LocalTableIndex, delta: u32, init_value: TableElement, ) -> Option<u32>

Grow table by the specified amount of elements.

Returns None if table can’t be grown by the specified amount of elements.

pub(crate) unsafe fn imported_table_grow( &mut self, table_index: TableIndex, delta: u32, init_value: TableElement, ) -> Option<u32>

Grow table by the specified amount of elements.

Safety

table_index must be a valid, imported table index.

pub(crate) fn table_get( &self, table_index: LocalTableIndex, index: u32, ) -> Option<TableElement>

Get table element by index.

pub(crate) unsafe fn imported_table_get( &self, table_index: TableIndex, index: u32, ) -> Option<TableElement>

Returns the element at the given index.

Safety

table_index must be a valid, imported table index.

pub(crate) fn table_set( &mut self, table_index: LocalTableIndex, index: u32, val: TableElement, ) -> Result<(), Trap>

Set table element by index.

pub(crate) unsafe fn imported_table_set( &mut self, table_index: TableIndex, index: u32, val: TableElement, ) -> Result<(), Trap>

Set table element by index for an imported table.

Safety

table_index must be a valid, imported table index.

pub(crate) fn func_ref( &self, function_index: FunctionIndex, ) -> Option<VMFuncRef>

Get a VMFuncRef for the given FunctionIndex.

pub(crate) fn table_init( &mut self, table_index: TableIndex, elem_index: ElemIndex, dst: u32, src: u32, len: u32, ) -> Result<(), Trap>

The table.init operation: initializes a portion of a table with a passive element.

Errors

Returns a Trap error when the range within the table is out of bounds or the range within the passive element is out of bounds.

pub(crate) fn table_fill( &mut self, table_index: TableIndex, start_index: u32, item: TableElement, len: u32, ) -> Result<(), Trap>

The table.fill operation: fills a portion of a table with a given value.

Errors

Returns a Trap error when the range within the table is out of bounds

pub(crate) fn table_copy( &mut self, dst_table_index: TableIndex, src_table_index: TableIndex, dst: u32, src: u32, len: u32, ) -> Result<(), Trap>

The table.copy operation.

pub(crate) fn elem_drop(&self, elem_index: ElemIndex)

Drop an element.

pub(crate) fn local_memory_copy( &self, memory_index: LocalMemoryIndex, dst: u32, src: u32, len: u32, ) -> Result<(), Trap>

Do a memory.copy for a locally defined memory.

Errors

Returns a Trap error when the source or destination ranges are out of bounds.

pub(crate) fn imported_memory_copy( &self, memory_index: MemoryIndex, dst: u32, src: u32, len: u32, ) -> Result<(), Trap>

Perform a memory.copy on an imported memory.

pub(crate) fn local_memory_fill( &self, memory_index: LocalMemoryIndex, dst: u32, val: u32, len: u32, ) -> Result<(), Trap>

Perform the memory.fill operation on a locally defined memory.

Errors

Returns a Trap error if the memory range is out of bounds.

pub(crate) fn imported_memory_fill( &self, memory_index: MemoryIndex, dst: u32, val: u32, len: u32, ) -> Result<(), Trap>

Perform the memory.fill operation on an imported memory.

Errors

Returns a Trap error if the memory range is out of bounds.

pub(crate) fn memory_init( &self, memory_index: MemoryIndex, data_index: DataIndex, dst: u32, src: u32, len: u32, ) -> Result<(), Trap>

Performs the memory.init operation.

Errors

Returns a Trap error if the destination range is out of this module’s memory’s bounds or if the source range is outside the data segment’s bounds.

pub(crate) fn data_drop(&self, data_index: DataIndex)

Drop the given data segment, truncating its length to zero.

pub(crate) fn get_table(&mut self, table_index: TableIndex) -> &mut VMTable

Get a table by index regardless of whether it is locally-defined or an imported, foreign table.

pub(crate) fn get_local_table(&mut self, index: LocalTableIndex) -> &mut VMTable

Get a locally-defined table.

pub(crate) fn get_foreign_table(&mut self, index: TableIndex) -> &mut VMTable

Get an imported, foreign table.

pub(crate) fn get_table_handle( &mut self, table_index: TableIndex, ) -> InternalStoreHandle<VMTable>

Get a table handle by index regardless of whether it is locally-defined or an imported, foreign table.

unsafe fn memory_wait( memory: &mut VMMemory, dst: u32, expected: ExpectedValue, timeout: i64, ) -> Result<u32, Trap>

Safety

See LinearMemory::do_wait.

pub(crate) fn local_memory_wait32( &mut self, memory_index: LocalMemoryIndex, dst: u32, val: u32, timeout: i64, ) -> Result<u32, Trap>

Perform an Atomic.Wait32

pub(crate) fn imported_memory_wait32( &mut self, memory_index: MemoryIndex, dst: u32, val: u32, timeout: i64, ) -> Result<u32, Trap>

Perform an Atomic.Wait32

pub(crate) fn local_memory_wait64( &mut self, memory_index: LocalMemoryIndex, dst: u32, val: u64, timeout: i64, ) -> Result<u32, Trap>

Perform an Atomic.Wait64

pub(crate) fn imported_memory_wait64( &mut self, memory_index: MemoryIndex, dst: u32, val: u64, timeout: i64, ) -> Result<u32, Trap>

Perform an Atomic.Wait64

pub(crate) fn local_memory_notify( &mut self, memory_index: LocalMemoryIndex, dst: u32, count: u32, ) -> Result<u32, Trap>

Perform an Atomic.Notify

pub(crate) fn imported_memory_notify( &mut self, memory_index: MemoryIndex, dst: u32, count: u32, ) -> Result<u32, Trap>

Perform an Atomic.Notify

Trait Implementations

impl Debug for Instance

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

Formats the value using the given formatter.