Struct wasmtime::Instance

pub struct Instance { /* fields omitted */ }

An instantiated WebAssembly module.

This type represents the instantiation of a Module. Once instantiated you can access the exports which are of type Extern and provide the ability to call functions, set globals, read memory, etc. This is where all the fun stuff happens!

An Instance is created from two inputs, a Module and a list of imports, provided as a list of Extern values. The Module is the wasm code that was compiled and we’re instantiating, and the Extern imports are how we’re satisfying the imports of the module provided. On successful instantiation an Instance will automatically invoke the wasm start function.

When interacting with any wasm code you’ll want to make an Instance to call any code or execute anything!

Implementations

impl Instance

pub fn new(
    store: &Store,
    module: &Module,
    imports: &[Extern]
) -> Result<Instance, Error>

Creates a new Instance from the previously compiled Module and list of imports specified.

This method instantiates the module provided with the imports, following the procedure in the core specification to instantiate. Instantiation can fail for a number of reasons (many specified below), but if successful the start function will be automatically run (if provided) and then the Instance will be returned.

Per the WebAssembly spec, instantiation includes running the module’s start function, if it has one (not to be confused with the _start function, which is not run).

Note that this is a low-level function that just performance an instantiation. See the Linker struct for an API which provides a convenient way to link imports and provides automatic Command and Reactor behavior.

Providing Imports

The imports array here is a bit tricky. The entries in the list of imports are intended to correspond 1:1 with the list of imports returned by Module::imports. Before calling Instance::new you’ll want to inspect the return value of Module::imports and, for each import type, create an Extern which corresponds to that type. These Extern values are all then collected into a list and passed to this function.

Note that this function is intentionally relatively low level. It is the intention that we’ll soon provide a higher level API which will be much more ergonomic for instantiating modules. If you need the full power of customization of imports, though, this is the method for you!

Errors

This function can fail for a number of reasons, including, but not limited to:

• The number of imports provided doesn’t match the number of imports returned by the module’s Module::imports method.
• The type of any Extern doesn’t match the corresponding ExternType entry that it maps to.
• The start function in the instance, if present, traps.
• Module/instance resource limits are exceeded.

When instantiation fails it’s recommended to inspect the return value to see why it failed, or bubble it upwards. If you’d like to specifically check for trap errors, you can use error.downcast::<Trap>().

Panics

This function will panic if called with a store associated with a asynchronous config.

pub async fn new_async(
    store: &Store,
    module: &Module,
    imports: &[Extern]
) -> Result<Instance, Error>

Same as Instance::new, except for usage in [asynchronous stores].

For more details about this function see the documentation on Instance::new. The only difference between these two methods is that this one will asynchronously invoke the wasm start function in case it calls any imported function which is an asynchronous host function (e.g. created with Func::new_async.

Panics

This function will panic if called with a store associated with a synchronous config. This is only compatible with stores associated with an asynchronous config.

pub fn ty(&self) -> InstanceType

Returns the type signature of this instance.

pub fn store(&self) -> &Store

Returns the associated Store that this Instance is compiled into.

This is the Store that generally serves as a sort of global cache for various instance-related things.

pub fn exports<'instance>(
    &'instance self
) -> impl ExactSizeIterator<Item = Export<'instance>> + 'instance

Returns the list of exported items from this Instance.

pub fn get_export(&self, name: &str) -> Option<Extern>

Looks up an exported Extern value by name.

This method will search the module for an export named name and return the value, if found.

Returns None if there was no export named name.

pub fn get_func(&self, name: &str) -> Option<Func>

Looks up an exported Func value by name.

Returns None if there was no export named name, or if there was but it wasn’t a function.

pub fn get_typed_func<Params, Results>(
    &self,
    name: &str
) -> Result<TypedFunc<Params, Results>> where
    Params: WasmParams,
    Results: WasmResults, 

Looks up an exported Func value by name and with its type.

This function is a convenience wrapper over Instance::get_func and Func::typed. For more information see the linked documentation.

Returns an error if name isn’t a function export or if the export’s type did not match Params or Results

pub fn get_table(&self, name: &str) -> Option<Table>

Looks up an exported Table value by name.

Returns None if there was no export named name, or if there was but it wasn’t a table.

pub fn get_memory(&self, name: &str) -> Option<Memory>

Looks up an exported Memory value by name.

Returns None if there was no export named name, or if there was but it wasn’t a memory.

pub fn get_global(&self, name: &str) -> Option<Global>

Looks up an exported Global value by name.

Returns None if there was no export named name, or if there was but it wasn’t a global.

Trait Implementations

impl Clone for Instance

fn clone(&self) -> Instance

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<Instance> for Extern

fn from(r: Instance) -> Self

Performs the conversion.