Bug 1717895 - Vendor latest Wasm spec tests r=rhunt
authorAsumu Takikawa <asumu@igalia.com>
Thu, 02 Sep 2021 15:56:01 +0000
changeset 590847 f6f4514d09bf220c9a0f2fd6abfeec36891ce36a
parent 590846 16701eb6570662d4e1ffb50f6d43db679766130f
child 590848 3b62bd57747f21c800a93da325d999fa5efb3850
push id149091
push userrhunt@eqrion.net
push dateThu, 02 Sep 2021 15:58:37 +0000
treeherderautoland@f6f4514d09bf [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersrhunt
bugs1717895
milestone93.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1717895 - Vendor latest Wasm spec tests r=rhunt Now includes the exception handling proposal test repo in the generate-spectests configuration. Differential Revision: https://phabricator.services.mozilla.com/D123404
js/src/jit-test/etc/wasm/generate-spectests/config-lock.toml
js/src/jit-test/etc/wasm/generate-spectests/config.toml
js/src/jit-test/tests/wasm/spec/exception-handling/directives.txt
js/src/jit-test/tests/wasm/spec/exception-handling/harness/directives.txt
js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js
js/src/jit-test/tests/wasm/spec/exception-handling/rethrow.wast.js
js/src/jit-test/tests/wasm/spec/exception-handling/tag.wast.js
js/src/jit-test/tests/wasm/spec/exception-handling/throw.wast.js
js/src/jit-test/tests/wasm/spec/exception-handling/try_catch.wast.js
js/src/jit-test/tests/wasm/spec/exception-handling/try_delegate.wast.js
js/src/jit-test/tests/wasm/spec/simd/harness/harness.js
js/src/jit-test/tests/wasm/spec/simd/simd_bitwise.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_const.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_conversions.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_f32x4.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_f32x4_arith.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_f32x4_cmp.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_f32x4_pmin_pmax.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_f32x4_rounding.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_i16x8_arith.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_i16x8_sat_arith.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_i32x4_arith.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_i32x4_trunc_sat_f32x4.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_i8x16_arith.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_i8x16_sat_arith.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_lane.wast.js
js/src/jit-test/tests/wasm/spec/simd/simd_splat.wast.js
js/src/jit-test/tests/wasm/spec/spec/const.wast.js
js/src/jit-test/tests/wasm/spec/spec/conversions.wast.js
js/src/jit-test/tests/wasm/spec/spec/f32.wast.js
js/src/jit-test/tests/wasm/spec/spec/f32_bitwise.wast.js
js/src/jit-test/tests/wasm/spec/spec/f32_cmp.wast.js
js/src/jit-test/tests/wasm/spec/spec/float_exprs.wast.js
js/src/jit-test/tests/wasm/spec/spec/harness/harness.js
js/src/jit-test/tests/wasm/spec/threads/const.wast.js
js/src/jit-test/tests/wasm/spec/threads/conversions.wast.js
js/src/jit-test/tests/wasm/spec/threads/harness/harness.js
--- a/js/src/jit-test/etc/wasm/generate-spectests/config-lock.toml
+++ b/js/src/jit-test/etc/wasm/generate-spectests/config-lock.toml
@@ -4,8 +4,12 @@ commit = 'dfdcb81a'
 
 [[repos]]
 name = 'spec'
 commit = 'c9ed6580'
 
 [[repos]]
 name = 'simd'
 commit = '1618b39a'
+
+[[repos]]
+name = 'exception-handling'
+commit = '7fcfe173'
--- a/js/src/jit-test/etc/wasm/generate-spectests/config.toml
+++ b/js/src/jit-test/etc/wasm/generate-spectests/config.toml
@@ -55,8 +55,21 @@ directive = "; skip-if: !wasmThreadsEnab
 [[repos]]
 name = "simd"
 url = "https://github.com/WebAssembly/simd"
 branch = "main"
 parent = "spec"
 # Skip in jit-test when it's not enabled
 directive = "; skip-if: !wasmSimdEnabled()"
 excluded_tests = []
+
+[[repos]]
+name = "exception-handling"
+url = "https://github.com/WebAssembly/exception-handling"
+branch = "master"
+parent = "spec"
+# Skip in jit-test when it's not enabled
+directive = "; --wasm-exceptions; skip-if: !wasmExceptionsEnabled()"
+excluded_tests = [
+  # This gets included due to divergence between the proposal repo and the
+  # upstream spec, it can be removed when the repo is rebased.
+  "global.wast"
+]
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/directives.txt
@@ -0,0 +1,1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); local-include:harness/harness.js; --wasm-exceptions; skip-if: !wasmExceptionsEnabled()
\ No newline at end of file
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/directives.txt
@@ -0,0 +1,1 @@
+|jit-test| skip-if: true
\ No newline at end of file
copy from js/src/jit-test/tests/wasm/spec/spec/harness/harness.js
copy to js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js
--- a/js/src/jit-test/tests/wasm/spec/spec/harness/harness.js
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js
@@ -230,16 +230,26 @@ function assert_malformed(thunk, message
         err instanceof WebAssembly.CompileError ||
         err instanceof WebAssembly.LinkError,
       true,
       `expected a malformed module`,
     );
   }
 }
 
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
 function assert_return(thunk, expected) {
   let results = thunk();
 
   if (results === undefined) {
     results = [];
   } else if (!Array.isArray(results)) {
     results = [results];
   }
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/rethrow.wast.js
@@ -0,0 +1,115 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/rethrow.wast
+
+// ./test/core/rethrow.wast:3
+let $0 = instantiate(`(module
+  (tag $$e0)
+  (tag $$e1)
+
+  (func (export "catch-rethrow-0")
+    (try
+      (do (throw $$e0))
+      (catch $$e0 (rethrow 0))
+    )
+  )
+
+  (func (export "catch-rethrow-1") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $$e0))
+      (catch $$e0
+        (if (i32.eqz (local.get 0)) (then (rethrow 1))) (i32.const 23)
+      )
+    )
+  )
+
+  (func (export "catchall-rethrow-0")
+    (try
+      (do (throw $$e0))
+      (catch_all (rethrow 0))
+    )
+  )
+
+  (func (export "catchall-rethrow-1") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $$e0))
+      (catch_all
+        (if (i32.eqz (local.get 0)) (then (rethrow 1))) (i32.const 23)
+      )
+    )
+  )
+
+  (func (export "rethrow-nested") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $$e1))
+      (catch $$e1
+        (try (result i32)
+          (do (throw $$e0))
+          (catch $$e0
+            (if (i32.eq (local.get 0) (i32.const 0)) (then (rethrow 1)))
+            (if (i32.eq (local.get 0) (i32.const 1)) (then (rethrow 2)))
+            (i32.const 23)
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "rethrow-recatch") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $$e0))
+      (catch $$e0
+        (try (result i32)
+         (do (if (i32.eqz (local.get 0)) (then (rethrow 2))) (i32.const 42))
+         (catch $$e0 (i32.const 23))
+        )
+      )
+    )
+  )
+)`);
+
+// ./test/core/rethrow.wast:68
+assert_exception(() => invoke($0, `catch-rethrow-0`, []));
+
+// ./test/core/rethrow.wast:70
+assert_exception(() => invoke($0, `catch-rethrow-1`, [0]));
+
+// ./test/core/rethrow.wast:71
+assert_return(() => invoke($0, `catch-rethrow-1`, [1]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:73
+assert_exception(() => invoke($0, `catchall-rethrow-0`, []));
+
+// ./test/core/rethrow.wast:75
+assert_exception(() => invoke($0, `catchall-rethrow-1`, [0]));
+
+// ./test/core/rethrow.wast:76
+assert_return(() => invoke($0, `catchall-rethrow-1`, [1]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:77
+assert_exception(() => invoke($0, `rethrow-nested`, [0]));
+
+// ./test/core/rethrow.wast:78
+assert_exception(() => invoke($0, `rethrow-nested`, [1]));
+
+// ./test/core/rethrow.wast:79
+assert_return(() => invoke($0, `rethrow-nested`, [2]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:81
+assert_return(() => invoke($0, `rethrow-recatch`, [0]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:82
+assert_return(() => invoke($0, `rethrow-recatch`, [1]), [value("i32", 42)]);
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/tag.wast.js
@@ -0,0 +1,40 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/tag.wast
+
+// ./test/core/tag.wast:3
+let $0 = instantiate(`(module
+  (tag)
+  (tag (param i32))
+  (tag (export "t2") (param i32))
+  (tag $$t3 (param i32 f32))
+  (export "t3" (tag 3))
+)`);
+
+// ./test/core/tag.wast:11
+register($0, `test`);
+
+// ./test/core/tag.wast:13
+let $1 = instantiate(`(module
+  (tag $$t0 (import "test" "t2") (param i32))
+  (import "test" "t3" (tag $$t1 (param i32 f32)))
+)`);
+
+// ./test/core/tag.wast:18
+assert_invalid(
+  () => instantiate(`(module (tag (result i32)))`),
+  `non-empty tag result type`,
+);
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/throw.wast.js
@@ -0,0 +1,72 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/throw.wast
+
+// ./test/core/throw.wast:3
+let $0 = instantiate(`(module
+  (tag $$e0)
+  (tag $$e-i32 (param i32))
+  (tag $$e-f32 (param f32))
+  (tag $$e-i64 (param i64))
+  (tag $$e-f64 (param f64))
+  (tag $$e-i32-i32 (param i32 i32))
+
+  (func $$throw-if (export "throw-if") (param i32) (result i32)
+    (local.get 0)
+    (i32.const 0) (if (i32.ne) (then (throw $$e0)))
+    (i32.const 0)
+  )
+
+  (func (export "throw-param-f32") (param f32) (local.get 0) (throw $$e-f32))
+
+  (func (export "throw-param-i64") (param i64) (local.get 0) (throw $$e-i64))
+
+  (func (export "throw-param-f64") (param f64) (local.get 0) (throw $$e-f64))
+
+  (func $$throw-1-2 (i32.const 1) (i32.const 2) (throw $$e-i32-i32))
+  (func (export "test-throw-1-2")
+    (try
+      (do (call $$throw-1-2))
+      (catch $$e-i32-i32
+        (i32.const 2)
+        (if (i32.ne) (then (unreachable)))
+        (i32.const 1)
+        (if (i32.ne) (then (unreachable)))
+      )
+    )
+  )
+)`);
+
+// ./test/core/throw.wast:37
+assert_return(() => invoke($0, `throw-if`, [0]), [value("i32", 0)]);
+
+// ./test/core/throw.wast:38
+assert_exception(() => invoke($0, `throw-if`, [10]));
+
+// ./test/core/throw.wast:39
+assert_exception(() => invoke($0, `throw-if`, [-1]));
+
+// ./test/core/throw.wast:41
+assert_exception(() => invoke($0, `throw-param-f32`, [value("f32", 5)]));
+
+// ./test/core/throw.wast:42
+assert_exception(() => invoke($0, `throw-param-i64`, [5n]));
+
+// ./test/core/throw.wast:43
+assert_exception(() => invoke($0, `throw-param-f64`, [value("f64", 5)]));
+
+// ./test/core/throw.wast:45
+assert_return(() => invoke($0, `test-throw-1-2`, []), []);
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/try_catch.wast.js
@@ -0,0 +1,284 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/try_catch.wast
+
+// ./test/core/try_catch.wast:3
+let $0 = instantiate(`(module
+  (tag $$e0 (export "e0"))
+  (func (export "throw") (throw $$e0))
+)`);
+
+// ./test/core/try_catch.wast:8
+register($0, `test`);
+
+// ./test/core/try_catch.wast:10
+let $1 = instantiate(`(module
+  (tag $$imported-e0 (import "test" "e0"))
+  (func $$imported-throw (import "test" "throw"))
+  (tag $$e0)
+  (tag $$e1)
+  (tag $$e2)
+  (tag $$e-i32 (param i32))
+  (tag $$e-f32 (param f32))
+  (tag $$e-i64 (param i64))
+  (tag $$e-f64 (param f64))
+
+  (func $$throw-if (param i32) (result i32)
+    (local.get 0)
+    (i32.const 0) (if (i32.ne) (then (throw $$e0)))
+    (i32.const 0)
+  )
+
+  (func (export "empty-catch") (try (do) (catch $$e0)))
+
+  (func (export "simple-throw-catch") (param i32) (result i32)
+    (try (result i32)
+      (do (local.get 0) (i32.eqz) (if (then (throw $$e0)) (else)) (i32.const 42))
+      (catch $$e0 (i32.const 23))
+    )
+  )
+
+  (func (export "unreachable-not-caught") (try (do (unreachable)) (catch_all)))
+
+  (func $$div (param i32 i32) (result i32)
+    (local.get 0) (local.get 1) (i32.div_u)
+  )
+  (func (export "trap-in-callee") (param i32 i32) (result i32)
+    (try (result i32)
+      (do (local.get 0) (local.get 1) (call $$div))
+      (catch_all (i32.const 11))
+    )
+  )
+
+  (func (export "catch-complex-1") (param i32) (result i32)
+    (try (result i32)
+      (do
+        (try (result i32)
+          (do
+            (local.get 0)
+            (i32.eqz)
+            (if
+              (then (throw $$e0))
+              (else
+                (local.get 0)
+                (i32.const 1)
+                (i32.eq)
+                (if (then (throw $$e1)) (else (throw $$e2)))
+              )
+            )
+            (i32.const 2)
+          )
+          (catch $$e0 (i32.const 3))
+        )
+      )
+      (catch $$e1 (i32.const 4))
+    )
+  )
+
+  (func (export "catch-complex-2") (param i32) (result i32)
+    (try (result i32)
+      (do
+        (local.get 0)
+        (i32.eqz)
+        (if
+          (then (throw $$e0))
+          (else
+            (local.get 0)
+            (i32.const 1)
+            (i32.eq)
+            (if (then (throw $$e1)) (else (throw $$e2)))
+          )
+        )
+        (i32.const 2)
+      )
+      (catch $$e0 (i32.const 3))
+      (catch $$e1 (i32.const 4))
+    )
+  )
+
+  (func (export "throw-catch-param-i32") (param i32) (result i32)
+    (try (result i32)
+      (do (local.get 0) (throw $$e-i32) (i32.const 2))
+      (catch $$e-i32 (return))
+    )
+  )
+
+  (func (export "throw-catch-param-f32") (param f32) (result f32)
+    (try (result f32)
+      (do (local.get 0) (throw $$e-f32) (f32.const 0))
+      (catch $$e-f32 (return))
+    )
+  )
+
+  (func (export "throw-catch-param-i64") (param i64) (result i64)
+    (try (result i64)
+      (do (local.get 0) (throw $$e-i64) (i64.const 2))
+      (catch $$e-i64 (return))
+    )
+  )
+
+  (func (export "throw-catch-param-f64") (param f64) (result f64)
+    (try (result f64)
+      (do (local.get 0) (throw $$e-f64) (f64.const 0))
+      (catch $$e-f64 (return))
+    )
+  )
+
+  (func $$throw-param-i32 (param i32) (local.get 0) (throw $$e-i32))
+  (func (export "catch-param-i32") (param i32) (result i32)
+    (try (result i32)
+      (do (i32.const 0) (local.get 0) (call $$throw-param-i32))
+      (catch $$e-i32)
+    )
+  )
+
+  (func (export "catch-imported") (result i32)
+    (try (result i32)
+      (do
+        (i32.const 1)
+        (call $$imported-throw)
+      )
+      (catch $$imported-e0 (i32.const 2))
+    )
+  )
+
+  (func (export "catchless-try") (param i32) (result i32)
+    (try (result i32)
+      (do
+        (try (result i32)
+          (do (local.get 0) (call $$throw-if))
+        )
+      )
+      (catch $$e0 (i32.const 1))
+    )
+  )
+)`);
+
+// ./test/core/try_catch.wast:152
+assert_return(() => invoke($1, `empty-catch`, []), []);
+
+// ./test/core/try_catch.wast:154
+assert_return(() => invoke($1, `simple-throw-catch`, [0]), [value("i32", 23)]);
+
+// ./test/core/try_catch.wast:155
+assert_return(() => invoke($1, `simple-throw-catch`, [1]), [value("i32", 42)]);
+
+// ./test/core/try_catch.wast:157
+assert_exception(() => invoke($1, `unreachable-not-caught`, []));
+
+// ./test/core/try_catch.wast:159
+assert_return(() => invoke($1, `trap-in-callee`, [7, 2]), [value("i32", 3)]);
+
+// ./test/core/try_catch.wast:160
+assert_exception(() => invoke($1, `trap-in-callee`, [1, 0]));
+
+// ./test/core/try_catch.wast:162
+assert_return(() => invoke($1, `catch-complex-1`, [0]), [value("i32", 3)]);
+
+// ./test/core/try_catch.wast:163
+assert_return(() => invoke($1, `catch-complex-1`, [1]), [value("i32", 4)]);
+
+// ./test/core/try_catch.wast:164
+assert_exception(() => invoke($1, `catch-complex-1`, [2]));
+
+// ./test/core/try_catch.wast:166
+assert_return(() => invoke($1, `catch-complex-2`, [0]), [value("i32", 3)]);
+
+// ./test/core/try_catch.wast:167
+assert_return(() => invoke($1, `catch-complex-2`, [1]), [value("i32", 4)]);
+
+// ./test/core/try_catch.wast:168
+assert_exception(() => invoke($1, `catch-complex-2`, [2]));
+
+// ./test/core/try_catch.wast:170
+assert_return(() => invoke($1, `throw-catch-param-i32`, [0]), [
+  value("i32", 0),
+]);
+
+// ./test/core/try_catch.wast:171
+assert_return(() => invoke($1, `throw-catch-param-i32`, [1]), [
+  value("i32", 1),
+]);
+
+// ./test/core/try_catch.wast:172
+assert_return(() => invoke($1, `throw-catch-param-i32`, [10]), [
+  value("i32", 10),
+]);
+
+// ./test/core/try_catch.wast:174
+assert_return(() => invoke($1, `throw-catch-param-f32`, [value("f32", 5)]), [
+  value("f32", 5),
+]);
+
+// ./test/core/try_catch.wast:175
+assert_return(() => invoke($1, `throw-catch-param-f32`, [value("f32", 10.5)]), [
+  value("f32", 10.5),
+]);
+
+// ./test/core/try_catch.wast:177
+assert_return(() => invoke($1, `throw-catch-param-i64`, [5n]), [
+  value("i64", 5n),
+]);
+
+// ./test/core/try_catch.wast:178
+assert_return(() => invoke($1, `throw-catch-param-i64`, [0n]), [
+  value("i64", 0n),
+]);
+
+// ./test/core/try_catch.wast:179
+assert_return(() => invoke($1, `throw-catch-param-i64`, [-1n]), [
+  value("i64", -1n),
+]);
+
+// ./test/core/try_catch.wast:181
+assert_return(() => invoke($1, `throw-catch-param-f64`, [value("f64", 5)]), [
+  value("f64", 5),
+]);
+
+// ./test/core/try_catch.wast:182
+assert_return(() => invoke($1, `throw-catch-param-f64`, [value("f64", 10.5)]), [
+  value("f64", 10.5),
+]);
+
+// ./test/core/try_catch.wast:184
+assert_return(() => invoke($1, `catch-param-i32`, [5]), [value("i32", 5)]);
+
+// ./test/core/try_catch.wast:186
+assert_return(() => invoke($1, `catch-imported`, []), [value("i32", 2)]);
+
+// ./test/core/try_catch.wast:188
+assert_return(() => invoke($1, `catchless-try`, [0]), [value("i32", 0)]);
+
+// ./test/core/try_catch.wast:189
+assert_return(() => invoke($1, `catchless-try`, [1]), [value("i32", 1)]);
+
+// ./test/core/try_catch.wast:191
+assert_malformed(
+  () => instantiate(`(module (func (catch_all))) `),
+  `unexpected token`,
+);
+
+// ./test/core/try_catch.wast:196
+assert_malformed(
+  () => instantiate(`(module (tag $$e) (func (catch $$e))) `),
+  `unexpected token`,
+);
+
+// ./test/core/try_catch.wast:201
+assert_malformed(
+  () => instantiate(`(module (func (try (do) (catch_all) (catch_all)))) `),
+  `unexpected token`,
+);
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/try_delegate.wast.js
@@ -0,0 +1,154 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/try_delegate.wast
+
+// ./test/core/try_delegate.wast:3
+let $0 = instantiate(`(module
+  (tag $$e0)
+  (tag $$e1)
+
+  (func (export "delegate-no-throw") (result i32)
+    (try $$t (result i32)
+      (do (try (result i32) (do (i32.const 1)) (delegate $$t)))
+      (catch $$e0 (i32.const 2))
+    )
+  )
+
+  (func $$throw-if (param i32)
+    (local.get 0)
+    (if (then (throw $$e0)) (else))
+  )
+
+  (func (export "delegate-throw") (param i32) (result i32)
+    (try $$t (result i32)
+      (do
+        (try (result i32)
+          (do (local.get 0) (call $$throw-if) (i32.const 1))
+          (delegate $$t)
+        )
+      )
+      (catch $$e0 (i32.const 2))
+    )
+  )
+
+  (func (export "delegate-skip") (result i32)
+    (try $$t (result i32)
+      (do
+        (try (result i32)
+          (do
+            (try (result i32)
+              (do (throw $$e0) (i32.const 1))
+              (delegate $$t)
+            )
+          )
+          (catch $$e0 (i32.const 2))
+        )
+      )
+      (catch $$e0 (i32.const 3))
+    )
+  )
+
+  (func (export "delegate-to-caller")
+    (try (do (try (do (throw $$e0)) (delegate 1))) (catch_all))
+  )
+
+  (func $$select-tag (param i32)
+    (block (block (block (local.get 0) (br_table 0 1 2)) (return)) (throw $$e0))
+    (throw $$e1)
+  )
+
+  (func (export "delegate-merge") (param i32 i32) (result i32)
+    (try $$t (result i32)
+      (do
+        (local.get 0)
+        (call $$select-tag)
+        (try
+          (result i32)
+          (do (local.get 1) (call $$select-tag) (i32.const 1))
+          (delegate $$t)
+        )
+      )
+      (catch $$e0 (i32.const 2))
+    )
+  )
+
+  (func (export "delegate-throw-no-catch") (result i32)
+    (try (result i32)
+      (do (try (result i32) (do (throw $$e0) (i32.const 1)) (delegate 0)))
+      (catch $$e1 (i32.const 2))
+    )
+  )
+)`);
+
+// ./test/core/try_delegate.wast:80
+assert_return(() => invoke($0, `delegate-no-throw`, []), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:82
+assert_return(() => invoke($0, `delegate-throw`, [0]), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:83
+assert_return(() => invoke($0, `delegate-throw`, [1]), [value("i32", 2)]);
+
+// ./test/core/try_delegate.wast:85
+assert_exception(() => invoke($0, `delegate-throw-no-catch`, []));
+
+// ./test/core/try_delegate.wast:87
+assert_return(() => invoke($0, `delegate-merge`, [1, 0]), [value("i32", 2)]);
+
+// ./test/core/try_delegate.wast:88
+assert_exception(() => invoke($0, `delegate-merge`, [2, 0]));
+
+// ./test/core/try_delegate.wast:89
+assert_return(() => invoke($0, `delegate-merge`, [0, 1]), [value("i32", 2)]);
+
+// ./test/core/try_delegate.wast:90
+assert_exception(() => invoke($0, `delegate-merge`, [0, 2]));
+
+// ./test/core/try_delegate.wast:91
+assert_return(() => invoke($0, `delegate-merge`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:93
+assert_return(() => invoke($0, `delegate-skip`, []), [value("i32", 3)]);
+
+// ./test/core/try_delegate.wast:95
+assert_exception(() => invoke($0, `delegate-to-caller`, []));
+
+// ./test/core/try_delegate.wast:97
+assert_malformed(
+  () => instantiate(`(module (func (delegate 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/try_delegate.wast:102
+assert_malformed(
+  () =>
+    instantiate(
+      `(module (tag $$e) (func (try (do) (catch $$e) (delegate 0)))) `,
+    ),
+  `unexpected token`,
+);
+
+// ./test/core/try_delegate.wast:107
+assert_malformed(
+  () => instantiate(`(module (func (try (do) (catch_all) (delegate 0)))) `),
+  `unexpected token`,
+);
+
+// ./test/core/try_delegate.wast:112
+assert_malformed(
+  () => instantiate(`(module (func (try (do) (delegate) (delegate 0)))) `),
+  `unexpected token`,
+);
--- a/js/src/jit-test/tests/wasm/spec/simd/harness/harness.js
+++ b/js/src/jit-test/tests/wasm/spec/simd/harness/harness.js
@@ -230,16 +230,26 @@ function assert_malformed(thunk, message
         err instanceof WebAssembly.CompileError ||
         err instanceof WebAssembly.LinkError,
       true,
       `expected a malformed module`,
     );
   }
 }
 
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
 function assert_return(thunk, expected) {
   let results = thunk();
 
   if (results === undefined) {
     results = [];
   } else if (!Array.isArray(results)) {
     results = [results];
   }
--- a/js/src/jit-test/tests/wasm/spec/simd/simd_bitwise.wast.js
+++ b/js/src/jit-test/tests/wasm/spec/simd/simd_bitwise.wast.js
@@ -1543,20 +1543,20 @@ assert_return(
         0x0,
         0x0,
         0xc0,
         0x7f,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_bitwise.wast:307
 assert_return(
   () =>
     invoke($0, `xor`, [
@@ -2184,20 +2184,20 @@ assert_return(
         0x0,
         0x0,
         0xc0,
         0x7f,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_bitwise.wast:377
 assert_return(
   () =>
     invoke($0, `andnot`, [
--- a/js/src/jit-test/tests/wasm/spec/simd/simd_const.wast.js
+++ b/js/src/jit-test/tests/wasm/spec/simd/simd_const.wast.js
@@ -1546,20 +1546,20 @@ assert_return(() => invoke($137, `f`, []
 // ./test/core/simd/simd_const.wast:547
 let $138 = instantiate(
   `(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126)))`,
 );
 
 // ./test/core/simd/simd_const.wast:548
 assert_return(() => invoke($138, `f`, []), [
   new F32x4Pattern(
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+    value("f32", -0),
+    value("f32", -0),
+    value("f32", -0),
+    value("f32", -0),
   ),
 ]);
 
 // ./test/core/simd/simd_const.wast:549
 let $139 = instantiate(
   `(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126)))`,
 );
 
--- a/js/src/jit-test/tests/wasm/spec/simd/simd_conversions.wast.js
+++ b/js/src/jit-test/tests/wasm/spec/simd/simd_conversions.wast.js
@@ -48,37 +48,17 @@ let $0 = instantiate(`(module
 // ./test/core/simd/simd_conversions.wast:35
 assert_return(
   () => invoke($0, `f64x2.promote_low_f32x4`, [f32x4([0, 0, 0, 0])]),
   [new F64x2Pattern(value("f64", 0), value("f64", 0))],
 );
 
 // ./test/core/simd/simd_conversions.wast:37
 assert_return(
-  () =>
-    invoke($0, `f64x2.promote_low_f32x4`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f64x2.promote_low_f32x4`, [f32x4([-0, -0, -0, -0])]),
   [new F64x2Pattern(value("f64", -0), value("f64", -0))],
 );
 
 // ./test/core/simd/simd_conversions.wast:39
 assert_return(
   () =>
     invoke($0, `f64x2.promote_low_f32x4`, [
       f32x4([
@@ -345,18 +325,18 @@ assert_return(() => invoke($0, `f32x4.de
     value("f32", 0),
     value("f32", 0),
   ),
 ]);
 
 // ./test/core/simd/simd_conversions.wast:75
 assert_return(() => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([-0, -0])]), [
   new F32x4Pattern(
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+    value("f32", -0),
+    value("f32", -0),
     value("f32", 0),
     value("f32", 0),
   ),
 ]);
 
 // ./test/core/simd/simd_conversions.wast:77
 assert_return(
   () =>
@@ -382,18 +362,18 @@ assert_return(
     invoke($0, `f32x4.demote_f64x2_zero`, [
       f64x2([
         -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
         -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_conversions.wast:81
 assert_return(() => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([1, 1])]), [
@@ -1202,18 +1182,18 @@ assert_return(
     invoke($0, `f32x4.demote_f64x2_zero`, [
       f64x2([
         -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
         -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_conversions.wast:169
 assert_return(
@@ -1240,18 +1220,18 @@ assert_return(
     invoke($0, `f32x4.demote_f64x2_zero`, [
       f64x2([
         -0.0000000000000000000000000000000000000000000007006492321624085,
         -0.0000000000000000000000000000000000000000000007006492321624085,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_conversions.wast:173
 assert_return(
--- a/js/src/jit-test/tests/wasm/spec/simd/simd_f32x4.wast.js
+++ b/js/src/jit-test/tests/wasm/spec/simd/simd_f32x4.wast.js
@@ -452,44 +452,23 @@ assert_return(
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:100
 assert_return(
-  () =>
-    invoke($0, `f32x4.min`, [
-      f32x4([0, 0, 0, 0]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.min`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:103
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
@@ -743,160 +722,68 @@ assert_return(
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:145
 assert_return(
-  () =>
-    invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0, 0, 0, 0]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:148
 assert_return(
   () =>
-    invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+    invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:151
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        0.000000000000000000000000000000000000000000001,
-        0.000000000000000000000000000000000000000000001,
-        0.000000000000000000000000000000000000000000001,
-        0.000000000000000000000000000000000000000000001,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        0.000000000000000000000000000000000000000000001,
+        0.000000000000000000000000000000000000000000001,
+        0.000000000000000000000000000000000000000000001,
+        0.000000000000000000000000000000000000000000001,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:154
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
@@ -908,73 +795,39 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:157
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        0.000000000000000000000000000000000000011754944,
-        0.000000000000000000000000000000000000011754944,
-        0.000000000000000000000000000000000000011754944,
-        0.000000000000000000000000000000000000011754944,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        0.000000000000000000000000000000000000011754944,
+        0.000000000000000000000000000000000000011754944,
+        0.000000000000000000000000000000000000011754944,
+        0.000000000000000000000000000000000000011754944,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:160
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
@@ -986,277 +839,134 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:163
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0.5, 0.5, 0.5, 0.5]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([0.5, 0.5, 0.5, 0.5]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:166
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-0.5, -0.5, -0.5, -0.5]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:169
 assert_return(
-  () =>
-    invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([1, 1, 1, 1]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:172
 assert_return(
   () =>
-    invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([-1, -1, -1, -1]),
-    ]),
+    invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
   [
     new F32x4Pattern(
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:175
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:178
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:181
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        340282350000000000000000000000000000000,
-        340282350000000000000000000000000000000,
-        340282350000000000000000000000000000000,
-        340282350000000000000000000000000000000,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        340282350000000000000000000000000000000,
+        340282350000000000000000000000000000000,
+        340282350000000000000000000000000000000,
+        340282350000000000000000000000000000000,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:184
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
     ]),
   [
@@ -1268,68 +978,34 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:187
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([Infinity, Infinity, Infinity, Infinity]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([Infinity, Infinity, Infinity, Infinity]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:190
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
@@ -1364,41 +1040,24 @@ assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:199
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
@@ -1763,34 +1422,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.000000000000000000000000000000000000000000001),
       value("f32", -0.000000000000000000000000000000000000000000001),
       value("f32", -0.000000000000000000000000000000000000000000001),
       value("f32", -0.000000000000000000000000000000000000000000001),
     ),
@@ -2162,41 +1804,24 @@ assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:295
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
@@ -2561,34 +2186,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.000000000000000000000000000000000000011754944),
       value("f32", -0.000000000000000000000000000000000000011754944),
       value("f32", -0.000000000000000000000000000000000000011754944),
       value("f32", -0.000000000000000000000000000000000000011754944),
     ),
@@ -2947,41 +2555,24 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:388
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([0.5, 0.5, 0.5, 0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:391
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
@@ -3263,34 +2854,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:436
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([-0.5, -0.5, -0.5, -0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
     ),
@@ -3575,44 +3149,23 @@ assert_return(
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:484
 assert_return(
-  () =>
-    invoke($0, `f32x4.min`, [
-      f32x4([1, 1, 1, 1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.min`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:487
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
@@ -3880,37 +3433,17 @@ assert_return(
       value("f32", -1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:532
 assert_return(
   () =>
-    invoke($0, `f32x4.min`, [
-      f32x4([-1, -1, -1, -1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+    invoke($0, `f32x4.min`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
     ),
   ],
@@ -4194,41 +3727,24 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:580
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:583
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
@@ -4513,34 +4029,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:628
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
     ),
@@ -4842,41 +4341,24 @@ assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:679
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
@@ -5241,34 +4723,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -340282350000000000000000000000000000000),
       value("f32", -340282350000000000000000000000000000000),
       value("f32", -340282350000000000000000000000000000000),
       value("f32", -340282350000000000000000000000000000000),
     ),
@@ -5630,41 +5095,24 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:772
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([Infinity, Infinity, Infinity, Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:775
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
@@ -5949,34 +5397,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:820
 assert_return(
   () =>
     invoke($0, `f32x4.min`, [
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
@@ -6927,34 +6358,17 @@ assert_return(
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
@@ -7722,34 +7136,17 @@ assert_return(
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
@@ -8517,34 +7914,17 @@ assert_return(
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
@@ -9312,34 +8692,17 @@ assert_return(
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
@@ -10066,38 +9429,17 @@ assert_return(
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1183
 assert_return(
-  () =>
-    invoke($0, `f32x4.max`, [
-      f32x4([0, 0, 0, 0]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f32x4.max`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
@@ -10357,121 +9699,46 @@ assert_return(
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1228
 assert_return(
-  () =>
-    invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0, 0, 0, 0]),
-    ]),
+  () => invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1231
 assert_return(
   () =>
-    invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+    invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1234
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
@@ -10483,73 +9750,39 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1237
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        -0.000000000000000000000000000000000000000000001,
-        -0.000000000000000000000000000000000000000000001,
-        -0.000000000000000000000000000000000000000000001,
-        -0.000000000000000000000000000000000000000000001,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        -0.000000000000000000000000000000000000000000001,
+        -0.000000000000000000000000000000000000000000001,
+        -0.000000000000000000000000000000000000000000001,
+        -0.000000000000000000000000000000000000000000001,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1240
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
@@ -10561,277 +9794,134 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1243
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        -0.000000000000000000000000000000000000011754944,
-        -0.000000000000000000000000000000000000011754944,
-        -0.000000000000000000000000000000000000011754944,
-        -0.000000000000000000000000000000000000011754944,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        -0.000000000000000000000000000000000000011754944,
+        -0.000000000000000000000000000000000000011754944,
+        -0.000000000000000000000000000000000000011754944,
+        -0.000000000000000000000000000000000000011754944,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1246
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([0.5, 0.5, 0.5, 0.5]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1249
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([-0.5, -0.5, -0.5, -0.5]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([-0.5, -0.5, -0.5, -0.5]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1252
 assert_return(
-  () =>
-    invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([1, 1, 1, 1]),
-    ]),
+  () => invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
   [
     new F32x4Pattern(
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1255
 assert_return(
   () =>
-    invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([-1, -1, -1, -1]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+    invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1258
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1261
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1264
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
     ]),
   [
@@ -10843,115 +9933,64 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1267
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        -340282350000000000000000000000000000000,
-        -340282350000000000000000000000000000000,
-        -340282350000000000000000000000000000000,
-        -340282350000000000000000000000000000000,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        -340282350000000000000000000000000000000,
+        -340282350000000000000000000000000000000,
+        -340282350000000000000000000000000000000,
+        -340282350000000000000000000000000000000,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1270
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1273
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1276
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
@@ -10978,34 +10017,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.000000000000000000000000000000000000000000001),
       value("f32", 0.000000000000000000000000000000000000000000001),
       value("f32", 0.000000000000000000000000000000000000000000001),
       value("f32", 0.000000000000000000000000000000000000000000001),
     ),
@@ -11377,41 +10399,24 @@ assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1330
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
@@ -11776,34 +10781,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.000000000000000000000000000000000000011754944),
       value("f32", 0.000000000000000000000000000000000000011754944),
       value("f32", 0.000000000000000000000000000000000000011754944),
       value("f32", 0.000000000000000000000000000000000000011754944),
     ),
@@ -12175,41 +11163,24 @@ assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1426
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
@@ -12561,34 +11532,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1471
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([0.5, 0.5, 0.5, 0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
     ),
@@ -12877,41 +11831,24 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1519
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([-0.5, -0.5, -0.5, -0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1522
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
@@ -13189,38 +12126,17 @@ assert_return(
       value("f32", 1),
       value("f32", 1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1567
 assert_return(
-  () =>
-    invoke($0, `f32x4.max`, [
-      f32x4([1, 1, 1, 1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f32x4.max`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
     ),
   ],
@@ -13494,43 +12410,23 @@ assert_return(
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1615
 assert_return(
   () =>
-    invoke($0, `f32x4.max`, [
-      f32x4([-1, -1, -1, -1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+    invoke($0, `f32x4.max`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1618
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
@@ -13808,34 +12704,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1663
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
     ),
@@ -14127,41 +13006,24 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1711
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1714
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
@@ -14456,34 +13318,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 340282350000000000000000000000000000000),
       value("f32", 340282350000000000000000000000000000000),
       value("f32", 340282350000000000000000000000000000000),
       value("f32", 340282350000000000000000000000000000000),
     ),
@@ -14855,41 +13700,24 @@ assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1810
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
@@ -15244,34 +14072,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1855
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([Infinity, Infinity, Infinity, Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
@@ -15563,41 +14374,24 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1903
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:1906
 assert_return(
   () =>
     invoke($0, `f32x4.max`, [
@@ -16541,34 +15335,17 @@ assert_return(
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
@@ -17336,34 +16113,17 @@ assert_return(
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
@@ -18131,34 +16891,17 @@ assert_return(
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
@@ -18926,34 +17669,17 @@ assert_return(
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
@@ -19667,174 +18393,56 @@ assert_return(
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:2265
 assert_return(
-  () =>
-    invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-      ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      value("f32", 0),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.min`, [f32x4([0, 0, -0, 0]), f32x4([0, -0, 0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:2268
 assert_return(
-  () =>
-    invoke($0, `f32x4.min`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0, 0, 0, 0]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:2271
 assert_return(
-  () =>
-    invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-      ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f32x4.max`, [f32x4([0, 0, -0, 0]), f32x4([0, -0, 0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4.wast:2274
 assert_return(
-  () =>
-    invoke($0, `f32x4.max`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0, 0, 0, 0]),
-    ]),
+  () => invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
@@ -19846,47 +18454,24 @@ assert_return(() => invoke($0, `f32x4.ab
     value("f32", 0),
     value("f32", 0),
     value("f32", 0),
     value("f32", 0),
   ),
 ]);
 
 // ./test/core/simd/simd_f32x4.wast:2281
-assert_return(
-  () =>
-    invoke($0, `f32x4.abs`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      value("f32", 0),
-      value("f32", 0),
-      value("f32", 0),
-      value("f32", 0),
-    ),
-  ],
-);
+assert_return(() => invoke($0, `f32x4.abs`, [f32x4([-0, -0, -0, -0])]), [
+  new F32x4Pattern(
+    value("f32", 0),
+    value("f32", 0),
+    value("f32", 0),
+    value("f32", 0),
+  ),
+]);
 
 // ./test/core/simd/simd_f32x4.wast:2283
 assert_return(
   () =>
     invoke($0, `f32x4.abs`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
--- a/js/src/jit-test/tests/wasm/spec/simd/simd_f32x4_arith.wast.js
+++ b/js/src/jit-test/tests/wasm/spec/simd/simd_f32x4_arith.wast.js
@@ -35,38 +35,17 @@ assert_return(
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:16
 assert_return(
-  () =>
-    invoke($0, `f32x4.add`, [
-      f32x4([0, 0, 0, 0]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f32x4.add`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
@@ -326,121 +305,46 @@ assert_return(
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:61
 assert_return(
-  () =>
-    invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0, 0, 0, 0]),
-    ]),
+  () => invoke($0, `f32x4.add`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:64
 assert_return(
   () =>
-    invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+    invoke($0, `f32x4.add`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:67
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
@@ -452,34 +356,17 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:70
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
@@ -491,34 +378,17 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:73
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
@@ -530,34 +400,17 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:76
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
@@ -569,238 +422,112 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:79
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([0.5, 0.5, 0.5, 0.5]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:82
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-0.5, -0.5, -0.5, -0.5]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:85
 assert_return(
-  () =>
-    invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([1, 1, 1, 1]),
-    ]),
+  () => invoke($0, `f32x4.add`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
   [
     new F32x4Pattern(
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:88
 assert_return(
   () =>
-    invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([-1, -1, -1, -1]),
-    ]),
+    invoke($0, `f32x4.add`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
   [
     new F32x4Pattern(
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:91
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:94
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:97
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
     ]),
   [
@@ -812,34 +539,17 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:100
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
     ]),
   [
@@ -851,68 +561,34 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:103
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:106
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
@@ -947,34 +623,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.000000000000000000000000000000000000000000001),
       value("f32", 0.000000000000000000000000000000000000000000001),
       value("f32", 0.000000000000000000000000000000000000000000001),
       value("f32", 0.000000000000000000000000000000000000000000001),
     ),
@@ -1346,34 +1005,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.000000000000000000000000000000000000000000001),
       value("f32", -0.000000000000000000000000000000000000000000001),
       value("f32", -0.000000000000000000000000000000000000000000001),
       value("f32", -0.000000000000000000000000000000000000000000001),
     ),
@@ -1745,34 +1387,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.000000000000000000000000000000000000011754944),
       value("f32", 0.000000000000000000000000000000000000011754944),
       value("f32", 0.000000000000000000000000000000000000011754944),
       value("f32", 0.000000000000000000000000000000000000011754944),
     ),
@@ -2144,34 +1769,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.000000000000000000000000000000000000011754944),
       value("f32", -0.000000000000000000000000000000000000011754944),
       value("f32", -0.000000000000000000000000000000000000011754944),
       value("f32", -0.000000000000000000000000000000000000011754944),
     ),
@@ -2530,34 +2138,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:304
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([0.5, 0.5, 0.5, 0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
     ),
@@ -2846,34 +2437,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:352
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([-0.5, -0.5, -0.5, -0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
     ),
@@ -3158,38 +2732,17 @@ assert_return(
       value("f32", 1),
       value("f32", 1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:400
 assert_return(
-  () =>
-    invoke($0, `f32x4.add`, [
-      f32x4([1, 1, 1, 1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f32x4.add`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
     ),
   ],
@@ -3463,37 +3016,17 @@ assert_return(
       value("f32", -1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:448
 assert_return(
   () =>
-    invoke($0, `f32x4.add`, [
-      f32x4([-1, -1, -1, -1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+    invoke($0, `f32x4.add`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
     ),
   ],
@@ -3777,34 +3310,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:496
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
     ),
@@ -4096,34 +3612,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:544
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
     ),
@@ -4425,34 +3924,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 340282350000000000000000000000000000000),
       value("f32", 340282350000000000000000000000000000000),
       value("f32", 340282350000000000000000000000000000000),
       value("f32", 340282350000000000000000000000000000000),
     ),
@@ -4824,34 +4306,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -340282350000000000000000000000000000000),
       value("f32", -340282350000000000000000000000000000000),
       value("f32", -340282350000000000000000000000000000000),
       value("f32", -340282350000000000000000000000000000000),
     ),
@@ -5213,34 +4678,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:688
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([Infinity, Infinity, Infinity, Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
@@ -5532,34 +4980,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:736
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
@@ -5919,67 +5350,33 @@ assert_return(
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:790
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
@@ -7305,67 +6702,33 @@ assert_return(
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:898
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
@@ -8691,67 +8054,33 @@ assert_return(
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1006
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
@@ -10077,67 +9406,33 @@ assert_return(
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1114
 assert_return(
   () =>
     invoke($0, `f32x4.add`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
@@ -11976,38 +11271,17 @@ assert_return(
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1288
 assert_return(
-  () =>
-    invoke($0, `f32x4.sub`, [
-      f32x4([0, 0, 0, 0]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f32x4.sub`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
@@ -12267,121 +11541,46 @@ assert_return(
       value("f32", Infinity),
       value("f32", Infinity),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1333
 assert_return(
-  () =>
-    invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0, 0, 0, 0]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.sub`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1336
 assert_return(
   () =>
-    invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+    invoke($0, `f32x4.sub`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1339
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
@@ -12393,34 +11592,17 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1342
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
@@ -12432,34 +11614,17 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1345
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
@@ -12471,34 +11636,17 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1348
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
@@ -12510,238 +11658,112 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1351
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([0.5, 0.5, 0.5, 0.5]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1354
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-0.5, -0.5, -0.5, -0.5]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1357
 assert_return(
-  () =>
-    invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([1, 1, 1, 1]),
-    ]),
+  () => invoke($0, `f32x4.sub`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
   [
     new F32x4Pattern(
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1360
 assert_return(
   () =>
-    invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([-1, -1, -1, -1]),
-    ]),
+    invoke($0, `f32x4.sub`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
   [
     new F32x4Pattern(
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1363
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1366
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1369
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
     ]),
   [
@@ -12753,34 +11775,17 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1372
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
     ]),
   [
@@ -12792,68 +11797,34 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1375
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1378
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
@@ -12888,34 +11859,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.000000000000000000000000000000000000000000001),
       value("f32", 0.000000000000000000000000000000000000000000001),
       value("f32", 0.000000000000000000000000000000000000000000001),
       value("f32", 0.000000000000000000000000000000000000000000001),
     ),
@@ -13287,34 +12241,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.000000000000000000000000000000000000000000001),
       value("f32", -0.000000000000000000000000000000000000000000001),
       value("f32", -0.000000000000000000000000000000000000000000001),
       value("f32", -0.000000000000000000000000000000000000000000001),
     ),
@@ -13686,34 +12623,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.000000000000000000000000000000000000011754944),
       value("f32", 0.000000000000000000000000000000000000011754944),
       value("f32", 0.000000000000000000000000000000000000011754944),
       value("f32", 0.000000000000000000000000000000000000011754944),
     ),
@@ -14085,34 +13005,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.000000000000000000000000000000000000011754944),
       value("f32", -0.000000000000000000000000000000000000011754944),
       value("f32", -0.000000000000000000000000000000000000011754944),
       value("f32", -0.000000000000000000000000000000000000011754944),
     ),
@@ -14471,34 +13374,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1576
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([0.5, 0.5, 0.5, 0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
       value("f32", 0.5),
     ),
@@ -14787,34 +13673,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1624
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([-0.5, -0.5, -0.5, -0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
       value("f32", -0.5),
     ),
@@ -15099,38 +13968,17 @@ assert_return(
       value("f32", 1),
       value("f32", 1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1672
 assert_return(
-  () =>
-    invoke($0, `f32x4.sub`, [
-      f32x4([1, 1, 1, 1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f32x4.sub`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
       value("f32", 1),
     ),
   ],
@@ -15404,37 +14252,17 @@ assert_return(
       value("f32", -1),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1720
 assert_return(
   () =>
-    invoke($0, `f32x4.sub`, [
-      f32x4([-1, -1, -1, -1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+    invoke($0, `f32x4.sub`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
       value("f32", -1),
     ),
   ],
@@ -15718,34 +14546,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1768
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
       value("f32", 6.2831855),
     ),
@@ -16037,34 +14848,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1816
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
       value("f32", -6.2831855),
     ),
@@ -16366,34 +15160,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 340282350000000000000000000000000000000),
       value("f32", 340282350000000000000000000000000000000),
       value("f32", 340282350000000000000000000000000000000),
       value("f32", 340282350000000000000000000000000000000),
     ),
@@ -16765,34 +15542,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -340282350000000000000000000000000000000),
       value("f32", -340282350000000000000000000000000000000),
       value("f32", -340282350000000000000000000000000000000),
       value("f32", -340282350000000000000000000000000000000),
     ),
@@ -17154,34 +15914,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:1960
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([Infinity, Infinity, Infinity, Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
@@ -17473,34 +16216,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2008
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
@@ -17860,67 +16586,33 @@ assert_return(
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2062
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
@@ -19246,67 +17938,33 @@ assert_return(
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2170
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
@@ -20632,67 +19290,33 @@ assert_return(
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2278
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
@@ -22018,67 +20642,33 @@ assert_return(
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2386
 assert_return(
   () =>
     invoke($0, `f32x4.sub`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
@@ -23917,44 +22507,23 @@ assert_return(
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2560
 assert_return(
-  () =>
-    invoke($0, `f32x4.mul`, [
-      f32x4([0, 0, 0, 0]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2563
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -23985,20 +22554,20 @@ assert_return(
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2569
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -24029,20 +22598,20 @@ assert_return(
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2575
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
@@ -24060,20 +22629,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([0, 0, 0, 0]),
       f32x4([-0.5, -0.5, -0.5, -0.5]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2581
 assert_return(
   () => invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
   [
@@ -24086,20 +22655,20 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2584
 assert_return(
   () => invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2587
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -24120,20 +22689,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([0, 0, 0, 0]),
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2593
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -24164,20 +22733,20 @@ assert_return(
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2599
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -24208,160 +22777,68 @@ assert_return(
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2605
 assert_return(
-  () =>
-    invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0, 0, 0, 0]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.mul`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2608
 assert_return(
   () =>
-    invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+    invoke($0, `f32x4.mul`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2611
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        0.000000000000000000000000000000000000000000001,
-        0.000000000000000000000000000000000000000000001,
-        0.000000000000000000000000000000000000000000001,
-        0.000000000000000000000000000000000000000000001,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        0.000000000000000000000000000000000000000000001,
+        0.000000000000000000000000000000000000000000001,
+        0.000000000000000000000000000000000000000000001,
+        0.000000000000000000000000000000000000000000001,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2614
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
@@ -24373,73 +22850,39 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2617
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        0.000000000000000000000000000000000000011754944,
-        0.000000000000000000000000000000000000011754944,
-        0.000000000000000000000000000000000000011754944,
-        0.000000000000000000000000000000000000011754944,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        0.000000000000000000000000000000000000011754944,
+        0.000000000000000000000000000000000000011754944,
+        0.000000000000000000000000000000000000011754944,
+        0.000000000000000000000000000000000000011754944,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2620
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
@@ -24451,277 +22894,134 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2623
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0.5, 0.5, 0.5, 0.5]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([0.5, 0.5, 0.5, 0.5]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2626
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-0.5, -0.5, -0.5, -0.5]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2629
 assert_return(
-  () =>
-    invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([1, 1, 1, 1]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.mul`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2632
 assert_return(
   () =>
-    invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([-1, -1, -1, -1]),
-    ]),
+    invoke($0, `f32x4.mul`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2635
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2638
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2641
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        340282350000000000000000000000000000000,
-        340282350000000000000000000000000000000,
-        340282350000000000000000000000000000000,
-        340282350000000000000000000000000000000,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        340282350000000000000000000000000000000,
+        340282350000000000000000000000000000000,
+        340282350000000000000000000000000000000,
+        340282350000000000000000000000000000000,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2644
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
     ]),
   [
@@ -24733,68 +23033,34 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2647
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2650
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
@@ -24829,41 +23095,24 @@ assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2659
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -24904,20 +23153,20 @@ assert_return(
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2665
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -24958,20 +23207,20 @@ assert_return(
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2671
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -25002,20 +23251,20 @@ assert_return(
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
       f32x4([-0.5, -0.5, -0.5, -0.5]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2677
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -25210,52 +23459,35 @@ assert_return(
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
       f32x4([0, 0, 0, 0]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2704
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
@@ -25276,20 +23508,20 @@ assert_return(
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2710
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -25330,20 +23562,20 @@ assert_return(
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2716
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -25379,20 +23611,20 @@ assert_return(
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
       f32x4([0.5, 0.5, 0.5, 0.5]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2722
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -25627,41 +23859,24 @@ assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2755
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -25702,20 +23917,20 @@ assert_return(
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2761
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -25756,20 +23971,20 @@ assert_return(
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2767
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -26008,52 +24223,35 @@ assert_return(
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
       f32x4([0, 0, 0, 0]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2800
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
@@ -26074,20 +24272,20 @@ assert_return(
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2806
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -26128,20 +24326,20 @@ assert_return(
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2812
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -26412,41 +24610,24 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2848
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([0.5, 0.5, 0.5, 0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2851
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -26477,20 +24658,20 @@ assert_return(
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2857
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -26715,47 +24896,30 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([-0.5, -0.5, -0.5, -0.5]),
       f32x4([0, 0, 0, 0]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2896
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([-0.5, -0.5, -0.5, -0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
@@ -26771,20 +24935,20 @@ assert_return(
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2902
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -27040,44 +25204,23 @@ assert_return(
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2944
 assert_return(
-  () =>
-    invoke($0, `f32x4.mul`, [
-      f32x4([1, 1, 1, 1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.mul`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2947
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -27334,48 +25477,28 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2989
 assert_return(
   () => invoke($0, `f32x4.mul`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:2992
 assert_return(
   () =>
-    invoke($0, `f32x4.mul`, [
-      f32x4([-1, -1, -1, -1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+    invoke($0, `f32x4.mul`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
@@ -27659,41 +25782,24 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3040
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3043
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -27965,47 +26071,30 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
       f32x4([0, 0, 0, 0]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3088
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
@@ -28307,41 +26396,24 @@ assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3139
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
@@ -28688,52 +26760,35 @@ assert_return(
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
       f32x4([0, 0, 0, 0]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3184
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
@@ -29095,34 +27150,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3232
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([Infinity, Infinity, Infinity, Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
@@ -29414,34 +27452,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3280
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
@@ -29801,67 +27822,33 @@ assert_return(
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3334
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
@@ -31187,67 +29174,33 @@ assert_return(
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3442
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
@@ -32573,67 +30526,33 @@ assert_return(
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3550
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
@@ -33959,67 +31878,33 @@ assert_return(
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3658
 assert_return(
   () =>
     invoke($0, `f32x4.mul`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
@@ -35858,38 +33743,17 @@ assert_return(
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3832
 assert_return(
-  () =>
-    invoke($0, `f32x4.div`, [
-      f32x4([0, 0, 0, 0]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
@@ -35926,20 +33790,20 @@ assert_return(
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3841
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -35970,20 +33834,20 @@ assert_return(
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3847
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
@@ -36001,20 +33865,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([0, 0, 0, 0]),
       f32x4([-0.5, -0.5, -0.5, -0.5]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3853
 assert_return(
   () => invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
   [
@@ -36027,20 +33891,20 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3856
 assert_return(
   () => invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3859
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -36061,20 +33925,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([0, 0, 0, 0]),
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3865
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -36105,20 +33969,20 @@ assert_return(
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3871
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -36139,170 +34003,78 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([0, 0, 0, 0]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3877
 assert_return(
-  () =>
-    invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0, 0, 0, 0]),
-    ]),
+  () => invoke($0, `f32x4.div`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3880
 assert_return(
   () =>
-    invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+    invoke($0, `f32x4.div`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3883
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        0.000000000000000000000000000000000000000000001,
-        0.000000000000000000000000000000000000000000001,
-        0.000000000000000000000000000000000000000000001,
-        0.000000000000000000000000000000000000000000001,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        0.000000000000000000000000000000000000000000001,
+        0.000000000000000000000000000000000000000000001,
+        0.000000000000000000000000000000000000000000001,
+        0.000000000000000000000000000000000000000000001,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3886
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
     ]),
   [
@@ -36314,73 +34086,39 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3889
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        0.000000000000000000000000000000000000011754944,
-        0.000000000000000000000000000000000000011754944,
-        0.000000000000000000000000000000000000011754944,
-        0.000000000000000000000000000000000000011754944,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        0.000000000000000000000000000000000000011754944,
+        0.000000000000000000000000000000000000011754944,
+        0.000000000000000000000000000000000000011754944,
+        0.000000000000000000000000000000000000011754944,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3892
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
     ]),
   [
@@ -36392,277 +34130,134 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3895
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([0.5, 0.5, 0.5, 0.5]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([0.5, 0.5, 0.5, 0.5]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3898
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-0.5, -0.5, -0.5, -0.5]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3901
 assert_return(
-  () =>
-    invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([1, 1, 1, 1]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+  () => invoke($0, `f32x4.div`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3904
 assert_return(
   () =>
-    invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([-1, -1, -1, -1]),
-    ]),
+    invoke($0, `f32x4.div`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3907
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3910
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3913
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([
-        340282350000000000000000000000000000000,
-        340282350000000000000000000000000000000,
-        340282350000000000000000000000000000000,
-        340282350000000000000000000000000000000,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([
+        340282350000000000000000000000000000000,
+        340282350000000000000000000000000000000,
+        340282350000000000000000000000000000000,
+        340282350000000000000000000000000000000,
+      ]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3916
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
     ]),
   [
@@ -36674,68 +34269,34 @@ assert_return(
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3919
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-      f32x4([Infinity, Infinity, Infinity, Infinity]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      f32x4([-0, -0, -0, -0]),
+      f32x4([Infinity, Infinity, Infinity, Infinity]),
+    ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3922
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
       value("f32", 0),
@@ -36770,34 +34331,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
@@ -37031,20 +34575,20 @@ assert_return(
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3961
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -37085,20 +34629,20 @@ assert_return(
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3967
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -37129,20 +34673,20 @@ assert_return(
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:3973
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -37169,34 +34713,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
@@ -37408,20 +34935,20 @@ assert_return(
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4006
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -37457,20 +34984,20 @@ assert_return(
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4012
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -37506,20 +35033,20 @@ assert_return(
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
         -0.000000000000000000000000000000000000000000001,
       ]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4018
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -37568,34 +35095,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
@@ -37883,20 +35393,20 @@ assert_return(
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4063
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -37927,20 +35437,20 @@ assert_return(
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
         0.000000000000000000000000000000000000011754944,
       ]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4069
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -37967,34 +35477,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
@@ -38255,20 +35748,20 @@ assert_return(
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4108
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -38304,20 +35797,20 @@ assert_return(
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
         -0.000000000000000000000000000000000000011754944,
       ]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4114
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -38353,34 +35846,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4120
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([0.5, 0.5, 0.5, 0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
@@ -38639,20 +36115,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([0.5, 0.5, 0.5, 0.5]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4165
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -38669,34 +36145,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4168
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([-0.5, -0.5, -0.5, -0.5]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
@@ -38941,20 +36400,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([-0.5, -0.5, -0.5, -0.5]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4210
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -38981,38 +36440,17 @@ assert_return(
       value("f32", Infinity),
       value("f32", Infinity),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4216
 assert_return(
-  () =>
-    invoke($0, `f32x4.div`, [
-      f32x4([1, 1, 1, 1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+  () => invoke($0, `f32x4.div`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
   ],
@@ -39262,20 +36700,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([1, 1, 1, 1]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4261
 assert_return(
   () => invoke($0, `f32x4.div`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
   [
@@ -39286,37 +36724,17 @@ assert_return(
       value("f32", -Infinity),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4264
 assert_return(
   () =>
-    invoke($0, `f32x4.div`, [
-      f32x4([-1, -1, -1, -1]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
+    invoke($0, `f32x4.div`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
   ],
@@ -39553,20 +36971,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([-1, -1, -1, -1]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4306
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -39600,34 +37018,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4312
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
@@ -39889,20 +37290,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4357
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -39919,34 +37320,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4360
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
@@ -40191,20 +37575,20 @@ assert_return(
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4402
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -40248,34 +37632,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
@@ -40607,20 +37974,20 @@ assert_return(
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
         340282350000000000000000000000000000000,
       ]),
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4453
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -40647,34 +38014,17 @@ assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
@@ -40984,20 +38334,20 @@ assert_return(
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
         -340282350000000000000000000000000000000,
       ]),
       f32x4([Infinity, Infinity, Infinity, Infinity]),
     ]),
   [
     new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4498
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
@@ -41036,34 +38386,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4504
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([Infinity, Infinity, Infinity, Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
       value("f32", -Infinity),
     ),
@@ -41355,34 +38688,17 @@ assert_return(
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4552
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
       f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
       value("f32", Infinity),
     ),
@@ -41742,67 +39058,33 @@ assert_return(
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4606
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
@@ -43128,67 +40410,33 @@ assert_return(
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
       `canonical_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4714
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xc0,
         0xff,
         0x0,
         0x0,
         0xc0,
@@ -44514,67 +41762,33 @@ assert_return(
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4822
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xa0,
         0x7f,
         0x0,
         0x0,
         0xa0,
@@ -45900,67 +43114,33 @@ assert_return(
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
         0xff,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [
     new F32x4Pattern(
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
       `arithmetic_nan`,
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:4930
 assert_return(
   () =>
     invoke($0, `f32x4.div`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
       bytes("v128", [
         0x0,
         0x0,
         0xa0,
         0xff,
         0x0,
         0x0,
         0xa0,
@@ -47795,47 +44975,24 @@ assert_return(() => invoke($0, `f32x4.sq
     value("f32", 0),
     value("f32", 0),
     value("f32", 0),
     value("f32", 0),
   ),
 ]);
 
 // ./test/core/simd/simd_f32x4_arith.wast:5103
-assert_return(
-  () =>
-    invoke($0, `f32x4.sqrt`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-      bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-    ),
-  ],
-);
+assert_return(() => invoke($0, `f32x4.sqrt`, [f32x4([-0, -0, -0, -0])]), [
+  new F32x4Pattern(
+    value("f32", -0),
+    value("f32", -0),
+    value("f32", -0),
+    value("f32", -0),
+  ),
+]);
 
 // ./test/core/simd/simd_f32x4_arith.wast:5105
 assert_return(
   () =>
     invoke($0, `f32x4.sqrt`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
@@ -48667,55 +45824,32 @@ assert_return(
       value("f32", 395442.78),
     ),
   ],
 );
 
 // ./test/core/simd/simd_f32x4_arith.wast:5189
 assert_return(() => invoke($0, `f32x4.neg`, [f32x4([0, 0, 0, 0])]), [
   new F32x4Pattern(
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
-    bytes("f32", [0x0, 0x0, 0x0, 0x80]),
+    value("f32", -0),
+    value("f32", -0),
+    value("f32", -0),
+    value("f32", -0),
   ),
 ]);
 
 // ./test/core/simd/simd_f32x4_arith.wast:5191
-assert_return(
-  () =>
-    invoke($0, `f32x4.neg`, [
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
-    ]),
-  [
-    new F32x4Pattern(
-      value("f32", 0),
-      value("f32", 0),
-      value("f32", 0),
-      value("f32", 0),
-    ),
-  ],
-);
+assert_return(() => invoke($0, `f32x4.neg`, [f32x4([-0, -0, -0, -0])]), [
+  new F32x4Pattern(
+    value("f32", 0),
+    value("f32", 0),
+    value("f32", 0),
+    value("f32", 0),
+  ),
+]);
 
 // ./test/core/simd/simd_f32x4_arith.wast:5193
 assert_return(
   () =>
     invoke($0, `f32x4.neg`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
--- a/js/src/jit-test/tests/wasm/spec/simd/simd_f32x4_cmp.wast.js
+++ b/js/src/jit-test/tests/wasm/spec/simd/simd_f32x4_cmp.wast.js
@@ -275,34 +275,17 @@ assert_return(
         0x0,
         0xc0,
         0x7f,
         0x0,
         0x0,
         0xc0,
         0x7f,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [i32x4([0x0, 0x0, 0x0, 0x0])],
 );
 
 // ./test/core/simd/simd_f32x4_cmp.wast:37
 assert_return(
   () =>
     invoke($0, `eq`, [
@@ -834,34 +817,17 @@ assert_return(
   () =>
     invoke($0, `eq`, [
       f32x4([
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
         0.000000000000000000000000000000000000000000001,
       ]),
-      bytes("v128", [
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-        0x0,
-        0x0,
-        0x0,
-        0x80,
-      ]),
+      f32x4([-0, -0, -0, -0]),
     ]),
   [i32x4([0x0, 0x0, 0x0, 0x0])],
 );
 </