More floating point tests! (#282)

* Test more floating-point almost-identities.

* Convert several inexact floating-point literals to hexadecimal form.

* Add a testcase based on LLVM PR27036.

* Test for incorrect rounding on sqrt(4.0).

* Test another notable x87 sqrt case.

* Test 1/(1/x).

* Test algebraic factoring reversal.

* Test algebraic factoring.

* Test plain and Kahan summation.

* Test that negates are not folded away at the expense of negative zero.

* Test that x + -x is not folded away.

* Test that addition is not folded to multiplication with different rounding.

* Test the reinterpret conversions with more special values.

* Test demote(promote(x)).

* Test reinterpret cast with -1.

* Test an interesting division boundary case.

* Test the minimum valid value for trunc_u conversions.

* Test min and max with signaling NaNs.

* Test the least value with a positive quotient with the maximum value.

* Test the least value with a positive square.

* Test the least value with a finite reciprocal.

* Test that unaligned memory accesses don't canonicalize NaNs.

* Test that (x/y)/z is not optimized to x/(y*z).

* Test that (x/y)*(z/w) is not optimized to (x*z)/(y*w).

* Test that (x/z)+(y/z) is not optimized to (x+y)/z.

* Test that sqrt(x*x) is not optimized to abs(x).

* Test that sqrt(x)*sqrt(y) is not optimized to sqrt(x*y).

* Test that sqrt(x)/sqrt(y) is not optimized to sqrt(x/y).

* Test that (x*sqrt(y))/y is not optimized to x/sqrt(y).

* Fix spello.

* Correct a function name to match the test.

Author: sunfishcode

ml-proto/test/conversions.wast

@@ -107,10 +107,10 @@
 (assert_return (invoke "i32.trunc_s_f32" (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "i32.trunc_s_f32" (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "i32.trunc_s_f32" (f32.const 1.0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const 1.1)) (i32.const 1))
+(assert_return (invoke "i32.trunc_s_f32" (f32.const 0x1.19999ap+0)) (i32.const 1))
 (assert_return (invoke "i32.trunc_s_f32" (f32.const 1.5)) (i32.const 1))
 (assert_return (invoke "i32.trunc_s_f32" (f32.const -1.0)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const -1.1)) (i32.const -1))
+(assert_return (invoke "i32.trunc_s_f32" (f32.const -0x1.19999ap+0)) (i32.const -1))
 (assert_return (invoke "i32.trunc_s_f32" (f32.const -1.5)) (i32.const -1))
 (assert_return (invoke "i32.trunc_s_f32" (f32.const -1.9)) (i32.const -1))
 (assert_return (invoke "i32.trunc_s_f32" (f32.const -2.0)) (i32.const -2))
@@ -127,13 +127,14 @@
 (assert_return (invoke "i32.trunc_u_f32" (f32.const 0x1p-149)) (i32.const 0))
 (assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1p-149)) (i32.const 0))
 (assert_return (invoke "i32.trunc_u_f32" (f32.const 1.0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 1.1)) (i32.const 1))
+(assert_return (invoke "i32.trunc_u_f32" (f32.const 0x1.19999ap+0)) (i32.const 1))
 (assert_return (invoke "i32.trunc_u_f32" (f32.const 1.5)) (i32.const 1))
 (assert_return (invoke "i32.trunc_u_f32" (f32.const 1.9)) (i32.const 1))
 (assert_return (invoke "i32.trunc_u_f32" (f32.const 2.0)) (i32.const 2))
 (assert_return (invoke "i32.trunc_u_f32" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
 (assert_return (invoke "i32.trunc_u_f32" (f32.const 4294967040.0)) (i32.const -256))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const -0.9)) (i32.const 0))
+(assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1.ccccccp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i32.const 0))
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const 4294967296.0)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const -1.0)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const infinity)) "integer overflow")
@@ -145,10 +146,10 @@
 (assert_return (invoke "i32.trunc_s_f64" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "i32.trunc_s_f64" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "i32.trunc_s_f64" (f64.const 1.0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const 1.1)) (i32.const 1))
+(assert_return (invoke "i32.trunc_s_f64" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
 (assert_return (invoke "i32.trunc_s_f64" (f64.const 1.5)) (i32.const 1))
 (assert_return (invoke "i32.trunc_s_f64" (f64.const -1.0)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const -1.1)) (i32.const -1))
+(assert_return (invoke "i32.trunc_s_f64" (f64.const -0x1.199999999999ap+0)) (i32.const -1))
 (assert_return (invoke "i32.trunc_s_f64" (f64.const -1.5)) (i32.const -1))
 (assert_return (invoke "i32.trunc_s_f64" (f64.const -1.9)) (i32.const -1))
 (assert_return (invoke "i32.trunc_s_f64" (f64.const -2.0)) (i32.const -2))
@@ -165,13 +166,14 @@
 (assert_return (invoke "i32.trunc_u_f64" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "i32.trunc_u_f64" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
 (assert_return (invoke "i32.trunc_u_f64" (f64.const 1.0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 1.1)) (i32.const 1))
+(assert_return (invoke "i32.trunc_u_f64" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
 (assert_return (invoke "i32.trunc_u_f64" (f64.const 1.5)) (i32.const 1))
 (assert_return (invoke "i32.trunc_u_f64" (f64.const 1.9)) (i32.const 1))
 (assert_return (invoke "i32.trunc_u_f64" (f64.const 2.0)) (i32.const 2))
 (assert_return (invoke "i32.trunc_u_f64" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
 (assert_return (invoke "i32.trunc_u_f64" (f64.const 4294967295.0)) (i32.const -1))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const -0.9)) (i32.const 0))
+(assert_return (invoke "i32.trunc_u_f64" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_u_f64" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0))
 (assert_return (invoke "i32.trunc_u_f64" (f64.const 1e8)) (i32.const 100000000))
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const 4294967296.0)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const -1.0)) "integer overflow")
@@ -187,10 +189,10 @@
 (assert_return (invoke "i64.trunc_s_f32" (f32.const 0x1p-149)) (i64.const 0))
 (assert_return (invoke "i64.trunc_s_f32" (f32.const -0x1p-149)) (i64.const 0))
 (assert_return (invoke "i64.trunc_s_f32" (f32.const 1.0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const 1.1)) (i64.const 1))
+(assert_return (invoke "i64.trunc_s_f32" (f32.const 0x1.19999ap+0)) (i64.const 1))
 (assert_return (invoke "i64.trunc_s_f32" (f32.const 1.5)) (i64.const 1))
 (assert_return (invoke "i64.trunc_s_f32" (f32.const -1.0)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -1.1)) (i64.const -1))
+(assert_return (invoke "i64.trunc_s_f32" (f32.const -0x1.19999ap+0)) (i64.const -1))
 (assert_return (invoke "i64.trunc_s_f32" (f32.const -1.5)) (i64.const -1))
 (assert_return (invoke "i64.trunc_s_f32" (f32.const -1.9)) (i64.const -1))
 (assert_return (invoke "i64.trunc_s_f32" (f32.const -2.0)) (i64.const -2))
@@ -209,11 +211,12 @@
 (assert_return (invoke "i64.trunc_u_f32" (f32.const 0x1p-149)) (i64.const 0))
 (assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1p-149)) (i64.const 0))
 (assert_return (invoke "i64.trunc_u_f32" (f32.const 1.0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const 1.1)) (i64.const 1))
+(assert_return (invoke "i64.trunc_u_f32" (f32.const 0x1.19999ap+0)) (i64.const 1))
 (assert_return (invoke "i64.trunc_u_f32" (f32.const 1.5)) (i64.const 1))
 (assert_return (invoke "i64.trunc_u_f32" (f32.const 4294967296)) (i64.const 4294967296))
 (assert_return (invoke "i64.trunc_u_f32" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const -0.9)) (i64.const 0))
+(assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1.ccccccp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i64.const 0))
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const 18446744073709551616.0)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const -1.0)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const infinity)) "integer overflow")
@@ -225,10 +228,10 @@
 (assert_return (invoke "i64.trunc_s_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
 (assert_return (invoke "i64.trunc_s_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
 (assert_return (invoke "i64.trunc_s_f64" (f64.const 1.0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const 1.1)) (i64.const 1))
+(assert_return (invoke "i64.trunc_s_f64" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
 (assert_return (invoke "i64.trunc_s_f64" (f64.const 1.5)) (i64.const 1))
 (assert_return (invoke "i64.trunc_s_f64" (f64.const -1.0)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -1.1)) (i64.const -1))
+(assert_return (invoke "i64.trunc_s_f64" (f64.const -0x1.199999999999ap+0)) (i64.const -1))
 (assert_return (invoke "i64.trunc_s_f64" (f64.const -1.5)) (i64.const -1))
 (assert_return (invoke "i64.trunc_s_f64" (f64.const -1.9)) (i64.const -1))
 (assert_return (invoke "i64.trunc_s_f64" (f64.const -2.0)) (i64.const -2))
@@ -247,12 +250,13 @@
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 1.0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 1.1)) (i64.const 1))
+(assert_return (invoke "i64.trunc_u_f64" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 1.5)) (i64.const 1))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 4294967295)) (i64.const 0xffffffff))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 4294967296)) (i64.const 0x100000000))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 18446744073709549568.0)) (i64.const -2048))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const -0.9)) (i64.const 0))
+(assert_return (invoke "i64.trunc_u_f64" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_u_f64" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 1e8)) (i64.const 100000000))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 1e16)) (i64.const 10000000000000000))
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
@@ -393,18 +397,33 @@
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 0)) (f32.const 0.0))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 0x80000000)) (f32.const -0.0))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 1)) (f32.const 0x1p-149))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const -1)) (f32.const -nan:0x7fffff))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 0x1.b79a2ap-113))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -0x1p-149))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const infinity))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -infinity))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)) (f32.const nan))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)) (f32.const -nan))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffa00000)) (f32.const -nan:0x200000))
 
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0)) (f64.const 0.0))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 1)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const -1)) (f64.const -nan:0xfffffffffffff))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 0x0.00000499602d2p-1022))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const infinity))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -infinity))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)) (f64.const nan))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)) (f64.const -nan))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff4000000000000)) (f64.const -nan:0x4000000000000))
 
 (assert_return (invoke "i32.reinterpret_f32" (f32.const 0.0)) (i32.const 0))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const -0.0)) (i32.const 0x80000000))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x7fffff)) (i32.const -1))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1p-149)) (i32.const 0x80000001))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const 1.0)) (i32.const 1065353216))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const 3.1415926)) (i32.const 1078530010))
@@ -413,10 +432,14 @@
 (assert_return (invoke "i32.reinterpret_f32" (f32.const infinity)) (i32.const 0x7f800000))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const -infinity)) (i32.const 0xff800000))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const nan)) (i32.const 0x7fc00000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan)) (i32.const 0xffc00000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const nan:0x200000)) (i32.const 0x7fa00000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x200000)) (i32.const 0xffa00000))
 
 (assert_return (invoke "i64.reinterpret_f64" (f64.const 0.0)) (i64.const 0))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const -0.0)) (i64.const 0x8000000000000000))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 1))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0xfffffffffffff)) (i64.const -1))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0x8000000000000001))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const 1.0)) (i64.const 4607182418800017408))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const 3.14159265358979)) (i64.const 4614256656552045841))
@@ -425,3 +448,6 @@
 (assert_return (invoke "i64.reinterpret_f64" (f64.const infinity)) (i64.const 0x7ff0000000000000))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const -infinity)) (i64.const 0xfff0000000000000))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const nan)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan)) (i64.const 0xfff8000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const nan:0x4000000000000)) (i64.const 0x7ff4000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0x4000000000000)) (i64.const 0xfff4000000000000))