Struct FrameHandle 

pub struct FrameHandle { /* private fields */ }

A handle to a stack frame, valid as long as execution is not resumed in the associated Store.

This handle can be held and cloned and used to refer to a frame within a paused store. It is cheap: it internally consists of a pointer to the actual frame, together with some metadata to determine when that pointer has gone stale.

At the API level, any usage of this frame handle requires a mutable borrow of the Store, because the Store logically owns the stack(s) for any execution within it. However, the existence of the handle itself does not hold a borrow on the Store; hence, the Store can continue to be used and queried, and some state (e.g. memories, tables, GC objects) can even be mutated, as long as execution is not resumed. The intent of this API is to allow a wide variety of debugger implementation strategies that expose stack frames and also allow other commands/actions at the same time.

The user can use FrameHandle::is_valid to determine if the handle is still valid and usable.

Implementations

impl FrameHandle

pub fn is_valid(&self, store: impl AsContextMut) -> bool

Determine whether this handle can still be used to refer to a frame.

pub fn parent( &self, store: impl AsContextMut, ) -> Result<Option<FrameHandle>, Error>

Get a handle to the next frame up the activation (the one that called this frame), if any.

pub fn instance(&self, store: impl AsContextMut) -> Result<Instance, Error>

Get the instance associated with the current frame.

pub fn module<'a, T>( &self, store: impl Into<StoreContextMut<'a, T>>, ) -> Result<Option<&'a Module>, Error>

where T: 'static,

Get the module associated with the current frame, if any (i.e., not a container instance for a host-created entity).

pub fn wasm_function_index_and_pc( &self, store: impl AsContextMut, ) -> Result<Option<(DefinedFuncIndex, u32)>, Error>

Get the raw function index associated with the current frame, and the PC as an offset within its code section, if it is a Wasm function directly from the given Module (rather than a trampoline).

pub fn num_locals(&self, store: impl AsContextMut) -> Result<u32, Error>

Get the number of locals in this frame.

pub fn num_stacks(&self, store: impl AsContextMut) -> Result<u32, Error>

Get the depth of the operand stack in this frame.

pub fn local(&self, store: impl AsContextMut, index: u32) -> Result<Val, Error>

Get the type and value of the given local in this frame.

Panics

Panics if the index is out-of-range (greater than num_locals()).

pub fn stack(&self, store: impl AsContextMut, index: u32) -> Result<Val, Error>

Get the type and value of the given operand-stack value in this frame.

Index 0 corresponds to the bottom-of-stack, and higher indices from there are more recently pushed values. In other words, index order reads the Wasm virtual machine’s abstract stack state left-to-right.

Trait Implementations

impl Clone for FrameHandle

fn clone(&self) -> FrameHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.