Struct wasmer_wasix::WasiInstanceHandles

pub struct WasiInstanceHandles {

    pub(crate) memory: Memory,
    pub(crate) instance: Instance,
    pub(crate) stack_pointer: Option<Global>,
    pub(crate) data_end: Option<Global>,
    pub(crate) stack_low: Option<Global>,
    pub(crate) stack_high: Option<Global>,
    pub(crate) start: Option<TypedFunction<(), ()>>,
    pub(crate) initialize: Option<TypedFunction<(), ()>>,
    pub(crate) thread_spawn: Option<TypedFunction<(i32, i32), ()>>,
    pub(crate) signal: Option<TypedFunction<i32, ()>>,
    pub(crate) signal_set: bool,
    pub(crate) has_stack_checkpoint: bool,
    pub(crate) asyncify_start_unwind: Option<TypedFunction<i32, ()>>,
    pub(crate) asyncify_stop_unwind: Option<TypedFunction<(), ()>>,
    pub(crate) asyncify_start_rewind: Option<TypedFunction<i32, ()>>,
    pub(crate) asyncify_stop_rewind: Option<TypedFunction<(), ()>>,
    pub(crate) asyncify_get_state: Option<TypedFunction<(), i32>>,
}

Various TypedFunction and Global handles for an active WASI(X) instance.

Used to access and modify runtime state.

Fields

memory: Memory

Represents a reference to the memory

instance: Instance

stack_pointer: Option<Global>

Points to the current location of the memory stack pointer

data_end: Option<Global>

Points to the end of the data section

stack_low: Option<Global>

Points to the lower end of the stack

stack_high: Option<Global>

Points to the higher end of the stack

start: Option<TypedFunction<(), ()>>

Main function that will be invoked (name = “_start”)

initialize: Option<TypedFunction<(), ()>>

Function thats invoked to initialize the WASM module (name = “_initialize”)

thread_spawn: Option<TypedFunction<(i32, i32), ()>>

Represents the callback for spawning a thread (name = “wasi_thread_start”) (due to limitations with i64 in browsers the parameters are broken into i32 pairs) [this takes a user_data field]

signal: Option<TypedFunction<i32, ()>>

Represents the callback for signals (name = “__wasm_signal”) Signals are triggered asynchronously at idle times of the process

signal_set: bool

Flag that indicates if the signal callback has been set by the WASM process - if it has not been set then the runtime behaves differently when a CTRL-C is pressed.

has_stack_checkpoint: bool

Flag that indicates if the stack capture exports are being used by this WASM process which means that it will be using asyncify

asyncify_start_unwind: Option<TypedFunction<i32, ()>>

asyncify_start_unwind(data : i32): call this to start unwinding the stack from the current location. “data” must point to a data structure as described above (with fields containing valid data).

asyncify_stop_unwind: Option<TypedFunction<(), ()>>

asyncify_stop_unwind(): call this to note that unwinding has concluded. If no other code will run before you start to rewind, this is not strictly necessary, however, if you swap between coroutines, or even just want to run some normal code during a “sleep”, then you must call this at the proper time. Otherwise, the code will think it is still unwinding when it should not be, which means it will keep unwinding in a meaningless way.

asyncify_start_rewind: Option<TypedFunction<i32, ()>>

asyncify_start_rewind(data : i32): call this to start rewinding the stack vack up to the location stored in the provided data. This prepares for the rewind; to start it, you must call the first function in the call stack to be unwound.

asyncify_stop_rewind: Option<TypedFunction<(), ()>>

asyncify_stop_rewind(): call this to note that rewinding has concluded, and normal execution can resume.

asyncify_get_state: Option<TypedFunction<(), i32>>

asyncify_get_state(): call this to get the current value of the internal “__asyncify_state” variable as described above. It can be used to distinguish between unwinding/rewinding and normal calls, so that you know when to start an asynchronous operation and when to propagate results back.

Implementations

impl WasiInstanceHandles

pub fn new(memory: Memory, store: &impl AsStoreRef, instance: Instance) -> Self

pub fn module(&self) -> &Module

pub fn module_clone(&self) -> Module

pub fn memory_view<'a>( &'a self, store: &'a (impl AsStoreRef + ?Sized), ) -> MemoryView<'a>

Providers safe access to the memory (it must be initialized before it can be used)

pub fn memory(&self) -> &Memory

Providers safe access to the memory (it must be initialized before it can be used)

pub fn memory_clone(&self) -> Memory

Copy the lazy reference so that when it’s initialized during the export phase, all the other references get a copy of it

pub fn instance(&self) -> &Instance

Trait Implementations

impl Clone for WasiInstanceHandles

fn clone(&self) -> WasiInstanceHandles

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WasiInstanceHandles

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

Formats the value using the given formatter.