Struct wasmtime_runtime::InstanceHandle

pub struct InstanceHandle { /* private fields */ }

A handle holding an Instance of a WebAssembly module.

Implementations

impl InstanceHandle

pub unsafe fn from_vmctx(vmctx: *mut VMContext) -> Self

Create a new InstanceHandle pointing at the instance pointed to by the given VMContext pointer.

Safety

This is unsafe because it doesn’t work on just any VMContext, it must be a VMContext allocated as part of an Instance.

Examples found in repository

src/debug_builtins.rs (line 11)

pub unsafe extern "C" fn resolve_vmctx_memory(ptr: usize) -> *const u8 {
    let handle = InstanceHandle::from_vmctx(VMCTX_AND_MEMORY.0);
    assert!(
        VMCTX_AND_MEMORY.1 < handle.module().memory_plans.len(),
        "memory index for debugger is out of bounds"
    );
    let index = MemoryIndex::new(VMCTX_AND_MEMORY.1);
    let mem = handle.instance().get_memory(index);
    mem.base.add(ptr)
}

#[no_mangle]
pub unsafe extern "C" fn resolve_vmctx_memory_ptr(p: *const u32) -> *const u8 {
    let ptr = std::ptr::read(p);
    assert!(
        !VMCTX_AND_MEMORY.0.is_null(),
        "must call `__vmctx->set()` before resolving Wasm pointers"
    );
    let handle = InstanceHandle::from_vmctx(VMCTX_AND_MEMORY.0);
    assert!(
        VMCTX_AND_MEMORY.1 < handle.module().memory_plans.len(),
        "memory index for debugger is out of bounds"
    );
    let index = MemoryIndex::new(VMCTX_AND_MEMORY.1);
    let mem = handle.instance().get_memory(index);
    mem.base.add(ptr as usize)
}

pub fn vmctx(&self) -> &VMContext

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

pub fn vmctx_ptr(&self) -> *mut VMContext

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

pub fn module(&self) -> &Arc<Module>

Return a reference to a module.

Examples found in repository

src/debug_builtins.rs (line 13)

pub unsafe extern "C" fn resolve_vmctx_memory(ptr: usize) -> *const u8 {
    let handle = InstanceHandle::from_vmctx(VMCTX_AND_MEMORY.0);
    assert!(
        VMCTX_AND_MEMORY.1 < handle.module().memory_plans.len(),
        "memory index for debugger is out of bounds"
    );
    let index = MemoryIndex::new(VMCTX_AND_MEMORY.1);
    let mem = handle.instance().get_memory(index);
    mem.base.add(ptr)
}

#[no_mangle]
pub unsafe extern "C" fn resolve_vmctx_memory_ptr(p: *const u32) -> *const u8 {
    let ptr = std::ptr::read(p);
    assert!(
        !VMCTX_AND_MEMORY.0.is_null(),
        "must call `__vmctx->set()` before resolving Wasm pointers"
    );
    let handle = InstanceHandle::from_vmctx(VMCTX_AND_MEMORY.0);
    assert!(
        VMCTX_AND_MEMORY.1 < handle.module().memory_plans.len(),
        "memory index for debugger is out of bounds"
    );
    let index = MemoryIndex::new(VMCTX_AND_MEMORY.1);
    let mem = handle.instance().get_memory(index);
    mem.base.add(ptr as usize)
}

pub fn get_exported_func(&mut self, export: FuncIndex) -> ExportFunction

Lookup a function by index.

Examples found in repository

src/instance.rs (line 1127)

    pub fn get_export_by_index(&mut self, export: EntityIndex) -> Export {
        match export {
            EntityIndex::Function(i) => Export::Function(self.get_exported_func(i)),
            EntityIndex::Global(i) => Export::Global(self.get_exported_global(i)),
            EntityIndex::Table(i) => Export::Table(self.get_exported_table(i)),
            EntityIndex::Memory(i) => Export::Memory(self.get_exported_memory(i)),
        }
    }

pub fn get_exported_global(&mut self, export: GlobalIndex) -> ExportGlobal

Lookup a global by index.

Examples found in repository

src/instance.rs (line 1128)

    pub fn get_export_by_index(&mut self, export: EntityIndex) -> Export {
        match export {
            EntityIndex::Function(i) => Export::Function(self.get_exported_func(i)),
            EntityIndex::Global(i) => Export::Global(self.get_exported_global(i)),
            EntityIndex::Table(i) => Export::Table(self.get_exported_table(i)),
            EntityIndex::Memory(i) => Export::Memory(self.get_exported_memory(i)),
        }
    }

pub fn get_exported_memory(&mut self, export: MemoryIndex) -> ExportMemory

Lookup a memory by index.

Examples found in repository

src/instance.rs (line 1130)

    pub fn get_export_by_index(&mut self, export: EntityIndex) -> Export {
        match export {
            EntityIndex::Function(i) => Export::Function(self.get_exported_func(i)),
            EntityIndex::Global(i) => Export::Global(self.get_exported_global(i)),
            EntityIndex::Table(i) => Export::Table(self.get_exported_table(i)),
            EntityIndex::Memory(i) => Export::Memory(self.get_exported_memory(i)),
        }
    }

pub fn get_exported_table(&mut self, export: TableIndex) -> ExportTable

Lookup a table by index.

Examples found in repository

src/instance.rs (line 1129)

    pub fn get_export_by_index(&mut self, export: EntityIndex) -> Export {
        match export {
            EntityIndex::Function(i) => Export::Function(self.get_exported_func(i)),
            EntityIndex::Global(i) => Export::Global(self.get_exported_global(i)),
            EntityIndex::Table(i) => Export::Table(self.get_exported_table(i)),
            EntityIndex::Memory(i) => Export::Memory(self.get_exported_memory(i)),
        }
    }

pub fn get_export_by_index(&mut self, export: EntityIndex) -> Export

Lookup an item with the given index.

pub fn exports(&self) -> Iter<'_, String, EntityIndex>

Return an iterator over the exports of this instance.

Specifically, it provides access to the key-value pairs, where the keys are export names, and the values are export declarations which can be resolved lookup_by_declaration.

pub fn host_state(&self) -> &dyn Any

Return a reference to the custom state attached to this instance.

pub fn get_defined_memory(&mut self, index: DefinedMemoryIndex) -> *mut Memory

Get a memory defined locally within this module.

pub unsafe fn table_index(&self, table: &VMTableDefinition) -> DefinedTableIndex

Return the table index for the given VMTableDefinition in this instance.

pub fn get_defined_table(&mut self, index: DefinedTableIndex) -> *mut Table

Get a table defined locally within this module.

pub fn get_defined_table_with_lazy_init(
    &mut self,
    index: DefinedTableIndex,
    range: impl Iterator<Item = u32>
) -> *mut Table

Get a table defined locally within this module, lazily initializing the given range first.

pub fn store(&self) -> *mut dyn Store

Returns the Store pointer that was stored on creation

pub unsafe fn set_store(&mut self, store: *mut dyn Store)

Configure the *mut dyn Store internal pointer after-the-fact.

This is provided for the original Store itself to configure the first self-pointer after the original Box has been initialized.

pub unsafe fn clone(&self) -> InstanceHandle

Returns a clone of this instance.

This is unsafe because the returned handle here is just a cheap clone of the internals, there’s no lifetime tracking around its validity. You’ll need to ensure that the returned handles all go out of scope at the same time.

Trait Implementations

impl Hash for InstanceHandle

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl PartialEq<InstanceHandle> for InstanceHandle

fn eq(&self, other: &InstanceHandle) -> 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 Eq for InstanceHandle

impl Send for InstanceHandle

impl StructuralEq for InstanceHandle

impl StructuralPartialEq for InstanceHandle

impl Sync for InstanceHandle