Remove float canonicalization from components (bytecodealliance#9879)

* Remove float canonicalization from components

This was removed from the spec quite awhile back so this catches up the
runtime to the spec where this is no longer required.

Closes bytecodealliance#9826

* Update tests

Author: alexcrichton

crates/wasmtime/src/runtime/component/func/typed.rs

@@ -875,19 +875,6 @@ integers! {
 
 macro_rules! floats {
     ($($float:ident/$get_float:ident = $ty:ident with abi:$abi:ident)*) => ($(const _: () = {
-        /// All floats in-and-out of the canonical abi always have their nan
-        /// payloads canonicalized. conveniently the `NAN` constant in rust has
-        /// the same representation as canonical nan, so we can use that for the
-        /// nan value.
-        #[inline]
-        fn canonicalize(float: $float) -> $float {
-            if float.is_nan() {
-                $float::NAN
-            } else {
-                float
-            }
-        }
-
         unsafe impl ComponentType for $float {
             type Lower = ValRaw;
 
@@ -910,7 +897,7 @@ macro_rules! floats {
                 dst: &mut MaybeUninit<Self::Lower>,
             ) -> Result<()> {
                 debug_assert!(matches!(ty, InterfaceType::$ty));
-                dst.write(ValRaw::$float(canonicalize(*self).to_bits()));
+                dst.write(ValRaw::$float(self.to_bits()));
                 Ok(())
             }
 
@@ -924,7 +911,7 @@ macro_rules! floats {
                 debug_assert!(matches!(ty, InterfaceType::$ty));
                 debug_assert!(offset % Self::SIZE32 == 0);
                 let ptr = cx.get(offset);
-                *ptr = canonicalize(*self).to_bits().to_le_bytes();
+                *ptr = self.to_bits().to_le_bytes();
                 Ok(())
             }
         }
@@ -933,14 +920,14 @@ macro_rules! floats {
             #[inline]
             fn lift(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
                 debug_assert!(matches!(ty, InterfaceType::$ty));
-                Ok(canonicalize($float::from_bits(src.$get_float())))
+                Ok($float::from_bits(src.$get_float()))
             }
 
             #[inline]
             fn load(_cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
                 debug_assert!(matches!(ty, InterfaceType::$ty));
                 debug_assert!((bytes.as_ptr() as usize) % Self::SIZE32 == 0);
-                Ok(canonicalize($float::from_le_bytes(bytes.try_into().unwrap())))
+                Ok($float::from_le_bytes(bytes.try_into().unwrap()))
             }
         }
     };)*)

tests/all/component_model/func.rs

@@ -503,26 +503,26 @@ fn floats() -> Result<()> {
             .call(&mut store, (CANON_32BIT_NAN | 1,))?
             .0
             .to_bits(),
-        CANON_32BIT_NAN
+        CANON_32BIT_NAN | 1
     );
     u32_to_f32.post_return(&mut store)?;
     assert_eq!(
         u64_to_f64
             .call(&mut store, (CANON_64BIT_NAN | 1,))?
             .0
             .to_bits(),
-        CANON_64BIT_NAN,
+        CANON_64BIT_NAN | 1,
     );
     u64_to_f64.post_return(&mut store)?;
 
     assert_eq!(
         f32_to_u32.call(&mut store, (f32::from_bits(CANON_32BIT_NAN | 1),))?,
-        (CANON_32BIT_NAN,)
+        (CANON_32BIT_NAN | 1,)
     );
     f32_to_u32.post_return(&mut store)?;
     assert_eq!(
         f64_to_u64.call(&mut store, (f64::from_bits(CANON_64BIT_NAN | 1),))?,
-        (CANON_64BIT_NAN,)
+        (CANON_64BIT_NAN | 1,)
     );
     f64_to_u64.post_return(&mut store)?;
 
@@ -937,7 +937,10 @@ fn many_parameters() -> Result<()> {
     assert_eq!(i8::from_le_bytes(*actual.take_n::<1>()), input.0);
     actual.skip::<7>();
     assert_eq!(u64::from_le_bytes(*actual.take_n::<8>()), input.1);
-    assert_eq!(u32::from_le_bytes(*actual.take_n::<4>()), CANON_32BIT_NAN);
+    assert_eq!(
+        u32::from_le_bytes(*actual.take_n::<4>()),
+        CANON_32BIT_NAN | 1
+    );
     assert_eq!(u8::from_le_bytes(*actual.take_n::<1>()), input.3);
     actual.skip::<1>();
     assert_eq!(i16::from_le_bytes(*actual.take_n::<2>()), input.4);
@@ -1703,7 +1706,7 @@ fn expected() -> Result<()> {
     let ret = to_expected_s16_f32
         .call(&mut store, (1, CANON_32BIT_NAN | 1))?
         .0;
-    assert_eq!(ret.unwrap_err().to_bits(), CANON_32BIT_NAN);
+    assert_eq!(ret.unwrap_err().to_bits(), CANON_32BIT_NAN | 1);
     to_expected_s16_f32.post_return(&mut store)?;
     assert!(to_expected_s16_f32.call(&mut store, (2, 0)).is_err());