summaryrefslogtreecommitdiffstats
path: root/js/src/jit-test/tests/wasm/spec/exception-handling
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/jit-test/tests/wasm/spec/exception-handling')
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/call_indirect.wast.js1240
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/custom.wast.js157
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/directives.txt1
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/harness/directives.txt1
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js360
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/rethrow.wast.js140
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/table_fill.wast.js234
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/table_get.wast.js126
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/table_grow.wast.js268
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/table_set.wast.js177
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/table_size.wast.js172
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/tag.wast.js40
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/throw.wast.js87
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/try_catch.wast.js318
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/try_delegate.wast.js177
-rw-r--r--js/src/jit-test/tests/wasm/spec/exception-handling/unreached-valid.wast.js85
16 files changed, 3583 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/call_indirect.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/call_indirect.wast.js
new file mode 100644
index 0000000000..cde2d92cef
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/call_indirect.wast.js
@@ -0,0 +1,1240 @@
+/* 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/call_indirect.wast
+
+// ./test/core/call_indirect.wast:3
+let $0 = instantiate(`(module
+ ;; Auxiliary definitions
+ (type $$proc (func))
+ (type $$out-i32 (func (result i32)))
+ (type $$out-i64 (func (result i64)))
+ (type $$out-f32 (func (result f32)))
+ (type $$out-f64 (func (result f64)))
+ (type $$out-f64-i32 (func (result f64 i32)))
+ (type $$over-i32 (func (param i32) (result i32)))
+ (type $$over-i64 (func (param i64) (result i64)))
+ (type $$over-f32 (func (param f32) (result f32)))
+ (type $$over-f64 (func (param f64) (result f64)))
+ (type $$over-i32-f64 (func (param i32 f64) (result i32 f64)))
+ (type $$swap-i32-i64 (func (param i32 i64) (result i64 i32)))
+ (type $$f32-i32 (func (param f32 i32) (result i32)))
+ (type $$i32-i64 (func (param i32 i64) (result i64)))
+ (type $$f64-f32 (func (param f64 f32) (result f32)))
+ (type $$i64-f64 (func (param i64 f64) (result f64)))
+ (type $$over-i32-duplicate (func (param i32) (result i32)))
+ (type $$over-i64-duplicate (func (param i64) (result i64)))
+ (type $$over-f32-duplicate (func (param f32) (result f32)))
+ (type $$over-f64-duplicate (func (param f64) (result f64)))
+
+ (func $$const-i32 (type $$out-i32) (i32.const 0x132))
+ (func $$const-i64 (type $$out-i64) (i64.const 0x164))
+ (func $$const-f32 (type $$out-f32) (f32.const 0xf32))
+ (func $$const-f64 (type $$out-f64) (f64.const 0xf64))
+ (func $$const-f64-i32 (type $$out-f64-i32) (f64.const 0xf64) (i32.const 32))
+
+ (func $$id-i32 (type $$over-i32) (local.get 0))
+ (func $$id-i64 (type $$over-i64) (local.get 0))
+ (func $$id-f32 (type $$over-f32) (local.get 0))
+ (func $$id-f64 (type $$over-f64) (local.get 0))
+ (func $$id-i32-f64 (type $$over-i32-f64) (local.get 0) (local.get 1))
+ (func $$swap-i32-i64 (type $$swap-i32-i64) (local.get 1) (local.get 0))
+
+ (func $$i32-i64 (type $$i32-i64) (local.get 1))
+ (func $$i64-f64 (type $$i64-f64) (local.get 1))
+ (func $$f32-i32 (type $$f32-i32) (local.get 1))
+ (func $$f64-f32 (type $$f64-f32) (local.get 1))
+
+ (func $$over-i32-duplicate (type $$over-i32-duplicate) (local.get 0))
+ (func $$over-i64-duplicate (type $$over-i64-duplicate) (local.get 0))
+ (func $$over-f32-duplicate (type $$over-f32-duplicate) (local.get 0))
+ (func $$over-f64-duplicate (type $$over-f64-duplicate) (local.get 0))
+
+ (table funcref
+ (elem
+ $$const-i32 $$const-i64 $$const-f32 $$const-f64 ;; 0..3
+ $$id-i32 $$id-i64 $$id-f32 $$id-f64 ;; 4..7
+ $$f32-i32 $$i32-i64 $$f64-f32 $$i64-f64 ;; 9..11
+ $$fac-i64 $$fib-i64 $$even $$odd ;; 12..15
+ $$runaway $$mutual-runaway1 $$mutual-runaway2 ;; 16..18
+ $$over-i32-duplicate $$over-i64-duplicate ;; 19..20
+ $$over-f32-duplicate $$over-f64-duplicate ;; 21..22
+ $$fac-i32 $$fac-f32 $$fac-f64 ;; 23..25
+ $$fib-i32 $$fib-f32 $$fib-f64 ;; 26..28
+ $$const-f64-i32 $$id-i32-f64 $$swap-i32-i64 ;; 29..31
+ )
+ )
+
+ ;; Syntax
+
+ (func
+ (call_indirect (i32.const 0))
+ (call_indirect (param i64) (i64.const 0) (i32.const 0))
+ (call_indirect (param i64) (param) (param f64 i32 i64)
+ (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+ )
+ (call_indirect (result) (i32.const 0))
+ (drop (i32.eqz (call_indirect (result i32) (i32.const 0))))
+ (drop (i32.eqz (call_indirect (result i32) (result) (i32.const 0))))
+ (drop (i32.eqz
+ (call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0))
+ ))
+ (drop (i32.eqz
+ (call_indirect
+ (param) (param i64) (param) (param f64 i32 i64) (param) (param)
+ (result) (result i32) (result) (result)
+ (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+ )
+ ))
+ (drop (i64.eqz
+ (call_indirect (type $$over-i64) (param i64) (result i64)
+ (i64.const 0) (i32.const 0)
+ )
+ ))
+ )
+
+ ;; Typing
+
+ (func (export "type-i32") (result i32)
+ (call_indirect (type $$out-i32) (i32.const 0))
+ )
+ (func (export "type-i64") (result i64)
+ (call_indirect (type $$out-i64) (i32.const 1))
+ )
+ (func (export "type-f32") (result f32)
+ (call_indirect (type $$out-f32) (i32.const 2))
+ )
+ (func (export "type-f64") (result f64)
+ (call_indirect (type $$out-f64) (i32.const 3))
+ )
+ (func (export "type-f64-i32") (result f64 i32)
+ (call_indirect (type $$out-f64-i32) (i32.const 29))
+ )
+
+ (func (export "type-index") (result i64)
+ (call_indirect (type $$over-i64) (i64.const 100) (i32.const 5))
+ )
+
+ (func (export "type-first-i32") (result i32)
+ (call_indirect (type $$over-i32) (i32.const 32) (i32.const 4))
+ )
+ (func (export "type-first-i64") (result i64)
+ (call_indirect (type $$over-i64) (i64.const 64) (i32.const 5))
+ )
+ (func (export "type-first-f32") (result f32)
+ (call_indirect (type $$over-f32) (f32.const 1.32) (i32.const 6))
+ )
+ (func (export "type-first-f64") (result f64)
+ (call_indirect (type $$over-f64) (f64.const 1.64) (i32.const 7))
+ )
+
+ (func (export "type-second-i32") (result i32)
+ (call_indirect (type $$f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8))
+ )
+ (func (export "type-second-i64") (result i64)
+ (call_indirect (type $$i32-i64) (i32.const 32) (i64.const 64) (i32.const 9))
+ )
+ (func (export "type-second-f32") (result f32)
+ (call_indirect (type $$f64-f32) (f64.const 64) (f32.const 32) (i32.const 10))
+ )
+ (func (export "type-second-f64") (result f64)
+ (call_indirect (type $$i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11))
+ )
+
+ (func (export "type-all-f64-i32") (result f64 i32)
+ (call_indirect (type $$out-f64-i32) (i32.const 29))
+ )
+ (func (export "type-all-i32-f64") (result i32 f64)
+ (call_indirect (type $$over-i32-f64)
+ (i32.const 1) (f64.const 2) (i32.const 30)
+ )
+ )
+ (func (export "type-all-i32-i64") (result i64 i32)
+ (call_indirect (type $$swap-i32-i64)
+ (i32.const 1) (i64.const 2) (i32.const 31)
+ )
+ )
+
+ ;; Dispatch
+
+ (func (export "dispatch") (param i32 i64) (result i64)
+ (call_indirect (type $$over-i64) (local.get 1) (local.get 0))
+ )
+
+ (func (export "dispatch-structural-i64") (param i32) (result i64)
+ (call_indirect (type $$over-i64-duplicate) (i64.const 9) (local.get 0))
+ )
+ (func (export "dispatch-structural-i32") (param i32) (result i32)
+ (call_indirect (type $$over-i32-duplicate) (i32.const 9) (local.get 0))
+ )
+ (func (export "dispatch-structural-f32") (param i32) (result f32)
+ (call_indirect (type $$over-f32-duplicate) (f32.const 9.0) (local.get 0))
+ )
+ (func (export "dispatch-structural-f64") (param i32) (result f64)
+ (call_indirect (type $$over-f64-duplicate) (f64.const 9.0) (local.get 0))
+ )
+
+ ;; Recursion
+
+ (func $$fac-i64 (export "fac-i64") (type $$over-i64)
+ (if (result i64) (i64.eqz (local.get 0))
+ (then (i64.const 1))
+ (else
+ (i64.mul
+ (local.get 0)
+ (call_indirect (type $$over-i64)
+ (i64.sub (local.get 0) (i64.const 1))
+ (i32.const 12)
+ )
+ )
+ )
+ )
+ )
+
+ (func $$fib-i64 (export "fib-i64") (type $$over-i64)
+ (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+ (then (i64.const 1))
+ (else
+ (i64.add
+ (call_indirect (type $$over-i64)
+ (i64.sub (local.get 0) (i64.const 2))
+ (i32.const 13)
+ )
+ (call_indirect (type $$over-i64)
+ (i64.sub (local.get 0) (i64.const 1))
+ (i32.const 13)
+ )
+ )
+ )
+ )
+ )
+
+ (func $$fac-i32 (export "fac-i32") (type $$over-i32)
+ (if (result i32) (i32.eqz (local.get 0))
+ (then (i32.const 1))
+ (else
+ (i32.mul
+ (local.get 0)
+ (call_indirect (type $$over-i32)
+ (i32.sub (local.get 0) (i32.const 1))
+ (i32.const 23)
+ )
+ )
+ )
+ )
+ )
+
+ (func $$fac-f32 (export "fac-f32") (type $$over-f32)
+ (if (result f32) (f32.eq (local.get 0) (f32.const 0.0))
+ (then (f32.const 1.0))
+ (else
+ (f32.mul
+ (local.get 0)
+ (call_indirect (type $$over-f32)
+ (f32.sub (local.get 0) (f32.const 1.0))
+ (i32.const 24)
+ )
+ )
+ )
+ )
+ )
+
+ (func $$fac-f64 (export "fac-f64") (type $$over-f64)
+ (if (result f64) (f64.eq (local.get 0) (f64.const 0.0))
+ (then (f64.const 1.0))
+ (else
+ (f64.mul
+ (local.get 0)
+ (call_indirect (type $$over-f64)
+ (f64.sub (local.get 0) (f64.const 1.0))
+ (i32.const 25)
+ )
+ )
+ )
+ )
+ )
+
+ (func $$fib-i32 (export "fib-i32") (type $$over-i32)
+ (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
+ (then (i32.const 1))
+ (else
+ (i32.add
+ (call_indirect (type $$over-i32)
+ (i32.sub (local.get 0) (i32.const 2))
+ (i32.const 26)
+ )
+ (call_indirect (type $$over-i32)
+ (i32.sub (local.get 0) (i32.const 1))
+ (i32.const 26)
+ )
+ )
+ )
+ )
+ )
+
+ (func $$fib-f32 (export "fib-f32") (type $$over-f32)
+ (if (result f32) (f32.le (local.get 0) (f32.const 1.0))
+ (then (f32.const 1.0))
+ (else
+ (f32.add
+ (call_indirect (type $$over-f32)
+ (f32.sub (local.get 0) (f32.const 2.0))
+ (i32.const 27)
+ )
+ (call_indirect (type $$over-f32)
+ (f32.sub (local.get 0) (f32.const 1.0))
+ (i32.const 27)
+ )
+ )
+ )
+ )
+ )
+
+ (func $$fib-f64 (export "fib-f64") (type $$over-f64)
+ (if (result f64) (f64.le (local.get 0) (f64.const 1.0))
+ (then (f64.const 1.0))
+ (else
+ (f64.add
+ (call_indirect (type $$over-f64)
+ (f64.sub (local.get 0) (f64.const 2.0))
+ (i32.const 28)
+ )
+ (call_indirect (type $$over-f64)
+ (f64.sub (local.get 0) (f64.const 1.0))
+ (i32.const 28)
+ )
+ )
+ )
+ )
+ )
+
+ (func $$even (export "even") (param i32) (result i32)
+ (if (result i32) (i32.eqz (local.get 0))
+ (then (i32.const 44))
+ (else
+ (call_indirect (type $$over-i32)
+ (i32.sub (local.get 0) (i32.const 1))
+ (i32.const 15)
+ )
+ )
+ )
+ )
+ (func $$odd (export "odd") (param i32) (result i32)
+ (if (result i32) (i32.eqz (local.get 0))
+ (then (i32.const 99))
+ (else
+ (call_indirect (type $$over-i32)
+ (i32.sub (local.get 0) (i32.const 1))
+ (i32.const 14)
+ )
+ )
+ )
+ )
+
+ ;; Stack exhaustion
+
+ ;; Implementations are required to have every call consume some abstract
+ ;; resource towards exhausting some abstract finite limit, such that
+ ;; infinitely recursive test cases reliably trap in finite time. This is
+ ;; because otherwise applications could come to depend on it on those
+ ;; implementations and be incompatible with implementations that don't do
+ ;; it (or don't do it under the same circumstances).
+
+ (func $$runaway (export "runaway") (call_indirect (type $$proc) (i32.const 16)))
+
+ (func $$mutual-runaway1 (export "mutual-runaway") (call_indirect (type $$proc) (i32.const 18)))
+ (func $$mutual-runaway2 (call_indirect (type $$proc) (i32.const 17)))
+
+ ;; As parameter of control constructs and instructions
+
+ (memory 1)
+
+ (func (export "as-select-first") (result i32)
+ (select (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 2) (i32.const 3))
+ )
+ (func (export "as-select-mid") (result i32)
+ (select (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 3))
+ )
+ (func (export "as-select-last") (result i32)
+ (select (i32.const 2) (i32.const 3) (call_indirect (type $$out-i32) (i32.const 0)))
+ )
+
+ (func (export "as-if-condition") (result i32)
+ (if (result i32) (call_indirect (type $$out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2)))
+ )
+
+ (func (export "as-br_if-first") (result i64)
+ (block (result i64) (br_if 0 (call_indirect (type $$out-i64) (i32.const 1)) (i32.const 2)))
+ )
+ (func (export "as-br_if-last") (result i32)
+ (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0))))
+ )
+
+ (func (export "as-br_table-first") (result f32)
+ (block (result f32) (call_indirect (type $$out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0))
+ )
+ (func (export "as-br_table-last") (result i32)
+ (block (result i32) (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0)) (br_table 0 0))
+ )
+
+ (func (export "as-store-first")
+ (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 1) (i32.store)
+ )
+ (func (export "as-store-last")
+ (i32.const 10) (call_indirect (type $$out-f64) (i32.const 3)) (f64.store)
+ )
+
+ (func (export "as-memory.grow-value") (result i32)
+ (memory.grow (call_indirect (type $$out-i32) (i32.const 0)))
+ )
+ (func (export "as-return-value") (result i32)
+ (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4)) (return)
+ )
+ (func (export "as-drop-operand")
+ (call_indirect (type $$over-i64) (i64.const 1) (i32.const 5)) (drop)
+ )
+ (func (export "as-br-value") (result f32)
+ (block (result f32) (br 0 (call_indirect (type $$over-f32) (f32.const 1) (i32.const 6))))
+ )
+ (func (export "as-local.set-value") (result f64)
+ (local f64) (local.set 0 (call_indirect (type $$over-f64) (f64.const 1) (i32.const 7))) (local.get 0)
+ )
+ (func (export "as-local.tee-value") (result f64)
+ (local f64) (local.tee 0 (call_indirect (type $$over-f64) (f64.const 1) (i32.const 7)))
+ )
+ (global $$a (mut f64) (f64.const 10.0))
+ (func (export "as-global.set-value") (result f64)
+ (global.set $$a (call_indirect (type $$over-f64) (f64.const 1.0) (i32.const 7)))
+ (global.get $$a)
+ )
+
+ (func (export "as-load-operand") (result i32)
+ (i32.load (call_indirect (type $$out-i32) (i32.const 0)))
+ )
+
+ (func (export "as-unary-operand") (result f32)
+ (block (result f32)
+ (f32.sqrt
+ (call_indirect (type $$over-f32) (f32.const 0x0p+0) (i32.const 6))
+ )
+ )
+ )
+
+ (func (export "as-binary-left") (result i32)
+ (block (result i32)
+ (i32.add
+ (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+ (i32.const 10)
+ )
+ )
+ )
+ (func (export "as-binary-right") (result i32)
+ (block (result i32)
+ (i32.sub
+ (i32.const 10)
+ (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+ )
+ )
+ )
+
+ (func (export "as-test-operand") (result i32)
+ (block (result i32)
+ (i32.eqz
+ (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+ )
+ )
+ )
+
+ (func (export "as-compare-left") (result i32)
+ (block (result i32)
+ (i32.le_u
+ (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+ (i32.const 10)
+ )
+ )
+ )
+ (func (export "as-compare-right") (result i32)
+ (block (result i32)
+ (i32.ne
+ (i32.const 10)
+ (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+ )
+ )
+ )
+
+ (func (export "as-convert-operand") (result i64)
+ (block (result i64)
+ (i64.extend_i32_s
+ (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+ )
+ )
+ )
+
+)`);
+
+// ./test/core/call_indirect.wast:471
+assert_return(() => invoke($0, `type-i32`, []), [value("i32", 306)]);
+
+// ./test/core/call_indirect.wast:472
+assert_return(() => invoke($0, `type-i64`, []), [value("i64", 356n)]);
+
+// ./test/core/call_indirect.wast:473
+assert_return(() => invoke($0, `type-f32`, []), [value("f32", 3890)]);
+
+// ./test/core/call_indirect.wast:474
+assert_return(() => invoke($0, `type-f64`, []), [value("f64", 3940)]);
+
+// ./test/core/call_indirect.wast:475
+assert_return(() => invoke($0, `type-f64-i32`, []), [value("f64", 3940), value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:477
+assert_return(() => invoke($0, `type-index`, []), [value("i64", 100n)]);
+
+// ./test/core/call_indirect.wast:479
+assert_return(() => invoke($0, `type-first-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:480
+assert_return(() => invoke($0, `type-first-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call_indirect.wast:481
+assert_return(() => invoke($0, `type-first-f32`, []), [value("f32", 1.32)]);
+
+// ./test/core/call_indirect.wast:482
+assert_return(() => invoke($0, `type-first-f64`, []), [value("f64", 1.64)]);
+
+// ./test/core/call_indirect.wast:484
+assert_return(() => invoke($0, `type-second-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:485
+assert_return(() => invoke($0, `type-second-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call_indirect.wast:486
+assert_return(() => invoke($0, `type-second-f32`, []), [value("f32", 32)]);
+
+// ./test/core/call_indirect.wast:487
+assert_return(() => invoke($0, `type-second-f64`, []), [value("f64", 64.1)]);
+
+// ./test/core/call_indirect.wast:489
+assert_return(() => invoke($0, `type-all-f64-i32`, []), [value("f64", 3940), value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:490
+assert_return(() => invoke($0, `type-all-i32-f64`, []), [value("i32", 1), value("f64", 2)]);
+
+// ./test/core/call_indirect.wast:491
+assert_return(() => invoke($0, `type-all-i32-i64`, []), [value("i64", 2n), value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:493
+assert_return(() => invoke($0, `dispatch`, [5, 2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:494
+assert_return(() => invoke($0, `dispatch`, [5, 5n]), [value("i64", 5n)]);
+
+// ./test/core/call_indirect.wast:495
+assert_return(() => invoke($0, `dispatch`, [12, 5n]), [value("i64", 120n)]);
+
+// ./test/core/call_indirect.wast:496
+assert_return(() => invoke($0, `dispatch`, [13, 5n]), [value("i64", 8n)]);
+
+// ./test/core/call_indirect.wast:497
+assert_return(() => invoke($0, `dispatch`, [20, 2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:498
+assert_trap(() => invoke($0, `dispatch`, [0, 2n]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:499
+assert_trap(() => invoke($0, `dispatch`, [15, 2n]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:500
+assert_trap(() => invoke($0, `dispatch`, [32, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:501
+assert_trap(() => invoke($0, `dispatch`, [-1, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:502
+assert_trap(() => invoke($0, `dispatch`, [1213432423, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:504
+assert_return(() => invoke($0, `dispatch-structural-i64`, [5]), [value("i64", 9n)]);
+
+// ./test/core/call_indirect.wast:505
+assert_return(() => invoke($0, `dispatch-structural-i64`, [12]), [value("i64", 362880n)]);
+
+// ./test/core/call_indirect.wast:506
+assert_return(() => invoke($0, `dispatch-structural-i64`, [13]), [value("i64", 55n)]);
+
+// ./test/core/call_indirect.wast:507
+assert_return(() => invoke($0, `dispatch-structural-i64`, [20]), [value("i64", 9n)]);
+
+// ./test/core/call_indirect.wast:508
+assert_trap(() => invoke($0, `dispatch-structural-i64`, [11]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:509
+assert_trap(() => invoke($0, `dispatch-structural-i64`, [22]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:511
+assert_return(() => invoke($0, `dispatch-structural-i32`, [4]), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:512
+assert_return(() => invoke($0, `dispatch-structural-i32`, [23]), [value("i32", 362880)]);
+
+// ./test/core/call_indirect.wast:513
+assert_return(() => invoke($0, `dispatch-structural-i32`, [26]), [value("i32", 55)]);
+
+// ./test/core/call_indirect.wast:514
+assert_return(() => invoke($0, `dispatch-structural-i32`, [19]), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:515
+assert_trap(() => invoke($0, `dispatch-structural-i32`, [9]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:516
+assert_trap(() => invoke($0, `dispatch-structural-i32`, [21]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:518
+assert_return(() => invoke($0, `dispatch-structural-f32`, [6]), [value("f32", 9)]);
+
+// ./test/core/call_indirect.wast:519
+assert_return(() => invoke($0, `dispatch-structural-f32`, [24]), [value("f32", 362880)]);
+
+// ./test/core/call_indirect.wast:520
+assert_return(() => invoke($0, `dispatch-structural-f32`, [27]), [value("f32", 55)]);
+
+// ./test/core/call_indirect.wast:521
+assert_return(() => invoke($0, `dispatch-structural-f32`, [21]), [value("f32", 9)]);
+
+// ./test/core/call_indirect.wast:522
+assert_trap(() => invoke($0, `dispatch-structural-f32`, [8]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:523
+assert_trap(() => invoke($0, `dispatch-structural-f32`, [19]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:525
+assert_return(() => invoke($0, `dispatch-structural-f64`, [7]), [value("f64", 9)]);
+
+// ./test/core/call_indirect.wast:526
+assert_return(() => invoke($0, `dispatch-structural-f64`, [25]), [value("f64", 362880)]);
+
+// ./test/core/call_indirect.wast:527
+assert_return(() => invoke($0, `dispatch-structural-f64`, [28]), [value("f64", 55)]);
+
+// ./test/core/call_indirect.wast:528
+assert_return(() => invoke($0, `dispatch-structural-f64`, [22]), [value("f64", 9)]);
+
+// ./test/core/call_indirect.wast:529
+assert_trap(() => invoke($0, `dispatch-structural-f64`, [10]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:530
+assert_trap(() => invoke($0, `dispatch-structural-f64`, [18]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:532
+assert_return(() => invoke($0, `fac-i64`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:533
+assert_return(() => invoke($0, `fac-i64`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:534
+assert_return(() => invoke($0, `fac-i64`, [5n]), [value("i64", 120n)]);
+
+// ./test/core/call_indirect.wast:535
+assert_return(() => invoke($0, `fac-i64`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/call_indirect.wast:537
+assert_return(() => invoke($0, `fac-i32`, [0]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:538
+assert_return(() => invoke($0, `fac-i32`, [1]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:539
+assert_return(() => invoke($0, `fac-i32`, [5]), [value("i32", 120)]);
+
+// ./test/core/call_indirect.wast:540
+assert_return(() => invoke($0, `fac-i32`, [10]), [value("i32", 3628800)]);
+
+// ./test/core/call_indirect.wast:542
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:543
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:544
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 5)]), [value("f32", 120)]);
+
+// ./test/core/call_indirect.wast:545
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 10)]), [value("f32", 3628800)]);
+
+// ./test/core/call_indirect.wast:547
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:548
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:549
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 5)]), [value("f64", 120)]);
+
+// ./test/core/call_indirect.wast:550
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 10)]), [value("f64", 3628800)]);
+
+// ./test/core/call_indirect.wast:552
+assert_return(() => invoke($0, `fib-i64`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:553
+assert_return(() => invoke($0, `fib-i64`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:554
+assert_return(() => invoke($0, `fib-i64`, [2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:555
+assert_return(() => invoke($0, `fib-i64`, [5n]), [value("i64", 8n)]);
+
+// ./test/core/call_indirect.wast:556
+assert_return(() => invoke($0, `fib-i64`, [20n]), [value("i64", 10946n)]);
+
+// ./test/core/call_indirect.wast:558
+assert_return(() => invoke($0, `fib-i32`, [0]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:559
+assert_return(() => invoke($0, `fib-i32`, [1]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:560
+assert_return(() => invoke($0, `fib-i32`, [2]), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:561
+assert_return(() => invoke($0, `fib-i32`, [5]), [value("i32", 8)]);
+
+// ./test/core/call_indirect.wast:562
+assert_return(() => invoke($0, `fib-i32`, [20]), [value("i32", 10946)]);
+
+// ./test/core/call_indirect.wast:564
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:565
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:566
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 2)]), [value("f32", 2)]);
+
+// ./test/core/call_indirect.wast:567
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 5)]), [value("f32", 8)]);
+
+// ./test/core/call_indirect.wast:568
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 20)]), [value("f32", 10946)]);
+
+// ./test/core/call_indirect.wast:570
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:571
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:572
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 2)]), [value("f64", 2)]);
+
+// ./test/core/call_indirect.wast:573
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 5)]), [value("f64", 8)]);
+
+// ./test/core/call_indirect.wast:574
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 20)]), [value("f64", 10946)]);
+
+// ./test/core/call_indirect.wast:576
+assert_return(() => invoke($0, `even`, [0]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:577
+assert_return(() => invoke($0, `even`, [1]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:578
+assert_return(() => invoke($0, `even`, [100]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:579
+assert_return(() => invoke($0, `even`, [77]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:580
+assert_return(() => invoke($0, `odd`, [0]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:581
+assert_return(() => invoke($0, `odd`, [1]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:582
+assert_return(() => invoke($0, `odd`, [200]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:583
+assert_return(() => invoke($0, `odd`, [77]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:585
+assert_exhaustion(() => invoke($0, `runaway`, []), `call stack exhausted`);
+
+// ./test/core/call_indirect.wast:586
+assert_exhaustion(() => invoke($0, `mutual-runaway`, []), `call stack exhausted`);
+
+// ./test/core/call_indirect.wast:588
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 306)]);
+
+// ./test/core/call_indirect.wast:589
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:590
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:592
+assert_return(() => invoke($0, `as-if-condition`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:594
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i64", 356n)]);
+
+// ./test/core/call_indirect.wast:595
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:597
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("f32", 3890)]);
+
+// ./test/core/call_indirect.wast:598
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:600
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/call_indirect.wast:601
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/call_indirect.wast:603
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:604
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:605
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/call_indirect.wast:606
+assert_return(() => invoke($0, `as-br-value`, []), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:607
+assert_return(() => invoke($0, `as-local.set-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:608
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:609
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:610
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:612
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("f32", 0)]);
+
+// ./test/core/call_indirect.wast:613
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 11)]);
+
+// ./test/core/call_indirect.wast:614
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:615
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/call_indirect.wast:616
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:617
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:618
+assert_return(() => invoke($0, `as-convert-operand`, []), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:623
+let $1 = instantiate(`(module
+ (type $$ii-i (func (param i32 i32) (result i32)))
+
+ (table $$t1 funcref (elem $$f $$g))
+ (table $$t2 funcref (elem $$h $$i $$j))
+ (table $$t3 4 funcref)
+ (elem (table $$t3) (i32.const 0) func $$g $$h)
+ (elem (table $$t3) (i32.const 3) func $$z)
+
+ (func $$f (type $$ii-i) (i32.add (local.get 0) (local.get 1)))
+ (func $$g (type $$ii-i) (i32.sub (local.get 0) (local.get 1)))
+ (func $$h (type $$ii-i) (i32.mul (local.get 0) (local.get 1)))
+ (func $$i (type $$ii-i) (i32.div_u (local.get 0) (local.get 1)))
+ (func $$j (type $$ii-i) (i32.rem_u (local.get 0) (local.get 1)))
+ (func $$z)
+
+ (func (export "call-1") (param i32 i32 i32) (result i32)
+ (call_indirect $$t1 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+ )
+ (func (export "call-2") (param i32 i32 i32) (result i32)
+ (call_indirect $$t2 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+ )
+ (func (export "call-3") (param i32 i32 i32) (result i32)
+ (call_indirect $$t3 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+ )
+)`);
+
+// ./test/core/call_indirect.wast:650
+assert_return(() => invoke($1, `call-1`, [2, 3, 0]), [value("i32", 5)]);
+
+// ./test/core/call_indirect.wast:651
+assert_return(() => invoke($1, `call-1`, [2, 3, 1]), [value("i32", -1)]);
+
+// ./test/core/call_indirect.wast:652
+assert_trap(() => invoke($1, `call-1`, [2, 3, 2]), `undefined element`);
+
+// ./test/core/call_indirect.wast:654
+assert_return(() => invoke($1, `call-2`, [2, 3, 0]), [value("i32", 6)]);
+
+// ./test/core/call_indirect.wast:655
+assert_return(() => invoke($1, `call-2`, [2, 3, 1]), [value("i32", 0)]);
+
+// ./test/core/call_indirect.wast:656
+assert_return(() => invoke($1, `call-2`, [2, 3, 2]), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:657
+assert_trap(() => invoke($1, `call-2`, [2, 3, 3]), `undefined element`);
+
+// ./test/core/call_indirect.wast:659
+assert_return(() => invoke($1, `call-3`, [2, 3, 0]), [value("i32", -1)]);
+
+// ./test/core/call_indirect.wast:660
+assert_return(() => invoke($1, `call-3`, [2, 3, 1]), [value("i32", 6)]);
+
+// ./test/core/call_indirect.wast:661
+assert_trap(() => invoke($1, `call-3`, [2, 3, 2]), `uninitialized element`);
+
+// ./test/core/call_indirect.wast:662
+assert_trap(() => invoke($1, `call-3`, [2, 3, 3]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:663
+assert_trap(() => invoke($1, `call-3`, [2, 3, 4]), `undefined element`);
+
+// ./test/core/call_indirect.wast:668
+assert_malformed(
+ () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32) (call_indirect (type $$sig) (result i32) (param i32) (i32.const 0) (i32.const 0) ) ) `),
+ `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:680
+assert_malformed(
+ () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32) (call_indirect (param i32) (type $$sig) (result i32) (i32.const 0) (i32.const 0) ) ) `),
+ `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:692
+assert_malformed(
+ () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32) (call_indirect (param i32) (result i32) (type $$sig) (i32.const 0) (i32.const 0) ) ) `),
+ `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:704
+assert_malformed(
+ () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32) (call_indirect (result i32) (type $$sig) (param i32) (i32.const 0) (i32.const 0) ) ) `),
+ `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:716
+assert_malformed(
+ () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32) (call_indirect (result i32) (param i32) (type $$sig) (i32.const 0) (i32.const 0) ) ) `),
+ `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:728
+assert_malformed(
+ () => instantiate(`(table 0 funcref) (func (result i32) (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0)) ) `),
+ `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:738
+assert_malformed(
+ () => instantiate(`(table 0 funcref) (func (call_indirect (param $$x i32) (i32.const 0) (i32.const 0))) `),
+ `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:745
+assert_malformed(
+ () => instantiate(`(type $$sig (func)) (table 0 funcref) (func (result i32) (call_indirect (type $$sig) (result i32) (i32.const 0)) ) `),
+ `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:755
+assert_malformed(
+ () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32) (call_indirect (type $$sig) (result i32) (i32.const 0)) ) `),
+ `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:765
+assert_malformed(
+ () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (call_indirect (type $$sig) (param i32) (i32.const 0) (i32.const 0)) ) `),
+ `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:775
+assert_malformed(
+ () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (table 0 funcref) (func (result i32) (call_indirect (type $$sig) (param i32) (result i32) (i32.const 0) (i32.const 0) ) ) `),
+ `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:790
+assert_invalid(
+ () => instantiate(`(module
+ (type (func))
+ (func $$no-table (call_indirect (type 0) (i32.const 0)))
+ )`),
+ `unknown table`,
+);
+
+// ./test/core/call_indirect.wast:798
+assert_invalid(
+ () => instantiate(`(module
+ (type (func))
+ (table 0 funcref)
+ (func $$type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:806
+assert_invalid(
+ () => instantiate(`(module
+ (type (func (result i64)))
+ (table 0 funcref)
+ (func $$type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:815
+assert_invalid(
+ () => instantiate(`(module
+ (type (func (param i32)))
+ (table 0 funcref)
+ (func $$arity-0-vs-1 (call_indirect (type 0) (i32.const 0)))
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:823
+assert_invalid(
+ () => instantiate(`(module
+ (type (func (param f64 i32)))
+ (table 0 funcref)
+ (func $$arity-0-vs-2 (call_indirect (type 0) (i32.const 0)))
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:831
+assert_invalid(
+ () => instantiate(`(module
+ (type (func))
+ (table 0 funcref)
+ (func $$arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0)))
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:839
+assert_invalid(
+ () => instantiate(`(module
+ (type (func))
+ (table 0 funcref)
+ (func $$arity-2-vs-0
+ (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:850
+assert_invalid(
+ () => instantiate(`(module
+ (type (func (param i32)))
+ (table 0 funcref)
+ (func $$type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop)))
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:858
+assert_invalid(
+ () => instantiate(`(module
+ (type (func (param i32)))
+ (table 0 funcref)
+ (func $$type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1)))
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:867
+assert_invalid(
+ () => instantiate(`(module
+ (type (func (param i32 i32)))
+ (table 0 funcref)
+ (func $$type-first-void-vs-num
+ (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:877
+assert_invalid(
+ () => instantiate(`(module
+ (type (func (param i32 i32)))
+ (table 0 funcref)
+ (func $$type-second-void-vs-num
+ (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:887
+assert_invalid(
+ () => instantiate(`(module
+ (type (func (param i32 f64)))
+ (table 0 funcref)
+ (func $$type-first-num-vs-num
+ (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:897
+assert_invalid(
+ () => instantiate(`(module
+ (type (func (param f64 i32)))
+ (table 0 funcref)
+ (func $$type-second-num-vs-num
+ (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:908
+assert_invalid(
+ () => instantiate(`(module
+ (func $$f (param i32))
+ (type $$sig (func (param i32)))
+ (table funcref (elem $$f))
+ (func $$type-first-empty-in-block
+ (block
+ (call_indirect (type $$sig) (i32.const 0))
+ )
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:921
+assert_invalid(
+ () => instantiate(`(module
+ (func $$f (param i32 i32))
+ (type $$sig (func (param i32 i32)))
+ (table funcref (elem $$f))
+ (func $$type-second-empty-in-block
+ (block
+ (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+ )
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:934
+assert_invalid(
+ () => instantiate(`(module
+ (func $$f (param i32))
+ (type $$sig (func (param i32)))
+ (table funcref (elem $$f))
+ (func $$type-first-empty-in-loop
+ (loop
+ (call_indirect (type $$sig) (i32.const 0))
+ )
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:947
+assert_invalid(
+ () => instantiate(`(module
+ (func $$f (param i32 i32))
+ (type $$sig (func (param i32 i32)))
+ (table funcref (elem $$f))
+ (func $$type-second-empty-in-loop
+ (loop
+ (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+ )
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:960
+assert_invalid(
+ () => instantiate(`(module
+ (func $$f (param i32))
+ (type $$sig (func (param i32)))
+ (table funcref (elem $$f))
+ (func $$type-first-empty-in-then
+ (i32.const 0) (i32.const 0)
+ (if
+ (then
+ (call_indirect (type $$sig) (i32.const 0))
+ )
+ )
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:976
+assert_invalid(
+ () => instantiate(`(module
+ (func $$f (param i32 i32))
+ (type $$sig (func (param i32 i32)))
+ (table funcref (elem $$f))
+ (func $$type-second-empty-in-then
+ (i32.const 0) (i32.const 0)
+ (if
+ (then
+ (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+ )
+ )
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:996
+assert_invalid(
+ () => instantiate(`(module
+ (table 0 funcref)
+ (func $$unbound-type (call_indirect (type 1) (i32.const 0)))
+ )`),
+ `unknown type`,
+);
+
+// ./test/core/call_indirect.wast:1003
+assert_invalid(
+ () => instantiate(`(module
+ (table 0 funcref)
+ (func $$large-type (call_indirect (type 1012321300) (i32.const 0)))
+ )`),
+ `unknown type`,
+);
+
+// ./test/core/call_indirect.wast:1014
+assert_invalid(
+ () => instantiate(`(module (table funcref (elem 0 0)))`),
+ `unknown function`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/custom.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/custom.wast.js
new file mode 100644
index 0000000000..747db66dec
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/custom.wast.js
@@ -0,0 +1,157 @@
+/* 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/custom.wast
+
+// ./test/core/custom.wast:1
+let $0 = instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\00\\24\\10" "a custom section" "this is the payload"
+ "\\00\\20\\10" "a custom section" "this is payload"
+ "\\00\\11\\10" "a custom section" ""
+ "\\00\\10\\00" "" "this is payload"
+ "\\00\\01\\00" "" ""
+ "\\00\\24\\10" "\\00\\00custom sectio\\00" "this is the payload"
+ "\\00\\24\\10" "\\ef\\bb\\bfa custom sect" "this is the payload"
+ "\\00\\24\\10" "a custom sect\\e2\\8c\\a3" "this is the payload"
+ "\\00\\1f\\16" "module within a module" "\\00asm" "\\01\\00\\00\\00"
+)`);
+
+// ./test/core/custom.wast:14
+let $1 = instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\01\\01\\00" ;; type section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\02\\01\\00" ;; import section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\03\\01\\00" ;; function section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\04\\01\\00" ;; table section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\05\\01\\00" ;; memory section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\06\\01\\00" ;; global section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\07\\01\\00" ;; export section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\09\\01\\00" ;; element section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\0a\\01\\00" ;; code section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+ "\\0b\\01\\00" ;; data section
+ "\\00\\0e\\06" "custom" "payload"
+ "\\00\\0e\\06" "custom" "payload"
+)`);
+
+// ./test/core/custom.wast:50
+let $2 = instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\01\\07\\01\\60\\02\\7f\\7f\\01\\7f" ;; type section
+ "\\00\\1a\\06" "custom" "this is the payload" ;; custom section
+ "\\03\\02\\01\\00" ;; function section
+ "\\07\\0a\\01\\06\\61\\64\\64\\54\\77\\6f\\00\\00" ;; export section
+ "\\0a\\09\\01\\07\\00\\20\\00\\20\\01\\6a\\0b" ;; code section
+ "\\00\\1b\\07" "custom2" "this is the payload" ;; custom section
+)`);
+
+// ./test/core/custom.wast:60
+assert_malformed(
+ () => instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\00"
+ )`),
+ `unexpected end`,
+);
+
+// ./test/core/custom.wast:68
+assert_malformed(
+ () => instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\00\\00"
+ )`),
+ `unexpected end`,
+);
+
+// ./test/core/custom.wast:76
+assert_malformed(
+ () => instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\00\\00\\00\\05\\01\\00\\07\\00\\00"
+ )`),
+ `unexpected end`,
+);
+
+// ./test/core/custom.wast:84
+assert_malformed(
+ () => instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\00\\26\\10" "a custom section" "this is the payload"
+ )`),
+ `unexpected end`,
+);
+
+// ./test/core/custom.wast:92
+assert_malformed(
+ () => instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\00\\25\\10" "a custom section" "this is the payload"
+ "\\00\\24\\10" "a custom section" "this is the payload"
+ )`),
+ `malformed section id`,
+);
+
+// ./test/core/custom.wast:101
+assert_malformed(
+ () => instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\01\\07\\01\\60\\02\\7f\\7f\\01\\7f" ;; type section
+ "\\00\\25\\10" "a custom section" "this is the payload" ;; wrong length!
+ "\\03\\02\\01\\00" ;; function section
+ "\\0a\\09\\01\\07\\00\\20\\00\\20\\01\\6a\\0b" ;; code section
+ "\\00\\1b\\07" "custom2" "this is the payload" ;; custom section
+ )`),
+ `function and code section have inconsistent lengths`,
+);
+
+// ./test/core/custom.wast:114
+assert_malformed(
+ () => instantiate(`(module binary
+ "\\00asm\\01\\00\\00\\00"
+ "\\00asm\\01\\00\\00\\00"
+ )`),
+ `length out of bounds`,
+);
+
+// ./test/core/custom.wast:122
+assert_malformed(
+ () => instantiate(`(module binary
+ "\\00asm" "\\01\\00\\00\\00"
+ "\\05\\03\\01\\00\\01" ;; memory section
+ "\\0c\\01\\02" ;; data count section (2 segments)
+ "\\0b\\06\\01\\00\\41\\00\\0b\\00" ;; data section (1 segment)
+ )`),
+ `data count and data section have inconsistent lengths`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/directives.txt b/js/src/jit-test/tests/wasm/spec/exception-handling/directives.txt
new file mode 100644
index 0000000000..82c2a20004
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; 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
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/harness/directives.txt b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/directives.txt
new file mode 100644
index 0000000000..d41243abbb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/directives.txt
@@ -0,0 +1 @@
+|jit-test| skip-if: true \ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js
new file mode 100644
index 0000000000..ba615e05dd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js
@@ -0,0 +1,360 @@
+"use strict";
+
+/* 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.
+ */
+
+if (!wasmIsSupported()) {
+ quit();
+}
+
+function bytes(type, bytes) {
+ var typedBuffer = new Uint8Array(bytes);
+ return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+}
+function value(type, value) {
+ return new WebAssembly.Global({
+ value: type,
+ mutable: false,
+ }, value);
+}
+
+function i8x16(elements) {
+ let typedBuffer = new Uint8Array(elements);
+ return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i16x8(elements) {
+ let typedBuffer = new Uint16Array(elements);
+ return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i32x4(elements) {
+ let typedBuffer = new Uint32Array(elements);
+ return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i64x2(elements) {
+ let typedBuffer = new BigUint64Array(elements);
+ return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f32x4(elements) {
+ let typedBuffer = new Float32Array(elements);
+ return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f64x2(elements) {
+ let typedBuffer = new Float64Array(elements);
+ return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+
+function either(...arr) {
+ return new EitherVariants(arr);
+}
+
+class F32x4Pattern {
+ constructor(x, y, z, w) {
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ this.w = w;
+ }
+}
+
+class F64x2Pattern {
+ constructor(x, y) {
+ this.x = x;
+ this.y = y;
+ }
+}
+
+let externrefs = {};
+let externsym = Symbol("externref");
+function externref(s) {
+ if (!(s in externrefs)) externrefs[s] = { [externsym]: s };
+ return externrefs[s];
+}
+function is_externref(x) {
+ return (x !== null && externsym in x) ? 1 : 0;
+}
+function is_funcref(x) {
+ return typeof x === "function" ? 1 : 0;
+}
+function eq_externref(x, y) {
+ return x === y ? 1 : 0;
+}
+function eq_funcref(x, y) {
+ return x === y ? 1 : 0;
+}
+
+let spectest = {
+ externref: externref,
+ is_externref: is_externref,
+ is_funcref: is_funcref,
+ eq_externref: eq_externref,
+ eq_funcref: eq_funcref,
+ print: console.log.bind(console),
+ print_i32: console.log.bind(console),
+ print_i32_f32: console.log.bind(console),
+ print_f64_f64: console.log.bind(console),
+ print_f32: console.log.bind(console),
+ print_f64: console.log.bind(console),
+ global_i32: 666,
+ global_i64: 666n,
+ global_f32: 666,
+ global_f64: 666,
+ table: new WebAssembly.Table({
+ initial: 10,
+ maximum: 20,
+ element: "anyfunc",
+ }),
+ memory: new WebAssembly.Memory({ initial: 1, maximum: 2 }),
+};
+
+let linkage = {
+ spectest,
+};
+
+function getInstance(instanceish) {
+ if (typeof instanceish === "string") {
+ assertEq(
+ instanceish in linkage,
+ true,
+ `'${instanceish}'' must be registered`,
+ );
+ return linkage[instanceish];
+ }
+ return instanceish;
+}
+
+function instantiate(source) {
+ let bytecode = wasmTextToBinary(source);
+ let module = new WebAssembly.Module(bytecode);
+ let instance = new WebAssembly.Instance(module, linkage);
+ return instance.exports;
+}
+
+function register(instanceish, name) {
+ linkage[name] = getInstance(instanceish);
+}
+
+function invoke(instanceish, field, params) {
+ let func = getInstance(instanceish)[field];
+ assertEq(func instanceof Function, true, "expected a function");
+ return wasmLosslessInvoke(func, ...params);
+}
+
+function get(instanceish, field) {
+ let global = getInstance(instanceish)[field];
+ assertEq(
+ global instanceof WebAssembly.Global,
+ true,
+ "expected a WebAssembly.Global",
+ );
+ return global;
+}
+
+function assert_trap(thunk, message) {
+ try {
+ thunk();
+ assertEq("normal return", "trap");
+ } catch (err) {
+ assertEq(
+ err instanceof WebAssembly.RuntimeError,
+ true,
+ "expected trap",
+ );
+ }
+}
+
+let StackOverflow;
+try {
+ (function f() {
+ 1 + f();
+ })();
+} catch (e) {
+ StackOverflow = e.constructor;
+}
+function assert_exhaustion(thunk, message) {
+ try {
+ thunk();
+ assertEq("normal return", "exhaustion");
+ } catch (err) {
+ assertEq(
+ err instanceof StackOverflow,
+ true,
+ "expected exhaustion",
+ );
+ }
+}
+
+function assert_invalid(thunk, message) {
+ try {
+ thunk();
+ assertEq("valid module", "invalid module");
+ } catch (err) {
+ assertEq(
+ err instanceof WebAssembly.LinkError ||
+ err instanceof WebAssembly.CompileError,
+ true,
+ "expected an invalid module",
+ );
+ }
+}
+
+function assert_unlinkable(thunk, message) {
+ try {
+ thunk();
+ assertEq(true, false, "expected an unlinkable module");
+ } catch (err) {
+ assertEq(
+ err instanceof WebAssembly.LinkError ||
+ err instanceof WebAssembly.CompileError,
+ true,
+ "expected an unlinkable module",
+ );
+ }
+}
+
+function assert_malformed(thunk, message) {
+ try {
+ thunk();
+ assertEq("valid module", "malformed module");
+ } catch (err) {
+ assertEq(
+ err instanceof TypeError ||
+ err instanceof SyntaxError ||
+ 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];
+ }
+ if (!Array.isArray(expected)) {
+ expected = [expected];
+ }
+
+ if (!compareResults(results, expected)) {
+ let got = results.map((x) => formatResult(x)).join(", ");
+ let wanted = expected.map((x) => formatExpected(x)).join(", ");
+ assertEq(
+ `[${got}]`,
+ `[${wanted}]`,
+ );
+ assertEq(true, false, `${got} !== ${wanted}`);
+ }
+}
+
+function formatResult(result) {
+ if (typeof (result) === "object") {
+ return wasmGlobalToString(result);
+ } else {
+ return `${result}`;
+ }
+}
+
+function formatExpected(expected) {
+ if (
+ expected === `f32_canonical_nan` ||
+ expected === `f32_arithmetic_nan` ||
+ expected === `f64_canonical_nan` ||
+ expected === `f64_arithmetic_nan`
+ ) {
+ return expected;
+ } else if (expected instanceof F32x4Pattern) {
+ return `f32x4(${formatExpected(expected.x)}, ${
+ formatExpected(expected.y)
+ }, ${formatExpected(expected.z)}, ${formatExpected(expected.w)})`;
+ } else if (expected instanceof F64x2Pattern) {
+ return `f64x2(${formatExpected(expected.x)}, ${
+ formatExpected(expected.y)
+ })`;
+ } else if (expected instanceof EitherVariants) {
+ return expected.formatExpected();
+ } else if (typeof (expected) === "object") {
+ return wasmGlobalToString(expected);
+ } else {
+ throw new Error("unknown expected result");
+ }
+}
+
+class EitherVariants {
+ constructor(arr) {
+ this.arr = arr;
+ }
+ matches(v) {
+ return this.arr.some((e) => compareResult(v, e));
+ }
+ formatExpected() {
+ return `either(${this.arr.map(formatExpected).join(", ")})`;
+ }
+}
+
+function compareResults(results, expected) {
+ if (results.length !== expected.length) {
+ return false;
+ }
+ for (let i in results) {
+ if (expected[i] instanceof EitherVariants) {
+ return expected[i].matches(results[i]);
+ }
+ if (!compareResult(results[i], expected[i])) {
+ return false;
+ }
+ }
+ return true;
+}
+
+function compareResult(result, expected) {
+ if (
+ expected === `canonical_nan` ||
+ expected === `arithmetic_nan`
+ ) {
+ return wasmGlobalIsNaN(result, expected);
+ } else if (expected instanceof F32x4Pattern) {
+ return compareResult(
+ wasmGlobalExtractLane(result, "f32x4", 0),
+ expected.x,
+ ) &&
+ compareResult(wasmGlobalExtractLane(result, "f32x4", 1), expected.y) &&
+ compareResult(wasmGlobalExtractLane(result, "f32x4", 2), expected.z) &&
+ compareResult(wasmGlobalExtractLane(result, "f32x4", 3), expected.w);
+ } else if (expected instanceof F64x2Pattern) {
+ return compareResult(
+ wasmGlobalExtractLane(result, "f64x2", 0),
+ expected.x,
+ ) &&
+ compareResult(wasmGlobalExtractLane(result, "f64x2", 1), expected.y);
+ } else if (typeof (expected) === "object") {
+ return wasmGlobalsEqual(result, expected);
+ } else {
+ throw new Error("unknown expected result");
+ }
+}
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/rethrow.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/rethrow.wast.js
new file mode 100644
index 0000000000..a995b8dc37
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/rethrow.wast.js
@@ -0,0 +1,140 @@
+/* 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))
+ )
+ )
+ )
+ )
+
+ (func (export "rethrow-stack-polymorphism")
+ (try
+ (do (throw $$e0))
+ (catch $$e0 (i32.const 1) (rethrow 0))
+ )
+ )
+)`);
+
+// ./test/core/rethrow.wast:75
+assert_exception(() => invoke($0, `catch-rethrow-0`, []));
+
+// ./test/core/rethrow.wast:77
+assert_exception(() => invoke($0, `catch-rethrow-1`, [0]));
+
+// ./test/core/rethrow.wast:78
+assert_return(() => invoke($0, `catch-rethrow-1`, [1]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:80
+assert_exception(() => invoke($0, `catchall-rethrow-0`, []));
+
+// ./test/core/rethrow.wast:82
+assert_exception(() => invoke($0, `catchall-rethrow-1`, [0]));
+
+// ./test/core/rethrow.wast:83
+assert_return(() => invoke($0, `catchall-rethrow-1`, [1]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:84
+assert_exception(() => invoke($0, `rethrow-nested`, [0]));
+
+// ./test/core/rethrow.wast:85
+assert_exception(() => invoke($0, `rethrow-nested`, [1]));
+
+// ./test/core/rethrow.wast:86
+assert_return(() => invoke($0, `rethrow-nested`, [2]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:88
+assert_return(() => invoke($0, `rethrow-recatch`, [0]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:89
+assert_return(() => invoke($0, `rethrow-recatch`, [1]), [value("i32", 42)]);
+
+// ./test/core/rethrow.wast:91
+assert_exception(() => invoke($0, `rethrow-stack-polymorphism`, []));
+
+// ./test/core/rethrow.wast:93
+assert_invalid(() => instantiate(`(module (func (rethrow 0)))`), `invalid rethrow label`);
+
+// ./test/core/rethrow.wast:94
+assert_invalid(
+ () => instantiate(`(module (func (block (rethrow 0))))`),
+ `invalid rethrow label`,
+);
+
+// ./test/core/rethrow.wast:95
+assert_invalid(
+ () => instantiate(`(module (func (try (do (rethrow 0)) (delegate 0))))`),
+ `invalid rethrow label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_fill.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_fill.wast.js
new file mode 100644
index 0000000000..9381e67fc5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_fill.wast.js
@@ -0,0 +1,234 @@
+/* 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/table_fill.wast
+
+// ./test/core/table_fill.wast:1
+let $0 = instantiate(`(module
+ (table $$t 10 externref)
+
+ (func (export "fill") (param $$i i32) (param $$r externref) (param $$n i32)
+ (table.fill $$t (local.get $$i) (local.get $$r) (local.get $$n))
+ )
+
+ (func (export "get") (param $$i i32) (result externref)
+ (table.get $$t (local.get $$i))
+ )
+)`);
+
+// ./test/core/table_fill.wast:13
+assert_return(() => invoke($0, `get`, [1]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:14
+assert_return(() => invoke($0, `get`, [2]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:15
+assert_return(() => invoke($0, `get`, [3]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:16
+assert_return(() => invoke($0, `get`, [4]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:17
+assert_return(() => invoke($0, `get`, [5]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:19
+assert_return(() => invoke($0, `fill`, [2, externref(1), 3]), []);
+
+// ./test/core/table_fill.wast:20
+assert_return(() => invoke($0, `get`, [1]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:21
+assert_return(() => invoke($0, `get`, [2]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:22
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:23
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:24
+assert_return(() => invoke($0, `get`, [5]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:26
+assert_return(() => invoke($0, `fill`, [4, externref(2), 2]), []);
+
+// ./test/core/table_fill.wast:27
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:28
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:29
+assert_return(() => invoke($0, `get`, [5]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:30
+assert_return(() => invoke($0, `get`, [6]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:32
+assert_return(() => invoke($0, `fill`, [4, externref(3), 0]), []);
+
+// ./test/core/table_fill.wast:33
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:34
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:35
+assert_return(() => invoke($0, `get`, [5]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:37
+assert_return(() => invoke($0, `fill`, [8, externref(4), 2]), []);
+
+// ./test/core/table_fill.wast:38
+assert_return(() => invoke($0, `get`, [7]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:39
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:40
+assert_return(() => invoke($0, `get`, [9]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:42
+assert_return(() => invoke($0, `fill`, [9, null, 1]), []);
+
+// ./test/core/table_fill.wast:43
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:44
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:46
+assert_return(() => invoke($0, `fill`, [10, externref(5), 0]), []);
+
+// ./test/core/table_fill.wast:47
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:49
+assert_trap(() => invoke($0, `fill`, [8, externref(6), 3]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:53
+assert_return(() => invoke($0, `get`, [7]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:54
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:55
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:57
+assert_trap(() => invoke($0, `fill`, [11, null, 0]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:62
+assert_trap(() => invoke($0, `fill`, [11, null, 10]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:70
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-index-value-length-empty-vs-i32-i32
+ (table.fill $$t)
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:79
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-index-empty-vs-i32
+ (table.fill $$t (ref.null extern) (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:88
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-value-empty-vs
+ (table.fill $$t (i32.const 1) (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:97
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-length-empty-vs-i32
+ (table.fill $$t (i32.const 1) (ref.null extern))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:106
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 0 externref)
+ (func $$type-index-f32-vs-i32
+ (table.fill $$t (f32.const 1) (ref.null extern) (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:115
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 0 funcref)
+ (func $$type-value-vs-funcref (param $$r externref)
+ (table.fill $$t (i32.const 1) (local.get $$r) (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:124
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 0 externref)
+ (func $$type-length-f32-vs-i32
+ (table.fill $$t (i32.const 1) (ref.null extern) (f32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:134
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t1 1 externref)
+ (table $$t2 1 funcref)
+ (func $$type-value-externref-vs-funcref-multi (param $$r externref)
+ (table.fill $$t2 (i32.const 0) (local.get $$r) (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:145
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 1 externref)
+ (func $$type-result-empty-vs-num (result i32)
+ (table.fill $$t (i32.const 0) (ref.null extern) (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_get.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_get.wast.js
new file mode 100644
index 0000000000..f4982cde3a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_get.wast.js
@@ -0,0 +1,126 @@
+/* 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/table_get.wast
+
+// ./test/core/table_get.wast:1
+let $0 = instantiate(`(module
+ (table $$t2 2 externref)
+ (table $$t3 3 funcref)
+ (elem (table $$t3) (i32.const 1) func $$dummy)
+ (func $$dummy)
+
+ (func (export "init") (param $$r externref)
+ (table.set $$t2 (i32.const 1) (local.get $$r))
+ (table.set $$t3 (i32.const 2) (table.get $$t3 (i32.const 1)))
+ )
+
+ (func (export "get-externref") (param $$i i32) (result externref)
+ (table.get $$t2 (local.get $$i))
+ )
+ (func $$f3 (export "get-funcref") (param $$i i32) (result funcref)
+ (table.get $$t3 (local.get $$i))
+ )
+
+ (func (export "is_null-funcref") (param $$i i32) (result i32)
+ (ref.is_null (call $$f3 (local.get $$i)))
+ )
+)`);
+
+// ./test/core/table_get.wast:24
+invoke($0, `init`, [externref(1)]);
+
+// ./test/core/table_get.wast:26
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_get.wast:27
+assert_return(() => invoke($0, `get-externref`, [1]), [value('externref', externref(1))]);
+
+// ./test/core/table_get.wast:29
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_get.wast:30
+assert_return(() => invoke($0, `is_null-funcref`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_get.wast:31
+assert_return(() => invoke($0, `is_null-funcref`, [2]), [value("i32", 0)]);
+
+// ./test/core/table_get.wast:33
+assert_trap(() => invoke($0, `get-externref`, [2]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:34
+assert_trap(() => invoke($0, `get-funcref`, [3]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:35
+assert_trap(() => invoke($0, `get-externref`, [-1]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:36
+assert_trap(() => invoke($0, `get-funcref`, [-1]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:41
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-index-empty-vs-i32 (result externref)
+ (table.get $$t)
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_get.wast:50
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-index-f32-vs-i32 (result externref)
+ (table.get $$t (f32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_get.wast:60
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-result-externref-vs-empty
+ (table.get $$t (i32.const 0))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_get.wast:69
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-result-externref-vs-funcref (result funcref)
+ (table.get $$t (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_get.wast:79
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t1 1 funcref)
+ (table $$t2 1 externref)
+ (func $$type-result-externref-vs-funcref-multi (result funcref)
+ (table.get $$t2 (i32.const 0))
+ )
+ )`),
+ `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_grow.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_grow.wast.js
new file mode 100644
index 0000000000..f299984d66
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_grow.wast.js
@@ -0,0 +1,268 @@
+/* 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/table_grow.wast
+
+// ./test/core/table_grow.wast:1
+let $0 = instantiate(`(module
+ (table $$t 0 externref)
+
+ (func (export "get") (param $$i i32) (result externref) (table.get $$t (local.get $$i)))
+ (func (export "set") (param $$i i32) (param $$r externref) (table.set $$t (local.get $$i) (local.get $$r)))
+
+ (func (export "grow") (param $$sz i32) (param $$init externref) (result i32)
+ (table.grow $$t (local.get $$init) (local.get $$sz))
+ )
+ (func (export "size") (result i32) (table.size $$t))
+)`);
+
+// ./test/core/table_grow.wast:13
+assert_return(() => invoke($0, `size`, []), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:14
+assert_trap(() => invoke($0, `set`, [0, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:15
+assert_trap(() => invoke($0, `get`, [0]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:17
+assert_return(() => invoke($0, `grow`, [1, null]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:18
+assert_return(() => invoke($0, `size`, []), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:19
+assert_return(() => invoke($0, `get`, [0]), [value('externref', null)]);
+
+// ./test/core/table_grow.wast:20
+assert_return(() => invoke($0, `set`, [0, externref(2)]), []);
+
+// ./test/core/table_grow.wast:21
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:22
+assert_trap(() => invoke($0, `set`, [1, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:23
+assert_trap(() => invoke($0, `get`, [1]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:25
+assert_return(() => invoke($0, `grow`, [4, externref(3)]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:26
+assert_return(() => invoke($0, `size`, []), [value("i32", 5)]);
+
+// ./test/core/table_grow.wast:27
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:28
+assert_return(() => invoke($0, `set`, [0, externref(2)]), []);
+
+// ./test/core/table_grow.wast:29
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:30
+assert_return(() => invoke($0, `get`, [1]), [value('externref', externref(3))]);
+
+// ./test/core/table_grow.wast:31
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(3))]);
+
+// ./test/core/table_grow.wast:32
+assert_return(() => invoke($0, `set`, [4, externref(4)]), []);
+
+// ./test/core/table_grow.wast:33
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(4))]);
+
+// ./test/core/table_grow.wast:34
+assert_trap(() => invoke($0, `set`, [5, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:35
+assert_trap(() => invoke($0, `get`, [5]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:39
+let $1 = instantiate(`(module
+ (table $$t 0x10 funcref)
+ (elem declare func $$f)
+ (func $$f (export "grow") (result i32)
+ (table.grow $$t (ref.func $$f) (i32.const 0xffff_fff0))
+ )
+)`);
+
+// ./test/core/table_grow.wast:47
+assert_return(() => invoke($1, `grow`, []), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:50
+let $2 = instantiate(`(module
+ (table $$t 0 externref)
+ (func (export "grow") (param i32) (result i32)
+ (table.grow $$t (ref.null extern) (local.get 0))
+ )
+)`);
+
+// ./test/core/table_grow.wast:57
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:58
+assert_return(() => invoke($2, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:59
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:60
+assert_return(() => invoke($2, `grow`, [2]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:61
+assert_return(() => invoke($2, `grow`, [800]), [value("i32", 3)]);
+
+// ./test/core/table_grow.wast:64
+let $3 = instantiate(`(module
+ (table $$t 0 10 externref)
+ (func (export "grow") (param i32) (result i32)
+ (table.grow $$t (ref.null extern) (local.get 0))
+ )
+)`);
+
+// ./test/core/table_grow.wast:71
+assert_return(() => invoke($3, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:72
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:73
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:74
+assert_return(() => invoke($3, `grow`, [2]), [value("i32", 2)]);
+
+// ./test/core/table_grow.wast:75
+assert_return(() => invoke($3, `grow`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_grow.wast:76
+assert_return(() => invoke($3, `grow`, [0]), [value("i32", 10)]);
+
+// ./test/core/table_grow.wast:77
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:78
+assert_return(() => invoke($3, `grow`, [65536]), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:81
+let $4 = instantiate(`(module
+ (table $$t 10 funcref)
+ (func (export "grow") (param i32) (result i32)
+ (table.grow $$t (ref.null func) (local.get 0))
+ )
+ (elem declare func 1)
+ (func (export "check-table-null") (param i32 i32) (result funcref)
+ (local funcref)
+ (local.set 2 (ref.func 1))
+ (block
+ (loop
+ (local.set 2 (table.get $$t (local.get 0)))
+ (br_if 1 (i32.eqz (ref.is_null (local.get 2))))
+ (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+ (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+ (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+ )
+ )
+ (local.get 2)
+ )
+)`);
+
+// ./test/core/table_grow.wast:103
+assert_return(() => invoke($4, `check-table-null`, [0, 9]), [value('anyfunc', null)]);
+
+// ./test/core/table_grow.wast:104
+assert_return(() => invoke($4, `grow`, [10]), [value("i32", 10)]);
+
+// ./test/core/table_grow.wast:105
+assert_return(() => invoke($4, `check-table-null`, [0, 19]), [value('anyfunc', null)]);
+
+// ./test/core/table_grow.wast:110
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 0 externref)
+ (func $$type-init-size-empty-vs-i32-externref (result i32)
+ (table.grow $$t)
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:119
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 0 externref)
+ (func $$type-size-empty-vs-i32 (result i32)
+ (table.grow $$t (ref.null extern))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:128
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 0 externref)
+ (func $$type-init-empty-vs-externref (result i32)
+ (table.grow $$t (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:137
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 0 externref)
+ (func $$type-size-f32-vs-i32 (result i32)
+ (table.grow $$t (ref.null extern) (f32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:146
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 0 funcref)
+ (func $$type-init-externref-vs-funcref (param $$r externref) (result i32)
+ (table.grow $$t (local.get $$r) (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:156
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 1 externref)
+ (func $$type-result-i32-vs-empty
+ (table.grow $$t (ref.null extern) (i32.const 0))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:165
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 1 externref)
+ (func $$type-result-i32-vs-f32 (result f32)
+ (table.grow $$t (ref.null extern) (i32.const 0))
+ )
+ )`),
+ `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_set.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_set.wast.js
new file mode 100644
index 0000000000..b44fcfc002
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_set.wast.js
@@ -0,0 +1,177 @@
+/* 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/table_set.wast
+
+// ./test/core/table_set.wast:1
+let $0 = instantiate(`(module
+ (table $$t2 1 externref)
+ (table $$t3 2 funcref)
+ (elem (table $$t3) (i32.const 1) func $$dummy)
+ (func $$dummy)
+
+ (func (export "get-externref") (param $$i i32) (result externref)
+ (table.get $$t2 (local.get $$i))
+ )
+ (func $$f3 (export "get-funcref") (param $$i i32) (result funcref)
+ (table.get $$t3 (local.get $$i))
+ )
+
+ (func (export "set-externref") (param $$i i32) (param $$r externref)
+ (table.set $$t2 (local.get $$i) (local.get $$r))
+ )
+ (func (export "set-funcref") (param $$i i32) (param $$r funcref)
+ (table.set $$t3 (local.get $$i) (local.get $$r))
+ )
+ (func (export "set-funcref-from") (param $$i i32) (param $$j i32)
+ (table.set $$t3 (local.get $$i) (table.get $$t3 (local.get $$j)))
+ )
+
+ (func (export "is_null-funcref") (param $$i i32) (result i32)
+ (ref.is_null (call $$f3 (local.get $$i)))
+ )
+)`);
+
+// ./test/core/table_set.wast:29
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_set.wast:30
+assert_return(() => invoke($0, `set-externref`, [0, externref(1)]), []);
+
+// ./test/core/table_set.wast:31
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', externref(1))]);
+
+// ./test/core/table_set.wast:32
+assert_return(() => invoke($0, `set-externref`, [0, null]), []);
+
+// ./test/core/table_set.wast:33
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_set.wast:35
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_set.wast:36
+assert_return(() => invoke($0, `set-funcref-from`, [0, 1]), []);
+
+// ./test/core/table_set.wast:37
+assert_return(() => invoke($0, `is_null-funcref`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_set.wast:38
+assert_return(() => invoke($0, `set-funcref`, [0, null]), []);
+
+// ./test/core/table_set.wast:39
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_set.wast:41
+assert_trap(() => invoke($0, `set-externref`, [2, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:42
+assert_trap(() => invoke($0, `set-funcref`, [3, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:43
+assert_trap(() => invoke($0, `set-externref`, [-1, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:44
+assert_trap(() => invoke($0, `set-funcref`, [-1, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:46
+assert_trap(() => invoke($0, `set-externref`, [2, externref(0)]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:47
+assert_trap(() => invoke($0, `set-funcref-from`, [3, 1]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:48
+assert_trap(() => invoke($0, `set-externref`, [-1, externref(0)]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:49
+assert_trap(() => invoke($0, `set-funcref-from`, [-1, 1]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:54
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-index-value-empty-vs-i32-externref
+ (table.set $$t)
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_set.wast:63
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-index-empty-vs-i32
+ (table.set $$t (ref.null extern))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_set.wast:72
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-value-empty-vs-externref
+ (table.set $$t (i32.const 1))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_set.wast:81
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-size-f32-vs-i32
+ (table.set $$t (f32.const 1) (ref.null extern))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_set.wast:90
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 funcref)
+ (func $$type-value-externref-vs-funcref (param $$r externref)
+ (table.set $$t (i32.const 1) (local.get $$r))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_set.wast:100
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t1 1 externref)
+ (table $$t2 1 funcref)
+ (func $$type-value-externref-vs-funcref-multi (param $$r externref)
+ (table.set $$t2 (i32.const 0) (local.get $$r))
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_set.wast:111
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 10 externref)
+ (func $$type-result-empty-vs-num (result i32)
+ (table.set $$t (i32.const 0) (ref.null extern))
+ )
+ )`),
+ `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_size.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_size.wast.js
new file mode 100644
index 0000000000..1a574c2ba9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_size.wast.js
@@ -0,0 +1,172 @@
+/* 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/table_size.wast
+
+// ./test/core/table_size.wast:1
+let $0 = instantiate(`(module
+ (table $$t0 0 externref)
+ (table $$t1 1 externref)
+ (table $$t2 0 2 externref)
+ (table $$t3 3 8 externref)
+
+ (func (export "size-t0") (result i32) (table.size $$t0))
+ (func (export "size-t1") (result i32) (table.size $$t1))
+ (func (export "size-t2") (result i32) (table.size $$t2))
+ (func (export "size-t3") (result i32) (table.size $$t3))
+
+ (func (export "grow-t0") (param $$sz i32)
+ (drop (table.grow $$t0 (ref.null extern) (local.get $$sz)))
+ )
+ (func (export "grow-t1") (param $$sz i32)
+ (drop (table.grow $$t1 (ref.null extern) (local.get $$sz)))
+ )
+ (func (export "grow-t2") (param $$sz i32)
+ (drop (table.grow $$t2 (ref.null extern) (local.get $$sz)))
+ )
+ (func (export "grow-t3") (param $$sz i32)
+ (drop (table.grow $$t3 (ref.null extern) (local.get $$sz)))
+ )
+)`);
+
+// ./test/core/table_size.wast:26
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:27
+assert_return(() => invoke($0, `grow-t0`, [1]), []);
+
+// ./test/core/table_size.wast:28
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:29
+assert_return(() => invoke($0, `grow-t0`, [4]), []);
+
+// ./test/core/table_size.wast:30
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 5)]);
+
+// ./test/core/table_size.wast:31
+assert_return(() => invoke($0, `grow-t0`, [0]), []);
+
+// ./test/core/table_size.wast:32
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 5)]);
+
+// ./test/core/table_size.wast:34
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:35
+assert_return(() => invoke($0, `grow-t1`, [1]), []);
+
+// ./test/core/table_size.wast:36
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 2)]);
+
+// ./test/core/table_size.wast:37
+assert_return(() => invoke($0, `grow-t1`, [4]), []);
+
+// ./test/core/table_size.wast:38
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 6)]);
+
+// ./test/core/table_size.wast:39
+assert_return(() => invoke($0, `grow-t1`, [0]), []);
+
+// ./test/core/table_size.wast:40
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 6)]);
+
+// ./test/core/table_size.wast:42
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:43
+assert_return(() => invoke($0, `grow-t2`, [3]), []);
+
+// ./test/core/table_size.wast:44
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:45
+assert_return(() => invoke($0, `grow-t2`, [1]), []);
+
+// ./test/core/table_size.wast:46
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:47
+assert_return(() => invoke($0, `grow-t2`, [0]), []);
+
+// ./test/core/table_size.wast:48
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:49
+assert_return(() => invoke($0, `grow-t2`, [4]), []);
+
+// ./test/core/table_size.wast:50
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:51
+assert_return(() => invoke($0, `grow-t2`, [1]), []);
+
+// ./test/core/table_size.wast:52
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 2)]);
+
+// ./test/core/table_size.wast:54
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 3)]);
+
+// ./test/core/table_size.wast:55
+assert_return(() => invoke($0, `grow-t3`, [1]), []);
+
+// ./test/core/table_size.wast:56
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 4)]);
+
+// ./test/core/table_size.wast:57
+assert_return(() => invoke($0, `grow-t3`, [3]), []);
+
+// ./test/core/table_size.wast:58
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:59
+assert_return(() => invoke($0, `grow-t3`, [0]), []);
+
+// ./test/core/table_size.wast:60
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:61
+assert_return(() => invoke($0, `grow-t3`, [2]), []);
+
+// ./test/core/table_size.wast:62
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:63
+assert_return(() => invoke($0, `grow-t3`, [1]), []);
+
+// ./test/core/table_size.wast:64
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 8)]);
+
+// ./test/core/table_size.wast:69
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 1 externref)
+ (func $$type-result-i32-vs-empty
+ (table.size $$t)
+ )
+ )`),
+ `type mismatch`,
+);
+
+// ./test/core/table_size.wast:78
+assert_invalid(
+ () => instantiate(`(module
+ (table $$t 1 externref)
+ (func $$type-result-i32-vs-f32 (result f32)
+ (table.size $$t)
+ )
+ )`),
+ `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/tag.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/tag.wast.js
new file mode 100644
index 0000000000..70e75a12d1
--- /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`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/throw.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/throw.wast.js
new file mode 100644
index 0000000000..cb0baf0d4c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/throw.wast.js
@@ -0,0 +1,87 @@
+/* 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`, []), []);
+
+// ./test/core/throw.wast:47
+assert_invalid(() => instantiate(`(module (func (throw 0)))`), `unknown tag 0`);
+
+// ./test/core/throw.wast:48
+assert_invalid(
+ () => instantiate(`(module (tag (param i32)) (func (throw 0)))`),
+ `type mismatch: instruction requires [i32] but stack has []`,
+);
+
+// ./test/core/throw.wast:50
+assert_invalid(
+ () => instantiate(`(module (tag (param i32)) (func (i64.const 5) (throw 0)))`),
+ `type mismatch: instruction requires [i32] but stack has [i64]`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/try_catch.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/try_catch.wast.js
new file mode 100644
index 0000000000..ab67fc936c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/try_catch.wast.js
@@ -0,0 +1,318 @@
+/* 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_trap(() => invoke($1, `unreachable-not-caught`, []), `unreachable`);
+
+// ./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_trap(() => invoke($1, `trap-in-callee`, [1, 0]), `integer divide by zero`);
+
+// ./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
+let $2 = instantiate(`(module
+ (func $$imported-throw (import "test" "throw"))
+ (tag $$e0)
+
+ (func (export "imported-mismatch") (result i32)
+ (try (result i32)
+ (do
+ (try (result i32)
+ (do
+ (i32.const 1)
+ (call $$imported-throw)
+ )
+ (catch $$e0 (i32.const 2))
+ )
+ )
+ (catch_all (i32.const 3))
+ )
+ )
+)`);
+
+// ./test/core/try_catch.wast:211
+assert_return(() => invoke($2, `imported-mismatch`, []), [value("i32", 3)]);
+
+// ./test/core/try_catch.wast:213
+assert_malformed(() => instantiate(`(module (func (catch_all))) `), `unexpected token`);
+
+// ./test/core/try_catch.wast:218
+assert_malformed(
+ () => instantiate(`(module (tag $$e) (func (catch $$e))) `),
+ `unexpected token`,
+);
+
+// ./test/core/try_catch.wast:223
+assert_malformed(
+ () => instantiate(`(module (func (try (do) (catch_all) (catch_all)))) `),
+ `unexpected token`,
+);
+
+// ./test/core/try_catch.wast:230
+assert_invalid(
+ () => instantiate(`(module (func (result i32) (try (result i32) (do))))`),
+ `type mismatch: instruction requires [i32] but stack has []`,
+);
+
+// ./test/core/try_catch.wast:232
+assert_invalid(
+ () => instantiate(`(module (func (result i32) (try (result i32) (do (i64.const 42)))))`),
+ `type mismatch: instruction requires [i32] but stack has [i64]`,
+);
+
+// ./test/core/try_catch.wast:234
+assert_invalid(
+ () => instantiate(`(module (tag) (func (try (do) (catch 0 (i32.const 42)))))`),
+ `type mismatch: block requires [] but stack has [i32]`,
+);
+
+// ./test/core/try_catch.wast:236
+assert_invalid(
+ () => instantiate(`(module
+ (tag (param i64))
+ (func (result i32)
+ (try (result i32) (do (i32.const 42)) (catch 0))))`),
+ `type mismatch: instruction requires [i32] but stack has [i64]`,
+);
+
+// ./test/core/try_catch.wast:241
+assert_invalid(
+ () => instantiate(`(module (func (try (do) (catch_all (i32.const 42)))))`),
+ `type mismatch: block requires [] but stack has [i32]`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/try_delegate.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/try_delegate.wast.js
new file mode 100644
index 0000000000..83400f02f5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/try_delegate.wast.js
@@ -0,0 +1,177 @@
+/* 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-block") (result i32)
+ (try (result i32)
+ (do (block (try (do (throw $$e0)) (delegate 0)))
+ (i32.const 0))
+ (catch_all (i32.const 1)))
+ )
+
+ (func (export "delegate-to-catch") (result i32)
+ (try (result i32)
+ (do (try
+ (do (throw $$e0))
+ (catch $$e0
+ (try (do (rethrow 1)) (delegate 0))))
+ (i32.const 0))
+ (catch_all (i32.const 1)))
+ )
+
+ (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:97
+assert_return(() => invoke($0, `delegate-no-throw`, []), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:99
+assert_return(() => invoke($0, `delegate-throw`, [0]), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:100
+assert_return(() => invoke($0, `delegate-throw`, [1]), [value("i32", 2)]);
+
+// ./test/core/try_delegate.wast:102
+assert_exception(() => invoke($0, `delegate-throw-no-catch`, []));
+
+// ./test/core/try_delegate.wast:104
+assert_return(() => invoke($0, `delegate-merge`, [1, 0]), [value("i32", 2)]);
+
+// ./test/core/try_delegate.wast:105
+assert_exception(() => invoke($0, `delegate-merge`, [2, 0]));
+
+// ./test/core/try_delegate.wast:106
+assert_return(() => invoke($0, `delegate-merge`, [0, 1]), [value("i32", 2)]);
+
+// ./test/core/try_delegate.wast:107
+assert_exception(() => invoke($0, `delegate-merge`, [0, 2]));
+
+// ./test/core/try_delegate.wast:108
+assert_return(() => invoke($0, `delegate-merge`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:110
+assert_return(() => invoke($0, `delegate-skip`, []), [value("i32", 3)]);
+
+// ./test/core/try_delegate.wast:112
+assert_return(() => invoke($0, `delegate-to-block`, []), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:113
+assert_return(() => invoke($0, `delegate-to-catch`, []), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:115
+assert_exception(() => invoke($0, `delegate-to-caller`, []));
+
+// ./test/core/try_delegate.wast:117
+assert_malformed(() => instantiate(`(module (func (delegate 0))) `), `unexpected token`);
+
+// ./test/core/try_delegate.wast:122
+assert_malformed(
+ () => instantiate(`(module (tag $$e) (func (try (do) (catch $$e) (delegate 0)))) `),
+ `unexpected token`,
+);
+
+// ./test/core/try_delegate.wast:127
+assert_malformed(
+ () => instantiate(`(module (func (try (do) (catch_all) (delegate 0)))) `),
+ `unexpected token`,
+);
+
+// ./test/core/try_delegate.wast:132
+assert_malformed(
+ () => instantiate(`(module (func (try (do) (delegate) (delegate 0)))) `),
+ `unexpected token`,
+);
+
+// ./test/core/try_delegate.wast:137
+assert_invalid(
+ () => instantiate(`(module (func (try (do) (delegate 1))))`),
+ `unknown label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/unreached-valid.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/unreached-valid.wast.js
new file mode 100644
index 0000000000..20ee3b42c7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/unreached-valid.wast.js
@@ -0,0 +1,85 @@
+/* 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/unreached-valid.wast
+
+// ./test/core/unreached-valid.wast:1
+let $0 = instantiate(`(module
+
+ ;; Check that both sides of the select are evaluated
+ (func (export "select-trap-left") (param $$cond i32) (result i32)
+ (select (unreachable) (i32.const 0) (local.get $$cond))
+ )
+ (func (export "select-trap-right") (param $$cond i32) (result i32)
+ (select (i32.const 0) (unreachable) (local.get $$cond))
+ )
+
+ (func (export "select-unreached")
+ (unreachable) (select)
+ (unreachable) (i32.const 0) (select)
+ (unreachable) (i32.const 0) (i32.const 0) (select)
+ (unreachable) (i32.const 0) (i32.const 0) (i32.const 0) (select)
+ (unreachable) (f32.const 0) (i32.const 0) (select)
+ (unreachable)
+ )
+
+ (func (export "select_unreached_result_1") (result i32)
+ (unreachable) (i32.add (select))
+ )
+
+ (func (export "select_unreached_result_2") (result i64)
+ (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
+ )
+
+ (func (export "unreachable-num")
+ (unreachable)
+ (select)
+ (i32.eqz)
+ (drop)
+ )
+ (func (export "unreachable-ref")
+ (unreachable)
+ (select)
+ (ref.is_null)
+ (drop)
+ )
+)`);
+
+// ./test/core/unreached-valid.wast:42
+assert_trap(() => invoke($0, `select-trap-left`, [1]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:43
+assert_trap(() => invoke($0, `select-trap-left`, [0]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:44
+assert_trap(() => invoke($0, `select-trap-right`, [1]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:45
+assert_trap(() => invoke($0, `select-trap-right`, [0]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:49
+let $1 = instantiate(`(module
+ (func (export "meet-bottom")
+ (block (result f64)
+ (block (result f32)
+ (unreachable)
+ (br_table 0 1 1 (i32.const 1))
+ )
+ (drop)
+ (f64.const 0)
+ )
+ (drop)
+ )
+)`);