Struct wasmer_runtime_core::vm::Ctx

#[repr(C)]
pub struct Ctx {
    pub internal: InternalCtx,
    pub local_backing: *mut LocalBacking,
    pub import_backing: *mut ImportBacking,
    pub module: *const ModuleInner,
    pub data: *mut c_void,
    pub data_finalizer: Option<fn(data: *mut c_void)>,
    // some fields omitted
}

The context of the currently running WebAssembly instance.

This is implicitly passed to every WebAssembly function. Since this is per-instance, each field has a statically (as in after compiling the wasm) known size, so no runtime checks are necessary.

While the runtime currently just passes this around as the first, implicit parameter of every function, it may someday be pinned to a register (especially on arm, which has a ton of registers) to reduce register shuffling.

Fields

internal: InternalCtx

InternalCtx data field

local_backing: *mut LocalBacking

These are pointers to things that are known to be owned by the owning Instance.

import_backing: *mut ImportBacking

Mutable pointer to import data

module: *const ModuleInner

Const pointer to module inner data

data: *mut c_void

This is intended to be user-supplied, per-instance contextual data. There are currently some issue with it, notably that it cannot be set before running the start function in a WebAssembly module. Additionally, the data field may be taken by another ABI implementation that the user wishes to use in addition to their own, such as WASI. This issue is being discussed at #1111.

Alternatively, per-function data can be used if the function in the [ImportObject] is a closure. This cannot duplicate data though, so if data may be shared if the [ImportObject] is reused.

data_finalizer: Option<fn(data: *mut c_void)>

If there's a function set in this field, it gets called when the context is destructed, e.g. when an Instance is dropped.

Methods

impl Ctx

pub fn memory(&self, mem_index: u32) -> &Memory

This exposes the specified memory of the WebAssembly instance as a immutable slice.

WebAssembly will soon support multiple linear memories, so this forces the user to specify.

Usage:

fn read_memory(ctx: &Ctx) -> u8 {
    let first_memory = ctx.memory(0);
    // Read the first byte of that linear memory.
    first_memory.view()[0].get()
}

pub unsafe fn memory_and_data_mut<T>(
    &mut self,
    mem_index: u32
) -> (&Memory, &mut T)

Get access to [Memory] and mutable access to the user defined data field as the type, T.

This method is required to access both at the same time. This is useful for updating a data type that stores information about locations in Wasm memory.

Safety

This function must be called with the same type, T, that the data was initialized with.

pub unsafe fn borrow_symbol_map(&self) -> &Option<HashMap<u32, String>>

Gives access to the emscripten symbol map, used for debugging

pub fn dynamic_sigindice_count(&self) -> usize

Returns the number of dynamic sigindices.

pub fn get_internal(&self, field: &InternalField) -> u64

Returns the value of the specified internal field.

pub fn set_internal(&mut self, field: &InternalField, value: u64)

Writes the value to the specified internal field.

pub fn call_with_table_index(
    &mut self,
    index: TableIndex,
    args: &[Value]
) -> CallResult<Vec<Value>>

Calls a host or Wasm function at the given table index

Trait Implementations

impl Debug for Ctx

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

Formats the value using the given formatter.

impl Drop for Ctx

When an instance context is destructed, we're calling its data_finalizer In order avoid leaking resources.

Implementing the data_finalizer function is the responsibility of the wasmer end-user.

See test: test_data_finalizer as an example

fn drop(&mut self)

Executes the destructor for this type.