[Parser] Use the new parser in wasm-shell and wasm-as (#6529)

Updating just one or the other of these tools would cause the tests
spec/import-after-*.fail.wast to fail, since only the updated tool would
correctly fail to parse its contents. To avoid this, update both tools at
once. (The tests erroneously pass before this change because check.py does not
ensure that .fail.wast tests fail, only that failing tests end in .fail.wast.)

In wasm-shell, to minimize the diff, only use the new parser to parse modules
and instructions. Continue using the legacy parsing based on s-expressions for
the other wast commands. Updating the parsing of the other commands to use
`Lexer` instead of `SExpressionParser` is left as future work. The boundary
between the two parsing styles is somewhat hacky, but it is worth it to enable
incremental development.

Update the tests to fix incorrect wast rejected by the new parser. Many of the
spec/old_* tests use non-standard forms from before Wasm MVP was standardized,
so fixing them would have been onerous. All of these tests have non-old_*
variants, so simply delete them.

14 files changed, 216 insertions, 4622 deletions

diff --git a/test/spec/array.wast b/test/spec/array.wast
index d9b75e287..c865fe697 100644
--- a/test/spec/array.wast
+++ b/test/spec/array.wast
@@ -40,10 +40,8 @@
     (type $s1 (array (ref $s0)))
   )
 
-  (rec
-    (func (param (ref $forward)))
-    (type $forward (array i32))
-  )
+  (func (param (ref $forward)))
+  (type $forward (array i32))
 )
 
 (assert_invalid
diff --git a/test/spec/float_memory64.wast b/test/spec/float_memory64.wast
index 6834fdf60..674b254f5 100644
--- a/test/spec/float_memory64.wast
+++ b/test/spec/float_memory64.wast
@@ -3,7 +3,7 @@
 ;; Test that load and store do not canonicalize NaNs as x87 does.
 
 (module
-  (memory (data i64 "\00\00\a0\7f"))
+  (memory i64 (data "\00\00\a0\7f"))
 
   (func (export "f32.load") (result f32) (f32.load (i64.const 0)))
   (func (export "i32.load") (result i32) (i32.load (i64.const 0)))
@@ -28,7 +28,7 @@
 (assert_return (invoke "f32.load") (f32.const nan:0x200000))
 
 (module
-  (memory (data i64 "\00\00\00\00\00\00\f4\7f"))
+  (memory i64 (data "\00\00\00\00\00\00\f4\7f"))
 
   (func (export "f64.load") (result f64) (f64.load (i64.const 0)))
   (func (export "i64.load") (result i64) (i64.load (i64.const 0)))
@@ -55,7 +55,7 @@
 ;; Test that unaligned load and store do not canonicalize NaNs.
 
 (module
-  (memory (data i64 "\00\00\00\a0\7f"))
+  (memory i64 (data "\00\00\00\a0\7f"))
 
   (func (export "f32.load") (result f32) (f32.load (i64.const 1)))
   (func (export "i32.load") (result i32) (i32.load (i64.const 1)))
@@ -80,7 +80,7 @@
 (assert_return (invoke "f32.load") (f32.const nan:0x200000))
 
 (module
-  (memory (data i64 "\00\00\00\00\00\00\00\f4\7f"))
+  (memory i64 (data "\00\00\00\00\00\00\00\f4\7f"))
 
   (func (export "f64.load") (result f64) (f64.load (i64.const 1)))
   (func (export "i64.load") (result i64) (i64.load (i64.const 1)))
@@ -107,7 +107,7 @@
 ;; Test that load and store do not canonicalize NaNs as some JS engines do.
 
 (module
-  (memory (data i64 "\01\00\d0\7f"))
+  (memory i64 (data "\01\00\d0\7f"))
 
   (func (export "f32.load") (result f32) (f32.load (i64.const 0)))
   (func (export "i32.load") (result i32) (i32.load (i64.const 0)))
@@ -132,7 +132,7 @@
 (assert_return (invoke "f32.load") (f32.const nan:0x500001))
 
 (module
-  (memory (data i64 "\01\00\00\00\00\00\fc\7f"))
+  (memory i64 (data "\01\00\00\00\00\00\fc\7f"))
 
   (func (export "f64.load") (result f64) (f64.load (i64.const 0)))
   (func (export "i64.load") (result i64) (i64.load (i64.const 0)))
diff --git a/test/spec/old_block.wast b/test/spec/old_block.wast
deleted file mode 100644
index 505560885..000000000
--- a/test/spec/old_block.wast
+++ /dev/null
@@ -1,284 +0,0 @@
-;; Test `block` operator
-
-(module
-  ;; Auxiliary definition
-  (func $dummy)
-
-  (func (export "empty")
-    (block)
-    (block $l)
-  )
-
-  (func (export "singular") (result i32)
-    (block (nop))
-    (block i32 (i32.const 7))
-  )
-
-  (func (export "multi") (result i32)
-    (block (call $dummy) (call $dummy) (call $dummy) (call $dummy))
-    (block i32 (call $dummy) (call $dummy) (call $dummy) (i32.const 8))
-  )
-
-  (func (export "nested") (result i32)
-    (block i32
-      (block (call $dummy) (block) (nop))
-      (block i32 (call $dummy) (i32.const 9))
-    )
-  )
-
-  (func (export "deep") (result i32)
-    (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-      (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-        (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-          (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-            (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-              (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-                (block i32 (block i32 (call $dummy) (i32.const 150)))
-              ))))))
-            ))))))
-          ))))))
-        ))))))
-      ))))))
-    ))))))
-  )
-
-  (func (export "as-unary-operand") (result i32)
-    (i32.ctz (block i32 (call $dummy) (i32.const 13)))
-  )
-  (func (export "as-binary-operand") (result i32)
-    (i32.mul
-      (block i32 (call $dummy) (i32.const 3))
-      (block i32 (call $dummy) (i32.const 4))
-    )
-  )
-  (func (export "as-test-operand") (result i32)
-    (i32.eqz (block i32 (call $dummy) (i32.const 13)))
-  )
-  (func (export "as-compare-operand") (result i32)
-    (f32.gt
-      (block f32 (call $dummy) (f32.const 3))
-      (block f32 (call $dummy) (f32.const 3))
-    )
-  )
-
-  (func (export "break-bare") (result i32)
-    (block (br 0) (unreachable))
-    (block (br_if 0 (i32.const 1)) (unreachable))
-    (block (br_table 0 (i32.const 0)) (unreachable))
-    (block (br_table 0 0 0 (i32.const 1)) (unreachable))
-    (i32.const 19)
-  )
-  (func (export "break-value") (result i32)
-    (block i32 (br 0 (i32.const 18)) (i32.const 19))
-  )
-  (func (export "break-repeated") (result i32)
-    (block i32
-      (br 0 (i32.const 18))
-      (br 0 (i32.const 19))
-      (drop (br_if 0 (i32.const 20) (i32.const 0)))
-      (drop (br_if 0 (i32.const 20) (i32.const 1)))
-      (br 0 (i32.const 21))
-      (br_table 0 (i32.const 22) (i32.const 4))
-      (br_table 0 0 0 (i32.const 23) (i32.const 1))
-      (i32.const 21)
-    )
-  )
-  (func (export "break-inner") (result i32)
-    (local i32)
-    (local.set 0 (i32.const 0))
-    (local.set 0 (i32.add (local.get 0) (block i32 (block i32 (br 1 (i32.const 0x1))))))
-    (local.set 0 (i32.add (local.get 0) (block i32 (block (br 0)) (i32.const 0x2))))
-    (local.set 0
-      (i32.add (local.get 0) (block i32 (i32.ctz (br 0 (i32.const 0x4)))))
-    )
-    (local.set 0
-      (i32.add (local.get 0) (block i32 (i32.ctz (block i32 (br 1 (i32.const 0x8))))))
-    )
-    (local.get 0)
-  )
-
-  (func (export "effects") (result i32)
-    (local i32)
-    (block
-      (local.set 0 (i32.const 1))
-      (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
-      (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
-      (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
-      (br 0)
-      (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
-    )
-    (i32.eq (local.get 0) (i32.const -14))
-  )
-)
-
-(assert_return (invoke "empty"))
-(assert_return (invoke "singular") (i32.const 7))
-(assert_return (invoke "multi") (i32.const 8))
-(assert_return (invoke "nested") (i32.const 9))
-(assert_return (invoke "deep") (i32.const 150))
-
-(assert_return (invoke "as-unary-operand") (i32.const 0))
-(assert_return (invoke "as-binary-operand") (i32.const 12))
-(assert_return (invoke "as-test-operand") (i32.const 0))
-(assert_return (invoke "as-compare-operand") (i32.const 0))
-
-(assert_return (invoke "break-bare") (i32.const 19))
-(assert_return (invoke "break-value") (i32.const 18))
-(assert_return (invoke "break-repeated") (i32.const 18))
-(assert_return (invoke "break-inner") (i32.const 0xf))
-
-(assert_return (invoke "effects") (i32.const 1))
-
-(assert_invalid
-  (module (func $type-empty-i32 (result i32) (block)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-empty-i64 (result i64) (block)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-empty-f32 (result f32) (block)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-empty-f64 (result f64) (block)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-value-num-vs-void
-    (block (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-void-vs-num (result i32)
-    (block (nop))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-num-vs-num (result i32)
-    (block (f32.const 0))
-  ))
-  "type mismatch"
-)
-
-(; TODO(stack): soft failure
-(assert_invalid
-  (module (func $type-value-num-vs-void-after-break
-    (block (br 0) (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-void-vs-num-after-break (result i32)
-    (block (i32.const 1) (br 0) (nop))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-num-vs-num-after-break (result i32)
-    (block (i32.const 1) (br 0) (f32.const 0))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-second-void-vs-num (result i32)
-    (block i32 (br 0 (i32.const 1)) (br 0 (nop)))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-second-num-vs-num (result i32)
-    (block i32 (br 0 (i32.const 1)) (br 0 (f64.const 1)))
-  ))
-  "type mismatch"
-)
-;)
-
-(assert_invalid
-  (module (func $type-break-last-void-vs-num (result i32)
-    (block i32 (br 0))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-void-vs-num (result i32)
-    (block i32 (br 0) (i32.const 1))
-  ))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-break-void-vs-num (result i32)
-    (block (br 0 (nop)) (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-num-vs-num (result i32)
-    (block (br 0 (i64.const 1)) (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-first-void-vs-num (result i32)
-    (block (br 0 (nop)) (br 0 (i32.const 1)))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-first-num-vs-num (result i32)
-    (block (br 0 (i64.const 1)) (br 0 (i32.const 1)))
-  ))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-break-nested-num-vs-void
-    (block i32 (block i32 (br 1 (i32.const 1))) (br 0))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-nested-empty-vs-num (result i32)
-    (block (block (br 1)) (br 0 (i32.const 1)))
-  ))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-break-nested-void-vs-num (result i32)
-    (block (block (br 1 (nop))) (br 0 (i32.const 1)))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-nested-num-vs-num (result i32)
-    (block (block (br 1 (i64.const 1))) (br 0 (i32.const 1)))
-  ))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-break-operand-empty-vs-num (result i32)
-    (i32.ctz (block (br 0)))
-  ))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-break-operand-void-vs-num (result i32)
-    (i64.ctz (block (br 0 (nop))))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-operand-num-vs-num (result i32)
-    (i64.ctz (block (br 0 (i64.const 9))))
-  ))
-  "type mismatch"
-)
-
diff --git a/test/spec/old_br_if.wast b/test/spec/old_br_if.wast
deleted file mode 100644
index 9ed24f153..000000000
--- a/test/spec/old_br_if.wast
+++ /dev/null
@@ -1,306 +0,0 @@
-;; Test `br_if` operator
-
-(module
-  (func $dummy)
-
-  (func (export "as-block-first") (param i32) (result i32)
-    (block (br_if 0 (local.get 0)) (return (i32.const 2))) (i32.const 3)
-  )
-  (func (export "as-block-mid") (param i32) (result i32)
-    (block (call $dummy) (br_if 0 (local.get 0)) (return (i32.const 2)))
-    (i32.const 3)
-  )
-  (func (export "as-block-last") (param i32)
-    (block (call $dummy) (call $dummy) (br_if 0 (local.get 0)))
-  )
-  (func (export "as-block-first-value") (param i32) (result i32)
-    (block i32 (drop (br_if 0 (i32.const 10) (local.get 0))) (return (i32.const 11)))
-  )
-  (func (export "as-block-mid-value") (param i32) (result i32)
-    (block i32 (call $dummy) (drop (br_if 0 (i32.const 20) (local.get 0))) (return (i32.const 21)))
-  )
-  (func (export "as-block-last-value") (param i32) (result i32)
-    (block i32
-      (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (local.get 0))
-    )
-  )
-
-  (func (export "as-loop-first") (param i32) (result i32)
-    (block (loop (br_if 1 (local.get 0)) (return (i32.const 2)))) (i32.const 3)
-  )
-  (func (export "as-loop-mid") (param i32) (result i32)
-    (block (loop (call $dummy) (br_if 1 (local.get 0)) (return (i32.const 2))))
-    (i32.const 4)
-  )
-  (func (export "as-loop-last") (param i32)
-    (loop (call $dummy) (br_if 1 (local.get 0)))
-  )
-
-  (func (export "as-if-then") (param i32 i32)
-    (block (if (local.get 0) (then (br_if 1 (local.get 1)) )(else (call $dummy))))
-  )
-  (func (export "as-if-else") (param i32 i32)
-    (block (if (local.get 0) (then (call $dummy) )(else (br_if 1 (local.get 1)))))
-  )
-
-  (func (export "nested-block-value") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block i32
-        (drop (i32.const 2))
-        (i32.add
-          (i32.const 4)
-          (block i32
-            (drop (br_if 1 (i32.const 8) (local.get 0)))
-            (i32.const 16)
-          )
-        )
-      )
-    )
-  )
-
-  (func (export "nested-br-value") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block i32
-        (drop (i32.const 2))
-        (br 0
-          (block i32 (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4))
-        )
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_if-value") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block i32
-        (drop (i32.const 2))
-        (drop (br_if 0
-          (block i32 (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4))
-          (i32.const 1)
-        ))
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_if-value-cond") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block i32
-        (drop (i32.const 2))
-        (drop (br_if 0
-          (i32.const 4)
-          (block i32 (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1))
-        ))
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_table-value") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block i32
-        (drop (i32.const 2))
-        (br_table 0
-          (block i32 (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4))
-          (i32.const 1)
-        )
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_table-value-index") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block i32
-        (drop (i32.const 2))
-        (br_table 0
-          (i32.const 4)
-          (block i32 (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1))
-        )
-        (i32.const 16)
-      )
-    )
-  )
-)
-
-(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-block-first" (i32.const 1)) (i32.const 3))
-(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-block-mid" (i32.const 1)) (i32.const 3))
-(assert_return (invoke "as-block-last" (i32.const 0)))
-(assert_return (invoke "as-block-last" (i32.const 1)))
-(assert_return (invoke "as-block-last-value" (i32.const 0)) (i32.const 11))
-(assert_return (invoke "as-block-last-value" (i32.const 1)) (i32.const 11))
-
-(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 3))
-(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 4))
-(assert_return (invoke "as-loop-last" (i32.const 0)))
-(assert_return (invoke "as-loop-last" (i32.const 1)))
-
-(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 0)))
-(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 0)))
-(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 1)))
-(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 1)))
-(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 0)))
-(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 0)))
-(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 1)))
-(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 1)))
-
-(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 21))
-(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 9))
-(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9))
-(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9))
-(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 9))
-(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9))
-(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 9))
-
-(assert_invalid
-  (module (func $type-false-i32 (block (i32.ctz (br_if 0 (i32.const 0))))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-false-i64 (block (i64.ctz (br_if 0 (i32.const 0))))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-false-f32 (block (f32.neg (br_if 0 (i32.const 0))))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-false-f64 (block (f64.neg (br_if 0 (i32.const 0))))))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-true-i32 (block (i32.ctz (br_if 0 (i32.const 1))))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-true-i64 (block (i64.ctz (br_if 0 (i64.const 1))))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-true-f32 (block (f32.neg (br_if 0 (f32.const 1))))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-true-f64 (block (f64.neg (br_if 0 (i64.const 1))))))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-false-arg-void-vs-num (result i32)
-    (block i32 (br_if 0 (i32.const 0)) (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-true-arg-void-vs-num (result i32)
-    (block i32 (br_if 0 (i32.const 1)) (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-false-arg-num-vs-void
-    (block (br_if 0 (i32.const 0) (i32.const 0)))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-true-arg-num-vs-void
-    (block (br_if 0 (i32.const 0) (i32.const 1)))
-  ))
-  "type mismatch"
-)
-
-(; TODO(stack): soft failure
-(assert_invalid
-  (module (func $type-false-arg-poly-vs-empty
-    (block (br_if 0 (unreachable) (i32.const 0)))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-true-arg-poly-vs-empty
-    (block (br_if 0 (unreachable) (i32.const 1)))
-  ))
-  "type mismatch"
-)
-;)
-
-(assert_invalid
-  (module (func $type-false-arg-void-vs-num (result i32)
-    (block i32 (br_if 0 (nop) (i32.const 0)) (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-true-arg-void-vs-num (result i32)
-    (block i32 (br_if 0 (nop) (i32.const 1)) (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-false-arg-num-vs-num (result i32)
-    (block i32 (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-true-arg-num-vs-num (result i32)
-    (block i32 (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1))
-  ))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-cond-void-vs-i32
-    (block (br_if 0 (nop)))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-cond-num-vs-i32
-    (block (br_if 0 (i64.const 0)))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-arg-cond-void-vs-i32 (result i32)
-    (block i32 (br_if 0 (i32.const 0) (nop)) (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-arg-cond-num-vs-i32 (result i32)
-    (block i32 (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1))
-  ))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $unbound-label (br_if 1 (i32.const 1))))
-  "unknown label"
-)
-(assert_invalid
-  (module (func $unbound-nested-label (block (block (br_if 5 (i32.const 1))))))
-  "unknown label"
-)
-(assert_invalid
-  (module (func $large-label (br_if 0x10000001 (i32.const 1))))
-  "unknown label"
-)
-
diff --git a/test/spec/old_call.wast b/test/spec/old_call.wast
deleted file mode 100644
index ed2cd286b..000000000
--- a/test/spec/old_call.wast
+++ /dev/null
@@ -1,253 +0,0 @@
-;; Test `call` operator
-
-(module
-  ;; Auxiliary definitions
-  (func $const-i32 (result i32) (i32.const 0x132))
-  (func $const-i64 (result i64) (i64.const 0x164))
-  (func $const-f32 (result f32) (f32.const 0xf32))
-  (func $const-f64 (result f64) (f64.const 0xf64))
-
-  (func $id-i32 (param i32) (result i32) (local.get 0))
-  (func $id-i64 (param i64) (result i64) (local.get 0))
-  (func $id-f32 (param f32) (result f32) (local.get 0))
-  (func $id-f64 (param f64) (result f64) (local.get 0))
-
-  (func $f32-i32 (param f32 i32) (result i32) (local.get 1))
-  (func $i32-i64 (param i32 i64) (result i64) (local.get 1))
-  (func $f64-f32 (param f64 f32) (result f32) (local.get 1))
-  (func $i64-f64 (param i64 f64) (result f64) (local.get 1))
-
-  ;; Typing
-
-  (func (export "type-i32") (result i32) (call $const-i32))
-  (func (export "type-i64") (result i64) (call $const-i64))
-  (func (export "type-f32") (result f32) (call $const-f32))
-  (func (export "type-f64") (result f64) (call $const-f64))
-
-  (func (export "type-first-i32") (result i32) (call $id-i32 (i32.const 32)))
-  (func (export "type-first-i64") (result i64) (call $id-i64 (i64.const 64)))
-  (func (export "type-first-f32") (result f32) (call $id-f32 (f32.const 1.32)))
-  (func (export "type-first-f64") (result f64) (call $id-f64 (f64.const 1.64)))
-
-  (func (export "type-second-i32") (result i32)
-    (call $f32-i32 (f32.const 32.1) (i32.const 32))
-  )
-  (func (export "type-second-i64") (result i64)
-    (call $i32-i64 (i32.const 32) (i64.const 64))
-  )
-  (func (export "type-second-f32") (result f32)
-    (call $f64-f32 (f64.const 64) (f32.const 32))
-  )
-  (func (export "type-second-f64") (result f64)
-    (call $i64-f64 (i64.const 64) (f64.const 64.1))
-  )
-
-  ;; Recursion
-
-  (func $fac (export "fac") (param i64) (result i64)
-    (if i64 (i64.eqz (local.get 0))
-      (then
-        (i64.const 1)
-      )
-      (else
-        (i64.mul (local.get 0) (call $fac (i64.sub (local.get 0) (i64.const 1))))
-      )
-    )
-  )
-
-  (func $fac-acc (export "fac-acc") (param i64 i64) (result i64)
-    (if i64 (i64.eqz (local.get 0))
-      (then
-        (local.get 1)
-      )
-      (else
-        (call $fac-acc
-          (i64.sub (local.get 0) (i64.const 1))
-          (i64.mul (local.get 0) (local.get 1))
-        )
-      )
-    )
-  )
-
-  (func $fib (export "fib") (param i64) (result i64)
-    (if i64 (i64.le_u (local.get 0) (i64.const 1))
-      (then
-        (i64.const 1)
-      )
-      (else
-        (i64.add
-          (call $fib (i64.sub (local.get 0) (i64.const 2)))
-          (call $fib (i64.sub (local.get 0) (i64.const 1)))
-        )
-      )
-    )
-  )
-
-  (func $even (export "even") (param i64) (result i32)
-    (if i32 (i64.eqz (local.get 0))
-      (then
-        (i32.const 44)
-      )
-      (else
-        (call $odd (i64.sub (local.get 0) (i64.const 1)))
-      )
-    )
-  )
-  (func $odd (export "odd") (param i64) (result i32)
-    (if i32 (i64.eqz (local.get 0))
-      (then
-        (i32.const 99)
-      )
-      (else
-        (call $even (i64.sub (local.get 0) (i64.const 1)))
-      )
-    )
-  )
-
-  ;; Stack exhaustion
-
-  ;; Implementations are required to have every call consume some abstract
-  ;; resource towards exhausting some abstract finite limit, such that
-  ;; infinitely recursive test cases reliably trap in finite time. This is
-  ;; because otherwise applications could come to depend on it on those
-  ;; implementations and be incompatible with implementations that don't do
-  ;; it (or don't do it under the same circumstances).
-
-  (func $runaway (export "runaway") (call $runaway))
-
-  (func $mutual-runaway1 (export "mutual-runaway") (call $mutual-runaway2))
-  (func $mutual-runaway2 (call $mutual-runaway1))
-)
-
-(assert_return (invoke "type-i32") (i32.const 0x132))
-(assert_return (invoke "type-i64") (i64.const 0x164))
-(assert_return (invoke "type-f32") (f32.const 0xf32))
-(assert_return (invoke "type-f64") (f64.const 0xf64))
-
-(assert_return (invoke "type-first-i32") (i32.const 32))
-(assert_return (invoke "type-first-i64") (i64.const 64))
-(assert_return (invoke "type-first-f32") (f32.const 1.32))
-(assert_return (invoke "type-first-f64") (f64.const 1.64))
-
-(assert_return (invoke "type-second-i32") (i32.const 32))
-(assert_return (invoke "type-second-i64") (i64.const 64))
-(assert_return (invoke "type-second-f32") (f32.const 32))
-(assert_return (invoke "type-second-f64") (f64.const 64.1))
-
-(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
-(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
-(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120))
-(assert_return
-  (invoke "fac-acc" (i64.const 25) (i64.const 1))
-  (i64.const 7034535277573963776)
-)
-
-(assert_return (invoke "fib" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fib" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fib" (i64.const 2)) (i64.const 2))
-(assert_return (invoke "fib" (i64.const 5)) (i64.const 8))
-(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946))
-
-(assert_return (invoke "even" (i64.const 0)) (i32.const 44))
-(assert_return (invoke "even" (i64.const 1)) (i32.const 99))
-(assert_return (invoke "even" (i64.const 10)) (i32.const 44))
-(assert_return (invoke "even" (i64.const 7)) (i32.const 99))
-(assert_return (invoke "odd" (i64.const 0)) (i32.const 99))
-(assert_return (invoke "odd" (i64.const 1)) (i32.const 44))
-(assert_return (invoke "odd" (i64.const 20)) (i32.const 99))
-(assert_return (invoke "odd" (i64.const 7)) (i32.const 44))
-
-(assert_trap (invoke "runaway") "call stack exhausted")
-(assert_trap (invoke "mutual-runaway") "call stack exhausted")
-
-
-;; Invalid typing
-
-(assert_invalid
-  (module
-    (func $type-void-vs-num (i32.eqz (call 1)))
-    (func)
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (func $type-num-vs-num (i32.eqz (call 1)))
-    (func (result i64) (i64.const 1))
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (func $arity-0-vs-1 (call 1))
-    (func (param i32))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (func $arity-0-vs-2 (call 1))
-    (func (param f64 i32))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (func $arity-1-vs-0 (call 1 (i32.const 1)))
-    (func)
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (func $arity-2-vs-0 (call 1 (f64.const 2) (i32.const 1)))
-    (func)
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (func $type-first-void-vs-num (call 1 (nop) (i32.const 1)))
-    (func (param i32 i32))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (func $type-second-void-vs-num (call 1 (i32.const 1) (nop)))
-    (func (param i32 i32))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (func $type-first-num-vs-num (call 1 (f64.const 1) (i32.const 1)))
-    (func (param i32 f64))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (func $type-second-num-vs-num (call 1 (i32.const 1) (f64.const 1)))
-    (func (param f64 i32))
-  )
-  "type mismatch"
-)
-
-
-;; Unbound function
-
-(assert_invalid
-  (module (func $unbound-func (call 1)))
-  "unknown function"
-)
-(assert_invalid
-  (module (func $large-func (call 1012321300)))
-  "unknown function"
-)
diff --git a/test/spec/old_call_indirect.wast b/test/spec/old_call_indirect.wast
deleted file mode 100644
index 00ecd0863..000000000
--- a/test/spec/old_call_indirect.wast
+++ /dev/null
@@ -1,378 +0,0 @@
-;; Test `call_indirect` operator
-
-(module
-  ;; Auxiliary definitions
-  (type $proc (func))
-  (type $out-i32 (func (result i32)))
-  (type $out-i64 (func (result i64)))
-  (type $out-f32 (func (result f32)))
-  (type $out-f64 (func (result f64)))
-  (type $over-i32 (func (param i32) (result i32)))
-  (type $over-i64 (func (param i64) (result i64)))
-  (type $over-f32 (func (param f32) (result f32)))
-  (type $over-f64 (func (param f64) (result f64)))
-  (type $f32-i32 (func (param f32 i32) (result i32)))
-  (type $i32-i64 (func (param i32 i64) (result i64)))
-  (type $f64-f32 (func (param f64 f32) (result f32)))
-  (type $i64-f64 (func (param i64 f64) (result f64)))
-  (type $over-i32-duplicate (func (param i32) (result i32)))
-  (type $over-i64-duplicate (func (param i64) (result i64)))
-  (type $over-f32-duplicate (func (param f32) (result f32)))
-  (type $over-f64-duplicate (func (param f64) (result f64)))
-
-  (func $const-i32 (type $out-i32) (i32.const 0x132))
-  (func $const-i64 (type $out-i64) (i64.const 0x164))
-  (func $const-f32 (type $out-f32) (f32.const 0xf32))
-  (func $const-f64 (type $out-f64) (f64.const 0xf64))
-
-  (func $id-i32 (type $over-i32) (local.get 0))
-  (func $id-i64 (type $over-i64) (local.get 0))
-  (func $id-f32 (type $over-f32) (local.get 0))
-  (func $id-f64 (type $over-f64) (local.get 0))
-
-  (func $i32-i64 (type $i32-i64) (local.get 1))
-  (func $i64-f64 (type $i64-f64) (local.get 1))
-  (func $f32-i32 (type $f32-i32) (local.get 1))
-  (func $f64-f32 (type $f64-f32) (local.get 1))
-
-  (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0))
-  (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0))
-  (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0))
-  (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0))
-
-  (table funcref
-    (elem
-      $const-i32 $const-i64 $const-f32 $const-f64
-      $id-i32 $id-i64 $id-f32 $id-f64
-      $f32-i32 $i32-i64 $f64-f32 $i64-f64
-      $fac $fib $even $odd
-      $runaway $mutual-runaway1 $mutual-runaway2
-      $over-i32-duplicate $over-i64-duplicate
-      $over-f32-duplicate $over-f64-duplicate
-    )
-  )
-
-  ;; Typing
-
-  (func (export "type-i32") (result i32) (call_indirect (type $out-i32) (i32.const 0)))
-  (func (export "type-i64") (result i64) (call_indirect (type $out-i64) (i32.const 1)))
-  (func (export "type-f32") (result f32) (call_indirect (type $out-f32) (i32.const 2)))
-  (func (export "type-f64") (result f64) (call_indirect (type $out-f64) (i32.const 3)))
-
-  (func (export "type-index") (result i64)
-    (call_indirect (type $over-i64) (i64.const 100) (i32.const 5))
-  )
-
-  (func (export "type-first-i32") (result i32)
-    (call_indirect (type $over-i32) (i32.const 32) (i32.const 4))
-  )
-  (func (export "type-first-i64") (result i64)
-    (call_indirect (type $over-i64) (i64.const 64) (i32.const 5))
-  )
-  (func (export "type-first-f32") (result f32)
-    (call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6))
-  )
-  (func (export "type-first-f64") (result f64)
-    (call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7))
-  )
-
-  (func (export "type-second-i32") (result i32)
-    (call_indirect (type $f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8))
-  )
-  (func (export "type-second-i64") (result i64)
-    (call_indirect (type $i32-i64) (i32.const 32) (i64.const 64) (i32.const 9))
-  )
-  (func (export "type-second-f32") (result f32)
-    (call_indirect (type $f64-f32) (f64.const 64) (f32.const 32) (i32.const 10))
-  )
-  (func (export "type-second-f64") (result f64)
-    (call_indirect (type $i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11))
-  )
-
-  ;; Dispatch
-
-  (func (export "dispatch") (param i32 i64) (result i64)
-    (call_indirect (type $over-i64) (local.get 1) (local.get 0))
-  )
-
-  (func (export "dispatch-structural") (param i32) (result i64)
-    (call_indirect (type $over-i64-duplicate) (i64.const 9) (local.get 0))
-  )
-
-  ;; Recursion
-
-  (func $fac (export "fac") (type $over-i64)
-    (if i64 (i64.eqz (local.get 0))
-      (then
-        (i64.const 1)
-      )
-      (else
-        (i64.mul
-          (local.get 0)
-          (call_indirect (type $over-i64)
-            (i64.sub (local.get 0) (i64.const 1))
-            (i32.const 12)
-          )
-        )
-      )
-    )
-  )
-
-  (func $fib (export "fib") (type $over-i64)
-    (if i64 (i64.le_u (local.get 0) (i64.const 1))
-      (then
-        (i64.const 1)
-      )
-      (else
-        (i64.add
-          (call_indirect (type $over-i64)
-            (i64.sub (local.get 0) (i64.const 2))
-            (i32.const 13)
-          )
-          (call_indirect (type $over-i64)
-            (i64.sub (local.get 0) (i64.const 1))
-            (i32.const 13)
-          )
-        )
-      )
-    )
-  )
-
-  (func $even (export "even") (param i32) (result i32)
-    (if i32 (i32.eqz (local.get 0))
-      (then
-        (i32.const 44)
-      )
-      (else
-        (call_indirect (type $over-i32)
-          (i32.sub (local.get 0) (i32.const 1))
-          (i32.const 15)
-        )
-      )
-    )
-  )
-  (func $odd (export "odd") (param i32) (result i32)
-    (if i32 (i32.eqz (local.get 0))
-      (then
-        (i32.const 99)
-      )
-      (else
-        (call_indirect (type $over-i32)
-          (i32.sub (local.get 0) (i32.const 1))
-          (i32.const 14)
-        )
-      )
-    )
-  )
-
-  ;; Stack exhaustion
-
-  ;; Implementations are required to have every call consume some abstract
-  ;; resource towards exhausting some abstract finite limit, such that
-  ;; infinitely recursive test cases reliably trap in finite time. This is
-  ;; because otherwise applications could come to depend on it on those
-  ;; implementations and be incompatible with implementations that don't do
-  ;; it (or don't do it under the same circumstances).
-
-  (func $runaway (export "runaway") (call_indirect (type $proc) (i32.const 16)))
-
-  (func $mutual-runaway1 (export "mutual-runaway") (call_indirect (type $proc) (i32.const 18)))
-  (func $mutual-runaway2 (call_indirect (type $proc) (i32.const 17)))
-)
-
-(assert_return (invoke "type-i32") (i32.const 0x132))
-(assert_return (invoke "type-i64") (i64.const 0x164))
-(assert_return (invoke "type-f32") (f32.const 0xf32))
-(assert_return (invoke "type-f64") (f64.const 0xf64))
-
-(assert_return (invoke "type-index") (i64.const 100))
-
-(assert_return (invoke "type-first-i32") (i32.const 32))
-(assert_return (invoke "type-first-i64") (i64.const 64))
-(assert_return (invoke "type-first-f32") (f32.const 1.32))
-(assert_return (invoke "type-first-f64") (f64.const 1.64))
-
-(assert_return (invoke "type-second-i32") (i32.const 32))
-(assert_return (invoke "type-second-i64") (i64.const 64))
-(assert_return (invoke "type-second-f32") (f32.const 32))
-(assert_return (invoke "type-second-f64") (f64.const 64.1))
-
-(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2))
-(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5))
-(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120))
-(assert_return (invoke "dispatch" (i32.const 13) (i64.const 5)) (i64.const 8))
-(assert_return (invoke "dispatch" (i32.const 20) (i64.const 2)) (i64.const 2))
-(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call signature mismatch")
-(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call signature mismatch")
-(assert_trap (invoke "dispatch" (i32.const 23) (i64.const 2)) "undefined element")
-(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element")
-(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element")
-
-(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9))
-(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9))
-(assert_return (invoke "dispatch-structural" (i32.const 12)) (i64.const 362880))
-(assert_return (invoke "dispatch-structural" (i32.const 20)) (i64.const 9))
-(assert_trap (invoke "dispatch-structural" (i32.const 11)) "indirect call signature mismatch")
-(assert_trap (invoke "dispatch-structural" (i32.const 22)) "indirect call signature mismatch")
-
-(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
-(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
-
-(assert_return (invoke "fib" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fib" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fib" (i64.const 2)) (i64.const 2))
-(assert_return (invoke "fib" (i64.const 5)) (i64.const 8))
-(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946))
-
-(assert_return (invoke "even" (i32.const 0)) (i32.const 44))
-(assert_return (invoke "even" (i32.const 1)) (i32.const 99))
-(assert_return (invoke "even" (i32.const 10)) (i32.const 44))
-(assert_return (invoke "even" (i32.const 7)) (i32.const 99))
-(assert_return (invoke "odd" (i32.const 0)) (i32.const 99))
-(assert_return (invoke "odd" (i32.const 1)) (i32.const 44))
-(assert_return (invoke "odd" (i32.const 20)) (i32.const 99))
-(assert_return (invoke "odd" (i32.const 7)) (i32.const 44))
-
-(assert_trap (invoke "runaway") "call stack exhausted")
-(assert_trap (invoke "mutual-runaway") "call stack exhausted")
-
-
-;; Invalid typing
-
-(assert_invalid
-  (module
-    (type (func))
-    (func $no-table (call_indirect (type 0) (i32.const 0)))
-  )
-  "unknown table"
-)
-
-(assert_invalid
-  (module
-    (type (func))
-    (table 0 funcref)
-    (func $type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type (func (result i64)))
-    (table 0 funcref)
-    (func $type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (type (func (param i32)))
-    (table 0 funcref)
-    (func $arity-0-vs-1 (call_indirect (type 0) (i32.const 0)))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type (func (param f64 i32)))
-    (table 0 funcref)
-    (func $arity-0-vs-2 (call_indirect (type 0) (i32.const 0)))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type (func))
-    (table 0 funcref)
-    (func $arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0)))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type (func))
-    (table 0 funcref)
-    (func $arity-2-vs-0
-      (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
-    )
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (type (func (param i32)))
-    (table 0 funcref)
-    (func $type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop)))
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type (func (param i32)))
-    (table 0 funcref)
-    (func $type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1)))
-  )
-  "type mismatch"
-)
-
-(assert_invalid
-  (module
-    (type (func (param i32 i32)))
-    (table 0 funcref)
-    (func $type-first-void-vs-num
-      (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
-    )
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type (func (param i32 i32)))
-    (table 0 funcref)
-    (func $type-second-void-vs-num
-      (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
-    )
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type (func (param i32 f64)))
-    (table 0 funcref)
-    (func $type-first-num-vs-num
-      (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
-    )
-  )
-  "type mismatch"
-)
-(assert_invalid
-  (module
-    (type (func (param f64 i32)))
-    (table 0 funcref)
-    (func $type-second-num-vs-num
-      (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
-    )
-  )
-  "type mismatch"
-)
-
-
-;; Unbound type
-
-(assert_invalid
-  (module
-    (table 0 funcref)
-    (func $unbound-type (call_indirect (type 1) (i32.const 0)))
-  )
-  "unknown type"
-)
-(assert_invalid
-  (module
-    (table 0 funcref)
-    (func $large-type (call_indirect (type 1012321300) (i32.const 0)))
-  )
-  "unknown type"
-)
diff --git a/test/spec/old_float_exprs.wast b/test/spec/old_float_exprs.wast
deleted file mode 100644
index bc3505810..000000000
--- a/test/spec/old_float_exprs.wast
+++ /dev/null
@@ -1,1979 +0,0 @@
-;; Test interesting floating-point "expressions". These tests contain code
-;; patterns which tempt common value-changing optimizations.
-
-;; Test that x*y+z is not done with x87-style intermediate precision.
-
-(module
-  (func (export "f64.no_contraction") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
-)
-
-(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))
-(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))
-(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))
-(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))
-(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))
-
-;; Test that x*y+z is not folded to fma.
-
-(module
-  (func (export "f32.no_fma") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.add (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
-  (func (export "f64.no_fma") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
-)
-
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-
-;; Test that x+0.0 is not folded to x.
-;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations".
-
-(module
-  (func (export "f32.no_fold_add_zero") (param $x f32) (result f32)
-    (f32.add (local.get $x) (f32.const 0.0)))
-  (func (export "f64.no_fold_add_zero") (param $x f64) (result f64)
-    (f64.add (local.get $x) (f64.const 0.0)))
-)
-
-(assert_return (invoke "f32.no_fold_add_zero" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f64.no_fold_add_zero" (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f32.no_fold_add_zero" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f64.no_fold_add_zero" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that 0.0 - x is not folded to -x.
-
-(module
-  (func (export "f32.no_fold_zero_sub") (param $x f32) (result f32)
-    (f32.sub (f32.const 0.0) (local.get $x)))
-  (func (export "f64.no_fold_zero_sub") (param $x f64) (result f64)
-    (f64.sub (f64.const 0.0) (local.get $x)))
-)
-
-(assert_return (invoke "f32.no_fold_zero_sub" (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f64.no_fold_zero_sub" (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f32.no_fold_zero_sub" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f64.no_fold_zero_sub" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that x - 0.0 is not folded to x.
-
-(module
-  (func (export "f32.no_fold_sub_zero") (param $x f32) (result f32)
-    (f32.sub (local.get $x) (f32.const 0.0)))
-  (func (export "f64.no_fold_sub_zero") (param $x f64) (result f64)
-    (f64.sub (local.get $x) (f64.const 0.0)))
-)
-
-(assert_return (invoke "f32.no_fold_sub_zero" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f64.no_fold_sub_zero" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that x*0.0 is not folded to 0.0.
-
-(module
-  (func (export "f32.no_fold_mul_zero") (param $x f32) (result f32)
-    (f32.mul (local.get $x) (f32.const 0.0)))
-  (func (export "f64.no_fold_mul_zero") (param $x f64) (result f64)
-    (f64.mul (local.get $x) (f64.const 0.0)))
-)
-
-(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -1.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -2.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_mul_zero" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -1.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -2.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_mul_zero" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that x*1.0 is not folded to x.
-;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations".
-
-(module
-  (func (export "f32.no_fold_mul_one") (param $x f32) (result f32)
-    (f32.mul (local.get $x) (f32.const 1.0)))
-  (func (export "f64.no_fold_mul_one") (param $x f64) (result f64)
-    (f64.mul (local.get $x) (f64.const 1.0)))
-)
-
-(assert_return (invoke "f32.no_fold_mul_one" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f64.no_fold_mul_one" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that 0.0/x is not folded to 0.0.
-
-(module
-  (func (export "f32.no_fold_zero_div") (param $x f32) (result f32)
-    (f32.div (f32.const 0.0) (local.get $x)))
-  (func (export "f64.no_fold_zero_div") (param $x f64) (result f64)
-    (f64.div (f64.const 0.0) (local.get $x)))
-)
-
-;; (assert_return_nan (invoke "f32.no_fold_zero_div" (f32.const 0.0)))
-;; (assert_return_nan (invoke "f32.no_fold_zero_div" (f32.const -0.0)))
-(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-;; (assert_return_nan (invoke "f64.no_fold_zero_div" (f64.const 0.0)))
-;; (assert_return_nan (invoke "f64.no_fold_zero_div" (f64.const -0.0)))
-(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that x/1.0 is not folded to x.
-
-(module
-  (func (export "f32.no_fold_div_one") (param $x f32) (result f32)
-    (f32.div (local.get $x) (f32.const 1.0)))
-  (func (export "f64.no_fold_div_one") (param $x f64) (result f64)
-    (f64.div (local.get $x) (f64.const 1.0)))
-)
-
-(assert_return (invoke "f32.no_fold_div_one" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f64.no_fold_div_one" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that x/-1.0 is not folded to -x.
-
-(module
-  (func (export "f32.no_fold_div_neg1") (param $x f32) (result f32)
-    (f32.div (local.get $x) (f32.const -1.0)))
-  (func (export "f64.no_fold_div_neg1") (param $x f64) (result f64)
-    (f64.div (local.get $x) (f64.const -1.0)))
-)
-
-(assert_return (invoke "f32.no_fold_div_neg1" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f64.no_fold_div_neg1" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that -0.0 - x is not folded to -x.
-
-(module
-  (func (export "f32.no_fold_neg0_sub") (param $x f32) (result f32)
-    (f32.sub (f32.const -0.0) (local.get $x)))
-  (func (export "f64.no_fold_neg0_sub") (param $x f64) (result f64)
-    (f64.sub (f64.const -0.0) (local.get $x)))
-)
-
-(assert_return (invoke "f32.no_fold_neg0_sub" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f64.no_fold_neg0_sub" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that -1.0 * x is not folded to -x.
-
-(module
-  (func (export "f32.no_fold_neg1_mul") (param $x f32) (result f32)
-    (f32.mul (f32.const -1.0) (local.get $x)))
-  (func (export "f64.no_fold_neg1_mul") (param $x f64) (result f64)
-    (f64.mul (f64.const -1.0) (local.get $x)))
-)
-
-(assert_return (invoke "f32.no_fold_neg1_mul" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f64.no_fold_neg1_mul" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that x == x is not folded to true.
-
-(module
-  (func (export "f32.no_fold_eq_self") (param $x f32) (result i32)
-    (f32.eq (local.get $x) (local.get $x)))
-  (func (export "f64.no_fold_eq_self") (param $x f64) (result i32)
-    (f64.eq (local.get $x) (local.get $x)))
-)
-
-(assert_return (invoke "f32.no_fold_eq_self" (f32.const nan)) (i32.const 0))
-(assert_return (invoke "f64.no_fold_eq_self" (f64.const nan)) (i32.const 0))
-
-;; Test that x != x is not folded to false.
-
-(module
-  (func (export "f32.no_fold_ne_self") (param $x f32) (result i32)
-    (f32.ne (local.get $x) (local.get $x)))
-  (func (export "f64.no_fold_ne_self") (param $x f64) (result i32)
-    (f64.ne (local.get $x) (local.get $x)))
-)
-
-(assert_return (invoke "f32.no_fold_ne_self" (f32.const nan)) (i32.const 1))
-(assert_return (invoke "f64.no_fold_ne_self" (f64.const nan)) (i32.const 1))
-
-;; Test that x - x is not folded to 0.0.
-
-(module
-  (func (export "f32.no_fold_sub_self") (param $x f32) (result f32)
-    (f32.sub (local.get $x) (local.get $x)))
-  (func (export "f64.no_fold_sub_self") (param $x f64) (result f64)
-    (f64.sub (local.get $x) (local.get $x)))
-)
-
-;; (assert_return_nan (invoke "f32.no_fold_sub_self" (f32.const infinity)))
-(assert_return (invoke "f32.no_fold_sub_self" (f32.const nan)) (f32.const nan))
-;; (assert_return_nan (invoke "f64.no_fold_sub_self" (f64.const infinity)))
-(assert_return (invoke "f64.no_fold_sub_self" (f64.const nan)) (f64.const nan))
-
-;; Test that x/3 is not folded to x*(1/3).
-
-(module
-  (func (export "f32.no_fold_div_3") (param $x f32) (result f32)
-    (f32.div (local.get $x) (f32.const 3.0)))
-  (func (export "f64.no_fold_div_3") (param $x f64) (result f64)
-    (f64.div (local.get $x) (f64.const 3.0)))
-)
-
-(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.359c26p+50)) (f32.const -0x1.9cd032p+48))
-(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.e45646p+93)) (f32.const -0x1.42e42ep+92))
-(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.2a3916p-83)) (f32.const -0x1.8da172p-85))
-(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.1f8b38p-124)) (f32.const -0x1.7f644ap-126))
-(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.d64f64p-56)) (f32.const -0x1.398a42p-57))
-(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.a8a88d29e2cc3p+632)) (f64.const -0x1.1b1b08c69732dp+631))
-(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.bcf52dc950972p-167)) (f64.const -0x1.28a373db8b0f7p-168))
-(assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.bd3c0d989f7a4p-874)) (f64.const 0x1.28d2b3bb14fc3p-875))
-(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.0138bf530a53cp+1007)) (f64.const -0x1.56f6546eb86fbp+1005))
-(assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.052b87f9d794dp+415)) (f64.const 0x1.5c3a0aa274c67p+413))
-
-;; Test that (x*z)+(y*z) is not folded to (x+y)*z
-
-(module
-  (func (export "f32.no_factor") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.add (f32.mul (local.get $x) (local.get $z)) (f32.mul (local.get $y) (local.get $z))))
-  (func (export "f64.no_factor") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.add (f64.mul (local.get $x) (local.get $z)) (f64.mul (local.get $y) (local.get $z))))
-)
-
-(assert_return (invoke "f32.no_factor" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7dp+109))
-(assert_return (invoke "f32.no_factor" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a342p-14))
-(assert_return (invoke "f32.no_factor" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651aaep+82))
-(assert_return (invoke "f32.no_factor" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa15p+55))
-(assert_return (invoke "f32.no_factor" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9cep-50))
-(assert_return (invoke "f64.no_factor" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1ap-649))
-(assert_return (invoke "f64.no_factor" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const 0x0p+0))
-(assert_return (invoke "f64.no_factor" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e2p+198))
-(assert_return (invoke "f64.no_factor" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f184p-512))
-(assert_return (invoke "f64.no_factor" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af53p-90))
-
-;; Test that (x+y)*z is not folded to (x*z)+(y*z)
-
-(module
-  (func (export "f32.no_distribute") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.mul (f32.add (local.get $x) (local.get $y)) (local.get $z)))
-  (func (export "f64.no_distribute") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.mul (f64.add (local.get $x) (local.get $y)) (local.get $z)))
-)
-
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7d2p+109))
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a34p-14))
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651abp+82))
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa14ep+55))
-(assert_return (invoke "f32.no_distribute" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9ccp-50))
-(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1bp-649))
-(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const -0x0p+0))
-(assert_return (invoke "f64.no_distribute" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e1fp+198))
-(assert_return (invoke "f64.no_distribute" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f183p-512))
-(assert_return (invoke "f64.no_distribute" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af52p-90))
-
-;; Test that x*(y/z) is not folded to (x*y)/z
-
-(module
-  (func (export "f32.no_regroup_div_mul") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.mul (local.get $x) (f32.div (local.get $y) (local.get $z))))
-  (func (export "f64.no_regroup_div_mul") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.mul (local.get $x) (f64.div (local.get $y) (local.get $z))))
-)
-
-(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x1.2844cap-63))
-(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x0p+0))
-(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.792258p+118))
-(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df2p-89))
-(assert_return (invoke "f32.no_regroup_div_mul" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -0x1.47d0eap+66))
-(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2dp+99))
-(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x0p+0))
-(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const infinity))
-(assert_return (invoke "f64.no_regroup_div_mul" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -0x1.926fa3cacc651p+255))
-(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x1.38d55f56406dp-639))
-
-;; Test that (x*y)/z is not folded to x*(y/z)
-
-(module
-  (func (export "f32.no_regroup_mul_div") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
-  (func (export "f64.no_regroup_mul_div") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
-)
-
-(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x0p+0))
-(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x1.1a00e8p-96))
-(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.79225ap+118))
-(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df4p-89))
-(assert_return (invoke "f32.no_regroup_mul_div" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -infinity))
-(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2ep+99))
-(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x1.0da0b6328e09p-907))
-(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const 0x1.4886b6d9a9a79p+871))
-(assert_return (invoke "f64.no_regroup_mul_div" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -infinity))
-(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x0p+0))
-
-;; Test that x+y+z+w is not reassociated.
-
-(module
-  (func (export "f32.no_reassociate_add") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
-    (f32.add (f32.add (f32.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
-  (func (export "f64.no_reassociate_add") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
-    (f64.add (f64.add (f64.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
-)
-
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-
-;; Test that x*y*z*w is not reassociated.
-
-(module
-  (func (export "f32.no_reassociate_mul") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
-    (f32.mul (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
-  (func (export "f64.no_reassociate_mul") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
-    (f64.mul (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
-)
-
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-(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))
-
-;; Test that x/0 is not folded away.
-
-(module
-  (func (export "f32.no_fold_div_0") (param $x f32) (result f32)
-    (f32.div (local.get $x) (f32.const 0.0)))
-  (func (export "f64.no_fold_div_0") (param $x f64) (result f64)
-    (f64.div (local.get $x) (f64.const 0.0)))
-)
-
-(assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const infinity))
-(assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -infinity))
-(assert_return (invoke "f32.no_fold_div_0" (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "f32.no_fold_div_0" (f32.const -infinity)) (f32.const -infinity))
-;; (assert_return_nan (invoke "f32.no_fold_div_0" (f32.const 0)))
-;; (assert_return_nan (invoke "f32.no_fold_div_0" (f32.const -0)))
-(assert_return (invoke "f32.no_fold_div_0" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f32.no_fold_div_0" (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const infinity))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -infinity))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const -infinity)) (f64.const -infinity))
-;; (assert_return_nan (invoke "f64.no_fold_div_0" (f64.const 0)))
-;; (assert_return_nan (invoke "f64.no_fold_div_0" (f64.const -0)))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that x/-0 is not folded away.
-
-(module
-  (func (export "f32.no_fold_div_neg0") (param $x f32) (result f32)
-    (f32.div (local.get $x) (f32.const -0.0)))
-  (func (export "f64.no_fold_div_neg0") (param $x f64) (result f64)
-    (f64.div (local.get $x) (f64.const -0.0)))
-)
-
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -infinity))
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const infinity))
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -infinity)) (f32.const infinity))
-;; (assert_return_nan (invoke "f32.no_fold_div_neg0" (f32.const 0)))
-;; (assert_return_nan (invoke "f32.no_fold_div_neg0" (f32.const -0)))
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan:0x200000)) (f32.const nan:0x400000))
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -infinity))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const infinity))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -infinity)) (f64.const infinity))
-;; (assert_return_nan (invoke "f64.no_fold_div_neg0" (f64.const 0)))
-;; (assert_return_nan (invoke "f64.no_fold_div_neg0" (f64.const -0)))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan:0x4000000000000)) (f64.const nan:0x8000000000000))
-
-;; Test that sqrt(x*x+y*y) is not folded to hypot.
-
-(module
-  (func (export "f32.no_fold_to_hypot") (param $x f32) (param $y f32) (result f32)
-    (f32.sqrt (f32.add (f32.mul (local.get $x) (local.get $x))
-                       (f32.mul (local.get $y) (local.get $y)))))
-  (func (export "f64.no_fold_to_hypot") (param $x f64) (param $y f64) (result f64)
-    (f64.sqrt (f64.add (f64.mul (local.get $x) (local.get $x))
-                       (f64.mul (local.get $y) (local.get $y)))))
-)
-
-(assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.c2f338p-81) (f32.const 0x1.401b5ep-68)) (f32.const 0x1.401cccp-68))
-(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.c38d1p-71) (f32.const -0x1.359ddp-107)) (f32.const 0x1.c36a62p-71))
-(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.99e0cap-114) (f32.const -0x1.ed0c6cp-69)) (f32.const 0x1.ed0e48p-69))
-(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.1b6ceap+5) (f32.const 0x1.5440bep+17)) (f32.const 0x1.5440cp+17))
-(assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.8f019ep-76) (f32.const -0x1.182308p-71)) (f32.const 0x1.17e2bcp-71))
-(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.1a0ac4f7c8711p-636) (f64.const 0x1.1372ebafff551p-534)) (f64.const 0x1.13463fa37014ep-534))
-(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.b793512167499p+395) (f64.const -0x1.11cbc52af4c36p+410)) (f64.const 0x1.11cbc530783a2p+410))
-(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.76777f44ff40bp-536) (f64.const -0x1.c3896e4dc1fbp-766)) (f64.const 0x1.8p-536))
-(assert_return (invoke "f64.no_fold_to_hypot" (f64.const -0x1.889ac72cc6b5dp-521) (f64.const 0x1.8d7084e659f3bp-733)) (f64.const 0x1.889ac72ca843ap-521))
-(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.5ee588c02cb08p-670) (f64.const -0x1.05ce25788d9ecp-514)) (f64.const 0x1.05ce25788d9dfp-514))
-
-;; Test that 1.0/x isn't approximated.
-
-(module
-  (func (export "f32.no_approximate_reciprocal") (param $x f32) (result f32)
-    (f32.div (f32.const 1.0) (local.get $x)))
-)
-
-(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.2900b6p-10)) (f32.const -0x1.b950d4p+9))
-(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.e7212p+127)) (f32.const 0x1.0d11f8p-128))
-(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.42a466p-93)) (f32.const -0x1.963ee6p+92))
-(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.5d0c32p+76)) (f32.const 0x1.778362p-77))
-(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.601de2p-82)) (f32.const -0x1.743d7ep+81))
-
-;; Test that 1.0/sqrt(x) isn't approximated or fused.
-
-(module
-  (func (export "f32.no_approximate_reciprocal_sqrt") (param $x f32) (result f32)
-    (f32.div (f32.const 1.0) (f32.sqrt (local.get $x))))
-  (func (export "f64.no_fuse_reciprocal_sqrt") (param $x f64) (result f64)
-    (f64.div (f64.const 1.0) (f64.sqrt (local.get $x))))
-)
-
-(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.6af12ap-43)) (f32.const 0x1.300ed4p+21))
-(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.e82fc6p-8)) (f32.const 0x1.72c376p+3))
-(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.b9fa9cp-66)) (f32.const 0x1.85a9bap+32))
-(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.f4f546p-44)) (f32.const 0x1.6e01c2p+21))
-(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.5da7aap-86)) (f32.const 0x1.b618cap+42))
-
-(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.1568a63b55fa3p+889)) (f64.const 0x1.5bc9c74c9952p-445))
-(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.239fcd0939cafp+311)) (f64.const 0x1.5334a922b4818p-156))
-(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.6e36a24e11054p+104)) (f64.const 0x1.ac13f20977f29p-53))
-(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.23ee173219f83p+668)) (f64.const 0x1.df753e055862dp-335))
-(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.b30f74caf9babp+146)) (f64.const 0x1.88bfc3d1764a9p-74))
-
-;; Test that sqrt(1.0/x) isn't approximated.
-
-(module
-  (func (export "f32.no_approximate_sqrt_reciprocal") (param $x f32) (result f32)
-    (f32.sqrt (f32.div (f32.const 1.0) (local.get $x))))
-)
-
-(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.a4c986p+60)) (f32.const 0x1.8f5ac6p-31))
-(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.50511ep-9)) (f32.const 0x1.3bdd46p+4))
-(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.125ec2p+69)) (f32.const 0x1.5db572p-35))
-(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.ba4c5p+13)) (f32.const 0x1.136f16p-7))
-(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.4a5be2p+104)) (f32.const 0x1.c2b5bp-53))
-
-;; Test that converting i32/i64 to f32/f64 and back isn't folded away
-
-(module
-  (func (export "i32.no_fold_f32_s") (param i32) (result i32)
-    (i32.trunc_f32_s (f32.convert_i32_s (local.get 0))))
-  (func (export "i32.no_fold_f32_u") (param i32) (result i32)
-    (i32.trunc_f32_u (f32.convert_i32_u (local.get 0))))
-  (func (export "i64.no_fold_f64_s") (param i64) (result i64)
-    (i64.trunc_f64_s (f64.convert_i64_s (local.get 0))))
-  (func (export "i64.no_fold_f64_u") (param i64) (result i64)
-    (i64.trunc_f64_u (f64.convert_i64_u (local.get 0))))
-)
-
-(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000000)) (i32.const 0x1000000))
-(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000001)) (i32.const 0x1000000))
-(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0xf0000010)) (i32.const 0xf0000010))
-
-(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000000)) (i32.const 0x1000000))
-(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000001)) (i32.const 0x1000000))
-(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0xf0000010)) (i32.const 0xf0000000))
-
-(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000000)) (i64.const 0x20000000000000))
-(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000001)) (i64.const 0x20000000000000))
-(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000400))
-
-(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000000)) (i64.const 0x20000000000000))
-(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000001)) (i64.const 0x20000000000000))
-(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000000))
-
-;; Test that x+y-y is not folded to x.
-
-(module
-  (func (export "f32.no_fold_add_sub") (param $x f32) (param $y f32) (result f32)
-    (f32.sub (f32.add (local.get $x) (local.get $y)) (local.get $y)))
-  (func (export "f64.no_fold_add_sub") (param $x f64) (param $y f64) (result f64)
-    (f64.sub (f64.add (local.get $x) (local.get $y)) (local.get $y)))
-)
-
-(assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.b553e4p-47) (f32.const -0x1.67db2cp-26)) (f32.const 0x1.cp-47))
-(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.a884dp-23) (f32.const 0x1.f2ae1ep-19)) (f32.const -0x1.a884ep-23))
-(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.fc04fp+82) (f32.const -0x1.65403ap+101)) (f32.const -0x1p+83))
-(assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.870fa2p-78) (f32.const 0x1.c54916p-56)) (f32.const 0x1.8p-78))
-(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.17e966p-108) (f32.const -0x1.5fa61ap-84)) (f32.const -0x1p-107))
-
-(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1053ea172dba8p-874) (f64.const 0x1.113c413408ac8p-857)) (f64.const -0x1.1053ea172p-874))
-(assert_return (invoke "f64.no_fold_add_sub" (f64.const 0x1.e377d54807972p-546) (f64.const 0x1.040a0a4d1ff7p-526)) (f64.const 0x1.e377d548p-546))
-(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.75f53cd926b62p-30) (f64.const -0x1.66b176e602bb5p-3)) (f64.const -0x1.75f53dp-30))
-(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.c450ff28332ap-341) (f64.const 0x1.15a5855023baep-305)) (f64.const -0x1.c451p-341))
-(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1ad4a596d3ea8p-619) (f64.const -0x1.17d81a41c0ea8p-588)) (f64.const -0x1.1ad4a8p-619))
-
-;; Test that x-y+y is not folded to x.
-
-(module
-  (func (export "f32.no_fold_sub_add") (param $x f32) (param $y f32) (result f32)
-    (f32.add (f32.sub (local.get $x) (local.get $y)) (local.get $y)))
-  (func (export "f64.no_fold_sub_add") (param $x f64) (param $y f64) (result f64)
-    (f64.add (f64.sub (local.get $x) (local.get $y)) (local.get $y)))
-)
-
-(assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.523cb8p+9) (f32.const 0x1.93096cp+8)) (f32.const -0x1.523cbap+9))
-(assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.a31a1p-111) (f32.const 0x1.745efp-95)) (f32.const -0x1.a4p-111))
-(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.3d5328p+26) (f32.const 0x1.58567p+35)) (f32.const 0x1.3d54p+26))
-(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.374e26p-39) (f32.const -0x1.66a5p-27)) (f32.const 0x1.374p-39))
-(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.320facp-3) (f32.const -0x1.ac069ap+14)) (f32.const 0x1.34p-3))
-
-(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.8f92aad2c9b8dp+255) (f64.const -0x1.08cd4992266cbp+259)) (f64.const 0x1.8f92aad2c9b9p+255))
-(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.5aaff55742c8bp-666) (f64.const 0x1.8f5f47181f46dp-647)) (f64.const 0x1.5aaff5578p-666))
-(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.21bc52967a98dp+251) (f64.const -0x1.fcffaa32d0884p+300)) (f64.const 0x1.2p+251))
-(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.9c78361f47374p-26) (f64.const -0x1.69d69f4edc61cp-13)) (f64.const 0x1.9c78361f48p-26))
-(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.4dbe68e4afab2p-367) (f64.const -0x1.dc24e5b39cd02p-361)) (f64.const 0x1.4dbe68e4afacp-367))
-
-;; Test that x*y/y is not folded to x.
-
-(module
-  (func (export "f32.no_fold_mul_div") (param $x f32) (param $y f32) (result f32)
-    (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $y)))
-  (func (export "f64.no_fold_mul_div") (param $x f64) (param $y f64) (result f64)
-    (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $y)))
-)
-
-(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.cd859ap+54) (f32.const 0x1.6ca936p-47)) (f32.const -0x1.cd8598p+54))
-(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.0b56b8p-26) (f32.const 0x1.48264cp-106)) (f32.const -0x1.0b56a4p-26))
-(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.e7555cp-48) (f32.const -0x1.9161cp+48)) (f32.const -0x1.e7555ap-48))
-(assert_return (invoke "f32.no_fold_mul_div" (f32.const 0x1.aaa50ep+52) (f32.const -0x1.dfb39ep+60)) (f32.const 0x1.aaa50cp+52))
-(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.2b7dfap-92) (f32.const -0x1.7c4ca6p-37)) (f32.const -0x1.2b7dfep-92))
-
-(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.3d79ff4118a1ap-837) (f64.const -0x1.b8b5dda31808cp-205)) (f64.const -0x1.3d79ff412263ep-837))
-(assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.f894d1ee6b3a4p+384) (f64.const 0x1.8c2606d03d58ap+585)) (f64.const 0x1.f894d1ee6b3a5p+384))
-(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.a022260acc993p+238) (f64.const -0x1.5fbc128fc8e3cp-552)) (f64.const -0x1.a022260acc992p+238))
-(assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.9d4b8ed174f54p-166) (f64.const 0x1.ee3d467aeeac6p-906)) (f64.const 0x1.8dcc95a053b2bp-166))
-(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.e95ea897cdcd4p+660) (f64.const -0x1.854d5df085f2ep-327)) (f64.const -0x1.e95ea897cdcd5p+660))
-
-;; Test that x/y*y is not folded to x.
-
-(module
-  (func (export "f32.no_fold_div_mul") (param $x f32) (param $y f32) (result f32)
-    (f32.mul (f32.div (local.get $x) (local.get $y)) (local.get $y)))
-  (func (export "f64.no_fold_div_mul") (param $x f64) (param $y f64) (result f64)
-    (f64.mul (f64.div (local.get $x) (local.get $y)) (local.get $y)))
-)
-
-(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.dc6364p+38) (f32.const 0x1.d630ecp+29)) (f32.const -0x1.dc6362p+38))
-(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.1f9836p-52) (f32.const -0x1.16c4e4p-18)) (f32.const -0x1.1f9838p-52))
-(assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.c5972cp-126) (f32.const -0x1.d6659ep+7)) (f32.const 0x1.c5980ep-126))
-(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.2e3a9ep-74) (f32.const -0x1.353994p+59)) (f32.const -0x1.2e3a4p-74))
-(assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.d96b82p-98) (f32.const 0x1.95d908p+27)) (f32.const 0x1.d96b84p-98))
-
-(assert_return (invoke "f64.no_fold_div_mul" (f64.const 0x1.d01f913a52481p-876) (f64.const -0x1.2cd0668b28344p+184)) (f64.const 0x1.d020daf71cdcp-876))
-(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.81cb7d400918dp-714) (f64.const 0x1.7caa643586d6ep-53)) (f64.const -0x1.81cb7d400918ep-714))
-(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.66904c97b5c8ep-145) (f64.const 0x1.5c3481592ad4cp+428)) (f64.const -0x1.66904c97b5c8dp-145))
-(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.e75859d2f0765p-278) (f64.const -0x1.5f19b6ab497f9p+283)) (f64.const -0x1.e75859d2f0764p-278))
-(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.515fe9c3b5f5p+620) (f64.const 0x1.36be869c99f7ap+989)) (f64.const -0x1.515fe9c3b5f4fp+620))
-
-;; Test that promote(demote(x)) is not folded to x.
-
-(module
-  (func (export "no_fold_demote_promote") (param $x f64) (result f64)
-    (f64.promote_f32 (f32.demote_f64 (local.get $x))))
-)
-
-(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.dece272390f5dp-133)) (f64.const -0x1.decep-133))
-(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.19e6c79938a6fp-85)) (f64.const -0x1.19e6c8p-85))
-(assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.49b297ec44dc1p+107)) (f64.const 0x1.49b298p+107))
-(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.74f5bd865163p-88)) (f64.const -0x1.74f5bep-88))
-(assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.26d675662367ep+104)) (f64.const 0x1.26d676p+104))
-
-;; Test that demote(promote(x)) is not folded to x, and aside from NaN is
-;; bit-preserving.
-
-(module
-  (func (export "no_fold_promote_demote") (param $x f32) (result f32)
-    (f32.demote_f64 (f64.promote_f32 (local.get $x))))
-)
-
-(assert_return (invoke "no_fold_promote_demote" (f32.const nan:0x200000)) (f32.const nan:0x600000))
-(assert_return (invoke "no_fold_promote_demote" (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "no_fold_promote_demote" (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-149)) (f32.const -0x1p-149))
-(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffcp-127)) (f32.const 0x1.fffffcp-127))
-(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffcp-127)) (f32.const -0x1.fffffcp-127))
-(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-126)) (f32.const -0x1p-126))
-(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "no_fold_promote_demote" (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "no_fold_promote_demote" (f32.const -infinity)) (f32.const -infinity))
-
-;; Test that demote(x+promote(y)) is not folded to demote(x)+y.
-
-(module
-  (func (export "no_demote_mixed_add") (param $x f64) (param $y f32) (result f32)
-    (f32.demote_f64 (f64.add (local.get $x) (f64.promote_f32 (local.get $y)))))
-  (func (export "no_demote_mixed_add_commuted") (param $y f32) (param $x f64) (result f32)
-    (f32.demote_f64 (f64.add (f64.promote_f32 (local.get $y)) (local.get $x))))
-)
-
-(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.f51a9d04854f9p-95) (f32.const 0x1.3f4e9cp-119)) (f32.const 0x1.f51a9ep-95))
-(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.065b3d81ad8dp+37) (f32.const 0x1.758cd8p+38)) (f32.const 0x1.f8ba76p+38))
-(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.626c80963bd17p-119) (f32.const -0x1.9bbf86p-121)) (f32.const 0x1.f6f93ep-120))
-(assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.0d5110e3385bbp-20) (f32.const 0x1.096f4ap-29)) (f32.const -0x1.0ccc5ap-20))
-(assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.73852db4e5075p-20) (f32.const -0x1.24e474p-41)) (f32.const -0x1.738536p-20))
-
-(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.3f4e9cp-119) (f64.const 0x1.f51a9d04854f9p-95)) (f32.const 0x1.f51a9ep-95))
-(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.758cd8p+38) (f64.const 0x1.065b3d81ad8dp+37)) (f32.const 0x1.f8ba76p+38))
-(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.9bbf86p-121) (f64.const 0x1.626c80963bd17p-119)) (f32.const 0x1.f6f93ep-120))
-(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.096f4ap-29) (f64.const -0x1.0d5110e3385bbp-20)) (f32.const -0x1.0ccc5ap-20))
-(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.24e474p-41) (f64.const -0x1.73852db4e5075p-20)) (f32.const -0x1.738536p-20))
-
-;; Test that demote(x-promote(y)) is not folded to demote(x)-y.
-
-(module
-  (func (export "no_demote_mixed_sub") (param $x f64) (param $y f32) (result f32)
-    (f32.demote_f64 (f64.sub (local.get $x) (f64.promote_f32 (local.get $y)))))
-)
-
-(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a0a183220e9b1p+82) (f32.const 0x1.c5acf8p+61)) (f32.const 0x1.a0a174p+82))
-(assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.6e2c5ac39f63ep+30) (f32.const 0x1.d48ca4p+17)) (f32.const -0x1.6e3bp+30))
-(assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.98c74350dde6ap+6) (f32.const 0x1.9d69bcp-12)) (f32.const -0x1.98c7aap+6))
-(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.0459f34091dbfp-54) (f32.const 0x1.61ad08p-71)) (f32.const 0x1.045942p-54))
-(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a7498dca3fdb7p+14) (f32.const 0x1.ed21c8p+15)) (f32.const -0x1.197d02p+15))
-
-;; Test that converting between integer and float and back isn't folded away.
-
-(module
-  (func (export "f32.i32.no_fold_trunc_s_convert_s") (param $x f32) (result f32)
-    (f32.convert_i32_s (i32.trunc_f32_s (local.get $x))))
-  (func (export "f32.i32.no_fold_trunc_u_convert_s") (param $x f32) (result f32)
-    (f32.convert_i32_s (i32.trunc_f32_u (local.get $x))))
-  (func (export "f32.i32.no_fold_trunc_s_convert_u") (param $x f32) (result f32)
-    (f32.convert_i32_u (i32.trunc_f32_s (local.get $x))))
-  (func (export "f32.i32.no_fold_trunc_u_convert_u") (param $x f32) (result f32)
-    (f32.convert_i32_u (i32.trunc_f32_u (local.get $x))))
-  (func (export "f64.i32.no_fold_trunc_s_convert_s") (param $x f64) (result f64)
-    (f64.convert_i32_s (i32.trunc_f64_s (local.get $x))))
-  (func (export "f64.i32.no_fold_trunc_u_convert_s") (param $x f64) (result f64)
-    (f64.convert_i32_s (i32.trunc_f64_u (local.get $x))))
-  (func (export "f64.i32.no_fold_trunc_s_convert_u") (param $x f64) (result f64)
-    (f64.convert_i32_u (i32.trunc_f64_s (local.get $x))))
-  (func (export "f64.i32.no_fold_trunc_u_convert_u") (param $x f64) (result f64)
-    (f64.convert_i32_u (i32.trunc_f64_u (local.get $x))))
-  (func (export "f32.i64.no_fold_trunc_s_convert_s") (param $x f32) (result f32)
-    (f32.convert_i64_s (i64.trunc_f32_s (local.get $x))))
-  (func (export "f32.i64.no_fold_trunc_u_convert_s") (param $x f32) (result f32)
-    (f32.convert_i64_s (i64.trunc_f32_u (local.get $x))))
-  (func (export "f32.i64.no_fold_trunc_s_convert_u") (param $x f32) (result f32)
-    (f32.convert_i64_u (i64.trunc_f32_s (local.get $x))))
-  (func (export "f32.i64.no_fold_trunc_u_convert_u") (param $x f32) (result f32)
-    (f32.convert_i64_u (i64.trunc_f32_u (local.get $x))))
-  (func (export "f64.i64.no_fold_trunc_s_convert_s") (param $x f64) (result f64)
-    (f64.convert_i64_s (i64.trunc_f64_s (local.get $x))))
-  (func (export "f64.i64.no_fold_trunc_u_convert_s") (param $x f64) (result f64)
-    (f64.convert_i64_s (i64.trunc_f64_u (local.get $x))))
-  (func (export "f64.i64.no_fold_trunc_s_convert_u") (param $x f64) (result f64)
-    (f64.convert_i64_u (i64.trunc_f64_s (local.get $x))))
-  (func (export "f64.i64.no_fold_trunc_u_convert_u") (param $x f64) (result f64)
-    (f64.convert_i64_u (i64.trunc_f64_u (local.get $x))))
-)
-
-(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0))
-(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0))
-(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0))
-(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0))
-(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0))
-(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+32))
-(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0))
-(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0))
-
-(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0))
-(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0))
-(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0))
-(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0))
-(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0))
-(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1.fffffffep+31))
-(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0))
-(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0))
-
-(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0))
-(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0))
-(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0))
-(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0))
-(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0))
-(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+64))
-(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0))
-(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0))
-
-(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0))
-(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0))
-(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0))
-(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0))
-(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0))
-(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1p+64))
-(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0))
-(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0))
-
-;; Test that dividing by a loop-invariant constant isn't optimized to be a
-;; multiplication by a reciprocal, which would be particularly tempting since
-;; the reciprocal computation could be hoisted.
-
-(module
-  (memory 1 1)
-  (func (export "init") (param $i i32) (param $x f32) (f32.store (local.get $i) (local.get $x)))
-
-  (func (export "run") (param $n i32) (param $z f32)
-    (local $i i32)
-    (block $exit
-      (loop $cont
-        (f32.store
-          (local.get $i)
-          (f32.div (f32.load (local.get $i)) (local.get $z))
-        )
-        (local.set $i (i32.add (local.get $i) (i32.const 4)))
-        (br_if $cont (i32.lt_u (local.get $i) (local.get $n)))
-      )
-    )
-  )
-
-  (func (export "check") (param $i i32) (result f32) (f32.load (local.get $i)))
-)
-
-(invoke "init" (i32.const  0) (f32.const 15.1))
-(invoke "init" (i32.const  4) (f32.const 15.2))
-(invoke "init" (i32.const  8) (f32.const 15.3))
-(invoke "init" (i32.const 12) (f32.const 15.4))
-(assert_return (invoke "check" (i32.const  0)) (f32.const 15.1))
-(assert_return (invoke "check" (i32.const  4)) (f32.const 15.2))
-(assert_return (invoke "check" (i32.const  8)) (f32.const 15.3))
-(assert_return (invoke "check" (i32.const 12)) (f32.const 15.4))
-(invoke "run" (i32.const 16) (f32.const 3.0))
-(assert_return (invoke "check" (i32.const  0)) (f32.const 0x1.422222p+2))
-(assert_return (invoke "check" (i32.const  4)) (f32.const 0x1.444444p+2))
-(assert_return (invoke "check" (i32.const  8)) (f32.const 0x1.466666p+2))
-(assert_return (invoke "check" (i32.const 12)) (f32.const 0x1.488888p+2))
-
-(module
-  (memory 1 1)
-  (func (export "init") (param $i i32) (param $x f64) (f64.store (local.get $i) (local.get $x)))
-
-  (func (export "run") (param $n i32) (param $z f64)
-    (local $i i32)
-    (block $exit
-      (loop $cont
-        (f64.store
-          (local.get $i)
-          (f64.div (f64.load (local.get $i)) (local.get $z))
-        )
-        (local.set $i (i32.add (local.get $i) (i32.const 8)))
-        (br_if $cont (i32.lt_u (local.get $i) (local.get $n)))
-      )
-    )
-  )
-
-  (func (export "check") (param $i i32) (result f64) (f64.load (local.get $i)))
-)
-
-(invoke "init" (i32.const  0) (f64.const 15.1))
-(invoke "init" (i32.const  8) (f64.const 15.2))
-(invoke "init" (i32.const 16) (f64.const 15.3))
-(invoke "init" (i32.const 24) (f64.const 15.4))
-(assert_return (invoke "check" (i32.const  0)) (f64.const 15.1))
-(assert_return (invoke "check" (i32.const  8)) (f64.const 15.2))
-(assert_return (invoke "check" (i32.const 16)) (f64.const 15.3))
-(assert_return (invoke "check" (i32.const 24)) (f64.const 15.4))
-(invoke "run" (i32.const 32) (f64.const 3.0))
-(assert_return (invoke "check" (i32.const  0)) (f64.const 0x1.4222222222222p+2))
-(assert_return (invoke "check" (i32.const  8)) (f64.const 0x1.4444444444444p+2))
-(assert_return (invoke "check" (i32.const 16)) (f64.const 0x1.4666666666667p+2))
-(assert_return (invoke "check" (i32.const 24)) (f64.const 0x1.4888888888889p+2))
-
-;; Test that ult/ugt/etc. aren't folded to olt/ogt/etc.
-
-(module
-  (func (export "f32.ult") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.ge (local.get $x) (local.get $y))))
-  (func (export "f32.ule") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.gt (local.get $x) (local.get $y))))
-  (func (export "f32.ugt") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.le (local.get $x) (local.get $y))))
-  (func (export "f32.uge") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.lt (local.get $x) (local.get $y))))
-
-  (func (export "f64.ult") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.ge (local.get $x) (local.get $y))))
-  (func (export "f64.ule") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.gt (local.get $x) (local.get $y))))
-  (func (export "f64.ugt") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.le (local.get $x) (local.get $y))))
-  (func (export "f64.uge") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.lt (local.get $x) (local.get $y))))
-)
-
-(assert_return (invoke "f32.ult" (f32.const 3.0) (f32.const 2.0)) (i32.const 0))
-(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 2.0)) (i32.const 0))
-(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 3.0)) (i32.const 1))
-(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const nan)) (i32.const 1))
-(assert_return (invoke "f32.ule" (f32.const 3.0) (f32.const 2.0)) (i32.const 0))
-(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 2.0)) (i32.const 1))
-(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 3.0)) (i32.const 1))
-(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const nan)) (i32.const 1))
-(assert_return (invoke "f32.ugt" (f32.const 3.0) (f32.const 2.0)) (i32.const 1))
-(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 2.0)) (i32.const 0))
-(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 3.0)) (i32.const 0))
-(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const nan)) (i32.const 1))
-(assert_return (invoke "f32.uge" (f32.const 3.0) (f32.const 2.0)) (i32.const 1))
-(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 2.0)) (i32.const 1))
-(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 3.0)) (i32.const 0))
-(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const nan)) (i32.const 1))
-(assert_return (invoke "f64.ult" (f64.const 3.0) (f64.const 2.0)) (i32.const 0))
-(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 2.0)) (i32.const 0))
-(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 3.0)) (i32.const 1))
-(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const nan)) (i32.const 1))
-(assert_return (invoke "f64.ule" (f64.const 3.0) (f64.const 2.0)) (i32.const 0))
-(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 2.0)) (i32.const 1))
-(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 3.0)) (i32.const 1))
-(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const nan)) (i32.const 1))
-(assert_return (invoke "f64.ugt" (f64.const 3.0) (f64.const 2.0)) (i32.const 1))
-(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 2.0)) (i32.const 0))
-(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 3.0)) (i32.const 0))
-(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const nan)) (i32.const 1))
-(assert_return (invoke "f64.uge" (f64.const 3.0) (f64.const 2.0)) (i32.const 1))
-(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 2.0)) (i32.const 1))
-(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 3.0)) (i32.const 0))
-(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const nan)) (i32.const 1))
-
-;; Test that x<y?x:y, etc. using select aren't folded to min, etc.
-
-(module
-  (func (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))))
-  (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))))
-  (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))))
-  (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))))
-
-  (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))))
-  (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))))
-  (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))))
-  (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))))
-)
-
-(assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_lt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_lt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_le_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_le_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_gt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_gt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_ge_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_lt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_le_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_le_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_gt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_gt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_ge_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
-
-;; Test that x<y?x:y, etc. using if and else aren't folded to min, etc.
-
-(module
-  (func (export "f32.no_fold_lt_if") (param $x f32) (param $y f32) (result f32) (if f32 (f32.lt (local.get $x) (local.get $y)) (then (local.get $x) )(else (local.get $y))))
-  (func (export "f32.no_fold_le_if") (param $x f32) (param $y f32) (result f32) (if f32 (f32.le (local.get $x) (local.get $y)) (then (local.get $x) )(else (local.get $y))))
-  (func (export "f32.no_fold_gt_if") (param $x f32) (param $y f32) (result f32) (if f32 (f32.gt (local.get $x) (local.get $y)) (then (local.get $x) )(else (local.get $y))))
-  (func (export "f32.no_fold_ge_if") (param $x f32) (param $y f32) (result f32) (if f32 (f32.ge (local.get $x) (local.get $y)) (then (local.get $x) )(else (local.get $y))))
-
-  (func (export "f64.no_fold_lt_if") (param $x f64) (param $y f64) (result f64) (if f64 (f64.lt (local.get $x) (local.get $y)) (then (local.get $x) )(else (local.get $y))))
-  (func (export "f64.no_fold_le_if") (param $x f64) (param $y f64) (result f64) (if f64 (f64.le (local.get $x) (local.get $y)) (then (local.get $x) )(else (local.get $y))))
-  (func (export "f64.no_fold_gt_if") (param $x f64) (param $y f64) (result f64) (if f64 (f64.gt (local.get $x) (local.get $y)) (then (local.get $x) )(else (local.get $y))))
-  (func (export "f64.no_fold_ge_if") (param $x f64) (param $y f64) (result f64) (if f64 (f64.ge (local.get $x) (local.get $y)) (then (local.get $x) )(else (local.get $y))))
-)
-
-(assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_lt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_lt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_le_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_le_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_gt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_gt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_ge_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_lt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_le_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_le_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_gt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_gt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_ge_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
-
-;; Test that x<0?-x:0, etc. using select aren't folded to abs
-
-(module
-  (func (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))))
-  (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))))
-  (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))))
-  (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))))
-
-  (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))))
-  (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))))
-  (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))))
-  (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))))
-)
-
-(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
-(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
-(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const 0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const 0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -0.0)) (f64.const -0.0))
-
-;; Test that x<0?-x:0, etc. using if aren't folded to abs
-
-(module
-  (func (export "f32.no_fold_lt_if_to_abs") (param $x f32) (result f32) (if f32 (f32.lt (local.get $x) (f32.const 0.0)) (then (f32.neg (local.get $x)) )(else (local.get $x))))
-  (func (export "f32.no_fold_le_if_to_abs") (param $x f32) (result f32) (if f32 (f32.le (local.get $x) (f32.const -0.0)) (then (f32.neg (local.get $x)) )(else (local.get $x))))
-  (func (export "f32.no_fold_gt_if_to_abs") (param $x f32) (result f32) (if f32 (f32.gt (local.get $x) (f32.const -0.0)) (then (local.get $x) )(else (f32.neg (local.get $x)))))
-  (func (export "f32.no_fold_ge_if_to_abs") (param $x f32) (result f32) (if f32 (f32.ge (local.get $x) (f32.const 0.0)) (then (local.get $x) )(else (f32.neg (local.get $x)))))
-
-  (func (export "f64.no_fold_lt_if_to_abs") (param $x f64) (result f64) (if f64 (f64.lt (local.get $x) (f64.const 0.0)) (then (f64.neg (local.get $x)) )(else (local.get $x))))
-  (func (export "f64.no_fold_le_if_to_abs") (param $x f64) (result f64) (if f64 (f64.le (local.get $x) (f64.const -0.0)) (then (f64.neg (local.get $x)) )(else (local.get $x))))
-  (func (export "f64.no_fold_gt_if_to_abs") (param $x f64) (result f64) (if f64 (f64.gt (local.get $x) (f64.const -0.0)) (then (local.get $x) )(else (f64.neg (local.get $x)))))
-  (func (export "f64.no_fold_ge_if_to_abs") (param $x f64) (result f64) (if f64 (f64.ge (local.get $x) (f64.const 0.0)) (then (local.get $x) )(else (f64.neg (local.get $x)))))
-)
-
-(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -nan)) (f32.const -nan))
-(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
-(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const 0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
-(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -nan)) (f64.const -nan))
-(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const 0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const 0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
-(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -0.0)) (f64.const -0.0))
-
-;; Test for a historic spreadsheet bug.
-;; https://support.microsoft.com/en-us/kb/78113
-
-(module
-  (func (export "incorrect_correction") (result f32)
-    (f32.sub (f32.sub (f32.add (f32.const 1.333) (f32.const 1.225)) (f32.const 1.333)) (f32.const 1.225))
-  )
-)
-
-(assert_return (invoke "incorrect_correction") (f32.const 0x1p-23))
-
-(module
-  (func (export "incorrect_correction") (result f64)
-    (f64.sub (f64.sub (f64.add (f64.const 1.333) (f64.const 1.225)) (f64.const 1.333)) (f64.const 1.225))
-  )
-)
-
-(assert_return (invoke "incorrect_correction") (f64.const -0x1p-52))
-
-;; Test for a historical calculator bug.
-;; http://www.hpmuseum.org/cgi-sys/cgiwrap/hpmuseum/articles.cgi?read=735
-
-(module
-  (func (export "calculate") (result f32)
-    (local $x f32)
-    (local $r f32)
-    (local $q f32)
-    (local $z0 f32)
-    (local $z1 f32)
-    (local.set $x (f32.const 156.25))
-    (local.set $r (f32.const 208.333333334))
-    (local.set $q (f32.const 1.77951304201))
-    (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))))
-    (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))))
-    (block (br_if 0 (f32.eq (local.get $z0) (local.get $z1))) (unreachable))
-    (local.get $z1)
-  )
-)
-
-(assert_return (invoke "calculate") (f32.const -0x1.d2ed46p+8))
-
-(module
-  (func (export "calculate") (result f64)
-    (local $x f64)
-    (local $r f64)
-    (local $q f64)
-    (local $z0 f64)
-    (local $z1 f64)
-    (local.set $x (f64.const 156.25))
-    (local.set $r (f64.const 208.333333334))
-    (local.set $q (f64.const 1.77951304201))
-    (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))))
-    (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))))
-    (block (br_if 0 (f64.eq (local.get $z0) (local.get $z1))) (unreachable))
-    (local.get $z1)
-  )
-)
-
-(assert_return (invoke "calculate") (f64.const -0x1.d2ed4d0218c93p+8))
-
-;; Test that 0 - (-0 - x) is not optimized to x.
-;; https://llvm.org/bugs/show_bug.cgi?id=26746
-
-(module
-  (func (export "llvm_pr26746") (param $x f32) (result f32)
-    (f32.sub (f32.const 0.0) (f32.sub (f32.const -0.0) (local.get $x)))
-  )
-)
-
-(assert_return (invoke "llvm_pr26746" (f32.const -0.0)) (f32.const 0.0))
-
-;; Test for improperly reassociating an addition and a conversion.
-;; https://llvm.org/bugs/show_bug.cgi?id=27153
-
-(module
-  (func (export "llvm_pr27153") (param $x i32) (result f32)
-    (f32.add (f32.convert_i32_s (i32.and (local.get $x) (i32.const 268435455))) (f32.const -8388608.0))
-  )
-)
-
-(assert_return (invoke "llvm_pr27153" (i32.const 33554434)) (f32.const 25165824.000000))
-
-;; Test that (float)x + (float)y is not optimized to (float)(x + y) when unsafe.
-;; https://llvm.org/bugs/show_bug.cgi?id=27036
-
-(module
-  (func (export "llvm_pr27036") (param $x i32) (param $y i32) (result f32)
-    (f32.add (f32.convert_i32_s (i32.or (local.get $x) (i32.const -25034805)))
-             (f32.convert_i32_s (i32.and (local.get $y) (i32.const 14942208))))
-  )
-)
-
-(assert_return (invoke "llvm_pr27036" (i32.const -25034805) (i32.const 14942208)) (f32.const -0x1.340068p+23))
-
-;; Test for bugs in old versions of historic IEEE 754 platforms as reported in:
-;;
-;; N. L. Schryer. 1981. A Test of a Computer's Floating-Point Arithmetic Unit.
-;; Tech. Rep. Computer Science Technical Report 89, AT&T Bell Laboratories, Feb.
-;;
-;; specifically, the appendices describing IEEE systems with "The Past" sections
-;; describing specific bugs. The 0 < 0 bug is omitted here due to being already
-;; covered elsewhere.
-(module
-  (func (export "thepast0") (param $a f64) (param $b f64) (param $c f64) (param $d f64) (result f64)
-    (f64.div (f64.mul (local.get $a) (local.get $b)) (f64.mul (local.get $c) (local.get $d)))
-  )
-
-  (func (export "thepast1") (param $a f64) (param $b f64) (param $c f64) (result f64)
-    (f64.sub (f64.mul (local.get $a) (local.get $b)) (local.get $c))
-  )
-
-  (func (export "thepast2") (param $a f32) (param $b f32) (param $c f32) (result f32)
-    (f32.mul (f32.mul (local.get $a) (local.get $b)) (local.get $c))
-  )
-)
-
-(assert_return (invoke "thepast0" (f64.const 0x1p-1021) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p1) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp-1022))
-(assert_return (invoke "thepast1" (f64.const 0x1p-54) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p-54)) (f64.const -0x1p-107))
-(assert_return (invoke "thepast2" (f32.const 0x1p-125) (f32.const 0x1p-1) (f32.const 0x1p0)) (f32.const 0x1p-126))
-
-;; Test for floating point tolerances observed in some GPUs.
-;; https://community.amd.com/thread/145582
-
-(module
-  (func (export "inverse") (param $x f32) (result f32)
-    (f32.div (f32.const 1.0) (local.get $x))
-  )
-)
-
-(assert_return (invoke "inverse" (f32.const 96.0)) (f32.const 0x1.555556p-7))
-
-;; Test for incorrect rounding on sqrt(4.0).
-;; http://www.askvg.com/microsoft-windows-calculator-bug/
-
-(module
-  (func (export "f32_sqrt_minus_2") (param $x f32) (result f32)
-    (f32.sub (f32.sqrt (local.get $x)) (f32.const 2.0))
-  )
-
-  (func (export "f64_sqrt_minus_2") (param $x f64) (result f64)
-    (f64.sub (f64.sqrt (local.get $x)) (f64.const 2.0))
-  )
-)
-
-(assert_return (invoke "f32_sqrt_minus_2" (f32.const 4.0)) (f32.const 0.0))
-(assert_return (invoke "f64_sqrt_minus_2" (f64.const 4.0)) (f64.const 0.0))
-
-;; Test that 1.0 / (1.0 / x) is not optimized to x.
-
-(module
-  (func (export "f32.no_fold_recip_recip") (param $x f32) (result f32)
-    (f32.div (f32.const 1.0) (f32.div (f32.const 1.0) (local.get $x))))
-
-  (func (export "f64.no_fold_recip_recip") (param $x f64) (result f64)
-    (f64.div (f64.const 1.0) (f64.div (f64.const 1.0) (local.get $x))))
-)
-
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x1.e8bf18p+65)) (f32.const -0x1.e8bf16p+65))
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.e24248p-77)) (f32.const 0x1.e24246p-77))
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.caf0e8p-64)) (f32.const 0x1.caf0eap-64))
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x1.e66982p+4)) (f32.const -0x1.e66984p+4))
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.f99916p+70)) (f32.const 0x1.f99914p+70))
-
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const infinity)) (f32.const infinity))
-
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.d81248dda63dp+148)) (f64.const -0x1.d81248dda63d1p+148))
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.f4750312039e3p+66)) (f64.const -0x1.f4750312039e2p+66))
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.fa50630eec7f6p+166)) (f64.const 0x1.fa50630eec7f5p+166))
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.db0598617ba92p-686)) (f64.const 0x1.db0598617ba91p-686))
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.85f1638a0c82bp+902)) (f64.const 0x1.85f1638a0c82ap+902))
-
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const infinity)) (f64.const infinity))
-
-;; Test that (x+y) * (x-y) is not optimized to x*x - y*y.
-
-(module
-  (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32)
-    (f32.mul (f32.add (local.get $x) (local.get $y))
-             (f32.sub (local.get $x) (local.get $y))))
-
-  (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64)
-    (f64.mul (f64.add (local.get $x) (local.get $y))
-             (f64.sub (local.get $x) (local.get $y))))
-)
-
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.ef678ep-55) (f32.const 0x1.c160b8p-54)) (f32.const -0x1.129402p-107))
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.2d76bcp+24) (f32.const 0x1.f4089cp+24)) (f32.const -0x1.36d89ap+49))
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7ca2b2p+45) (f32.const -0x1.08513cp+47)) (f32.const -0x1.db10dep+93))
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7d5e3p+17) (f32.const -0x1.c783b4p+7)) (f32.const 0x1.1c10a6p+35))
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.daf96p+7) (f32.const -0x1.dac6bp+19)) (f32.const -0x1.b8422ep+39))
-
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.e17c0a02ac6b5p-476) (f64.const 0x1.e8f13f1fcdc14p-463)) (f64.const -0x1.d2ec518f62863p-925))
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.971b55a57e3a3p-377) (f64.const 0x1.edeb4233c1b27p-399)) (f64.const 0x1.43b3f69fb258bp-753))
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.c3b9dc02472fap-378) (f64.const -0x1.74e9faebaff14p-369)) (f64.const -0x1.0f9c07e8caa25p-737))
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.afaf4688ed019p+179) (f64.const 0x1.b07171cb49e94p+188)) (f64.const -0x1.6d3f2e2bebcf7p+377))
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.4377a98948f12p+114) (f64.const -0x1.500c05bd24c97p+90)) (f64.const 0x1.98b72dbf7bf72p+228))
-
-;; Test that x*x - y*y is not optimized to (x+y) * (x-y).
-
-(module
-  (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32)
-    (f32.sub (f32.mul (local.get $x) (local.get $x))
-             (f32.mul (local.get $y) (local.get $y))))
-
-  (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64)
-    (f64.sub (f64.mul (local.get $x) (local.get $x))
-             (f64.mul (local.get $y) (local.get $y))))
-)
-
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.8e2c14p-46) (f32.const 0x1.bad59ap-39)) (f32.const -0x1.7efe5p-77))
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.7ef192p+41) (f32.const -0x1.db184ap+33)) (f32.const 0x1.1e6932p+83))
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7eb458p-12) (f32.const -0x1.52c498p-13)) (f32.const 0x1.cc0bc6p-24))
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.2675c6p-44) (f32.const -0x1.edd31ap-46)) (f32.const 0x1.17294cp-88))
-(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.9a5f92p+51) (f32.const -0x1.2b0098p+52)) (f32.const -0x1.7189a6p+103))
-
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.749a128f18f69p+356) (f64.const -0x1.0bc97ee1354e1p+337)) (f64.const 0x1.0f28115518d74p+713))
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.2dab01b2215eap+309) (f64.const -0x1.e12b288bff2bdp+331)) (f64.const -0x1.c4319ad25d201p+663))
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.3ed898431e102p+42) (f64.const -0x1.c409183fa92e6p+39)) (f64.const 0x1.80a611103c71dp+84))
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.be663e4c0e4b2p+182) (f64.const -0x1.da85703760d25p+166)) (f64.const 0x1.853434f1a2ffep+365))
-(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.230e09952df1cp-236) (f64.const -0x1.fa2752adfadc9p-237)) (f64.const 0x1.42e43156bd1b8p-474))
-
-;; Test that plain summation is not reassociated, and that Kahan summation
-;; isn't optimized into plain summation.
-
-(module
-  (memory (data
-    "\c4\c5\57\24\a5\84\c8\0b\6d\b8\4b\2e\f2\76\17\1c\ca\4a\56\1e\1b\6e\71\22"
-    "\5d\17\1e\6e\bf\cd\14\5c\c7\21\55\51\39\9c\1f\b2\51\f0\a3\93\d7\c1\2c\ae"
-    "\7e\a8\28\3a\01\21\f4\0a\58\93\f8\42\77\9f\83\39\6a\5f\ba\f7\0a\d8\51\6a"
-    "\34\ca\ad\c6\34\0e\d8\26\dc\4c\33\1c\ed\29\90\a8\78\0f\d1\ce\76\31\23\83"
-    "\b8\35\e8\f2\44\b0\d3\a1\fc\bb\32\e1\b0\ba\69\44\09\d6\d9\7d\ff\2e\c0\5a"
-    "\36\14\33\14\3e\a9\fa\87\6d\8b\bc\ce\9d\a7\fd\c4\e9\85\3f\dd\d7\e1\18\a6"
-    "\50\26\72\6e\3f\73\0f\f8\12\93\23\34\61\76\12\48\c0\9b\05\93\eb\ac\86\de"
-    "\94\3e\55\e8\8c\e8\dd\e4\fc\95\47\be\56\03\21\20\4c\e6\bf\7b\f6\7f\d5\ba"
-    "\73\1c\c1\14\8f\c4\27\96\b3\bd\33\ff\78\41\5f\c0\5a\ce\f6\67\6e\73\9a\17"
-    "\66\70\03\f8\ce\27\a3\52\b2\9f\3b\bf\fb\ae\ed\d3\5a\f8\37\57\f0\f5\6e\ef"
-    "\b1\4d\70\3d\54\a7\01\9a\85\08\48\91\f5\9d\0c\60\87\5b\d9\54\1e\51\6d\88"
-    "\8e\08\8c\a5\71\3a\56\08\67\46\8f\8f\13\2a\2c\ec\2c\1f\b4\62\2b\6f\41\0a"
-    "\c4\65\42\a2\31\6b\2c\7d\3e\bb\75\ac\86\97\30\d9\48\cd\9a\1f\56\c4\c6\e4"
-    "\12\c0\9d\fb\ee\02\8c\ce\1c\f2\1e\a1\78\23\db\c4\1e\49\03\d3\71\cc\08\50"
-    "\c5\d8\5c\ed\d5\b5\65\ac\b5\c9\21\d2\c9\29\76\de\f0\30\1a\5b\3c\f2\3b\db"
-    "\3a\39\82\3a\16\08\6f\a8\f1\be\69\69\99\71\a6\05\d3\14\93\2a\16\f2\2f\11"
-    "\c7\7e\20\bb\91\44\ee\f8\e4\01\53\c0\b9\7f\f0\bf\f0\03\9c\6d\b1\df\a2\44"
-    "\01\6d\6b\71\2b\5c\b3\21\19\46\5e\8f\db\91\d3\7c\78\6b\b7\12\00\8f\eb\bd"
-    "\8a\f5\d4\2e\c4\c1\1e\df\73\63\59\47\49\03\0a\b7\cf\24\cf\9c\0e\44\7a\9e"
-    "\14\fb\42\bf\9d\39\30\9e\a0\ab\2f\d1\ae\9e\6a\83\43\e3\55\7d\85\bf\63\8a"
-    "\f8\96\10\1f\fe\6d\e7\22\1b\e1\69\46\8a\44\c8\c8\f9\0c\2b\19\07\a5\02\3e"
-    "\f2\30\10\9a\85\8a\5f\ef\81\45\a0\77\b1\03\10\73\4b\ae\98\9d\47\bf\9a\2d"
-    "\3a\d5\0f\03\66\e3\3d\53\d9\40\ce\1f\6f\32\2f\21\2b\23\21\6c\62\d4\a7\3e"
-    "\a8\ce\28\31\2d\00\3d\67\5e\af\a0\cf\2e\d2\b9\6b\84\eb\69\08\3c\62\36\be"
-    "\12\fd\36\7f\88\3e\ad\bc\0b\c0\41\c4\50\b6\e3\50\31\e8\ce\e2\96\65\55\9c"
-    "\16\46\e6\b0\2d\3a\e8\81\05\b0\bf\34\f7\bc\10\1c\fb\cc\3c\f1\85\97\42\9f"
-    "\eb\14\8d\3c\bf\d7\17\88\49\9d\8b\2b\b2\3a\83\d1\4f\04\9e\a1\0f\ad\08\9d"
-    "\54\af\d1\82\c3\ec\32\2f\02\8f\05\21\2d\a2\b7\e4\f4\6f\2e\81\2b\0b\9c\fc"
-    "\cb\fe\74\02\f9\db\f4\f3\ea\00\a8\ec\d1\99\74\26\dd\d6\34\d5\25\b1\46\dd"
-    "\9c\aa\71\f5\60\b0\88\c8\e0\0b\59\5a\25\4f\29\66\f9\e3\2e\fe\e9\da\e5\18"
-    "\4f\27\62\f4\ce\a4\21\95\74\c7\57\64\27\9a\4c\fd\54\7d\61\ce\c3\ac\87\46"
-    "\9c\fa\ff\09\ca\79\97\67\24\74\ca\d4\21\83\26\25\19\12\37\64\19\e5\65\e0"
-    "\74\75\8e\dd\c8\ef\74\c7\d8\21\2b\79\04\51\46\65\60\03\5d\fa\d8\f4\65\a4"
-    "\9e\5d\23\da\d7\8a\92\80\a4\de\78\3c\f1\57\42\6d\cd\c9\2f\d5\a4\9e\ab\40"
-    "\f4\cb\1b\d7\a3\ca\fc\eb\a7\01\b2\9a\69\4e\46\9b\18\4e\dd\79\a7\aa\a6\52"
-    "\39\1e\ef\30\cc\9b\bd\5b\ee\4c\21\6d\30\00\72\b0\46\5f\08\cf\c5\b9\e0\3e"
-    "\c2\b3\0c\dc\8e\64\de\19\42\79\cf\43\ea\43\5d\8e\88\f7\ab\15\dc\3f\c8\67"
-    "\20\db\b8\64\b1\47\1f\de\f2\cb\3f\59\9f\d8\46\90\dc\ae\2f\22\f9\e2\31\89"
-    "\d9\9c\1c\4c\d3\a9\4a\57\84\9c\9f\ea\2c\3c\ae\3c\c3\1e\8b\e5\4e\17\01\25"
-    "\db\34\46\5f\15\ea\05\0c\7c\d9\45\8c\19\d0\73\8a\96\16\dd\44\f9\05\b7\5b"
-    "\71\b0\e6\21\36\5f\75\89\91\73\75\ab\7d\ae\d3\73\ec\37\c6\ea\55\75\ef\ea"
-    "\ab\8b\7b\11\dc\6d\1a\b2\6a\c4\25\cf\aa\e3\9f\49\49\89\cb\37\9b\0a\a7\01"
-    "\60\70\dc\b7\c8\83\e1\42\f5\be\ad\62\94\ad\8d\a1"
-  ))
-
-  (func (export "f32.kahan_sum") (param $p i32) (param $n i32) (result f32)
-    (local $sum f32)
-    (local $c f32)
-    (local $t f32)
-    (block $exit
-      (loop $top
-        (local.set $t
-          (f32.sub
-            (f32.sub
-              (local.tee $sum
-                (f32.add
-                  (local.get $c)
-                  (local.tee $t
-                    (f32.sub (f32.load (local.get $p)) (local.get $t))
-                  )
-                )
-              )
-              (local.get $c)
-            )
-            (local.get $t)
-          )
-        )
-        (local.set $p (i32.add (local.get $p) (i32.const 4)))
-        (local.set $c (local.get $sum))
-        (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1))))
-      )
-    )
-    (local.get $sum)
-  )
-
-  (func (export "f32.plain_sum") (param $p i32) (param $n i32) (result f32)
-    (local $sum f32)
-    (block $exit
-      (loop $top
-        (local.set $sum (f32.add (local.get $sum) (f32.load (local.get $p))))
-        (local.set $p (i32.add (local.get $p) (i32.const 4)))
-        (local.set $n (i32.add (local.get $n) (i32.const -1)))
-        (br_if $top (local.get $n))
-      )
-    )
-    (local.get $sum)
-  )
-)
-
-(assert_return (invoke "f32.kahan_sum" (i32.const 0) (i32.const 256)) (f32.const -0x1.101a1ap+104))
-(assert_return (invoke "f32.plain_sum" (i32.const 0) (i32.const 256)) (f32.const -0x1.a0343ap+103))
-
-(module
-  (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"
-  ))
-
-  (func (export "f64.kahan_sum") (param $p i32) (param $n i32) (result f64)
-    (local $sum f64)
-    (local $c f64)
-    (local $t f64)
-    (block $exit
-      (loop $top
-        (local.set $t
-          (f64.sub
-            (f64.sub
-              (local.tee $sum
-                (f64.add
-                  (local.get $c)
-                  (local.tee $t
-                    (f64.sub (f64.load (local.get $p)) (local.get $t))
-                  )
-                )
-              )
-              (local.get $c)
-            )
-            (local.get $t)
-          )
-        )
-        (local.set $p (i32.add (local.get $p) (i32.const 8)))
-        (local.set $c (local.get $sum))
-        (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1))))
-      )
-    )
-    (local.get $sum)
-  )
-
-  (func (export "f64.plain_sum") (param $p i32) (param $n i32) (result f64)
-    (local $sum f64)
-    (block $exit
-      (loop $top
-        (local.set $sum (f64.add (local.get $sum) (f64.load (local.get $p))))
-        (local.set $p (i32.add (local.get $p) (i32.const 8)))
-        (local.set $n (i32.add (local.get $n) (i32.const -1)))
-        (br_if $top (local.get $n))
-      )
-    )
-    (local.get $sum)
-  )
-)
-
-(assert_return (invoke "f64.kahan_sum" (i32.const 0) (i32.const 256)) (f64.const 0x1.dd7cb2a5ffc88p+998))
-(assert_return (invoke "f64.plain_sum" (i32.const 0) (i32.const 256)) (f64.const 0x1.dd7cb2a63fc87p+998))
-
-;; Test that -(x - y) is not folded to y - x.
-
-(module
-  (func (export "f32.no_fold_neg_sub") (param $x f32) (param $y f32) (result f32)
-    (f32.neg (f32.sub (local.get $x) (local.get $y))))
-
-  (func (export "f64.no_fold_neg_sub") (param $x f64) (param $y f64) (result f64)
-    (f64.neg (f64.sub (local.get $x) (local.get $y))))
-)
-
-(assert_return (invoke "f32.no_fold_neg_sub" (f32.const -0.0) (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_neg_sub" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
-(assert_return (invoke "f32.no_fold_neg_sub" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_neg_sub" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0))
-
-(assert_return (invoke "f64.no_fold_neg_sub" (f64.const -0.0) (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_neg_sub" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
-(assert_return (invoke "f64.no_fold_neg_sub" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_neg_sub" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0))
-
-;; Test that -x + x is not folded to 0.0.
-
-(module
-  (func (export "f32.no_fold_add_neg") (param $x f32) (result f32)
-    (f32.add (f32.neg (local.get $x)) (local.get $x)))
-
-  (func (export "f64.no_fold_add_neg") (param $x f64) (result f64)
-    (f64.add (f64.neg (local.get $x)) (local.get $x)))
-)
-
-(assert_return (invoke "f32.no_fold_add_neg" (f32.const 0.0)) (f32.const 0.0))
-(assert_return (invoke "f32.no_fold_add_neg" (f32.const -0.0)) (f32.const 0.0))
-;; (assert_return_nan (invoke "f32.no_fold_add_neg" (f32.const infinity)))
-;; (assert_return_nan (invoke "f32.no_fold_add_neg" (f32.const -infinity)))
-
-(assert_return (invoke "f64.no_fold_add_neg" (f64.const 0.0)) (f64.const 0.0))
-(assert_return (invoke "f64.no_fold_add_neg" (f64.const -0.0)) (f64.const 0.0))
-;; (assert_return_nan (invoke "f64.no_fold_add_neg" (f64.const infinity)))
-;; (assert_return_nan (invoke "f64.no_fold_add_neg" (f64.const -infinity)))
-
-;; Test that x+x+x+x+x+x is not folded to x * 6.
-
-(module
-  (func (export "f32.no_fold_6x_via_add") (param $x f32) (result f32)
-    (f32.add (f32.add (f32.add (f32.add (f32.add
-    (local.get $x)
-    (local.get $x)) (local.get $x)) (local.get $x))
-    (local.get $x)) (local.get $x)))
-
-  (func (export "f64.no_fold_6x_via_add") (param $x f64) (result f64)
-    (f64.add (f64.add (f64.add (f64.add (f64.add
-    (local.get $x)
-    (local.get $x)) (local.get $x)) (local.get $x))
-    (local.get $x)) (local.get $x)))
-)
-
-(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.598a0cp+99)) (f32.const -0x1.03278ap+102))
-(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.d3e7acp-77)) (f32.const -0x1.5eedc2p-74))
-(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const 0x1.00fa02p-77)) (f32.const 0x1.817702p-75))
-(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.51f434p-31)) (f32.const -0x1.faee4cp-29))
-(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.00328ap+80)) (f32.const -0x1.804bcep+82))
-
-(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.310e15acaffe6p+68)) (f64.const -0x1.c995208307fdap+70))
-(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.aad62c78fa9b4p-535)) (f64.const -0x1.4020a15abbf46p-532))
-(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.f8fbfa94f6ab2p+271)) (f64.const -0x1.7abcfbefb9005p+274))
-(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const 0x1.756ccc2830a8ep+751)) (f64.const 0x1.1811991e247ebp+754))
-(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.8fd1ab1d2402ap+234)) (f64.const -0x1.2bdd4055db01fp+237))
-
-;; Test that (x/y)/z is not optimized to x/(y*z),
-;; which is an "allowable alternative Form" in Fortran.
-
-(module
-  (func (export "f32.no_fold_div_div") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.div (f32.div (local.get $x) (local.get $y)) (local.get $z)))
-
-  (func (export "f64.no_fold_div_div") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.div (f64.div (local.get $x) (local.get $y)) (local.get $z)))
-)
-
-(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))
-(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))
-(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 infinity))
-(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))
-(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))
-
-(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))
-(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))
-(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))
-(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 -infinity))
-(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))
-
-;; Test that (x/y)*(z/w) is not optimized to (x*z)/(y*w), example from
-;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
-;; section 7.4.1: FORTRAN Floating Point in a Nutshell: Philosophy
-
-(module
-  (func (export "f32.no_fold_mul_divs") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
-    (f32.mul (f32.div (local.get $x) (local.get $y)) (f32.div (local.get $z) (local.get $w))))
-
-  (func (export "f64.no_fold_mul_divs") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
-    (f64.mul (f64.div (local.get $x) (local.get $y)) (f64.div (local.get $z) (local.get $w))))
-)
-
-(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))
-(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))
-(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))
-(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 -infinity))
-(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))
-
-(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))
-(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 -infinity))
-(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))
-(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))
-(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))
-
-;; Test that (x/z)+(y/z) is not optimized to (x+y)/z.
-
-(module
-  (func (export "f32.no_fold_add_divs") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.add (f32.div (local.get $x) (local.get $z)) (f32.div (local.get $y) (local.get $z))))
-
-  (func (export "f64.no_fold_add_divs") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.add (f64.div (local.get $x) (local.get $z)) (f64.div (local.get $y) (local.get $z))))
-)
-
-(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))
-(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))
-(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))
-(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))
-(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))
-
-(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))
-(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))
-(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))
-(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))
-(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))
-
-;; Test that sqrt(x*x) is not optimized to abs(x).
-
-(module
-  (func (export "f32.no_fold_sqrt_square") (param $x f32) (result f32)
-    (f32.sqrt (f32.mul (local.get $x) (local.get $x))))
-
-  (func (export "f64.no_fold_sqrt_square") (param $x f64) (result f64)
-    (f64.sqrt (f64.mul (local.get $x) (local.get $x))))
-)
-
-(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.5cb316p-66)) (f32.const 0x1.5cb322p-66))
-(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.b0f9e4p-73)) (f32.const 0x1.b211b2p-73))
-(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.de417cp-71)) (f32.const 0x1.de65b8p-71))
-(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.64c872p-86)) (f32.const 0x0p+0))
-(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.e199e4p+108)) (f32.const infinity))
-
-(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.1759d657203fdp-529)) (f64.const 0x1.1759dd57545f3p-529))
-(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.4c68de1c78d83p-514)) (f64.const 0x1.4c68de1c78d81p-514))
-(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.214736edb6e1ep-521)) (f64.const 0x1.214736ed9cf8dp-521))
-(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.0864b9f68457p-616)) (f64.const 0x0p+0))
-(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.b2a9855995abap+856)) (f64.const infinity))
-
-;; Test that sqrt(x)*sqrt(y) is not optimized to sqrt(x*y).
-
-(module
-  (func (export "f32.no_fold_mul_sqrts") (param $x f32) (param $y f32) (result f32)
-    (f32.mul (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y))))
-
-  (func (export "f64.no_fold_mul_sqrts") (param $x f64) (param $y f64) (result f64)
-    (f64.mul (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
-)
-
-;; (assert_return_nan (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.dddda8p-125) (f32.const -0x1.25d22ap-83)))
-(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.418d14p-92) (f32.const 0x1.c6535cp-32)) (f32.const 0x1.7e373ap-62))
-(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.4de7ep-88) (f32.const 0x1.84ff18p+6)) (f32.const 0x1.686668p-41))
-(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.78091ep+101) (f32.const 0x1.81feb8p-9)) (f32.const 0x1.7cfb98p+46))
-(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.583ap-56) (f32.const 0x1.14ba2ap-9)) (f32.const 0x1.b47a8ep-33))
-
-;; (assert_return_nan (invoke "f64.no_fold_mul_sqrts" (f64.const -0x1.d1144cc28cdbep-635) (f64.const -0x1.bf9bc373d3b6ap-8)))
-(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.5a7eb976bebc9p-643) (f64.const 0x1.f30cb8865a4cap-404)) (f64.const 0x1.260a1032d6e76p-523))
-(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.711a0c1707935p-89) (f64.const 0x1.6fb5de51a20d3p-913)) (f64.const 0x1.7067ca28e31ecp-501))
-(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.fb0bbea33b076p-363) (f64.const 0x1.d963b34894158p-573)) (f64.const 0x1.e9edc1fa624afp-468))
-(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.8676eab7a4d0dp+24) (f64.const 0x1.75a58231ba7a5p+513)) (f64.const 0x1.0e16aebe203b3p+269))
-
-;; Test that sqrt(x)/sqrt(y) is not optimized to sqrt(x/y).
-
-(module
-  (func (export "f32.no_fold_div_sqrts") (param $x f32) (param $y f32) (result f32)
-    (f32.div (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y))))
-
-  (func (export "f64.no_fold_div_sqrts") (param $x f64) (param $y f64) (result f64)
-    (f64.div (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
-)
-
-;; (assert_return_nan (invoke "f32.no_fold_div_sqrts" (f32.const -0x1.bea9bap+25) (f32.const -0x1.db776ep-58)))
-(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b983b6p+32) (f32.const 0x1.901f1ep+27)) (f32.const 0x1.7c4df6p+2))
-(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.d45e72p-120) (f32.const 0x1.ab49ccp+15)) (f32.const 0x1.7b0b04p-68))
-(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b2e444p+59) (f32.const 0x1.5b8b16p-30)) (f32.const 0x1.94fca8p+44))
-(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.835aa6p-112) (f32.const 0x1.d17128p-103)) (f32.const 0x1.4a468p-5))
-
-;; (assert_return_nan (invoke "f64.no_fold_div_sqrts" (f64.const -0x1.509fc16411167p-711) (f64.const -0x1.9c4255f5d6517p-187)))
-(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.b6897bddac76p-587) (f64.const 0x1.104578b4c91f3p+541)) (f64.const 0x1.44e4f21f26cc9p-564))
-(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.ac83451b08989p+523) (f64.const 0x1.8da575c6d12b8p-109)) (f64.const 0x1.09c003991ce17p+316))
-(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.bab7836456417p-810) (f64.const 0x1.1ff60d03ba607p+291)) (f64.const 0x1.c0e6c833bf657p-551))
-(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.a957816ad9515p-789) (f64.const 0x1.8c18a3a222ab1p+945)) (f64.const 0x1.0948539781e92p-867))
-
-;; Test that (x*sqrt(y))/y is not optimized to x/sqrt(y).
-
-(module
-  (func (export "f32.no_fold_mul_sqrt_div") (param $x f32) (param $y f32) (result f32)
-    (f32.div (f32.mul (local.get $x) (f32.sqrt (local.get $y))) (local.get $y)))
-
-  (func (export "f64.no_fold_mul_sqrt_div") (param $x f64) (param $y f64) (result f64)
-    (f64.div (f64.mul (local.get $x) (f64.sqrt (local.get $y))) (local.get $y)))
-)
-
-(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.f4a7cap+81) (f32.const 0x1.c09adep+92)) (f32.const -infinity))
-(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.90bf1cp-120) (f32.const 0x1.8dbe88p-97)) (f32.const -0x0p+0))
-(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const 0x1.8570e8p+29) (f32.const 0x1.217d3p-128)) (f32.const 0x1.6e391ap+93))
-(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.5b4652p+43) (f32.const 0x1.a9d71cp+112)) (f32.const -0x1.0d423ap-13))
-(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.910604p+8) (f32.const 0x1.0ca912p+7)) (f32.const -0x1.14cdecp+5))
-
-(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.1dcdeb857305fp+698) (f64.const 0x1.a066171c40eb9p+758)) (f64.const infinity))
-(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.8b4f1c218e2abp-827) (f64.const 0x1.5e1ee65953b0bp-669)) (f64.const -0x0p+0))
-(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.74ee531ddba38p-425) (f64.const 0x1.f370f758857f3p+560)) (f64.const 0x1.0aff34269583ep-705))
-(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.27f216b0da6c5p+352) (f64.const 0x1.8e0b4e0b9fd7ep-483)) (f64.const -0x1.4fa558aad514ep+593))
-(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.4c6955df9912bp+104) (f64.const 0x1.0cca42c9d371ep+842)) (f64.const 0x1.4468072f54294p-317))
-
-;; Test that subnormals are not flushed even in an intermediate value in an
-;; expression with a normal result.
-
-(module
-  (func (export "f32.no_flush_intermediate_subnormal") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
-
-  (func (export "f64.no_flush_intermediate_subnormal") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
-)
-
-(assert_return (invoke "f32.no_flush_intermediate_subnormal" (f32.const 0x1p-126) (f32.const 0x1p-23) (f32.const 0x1p23)) (f32.const 0x1p-126))
-(assert_return (invoke "f64.no_flush_intermediate_subnormal" (f64.const 0x1p-1022) (f64.const 0x1p-52) (f64.const 0x1p52)) (f64.const 0x1p-1022))
-
-;; Test corner cases of John Hauser's microarchitectural recoding scheme.
-;; https://github.com/riscv/riscv-tests/blob/695b86a6fcbe06ffbed8891af7e6fe7bf2062543/isa/rv64uf/recoding.S
-
-(module
-  (func (export "f32.recoding_eq") (param $x f32) (param $y f32) (result i32)
-    (f32.eq (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
-
-  (func (export "f32.recoding_le") (param $x f32) (param $y f32) (result i32)
-    (f32.le (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
-
-  (func (export "f32.recoding_lt") (param $x f32) (param $y f32) (result i32)
-    (f32.lt (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
-
-  (func (export "f64.recoding_eq") (param $x f64) (param $y f64) (result i32)
-    (f64.eq (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
-
-  (func (export "f64.recoding_le") (param $x f64) (param $y f64) (result i32)
-    (f64.le (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
-
-  (func (export "f64.recoding_lt") (param $x f64) (param $y f64) (result i32)
-    (f64.lt (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
-
-  (func (export "recoding_demote") (param $x f64) (param $y f32) (result f32)
-    (f32.mul (f32.demote_f64 (local.get $x)) (local.get $y)))
-)
-
-(assert_return (invoke "f32.recoding_eq" (f32.const -infinity) (f32.const 3.0)) (i32.const 1))
-(assert_return (invoke "f32.recoding_le" (f32.const -infinity) (f32.const 3.0)) (i32.const 1))
-(assert_return (invoke "f32.recoding_lt" (f32.const -infinity) (f32.const 3.0)) (i32.const 0))
-
-(assert_return (invoke "f32.recoding_eq" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "f32.recoding_le" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "f32.recoding_lt" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
-
-(assert_return (invoke "f64.recoding_eq" (f64.const -infinity) (f64.const 3.0)) (i32.const 1))
-(assert_return (invoke "f64.recoding_le" (f64.const -infinity) (f64.const 3.0)) (i32.const 1))
-(assert_return (invoke "f64.recoding_lt" (f64.const -infinity) (f64.const 3.0)) (i32.const 0))
-
-(assert_return (invoke "f64.recoding_eq" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "f64.recoding_le" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "f64.recoding_lt" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0))
-
-(assert_return (invoke "recoding_demote" (f64.const 0x1.4c8f8p-132) (f32.const 1221)) (f32.const 0x1.8c8a1cp-122))
-
-;; Test that division is not done as on an extended-base system.
-;; http://www.ucbtest.org/goldberg/addendum.html
-
-(module
-  (func (export "f32.no_extended_precision_div") (param $x f32) (param $y f32) (param $z f32) (result i32)
-    (f32.eq (f32.div (local.get $x) (local.get $y)) (local.get $z)))
-
-  (func (export "f64.no_extended_precision_div") (param $x f64) (param $y f64) (param $z f64) (result i32)
-    (f64.eq (f64.div (local.get $x) (local.get $y)) (local.get $z)))
-)
-
-(assert_return (invoke "f32.no_extended_precision_div" (f32.const 3.0) (f32.const 7.0) (f32.const 0x1.b6db6ep-2)) (i32.const 1))
-(assert_return (invoke "f64.no_extended_precision_div" (f64.const 3.0) (f64.const 7.0) (f64.const 0x1.b6db6db6db6dbp-2)) (i32.const 1))
-
-;; a*x + b*x == (a+b)*x for all x only if the operations a*x, b*x, and (a+b)
-;; are all exact operations, which is true only if a and b are exact powers of
-;; 2. Even then, if a==-b and x==-0, then a*x+b*x==0.0, (a+b)*x==-0.0.
-;; https://dlang.org/d-floating-point.html
-
-(module
-  (func (export "f32.no_distribute_exact") (param $x f32) (result f32)
-    (f32.add (f32.mul (f32.const -8.0) (local.get $x)) (f32.mul (f32.const 8.0) (local.get $x))))
-
-  (func (export "f64.no_distribute_exact") (param $x f64) (result f64)
-    (f64.add (f64.mul (f64.const -8.0) (local.get $x)) (f64.mul (f64.const 8.0) (local.get $x))))
-)
-
-(assert_return (invoke "f32.no_distribute_exact" (f32.const -0.0)) (f32.const 0.0))
-(assert_return (invoke "f64.no_distribute_exact" (f64.const -0.0)) (f64.const 0.0))
-
-;; Test that various approximations of sqrt(2), sqrt(3), and sqrt(5) compute the
-;; expected approximation.
-;; https://xkcd.com/1047/
-(module
-  (func (export "f32.sqrt") (param f32) (result f32)
-    (f32.sqrt (local.get 0)))
-
-  (func (export "f32.xkcd_sqrt_2") (param f32) (param f32) (param f32) (param f32) (result f32)
-    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (f32.sub (local.get 3) (local.get 2)))))
-
-  (func (export "f32.xkcd_sqrt_3") (param f32) (param f32) (param f32) (result f32)
-    (f32.div (f32.mul (local.get 0) (local.get 1)) (local.get 2)))
-
-  (func (export "f32.xkcd_sqrt_5") (param f32) (param f32) (param f32) (result f32)
-    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (local.get 0))))
-
-  (func (export "f32.xkcd_better_sqrt_5") (param f32) (param f32) (param f32) (param f32) (result f32)
-    (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)))))
-
-  (func (export "f64.sqrt") (param f64) (result f64)
-    (f64.sqrt (local.get 0)))
-
-  (func (export "f64.xkcd_sqrt_2") (param f64) (param f64) (param f64) (param f64) (result f64)
-    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (f64.sub (local.get 3) (local.get 2)))))
-
-  (func (export "f64.xkcd_sqrt_3") (param f64) (param f64) (param f64) (result f64)
-    (f64.div (f64.mul (local.get 0) (local.get 1)) (local.get 2)))
-
-  (func (export "f64.xkcd_sqrt_5") (param f64) (param f64) (param f64) (result f64)
-    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (local.get 0))))
-
-  (func (export "f64.xkcd_better_sqrt_5") (param f64) (param f64) (param f64) (param f64) (result f64)
-    (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)))))
-)
-
-(assert_return (invoke "f32.sqrt" (f32.const 2.0)) (f32.const 0x1.6a09e6p+0))
-(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))
-(assert_return (invoke "f32.sqrt" (f32.const 3.0)) (f32.const 0x1.bb67aep+0))
-(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))
-(assert_return (invoke "f32.sqrt" (f32.const 5.0)) (f32.const 0x1.1e377ap+1))
-(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))
-(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))
-
-(assert_return (invoke "f64.sqrt" (f64.const 2.0)) (f64.const 0x1.6a09e667f3bcdp+0))
-(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))
-(assert_return (invoke "f64.sqrt" (f64.const 3.0)) (f64.const 0x1.bb67ae8584caap+0))
-(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))
-(assert_return (invoke "f64.sqrt" (f64.const 5.0)) (f64.const 0x1.1e3779b97f4a8p+1))
-(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))
-(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))
-
-;; Compute the floating-point radix.
-;; M. A. Malcom. Algorithms to reveal properties of floating-point arithmetic.
-;; Communications of the ACM, 15(11):949-951, November 1972.
-(module
-  (func (export "f32.compute_radix") (param $0 f32) (param $1 f32) (result f32)
-    (loop $label$0
-      (br_if $label$0
-        (f32.eq
-          (f32.add
-            (f32.sub
-              (f32.add
-                (local.tee $0 (f32.add (local.get $0) (local.get $0)))
-                (f32.const 1)
-              )
-              (local.get $0)
-            )
-            (f32.const -1)
-          )
-          (f32.const 0)
-        )
-      )
-    )
-    (loop $label$2
-      (br_if $label$2
-        (f32.ne
-          (f32.sub
-            (f32.sub
-              (f32.add
-                (local.get $0)
-                (local.tee $1 (f32.add (local.get $1) (f32.const 1)))
-              )
-              (local.get $0)
-            )
-            (local.get $1)
-          )
-          (f32.const 0)
-        )
-      )
-    )
-    (local.get $1)
-  )
-
-  (func (export "f64.compute_radix") (param $0 f64) (param $1 f64) (result f64)
-    (loop $label$0
-      (br_if $label$0
-        (f64.eq
-          (f64.add
-            (f64.sub
-              (f64.add
-                (local.tee $0 (f64.add (local.get $0) (local.get $0)))
-                (f64.const 1)
-              )
-              (local.get $0)
-            )
-            (f64.const -1)
-          )
-          (f64.const 0)
-        )
-      )
-    )
-    (loop $label$2
-      (br_if $label$2
-        (f64.ne
-          (f64.sub
-            (f64.sub
-              (f64.add
-                (local.get $0)
-                (local.tee $1 (f64.add (local.get $1) (f64.const 1)))
-              )
-              (local.get $0)
-            )
-            (local.get $1)
-          )
-          (f64.const 0)
-        )
-      )
-    )
-    (local.get $1)
-  )
-)
-
-(assert_return (invoke "f32.compute_radix" (f32.const 1.0) (f32.const 1.0)) (f32.const 2.0))
-(assert_return (invoke "f64.compute_radix" (f64.const 1.0) (f64.const 1.0)) (f64.const 2.0))
-
-;; Test that (x - 1) * y + y is not optimized to x * y.
-;; http://blog.frama-c.com/index.php?post/2013/05/14/Contrarianism
-
-(module
-  (func (export "f32.no_fold_sub1_mul_add") (param $x f32) (param $y f32) (result f32)
-    (f32.add (f32.mul (f32.sub (local.get $x) (f32.const 1.0)) (local.get $y)) (local.get $y)))
-
-  (func (export "f64.no_fold_sub1_mul_add") (param $x f64) (param $y f64) (result f64)
-    (f64.add (f64.mul (f64.sub (local.get $x) (f64.const 1.0)) (local.get $y)) (local.get $y)))
-)
-
-(assert_return (invoke "f32.no_fold_sub1_mul_add" (f32.const 0x1p-32) (f32.const 1.0)) (f32.const 0x0p+0))
-(assert_return (invoke "f64.no_fold_sub1_mul_add" (f64.const 0x1p-64) (f64.const 1.0)) (f64.const 0x0p+0))
-
-;; Test that x+z >= y+z is not optimized to x >= y (monotonicity).
-;; http://cs.nyu.edu/courses/spring13/CSCI-UA.0201-003/lecture6.pdf
-
-(module
-  (func (export "f32.no_fold_add_le_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32)
-    (f32.le (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z))))
-
-  (func (export "f32.no_fold_add_ge_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32)
-    (f32.ge (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z))))
-
-  (func (export "f64.no_fold_add_le_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32)
-    (f64.le (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z))))
-
-  (func (export "f64.no_fold_add_ge_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32)
-    (f64.ge (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z))))
-)
-
-(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const 0.0) (f32.const 0.0) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const infinity) (f32.const -infinity) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const 0.0) (f64.const 0.0) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const infinity) (f64.const -infinity) (f64.const infinity)) (i32.const 0))
-
-;; Test that !(x < y) and friends are not optimized to x >= y and friends.
-
-(module
-  (func (export "f32.not_lt") (param $x f32) (param $y f32) (result i32)
-    (i32.eqz (f32.lt (local.get $x) (local.get $y))))
-
-  (func (export "f32.not_le") (param $x f32) (param $y f32) (result i32)
-    (i32.eqz (f32.le (local.get $x) (local.get $y))))
-
-  (func (export "f32.not_gt") (param $x f32) (param $y f32) (result i32)
-    (i32.eqz (f32.gt (local.get $x) (local.get $y))))
-
-  (func (export "f32.not_ge") (param $x f32) (param $y f32) (result i32)
-    (i32.eqz (f32.ge (local.get $x) (local.get $y))))
-
-  (func (export "f64.not_lt") (param $x f64) (param $y f64) (result i32)
-    (i32.eqz (f64.lt (local.get $x) (local.get $y))))
-
-  (func (export "f64.not_le") (param $x f64) (param $y f64) (result i32)
-    (i32.eqz (f64.le (local.get $x) (local.get $y))))
-
-  (func (export "f64.not_gt") (param $x f64) (param $y f64) (result i32)
-    (i32.eqz (f64.gt (local.get $x) (local.get $y))))
-
-  (func (export "f64.not_ge") (param $x f64) (param $y f64) (result i32)
-    (i32.eqz (f64.ge (local.get $x) (local.get $y))))
-)
-
-(assert_return (invoke "f32.not_lt" (f32.const nan) (f32.const 0.0)) (i32.const 1))
-(assert_return (invoke "f32.not_le" (f32.const nan) (f32.const 0.0)) (i32.const 1))
-(assert_return (invoke "f32.not_gt" (f32.const nan) (f32.const 0.0)) (i32.const 1))
-(assert_return (invoke "f32.not_ge" (f32.const nan) (f32.const 0.0)) (i32.const 1))
-(assert_return (invoke "f64.not_lt" (f64.const nan) (f64.const 0.0)) (i32.const 1))
-(assert_return (invoke "f64.not_le" (f64.const nan) (f64.const 0.0)) (i32.const 1))
-(assert_return (invoke "f64.not_gt" (f64.const nan) (f64.const 0.0)) (i32.const 1))
-(assert_return (invoke "f64.not_ge" (f64.const nan) (f64.const 0.0)) (i32.const 1))
-
-;; Test that a method for approximating a "machine epsilon" produces the expected
-;; approximation.
-;; http://blogs.mathworks.com/cleve/2014/07/07/floating-point-numbers/#24cb4f4d-b8a9-4c19-b22b-9d2a9f7f3812
-
-(module
-  (func (export "f32.epsilon") (result f32)
-    (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)))))
-
-  (func (export "f64.epsilon") (result f64)
-    (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)))))
-)
-
-(assert_return (invoke "f32.epsilon") (f32.const -0x1p-23))
-(assert_return (invoke "f64.epsilon") (f64.const 0x1p-52))
-
-;; Test that floating-point numbers are not optimized as if they form a
-;; trichotomy.
-
-(module
-  (func (export "f32.no_trichotomy_lt") (param $x f32) (param $y f32) (result i32)
-    (i32.or (f32.lt (local.get $x) (local.get $y)) (f32.ge (local.get $x) (local.get $y))))
-  (func (export "f32.no_trichotomy_le") (param $x f32) (param $y f32) (result i32)
-    (i32.or (f32.le (local.get $x) (local.get $y)) (f32.gt (local.get $x) (local.get $y))))
-  (func (export "f32.no_trichotomy_gt") (param $x f32) (param $y f32) (result i32)
-    (i32.or (f32.gt (local.get $x) (local.get $y)) (f32.le (local.get $x) (local.get $y))))
-  (func (export "f32.no_trichotomy_ge") (param $x f32) (param $y f32) (result i32)
-    (i32.or (f32.ge (local.get $x) (local.get $y)) (f32.lt (local.get $x) (local.get $y))))
-
-  (func (export "f64.no_trichotomy_lt") (param $x f64) (param $y f64) (result i32)
-    (i32.or (f64.lt (local.get $x) (local.get $y)) (f64.ge (local.get $x) (local.get $y))))
-  (func (export "f64.no_trichotomy_le") (param $x f64) (param $y f64) (result i32)
-    (i32.or (f64.le (local.get $x) (local.get $y)) (f64.gt (local.get $x) (local.get $y))))
-  (func (export "f64.no_trichotomy_gt") (param $x f64) (param $y f64) (result i32)
-    (i32.or (f64.gt (local.get $x) (local.get $y)) (f64.le (local.get $x) (local.get $y))))
-  (func (export "f64.no_trichotomy_ge") (param $x f64) (param $y f64) (result i32)
-    (i32.or (f64.ge (local.get $x) (local.get $y)) (f64.lt (local.get $x) (local.get $y))))
-)
-
-(assert_return (invoke "f32.no_trichotomy_lt" (f32.const 0.0) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "f32.no_trichotomy_le" (f32.const 0.0) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "f32.no_trichotomy_gt" (f32.const 0.0) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "f32.no_trichotomy_ge" (f32.const 0.0) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "f64.no_trichotomy_lt" (f64.const 0.0) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "f64.no_trichotomy_le" (f64.const 0.0) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "f64.no_trichotomy_gt" (f64.const 0.0) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "f64.no_trichotomy_ge" (f64.const 0.0) (f64.const nan)) (i32.const 0))
diff --git a/test/spec/old_float_literals.wast b/test/spec/old_float_literals.wast
deleted file mode 100644
index 6f890affd..000000000
--- a/test/spec/old_float_literals.wast
+++ /dev/null
@@ -1,137 +0,0 @@
-;; Test floating-point literal parsing.
-
-(module
-  ;; f32 special values
-  (func (export "f32.nan") (result i32) (i32.reinterpret_f32 (f32.const nan)))
-  (func (export "f32.positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan)))
-  (func (export "f32.negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan)))
-  (func (export "f32.plain_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x400000)))
-  (func (export "f32.informally_known_as_plain_snan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x200000)))
-  (func (export "f32.all_ones_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x7fffff)))
-  (func (export "f32.misc_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x012345)))
-  (func (export "f32.misc_positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan:0x304050)))
-  (func (export "f32.misc_negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x2abcde)))
-  (func (export "f32.infinity") (result i32) (i32.reinterpret_f32 (f32.const infinity)))
-  (func (export "f32.positive_infinity") (result i32) (i32.reinterpret_f32 (f32.const +infinity)))
-  (func (export "f32.negative_infinity") (result i32) (i32.reinterpret_f32 (f32.const -infinity)))
-
-  ;; f32 numbers
-  (func (export "f32.zero") (result i32) (i32.reinterpret_f32 (f32.const 0x0.0p0)))
-  (func (export "f32.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0x0.0p0)))
-  (func (export "f32.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0x0.0p0)))
-  (func (export "f32.misc") (result i32) (i32.reinterpret_f32 (f32.const 0x1.921fb6p+2)))
-  (func (export "f32.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-149)))
-  (func (export "f32.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-126)))
-  (func (export "f32.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffep+127)))
-  (func (export "f32.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffcp-127)))
-  (func (export "f32.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 0x1.p10)))
-
-  ;; f32 in decimal format
-  (func (export "f32_dec.zero") (result i32) (i32.reinterpret_f32 (f32.const 0.0e0)))
-  (func (export "f32_dec.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0.0e0)))
-  (func (export "f32_dec.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0.0e0)))
-  (func (export "f32_dec.misc") (result i32) (i32.reinterpret_f32 (f32.const 6.28318548202514648)))
-  (func (export "f32_dec.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 1.4013e-45)))
-  (func (export "f32_dec.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754944e-38)))
-  (func (export "f32_dec.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754942e-38)))
-  (func (export "f32_dec.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 3.4028234e+38)))
-  (func (export "f32_dec.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 1.e10)))
-
-  ;; f64 special values
-  (func (export "f64.nan") (result i64) (i64.reinterpret_f64 (f64.const nan)))
-  (func (export "f64.positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan)))
-  (func (export "f64.negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan)))
-  (func (export "f64.plain_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x8000000000000)))
-  (func (export "f64.informally_known_as_plain_snan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x4000000000000)))
-  (func (export "f64.all_ones_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0xfffffffffffff)))
-  (func (export "f64.misc_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x0123456789abc)))
-  (func (export "f64.misc_positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan:0x3040506070809)))
-  (func (export "f64.misc_negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0x2abcdef012345)))
-  (func (export "f64.infinity") (result i64) (i64.reinterpret_f64 (f64.const infinity)))
-  (func (export "f64.positive_infinity") (result i64) (i64.reinterpret_f64 (f64.const +infinity)))
-  (func (export "f64.negative_infinity") (result i64) (i64.reinterpret_f64 (f64.const -infinity)))
-
-  ;; f64 numbers
-  (func (export "f64.zero") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0p0)))
-  (func (export "f64.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0x0.0p0)))
-  (func (export "f64.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0x0.0p0)))
-  (func (export "f64.misc") (result i64) (i64.reinterpret_f64 (f64.const 0x1.921fb54442d18p+2)))
-  (func (export "f64.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0000000000001p-1022)))
-  (func (export "f64.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 0x1p-1022)))
-  (func (export "f64.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 0x0.fffffffffffffp-1022)))
-  (func (export "f64.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 0x1.fffffffffffffp+1023)))
-  (func (export "f64.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 0x1.p100)))
-
-  ;; f64 numbers in decimal format
-  (func (export "f64_dec.zero") (result i64) (i64.reinterpret_f64 (f64.const 0.0e0)))
-  (func (export "f64_dec.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0.0e0)))
-  (func (export "f64_dec.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0.0e0)))
-  (func (export "f64_dec.misc") (result i64) (i64.reinterpret_f64 (f64.const 6.28318530717958623)))
-  (func (export "f64_dec.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 4.94066e-324)))
-  (func (export "f64_dec.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072012e-308)))
-  (func (export "f64_dec.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072011e-308)))
-  (func (export "f64_dec.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 1.7976931348623157e+308)))
-  (func (export "f64_dec.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 1.e100)))
-)
-
-(assert_return (invoke "f32.nan") (i32.const 0x7fc00000))
-(assert_return (invoke "f32.positive_nan") (i32.const 0x7fc00000))
-(assert_return (invoke "f32.negative_nan") (i32.const 0xffc00000))
-(assert_return (invoke "f32.plain_nan") (i32.const 0x7fc00000))
-(assert_return (invoke "f32.informally_known_as_plain_snan") (i32.const 0x7fa00000))
-(assert_return (invoke "f32.all_ones_nan") (i32.const 0xffffffff))
-(assert_return (invoke "f32.misc_nan") (i32.const 0x7f812345))
-(assert_return (invoke "f32.misc_positive_nan") (i32.const 0x7fb04050))
-(assert_return (invoke "f32.misc_negative_nan") (i32.const 0xffaabcde))
-(assert_return (invoke "f32.infinity") (i32.const 0x7f800000))
-(assert_return (invoke "f32.positive_infinity") (i32.const 0x7f800000))
-(assert_return (invoke "f32.negative_infinity") (i32.const 0xff800000))
-(assert_return (invoke "f32.zero") (i32.const 0))
-(assert_return (invoke "f32.positive_zero") (i32.const 0))
-(assert_return (invoke "f32.negative_zero") (i32.const 0x80000000))
-(assert_return (invoke "f32.misc") (i32.const 0x40c90fdb))
-(assert_return (invoke "f32.min_positive") (i32.const 1))
-(assert_return (invoke "f32.min_normal") (i32.const 0x800000))
-(assert_return (invoke "f32.max_subnormal") (i32.const 0x7fffff))
-(assert_return (invoke "f32.max_finite") (i32.const 0x7f7fffff))
-(assert_return (invoke "f32.trailing_dot") (i32.const 0x44800000))
-(assert_return (invoke "f32_dec.zero") (i32.const 0))
-(assert_return (invoke "f32_dec.positive_zero") (i32.const 0))
-(assert_return (invoke "f32_dec.negative_zero") (i32.const 0x80000000))
-(assert_return (invoke "f32_dec.misc") (i32.const 0x40c90fdb))
-(assert_return (invoke "f32_dec.min_positive") (i32.const 1))
-(assert_return (invoke "f32_dec.min_normal") (i32.const 0x800000))
-(assert_return (invoke "f32_dec.max_subnormal") (i32.const 0x7fffff))
-(assert_return (invoke "f32_dec.max_finite") (i32.const 0x7f7fffff))
-(assert_return (invoke "f32_dec.trailing_dot") (i32.const 0x501502f9))
-
-(assert_return (invoke "f64.nan") (i64.const 0x7ff8000000000000))
-(assert_return (invoke "f64.positive_nan") (i64.const 0x7ff8000000000000))
-(assert_return (invoke "f64.negative_nan") (i64.const 0xfff8000000000000))
-(assert_return (invoke "f64.plain_nan") (i64.const 0x7ff8000000000000))
-(assert_return (invoke "f64.informally_known_as_plain_snan") (i64.const 0x7ff4000000000000))
-(assert_return (invoke "f64.all_ones_nan") (i64.const 0xffffffffffffffff))
-(assert_return (invoke "f64.misc_nan") (i64.const 0x7ff0123456789abc))
-(assert_return (invoke "f64.misc_positive_nan") (i64.const 0x7ff3040506070809))
-(assert_return (invoke "f64.misc_negative_nan") (i64.const 0xfff2abcdef012345))
-(assert_return (invoke "f64.infinity") (i64.const 0x7ff0000000000000))
-(assert_return (invoke "f64.positive_infinity") (i64.const 0x7ff0000000000000))
-(assert_return (invoke "f64.negative_infinity") (i64.const 0xfff0000000000000))
-(assert_return (invoke "f64.zero") (i64.const 0))
-(assert_return (invoke "f64.positive_zero") (i64.const 0))
-(assert_return (invoke "f64.negative_zero") (i64.const 0x8000000000000000))
-(assert_return (invoke "f64.misc") (i64.const 0x401921fb54442d18))
-(assert_return (invoke "f64.min_positive") (i64.const 1))
-(assert_return (invoke "f64.min_normal") (i64.const 0x10000000000000))
-(assert_return (invoke "f64.max_subnormal") (i64.const 0xfffffffffffff))
-(assert_return (invoke "f64.max_finite") (i64.const 0x7fefffffffffffff))
-(assert_return (invoke "f64.trailing_dot") (i64.const 0x4630000000000000))
-(assert_return (invoke "f64_dec.zero") (i64.const 0))
-(assert_return (invoke "f64_dec.positive_zero") (i64.const 0))
-(assert_return (invoke "f64_dec.negative_zero") (i64.const 0x8000000000000000))
-(assert_return (invoke "f64_dec.misc") (i64.const 0x401921fb54442d18))
-(assert_return (invoke "f64_dec.min_positive") (i64.const 1))
-(assert_return (invoke "f64_dec.min_normal") (i64.const 0x10000000000000))
-(assert_return (invoke "f64_dec.max_subnormal") (i64.const 0xfffffffffffff))
-(assert_return (invoke "f64_dec.max_finite") (i64.const 0x7fefffffffffffff))
-(assert_return (invoke "f64_dec.trailing_dot") (i64.const 0x54b249ad2594c37d))
diff --git a/test/spec/old_func.wast b/test/spec/old_func.wast
deleted file mode 100644
index 5a2aa8165..000000000
--- a/test/spec/old_func.wast
+++ /dev/null
@@ -1,522 +0,0 @@
-;; Test `func` declarations, i.e. functions
-
-(module
-  ;; Auxiliary definition
-  (type $sig (func))
-  (func $dummy)
-
-  ;; Syntax
-
-  (func)
-  (func (export "f"))
-  (func $f)
-  (func $h (export "g"))
-
-  (func (local))
-  (func (local) (local))
-  (func (local i32))
-  (func (local $x i32))
-  (func (local i32 f64 i64))
-  (func (local i32) (local f64))
-  (func (local i32 f32) (local $x i64) (local) (local i32 f64))
-
-  (func (param))
-  (func (param) (param))
-  (func (param i32))
-  (func (param $x i32))
-  (func (param i32 f64 i64))
-  (func (param i32) (param f64))
-  (func (param i32 f32) (param $x i64) (param) (param i32 f64))
-
-  (func (result i32) (unreachable))
-
-  (func (type $sig))
-
-  (func $complex
-    (param i32 f32) (param $x i64) (param) (param i32)
-    (result i32)
-    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
-    (unreachable) (unreachable)
-  )
-  (func $complex-sig
-    (type $sig)
-    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
-    (unreachable) (unreachable)
-  )
-
-
-  ;; Typing of locals
-
-  (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0))
-  (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0))
-  (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0))
-  (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0))
-  (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1))
-  (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1))
-  (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1))
-  (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1))
-  (func (export "local-mixed") (result f64)
-    (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32)
-    (drop (f32.neg (local.get 0)))
-    (drop (i32.eqz (local.get 1)))
-    (drop (i64.eqz (local.get 2)))
-    (drop (i32.eqz (local.get 3)))
-    (drop (f64.neg (local.get 4)))
-    (drop (i32.eqz (local.get 5)))
-    (local.get 4)
-  )
-
-  ;; Typing of parameters
-
-  (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0))
-  (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0))
-  (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0))
-  (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0))
-  (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1))
-  (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1))
-  (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1))
-  (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1))
-  (func (export "param-mixed") (param f32 i32) (param) (param $x i64) (param i32 f64 i32)
-    (result f64)
-    (drop (f32.neg (local.get 0)))
-    (drop (i32.eqz (local.get 1)))
-    (drop (i64.eqz (local.get 2)))
-    (drop (i32.eqz (local.get 3)))
-    (drop (f64.neg (local.get 4)))
-    (drop (i32.eqz (local.get 5)))
-    (local.get 4)
-  )
-
-  ;; Typing of result
-
-  (func (export "empty"))
-  (func (export "value-void") (call $dummy))
-  (func (export "value-i32") (result i32) (i32.const 77))
-  (func (export "value-i64") (result i64) (i64.const 7777))
-  (func (export "value-f32") (result f32) (f32.const 77.7))
-  (func (export "value-f64") (result f64) (f64.const 77.77))
-  (func (export "value-block-void") (block (call $dummy) (call $dummy)))
-  (func (export "value-block-i32") (result i32)
-    (block i32 (call $dummy) (i32.const 77))
-  )
-
-  (func (export "return-empty") (return))
-  (func (export "return-i32") (result i32) (return (i32.const 78)))
-  (func (export "return-i64") (result i64) (return (i64.const 7878)))
-  (func (export "return-f32") (result f32) (return (f32.const 78.7)))
-  (func (export "return-f64") (result f64) (return (f64.const 78.78)))
-  (func (export "return-block-i32") (result i32)
-    (return (block i32 (call $dummy) (i32.const 77)))
-  )
-
-  (func (export "break-empty") (br 0))
-  (func (export "break-i32") (result i32) (br 0 (i32.const 79)))
-  (func (export "break-i64") (result i64) (br 0 (i64.const 7979)))
-  (func (export "break-f32") (result f32) (br 0 (f32.const 79.9)))
-  (func (export "break-f64") (result f64) (br 0 (f64.const 79.79)))
-  (func (export "break-block-i32") (result i32)
-    (br 0 (block i32 (call $dummy) (i32.const 77)))
-  )
-
-  (func (export "break-br_if-empty") (param i32)
-    (br_if 0 (local.get 0))
-  )
-  (func (export "break-br_if-num") (param i32) (result i32)
-    (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51)
-  )
-
-  (func (export "break-br_table-empty") (param i32)
-    (br_table 0 0 0 (local.get 0))
-  )
-  (func (export "break-br_table-num") (param i32) (result i32)
-    (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51)
-  )
-  (func (export "break-br_table-nested-empty") (param i32)
-    (block (br_table 0 1 0 (local.get 0)))
-  )
-  (func (export "break-br_table-nested-num") (param i32) (result i32)
-    (i32.add
-      (block i32 (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51))
-      (i32.const 2)
-    )
-  )
-
-  ;; Default initialization of locals
-
-  (func (export "init-local-i32") (result i32) (local i32) (local.get 0))
-  (func (export "init-local-i64") (result i64) (local i64) (local.get 0))
-  (func (export "init-local-f32") (result f32) (local f32) (local.get 0))
-  (func (export "init-local-f64") (result f64) (local f64) (local.get 0))
-
-
-  ;; Desugaring of implicit type signature
-  (func $empty-sig-1)  ;; should be assigned type $sig
-  (func $complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32))
-  (func $empty-sig-2)  ;; should be assigned type $sig
-  (func $complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32))
-  (func $complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32))
-
-  (type $empty-sig-duplicate (func))
-  (type $complex-sig-duplicate (func (param f64 i64 f64 i64 f64 i64 f32 i32)))
-  (table funcref
-    (elem
-      $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1
-    )
-  )
-
-  (func (export "signature-explicit-reused")
-    (call_indirect (type $sig) (i32.const 1))
-    (call_indirect (type $sig) (i32.const 4))
-  )
-
-  (func (export "signature-implicit-reused")
-
-    ;; XXX: Use numeric indices in this test again once we have a
-    ;; spec-compliant text parser. Original comment follows.
-
-    ;; The implicit index 16 in this test depends on the function and
-    ;; type definitions, and may need adapting if they change.
-    (call_indirect (type 2) ;; XXX: was `(type 16)`
-      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
-      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
-      (i32.const 0)
-    )
-    (call_indirect (type 2) ;; XXX: was `(type 16)`
-      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
-      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
-      (i32.const 2)
-    )
-    (call_indirect (type 2) ;; XXX: was `(type 16)`
-      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
-      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
-      (i32.const 3)
-    )
-  )
-
-  (func (export "signature-explicit-duplicate")
-    (call_indirect (type $empty-sig-duplicate) (i32.const 1))
-  )
-
-  (func (export "signature-implicit-duplicate")
-    (call_indirect (type $complex-sig-duplicate)
-      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
-      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
-      (i32.const 0)
-    )
-  )
-)
-
-(assert_return (invoke "local-first-i32") (i32.const 0))
-(assert_return (invoke "local-first-i64") (i64.const 0))
-(assert_return (invoke "local-first-f32") (f32.const 0))
-(assert_return (invoke "local-first-f64") (f64.const 0))
-(assert_return (invoke "local-second-i32") (i32.const 0))
-(assert_return (invoke "local-second-i64") (i64.const 0))
-(assert_return (invoke "local-second-f32") (f32.const 0))
-(assert_return (invoke "local-second-f64") (f64.const 0))
-(assert_return (invoke "local-mixed") (f64.const 0))
-
-(assert_return
-  (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2)
-)
-(assert_return
-  (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2)
-)
-(assert_return
-  (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2)
-)
-(assert_return
-  (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2)
-)
-(assert_return
-  (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3)
-)
-(assert_return
-  (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3)
-)
-(assert_return
-  (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3)
-)
-(assert_return
-  (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3)
-)
-
-(assert_return
-  (invoke "param-mixed"
-    (f32.const 1) (i32.const 2) (i64.const 3)
-    (i32.const 4) (f64.const 5.5) (i32.const 6)
-  )
-  (f64.const 5.5)
-)
-
-(assert_return (invoke "empty"))
-(assert_return (invoke "value-void"))
-(assert_return (invoke "value-i32") (i32.const 77))
-(assert_return (invoke "value-i64") (i64.const 7777))
-(assert_return (invoke "value-f32") (f32.const 77.7))
-(assert_return (invoke "value-f64") (f64.const 77.77))
-(assert_return (invoke "value-block-void"))
-(assert_return (invoke "value-block-i32") (i32.const 77))
-
-(assert_return (invoke "return-empty"))
-(assert_return (invoke "return-i32") (i32.const 78))
-(assert_return (invoke "return-i64") (i64.const 7878))
-(assert_return (invoke "return-f32") (f32.const 78.7))
-(assert_return (invoke "return-f64") (f64.const 78.78))
-(assert_return (invoke "return-block-i32") (i32.const 77))
-
-(assert_return (invoke "break-empty"))
-(assert_return (invoke "break-i32") (i32.const 79))
-(assert_return (invoke "break-i64") (i64.const 7979))
-(assert_return (invoke "break-f32") (f32.const 79.9))
-(assert_return (invoke "break-f64") (f64.const 79.79))
-(assert_return (invoke "break-block-i32") (i32.const 77))
-
-(assert_return (invoke "break-br_if-empty" (i32.const 0)))
-(assert_return (invoke "break-br_if-empty" (i32.const 2)))
-(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51))
-(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50))
-
-(assert_return (invoke "break-br_table-empty" (i32.const 0)))
-(assert_return (invoke "break-br_table-empty" (i32.const 1)))
-(assert_return (invoke "break-br_table-empty" (i32.const 5)))
-(assert_return (invoke "break-br_table-empty" (i32.const -1)))
-(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50))
-(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50))
-(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50))
-(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50))
-(assert_return (invoke "break-br_table-nested-empty" (i32.const 0)))
-(assert_return (invoke "break-br_table-nested-empty" (i32.const 1)))
-(assert_return (invoke "break-br_table-nested-empty" (i32.const 3)))
-(assert_return (invoke "break-br_table-nested-empty" (i32.const -2)))
-(assert_return
-  (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52)
-)
-(assert_return
-  (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50)
-)
-(assert_return
-  (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52)
-)
-(assert_return
-  (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52)
-)
-
-(assert_return (invoke "init-local-i32") (i32.const 0))
-(assert_return (invoke "init-local-i64") (i64.const 0))
-(assert_return (invoke "init-local-f32") (f32.const 0))
-(assert_return (invoke "init-local-f64") (f64.const 0))
-
-(assert_return (invoke "signature-explicit-reused"))
-(assert_return (invoke "signature-implicit-reused"))
-(assert_return (invoke "signature-explicit-duplicate"))
-(assert_return (invoke "signature-implicit-duplicate"))
-
-
-;; Invalid typing of locals
-
-(assert_invalid
-  (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.get 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1))))
-  "type mismatch"
-)
-
-
-;; Invalid typing of parameters
-
-(assert_invalid
-  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
-  "type mismatch"
-)
-
-
-;; Invalid typing of result
-
-(assert_invalid
-  (module (func $type-empty-i32 (result i32)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-empty-i64 (result i64)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-empty-f32 (result f32)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-empty-f64 (result f64)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-value-void-vs-num (result i32)
-    (nop)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-num-vs-void
-    (i32.const 0)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-num-vs-num (result i32)
-    (f32.const 0)
-  ))
-  "type mismatch"
-)
-
-(; TODO(stack): Should these become legal?
-(assert_invalid
-  (module (func $type-value-void-vs-num-after-return (result i32)
-    (return (i32.const 1)) (nop)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-num-vs-num-after-return (result i32)
-    (return (i32.const 1)) (f32.const 0)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-void-vs-num-after-break (result i32)
-    (br 0 (i32.const 1)) (nop)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-num-vs-num-after-break (result i32)
-    (br 0 (i32.const 1)) (f32.const 0)
-  ))
-  "arity mismatch"
-)
-;)
-
-(assert_invalid
-  (module (func $type-return-last-empty-vs-num (result i32)
-    (return)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-return-last-void-vs-num (result i32)
-    (return (nop))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-return-last-num-vs-num (result i32)
-    (return (i64.const 0))
-  ))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-return-empty-vs-num (result i32)
-    (return) (i32.const 1)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-return-void-vs-num (result i32)
-    (return (nop)) (i32.const 1)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-return-num-vs-num (result i32)
-    (return (i64.const 1)) (i32.const 1)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-return-first-num-vs-num (result i32)
-    (return (i64.const 1)) (return (i32.const 1))
-  ))
-  "type mismatch"
-)
-(; TODO(stack): Should this become legal?
-(assert_invalid
-  (module (func $type-return-second-num-vs-num (result i32)
-    (return (i32.const 1)) (return (f64.const 1))
-  ))
-  "type mismatch"
-)
-;)
-
-(assert_invalid
-  (module (func $type-break-last-void-vs-num (result i32)
-    (br 0)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-last-num-vs-num (result i32)
-    (br 0 (f32.const 0))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-void-vs-num (result i32)
-    (br 0) (i32.const 1)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-num-vs-num (result i32)
-    (br 0 (i64.const 1)) (i32.const 1)
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-first-num-vs-num (result i32)
-    (br 0 (i64.const 1)) (br 0 (i32.const 1))
-  ))
-  "type mismatch"
-)
-
-(; TODO(stack): soft failure
-(assert_invalid
-  (module (func $type-break-second-num-vs-num (result i32)
-    (br 0 (i32.const 1)) (br 0 (f64.const 1))
-  ))
-  "type mismatch"
-)
-;)
-
-(assert_invalid
-  (module (func $type-break-nested-empty-vs-num (result i32)
-    (block (br 1)) (br 0 (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-nested-void-vs-num (result i32)
-    (block (br 1 (nop))) (br 0 (i32.const 1))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-break-nested-num-vs-num (result i32)
-    (block (br 1 (i64.const 1))) (br 0 (i32.const 1))
-  ))
-  "type mismatch"
-)
diff --git a/test/spec/old_loop.wast b/test/spec/old_loop.wast
deleted file mode 100644
index 9e51f618c..000000000
--- a/test/spec/old_loop.wast
+++ /dev/null
@@ -1,282 +0,0 @@
-;; Test `loop` opcode
-
-(module
-  (func $dummy)
-
-  (func (export "empty")
-    (loop)
-    (loop $l)
-  )
-
-  (func (export "singular") (result i32)
-    (loop (nop))
-    (loop i32 (i32.const 7))
-  )
-
-  (func (export "multi") (result i32)
-    (loop (call $dummy) (call $dummy) (call $dummy) (call $dummy))
-    (loop i32 (call $dummy) (call $dummy) (call $dummy) (i32.const 8))
-  )
-
-  (func (export "nested") (result i32)
-    (loop i32
-      (loop (call $dummy) (block) (nop))
-      (loop i32 (call $dummy) (i32.const 9))
-    )
-  )
-
-  (func (export "deep") (result i32)
-    (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-      (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-        (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-          (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-            (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-              (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-                (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-                  (loop i32 (block i32 (call $dummy) (i32.const 150)))
-                ))))))
-              ))))))
-            ))))))
-          ))))))
-        ))))))
-      ))))))
-    ))))))
-  )
-
-  (func (export "as-unary-operand") (result i32)
-    (i32.ctz (loop i32 (call $dummy) (i32.const 13)))
-  )
-  (func (export "as-binary-operand") (result i32)
-    (i32.mul
-      (loop i32 (call $dummy) (i32.const 3))
-      (loop i32 (call $dummy) (i32.const 4))
-    )
-  )
-  (func (export "as-test-operand") (result i32)
-    (i32.eqz (loop i32 (call $dummy) (i32.const 13)))
-  )
-  (func (export "as-compare-operand") (result i32)
-    (f32.gt
-      (loop f32 (call $dummy) (f32.const 3))
-      (loop f32 (call $dummy) (f32.const 3))
-    )
-  )
-
-  (func (export "break-bare") (result i32)
-    (block (loop (br 1) (br 0) (unreachable)))
-    (block (loop (br_if 1 (i32.const 1)) (unreachable)))
-    (block (loop (br_table 1 (i32.const 0)) (unreachable)))
-    (block (loop (br_table 1 1 1 (i32.const 1)) (unreachable)))
-    (i32.const 19)
-  )
-  (func (export "break-value") (result i32)
-    (block i32 (loop i32 (br 1 (i32.const 18)) (br 0) (i32.const 19)))
-  )
-  (func (export "break-repeated") (result i32)
-    (block i32
-      (loop i32
-        (br 1 (i32.const 18))
-        (br 1 (i32.const 19))
-        (drop (br_if 1 (i32.const 20) (i32.const 0)))
-        (drop (br_if 1 (i32.const 20) (i32.const 1)))
-        (br 1 (i32.const 21))
-        (br_table 1 (i32.const 22) (i32.const 0))
-        (br_table 1 1 1 (i32.const 23) (i32.const 1))
-        (i32.const 21)
-      )
-    )
-  )
-  (func (export "break-inner") (result i32)
-    (local i32)
-    (local.set 0 (i32.const 0))
-    (local.set 0 (i32.add (local.get 0) (block i32 (loop i32 (block i32 (br 2 (i32.const 0x1)))))))
-    (local.set 0 (i32.add (local.get 0) (block i32 (loop i32 (loop i32 (br 2 (i32.const 0x2)))))))
-    (local.set 0 (i32.add (local.get 0) (block i32 (loop i32 (block i32 (loop i32 (br 1 (i32.const 0x4))))))))
-    (local.set 0 (i32.add (local.get 0) (block i32 (loop i32 (i32.ctz (br 1 (i32.const 0x8)))))))
-    (local.set 0 (i32.add (local.get 0) (block i32 (loop i32 (i32.ctz (loop i32 (br 2 (i32.const 0x10))))))))
-    (local.get 0)
-  )
-  (func (export "cont-inner") (result i32)
-    (local i32)
-    (local.set 0 (i32.const 0))
-    (local.set 0 (i32.add (local.get 0) (loop i32 (loop i32 (br 1)))))
-    (local.set 0 (i32.add (local.get 0) (loop i32 (i32.ctz (br 0)))))
-    (local.set 0 (i32.add (local.get 0) (loop i32 (i32.ctz (loop i32 (br 1))))))
-    (local.get 0)
-  )
-
-  (func $fx (export "effects") (result i32)
-    (local i32)
-    (block
-      (loop
-        (local.set 0 (i32.const 1))
-        (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
-        (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
-        (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
-        (br 1)
-        (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
-      )
-    )
-    (i32.eq (local.get 0) (i32.const -14))
-  )
-
-  (func (export "while") (param i64) (result i64)
-    (local i64)
-    (local.set 1 (i64.const 1))
-    (block
-      (loop
-        (br_if 1 (i64.eqz (local.get 0)))
-        (local.set 1 (i64.mul (local.get 0) (local.get 1)))
-        (local.set 0 (i64.sub (local.get 0) (i64.const 1)))
-        (br 0)
-      )
-    )
-    (local.get 1)
-  )
-
-  (func (export "for") (param i64) (result i64)
-    (local i64 i64)
-    (local.set 1 (i64.const 1))
-    (local.set 2 (i64.const 2))
-    (block
-      (loop
-        (br_if 1 (i64.gt_u (local.get 2) (local.get 0)))
-        (local.set 1 (i64.mul (local.get 1) (local.get 2)))
-        (local.set 2 (i64.add (local.get 2) (i64.const 1)))
-        (br 0)
-      )
-    )
-    (local.get 1)
-  )
-
-  (func (export "nesting") (param f32 f32) (result f32)
-    (local f32 f32)
-    (block
-      (loop
-        (br_if 1 (f32.eq (local.get 0) (f32.const 0)))
-        (local.set 2 (local.get 1))
-        (block
-          (loop
-            (br_if 1 (f32.eq (local.get 2) (f32.const 0)))
-            (br_if 3 (f32.lt (local.get 2) (f32.const 0)))
-            (local.set 3 (f32.add (local.get 3) (local.get 2)))
-            (local.set 2 (f32.sub (local.get 2) (f32.const 2)))
-            (br 0)
-          )
-        )
-        (local.set 3 (f32.div (local.get 3) (local.get 0)))
-        (local.set 0 (f32.sub (local.get 0) (f32.const 1)))
-        (br 0)
-      )
-    )
-    (local.get 3)
-  )
-)
-
-(assert_return (invoke "empty"))
-(assert_return (invoke "singular") (i32.const 7))
-(assert_return (invoke "multi") (i32.const 8))
-(assert_return (invoke "nested") (i32.const 9))
-(assert_return (invoke "deep") (i32.const 150))
-
-(assert_return (invoke "as-unary-operand") (i32.const 0))
-(assert_return (invoke "as-binary-operand") (i32.const 12))
-(assert_return (invoke "as-test-operand") (i32.const 0))
-(assert_return (invoke "as-compare-operand") (i32.const 0))
-
-(assert_return (invoke "break-bare") (i32.const 19))
-(assert_return (invoke "break-value") (i32.const 18))
-(assert_return (invoke "break-repeated") (i32.const 18))
-(assert_return (invoke "break-inner") (i32.const 0x1f))
-
-(assert_return (invoke "effects") (i32.const 1))
-
-(assert_return (invoke "while" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "while" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "while" (i64.const 2)) (i64.const 2))
-(assert_return (invoke "while" (i64.const 3)) (i64.const 6))
-(assert_return (invoke "while" (i64.const 5)) (i64.const 120))
-(assert_return (invoke "while" (i64.const 20)) (i64.const 2432902008176640000))
-
-(assert_return (invoke "for" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "for" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "for" (i64.const 2)) (i64.const 2))
-(assert_return (invoke "for" (i64.const 3)) (i64.const 6))
-(assert_return (invoke "for" (i64.const 5)) (i64.const 120))
-(assert_return (invoke "for" (i64.const 20)) (i64.const 2432902008176640000))
-
-(assert_return (invoke "nesting" (f32.const 0) (f32.const 7)) (f32.const 0))
-(assert_return (invoke "nesting" (f32.const 7) (f32.const 0)) (f32.const 0))
-(assert_return (invoke "nesting" (f32.const 1) (f32.const 1)) (f32.const 1))
-(assert_return (invoke "nesting" (f32.const 1) (f32.const 2)) (f32.const 2))
-(assert_return (invoke "nesting" (f32.const 1) (f32.const 3)) (f32.const 4))
-(assert_return (invoke "nesting" (f32.const 1) (f32.const 4)) (f32.const 6))
-(assert_return (invoke "nesting" (f32.const 1) (f32.const 100)) (f32.const 2550))
-(assert_return (invoke "nesting" (f32.const 1) (f32.const 101)) (f32.const 2601))
-(assert_return (invoke "nesting" (f32.const 2) (f32.const 1)) (f32.const 1))
-(assert_return (invoke "nesting" (f32.const 3) (f32.const 1)) (f32.const 1))
-(assert_return (invoke "nesting" (f32.const 10) (f32.const 1)) (f32.const 1))
-(assert_return (invoke "nesting" (f32.const 2) (f32.const 2)) (f32.const 3))
-(assert_return (invoke "nesting" (f32.const 2) (f32.const 3)) (f32.const 4))
-(assert_return (invoke "nesting" (f32.const 7) (f32.const 4)) (f32.const 10.3095235825))
-(assert_return (invoke "nesting" (f32.const 7) (f32.const 100)) (f32.const 4381.54785156))
-(assert_return (invoke "nesting" (f32.const 7) (f32.const 101)) (f32.const 2601))
-
-(assert_invalid
-  (module (func $type-empty-i32 (result i32) (loop)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-empty-i64 (result i64) (loop)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-empty-f32 (result f32) (loop)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-empty-f64 (result f64) (loop)))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $type-value-void-vs-num (result i32)
-    (loop (nop))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-num-vs-num (result i32)
-    (loop (f32.const 0))
-  ))
-  "type mismatch"
-)
-
-(; TODO(stack): soft failure
-(assert_invalid
-  (module (func $type-value-void-vs-num-after-break (result i32)
-    (loop (br 1 (i32.const 1)) (nop))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-value-num-vs-num-after-break (result i32)
-    (loop (br 1 (i32.const 1)) (f32.const 0))
-  ))
-  "type mismatch"
-)
-;)
-
-(assert_invalid
-  (module (func $type-cont-last-void-vs-empty (result i32)
-    (loop (br 0 (nop)))
-  ))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-cont-last-num-vs-empty (result i32)
-    (loop (br 0 (i32.const 0)))
-  ))
-  "type mismatch"
-)
-
diff --git a/test/spec/old_unreachable.wast b/test/spec/old_unreachable.wast
deleted file mode 100644
index a1d7934c1..000000000
--- a/test/spec/old_unreachable.wast
+++ /dev/null
@@ -1,262 +0,0 @@
-;; Test `unreachable` operator
-
-(module
-  ;; Auxiliary definitions
-  (func $dummy)
-  (func $dummy3 (param i32 i32 i32))
-
-  (func (export "type-i32") (result i32) (unreachable))
-  (func (export "type-i64") (result i32) (unreachable))
-  (func (export "type-f32") (result f64) (unreachable))
-  (func (export "type-f64") (result f64) (unreachable))
-
-  (func (export "as-func-first") (result i32)
-    (unreachable) (i32.const -1)
-  )
-  (func (export "as-func-mid") (result i32)
-    (call $dummy) (unreachable) (i32.const -1)
-  )
-  (func (export "as-func-last")
-    (call $dummy) (unreachable)
-  )
-  (func (export "as-func-value") (result i32)
-    (call $dummy) (unreachable)
-  )
-
-  (func (export "as-block-first") (result i32)
-    (block i32 (unreachable) (i32.const 2))
-  )
-  (func (export "as-block-mid") (result i32)
-    (block i32 (call $dummy) (unreachable) (i32.const 2))
-  )
-  (func (export "as-block-last")
-    (block (nop) (call $dummy) (unreachable))
-  )
-  (func (export "as-block-value") (result i32)
-    (block i32 (nop) (call $dummy) (unreachable))
-  )
-  (func (export "as-block-broke") (result i32)
-    (block i32 (call $dummy) (br 0 (i32.const 1)) (unreachable))
-  )
-
-  (func (export "as-loop-first") (result i32)
-    (loop i32 (unreachable) (i32.const 2))
-  )
-  (func (export "as-loop-mid") (result i32)
-    (loop i32 (call $dummy) (unreachable) (i32.const 2))
-  )
-  (func (export "as-loop-last")
-    (loop (nop) (call $dummy) (unreachable))
-  )
-  (func (export "as-loop-broke") (result i32)
-    (block i32 (loop i32 (call $dummy) (br 1 (i32.const 1)) (unreachable)))
-  )
-
-  (func (export "as-br-value") (result i32)
-    (block i32 (br 0 (unreachable)))
-  )
-
-  (func (export "as-br_if-cond")
-    (block (br_if 0 (unreachable)))
-  )
-  (func (export "as-br_if-value") (result i32)
-    (block i32 (br_if 0 (unreachable) (i32.const 1)) (i32.const 7))
-  )
-  (func (export "as-br_if-value-cond") (result i32)
-    (block i32 (drop (br_if 0 (i32.const 6) (unreachable))) (i32.const 7))
-  )
-
-  (func (export "as-br_table-index")
-    (block (br_table 0 0 0 (unreachable)))
-  )
-  (func (export "as-br_table-value") (result i32)
-    (block i32 (br_table 0 0 0 (unreachable) (i32.const 1)) (i32.const 7))
-  )
-  (func (export "as-br_table-value-index") (result i32)
-    (block i32 (br_table 0 0 (i32.const 6) (unreachable)) (i32.const 7))
-  )
-
-  (func (export "as-return-value") (result i64)
-    (return (unreachable))
-  )
-
-  (func (export "as-if-cond") (result i32)
-    (if i32 (unreachable) (then (i32.const 0) )(else (i32.const 1)))
-  )
-  (func (export "as-if-then") (param i32 i32) (result i32)
-    (if i32 (local.get 0) (then (unreachable) )(else (local.get 1)))
-  )
-  (func (export "as-if-else") (param i32 i32) (result i32)
-    (if i32 (local.get 0) (then (local.get 1) )(else (unreachable)))
-  )
-
-  (func (export "as-select-first") (param i32 i32) (result i32)
-    (select (unreachable) (local.get 0) (local.get 1))
-  )
-  (func (export "as-select-second") (param i32 i32) (result i32)
-    (select (local.get 0) (unreachable) (local.get 1))
-  )
-  (func (export "as-select-cond") (result i32)
-    (select (i32.const 0) (i32.const 1) (unreachable))
-  )
-
-  (func (export "as-call-first")
-    (call $dummy3 (unreachable) (i32.const 2) (i32.const 3))
-  )
-  (func (export "as-call-mid")
-    (call $dummy3 (i32.const 1) (unreachable) (i32.const 3))
-  )
-  (func (export "as-call-last")
-    (call $dummy3 (i32.const 1) (i32.const 2) (unreachable))
-  )
-
-  (type $sig (func (param i32 i32 i32)))
-  (table funcref (elem $dummy3))
-  (func (export "as-call_indirect-func")
-    (call_indirect (type $sig) (unreachable) (i32.const 1) (i32.const 2) (i32.const 3))
-  )
-  (func (export "as-call_indirect-first")
-    (call_indirect (type $sig) (i32.const 0) (unreachable) (i32.const 2) (i32.const 3))
-  )
-  (func (export "as-call_indirect-mid")
-    (call_indirect (type $sig) (i32.const 0) (i32.const 1) (unreachable) (i32.const 3))
-  )
-  (func (export "as-call_indirect-last")
-    (call_indirect (type $sig) (i32.const 0) (i32.const 1) (i32.const 2) (unreachable))
-  )
-
-  (func (export "as-local.set-value") (local f32)
-    (local.set 0 (unreachable))
-  )
-
-  (memory 1)
-  (func (export "as-load-address") (result f32)
-    (f32.load (unreachable))
-  )
-  (func (export "as-loadN-address") (result i64)
-    (i64.load8_s (unreachable))
-  )
-
-  (func (export "as-store-address")
-    (f64.store (unreachable) (f64.const 7))
-  )
-  (func (export "as-store-value")
-    (i64.store (i32.const 2) (unreachable))
-  )
-
-  (func (export "as-storeN-address")
-    (i32.store8 (unreachable) (i32.const 7))
-  )
-  (func (export "as-storeN-value")
-    (i64.store16 (i32.const 2) (unreachable))
-  )
-
-  (func (export "as-unary-operand") (result f32)
-    (f32.neg (unreachable))
-  )
-
-  (func (export "as-binary-left") (result i32)
-    (i32.add (unreachable) (i32.const 10))
-  )
-  (func (export "as-binary-right") (result i64)
-    (i64.sub (i64.const 10) (unreachable))
-  )
-
-  (func (export "as-test-operand") (result i32)
-    (i32.eqz (unreachable))
-  )
-
-  (func (export "as-compare-left") (result i32)
-    (f64.le (unreachable) (f64.const 10))
-  )
-  (func (export "as-compare-right") (result i32)
-    (f32.ne (f32.const 10) (unreachable))
-  )
-
-  (func (export "as-convert-operand") (result i32)
-    (i32.wrap_i64 (unreachable))
-  )
-
-  (func (export "as-memory.grow-size") (result i32)
-    (memory.grow (unreachable))
-  )
-)
-
-(assert_trap (invoke "type-i32") "unreachable")
-(assert_trap (invoke "type-i64") "unreachable")
-(assert_trap (invoke "type-f32") "unreachable")
-(assert_trap (invoke "type-f64") "unreachable")
-
-(assert_trap (invoke "as-func-first") "unreachable")
-(assert_trap (invoke "as-func-mid") "unreachable")
-(assert_trap (invoke "as-func-last") "unreachable")
-(assert_trap (invoke "as-func-value") "unreachable")
-
-(assert_trap (invoke "as-block-first") "unreachable")
-(assert_trap (invoke "as-block-mid") "unreachable")
-(assert_trap (invoke "as-block-last") "unreachable")
-(assert_trap (invoke "as-block-value") "unreachable")
-(assert_return (invoke "as-block-broke") (i32.const 1))
-
-(assert_trap (invoke "as-loop-first") "unreachable")
-(assert_trap (invoke "as-loop-mid") "unreachable")
-(assert_trap (invoke "as-loop-last") "unreachable")
-(assert_return (invoke "as-loop-broke") (i32.const 1))
-
-(assert_trap (invoke "as-br-value") "unreachable")
-
-(assert_trap (invoke "as-br_if-cond") "unreachable")
-(assert_trap (invoke "as-br_if-value") "unreachable")
-(assert_trap (invoke "as-br_if-value-cond") "unreachable")
-
-(assert_trap (invoke "as-br_table-index") "unreachable")
-(assert_trap (invoke "as-br_table-value") "unreachable")
-(assert_trap (invoke "as-br_table-value-index") "unreachable")
-
-(assert_trap (invoke "as-return-value") "unreachable")
-
-(assert_trap (invoke "as-if-cond") "unreachable")
-(assert_trap (invoke "as-if-then" (i32.const 1) (i32.const 6)) "unreachable")
-(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
-(assert_trap (invoke "as-if-else" (i32.const 0) (i32.const 6)) "unreachable")
-(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
-
-(assert_trap (invoke "as-select-first" (i32.const 0) (i32.const 6)) "unreachable")
-(assert_trap (invoke "as-select-first" (i32.const 1) (i32.const 6)) "unreachable")
-(assert_trap (invoke "as-select-second" (i32.const 0) (i32.const 6)) "unreachable")
-(assert_trap (invoke "as-select-second" (i32.const 1) (i32.const 6)) "unreachable")
-(assert_trap (invoke "as-select-cond") "unreachable")
-
-(assert_trap (invoke "as-call-first") "unreachable")
-(assert_trap (invoke "as-call-mid") "unreachable")
-(assert_trap (invoke "as-call-last") "unreachable")
-
-(assert_trap (invoke "as-call_indirect-func") "unreachable")
-(assert_trap (invoke "as-call_indirect-first") "unreachable")
-(assert_trap (invoke "as-call_indirect-mid") "unreachable")
-(assert_trap (invoke "as-call_indirect-last") "unreachable")
-
-(assert_trap (invoke "as-local.set-value") "unreachable")
-
-(assert_trap (invoke "as-load-address") "unreachable")
-(assert_trap (invoke "as-loadN-address") "unreachable")
-
-(assert_trap (invoke "as-store-address") "unreachable")
-(assert_trap (invoke "as-store-value") "unreachable")
-(assert_trap (invoke "as-storeN-address") "unreachable")
-(assert_trap (invoke "as-storeN-value") "unreachable")
-
-(assert_trap (invoke "as-unary-operand") "unreachable")
-
-(assert_trap (invoke "as-binary-left") "unreachable")
-(assert_trap (invoke "as-binary-right") "unreachable")
-
-(assert_trap (invoke "as-test-operand") "unreachable")
-
-(assert_trap (invoke "as-compare-left") "unreachable")
-(assert_trap (invoke "as-compare-right") "unreachable")
-
-(assert_trap (invoke "as-convert-operand") "unreachable")
-
-(assert_trap (invoke "as-memory.grow-size") "unreachable")
-
diff --git a/test/spec/simd.wast b/test/spec/simd.wast
index cec571387..351de4df2 100644
--- a/test/spec/simd.wast
+++ b/test/spec/simd.wast
@@ -297,13 +297,13 @@
 
 ;; i16x8 lane accesses
 (assert_return (invoke "i16x8.splat" (i32.const 5)) (v128.const i16x8 5 5 5 5 5 5 5 5))
-(assert_return (invoke "i16x8.splat" (i32.const 65537)) (v128.const i32x4 1 1 1 1 1 1 1 1))
-(assert_return (invoke "i16x8.extract_lane_s_first" (v128.const i32x4 65535 0 0 0 0 0 0 0)) (i32.const -1))
-(assert_return (invoke "i16x8.extract_lane_s_last" (v128.const i32x4 0 0 0 0 0 0 0 65535)) (i32.const -1))
-(assert_return (invoke "i16x8.extract_lane_u_first" (v128.const i32x4 65535 0 0 0 0 0 0 0)) (i32.const 65535))
-(assert_return (invoke "i16x8.extract_lane_u_last" (v128.const i32x4 0 0 0 0 0 0 0 65535)) (i32.const 65535))
-(assert_return (invoke "i16x8.replace_lane_first" (v128.const i64x2 0 0) (i32.const 7)) (v128.const i32x4 7 0 0 0 0 0 0 0))
-(assert_return (invoke "i16x8.replace_lane_last" (v128.const i64x2 0 0) (i32.const 7)) (v128.const i32x4 0 0 0 0 0 0 0 7))
+(assert_return (invoke "i16x8.splat" (i32.const 65537)) (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extract_lane_s_first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i16x8.extract_lane_s_last" (v128.const i16x8 0 0 0 0 0 0 0 65535)) (i32.const -1))
+(assert_return (invoke "i16x8.extract_lane_u_first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const 65535))
+(assert_return (invoke "i16x8.extract_lane_u_last" (v128.const i16x8 0 0 0 0 0 0 0 65535)) (i32.const 65535))
+(assert_return (invoke "i16x8.replace_lane_first" (v128.const i64x2 0 0) (i32.const 7)) (v128.const i16x8 7 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.replace_lane_last" (v128.const i64x2 0 0) (i32.const 7)) (v128.const i16x8 0 0 0 0 0 0 0 7))
 
 ;; i32x4 lane accesses
 (assert_return (invoke "i32x4.splat" (i32.const -5)) (v128.const i32x4 -5 -5 -5 -5))
@@ -336,144 +336,144 @@
 ;; i8x16 comparisons
 (assert_return
   (invoke "i8x16.eq"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 -1 0 -1 0 0 0 0 0 -1 0 0 -1 0 0 0 0)
+  (v128.const i8x16 -1 0 -1 0 0 0 0 0 -1 0 0 -1 0 0 0 0)
 )
 (assert_return
   (invoke "i8x16.ne"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 0 -1 0 -1 -1 -1 -1 -1 0 -1 -1 0 -1 -1 -1 -1)
+  (v128.const i8x16 0 -1 0 -1 -1 -1 -1 -1 0 -1 -1 0 -1 -1 -1 -1)
 )
 (assert_return
   (invoke "i8x16.lt_s"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 0 0 0 -1 0 -1 -1 0 0 0 -1 0 0 -1 -1 0)
+  (v128.const i8x16 0 0 0 -1 0 -1 -1 0 0 0 -1 0 0 -1 -1 0)
 )
 (assert_return
   (invoke "i8x16.lt_u"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 0 -1 0 0 -1 -1 0 -1 0 -1 0 0 -1 -1 0 -1)
+  (v128.const i8x16 0 -1 0 0 -1 -1 0 -1 0 -1 0 0 -1 -1 0 -1)
 )
 (assert_return
   (invoke "i8x16.gt_s"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 0 -1 0 0 -1 0 0 -1 0 -1 0 0 -1 0 0 -1)
+  (v128.const i8x16 0 -1 0 0 -1 0 0 -1 0 -1 0 0 -1 0 0 -1)
 )
 (assert_return
   (invoke "i8x16.gt_u"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 0 0 0 -1 0 0 -1 0 0 0 -1 0 0 0 -1 0)
+  (v128.const i8x16 0 0 0 -1 0 0 -1 0 0 0 -1 0 0 0 -1 0)
 )
 (assert_return
   (invoke "i8x16.le_s"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 -1 0 -1 -1 0 -1 -1 0 -1 0 -1 -1 0 -1 -1 0)
+  (v128.const i8x16 -1 0 -1 -1 0 -1 -1 0 -1 0 -1 -1 0 -1 -1 0)
 )
 (assert_return
   (invoke "i8x16.le_u"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 -1 -1 -1 0 -1 -1 0 -1 -1 -1 0 -1 -1 -1 0 -1)
+  (v128.const i8x16 -1 -1 -1 0 -1 -1 0 -1 -1 -1 0 -1 -1 -1 0 -1)
 )
 (assert_return
   (invoke "i8x16.ge_s"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 -1 -1 -1 0 -1 0 0 -1 -1 -1 0 -1 -1 0 0 -1)
+  (v128.const i8x16 -1 -1 -1 0 -1 0 0 -1 -1 -1 0 -1 -1 0 0 -1)
 )
 (assert_return
   (invoke "i8x16.ge_u"
-    (v128.const i32x4 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
-    (v128.const i32x4 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
+    (v128.const i8x16 0 127 13 128 1   13  129 42  0 127 255 42  1   13  129 42)
+    (v128.const i8x16 0 255 13 42  129 127 0   128 0 255 13  42  129 127 0   128)
   )
-  (v128.const i32x4 -1 0 -1 -1 0 0 -1 0 -1 0 -1 -1 0 0 -1 0)
+  (v128.const i8x16 -1 0 -1 -1 0 0 -1 0 -1 0 -1 -1 0 0 -1 0)
 )
 
 ;; i16x8 comparisons
 (assert_return (invoke "i16x8.eq"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 -1 0 0 0 0 0 0 0)
+  (v128.const i16x8 -1 0 0 0 0 0 0 0)
 )
 (assert_return
   (invoke "i16x8.ne"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 0 -1 -1 -1 -1 -1 -1 -1)
+  (v128.const i16x8 0 -1 -1 -1 -1 -1 -1 -1)
 )
 (assert_return
   (invoke "i16x8.lt_s"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 0 0 0 -1 0 -1 0 -1)
+  (v128.const i16x8 0 0 0 -1 0 -1 0 -1)
 )
 (assert_return
   (invoke "i16x8.lt_u"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 0 0 0 0 -1 0 -1 0)
+  (v128.const i16x8 0 0 0 0 -1 0 -1 0)
 )
 (assert_return
   (invoke "i16x8.gt_s"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 0 -1 -1 0 -1 0 -1 0)
+  (v128.const i16x8 0 -1 -1 0 -1 0 -1 0)
 )
 (assert_return
   (invoke "i16x8.gt_u"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 0 -1 -1 -1 0 -1 0 -1)
+  (v128.const i16x8 0 -1 -1 -1 0 -1 0 -1)
 )
 (assert_return
   (invoke "i16x8.le_s"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 -1 0 0 -1 0 -1 0 -1)
+  (v128.const i16x8 -1 0 0 -1 0 -1 0 -1)
 )
 (assert_return
   (invoke "i16x8.le_u"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 -1 0 0 0 -1 0 -1 0)
+  (v128.const i16x8 -1 0 0 0 -1 0 -1 0)
 )
 (assert_return
   (invoke "i16x8.ge_s"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 -1 -1 -1 0 -1 0 -1 0)
+  (v128.const i16x8 -1 -1 -1 0 -1 0 -1 0)
 )
 (assert_return
   (invoke "i16x8.ge_u"
-    (v128.const i32x4 0 32767 13 32768 1     32769 42    40000)
-    (v128.const i32x4 0 13    1  32767 32769 42    40000 32767)
+    (v128.const i16x8 0 32767 13 32768 1     32769 42    40000)
+    (v128.const i16x8 0 13    1  32767 32769 42    40000 32767)
   )
-  (v128.const i32x4 -1 -1 -1 -1 0 -1 0 -1)
+  (v128.const i16x8 -1 -1 -1 -1 0 -1 0 -1)
 )
 
 ;; i32x4 comparisons
@@ -498,18 +498,18 @@
 (assert_return (invoke "f32x4.gt" (v128.const f32x4 0 -1 1 0) (v128.const f32x4 0 0 -1 1)) (v128.const i32x4 0 0 -1 0))
 (assert_return (invoke "f32x4.le" (v128.const f32x4 0 -1 1 0) (v128.const f32x4 0 0 -1 1)) (v128.const i32x4 -1 -1 0 -1))
 (assert_return (invoke "f32x4.ge" (v128.const f32x4 0 -1 1 0) (v128.const f32x4 0 0 -1 1)) (v128.const i32x4 -1 0 -1 0))
-(assert_return (invoke "f32x4.eq" (v128.const f32x4 nan 0 nan infinity) (v128.const f32x4 0 nan nan infinity)) (v128.const i32x4 0 0 0 -1))
-(assert_return (invoke "f32x4.ne" (v128.const f32x4 nan 0 nan infinity) (v128.const f32x4 0 nan nan infinity)) (v128.const i32x4 -1 -1 -1 0))
-(assert_return (invoke "f32x4.lt" (v128.const f32x4 nan 0 nan infinity) (v128.const f32x4 0 nan nan infinity)) (v128.const i32x4 0 0 0 0))
-(assert_return (invoke "f32x4.gt" (v128.const f32x4 nan 0 nan infinity) (v128.const f32x4 0 nan nan infinity)) (v128.const i32x4 0 0 0 0))
-(assert_return (invoke "f32x4.le" (v128.const f32x4 nan 0 nan infinity) (v128.const f32x4 0 nan nan infinity)) (v128.const i32x4 0 0 0 -1))
-(assert_return (invoke "f32x4.ge" (v128.const f32x4 nan 0 nan infinity) (v128.const f32x4 0 nan nan infinity)) (v128.const i32x4 0 0 0 -1))
-(assert_return (invoke "f32x4.eq" (v128.const f32x4 -infinity 0 nan -infinity) (v128.const f32x4 0 infinity infinity nan)) (v128.const i32x4 0 0 0 0))
-(assert_return (invoke "f32x4.ne" (v128.const f32x4 -infinity 0 nan -infinity) (v128.const f32x4 0 infinity infinity nan)) (v128.const i32x4 -1 -1 -1 -1))
-(assert_return (invoke "f32x4.lt" (v128.const f32x4 -infinity 0 nan -infinity) (v128.const f32x4 0 infinity infinity nan)) (v128.const i32x4 -1 -1 0 0))
-(assert_return (invoke "f32x4.gt" (v128.const f32x4 -infinity 0 nan -infinity) (v128.const f32x4 0 infinity infinity nan)) (v128.const i32x4 0 0 0 0))
-(assert_return (invoke "f32x4.le" (v128.const f32x4 -infinity 0 nan -infinity) (v128.const f32x4 0 infinity infinity nan)) (v128.const i32x4 -1 -1 0 0))
-(assert_return (invoke "f32x4.ge" (v128.const f32x4 -infinity 0 nan -infinity) (v128.const f32x4 0 infinity infinity nan)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "f32x4.eq" (v128.const f32x4 nan 0 nan inf) (v128.const f32x4 0 nan nan inf)) (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "f32x4.ne" (v128.const f32x4 nan 0 nan inf) (v128.const f32x4 0 nan nan inf)) (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "f32x4.lt" (v128.const f32x4 nan 0 nan inf) (v128.const f32x4 0 nan nan inf)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "f32x4.gt" (v128.const f32x4 nan 0 nan inf) (v128.const f32x4 0 nan nan inf)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "f32x4.le" (v128.const f32x4 nan 0 nan inf) (v128.const f32x4 0 nan nan inf)) (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "f32x4.ge" (v128.const f32x4 nan 0 nan inf) (v128.const f32x4 0 nan nan inf)) (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "f32x4.eq" (v128.const f32x4 -inf 0 nan -inf) (v128.const f32x4 0 inf inf nan)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "f32x4.ne" (v128.const f32x4 -inf 0 nan -inf) (v128.const f32x4 0 inf inf nan)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "f32x4.lt" (v128.const f32x4 -inf 0 nan -inf) (v128.const f32x4 0 inf inf nan)) (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "f32x4.gt" (v128.const f32x4 -inf 0 nan -inf) (v128.const f32x4 0 inf inf nan)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "f32x4.le" (v128.const f32x4 -inf 0 nan -inf) (v128.const f32x4 0 inf inf nan)) (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "f32x4.ge" (v128.const f32x4 -inf 0 nan -inf) (v128.const f32x4 0 inf inf nan)) (v128.const i32x4 0 0 0 0))
 
 ;; f64x2 comparisons
 (assert_return (invoke "f64x2.eq" (v128.const f64x2 0 1) (v128.const f64x2 0 0)) (v128.const i64x2 -1 0))
@@ -518,12 +518,12 @@
 (assert_return (invoke "f64x2.gt" (v128.const f64x2 0 1) (v128.const f64x2 0 0)) (v128.const i64x2 0 -1))
 (assert_return (invoke "f64x2.le" (v128.const f64x2 0 1) (v128.const f64x2 0 0)) (v128.const i64x2 -1 0))
 (assert_return (invoke "f64x2.ge" (v128.const f64x2 0 1) (v128.const f64x2 0 0)) (v128.const i64x2 -1 -1))
-(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan 0) (v128.const f64x2 infinity infinity)) (v128.const i64x2 0 0))
-(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan 0) (v128.const f64x2 infinity infinity)) (v128.const i64x2 -1 -1))
-(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan 0) (v128.const f64x2 infinity infinity)) (v128.const i64x2 0 -1))
-(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan 0) (v128.const f64x2 infinity infinity)) (v128.const i64x2 0 0))
-(assert_return (invoke "f64x2.le" (v128.const f64x2 nan 0) (v128.const f64x2 infinity infinity)) (v128.const i64x2 0 -1))
-(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan 0) (v128.const f64x2 infinity infinity)) (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan 0) (v128.const f64x2 inf inf)) (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan 0) (v128.const f64x2 inf inf)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan 0) (v128.const f64x2 inf inf)) (v128.const i64x2 0 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan 0) (v128.const f64x2 inf inf)) (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan 0) (v128.const f64x2 inf inf)) (v128.const i64x2 0 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan 0) (v128.const f64x2 inf inf)) (v128.const i64x2 0 0))
 
 ;; bitwise operations
 (assert_return (invoke "v128.not" (v128.const i32x4 0 -1 0 -1)) (v128.const i32x4 -1 0 -1 0))
@@ -597,99 +597,99 @@
 (assert_return (invoke "i8x16.abs" (v128.const i8x16 0 1 42 -3 -56 127 -128 -126 0 -1 -42 3 56 -127 -128 126))
   (v128.const i8x16 0 1 42 3 56 127 -128 126 0 1 42 3 56 127 -128 126)
 )
-(assert_return (invoke "i8x16.neg" (v128.const i32x4 0 1 42 -3 -56 127 -128 -126 0 -1 -42 3 56 -127 -128 126))
-  (v128.const i32x4 0 -1 -42 3 56 -127 -128 126 0 1 42 -3 -56 127 -128 -126)
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0 1 42 -3 -56 127 -128 -126 0 -1 -42 3 56 -127 -128 126))
+  (v128.const i8x16 0 -1 -42 3 56 -127 -128 126 0 1 42 -3 -56 127 -128 -126)
 )
-(assert_return (invoke "i8x16.all_true" (v128.const i32x4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 0))
-(assert_return (invoke "i8x16.all_true" (v128.const i32x4 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0)) (i32.const 0))
-(assert_return (invoke "i8x16.all_true" (v128.const i32x4 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1)) (i32.const 0))
-(assert_return (invoke "i8x16.all_true" (v128.const i32x4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0)) (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1)) (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) (i32.const 1))
 (assert_return (invoke "i8x16.bitmask" (v128.const i8x16 -1 0 1 -128 127 -127 0 128 -1 0 1 -128 127 -127 0 128)) (i32.const 43433))
-(assert_return (invoke "i8x16.shl" (v128.const i32x4 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 1))
-  (v128.const i32x4 0 2 4 8 16 32 64 -128 0 6 12 24 48 96 -64 -128)
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 1))
+  (v128.const i8x16 0 2 4 8 16 32 64 -128 0 6 12 24 48 96 -64 -128)
 )
-(assert_return (invoke "i8x16.shl" (v128.const i32x4 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 8))
-  (v128.const i32x4 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64)
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 8))
+  (v128.const i8x16 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64)
 )
-(assert_return (invoke "i8x16.shr_u" (v128.const i32x4 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 1))
-  (v128.const i32x4 0 0 1 2 4 8 16 32 64 1 3 6 12 24 48 96)
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 1))
+  (v128.const i8x16 0 0 1 2 4 8 16 32 64 1 3 6 12 24 48 96)
 )
-(assert_return (invoke "i8x16.shr_u" (v128.const i32x4 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 8))
-  (v128.const i32x4 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64)
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 8))
+  (v128.const i8x16 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64)
 )
-(assert_return (invoke "i8x16.shr_s" (v128.const i32x4 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 1))
-  (v128.const i32x4 0 0 1 2 4 8 16 32 -64 1 3 6 12 24 48 -32)
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 1))
+  (v128.const i8x16 0 0 1 2 4 8 16 32 -64 1 3 6 12 24 48 -32)
 )
-(assert_return (invoke "i8x16.shr_s" (v128.const i32x4 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 8))
-  (v128.const i32x4 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64)
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64) (i32.const 8))
+  (v128.const i8x16 0 1 2 4 8 16 32 64 -128 3 6 12 24 48 96 -64)
 )
 (assert_return
   (invoke "i8x16.add"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
-  (v128.const i32x4 3 17 0 0 0 135 109 46 145 225 48 184 17 249 128 215)
+  (v128.const i8x16 3 17 0 0 0 135 109 46 145 225 48 184 17 249 128 215)
 )
 (assert_return
   (invoke "i8x16.add_sat_s"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
-  (v128.const i32x4 3 17 0 128 0 135 109 46 127 225 48 184 17 249 127 215)
+  (v128.const i8x16 3 17 0 128 0 135 109 46 127 225 48 184 17 249 127 215)
 )
 (assert_return
   (invoke "i8x16.add_sat_u"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
-  (v128.const i32x4 3 255 255 255 255 135 109 46 145 225 255 184 17 255 128 215)
+  (v128.const i8x16 3 255 255 255 255 135 109 46 145 225 255 184 17 255 128 215)
 )
 (assert_return
   (invoke "i8x16.sub"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
-  (v128.const i32x4 253 67 254 0 254 123 159 12 61 167 158 100 17 251 130 187)
+  (v128.const i8x16 253 67 254 0 254 123 159 12 61 167 158 100 17 251 130 187)
 )
 (assert_return
   (invoke "i8x16.sub_sat_s"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
-  (v128.const i32x4 253 67 254 0 127 128 159 12 61 167 158 128 17 251 130 127)
+  (v128.const i8x16 253 67 254 0 127 128 159 12 61 167 158 128 17 251 130 127)
 )
 (assert_return
   (invoke "i8x16.sub_sat_u"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
-  (v128.const i32x4 0 0 254 0 0 123 0 12 61 167 158 100 17 0 0 0)
+  (v128.const i8x16 0 0 254 0 0 123 0 12 61 167 158 100 17 0 0 0)
 )
 (assert_return
   (invoke "i8x16.min_s"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
   (v128.const i8x16 0 231 255 128 129 129 6 17 42 196 231 142 0 250 1 142)
 )
 (assert_return
   (invoke "i8x16.min_u"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
   (v128.const i8x16 0 42 1 128 127 6 6 17 42 29 73 42 0 250 1 73)
 )
 (assert_return
   (invoke "i8x16.max_s"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
   (v128.const i8x16 3 42 1 128 127 6 103 29 103 29 73 42 17 255 127 73)
 )
 (assert_return
   (invoke "i8x16.max_u"
-    (v128.const i32x4 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
-    (v128.const i32x4 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
+    (v128.const i8x16 0  42 255 128 127 129   6 29 103 196 231 142 17 250   1  73)
+    (v128.const i8x16 3 231   1 128 129 6   103 17  42  29  73  42  0 255 127 142)
   )
   (v128.const i8x16 3 231 255 128 129 129 103 29 103 196 231 142 17 255 127 142)
 )
@@ -705,96 +705,96 @@
 (assert_return (invoke "i16x8.abs" (v128.const i16x8 0 1 42 -3 -56 32767 -32768 32766))
   (v128.const i16x8 0 1 42 3 56 32767 -32768 32766)
 )
-(assert_return (invoke "i16x8.neg" (v128.const i32x4 0 1 42 -3 -56 32767 -32768 32766))
-  (v128.const i32x4 0 -1 -42 3 56 -32767 -32768 -32766)
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0 1 42 -3 -56 32767 -32768 32766))
+  (v128.const i16x8 0 -1 -42 3 56 -32767 -32768 -32766)
 )
-(assert_return (invoke "i16x8.all_true" (v128.const i32x4 0 0 0 0 0 0 0 0)) (i32.const 0))
-(assert_return (invoke "i16x8.all_true" (v128.const i32x4 0 0 1 0 0 0 0 0)) (i32.const 0))
-(assert_return (invoke "i16x8.all_true" (v128.const i32x4 1 1 1 1 1 0 1 1)) (i32.const 0))
-(assert_return (invoke "i16x8.all_true" (v128.const i32x4 1 1 1 1 1 1 1 1)) (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 0 0)) (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 1 0 0 0 0 0)) (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 0 1 1)) (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 1 1)) (i32.const 1))
 (assert_return (invoke "i16x8.bitmask" (v128.const i16x8 -1 0 1 -32768 32767 -32767 0 32768)) (i32.const 169))
-(assert_return (invoke "i16x8.shl" (v128.const i32x4 0 8 16 128 256 2048 4096 -32768) (i32.const 1)) (v128.const i32x4 0 16 32 256 512 4096 8192 0))
-(assert_return (invoke "i16x8.shl" (v128.const i32x4 0 8 16 128 256 2048 4096 -32768) (i32.const 16)) (v128.const i32x4 0 8 16 128 256 2048 4096 -32768))
-(assert_return (invoke "i16x8.shr_u" (v128.const i32x4 0 8 16 128 256 2048 4096 -32768) (i32.const 1)) (v128.const i32x4 0 4 8 64 128 1024 2048 16384))
-(assert_return (invoke "i16x8.shr_u" (v128.const i32x4 0 8 16 128 256 2048 4096 -32768) (i32.const 16)) (v128.const i32x4 0 8 16 128 256 2048 4096 -32768))
-(assert_return (invoke "i16x8.shr_s" (v128.const i32x4 0 8 16 128 256 2048 4096 -32768) (i32.const 1)) (v128.const i32x4 0 4 8 64 128 1024 2048 -16384))
-(assert_return (invoke "i16x8.shr_s" (v128.const i32x4 0 8 16 128 256 2048 4096 -32768) (i32.const 16)) (v128.const i32x4 0 8 16 128 256 2048 4096 -32768))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 8 16 128 256 2048 4096 -32768) (i32.const 1)) (v128.const i16x8 0 16 32 256 512 4096 8192 0))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 8 16 128 256 2048 4096 -32768) (i32.const 16)) (v128.const i16x8 0 8 16 128 256 2048 4096 -32768))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 8 16 128 256 2048 4096 -32768) (i32.const 1)) (v128.const i16x8 0 4 8 64 128 1024 2048 16384))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 8 16 128 256 2048 4096 -32768) (i32.const 16)) (v128.const i16x8 0 8 16 128 256 2048 4096 -32768))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 8 16 128 256 2048 4096 -32768) (i32.const 1)) (v128.const i16x8 0 4 8 64 128 1024 2048 -16384))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 8 16 128 256 2048 4096 -32768) (i32.const 16)) (v128.const i16x8 0 8 16 128 256 2048 4096 -32768))
 (assert_return
   (invoke "i16x8.add"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 768 65281 0 0 34560 12288 63744 32768)
+  (v128.const i16x8 768 65281 0 0 34560 12288 63744 32768)
 )
 (assert_return
   (invoke "i16x8.add_sat_s"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 768 65281 32768 0 34560 12288 63744 32767)
+  (v128.const i16x8 768 65281 32768 0 34560 12288 63744 32767)
 )
 (assert_return
   (invoke "i16x8.add_sat_u"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 768 65281 65535 65535 34560 65535 65535 32768)
+  (v128.const i16x8 768 65281 65535 65535 34560 65535 65535 32768)
 )
 (assert_return
   (invoke "i16x8.sub"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 64768 65279 0 65024 31488 40448 64256 32764)
+  (v128.const i16x8 64768 65279 0 65024 31488 40448 64256 32764)
 )
 (assert_return
   (invoke "i16x8.sub_sat_s"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 64768 65279 0 32767 32768 40448 64256 32764)
+  (v128.const i16x8 64768 65279 0 32767 32768 40448 64256 32764)
 )
 (assert_return
   (invoke "i16x8.sub_sat_u"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 0 65279 0 0 31488 40448 0 32764)
+  (v128.const i16x8 0 65279 0 0 31488 40448 0 32764)
 )
 (assert_return
   (invoke "i16x8.mul"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 0 65280 0 0 0 0 0 65532)
+  (v128.const i16x8 0 65280 0 0 0 0 0 65532)
 )
 (assert_return
   (invoke "i16x8.min_s"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 0 65280 32768 33024 33024 59136 64000 2)
+  (v128.const i16x8 0 65280 32768 33024 33024 59136 64000 2)
 )
 (assert_return
   (invoke "i16x8.min_u"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 0 1 32768 32512 1536 18688 64000 2)
+  (v128.const i16x8 0 1 32768 32512 1536 18688 64000 2)
 )
 (assert_return
   (invoke "i16x8.max_s"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 768 1 32768 32512 1536 18688 65280 32766)
+  (v128.const i16x8 768 1 32768 32512 1536 18688 65280 32766)
 )
 (assert_return
   (invoke "i16x8.max_u"
-    (v128.const i32x4 0   65280 32768 32512 33024 59136 64000 32766)
-    (v128.const i32x4 768     1 32768 33024  1536 18688 65280     2)
+    (v128.const i16x8 0   65280 32768 32512 33024 59136 64000 32766)
+    (v128.const i16x8 768     1 32768 33024  1536 18688 65280     2)
   )
-  (v128.const i32x4 768 65280 32768 33024 33024 59136 65280 32766)
+  (v128.const i16x8 768 65280 32768 33024 33024 59136 65280 32766)
 )
 (assert_return
   (invoke "i16x8.avgr_u"
@@ -933,7 +933,7 @@
   (v128.const i32x4 0xffffffff 0x80000001 42 0xc0000000)
 )
 (assert_return
-  (invoke "i32x4.dot_i16x8_s" (v128.const i32x4 0 1 2 3 4 5 6 7) (v128.const i32x4 -1 2 -3 4 5 6 -7 -8))
+  (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 1 2 3 4 5 6 7) (v128.const i16x8 -1 2 -3 4 5 6 -7 -8))
   (v128.const i32x4 2 6 50 -98)
 )
 
@@ -952,45 +952,45 @@
 (assert_return (invoke "i64x2.mul" (v128.const i64x2 2 42) (v128.const i64x2 0x8000000000000001 0)) (v128.const i64x2 2 0))
 
 ;; f32x4 arithmetic
-(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0 nan -infinity 5)) (v128.const f32x4 0 nan infinity 5))
-(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0 nan -infinity 5)) (v128.const f32x4 0 -nan infinity -5))
-(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0 nan infinity 4)) (v128.const f32x4 -0 nan infinity 2))
-(assert_return (invoke "f32x4.add" (v128.const f32x4 nan -nan infinity 42) (v128.const f32x4 42 infinity infinity 1)) (v128.const f32x4 nan nan infinity 43))
-(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan -nan infinity 42) (v128.const f32x4 42 infinity -infinity 1)) (v128.const f32x4 nan nan infinity 41))
-(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan -nan infinity 42) (v128.const f32x4 42 infinity infinity 2)) (v128.const f32x4 nan nan infinity 84))
-(assert_return (invoke "f32x4.div" (v128.const f32x4 nan -nan infinity 42) (v128.const f32x4 42 infinity 2 2)) (v128.const f32x4 nan nan infinity 21))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0 nan -inf 5)) (v128.const f32x4 0 nan inf 5))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0 nan -inf 5)) (v128.const f32x4 0 -nan inf -5))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0 nan inf 4)) (v128.const f32x4 -0 nan inf 2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan -nan inf 42) (v128.const f32x4 42 inf inf 1)) (v128.const f32x4 nan nan inf 43))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan -nan inf 42) (v128.const f32x4 42 inf -inf 1)) (v128.const f32x4 nan nan inf 41))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan -nan inf 42) (v128.const f32x4 42 inf inf 2)) (v128.const f32x4 nan nan inf 84))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan -nan inf 42) (v128.const f32x4 42 inf 2 2)) (v128.const f32x4 nan nan inf 21))
 (assert_return (invoke "f32x4.min" (v128.const f32x4 -0 0 nan 5) (v128.const f32x4 0 -0 5 nan)) (v128.const f32x4 -0 -0 nan nan))
 (assert_return (invoke "f32x4.max" (v128.const f32x4 -0 0 nan 5) (v128.const f32x4 0 -0 5 nan)) (v128.const f32x4 0 0 nan nan))
 (assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0 0 nan 5) (v128.const f32x4 0 -0 5 nan)) (v128.const f32x4 -0 0 nan 5))
 (assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0 0 nan 5) (v128.const f32x4 0 -0 5 nan)) (v128.const f32x4 -0 0 nan 5))
-(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0 0 infinity -infinity)) (v128.const f32x4 -0 0 infinity -infinity))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0 0 inf -inf)) (v128.const f32x4 -0 0 inf -inf))
 (assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan 42 0.5 -0.5)) (v128.const f32x4 nan 42 1 -0))
 (assert_return (invoke "f32x4.ceil" (v128.const f32x4 1.5 -1.5 4.2 -4.2)) (v128.const f32x4 2 -1 5 -4))
-(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0 0 infinity -infinity)) (v128.const f32x4 -0 0 infinity -infinity))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0 0 inf -inf)) (v128.const f32x4 -0 0 inf -inf))
 (assert_return (invoke "f32x4.floor" (v128.const f32x4 nan 42 0.5 -0.5)) (v128.const f32x4 nan 42 0 -1))
 (assert_return (invoke "f32x4.floor" (v128.const f32x4 1.5 -1.5 4.2 -4.2)) (v128.const f32x4 1 -2 4 -5))
-(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0 0 infinity -infinity)) (v128.const f32x4 -0 0 infinity -infinity))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0 0 inf -inf)) (v128.const f32x4 -0 0 inf -inf))
 (assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan 42 0.5 -0.5)) (v128.const f32x4 nan 42 0 -0))
 (assert_return (invoke "f32x4.trunc" (v128.const f32x4 1.5 -1.5 4.2 -4.2)) (v128.const f32x4 1 -1 4 -4))
-(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0 0 infinity -infinity)) (v128.const f32x4 -0 0 infinity -infinity))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0 0 inf -inf)) (v128.const f32x4 -0 0 inf -inf))
 (assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan 42 0.5 -0.5)) (v128.const f32x4 nan 42 0 -0))
 (assert_return (invoke "f32x4.nearest" (v128.const f32x4 1.5 -1.5 4.2 -4.2)) (v128.const f32x4 2 -2 4 -4))
 
 ;; f64x2 arithmetic
 (assert_return (invoke "f64x2.abs" (v128.const f64x2 -0 nan)) (v128.const f64x2 0 nan))
-(assert_return (invoke "f64x2.abs" (v128.const f64x2 -infinity 5)) (v128.const f64x2 infinity 5))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -inf 5)) (v128.const f64x2 inf 5))
 (assert_return (invoke "f64x2.neg" (v128.const f64x2 -0 nan)) (v128.const f64x2 0 -nan))
-(assert_return (invoke "f64x2.neg" (v128.const f64x2 -infinity 5)) (v128.const f64x2 infinity -5))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -inf 5)) (v128.const f64x2 inf -5))
 (assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0 nan)) (v128.const f64x2 -0 nan))
-(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 infinity 4)) (v128.const f64x2 infinity 2))
-(assert_return (invoke "f64x2.add" (v128.const f64x2 nan -nan) (v128.const f64x2 42 infinity)) (v128.const f64x2 nan nan))
-(assert_return (invoke "f64x2.add" (v128.const f64x2 infinity 42) (v128.const f64x2 infinity 1)) (v128.const f64x2 infinity 43))
-(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan -nan) (v128.const f64x2 42 infinity)) (v128.const f64x2 nan nan))
-(assert_return (invoke "f64x2.sub" (v128.const f64x2 infinity 42) (v128.const f64x2 -infinity 1)) (v128.const f64x2 infinity 41))
-(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan -nan) (v128.const f64x2 42 infinity)) (v128.const f64x2 nan nan))
-(assert_return (invoke "f64x2.mul" (v128.const f64x2 infinity 42) (v128.const f64x2 infinity 2)) (v128.const f64x2 infinity 84))
-(assert_return (invoke "f64x2.div" (v128.const f64x2 nan -nan) (v128.const f64x2 42 infinity)) (v128.const f64x2 nan nan))
-(assert_return (invoke "f64x2.div" (v128.const f64x2 infinity 42) (v128.const f64x2 2 2)) (v128.const f64x2 infinity 21))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 inf 4)) (v128.const f64x2 inf 2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan -nan) (v128.const f64x2 42 inf)) (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf 42) (v128.const f64x2 inf 1)) (v128.const f64x2 inf 43))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan -nan) (v128.const f64x2 42 inf)) (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf 42) (v128.const f64x2 -inf 1)) (v128.const f64x2 inf 41))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan -nan) (v128.const f64x2 42 inf)) (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf 42) (v128.const f64x2 inf 2)) (v128.const f64x2 inf 84))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan -nan) (v128.const f64x2 42 inf)) (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf 42) (v128.const f64x2 2 2)) (v128.const f64x2 inf 21))
 (assert_return (invoke "f64x2.min" (v128.const f64x2 -0 0) (v128.const f64x2 0 -0)) (v128.const f64x2 -0 -0))
 (assert_return (invoke "f64x2.min" (v128.const f64x2 nan 5) (v128.const f64x2 5 nan)) (v128.const f64x2 nan nan))
 (assert_return (invoke "f64x2.max" (v128.const f64x2 -0 0) (v128.const f64x2 0 -0)) (v128.const f64x2 0 0))
@@ -1000,25 +1000,25 @@
 (assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0 0) (v128.const f64x2 0 -0)) (v128.const f64x2 -0 0))
 (assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan 5) (v128.const f64x2 5 nan)) (v128.const f64x2 nan 5))
 (assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0 0)) (v128.const f64x2 -0 0))
-(assert_return (invoke "f64x2.ceil" (v128.const f64x2 infinity -infinity)) (v128.const f64x2 infinity -infinity))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 inf -inf)) (v128.const f64x2 inf -inf))
 (assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan 42)) (v128.const f64x2 nan 42))
 (assert_return (invoke "f64x2.ceil" (v128.const f64x2 0.5 -0.5)) (v128.const f64x2 1 -0))
 (assert_return (invoke "f64x2.ceil" (v128.const f64x2 1.5 -1.5)) (v128.const f64x2 2 -1))
 (assert_return (invoke "f64x2.ceil" (v128.const f64x2 4.2 -4.2)) (v128.const f64x2 5 -4))
 (assert_return (invoke "f64x2.floor" (v128.const f64x2 -0 0)) (v128.const f64x2 -0 0))
-(assert_return (invoke "f64x2.floor" (v128.const f64x2 infinity -infinity)) (v128.const f64x2 infinity -infinity))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 inf -inf)) (v128.const f64x2 inf -inf))
 (assert_return (invoke "f64x2.floor" (v128.const f64x2 nan 42)) (v128.const f64x2 nan 42))
 (assert_return (invoke "f64x2.floor" (v128.const f64x2 0.5 -0.5)) (v128.const f64x2 0 -1))
 (assert_return (invoke "f64x2.floor" (v128.const f64x2 1.5 -1.5)) (v128.const f64x2 1 -2))
 (assert_return (invoke "f64x2.floor" (v128.const f64x2 4.2 -4.2)) (v128.const f64x2 4 -5))
 (assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0 0)) (v128.const f64x2 -0 0))
-(assert_return (invoke "f64x2.trunc" (v128.const f64x2 infinity -infinity)) (v128.const f64x2 infinity -infinity))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 inf -inf)) (v128.const f64x2 inf -inf))
 (assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan 42)) (v128.const f64x2 nan 42))
 (assert_return (invoke "f64x2.trunc" (v128.const f64x2 0.5 -0.5)) (v128.const f64x2 0 -0))
 (assert_return (invoke "f64x2.trunc" (v128.const f64x2 1.5 -1.5)) (v128.const f64x2 1 -1))
 (assert_return (invoke "f64x2.trunc" (v128.const f64x2 4.2 -4.2)) (v128.const f64x2 4 -4))
 (assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0 0)) (v128.const f64x2 -0 0))
-(assert_return (invoke "f64x2.nearest" (v128.const f64x2 infinity -infinity)) (v128.const f64x2 infinity -infinity))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 inf -inf)) (v128.const f64x2 inf -inf))
 (assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan 42)) (v128.const f64x2 nan 42))
 (assert_return (invoke "f64x2.nearest" (v128.const f64x2 0.5 -0.5)) (v128.const f64x2 0 -0))
 (assert_return (invoke "f64x2.nearest" (v128.const f64x2 1.5 -1.5)) (v128.const f64x2 2 -2))
@@ -1050,8 +1050,8 @@
 )
 
 ;; conversions
-(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 42 nan infinity -infinity)) (v128.const i32x4 42 0 2147483647 -2147483648))
-(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 42 nan infinity -infinity)) (v128.const i32x4 42 0 4294967295 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 42 nan inf -inf)) (v128.const i32x4 42 0 2147483647 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 42 nan inf -inf)) (v128.const i32x4 42 0 4294967295 0))
 (assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 -1 2147483647 -2147483648)) (v128.const f32x4 0 -1 2147483648 -2147483648))
 (assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 -1 2147483647 -2147483648)) (v128.const f32x4 0 4294967296 2147483648 2147483648))
 (assert_return
diff --git a/test/spec/struct.wast b/test/spec/struct.wast
index 4d86f6538..9939183e6 100644
--- a/test/spec/struct.wast
+++ b/test/spec/struct.wast
@@ -6,10 +6,8 @@
     (type $s1 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1))))
   )
 
-  (rec
-    (func (param (ref $forward)))
-    (type $forward (struct))
-  )
+  (func (param (ref $forward)))
+  (type $forward (struct))
 )
 
 (assert_invalid
diff --git a/test/spec/tags.wast b/test/spec/tags.wast
index aee2aab9c..3b259f417 100644
--- a/test/spec/tags.wast
+++ b/test/spec/tags.wast
@@ -1,6 +1,9 @@
 ;; Test tags
 
 (module
+  (tag $e-import (import "env" "im0") (param i32))
+  (import "env" "im1" (tag (param i32 f32)))
+
   (tag (param i32))
   (tag $e (param i32 f32))
 
@@ -8,9 +11,7 @@
   (tag $e-params1 (param i32) (param f32))
 
   (tag $e-export (export "ex0") (param i32))
-  (tag $e-import (import "env" "im0") (param i32))
 
-  (import "env" "im1" (tag (param i32 f32)))
   (export "ex1" (tag $e))
 )