Struct WasmPtr 

pub struct WasmPtr<T, Ty = Item>
where
    T: Copy,
{ /* private fields */ }

A zero-cost type that represents a pointer to something in Wasm linear memory.

This type can be used directly in the host function arguments:

pub fn host_import(ctx: &mut Ctx, ptr: WasmPtr<u32>) {
    let memory = ctx.memory(0);
    let derefed_ptr = ptr.deref(memory).expect("pointer in bounds");
    let inner_val: u32 = derefed_ptr.get();
    println!("Got {} from Wasm memory address 0x{:X}", inner_val, ptr.offset());
    // update the value being pointed to
    derefed_ptr.set(inner_val + 1);
}

Implementations

impl<T, Ty> WasmPtr<T, Ty>

where T: Copy,

Methods relevant to all types of WasmPtr.

pub fn new(offset: u32) -> WasmPtr<T, Ty>

Create a new WasmPtr at the given offset.

pub fn offset(self) -> u32

Get the offset into Wasm linear memory for this WasmPtr.

impl<T> WasmPtr<T>

where T: Copy + ValueType,

Methods for WasmPtrs to data that can be dereferenced, namely to types that implement ValueType, meaning that they’re valid for all possible bit patterns.

pub fn deref<'a>(self, memory: &'a Memory) -> Option<&'a Cell<T>>

Dereference the WasmPtr getting access to a &Cell<T> allowing for reading and mutating of the inner value.

This method is unsound if used with unsynchronized shared memory. If you’re unsure what that means, it likely does not apply to you. This invariant will be enforced in the future.

pub unsafe fn deref_mut<'a>(self, memory: &'a Memory) -> Option<&'a mut Cell<T>>

Mutably dereference this WasmPtr getting a &mut Cell<T> allowing for direct access to a &mut T.

Safety

• This method does not do any aliasing checks: it’s possible to create &mut T that point to the same memory. You should ensure that you have exclusive access to Wasm linear memory before calling this method.

impl<T> WasmPtr<T, Array>

where T: Copy + ValueType,

Methods for WasmPtrs to arrays of data that can be dereferenced, namely to types that implement ValueType, meaning that they’re valid for all possible bit patterns.

pub fn deref( self, memory: &Memory, index: u32, length: u32, ) -> Option<&[Cell<T>]>

Dereference the WasmPtr getting access to a &[Cell<T>] allowing for reading and mutating of the inner values.

This method is unsound if used with unsynchronized shared memory. If you’re unsure what that means, it likely does not apply to you. This invariant will be enforced in the future.

pub unsafe fn deref_mut( self, memory: &Memory, index: u32, length: u32, ) -> Option<&mut [Cell<T>]>

Mutably dereference this WasmPtr getting a &mut [Cell<T>] allowing for direct access to a &mut [T].

Safety

• This method does not do any aliasing checks: it’s possible to create &mut T that point to the same memory. You should ensure that you have exclusive access to Wasm linear memory before calling this method.

pub fn get_utf8_string(self, memory: &Memory, str_len: u32) -> Option<&str>

Get a UTF-8 string from the WasmPtr with the given length.

Note that this method returns a reference to Wasm linear memory. The underlying data can be mutated if the Wasm is allowed to execute or an aliasing WasmPtr is used to mutate memory.

pub fn get_utf8_string_with_nul(self, memory: &Memory) -> Option<&str>

Get a UTF-8 string from the WasmPtr, where the string is nul-terminated.

Note that this does not account for UTF-8 strings that contain nul themselves, [get_utf8_string] has to be used for those.

Also note that this method returns a reference to Wasm linear memory. The underlying data can be mutated if the Wasm is allowed to execute or an aliasing WasmPtr is used to mutate memory.

Trait Implementations

impl<T, Ty> Clone for WasmPtr<T, Ty>

where T: Copy,

fn clone(&self) -> WasmPtr<T, Ty>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, Ty> Debug for WasmPtr<T, Ty>

where T: Copy,

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

Formats the value using the given formatter.

impl<T, Ty> PartialEq for WasmPtr<T, Ty>

where T: Copy,

fn eq(&self, other: &WasmPtr<T, Ty>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, Ty> WasmExternType for WasmPtr<T, Ty>

where T: Copy,

type Native = i32

Native wasm type for this WasmExternType.

fn to_native(self) -> <WasmPtr<T, Ty> as WasmExternType>::Native

Convert self to Native type.

fn from_native(n: <WasmPtr<T, Ty> as WasmExternType>::Native) -> WasmPtr<T, Ty>

Convert from given Native type to self.

impl<T, Ty> Copy for WasmPtr<T, Ty>

where T: Copy,

impl<T, Ty> Eq for WasmPtr<T, Ty>

where T: Copy,

impl<T, Ty> ValueType for WasmPtr<T, Ty>

where T: Copy,