wasmer 7.2.0-alpha.2

High-performance WebAssembly runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use wasmer_types::StoreId;

use crate::{BackendStore, macros::backend::match_rt};

/// Set of objects managed by a context.
#[derive(Debug)]
pub enum StoreObjects {
    #[cfg(feature = "sys")]
    /// Store objects for the `sys` runtime.
    Sys(crate::backend::sys::store::StoreObjects),

    #[cfg(feature = "v8")]
    /// Store objects for the `v8` runtime.
    V8(crate::backend::v8::store::StoreObjects),

    #[cfg(feature = "js")]
    /// Store objects for the `js` runtime.
    Js(crate::backend::js::store::StoreObjects),
}

impl StoreObjects {
    /// Checks whether two stores are identical. A store is considered
    /// equal to another store if both have the same engine.
    #[inline]
    pub fn same(a: &Self, b: &Self) -> bool {
        match (a, b) {
            #[cfg(feature = "sys")]
            (Self::Sys(a), Self::Sys(b)) => a.id() == b.id(),
            #[cfg(feature = "v8")]
            (Self::V8(a), Self::V8(b)) => a.id() == b.id(),
            #[cfg(feature = "js")]
            (Self::Js(a), Self::Js(b)) => a.id() == b.id(),

            _ => panic!(
                "Incompatible `StoreObjects` instance: {}, {}!",
                a.id(),
                b.id()
            ),
        }
    }

    /// Returns the ID of this store
    #[inline]
    pub fn id(&self) -> StoreId {
        match_rt!(on self => s {
            s.id()
        })
    }

    #[inline]
    pub(crate) fn from_store_ref(store: &BackendStore) -> Self {
        match store {
            #[cfg(feature = "sys")]
            BackendStore::Sys(_) => Self::Sys(Default::default()),
            #[cfg(feature = "v8")]
            BackendStore::V8(_) => Self::V8(Default::default()),
            #[cfg(feature = "js")]
            BackendStore::Js(_) => Self::Js(Default::default()),
        }
    }

    /// Return a vector of all globals and converted to u128
    #[inline]
    pub fn as_u128_globals(&self) -> Vec<u128> {
        match_rt!(on self => s {
            s.as_u128_globals()
        })
    }

    /// Set a global, at index idx. Will panic if idx is out of range
    /// Safety: the caller should check that the raw value is compatible
    /// with destination VMGlobal type
    #[inline]
    pub fn set_global_unchecked(&self, idx: usize, val: u128) {
        match_rt!(on self => s {
            s.set_global_unchecked(idx, val)
        })
    }

    #[cfg(all(unix, feature = "experimental-host-interrupt"))]
    /// Builds an [`Interrupter`] for this store
    pub fn interrupter(&self) -> Interrupter {
        match self {
            #[cfg(feature = "sys")]
            Self::Sys(s) => Interrupter(InterrupterInner::Sys(
                crate::backend::sys::store::Interrupter::new(s.id()),
            )),
            _ => panic!("Interrupters can only be built for stores from the sys backend"),
        }
    }
}

/// Allows embedders to interrupt a running WASM instance.
#[cfg(all(unix, feature = "experimental-host-interrupt"))]
#[derive(Clone)]
pub struct Interrupter(InterrupterInner);

#[cfg(all(unix, feature = "experimental-host-interrupt"))]
impl Interrupter {
    /// Interrupts running WASM instances from the owning [`Store`](crate::Store).
    pub fn interrupt(&self) {
        self.0.interrupt()
    }
}

/// Allows embedders to interrupt a running WASM instance.
#[cfg(all(unix, feature = "experimental-host-interrupt"))]
#[derive(Clone)]
pub enum InterrupterInner {
    #[cfg(feature = "sys")]
    /// Interrupter for the `sys` runtime.
    Sys(crate::backend::sys::store::Interrupter),
}

#[cfg(all(unix, feature = "experimental-host-interrupt"))]
impl InterrupterInner {
    /// Interrupts running WASM instances from the owning [`Store`](crate::Store).
    pub fn interrupt(&self) {
        match self {
            #[cfg(feature = "sys")]
            Self::Sys(i) => i.interrupt(),
        }
    }
}