WIP: Add optional NaN canonicalization

crates/core/src/lib.rs

@@ -44,5 +44,5 @@ pub use self::{
     typed::{Typed, TypedVal},
     units::Pages,
     untyped::{DecodeUntypedSlice, EncodeUntypedSlice, UntypedError, UntypedVal},
-    value::ValType,
+    value::{CanonicalizeNan, ValType},
 };

crates/core/src/typed.rs

@@ -299,19 +299,23 @@ impl TypedVal {
 
         fn f32_abs(f32) -> f32;
         fn f32_neg(f32) -> f32;
+        fn f32_neg_canonicalize_nan(f32) -> f32;
         fn f32_ceil(f32) -> f32;
         fn f32_floor(f32) -> f32;
         fn f32_trunc(f32) -> f32;
         fn f32_nearest(f32) -> f32;
         fn f32_sqrt(f32) -> f32;
+        fn f32_sqrt_canonicalize_nan(f32) -> f32;
 
         fn f64_abs(f64) -> f64;
         fn f64_neg(f64) -> f64;
+        fn f64_neg_canonicalize_nan(f64) -> f64;
         fn f64_ceil(f64) -> f64;
         fn f64_floor(f64) -> f64;
         fn f64_trunc(f64) -> f64;
         fn f64_nearest(f64) -> f64;
         fn f64_sqrt(f64) -> f64;
+        fn f64_sqrt_canonicalize_nan(f64) -> f64;
 
         fn f32_add(f32, f32) -> f32;
         fn f32_sub(f32, f32) -> f32;
@@ -321,6 +325,14 @@ impl TypedVal {
         fn f32_max(f32, f32) -> f32;
         fn f32_copysign(f32, f32) -> f32;
 
+        fn f32_add_canonicalize_nan(f32, f32) -> f32;
+        fn f32_sub_canonicalize_nan(f32, f32) -> f32;
+        fn f32_mul_canonicalize_nan(f32, f32) -> f32;
+        fn f32_div_canonicalize_nan(f32, f32) -> f32;
+        fn f32_min_canonicalize_nan(f32, f32) -> f32;
+        fn f32_max_canonicalize_nan(f32, f32) -> f32;
+        fn f32_copysign_canonicalize_nan(f32, f32) -> f32;
+
         fn f64_add(f64, f64) -> f64;
         fn f64_sub(f64, f64) -> f64;
         fn f64_mul(f64, f64) -> f64;
@@ -329,6 +341,14 @@ impl TypedVal {
         fn f64_max(f64, f64) -> f64;
         fn f64_copysign(f64, f64) -> f64;
 
+        fn f64_add_canonicalize_nan(f64, f64) -> f64;
+        fn f64_sub_canonicalize_nan(f64, f64) -> f64;
+        fn f64_mul_canonicalize_nan(f64, f64) -> f64;
+        fn f64_div_canonicalize_nan(f64, f64) -> f64;
+        fn f64_min_canonicalize_nan(f64, f64) -> f64;
+        fn f64_max_canonicalize_nan(f64, f64) -> f64;
+        fn f64_copysign_canonicalize_nan(f64, f64) -> f64;
+
         // Conversions
 
         fn i32_wrap_i64(i64) -> i32;

crates/core/src/untyped.rs

@@ -1,6 +1,7 @@
 use crate::{
     value::{LoadInto, StoreFrom},
     ArithmeticOps,
+    CanonicalizeNan,
     ExtendInto,
     Float,
     Integer,
@@ -931,6 +932,11 @@
         self.execute_unary(<f32 as Neg>::neg)
     }
 
+    /// Execute `f32.neg` Wasm operation.
+    pub fn f32_neg_canonicalize_nan(self) -> Self {
+        self.execute_unary(|value| <f32 as Neg>::neg(value).canonicalize_nan())
+    }
+
     /// Execute `f32.ceil` Wasm operation.
     pub fn f32_ceil(self) -> Self {
         self.execute_unary(<f32 as Float>::ceil)
@@ -953,7 +959,12 @@
 
     /// Execute `f32.sqrt` Wasm operation.
     pub fn f32_sqrt(self) -> Self {
-        self.execute_unary(<f32 as Float>::sqrt)
+        self.execute_unary(<F32 as Float>::sqrt)
+    }
+
+    /// Execute `f32.sqrt` Wasm operation.
+    pub fn f32_sqrt_canonicalize_nan(self) -> Self {
+        self.execute_unary(|value| <f32 as Float>::sqrt(value).canonicalize_nan())
     }
 
     /// Execute `f64.abs` Wasm operation.
@@ -966,6 +977,11 @@
         self.execute_unary(<f64 as Neg>::neg)
     }
 
+    /// Execute `f64.neg` Wasm operation.
+    pub fn f64_neg_canonicalize_nan(self) -> Self {
+        self.execute_unary(|value| <f64 as Neg>::neg(value).canonicalize_nan())
+    }
+
     /// Execute `f64.ceil` Wasm operation.
     pub fn f64_ceil(self) -> Self {
         self.execute_unary(<f64 as Float>::ceil)
@@ -991,76 +1007,179 @@
         self.execute_unary(<f64 as Float>::sqrt)
     }
 
+    /// Execute `f64.sqrt` Wasm operation.
+    pub fn f64_sqrt_canonicalize_nan(self) -> Self {
+        self.execute_unary(|value| <f64 as Float>::sqrt(value).canonicalize_nan())
+    }
+
     /// Execute `f32.add` Wasm operation.
     pub fn f32_add(self, rhs: Self) -> Self {
         self.execute_binary(rhs, <f32 as ArithmeticOps>::add)
     }
 
+    /// Execute `f32.add` Wasm operation with NaN canonicalization.
+    pub fn f32_add_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f32 as ArithmeticOps>::add(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f64.add` Wasm operation.
     pub fn f64_add(self, rhs: Self) -> Self {
         self.execute_binary(rhs, <f64 as ArithmeticOps>::add)
     }
 
+    /// Execute `f64.add` Wasm operation with NaN canonicalization.
+    pub fn f64_add_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f64 as ArithmeticOps>::add(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f32.sub` Wasm operation.
     pub fn f32_sub(self, rhs: Self) -> Self {
         self.execute_binary(rhs, <f32 as ArithmeticOps>::sub)
     }
 
+    /// Execute `f32.sub` Wasm operation with NaN canonicalization.
+    pub fn f32_sub_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f32 as ArithmeticOps>::sub(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f64.sub` Wasm operation.
     pub fn f64_sub(self, rhs: Self) -> Self {
         self.execute_binary(rhs, <f64 as ArithmeticOps>::sub)
     }
 
+    /// Execute `f64.sub` Wasm operation with NaN canonicalization.
+    pub fn f64_sub_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f64 as ArithmeticOps>::sub(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f32.mul` Wasm operation.
     pub fn f32_mul(self, rhs: Self) -> Self {
         self.execute_binary(rhs, <f32 as ArithmeticOps>::mul)
     }
 
+    /// Execute `f32.mul` Wasm operation with NaN canonicalization.
+    pub fn f32_mul_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f32 as ArithmeticOps>::mul(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f64.mul` Wasm operation.
     pub fn f64_mul(self, rhs: Self) -> Self {
         self.execute_binary(rhs, <f64 as ArithmeticOps>::mul)
     }
 
+    /// Execute `f64.mul` Wasm operation with NaN canonicalization.
+    pub fn f64_mul_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f64 as ArithmeticOps>::mul(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f32.div` Wasm operation.
     pub fn f32_div(self, rhs: Self) -> Self {
         self.execute_binary(rhs, <f32 as Float>::div)
     }
 
+    /// Execute `f32.div` Wasm operation with NaN canonicalization.
+    pub fn f32_div_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f32 as Float>::div(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f64.div` Wasm operation.
     pub fn f64_div(self, rhs: Self) -> Self {
         self.execute_binary(rhs, <f64 as Float>::div)
     }
 
+    /// Execute `f64.div` Wasm operation with NaN canonicalization.
+    pub fn f64_div_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f64 as Float>::div(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f32.min` Wasm operation.
     pub fn f32_min(self, other: Self) -> Self {
         self.execute_binary(other, <f32 as Float>::min)
     }
 
+    /// Execute `f32.min` Wasm operation with NaN canonicalization.
+    pub fn f32_min_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f32 as Float>::min(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f64.min` Wasm operation.
     pub fn f64_min(self, other: Self) -> Self {
         self.execute_binary(other, <f64 as Float>::min)
     }
 
+    /// Execute `f64.min` Wasm operation with NaN canonicalization.
+    pub fn f64_min_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f64 as Float>::min(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f32.max` Wasm operation.
     pub fn f32_max(self, other: Self) -> Self {
         self.execute_binary(other, <f32 as Float>::max)
     }
 
+    /// Execute `f32.max` Wasm operation with NaN canonicalization.
+    pub fn f32_max_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f32 as Float>::max(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f64.max` Wasm operation.
     pub fn f64_max(self, other: Self) -> Self {
         self.execute_binary(other, <f64 as Float>::max)
     }
 
+    /// Execute `f64.max` Wasm operation with NaN canonicalization.
+    pub fn f64_max_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f64 as Float>::max(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f32.copysign` Wasm operation.
     pub fn f32_copysign(self, other: Self) -> Self {
         self.execute_binary(other, <f32 as Float>::copysign)
     }
 
+    /// Execute `f32.copysign` Wasm operation with NaN canonicalization.
+    pub fn f32_copysign_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f32 as Float>::copysign(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `f64.copysign` Wasm operation.
     pub fn f64_copysign(self, other: Self) -> Self {
         self.execute_binary(other, <f64 as Float>::copysign)
     }
 
+    /// Execute `f64.copysign` Wasm operation with NaN canonicalization.
+    pub fn f64_copysign_canonicalize_nan(self, rhs: Self) -> Self {
+        self.execute_binary(rhs, |lhs, rhs| {
+            <f64 as Float>::copysign(lhs, rhs).canonicalize_nan()
+        })
+    }
+
     /// Execute `i32.wrap_i64` Wasm operation.
     pub fn i32_wrap_i64(self) -> Self {
         self.execute_unary(<i64 as WrapInto<i32>>::wrap_into)

crates/core/src/value.rs

@@ -791,3 +791,34 @@
         )
     }
 }
+
+/// Trait implemented by floating point types for NaN canonicalization.
+pub trait CanonicalizeNan {
+    /// Canonicalizes `self` if it is NaN.
+    fn canonicalize_nan(self) -> Self;
+}
+
+macro_rules! impl_caninocalize_nan {
+    ( $( $ty:ty as $nan_val:literal),* $(,)? ) => {
+        $(
+            impl CanonicalizeNan for $ty {
+                fn canonicalize_nan(self) -> Self {
+                    if self.is_nan() {
+                        let canonicalized = Self::from_bits($nan_val);
+                        debug_assert!(canonicalized.is_nan());
+                        return canonicalized
+                    }
+                    self
+                }
+            }
+        )*
+    };
+}
+impl_caninocalize_nan! {
+    // Note: These patterns ensures that the sign bit can be either 0 or 1,
+    //       the exponent bits are all set to 1 (indicating an infinity or NaN),
+    //       and the fraction (mantissa) bits are all zero, except the most significant bit
+    //       of the fraction is set to 1 to indicate a quiet NaN.
+    f32 as 0x7FC00000_u32,
+    f64 as 0x7FF8000000000000_u64,
+}