[EH] Convert EH tests into lit tests (#3923)

This converts most EH tests in test/passes into test/lit/passes. Fixed
some files to follow 2-space indentation and improved some comments.

14 files changed, 1856 insertions, 0 deletions

diff --git a/test/lit/passes/coalesce-locals-eh.wast b/test/lit/passes/coalesce-locals-eh.wast
new file mode 100644
index 000000000..f564c2991
--- /dev/null
+++ b/test/lit/passes/coalesce-locals-eh.wast
@@ -0,0 +1,43 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --coalesce-locals -all -S -o - | filecheck %s
+
+(module
+  ;; CHECK:      (func $bar (result i32)
+  ;; CHECK-NEXT:  (i32.const 1984)
+  ;; CHECK-NEXT: )
+  (func $bar (result i32)
+    (i32.const 1984)
+  )
+
+ (event $e (attr 0))
+  ;; CHECK:      (func $bug-cfg-traversal (param $0 i32) (result i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (local.set $0
+  ;; CHECK-NEXT:     (call $bar)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (unreachable)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.get $0)
+  ;; CHECK-NEXT: )
+  (func $bug-cfg-traversal (param $0 i32) (result i32)
+    (local $x i32)
+    ;; This is a regrssion test case for a bug in cfg-traversal for EH.
+    ;; See https://github.com/WebAssembly/binaryen/pull/3594
+    (try
+      (do
+        (local.set $x
+          ;; the call may or may not throw, so we may reach the get of $x
+          (call $bar)
+        )
+      )
+      (catch_all
+        (unreachable)
+      )
+    )
+    (local.get $x)
+  )
+)
diff --git a/test/lit/passes/code-folding-eh.wast b/test/lit/passes/code-folding-eh.wast
new file mode 100644
index 000000000..6a1a1eb36
--- /dev/null
+++ b/test/lit/passes/code-folding-eh.wast
@@ -0,0 +1,153 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --remove-unused-names --code-folding -all -S -o - \
+;; RUN:   | filecheck %s
+
+(module
+  (event $e-i32 (attr 0) (param i32))
+
+  ;; CHECK:      (func $pop-test
+  ;; CHECK-NEXT:  (block $folding-inner0
+  ;; CHECK-NEXT:   (try
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (try
+  ;; CHECK-NEXT:      (do
+  ;; CHECK-NEXT:       (nop)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (catch $e-i32
+  ;; CHECK-NEXT:       (drop
+  ;; CHECK-NEXT:        (pop i32)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (br $folding-inner0)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch $e-i32
+  ;; CHECK-NEXT:     (drop
+  ;; CHECK-NEXT:      (pop i32)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (br $folding-inner0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (return)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 111)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 222)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 333)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT: )
+  (func $pop-test
+    (try
+      (do
+        (try
+          (do)
+          (catch $e-i32
+            ;; Expressions containing a pop should NOT be taken out and folded.
+            (drop (pop i32))
+            (drop (i32.const 111))
+            (drop (i32.const 222))
+            (drop (i32.const 333))
+            (unreachable)
+          )
+        )
+      )
+      (catch $e-i32
+        (drop (pop i32))
+        (drop (i32.const 111))
+        (drop (i32.const 222))
+        (drop (i32.const 333))
+        (unreachable)
+      )
+    )
+  )
+
+  (func $foo)
+  ;; CHECK:      (func $try-call-optimize-terminating-tails (result i32)
+  ;; CHECK-NEXT:  (try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:    (return
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:    (return
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (i32.const 0)
+  ;; CHECK-NEXT: )
+  (func $try-call-optimize-terminating-tails (result i32)
+    (try
+      (do
+        ;; Expressions that can throw should NOT be taken out of 'try' scope.
+        (call $foo)
+        (call $foo)
+        (call $foo)
+        (call $foo)
+        (return (i32.const 0))
+      )
+      (catch_all
+        (call $foo)
+        (call $foo)
+        (call $foo)
+        (call $foo)
+        (return (i32.const 0))
+      )
+    )
+    (i32.const 0)
+  )
+
+  ;; CHECK:      (func $try-call-optimize-expression-tails
+  ;; CHECK-NEXT:  (block $x
+  ;; CHECK-NEXT:   (try
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (call $foo)
+  ;; CHECK-NEXT:     (call $foo)
+  ;; CHECK-NEXT:     (call $foo)
+  ;; CHECK-NEXT:     (br $x)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch_all
+  ;; CHECK-NEXT:     (call $foo)
+  ;; CHECK-NEXT:     (call $foo)
+  ;; CHECK-NEXT:     (call $foo)
+  ;; CHECK-NEXT:     (br $x)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (unreachable)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $try-call-optimize-expression-tails
+    (block $x
+      (try
+        (do
+          ;; Expressions that can throw should NOT be taken out of 'try' scope.
+          (call $foo)
+          (call $foo)
+          (call $foo)
+          (br $x)
+        )
+        (catch_all
+          (call $foo)
+          (call $foo)
+          (call $foo)
+          (br $x)
+        )
+      )
+      (unreachable)
+    )
+  )
+)
diff --git a/test/lit/passes/code-pushing-eh.wast b/test/lit/passes/code-pushing-eh.wast
new file mode 100644
index 000000000..fe406ec2b
--- /dev/null
+++ b/test/lit/passes/code-pushing-eh.wast
@@ -0,0 +1,208 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --code-pushing -all -S -o - | filecheck %s
+
+(module
+  (event $e (attr 0) (param i32))
+
+  ;; CHECK:      (func $cant-push-past-call
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (local.set $x
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (call $cant-push-past-call)
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (br_if $out
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $cant-push-past-call
+    (local $x i32)
+    (block $out
+      ;; This local.set cannot be pushed down, because the call below can throw
+      (local.set $x (i32.const 1))
+      (call $cant-push-past-call)
+      (drop (i32.const 1))
+      (br_if $out (i32.const 2))
+      (drop (local.get $x))
+    )
+  )
+
+  ;; CHECK:      (func $cant-push-past-throw
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (local.set $x
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (throw $e
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (br_if $out
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $cant-push-past-throw
+    (local $x i32)
+    (block $out
+      ;; This local.set cannot be pushed down, because there is 'throw' below
+      (local.set $x (i32.const 1))
+      (throw $e (i32.const 0))
+      (drop (i32.const 1))
+      (br_if $out (i32.const 2))
+      (drop (local.get $x))
+    )
+  )
+
+  ;; CHECK:      (func $can-push-past-try
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (try $try
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (throw $e
+  ;; CHECK-NEXT:      (i32.const 0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch_all
+  ;; CHECK-NEXT:     (nop)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (br_if $out
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (local.set $x
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $can-push-past-try
+    (local $x i32)
+    (block $out
+      ;; This local.set can be pushed down, because the 'throw' below is going
+      ;; to be caught by the inner catch_all
+      (local.set $x (i32.const 1))
+      (try
+        (do
+          (throw $e (i32.const 0))
+        )
+        (catch_all)
+      )
+      (drop (i32.const 1))
+      (br_if $out (i32.const 2))
+      (drop (local.get $x))
+    )
+  )
+
+  (func $foo)
+  ;; CHECK:      (func $cant-push-past-try
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (local.set $x
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (try $try
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (call $foo)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch $e
+  ;; CHECK-NEXT:     (drop
+  ;; CHECK-NEXT:      (pop i32)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (br_if $out
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $cant-push-past-try
+    (local $x i32)
+    (block $out
+      ;; This local.set cannot be pushed down, because the exception thrown by
+      ;; 'call $foo' below may not be caught by 'catch $e'
+      (local.set $x (i32.const 1))
+      (try
+        (do
+          (call $foo)
+        )
+        (catch $e
+          (drop (pop i32))
+        )
+      )
+      (drop (i32.const 1))
+      (br_if $out (i32.const 2))
+      (drop (local.get $x))
+    )
+  )
+
+  ;; CHECK:      (func $cant-push-past-rethrow-within-catch
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (block $out
+  ;; CHECK-NEXT:   (local.set $x
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (try $l0
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (throw $e
+  ;; CHECK-NEXT:      (i32.const 0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch_all
+  ;; CHECK-NEXT:     (rethrow $l0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (br_if $out
+  ;; CHECK-NEXT:    (i32.const 2)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $cant-push-past-rethrow-within-catch
+    (local $x i32)
+    (block $out
+      ;; This local.set cannot be pushed down, because there is 'rethrow' within
+      ;; the inner catch_all
+      (local.set $x (i32.const 1))
+      (try $l0
+        (do
+          (throw $e (i32.const 0))
+        )
+        (catch_all
+          (rethrow $l0)
+        )
+      )
+      (drop (i32.const 1))
+      (br_if $out (i32.const 2))
+      (drop (local.get $x))
+    )
+  )
+)
diff --git a/test/lit/passes/dce-eh.wast b/test/lit/passes/dce-eh.wast
new file mode 100644
index 000000000..1bb6358dd
--- /dev/null
+++ b/test/lit/passes/dce-eh.wast
@@ -0,0 +1,125 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --dce -all -S -o - | filecheck %s
+
+;; If either try body or catch body is reachable, the whole try construct is
+;; reachable
+(module
+  (func $foo)
+  (event $e (attr 0))
+
+  ;; CHECK:      (func $try_unreachable
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (unreachable)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (call $foo)
+  ;; CHECK-NEXT: )
+  (func $try_unreachable
+    (try
+      (do
+        (unreachable)
+      )
+      (catch_all)
+    )
+    (call $foo) ;; shouldn't be dce'd
+  )
+
+  ;; CHECK:      (func $catch_unreachable
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (unreachable)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (call $foo)
+  ;; CHECK-NEXT: )
+  (func $catch_unreachable
+    (try
+      (do)
+      (catch_all
+        (unreachable)
+      )
+    )
+    (call $foo) ;; shouldn't be dce'd
+  )
+
+  ;; CHECK:      (func $both_unreachable
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (unreachable)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (unreachable)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $both_unreachable
+    (try
+      (do
+        (unreachable)
+      )
+      (catch_all
+        (unreachable)
+      )
+    )
+    (call $foo) ;; should be dce'd
+  )
+
+  ;; CHECK:      (func $throw
+  ;; CHECK-NEXT:  (block $label$0
+  ;; CHECK-NEXT:   (block $label$1
+  ;; CHECK-NEXT:    (throw $e)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $throw
+    ;; All these wrapping expressions before 'throw' will be dce'd
+    (drop
+      (block $label$0 (result externref)
+        (if
+          (i32.clz
+            (block $label$1 (result i32)
+              (throw $e)
+            )
+          )
+          (nop)
+        )
+        (ref.null extern)
+      )
+    )
+  )
+
+  ;; CHECK:      (func $rethrow
+  ;; CHECK-NEXT:  (try $l0
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $e
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (rethrow $l0)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $rethrow
+    (try $l0
+      (do)
+      (catch $e
+        (drop
+          ;; This i32.add will be dce'd
+          (i32.add
+            (i32.const 0)
+            (rethrow $l0)
+          )
+        )
+      )
+    )
+  )
+)
diff --git a/test/lit/passes/inlining-eh.wast b/test/lit/passes/inlining-eh.wast
new file mode 100644
index 000000000..9879978e1
--- /dev/null
+++ b/test/lit/passes/inlining-eh.wast
@@ -0,0 +1,99 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --inlining -all -S -o - | filecheck %s
+
+(module
+  ;; ---------------------------------------------------------------------------
+  (import "a" "b" (func $foo (result i32)))
+  (event $event$0 (attr 0) (param i32))
+  (func $callee-with-label
+    (try $label
+      (do)
+      (catch $event$0
+        (nop)
+      )
+    )
+  )
+
+  ;; Properly ensure unique try labels after an inlining
+
+  ;; CHECK:      (func $caller-with-label (param $x i32)
+  ;; CHECK-NEXT:  (loop $label
+  ;; CHECK-NEXT:   (block
+  ;; CHECK-NEXT:    (block $__inlined_func$callee-with-label
+  ;; CHECK-NEXT:     (try $label0
+  ;; CHECK-NEXT:      (do
+  ;; CHECK-NEXT:       (nop)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (catch $event$0
+  ;; CHECK-NEXT:       (nop)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (br_if $label
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $caller-with-label (param $x i32)
+    (loop $label ;; The same label as the try that will be inlined into here
+      (call $callee-with-label)
+      (br_if $label
+        (call $foo)
+      )
+    )
+  )
+
+  ;; ---------------------------------------------------------------------------
+  ;; CHECK:      (func $callee-with-try-delegate
+  ;; CHECK-NEXT:  (try $label$3
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (delegate 0)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $callee-with-try-delegate
+    (try $label$3
+      (do)
+      (delegate 0)
+    )
+  )
+
+  ;; For now, do not inline a try-delegate
+
+  ;; CHECK:      (func $caller
+  ;; CHECK-NEXT:  (call $callee-with-try-delegate)
+  ;; CHECK-NEXT: )
+  (func $caller
+    (call $callee-with-try-delegate)
+  )
+
+  ;; ---------------------------------------------------------------------------
+  (func $callee (result i32)
+    (i32.const 42)
+  )
+
+  ;; Properly support inlining into a function with a try-delegate
+
+  ;; CHECK:      (func $caller-with-try-delegate (result i32)
+  ;; CHECK-NEXT:  (try $label$3
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (delegate 0)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (block (result i32)
+  ;; CHECK-NEXT:   (block $__inlined_func$callee (result i32)
+  ;; CHECK-NEXT:    (i32.const 42)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $caller-with-try-delegate (result i32)
+    (try $label$3
+      (do)
+      (delegate 0)
+    )
+    (call $callee)
+  )
+)
diff --git a/test/lit/passes/instrument-locals-eh.wast b/test/lit/passes/instrument-locals-eh.wast
new file mode 100644
index 000000000..99ba94583
--- /dev/null
+++ b/test/lit/passes/instrument-locals-eh.wast
@@ -0,0 +1,30 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --instrument-locals -all -S -o - | filecheck %s
+
+(module
+  (event $e (attr 0) (param i32))
+
+  ;; CHECK:      (func $test
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $e
+  ;; CHECK-NEXT:    (local.set $x
+  ;; CHECK-NEXT:     (pop i32)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test
+    (local $x i32)
+    (try
+      (do)
+      (catch $e
+        ;; Pop instructions should not be instrumented
+        (local.set $x (pop i32))
+      )
+    )
+  )
+)
diff --git a/test/lit/passes/optimize-instructions-eh.wast b/test/lit/passes/optimize-instructions-eh.wast
new file mode 100644
index 000000000..50ae665e2
--- /dev/null
+++ b/test/lit/passes/optimize-instructions-eh.wast
@@ -0,0 +1,249 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --remove-unused-names --optimize-instructions -all -S -o - \
+;; RUN:   | filecheck %s
+
+(module
+  (func $dummy)
+  (event $e (attr 0) (param i32))
+
+  ;; The following are the unit tests for Properties::getFallthrough for EH
+  ;; instructions, which are used in one of binary optimizations in
+  ;; OptimizeInstructions::visitBinary().
+
+  ;; When a pattern of (i32.add (expr) (expr with all 1s)) is detected and
+  ;; 'expr' is guaranteed to take equal or less bits than the number of bits in
+  ;; the second expression, the i32.add can be dropped and we can only leave
+  ;; (expr). For example:
+  ;; (i32.add (local.get $x) (i32.const 7)) can be just (local.get $x) when $x
+  ;; is guaranteed to contain a value equal to or less than 7.
+
+  ;; CHECK:      (func $getFallthrough-try-no-throw
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (try (result i32)
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch_all
+  ;; CHECK-NEXT:     (i32.const 3)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $getFallthrough-try-no-throw
+    (local $x i32)
+    (local.set $x
+      (try (result i32)
+        (do
+          (i32.const 1)
+        )
+        (catch_all
+          (i32.const 3)
+        )
+      )
+    )
+    ;; The 'try' above is guaranteed not to throw, so we can be sure the $x
+    ;; contains 1 at this point, which is smaller than 7 (0b111), so we know the
+    ;; masking with 0b111 is not ncessary and we can only leave (local.set $x).
+    (drop (i32.and (local.get $x) (i32.const 7)))
+  )
+
+  ;; CHECK:      (func $getFallthrough-try-may-throw
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (try (result i32)
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (call $dummy)
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch_all
+  ;; CHECK-NEXT:     (i32.const 3)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 7)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $getFallthrough-try-may-throw
+    (local $x i32)
+    (local.set $x
+      (try (result i32)
+        (do
+          (call $dummy)
+          (i32.const 1)
+        )
+        (catch_all
+          (i32.const 3)
+        )
+      )
+    )
+    ;; The 'try' body above may throw because of the call, so we are not sure
+    ;; what $x contains at this point, so we can't remove the masking here.
+    (drop (i32.and (local.get $x) (i32.const 7)))
+  )
+
+  ;; CHECK:      (func $getFallthrough-nested-try-0
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (try (result i32)
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (try
+  ;; CHECK-NEXT:      (do
+  ;; CHECK-NEXT:       (call $dummy)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (catch $e
+  ;; CHECK-NEXT:       (drop
+  ;; CHECK-NEXT:        (pop i32)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch $e
+  ;; CHECK-NEXT:     (drop
+  ;; CHECK-NEXT:      (pop i32)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 3)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 7)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $getFallthrough-nested-try-0
+    (local $x i32)
+    (local.set $x
+      (try (result i32)
+        (do
+          (try
+            (do
+              (call $dummy)
+            )
+            (catch $e
+              (drop (pop i32))
+            )
+          )
+          (i32.const 1)
+        )
+        (catch $e
+          (drop (pop i32))
+          (i32.const 3)
+        )
+      )
+    )
+    ;; The inner 'try' may throw and it may not be caught by both the inner and
+    ;; outer catches, so we are not sure what $x contains at this point, which
+    ;; prevents the masking optimization.
+    (drop (i32.and (local.get $x) (i32.const 7)))
+  )
+
+  ;; CHECK:      (func $getFallthrough-nested-try-1
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (try (result i32)
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (try
+  ;; CHECK-NEXT:      (do
+  ;; CHECK-NEXT:       (call $dummy)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (catch_all
+  ;; CHECK-NEXT:       (nop)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch_all
+  ;; CHECK-NEXT:     (i32.const 3)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (local.get $x)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $getFallthrough-nested-try-1
+    (local $x i32)
+    (local.set $x
+      (try (result i32)
+        (do
+          (try
+            (do
+              (call $dummy)
+            )
+            (catch_all)
+          )
+          (i32.const 1)
+        )
+        (catch_all
+          (i32.const 3)
+        )
+      )
+    )
+    ;; The inner try may throw, but it will caught by the inner catch_all, and
+    ;; $x will be set to 1. So we can do the masking optimization and remove
+    ;; i32.and here.
+    (drop (i32.and (local.get $x) (i32.const 7)))
+  )
+
+  ;; CHECK:      (func $getFallthrough-nested-try-2
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (try (result i32)
+  ;; CHECK-NEXT:    (do
+  ;; CHECK-NEXT:     (try
+  ;; CHECK-NEXT:      (do
+  ;; CHECK-NEXT:       (nop)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (catch_all
+  ;; CHECK-NEXT:       (call $dummy)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (i32.const 3)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (catch_all
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.and
+  ;; CHECK-NEXT:    (local.get $x)
+  ;; CHECK-NEXT:    (i32.const 7)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $getFallthrough-nested-try-2
+    (local $x i32)
+    (local.set $x
+      (try (result i32)
+        (do
+          (try
+            (do)
+            (catch_all
+              (call $dummy)
+            )
+          )
+          (i32.const 3)
+        )
+        (catch_all
+          (i32.const 1)
+        )
+      )
+    )
+    ;; Depending on whether (call $dummy) throws or not, we are not sure whether
+    ;; $x will contain 1 or 3 at this point, which prevents the masking
+    ;; optimization.
+    (drop (i32.and (local.get $x) (i32.const 7)))
+  )
+)
diff --git a/test/lit/passes/remove-unused-module-elements-eh.wast b/test/lit/passes/remove-unused-module-elements-eh.wast
new file mode 100644
index 000000000..7e0c66af4
--- /dev/null
+++ b/test/lit/passes/remove-unused-module-elements-eh.wast
@@ -0,0 +1,30 @@
+;; RUN: wasm-opt %s --remove-unused-module-elements -all -S -o - | filecheck %s
+
+;; Non-exported and unused events can be removed
+(module
+  (type $0 (func (param i32)))
+
+  ;; CHECK-NOT: (event $e-remove
+  ;; CHECK: (event $e-export
+  ;; CHECK: (event $e-throw
+  ;; CHECK: (event $e-catch
+  (event $e-remove (attr 0) (type $0))   ;; can be removed
+  (event $e-export (attr 0) (param i64)) ;; cannot be removed (exported)
+  (event $e-throw (attr 0) (type $0))    ;; cannot be removed (used in throw)
+  (event $e-catch (attr 0) (type $0))    ;; cannot be removed (used in catch)
+
+  (export "e-export" (event $e-export))
+  (import "env" "e" (event $e-import (attr 0) (param i32)))
+
+  (start $start)
+  (func $start
+    (try
+      (do
+        (throw $e-throw (i32.const 0))
+      )
+      (catch $e-catch
+        (drop (pop i32))
+      )
+    )
+  )
+)
diff --git a/test/lit/passes/remove-unused-names-eh.wast b/test/lit/passes/remove-unused-names-eh.wast
new file mode 100644
index 000000000..fd20c07e4
--- /dev/null
+++ b/test/lit/passes/remove-unused-names-eh.wast
@@ -0,0 +1,70 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --remove-unused-names -all -S -o - | filecheck %s
+
+(module
+  (event $event$0 (attr 0) (param i32))
+
+  ;; CHECK:      (func $func0
+  ;; CHECK-NEXT:  (try $label$9
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $event$0
+  ;; CHECK-NEXT:    (try $label$8
+  ;; CHECK-NEXT:     (do
+  ;; CHECK-NEXT:      (try
+  ;; CHECK-NEXT:       (do
+  ;; CHECK-NEXT:        (rethrow $label$9)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (delegate $label$8)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch $event$0
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (pop i32)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $func0
+    (try $label$9 ;; needed due to a rethrow
+      (do)
+      (catch $event$0
+        (try $label$8 ;; needed due to a delegate
+          (do
+            (try $label$6 ;; this one is not needed
+              (do
+                (rethrow $label$9)
+              )
+              (delegate $label$8)
+            )
+          )
+          (catch $event$0
+            (drop
+              (pop i32)
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $func1
+  ;; CHECK-NEXT:  (try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (delegate 0)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $func1
+    (try $label$3 ;; this one is not needed
+      (do
+        (nop)
+      )
+      (delegate 0) ;; delegates to the caller
+    )
+  )
+)
diff --git a/test/lit/passes/rse-eh.wast b/test/lit/passes/rse-eh.wast
new file mode 100644
index 000000000..d6f7074e7
--- /dev/null
+++ b/test/lit/passes/rse-eh.wast
@@ -0,0 +1,449 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --rse -all -S -o - | filecheck %s
+
+(module
+  (event $e (attr 0) (param i32))
+  (event $e2 (attr 0))
+
+  ;; CHECK:      (func $try1
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (local.set $x
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $try1
+    (local $x i32)
+    (try
+      (do)
+      (catch_all
+        (local.set $x (i32.const 1))
+      )
+    )
+    ;; try will not throw. So this should NOT be dropped
+    (local.set $x (i32.const 1))
+  )
+
+  ;; CHECK:      (func $try2
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (throw $e
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (local.set $x
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $try2
+    (local $x i32)
+    (try
+      (do
+        (throw $e (i32.const 0))
+        (local.set $x (i32.const 1))
+      )
+      (catch_all)
+    )
+    ;; local.set is after 'throw' so it will not run. This should NOT be
+    ;; dropped.
+    (local.set $x (i32.const 1))
+  )
+
+  ;; CHECK:      (func $try3
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (throw $e
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (local.set $x
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $try3
+    (local $x i32)
+    (try
+      (do
+        (throw $e (i32.const 0))
+      )
+      (catch_all
+        (local.set $x (i32.const 1))
+      )
+    )
+    ;; try body will throw and catch_all contains the same local.set. This
+    ;; should be dropped.
+    (local.set $x (i32.const 1))
+  )
+
+  (func $foo)
+  ;; CHECK:      (func $try4
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:    (local.set $x
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $try4
+    (local $x i32)
+    (try
+      (do
+        (call $foo)
+        (local.set $x (i32.const 1))
+      )
+      (catch_all)
+    )
+    ;; (call $foo) may throw and the local.set may not run, so this should NOT
+    ;; be dropped
+    (local.set $x (i32.const 1))
+  )
+
+  ;; CHECK:      (func $try5
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (local.set $x
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (call $foo)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $try5
+    (local $x i32)
+    (try
+      (do
+        (local.set $x (i32.const 1))
+        (call $foo)
+      )
+      (catch_all)
+    )
+    ;; Even if (call $foo) throws, local.set runs before it, so this should be
+    ;; dropped
+    (local.set $x (i32.const 1))
+  )
+
+  ;; CHECK:      (func $nested-try1
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (try $l0
+  ;; CHECK-NEXT:     (do
+  ;; CHECK-NEXT:      (throw $e
+  ;; CHECK-NEXT:       (i32.const 0)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch_all
+  ;; CHECK-NEXT:      (rethrow $l0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (local.set $x
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $nested-try1
+    (local $x i32)
+    (try
+      (do
+        (try $l0
+          (do
+            (throw $e (i32.const 0))
+          )
+          (catch_all
+            (rethrow $l0)
+          )
+        )
+      )
+      (catch_all
+        (local.set $x (i32.const 1))
+      )
+    )
+    ;; The exception is caught by the inner catch_all and rethrown and again
+    ;; caught by the outer catch_all, which runs the local.set. So this should
+    ;; be dropped.
+    (local.set $x (i32.const 1))
+  )
+
+  ;; CHECK:      (func $nested-try2
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (try $l0
+  ;; CHECK-NEXT:     (do
+  ;; CHECK-NEXT:      (throw $e
+  ;; CHECK-NEXT:       (i32.const 0)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch_all
+  ;; CHECK-NEXT:      (local.set $x
+  ;; CHECK-NEXT:       (i32.const 1)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (rethrow $l0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $nested-try2
+    (local $x i32)
+    (try
+      (do
+        (try $l0
+          (do
+            (throw $e (i32.const 0))
+          )
+          (catch_all
+            (local.set $x (i32.const 1))
+            (rethrow $l0)
+          )
+        )
+      )
+      (catch_all)
+    )
+    ;; The exception is caught by the inner catch_all, which runs the local.set,
+    ;; so this should be dropped
+    (local.set $x (i32.const 1))
+  )
+
+  ;; CHECK:      (func $nested-try3
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (try $l0
+  ;; CHECK-NEXT:     (do
+  ;; CHECK-NEXT:      (throw $e
+  ;; CHECK-NEXT:       (i32.const 0)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch $e
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (pop i32)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.set $x
+  ;; CHECK-NEXT:       (i32.const 1)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (rethrow $l0)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $nested-try3
+    (local $x i32)
+    (try
+      (do
+        (try $l0
+          (do
+            (throw $e (i32.const 0))
+          )
+          (catch $e
+            (drop (pop i32))
+            (local.set $x (i32.const 1))
+            (rethrow $l0)
+          )
+        )
+      )
+      (catch_all)
+    )
+    ;; Unlike nested-try2, the exception may not be caught by the inner catch,
+    ;; so the local.set may not run. So this should NOT be dropped.
+    (local.set $x (i32.const 1))
+  )
+
+  ;; CHECK:      (func $nested-catch1
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (throw $e
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $e
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (pop i32)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $e2
+  ;; CHECK-NEXT:    (try $try0
+  ;; CHECK-NEXT:     (do
+  ;; CHECK-NEXT:      (throw $e
+  ;; CHECK-NEXT:       (i32.const 0)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch $e
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (pop i32)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch $e2
+  ;; CHECK-NEXT:      (local.set $x
+  ;; CHECK-NEXT:       (i32.const 1)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $nested-catch1
+    (local $x i32)
+    (try
+      (do
+        (throw $e (i32.const 0))
+      )
+      (catch $e
+        (drop (pop i32))
+      )
+      (catch $e2
+        (try
+          (do
+            (throw $e (i32.const 0))
+          )
+          (catch $e
+            (drop (pop i32))
+          )
+          (catch $e2
+            (local.set $x (i32.const 1))
+          )
+        )
+      )
+    )
+    ;; This should NOT be dropped because the exception might not be caught by
+    ;; the inner catches, and the local.set above us may not have run, and
+    ;; other possible code paths do not even set the local.
+    (local.set $x (i32.const 1))
+  )
+
+  ;; CHECK:      (func $nested-catch2
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (throw $e
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $e
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (pop i32)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (local.set $x
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (try $try1
+  ;; CHECK-NEXT:     (do
+  ;; CHECK-NEXT:      (throw $e
+  ;; CHECK-NEXT:       (i32.const 0)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch $e
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (pop i32)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.set $x
+  ;; CHECK-NEXT:       (i32.const 1)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch_all
+  ;; CHECK-NEXT:      (local.set $x
+  ;; CHECK-NEXT:       (i32.const 1)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $nested-catch2
+    (local $x i32)
+    (try
+      (do
+        (throw $e (i32.const 0))
+      )
+      (catch $e
+        (drop (pop i32))
+        (local.set $x (i32.const 1))
+      )
+      (catch_all
+        (try
+          (do
+            (throw $e (i32.const 0))
+          )
+          (catch $e
+            (drop (pop i32))
+            (local.set $x (i32.const 1))
+          )
+          (catch_all
+            (local.set $x (i32.const 1))
+          )
+        )
+      )
+    )
+    ;; This should be dropped because the exception is guaranteed to be caught
+    ;; by one of the catches and it will set the local to 1.
+    (local.set $x (i32.const 1))
+  )
+)
diff --git a/test/lit/passes/simplify-locals-eh.wast b/test/lit/passes/simplify-locals-eh.wast
new file mode 100644
index 000000000..fb5f671f3
--- /dev/null
+++ b/test/lit/passes/simplify-locals-eh.wast
@@ -0,0 +1,153 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --simplify-locals -all -S -o - | filecheck %s
+
+(module
+  (event $e-i32 (attr 0) (param i32))
+  ;; CHECK:      (func $foo (param $0 i32) (param $1 i32)
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT: )
+  (func $foo (param i32 i32))
+  ;; CHECK:      (func $pop-cannot-be-sinked
+  ;; CHECK-NEXT:  (local $0 i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $e-i32
+  ;; CHECK-NEXT:    (local.set $0
+  ;; CHECK-NEXT:     (pop i32)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (call $foo
+  ;; CHECK-NEXT:     (i32.const 3)
+  ;; CHECK-NEXT:     (local.get $0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $pop-cannot-be-sinked (local $0 i32)
+    (try
+      (do)
+      (catch $e-i32
+        ;; This (local.set $0) of (pop i32) cannot be sunk to (local.get $0)
+        ;; below, because the pop should follow right after 'catch'.
+        (local.set $0 (pop i32))
+        (call $foo
+          (i32.const 3)
+          (local.get $0)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $pop-within-catch-can-be-sinked
+  ;; CHECK-NEXT:  (local $0 i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (nop)
+  ;; CHECK-NEXT:    (call $foo
+  ;; CHECK-NEXT:     (i32.const 3)
+  ;; CHECK-NEXT:     (try $try0 (result i32)
+  ;; CHECK-NEXT:      (do
+  ;; CHECK-NEXT:       (i32.const 0)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (catch $e-i32
+  ;; CHECK-NEXT:       (pop i32)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $pop-within-catch-can-be-sinked (local $0 i32)
+    (try
+      (do)
+      (catch_all
+        ;; This whole 'try' body can be sinked to eliminate local.set /
+        ;; local.get. Even though it contains a pop, it is enclosed within
+        ;; try-catch, so it is OK.
+        (local.set $0
+          (try (result i32)
+            (do (i32.const 0))
+            (catch $e-i32 (pop i32))
+          )
+        )
+        (call $foo
+          (i32.const 3)
+          (local.get $0)
+        )
+      )
+    )
+  )
+
+  ;; CHECK:      (func $bar (result i32)
+  ;; CHECK-NEXT:  (i32.const 3)
+  ;; CHECK-NEXT: )
+  (func $bar (result i32) (i32.const 3))
+  ;; CHECK:      (func $call-cannot-be-sinked-into-try
+  ;; CHECK-NEXT:  (local $0 i32)
+  ;; CHECK-NEXT:  (local.set $0
+  ;; CHECK-NEXT:   (call $bar)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (local.get $0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $e-i32
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (pop i32)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $call-cannot-be-sinked-into-try (local $0 i32)
+    (drop
+      ;; This local.tee should NOT be sinked into 'try' below, because it may
+      ;; throw
+      (local.tee $0 (call $bar))
+    )
+    (try
+      (do
+        (drop (local.get $0))
+      )
+      (catch $e-i32
+        (drop (pop i32))
+      )
+    )
+  )
+
+  ;; CHECK:      (func $non-call-can-be-sinked-into-try
+  ;; CHECK-NEXT:  (local $0 i32)
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (i32.const 3)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $e-i32
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (pop i32)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $non-call-can-be-sinked-into-try (local $0 i32)
+    (drop
+      ;; This local.tee can be sinked into 'try' below, because it cannot throw
+      (local.tee $0 (i32.const 3))
+    )
+    (try
+      (do
+        (drop (local.get $0))
+      )
+      (catch $e-i32
+        (drop (pop i32))
+      )
+    )
+  )
+)
diff --git a/test/lit/passes/stack-ir-eh.wast b/test/lit/passes/stack-ir-eh.wast
new file mode 100644
index 000000000..a398be325
--- /dev/null
+++ b/test/lit/passes/stack-ir-eh.wast
@@ -0,0 +1,60 @@
+;; RUN: wasm-opt %s --generate-stack-ir --optimize-stack-ir --print-stack-ir \
+;; RUN:   -all -S -o - | filecheck %s
+
+(module
+  (event $e0 (attr 0) (param i32))
+
+  ;; CHECK:      (func $eh
+  ;; CHECK-NEXT:  try $l0
+  ;; CHECK-NEXT:   i32.const 0
+  ;; CHECK-NEXT:   throw $e0
+  ;; CHECK-NEXT:  catch $e0
+  ;; CHECK-NEXT:
+  ;; CHECK-NEXT:   drop
+  ;; CHECK-NEXT:  catch_all
+  ;; CHECK-NEXT:   rethrow $l0
+  ;; CHECK-NEXT:  end
+  ;; CHECK-NEXT:  try $l00
+  ;; CHECK-NEXT:   try $try
+  ;; CHECK-NEXT:    i32.const 0
+  ;; CHECK-NEXT:    throw $e0
+  ;; CHECK-NEXT:   delegate $l00
+  ;; CHECK-NEXT:   unreachable
+  ;; CHECK-NEXT:  catch_all
+  ;; CHECK-NEXT:   nop
+  ;; CHECK-NEXT:  end
+  ;; CHECK-NEXT:  try $l01
+  ;; CHECK-NEXT:   nop
+  ;; CHECK-NEXT:  delegate 0
+  ;; CHECK-NEXT: )
+  (func $eh
+    (try $l0
+      (do
+        (throw $e0 (i32.const 0))
+      )
+      (catch $e0
+        (drop (pop i32))
+      )
+      (catch_all
+        (rethrow $l0)
+      )
+    )
+
+    (try $l0
+      (do
+        (try
+          (do
+            (throw $e0 (i32.const 0))
+          )
+          (delegate $l0)
+        )
+      )
+      (catch_all)
+    )
+
+    (try $l0
+      (do)
+      (delegate 0) ;; delegate to caller
+    )
+  )
+)
diff --git a/test/lit/passes/stack-ir-roundtrip-eh.wast b/test/lit/passes/stack-ir-roundtrip-eh.wast
new file mode 100644
index 000000000..b9bb22d3e
--- /dev/null
+++ b/test/lit/passes/stack-ir-roundtrip-eh.wast
@@ -0,0 +1,61 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --generate-stack-ir --roundtrip -all -S -o - | filecheck %s
+
+(module
+ (event $event (attr 0) (param i32))
+  ;; CHECK:      (func $delegate-child
+  ;; CHECK-NEXT:  (try $label$9
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (try $label$7
+  ;; CHECK-NEXT:     (do
+  ;; CHECK-NEXT:      (nop)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch $event$0
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (pop i32)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (try $label$6
+  ;; CHECK-NEXT:       (do
+  ;; CHECK-NEXT:        (nop)
+  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (delegate 2)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $event$0
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (pop i32)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $delegate-child
+    (try
+      (do
+        (try
+          (do)
+          (catch $event
+            (drop
+              (pop i32)
+            )
+            (try
+              (do)
+              ;; the binary writer must properly handle this delegate which is
+              ;; the child of other try's, and not get confused by their
+              ;; information on the stack (this is a regression test for us
+              ;; properly ending the scope with a delegate and popping the
+              ;; relevant stack).
+              (delegate 2)
+            )
+          )
+        )
+      )
+      (catch $event
+        (drop
+          (pop i32)
+        )
+      )
+    )
+  )
+)
diff --git a/test/lit/passes/vacuum-eh.wast b/test/lit/passes/vacuum-eh.wast
new file mode 100644
index 000000000..d69278319
--- /dev/null
+++ b/test/lit/passes/vacuum-eh.wast
@@ -0,0 +1,126 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
+;; RUN: wasm-opt %s --vacuum -all -S -o - | filecheck %s
+
+(module
+  (event $e (attr 0) (param i32))
+  (event $e2 (attr 0) (param i32))
+
+  ;; CHECK:      (func $try-test
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT: )
+  (func $try-test
+    ;; When try body does not throw, try-body can be replaced with the try body
+    (try
+      (do
+        (drop (i32.const 0))
+      )
+      (catch $e
+        (drop (pop i32))
+      )
+    )
+  )
+
+  ;; CHECK:      (func $inner-try-catch_all-test
+  ;; CHECK-NEXT:  (local $0 i32)
+  ;; CHECK-NEXT:  (try $try0
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (throw $e
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch_all
+  ;; CHECK-NEXT:    (local.set $0
+  ;; CHECK-NEXT:     (i32.const 1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $inner-try-catch_all-test (local $0 i32)
+    ;; The exception thrown in the inner try is caught by the inner catch_all,
+    ;; so the outer try body does not throw and the outer try-catch can be
+    ;; removed
+    (try
+      (do
+        (try
+          (do
+            (throw $e (i32.const 0))
+          )
+          (catch_all
+            (local.set $0 (i32.const 1))
+          )
+        )
+      )
+      (catch $e
+        (drop (pop i32))
+      )
+    )
+  )
+
+  ;; CHECK:      (func $inner-try-catch-test
+  ;; CHECK-NEXT:  (local $0 i32)
+  ;; CHECK-NEXT:  (try $try
+  ;; CHECK-NEXT:   (do
+  ;; CHECK-NEXT:    (try $try1
+  ;; CHECK-NEXT:     (do
+  ;; CHECK-NEXT:      (throw $e2
+  ;; CHECK-NEXT:       (i32.const 0)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (catch $e
+  ;; CHECK-NEXT:      (drop
+  ;; CHECK-NEXT:       (pop i32)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:      (local.set $0
+  ;; CHECK-NEXT:       (i32.const 1)
+  ;; CHECK-NEXT:      )
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (catch $e
+  ;; CHECK-NEXT:    (drop
+  ;; CHECK-NEXT:     (pop i32)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $inner-try-catch-test (local $0 i32)
+    ;; The exception thrown in the inner try will not be caught by the inner
+    ;; catch, so the outer try-catch cannot be removed
+    (try
+      (do
+        (try
+          (do
+            (throw $e2 (i32.const 0))
+          )
+          (catch $e
+            (drop (pop i32))
+            (local.set $0 (i32.const 1))
+          )
+        )
+      )
+      (catch $e
+        (drop (pop i32))
+      )
+    )
+  )
+
+  ;; CHECK:      (func $br-in-catch
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT: )
+  (func $br-in-catch
+    ;; When catch body is removed, the removal of 'br' inside the catch body
+    ;; should be propagated up to the outer block, so that its type will be
+    ;; correctly updated to unreachable.
+    (block $label$1
+      (try
+        (do
+          (unreachable)
+        )
+        (catch $e
+          (drop (pop i32))
+          (br $label$1)
+        )
+      )
+    )
+  )
+)