From f787591e993d581a0abcc41b52bcace14465a6b8 Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Mon, 18 Apr 2016 06:35:21 -0700
Subject: [PATCH 1/4] More tests!

This adds more floating point rounding tests, more expression optimizer
bait tests, more real-world floating point bug tests, and more comments.
---
 ml-proto/TestingTodo.md            |  12 +-
 ml-proto/test/conversions.wast     |  24 ++
 ml-proto/test/f32.wast             |   3 +
 ml-proto/test/f32_cmp.wast         |   3 +
 ml-proto/test/f64.wast             |   3 +
 ml-proto/test/f64_cmp.wast         |   3 +
 ml-proto/test/float_exprs.wast     | 592 ++++++++++++++++++++++++++++-
 ml-proto/test/float_literals.wast  |   2 +
 ml-proto/test/float_memory.wast    | 165 +++++---
 ml-proto/test/float_misc.wast      | 204 +++++++++-
 ml-proto/test/int_exprs.wast       |   3 +
 ml-proto/test/nan-propagation.wast |   2 +
 12 files changed, 948 insertions(+), 68 deletions(-)

diff --git a/ml-proto/TestingTodo.md b/ml-proto/TestingTodo.md
index 5e6ecbd678..a0cdd22b59 100644
--- a/ml-proto/TestingTodo.md
+++ b/ml-proto/TestingTodo.md
@@ -49,8 +49,8 @@ Floating point semantics:
  - ~~test that nearestint doesn't do JS-style Math.round or C-style round(3) rounding~~
  - ~~test that signalling NaN doesn't cause weirdness~~
  - ~~test that signalling/quiet NaNs can have sign bits and payloads in literals~~
- - test that conversion from int32/int64 to float32 rounds correctly
- - test that [relaxed optimizations](https://gcc.gnu.org/wiki/FloatingPointMath) are not done
+ - ~~test that conversion from int32/int64 to float32 rounds correctly~~
+ - ~~test that [relaxed optimizations](https://gcc.gnu.org/wiki/FloatingPointMath) are not done~~
 
 Linear memory semantics:
  - test that loading from null works
@@ -82,13 +82,14 @@ Expression optimizer bait:
  - ~~test that floating-point division by immediate 0 and -0 is defined~~
  - ~~test that floating-point (x*y)/y isn't folded to x~~
  - ~~test that floating-point (x+y)-y isn't folded to x~~
- - test that ult/ugt/etc (formed with a not operator) aren't folded to oge/ole/etc.
+ - ~~test that ult/ugt/etc (formed with a not operator) aren't folded to oge/ole/etc.~~
  - ~~test that floating point add/mul aren't reassociated even when tempting~~
  - ~~test that floating point mul+add isn't folded to fma even when tempting~~
  - ~~test that floating point sqrt(x*x+y*y) isn't folded to hypot even when tempting~~
  - ~~test that 1/x isn't translated into reciprocal-approximate~~
  - ~~test that 1/sqrt(x) isn't approximated either~~
  - ~~test that fp division by non-power-2 constant gets full precision (isn't a multiply-by-reciprocal deal)?~~
+ - ~~test that x<y?x:y is not folded to min, etc.~~
 
 Misc optimizer bait:
  - ~~test that the impl doesn't constant-fold away or DCE away or speculate operations that should trap, such as `1/0u`, `1/0`, `1%0u`, `1%0, convertToInt(NaN)`, `INT_MIN/-1` and so on.~~
@@ -109,11 +110,6 @@ Misc x87-isms:
  - ~~test for evaluating intermediate results at greater precision~~
  - ~~test for loading and storing NaNs~~
 
-Control flow:
- - test that continue goes to the right place in `do_while` and `forever`
- - test that break goes to the right place in all cases where it can appear
- - test devious switch case patterns
-
 Validation errors:
  - load/store or variables with type void/bool/funcptr/etc.
  - sign-extend load from int64 to int32 etc.
diff --git a/ml-proto/test/conversions.wast b/ml-proto/test/conversions.wast
index 1f75e703f3..9711552a9c 100644
--- a/ml-proto/test/conversions.wast
+++ b/ml-proto/test/conversions.wast
@@ -268,6 +268,11 @@
 (assert_return (invoke "f32.convert_s_i32" (i32.const 2147483647)) (f32.const 2147483648))
 (assert_return (invoke "f32.convert_s_i32" (i32.const -2147483648)) (f32.const -2147483648))
 (assert_return (invoke "f32.convert_s_i32" (i32.const 1234567890)) (f32.const 0x1.26580cp+30))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_s_i32" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_s_i32" (i32.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_s_i32" (i32.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_s_i32" (i32.const -16777219)) (f32.const -16777220.0))
 
 (assert_return (invoke "f32.convert_s_i64" (i64.const 1)) (f32.const 1.0))
 (assert_return (invoke "f32.convert_s_i64" (i64.const -1)) (f32.const -1.0))
@@ -275,6 +280,11 @@
 (assert_return (invoke "f32.convert_s_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
 (assert_return (invoke "f32.convert_s_i64" (i64.const -9223372036854775808)) (f32.const -9223372036854775808))
 (assert_return (invoke "f32.convert_s_i64" (i64.const 314159265358979)) (f32.const 0x1.1db9e8p+48)) ;; PI
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_s_i64" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_s_i64" (i64.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_s_i64" (i64.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_s_i64" (i64.const -16777219)) (f32.const -16777220.0))
 
 (assert_return (invoke "f64.convert_s_i32" (i32.const 1)) (f64.const 1.0))
 (assert_return (invoke "f64.convert_s_i32" (i32.const -1)) (f64.const -1.0))
@@ -289,6 +299,11 @@
 (assert_return (invoke "f64.convert_s_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
 (assert_return (invoke "f64.convert_s_i64" (i64.const -9223372036854775808)) (f64.const -9223372036854775808))
 (assert_return (invoke "f64.convert_s_i64" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum
+;; Test rounding directions.
+(assert_return (invoke "f64.convert_s_i64" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_s_i64" (i64.const -9007199254740993)) (f64.const -9007199254740992))
+(assert_return (invoke "f64.convert_s_i64" (i64.const 9007199254740995)) (f64.const 9007199254740996))
+(assert_return (invoke "f64.convert_s_i64" (i64.const -9007199254740995)) (f64.const -9007199254740996))
 
 (assert_return (invoke "f32.convert_u_i32" (i32.const 1)) (f32.const 1.0))
 (assert_return (invoke "f32.convert_u_i32" (i32.const 0)) (f32.const 0.0))
@@ -296,12 +311,18 @@
 (assert_return (invoke "f32.convert_u_i32" (i32.const -2147483648)) (f32.const 2147483648))
 (assert_return (invoke "f32.convert_u_i32" (i32.const 0x12345678)) (f32.const 0x1.234568p+28))
 (assert_return (invoke "f32.convert_u_i32" (i32.const 0xffffffff)) (f32.const 4294967296.0))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_u_i32" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_u_i32" (i32.const 16777219)) (f32.const 16777220.0))
 
 (assert_return (invoke "f32.convert_u_i64" (i64.const 1)) (f32.const 1.0))
 (assert_return (invoke "f32.convert_u_i64" (i64.const 0)) (f32.const 0.0))
 (assert_return (invoke "f32.convert_u_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
 (assert_return (invoke "f32.convert_u_i64" (i64.const -9223372036854775808)) (f32.const 9223372036854775808))
 (assert_return (invoke "f32.convert_u_i64" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_u_i64" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_u_i64" (i64.const 16777219)) (f32.const 16777220.0))
 
 (assert_return (invoke "f64.convert_u_i32" (i32.const 1)) (f64.const 1.0))
 (assert_return (invoke "f64.convert_u_i32" (i32.const 0)) (f64.const 0.0))
@@ -314,6 +335,9 @@
 (assert_return (invoke "f64.convert_u_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
 (assert_return (invoke "f64.convert_u_i64" (i64.const -9223372036854775808)) (f64.const 9223372036854775808))
 (assert_return (invoke "f64.convert_u_i64" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0))
+;; Test rounding directions.
+(assert_return (invoke "f64.convert_u_i64" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_u_i64" (i64.const 9007199254740995)) (f64.const 9007199254740996))
 
 (assert_return (invoke "f64.promote_f32" (f32.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.promote_f32" (f32.const -0.0)) (f64.const -0.0))
diff --git a/ml-proto/test/f32.wast b/ml-proto/test/f32.wast
index 97a2ae9859..45d736141b 100644
--- a/ml-proto/test/f32.wast
+++ b/ml-proto/test/f32.wast
@@ -1,3 +1,6 @@
+;; Test all the f32 operators on major boundary values and all special
+;; values (except comparison operators, which are tested in f32_cmp.wast).
+
 (module
   (func $add (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y)))
   (func $sub (param $x f32) (param $y f32) (result f32) (f32.sub (get_local $x) (get_local $y)))
diff --git a/ml-proto/test/f32_cmp.wast b/ml-proto/test/f32_cmp.wast
index 860238c8a7..f4d4637cb0 100644
--- a/ml-proto/test/f32_cmp.wast
+++ b/ml-proto/test/f32_cmp.wast
@@ -1,3 +1,6 @@
+;; Test all the f32 comparison operators on major boundary values and all
+;; special values.
+
 (module
   (func $eq (param $x f32) (param $y f32) (result i32) (f32.eq (get_local $x) (get_local $y)))
   (func $ne (param $x f32) (param $y f32) (result i32) (f32.ne (get_local $x) (get_local $y)))
diff --git a/ml-proto/test/f64.wast b/ml-proto/test/f64.wast
index 6c453f66ea..df566fa54f 100644
--- a/ml-proto/test/f64.wast
+++ b/ml-proto/test/f64.wast
@@ -1,3 +1,6 @@
+;; Test all the f64 operators on major boundary values and all special
+;; values (except comparison operators, which are tested in f64_cmp.wast).
+
 (module
   (func $add (param $x f64) (param $y f64) (result f64) (f64.add (get_local $x) (get_local $y)))
   (func $sub (param $x f64) (param $y f64) (result f64) (f64.sub (get_local $x) (get_local $y)))
diff --git a/ml-proto/test/f64_cmp.wast b/ml-proto/test/f64_cmp.wast
index a6575cd604..9d822deda2 100644
--- a/ml-proto/test/f64_cmp.wast
+++ b/ml-proto/test/f64_cmp.wast
@@ -1,3 +1,6 @@
+;; Test all the f64 comparison operators on major boundary values and all
+;; special values.
+
 (module
   (func $eq (param $x f64) (param $y f64) (result i32) (f64.eq (get_local $x) (get_local $y)))
   (func $ne (param $x f64) (param $y f64) (result i32) (f64.ne (get_local $x) (get_local $y)))
diff --git a/ml-proto/test/float_exprs.wast b/ml-proto/test/float_exprs.wast
index 843d53bab1..34649315ab 100644
--- a/ml-proto/test/float_exprs.wast
+++ b/ml-proto/test/float_exprs.wast
@@ -1,3 +1,6 @@
+;; Test interesting floating-point "expressions". These tests contain code
+;; patterns which tempt common value-changing optimizations.
+
 ;; Test that x*y+z is not done with x87-style intermediate precision.
 
 (module
@@ -64,6 +67,8 @@
 
 (assert_return (invoke "f32.no_fold_zero_sub" (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f64.no_fold_zero_sub" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f32.no_fold_zero_sub" (f32.const nan:0x200000)) (f32.const nan:0x600000))
+(assert_return (invoke "f64.no_fold_zero_sub" (f64.const nan:0x4000000000000)) (f64.const nan:0xc000000000000))
 
 ;; Test that x*0.0 is not folded to 0.0.
 
@@ -103,6 +108,66 @@
 (assert_return_nan (invoke "f64.no_fold_zero_div" (f64.const -0.0)))
 (assert_return (invoke "f64.no_fold_zero_div" (f64.const nan)) (f64.const nan))
 
+;; Test that x/1.0 is not folded to x.
+
+(module
+  (func $f32.no_fold_div_one (param $x f32) (result f32)
+    (f32.div (get_local $x) (f32.const 1.0)))
+  (export "f32.no_fold_div_one" $f32.no_fold_div_one)
+
+  (func $f64.no_fold_div_one (param $x f64) (result f64)
+    (f64.div (get_local $x) (f64.const 1.0)))
+  (export "f64.no_fold_div_one" $f64.no_fold_div_one)
+)
+
+(assert_return (invoke "f32.no_fold_div_one" (f32.const nan:0x200000)) (f32.const nan:0x600000))
+(assert_return (invoke "f64.no_fold_div_one" (f64.const nan:0x4000000000000)) (f64.const nan:0xc000000000000))
+
+;; Test that x/-1.0 is not folded to -x.
+
+(module
+  (func $f32.no_fold_div_neg1 (param $x f32) (result f32)
+    (f32.div (get_local $x) (f32.const -1.0)))
+  (export "f32.no_fold_div_neg1" $f32.no_fold_div_neg1)
+
+  (func $f64.no_fold_div_neg1 (param $x f64) (result f64)
+    (f64.div (get_local $x) (f64.const -1.0)))
+  (export "f64.no_fold_div_neg1" $f64.no_fold_div_neg1)
+)
+
+(assert_return (invoke "f32.no_fold_div_neg1" (f32.const nan:0x200000)) (f32.const nan:0x600000))
+(assert_return (invoke "f64.no_fold_div_neg1" (f64.const nan:0x4000000000000)) (f64.const nan:0xc000000000000))
+
+;; Test that -0.0 - x is not folded to -x.
+
+(module
+  (func $f32.no_fold_neg0_sub (param $x f32) (result f32)
+    (f32.sub (f32.const -0.0) (get_local $x)))
+  (export "f32.no_fold_neg0_sub" $f32.no_fold_neg0_sub)
+
+  (func $f64.no_fold_neg0_sub (param $x f64) (result f64)
+    (f64.sub (f64.const -0.0) (get_local $x)))
+  (export "f64.no_fold_neg0_sub" $f64.no_fold_neg0_sub)
+)
+
+(assert_return (invoke "f32.no_fold_neg0_sub" (f32.const nan:0x200000)) (f32.const nan:0x600000))
+(assert_return (invoke "f64.no_fold_neg0_sub" (f64.const nan:0x4000000000000)) (f64.const nan:0xc000000000000))
+
+;; Test that -1.0 * x is not folded to -x.
+
+(module
+  (func $f32.no_fold_neg1_mul (param $x f32) (result f32)
+    (f32.mul (f32.const -1.0) (get_local $x)))
+  (export "f32.no_fold_neg1_mul" $f32.no_fold_neg1_mul)
+
+  (func $f64.no_fold_neg1_mul (param $x f64) (result f64)
+    (f64.mul (f64.const -1.0) (get_local $x)))
+  (export "f64.no_fold_neg1_mul" $f64.no_fold_neg1_mul)
+)
+
+(assert_return (invoke "f32.no_fold_neg1_mul" (f32.const nan:0x200000)) (f32.const nan:0x600000))
+(assert_return (invoke "f64.no_fold_neg1_mul" (f64.const nan:0x4000000000000)) (f64.const nan:0xc000000000000))
+
 ;; Test that x == x is not folded to true.
 
 (module
@@ -176,25 +241,94 @@
 ;; Test that (x*z)+(y*z) is not folded to (x+y)*z
 
 (module
-  (func $f32.no_distribute (param $x f32) (param $y f32) (param $z f32) (result f32)
+  (func $f32.no_factor (param $x f32) (param $y f32) (param $z f32) (result f32)
     (f32.add (f32.mul (get_local $x) (get_local $z)) (f32.mul (get_local $y) (get_local $z))))
+  (export "f32.no_factor" $f32.no_factor)
+
+  (func $f64.no_factor (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.add (f64.mul (get_local $x) (get_local $z)) (f64.mul (get_local $y) (get_local $z))))
+  (export "f64.no_factor" $f64.no_factor)
+)
+
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7dp+109))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a342p-14))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651aaep+82))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa15p+55))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9cep-50))
+(assert_return (invoke "f64.no_factor" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1ap-649))
+(assert_return (invoke "f64.no_factor" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_factor" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e2p+198))
+(assert_return (invoke "f64.no_factor" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f184p-512))
+(assert_return (invoke "f64.no_factor" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af53p-90))
+
+;; Test that (x+y)*z is not folded to (x*z)+(y*z)
+
+(module
+  (func $f32.no_distribute (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.mul (f32.add (get_local $x) (get_local $y)) (get_local $z)))
   (export "f32.no_distribute" $f32.no_distribute)
 
   (func $f64.no_distribute (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.add (f64.mul (get_local $x) (get_local $z)) (f64.mul (get_local $y) (get_local $z))))
+    (f64.mul (f64.add (get_local $x) (get_local $y)) (get_local $z)))
   (export "f64.no_distribute" $f64.no_distribute)
 )
 
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7dp+109))
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a342p-14))
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651aaep+82))
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa15p+55))
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9cep-50))
-(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1ap-649))
-(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const 0x0p+0))
-(assert_return (invoke "f64.no_distribute" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e2p+198))
-(assert_return (invoke "f64.no_distribute" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f184p-512))
-(assert_return (invoke "f64.no_distribute" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af53p-90))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7d2p+109))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a34p-14))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651abp+82))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa14ep+55))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9ccp-50))
+(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1bp-649))
+(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_distribute" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e1fp+198))
+(assert_return (invoke "f64.no_distribute" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f183p-512))
+(assert_return (invoke "f64.no_distribute" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af52p-90))
+
+;; Test that x*(y/z) is not folded to (x*y)/z
+
+(module
+  (func $f32.no_regroup_div_mul (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.mul (get_local $x) (f32.div (get_local $y) (get_local $z))))
+  (export "f32.no_regroup_div_mul" $f32.no_regroup_div_mul)
+
+  (func $f64.no_regroup_div_mul (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.mul (get_local $x) (f64.div (get_local $y) (get_local $z))))
+  (export "f64.no_regroup_div_mul" $f64.no_regroup_div_mul)
+)
+
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x1.2844cap-63))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x0p+0))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.792258p+118))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df2p-89))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -0x1.47d0eap+66))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2dp+99))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const infinity))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -0x1.926fa3cacc651p+255))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x1.38d55f56406dp-639))
+
+;; Test that (x*y)/z is not folded to x*(y/z)
+
+(module
+  (func $f32.no_regroup_mul_div (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.div (f32.mul (get_local $x) (get_local $y)) (get_local $z)))
+  (export "f32.no_regroup_mul_div" $f32.no_regroup_mul_div)
+
+  (func $f64.no_regroup_mul_div (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.div (f64.mul (get_local $x) (get_local $y)) (get_local $z)))
+  (export "f64.no_regroup_mul_div" $f64.no_regroup_mul_div)
+)
+
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x1.1a00e8p-96))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.79225ap+118))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df4p-89))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -infinity))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2ep+99))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x1.0da0b6328e09p-907))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const 0x1.4886b6d9a9a79p+871))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -infinity))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x0p+0))
 
 ;; Test that x+y+z+w is not reassociated.
 
@@ -650,3 +784,437 @@
 (assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1p+64))
 (assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0))
 (assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0))
+
+;; Test that dividing by a loop-invariant constant isn't optimized to be a
+;; multiplication by a reciprocal, which would be particularly tempting since
+;; the reciprocal computation could be hoisted.
+
+(module
+  (memory 1 1)
+  (func $init (param $i i32) (param $x f32) (f32.store (get_local $i) (get_local $x)))
+  (export "init" $init)
+
+  (func $run (param $n i32) (param $z f32)
+    (local $i i32)
+    (loop $exit $cont
+      (f32.store (get_local $i) (f32.div (f32.load (get_local $i)) (get_local $z)))
+      (set_local $i (i32.add (get_local $i) (i32.const 4)))
+      (br_if $cont (i32.lt_u (get_local $i) (get_local $n)))
+    )
+  )
+  (export "run" $run)
+
+  (func $check (param $i i32) (result f32) (f32.load (get_local $i)))
+  (export "check" $check)
+)
+
+(invoke "init" (i32.const  0) (f32.const 15.1))
+(invoke "init" (i32.const  4) (f32.const 15.2))
+(invoke "init" (i32.const  8) (f32.const 15.3))
+(invoke "init" (i32.const 12) (f32.const 15.4))
+(assert_return (invoke "check" (i32.const  0)) (f32.const 15.1))
+(assert_return (invoke "check" (i32.const  4)) (f32.const 15.2))
+(assert_return (invoke "check" (i32.const  8)) (f32.const 15.3))
+(assert_return (invoke "check" (i32.const 12)) (f32.const 15.4))
+(invoke "run" (i32.const 16) (f32.const 3.0))
+(assert_return (invoke "check" (i32.const  0)) (f32.const 0x1.422222p+2))
+(assert_return (invoke "check" (i32.const  4)) (f32.const 0x1.444444p+2))
+(assert_return (invoke "check" (i32.const  8)) (f32.const 0x1.466666p+2))
+(assert_return (invoke "check" (i32.const 12)) (f32.const 0x1.488888p+2))
+
+(module
+  (memory 1 1)
+  (func $init (param $i i32) (param $x f64) (f64.store (get_local $i) (get_local $x)))
+  (export "init" $init)
+
+  (func $run (param $n i32) (param $z f64)
+    (local $i i32)
+    (loop $exit $cont
+      (f64.store (get_local $i) (f64.div (f64.load (get_local $i)) (get_local $z)))
+      (set_local $i (i32.add (get_local $i) (i32.const 8)))
+      (br_if $cont (i32.lt_u (get_local $i) (get_local $n)))
+    )
+  )
+  (export "run" $run)
+
+  (func $check (param $i i32) (result f64) (f64.load (get_local $i)))
+  (export "check" $check)
+)
+
+(invoke "init" (i32.const  0) (f64.const 15.1))
+(invoke "init" (i32.const  8) (f64.const 15.2))
+(invoke "init" (i32.const 16) (f64.const 15.3))
+(invoke "init" (i32.const 24) (f64.const 15.4))
+(assert_return (invoke "check" (i32.const  0)) (f64.const 15.1))
+(assert_return (invoke "check" (i32.const  8)) (f64.const 15.2))
+(assert_return (invoke "check" (i32.const 16)) (f64.const 15.3))
+(assert_return (invoke "check" (i32.const 24)) (f64.const 15.4))
+(invoke "run" (i32.const 32) (f64.const 3.0))
+(assert_return (invoke "check" (i32.const  0)) (f64.const 0x1.4222222222222p+2))
+(assert_return (invoke "check" (i32.const  8)) (f64.const 0x1.4444444444444p+2))
+(assert_return (invoke "check" (i32.const 16)) (f64.const 0x1.4666666666667p+2))
+(assert_return (invoke "check" (i32.const 24)) (f64.const 0x1.4888888888889p+2))
+
+;; Test that ult/ugt/etc. aren't folded to olt/ogt/etc.
+
+(module
+  (func $f32.ult (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.ge (get_local $x) (get_local $y))))
+  (func $f32.ule (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.gt (get_local $x) (get_local $y))))
+  (func $f32.ugt (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.le (get_local $x) (get_local $y))))
+  (func $f32.uge (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.lt (get_local $x) (get_local $y))))
+
+  (func $f64.ult (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.ge (get_local $x) (get_local $y))))
+  (func $f64.ule (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.gt (get_local $x) (get_local $y))))
+  (func $f64.ugt (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.le (get_local $x) (get_local $y))))
+  (func $f64.uge (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.lt (get_local $x) (get_local $y))))
+
+  (export "f32.ult" $f32.ult)
+  (export "f32.ule" $f32.ule)
+  (export "f32.ugt" $f32.ugt)
+  (export "f32.uge" $f32.uge)
+  (export "f64.ult" $f64.ult)
+  (export "f64.ule" $f64.ule)
+  (export "f64.ugt" $f64.ugt)
+  (export "f64.uge" $f64.uge)
+)
+
+(assert_return (invoke "f32.ult" (f32.const 3.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f32.ule" (f32.const 3.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f32.ugt" (f32.const 3.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 3.0)) (i32.const 0))
+(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f32.uge" (f32.const 3.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 3.0)) (i32.const 0))
+(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f64.ult" (f64.const 3.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "f64.ule" (f64.const 3.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "f64.ugt" (f64.const 3.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 3.0)) (i32.const 0))
+(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "f64.uge" (f64.const 3.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 3.0)) (i32.const 0))
+(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+
+;; Test that x<y?x:y, etc. using select aren't folded to min, etc.
+
+(module
+  (func $f32.no_fold_lt_select (param $x f32) (param $y f32) (result f32) (select (get_local $x) (get_local $y) (f32.lt (get_local $x) (get_local $y))))
+  (export "f32.no_fold_lt_select" $f32.no_fold_lt_select)
+  (func $f32.no_fold_le_select (param $x f32) (param $y f32) (result f32) (select (get_local $x) (get_local $y) (f32.le (get_local $x) (get_local $y))))
+  (export "f32.no_fold_le_select" $f32.no_fold_le_select)
+  (func $f32.no_fold_gt_select (param $x f32) (param $y f32) (result f32) (select (get_local $x) (get_local $y) (f32.gt (get_local $x) (get_local $y))))
+  (export "f32.no_fold_gt_select" $f32.no_fold_gt_select)
+  (func $f32.no_fold_ge_select (param $x f32) (param $y f32) (result f32) (select (get_local $x) (get_local $y) (f32.ge (get_local $x) (get_local $y))))
+  (export "f32.no_fold_ge_select" $f32.no_fold_ge_select)
+
+  (func $f64.no_fold_lt_select (param $x f64) (param $y f64) (result f64) (select (get_local $x) (get_local $y) (f64.lt (get_local $x) (get_local $y))))
+  (export "f64.no_fold_lt_select" $f64.no_fold_lt_select)
+  (func $f64.no_fold_le_select (param $x f64) (param $y f64) (result f64) (select (get_local $x) (get_local $y) (f64.le (get_local $x) (get_local $y))))
+  (export "f64.no_fold_le_select" $f64.no_fold_le_select)
+  (func $f64.no_fold_gt_select (param $x f64) (param $y f64) (result f64) (select (get_local $x) (get_local $y) (f64.gt (get_local $x) (get_local $y))))
+  (export "f64.no_fold_gt_select" $f64.no_fold_gt_select)
+  (func $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))))
+  (export "f64.no_fold_ge_select" $f64.no_fold_ge_select)
+)
+
+(assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const nan)) (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 (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 (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 (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 (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 (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 (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 (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))
+
+;; Test that x<y?x:y, etc. using if and else aren't folded to min, etc.
+
+(module
+  (func $f32.no_fold_lt_if (param $x f32) (param $y f32) (result f32) (if (f32.lt (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (export "f32.no_fold_lt_if" $f32.no_fold_lt_if)
+  (func $f32.no_fold_le_if (param $x f32) (param $y f32) (result f32) (if (f32.le (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (export "f32.no_fold_le_if" $f32.no_fold_le_if)
+  (func $f32.no_fold_gt_if (param $x f32) (param $y f32) (result f32) (if (f32.gt (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (export "f32.no_fold_gt_if" $f32.no_fold_gt_if)
+  (func $f32.no_fold_ge_if (param $x f32) (param $y f32) (result f32) (if (f32.ge (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (export "f32.no_fold_ge_if" $f32.no_fold_ge_if)
+
+  (func $f64.no_fold_lt_if (param $x f64) (param $y f64) (result f64) (if (f64.lt (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (export "f64.no_fold_lt_if" $f64.no_fold_lt_if)
+  (func $f64.no_fold_le_if (param $x f64) (param $y f64) (result f64) (if (f64.le (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (export "f64.no_fold_le_if" $f64.no_fold_le_if)
+  (func $f64.no_fold_gt_if (param $x f64) (param $y f64) (result f64) (if (f64.gt (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (export "f64.no_fold_gt_if" $f64.no_fold_gt_if)
+  (func $f64.no_fold_ge_if (param $x f64) (param $y f64) (result f64) (if (f64.ge (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (export "f64.no_fold_ge_if" $f64.no_fold_ge_if)
+)
+
+(assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const nan)) (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 (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 (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 (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 (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 (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 (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 (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))
+
+;; Test that x<0?-x:0, etc. using select aren't folded to abs
+
+(module
+  (func $f32.no_fold_lt_select_to_abs (param $x f32) (result f32) (select (f32.neg (get_local $x)) (get_local $x) (f32.lt (get_local $x) (f32.const 0.0))))
+  (export "f32.no_fold_lt_select_to_abs" $f32.no_fold_lt_select_to_abs)
+  (func $f32.no_fold_le_select_to_abs (param $x f32) (result f32) (select (f32.neg (get_local $x)) (get_local $x) (f32.le (get_local $x) (f32.const -0.0))))
+  (export "f32.no_fold_le_select_to_abs" $f32.no_fold_le_select_to_abs)
+  (func $f32.no_fold_gt_select_to_abs (param $x f32) (result f32) (select (get_local $x) (f32.neg (get_local $x)) (f32.gt (get_local $x) (f32.const -0.0))))
+  (export "f32.no_fold_gt_select_to_abs" $f32.no_fold_gt_select_to_abs)
+  (func $f32.no_fold_ge_select_to_abs (param $x f32) (result f32) (select (get_local $x) (f32.neg (get_local $x)) (f32.ge (get_local $x) (f32.const 0.0))))
+  (export "f32.no_fold_ge_select_to_abs" $f32.no_fold_ge_select_to_abs)
+
+  (func $f64.no_fold_lt_select_to_abs (param $x f64) (result f64) (select (f64.neg (get_local $x)) (get_local $x) (f64.lt (get_local $x) (f64.const 0.0))))
+  (export "f64.no_fold_lt_select_to_abs" $f64.no_fold_lt_select_to_abs)
+  (func $f64.no_fold_le_select_to_abs (param $x f64) (result f64) (select (f64.neg (get_local $x)) (get_local $x) (f64.le (get_local $x) (f64.const -0.0))))
+  (export "f64.no_fold_le_select_to_abs" $f64.no_fold_le_select_to_abs)
+  (func $f64.no_fold_gt_select_to_abs (param $x f64) (result f64) (select (get_local $x) (f64.neg (get_local $x)) (f64.gt (get_local $x) (f64.const -0.0))))
+  (export "f64.no_fold_gt_select_to_abs" $f64.no_fold_gt_select_to_abs)
+  (func $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))))
+  (export "f64.no_fold_ge_select_to_abs" $f64.no_fold_ge_select_to_abs)
+)
+
+(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 (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 (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 (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 (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 (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 (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 (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 (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))
+
+;; Test that x<0?-x:0, etc. using if aren't folded to abs
+
+(module
+  (func $f32.no_fold_lt_if_to_abs (param $x f32) (result f32) (if (f32.lt (get_local $x) (f32.const 0.0)) (f32.neg (get_local $x)) (get_local $x)))
+  (export "f32.no_fold_lt_if_to_abs" $f32.no_fold_lt_if_to_abs)
+  (func $f32.no_fold_le_if_to_abs (param $x f32) (result f32) (if (f32.le (get_local $x) (f32.const -0.0)) (f32.neg (get_local $x)) (get_local $x)))
+  (export "f32.no_fold_le_if_to_abs" $f32.no_fold_le_if_to_abs)
+  (func $f32.no_fold_gt_if_to_abs (param $x f32) (result f32) (if (f32.gt (get_local $x) (f32.const -0.0)) (get_local $x) (f32.neg (get_local $x))))
+  (export "f32.no_fold_gt_if_to_abs" $f32.no_fold_gt_if_to_abs)
+  (func $f32.no_fold_ge_if_to_abs (param $x f32) (result f32) (if (f32.ge (get_local $x) (f32.const 0.0)) (get_local $x) (f32.neg (get_local $x))))
+  (export "f32.no_fold_ge_if_to_abs" $f32.no_fold_ge_if_to_abs)
+
+  (func $f64.no_fold_lt_if_to_abs (param $x f64) (result f64) (if (f64.lt (get_local $x) (f64.const 0.0)) (f64.neg (get_local $x)) (get_local $x)))
+  (export "f64.no_fold_lt_if_to_abs" $f64.no_fold_lt_if_to_abs)
+  (func $f64.no_fold_le_if_to_abs (param $x f64) (result f64) (if (f64.le (get_local $x) (f64.const -0.0)) (f64.neg (get_local $x)) (get_local $x)))
+  (export "f64.no_fold_le_if_to_abs" $f64.no_fold_le_if_to_abs)
+  (func $f64.no_fold_gt_if_to_abs (param $x f64) (result f64) (if (f64.gt (get_local $x) (f64.const -0.0)) (get_local $x) (f64.neg (get_local $x))))
+  (export "f64.no_fold_gt_if_to_abs" $f64.no_fold_gt_if_to_abs)
+  (func $f64.no_fold_ge_if_to_abs (param $x f64) (result f64) (if (f64.ge (get_local $x) (f64.const 0.0)) (get_local $x) (f64.neg (get_local $x))))
+  (export "f64.no_fold_ge_if_to_abs" $f64.no_fold_ge_if_to_abs)
+)
+
+(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 (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 (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 (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 (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 (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 (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 (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 (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))
+
+;; Test for a historic spreadsheet bug.
+;; https://support.microsoft.com/en-us/kb/78113
+
+(module
+  (func $incorrect_correction (result f32)
+    (f32.sub (f32.sub (f32.add (f32.const 1.333) (f32.const 1.225)) (f32.const 1.333)) (f32.const 1.225))
+  )
+  (export "incorrect_correction" $incorrect_correction)
+)
+
+(assert_return (invoke "incorrect_correction") (f32.const 0x1p-23))
+
+(module
+  (func $incorrect_correction (result f64)
+    (f64.sub (f64.sub (f64.add (f64.const 1.333) (f64.const 1.225)) (f64.const 1.333)) (f64.const 1.225))
+  )
+  (export "incorrect_correction" $incorrect_correction)
+)
+
+(assert_return (invoke "incorrect_correction") (f64.const -0x1p-52))
+
+;; Test for a historical calculator bug.
+;; http://www.hpmuseum.org/cgi-sys/cgiwrap/hpmuseum/articles.cgi?read=735
+
+(module
+  (func $calculate (result f32)
+    (local $x f32)
+    (local $r f32)
+    (local $q f32)
+    (local $z0 f32)
+    (local $z1 f32)
+    (set_local $x (f32.const 156.25))
+    (set_local $r (f32.const 208.333333334))
+    (set_local $q (f32.const 1.77951304201))
+    (set_local $z0 (f32.div (f32.mul (f32.neg (get_local $r)) (get_local $x)) (f32.sub (f32.mul (get_local $x) (get_local $q)) (get_local $r))))
+    (set_local $z1 (f32.div (f32.mul (f32.neg (get_local $r)) (get_local $x)) (f32.sub (f32.mul (get_local $x) (get_local $q)) (get_local $r))))
+    (block (br_if 0 (f32.eq (get_local $z0) (get_local $z1))) (unreachable))
+    (get_local $z1)
+  )
+  (export "calculate" $calculate)
+)
+
+(assert_return (invoke "calculate") (f32.const -0x1.d2ed46p+8))
+
+(module
+  (func $calculate (result f64)
+    (local $x f64)
+    (local $r f64)
+    (local $q f64)
+    (local $z0 f64)
+    (local $z1 f64)
+    (set_local $x (f64.const 156.25))
+    (set_local $r (f64.const 208.333333334))
+    (set_local $q (f64.const 1.77951304201))
+    (set_local $z0 (f64.div (f64.mul (f64.neg (get_local $r)) (get_local $x)) (f64.sub (f64.mul (get_local $x) (get_local $q)) (get_local $r))))
+    (set_local $z1 (f64.div (f64.mul (f64.neg (get_local $r)) (get_local $x)) (f64.sub (f64.mul (get_local $x) (get_local $q)) (get_local $r))))
+    (block (br_if 0 (f64.eq (get_local $z0) (get_local $z1))) (unreachable))
+    (get_local $z1)
+  )
+  (export "calculate" $calculate)
+)
+
+(assert_return (invoke "calculate") (f64.const -0x1.d2ed4d0218c93p+8))
+
+;; Test that 0 - (-0 - x) is not optimized to x.
+;; https://llvm.org/bugs/show_bug.cgi?id=26746
+
+(module
+  (func $llvm_pr26746 (param $x f32) (result f32)
+    (f32.sub (f32.const 0.0) (f32.sub (f32.const -0.0) (get_local $x)))
+  )
+  (export "llvm_pr26746" $llvm_pr26746)
+)
+
+(assert_return (invoke "llvm_pr26746" (f32.const -0.0)) (f32.const 0.0))
+
+;; Test for improperly reassociating an addition and a conversion.
+;; https://llvm.org/bugs/show_bug.cgi?id=27153
+
+(module
+  (func $llvm_pr27153 (param $x i32) (result f32)
+    (f32.add (f32.convert_s/i32 (i32.and (get_local $x) (i32.const 268435455))) (f32.const -8388608.0))
+  )
+  (export "llvm_pr27153" $llvm_pr27153)
+)
+
+(assert_return (invoke "llvm_pr27153" (i32.const 33554434)) (f32.const 25165824.000000))
diff --git a/ml-proto/test/float_literals.wast b/ml-proto/test/float_literals.wast
index 58df551bfc..8c95e35b6f 100644
--- a/ml-proto/test/float_literals.wast
+++ b/ml-proto/test/float_literals.wast
@@ -1,3 +1,5 @@
+;; Test floating-point literal parsing.
+
 (module
   ;; f32 special values
   (func $f32.nan (result i32) (i32.reinterpret/f32 (f32.const nan)))
diff --git a/ml-proto/test/float_memory.wast b/ml-proto/test/float_memory.wast
index cba672a0fb..efcb732c6e 100644
--- a/ml-proto/test/float_memory.wast
+++ b/ml-proto/test/float_memory.wast
@@ -1,64 +1,141 @@
-;; x87 loads and stores canonicalize some bit patterns. Test that wasm loads and
-;; stores don't do this.
+;; Test that floating-point load and store are bit-preserving.
+
+;; Test that load and store do not canonicalize NaNs as x87 does.
 
 (module
-  (memory 1 1)
+  (memory 1 1 (segment 0 "\00\00\a0\7f"))
 
-  (func $store_i32 (param $x i32) (result i32)
-    (i32.store (i32.const 0) (get_local $x)))
+  (func $f32.load (result f32) (f32.load (i32.const 0)))
+  (export "f32.load" $f32.load)
 
-  (func $load_i32 (result i32)
-    (i32.load (i32.const 0)))
+  (func $i32.load (result i32) (i32.load (i32.const 0)))
+  (export "i32.load" $i32.load)
 
-  (func $store_f32 (param $x f32) (result f32)
-    (f32.store (i32.const 0) (get_local $x)))
+  (func $f32.store (f32.store (i32.const 0) (f32.const nan:0x200000)))
+  (export "f32.store" $f32.store)
 
-  (func $load_f32 (result f32)
-    (f32.load (i32.const 0)))
+  (func $i32.store (i32.store (i32.const 0) (i32.const 0x7fa00000)))
+  (export "i32.store" $i32.store)
 
-  (export "store_i32" $store_i32)
-  (export "load_i32" $load_i32)
-  (export "store_f32" $store_f32)
-  (export "load_f32" $load_f32)
+  (func $reset (i32.store (i32.const 0) (i32.const 0)))
+  (export "reset" $reset)
 )
 
-(assert_return (invoke "store_i32" (i32.const 0x7f800001)) (i32.const 0x7f800001))
-(assert_return (invoke "load_f32") (f32.const nan:0x000001))
-(assert_return (invoke "store_i32" (i32.const 0x80000000)) (i32.const 0x80000000))
-(assert_return (invoke "load_f32") (f32.const -0.0))
+(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
+(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(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))
+(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))
+
+(module
+  (memory 1 1 (segment 0 "\00\00\00\00\00\00\f4\7f"))
+
+  (func $f64.load (result f64) (f64.load (i32.const 0)))
+  (export "f64.load" $f64.load)
+
+  (func $i64.load (result i64) (i64.load (i32.const 0)))
+  (export "i64.load" $i64.load)
+
+  (func $f64.store (f64.store (i32.const 0) (f64.const nan:0x4000000000000)))
+  (export "f64.store" $f64.store)
+
+  (func $i64.store (i64.store (i32.const 0) (i64.const 0x7ff4000000000000)))
+  (export "i64.store" $i64.store)
+
+  (func $reset (i64.store (i32.const 0) (i64.const 0)))
+  (export "reset" $reset)
+)
 
-(assert_return (invoke "store_f32" (f32.const nan:0x000001)) (f32.const nan:0x000001))
-(assert_return (invoke "load_i32") (i32.const 0x7f800001))
-(assert_return (invoke "store_f32" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "load_i32") (i32.const 0x80000000))
+(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
+(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(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))
+(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))
+
+;; Test that load and store do not canonicalize NaNs as some JS engines do.
 
 (module
-  (memory 1 1)
+  (memory 1 1 (segment 0 "\01\00\d0\7f"))
 
-  (func $store_i64 (param $x i64) (result i64)
-    (i64.store (i32.const 0) (get_local $x)))
+  (func $f32.load (result f32) (f32.load (i32.const 0)))
+  (export "f32.load" $f32.load)
 
-  (func $load_i64 (result i64)
-    (i64.load (i32.const 0)))
+  (func $i32.load (result i32) (i32.load (i32.const 0)))
+  (export "i32.load" $i32.load)
 
-  (func $store_f64 (param $x f64) (result f64)
-    (f64.store (i32.const 0) (get_local $x)))
+  (func $f32.store (f32.store (i32.const 0) (f32.const nan:0x500001)))
+  (export "f32.store" $f32.store)
 
-  (func $load_f64 (result f64)
-    (f64.load (i32.const 0)))
+  (func $i32.store (i32.store (i32.const 0) (i32.const 0x7fd00001)))
+  (export "i32.store" $i32.store)
 
-  (export "store_i64" $store_i64)
-  (export "load_i64" $load_i64)
-  (export "store_f64" $store_f64)
-  (export "load_f64" $load_f64)
+  (func $reset (i32.store (i32.const 0) (i32.const 0)))
+  (export "reset" $reset)
 )
 
-(assert_return (invoke "store_i64" (i64.const 0x7ff0000000000001)) (i64.const 0x7ff0000000000001))
-(assert_return (invoke "load_f64") (f64.const nan:0x0000000000001))
-(assert_return (invoke "store_i64" (i64.const 0x8000000000000000)) (i64.const 0x8000000000000000))
-(assert_return (invoke "load_f64") (f64.const -0.0))
+(assert_return (invoke "i32.load") (i32.const 0x7fd00001))
+(assert_return (invoke "f32.load") (f32.const nan:0x500001))
+(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))
+(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))
+
+(module
+  (memory 1 1 (segment 0 "\01\00\00\00\00\00\fc\7f"))
+
+  (func $f64.load (result f64) (f64.load (i32.const 0)))
+  (export "f64.load" $f64.load)
+
+  (func $i64.load (result i64) (i64.load (i32.const 0)))
+  (export "i64.load" $i64.load)
+
+  (func $f64.store (f64.store (i32.const 0) (f64.const nan:0xc000000000001)))
+  (export "f64.store" $f64.store)
+
+  (func $i64.store (i64.store (i32.const 0) (i64.const 0x7ffc000000000001)))
+  (export "i64.store" $i64.store)
+
+  (func $reset (i64.store (i32.const 0) (i64.const 0)))
+  (export "reset" $reset)
+)
 
-(assert_return (invoke "store_f64" (f64.const nan:0x0000000000001)) (f64.const nan:0x0000000000001))
-(assert_return (invoke "load_i64") (i64.const 0x7ff0000000000001))
-(assert_return (invoke "store_f64" (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "load_i64") (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
+(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))
+(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))
+(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))
diff --git a/ml-proto/test/float_misc.wast b/ml-proto/test/float_misc.wast
index b836617487..6833362cf7 100644
--- a/ml-proto/test/float_misc.wast
+++ b/ml-proto/test/float_misc.wast
@@ -8,6 +8,10 @@
 ;; WebAssembly (rounding direction, exception masks, precision level, subnormal
 ;; mode, etc.), and (c) the WebAssembly implementation doesn't perform any
 ;; common value-changing optimizations.
+;;
+;; This file supplements f32.wast, f64.wast, f32_cmp.wast, and f64_cmp.wast with
+;; additional single-instruction tests covering additional miscellaneous
+;; interesting cases.
 
 (module
   (func $f32.add (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y)))
@@ -74,7 +78,7 @@
 (assert_return (invoke "f32.add" (f32.const 0x1p23) (f32.const 0x1p-1)) (f32.const 0x1p23))
 (assert_return (invoke "f32.add" (f32.const 0x1.000002p+23) (f32.const 0x1p-1)) (f32.const 0x1.000004p+23))
 
-;; Test that what some systems call signalling NaN behaves as a quiet NaN.
+;; Test that what some systems call signaling NaN behaves as a quiet NaN.
 (assert_return (invoke "f32.add" (f32.const nan:0x200000) (f32.const 1.0)) (f32.const nan:0x600000))
 
 (assert_return (invoke "f64.add" (f64.const 1.1234567890) (f64.const 1.2345e-10)) (f64.const 0x1.1f9add37c11f7p+0))
@@ -93,18 +97,28 @@
 (assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1p-53)) (f64.const 0x1.0p+0))
 (assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1.0000000000001p-53)) (f64.const 0x1.0000000000001p+0))
 
-;; Computations that round differently in round-to-odd mode.
+;; Computations that round differently in ties-to-odd mode.
 (assert_return (invoke "f64.add" (f64.const 0x1p52) (f64.const 0x1p-1)) (f64.const 0x1p52))
 (assert_return (invoke "f64.add" (f64.const 0x1.0000000000001p+52) (f64.const 0x1p-1)) (f64.const 0x1.0000000000002p+52))
 
 ;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.add" (f32.const -0x1.39675ap+102) (f32.const 0x1.76c94cp-99)) (f32.const -0x1.39675ap+102))
+(assert_return (invoke "f32.add" (f32.const 0x1.6c0f24p+67) (f32.const -0x1.2b92dp+52)) (f32.const 0x1.6c0cccp+67))
+(assert_return (invoke "f32.add" (f32.const 0x1.e62318p-83) (f32.const 0x1.f74abep-125)) (f32.const 0x1.e62318p-83))
+(assert_return (invoke "f32.add" (f32.const 0x1.2a71d4p+39) (f32.const -0x1.c9f10cp+55)) (f32.const -0x1.c9efe2p+55))
+(assert_return (invoke "f32.add" (f32.const 0x1.f8f736p-15) (f32.const 0x1.7bd45ep+106)) (f32.const 0x1.7bd45ep+106))
 (assert_return (invoke "f64.add" (f64.const 0x1.f33e1fbca27aap-413) (f64.const -0x1.6b192891ed61p+249)) (f64.const -0x1.6b192891ed61p+249))
 (assert_return (invoke "f64.add" (f64.const -0x1.46f75d130eeb1p+76) (f64.const 0x1.25275d6f7a4acp-184)) (f64.const -0x1.46f75d130eeb1p+76))
 (assert_return (invoke "f64.add" (f64.const 0x1.04dec9265a731p-148) (f64.const -0x1.11eed4e8c127cp-12)) (f64.const -0x1.11eed4e8c127cp-12))
 (assert_return (invoke "f64.add" (f64.const 0x1.05773b7166b0ap+497) (f64.const 0x1.134022f2da37bp+66)) (f64.const 0x1.05773b7166b0ap+497))
 (assert_return (invoke "f64.add" (f64.const 0x1.ef4f794282a82p+321) (f64.const 0x1.14a82266badep+394)) (f64.const 0x1.14a82266badep+394))
 
-;; Computations that round differently in round-doward mode.
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.add" (f32.const 0x1.1bf976p+72) (f32.const -0x1.7f5868p+20)) (f32.const 0x1.1bf976p+72))
+(assert_return (invoke "f32.add" (f32.const 0x1.7f9c6cp-45) (f32.const -0x1.b9bb0ep-78)) (f32.const 0x1.7f9c6cp-45))
+(assert_return (invoke "f32.add" (f32.const -0x1.32d1bcp-42) (f32.const 0x1.f7d214p+125)) (f32.const 0x1.f7d214p+125))
+(assert_return (invoke "f32.add" (f32.const -0x1.8e5c0ep-44) (f32.const -0x1.3afa4cp-106)) (f32.const -0x1.8e5c0ep-44))
+(assert_return (invoke "f32.add" (f32.const 0x1.13cd78p-10) (f32.const -0x1.3af316p-107)) (f32.const 0x1.13cd78p-10))
 (assert_return (invoke "f64.add" (f64.const 0x1.f8dd15ca97d4ap+179) (f64.const -0x1.367317d1fe8bfp-527)) (f64.const 0x1.f8dd15ca97d4ap+179))
 (assert_return (invoke "f64.add" (f64.const 0x1.5db08d739228cp+155) (f64.const -0x1.fb316fa147dcbp-61)) (f64.const 0x1.5db08d739228cp+155))
 (assert_return (invoke "f64.add" (f64.const 0x1.bbb403cb85c07p-404) (f64.const -0x1.7e44046b8bbf3p-979)) (f64.const 0x1.bbb403cb85c07p-404))
@@ -112,6 +126,11 @@
 (assert_return (invoke "f64.add" (f64.const -0x1.b61dedf4e0306p+3) (f64.const 0x1.09e2f31773c4ap+290)) (f64.const 0x1.09e2f31773c4ap+290))
 
 ;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.add" (f32.const -0x1.129bd8p-117) (f32.const 0x1.c75012p-43)) (f32.const 0x1.c75012p-43))
+(assert_return (invoke "f32.add" (f32.const -0x1.c204a2p-16) (f32.const 0x1.80b132p-27)) (f32.const -0x1.c1d48cp-16))
+(assert_return (invoke "f32.add" (f32.const -0x1.decc1cp+36) (f32.const 0x1.c688dap-109)) (f32.const -0x1.decc1cp+36))
+(assert_return (invoke "f32.add" (f32.const 0x1.61ce6ap-118) (f32.const -0x1.772892p+30)) (f32.const -0x1.772892p+30))
+(assert_return (invoke "f32.add" (f32.const -0x1.3dc826p-120) (f32.const 0x1.fc3f66p+95)) (f32.const 0x1.fc3f66p+95))
 (assert_return (invoke "f64.add" (f64.const 0x1.bf68acc263a0fp-777) (f64.const -0x1.5f9352965e5a6p+1004)) (f64.const -0x1.5f9352965e5a6p+1004))
 (assert_return (invoke "f64.add" (f64.const -0x1.76eaa70911f51p+516) (f64.const -0x1.2d746324ce47ap+493)) (f64.const -0x1.76eaa963fabb6p+516))
 (assert_return (invoke "f64.add" (f64.const -0x1.b637d82c15a7ap-967) (f64.const 0x1.cc654ccab4152p-283)) (f64.const 0x1.cc654ccab4152p-283))
@@ -146,7 +165,7 @@
 (assert_return (invoke "f64.add" (f64.const 0x0.89e17f0fdc567p-1022) (f64.const -0x1.d9a93a01fd27dp-1021)) (f64.const -0x1.94b87a7a0efcap-1021))
 (assert_return (invoke "f64.add" (f64.const -0x0.3f3d1a052fa2bp-1022) (f64.const -0x1.4b78292c7d2adp-1021)) (f64.const -0x1.6b16b62f14fc2p-1021))
 
-;; Test that what some systems call signalling NaN behaves as a quiet NaN.
+;; Test that what some systems call signaling NaN behaves as a quiet NaN.
 (assert_return (invoke "f64.add" (f64.const nan:0x4000000000000) (f64.const 1.0)) (f64.const nan:0xc000000000000))
 
 ;; Test for a historic spreadsheet bug.
@@ -167,6 +186,42 @@
 (assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1p-54)) (f64.const 0x1.0p+0))
 (assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1.0000000000001p-54)) (f64.const 0x1.fffffffffffffp-1))
 
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.sub" (f32.const 0x1.ee2466p-106) (f32.const -0x1.16277ep+119)) (f32.const 0x1.16277ep+119))
+(assert_return (invoke "f32.sub" (f32.const -0x1.446f9ep+119) (f32.const -0x1.4396a4p+43)) (f32.const -0x1.446f9ep+119))
+(assert_return (invoke "f32.sub" (f32.const 0x1.74773cp+0) (f32.const -0x1.a25512p-82)) (f32.const 0x1.74773cp+0))
+(assert_return (invoke "f32.sub" (f32.const 0x1.9345c4p-117) (f32.const 0x1.6792c2p-76)) (f32.const -0x1.6792c2p-76))
+(assert_return (invoke "f32.sub" (f32.const 0x1.9ecfa4p-18) (f32.const -0x1.864b44p-107)) (f32.const 0x1.9ecfa4p-18))
+(assert_return (invoke "f64.sub" (f64.const -0x1.5b798875e7845p-333) (f64.const -0x1.b5147117452fep-903)) (f64.const -0x1.5b798875e7845p-333))
+(assert_return (invoke "f64.sub" (f64.const -0x1.6c87baeb6d72dp+552) (f64.const -0x1.64fb35d4b5571p-158)) (f64.const -0x1.6c87baeb6d72dp+552))
+(assert_return (invoke "f64.sub" (f64.const 0x1.b3d369fcf74bp-461) (f64.const -0x1.ea1668c0dec93p-837)) (f64.const 0x1.b3d369fcf74bp-461))
+(assert_return (invoke "f64.sub" (f64.const 0x1.0abd449353eadp-1005) (f64.const -0x1.0422ea3e82ee9p+154)) (f64.const 0x1.0422ea3e82ee9p+154))
+(assert_return (invoke "f64.sub" (f64.const -0x1.aadbc6b43cc3dp-143) (f64.const -0x1.e7f922ef1ee58p-539)) (f64.const -0x1.aadbc6b43cc3dp-143))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.sub" (f32.const -0x1.61e262p+108) (f32.const -0x1.baf3e4p+112)) (f32.const 0x1.a4d5bep+112))
+(assert_return (invoke "f32.sub" (f32.const -0x1.62c2f6p+109) (f32.const 0x1.6e514ap+6)) (f32.const -0x1.62c2f6p+109))
+(assert_return (invoke "f32.sub" (f32.const -0x1.287c94p-83) (f32.const 0x1.0f2f9cp-24)) (f32.const -0x1.0f2f9cp-24))
+(assert_return (invoke "f32.sub" (f32.const -0x1.c8825cp-77) (f32.const -0x1.4aead6p-12)) (f32.const 0x1.4aead6p-12))
+(assert_return (invoke "f32.sub" (f32.const -0x1.2976a4p+99) (f32.const 0x1.c6e3b8p-59)) (f32.const -0x1.2976a4p+99))
+(assert_return (invoke "f64.sub" (f64.const -0x1.76cb28ae6c045p+202) (f64.const -0x1.0611f2af4e9b9p+901)) (f64.const 0x1.0611f2af4e9b9p+901))
+(assert_return (invoke "f64.sub" (f64.const 0x1.baf35eff22e9ep-368) (f64.const 0x1.5c3e08ecf73ecp-451)) (f64.const 0x1.baf35eff22e9ep-368))
+(assert_return (invoke "f64.sub" (f64.const -0x1.8fd354b376f1fp-200) (f64.const 0x1.513c860f386ffp-508)) (f64.const -0x1.8fd354b376f1fp-200))
+(assert_return (invoke "f64.sub" (f64.const -0x1.760d447230ae6p-992) (f64.const -0x1.16f788438ae3ep-328)) (f64.const 0x1.16f788438ae3ep-328))
+(assert_return (invoke "f64.sub" (f64.const -0x1.73aab4fcfc7ap+112) (f64.const 0x1.7c589f990b884p+171)) (f64.const -0x1.7c589f990b884p+171))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.sub" (f32.const 0x1.ea264cp+95) (f32.const 0x1.852988p-15)) (f32.const 0x1.ea264cp+95))
+(assert_return (invoke "f32.sub" (f32.const -0x1.14ec7cp+19) (f32.const -0x1.0ad3fep-35)) (f32.const -0x1.14ec7cp+19))
+(assert_return (invoke "f32.sub" (f32.const -0x1.3251dap-36) (f32.const -0x1.49c97ep-56)) (f32.const -0x1.3251c6p-36))
+(assert_return (invoke "f32.sub" (f32.const -0x1.13565ep-14) (f32.const 0x1.2f89a8p-13)) (f32.const -0x1.b934d8p-13))
+(assert_return (invoke "f32.sub" (f32.const -0x1.6032b6p-33) (f32.const -0x1.bb5196p-104)) (f32.const -0x1.6032b6p-33))
+(assert_return (invoke "f64.sub" (f64.const -0x1.b5b0797af491p-157) (f64.const -0x1.694b8348189e8p+722)) (f64.const 0x1.694b8348189e8p+722))
+(assert_return (invoke "f64.sub" (f64.const -0x1.72b142826ed73p+759) (f64.const -0x1.010477bc9afbdp+903)) (f64.const 0x1.010477bc9afbdp+903))
+(assert_return (invoke "f64.sub" (f64.const 0x1.83273b6bb94cfp-796) (f64.const 0x1.1a93f948a2abbp+181)) (f64.const -0x1.1a93f948a2abbp+181))
+(assert_return (invoke "f64.sub" (f64.const -0x1.207e7156cbf2p-573) (f64.const 0x1.cf3f12fd3814dp-544)) (f64.const -0x1.cf3f13063c086p-544))
+(assert_return (invoke "f64.sub" (f64.const -0x1.837e6844f1718p-559) (f64.const -0x1.1c29b757f98abp-14)) (f64.const 0x1.1c29b757f98abp-14))
+
 ;; Computations that round differently on x87.
 (assert_return (invoke "f64.sub" (f64.const 0x1.c21151a709b6cp-78) (f64.const 0x1.0a12fff8910f6p-115)) (f64.const 0x1.c21151a701663p-78))
 (assert_return (invoke "f64.sub" (f64.const 0x1.c57912aae2f64p-982) (f64.const 0x1.dbfbd4800b7cfp-1010)) (f64.const 0x1.c579128d2338fp-982))
@@ -174,6 +229,13 @@
 (assert_return (invoke "f64.sub" (f64.const -0x1.363eee391cde2p-39) (f64.const -0x1.a65462000265fp-69)) (f64.const -0x1.363eee32838c9p-39))
 (assert_return (invoke "f64.sub" (f64.const 0x1.59016dba002a1p-25) (f64.const 0x1.5d4374f124cccp-3)) (f64.const -0x1.5d436f8d1f15dp-3))
 
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.sub" (f64.const -0x1.18196bca005cfp-814) (f64.const -0x1.db7b01ce3f52fp-766)) (f64.const 0x1.db7b01ce3f51dp-766))
+(assert_return (invoke "f64.sub" (f64.const -0x1.d17b3528d219p+33) (f64.const 0x1.fd739d4ea220ap+367)) (f64.const -0x1.fd739d4ea220ap+367))
+(assert_return (invoke "f64.sub" (f64.const 0x1.dea46994de319p+114) (f64.const 0x1.b5b19cd55c7d3p-590)) (f64.const 0x1.dea46994de319p+114))
+(assert_return (invoke "f64.sub" (f64.const 0x1.b60f9b2fbd9ecp-489) (f64.const -0x1.6f81c59ec5b8ep-694)) (f64.const 0x1.b60f9b2fbd9ecp-489))
+(assert_return (invoke "f64.sub" (f64.const 0x1.5e423fe8571f4p-57) (f64.const 0x1.9624ed7c162dfp-618)) (f64.const 0x1.5e423fe8571f4p-57))
+
 (assert_return (invoke "f32.mul" (f32.const 1e15) (f32.const 1e15)) (f32.const 0x1.93e592p+99))
 (assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const infinity))
 (assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const infinity))
@@ -200,6 +262,42 @@
 ;; http://www.joelonsoftware.com/items/2007/09/26b.html
 (assert_return (invoke "f64.mul" (f64.const 77.1) (f64.const 850)) (f64.const 65534.99999999999272404))
 
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.mul" (f32.const -0x1.14df2ep+61) (f32.const 0x1.748878p-36)) (f32.const -0x1.92e7e8p+25))
+(assert_return (invoke "f32.mul" (f32.const -0x1.5629e2p+102) (f32.const -0x1.c33012p-102)) (f32.const 0x1.2d8604p+1))
+(assert_return (invoke "f32.mul" (f32.const -0x1.b17694p+92) (f32.const -0x1.e4b56ap-97)) (f32.const 0x1.9a5baep-4))
+(assert_return (invoke "f32.mul" (f32.const -0x1.1626a6p+79) (f32.const -0x1.c57d7p-75)) (f32.const 0x1.ecbaaep+4))
+(assert_return (invoke "f32.mul" (f32.const 0x1.7acf72p+53) (f32.const 0x1.6c89acp+5)) (f32.const 0x1.0db556p+59))
+(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -infinity))
+(assert_return (invoke "f64.mul" (f64.const -0x1.cc1ae79fffc5bp-986) (f64.const -0x1.c36ccc2861ca6p-219)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.c0232b3e64b56p+606) (f64.const -0x1.f6939cf3affaap+106)) (f64.const -0x1.b7e3aedf190d3p+713))
+(assert_return (invoke "f64.mul" (f64.const -0x1.60f289966b271p-313) (f64.const 0x1.28a5497f0c259p+583)) (f64.const -0x1.98fc50bcec259p+270))
+(assert_return (invoke "f64.mul" (f64.const 0x1.37dab12d3afa2p+795) (f64.const 0x1.81e156bd393f1p-858)) (f64.const 0x1.d6126554b8298p-63))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.mul" (f32.const -0x1.3f57a2p-89) (f32.const -0x1.041d68p+92)) (f32.const 0x1.4479bp+3))
+(assert_return (invoke "f32.mul" (f32.const 0x1.4d0582p+73) (f32.const 0x1.6e043ap+19)) (f32.const 0x1.dc236p+92))
+(assert_return (invoke "f32.mul" (f32.const -0x1.2fdap-32) (f32.const -0x1.e1731cp+74)) (f32.const 0x1.1db89ep+43))
+(assert_return (invoke "f32.mul" (f32.const 0x1.7bc8fep+67) (f32.const -0x1.3ad592p+15)) (f32.const -0x1.d3115ep+82))
+(assert_return (invoke "f32.mul" (f32.const 0x1.936742p+30) (f32.const -0x1.a7a19p+66)) (f32.const -0x1.4dc71ap+97))
+(assert_return (invoke "f64.mul" (f64.const -0x1.ba737b4ca3b13p-639) (f64.const 0x1.8923309857438p-314)) (f64.const -0x1.53bc0d07baa37p-952))
+(assert_return (invoke "f64.mul" (f64.const 0x1.7c1932e610219p-276) (f64.const -0x1.2605db646489fp-635)) (f64.const -0x1.b48da2b0d2ae3p-911))
+(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const infinity))
+(assert_return (invoke "f64.mul" (f64.const 0x1.4c19466551da3p+947) (f64.const 0x1.0bdcd6c7646e9p-439)) (f64.const 0x1.5b7cd8c3f638ap+508))
+(assert_return (invoke "f64.mul" (f64.const 0x1.ff1da1726e3dfp+339) (f64.const -0x1.043c44f52b158p+169)) (f64.const -0x1.03c9364bb585cp+509))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const infinity))
+(assert_return (invoke "f32.mul" (f32.const -0x1.8c9f74p-3) (f32.const 0x1.e2b452p-99)) (f32.const -0x1.75edccp-101))
+(assert_return (invoke "f32.mul" (f32.const -0x1.cc605ap-19) (f32.const 0x1.ec321ap+105)) (f32.const -0x1.ba91a4p+87))
+(assert_return (invoke "f32.mul" (f32.const -0x1.5fbb7ap+56) (f32.const 0x1.a8965ep-96)) (f32.const -0x1.23ae8ep-39))
+(assert_return (invoke "f32.mul" (f32.const -0x1.fb7f12p+16) (f32.const 0x1.3a701ap-119)) (f32.const -0x1.37ac0cp-102))
+(assert_return (invoke "f64.mul" (f64.const -0x1.5b0266454c26bp-496) (f64.const -0x1.af5787e3e0399p+433)) (f64.const 0x1.2457d81949e0bp-62))
+(assert_return (invoke "f64.mul" (f64.const 0x1.0d54a82393d45p+478) (f64.const -0x1.425760807ceaep-764)) (f64.const -0x1.532068c8d0d5dp-286))
+(assert_return (invoke "f64.mul" (f64.const -0x1.b532af981786p+172) (f64.const 0x1.ada95085ba36fp+359)) (f64.const -0x1.6ee38c1e01864p+532))
+(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -infinity))
+(assert_return (invoke "f64.mul" (f64.const 0x1.68bbf1cfff90ap+81) (f64.const 0x1.09cd17d652c5p+70)) (f64.const 0x1.768b8d67d794p+151))
+
 ;; Computations that round differently on x87.
 (assert_return (invoke "f64.mul" (f64.const 0x1.f99fb602c89b7p-341) (f64.const 0x1.6caab46a31a2ep-575)) (f64.const 0x1.68201f986e9d7p-915))
 (assert_return (invoke "f64.mul" (f64.const -0x1.86999c5eee379p-9) (f64.const 0x1.6e3b9e0d53e0dp+723)) (f64.const -0x1.17654a0ef35f5p+715))
@@ -214,6 +312,13 @@
 (assert_return (invoke "f64.mul" (f64.const -0x1.c6a56169e9cep-772) (f64.const 0x1.517d55a474122p-255)) (f64.const -0x0.12baf260afb77p-1022))
 (assert_return (invoke "f64.mul" (f64.const -0x1.08951b0b41705p-516) (f64.const -0x1.102dc27168d09p-507)) (f64.const 0x0.8ca6dbf3f592bp-1022))
 
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.mul" (f64.const 0x1.8d0dea50c8c9bp+852) (f64.const 0x1.21cac31d87a24p-881)) (f64.const 0x1.c177311f7cd73p-29))
+(assert_return (invoke "f64.mul" (f64.const 0x1.98049118e3063p-7) (f64.const 0x1.6362525151b58p-149)) (f64.const 0x1.1b358514103f9p-155))
+(assert_return (invoke "f64.mul" (f64.const -0x1.ea65cb0631323p+1) (f64.const 0x1.fce683201a19bp-41)) (f64.const -0x1.e76dc8c223667p-39))
+(assert_return (invoke "f64.mul" (f64.const 0x1.e4d235961d543p-373) (f64.const 0x1.bc56f20ef9a48p-205)) (f64.const 0x1.a4c09efcb71d6p-577))
+(assert_return (invoke "f64.mul" (f64.const -0x1.b9612e66faba8p+77) (f64.const 0x1.e2bc6aa782273p-348)) (f64.const -0x1.a026ea4f81db1p-270))
+
 (assert_return (invoke "f32.div" (f32.const 1.123456789) (f32.const 100)) (f32.const 0x1.702264p-7))
 (assert_return (invoke "f32.div" (f32.const 8391667.0) (f32.const 12582905.0)) (f32.const 0x1.55754p-1))
 (assert_return (invoke "f32.div" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 0x1p+53))
@@ -221,6 +326,7 @@
 (assert_return (invoke "f32.div" (f32.const 4) (f32.const 3)) (f32.const 0x1.555556p+0))
 
 ;; Test for a historic hardware bug.
+;; https://en.wikipedia.org/wiki/Pentium_FDIV_bug
 (assert_return (invoke "f32.div" (f32.const 4195835) (f32.const 3145727)) (f32.const 0x1.557542p+0))
 
 (assert_return (invoke "f64.div" (f64.const 1.123456789) (f64.const 100)) (f64.const 0.01123456789))
@@ -229,8 +335,45 @@
 (assert_return (invoke "f64.div" (f64.const 4) (f64.const 3)) (f64.const 0x1.5555555555555p+0))
 
 ;; Test for a historic hardware bug.
+;; https://en.wikipedia.org/wiki/Pentium_FDIV_bug
 (assert_return (invoke "f64.div" (f64.const 4195835) (f64.const 3145727)) (f64.const 0x1.557541c7c6b43p+0))
 
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.div" (f32.const 0x1.6a6c5ap-48) (f32.const 0x1.fa0b7p+127)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1.616fb2p-87) (f32.const 0x1.332172p+68)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.div" (f32.const -0x1.96e778p+16) (f32.const 0x1.eb0c56p-80)) (f32.const -0x1.a8440ap+95))
+(assert_return (invoke "f32.div" (f32.const -0x1.e2624p-76) (f32.const -0x1.ed236ep-122)) (f32.const 0x1.f4d584p+45))
+(assert_return (invoke "f32.div" (f32.const -0x1.e2374ep+41) (f32.const 0x1.71fcdcp-80)) (f32.const -0x1.4da706p+121))
+(assert_return (invoke "f64.div" (f64.const 0x1.163c09d0c38c1p+147) (f64.const 0x1.e04cc737348e6p+223)) (f64.const 0x1.289921caeed23p-77))
+(assert_return (invoke "f64.div" (f64.const 0x1.d6867e741e0a9p-626) (f64.const 0x1.335eb19a9aae4p-972)) (f64.const 0x1.87e342d11f519p+346))
+(assert_return (invoke "f64.div" (f64.const -0x1.d5edf648aeb98p+298) (f64.const 0x1.0dda15b079355p+640)) (f64.const -0x1.bdceaf9734b5cp-342))
+(assert_return (invoke "f64.div" (f64.const -0x1.b683e3934aedap+691) (f64.const 0x1.c364e1df00dffp+246)) (f64.const -0x1.f16456e7afe3bp+444))
+(assert_return (invoke "f64.div" (f64.const -0x1.44ca7539cc851p+540) (f64.const 0x1.58501bccc58fep+453)) (f64.const -0x1.e2f8657e0924ep+86))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const infinity))
+(assert_return (invoke "f32.div" (f32.const 0x1.e35abep-46) (f32.const 0x1.c69dfp+44)) (f32.const 0x1.102eb4p-90))
+(assert_return (invoke "f32.div" (f32.const 0x1.45ff2ap+0) (f32.const -0x1.1e8754p+89)) (f32.const -0x1.23434ep-89))
+(assert_return (invoke "f32.div" (f32.const 0x1.8db18ap-51) (f32.const 0x1.47c678p-128)) (f32.const 0x1.369b96p+77))
+(assert_return (invoke "f32.div" (f32.const 0x1.78599p+90) (f32.const 0x1.534144p+87)) (f32.const 0x1.1bfddcp+3))
+(assert_return (invoke "f64.div" (f64.const 0x0.f331c4f47eb51p-1022) (f64.const -0x1.c7ff45bf6f03ap+362)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.div" (f64.const -0x1.0fc8707b9d19cp-987) (f64.const 0x1.77524d5f4a563p-536)) (f64.const -0x1.72c1a937d231p-452))
+(assert_return (invoke "f64.div" (f64.const -0x1.edb3aa64bb338p-403) (f64.const -0x1.1c7c164320e4p+45)) (f64.const 0x1.bc44cc1c5ae63p-448))
+(assert_return (invoke "f64.div" (f64.const -0x1.6534b34e8686bp+80) (f64.const 0x1.c34a7fc59e3c3p-791)) (f64.const -0x1.95421bf291b66p+870))
+(assert_return (invoke "f64.div" (f64.const -0x1.91f58d7ed1237p+236) (f64.const -0x1.f190d808383c8p+55)) (f64.const 0x1.9d9eb0836f906p+180))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const infinity))
+(assert_return (invoke "f32.div" (f32.const -0x1.53c9b6p+77) (f32.const 0x1.d689ap+27)) (f32.const -0x1.71baa4p+49))
+(assert_return (invoke "f32.div" (f32.const 0x1.664a8ap+38) (f32.const -0x1.59dba2p+96)) (f32.const -0x1.0933f4p-58))
+(assert_return (invoke "f32.div" (f32.const -0x1.99e0fap+111) (f32.const -0x1.c2b5a8p+9)) (f32.const 0x1.d19de6p+101))
+(assert_return (invoke "f32.div" (f32.const -0x1.5a815ap+92) (f32.const -0x1.b5820ap+13)) (f32.const 0x1.9580b8p+78))
+(assert_return (invoke "f64.div" (f64.const -0x1.81fd1e2af7bebp-655) (f64.const 0x1.edefc4eae536cp-691)) (f64.const -0x1.901abdd91b661p+35))
+(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const infinity))
+(assert_return (invoke "f64.div" (f64.const -0x1.2bd2e8fbdcad7p-746) (f64.const 0x1.b115674cc476ep-65)) (f64.const -0x1.62752bf19fa81p-682))
+(assert_return (invoke "f64.div" (f64.const -0x1.f923e3fea9efep+317) (f64.const -0x1.8044c74d27a39p-588)) (f64.const 0x1.5086518cc7186p+905))
+(assert_return (invoke "f64.div" (f64.const 0x1.516ed2051d6bbp+181) (f64.const -0x1.c9f455eb9c2eep+214)) (f64.const -0x1.79414d67f2889p-34))
+
 ;; Computations that round differently on x87.
 (assert_return (invoke "f64.div" (f64.const -0x1.9c52726aed366p+585) (f64.const -0x1.7d0568c75660fp+195)) (f64.const 0x1.1507ca2a65f23p+390))
 (assert_return (invoke "f64.div" (f64.const -0x1.522672f461667p+546) (f64.const -0x1.36d36572c9f71p+330)) (f64.const 0x1.1681369370619p+216))
@@ -260,6 +403,11 @@
 (assert_return (invoke "f64.div" (f64.const 0x1.cf82510d0ae6bp+89) (f64.const 0x1.0207d86498053p+97)) (f64.const 0x1.cbdc804e2cf14p-8))
 (assert_return (invoke "f64.div" (f64.const 0x1.4c82cbb508e21p-11) (f64.const -0x1.6b57208c2d5d5p+52)) (f64.const -0x1.d48e8b369129ap-64))
 
+;; Test for bugs found in an early RISC-V implementation.
+;; https://github.com/riscv/riscv-tests/pull/8
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.56p+7)) (f32.const 0x1.a2744cp+3))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.594dfcp-23)) (f32.const 0x1.a4789cp-12))
+
 ;; Computations that round differently on x87.
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.0263fcc94f259p-164)) (f64.const 0x1.0131485de579fp-82))
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.352dfa278c43dp+338)) (f64.const 0x1.195607dac5417p+169))
@@ -267,6 +415,54 @@
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.518c8e68cb753p-37)) (f64.const 0x1.9fb8ef1ad5bfdp-19))
 (assert_return (invoke "f64.sqrt" (f64.const 0x1.86d8b6518078ep-370)) (f64.const 0x1.3c5142a48fcadp-185))
 
+;; Test for bugs found in an early RISC-V implementation.
+;; https://github.com/riscv/riscv-tests/pull/8
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.56p+7)) (f64.const 0x1.a2744ce9674f5p+3))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.594dfc70aa105p-23)) (f64.const 0x1.a4789c0e37f99p-12))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.098064p-3)) (f32.const 0x1.70b23p-2))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.d9befp+100)) (f32.const 0x1.5c4052p+50))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.42b5b6p-4)) (f32.const 0x1.1f6d0ep-2))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.3684dp-71)) (f32.const 0x1.8ebae2p-36))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.d8bc4ep-11)) (f32.const 0x1.ebf9eap-6))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.5c39f220d5704p-924)) (f64.const 0x1.2a92bc24ceae9p-462))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.53521a635745cp+727)) (f64.const 0x1.a0cfdc4ef8ff1p+363))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.dfd5bbc9f4678p+385)) (f64.const 0x1.efa817117c94cp+192))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.33f9640811cd4p+105)) (f64.const 0x1.8d17c9243baa3p+52))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.6c0ef0267ff45p+999)) (f64.const 0x1.afbcfae3f2b4p+499))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.26a62ep+27)) (f32.const 0x1.84685p+13))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.166002p-113)) (f32.const 0x1.798762p-57))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.3dfb5p-15)) (f32.const 0x1.937e38p-8))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.30eb2cp-120)) (f32.const 0x1.176406p-60))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.cb705cp-123)) (f32.const 0x1.e5020ap-62))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.edae8aea0543p+695)) (f64.const 0x1.f6c1ea4fc8dd2p+347))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.f7ee4bda5c9c3p-763)) (f64.const 0x1.fbf30bdaf11c5p-382))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.a48f348266ad1p-30)) (f64.const 0x1.481ee7540baf7p-15))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.feb5a1ce3ed9cp-242)) (f64.const 0x1.6995060c20d46p-121))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.957d9796e3834p+930)) (f64.const 0x1.42305213157bap+465))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.65787cp+118)) (f32.const 0x1.2e82a4p+59))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.736044p+15)) (f32.const 0x1.b40e4p+7))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.a00edp-1)) (f32.const 0x1.cd8aecp-1))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.7a4c8p-87)) (f32.const 0x1.b819e4p-44))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.5d24d4p-94)) (f32.const 0x1.2af75ep-47))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.a008948ead274p+738)) (f64.const 0x1.4659b37c39b19p+369))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.70f6199ed21f5p-381)) (f64.const 0x1.b2a2bddf3300dp-191))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.35c1d49f2a352p+965)) (f64.const 0x1.8e3d9f01a9716p+482))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.3fbdcfb2b2a15p-45)) (f64.const 0x1.949ba4feca42ap-23))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.c201b94757145p-492)) (f64.const 0x1.5369ee6bf2967p-246))
+
+;; Computations that round differently when computed via f32.
+(assert_return_nan (invoke "f64.sqrt" (f64.const -0x1.360e8d0032adp-963)))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.d9a6f5eef0503p+103)) (f64.const 0x1.ec73f56c166f6p+51))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.aa051a5c4ec27p-760)) (f64.const 0x1.4a3e771ff5149p-380))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.e5522a741babep-276)) (f64.const 0x1.607ae2b6feb7dp-138))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.4832badc0c061p+567)) (f64.const 0x1.99ec7934139b2p+283))
+
 ;; Test that the bitwise floating point operators are bitwise on NaN.
 
 (assert_return (invoke "f32.abs" (f32.const nan)) (f32.const nan))
diff --git a/ml-proto/test/int_exprs.wast b/ml-proto/test/int_exprs.wast
index 2d10c98f23..88324d11ce 100644
--- a/ml-proto/test/int_exprs.wast
+++ b/ml-proto/test/int_exprs.wast
@@ -1,3 +1,6 @@
+;; Test interesting integer "expressions". These tests contain code
+;; patterns which tempt common value-changing optimizations.
+
 ;; Test that x+1<y+1 is not folded to x<y
 
 (module
diff --git a/ml-proto/test/nan-propagation.wast b/ml-proto/test/nan-propagation.wast
index 90e69de036..26805bea34 100644
--- a/ml-proto/test/nan-propagation.wast
+++ b/ml-proto/test/nan-propagation.wast
@@ -1,3 +1,5 @@
+;; Test that NaN values are propagated through arithmetic operators properly.
+
 (module
   (func $add (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y)))
   (func $sub (param $x f32) (param $y f32) (result f32) (f32.sub (get_local $x) (get_local $y)))

From b38f57fe7e688956d0e1a60d7ae1f0c108f74a06 Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Mon, 18 Apr 2016 12:45:12 -0700
Subject: [PATCH 2/4] Test that f32.nearest isn't implemented naively.

---
 ml-proto/test/float_misc.wast | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/ml-proto/test/float_misc.wast b/ml-proto/test/float_misc.wast
index 6833362cf7..32ff6cba66 100644
--- a/ml-proto/test/float_misc.wast
+++ b/ml-proto/test/float_misc.wast
@@ -519,6 +519,16 @@
 (assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp-1)) (f64.const -1.0))
 (assert_return (invoke "f64.floor" (f64.const -0x1p-1022)) (f64.const -1.0))
 
+;; Test that nearest isn't implemented naively.
+;; http://blog.frama-c.com/index.php?post/2013/05/02/nearbyintf1
+;; http://blog.frama-c.com/index.php?post/2013/05/04/nearbyintf3
+(assert_return (invoke "f32.nearest" (f32.const 0x1.000002p+23)) (f32.const 0x1.000002p+23))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.000004p+23)) (f32.const 0x1.000004p+23))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep-2)) (f32.const 0.0))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000001p+52)) (f64.const 0x1.0000000000001p+52))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000002p+52)) (f64.const 0x1.0000000000002p+52))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp-2)) (f64.const 0.0))
+
 ;; Nearest should not round halfway cases away from zero (as C's round(3) does)
 ;; or up (as JS's Math.round does).
 (assert_return (invoke "f32.nearest" (f32.const 4.5)) (f32.const 4.0))

From c60d40c79820cf53dee3f46007495809e9c8700d Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Mon, 18 Apr 2016 15:09:34 -0700
Subject: [PATCH 3/4] Add tests for bugs reported in old hardware platforms.

---
 ml-proto/test/float_exprs.wast | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/ml-proto/test/float_exprs.wast b/ml-proto/test/float_exprs.wast
index 34649315ab..1ed8a935b2 100644
--- a/ml-proto/test/float_exprs.wast
+++ b/ml-proto/test/float_exprs.wast
@@ -1218,3 +1218,32 @@
 )
 
 (assert_return (invoke "llvm_pr27153" (i32.const 33554434)) (f32.const 25165824.000000))
+
+;; Test for bugs in old versions of historic IEEE 754 platforms as reported in:
+;;
+;; N. L. Schryer. 1981. A Test of a Computer's Floating-Point Arithmetic Unit.
+;; Tech. Rep. Computer Science Technical Report 89, AT&T Bell Laboratories, Feb.
+;;
+;; specifically, the appendices describing IEEE systems with "The Past" sections
+;; describing specific bugs. The 0 < 0 bug is omitted here due to being already
+;; covered elsewhere.
+(module
+  (func $thepast0 (param $a f64) (param $b f64) (param $c f64) (param $d f64) (result f64)
+    (f64.div (f64.mul (get_local $a) (get_local $b)) (f64.mul (get_local $c) (get_local $d)))
+  )
+  (export "thepast0" $thepast0)
+
+  (func $thepast1 (param $a f64) (param $b f64) (param $c f64) (result f64)
+    (f64.sub (f64.mul (get_local $a) (get_local $b)) (get_local $c))
+  )
+  (export "thepast1" $thepast1)
+
+  (func $thepast2 (param $a f32) (param $b f32) (param $c f32) (result f32)
+    (f32.mul (f32.mul (get_local $a) (get_local $b)) (get_local $c))
+  )
+  (export "thepast2" $thepast2)
+)
+
+(assert_return (invoke "thepast0" (f64.const 0x1p-1021) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p1) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp-1022))
+(assert_return (invoke "thepast1" (f64.const 0x1p-54) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p-54)) (f64.const -0x1p-107))
+(assert_return (invoke "thepast2" (f32.const 0x1p-125) (f32.const 0x1p-1) (f32.const 0x1p0)) (f32.const 0x1p-126))

From 5f830814e2cf81e4ed98339b71050ea923244548 Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Mon, 18 Apr 2016 15:27:50 -0700
Subject: [PATCH 4/4] Test a case observed on some GPUs.

---
 ml-proto/test/float_exprs.wast | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/ml-proto/test/float_exprs.wast b/ml-proto/test/float_exprs.wast
index 1ed8a935b2..7307982c0e 100644
--- a/ml-proto/test/float_exprs.wast
+++ b/ml-proto/test/float_exprs.wast
@@ -1247,3 +1247,15 @@
 (assert_return (invoke "thepast0" (f64.const 0x1p-1021) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p1) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp-1022))
 (assert_return (invoke "thepast1" (f64.const 0x1p-54) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p-54)) (f64.const -0x1p-107))
 (assert_return (invoke "thepast2" (f32.const 0x1p-125) (f32.const 0x1p-1) (f32.const 0x1p0)) (f32.const 0x1p-126))
+
+;; Test for floating point tolerances observed in some GPUs.
+;; https://community.amd.com/thread/145582
+
+(module
+  (func $inverse (param $x f32) (result f32)
+    (f32.div (f32.const 1.0) (get_local $x))
+  )
+  (export "inverse" $inverse)
+)
+
+(assert_return (invoke "inverse" (f32.const 96.0)) (f32.const 0x1.555556p-7))