wasmtime 35.0.0

High-level API to expose the Wasmtime 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

use crate::runtime::types::TagType;
use crate::{
    AsContext,
    store::{StoreInstanceId, StoreOpaque},
};
use wasmtime_environ::{DefinedTagIndex, VMSharedTypeIndex};

/// A WebAssembly `tag`.
#[derive(Copy, Clone, Debug)]
#[repr(C)] // here for the C API in the future
pub struct Tag {
    instance: StoreInstanceId,
    index: DefinedTagIndex,
}

impl Tag {
    pub(crate) unsafe fn from_wasmtime_tag(
        wasmtime_export: crate::runtime::vm::ExportTag,
        store: &StoreOpaque,
    ) -> Self {
        debug_assert!(
            wasmtime_export.tag.signature.unwrap_engine_type_index()
                != VMSharedTypeIndex::default()
        );
        Tag {
            instance: store.vmctx_id(wasmtime_export.vmctx),
            index: wasmtime_export.index,
        }
    }

    /// Returns the underlying type of this `tag`.
    ///
    /// # Panics
    ///
    /// Panics if `store` does not own this tag.
    pub fn ty(&self, store: impl AsContext) -> TagType {
        self._ty(store.as_context().0)
    }

    pub(crate) fn _ty(&self, store: &StoreOpaque) -> TagType {
        TagType::from_wasmtime_tag(store.engine(), self.wasmtime_ty(store))
    }

    pub(crate) fn wasmtime_ty<'a>(&self, store: &'a StoreOpaque) -> &'a wasmtime_environ::Tag {
        let module = store[self.instance].env_module();
        let index = module.tag_index(self.index);
        &module.tags[index]
    }

    pub(crate) fn vmimport(&self, store: &StoreOpaque) -> crate::runtime::vm::VMTagImport {
        let instance = &store[self.instance];
        crate::runtime::vm::VMTagImport {
            from: instance.tag_ptr(self.index).into(),
            vmctx: instance.vmctx().into(),
            index: self.index,
        }
    }

    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
        store.id() == self.instance.store_id()
    }

    /// Determines whether this tag is reference equal to the other
    /// given tag in the given store.
    ///
    /// # Panics
    ///
    /// Panics if either tag do not belong to the given `store`.
    pub fn eq(a: &Tag, b: &Tag, store: impl AsContext) -> bool {
        // make sure both tags belong to the store
        let store = store.as_context();
        let _ = &store[a.instance];
        let _ = &store[b.instance];

        // then compare to see if they have the same definition
        a.instance == b.instance && a.index == b.index
    }
}