github.com/wasilibs/wazerox@v0.0.0-20240124024944-4923be63ab5f/internal/integration_test/spectest/v1/testdata/float_exprs.wast (about) 1 ;; Test interesting floating-point "expressions". These tests contain code 2 ;; patterns which tempt common value-changing optimizations. 3 4 ;; Test that x*y+z is not done with x87-style intermediate precision. 5 6 (module 7 (func (export "f64.no_contraction") (param $x f64) (param $y f64) (param $z f64) (result f64) 8 (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z))) 9 ) 10 11 (assert_return (invoke "f64.no_contraction" (f64.const -0x1.9e87ce14273afp-103) (f64.const 0x1.2515ad31db63ep+664) (f64.const 0x1.868c6685e6185p+533)) (f64.const -0x1.da94885b11493p+561)) 12 (assert_return (invoke "f64.no_contraction" (f64.const 0x1.da21c460a6f44p+52) (f64.const 0x1.60859d2e7714ap-321) (f64.const 0x1.e63f1b7b660e1p-302)) (f64.const 0x1.4672f256d1794p-268)) 13 (assert_return (invoke "f64.no_contraction" (f64.const -0x1.f3eaf43f327cp-594) (f64.const 0x1.dfcc009906b57p+533) (f64.const 0x1.5984e03c520a1p-104)) (f64.const -0x1.d4797fb3db166p-60)) 14 (assert_return (invoke "f64.no_contraction" (f64.const 0x1.dab6c772cb2e2p-69) (f64.const -0x1.d761663679a84p-101) (f64.const 0x1.f22f92c843226p-218)) (f64.const -0x1.b50d72dfcef68p-169)) 15 (assert_return (invoke "f64.no_contraction" (f64.const -0x1.87c5def1e4d3dp-950) (f64.const -0x1.50cd5dab2207fp+935) (f64.const 0x1.e629bd0da8c5dp-54)) (f64.const 0x1.01b6feb4e78a7p-14)) 16 17 ;; Test that x*y+z is not folded to fma. 18 19 (module 20 (func (export "f32.no_fma") (param $x f32) (param $y f32) (param $z f32) (result f32) 21 (f32.add (f32.mul (local.get $x) (local.get $y)) (local.get $z))) 22 (func (export "f64.no_fma") (param $x f64) (param $y f64) (param $z f64) (result f64) 23 (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z))) 24 ) 25 26 (assert_return (invoke "f32.no_fma" (f32.const 0x1.a78402p+124) (f32.const 0x1.cf8548p-23) (f32.const 0x1.992adap+107)) (f32.const 0x1.a5262cp+107)) 27 (assert_return (invoke "f32.no_fma" (f32.const 0x1.ed15a4p-28) (f32.const -0x1.613c72p-50) (f32.const 0x1.4757bp-88)) (f32.const -0x1.5406b8p-77)) 28 (assert_return (invoke "f32.no_fma" (f32.const 0x1.ae63a2p+37) (f32.const 0x1.b3a59ap-13) (f32.const 0x1.c16918p+10)) (f32.const 0x1.6e385cp+25)) 29 (assert_return (invoke "f32.no_fma" (f32.const 0x1.2a77fap-8) (f32.const -0x1.bb7356p+22) (f32.const -0x1.32be2ap+1)) (f32.const -0x1.0286d4p+15)) 30 (assert_return (invoke "f32.no_fma" (f32.const 0x1.298fb6p+126) (f32.const -0x1.03080cp-70) (f32.const -0x1.418de6p+34)) (f32.const -0x1.2d15c6p+56)) 31 (assert_return (invoke "f64.no_fma" (f64.const 0x1.ac357ff46eed4p+557) (f64.const 0x1.852c01a5e7297p+430) (f64.const -0x1.05995704eda8ap+987)) (f64.const 0x1.855d905d338ep+987)) 32 (assert_return (invoke "f64.no_fma" (f64.const 0x1.e2fd6bf32010cp+749) (f64.const 0x1.01c2238d405e4p-130) (f64.const 0x1.2ecc0db4b9f94p+573)) (f64.const 0x1.e64eb07e063bcp+619)) 33 (assert_return (invoke "f64.no_fma" (f64.const 0x1.92b7c7439ede3p-721) (f64.const -0x1.6aa97586d3de6p+1011) (f64.const 0x1.8de4823f6358ap+237)) (f64.const -0x1.1d4139fd20ecdp+291)) 34 (assert_return (invoke "f64.no_fma" (f64.const -0x1.466d30bddb453p-386) (f64.const -0x1.185a4d739c7aap+443) (f64.const 0x1.5f9c436fbfc7bp+55)) (f64.const 0x1.bd61a350fcc1ap+57)) 35 (assert_return (invoke "f64.no_fma" (f64.const 0x1.7e2c44058a799p+52) (f64.const 0x1.c73b71765b8b2p+685) (f64.const -0x1.16c641df0b108p+690)) (f64.const 0x1.53ccb53de0bd1p+738)) 36 37 ;; Test that x+0.0 is not folded to x. 38 ;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations". 39 40 (module 41 (func (export "f32.no_fold_add_zero") (param $x f32) (result f32) 42 (f32.add (local.get $x) (f32.const 0.0))) 43 (func (export "f64.no_fold_add_zero") (param $x f64) (result f64) 44 (f64.add (local.get $x) (f64.const 0.0))) 45 ) 46 47 (assert_return (invoke "f32.no_fold_add_zero" (f32.const -0.0)) (f32.const 0.0)) 48 (assert_return (invoke "f64.no_fold_add_zero" (f64.const -0.0)) (f64.const 0.0)) 49 (assert_return (invoke "f32.no_fold_add_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 50 (assert_return (invoke "f64.no_fold_add_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 51 52 ;; Test that 0.0 - x is not folded to -x. 53 54 (module 55 (func (export "f32.no_fold_zero_sub") (param $x f32) (result f32) 56 (f32.sub (f32.const 0.0) (local.get $x))) 57 (func (export "f64.no_fold_zero_sub") (param $x f64) (result f64) 58 (f64.sub (f64.const 0.0) (local.get $x))) 59 ) 60 61 (assert_return (invoke "f32.no_fold_zero_sub" (f32.const 0.0)) (f32.const 0.0)) 62 (assert_return (invoke "f64.no_fold_zero_sub" (f64.const 0.0)) (f64.const 0.0)) 63 (assert_return (invoke "f32.no_fold_zero_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 64 (assert_return (invoke "f64.no_fold_zero_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 65 66 ;; Test that x - 0.0 is not folded to x. 67 68 (module 69 (func (export "f32.no_fold_sub_zero") (param $x f32) (result f32) 70 (f32.sub (local.get $x) (f32.const 0.0))) 71 (func (export "f64.no_fold_sub_zero") (param $x f64) (result f64) 72 (f64.sub (local.get $x) (f64.const 0.0))) 73 ) 74 75 (assert_return (invoke "f32.no_fold_sub_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 76 (assert_return (invoke "f64.no_fold_sub_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 77 78 ;; Test that x*0.0 is not folded to 0.0. 79 80 (module 81 (func (export "f32.no_fold_mul_zero") (param $x f32) (result f32) 82 (f32.mul (local.get $x) (f32.const 0.0))) 83 (func (export "f64.no_fold_mul_zero") (param $x f64) (result f64) 84 (f64.mul (local.get $x) (f64.const 0.0))) 85 ) 86 87 (assert_return (invoke "f32.no_fold_mul_zero" (f32.const -0.0)) (f32.const -0.0)) 88 (assert_return (invoke "f32.no_fold_mul_zero" (f32.const -1.0)) (f32.const -0.0)) 89 (assert_return (invoke "f32.no_fold_mul_zero" (f32.const -2.0)) (f32.const -0.0)) 90 (assert_return (invoke "f32.no_fold_mul_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 91 (assert_return (invoke "f64.no_fold_mul_zero" (f64.const -0.0)) (f64.const -0.0)) 92 (assert_return (invoke "f64.no_fold_mul_zero" (f64.const -1.0)) (f64.const -0.0)) 93 (assert_return (invoke "f64.no_fold_mul_zero" (f64.const -2.0)) (f64.const -0.0)) 94 (assert_return (invoke "f64.no_fold_mul_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 95 96 ;; Test that x*1.0 is not folded to x. 97 ;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations". 98 99 (module 100 (func (export "f32.no_fold_mul_one") (param $x f32) (result f32) 101 (f32.mul (local.get $x) (f32.const 1.0))) 102 (func (export "f64.no_fold_mul_one") (param $x f64) (result f64) 103 (f64.mul (local.get $x) (f64.const 1.0))) 104 ) 105 106 (assert_return (invoke "f32.no_fold_mul_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 107 (assert_return (invoke "f64.no_fold_mul_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 108 109 ;; Test that 0.0/x is not folded to 0.0. 110 111 (module 112 (func (export "f32.no_fold_zero_div") (param $x f32) (result f32) 113 (f32.div (f32.const 0.0) (local.get $x))) 114 (func (export "f64.no_fold_zero_div") (param $x f64) (result f64) 115 (f64.div (f64.const 0.0) (local.get $x))) 116 ) 117 118 (assert_return (invoke "f32.no_fold_zero_div" (f32.const 0.0)) (f32.const nan:canonical)) 119 (assert_return (invoke "f32.no_fold_zero_div" (f32.const -0.0)) (f32.const nan:canonical)) 120 (assert_return (invoke "f32.no_fold_zero_div" (f32.const nan)) (f32.const nan:canonical)) 121 (assert_return (invoke "f32.no_fold_zero_div" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 122 (assert_return (invoke "f64.no_fold_zero_div" (f64.const 0.0)) (f64.const nan:canonical)) 123 (assert_return (invoke "f64.no_fold_zero_div" (f64.const -0.0)) (f64.const nan:canonical)) 124 (assert_return (invoke "f64.no_fold_zero_div" (f64.const nan)) (f64.const nan:canonical)) 125 (assert_return (invoke "f64.no_fold_zero_div" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 126 127 ;; Test that x/1.0 is not folded to x. 128 129 (module 130 (func (export "f32.no_fold_div_one") (param $x f32) (result f32) 131 (f32.div (local.get $x) (f32.const 1.0))) 132 (func (export "f64.no_fold_div_one") (param $x f64) (result f64) 133 (f64.div (local.get $x) (f64.const 1.0))) 134 ) 135 136 (assert_return (invoke "f32.no_fold_div_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 137 (assert_return (invoke "f64.no_fold_div_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 138 139 ;; Test that x/-1.0 is not folded to -x. 140 141 (module 142 (func (export "f32.no_fold_div_neg1") (param $x f32) (result f32) 143 (f32.div (local.get $x) (f32.const -1.0))) 144 (func (export "f64.no_fold_div_neg1") (param $x f64) (result f64) 145 (f64.div (local.get $x) (f64.const -1.0))) 146 ) 147 148 (assert_return (invoke "f32.no_fold_div_neg1" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 149 (assert_return (invoke "f64.no_fold_div_neg1" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 150 151 ;; Test that -0.0 - x is not folded to -x. 152 153 (module 154 (func (export "f32.no_fold_neg0_sub") (param $x f32) (result f32) 155 (f32.sub (f32.const -0.0) (local.get $x))) 156 (func (export "f64.no_fold_neg0_sub") (param $x f64) (result f64) 157 (f64.sub (f64.const -0.0) (local.get $x))) 158 ) 159 160 (assert_return (invoke "f32.no_fold_neg0_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 161 (assert_return (invoke "f64.no_fold_neg0_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 162 163 ;; Test that -1.0 * x is not folded to -x. 164 165 (module 166 (func (export "f32.no_fold_neg1_mul") (param $x f32) (result f32) 167 (f32.mul (f32.const -1.0) (local.get $x))) 168 (func (export "f64.no_fold_neg1_mul") (param $x f64) (result f64) 169 (f64.mul (f64.const -1.0) (local.get $x))) 170 ) 171 172 (assert_return (invoke "f32.no_fold_neg1_mul" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 173 (assert_return (invoke "f64.no_fold_neg1_mul" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 174 175 ;; Test that x == x is not folded to true. 176 177 (module 178 (func (export "f32.no_fold_eq_self") (param $x f32) (result i32) 179 (f32.eq (local.get $x) (local.get $x))) 180 (func (export "f64.no_fold_eq_self") (param $x f64) (result i32) 181 (f64.eq (local.get $x) (local.get $x))) 182 ) 183 184 (assert_return (invoke "f32.no_fold_eq_self" (f32.const nan)) (i32.const 0)) 185 (assert_return (invoke "f64.no_fold_eq_self" (f64.const nan)) (i32.const 0)) 186 187 ;; Test that x != x is not folded to false. 188 189 (module 190 (func (export "f32.no_fold_ne_self") (param $x f32) (result i32) 191 (f32.ne (local.get $x) (local.get $x))) 192 (func (export "f64.no_fold_ne_self") (param $x f64) (result i32) 193 (f64.ne (local.get $x) (local.get $x))) 194 ) 195 196 (assert_return (invoke "f32.no_fold_ne_self" (f32.const nan)) (i32.const 1)) 197 (assert_return (invoke "f64.no_fold_ne_self" (f64.const nan)) (i32.const 1)) 198 199 ;; Test that x - x is not folded to 0.0. 200 201 (module 202 (func (export "f32.no_fold_sub_self") (param $x f32) (result f32) 203 (f32.sub (local.get $x) (local.get $x))) 204 (func (export "f64.no_fold_sub_self") (param $x f64) (result f64) 205 (f64.sub (local.get $x) (local.get $x))) 206 ) 207 208 (assert_return (invoke "f32.no_fold_sub_self" (f32.const inf)) (f32.const nan:canonical)) 209 (assert_return (invoke "f32.no_fold_sub_self" (f32.const nan)) (f32.const nan:canonical)) 210 (assert_return (invoke "f64.no_fold_sub_self" (f64.const inf)) (f64.const nan:canonical)) 211 (assert_return (invoke "f64.no_fold_sub_self" (f64.const nan)) (f64.const nan:canonical)) 212 213 ;; Test that x / x is not folded to 1.0. 214 215 (module 216 (func (export "f32.no_fold_div_self") (param $x f32) (result f32) 217 (f32.div (local.get $x) (local.get $x))) 218 (func (export "f64.no_fold_div_self") (param $x f64) (result f64) 219 (f64.div (local.get $x) (local.get $x))) 220 ) 221 222 (assert_return (invoke "f32.no_fold_div_self" (f32.const inf)) (f32.const nan:canonical)) 223 (assert_return (invoke "f32.no_fold_div_self" (f32.const nan)) (f32.const nan:canonical)) 224 (assert_return (invoke "f32.no_fold_div_self" (f32.const 0.0)) (f32.const nan:canonical)) 225 (assert_return (invoke "f32.no_fold_div_self" (f32.const -0.0)) (f32.const nan:canonical)) 226 (assert_return (invoke "f64.no_fold_div_self" (f64.const inf)) (f64.const nan:canonical)) 227 (assert_return (invoke "f64.no_fold_div_self" (f64.const nan)) (f64.const nan:canonical)) 228 (assert_return (invoke "f64.no_fold_div_self" (f64.const 0.0)) (f64.const nan:canonical)) 229 (assert_return (invoke "f64.no_fold_div_self" (f64.const -0.0)) (f64.const nan:canonical)) 230 231 ;; Test that x/3 is not folded to x*(1/3). 232 233 (module 234 (func (export "f32.no_fold_div_3") (param $x f32) (result f32) 235 (f32.div (local.get $x) (f32.const 3.0))) 236 (func (export "f64.no_fold_div_3") (param $x f64) (result f64) 237 (f64.div (local.get $x) (f64.const 3.0))) 238 ) 239 240 (assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.359c26p+50)) (f32.const -0x1.9cd032p+48)) 241 (assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.e45646p+93)) (f32.const -0x1.42e42ep+92)) 242 (assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.2a3916p-83)) (f32.const -0x1.8da172p-85)) 243 (assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.1f8b38p-124)) (f32.const -0x1.7f644ap-126)) 244 (assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.d64f64p-56)) (f32.const -0x1.398a42p-57)) 245 (assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.a8a88d29e2cc3p+632)) (f64.const -0x1.1b1b08c69732dp+631)) 246 (assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.bcf52dc950972p-167)) (f64.const -0x1.28a373db8b0f7p-168)) 247 (assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.bd3c0d989f7a4p-874)) (f64.const 0x1.28d2b3bb14fc3p-875)) 248 (assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.0138bf530a53cp+1007)) (f64.const -0x1.56f6546eb86fbp+1005)) 249 (assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.052b87f9d794dp+415)) (f64.const 0x1.5c3a0aa274c67p+413)) 250 251 ;; Test that (x*z)+(y*z) is not folded to (x+y)*z. 252 253 (module 254 (func (export "f32.no_factor") (param $x f32) (param $y f32) (param $z f32) (result f32) 255 (f32.add (f32.mul (local.get $x) (local.get $z)) (f32.mul (local.get $y) (local.get $z)))) 256 (func (export "f64.no_factor") (param $x f64) (param $y f64) (param $z f64) (result f64) 257 (f64.add (f64.mul (local.get $x) (local.get $z)) (f64.mul (local.get $y) (local.get $z)))) 258 ) 259 260 (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)) 261 (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)) 262 (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)) 263 (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)) 264 (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)) 265 (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)) 266 (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)) 267 (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)) 268 (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)) 269 (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)) 270 271 ;; Test that (x+y)*z is not folded to (x*z)+(y*z). 272 273 (module 274 (func (export "f32.no_distribute") (param $x f32) (param $y f32) (param $z f32) (result f32) 275 (f32.mul (f32.add (local.get $x) (local.get $y)) (local.get $z))) 276 (func (export "f64.no_distribute") (param $x f64) (param $y f64) (param $z f64) (result f64) 277 (f64.mul (f64.add (local.get $x) (local.get $y)) (local.get $z))) 278 ) 279 280 (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)) 281 (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)) 282 (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)) 283 (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)) 284 (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)) 285 (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)) 286 (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)) 287 (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)) 288 (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)) 289 (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)) 290 291 ;; Test that x*(y/z) is not folded to (x*y)/z. 292 293 (module 294 (func (export "f32.no_regroup_div_mul") (param $x f32) (param $y f32) (param $z f32) (result f32) 295 (f32.mul (local.get $x) (f32.div (local.get $y) (local.get $z)))) 296 (func (export "f64.no_regroup_div_mul") (param $x f64) (param $y f64) (param $z f64) (result f64) 297 (f64.mul (local.get $x) (f64.div (local.get $y) (local.get $z)))) 298 ) 299 300 (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)) 301 (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)) 302 (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)) 303 (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)) 304 (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)) 305 (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)) 306 (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)) 307 (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 inf)) 308 (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)) 309 (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)) 310 311 ;; Test that (x*y)/z is not folded to x*(y/z). 312 313 (module 314 (func (export "f32.no_regroup_mul_div") (param $x f32) (param $y f32) (param $z f32) (result f32) 315 (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $z))) 316 (func (export "f64.no_regroup_mul_div") (param $x f64) (param $y f64) (param $z f64) (result f64) 317 (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $z))) 318 ) 319 320 (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)) 321 (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)) 322 (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)) 323 (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)) 324 (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 -inf)) 325 (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)) 326 (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)) 327 (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)) 328 (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 -inf)) 329 (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)) 330 331 ;; Test that x+y+z+w is not reassociated. 332 333 (module 334 (func (export "f32.no_reassociate_add") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32) 335 (f32.add (f32.add (f32.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w))) 336 (func (export "f64.no_reassociate_add") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64) 337 (f64.add (f64.add (f64.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w))) 338 ) 339 340 (assert_return (invoke "f32.no_reassociate_add" (f32.const -0x1.5f7ddcp+44) (f32.const 0x1.854e1p+34) (f32.const -0x1.b2068cp+47) (f32.const -0x1.209692p+41)) (f32.const -0x1.e26c76p+47)) 341 (assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.da3b78p-9) (f32.const -0x1.4312fap-7) (f32.const 0x1.0395e6p-4) (f32.const -0x1.6d5ea6p-7)) (f32.const 0x1.78b31ap-5)) 342 (assert_return (invoke "f32.no_reassociate_add" (f32.const -0x1.fdb93ap+34) (f32.const -0x1.b6fce6p+41) (f32.const 0x1.c131d8p+44) (f32.const 0x1.8835b6p+38)) (f32.const 0x1.8ff3a2p+44)) 343 (assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.1739fcp+47) (f32.const 0x1.a4b186p+49) (f32.const -0x1.0c623cp+35) (f32.const 0x1.16a102p+51)) (f32.const 0x1.913ff6p+51)) 344 (assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.733cfap+108) (f32.const -0x1.38d30cp+108) (f32.const 0x1.2f5854p+105) (f32.const -0x1.ccb058p+94)) (f32.const 0x1.813716p+106)) 345 (assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.697a4d9ff19a6p+841) (f64.const 0x1.b305466238397p+847) (f64.const 0x1.e0b2d9bfb4e72p+855) (f64.const -0x1.6e1f3ae2b06bbp+857)) (f64.const -0x1.eb0e5936f087ap+856)) 346 (assert_return (invoke "f64.no_reassociate_add" (f64.const 0x1.00ef6746b30e1p-543) (f64.const 0x1.cc1cfafdf3fe1p-544) (f64.const -0x1.f7726df3ecba6p-543) (f64.const -0x1.b26695f99d307p-594)) (f64.const -0x1.074892e3fad76p-547)) 347 (assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.e807b3bd6d854p+440) (f64.const 0x1.cedae26c2c5fp+407) (f64.const -0x1.00ab6e1442541p+437) (f64.const 0x1.28538a55997bdp+397)) (f64.const -0x1.040e90bf871ebp+441)) 348 (assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.ba2b6f35a2402p-317) (f64.const 0x1.ad1c3fea7cd9ep-307) (f64.const -0x1.93aace2bf1261p-262) (f64.const 0x1.9fddbe472847ep-260)) (f64.const 0x1.3af30abc2c01bp-260)) 349 (assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.ccb9c6092fb1dp+641) (f64.const -0x1.4b7c28c108244p+614) (f64.const 0x1.8a7cefef4bde1p+646) (f64.const -0x1.901b28b08b482p+644)) (f64.const 0x1.1810579194126p+646)) 350 351 ;; Test that x*y*z*w is not reassociated. 352 353 (module 354 (func (export "f32.no_reassociate_mul") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32) 355 (f32.mul (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w))) 356 (func (export "f64.no_reassociate_mul") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64) 357 (f64.mul (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w))) 358 ) 359 360 (assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.950ba8p-116) (f32.const 0x1.efdacep-33) (f32.const -0x1.5f9bcp+102) (f32.const 0x1.f04508p-56)) (f32.const -0x1.ff356ep-101)) 361 (assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.5990aep-56) (f32.const -0x1.7dfb04p+102) (f32.const -0x1.4f774ap-125) (f32.const -0x1.595fe6p+70)) (f32.const -0x1.c7c8fcp-8)) 362 (assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.6ad9a4p-48) (f32.const -0x1.9138aap+55) (f32.const -0x1.4a774ep-40) (f32.const 0x1.1ff08p+76)) (f32.const 0x1.9cd8ecp+44)) 363 (assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.e1caecp-105) (f32.const 0x1.af0dd2p+77) (f32.const -0x1.016eep+56) (f32.const -0x1.ab70d6p+59)) (f32.const 0x1.54870ep+89)) 364 (assert_return (invoke "f32.no_reassociate_mul" (f32.const -0x1.3b1dcp-99) (f32.const 0x1.4e5a34p-49) (f32.const -0x1.38ba5ap+3) (f32.const 0x1.7fb8eep+59)) (f32.const 0x1.5bbf98p-85)) 365 (assert_return (invoke "f64.no_reassociate_mul" (f64.const -0x1.e7842ab7181p-667) (f64.const -0x1.fabf40ceeceafp+990) (f64.const -0x1.1a38a825ab01ap-376) (f64.const -0x1.27e8ea469b14fp+664)) (f64.const 0x1.336eb428af4f3p+613)) 366 (assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.4ca2292a6acbcp+454) (f64.const 0x1.6ffbab850089ap-516) (f64.const -0x1.547c32e1f5b93p-899) (f64.const -0x1.c7571d9388375p+540)) (f64.const 0x1.1ac796954fc1p-419)) 367 (assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.73881a52e0401p-501) (f64.const -0x1.1b68dd9efb1a7p+788) (f64.const 0x1.d1c5e6a3eb27cp-762) (f64.const -0x1.56cb2fcc7546fp+88)) (f64.const 0x1.f508db92c34efp-386)) 368 (assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.2efa87859987cp+692) (f64.const 0x1.68e4373e241p-423) (f64.const 0x1.4e2d0fb383a57p+223) (f64.const -0x1.301d3265c737bp-23)) (f64.const -0x1.4b2b6c393f30cp+470)) 369 (assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.1013f7498b95fp-234) (f64.const 0x1.d2d1c36fff138p-792) (f64.const -0x1.cbf1824ea7bfdp+728) (f64.const -0x1.440da9c8b836dp-599)) (f64.const 0x1.1a16512881c91p-895)) 370 371 ;; Test that x/0 is not folded away. 372 373 (module 374 (func (export "f32.no_fold_div_0") (param $x f32) (result f32) 375 (f32.div (local.get $x) (f32.const 0.0))) 376 (func (export "f64.no_fold_div_0") (param $x f64) (result f64) 377 (f64.div (local.get $x) (f64.const 0.0))) 378 ) 379 380 (assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const inf)) 381 (assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -inf)) 382 (assert_return (invoke "f32.no_fold_div_0" (f32.const inf)) (f32.const inf)) 383 (assert_return (invoke "f32.no_fold_div_0" (f32.const -inf)) (f32.const -inf)) 384 (assert_return (invoke "f32.no_fold_div_0" (f32.const 0)) (f32.const nan:canonical)) 385 (assert_return (invoke "f32.no_fold_div_0" (f32.const -0)) (f32.const nan:canonical)) 386 (assert_return (invoke "f32.no_fold_div_0" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 387 (assert_return (invoke "f32.no_fold_div_0" (f32.const nan)) (f32.const nan:canonical)) 388 (assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const inf)) 389 (assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -inf)) 390 (assert_return (invoke "f64.no_fold_div_0" (f64.const inf)) (f64.const inf)) 391 (assert_return (invoke "f64.no_fold_div_0" (f64.const -inf)) (f64.const -inf)) 392 (assert_return (invoke "f64.no_fold_div_0" (f64.const 0)) (f64.const nan:canonical)) 393 (assert_return (invoke "f64.no_fold_div_0" (f64.const -0)) (f64.const nan:canonical)) 394 (assert_return (invoke "f64.no_fold_div_0" (f64.const nan)) (f64.const nan:canonical)) 395 (assert_return (invoke "f64.no_fold_div_0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 396 397 ;; Test that x/-0 is not folded away. 398 399 (module 400 (func (export "f32.no_fold_div_neg0") (param $x f32) (result f32) 401 (f32.div (local.get $x) (f32.const -0.0))) 402 (func (export "f64.no_fold_div_neg0") (param $x f64) (result f64) 403 (f64.div (local.get $x) (f64.const -0.0))) 404 ) 405 406 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -inf)) 407 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const inf)) 408 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const inf)) (f32.const -inf)) 409 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const -inf)) (f32.const inf)) 410 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const 0)) (f32.const nan:canonical)) 411 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const -0)) (f32.const nan:canonical)) 412 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 413 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan)) (f32.const nan:canonical)) 414 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -inf)) 415 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const inf)) 416 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const inf)) (f64.const -inf)) 417 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const -inf)) (f64.const inf)) 418 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const 0)) (f64.const nan:canonical)) 419 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const -0)) (f64.const nan:canonical)) 420 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan)) (f64.const nan:canonical)) 421 (assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic)) 422 423 ;; Test that sqrt(x*x+y*y) is not folded to hypot. 424 425 (module 426 (func (export "f32.no_fold_to_hypot") (param $x f32) (param $y f32) (result f32) 427 (f32.sqrt (f32.add (f32.mul (local.get $x) (local.get $x)) 428 (f32.mul (local.get $y) (local.get $y))))) 429 (func (export "f64.no_fold_to_hypot") (param $x f64) (param $y f64) (result f64) 430 (f64.sqrt (f64.add (f64.mul (local.get $x) (local.get $x)) 431 (f64.mul (local.get $y) (local.get $y))))) 432 ) 433 434 (assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.c2f338p-81) (f32.const 0x1.401b5ep-68)) (f32.const 0x1.401cccp-68)) 435 (assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.c38d1p-71) (f32.const -0x1.359ddp-107)) (f32.const 0x1.c36a62p-71)) 436 (assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.99e0cap-114) (f32.const -0x1.ed0c6cp-69)) (f32.const 0x1.ed0e48p-69)) 437 (assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.1b6ceap+5) (f32.const 0x1.5440bep+17)) (f32.const 0x1.5440cp+17)) 438 (assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.8f019ep-76) (f32.const -0x1.182308p-71)) (f32.const 0x1.17e2bcp-71)) 439 (assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.1a0ac4f7c8711p-636) (f64.const 0x1.1372ebafff551p-534)) (f64.const 0x1.13463fa37014ep-534)) 440 (assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.b793512167499p+395) (f64.const -0x1.11cbc52af4c36p+410)) (f64.const 0x1.11cbc530783a2p+410)) 441 (assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.76777f44ff40bp-536) (f64.const -0x1.c3896e4dc1fbp-766)) (f64.const 0x1.8p-536)) 442 (assert_return (invoke "f64.no_fold_to_hypot" (f64.const -0x1.889ac72cc6b5dp-521) (f64.const 0x1.8d7084e659f3bp-733)) (f64.const 0x1.889ac72ca843ap-521)) 443 (assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.5ee588c02cb08p-670) (f64.const -0x1.05ce25788d9ecp-514)) (f64.const 0x1.05ce25788d9dfp-514)) 444 445 ;; Test that 1.0/x isn't approximated. 446 447 (module 448 (func (export "f32.no_approximate_reciprocal") (param $x f32) (result f32) 449 (f32.div (f32.const 1.0) (local.get $x))) 450 ) 451 452 (assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.2900b6p-10)) (f32.const -0x1.b950d4p+9)) 453 (assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.e7212p+127)) (f32.const 0x1.0d11f8p-128)) 454 (assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.42a466p-93)) (f32.const -0x1.963ee6p+92)) 455 (assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.5d0c32p+76)) (f32.const 0x1.778362p-77)) 456 (assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.601de2p-82)) (f32.const -0x1.743d7ep+81)) 457 458 ;; Test that 1.0/sqrt(x) isn't approximated or fused. 459 460 (module 461 (func (export "f32.no_approximate_reciprocal_sqrt") (param $x f32) (result f32) 462 (f32.div (f32.const 1.0) (f32.sqrt (local.get $x)))) 463 (func (export "f64.no_fuse_reciprocal_sqrt") (param $x f64) (result f64) 464 (f64.div (f64.const 1.0) (f64.sqrt (local.get $x)))) 465 ) 466 467 (assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.6af12ap-43)) (f32.const 0x1.300ed4p+21)) 468 (assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.e82fc6p-8)) (f32.const 0x1.72c376p+3)) 469 (assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.b9fa9cp-66)) (f32.const 0x1.85a9bap+32)) 470 (assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.f4f546p-44)) (f32.const 0x1.6e01c2p+21)) 471 (assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.5da7aap-86)) (f32.const 0x1.b618cap+42)) 472 473 (assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.1568a63b55fa3p+889)) (f64.const 0x1.5bc9c74c9952p-445)) 474 (assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.239fcd0939cafp+311)) (f64.const 0x1.5334a922b4818p-156)) 475 (assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.6e36a24e11054p+104)) (f64.const 0x1.ac13f20977f29p-53)) 476 (assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.23ee173219f83p+668)) (f64.const 0x1.df753e055862dp-335)) 477 (assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.b30f74caf9babp+146)) (f64.const 0x1.88bfc3d1764a9p-74)) 478 479 ;; Test that sqrt(1.0/x) isn't approximated. 480 481 (module 482 (func (export "f32.no_approximate_sqrt_reciprocal") (param $x f32) (result f32) 483 (f32.sqrt (f32.div (f32.const 1.0) (local.get $x)))) 484 ) 485 486 (assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.a4c986p+60)) (f32.const 0x1.8f5ac6p-31)) 487 (assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.50511ep-9)) (f32.const 0x1.3bdd46p+4)) 488 (assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.125ec2p+69)) (f32.const 0x1.5db572p-35)) 489 (assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.ba4c5p+13)) (f32.const 0x1.136f16p-7)) 490 (assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.4a5be2p+104)) (f32.const 0x1.c2b5bp-53)) 491 492 ;; Test that converting i32/i64 to f32/f64 and back isn't folded away. 493 494 (module 495 (func (export "i32.no_fold_f32_s") (param i32) (result i32) 496 (i32.trunc_f32_s (f32.convert_i32_s (local.get 0)))) 497 (func (export "i32.no_fold_f32_u") (param i32) (result i32) 498 (i32.trunc_f32_u (f32.convert_i32_u (local.get 0)))) 499 (func (export "i64.no_fold_f64_s") (param i64) (result i64) 500 (i64.trunc_f64_s (f64.convert_i64_s (local.get 0)))) 501 (func (export "i64.no_fold_f64_u") (param i64) (result i64) 502 (i64.trunc_f64_u (f64.convert_i64_u (local.get 0)))) 503 ) 504 505 (assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000000)) (i32.const 0x1000000)) 506 (assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000001)) (i32.const 0x1000000)) 507 (assert_return (invoke "i32.no_fold_f32_s" (i32.const 0xf0000010)) (i32.const 0xf0000010)) 508 509 (assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000000)) (i32.const 0x1000000)) 510 (assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000001)) (i32.const 0x1000000)) 511 (assert_return (invoke "i32.no_fold_f32_u" (i32.const 0xf0000010)) (i32.const 0xf0000000)) 512 513 (assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000000)) (i64.const 0x20000000000000)) 514 (assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000001)) (i64.const 0x20000000000000)) 515 (assert_return (invoke "i64.no_fold_f64_s" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000400)) 516 517 (assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000000)) (i64.const 0x20000000000000)) 518 (assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000001)) (i64.const 0x20000000000000)) 519 (assert_return (invoke "i64.no_fold_f64_u" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000000)) 520 521 ;; Test that x+y-y is not folded to x. 522 523 (module 524 (func (export "f32.no_fold_add_sub") (param $x f32) (param $y f32) (result f32) 525 (f32.sub (f32.add (local.get $x) (local.get $y)) (local.get $y))) 526 (func (export "f64.no_fold_add_sub") (param $x f64) (param $y f64) (result f64) 527 (f64.sub (f64.add (local.get $x) (local.get $y)) (local.get $y))) 528 ) 529 530 (assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.b553e4p-47) (f32.const -0x1.67db2cp-26)) (f32.const 0x1.cp-47)) 531 (assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.a884dp-23) (f32.const 0x1.f2ae1ep-19)) (f32.const -0x1.a884ep-23)) 532 (assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.fc04fp+82) (f32.const -0x1.65403ap+101)) (f32.const -0x1p+83)) 533 (assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.870fa2p-78) (f32.const 0x1.c54916p-56)) (f32.const 0x1.8p-78)) 534 (assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.17e966p-108) (f32.const -0x1.5fa61ap-84)) (f32.const -0x1p-107)) 535 536 (assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1053ea172dba8p-874) (f64.const 0x1.113c413408ac8p-857)) (f64.const -0x1.1053ea172p-874)) 537 (assert_return (invoke "f64.no_fold_add_sub" (f64.const 0x1.e377d54807972p-546) (f64.const 0x1.040a0a4d1ff7p-526)) (f64.const 0x1.e377d548p-546)) 538 (assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.75f53cd926b62p-30) (f64.const -0x1.66b176e602bb5p-3)) (f64.const -0x1.75f53dp-30)) 539 (assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.c450ff28332ap-341) (f64.const 0x1.15a5855023baep-305)) (f64.const -0x1.c451p-341)) 540 (assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1ad4a596d3ea8p-619) (f64.const -0x1.17d81a41c0ea8p-588)) (f64.const -0x1.1ad4a8p-619)) 541 542 ;; Test that x-y+y is not folded to x. 543 544 (module 545 (func (export "f32.no_fold_sub_add") (param $x f32) (param $y f32) (result f32) 546 (f32.add (f32.sub (local.get $x) (local.get $y)) (local.get $y))) 547 (func (export "f64.no_fold_sub_add") (param $x f64) (param $y f64) (result f64) 548 (f64.add (f64.sub (local.get $x) (local.get $y)) (local.get $y))) 549 ) 550 551 (assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.523cb8p+9) (f32.const 0x1.93096cp+8)) (f32.const -0x1.523cbap+9)) 552 (assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.a31a1p-111) (f32.const 0x1.745efp-95)) (f32.const -0x1.a4p-111)) 553 (assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.3d5328p+26) (f32.const 0x1.58567p+35)) (f32.const 0x1.3d54p+26)) 554 (assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.374e26p-39) (f32.const -0x1.66a5p-27)) (f32.const 0x1.374p-39)) 555 (assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.320facp-3) (f32.const -0x1.ac069ap+14)) (f32.const 0x1.34p-3)) 556 557 (assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.8f92aad2c9b8dp+255) (f64.const -0x1.08cd4992266cbp+259)) (f64.const 0x1.8f92aad2c9b9p+255)) 558 (assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.5aaff55742c8bp-666) (f64.const 0x1.8f5f47181f46dp-647)) (f64.const 0x1.5aaff5578p-666)) 559 (assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.21bc52967a98dp+251) (f64.const -0x1.fcffaa32d0884p+300)) (f64.const 0x1.2p+251)) 560 (assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.9c78361f47374p-26) (f64.const -0x1.69d69f4edc61cp-13)) (f64.const 0x1.9c78361f48p-26)) 561 (assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.4dbe68e4afab2p-367) (f64.const -0x1.dc24e5b39cd02p-361)) (f64.const 0x1.4dbe68e4afacp-367)) 562 563 ;; Test that x*y/y is not folded to x. 564 565 (module 566 (func (export "f32.no_fold_mul_div") (param $x f32) (param $y f32) (result f32) 567 (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $y))) 568 (func (export "f64.no_fold_mul_div") (param $x f64) (param $y f64) (result f64) 569 (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $y))) 570 ) 571 572 (assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.cd859ap+54) (f32.const 0x1.6ca936p-47)) (f32.const -0x1.cd8598p+54)) 573 (assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.0b56b8p-26) (f32.const 0x1.48264cp-106)) (f32.const -0x1.0b56a4p-26)) 574 (assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.e7555cp-48) (f32.const -0x1.9161cp+48)) (f32.const -0x1.e7555ap-48)) 575 (assert_return (invoke "f32.no_fold_mul_div" (f32.const 0x1.aaa50ep+52) (f32.const -0x1.dfb39ep+60)) (f32.const 0x1.aaa50cp+52)) 576 (assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.2b7dfap-92) (f32.const -0x1.7c4ca6p-37)) (f32.const -0x1.2b7dfep-92)) 577 578 (assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.3d79ff4118a1ap-837) (f64.const -0x1.b8b5dda31808cp-205)) (f64.const -0x1.3d79ff412263ep-837)) 579 (assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.f894d1ee6b3a4p+384) (f64.const 0x1.8c2606d03d58ap+585)) (f64.const 0x1.f894d1ee6b3a5p+384)) 580 (assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.a022260acc993p+238) (f64.const -0x1.5fbc128fc8e3cp-552)) (f64.const -0x1.a022260acc992p+238)) 581 (assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.9d4b8ed174f54p-166) (f64.const 0x1.ee3d467aeeac6p-906)) (f64.const 0x1.8dcc95a053b2bp-166)) 582 (assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.e95ea897cdcd4p+660) (f64.const -0x1.854d5df085f2ep-327)) (f64.const -0x1.e95ea897cdcd5p+660)) 583 584 ;; Test that x/y*y is not folded to x. 585 586 (module 587 (func (export "f32.no_fold_div_mul") (param $x f32) (param $y f32) (result f32) 588 (f32.mul (f32.div (local.get $x) (local.get $y)) (local.get $y))) 589 (func (export "f64.no_fold_div_mul") (param $x f64) (param $y f64) (result f64) 590 (f64.mul (f64.div (local.get $x) (local.get $y)) (local.get $y))) 591 ) 592 593 (assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.dc6364p+38) (f32.const 0x1.d630ecp+29)) (f32.const -0x1.dc6362p+38)) 594 (assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.1f9836p-52) (f32.const -0x1.16c4e4p-18)) (f32.const -0x1.1f9838p-52)) 595 (assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.c5972cp-126) (f32.const -0x1.d6659ep+7)) (f32.const 0x1.c5980ep-126)) 596 (assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.2e3a9ep-74) (f32.const -0x1.353994p+59)) (f32.const -0x1.2e3a4p-74)) 597 (assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.d96b82p-98) (f32.const 0x1.95d908p+27)) (f32.const 0x1.d96b84p-98)) 598 599 (assert_return (invoke "f64.no_fold_div_mul" (f64.const 0x1.d01f913a52481p-876) (f64.const -0x1.2cd0668b28344p+184)) (f64.const 0x1.d020daf71cdcp-876)) 600 (assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.81cb7d400918dp-714) (f64.const 0x1.7caa643586d6ep-53)) (f64.const -0x1.81cb7d400918ep-714)) 601 (assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.66904c97b5c8ep-145) (f64.const 0x1.5c3481592ad4cp+428)) (f64.const -0x1.66904c97b5c8dp-145)) 602 (assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.e75859d2f0765p-278) (f64.const -0x1.5f19b6ab497f9p+283)) (f64.const -0x1.e75859d2f0764p-278)) 603 (assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.515fe9c3b5f5p+620) (f64.const 0x1.36be869c99f7ap+989)) (f64.const -0x1.515fe9c3b5f4fp+620)) 604 605 ;; Test that x/2*2 is not folded to x. 606 607 (module 608 (func (export "f32.no_fold_div2_mul2") (param $x f32) (result f32) 609 (f32.mul (f32.div (local.get $x) (f32.const 2.0)) (f32.const 2.0))) 610 (func (export "f64.no_fold_div2_mul2") (param $x f64) (result f64) 611 (f64.mul (f64.div (local.get $x) (f64.const 2.0)) (f64.const 2.0))) 612 ) 613 614 (assert_return (invoke "f32.no_fold_div2_mul2" (f32.const 0x1.fffffep-126)) (f32.const 0x1p-125)) 615 (assert_return (invoke "f64.no_fold_div2_mul2" (f64.const 0x1.fffffffffffffp-1022)) (f64.const 0x1p-1021)) 616 617 ;; Test that promote(demote(x)) is not folded to x. 618 619 (module 620 (func (export "no_fold_demote_promote") (param $x f64) (result f64) 621 (f64.promote_f32 (f32.demote_f64 (local.get $x)))) 622 ) 623 624 (assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.dece272390f5dp-133)) (f64.const -0x1.decep-133)) 625 (assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.19e6c79938a6fp-85)) (f64.const -0x1.19e6c8p-85)) 626 (assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.49b297ec44dc1p+107)) (f64.const 0x1.49b298p+107)) 627 (assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.74f5bd865163p-88)) (f64.const -0x1.74f5bep-88)) 628 (assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.26d675662367ep+104)) (f64.const 0x1.26d676p+104)) 629 630 ;; Test that demote(promote(x)) is not folded to x, and aside from NaN is 631 ;; bit-preserving. 632 633 (module 634 (func (export "no_fold_promote_demote") (param $x f32) (result f32) 635 (f32.demote_f64 (f64.promote_f32 (local.get $x)))) 636 ) 637 638 (assert_return (invoke "no_fold_promote_demote" (f32.const nan:0x200000)) (f32.const nan:arithmetic)) 639 (assert_return (invoke "no_fold_promote_demote" (f32.const 0x0p+0)) (f32.const 0x0p+0)) 640 (assert_return (invoke "no_fold_promote_demote" (f32.const -0x0p+0)) (f32.const -0x0p+0)) 641 (assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-149)) (f32.const 0x1p-149)) 642 (assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-149)) (f32.const -0x1p-149)) 643 (assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffcp-127)) (f32.const 0x1.fffffcp-127)) 644 (assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffcp-127)) (f32.const -0x1.fffffcp-127)) 645 (assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-126)) (f32.const 0x1p-126)) 646 (assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-126)) (f32.const -0x1p-126)) 647 (assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127)) 648 (assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127)) 649 (assert_return (invoke "no_fold_promote_demote" (f32.const inf)) (f32.const inf)) 650 (assert_return (invoke "no_fold_promote_demote" (f32.const -inf)) (f32.const -inf)) 651 652 ;; Test that demote(x+promote(y)) is not folded to demote(x)+y. 653 654 (module 655 (func (export "no_demote_mixed_add") (param $x f64) (param $y f32) (result f32) 656 (f32.demote_f64 (f64.add (local.get $x) (f64.promote_f32 (local.get $y))))) 657 (func (export "no_demote_mixed_add_commuted") (param $y f32) (param $x f64) (result f32) 658 (f32.demote_f64 (f64.add (f64.promote_f32 (local.get $y)) (local.get $x)))) 659 ) 660 661 (assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.f51a9d04854f9p-95) (f32.const 0x1.3f4e9cp-119)) (f32.const 0x1.f51a9ep-95)) 662 (assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.065b3d81ad8dp+37) (f32.const 0x1.758cd8p+38)) (f32.const 0x1.f8ba76p+38)) 663 (assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.626c80963bd17p-119) (f32.const -0x1.9bbf86p-121)) (f32.const 0x1.f6f93ep-120)) 664 (assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.0d5110e3385bbp-20) (f32.const 0x1.096f4ap-29)) (f32.const -0x1.0ccc5ap-20)) 665 (assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.73852db4e5075p-20) (f32.const -0x1.24e474p-41)) (f32.const -0x1.738536p-20)) 666 667 (assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.3f4e9cp-119) (f64.const 0x1.f51a9d04854f9p-95)) (f32.const 0x1.f51a9ep-95)) 668 (assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.758cd8p+38) (f64.const 0x1.065b3d81ad8dp+37)) (f32.const 0x1.f8ba76p+38)) 669 (assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.9bbf86p-121) (f64.const 0x1.626c80963bd17p-119)) (f32.const 0x1.f6f93ep-120)) 670 (assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.096f4ap-29) (f64.const -0x1.0d5110e3385bbp-20)) (f32.const -0x1.0ccc5ap-20)) 671 (assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.24e474p-41) (f64.const -0x1.73852db4e5075p-20)) (f32.const -0x1.738536p-20)) 672 673 ;; Test that demote(x-promote(y)) is not folded to demote(x)-y. 674 675 (module 676 (func (export "no_demote_mixed_sub") (param $x f64) (param $y f32) (result f32) 677 (f32.demote_f64 (f64.sub (local.get $x) (f64.promote_f32 (local.get $y))))) 678 ) 679 680 (assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a0a183220e9b1p+82) (f32.const 0x1.c5acf8p+61)) (f32.const 0x1.a0a174p+82)) 681 (assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.6e2c5ac39f63ep+30) (f32.const 0x1.d48ca4p+17)) (f32.const -0x1.6e3bp+30)) 682 (assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.98c74350dde6ap+6) (f32.const 0x1.9d69bcp-12)) (f32.const -0x1.98c7aap+6)) 683 (assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.0459f34091dbfp-54) (f32.const 0x1.61ad08p-71)) (f32.const 0x1.045942p-54)) 684 (assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a7498dca3fdb7p+14) (f32.const 0x1.ed21c8p+15)) (f32.const -0x1.197d02p+15)) 685 686 ;; Test that converting between integer and float and back isn't folded away. 687 688 (module 689 (func (export "f32.i32.no_fold_trunc_s_convert_s") (param $x f32) (result f32) 690 (f32.convert_i32_s (i32.trunc_f32_s (local.get $x)))) 691 (func (export "f32.i32.no_fold_trunc_u_convert_s") (param $x f32) (result f32) 692 (f32.convert_i32_s (i32.trunc_f32_u (local.get $x)))) 693 (func (export "f32.i32.no_fold_trunc_s_convert_u") (param $x f32) (result f32) 694 (f32.convert_i32_u (i32.trunc_f32_s (local.get $x)))) 695 (func (export "f32.i32.no_fold_trunc_u_convert_u") (param $x f32) (result f32) 696 (f32.convert_i32_u (i32.trunc_f32_u (local.get $x)))) 697 (func (export "f64.i32.no_fold_trunc_s_convert_s") (param $x f64) (result f64) 698 (f64.convert_i32_s (i32.trunc_f64_s (local.get $x)))) 699 (func (export "f64.i32.no_fold_trunc_u_convert_s") (param $x f64) (result f64) 700 (f64.convert_i32_s (i32.trunc_f64_u (local.get $x)))) 701 (func (export "f64.i32.no_fold_trunc_s_convert_u") (param $x f64) (result f64) 702 (f64.convert_i32_u (i32.trunc_f64_s (local.get $x)))) 703 (func (export "f64.i32.no_fold_trunc_u_convert_u") (param $x f64) (result f64) 704 (f64.convert_i32_u (i32.trunc_f64_u (local.get $x)))) 705 (func (export "f32.i64.no_fold_trunc_s_convert_s") (param $x f32) (result f32) 706 (f32.convert_i64_s (i64.trunc_f32_s (local.get $x)))) 707 (func (export "f32.i64.no_fold_trunc_u_convert_s") (param $x f32) (result f32) 708 (f32.convert_i64_s (i64.trunc_f32_u (local.get $x)))) 709 (func (export "f32.i64.no_fold_trunc_s_convert_u") (param $x f32) (result f32) 710 (f32.convert_i64_u (i64.trunc_f32_s (local.get $x)))) 711 (func (export "f32.i64.no_fold_trunc_u_convert_u") (param $x f32) (result f32) 712 (f32.convert_i64_u (i64.trunc_f32_u (local.get $x)))) 713 (func (export "f64.i64.no_fold_trunc_s_convert_s") (param $x f64) (result f64) 714 (f64.convert_i64_s (i64.trunc_f64_s (local.get $x)))) 715 (func (export "f64.i64.no_fold_trunc_u_convert_s") (param $x f64) (result f64) 716 (f64.convert_i64_s (i64.trunc_f64_u (local.get $x)))) 717 (func (export "f64.i64.no_fold_trunc_s_convert_u") (param $x f64) (result f64) 718 (f64.convert_i64_u (i64.trunc_f64_s (local.get $x)))) 719 (func (export "f64.i64.no_fold_trunc_u_convert_u") (param $x f64) (result f64) 720 (f64.convert_i64_u (i64.trunc_f64_u (local.get $x)))) 721 ) 722 723 (assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0)) 724 (assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0)) 725 (assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0)) 726 (assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0)) 727 (assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0)) 728 (assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+32)) 729 (assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0)) 730 (assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0)) 731 732 (assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0)) 733 (assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0)) 734 (assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0)) 735 (assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0)) 736 (assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0)) 737 (assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1.fffffffep+31)) 738 (assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0)) 739 (assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0)) 740 741 (assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0)) 742 (assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0)) 743 (assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0)) 744 (assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0)) 745 (assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0)) 746 (assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+64)) 747 (assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0)) 748 (assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0)) 749 750 (assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0)) 751 (assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0)) 752 (assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0)) 753 (assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0)) 754 (assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0)) 755 (assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1p+64)) 756 (assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0)) 757 (assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0)) 758 759 ;; Test that dividing by a loop-invariant constant isn't optimized to be a 760 ;; multiplication by a reciprocal, which would be particularly tempting since 761 ;; the reciprocal computation could be hoisted. 762 763 (module 764 (memory 1 1) 765 (func (export "init") (param $i i32) (param $x f32) (f32.store (local.get $i) (local.get $x))) 766 767 (func (export "run") (param $n i32) (param $z f32) 768 (local $i i32) 769 (block $exit 770 (loop $cont 771 (f32.store 772 (local.get $i) 773 (f32.div (f32.load (local.get $i)) (local.get $z)) 774 ) 775 (local.set $i (i32.add (local.get $i) (i32.const 4))) 776 (br_if $cont (i32.lt_u (local.get $i) (local.get $n))) 777 ) 778 ) 779 ) 780 781 (func (export "check") (param $i i32) (result f32) (f32.load (local.get $i))) 782 ) 783 784 (invoke "init" (i32.const 0) (f32.const 15.1)) 785 (invoke "init" (i32.const 4) (f32.const 15.2)) 786 (invoke "init" (i32.const 8) (f32.const 15.3)) 787 (invoke "init" (i32.const 12) (f32.const 15.4)) 788 (assert_return (invoke "check" (i32.const 0)) (f32.const 15.1)) 789 (assert_return (invoke "check" (i32.const 4)) (f32.const 15.2)) 790 (assert_return (invoke "check" (i32.const 8)) (f32.const 15.3)) 791 (assert_return (invoke "check" (i32.const 12)) (f32.const 15.4)) 792 (invoke "run" (i32.const 16) (f32.const 3.0)) 793 (assert_return (invoke "check" (i32.const 0)) (f32.const 0x1.422222p+2)) 794 (assert_return (invoke "check" (i32.const 4)) (f32.const 0x1.444444p+2)) 795 (assert_return (invoke "check" (i32.const 8)) (f32.const 0x1.466666p+2)) 796 (assert_return (invoke "check" (i32.const 12)) (f32.const 0x1.488888p+2)) 797 798 (module 799 (memory 1 1) 800 (func (export "init") (param $i i32) (param $x f64) (f64.store (local.get $i) (local.get $x))) 801 802 (func (export "run") (param $n i32) (param $z f64) 803 (local $i i32) 804 (block $exit 805 (loop $cont 806 (f64.store 807 (local.get $i) 808 (f64.div (f64.load (local.get $i)) (local.get $z)) 809 ) 810 (local.set $i (i32.add (local.get $i) (i32.const 8))) 811 (br_if $cont (i32.lt_u (local.get $i) (local.get $n))) 812 ) 813 ) 814 ) 815 816 (func (export "check") (param $i i32) (result f64) (f64.load (local.get $i))) 817 ) 818 819 (invoke "init" (i32.const 0) (f64.const 15.1)) 820 (invoke "init" (i32.const 8) (f64.const 15.2)) 821 (invoke "init" (i32.const 16) (f64.const 15.3)) 822 (invoke "init" (i32.const 24) (f64.const 15.4)) 823 (assert_return (invoke "check" (i32.const 0)) (f64.const 15.1)) 824 (assert_return (invoke "check" (i32.const 8)) (f64.const 15.2)) 825 (assert_return (invoke "check" (i32.const 16)) (f64.const 15.3)) 826 (assert_return (invoke "check" (i32.const 24)) (f64.const 15.4)) 827 (invoke "run" (i32.const 32) (f64.const 3.0)) 828 (assert_return (invoke "check" (i32.const 0)) (f64.const 0x1.4222222222222p+2)) 829 (assert_return (invoke "check" (i32.const 8)) (f64.const 0x1.4444444444444p+2)) 830 (assert_return (invoke "check" (i32.const 16)) (f64.const 0x1.4666666666667p+2)) 831 (assert_return (invoke "check" (i32.const 24)) (f64.const 0x1.4888888888889p+2)) 832 833 ;; Test that ult/ugt/etc. aren't folded to olt/ogt/etc. 834 835 (module 836 (func (export "f32.ult") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.ge (local.get $x) (local.get $y)))) 837 (func (export "f32.ule") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.gt (local.get $x) (local.get $y)))) 838 (func (export "f32.ugt") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.le (local.get $x) (local.get $y)))) 839 (func (export "f32.uge") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.lt (local.get $x) (local.get $y)))) 840 841 (func (export "f64.ult") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.ge (local.get $x) (local.get $y)))) 842 (func (export "f64.ule") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.gt (local.get $x) (local.get $y)))) 843 (func (export "f64.ugt") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.le (local.get $x) (local.get $y)))) 844 (func (export "f64.uge") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.lt (local.get $x) (local.get $y)))) 845 ) 846 847 (assert_return (invoke "f32.ult" (f32.const 3.0) (f32.const 2.0)) (i32.const 0)) 848 (assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 2.0)) (i32.const 0)) 849 (assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 3.0)) (i32.const 1)) 850 (assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const nan)) (i32.const 1)) 851 (assert_return (invoke "f32.ule" (f32.const 3.0) (f32.const 2.0)) (i32.const 0)) 852 (assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 2.0)) (i32.const 1)) 853 (assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 3.0)) (i32.const 1)) 854 (assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const nan)) (i32.const 1)) 855 (assert_return (invoke "f32.ugt" (f32.const 3.0) (f32.const 2.0)) (i32.const 1)) 856 (assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 2.0)) (i32.const 0)) 857 (assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 3.0)) (i32.const 0)) 858 (assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const nan)) (i32.const 1)) 859 (assert_return (invoke "f32.uge" (f32.const 3.0) (f32.const 2.0)) (i32.const 1)) 860 (assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 2.0)) (i32.const 1)) 861 (assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 3.0)) (i32.const 0)) 862 (assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const nan)) (i32.const 1)) 863 (assert_return (invoke "f64.ult" (f64.const 3.0) (f64.const 2.0)) (i32.const 0)) 864 (assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 2.0)) (i32.const 0)) 865 (assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 3.0)) (i32.const 1)) 866 (assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const nan)) (i32.const 1)) 867 (assert_return (invoke "f64.ule" (f64.const 3.0) (f64.const 2.0)) (i32.const 0)) 868 (assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 2.0)) (i32.const 1)) 869 (assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 3.0)) (i32.const 1)) 870 (assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const nan)) (i32.const 1)) 871 (assert_return (invoke "f64.ugt" (f64.const 3.0) (f64.const 2.0)) (i32.const 1)) 872 (assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 2.0)) (i32.const 0)) 873 (assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 3.0)) (i32.const 0)) 874 (assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const nan)) (i32.const 1)) 875 (assert_return (invoke "f64.uge" (f64.const 3.0) (f64.const 2.0)) (i32.const 1)) 876 (assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 2.0)) (i32.const 1)) 877 (assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 3.0)) (i32.const 0)) 878 (assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const nan)) (i32.const 1)) 879 880 ;; Test that x<y?x:y, etc. using select aren't folded to min, etc. 881 882 (module 883 (func (export "f32.no_fold_lt_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.lt (local.get $x) (local.get $y)))) 884 (func (export "f32.no_fold_le_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.le (local.get $x) (local.get $y)))) 885 (func (export "f32.no_fold_gt_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.gt (local.get $x) (local.get $y)))) 886 (func (export "f32.no_fold_ge_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.ge (local.get $x) (local.get $y)))) 887 888 (func (export "f64.no_fold_lt_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.lt (local.get $x) (local.get $y)))) 889 (func (export "f64.no_fold_le_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.le (local.get $x) (local.get $y)))) 890 (func (export "f64.no_fold_gt_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.gt (local.get $x) (local.get $y)))) 891 (func (export "f64.no_fold_ge_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.ge (local.get $x) (local.get $y)))) 892 ) 893 894 (assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan)) 895 (assert_return (invoke "f32.no_fold_lt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0)) 896 (assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0)) 897 (assert_return (invoke "f32.no_fold_lt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0)) 898 (assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const nan)) (f32.const nan)) 899 (assert_return (invoke "f32.no_fold_le_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0)) 900 (assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0)) 901 (assert_return (invoke "f32.no_fold_le_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0)) 902 (assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan)) 903 (assert_return (invoke "f32.no_fold_gt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0)) 904 (assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0)) 905 (assert_return (invoke "f32.no_fold_gt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0)) 906 (assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const nan)) (f32.const nan)) 907 (assert_return (invoke "f32.no_fold_ge_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0)) 908 (assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0)) 909 (assert_return (invoke "f32.no_fold_ge_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0)) 910 (assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan)) 911 (assert_return (invoke "f64.no_fold_lt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0)) 912 (assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0)) 913 (assert_return (invoke "f64.no_fold_lt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0)) 914 (assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const nan)) (f64.const nan)) 915 (assert_return (invoke "f64.no_fold_le_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0)) 916 (assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0)) 917 (assert_return (invoke "f64.no_fold_le_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0)) 918 (assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan)) 919 (assert_return (invoke "f64.no_fold_gt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0)) 920 (assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0)) 921 (assert_return (invoke "f64.no_fold_gt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0)) 922 (assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const nan)) (f64.const nan)) 923 (assert_return (invoke "f64.no_fold_ge_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0)) 924 (assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0)) 925 (assert_return (invoke "f64.no_fold_ge_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0)) 926 927 ;; Test that x<y?x:y, etc. using if and else aren't folded to min, etc. 928 929 (module 930 (func (export "f32.no_fold_lt_if") (param $x f32) (param $y f32) (result f32) 931 (if (result f32) (f32.lt (local.get $x) (local.get $y)) 932 (then (local.get $x)) (else (local.get $y)) 933 ) 934 ) 935 (func (export "f32.no_fold_le_if") (param $x f32) (param $y f32) (result f32) 936 (if (result f32) (f32.le (local.get $x) (local.get $y)) 937 (then (local.get $x)) (else (local.get $y)) 938 ) 939 ) 940 (func (export "f32.no_fold_gt_if") (param $x f32) (param $y f32) (result f32) 941 (if (result f32) (f32.gt (local.get $x) (local.get $y)) 942 (then (local.get $x)) (else (local.get $y)) 943 ) 944 ) 945 (func (export "f32.no_fold_ge_if") (param $x f32) (param $y f32) (result f32) 946 (if (result f32) (f32.ge (local.get $x) (local.get $y)) 947 (then (local.get $x)) (else (local.get $y)) 948 ) 949 ) 950 951 (func (export "f64.no_fold_lt_if") (param $x f64) (param $y f64) (result f64) 952 (if (result f64) (f64.lt (local.get $x) (local.get $y)) 953 (then (local.get $x)) (else (local.get $y)) 954 ) 955 ) 956 (func (export "f64.no_fold_le_if") (param $x f64) (param $y f64) (result f64) 957 (if (result f64) (f64.le (local.get $x) (local.get $y)) 958 (then (local.get $x)) (else (local.get $y)) 959 ) 960 ) 961 (func (export "f64.no_fold_gt_if") (param $x f64) (param $y f64) (result f64) 962 (if (result f64) (f64.gt (local.get $x) (local.get $y)) 963 (then (local.get $x)) (else (local.get $y)) 964 ) 965 ) 966 (func (export "f64.no_fold_ge_if") (param $x f64) (param $y f64) (result f64) 967 (if (result f64) (f64.ge (local.get $x) (local.get $y)) 968 (then (local.get $x)) (else (local.get $y)) 969 ) 970 ) 971 ) 972 973 (assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan)) 974 (assert_return (invoke "f32.no_fold_lt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0)) 975 (assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0)) 976 (assert_return (invoke "f32.no_fold_lt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0)) 977 (assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const nan)) (f32.const nan)) 978 (assert_return (invoke "f32.no_fold_le_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0)) 979 (assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0)) 980 (assert_return (invoke "f32.no_fold_le_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0)) 981 (assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan)) 982 (assert_return (invoke "f32.no_fold_gt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0)) 983 (assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0)) 984 (assert_return (invoke "f32.no_fold_gt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0)) 985 (assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const nan)) (f32.const nan)) 986 (assert_return (invoke "f32.no_fold_ge_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0)) 987 (assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0)) 988 (assert_return (invoke "f32.no_fold_ge_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0)) 989 (assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan)) 990 (assert_return (invoke "f64.no_fold_lt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0)) 991 (assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0)) 992 (assert_return (invoke "f64.no_fold_lt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0)) 993 (assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const nan)) (f64.const nan)) 994 (assert_return (invoke "f64.no_fold_le_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0)) 995 (assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0)) 996 (assert_return (invoke "f64.no_fold_le_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0)) 997 (assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan)) 998 (assert_return (invoke "f64.no_fold_gt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0)) 999 (assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0)) 1000 (assert_return (invoke "f64.no_fold_gt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0)) 1001 (assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const nan)) (f64.const nan)) 1002 (assert_return (invoke "f64.no_fold_ge_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0)) 1003 (assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0)) 1004 (assert_return (invoke "f64.no_fold_ge_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0)) 1005 1006 ;; Test that x<0?-x:x, etc. using select aren't folded to abs. 1007 1008 (module 1009 (func (export "f32.no_fold_lt_select_to_abs") (param $x f32) (result f32) (select (f32.neg (local.get $x)) (local.get $x) (f32.lt (local.get $x) (f32.const 0.0)))) 1010 (func (export "f32.no_fold_le_select_to_abs") (param $x f32) (result f32) (select (f32.neg (local.get $x)) (local.get $x) (f32.le (local.get $x) (f32.const -0.0)))) 1011 (func (export "f32.no_fold_gt_select_to_abs") (param $x f32) (result f32) (select (local.get $x) (f32.neg (local.get $x)) (f32.gt (local.get $x) (f32.const -0.0)))) 1012 (func (export "f32.no_fold_ge_select_to_abs") (param $x f32) (result f32) (select (local.get $x) (f32.neg (local.get $x)) (f32.ge (local.get $x) (f32.const 0.0)))) 1013 1014 (func (export "f64.no_fold_lt_select_to_abs") (param $x f64) (result f64) (select (f64.neg (local.get $x)) (local.get $x) (f64.lt (local.get $x) (f64.const 0.0)))) 1015 (func (export "f64.no_fold_le_select_to_abs") (param $x f64) (result f64) (select (f64.neg (local.get $x)) (local.get $x) (f64.le (local.get $x) (f64.const -0.0)))) 1016 (func (export "f64.no_fold_gt_select_to_abs") (param $x f64) (result f64) (select (local.get $x) (f64.neg (local.get $x)) (f64.gt (local.get $x) (f64.const -0.0)))) 1017 (func (export "f64.no_fold_ge_select_to_abs") (param $x f64) (result f64) (select (local.get $x) (f64.neg (local.get $x)) (f64.ge (local.get $x) (f64.const 0.0)))) 1018 ) 1019 1020 (assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000)) 1021 (assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -nan)) (f32.const -nan)) 1022 (assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const 0.0)) (f32.const 0.0)) 1023 (assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -0.0)) (f32.const -0.0)) 1024 (assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000)) 1025 (assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -nan)) (f32.const -nan)) 1026 (assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const 0.0)) (f32.const -0.0)) 1027 (assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -0.0)) (f32.const 0.0)) 1028 (assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000)) 1029 (assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -nan)) (f32.const nan)) 1030 (assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const 0.0)) (f32.const -0.0)) 1031 (assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -0.0)) (f32.const 0.0)) 1032 (assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000)) 1033 (assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -nan)) (f32.const nan)) 1034 (assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const 0.0)) (f32.const 0.0)) 1035 (assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -0.0)) (f32.const -0.0)) 1036 (assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000)) 1037 (assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -nan)) (f64.const -nan)) 1038 (assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const 0.0)) (f64.const 0.0)) 1039 (assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -0.0)) (f64.const -0.0)) 1040 (assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000)) 1041 (assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -nan)) (f64.const -nan)) 1042 (assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const 0.0)) (f64.const -0.0)) 1043 (assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -0.0)) (f64.const 0.0)) 1044 (assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000)) 1045 (assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -nan)) (f64.const nan)) 1046 (assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const 0.0)) (f64.const -0.0)) 1047 (assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -0.0)) (f64.const 0.0)) 1048 (assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000)) 1049 (assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -nan)) (f64.const nan)) 1050 (assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const 0.0)) (f64.const 0.0)) 1051 (assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -0.0)) (f64.const -0.0)) 1052 1053 ;; Test that x<0?-x:x, etc. using if aren't folded to abs. 1054 1055 (module 1056 (func (export "f32.no_fold_lt_if_to_abs") (param $x f32) (result f32) 1057 (if (result f32) (f32.lt (local.get $x) (f32.const 0.0)) 1058 (then (f32.neg (local.get $x))) (else (local.get $x)) 1059 ) 1060 ) 1061 (func (export "f32.no_fold_le_if_to_abs") (param $x f32) (result f32) 1062 (if (result f32) (f32.le (local.get $x) (f32.const -0.0)) 1063 (then (f32.neg (local.get $x))) (else (local.get $x)) 1064 ) 1065 ) 1066 (func (export "f32.no_fold_gt_if_to_abs") (param $x f32) (result f32) 1067 (if (result f32) (f32.gt (local.get $x) (f32.const -0.0)) 1068 (then (local.get $x)) (else (f32.neg (local.get $x))) 1069 ) 1070 ) 1071 (func (export "f32.no_fold_ge_if_to_abs") (param $x f32) (result f32) 1072 (if (result f32) (f32.ge (local.get $x) (f32.const 0.0)) 1073 (then (local.get $x)) (else (f32.neg (local.get $x))) 1074 ) 1075 ) 1076 1077 (func (export "f64.no_fold_lt_if_to_abs") (param $x f64) (result f64) 1078 (if (result f64) (f64.lt (local.get $x) (f64.const 0.0)) 1079 (then (f64.neg (local.get $x))) (else (local.get $x)) 1080 ) 1081 ) 1082 (func (export "f64.no_fold_le_if_to_abs") (param $x f64) (result f64) 1083 (if (result f64) (f64.le (local.get $x) (f64.const -0.0)) 1084 (then (f64.neg (local.get $x))) (else (local.get $x)) 1085 ) 1086 ) 1087 (func (export "f64.no_fold_gt_if_to_abs") (param $x f64) (result f64) 1088 (if (result f64) (f64.gt (local.get $x) (f64.const -0.0)) 1089 (then (local.get $x)) (else (f64.neg (local.get $x))) 1090 ) 1091 ) 1092 (func (export "f64.no_fold_ge_if_to_abs") (param $x f64) (result f64) 1093 (if (result f64) (f64.ge (local.get $x) (f64.const 0.0)) 1094 (then (local.get $x)) (else (f64.neg (local.get $x))) 1095 ) 1096 ) 1097 ) 1098 1099 (assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000)) 1100 (assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -nan)) (f32.const -nan)) 1101 (assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const 0.0)) (f32.const 0.0)) 1102 (assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -0.0)) (f32.const -0.0)) 1103 (assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000)) 1104 (assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -nan)) (f32.const -nan)) 1105 (assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const 0.0)) (f32.const -0.0)) 1106 (assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -0.0)) (f32.const 0.0)) 1107 (assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000)) 1108 (assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -nan)) (f32.const nan)) 1109 (assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const 0.0)) (f32.const -0.0)) 1110 (assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -0.0)) (f32.const 0.0)) 1111 (assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000)) 1112 (assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -nan)) (f32.const nan)) 1113 (assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const 0.0)) (f32.const 0.0)) 1114 (assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -0.0)) (f32.const -0.0)) 1115 (assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000)) 1116 (assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -nan)) (f64.const -nan)) 1117 (assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const 0.0)) (f64.const 0.0)) 1118 (assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -0.0)) (f64.const -0.0)) 1119 (assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000)) 1120 (assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -nan)) (f64.const -nan)) 1121 (assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const 0.0)) (f64.const -0.0)) 1122 (assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -0.0)) (f64.const 0.0)) 1123 (assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000)) 1124 (assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -nan)) (f64.const nan)) 1125 (assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const 0.0)) (f64.const -0.0)) 1126 (assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -0.0)) (f64.const 0.0)) 1127 (assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000)) 1128 (assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -nan)) (f64.const nan)) 1129 (assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const 0.0)) (f64.const 0.0)) 1130 (assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -0.0)) (f64.const -0.0)) 1131 1132 ;; Test for a historic spreadsheet bug. 1133 ;; https://support.microsoft.com/en-us/kb/78113 1134 1135 (module 1136 (func (export "f32.incorrect_correction") (result f32) 1137 (f32.sub (f32.sub (f32.add (f32.const 1.333) (f32.const 1.225)) (f32.const 1.333)) (f32.const 1.225)) 1138 ) 1139 (func (export "f64.incorrect_correction") (result f64) 1140 (f64.sub (f64.sub (f64.add (f64.const 1.333) (f64.const 1.225)) (f64.const 1.333)) (f64.const 1.225)) 1141 ) 1142 ) 1143 1144 (assert_return (invoke "f32.incorrect_correction") (f32.const 0x1p-23)) 1145 (assert_return (invoke "f64.incorrect_correction") (f64.const -0x1p-52)) 1146 1147 ;; Test for a historical calculator bug. 1148 ;; http://www.hpmuseum.org/cgi-sys/cgiwrap/hpmuseum/articles.cgi?read=735 1149 1150 (module 1151 (func (export "calculate") (result f32) 1152 (local $x f32) 1153 (local $r f32) 1154 (local $q f32) 1155 (local $z0 f32) 1156 (local $z1 f32) 1157 (local.set $x (f32.const 156.25)) 1158 (local.set $r (f32.const 208.333333334)) 1159 (local.set $q (f32.const 1.77951304201)) 1160 (local.set $z0 (f32.div (f32.mul (f32.neg (local.get $r)) (local.get $x)) (f32.sub (f32.mul (local.get $x) (local.get $q)) (local.get $r)))) 1161 (local.set $z1 (f32.div (f32.mul (f32.neg (local.get $r)) (local.get $x)) (f32.sub (f32.mul (local.get $x) (local.get $q)) (local.get $r)))) 1162 (block (br_if 0 (f32.eq (local.get $z0) (local.get $z1))) (unreachable)) 1163 (local.get $z1) 1164 ) 1165 ) 1166 1167 (assert_return (invoke "calculate") (f32.const -0x1.d2ed46p+8)) 1168 1169 (module 1170 (func (export "calculate") (result f64) 1171 (local $x f64) 1172 (local $r f64) 1173 (local $q f64) 1174 (local $z0 f64) 1175 (local $z1 f64) 1176 (local.set $x (f64.const 156.25)) 1177 (local.set $r (f64.const 208.333333334)) 1178 (local.set $q (f64.const 1.77951304201)) 1179 (local.set $z0 (f64.div (f64.mul (f64.neg (local.get $r)) (local.get $x)) (f64.sub (f64.mul (local.get $x) (local.get $q)) (local.get $r)))) 1180 (local.set $z1 (f64.div (f64.mul (f64.neg (local.get $r)) (local.get $x)) (f64.sub (f64.mul (local.get $x) (local.get $q)) (local.get $r)))) 1181 (block (br_if 0 (f64.eq (local.get $z0) (local.get $z1))) (unreachable)) 1182 (local.get $z1) 1183 ) 1184 ) 1185 1186 (assert_return (invoke "calculate") (f64.const -0x1.d2ed4d0218c93p+8)) 1187 1188 ;; Test that 0 - (-0 - x) is not optimized to x. 1189 ;; https://llvm.org/bugs/show_bug.cgi?id=26746 1190 1191 (module 1192 (func (export "llvm_pr26746") (param $x f32) (result f32) 1193 (f32.sub (f32.const 0.0) (f32.sub (f32.const -0.0) (local.get $x))) 1194 ) 1195 ) 1196 1197 (assert_return (invoke "llvm_pr26746" (f32.const -0.0)) (f32.const 0.0)) 1198 1199 ;; Test for improperly reassociating an addition and a conversion. 1200 ;; https://llvm.org/bugs/show_bug.cgi?id=27153 1201 1202 (module 1203 (func (export "llvm_pr27153") (param $x i32) (result f32) 1204 (f32.add (f32.convert_i32_s (i32.and (local.get $x) (i32.const 268435455))) (f32.const -8388608.0)) 1205 ) 1206 ) 1207 1208 (assert_return (invoke "llvm_pr27153" (i32.const 33554434)) (f32.const 25165824.000000)) 1209 1210 ;; Test that (float)x + (float)y is not optimized to (float)(x + y) when unsafe. 1211 ;; https://llvm.org/bugs/show_bug.cgi?id=27036 1212 1213 (module 1214 (func (export "llvm_pr27036") (param $x i32) (param $y i32) (result f32) 1215 (f32.add (f32.convert_i32_s (i32.or (local.get $x) (i32.const -25034805))) 1216 (f32.convert_i32_s (i32.and (local.get $y) (i32.const 14942208)))) 1217 ) 1218 ) 1219 1220 (assert_return (invoke "llvm_pr27036" (i32.const -25034805) (i32.const 14942208)) (f32.const -0x1.340068p+23)) 1221 1222 ;; Test for bugs in old versions of historic IEEE 754 platforms as reported in: 1223 ;; 1224 ;; N. L. Schryer. 1981. A Test of a Computer's Floating-Point Arithmetic Unit. 1225 ;; Tech. Rep. Computer Science Technical Report 89, AT&T Bell Laboratories, Feb. 1226 ;; 1227 ;; specifically, the appendices describing IEEE systems with "The Past" sections 1228 ;; describing specific bugs. The 0 < 0 bug is omitted here due to being already 1229 ;; covered elsewhere. 1230 (module 1231 (func (export "thepast0") (param $a f64) (param $b f64) (param $c f64) (param $d f64) (result f64) 1232 (f64.div (f64.mul (local.get $a) (local.get $b)) (f64.mul (local.get $c) (local.get $d))) 1233 ) 1234 1235 (func (export "thepast1") (param $a f64) (param $b f64) (param $c f64) (result f64) 1236 (f64.sub (f64.mul (local.get $a) (local.get $b)) (local.get $c)) 1237 ) 1238 1239 (func (export "thepast2") (param $a f32) (param $b f32) (param $c f32) (result f32) 1240 (f32.mul (f32.mul (local.get $a) (local.get $b)) (local.get $c)) 1241 ) 1242 ) 1243 1244 (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)) 1245 (assert_return (invoke "thepast1" (f64.const 0x1p-54) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p-54)) (f64.const -0x1p-107)) 1246 (assert_return (invoke "thepast2" (f32.const 0x1p-125) (f32.const 0x1p-1) (f32.const 0x1p0)) (f32.const 0x1p-126)) 1247 1248 ;; Test for floating point tolerances observed in some GPUs. 1249 ;; https://community.amd.com/thread/145582 1250 1251 (module 1252 (func (export "inverse") (param $x f32) (result f32) 1253 (f32.div (f32.const 1.0) (local.get $x)) 1254 ) 1255 ) 1256 1257 (assert_return (invoke "inverse" (f32.const 96.0)) (f32.const 0x1.555556p-7)) 1258 1259 ;; Test for incorrect rounding on sqrt(4.0). 1260 ;; http://www.askvg.com/microsoft-windows-calculator-bug/ 1261 1262 (module 1263 (func (export "f32_sqrt_minus_2") (param $x f32) (result f32) 1264 (f32.sub (f32.sqrt (local.get $x)) (f32.const 2.0)) 1265 ) 1266 1267 (func (export "f64_sqrt_minus_2") (param $x f64) (result f64) 1268 (f64.sub (f64.sqrt (local.get $x)) (f64.const 2.0)) 1269 ) 1270 ) 1271 1272 (assert_return (invoke "f32_sqrt_minus_2" (f32.const 4.0)) (f32.const 0.0)) 1273 (assert_return (invoke "f64_sqrt_minus_2" (f64.const 4.0)) (f64.const 0.0)) 1274 1275 ;; Test that 1.0 / (1.0 / x) is not optimized to x. 1276 1277 (module 1278 (func (export "f32.no_fold_recip_recip") (param $x f32) (result f32) 1279 (f32.div (f32.const 1.0) (f32.div (f32.const 1.0) (local.get $x)))) 1280 1281 (func (export "f64.no_fold_recip_recip") (param $x f64) (result f64) 1282 (f64.div (f64.const 1.0) (f64.div (f64.const 1.0) (local.get $x)))) 1283 ) 1284 1285 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x1.e8bf18p+65)) (f32.const -0x1.e8bf16p+65)) 1286 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.e24248p-77)) (f32.const 0x1.e24246p-77)) 1287 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.caf0e8p-64)) (f32.const 0x1.caf0eap-64)) 1288 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x1.e66982p+4)) (f32.const -0x1.e66984p+4)) 1289 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.f99916p+70)) (f32.const 0x1.f99914p+70)) 1290 1291 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x0p+0)) (f32.const -0x0p+0)) 1292 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x0p+0)) (f32.const 0x0p+0)) 1293 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const -inf)) (f32.const -inf)) 1294 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const inf)) (f32.const inf)) 1295 1296 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.d81248dda63dp+148)) (f64.const -0x1.d81248dda63d1p+148)) 1297 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.f4750312039e3p+66)) (f64.const -0x1.f4750312039e2p+66)) 1298 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.fa50630eec7f6p+166)) (f64.const 0x1.fa50630eec7f5p+166)) 1299 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.db0598617ba92p-686)) (f64.const 0x1.db0598617ba91p-686)) 1300 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.85f1638a0c82bp+902)) (f64.const 0x1.85f1638a0c82ap+902)) 1301 1302 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x0p+0)) (f64.const -0x0p+0)) 1303 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x0p+0)) (f64.const 0x0p+0)) 1304 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const -inf)) (f64.const -inf)) 1305 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const inf)) (f64.const inf)) 1306 1307 ;; Test that (x+y) * (x-y) is not optimized to x*x - y*y. 1308 1309 (module 1310 (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32) 1311 (f32.mul (f32.add (local.get $x) (local.get $y)) 1312 (f32.sub (local.get $x) (local.get $y)))) 1313 1314 (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64) 1315 (f64.mul (f64.add (local.get $x) (local.get $y)) 1316 (f64.sub (local.get $x) (local.get $y)))) 1317 ) 1318 1319 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.ef678ep-55) (f32.const 0x1.c160b8p-54)) (f32.const -0x1.129402p-107)) 1320 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.2d76bcp+24) (f32.const 0x1.f4089cp+24)) (f32.const -0x1.36d89ap+49)) 1321 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7ca2b2p+45) (f32.const -0x1.08513cp+47)) (f32.const -0x1.db10dep+93)) 1322 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7d5e3p+17) (f32.const -0x1.c783b4p+7)) (f32.const 0x1.1c10a6p+35)) 1323 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.daf96p+7) (f32.const -0x1.dac6bp+19)) (f32.const -0x1.b8422ep+39)) 1324 1325 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.e17c0a02ac6b5p-476) (f64.const 0x1.e8f13f1fcdc14p-463)) (f64.const -0x1.d2ec518f62863p-925)) 1326 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.971b55a57e3a3p-377) (f64.const 0x1.edeb4233c1b27p-399)) (f64.const 0x1.43b3f69fb258bp-753)) 1327 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.c3b9dc02472fap-378) (f64.const -0x1.74e9faebaff14p-369)) (f64.const -0x1.0f9c07e8caa25p-737)) 1328 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.afaf4688ed019p+179) (f64.const 0x1.b07171cb49e94p+188)) (f64.const -0x1.6d3f2e2bebcf7p+377)) 1329 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.4377a98948f12p+114) (f64.const -0x1.500c05bd24c97p+90)) (f64.const 0x1.98b72dbf7bf72p+228)) 1330 1331 ;; Test that x*x - y*y is not optimized to (x+y) * (x-y). 1332 1333 (module 1334 (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32) 1335 (f32.sub (f32.mul (local.get $x) (local.get $x)) 1336 (f32.mul (local.get $y) (local.get $y)))) 1337 1338 (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64) 1339 (f64.sub (f64.mul (local.get $x) (local.get $x)) 1340 (f64.mul (local.get $y) (local.get $y)))) 1341 ) 1342 1343 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.8e2c14p-46) (f32.const 0x1.bad59ap-39)) (f32.const -0x1.7efe5p-77)) 1344 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.7ef192p+41) (f32.const -0x1.db184ap+33)) (f32.const 0x1.1e6932p+83)) 1345 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7eb458p-12) (f32.const -0x1.52c498p-13)) (f32.const 0x1.cc0bc6p-24)) 1346 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.2675c6p-44) (f32.const -0x1.edd31ap-46)) (f32.const 0x1.17294cp-88)) 1347 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.9a5f92p+51) (f32.const -0x1.2b0098p+52)) (f32.const -0x1.7189a6p+103)) 1348 1349 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.749a128f18f69p+356) (f64.const -0x1.0bc97ee1354e1p+337)) (f64.const 0x1.0f28115518d74p+713)) 1350 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.2dab01b2215eap+309) (f64.const -0x1.e12b288bff2bdp+331)) (f64.const -0x1.c4319ad25d201p+663)) 1351 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.3ed898431e102p+42) (f64.const -0x1.c409183fa92e6p+39)) (f64.const 0x1.80a611103c71dp+84)) 1352 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.be663e4c0e4b2p+182) (f64.const -0x1.da85703760d25p+166)) (f64.const 0x1.853434f1a2ffep+365)) 1353 (assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.230e09952df1cp-236) (f64.const -0x1.fa2752adfadc9p-237)) (f64.const 0x1.42e43156bd1b8p-474)) 1354 1355 ;; Test that platforms where SIMD instructions flush subnormals don't implicitly 1356 ;; optimize using SIMD instructions. 1357 1358 (module 1359 (memory (data 1360 "\01\00\00\00\01\00\00\80\01\00\00\00\01\00\00\80" 1361 "\01\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00" 1362 "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" 1363 )) 1364 1365 (func (export "f32.simple_x4_sum") 1366 (param $i i32) 1367 (param $j i32) 1368 (param $k i32) 1369 (local $x0 f32) (local $x1 f32) (local $x2 f32) (local $x3 f32) 1370 (local $y0 f32) (local $y1 f32) (local $y2 f32) (local $y3 f32) 1371 (local.set $x0 (f32.load offset=0 (local.get $i))) 1372 (local.set $x1 (f32.load offset=4 (local.get $i))) 1373 (local.set $x2 (f32.load offset=8 (local.get $i))) 1374 (local.set $x3 (f32.load offset=12 (local.get $i))) 1375 (local.set $y0 (f32.load offset=0 (local.get $j))) 1376 (local.set $y1 (f32.load offset=4 (local.get $j))) 1377 (local.set $y2 (f32.load offset=8 (local.get $j))) 1378 (local.set $y3 (f32.load offset=12 (local.get $j))) 1379 (f32.store offset=0 (local.get $k) (f32.add (local.get $x0) (local.get $y0))) 1380 (f32.store offset=4 (local.get $k) (f32.add (local.get $x1) (local.get $y1))) 1381 (f32.store offset=8 (local.get $k) (f32.add (local.get $x2) (local.get $y2))) 1382 (f32.store offset=12 (local.get $k) (f32.add (local.get $x3) (local.get $y3))) 1383 ) 1384 1385 (func (export "f32.load") 1386 (param $k i32) (result f32) 1387 (f32.load (local.get $k)) 1388 ) 1389 ) 1390 1391 (assert_return (invoke "f32.simple_x4_sum" (i32.const 0) (i32.const 16) (i32.const 32))) 1392 (assert_return (invoke "f32.load" (i32.const 32)) (f32.const 0x1p-148)) 1393 (assert_return (invoke "f32.load" (i32.const 36)) (f32.const 0x0p+0)) 1394 (assert_return (invoke "f32.load" (i32.const 40)) (f32.const 0x1p-149)) 1395 (assert_return (invoke "f32.load" (i32.const 44)) (f32.const -0x1p-149)) 1396 1397 (module 1398 (memory (data 1399 "\01\00\00\00\00\00\00\00\01\00\00\00\00\00\00\80\01\00\00\00\00\00\00\00\01\00\00\00\00\00\00\80" 1400 "\01\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" 1401 "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" 1402 )) 1403 1404 (func (export "f64.simple_x4_sum") 1405 (param $i i32) 1406 (param $j i32) 1407 (param $k i32) 1408 (local $x0 f64) (local $x1 f64) (local $x2 f64) (local $x3 f64) 1409 (local $y0 f64) (local $y1 f64) (local $y2 f64) (local $y3 f64) 1410 (local.set $x0 (f64.load offset=0 (local.get $i))) 1411 (local.set $x1 (f64.load offset=8 (local.get $i))) 1412 (local.set $x2 (f64.load offset=16 (local.get $i))) 1413 (local.set $x3 (f64.load offset=24 (local.get $i))) 1414 (local.set $y0 (f64.load offset=0 (local.get $j))) 1415 (local.set $y1 (f64.load offset=8 (local.get $j))) 1416 (local.set $y2 (f64.load offset=16 (local.get $j))) 1417 (local.set $y3 (f64.load offset=24 (local.get $j))) 1418 (f64.store offset=0 (local.get $k) (f64.add (local.get $x0) (local.get $y0))) 1419 (f64.store offset=8 (local.get $k) (f64.add (local.get $x1) (local.get $y1))) 1420 (f64.store offset=16 (local.get $k) (f64.add (local.get $x2) (local.get $y2))) 1421 (f64.store offset=24 (local.get $k) (f64.add (local.get $x3) (local.get $y3))) 1422 ) 1423 1424 (func (export "f64.load") 1425 (param $k i32) (result f64) 1426 (f64.load (local.get $k)) 1427 ) 1428 ) 1429 1430 (assert_return (invoke "f64.simple_x4_sum" (i32.const 0) (i32.const 32) (i32.const 64))) 1431 (assert_return (invoke "f64.load" (i32.const 64)) (f64.const 0x0.0000000000001p-1021)) 1432 (assert_return (invoke "f64.load" (i32.const 72)) (f64.const 0x0p+0)) 1433 (assert_return (invoke "f64.load" (i32.const 80)) (f64.const 0x0.0000000000001p-1022)) 1434 (assert_return (invoke "f64.load" (i32.const 88)) (f64.const -0x0.0000000000001p-1022)) 1435 1436 ;; Test that plain summation is not reassociated, and that Kahan summation 1437 ;; isn't optimized into plain summation. 1438 1439 (module 1440 (memory (data 1441 "\c4\c5\57\24\a5\84\c8\0b\6d\b8\4b\2e\f2\76\17\1c\ca\4a\56\1e\1b\6e\71\22" 1442 "\5d\17\1e\6e\bf\cd\14\5c\c7\21\55\51\39\9c\1f\b2\51\f0\a3\93\d7\c1\2c\ae" 1443 "\7e\a8\28\3a\01\21\f4\0a\58\93\f8\42\77\9f\83\39\6a\5f\ba\f7\0a\d8\51\6a" 1444 "\34\ca\ad\c6\34\0e\d8\26\dc\4c\33\1c\ed\29\90\a8\78\0f\d1\ce\76\31\23\83" 1445 "\b8\35\e8\f2\44\b0\d3\a1\fc\bb\32\e1\b0\ba\69\44\09\d6\d9\7d\ff\2e\c0\5a" 1446 "\36\14\33\14\3e\a9\fa\87\6d\8b\bc\ce\9d\a7\fd\c4\e9\85\3f\dd\d7\e1\18\a6" 1447 "\50\26\72\6e\3f\73\0f\f8\12\93\23\34\61\76\12\48\c0\9b\05\93\eb\ac\86\de" 1448 "\94\3e\55\e8\8c\e8\dd\e4\fc\95\47\be\56\03\21\20\4c\e6\bf\7b\f6\7f\d5\ba" 1449 "\73\1c\c1\14\8f\c4\27\96\b3\bd\33\ff\78\41\5f\c0\5a\ce\f6\67\6e\73\9a\17" 1450 "\66\70\03\f8\ce\27\a3\52\b2\9f\3b\bf\fb\ae\ed\d3\5a\f8\37\57\f0\f5\6e\ef" 1451 "\b1\4d\70\3d\54\a7\01\9a\85\08\48\91\f5\9d\0c\60\87\5b\d9\54\1e\51\6d\88" 1452 "\8e\08\8c\a5\71\3a\56\08\67\46\8f\8f\13\2a\2c\ec\2c\1f\b4\62\2b\6f\41\0a" 1453 "\c4\65\42\a2\31\6b\2c\7d\3e\bb\75\ac\86\97\30\d9\48\cd\9a\1f\56\c4\c6\e4" 1454 "\12\c0\9d\fb\ee\02\8c\ce\1c\f2\1e\a1\78\23\db\c4\1e\49\03\d3\71\cc\08\50" 1455 "\c5\d8\5c\ed\d5\b5\65\ac\b5\c9\21\d2\c9\29\76\de\f0\30\1a\5b\3c\f2\3b\db" 1456 "\3a\39\82\3a\16\08\6f\a8\f1\be\69\69\99\71\a6\05\d3\14\93\2a\16\f2\2f\11" 1457 "\c7\7e\20\bb\91\44\ee\f8\e4\01\53\c0\b9\7f\f0\bf\f0\03\9c\6d\b1\df\a2\44" 1458 "\01\6d\6b\71\2b\5c\b3\21\19\46\5e\8f\db\91\d3\7c\78\6b\b7\12\00\8f\eb\bd" 1459 "\8a\f5\d4\2e\c4\c1\1e\df\73\63\59\47\49\03\0a\b7\cf\24\cf\9c\0e\44\7a\9e" 1460 "\14\fb\42\bf\9d\39\30\9e\a0\ab\2f\d1\ae\9e\6a\83\43\e3\55\7d\85\bf\63\8a" 1461 "\f8\96\10\1f\fe\6d\e7\22\1b\e1\69\46\8a\44\c8\c8\f9\0c\2b\19\07\a5\02\3e" 1462 "\f2\30\10\9a\85\8a\5f\ef\81\45\a0\77\b1\03\10\73\4b\ae\98\9d\47\bf\9a\2d" 1463 "\3a\d5\0f\03\66\e3\3d\53\d9\40\ce\1f\6f\32\2f\21\2b\23\21\6c\62\d4\a7\3e" 1464 "\a8\ce\28\31\2d\00\3d\67\5e\af\a0\cf\2e\d2\b9\6b\84\eb\69\08\3c\62\36\be" 1465 "\12\fd\36\7f\88\3e\ad\bc\0b\c0\41\c4\50\b6\e3\50\31\e8\ce\e2\96\65\55\9c" 1466 "\16\46\e6\b0\2d\3a\e8\81\05\b0\bf\34\f7\bc\10\1c\fb\cc\3c\f1\85\97\42\9f" 1467 "\eb\14\8d\3c\bf\d7\17\88\49\9d\8b\2b\b2\3a\83\d1\4f\04\9e\a1\0f\ad\08\9d" 1468 "\54\af\d1\82\c3\ec\32\2f\02\8f\05\21\2d\a2\b7\e4\f4\6f\2e\81\2b\0b\9c\fc" 1469 "\cb\fe\74\02\f9\db\f4\f3\ea\00\a8\ec\d1\99\74\26\dd\d6\34\d5\25\b1\46\dd" 1470 "\9c\aa\71\f5\60\b0\88\c8\e0\0b\59\5a\25\4f\29\66\f9\e3\2e\fe\e9\da\e5\18" 1471 "\4f\27\62\f4\ce\a4\21\95\74\c7\57\64\27\9a\4c\fd\54\7d\61\ce\c3\ac\87\46" 1472 "\9c\fa\ff\09\ca\79\97\67\24\74\ca\d4\21\83\26\25\19\12\37\64\19\e5\65\e0" 1473 "\74\75\8e\dd\c8\ef\74\c7\d8\21\2b\79\04\51\46\65\60\03\5d\fa\d8\f4\65\a4" 1474 "\9e\5d\23\da\d7\8a\92\80\a4\de\78\3c\f1\57\42\6d\cd\c9\2f\d5\a4\9e\ab\40" 1475 "\f4\cb\1b\d7\a3\ca\fc\eb\a7\01\b2\9a\69\4e\46\9b\18\4e\dd\79\a7\aa\a6\52" 1476 "\39\1e\ef\30\cc\9b\bd\5b\ee\4c\21\6d\30\00\72\b0\46\5f\08\cf\c5\b9\e0\3e" 1477 "\c2\b3\0c\dc\8e\64\de\19\42\79\cf\43\ea\43\5d\8e\88\f7\ab\15\dc\3f\c8\67" 1478 "\20\db\b8\64\b1\47\1f\de\f2\cb\3f\59\9f\d8\46\90\dc\ae\2f\22\f9\e2\31\89" 1479 "\d9\9c\1c\4c\d3\a9\4a\57\84\9c\9f\ea\2c\3c\ae\3c\c3\1e\8b\e5\4e\17\01\25" 1480 "\db\34\46\5f\15\ea\05\0c\7c\d9\45\8c\19\d0\73\8a\96\16\dd\44\f9\05\b7\5b" 1481 "\71\b0\e6\21\36\5f\75\89\91\73\75\ab\7d\ae\d3\73\ec\37\c6\ea\55\75\ef\ea" 1482 "\ab\8b\7b\11\dc\6d\1a\b2\6a\c4\25\cf\aa\e3\9f\49\49\89\cb\37\9b\0a\a7\01" 1483 "\60\70\dc\b7\c8\83\e1\42\f5\be\ad\62\94\ad\8d\a1" 1484 )) 1485 1486 (func (export "f32.kahan_sum") (param $p i32) (param $n i32) (result f32) 1487 (local $sum f32) 1488 (local $c f32) 1489 (local $t f32) 1490 (block $exit 1491 (loop $top 1492 (local.set $t 1493 (f32.sub 1494 (f32.sub 1495 (local.tee $sum 1496 (f32.add 1497 (local.get $c) 1498 (local.tee $t 1499 (f32.sub (f32.load (local.get $p)) (local.get $t)) 1500 ) 1501 ) 1502 ) 1503 (local.get $c) 1504 ) 1505 (local.get $t) 1506 ) 1507 ) 1508 (local.set $p (i32.add (local.get $p) (i32.const 4))) 1509 (local.set $c (local.get $sum)) 1510 (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1)))) 1511 ) 1512 ) 1513 (local.get $sum) 1514 ) 1515 1516 (func (export "f32.plain_sum") (param $p i32) (param $n i32) (result f32) 1517 (local $sum f32) 1518 (block $exit 1519 (loop $top 1520 (local.set $sum (f32.add (local.get $sum) (f32.load (local.get $p)))) 1521 (local.set $p (i32.add (local.get $p) (i32.const 4))) 1522 (local.set $n (i32.add (local.get $n) (i32.const -1))) 1523 (br_if $top (local.get $n)) 1524 ) 1525 ) 1526 (local.get $sum) 1527 ) 1528 ) 1529 1530 (assert_return (invoke "f32.kahan_sum" (i32.const 0) (i32.const 256)) (f32.const -0x1.101a1ap+104)) 1531 (assert_return (invoke "f32.plain_sum" (i32.const 0) (i32.const 256)) (f32.const -0x1.a0343ap+103)) 1532 1533 (module 1534 (memory (data "\13\05\84\42\5d\a2\2c\c6\43\db\55\a9\cd\da\55\e3\73\fc\58\d6\ba\d5\00\fd\83\35\42\88\8b\13\5d\38\4a\47\0d\72\73\a1\1a\ef\c4\45\17\57\d8\c9\46\e0\8d\6c\e1\37\70\c8\83\5b\55\5e\5a\2d\73\1e\56\c8\e1\6d\69\14\78\0a\8a\5a\64\3a\09\c7\a8\87\c5\f0\d3\5d\e6\03\fc\93\be\26\ca\d6\a9\91\60\bd\b0\ed\ae\f7\30\7e\92\3a\6f\a7\59\8e\aa\7d\bf\67\58\2a\54\f8\4e\fe\ed\35\58\a6\51\bf\42\e5\4b\66\27\24\6d\7f\42\2d\28\92\18\ec\08\ae\e7\55\da\b1\a6\65\a5\72\50\47\1b\b8\a9\54\d7\a6\06\5b\0f\42\58\83\8a\17\82\c6\10\43\a0\c0\2e\6d\bc\5a\85\53\72\7f\ad\44\bc\30\3c\55\b2\24\9a\74\3a\9e\e1\d8\0f\70\fc\a9\3a\cd\93\4b\ec\e3\7e\dd\5d\27\cd\f8\a0\9d\1c\11\c0\57\2e\fd\c8\13\32\cc\3a\1a\7d\a3\41\55\ed\c3\82\49\2a\04\1e\ef\73\b9\2e\2e\e3\5f\f4\df\e6\b2\33\0c\39\3f\6f\44\6a\03\c1\42\b9\fa\b1\c8\ed\a5\58\99\7f\ed\b4\72\9e\79\eb\fb\43\82\45\aa\bb\95\d2\ff\28\9e\f6\a1\ad\95\d6\55\95\0d\6f\60\11\c7\78\3e\49\f2\7e\48\f4\a2\71\d0\13\8e\b3\de\99\52\e3\45\74\ea\76\0e\1b\2a\c8\ee\14\01\c4\50\5b\36\3c\ef\ba\72\a2\a6\08\f8\7b\36\9d\f9\ef\0b\c7\56\2d\5c\f0\9d\5d\de\fc\b8\ad\0f\64\0e\97\15\32\26\c2\31\e6\05\1e\ef\cb\17\1b\6d\15\0b\74\5d\d3\2e\f8\6b\86\b4\ba\73\52\53\99\a9\76\20\45\c9\40\80\6b\14\ed\a1\fa\80\46\e6\26\d2\e6\98\c4\57\bf\c4\1c\a4\90\7a\36\94\14\ba\15\89\6e\e6\9c\37\8c\f4\de\12\22\5d\a1\79\50\67\0d\3d\7a\e9\d4\aa\2e\7f\2a\7a\30\3d\ea\5d\12\48\fe\e1\18\cd\a4\57\a2\87\3e\b6\9a\8b\db\da\9d\78\9c\cf\8d\b1\4f\90\b4\34\e0\9d\f6\ca\fe\4c\3b\78\6d\0a\5c\18\9f\61\b9\dd\b4\e0\0f\76\e0\1b\69\0d\5e\58\73\70\5e\0e\2d\a1\7d\ff\20\eb\91\34\92\ac\38\72\2a\1f\8e\71\2e\6a\f1\af\c7\27\70\d9\c4\57\f7\d2\3c\1d\b8\f0\f0\64\cf\dc\ae\be\a3\cc\3e\22\7d\4e\69\21\63\17\ed\03\02\54\9a\0f\50\4e\13\5a\35\a1\22\a4\df\86\c2\74\79\16\b8\69\69\a0\52\5d\11\64\bd\5b\93\fc\69\a0\f4\13\d0\81\51\dd\fa\0c\15\c3\7a\c9\62\7a\a9\1d\c9\e6\5a\b3\5b\97\02\3c\64\22\12\3c\22\90\64\2d\30\54\4c\b4\a1\22\09\57\22\5e\8e\38\2b\02\a8\ae\f6\be\0d\2b\f2\03\ad\fa\10\01\71\77\2a\30\02\95\f6\00\3e\d0\c4\8d\34\19\50\21\0a\bc\50\da\3c\30\d6\3a\31\94\8d\3a\fe\ef\14\57\9d\4b\93\00\96\24\0c\6f\fd\bc\23\76\02\6c\eb\52\72\80\11\7e\80\3a\13\12\38\1d\38\49\95\40\27\8a\44\7b\e8\dc\6d\8c\8c\8e\3c\b5\b3\18\0e\f6\08\1a\84\41\35\ff\8b\b8\93\40\ea\e1\51\1d\89\a5\8d\42\68\29\ea\2f\c1\7a\52\eb\90\5d\4d\d6\80\e3\d7\75\48\ce\ed\d3\01\1c\8d\5b\a5\94\0d\78\cf\f1\06\13\2f\98\02\a4\6d\2e\6c\f2\d5\74\29\89\4c\f9\03\f5\c7\18\ad\7a\f0\68\f8\5c\d6\59\87\6e\d6\3f\06\be\86\20\e3\41\91\22\f3\6e\8b\f0\68\1c\57\a7\fc\b0\7c\9e\99\0b\96\1a\89\5f\e6\0d\7c\08\51\a0\a2\67\9a\47\00\93\6b\f9\28\f0\68\db\62\f1\e0\65\2c\53\33\e0\a7\ca\11\42\30\f6\af\01\c1\65\3d\32\01\6f\ab\2e\be\d3\8b\be\14\c3\ff\ec\fb\f0\f9\c5\0c\05\6f\01\09\6b\e3\34\31\0c\1f\66\a6\42\bc\1a\87\49\16\16\8c\b0\90\0d\34\8c\0a\e1\09\5e\10\a4\6b\56\cc\f0\c9\bb\dc\b8\5c\ce\f6\cc\8d\75\7e\b3\07\88\04\2f\b4\5e\c9\e3\4a\23\73\19\62\6c\9a\03\76\44\86\9c\60\fc\db\72\8f\27\a0\dd\b3\c5\da\ff\f9\ec\6a\b1\7b\d3\cf\50\37\c9\7a\78\0c\e4\3a\b6\f5\e6\f4\98\6e\42\7d\35\73\8b\45\c0\56\97\cd\6d\ce\cf\ad\31\b3\c3\54\fa\ef\d5\c0\f4\6a\5f\54\e7\49\3e\33\0a\30\38\fd\d9\05\ff\a5\3f\57\46\14\b5\91\17\ca\6b\98\23\7a\65\b3\6c\02\b4\cc\79\5d\58\d8\b3\d5\94\ae\f4\6d\75\65\f7\92\bf\7e\47\4c\3c\ee\db\ac\f1\32\5d\fb\6f\41\1c\34\c8\83\4f\c2\58\01\be\05\3e\66\16\a6\04\6d\5d\4f\86\09\27\82\25\12\cd\3a\cd\ce\6b\bc\ca\ac\28\9b\ee\6a\25\86\9e\45\70\c6\d2\bd\3b\7d\42\e5\27\af\c7\1d\f4\81\c8\b3\76\8a\a8\36\a3\ae\2a\e6\18\e1\36\22\ad\f6\25\72\b0\39\8b\01\9a\22\7b\84\c3\2d\5f\72\a4\98\ac\15\70\e7\d4\18\e2\7d\d2\30\7c\33\08\cd\ca\c4\22\85\88\75\81\c6\4a\74\58\8d\e0\e8\ac\c5\ab\75\5a\f4\28\12\f0\18\45\52\f2\97\b2\93\41\6f\8d\7f\db\70\fb\a3\5d\1f\a7\8d\98\20\2b\22\9f\3a\01\b5\8b\1b\d2\cb\14\03\0e\14\14\d2\19\5a\1f\ce\5e\cd\81\79\15\01\ca\de\73\74\8c\56\20\9f\77\2d\25\16\f6\61\51\1d\a4\8e\9b\98\a5\c6\ec\a8\45\57\82\59\78\0d\90\b4\df\51\b0\c3\82\94\cc\b3\53\09\15\6d\96\6c\3a\40\47\b7\4a\7a\05\2f\a1\1e\8c\9d\a0\20\88\fb\52\b7\9f\f3\f3\bb\5f\e7\8a\61\a7\21\b1\ac\fa\09\aa\a4\6c\bc\24\80\ba\2a\e9\65\ff\70\ff\cc\fa\65\87\76\f3\c5\15\ce\cb\e8\42\31\00\0c\91\57\d9\e0\9d\35\54\24\ad\a4\d8\f9\08\67\63\c8\cf\81\dd\90\a2\d7\c4\07\4a\e6\10\6f\67\e7\27\d4\23\59\18\f2\a8\9d\5f\d8\94\30\aa\54\86\4f\87\9d\82\b5\26\ca\a6\96\bf\cf\55\f9\9d\37\01\19\48\43\c5\94\6c\f3\74\97\58\4c\3c\9d\08\e8\04\c2\58\30\76\e1\a0\f8\ea\e9\c5\ae\cf\78\9e\a9\0c\ac\b3\44\42\e0\bc\5d\1b\9c\49\58\4a\1c\19\49\c1\3a\ea\f5\eb\3b\81\a9\4b\70\0c\cc\9e\1a\d3\2f\b7\52\2f\20\3b\eb\64\51\1d\a0\2d\b2\3e\be\13\85\48\92\32\2e\db\5c\a1\e7\8c\45\91\35\01\0a\93\c2\eb\09\ce\f3\d2\22\24\d0\8c\cc\1d\9d\38\c8\4d\e3\82\cc\64\15\06\2d\e7\01\2f\ab\bb\b5\04\4c\92\1c\7a\d6\3f\e8\5f\31\15\0c\dc\e4\31\b4\c4\25\3e\2a\aa\00\9e\c8\e5\21\7a\7f\29\f1\c0\af\1d\5e\e8\63\39\ad\f8\7e\6c\c8\c5\7f\c2\a8\97\27\0a\d9\f4\21\6a\ea\03\09\fb\f7\96\3b\83\79\5f\7c\4b\30\9f\56\35\de\b4\73\d4\95\f0\14\c3\74\2f\0d\a3\1d\4e\8d\31\24\b3\1a\84\85\62\5a\7b\3c\14\39\17\e6\6d\eb\37\c2\00\58\5b\0b\e3\3c\8a\62\e1\f8\35\4b\56\e2\87\60\8b\be\a7\38\91\77\54\a9\5a\24\25\90\9f\a5\42\77\f3\5c\39\df\ff\74\07\76\a1\cd\1f\62\0b\81\81\68\af\05\c1\c0\7f\26\ee\c0\91\a3\6a\7d\29\61\45\27\e5\57\88\dc\0d\97\04\1a\33\a9\44\8a\da\02\10\45\3f\8e\55\a6\76\8c\4d\e3\f1\89\83\c8\d0\f8\9b\50\77\9f\47\df\4c\9c\66\0d\aa\18\b8\5f\4f\c4\01\ce\dc\84\ac\46\9e\69\e1\76\45\6b\61\89\e4\5d\94\bb\11\83\9f\78\d8\0a\d2\f5\7e\5d\43\ea\bc\10\f1\3a\c9\e2\64\fb\53\65\d0\c7\b4\a7\fb\d4\05\53\25\d0\cd\29\88\00\56\25\24\7d\5d\b4\f3\41\9f\e9\b5\f7\ae\64\2c\e3\c9\6d\d5\84\3a\72\12\b8\7a\d9\1b\09\e8\38\da\26\4f\04\ce\03\71\6e\8a\44\7b\5c\81\59\9c\d2\e4\c3\ba\59\a6\e5\28\a7\8f\9a\e4\d5\4e\b9\ca\7f\cb\75\b8\2b\43\3e\b3\15\46\b1\a5\bc\9d\9e\38\15\f1\bd\1b\21\aa\f1\82\00\95\fc\a7\77\47\39\a7\33\43\92\d7\52\40\4b\06\81\8a\a0\bd\f1\6b\99\84\42\5b\e2\3b\c5\5e\12\5c\28\4d\b6\0e\4e\c8\5c\e8\01\8a\c5\e7\e4\9d\42\ee\5d\9c\c4\eb\eb\68\09\27\92\95\9a\11\54\73\c4\12\80\fb\7d\fe\c5\08\60\7f\36\41\e0\10\ba\d6\2b\6c\f1\b4\17\fe\26\34\e3\4b\f8\a8\e3\91\be\4f\2a\fc\da\81\b8\e7\fe\d5\26\50\47\f3\1a\65\32\81\e0\05\b8\4f\32\31\26\00\4a\53\97\c2\c3\0e\2e\a1\26\54\ab\05\8e\56\2f\7d\af\22\84\68\a5\8b\97\f6\a4\fd\a8\cc\75\41\96\86\fd\27\3d\29\86\8d\7f\4c\d4\8e\73\41\f4\1e\e2\dd\58\27\97\ce\9c\94\cf\7a\04\2f\dc\ed" 1535 )) 1536 1537 (func (export "f64.kahan_sum") (param $p i32) (param $n i32) (result f64) 1538 (local $sum f64) 1539 (local $c f64) 1540 (local $t f64) 1541 (block $exit 1542 (loop $top 1543 (local.set $t 1544 (f64.sub 1545 (f64.sub 1546 (local.tee $sum 1547 (f64.add 1548 (local.get $c) 1549 (local.tee $t 1550 (f64.sub (f64.load (local.get $p)) (local.get $t)) 1551 ) 1552 ) 1553 ) 1554 (local.get $c) 1555 ) 1556 (local.get $t) 1557 ) 1558 ) 1559 (local.set $p (i32.add (local.get $p) (i32.const 8))) 1560 (local.set $c (local.get $sum)) 1561 (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1)))) 1562 ) 1563 ) 1564 (local.get $sum) 1565 ) 1566 1567 (func (export "f64.plain_sum") (param $p i32) (param $n i32) (result f64) 1568 (local $sum f64) 1569 (block $exit 1570 (loop $top 1571 (local.set $sum (f64.add (local.get $sum) (f64.load (local.get $p)))) 1572 (local.set $p (i32.add (local.get $p) (i32.const 8))) 1573 (local.set $n (i32.add (local.get $n) (i32.const -1))) 1574 (br_if $top (local.get $n)) 1575 ) 1576 ) 1577 (local.get $sum) 1578 ) 1579 ) 1580 1581 (assert_return (invoke "f64.kahan_sum" (i32.const 0) (i32.const 256)) (f64.const 0x1.dd7cb2a5ffc88p+998)) 1582 (assert_return (invoke "f64.plain_sum" (i32.const 0) (i32.const 256)) (f64.const 0x1.dd7cb2a63fc87p+998)) 1583 1584 ;; Test that -(x - y) is not folded to y - x. 1585 1586 (module 1587 (func (export "f32.no_fold_neg_sub") (param $x f32) (param $y f32) (result f32) 1588 (f32.neg (f32.sub (local.get $x) (local.get $y)))) 1589 1590 (func (export "f64.no_fold_neg_sub") (param $x f64) (param $y f64) (result f64) 1591 (f64.neg (f64.sub (local.get $x) (local.get $y)))) 1592 ) 1593 1594 (assert_return (invoke "f32.no_fold_neg_sub" (f32.const -0.0) (f32.const -0.0)) (f32.const -0.0)) 1595 (assert_return (invoke "f32.no_fold_neg_sub" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0)) 1596 (assert_return (invoke "f32.no_fold_neg_sub" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0)) 1597 (assert_return (invoke "f32.no_fold_neg_sub" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0)) 1598 1599 (assert_return (invoke "f64.no_fold_neg_sub" (f64.const -0.0) (f64.const -0.0)) (f64.const -0.0)) 1600 (assert_return (invoke "f64.no_fold_neg_sub" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0)) 1601 (assert_return (invoke "f64.no_fold_neg_sub" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0)) 1602 (assert_return (invoke "f64.no_fold_neg_sub" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0)) 1603 1604 ;; Test that -(x + y) is not folded to (-x + -y). 1605 1606 (module 1607 (func (export "f32.no_fold_neg_add") (param $x f32) (param $y f32) (result f32) 1608 (f32.neg (f32.add (local.get $x) (local.get $y)))) 1609 1610 (func (export "f64.no_fold_neg_add") (param $x f64) (param $y f64) (result f64) 1611 (f64.neg (f64.add (local.get $x) (local.get $y)))) 1612 ) 1613 1614 (assert_return (invoke "f32.no_fold_neg_add" (f32.const -0.0) (f32.const -0.0)) (f32.const 0.0)) 1615 (assert_return (invoke "f32.no_fold_neg_add" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0)) 1616 (assert_return (invoke "f32.no_fold_neg_add" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0)) 1617 (assert_return (invoke "f32.no_fold_neg_add" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0)) 1618 1619 (assert_return (invoke "f64.no_fold_neg_add" (f64.const -0.0) (f64.const -0.0)) (f64.const 0.0)) 1620 (assert_return (invoke "f64.no_fold_neg_add" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0)) 1621 (assert_return (invoke "f64.no_fold_neg_add" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0)) 1622 (assert_return (invoke "f64.no_fold_neg_add" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0)) 1623 1624 ;; Test that (-x + -y) is not folded to -(x + y). 1625 1626 (module 1627 (func (export "f32.no_fold_add_neg_neg") (param $x f32) (param $y f32) (result f32) 1628 (f32.add (f32.neg (local.get $x)) (f32.neg (local.get $y)))) 1629 1630 (func (export "f64.no_fold_add_neg_neg") (param $x f64) (param $y f64) (result f64) 1631 (f64.add (f64.neg (local.get $x)) (f64.neg (local.get $y)))) 1632 ) 1633 1634 (assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const -0.0) (f32.const -0.0)) (f32.const 0.0)) 1635 (assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0)) 1636 (assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0)) 1637 (assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0)) 1638 1639 (assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const -0.0) (f64.const -0.0)) (f64.const 0.0)) 1640 (assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0)) 1641 (assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0)) 1642 (assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0)) 1643 1644 ;; Test that -x + x is not folded to 0.0. 1645 1646 (module 1647 (func (export "f32.no_fold_add_neg") (param $x f32) (result f32) 1648 (f32.add (f32.neg (local.get $x)) (local.get $x))) 1649 1650 (func (export "f64.no_fold_add_neg") (param $x f64) (result f64) 1651 (f64.add (f64.neg (local.get $x)) (local.get $x))) 1652 ) 1653 1654 (assert_return (invoke "f32.no_fold_add_neg" (f32.const 0.0)) (f32.const 0.0)) 1655 (assert_return (invoke "f32.no_fold_add_neg" (f32.const -0.0)) (f32.const 0.0)) 1656 (assert_return (invoke "f32.no_fold_add_neg" (f32.const inf)) (f32.const nan:canonical)) 1657 (assert_return (invoke "f32.no_fold_add_neg" (f32.const -inf)) (f32.const nan:canonical)) 1658 1659 (assert_return (invoke "f64.no_fold_add_neg" (f64.const 0.0)) (f64.const 0.0)) 1660 (assert_return (invoke "f64.no_fold_add_neg" (f64.const -0.0)) (f64.const 0.0)) 1661 (assert_return (invoke "f64.no_fold_add_neg" (f64.const inf)) (f64.const nan:canonical)) 1662 (assert_return (invoke "f64.no_fold_add_neg" (f64.const -inf)) (f64.const nan:canonical)) 1663 1664 ;; Test that x+x+x+x+x+x is not folded to x * 6. 1665 1666 (module 1667 (func (export "f32.no_fold_6x_via_add") (param $x f32) (result f32) 1668 (f32.add (f32.add (f32.add (f32.add (f32.add 1669 (local.get $x) 1670 (local.get $x)) (local.get $x)) (local.get $x)) 1671 (local.get $x)) (local.get $x))) 1672 1673 (func (export "f64.no_fold_6x_via_add") (param $x f64) (result f64) 1674 (f64.add (f64.add (f64.add (f64.add (f64.add 1675 (local.get $x) 1676 (local.get $x)) (local.get $x)) (local.get $x)) 1677 (local.get $x)) (local.get $x))) 1678 ) 1679 1680 (assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.598a0cp+99)) (f32.const -0x1.03278ap+102)) 1681 (assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.d3e7acp-77)) (f32.const -0x1.5eedc2p-74)) 1682 (assert_return (invoke "f32.no_fold_6x_via_add" (f32.const 0x1.00fa02p-77)) (f32.const 0x1.817702p-75)) 1683 (assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.51f434p-31)) (f32.const -0x1.faee4cp-29)) 1684 (assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.00328ap+80)) (f32.const -0x1.804bcep+82)) 1685 1686 (assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.310e15acaffe6p+68)) (f64.const -0x1.c995208307fdap+70)) 1687 (assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.aad62c78fa9b4p-535)) (f64.const -0x1.4020a15abbf46p-532)) 1688 (assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.f8fbfa94f6ab2p+271)) (f64.const -0x1.7abcfbefb9005p+274)) 1689 (assert_return (invoke "f64.no_fold_6x_via_add" (f64.const 0x1.756ccc2830a8ep+751)) (f64.const 0x1.1811991e247ebp+754)) 1690 (assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.8fd1ab1d2402ap+234)) (f64.const -0x1.2bdd4055db01fp+237)) 1691 1692 ;; Test that (x/y)/z is not optimized to x/(y*z), 1693 ;; which is an "allowable alternative Form" in Fortran. 1694 1695 (module 1696 (func (export "f32.no_fold_div_div") (param $x f32) (param $y f32) (param $z f32) (result f32) 1697 (f32.div (f32.div (local.get $x) (local.get $y)) (local.get $z))) 1698 1699 (func (export "f64.no_fold_div_div") (param $x f64) (param $y f64) (param $z f64) (result f64) 1700 (f64.div (f64.div (local.get $x) (local.get $y)) (local.get $z))) 1701 ) 1702 1703 (assert_return (invoke "f32.no_fold_div_div" (f32.const -0x1.f70228p+78) (f32.const -0x1.fbc612p-16) (f32.const -0x1.8c379p+10)) (f32.const -0x1.47b43cp+83)) 1704 (assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.d29d2ep-70) (f32.const 0x1.f3a17ep+110) (f32.const -0x1.64d41p-112)) (f32.const -0x0p+0)) 1705 (assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.867f98p+43) (f32.const 0x1.30acfcp-105) (f32.const 0x1.e210d8p+105)) (f32.const inf)) 1706 (assert_return (invoke "f32.no_fold_div_div" (f32.const -0x1.c4001ap-14) (f32.const -0x1.9beb6cp+124) (f32.const -0x1.74f34cp-43)) (f32.const -0x1.819874p-96)) 1707 (assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.db0e6ep+46) (f32.const 0x1.55eea2p+56) (f32.const -0x1.f3134p+124)) (f32.const -0x1.6cep-135)) 1708 1709 (assert_return (invoke "f64.no_fold_div_div" (f64.const 0x1.b4dc8ec3c7777p+337) (f64.const 0x1.9f95ac2d1863p+584) (f64.const -0x1.d4318abba341ep-782)) (f64.const -0x1.2649159d87e02p+534)) 1710 (assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.ac53af5eb445fp+791) (f64.const 0x1.8549c0a4ceb13p-29) (f64.const 0x1.64e384003c801p+316)) (f64.const -0x1.9417cdccbae91p+503)) 1711 (assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.d2685afb27327p+2) (f64.const -0x1.abb1eeed3dbebp+880) (f64.const 0x1.a543e2e6968a3p+170)) (f64.const 0x0.0000002a69a5fp-1022)) 1712 (assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.47ddede78ad1cp+825) (f64.const 0x1.6d932d070a367p-821) (f64.const 0x1.79cf18cc64fp+961)) (f64.const -inf)) 1713 (assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.f73d4979a9379p-888) (f64.const 0x1.4d83b53e97788p-596) (f64.const -0x1.f8f86c9603b5bp-139)) (f64.const 0x1.87a7bd89c586cp-154)) 1714 1715 ;; Test that (x/y)*(z/w) is not optimized to (x*z)/(y*w), example from 1716 ;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html 1717 ;; section 7.4.1: FORTRAN Floating Point in a Nutshell: Philosophy 1718 1719 (module 1720 (func (export "f32.no_fold_mul_divs") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32) 1721 (f32.mul (f32.div (local.get $x) (local.get $y)) (f32.div (local.get $z) (local.get $w)))) 1722 1723 (func (export "f64.no_fold_mul_divs") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64) 1724 (f64.mul (f64.div (local.get $x) (local.get $y)) (f64.div (local.get $z) (local.get $w)))) 1725 ) 1726 1727 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.c483bep-109) (f32.const 0x1.ee1c3cp-92) (f32.const 0x1.800756p-88) (f32.const -0x1.95b972p+4)) (f32.const 0x1.bbd30cp-110)) 1728 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.0f4262p+102) (f32.const 0x1.248498p+25) (f32.const 0x1.f66a7cp-17) (f32.const 0x1.897fc8p-3)) (f32.const -0x1.2f1aa4p+63)) 1729 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.df5f22p+33) (f32.const -0x1.fcee3ep+39) (f32.const -0x1.9ea914p+29) (f32.const -0x1.2c4d3p+10)) (f32.const 0x1.4cf51cp+13)) 1730 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.f568bcp+109) (f32.const 0x1.d9963p-34) (f32.const 0x1.37a87ap-16) (f32.const 0x1.a1524ap+78)) (f32.const -inf)) 1731 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const 0x1.3dd592p-53) (f32.const -0x1.332c22p-64) (f32.const 0x1.b01064p-91) (f32.const 0x1.92bb3ap-36)) (f32.const -0x1.1c2dbp-44)) 1732 1733 (assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.363d6764f7b12p-819) (f64.const -0x1.ed5471f660b5fp-464) (f64.const -0x1.671b0a7f3a42p+547) (f64.const 0x1.0633be34ba1f2p+186)) (f64.const -0x1.b8fa2b76baeebp+5)) 1734 (assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.37880182e0fa8p+115) (f64.const 0x1.f842631576147p-920) (f64.const -0x1.999372231d156p+362) (f64.const -0x1.d5db481ab9554p+467)) (f64.const -inf)) 1735 (assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.9a747c8d4b541p+308) (f64.const -0x1.99092ad6bbdc8p+192) (f64.const -0x1.cb23755c20101p-140) (f64.const -0x1.de8716f6b0b6ap+732)) (f64.const 0x1.ecf584c8466a5p-757)) 1736 (assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.c424b2ece903dp+129) (f64.const -0x1.568ce281db37fp-347) (f64.const 0x1.53900b99fd3dp-957) (f64.const 0x1.5c33952254dadp+223)) (f64.const 0x0p+0)) 1737 (assert_return (invoke "f64.no_fold_mul_divs" (f64.const 0x1.a8ec2cecb32a9p-18) (f64.const 0x1.58acab0051851p-277) (f64.const 0x1.35e87c9077f7fp-620) (f64.const -0x1.925ee37ffb386p+352)) (f64.const -0x1.e6286970b31bfp-714)) 1738 1739 ;; Test that (x/z)+(y/z) is not optimized to (x+y)/z. 1740 1741 (module 1742 (func (export "f32.no_fold_add_divs") (param $x f32) (param $y f32) (param $z f32) (result f32) 1743 (f32.add (f32.div (local.get $x) (local.get $z)) (f32.div (local.get $y) (local.get $z)))) 1744 1745 (func (export "f64.no_fold_add_divs") (param $x f64) (param $y f64) (param $z f64) (result f64) 1746 (f64.add (f64.div (local.get $x) (local.get $z)) (f64.div (local.get $y) (local.get $z)))) 1747 ) 1748 1749 (assert_return (invoke "f32.no_fold_add_divs" (f32.const 0x1.795e7p+8) (f32.const -0x1.48a5eep-5) (f32.const -0x1.9a244cp+126)) (f32.const -0x1.d709b6p-119)) 1750 (assert_return (invoke "f32.no_fold_add_divs" (f32.const -0x1.ae89e8p-63) (f32.const -0x1.e9903ep-49) (f32.const -0x1.370a8cp+47)) (f32.const 0x1.92f3f6p-96)) 1751 (assert_return (invoke "f32.no_fold_add_divs" (f32.const -0x1.626408p-46) (f32.const 0x1.2ee5b2p-64) (f32.const -0x1.ecefaap+48)) (f32.const 0x1.701864p-95)) 1752 (assert_return (invoke "f32.no_fold_add_divs" (f32.const -0x1.061d3p-101) (f32.const 0x1.383492p-98) (f32.const -0x1.1d92d2p+88)) (f32.const 0x0p+0)) 1753 (assert_return (invoke "f32.no_fold_add_divs" (f32.const 0x1.1ea39ep-10) (f32.const 0x1.a7fffep-3) (f32.const 0x1.6fc574p-123)) (f32.const 0x1.28b2dep+120)) 1754 1755 (assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.c5fcc3273b136p+430) (f64.const 0x1.892a09eed8f6fp+434) (f64.const 0x1.8258b71e64397p+911)) (f64.const 0x1.e36eb9706ad82p-478)) 1756 (assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.2215d4061b5b3p+53) (f64.const 0x1.fb6184d97f27cp+5) (f64.const -0x1.f3bb59dacc0ebp-957)) (f64.const 0x1.2934eb0118be3p+1009)) 1757 (assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.e7a4533741d8ep-967) (f64.const 0x1.a519bb7feb802p-976) (f64.const 0x1.1f8a43454e51ap+504)) (f64.const 0x0p+0)) 1758 (assert_return (invoke "f64.no_fold_add_divs" (f64.const 0x1.991c6cf93e2b4p+313) (f64.const -0x1.f2f7432698d11p+329) (f64.const 0x1.0d8c1b2453617p-126)) (f64.const -0x1.d9e1d84ddd1d4p+455)) 1759 (assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.d436849dc1271p-728) (f64.const 0x1.19d1c1450e52dp-755) (f64.const 0x1.fa1be69ea06fep-70)) (f64.const -0x1.d9a9b1c2f5623p-659)) 1760 1761 ;; Test that sqrt(x*x) is not optimized to abs(x). 1762 1763 (module 1764 (func (export "f32.no_fold_sqrt_square") (param $x f32) (result f32) 1765 (f32.sqrt (f32.mul (local.get $x) (local.get $x)))) 1766 1767 (func (export "f64.no_fold_sqrt_square") (param $x f64) (result f64) 1768 (f64.sqrt (f64.mul (local.get $x) (local.get $x)))) 1769 ) 1770 1771 (assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.5cb316p-66)) (f32.const 0x1.5cb322p-66)) 1772 (assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.b0f9e4p-73)) (f32.const 0x1.b211b2p-73)) 1773 (assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.de417cp-71)) (f32.const 0x1.de65b8p-71)) 1774 (assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.64c872p-86)) (f32.const 0x0p+0)) 1775 (assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.e199e4p+108)) (f32.const inf)) 1776 1777 (assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.1759d657203fdp-529)) (f64.const 0x1.1759dd57545f3p-529)) 1778 (assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.4c68de1c78d83p-514)) (f64.const 0x1.4c68de1c78d81p-514)) 1779 (assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.214736edb6e1ep-521)) (f64.const 0x1.214736ed9cf8dp-521)) 1780 (assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.0864b9f68457p-616)) (f64.const 0x0p+0)) 1781 (assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.b2a9855995abap+856)) (f64.const inf)) 1782 1783 ;; Test that sqrt(x)*sqrt(y) is not optimized to sqrt(x*y). 1784 1785 (module 1786 (func (export "f32.no_fold_mul_sqrts") (param $x f32) (param $y f32) (result f32) 1787 (f32.mul (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y)))) 1788 1789 (func (export "f64.no_fold_mul_sqrts") (param $x f64) (param $y f64) (result f64) 1790 (f64.mul (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y)))) 1791 ) 1792 1793 (assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.dddda8p-125) (f32.const -0x1.25d22ap-83)) (f32.const nan:canonical)) 1794 (assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.418d14p-92) (f32.const 0x1.c6535cp-32)) (f32.const 0x1.7e373ap-62)) 1795 (assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.4de7ep-88) (f32.const 0x1.84ff18p+6)) (f32.const 0x1.686668p-41)) 1796 (assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.78091ep+101) (f32.const 0x1.81feb8p-9)) (f32.const 0x1.7cfb98p+46)) 1797 (assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.583ap-56) (f32.const 0x1.14ba2ap-9)) (f32.const 0x1.b47a8ep-33)) 1798 1799 (assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const -0x1.d1144cc28cdbep-635) (f64.const -0x1.bf9bc373d3b6ap-8)) (f64.const nan:canonical)) 1800 (assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.5a7eb976bebc9p-643) (f64.const 0x1.f30cb8865a4cap-404)) (f64.const 0x1.260a1032d6e76p-523)) 1801 (assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.711a0c1707935p-89) (f64.const 0x1.6fb5de51a20d3p-913)) (f64.const 0x1.7067ca28e31ecp-501)) 1802 (assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.fb0bbea33b076p-363) (f64.const 0x1.d963b34894158p-573)) (f64.const 0x1.e9edc1fa624afp-468)) 1803 (assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.8676eab7a4d0dp+24) (f64.const 0x1.75a58231ba7a5p+513)) (f64.const 0x1.0e16aebe203b3p+269)) 1804 1805 ;; Test that sqrt(x)/sqrt(y) is not optimized to sqrt(x/y). 1806 1807 (module 1808 (func (export "f32.no_fold_div_sqrts") (param $x f32) (param $y f32) (result f32) 1809 (f32.div (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y)))) 1810 1811 (func (export "f64.no_fold_div_sqrts") (param $x f64) (param $y f64) (result f64) 1812 (f64.div (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y)))) 1813 ) 1814 1815 (assert_return (invoke "f32.no_fold_div_sqrts" (f32.const -0x1.bea9bap+25) (f32.const -0x1.db776ep-58)) (f32.const nan:canonical)) 1816 (assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b983b6p+32) (f32.const 0x1.901f1ep+27)) (f32.const 0x1.7c4df6p+2)) 1817 (assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.d45e72p-120) (f32.const 0x1.ab49ccp+15)) (f32.const 0x1.7b0b04p-68)) 1818 (assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b2e444p+59) (f32.const 0x1.5b8b16p-30)) (f32.const 0x1.94fca8p+44)) 1819 (assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.835aa6p-112) (f32.const 0x1.d17128p-103)) (f32.const 0x1.4a468p-5)) 1820 1821 (assert_return (invoke "f64.no_fold_div_sqrts" (f64.const -0x1.509fc16411167p-711) (f64.const -0x1.9c4255f5d6517p-187)) (f64.const nan:canonical)) 1822 (assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.b6897bddac76p-587) (f64.const 0x1.104578b4c91f3p+541)) (f64.const 0x1.44e4f21f26cc9p-564)) 1823 (assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.ac83451b08989p+523) (f64.const 0x1.8da575c6d12b8p-109)) (f64.const 0x1.09c003991ce17p+316)) 1824 (assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.bab7836456417p-810) (f64.const 0x1.1ff60d03ba607p+291)) (f64.const 0x1.c0e6c833bf657p-551)) 1825 (assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.a957816ad9515p-789) (f64.const 0x1.8c18a3a222ab1p+945)) (f64.const 0x1.0948539781e92p-867)) 1826 1827 ;; Test that (x*sqrt(y))/y is not optimized to x/sqrt(y). 1828 1829 (module 1830 (func (export "f32.no_fold_mul_sqrt_div") (param $x f32) (param $y f32) (result f32) 1831 (f32.div (f32.mul (local.get $x) (f32.sqrt (local.get $y))) (local.get $y))) 1832 1833 (func (export "f64.no_fold_mul_sqrt_div") (param $x f64) (param $y f64) (result f64) 1834 (f64.div (f64.mul (local.get $x) (f64.sqrt (local.get $y))) (local.get $y))) 1835 ) 1836 1837 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.f4a7cap+81) (f32.const 0x1.c09adep+92)) (f32.const -inf)) 1838 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.90bf1cp-120) (f32.const 0x1.8dbe88p-97)) (f32.const -0x0p+0)) 1839 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const 0x1.8570e8p+29) (f32.const 0x1.217d3p-128)) (f32.const 0x1.6e391ap+93)) 1840 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.5b4652p+43) (f32.const 0x1.a9d71cp+112)) (f32.const -0x1.0d423ap-13)) 1841 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.910604p+8) (f32.const 0x1.0ca912p+7)) (f32.const -0x1.14cdecp+5)) 1842 1843 (assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.1dcdeb857305fp+698) (f64.const 0x1.a066171c40eb9p+758)) (f64.const inf)) 1844 (assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.8b4f1c218e2abp-827) (f64.const 0x1.5e1ee65953b0bp-669)) (f64.const -0x0p+0)) 1845 (assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.74ee531ddba38p-425) (f64.const 0x1.f370f758857f3p+560)) (f64.const 0x1.0aff34269583ep-705)) 1846 (assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.27f216b0da6c5p+352) (f64.const 0x1.8e0b4e0b9fd7ep-483)) (f64.const -0x1.4fa558aad514ep+593)) 1847 (assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.4c6955df9912bp+104) (f64.const 0x1.0cca42c9d371ep+842)) (f64.const 0x1.4468072f54294p-317)) 1848 1849 ;; Test that subnormals are not flushed even in an intermediate value in an 1850 ;; expression with a normal result. 1851 1852 (module 1853 (func (export "f32.no_flush_intermediate_subnormal") (param $x f32) (param $y f32) (param $z f32) (result f32) 1854 (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z))) 1855 1856 (func (export "f64.no_flush_intermediate_subnormal") (param $x f64) (param $y f64) (param $z f64) (result f64) 1857 (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z))) 1858 ) 1859 1860 (assert_return (invoke "f32.no_flush_intermediate_subnormal" (f32.const 0x1p-126) (f32.const 0x1p-23) (f32.const 0x1p23)) (f32.const 0x1p-126)) 1861 (assert_return (invoke "f64.no_flush_intermediate_subnormal" (f64.const 0x1p-1022) (f64.const 0x1p-52) (f64.const 0x1p52)) (f64.const 0x1p-1022)) 1862 1863 ;; Test corner cases of John Hauser's microarchitectural recoding scheme. 1864 ;; https://github.com/riscv/riscv-tests/blob/695b86a6fcbe06ffbed8891af7e6fe7bf2062543/isa/rv64uf/recoding.S 1865 1866 (module 1867 (func (export "f32.recoding_eq") (param $x f32) (param $y f32) (result i32) 1868 (f32.eq (f32.mul (local.get $x) (local.get $y)) (local.get $x))) 1869 1870 (func (export "f32.recoding_le") (param $x f32) (param $y f32) (result i32) 1871 (f32.le (f32.mul (local.get $x) (local.get $y)) (local.get $x))) 1872 1873 (func (export "f32.recoding_lt") (param $x f32) (param $y f32) (result i32) 1874 (f32.lt (f32.mul (local.get $x) (local.get $y)) (local.get $x))) 1875 1876 (func (export "f64.recoding_eq") (param $x f64) (param $y f64) (result i32) 1877 (f64.eq (f64.mul (local.get $x) (local.get $y)) (local.get $x))) 1878 1879 (func (export "f64.recoding_le") (param $x f64) (param $y f64) (result i32) 1880 (f64.le (f64.mul (local.get $x) (local.get $y)) (local.get $x))) 1881 1882 (func (export "f64.recoding_lt") (param $x f64) (param $y f64) (result i32) 1883 (f64.lt (f64.mul (local.get $x) (local.get $y)) (local.get $x))) 1884 1885 (func (export "recoding_demote") (param $x f64) (param $y f32) (result f32) 1886 (f32.mul (f32.demote_f64 (local.get $x)) (local.get $y))) 1887 ) 1888 1889 (assert_return (invoke "f32.recoding_eq" (f32.const -inf) (f32.const 3.0)) (i32.const 1)) 1890 (assert_return (invoke "f32.recoding_le" (f32.const -inf) (f32.const 3.0)) (i32.const 1)) 1891 (assert_return (invoke "f32.recoding_lt" (f32.const -inf) (f32.const 3.0)) (i32.const 0)) 1892 1893 (assert_return (invoke "f32.recoding_eq" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1)) 1894 (assert_return (invoke "f32.recoding_le" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1)) 1895 (assert_return (invoke "f32.recoding_lt" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0)) 1896 1897 (assert_return (invoke "f64.recoding_eq" (f64.const -inf) (f64.const 3.0)) (i32.const 1)) 1898 (assert_return (invoke "f64.recoding_le" (f64.const -inf) (f64.const 3.0)) (i32.const 1)) 1899 (assert_return (invoke "f64.recoding_lt" (f64.const -inf) (f64.const 3.0)) (i32.const 0)) 1900 1901 (assert_return (invoke "f64.recoding_eq" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1)) 1902 (assert_return (invoke "f64.recoding_le" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1)) 1903 (assert_return (invoke "f64.recoding_lt" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0)) 1904 1905 (assert_return (invoke "recoding_demote" (f64.const 0x1.4c8f8p-132) (f32.const 1221)) (f32.const 0x1.8c8a1cp-122)) 1906 1907 ;; Test that division is not done as on an extended-base system. 1908 ;; http://www.ucbtest.org/goldberg/addendum.html 1909 1910 (module 1911 (func (export "f32.no_extended_precision_div") (param $x f32) (param $y f32) (param $z f32) (result i32) 1912 (f32.eq (f32.div (local.get $x) (local.get $y)) (local.get $z))) 1913 1914 (func (export "f64.no_extended_precision_div") (param $x f64) (param $y f64) (param $z f64) (result i32) 1915 (f64.eq (f64.div (local.get $x) (local.get $y)) (local.get $z))) 1916 ) 1917 1918 (assert_return (invoke "f32.no_extended_precision_div" (f32.const 3.0) (f32.const 7.0) (f32.const 0x1.b6db6ep-2)) (i32.const 1)) 1919 (assert_return (invoke "f64.no_extended_precision_div" (f64.const 3.0) (f64.const 7.0) (f64.const 0x1.b6db6db6db6dbp-2)) (i32.const 1)) 1920 1921 ;; a*x + b*x == (a+b)*x for all x only if the operations a*x, b*x, and (a+b) 1922 ;; are all exact operations, which is true only if a and b are exact powers of 1923 ;; 2. Even then, if a==-b and x==-0, then a*x+b*x==0.0, (a+b)*x==-0.0. 1924 ;; https://dlang.org/d-floating-point.html 1925 1926 (module 1927 (func (export "f32.no_distribute_exact") (param $x f32) (result f32) 1928 (f32.add (f32.mul (f32.const -8.0) (local.get $x)) (f32.mul (f32.const 8.0) (local.get $x)))) 1929 1930 (func (export "f64.no_distribute_exact") (param $x f64) (result f64) 1931 (f64.add (f64.mul (f64.const -8.0) (local.get $x)) (f64.mul (f64.const 8.0) (local.get $x)))) 1932 ) 1933 1934 (assert_return (invoke "f32.no_distribute_exact" (f32.const -0.0)) (f32.const 0.0)) 1935 (assert_return (invoke "f64.no_distribute_exact" (f64.const -0.0)) (f64.const 0.0)) 1936 1937 ;; Test that various approximations of sqrt(2), sqrt(3), and sqrt(5) compute the 1938 ;; expected approximation. 1939 ;; https://xkcd.com/1047/ 1940 (module 1941 (func (export "f32.sqrt") (param f32) (result f32) 1942 (f32.sqrt (local.get 0))) 1943 1944 (func (export "f32.xkcd_sqrt_2") (param f32) (param f32) (param f32) (param f32) (result f32) 1945 (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (f32.sub (local.get 3) (local.get 2))))) 1946 1947 (func (export "f32.xkcd_sqrt_3") (param f32) (param f32) (param f32) (result f32) 1948 (f32.div (f32.mul (local.get 0) (local.get 1)) (local.get 2))) 1949 1950 (func (export "f32.xkcd_sqrt_5") (param f32) (param f32) (param f32) (result f32) 1951 (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (local.get 0)))) 1952 1953 (func (export "f32.xkcd_better_sqrt_5") (param f32) (param f32) (param f32) (param f32) (result f32) 1954 (f32.div (f32.add (local.get 0) (f32.mul (local.get 1) (local.get 2))) (f32.sub (local.get 3) (f32.mul (local.get 1) (local.get 2))))) 1955 1956 (func (export "f64.sqrt") (param f64) (result f64) 1957 (f64.sqrt (local.get 0))) 1958 1959 (func (export "f64.xkcd_sqrt_2") (param f64) (param f64) (param f64) (param f64) (result f64) 1960 (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (f64.sub (local.get 3) (local.get 2))))) 1961 1962 (func (export "f64.xkcd_sqrt_3") (param f64) (param f64) (param f64) (result f64) 1963 (f64.div (f64.mul (local.get 0) (local.get 1)) (local.get 2))) 1964 1965 (func (export "f64.xkcd_sqrt_5") (param f64) (param f64) (param f64) (result f64) 1966 (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (local.get 0)))) 1967 1968 (func (export "f64.xkcd_better_sqrt_5") (param f64) (param f64) (param f64) (param f64) (result f64) 1969 (f64.div (f64.add (local.get 0) (f64.mul (local.get 1) (local.get 2))) (f64.sub (local.get 3) (f64.mul (local.get 1) (local.get 2))))) 1970 ) 1971 1972 (assert_return (invoke "f32.sqrt" (f32.const 2.0)) (f32.const 0x1.6a09e6p+0)) 1973 (assert_return (invoke "f32.xkcd_sqrt_2" (f32.const 3.0) (f32.const 5.0) (f32.const 0x1.921fb6p+1) (f32.const 7.0)) (f32.const 0x1.6a0a54p+0)) 1974 (assert_return (invoke "f32.sqrt" (f32.const 3.0)) (f32.const 0x1.bb67aep+0)) 1975 (assert_return (invoke "f32.xkcd_sqrt_3" (f32.const 2.0) (f32.const 0x1.5bf0a8p+1) (f32.const 0x1.921fb6p+1)) (f32.const 0x1.bb02d4p+0)) 1976 (assert_return (invoke "f32.sqrt" (f32.const 5.0)) (f32.const 0x1.1e377ap+1)) 1977 (assert_return (invoke "f32.xkcd_sqrt_5" (f32.const 2.0) (f32.const 0x1.5bf0a8p+1) (f32.const 3.0)) (f32.const 0x1.1e2d58p+1)) 1978 (assert_return (invoke "f32.xkcd_better_sqrt_5" (f32.const 13.0) (f32.const 4.0) (f32.const 0x1.921fb6p+1) (f32.const 24.0)) (f32.const 0x1.1e377ap+1)) 1979 1980 (assert_return (invoke "f64.sqrt" (f64.const 2.0)) (f64.const 0x1.6a09e667f3bcdp+0)) 1981 (assert_return (invoke "f64.xkcd_sqrt_2" (f64.const 3.0) (f64.const 5.0) (f64.const 0x1.921fb54442d18p+1) (f64.const 7.0)) (f64.const 0x1.6a0a5362b055fp+0)) 1982 (assert_return (invoke "f64.sqrt" (f64.const 3.0)) (f64.const 0x1.bb67ae8584caap+0)) 1983 (assert_return (invoke "f64.xkcd_sqrt_3" (f64.const 2.0) (f64.const 0x1.5bf0a8b145769p+1) (f64.const 0x1.921fb54442d18p+1)) (f64.const 0x1.bb02d4eca8f95p+0)) 1984 (assert_return (invoke "f64.sqrt" (f64.const 5.0)) (f64.const 0x1.1e3779b97f4a8p+1)) 1985 (assert_return (invoke "f64.xkcd_sqrt_5" (f64.const 2.0) (f64.const 0x1.5bf0a8b145769p+1) (f64.const 3.0)) (f64.const 0x1.1e2d58d8b3bcep+1)) 1986 (assert_return (invoke "f64.xkcd_better_sqrt_5" (f64.const 13.0) (f64.const 4.0) (f64.const 0x1.921fb54442d18p+1) (f64.const 24.0)) (f64.const 0x1.1e3778509a5a3p+1)) 1987 1988 ;; Compute the floating-point radix. 1989 ;; M. A. Malcom. Algorithms to reveal properties of floating-point arithmetic. 1990 ;; Communications of the ACM, 15(11):949-951, November 1972. 1991 (module 1992 (func (export "f32.compute_radix") (param $0 f32) (param $1 f32) (result f32) 1993 (loop $label$0 1994 (br_if $label$0 1995 (f32.eq 1996 (f32.add 1997 (f32.sub 1998 (f32.add 1999 (local.tee $0 (f32.add (local.get $0) (local.get $0))) 2000 (f32.const 1) 2001 ) 2002 (local.get $0) 2003 ) 2004 (f32.const -1) 2005 ) 2006 (f32.const 0) 2007 ) 2008 ) 2009 ) 2010 (loop $label$2 2011 (br_if $label$2 2012 (f32.ne 2013 (f32.sub 2014 (f32.sub 2015 (f32.add 2016 (local.get $0) 2017 (local.tee $1 (f32.add (local.get $1) (f32.const 1))) 2018 ) 2019 (local.get $0) 2020 ) 2021 (local.get $1) 2022 ) 2023 (f32.const 0) 2024 ) 2025 ) 2026 ) 2027 (local.get $1) 2028 ) 2029 2030 (func (export "f64.compute_radix") (param $0 f64) (param $1 f64) (result f64) 2031 (loop $label$0 2032 (br_if $label$0 2033 (f64.eq 2034 (f64.add 2035 (f64.sub 2036 (f64.add 2037 (local.tee $0 (f64.add (local.get $0) (local.get $0))) 2038 (f64.const 1) 2039 ) 2040 (local.get $0) 2041 ) 2042 (f64.const -1) 2043 ) 2044 (f64.const 0) 2045 ) 2046 ) 2047 ) 2048 (loop $label$2 2049 (br_if $label$2 2050 (f64.ne 2051 (f64.sub 2052 (f64.sub 2053 (f64.add 2054 (local.get $0) 2055 (local.tee $1 (f64.add (local.get $1) (f64.const 1))) 2056 ) 2057 (local.get $0) 2058 ) 2059 (local.get $1) 2060 ) 2061 (f64.const 0) 2062 ) 2063 ) 2064 ) 2065 (local.get $1) 2066 ) 2067 ) 2068 2069 (assert_return (invoke "f32.compute_radix" (f32.const 1.0) (f32.const 1.0)) (f32.const 2.0)) 2070 (assert_return (invoke "f64.compute_radix" (f64.const 1.0) (f64.const 1.0)) (f64.const 2.0)) 2071 2072 ;; Test that (x - 1) * y + y is not optimized to x * y. 2073 ;; http://blog.frama-c.com/index.php?post/2013/05/14/Contrarianism 2074 2075 (module 2076 (func (export "f32.no_fold_sub1_mul_add") (param $x f32) (param $y f32) (result f32) 2077 (f32.add (f32.mul (f32.sub (local.get $x) (f32.const 1.0)) (local.get $y)) (local.get $y))) 2078 2079 (func (export "f64.no_fold_sub1_mul_add") (param $x f64) (param $y f64) (result f64) 2080 (f64.add (f64.mul (f64.sub (local.get $x) (f64.const 1.0)) (local.get $y)) (local.get $y))) 2081 ) 2082 2083 (assert_return (invoke "f32.no_fold_sub1_mul_add" (f32.const 0x1p-32) (f32.const 1.0)) (f32.const 0x0p+0)) 2084 (assert_return (invoke "f64.no_fold_sub1_mul_add" (f64.const 0x1p-64) (f64.const 1.0)) (f64.const 0x0p+0)) 2085 2086 ;; Test that x+z >= y+z is not optimized to x >= y (monotonicity). 2087 ;; http://cs.nyu.edu/courses/spring13/CSCI-UA.0201-003/lecture6.pdf 2088 2089 (module 2090 (func (export "f32.no_fold_add_le_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32) 2091 (f32.le (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z)))) 2092 2093 (func (export "f32.no_fold_add_ge_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32) 2094 (f32.ge (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z)))) 2095 2096 (func (export "f64.no_fold_add_le_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32) 2097 (f64.le (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z)))) 2098 2099 (func (export "f64.no_fold_add_ge_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32) 2100 (f64.ge (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z)))) 2101 ) 2102 2103 (assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const 0.0) (f32.const 0.0) (f32.const nan)) (i32.const 0)) 2104 (assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const inf) (f32.const -inf) (f32.const inf)) (i32.const 0)) 2105 (assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const 0.0) (f64.const 0.0) (f64.const nan)) (i32.const 0)) 2106 (assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const inf) (f64.const -inf) (f64.const inf)) (i32.const 0)) 2107 2108 ;; Test that !(x < y) and friends are not optimized to x >= y and friends. 2109 2110 (module 2111 (func (export "f32.not_lt") (param $x f32) (param $y f32) (result i32) 2112 (i32.eqz (f32.lt (local.get $x) (local.get $y)))) 2113 2114 (func (export "f32.not_le") (param $x f32) (param $y f32) (result i32) 2115 (i32.eqz (f32.le (local.get $x) (local.get $y)))) 2116 2117 (func (export "f32.not_gt") (param $x f32) (param $y f32) (result i32) 2118 (i32.eqz (f32.gt (local.get $x) (local.get $y)))) 2119 2120 (func (export "f32.not_ge") (param $x f32) (param $y f32) (result i32) 2121 (i32.eqz (f32.ge (local.get $x) (local.get $y)))) 2122 2123 (func (export "f64.not_lt") (param $x f64) (param $y f64) (result i32) 2124 (i32.eqz (f64.lt (local.get $x) (local.get $y)))) 2125 2126 (func (export "f64.not_le") (param $x f64) (param $y f64) (result i32) 2127 (i32.eqz (f64.le (local.get $x) (local.get $y)))) 2128 2129 (func (export "f64.not_gt") (param $x f64) (param $y f64) (result i32) 2130 (i32.eqz (f64.gt (local.get $x) (local.get $y)))) 2131 2132 (func (export "f64.not_ge") (param $x f64) (param $y f64) (result i32) 2133 (i32.eqz (f64.ge (local.get $x) (local.get $y)))) 2134 ) 2135 2136 (assert_return (invoke "f32.not_lt" (f32.const nan) (f32.const 0.0)) (i32.const 1)) 2137 (assert_return (invoke "f32.not_le" (f32.const nan) (f32.const 0.0)) (i32.const 1)) 2138 (assert_return (invoke "f32.not_gt" (f32.const nan) (f32.const 0.0)) (i32.const 1)) 2139 (assert_return (invoke "f32.not_ge" (f32.const nan) (f32.const 0.0)) (i32.const 1)) 2140 (assert_return (invoke "f64.not_lt" (f64.const nan) (f64.const 0.0)) (i32.const 1)) 2141 (assert_return (invoke "f64.not_le" (f64.const nan) (f64.const 0.0)) (i32.const 1)) 2142 (assert_return (invoke "f64.not_gt" (f64.const nan) (f64.const 0.0)) (i32.const 1)) 2143 (assert_return (invoke "f64.not_ge" (f64.const nan) (f64.const 0.0)) (i32.const 1)) 2144 2145 ;; Test that a method for approximating a "machine epsilon" produces the expected 2146 ;; approximation. 2147 ;; http://blogs.mathworks.com/cleve/2014/07/07/floating-point-numbers/#24cb4f4d-b8a9-4c19-b22b-9d2a9f7f3812 2148 2149 (module 2150 (func (export "f32.epsilon") (result f32) 2151 (f32.sub (f32.const 1.0) (f32.mul (f32.const 3.0) (f32.sub (f32.div (f32.const 4.0) (f32.const 3.0)) (f32.const 1.0))))) 2152 2153 (func (export "f64.epsilon") (result f64) 2154 (f64.sub (f64.const 1.0) (f64.mul (f64.const 3.0) (f64.sub (f64.div (f64.const 4.0) (f64.const 3.0)) (f64.const 1.0))))) 2155 ) 2156 2157 (assert_return (invoke "f32.epsilon") (f32.const -0x1p-23)) 2158 (assert_return (invoke "f64.epsilon") (f64.const 0x1p-52)) 2159 2160 ;; Test that a method for computing a "machine epsilon" produces the expected 2161 ;; result. 2162 ;; https://www.math.utah.edu/~beebe/software/ieee/ 2163 2164 (module 2165 (func (export "f32.epsilon") (result f32) 2166 (local $x f32) 2167 (local $result f32) 2168 (local.set $x (f32.const 1)) 2169 (loop $loop 2170 (br_if $loop 2171 (f32.gt 2172 (f32.add 2173 (local.tee $x 2174 (f32.mul 2175 (local.tee $result (local.get $x)) 2176 (f32.const 0.5) 2177 ) 2178 ) 2179 (f32.const 1) 2180 ) 2181 (f32.const 1) 2182 ) 2183 ) 2184 ) 2185 (local.get $result) 2186 ) 2187 2188 (func (export "f64.epsilon") (result f64) 2189 (local $x f64) 2190 (local $result f64) 2191 (local.set $x (f64.const 1)) 2192 (loop $loop 2193 (br_if $loop 2194 (f64.gt 2195 (f64.add 2196 (local.tee $x 2197 (f64.mul 2198 (local.tee $result (local.get $x)) 2199 (f64.const 0.5) 2200 ) 2201 ) 2202 (f64.const 1) 2203 ) 2204 (f64.const 1) 2205 ) 2206 ) 2207 ) 2208 (local.get $result) 2209 ) 2210 ) 2211 2212 (assert_return (invoke "f32.epsilon") (f32.const 0x1p-23)) 2213 (assert_return (invoke "f64.epsilon") (f64.const 0x1p-52)) 2214 2215 ;; Test that floating-point numbers are not optimized as if they form a 2216 ;; trichotomy. 2217 2218 (module 2219 (func (export "f32.no_trichotomy_lt") (param $x f32) (param $y f32) (result i32) 2220 (i32.or (f32.lt (local.get $x) (local.get $y)) (f32.ge (local.get $x) (local.get $y)))) 2221 (func (export "f32.no_trichotomy_le") (param $x f32) (param $y f32) (result i32) 2222 (i32.or (f32.le (local.get $x) (local.get $y)) (f32.gt (local.get $x) (local.get $y)))) 2223 (func (export "f32.no_trichotomy_gt") (param $x f32) (param $y f32) (result i32) 2224 (i32.or (f32.gt (local.get $x) (local.get $y)) (f32.le (local.get $x) (local.get $y)))) 2225 (func (export "f32.no_trichotomy_ge") (param $x f32) (param $y f32) (result i32) 2226 (i32.or (f32.ge (local.get $x) (local.get $y)) (f32.lt (local.get $x) (local.get $y)))) 2227 2228 (func (export "f64.no_trichotomy_lt") (param $x f64) (param $y f64) (result i32) 2229 (i32.or (f64.lt (local.get $x) (local.get $y)) (f64.ge (local.get $x) (local.get $y)))) 2230 (func (export "f64.no_trichotomy_le") (param $x f64) (param $y f64) (result i32) 2231 (i32.or (f64.le (local.get $x) (local.get $y)) (f64.gt (local.get $x) (local.get $y)))) 2232 (func (export "f64.no_trichotomy_gt") (param $x f64) (param $y f64) (result i32) 2233 (i32.or (f64.gt (local.get $x) (local.get $y)) (f64.le (local.get $x) (local.get $y)))) 2234 (func (export "f64.no_trichotomy_ge") (param $x f64) (param $y f64) (result i32) 2235 (i32.or (f64.ge (local.get $x) (local.get $y)) (f64.lt (local.get $x) (local.get $y)))) 2236 ) 2237 2238 (assert_return (invoke "f32.no_trichotomy_lt" (f32.const 0.0) (f32.const nan)) (i32.const 0)) 2239 (assert_return (invoke "f32.no_trichotomy_le" (f32.const 0.0) (f32.const nan)) (i32.const 0)) 2240 (assert_return (invoke "f32.no_trichotomy_gt" (f32.const 0.0) (f32.const nan)) (i32.const 0)) 2241 (assert_return (invoke "f32.no_trichotomy_ge" (f32.const 0.0) (f32.const nan)) (i32.const 0)) 2242 (assert_return (invoke "f64.no_trichotomy_lt" (f64.const 0.0) (f64.const nan)) (i32.const 0)) 2243 (assert_return (invoke "f64.no_trichotomy_le" (f64.const 0.0) (f64.const nan)) (i32.const 0)) 2244 (assert_return (invoke "f64.no_trichotomy_gt" (f64.const 0.0) (f64.const nan)) (i32.const 0)) 2245 (assert_return (invoke "f64.no_trichotomy_ge" (f64.const 0.0) (f64.const nan)) (i32.const 0)) 2246 2247 ;; Some test harnesses which can run this testsuite are unable to perform tests 2248 ;; of NaN bitpatterns. The following tests whether the underlying platform is 2249 ;; generally producing the kinds of NaNs expected. 2250 (module 2251 (func (export "f32.arithmetic_nan_bitpattern") 2252 (param $x i32) (param $y i32) (result i32) 2253 (i32.and (i32.reinterpret_f32 2254 (f32.div 2255 (f32.reinterpret_i32 (local.get $x)) 2256 (f32.reinterpret_i32 (local.get $y)))) 2257 (i32.const 0x7fc00000))) 2258 (func (export "f32.canonical_nan_bitpattern") 2259 (param $x i32) (param $y i32) (result i32) 2260 (i32.and (i32.reinterpret_f32 2261 (f32.div 2262 (f32.reinterpret_i32 (local.get $x)) 2263 (f32.reinterpret_i32 (local.get $y)))) 2264 (i32.const 0x7fffffff))) 2265 (func (export "f32.nonarithmetic_nan_bitpattern") 2266 (param $x i32) (result i32) 2267 (i32.reinterpret_f32 (f32.neg (f32.reinterpret_i32 (local.get $x))))) 2268 2269 (func (export "f64.arithmetic_nan_bitpattern") 2270 (param $x i64) (param $y i64) (result i64) 2271 (i64.and (i64.reinterpret_f64 2272 (f64.div 2273 (f64.reinterpret_i64 (local.get $x)) 2274 (f64.reinterpret_i64 (local.get $y)))) 2275 (i64.const 0x7ff8000000000000))) 2276 (func (export "f64.canonical_nan_bitpattern") 2277 (param $x i64) (param $y i64) (result i64) 2278 (i64.and (i64.reinterpret_f64 2279 (f64.div 2280 (f64.reinterpret_i64 (local.get $x)) 2281 (f64.reinterpret_i64 (local.get $y)))) 2282 (i64.const 0x7fffffffffffffff))) 2283 (func (export "f64.nonarithmetic_nan_bitpattern") 2284 (param $x i64) (result i64) 2285 (i64.reinterpret_f64 (f64.neg (f64.reinterpret_i64 (local.get $x))))) 2286 2287 ;; Versions of no_fold testcases that only care about NaN bitpatterns. 2288 (func (export "f32.no_fold_sub_zero") (param $x i32) (result i32) 2289 (i32.and (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (local.get $x)) (f32.const 0.0))) 2290 (i32.const 0x7fc00000))) 2291 (func (export "f32.no_fold_neg0_sub") (param $x i32) (result i32) 2292 (i32.and (i32.reinterpret_f32 (f32.sub (f32.const -0.0) (f32.reinterpret_i32 (local.get $x)))) 2293 (i32.const 0x7fc00000))) 2294 (func (export "f32.no_fold_mul_one") (param $x i32) (result i32) 2295 (i32.and (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0))) 2296 (i32.const 0x7fc00000))) 2297 (func (export "f32.no_fold_neg1_mul") (param $x i32) (result i32) 2298 (i32.and (i32.reinterpret_f32 (f32.mul (f32.const -1.0) (f32.reinterpret_i32 (local.get $x)))) 2299 (i32.const 0x7fc00000))) 2300 (func (export "f32.no_fold_div_one") (param $x i32) (result i32) 2301 (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0))) 2302 (i32.const 0x7fc00000))) 2303 (func (export "f32.no_fold_div_neg1") (param $x i32) (result i32) 2304 (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const -1.0))) 2305 (i32.const 0x7fc00000))) 2306 (func (export "f64.no_fold_sub_zero") (param $x i64) (result i64) 2307 (i64.and (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (local.get $x)) (f64.const 0.0))) 2308 (i64.const 0x7ff8000000000000))) 2309 (func (export "f64.no_fold_neg0_sub") (param $x i64) (result i64) 2310 (i64.and (i64.reinterpret_f64 (f64.sub (f64.const -0.0) (f64.reinterpret_i64 (local.get $x)))) 2311 (i64.const 0x7ff8000000000000))) 2312 (func (export "f64.no_fold_mul_one") (param $x i64) (result i64) 2313 (i64.and (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0))) 2314 (i64.const 0x7ff8000000000000))) 2315 (func (export "f64.no_fold_neg1_mul") (param $x i64) (result i64) 2316 (i64.and (i64.reinterpret_f64 (f64.mul (f64.const -1.0) (f64.reinterpret_i64 (local.get $x)))) 2317 (i64.const 0x7ff8000000000000))) 2318 (func (export "f64.no_fold_div_one") (param $x i64) (result i64) 2319 (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0))) 2320 (i64.const 0x7ff8000000000000))) 2321 (func (export "f64.no_fold_div_neg1") (param $x i64) (result i64) 2322 (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const -1.0))) 2323 (i64.const 0x7ff8000000000000))) 2324 (func (export "no_fold_promote_demote") (param $x i32) (result i32) 2325 (i32.and (i32.reinterpret_f32 (f32.demote_f64 (f64.promote_f32 (f32.reinterpret_i32 (local.get $x))))) 2326 (i32.const 0x7fc00000))) 2327 ) 2328 2329 (assert_return (invoke "f32.arithmetic_nan_bitpattern" (i32.const 0x7f803210) (i32.const 0x7f803210)) (i32.const 0x7fc00000)) 2330 (assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0) (i32.const 0)) (i32.const 0x7fc00000)) 2331 (assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0x7fc00000) (i32.const 0x7fc00000)) (i32.const 0x7fc00000)) 2332 (assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0xffc00000) (i32.const 0x7fc00000)) (i32.const 0x7fc00000)) 2333 (assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0x7fc00000) (i32.const 0xffc00000)) (i32.const 0x7fc00000)) 2334 (assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0xffc00000) (i32.const 0xffc00000)) (i32.const 0x7fc00000)) 2335 (assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0x7fc03210)) (i32.const 0xffc03210)) 2336 (assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0xffc03210)) (i32.const 0x7fc03210)) 2337 (assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0x7f803210)) (i32.const 0xff803210)) 2338 (assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0xff803210)) (i32.const 0x7f803210)) 2339 (assert_return (invoke "f64.arithmetic_nan_bitpattern" (i64.const 0x7ff0000000003210) (i64.const 0x7ff0000000003210)) (i64.const 0x7ff8000000000000)) 2340 (assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0) (i64.const 0)) (i64.const 0x7ff8000000000000)) 2341 (assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0x7ff8000000000000) (i64.const 0x7ff8000000000000)) (i64.const 0x7ff8000000000000)) 2342 (assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0xfff8000000000000) (i64.const 0x7ff8000000000000)) (i64.const 0x7ff8000000000000)) 2343 (assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0x7ff8000000000000) (i64.const 0xfff8000000000000)) (i64.const 0x7ff8000000000000)) 2344 (assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0xfff8000000000000) (i64.const 0xfff8000000000000)) (i64.const 0x7ff8000000000000)) 2345 (assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0x7ff8000000003210)) (i64.const 0xfff8000000003210)) 2346 (assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0xfff8000000003210)) (i64.const 0x7ff8000000003210)) 2347 (assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0x7ff0000000003210)) (i64.const 0xfff0000000003210)) 2348 (assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0xfff0000000003210)) (i64.const 0x7ff0000000003210)) 2349 (assert_return (invoke "f32.no_fold_sub_zero" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) 2350 (assert_return (invoke "f32.no_fold_neg0_sub" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) 2351 (assert_return (invoke "f32.no_fold_mul_one" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) 2352 (assert_return (invoke "f32.no_fold_neg1_mul" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) 2353 (assert_return (invoke "f32.no_fold_div_one" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) 2354 (assert_return (invoke "f32.no_fold_div_neg1" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) 2355 (assert_return (invoke "f64.no_fold_sub_zero" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) 2356 (assert_return (invoke "f64.no_fold_neg0_sub" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) 2357 (assert_return (invoke "f64.no_fold_mul_one" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) 2358 (assert_return (invoke "f64.no_fold_neg1_mul" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) 2359 (assert_return (invoke "f64.no_fold_div_one" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) 2360 (assert_return (invoke "f64.no_fold_div_neg1" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000)) 2361 (assert_return (invoke "no_fold_promote_demote" (i32.const 0x7fa00000)) (i32.const 0x7fc00000)) 2362 2363 ;; Test that IEEE 754 double precision does, in fact, compute a certain dot 2364 ;; product correctly. 2365 2366 (module 2367 (func (export "dot_product_example") 2368 (param $x0 f64) (param $x1 f64) (param $x2 f64) (param $x3 f64) 2369 (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64) 2370 (result f64) 2371 (f64.add (f64.add (f64.add 2372 (f64.mul (local.get $x0) (local.get $y0)) 2373 (f64.mul (local.get $x1) (local.get $y1))) 2374 (f64.mul (local.get $x2) (local.get $y2))) 2375 (f64.mul (local.get $x3) (local.get $y3))) 2376 ) 2377 2378 (func (export "with_binary_sum_collapse") 2379 (param $x0 f64) (param $x1 f64) (param $x2 f64) (param $x3 f64) 2380 (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64) 2381 (result f64) 2382 (f64.add (f64.add (f64.mul (local.get $x0) (local.get $y0)) 2383 (f64.mul (local.get $x1) (local.get $y1))) 2384 (f64.add (f64.mul (local.get $x2) (local.get $y2)) 2385 (f64.mul (local.get $x3) (local.get $y3)))) 2386 ) 2387 ) 2388 2389 (assert_return (invoke "dot_product_example" 2390 (f64.const 3.2e7) (f64.const 1.0) (f64.const -1.0) (f64.const 8.0e7) 2391 (f64.const 4.0e7) (f64.const 1.0) (f64.const -1.0) (f64.const -1.6e7)) 2392 (f64.const 2.0)) 2393 (assert_return (invoke "with_binary_sum_collapse" 2394 (f64.const 3.2e7) (f64.const 1.0) (f64.const -1.0) (f64.const 8.0e7) 2395 (f64.const 4.0e7) (f64.const 1.0) (f64.const -1.0) (f64.const -1.6e7)) 2396 (f64.const 2.0)) 2397 2398 ;; http://www.vinc17.org/research/fptest.en.html#contract2fma 2399 2400 (module 2401 (func (export "f32.contract2fma") 2402 (param $x f32) (param $y f32) (result f32) 2403 (f32.sqrt (f32.sub (f32.mul (local.get $x) (local.get $x)) 2404 (f32.mul (local.get $y) (local.get $y))))) 2405 (func (export "f64.contract2fma") 2406 (param $x f64) (param $y f64) (result f64) 2407 (f64.sqrt (f64.sub (f64.mul (local.get $x) (local.get $x)) 2408 (f64.mul (local.get $y) (local.get $y))))) 2409 ) 2410 2411 (assert_return (invoke "f32.contract2fma" (f32.const 1.0) (f32.const 1.0)) (f32.const 0.0)) 2412 (assert_return (invoke "f32.contract2fma" (f32.const 0x1.19999ap+0) (f32.const 0x1.19999ap+0)) (f32.const 0.0)) 2413 (assert_return (invoke "f32.contract2fma" (f32.const 0x1.333332p+0) (f32.const 0x1.333332p+0)) (f32.const 0.0)) 2414 (assert_return (invoke "f64.contract2fma" (f64.const 1.0) (f64.const 1.0)) (f64.const 0.0)) 2415 (assert_return (invoke "f64.contract2fma" (f64.const 0x1.199999999999ap+0) (f64.const 0x1.199999999999ap+0)) (f64.const 0.0)) 2416 (assert_return (invoke "f64.contract2fma" (f64.const 0x1.3333333333333p+0) (f64.const 0x1.3333333333333p+0)) (f64.const 0.0)) 2417 2418 ;; Test that floating-point isn't implemented with QuickBasic for MS-DOS. 2419 ;; https://support.microsoft.com/en-us/help/42980/-complete-tutorial-to-understand-ieee-floating-point-errors 2420 2421 (module 2422 (func (export "f32.division_by_small_number") 2423 (param $a f32) (param $b f32) (param $c f32) (result f32) 2424 (f32.sub (local.get $a) (f32.div (local.get $b) (local.get $c)))) 2425 (func (export "f64.division_by_small_number") 2426 (param $a f64) (param $b f64) (param $c f64) (result f64) 2427 (f64.sub (local.get $a) (f64.div (local.get $b) (local.get $c)))) 2428 ) 2429 2430 (assert_return (invoke "f32.division_by_small_number" (f32.const 112000000) (f32.const 100000) (f32.const 0.0009)) (f32.const 888888)) 2431 (assert_return (invoke "f64.division_by_small_number" (f64.const 112000000) (f64.const 100000) (f64.const 0.0009)) (f64.const 888888.8888888806)) 2432 2433 ;; Test a simple golden ratio computation. 2434 ;; http://mathworld.wolfram.com/GoldenRatio.html 2435 2436 (module 2437 (func (export "f32.golden_ratio") (param $a f32) (param $b f32) (param $c f32) (result f32) 2438 (f32.mul (local.get 0) (f32.add (local.get 1) (f32.sqrt (local.get 2))))) 2439 (func (export "f64.golden_ratio") (param $a f64) (param $b f64) (param $c f64) (result f64) 2440 (f64.mul (local.get 0) (f64.add (local.get 1) (f64.sqrt (local.get 2))))) 2441 ) 2442 2443 (assert_return (invoke "f32.golden_ratio" (f32.const 0.5) (f32.const 1.0) (f32.const 5.0)) (f32.const 1.618034)) 2444 (assert_return (invoke "f64.golden_ratio" (f64.const 0.5) (f64.const 1.0) (f64.const 5.0)) (f64.const 1.618033988749895)) 2445 2446 ;; Test some silver means computations. 2447 ;; http://mathworld.wolfram.com/SilverRatio.html 2448 2449 (module 2450 (func (export "f32.silver_means") (param $n f32) (result f32) 2451 (f32.mul (f32.const 0.5) 2452 (f32.add (local.get $n) 2453 (f32.sqrt (f32.add (f32.mul (local.get $n) (local.get $n)) 2454 (f32.const 4.0)))))) 2455 (func (export "f64.silver_means") (param $n f64) (result f64) 2456 (f64.mul (f64.const 0.5) 2457 (f64.add (local.get $n) 2458 (f64.sqrt (f64.add (f64.mul (local.get $n) (local.get $n)) 2459 (f64.const 4.0)))))) 2460 ) 2461 2462 (assert_return (invoke "f32.silver_means" (f32.const 0.0)) (f32.const 1.0)) 2463 (assert_return (invoke "f32.silver_means" (f32.const 1.0)) (f32.const 1.6180340)) 2464 (assert_return (invoke "f32.silver_means" (f32.const 2.0)) (f32.const 2.4142136)) 2465 (assert_return (invoke "f32.silver_means" (f32.const 3.0)) (f32.const 3.3027756)) 2466 (assert_return (invoke "f32.silver_means" (f32.const 4.0)) (f32.const 4.2360680)) 2467 (assert_return (invoke "f32.silver_means" (f32.const 5.0)) (f32.const 5.1925821)) 2468 (assert_return (invoke "f64.silver_means" (f64.const 0.0)) (f64.const 1.0)) 2469 (assert_return (invoke "f64.silver_means" (f64.const 1.0)) (f64.const 1.618033988749895)) 2470 (assert_return (invoke "f64.silver_means" (f64.const 2.0)) (f64.const 2.414213562373095)) 2471 (assert_return (invoke "f64.silver_means" (f64.const 3.0)) (f64.const 3.302775637731995)) 2472 (assert_return (invoke "f64.silver_means" (f64.const 4.0)) (f64.const 4.236067977499790)) 2473 (assert_return (invoke "f64.silver_means" (f64.const 5.0)) (f64.const 5.192582403567252)) 2474 2475 ;; Test that an f64 0.4 isn't double-rounded as via extended precision. 2476 ;; https://bugs.llvm.org/show_bug.cgi?id=11200 2477 2478 (module 2479 (func (export "point_four") (param $four f64) (param $ten f64) (result i32) 2480 (f64.lt (f64.div (local.get $four) (local.get $ten)) (f64.const 0.4))) 2481 ) 2482 2483 (assert_return (invoke "point_four" (f64.const 4.0) (f64.const 10.0)) (i32.const 0)) 2484 2485 ;; Test an approximation function for tau; it should produces the correctly 2486 ;; rounded result after (and only after) the expected number of iterations. 2487 2488 (module 2489 (func (export "tau") (param i32) (result f64) 2490 (local f64 f64 f64 f64) 2491 f64.const 0x0p+0 2492 local.set 1 2493 block 2494 local.get 0 2495 i32.const 1 2496 i32.lt_s 2497 br_if 0 2498 f64.const 0x1p+0 2499 local.set 2 2500 f64.const 0x0p+0 2501 local.set 3 2502 loop 2503 local.get 1 2504 local.get 2 2505 f64.const 0x1p+3 2506 local.get 3 2507 f64.const 0x1p+3 2508 f64.mul 2509 local.tee 4 2510 f64.const 0x1p+0 2511 f64.add 2512 f64.div 2513 f64.const 0x1p+2 2514 local.get 4 2515 f64.const 0x1p+2 2516 f64.add 2517 f64.div 2518 f64.sub 2519 f64.const 0x1p+1 2520 local.get 4 2521 f64.const 0x1.4p+2 2522 f64.add 2523 f64.div 2524 f64.sub 2525 f64.const 0x1p+1 2526 local.get 4 2527 f64.const 0x1.8p+2 2528 f64.add 2529 f64.div 2530 f64.sub 2531 f64.mul 2532 f64.add 2533 local.set 1 2534 local.get 3 2535 f64.const 0x1p+0 2536 f64.add 2537 local.set 3 2538 local.get 2 2539 f64.const 0x1p-4 2540 f64.mul 2541 local.set 2 2542 local.get 0 2543 i32.const -1 2544 i32.add 2545 local.tee 0 2546 br_if 0 2547 end 2548 end 2549 local.get 1 2550 ) 2551 ) 2552 2553 (assert_return (invoke "tau" (i32.const 10)) (f64.const 0x1.921fb54442d14p+2)) 2554 (assert_return (invoke "tau" (i32.const 11)) (f64.const 0x1.921fb54442d18p+2)) 2555 2556 ;; Test that y < 0 ? x : (x + 1) is not folded to x + (y < 0). 2557 2558 (module 2559 (func (export "f32.no_fold_conditional_inc") (param $x f32) (param $y f32) (result f32) 2560 (select (local.get $x) 2561 (f32.add (local.get $x) (f32.const 1.0)) 2562 (f32.lt (local.get $y) (f32.const 0.0)))) 2563 (func (export "f64.no_fold_conditional_inc") (param $x f64) (param $y f64) (result f64) 2564 (select (local.get $x) 2565 (f64.add (local.get $x) (f64.const 1.0)) 2566 (f64.lt (local.get $y) (f64.const 0.0)))) 2567 ) 2568 2569 (assert_return (invoke "f32.no_fold_conditional_inc" (f32.const -0.0) (f32.const -1.0)) (f32.const -0.0)) 2570 (assert_return (invoke "f64.no_fold_conditional_inc" (f64.const -0.0) (f64.const -1.0)) (f64.const -0.0))