Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1550 insertions, 0 deletions

diff --git a/js/src/jit-test/tests/wasm/exceptions/instructions.js b/js/src/jit-test/tests/wasm/exceptions/instructions.js
new file mode 100644
index 0000000000..a7f908704d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/instructions.js
@@ -0,0 +1,1550 @@
+// Tests for Wasm exception proposal instructions.
+
+// Test try blocks with no handlers.
+assertEq(
+  wasmEvalText(
+    `(module
+       (func (export "f") (result i32)
+         try (result i32) (i32.const 0) end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (func (export "f") (result i32)
+         try (result i32) (i32.const 0) (br 0) (i32.const 1) end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             (throw $exn)
+             (i32.const 1)
+           end
+           drop
+           (i32.const 2)
+         catch $exn
+           (i32.const 0)
+         end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             try
+               try
+                 (throw $exn)
+               end
+             end
+             (i32.const 1)
+           end
+           drop
+           (i32.const 2)
+         catch $exn
+           (i32.const 0)
+         end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             try
+               try
+                 (throw $exn)
+               end
+             catch_all
+               rethrow 0
+             end
+             (i32.const 1)
+           end
+           drop
+           (i32.const 2)
+         catch $exn
+           (i32.const 0)
+         end))`
+  ).exports.f(),
+  0
+);
+
+// Test trivial try-catch with empty bodies.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try nop catch $exn end
+         (i32.const 0)))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (func (export "f") (result i32)
+         try nop catch_all end
+         (i32.const 0)))`
+  ).exports.f(),
+  0
+);
+
+// Test try block with no throws
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 0)
+         catch $exn
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  0
+);
+
+// Ensure catch block is really not run when no throw occurs.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32) (local i32)
+         try
+           (local.set 0 (i32.const 42))
+         catch $exn
+           (local.set 0 (i32.const 99))
+         end
+         (local.get 0)))`
+  ).exports.f(),
+  42
+);
+
+// Simple uses of throw.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 42)
+           (throw $exn)
+         catch $exn
+           drop
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func $foo (param i32) (result i32)
+         (local.get 0) (throw $exn))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 42)
+           (call $foo)
+         catch $exn
+           drop
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Simple uses of throw of some Wasm vectortype values (Simd128).
+if (wasmSimdEnabled()) {
+  assertEq(
+    wasmEvalText(
+      `(module
+         (type (func (param v128 v128 v128 v128)))
+         (tag $exn (type 0))
+         (func (export "f") (result i32)
+           try (result i32)
+             (v128.const i32x4 42 41 40 39)
+             (v128.const f32x4 4.2 4.1 0.40 3.9)
+             (v128.const i64x2 42 41)
+             (v128.const f64x2 4.2 4.1)
+             (throw $exn)
+           catch $exn
+             drop drop drop
+             (i64x2.all_true)
+           end))`
+    ).exports.f(),
+    1
+  );
+
+  assertEq(
+    wasmEvalText(
+      `(module
+         (type (func (param v128 v128 v128 v128)))
+         (tag $exn (type 0))
+         (func $foo (param v128 v128 v128 v128) (result i32)
+           (throw $exn (local.get 0)
+                       (local.get 1)
+                       (local.get 2)
+                       (local.get 3)))
+         (func (export "f") (result i32)
+           try (result i32)
+             (v128.const i32x4 42 41 40 39)
+             (v128.const f32x4 4.2 4.1 0.40 3.9)
+             (v128.const i64x2 42 41)
+             (v128.const f64x2 4.2 4.1)
+             (call $foo)
+           catch $exn
+             drop drop drop
+             (i64x2.all_true)
+           end))`
+    ).exports.f(),
+    1
+  );
+
+  {
+    let imports =
+        wasmEvalText(
+          `(module
+             (tag $exn (export "exn") (param v128))
+             (func (export "throws") (param v128) (result v128)
+               (throw $exn (local.get 0))
+               (v128.const i32x4 9 10 11 12)))`).exports;
+
+    let mod =
+        `(module
+           (import "m" "exn" (tag $exn (param v128)))
+           (import "m" "throws" (func $throws (param v128) (result v128)))
+           (func (export "f") (result i32) (local v128)
+             (v128.const i32x4 1 2 3 4)
+             (local.tee 0)
+             try (param v128) (result v128)
+               (call $throws)
+             catch $exn
+             catch_all (v128.const i32x4 5 6 7 8)
+             end
+             (local.get 0)
+             (i32x4.eq)
+             (i32x4.all_true)))`;
+
+    assertEq(wasmEvalText(mod, { m : imports }).exports.f(), 1);
+  }
+}
+
+// Further nested call frames should be ok.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func $foo (param i32) (result i32)
+         (local.get 0) (call $bar))
+       (func $bar (param i32) (result i32)
+         (local.get 0) (call $quux))
+       (func $quux (param i32) (result i32)
+         (local.get 0) (throw $exn))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 42)
+           (call $foo)
+         catch $exn
+           drop
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Basic throwing from loop.
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn)
+       ;; For the purpose of this test, the params below should be increasing.
+       (func (export "f") (param $depth_to_throw_exn i32)
+                          (param $maximum_loop_iterations i32)
+                          (result i32)
+                          (local $loop_counter i32)
+         ;; The loop is counting down.
+         (local.get $maximum_loop_iterations)
+         (local.set $loop_counter)
+         (block $catch
+           (loop $loop
+             (if (i32.eqz (local.get $loop_counter))
+                 (then
+                   (return (i32.const 440)))
+                 (else
+                   try
+                     (if (i32.eq (local.get $depth_to_throw_exn)
+                                 (local.get $loop_counter))
+                       (then
+                         (throw $exn))
+                       (else
+                         (local.set $loop_counter
+                                    (i32.sub (local.get $loop_counter)
+                                             (i32.const 1)))))
+                   catch $exn (br $catch)
+                   catch_all
+                   end))
+               (br $loop))
+             (return (i32.const 10001)))
+         (i32.const 10000)))`
+  ).exports.f(2, 4),
+  10000
+);
+
+// Ensure conditional throw works.
+let conditional = wasmEvalText(
+  `(module
+     (type (func (param)))
+     (tag $exn (type 0))
+     (func (export "f") (param i32) (result i32)
+       try (result i32)
+         (local.get 0)
+         if (result i32)
+           (throw $exn)
+         else
+           (i32.const 42)
+         end
+       catch $exn
+         (i32.const 99)
+       end))`
+).exports.f;
+
+assertEq(conditional(0), 42);
+assertEq(conditional(1), 99);
+
+// Ensure multiple & nested try-catch blocks work.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func $foo (throw $exn))
+       (func (export "f") (result i32) (local i32)
+         try
+           nop
+         catch $exn
+           (local.set 0 (i32.const 99))
+         end
+         try
+           (call $foo)
+         catch $exn
+           (local.set 0 (i32.const 42))
+         end
+         (local.get 0)))`
+  ).exports.f(),
+  42
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32) (local i32)
+         try
+           try
+             try
+               (throw $exn)
+             catch $exn
+               (local.set 0 (i32.const 42))
+             end
+           catch $exn
+             (local.set 0 (i32.const 97))
+           end
+         catch $exn
+           (local.set 0 (i32.const 98))
+         end
+         (local.get 0)))`
+  ).exports.f(),
+  42
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn)
+       (func (export "f") (result i32)
+         try
+           throw $exn
+         catch $exn
+           try
+             (throw $exn)
+           catch $exn
+           end
+         end
+         (i32.const 27)))`
+  ).exports.f(),
+  27
+);
+
+{
+  let nested_throw_in_block_and_in_catch =
+      wasmEvalText(
+        `(module
+           (tag $exn)
+           (func $throw
+             (throw $exn))
+           (func (export "f") (param $arg i32) (result i32)
+             (block (result i32)
+               try (result i32)
+                 (call $throw)
+                 (unreachable)
+               catch $exn
+                 (if (result i32)
+                   (local.get $arg)
+                   (then
+                     try (result i32)
+                       (call $throw)
+                       (unreachable)
+                     catch $exn
+                       (i32.const 27)
+                     end)
+                   (else
+                     (i32.const 11))
+                  )
+                end
+              )
+            ))`
+      ).exports.f;
+
+  assertEq(nested_throw_in_block_and_in_catch(1), 27);
+  assertEq(nested_throw_in_block_and_in_catch(0), 11);
+}
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $thrownExn)
+       (tag $notThrownExn)
+       (func (export "f") (result i32)
+         try (result i32)
+            try (result i32)
+               (throw $thrownExn)
+            catch $notThrownExn
+               (i32.const 19)
+            catch $thrownExn
+               (i32.const 20)
+            catch_all
+               (i32.const 21)
+            end
+         end))`
+  ).exports.f(),
+  20
+);
+
+// Test that uncaught exceptions get propagated.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $thrownExn)
+       (tag $notThrownExn)
+       (func (export "f") (result i32) (local i32)
+         try
+           try
+             try
+               (throw $thrownExn)
+              catch $notThrownExn
+                 (local.set 0
+                   (i32.or (local.get 0)
+                           (i32.const 1)))
+              end
+             catch $notThrownExn
+               (local.set 0
+                 (i32.or (local.get 0)
+                         (i32.const 2)))
+             end
+           catch $thrownExn
+             (local.set 0
+               (i32.or (local.get 0)
+                       (i32.const 4)))
+           end
+         (local.get 0)))`
+  ).exports.f(),
+  4
+);
+
+// Test tag dispatch for catches.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (tag $exn3 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           throw $exn1
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         catch $exn3
+           i32.const 3
+         end))`
+  ).exports.f(),
+  1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (tag $exn3 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           throw $exn2
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         catch $exn3
+           i32.const 3
+         end))`
+  ).exports.f(),
+  2
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (tag $exn3 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           throw $exn3
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         catch $exn3
+           i32.const 3
+         end))`
+  ).exports.f(),
+  3
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (tag $exn3 (type 0))
+       (tag $exn4 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             throw $exn4
+           catch $exn1
+             i32.const 1
+           catch $exn2
+             i32.const 2
+           catch $exn3
+             i32.const 3
+           end
+         catch $exn4
+           i32.const 4
+         end))`
+  ).exports.f(),
+  4
+);
+
+// Test usage of br before a throw.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (i32.const 2)
+           (br $l)
+           (throw $exn)
+         catch $exn
+           drop
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  2
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (throw $exn)
+         catch $exn
+           (i32.const 2)
+           (br $l)
+           rethrow 0
+         end))`
+  ).exports.f(),
+  2
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (throw $exn)
+         catch_all
+           (i32.const 2)
+           (br $l)
+           rethrow 0
+         end))`
+  ).exports.f(),
+  2
+);
+
+// Test br branching out of a catch block.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         block $l (result i32)
+           block (result i32)
+             try (result i32)
+               (i32.const 42)
+               (throw $exn)
+             catch $exn
+               br $l
+               (i32.const 99)
+             end
+           end
+         end))`
+  ).exports.f(),
+  42
+);
+
+// Test dead catch block.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         i32.const 0
+         return
+         try nop catch $exn end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (func (export "f") (result i32)
+         i32.const 0
+         return
+         try nop catch_all end))`
+  ).exports.f(),
+  0
+);
+
+// Test catch with exception values pushed to stack.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (type (func (param i32)))
+       (type (func (param i64)))
+       (tag $exn (type 0))
+       (tag $foo (type 1))
+       (tag $bar (type 2))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (i32.const 42)
+           (throw $exn)
+         catch $exn
+         catch_all
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  42
+);
+
+// Throw an exception carrying more than one value.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32 i64 f32 f64)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32 i64 f32 f64)
+           (i32.const 42)
+           (i64.const 84)
+           (f32.const 42.2)
+           (f64.const 84.4)
+           (throw $exn)
+         catch $exn
+         catch_all
+           (i32.const 99)
+           (i64.const 999)
+           (f32.const 99.9)
+           (f64.const 999.9)
+         end
+         drop drop drop))`
+  ).exports.f(),
+  42
+);
+
+// This should also work inside nested frames.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32 i64 f32 f64)))
+       (tag $exn (type 0))
+       (func $foo (param i32 i64 f32 f64) (result i32 i64 f32 f64)
+         (local.get 0)
+         (local.get 1)
+         (local.get 2)
+         (local.get 3)
+         (throw $exn))
+       (func (export "f") (result i32)
+         try $l (result i32 i64 f32 f64)
+           (i32.const 42)
+           (i64.const 84)
+           (f32.const 42.2)
+           (f64.const 84.4)
+           (call $foo)
+         catch $exn
+         catch_all
+           (i32.const 99)
+           (i64.const 999)
+           (f32.const 99.9)
+           (f64.const 999.9)
+         end
+         drop drop drop))`
+  ).exports.f(),
+  42
+);
+
+// Multiple tagged catch in succession.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 42)
+           (throw $exn2)
+         catch $exn1
+         catch $exn2
+         catch_all
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  42
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn0)
+       (tag $exn1)
+       (tag $exn2)
+       (tag $exn3)
+       (tag $exn4)
+       (tag $exn5)
+       (func (export "f") (result i32)
+         try (result i32)
+           (throw $exn4)
+          catch $exn5 (i32.const 5)
+          catch $exn2 (i32.const 2)
+          catch $exn4 (i32.const 4) ;; Caught here.
+          catch $exn4 (i32.const 44)
+          end
+        ))`
+  ).exports.f(),
+  4
+);
+
+// Try catch with block parameters.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         (i32.const 42)
+         try (param i32) (result i32)
+           nop
+         catch $exn
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  42
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         (i32.const 42)
+         try $l (param i32) (result i32)
+           (throw $exn)
+         catch $exn
+         catch_all
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  42
+);
+
+// Test the catch_all case.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (i32.const 42)
+           (throw $exn2)
+         catch $exn1
+         catch_all
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  99
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param i32))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             (i32.const 42)
+             (throw $exn)
+           catch_all
+             (i32.const 99)
+           end
+         catch $exn
+         end))`
+  ).exports.f(),
+  99
+);
+
+// Test foreign exception catch.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (import "m" "foreign" (func $foreign))
+       (tag $exn (type 0))
+       (func (export "f") (result i32) (local i32)
+         try $l
+           (call $foreign)
+         catch $exn
+         catch_all
+           (local.set 0 (i32.const 42))
+         end
+         (local.get 0)))`,
+    {
+      m: {
+        foreign() {
+          throw 5;
+        },
+      },
+    }
+  ).exports.f(),
+  42
+);
+
+// Exception handlers should not catch traps.
+assertErrorMessage(
+  () =>
+    wasmEvalText(
+      `(module
+         (type (func))
+         (tag $exn (type 0))
+         (func (export "f") (result i32) (local i32)
+           try $l
+             unreachable
+           catch $exn
+             (local.set 0 (i32.const 98))
+           catch_all
+             (local.set 0 (i32.const 99))
+           end
+           (local.get 0)))`
+    ).exports.f(),
+  WebAssembly.RuntimeError,
+  "unreachable executed"
+);
+
+// Ensure that a RuntimeError created by the user is not filtered out
+// as a trap emitted by the runtime (i.e., the filtering predicate is not
+// observable from JS).
+assertEq(
+  wasmEvalText(
+    `(module
+       (import "m" "foreign" (func $foreign))
+       (func (export "f") (result i32)
+         try (result i32)
+           (call $foreign)
+           (i32.const 99)
+         catch_all
+           (i32.const 42)
+         end))`,
+    {
+      m: {
+        foreign() {
+          throw new WebAssembly.RuntimeError();
+        },
+      },
+    }
+  ).exports.f(),
+  42
+);
+
+// Test uncatchable JS exceptions (OOM & stack overflow).
+{
+  let f = wasmEvalText(
+    `(module
+       (import "m" "foreign" (func $foreign))
+       (func (export "f") (result)
+         try
+           (call $foreign)
+         catch_all
+         end))`,
+    {
+      m: {
+        foreign() {
+          throwOutOfMemory();
+        },
+      },
+    }
+  ).exports.f;
+
+  var thrownVal;
+  try {
+    f();
+  } catch (exn) {
+    thrownVal = exn;
+  }
+
+  assertEq(thrownVal, "out of memory");
+}
+
+assertErrorMessage(
+  () =>
+    wasmEvalText(
+      `(module
+       (import "m" "foreign" (func $foreign))
+       (func (export "f")
+         try
+           (call $foreign)
+         catch_all
+         end))`,
+      {
+        m: {
+          foreign: function foreign() {
+            foreign();
+          },
+        },
+      }
+    ).exports.f(),
+  Error,
+  "too much recursion"
+);
+
+// Test all implemented instructions in a single module.
+{
+  let divFunctypeInline =
+      `(param $numerator i32) (param $denominator i32) (result i32)`;
+
+  let safediv = wasmEvalText(
+    `(module
+       (tag $divexn (param i32 i32))
+       (tag $notThrownExn (param i32))
+       (func $throwingdiv ${divFunctypeInline}
+          (local.get $numerator)
+          (local.get $denominator)
+          (if (param i32 i32) (result i32)
+            (i32.eqz (local.get $denominator))
+            (then
+              try (param i32 i32)
+                (throw $divexn)
+              delegate 0
+              (i32.const 9))
+            (else
+              i32.div_u)))
+       (func $safediv (export "safediv") ${divFunctypeInline}
+          (local.get $numerator)
+          (local.get $denominator)
+          try (param i32 i32) (result i32)
+              (call $throwingdiv)
+          catch $notThrownExn
+          catch $divexn
+            i32.add
+          catch_all
+            (i32.const 44)
+          end
+        ))`
+  ).exports.safediv;
+
+  assertEq(safediv(6, 3), 2);
+  assertEq(safediv(6, 0), 6);
+}
+
+// Test simple rethrow.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch $exn
+             rethrow 0
+           end
+           i32.const 1
+         catch $exn
+           i32.const 27
+         end))`
+  ).exports.f(),
+  27
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch_all
+             rethrow 0
+           end
+           i32.const 1
+         catch $exn
+           i32.const 27
+         end))`
+  ).exports.f(),
+  27
+);
+
+// Test rethrows in nested blocks.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch $exn
+             block
+               rethrow 1
+             end
+           end
+           i32.const 1
+         catch $exn
+           i32.const 27
+         end))`
+  ).exports.f(),
+  27
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch_all
+             block
+               rethrow 1
+             end
+           end
+           i32.const 1
+         catch $exn
+           i32.const 27
+         end))`
+  ).exports.f(),
+  27
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn1
+           catch $exn1
+             try
+               throw $exn2
+             catch $exn2
+               rethrow 1
+             end
+           end
+           i32.const 0
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         end))`
+  ).exports.f(),
+  1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn1
+           catch $exn1
+             try
+               throw $exn2
+             catch_all
+               rethrow 1
+             end
+           end
+           i32.const 0
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Test that rethrow makes the rest of the block dead code.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag (param i32))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 1)
+         catch 0
+           (rethrow 0)
+           (i32.const 2)
+         end
+       ))`
+  ).exports.f(),
+  1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag (param i32))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             (i32.const 13)
+             (throw 0)
+            catch 0
+              (rethrow 0)
+            end
+           (unreachable)
+         catch 0
+         end
+       ))`
+  ).exports.f(),
+  13
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag)
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             (throw 0)
+           catch 0
+             (i32.const 4)
+             (rethrow 0)
+           end
+           (unreachable)
+         catch 0
+            (i32.const 13)
+         end
+       ))`
+  ).exports.f(),
+  13
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag (param i32))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             (i32.const 13)
+             (throw 0)
+           catch 0
+             (i32.const 111)
+             (rethrow 0)
+           end
+           (i32.const 222)
+         catch 0
+       end
+     ))`
+  ).exports.f(),
+  13
+);
+
+// Test try-delegate blocks.
+
+// Dead delegate to caller
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         i32.const 1
+         br 0
+         try
+           throw $exn
+         delegate 0))`
+  ).exports.f(),
+  1
+);
+
+// Nested try-delegate.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             try
+               throw $exn
+             delegate 0
+           end
+           i32.const 0
+         catch $exn
+           i32.const 1
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Non-throwing and breaking try-delegate.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           i32.const 1
+           br 0
+         delegate 0))`
+    ).exports.f(),
+    1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           i32.const 1
+           return
+         delegate 0))`
+    ).exports.f(),
+    1
+  );
+
+// More nested try-delegate.
+assertEq(
+    wasmEvalText(
+      `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             i32.const 42
+             throw $exn
+           delegate 0
+           i32.const 0
+         catch $exn
+           i32.const 1
+           i32.add
+         end))`
+  ).exports.f(),
+  43
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             try
+               i32.const 42
+               throw $exn
+             delegate 1
+             i32.const 0
+           catch $exn
+             i32.const 1
+             i32.add
+           end
+         catch $exn
+           i32.const 2
+           i32.add
+         end))`
+  ).exports.f(),
+  44
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             try (result i32)
+               try
+                 i32.const 42
+                 throw $exn
+               delegate 1
+               i32.const 0
+             catch $exn
+               i32.const 1
+               i32.add
+             end
+           delegate 0
+         catch $exn
+           i32.const 2
+           i32.add
+         end))`
+  ).exports.f(),
+  44
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func $g (param i32) (result i32) (i32.const 42))
+       (func (export "f") (result i32)
+         try (result i32)
+           try $t
+             block (result i32)
+               (i32.const 4)
+               (call $g)
+               try
+                 throw $exn
+               delegate $t
+             end
+             drop
+           end
+           i32.const 0
+         catch_all
+           i32.const 1
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Test delegation to function body and blocks.
+
+// Non-throwing.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           i32.const 1
+         delegate 0))`
+  ).exports.f(),
+  1
+);
+
+// Block target.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param i32))
+       (func (export "f") (result i32)
+         try (result i32)
+           block
+             try
+               i32.const 1
+               throw $exn
+             delegate 0
+           end
+           i32.const 0
+         catch $exn
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Catch target.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch $exn
+             try
+               throw $exn
+             delegate 0
+           end
+           i32.const 0
+         catch_all
+           i32.const 1
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Target function body.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           call $g
+         catch $exn
+         end)
+       (func $g (result i32)
+         try (result i32)
+           try
+             i32.const 42
+             throw $exn
+           delegate 1
+           i32.const 0
+         catch $exn
+           i32.const 1
+           i32.add
+         end))`
+  ).exports.f(),
+  42
+);
+
+// Try-delegate from inside a loop.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn)
+       ;; For the purpose of this test, the params below should be increasing.
+       (func (export "f") (param $depth_to_throw_exn i32)
+                          (param $maximum_loop_iterations i32)
+                          (result i32)
+                          (local $loop_countdown i32)
+                          ;; Counts how many times the loop was started.
+                          (local $loop_verifier i32)
+         ;; The loop is counting down.
+         (local.get $maximum_loop_iterations)
+         (local.set $loop_countdown)
+         try $catch_exn (result i32)
+           try
+             (loop $loop
+               ;; Counts how many times the loop was started.
+               (local.set $loop_verifier
+                          (i32.add (i32.const 1)
+                                   (local.get $loop_verifier)))
+               (if (i32.eqz (local.get $loop_countdown))
+                 (then (return (i32.const 440)))
+                 (else
+                   try $rethrow_label
+                     (if (i32.eq (local.get $depth_to_throw_exn)
+                                 (local.get $loop_countdown))
+                         (then (throw $exn))
+                         (else
+                           (local.set $loop_countdown
+                                      (i32.sub (local.get $loop_countdown)
+                                               (i32.const 1)))))
+                   catch $exn try
+                               (rethrow $rethrow_label)
+                              delegate $catch_exn
+                   end
+                 ))
+               (br $loop))
+             catch_all unreachable
+             end
+             (i32.const 2000)
+         catch_all (i32.const 10000)
+         end
+         (i32.add (local.get $loop_verifier))))`
+  ).exports.f(3, 5),
+  10003
+);