#[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(*mut c_void)>,
/* private fields */
}
Expand description
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(*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.
Implementations
sourceimpl Ctx
impl Ctx
sourcepub fn memory(&self, mem_index: u32) -> &Memory
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()
}
sourcepub unsafe fn memory_and_data_mut<T>(
&mut self,
mem_index: u32
) -> (&Memory, &mut T)
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.
sourcepub unsafe fn borrow_symbol_map(
&self
) -> &Option<HashMap<u32, String, RandomState>>
pub unsafe fn borrow_symbol_map(
&self
) -> &Option<HashMap<u32, String, RandomState>>
Gives access to the emscripten symbol map, used for debugging
sourcepub fn dynamic_sigindice_count(&self) -> usize
pub fn dynamic_sigindice_count(&self) -> usize
Returns the number of dynamic sigindices.
sourcepub fn get_internal(&self, field: &InternalField) -> u64
pub fn get_internal(&self, field: &InternalField) -> u64
Returns the value of the specified internal field.
sourcepub fn set_internal(&mut self, field: &InternalField, value: u64)
pub fn set_internal(&mut self, field: &InternalField, value: u64)
Writes the value to the specified internal field.
sourcepub fn call_with_table_index(
&mut self,
index: TableIndex,
args: &[Value]
) -> Result<Vec<Value, Global>, CallError>
pub fn call_with_table_index(
&mut self,
index: TableIndex,
args: &[Value]
) -> Result<Vec<Value, Global>, CallError>
Calls a host or Wasm function at the given table index
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Ctx
impl !Send for Ctx
impl !Sync for Ctx
impl Unpin for Ctx
impl !UnwindSafe for Ctx
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more