Struct wasmer::WasmPtr[][src]

#[repr(transparent)]pub struct WasmPtr<T: Copy, Ty = Item> { /* fields omitted */ }

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(memory: Memory, ptr: WasmPtr<u32>) {
    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: Copy, Ty> WasmPtr<T, Ty>[src]

Methods relevant to all types of WasmPtr.

pub fn new(offset: u32) -> Self[src]

Create a new WasmPtr at the given offset.

pub fn offset(self) -> u32[src]

Get the offset into Wasm linear memory for this WasmPtr.

impl<T: Copy + ValueType> WasmPtr<T, Item>[src]

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>>[src]

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>>[src]

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: Copy + ValueType> WasmPtr<T, Array>[src]

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>]>
[src]

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>]>
[src]

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 unsafe fn get_utf8_str<'a>(
    self,
    memory: &'a Memory,
    str_len: u32
) -> Option<&'a str>
[src]

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

Note that . The underlying data can be mutated if the Wasm is allowed to execute or an aliasing WasmPtr is used to mutate memory.

Safety

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.

str has invariants that must not be broken by mutating Wasm memory. Thus the caller must ensure that the backing memory is not modified while the reference is held.

Additionally, if memory is dynamic, the caller must also ensure that memory is not grown while the reference is held.

pub fn get_utf8_string(self, memory: &Memory, str_len: u32) -> Option<String>[src]

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

an aliasing WasmPtr is used to mutate memory.

pub unsafe fn get_utf8_str_with_nul<'a>(
    self,
    memory: &'a Memory
) -> Option<&'a str>
[src]

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, WasmPtr::get_utf8_str has to be used for those.

Safety

This method behaves similarly to WasmPtr::get_utf8_str, all safety invariants on that method must also be upheld here.

pub fn get_utf8_string_with_nul(self, memory: &Memory) -> Option<String>[src]

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, WasmPtr::get_utf8_string has to be used for those.

Trait Implementations

impl<T: Copy, Ty> Clone for WasmPtr<T, Ty>[src]

impl<T: Copy, Ty> Copy for WasmPtr<T, Ty>[src]

impl<T: Copy, Ty> Debug for WasmPtr<T, Ty>[src]

impl<T: Copy, Ty> Eq for WasmPtr<T, Ty>[src]

impl<T: Copy, Ty> FromToNativeWasmType for WasmPtr<T, Ty>[src]

type Native = i32

Native Wasm type.

impl<T: Copy, Ty> PartialEq<WasmPtr<T, Ty>> for WasmPtr<T, Ty>[src]

impl<T: Copy, Ty> ValueType for WasmPtr<T, Ty>[src]

Auto Trait Implementations

impl<T, Ty> RefUnwindSafe for WasmPtr<T, Ty> where
    T: RefUnwindSafe,
    Ty: RefUnwindSafe
[src]

impl<T, Ty> Send for WasmPtr<T, Ty> where
    T: Send,
    Ty: Send
[src]

impl<T, Ty> Sync for WasmPtr<T, Ty> where
    T: Sync,
    Ty: Sync
[src]

impl<T, Ty> Unpin for WasmPtr<T, Ty> where
    T: Unpin,
    Ty: Unpin
[src]

impl<T, Ty> UnwindSafe for WasmPtr<T, Ty> where
    T: UnwindSafe,
    Ty: UnwindSafe
[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<Q, K> Equivalent<K> for Q where
    K: Borrow<Q> + ?Sized,
    Q: Eq + ?Sized
[src]

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Pointable for T

type Init = T

The type for initializers.

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,