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

local_backing: *mut LocalBacking

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

import_backing: *mut ImportBacking

module: *const ModuleInner

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.

#219 fixes that issue, as well as allowing the user to have per-function context, instead of just per-instance.

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

Trait Implementations

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.

impl Debug for Ctx

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

Formats the value using the given formatter.