wasmi_core 2.0.0-beta.0

Core primitives for the wasmi WebAssembly interpreter
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use crate::{IndexType, TableError};

#[cfg(doc)]
use crate::Table;

/// A Wasm reference type.
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RefType {
    /// A Wasm `funcref` reference type.
    Func,
    /// A Wasm `externref` reference type.
    Extern,
}

/// A Wasm table descriptor.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct TableType {
    /// The type of values stored in the [`Table`].
    element: RefType,
    /// The minimum number of elements the [`Table`] must have.
    min: u64,
    /// The optional maximum number of elements the [`Table`] can have.
    ///
    /// If this is `None` then the [`Table`] is not limited in size.
    max: Option<u64>,
    /// The index type used by the [`Table`].
    index_ty: IndexType,
}

impl TableType {
    /// Creates a new [`TableType`].
    ///
    /// # Panics
    ///
    /// If `min` is greater than `max`.
    pub fn new(element: RefType, min: u32, max: Option<u32>) -> Self {
        Self::new_impl(element, IndexType::I32, u64::from(min), max.map(u64::from))
    }

    /// Creates a new [`TableType`] with a 64-bit index type.
    ///
    /// # Note
    ///
    /// 64-bit tables are part of the [Wasm `memory64` proposal].
    ///
    /// [Wasm `memory64` proposal]: https://github.com/WebAssembly/memory64
    ///
    /// # Panics
    ///
    /// If `min` is greater than `max`.
    pub fn new64(element: RefType, min: u64, max: Option<u64>) -> Self {
        Self::new_impl(element, IndexType::I64, min, max)
    }

    /// Convenience constructor to create a new [`TableType`].
    pub(crate) fn new_impl(
        element: RefType,
        index_ty: IndexType,
        min: u64,
        max: Option<u64>,
    ) -> Self {
        let absolute_max = index_ty.max_size();
        assert!(u128::from(min) <= absolute_max);
        max.inspect(|&max| {
            assert!(min <= max && u128::from(max) <= absolute_max);
        });
        Self {
            element,
            min,
            max,
            index_ty,
        }
    }

    /// Returns `true` if this is a 64-bit [`TableType`].
    ///
    /// 64-bit memories are part of the Wasm `memory64` proposal.
    pub fn is_64(&self) -> bool {
        self.index_ty.is_64()
    }

    /// Returns the [`IndexType`] used by the [`TableType`].
    pub fn index_ty(&self) -> IndexType {
        self.index_ty
    }

    /// Returns the [`RefType`] of elements stored in the table.
    pub fn element(&self) -> RefType {
        self.element
    }

    /// Returns minimum number of elements the table must have.
    pub fn minimum(&self) -> u64 {
        self.min
    }

    /// The optional maximum number of elements the table can have.
    ///
    /// If this returns `None` then the table is not limited in size.
    pub fn maximum(&self) -> Option<u64> {
        self.max
    }

    /// Returns `Ok` if the element type of `self` matches `ty`.
    ///
    /// # Errors
    ///
    /// Returns a [`TableError::ElementTypeMismatch`] otherwise.
    pub(crate) fn ensure_element_type_matches(&self, ty: RefType) -> Result<(), TableError> {
        if self.element() != ty {
            return Err(TableError::ElementTypeMismatch);
        }
        Ok(())
    }

    /// Returns `true` if the [`TableType`] is a subtype of the `other` [`TableType`].
    ///
    /// # Note
    ///
    /// This implements the [subtyping rules] according to the WebAssembly spec.
    ///
    /// [import subtyping]:
    /// https://webassembly.github.io/spec/core/valid/types.html#import-subtyping
    pub fn is_subtype_of(&self, other: &Self) -> bool {
        if self.is_64() != other.is_64() {
            return false;
        }
        if self.element() != other.element() {
            return false;
        }
        if self.minimum() < other.minimum() {
            return false;
        }
        match (self.maximum(), other.maximum()) {
            (_, None) => true,
            (Some(max), Some(other_max)) => max <= other_max,
            _ => false,
        }
    }
}