submilli-wasm 0.2.0

A WebAssembly interpreter with a wasmtime-compatible API, built for fast compilation and startup
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

//! Handle → entity accessors for [`StoreInner`]: bounds- and provenance-checked (#34) reads
//! of the store's arenas, split from `inner.rs`. All are `#[inline]` —
//! they sit on the interpreter's per-op paths, and the dispatch loop monomorphizes in the
//! consumer crate (cross-crate inlining needs the attribute).

use super::entity::{
    FuncEntity, GlobalEntity, InstanceEntity, MemoryEntity, TableEntity, TagEntity,
};
use super::inner::StoreInner;
use crate::extern_::{Global, Memory, Table, Tag};
use crate::func::Func;
use crate::instance::Instance;

impl StoreInner {
    #[inline]
    pub(crate) fn func(&self, handle: Func) -> &FuncEntity {
        self.check_handle(handle.store);
        self.funcs.get(handle.index)
    }

    #[inline]
    pub(crate) fn memory(&self, handle: Memory) -> &MemoryEntity {
        self.check_handle(handle.store);
        self.memories.get(handle.index)
    }

    #[inline]
    pub(crate) fn memory_mut(&mut self, handle: Memory) -> &mut MemoryEntity {
        self.check_handle(handle.store);
        self.memories.get_mut(handle.index)
    }

    /// The memory at `index`, which must be the arena index of a [`Memory`] handle of *this* store
    /// whose store was already checked — no store check here (the execution's memory-0 cache).
    /// `None` if there is none.
    #[inline]
    pub(crate) fn resolved_memory(&self, index: u32) -> Option<&MemoryEntity> {
        self.memories.get_opt(index)
    }

    /// Mutable [`resolved_memory`](Self::resolved_memory).
    #[inline]
    pub(crate) fn resolved_memory_mut(&mut self, index: u32) -> Option<&mut MemoryEntity> {
        self.memories.get_opt_mut(index)
    }

    #[inline]
    pub(crate) fn table(&self, handle: Table) -> &TableEntity {
        self.check_handle(handle.store);
        self.tables.get(handle.index)
    }

    #[inline]
    pub(crate) fn table_mut(&mut self, handle: Table) -> &mut TableEntity {
        self.check_handle(handle.store);
        self.tables.get_mut(handle.index)
    }

    #[inline]
    pub(crate) fn global(&self, handle: Global) -> &GlobalEntity {
        self.check_handle(handle.store);
        self.globals.get(handle.index)
    }

    #[inline]
    pub(crate) fn global_mut(&mut self, handle: Global) -> &mut GlobalEntity {
        self.check_handle(handle.store);
        self.globals.get_mut(handle.index)
    }

    #[inline]
    pub(crate) fn tag(&self, handle: Tag) -> &TagEntity {
        self.check_handle(handle.store);
        self.tags.get(handle.index)
    }

    #[inline]
    pub(crate) fn instance(&self, handle: Instance) -> &InstanceEntity {
        self.check_handle(handle.store);
        self.instances.get(handle.index)
    }

    #[inline]
    pub(crate) fn instance_mut(&mut self, handle: Instance) -> &mut InstanceEntity {
        self.check_handle(handle.store);
        self.instances.get_mut(handle.index)
    }
}