diff --git a/interpreter/host/run.ml b/interpreter/host/run.ml
index 3e041c9a5d..3f53552398 100644
--- a/interpreter/host/run.ml
+++ b/interpreter/host/run.ml
@@ -357,7 +357,7 @@ let run_assertion ass =
     assert_result ass.at (got_vs = expect_vs) got_vs print_result expect_vs
 
   | AssertReturnCanonicalNaN act ->
-    trace ("Asserting return...");
+    trace ("Asserting return canonical nan...");
     let got_vs = run_action act in
     let is_canonical_nan =
       match got_vs with
@@ -367,15 +367,15 @@ let run_assertion ass =
     in assert_result ass.at is_canonical_nan got_vs print_endline "nan"
 
   | AssertReturnArithmeticNaN act ->
-    trace ("Asserting return...");
+    trace ("Asserting return arithmetic nan...");
     let got_vs = run_action act in
     let is_arithmetic_nan =
       (* Accept any NaN that's one everywhere pos_nan is one *)
       match got_vs with
-      | [Values.F32 got_f32] -> let pos_nan = F32.to_bits F32.pos_nan in
-        Int32.logand (F32.to_bits got_f32) pos_nan = pos_nan
-      | [Values.F64 got_f64] -> let pos_nan = F64.to_bits F64.pos_nan in
-        Int64.logand (F64.to_bits got_f64) pos_nan = pos_nan
+      | [Values.F32 got_f32] -> let bare_nan = F32.to_bits F32.bare_nan in
+        Int32.logand (F32.to_bits got_f32) bare_nan = bare_nan
+      | [Values.F64 got_f64] -> let bare_nan = F64.to_bits F64.bare_nan in
+        Int64.logand (F64.to_bits got_f64) bare_nan = bare_nan
       | _ -> false
     in assert_result ass.at is_arithmetic_nan got_vs print_endline "nan"
 
diff --git a/interpreter/spec/float.ml b/interpreter/spec/float.ml
index a2f2f007a6..0d8edef466 100644
--- a/interpreter/spec/float.ml
+++ b/interpreter/spec/float.ml
@@ -27,6 +27,7 @@ sig
   type bits
   val pos_nan : t
   val neg_nan : t
+  val bare_nan : t
   val of_float : float -> t
   val to_float : t -> float
   val of_string : string -> t
diff --git a/test/core/conversions.wast b/test/core/conversions.wast
index af178dc44b..b27f05dbee 100644
--- a/test/core/conversions.wast
+++ b/test/core/conversions.wast
@@ -320,7 +320,7 @@
 (assert_return (invoke "f64.promote_f32" (f32.const 0x1.8f867ep+125)) (f64.const 6.6382536710104395e+37))
 (assert_return (invoke "f64.promote_f32" (f32.const infinity)) (f64.const infinity))
 (assert_return (invoke "f64.promote_f32" (f32.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "f64.promote_f32" (f32.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.promote_f32" (f32.const nan)))
 
 (assert_return (invoke "f32.demote_f64" (f64.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.demote_f64" (f64.const -0.0)) (f32.const -0.0))
@@ -364,7 +364,7 @@
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1.cb98354d521ffp-127)) (f32.const 0x1.cb9834p-127))
 (assert_return (invoke "f32.demote_f64" (f64.const -0x1.6972b30cfb562p+1)) (f32.const -0x1.6972b4p+1))
 (assert_return (invoke "f32.demote_f64" (f64.const -0x1.bedbe4819d4c4p+112)) (f32.const -0x1.bedbe4p+112))
-(assert_return (invoke "f32.demote_f64" (f64.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.demote_f64" (f64.const nan)))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1p-1022)) (f32.const 0.0))
 (assert_return (invoke "f32.demote_f64" (f64.const -0x1p-1022)) (f32.const -0.0))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1.0p-150)) (f32.const 0.0))
@@ -375,28 +375,28 @@
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 0)) (f32.const 0.0))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 0x80000000)) (f32.const -0.0))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 1)) (f32.const 0x1p-149))
-(assert_return (invoke "f32.reinterpret_i32" (i32.const -1)) (f32.const -nan:0x7fffff))
+(assert_return_arithmetic_nan (invoke "f32.reinterpret_i32" (i32.const -1)))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 0x1.b79a2ap-113))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -0x1p-149))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const infinity))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -infinity))
-(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)) (f32.const nan))
-(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)) (f32.const -nan))
-(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffa00000)) (f32.const -nan:0x200000))
+(assert_return_canonical_nan (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)))
+(assert_return_canonical_nan (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)))
+(assert_return_arithmetic_nan (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)))
+(assert_return_arithmetic_nan (invoke "f32.reinterpret_i32" (i32.const 0xffa00000)))
 
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0)) (f64.const 0.0))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 1)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "f64.reinterpret_i64" (i64.const -1)) (f64.const -nan:0xfffffffffffff))
+(assert_return_arithmetic_nan (invoke "f64.reinterpret_i64" (i64.const -1)))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 0x0.00000499602d2p-1022))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const infinity))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -infinity))
-(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)) (f64.const nan))
-(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)) (f64.const -nan))
-(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)) (f64.const nan:0x4000000000000))
-(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff4000000000000)) (f64.const -nan:0x4000000000000))
+(assert_return_canonical_nan (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)))
+(assert_return_canonical_nan (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)))
+(assert_return_arithmetic_nan (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)))
+(assert_return_arithmetic_nan (invoke "f64.reinterpret_i64" (i64.const 0xfff4000000000000)))
 
 (assert_return (invoke "i32.reinterpret_f32" (f32.const 0.0)) (i32.const 0))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const -0.0)) (i32.const 0x80000000))
diff --git a/test/core/f32.wast b/test/core/f32.wast
index 790cc0b3d5..5224495da4 100644
--- a/test/core/f32.wast
+++ b/test/core/f32.wast
@@ -2302,42 +2302,42 @@
 (assert_return (invoke "copysign" (f32.const -infinity) (f32.const nan)) (f32.const infinity))
 (assert_return (invoke "copysign" (f32.const infinity) (f32.const -nan)) (f32.const -infinity))
 (assert_return (invoke "copysign" (f32.const infinity) (f32.const nan)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x0p+0)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x0p+0)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-149)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-149)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-126)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-126)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-1)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-1)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p+0)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p+0)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -infinity)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const infinity)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -infinity)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const infinity)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const 0x0p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const 0x0p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const -0x1p-149)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const 0x1p-149)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const -0x1p-149)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const 0x1p-149)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const -0x1p-126)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const 0x1p-126)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const -0x1p-126)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const 0x1p-126)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const -0x1p-1)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const 0x1p-1)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const -0x1p-1)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const 0x1p-1)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const -0x1p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const 0x1p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const -0x1p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const 0x1p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const -0x1.921fb6p+2)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const 0x1.921fb6p+2)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const -0x1.fffffep+127)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const 0x1.fffffep+127)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const -0x1.fffffep+127)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const 0x1.fffffep+127)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const -infinity)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const infinity)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const -infinity)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const infinity)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const -nan)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const -nan) (f32.const nan)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const -nan)))
+(assert_return_canonical_nan (invoke "copysign" (f32.const nan) (f32.const nan)))
 (assert_return (invoke "sqrt" (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "sqrt" (f32.const 0x0p+0)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "sqrt" (f32.const -0x1p-149)))
@@ -2444,8 +2444,8 @@
 (assert_return (invoke "abs" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "abs" (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "abs" (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "abs" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "abs" (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "abs" (f32.const -nan)))
+(assert_return_canonical_nan (invoke "abs" (f32.const nan)))
 (assert_return (invoke "neg" (f32.const -0x0p+0)) (f32.const 0x0p+0))
 (assert_return (invoke "neg" (f32.const 0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "neg" (f32.const -0x1p-149)) (f32.const 0x1p-149))
@@ -2462,5 +2462,5 @@
 (assert_return (invoke "neg" (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "neg" (f32.const -infinity)) (f32.const infinity))
 (assert_return (invoke "neg" (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "neg" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "neg" (f32.const nan)) (f32.const -nan))
+(assert_return_canonical_nan (invoke "neg" (f32.const -nan)))
+(assert_return_canonical_nan (invoke "neg" (f32.const nan)))
diff --git a/test/core/f64.wast b/test/core/f64.wast
index 911f00f6e8..00eff4dc86 100644
--- a/test/core/f64.wast
+++ b/test/core/f64.wast
@@ -2318,42 +2318,42 @@
 (assert_return (invoke "copysign" (f64.const -infinity) (f64.const nan)) (f64.const infinity))
 (assert_return (invoke "copysign" (f64.const infinity) (f64.const -nan)) (f64.const -infinity))
 (assert_return (invoke "copysign" (f64.const infinity) (f64.const nan)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0p+0)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0p+0)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1022)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p+0)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p+0)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -infinity)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const infinity)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -infinity)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const infinity)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const 0x0p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const 0x0p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const -0x0.0000000000001p-1022)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const 0x0.0000000000001p-1022)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1022)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1022)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const -0x1p-1022)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const 0x1p-1022)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const -0x1p-1)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const 0x1p-1)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const -0x1p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const 0x1p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const -0x1p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const 0x1p+0)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const -infinity)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const infinity)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const -infinity)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const infinity)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const -nan)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const -nan) (f64.const nan)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const -nan)))
+(assert_return_canonical_nan (invoke "copysign" (f64.const nan) (f64.const nan)))
 (assert_return (invoke "sqrt" (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "sqrt" (f64.const 0x0p+0)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "sqrt" (f64.const -0x0.0000000000001p-1022)))
@@ -2460,8 +2460,8 @@
 (assert_return (invoke "abs" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "abs" (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "abs" (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "abs" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "abs" (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "abs" (f64.const -nan)))
+(assert_return_canonical_nan (invoke "abs" (f64.const nan)))
 (assert_return (invoke "neg" (f64.const -0x0p+0)) (f64.const 0x0p+0))
 (assert_return (invoke "neg" (f64.const 0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "neg" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
@@ -2478,5 +2478,5 @@
 (assert_return (invoke "neg" (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "neg" (f64.const -infinity)) (f64.const infinity))
 (assert_return (invoke "neg" (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "neg" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "neg" (f64.const nan)) (f64.const -nan))
+(assert_return_canonical_nan (invoke "neg" (f64.const -nan)))
+(assert_return_canonical_nan (invoke "neg" (f64.const nan)))
diff --git a/test/core/float_exprs.wast b/test/core/float_exprs.wast
index caa30175f7..cce74dfda9 100644
--- a/test/core/float_exprs.wast
+++ b/test/core/float_exprs.wast
@@ -861,35 +861,35 @@
   (func (export "f64.no_fold_ge_select") (param $x f64) (param $y f64) (result f64) (select (get_local $x) (get_local $y) (f64.ge (get_local $x) (get_local $y))))
 )
 
-(assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const nan)))
 (assert_return (invoke "f32.no_fold_lt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_lt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const nan)))
 (assert_return (invoke "f32.no_fold_le_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_le_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const nan)))
 (assert_return (invoke "f32.no_fold_gt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_gt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const nan)))
 (assert_return (invoke "f32.no_fold_ge_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_ge_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const nan)))
 (assert_return (invoke "f64.no_fold_lt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_lt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const nan)))
 (assert_return (invoke "f64.no_fold_le_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_le_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const nan)))
 (assert_return (invoke "f64.no_fold_gt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_gt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const nan)))
 (assert_return (invoke "f64.no_fold_ge_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_ge_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
@@ -908,35 +908,35 @@
   (func (export "f64.no_fold_ge_if") (param $x f64) (param $y f64) (result f64) (if f64 (f64.ge (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
 )
 
-(assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const nan)))
 (assert_return (invoke "f32.no_fold_lt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_lt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const nan)))
 (assert_return (invoke "f32.no_fold_le_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_le_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const nan)))
 (assert_return (invoke "f32.no_fold_gt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_gt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return_canonical_nan (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const nan)))
 (assert_return (invoke "f32.no_fold_ge_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_ge_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const nan)))
 (assert_return (invoke "f64.no_fold_lt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_lt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const nan)))
 (assert_return (invoke "f64.no_fold_le_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_le_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const nan)))
 (assert_return (invoke "f64.no_fold_gt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_gt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return_canonical_nan (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const nan)))
 (assert_return (invoke "f64.no_fold_ge_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_ge_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
@@ -955,36 +955,36 @@
   (func (export "f64.no_fold_ge_select_to_abs") (param $x f64) (result f64) (select (get_local $x) (f64.neg (get_local $x)) (f64.ge (get_local $x) (f64.const 0.0))))
 )
 
-(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return_arithmetic_nan (invoke "f32.no_fold_lt_select_to_abs" (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "f32.no_fold_lt_select_to_abs" (f32.const -nan)))
 (assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -nan))(f32.const -nan))
+(assert_return_arithmetic_nan (invoke "f32.no_fold_le_select_to_abs" (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "f32.no_fold_le_select_to_abs" (f32.const -nan)))
 (assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const 0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
-(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return_arithmetic_nan (invoke "f32.no_fold_gt_select_to_abs" (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "f32.no_fold_gt_select_to_abs" (f32.const -nan)))
 (assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const 0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
-(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return_arithmetic_nan (invoke "f32.no_fold_ge_select_to_abs" (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "f32.no_fold_ge_select_to_abs" (f32.const -nan)))
 (assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return_arithmetic_nan (invoke "f64.no_fold_lt_select_to_abs" (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "f64.no_fold_lt_select_to_abs" (f64.const -nan)))
 (assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return_arithmetic_nan (invoke "f64.no_fold_le_select_to_abs" (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "f64.no_fold_le_select_to_abs" (f64.const -nan)))
 (assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const 0.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return_arithmetic_nan (invoke "f64.no_fold_gt_select_to_abs" (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "f64.no_fold_gt_select_to_abs" (f64.const -nan)))
 (assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const 0.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return_arithmetic_nan (invoke "f64.no_fold_ge_select_to_abs" (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "f64.no_fold_ge_select_to_abs" (f64.const -nan)))
 (assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -0.0)) (f64.const -0.0))
 
@@ -1002,36 +1002,36 @@
   (func (export "f64.no_fold_ge_if_to_abs") (param $x f64) (result f64) (if f64 (f64.ge (get_local $x) (f64.const 0.0)) (get_local $x) (f64.neg (get_local $x))))
 )
 
-(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return_arithmetic_nan (invoke "f32.no_fold_lt_if_to_abs" (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "f32.no_fold_lt_if_to_abs" (f32.const -nan)))
 (assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return_arithmetic_nan (invoke "f32.no_fold_le_if_to_abs" (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "f32.no_fold_le_if_to_abs" (f32.const -nan)))
 (assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const 0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
-(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return_arithmetic_nan (invoke "f32.no_fold_gt_if_to_abs" (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "f32.no_fold_gt_if_to_abs" (f32.const -nan)))
 (assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const 0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
-(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return_arithmetic_nan (invoke "f32.no_fold_ge_if_to_abs" (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "f32.no_fold_ge_if_to_abs" (f32.const -nan)))
 (assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return_arithmetic_nan (invoke "f64.no_fold_lt_if_to_abs" (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "f64.no_fold_lt_if_to_abs" (f64.const -nan)))
 (assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return_arithmetic_nan (invoke "f64.no_fold_le_if_to_abs" (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "f64.no_fold_le_if_to_abs" (f64.const -nan)))
 (assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const 0.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return_arithmetic_nan (invoke "f64.no_fold_gt_if_to_abs" (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "f64.no_fold_gt_if_to_abs" (f64.const -nan)))
 (assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const 0.0)) (f64.const -0.0))
 (assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return_arithmetic_nan (invoke "f64.no_fold_ge_if_to_abs" (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "f64.no_fold_ge_if_to_abs" (f64.const -nan)))
 (assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -0.0)) (f64.const -0.0))
 
diff --git a/test/core/float_memory.wast b/test/core/float_memory.wast
index 3801158f92..9681eb37ae 100644
--- a/test/core/float_memory.wast
+++ b/test/core/float_memory.wast
@@ -13,19 +13,19 @@
 )
 
 (assert_return (invoke "i32.load") (i32.const 0x7fa00000))
-(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(assert_return_arithmetic_nan (invoke "f32.load"))
 (invoke "reset")
 (assert_return (invoke "i32.load") (i32.const 0x0))
 (assert_return (invoke "f32.load") (f32.const 0.0))
 (invoke "f32.store")
 (assert_return (invoke "i32.load") (i32.const 0x7fa00000))
-(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(assert_return_arithmetic_nan (invoke "f32.load"))
 (invoke "reset")
 (assert_return (invoke "i32.load") (i32.const 0x0))
 (assert_return (invoke "f32.load") (f32.const 0.0))
 (invoke "i32.store")
 (assert_return (invoke "i32.load") (i32.const 0x7fa00000))
-(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(assert_return_arithmetic_nan (invoke "f32.load"))
 
 (module
   (memory (data "\00\00\00\00\00\00\f4\7f"))
@@ -38,19 +38,19 @@
 )
 
 (assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
-(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(assert_return_arithmetic_nan (invoke "f64.load"))
 (invoke "reset")
 (assert_return (invoke "i64.load") (i64.const 0x0))
 (assert_return (invoke "f64.load") (f64.const 0.0))
 (invoke "f64.store")
 (assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
-(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(assert_return_arithmetic_nan (invoke "f64.load"))
 (invoke "reset")
 (assert_return (invoke "i64.load") (i64.const 0x0))
 (assert_return (invoke "f64.load") (f64.const 0.0))
 (invoke "i64.store")
 (assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
-(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(assert_return_arithmetic_nan (invoke "f64.load"))
 
 ;; Test that unaligned load and store do not canonicalize NaNs.
 
@@ -65,19 +65,19 @@
 )
 
 (assert_return (invoke "i32.load") (i32.const 0x7fa00000))
-(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(assert_return_arithmetic_nan (invoke "f32.load"))
 (invoke "reset")
 (assert_return (invoke "i32.load") (i32.const 0x0))
 (assert_return (invoke "f32.load") (f32.const 0.0))
 (invoke "f32.store")
 (assert_return (invoke "i32.load") (i32.const 0x7fa00000))
-(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(assert_return_arithmetic_nan (invoke "f32.load"))
 (invoke "reset")
 (assert_return (invoke "i32.load") (i32.const 0x0))
 (assert_return (invoke "f32.load") (f32.const 0.0))
 (invoke "i32.store")
 (assert_return (invoke "i32.load") (i32.const 0x7fa00000))
-(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(assert_return_arithmetic_nan (invoke "f32.load"))
 
 (module
   (memory (data "\00\00\00\00\00\00\00\f4\7f"))
@@ -90,19 +90,19 @@
 )
 
 (assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
-(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(assert_return_arithmetic_nan (invoke "f64.load"))
 (invoke "reset")
 (assert_return (invoke "i64.load") (i64.const 0x0))
 (assert_return (invoke "f64.load") (f64.const 0.0))
 (invoke "f64.store")
 (assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
-(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(assert_return_arithmetic_nan (invoke "f64.load"))
 (invoke "reset")
 (assert_return (invoke "i64.load") (i64.const 0x0))
 (assert_return (invoke "f64.load") (f64.const 0.0))
 (invoke "i64.store")
 (assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
-(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(assert_return_arithmetic_nan (invoke "f64.load"))
 
 ;; Test that load and store do not canonicalize NaNs as some JS engines do.
 
@@ -117,19 +117,19 @@
 )
 
 (assert_return (invoke "i32.load") (i32.const 0x7fd00001))
-(assert_return (invoke "f32.load") (f32.const nan:0x500001))
+(assert_return_arithmetic_nan (invoke "f32.load"))
 (invoke "reset")
 (assert_return (invoke "i32.load") (i32.const 0x0))
 (assert_return (invoke "f32.load") (f32.const 0.0))
 (invoke "f32.store")
 (assert_return (invoke "i32.load") (i32.const 0x7fd00001))
-(assert_return (invoke "f32.load") (f32.const nan:0x500001))
+(assert_return_arithmetic_nan (invoke "f32.load"))
 (invoke "reset")
 (assert_return (invoke "i32.load") (i32.const 0x0))
 (assert_return (invoke "f32.load") (f32.const 0.0))
 (invoke "i32.store")
 (assert_return (invoke "i32.load") (i32.const 0x7fd00001))
-(assert_return (invoke "f32.load") (f32.const nan:0x500001))
+(assert_return_arithmetic_nan (invoke "f32.load"))
 
 (module
   (memory (data "\01\00\00\00\00\00\fc\7f"))
@@ -142,16 +142,16 @@
 )
 
 (assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
-(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))
+(assert_return_arithmetic_nan (invoke "f64.load"))
 (invoke "reset")
 (assert_return (invoke "i64.load") (i64.const 0x0))
 (assert_return (invoke "f64.load") (f64.const 0.0))
 (invoke "f64.store")
 (assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
-(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))
+(assert_return_arithmetic_nan (invoke "f64.load"))
 (invoke "reset")
 (assert_return (invoke "i64.load") (i64.const 0x0))
 (assert_return (invoke "f64.load") (f64.const 0.0))
 (invoke "i64.store")
 (assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
-(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))
+(assert_return_arithmetic_nan (invoke "f64.load"))
diff --git a/test/core/float_misc.wast b/test/core/float_misc.wast
index a577288ce9..39af1d0ae4 100644
--- a/test/core/float_misc.wast
+++ b/test/core/float_misc.wast
@@ -540,40 +540,40 @@
 
 ;; Test that the bitwise floating point operators are bitwise on NaN.
 
-(assert_return (invoke "f32.abs" (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.abs" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "f32.abs" (f32.const nan:0x0f1e2)) (f32.const nan:0x0f1e2))
-(assert_return (invoke "f32.abs" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2))
-(assert_return (invoke "f64.abs" (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.abs" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "f64.abs" (f64.const nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
-(assert_return (invoke "f64.abs" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
-
-(assert_return (invoke "f32.neg" (f32.const nan)) (f32.const -nan))
-(assert_return (invoke "f32.neg" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "f32.neg" (f32.const nan:0x0f1e2)) (f32.const -nan:0x0f1e2))
-(assert_return (invoke "f32.neg" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2))
-(assert_return (invoke "f64.neg" (f64.const nan)) (f64.const -nan))
-(assert_return (invoke "f64.neg" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "f64.neg" (f64.const nan:0x0f1e27a6b)) (f64.const -nan:0x0f1e27a6b))
-(assert_return (invoke "f64.neg" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
-
-(assert_return (invoke "f32.copysign" (f32.const nan) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.copysign" (f32.const nan) (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "f32.copysign" (f32.const -nan) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.copysign" (f32.const -nan) (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
-(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2))
-(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
-(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2))
-(assert_return (invoke "f64.copysign" (f64.const nan) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.copysign" (f64.const nan) (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "f64.copysign" (f64.const -nan) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.copysign" (f64.const -nan) (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b))
-(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b))
-(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b))
-(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b))
+(assert_return_canonical_nan (invoke "f32.abs" (f32.const nan)))
+(assert_return_canonical_nan (invoke "f32.abs" (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "f32.abs" (f32.const nan:0x0f1e2)))
+(assert_return_arithmetic_nan (invoke "f32.abs" (f32.const -nan:0x0f1e2)))
+(assert_return_canonical_nan (invoke "f64.abs" (f64.const nan)))
+(assert_return_canonical_nan (invoke "f64.abs" (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "f64.abs" (f64.const nan:0x0f1e27a6b)))
+(assert_return_arithmetic_nan (invoke "f64.abs" (f64.const -nan:0x0f1e27a6b)))
+
+(assert_return_canonical_nan (invoke "f32.neg" (f32.const nan)))
+(assert_return_canonical_nan (invoke "f32.neg" (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "f32.neg" (f32.const nan:0x0f1e2)))
+(assert_return_arithmetic_nan (invoke "f32.neg" (f32.const -nan:0x0f1e2)))
+(assert_return_canonical_nan (invoke "f64.neg" (f64.const nan)))
+(assert_return_canonical_nan (invoke "f64.neg" (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "f64.neg" (f64.const nan:0x0f1e27a6b)))
+(assert_return_arithmetic_nan (invoke "f64.neg" (f64.const -nan:0x0f1e27a6b)))
+
+(assert_return_canonical_nan (invoke "f32.copysign" (f32.const nan) (f32.const nan)))
+(assert_return_canonical_nan (invoke "f32.copysign" (f32.const nan) (f32.const -nan)))
+(assert_return_canonical_nan (invoke "f32.copysign" (f32.const -nan) (f32.const nan)))
+(assert_return_canonical_nan (invoke "f32.copysign" (f32.const -nan) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const -nan)))
+(assert_return_canonical_nan (invoke "f64.copysign" (f64.const nan) (f64.const nan)))
+(assert_return_canonical_nan (invoke "f64.copysign" (f64.const nan) (f64.const -nan)))
+(assert_return_canonical_nan (invoke "f64.copysign" (f64.const -nan) (f64.const nan)))
+(assert_return_canonical_nan (invoke "f64.copysign" (f64.const -nan) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const -nan)))
 
 ;; Test that ceil isn't implemented as adding 0.5 and rounding to nearest.
 (assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep-1)) (f32.const 1.0))
diff --git a/test/core/select.wast b/test/core/select.wast
index 4dfa456121..8ca5b1a757 100644
--- a/test/core/select.wast
+++ b/test/core/select.wast
@@ -38,23 +38,23 @@
 (assert_return (invoke "select_i64" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2))
 (assert_return (invoke "select_i64" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2))
 
-(assert_return (invoke "select_f32" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan))
-(assert_return (invoke "select_f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304))
+(assert_return_canonical_nan (invoke "select_f32" (f32.const nan) (f32.const 1) (i32.const 1)))
+(assert_return_arithmetic_nan (invoke "select_f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)))
 (assert_return (invoke "select_f32" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1))
 (assert_return (invoke "select_f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1))
 (assert_return (invoke "select_f32" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2))
 (assert_return (invoke "select_f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2))
-(assert_return (invoke "select_f32" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan))
-(assert_return (invoke "select_f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304))
+(assert_return_canonical_nan (invoke "select_f32" (f32.const 2) (f32.const nan) (i32.const 0)))
+(assert_return_arithmetic_nan (invoke "select_f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)))
 
-(assert_return (invoke "select_f64" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan))
-(assert_return (invoke "select_f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304))
+(assert_return_canonical_nan (invoke "select_f64" (f64.const nan) (f64.const 1) (i32.const 1)))
+(assert_return_arithmetic_nan (invoke "select_f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)))
 (assert_return (invoke "select_f64" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1))
 (assert_return (invoke "select_f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1))
 (assert_return (invoke "select_f64" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2))
 (assert_return (invoke "select_f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2))
-(assert_return (invoke "select_f64" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
-(assert_return (invoke "select_f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
+(assert_return_canonical_nan (invoke "select_f64" (f64.const 2) (f64.const nan) (i32.const 0)))
+(assert_return_arithmetic_nan (invoke "select_f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)))
 
 (assert_trap (invoke "select_trap_l" (i32.const 1)) "unreachable executed")
 (assert_trap (invoke "select_trap_l" (i32.const 0)) "unreachable executed")