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, 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, Arc<[u8]>>>

Passive data segments from our module. As data.drops happen, entries get removed. A missing entry is considered equivalent to an empty slice.

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 signature_ids_ptr(&self) -> *mut VMSharedSignatureIndex

Return a pointer to the VMSharedSignatureIndexs.

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 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 *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 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.