tinywasm 0.9.0

A tiny 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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

pub(crate) trait TinywasmIntExt: Sized {
    fn checked_wrapping_rem(self, rhs: Self) -> Result<Self, Trap>;
    fn wasm_checked_div(self, rhs: Self) -> Result<Self, Trap>;
}

/// Doing the actual conversion from float to int is a bit tricky, because
/// we need to check for overflow. This macro generates the min/max values
/// for a specific conversion, which are then used in the actual conversion.
/// Rust sadly doesn't have wrapping casts for floats yet.
#[rustfmt::skip]
macro_rules! float_min_max {
    (f32, i32) => {(i32::MIN as f32 - (1 << 8) as f32, i32::MAX as f32 + 1.0)}; // 2^8: f32 precision margin
    (f64, i32) => {(i32::MIN as f64 - 1.0, i32::MAX as f64 + 1.0)};
    (f32, u32) => {(-1.0_f32, u32::MAX as f32 + 1.0)};
    (f64, u32) => {(-1.0_f64, u32::MAX as f64 + 1.0)};
    (f32, i64) => {(i64::MIN as f32 - (1i64 << 40) as f32, i64::MAX as f32 + 1.0)}; // 2^40: f32 has 23 mantissa bits
    (f64, i64) => {(i64::MIN as f64 - (1i64 << 11) as f64, i64::MAX as f64 + 1.0)}; // 2^11: f64 precision margin
    (f32, u64) => {(-1.0_f32, u64::MAX as f32 + 1.0)};
    (f64, u64) => {(-1.0_f64, u64::MAX as f64 + 1.0)};
    ($from:ty, $to:ty) => {compile_error!("invalid float conversion")};
}

/// Convert a value on the stack with error checking
macro_rules! checked_conv_float {
    // Direct conversion with error checking (two types)
    ($from:tt, $to:tt, $self:expr) => {
        checked_conv_float!($from, $to, $to, $self)
    };
    // Conversion with an intermediate unsigned type and error checking (three types)
    ($from:tt, $intermediate:tt, $to:tt, $self:expr) => {{
        let v = <$from>::stack_pop(&mut $self.store.value_stack);
        let (min, max) = float_min_max!($from, $intermediate);
        if unlikely(v.is_nan()) {
            return Err(crate::Trap::InvalidConversionToInt);
        }
        if unlikely(v <= min || v >= max) {
            return Err(crate::Trap::IntegerOverflow);
        }
        $self.store.value_stack.push::<$to>((v as $intermediate as $to).into())?;
    }};
}

pub(crate) use checked_conv_float;
pub(crate) use float_min_max;

pub(super) fn trap_0() -> Trap {
    crate::Trap::DivisionByZero
}
pub(crate) trait TinywasmFloatExt {
    fn tw_minimum(self, other: Self) -> Self;
    fn tw_maximum(self, other: Self) -> Self;
    fn tw_nearest(self) -> Self;
}

use crate::{Result, Trap};

#[cfg(not(feature = "std"))]
use super::no_std_floats::NoStdFloatExt;

macro_rules! impl_wasm_float_ops {
    ($($t:ty)*) => ($(
        impl TinywasmFloatExt for $t {
            // https://webassembly.github.io/spec/core/exec/numerics.html#op-fnearest
            #[inline]
            fn tw_nearest(self) -> Self {
                match self {
                    #[cfg(not(feature = "canonicalize-nans"))]
                    x if x.is_nan() => x, // preserve NaN
                    #[cfg(feature = "canonicalize-nans")]
                    x if x.is_nan() => Self::NAN, // Do not preserve NaN
                    x if x.is_infinite() || x == 0.0 => x, // preserve infinities and zeros
                    x if (0.0..=0.5).contains(&x) => 0.0,
                    x if (-0.5..0.0).contains(&x) => -0.0,
                    x => {
                        // Handle normal and halfway cases
                        let rounded = x.round();
                        let diff = (x - rounded).abs();
                        if diff != 0.5 || rounded % 2.0 == 0.0 {
                            return rounded
                        }

                        rounded - x.signum() // Make even
                    }
                }
            }

            // https://webassembly.github.io/spec/core/exec/numerics.html#op-fmin
            // Based on f32::minimum (which is not yet stable)
            #[inline]
            fn tw_minimum(self, other: Self) -> Self {
                match self.partial_cmp(&other) {
                    Some(core::cmp::Ordering::Less) => self,
                    Some(core::cmp::Ordering::Greater) => other,
                    Some(core::cmp::Ordering::Equal) => if self.is_sign_negative() && other.is_sign_positive() { self } else { other },
                    #[cfg(not(feature = "canonicalize-nans"))]
                    None => self + other, // At least one input is NaN. Use `+` to perform NaN propagation and quieting.
                    #[cfg(feature = "canonicalize-nans")]
                    None => Self::NAN, // Do not preserve NaN
                }
            }

            // https://webassembly.github.io/spec/core/exec/numerics.html#op-fmax
            // Based on f32::maximum (which is not yet stable)
            #[inline]
            fn tw_maximum(self, other: Self) -> Self {
                match self.partial_cmp(&other) {
                    Some(core::cmp::Ordering::Greater) => self,
                    Some(core::cmp::Ordering::Less) => other,
                    Some(core::cmp::Ordering::Equal) => if self.is_sign_negative() && other.is_sign_positive() { other } else { self },
                    #[cfg(not(feature = "canonicalize-nans"))]
                    None => self + other, // At least one input is NaN. Use `+` to perform NaN propagation and quieting.
                    #[cfg(feature = "canonicalize-nans")]
                    None => Self::NAN, // Do not preserve NaN
                }
            }
        }
    )*)
}

impl_wasm_float_ops! { f32 f64 }

pub(crate) trait WasmIntOps {
    fn wasm_shl(self, rhs: Self) -> Self;
    fn wasm_shr(self, rhs: Self) -> Self;
    fn wasm_rotl(self, rhs: Self) -> Self;
    fn wasm_rotr(self, rhs: Self) -> Self;
}

macro_rules! impl_wrapping_self_sh {
    ($($t:ty)*) => ($(
        impl WasmIntOps for $t {
            #[inline]
            fn wasm_shl(self, rhs: Self) -> Self {
                self.wrapping_shl(rhs as u32)
            }

            #[inline]
            fn wasm_shr(self, rhs: Self) -> Self {
                self.wrapping_shr(rhs as u32)
            }

            #[inline]
            fn wasm_rotl(self, rhs: Self) -> Self {
                self.rotate_left(rhs as u32)
            }

            #[inline]
            fn wasm_rotr(self, rhs: Self) -> Self {
                self.rotate_right(rhs as u32)
            }
        }
    )*)
}

impl_wrapping_self_sh! { i32 i64 u32 u64 }

macro_rules! impl_checked_wrapping_rem {
    ($($t:ty)*) => ($(
        impl TinywasmIntExt for $t {
            fn checked_wrapping_rem(self, rhs: Self) -> Result<Self, crate::Trap> {
                if rhs == 0 {
                    Err(crate::Trap::DivisionByZero)
                } else {
                    Ok(self.wrapping_rem(rhs))
                }
            }

            fn wasm_checked_div(self, rhs: Self) -> Result<Self, crate::Trap> {
                if rhs == 0 {
                    Err(crate::Trap::DivisionByZero)
                } else {
                    self.checked_div(rhs).ok_or_else(|| crate::Trap::IntegerOverflow)
                }
            }
        }
    )*)
}

impl_checked_wrapping_rem! { i32 i64 u32 u64 }