Basic EH instrucion support for the new spec (#3487)

This updates `try`-`catch`-`catch_all` and `rethrow` instructions to
match the new spec. `delegate` is not included. Now `Try` contains not a
single `catchBody` expression but a vector of catch
bodies and events.

This updates most existing routines, optimizations, and tests modulo the
interpreter and the CFG traversal. Because the interpreter has not been
updated yet, the EH spec test is temporarily disabled in check.py. Also,
because the CFG traversal for EH is not yet updated, several EH tests in
`rse_all-features.wast`, which uses CFG traversal, are temporarily
commented out.

Also added a few more tests in existing EH test functions in
test/passes. In the previous spec, `catch` was catching all exceptions
so it was assumed that anything `try` body throws is caught by its
`catch`, but now we can assume the same only if there is a `catch_all`.
Newly added tests test cases when there is a `catch_all` and cases there
are only `catch`es separately.

73 files changed, 1621 insertions, 961 deletions

diff --git a/check.py b/check.py
index 237697d43..fa9a060f8 100755
--- a/check.py
+++ b/check.py
@@ -189,6 +189,9 @@ def run_spec_tests():
         # windows has some failures that need to be investigated
         if base == 'names.wast' and shared.skip_if_on_windows('spec: ' + base):
             continue
+        # FIXME Reenable this after updating interpreter for EH
+        if base == 'exception-handling.wast':
+            continue
 
         def run_spec_test(wast):
             cmd = shared.WASM_SHELL + [wast]
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 59ca3aebc..f08b5f777 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -1200,10 +1200,20 @@ BinaryenExpressionRef BinaryenRefEq(BinaryenModuleRef module,
 
 BinaryenExpressionRef BinaryenTry(BinaryenModuleRef module,
                                   BinaryenExpressionRef body,
-                                  BinaryenExpressionRef catchBody) {
+                                  const char** catchEvents_,
+                                  BinaryenIndex numCatchEvents,
+                                  BinaryenExpressionRef* catchBodies_,
+                                  BinaryenIndex numCatchBodies) {
+  std::vector<Name> catchEvents;
+  std::vector<Expression*> catchBodies;
+  for (BinaryenIndex i = 0; i < numCatchEvents; i++) {
+    catchEvents.push_back(catchEvents_[i]);
+  }
+  for (BinaryenIndex i = 0; i < numCatchBodies; i++) {
+    catchBodies.push_back((Expression*)catchBodies_[i]);
+  }
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeTry((Expression*)body, (Expression*)catchBody));
+    Builder(*(Module*)module).makeTry(body, catchEvents, catchBodies));
 }
 
 BinaryenExpressionRef BinaryenThrow(BinaryenModuleRef module,
@@ -1219,9 +1229,8 @@ BinaryenExpressionRef BinaryenThrow(BinaryenModuleRef module,
 }
 
 BinaryenExpressionRef BinaryenRethrow(BinaryenModuleRef module,
-                                      BinaryenExpressionRef exnref) {
-  return static_cast<Expression*>(
-    Builder(*(Module*)module).makeRethrow((Expression*)exnref));
+                                      BinaryenIndex depth) {
+  return static_cast<Expression*>(Builder(*(Module*)module).makeRethrow(depth));
 }
 
 BinaryenExpressionRef BinaryenBrOnExn(BinaryenModuleRef module,
@@ -2755,17 +2764,101 @@ void BinaryenTrySetBody(BinaryenExpressionRef expr,
   assert(bodyExpr);
   static_cast<Try*>(expression)->body = (Expression*)bodyExpr;
 }
-BinaryenExpressionRef BinaryenTryGetCatchBody(BinaryenExpressionRef expr) {
+BinaryenIndex BinaryenTryGetNumCatchEvents(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  return static_cast<Try*>(expression)->catchEvents.size();
+}
+BinaryenIndex BinaryenTryGetNumCatchBodies(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  return static_cast<Try*>(expression)->catchBodies.size();
+}
+const char* BinaryenTryGetCatchEventAt(BinaryenExpressionRef expr,
+                                       BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  assert(index < static_cast<Try*>(expression)->catchEvents.size());
+  return static_cast<Try*>(expression)->catchEvents[index].c_str();
+}
+void BinaryenTrySetCatchEventAt(BinaryenExpressionRef expr,
+                                BinaryenIndex index,
+                                const char* catchEvent) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Try>());
-  return static_cast<Try*>(expression)->catchBody;
+  assert(index < static_cast<Try*>(expression)->catchEvents.size());
+  assert(catchEvent);
+  static_cast<Try*>(expression)->catchEvents[index] = catchEvent;
 }
-void BinaryenTrySetCatchBody(BinaryenExpressionRef expr,
-                             BinaryenExpressionRef catchBodyExpr) {
+BinaryenIndex BinaryenTryAppendCatchEvent(BinaryenExpressionRef expr,
+                                          const char* catchEvent) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Try>());
-  assert(catchBodyExpr);
-  static_cast<Try*>(expression)->catchBody = (Expression*)catchBodyExpr;
+  assert(catchEvent);
+  auto& list = static_cast<Try*>(expression)->catchEvents;
+  auto index = list.size();
+  list.push_back(catchEvent);
+  return index;
+}
+void BinaryenTryInsertCatchEventAt(BinaryenExpressionRef expr,
+                                   BinaryenIndex index,
+                                   const char* catchEvent) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  assert(catchEvent);
+  static_cast<Try*>(expression)->catchEvents.insertAt(index, catchEvent);
+}
+const char* BinaryenTryRemoveCatchEventAt(BinaryenExpressionRef expr,
+                                          BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  return static_cast<Try*>(expression)->catchEvents.removeAt(index).c_str();
+}
+BinaryenExpressionRef BinaryenTryGetCatchBodyAt(BinaryenExpressionRef expr,
+                                                BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  assert(index < static_cast<Try*>(expression)->catchBodies.size());
+  return static_cast<Try*>(expression)->catchBodies[index];
+}
+void BinaryenTrySetCatchBodyAt(BinaryenExpressionRef expr,
+                               BinaryenIndex index,
+                               BinaryenExpressionRef catchExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  assert(index < static_cast<Try*>(expression)->catchBodies.size());
+  assert(catchExpr);
+  static_cast<Try*>(expression)->catchBodies[index] = (Expression*)catchExpr;
+}
+BinaryenIndex BinaryenTryAppendCatchBody(BinaryenExpressionRef expr,
+                                         BinaryenExpressionRef catchExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  assert(catchExpr);
+  auto& list = static_cast<Try*>(expression)->catchBodies;
+  auto index = list.size();
+  list.push_back((Expression*)catchExpr);
+  return index;
+}
+void BinaryenTryInsertCatchBodyAt(BinaryenExpressionRef expr,
+                                  BinaryenIndex index,
+                                  BinaryenExpressionRef catchExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  assert(catchExpr);
+  static_cast<Try*>(expression)
+    ->catchBodies.insertAt(index, (Expression*)catchExpr);
+}
+BinaryenExpressionRef BinaryenTryRemoveCatchBodyAt(BinaryenExpressionRef expr,
+                                                   BinaryenIndex index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  return static_cast<Try*>(expression)->catchBodies.removeAt(index);
+}
+int BinaryenTryHasCatchAll(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<Try>());
+  return static_cast<Try*>(expression)->hasCatchAll();
 }
 // Throw
 const char* BinaryenThrowGetEvent(BinaryenExpressionRef expr) {
@@ -2825,17 +2918,15 @@ BinaryenExpressionRef BinaryenThrowRemoveOperandAt(BinaryenExpressionRef expr,
   return static_cast<Throw*>(expression)->operands.removeAt(index);
 }
 // Rethrow
-BinaryenExpressionRef BinaryenRethrowGetExnref(BinaryenExpressionRef expr) {
+BinaryenIndex BinaryenRethrowGetDepth(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Rethrow>());
-  return static_cast<Rethrow*>(expression)->exnref;
+  return static_cast<Rethrow*>(expression)->depth;
 }
-void BinaryenRethrowSetExnref(BinaryenExpressionRef expr,
-                              BinaryenExpressionRef exnrefExpr) {
+void BinaryenRethrowSetDepth(BinaryenExpressionRef expr, BinaryenIndex depth) {
   auto* expression = (Expression*)expr;
   assert(expression->is<Rethrow>());
-  assert(exnrefExpr);
-  static_cast<Rethrow*>(expression)->exnref = (Expression*)exnrefExpr;
+  static_cast<Rethrow*>(expression)->depth = depth;
 }
 // BrOnExn
 const char* BinaryenBrOnExnGetEvent(BinaryenExpressionRef expr) {
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index a32d9ff1c..8d991343d 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -796,16 +796,20 @@ BINARYEN_API BinaryenExpressionRef BinaryenRefFunc(BinaryenModuleRef module,
 BINARYEN_API BinaryenExpressionRef BinaryenRefEq(BinaryenModuleRef module,
                                                  BinaryenExpressionRef left,
                                                  BinaryenExpressionRef right);
-BINARYEN_API BinaryenExpressionRef BinaryenTry(BinaryenModuleRef module,
-                                               BinaryenExpressionRef body,
-                                               BinaryenExpressionRef catchBody);
+BINARYEN_API BinaryenExpressionRef
+BinaryenTry(BinaryenModuleRef module,
+            BinaryenExpressionRef body,
+            const char** catchEvents,
+            BinaryenIndex numCatchEvents,
+            BinaryenExpressionRef* catchBodies,
+            BinaryenIndex numCatchBodies);
 BINARYEN_API BinaryenExpressionRef
 BinaryenThrow(BinaryenModuleRef module,
               const char* event,
               BinaryenExpressionRef* operands,
               BinaryenIndex numOperands);
-BINARYEN_API BinaryenExpressionRef
-BinaryenRethrow(BinaryenModuleRef module, BinaryenExpressionRef exnref);
+BINARYEN_API BinaryenExpressionRef BinaryenRethrow(BinaryenModuleRef module,
+                                                   BinaryenIndex depth);
 BINARYEN_API BinaryenExpressionRef
 BinaryenBrOnExn(BinaryenModuleRef module,
                 const char* name,
@@ -1714,12 +1718,57 @@ BinaryenTryGetBody(BinaryenExpressionRef expr);
 // Sets the body expression of a `try` expression.
 BINARYEN_API void BinaryenTrySetBody(BinaryenExpressionRef expr,
                                      BinaryenExpressionRef bodyExpr);
-// Gets the catch body expression of a `try` expression.
+// Gets the number of catch blocks (= the number of catch events) of a `try`
+// expression.
+BINARYEN_API BinaryenIndex
+BinaryenTryGetNumCatchEvents(BinaryenExpressionRef expr);
+// Gets the number of catch/catch_all blocks of a `try` expression.
+BINARYEN_API BinaryenIndex
+BinaryenTryGetNumCatchBodies(BinaryenExpressionRef expr);
+// Gets the catch event at the specified index of a `try` expression.
+BINARYEN_API const char* BinaryenTryGetCatchEventAt(BinaryenExpressionRef expr,
+                                                    BinaryenIndex index);
+// Sets the catch event at the specified index of a `try` expression.
+BINARYEN_API void BinaryenTrySetCatchEventAt(BinaryenExpressionRef expr,
+                                             BinaryenIndex index,
+                                             const char* catchEvent);
+// Appends a catch event to a `try` expression, returning its insertion index.
+BINARYEN_API BinaryenIndex
+BinaryenTryAppendCatchEvent(BinaryenExpressionRef expr, const char* catchEvent);
+// Inserts a catch event at the specified index of a `try` expression, moving
+// existing catch events including the one previously at that index one index
+// up.
+BINARYEN_API void BinaryenTryInsertCatchEventAt(BinaryenExpressionRef expr,
+                                                BinaryenIndex index,
+                                                const char* catchEvent);
+// Removes the catch event at the specified index of a `try` expression, moving
+// all subsequent catch events one index down. Returns the event.
+BINARYEN_API const char*
+BinaryenTryRemoveCatchEventAt(BinaryenExpressionRef expr, BinaryenIndex index);
+// Gets the catch body expression at the specified index of a `try` expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenTryGetCatchBodyAt(BinaryenExpressionRef expr, BinaryenIndex index);
+// Sets the catch body expression at the specified index of a `try` expression.
+BINARYEN_API void BinaryenTrySetCatchBodyAt(BinaryenExpressionRef expr,
+                                            BinaryenIndex index,
+                                            BinaryenExpressionRef catchExpr);
+// Appends a catch expression to a `try` expression, returning its insertion
+// index.
+BINARYEN_API BinaryenIndex BinaryenTryAppendCatchBody(
+  BinaryenExpressionRef expr, BinaryenExpressionRef catchExpr);
+// Inserts a catch expression at the specified index of a `try` expression,
+// moving existing catch bodies including the one previously at that index one
+// index up.
+BINARYEN_API void BinaryenTryInsertCatchBodyAt(BinaryenExpressionRef expr,
+                                               BinaryenIndex index,
+                                               BinaryenExpressionRef catchExpr);
+// Removes the catch expression at the specified index of a `try` expression,
+// moving all subsequent catch bodies one index down. Returns the catch
+// expression.
 BINARYEN_API BinaryenExpressionRef
-BinaryenTryGetCatchBody(BinaryenExpressionRef expr);
-// Sets the catch body expression of a `try` expression.
-BINARYEN_API void BinaryenTrySetCatchBody(BinaryenExpressionRef expr,
-                                          BinaryenExpressionRef catchBodyExpr);
+BinaryenTryRemoveCatchBodyAt(BinaryenExpressionRef expr, BinaryenIndex index);
+// Gets whether an `try` expression has a catch_all clause.
+BINARYEN_API int BinaryenTryHasCatchAll(BinaryenExpressionRef expr);
 
 // Throw
 
@@ -1757,12 +1806,11 @@ BinaryenThrowRemoveOperandAt(BinaryenExpressionRef expr, BinaryenIndex index);
 
 // Rethrow
 
-// Gets the exception reference expression of a `rethrow` expression.
-BINARYEN_API BinaryenExpressionRef
-BinaryenRethrowGetExnref(BinaryenExpressionRef expr);
+// Gets the depth of a `rethrow` expression.
+BINARYEN_API BinaryenIndex BinaryenRethrowGetDepth(BinaryenExpressionRef expr);
 // Sets the exception reference expression of a `rethrow` expression.
-BINARYEN_API void BinaryenRethrowSetExnref(BinaryenExpressionRef expr,
-                                           BinaryenExpressionRef exnrefExpr);
+BINARYEN_API void BinaryenRethrowSetDepth(BinaryenExpressionRef expr,
+                                          BinaryenIndex depth);
 
 // BrOnExn
 
diff --git a/src/cfg/cfg-traversal.h b/src/cfg/cfg-traversal.h
index 647b795a4..479c09e4b 100644
--- a/src/cfg/cfg-traversal.h
+++ b/src/cfg/cfg-traversal.h
@@ -304,12 +304,16 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
         break;
       }
       case Expression::Id::TryId: {
+        // FIXME Update the implementation to match the new spec
+        WASM_UNREACHABLE("unimp");
+        /*
         self->pushTask(SubType::doEndTry, currp);
         self->pushTask(SubType::scan, &curr->cast<Try>()->catchBody);
         self->pushTask(SubType::doStartCatch, currp);
         self->pushTask(SubType::scan, &curr->cast<Try>()->body);
         self->pushTask(SubType::doStartTry, currp);
         return; // don't do anything else
+        */
       }
       case Expression::Id::ThrowId:
       case Expression::Id::RethrowId: {
diff --git a/src/ir/ExpressionAnalyzer.cpp b/src/ir/ExpressionAnalyzer.cpp
index 88dce6767..04ef52026 100644
--- a/src/ir/ExpressionAnalyzer.cpp
+++ b/src/ir/ExpressionAnalyzer.cpp
@@ -206,6 +206,7 @@ bool ExpressionAnalyzer::flexibleEqual(Expression* left,
   }
 
 #define DELEGATE_FIELD_INT_ARRAY(id, name) COMPARE_LIST(name)
+#define DELEGATE_FIELD_NAME_VECTOR(id, name) COMPARE_LIST(name)
 
 #define DELEGATE_FIELD_SCOPE_NAME_DEF(id, name)                                \
   if (castLeft->name.is() != castRight->name.is()) {                           \
diff --git a/src/ir/ExpressionManipulator.cpp b/src/ir/ExpressionManipulator.cpp
index 18c3f2df9..7ad8d0f50 100644
--- a/src/ir/ExpressionManipulator.cpp
+++ b/src/ir/ExpressionManipulator.cpp
@@ -97,6 +97,7 @@ flexibleCopy(Expression* original, Module& wasm, CustomCopier custom) {
   COPY_FIELD_LIST(name)
 
 #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, name) COPY_VECTOR(name)
+#define DELEGATE_FIELD_NAME_VECTOR(id, name) COPY_VECTOR(name)
 
 #define DELEGATE_FIELD_INT_ARRAY(id, name) COPY_ARRAY(name)
 
diff --git a/src/ir/branch-utils.h b/src/ir/branch-utils.h
index d7a6edcae..2e7ef470d 100644
--- a/src/ir/branch-utils.h
+++ b/src/ir/branch-utils.h
@@ -58,6 +58,7 @@ template<typename T> void operateOnScopeNameUses(Expression* expr, T func) {
 #define DELEGATE_FIELD_INT(id, name)
 #define DELEGATE_FIELD_LITERAL(id, name)
 #define DELEGATE_FIELD_NAME(id, name)
+#define DELEGATE_FIELD_NAME_VECTOR(id, name)
 #define DELEGATE_FIELD_SCOPE_NAME_DEF(id, name)
 #define DELEGATE_FIELD_SIGNATURE(id, name)
 #define DELEGATE_FIELD_TYPE(id, name)
@@ -104,6 +105,7 @@ template<typename T> void operateOnScopeNameDefs(Expression* expr, T func) {
 #define DELEGATE_FIELD_INT(id, name)
 #define DELEGATE_FIELD_LITERAL(id, name)
 #define DELEGATE_FIELD_NAME(id, name)
+#define DELEGATE_FIELD_NAME_VECTOR(id, name)
 #define DELEGATE_FIELD_SIGNATURE(id, name)
 #define DELEGATE_FIELD_TYPE(id, name)
 #define DELEGATE_FIELD_ADDRESS(id, name)
diff --git a/src/ir/cost.h b/src/ir/cost.h
index fbb4e83ad..4424f2e00 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -546,7 +546,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, Index> {
   }
   Index visitTry(Try* curr) {
     // We assume no exception will be thrown in most cases
-    return visit(curr->body) + maybeVisit(curr->catchBody);
+    return visit(curr->body);
   }
   Index visitThrow(Throw* curr) {
     Index ret = 100;
@@ -555,7 +555,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, Index> {
     }
     return ret;
   }
-  Index visitRethrow(Rethrow* curr) { return 100 + visit(curr->exnref); }
+  Index visitRethrow(Rethrow* curr) { return 100; }
   Index visitBrOnExn(BrOnExn* curr) {
     return 1 + visit(curr->exnref) + curr->sent.size();
   }
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 71957d1f8..22fab593d 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -84,14 +84,16 @@ public:
   // wrt atomics (e.g. memory.grow)
   bool isAtomic = false;
   bool throws = false;
-  // The nested depth of try. If an instruction that may throw is inside an
-  // inner try, we don't mark it as 'throws', because it will be caught by an
-  // inner catch.
+  // The nested depth of try-catch_all. If an instruction that may throw is
+  // inside an inner try-catch_all, we don't mark it as 'throws', because it
+  // will be caught by an inner catch_all. We only count 'try's with a
+  // 'catch_all' because instructions within a 'try' without a 'catch_all' can
+  // still throw outside of the try.
   size_t tryDepth = 0;
   // The nested depth of catch. This is necessary to track danglng pops.
   size_t catchDepth = 0;
-  // If this expression contains 'exnref.pop's that are not enclosed in 'catch'
-  // body. For example, (drop (exnref.pop)) should set this to true.
+  // If this expression contains 'pop's that are not enclosed in 'catch' body.
+  // For example, (drop (pop i32)) should set this to true.
   bool danglingPop = false;
 
   // Helper functions to check for various effect types
@@ -258,7 +260,10 @@ private:
       if (curr->is<Try>()) {
         self->pushTask(doVisitTry, currp);
         self->pushTask(doEndCatch, currp);
-        self->pushTask(scan, &curr->cast<Try>()->catchBody);
+        auto& catchBodies = curr->cast<Try>()->catchBodies;
+        for (int i = int(catchBodies.size()) - 1; i >= 0; i--) {
+          self->pushTask(scan, &catchBodies[i]);
+        }
         self->pushTask(doStartCatch, currp);
         self->pushTask(scan, &curr->cast<Try>()->body);
         self->pushTask(doStartTry, currp);
@@ -269,12 +274,22 @@ private:
     }
 
     static void doStartTry(InternalAnalyzer* self, Expression** currp) {
-      self->parent.tryDepth++;
+      Try* curr = (*currp)->cast<Try>();
+      // We only count 'try's with a 'catch_all' because instructions within a
+      // 'try' without a 'catch_all' can still throw outside of the try.
+      if (curr->hasCatchAll()) {
+        self->parent.tryDepth++;
+      }
     }
 
     static void doStartCatch(InternalAnalyzer* self, Expression** currp) {
-      assert(self->parent.tryDepth > 0 && "try depth cannot be negative");
-      self->parent.tryDepth--;
+      Try* curr = (*currp)->cast<Try>();
+      // We only count 'try's with a 'catch_all' because instructions within a
+      // 'try' without a 'catch_all' can still throw outside of the try.
+      if (curr->hasCatchAll()) {
+        assert(self->parent.tryDepth > 0 && "try depth cannot be negative");
+        self->parent.tryDepth--;
+      }
       self->parent.catchDepth++;
     }
 
diff --git a/src/ir/utils.h b/src/ir/utils.h
index 0136fd11c..424298bb3 100644
--- a/src/ir/utils.h
+++ b/src/ir/utils.h
@@ -222,8 +222,10 @@ struct AutoDrop : public WalkerPass<ExpressionStackWalker<AutoDrop>> {
     if (maybeDrop(curr->body)) {
       acted = true;
     }
-    if (maybeDrop(curr->catchBody)) {
-      acted = true;
+    for (auto* catchBody : curr->catchBodies) {
+      if (maybeDrop(catchBody)) {
+        acted = true;
+      }
     }
     if (acted) {
       reFinalize();
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 6cdf26e32..c3dc2144c 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -2135,14 +2135,15 @@ function wrapModule(module, self = {}) {
     }
   };
 
-  self['try'] = function(body, catchBody) {
-    return Module['_BinaryenTry'](module, body, catchBody);
+  self['try'] = function(body, catchEvents, catchBodies) {
+    return preserveStack(() =>
+      Module['_BinaryenTry'](module, body, i32sToStack(catchEvents.map(strToStack)), catchEvents.length, i32sToStack(catchBodies), catchBodies.length));
   };
   self['throw'] = function(event_, operands) {
     return preserveStack(() => Module['_BinaryenThrow'](module, strToStack(event_), i32sToStack(operands), operands.length));
   };
-  self['rethrow'] = function(exnref) {
-    return Module['_BinaryenRethrow'](module, exnref);
+  self['rethrow'] = function(depth) {
+    return Module['_BinaryenRethrow'](module, depth);
   };
   self['br_on_exn'] = function(label, event_, exnref) {
     return preserveStack(() => Module['_BinaryenBrOnExn'](module, strToStack(label), strToStack(event_), exnref));
@@ -2850,7 +2851,9 @@ Module['getExpressionInfo'] = function(expr) {
         'id': id,
         'type': type,
         'body': Module['_BinaryenTryGetBody'](expr),
-        'catchBody': Module['_BinaryenTryGetCatchBody'](expr)
+        'catchEvents': getAllNested(expr, Module['_BinaryenTryGetNumCatchEvents'], Module['_BinaryenTryGetCatchEventAt']),
+        'catchBodies': getAllNested(expr, Module['_BinaryenTryGetNumCatchBodies'], Module['_BinaryenTryGetCatchBodyAt']),
+        'hasCatchAll': Module['_BinaryenTryHasCatchAll'](expr)
       };
     case Module['ThrowId']:
       return {
@@ -2863,7 +2866,7 @@ Module['getExpressionInfo'] = function(expr) {
       return {
         'id': id,
         'type': type,
-        'exnref': Module['_BinaryenRethrowGetExnref'](expr)
+        'depth': Module['_BinaryenRethrowGetDepth'](expr)
       };
     case Module['BrOnExnId']:
       return {
@@ -4189,12 +4192,97 @@ Module['Try'] = makeExpressionWrapper({
   'setBody'(expr, bodyExpr) {
     Module['_BinaryenTrySetBody'](expr, bodyExpr);
   },
-  'getCatchBody'(expr) {
-    return Module['_BinaryenTryGetCatchBody'](expr);
+  'getNumCatchEvents'(expr) {
+    return Module['_BinaryenTryGetNumCatchEvents'](expr);
+  },
+  'getCatchEvents'(expr) {
+    const numCatchEvents = Module['_BinaryenTryGetNumCatchEvents'](expr);
+    const catchEvents = new Array(numCatchEvents);
+    let index = 0;
+    while (index < numCatchEvents) {
+      catchEvents[index] = UTF8ToString(Module['_BinaryenTryGetCatchEventAt'](expr, index++));
+    }
+    return catchEvents;
+  },
+  'setCatchEvents'(expr, catchEvents) {
+    const numCatchEvents = catchEvents.length;
+    let prevNumCatchEvents = Module['_BinaryenTryGetNumCatchEvents'](expr);
+    let index = 0;
+    while (index < numCatchEvents) {
+      preserveStack(() => {
+        if (index < prevNumCatchEvents) {
+          Module['_BinaryenTrySetCatchEventAt'](expr, index, strToStack(catchEvents[index]));
+        } else {
+          Module['_BinaryenTryAppendCatchEvent'](expr, strToStack(catchEvents[index]));
+        }
+      });
+      ++index;
+    }
+    while (prevNumCatchEvents > index) {
+      Module['_BinaryenTryRemoveCatchEventAt'](expr, --prevNumCatchEvents);
+    }
+  },
+  'getCatchEventAt'(expr, index) {
+    return UTF8ToString(Module['_BinaryenTryGetCatchEventAt'](expr, index));
+  },
+  'setCatchEventAt'(expr, index, catchEvent) {
+    preserveStack(() => { Module['_BinaryenTrySetCatchEventAt'](expr, index, strToStack(catchEvent)) });
+  },
+  'appendCatchEvent'(expr, catchEvent) {
+    preserveStack(() => Module['_BinaryenTryAppendCatchEvent'](expr, strToStack(catchEvent)));
+  },
+  'insertCatchEventAt'(expr, index, catchEvent) {
+    preserveStack(() => { Module['_BinaryenTryInsertCatchEventAt'](expr, index, strToStack(catchEvent)) });
+  },
+  'removeCatchEventAt'(expr, index) {
+    return UTF8ToString(Module['_BinaryenTryRemoveCatchEventAt'](expr, index));
+  },
+  'getNumCatchBodies'(expr) {
+    return Module['_BinaryenTryGetNumCatchBodies'](expr);
+  },
+  'getCatchBodies'(expr) {
+    const numCatchBodies = Module['_BinaryenTryGetNumCatchBodies'](expr);
+    const catchbodies = new Array(numCatchBodies);
+    let index = 0;
+    while (index < numCatchBodies) {
+      catchbodies[index] = Module['_BinaryenTryGetCatchBodyAt'](expr, index++);
+    }
+    return catchbodies;
+  },
+  'setCatchBodies'(expr, catchbodies) {
+    const numCatchBodies = catchbodies.length;
+    let prevNumCatchBodies = Module['_BinaryenTryGetNumCatchBodies'](expr);
+    let index = 0;
+    while (index < numCatchBodies) {
+      if (index < prevNumCatchBodies) {
+        Module['_BinaryenTrySetCatchBodyAt'](expr, index, catchbodies[index]);
+      } else {
+        Module['_BinaryenTryAppendCatchBody'](expr, catchbodies[index]);
+      }
+      ++index;
+    }
+    while (prevNumCatchBodies > index) {
+      Module['_BinaryenTryRemoveCatchBodyAt'](expr, --prevNumCatchBodies);
+    }
+  },
+  'getCatchBodyAt'(expr, index) {
+    return Module['_BinaryenTryGetCatchBodyAt'](expr, index);
+  },
+  'setCatchBodyAt'(expr, index, catchExpr) {
+    Module['_BinaryenTrySetCatchBodyAt'](expr, index, catchExpr);
+  },
+  'appendCatchBody'(expr, catchExpr) {
+    return Module['_BinaryenTryAppendCatchBody'](expr, catchExpr);
+  },
+  'insertCatchBodyAt'(expr, index, catchExpr) {
+    Module['_BinaryenTryInsertCatchBodyAt'](expr, index, catchExpr);
+  },
+  'removeCatchBodyAt'(expr, index) {
+    return Module['_BinaryenTryRemoveCatchBodyAt'](expr, index);
+  },
+  'hasCatchAll'(expr) {
+    return Boolean(Module['_BinaryenTryHasCatchAll'](expr));
   },
-  'setCatchBody'(expr, catchBodyExpr) {
-    Module['_BinaryenTrySetCatchBody'](expr, catchBodyExpr);
-  }
 });
 
 Module['Throw'] = makeExpressionWrapper({
@@ -4250,11 +4338,11 @@ Module['Throw'] = makeExpressionWrapper({
 });
 
 Module['Rethrow'] = makeExpressionWrapper({
-  'getExnref'(expr) {
-    return Module['_BinaryenRethrowGetExnref'](expr);
+  'getDepth'(expr) {
+    return Module['_BinaryenRethrowGetDepth'](expr);
   },
-  'setExnref'(expr, exnrefExpr) {
-    Module['_BinaryenRethrowSetExnref'](expr, exnrefExpr);
+  'setDepth'(expr, depthExpr) {
+    Module['_BinaryenRethrowSetDepth'](expr, depthExpr);
   }
 });
 
diff --git a/src/passes/CodeFolding.cpp b/src/passes/CodeFolding.cpp
index ee54c50a6..a0fc11c83 100644
--- a/src/passes/CodeFolding.cpp
+++ b/src/passes/CodeFolding.cpp
@@ -306,10 +306,10 @@ private:
       }
       if (getModule()->features.hasExceptionHandling()) {
         EffectAnalyzer effects(getPassOptions(), getModule()->features, item);
-        // Currently pop instructions are only used for exnref.pop, which is a
-        // pseudo instruction following a catch. We cannot move expressions
-        // containing pops if they are not enclosed in a 'catch' body, because a
-        // pop instruction should follow right after 'catch'.
+        // Pop instructions are pseudoinstructions used only after 'catch' to
+        // simulate its behavior. We cannot move expressions containing pops if
+        // they are not enclosed in a 'catch' body, because a pop instruction
+        // should follow right after 'catch'.
         if (effects.danglingPop) {
           return false;
         }
diff --git a/src/passes/DeadCodeElimination.cpp b/src/passes/DeadCodeElimination.cpp
index 3e84a7be1..c30da5428 100644
--- a/src/passes/DeadCodeElimination.cpp
+++ b/src/passes/DeadCodeElimination.cpp
@@ -161,9 +161,12 @@ struct DeadCodeElimination
     } else if (auto* tryy = curr->dynCast<Try>()) {
       // If both try body and catch body are unreachable, there is no need for a
       // concrete type, which may allow more reduction.
+      bool allCatchesUnreachable = true;
+      for (auto* catchBody : tryy->catchBodies) {
+        allCatchesUnreachable &= catchBody->type == Type::unreachable;
+      }
       if (tryy->type != Type::unreachable &&
-          tryy->body->type == Type::unreachable &&
-          tryy->catchBody->type == Type::unreachable) {
+          tryy->body->type == Type::unreachable && allCatchesUnreachable) {
         typeUpdater.changeType(tryy, Type::unreachable);
       }
     } else {
diff --git a/src/passes/MergeBlocks.cpp b/src/passes/MergeBlocks.cpp
index 33dbec77c..0ce776524 100644
--- a/src/passes/MergeBlocks.cpp
+++ b/src/passes/MergeBlocks.cpp
@@ -597,8 +597,6 @@ struct MergeBlocks : public WalkerPass<PostWalker<MergeBlocks>> {
     }
   }
 
-  void visitRethrow(Rethrow* curr) { optimize(curr, curr->exnref); }
-
   void visitBrOnExn(BrOnExn* curr) { optimize(curr, curr->exnref); }
 };
 
diff --git a/src/passes/OptimizeInstructions.cpp b/src/passes/OptimizeInstructions.cpp
index 2b0a95fc7..c06763643 100644
--- a/src/passes/OptimizeInstructions.cpp
+++ b/src/passes/OptimizeInstructions.cpp
@@ -1099,7 +1099,9 @@ private:
     } else if (auto* tryy = boolean->dynCast<Try>()) {
       if (tryy->type == Type::i32) {
         tryy->body = optimizeBoolean(tryy->body);
-        tryy->catchBody = optimizeBoolean(tryy->catchBody);
+        for (Index i = 0; i < tryy->catchBodies.size(); i++) {
+          tryy->catchBodies[i] = optimizeBoolean(tryy->catchBodies[i]);
+        }
       }
     }
     // TODO: recurse into br values?
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index e1d80a11a..b6da29861 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -1710,7 +1710,10 @@ struct PrintExpressionContents
     printMedium(o, "throw ");
     printName(curr->event, o);
   }
-  void visitRethrow(Rethrow* curr) { printMedium(o, "rethrow"); }
+  void visitRethrow(Rethrow* curr) {
+    printMedium(o, "rethrow ");
+    o << curr->depth;
+  }
   void visitBrOnExn(BrOnExn* curr) {
     printMedium(o, "br_on_exn ");
     printName(curr->name, o);
@@ -2363,12 +2366,23 @@ struct PrintSExpression : public OverriddenVisitor<PrintSExpression> {
     maybePrintImplicitBlock(curr->body, true);
     decIndent();
     o << "\n";
-    doIndent(o, indent);
-    o << "(catch";
-    incIndent();
-    maybePrintImplicitBlock(curr->catchBody, true);
-    decIndent();
-    o << "\n";
+    for (size_t i = 0; i < curr->catchEvents.size(); i++) {
+      doIndent(o, indent);
+      o << "(catch ";
+      printName(curr->catchEvents[i], o);
+      incIndent();
+      maybePrintImplicitBlock(curr->catchBodies[i], true);
+      decIndent();
+      o << "\n";
+    }
+    if (curr->hasCatchAll()) {
+      doIndent(o, indent);
+      o << "(catch_all";
+      incIndent();
+      maybePrintImplicitBlock(curr->catchBodies.back(), true);
+      decIndent();
+      o << "\n";
+    }
     decIndent();
     if (full) {
       o << " ;; end try";
@@ -2386,9 +2400,7 @@ struct PrintSExpression : public OverriddenVisitor<PrintSExpression> {
   void visitRethrow(Rethrow* curr) {
     o << '(';
     PrintExpressionContents(currFunction, o).visit(curr);
-    incIndent();
-    printFullLine(curr->exnref);
-    decIndent();
+    o << ')';
   }
   void visitBrOnExn(BrOnExn* curr) {
     o << '(';
diff --git a/src/passes/SimplifyLocals.cpp b/src/passes/SimplifyLocals.cpp
index 963575c5f..9f164ae92 100644
--- a/src/passes/SimplifyLocals.cpp
+++ b/src/passes/SimplifyLocals.cpp
@@ -425,8 +425,8 @@ struct SimplifyLocals
     if (set->isTee()) {
       return false;
     }
-    // We cannot move expressions containing exnref.pops that are not enclosed
-    // in 'catch', because 'exnref.pop' should follow right after 'catch'.
+    // We cannot move expressions containing pops that are not enclosed in
+    // 'catch', because 'pop' should follow right after 'catch'.
     FeatureSet features = this->getModule()->features;
     if (features.hasExceptionHandling() &&
         EffectAnalyzer(this->getPassOptions(), features, set->value)
diff --git a/src/passes/Vacuum.cpp b/src/passes/Vacuum.cpp
index 789c53ad7..ca777431a 100644
--- a/src/passes/Vacuum.cpp
+++ b/src/passes/Vacuum.cpp
@@ -341,7 +341,9 @@ struct Vacuum : public WalkerPass<ExpressionStackWalker<Vacuum>> {
     if (!EffectAnalyzer(getPassOptions(), getModule()->features, curr->body)
            .throws) {
       replaceCurrent(curr->body);
-      typeUpdater.noteRecursiveRemoval(curr->catchBody);
+      for (auto* catchBody : curr->catchBodies) {
+        typeUpdater.noteRecursiveRemoval(catchBody);
+      }
     }
   }
 
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 284f81aab..ea18fdf67 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -995,6 +995,7 @@ enum ASTNodes {
 
   Try = 0x06,
   Catch = 0x07,
+  CatchAll = 0x05,
   Throw = 0x08,
   Rethrow = 0x09,
   BrOnExn = 0x0a,
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index a2aa2d505..faf275f66 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -624,17 +624,24 @@ public:
     ret->finalize();
     return ret;
   }
-  Try* makeTry(Expression* body, Expression* catchBody) {
+  Try* makeTry(Expression* body,
+               const std::vector<Name>& catchEvents,
+               const std::vector<Expression*>& catchBodies) {
     auto* ret = wasm.allocator.alloc<Try>();
     ret->body = body;
-    ret->catchBody = catchBody;
+    ret->catchEvents.set(catchEvents);
+    ret->catchBodies.set(catchBodies);
     ret->finalize();
     return ret;
   }
-  Try* makeTry(Expression* body, Expression* catchBody, Type type) {
+  Try* makeTry(Expression* body,
+               const std::vector<Name>& catchEvents,
+               const std::vector<Expression*>& catchBodies,
+               Type type) {
     auto* ret = wasm.allocator.alloc<Try>();
     ret->body = body;
-    ret->catchBody = catchBody;
+    ret->catchEvents.set(catchEvents);
+    ret->catchBodies.set(catchBodies);
     ret->finalize(type);
     return ret;
   }
@@ -648,9 +655,9 @@ public:
     ret->finalize();
     return ret;
   }
-  Rethrow* makeRethrow(Expression* exnref) {
+  Rethrow* makeRethrow(Index depth) {
     auto* ret = wasm.allocator.alloc<Rethrow>();
-    ret->exnref = exnref;
+    ret->depth = depth;
     ret->finalize();
     return ret;
   }
diff --git a/src/wasm-delegations-fields.h b/src/wasm-delegations-fields.h
index 37fb60ef2..b5d80b86a 100644
--- a/src/wasm-delegations-fields.h
+++ b/src/wasm-delegations-fields.h
@@ -57,6 +57,10 @@
 //
 // DELEGATE_FIELD_NAME(id, name) - called for a Name.
 //
+// DELEGATE_FIELD_NAME_VECTOR(id, name) - called for a variable-sized vector of
+//    names (like try's catch event names). If this is not defined, and
+//    DELEGATE_GET_FIELD is, then DELEGATE_FIELD_CHILD is called on them.
+//
 // DELEGATE_FIELD_SCOPE_NAME_DEF(id, name) - called for a scope name definition
 //    (like a block's name).
 //
@@ -124,6 +128,17 @@
 #error please define DELEGATE_FIELD_NAME(id, name)
 #endif
 
+#ifndef DELEGATE_FIELD_NAME_VECTOR
+#ifdef DELEGATE_GET_FIELD
+#define DELEGATE_FIELD_NAME_VECTOR(id, name)                                   \
+  for (Index i = 0; i < (DELEGATE_GET_FIELD(id, name)).size(); i++) {          \
+    DELEGATE_FIELD_NAME(id, name[i]);                                          \
+  }
+#else
+#error please define DELEGATE_FIELD_NAME_VECTOR(id, name)
+#endif
+#endif
+
 #ifndef DELEGATE_FIELD_SCOPE_NAME_DEF
 #error please define DELEGATE_FIELD_SCOPE_NAME_DEF(id, name)
 #endif
@@ -490,7 +505,8 @@ switch (DELEGATE_ID) {
   }
   case Expression::Id::TryId: {
     DELEGATE_START(Try);
-    DELEGATE_FIELD_CHILD(Try, catchBody);
+    DELEGATE_FIELD_CHILD_VECTOR(Try, catchBodies);
+    DELEGATE_FIELD_NAME_VECTOR(Try, catchEvents);
     DELEGATE_FIELD_CHILD(Try, body);
     DELEGATE_END(Try);
     break;
@@ -504,7 +520,7 @@ switch (DELEGATE_ID) {
   }
   case Expression::Id::RethrowId: {
     DELEGATE_START(Rethrow);
-    DELEGATE_FIELD_CHILD(Rethrow, exnref);
+    DELEGATE_FIELD_INT(Rethrow, depth);
     DELEGATE_END(Rethrow);
     break;
   }
@@ -665,6 +681,7 @@ switch (DELEGATE_ID) {
 #undef DELEGATE_FIELD_INT_ARRAY
 #undef DELEGATE_FIELD_LITERAL
 #undef DELEGATE_FIELD_NAME
+#undef DELEGATE_FIELD_NAME_VECTOR
 #undef DELEGATE_FIELD_SCOPE_NAME_DEF
 #undef DELEGATE_FIELD_SCOPE_NAME_USE
 #undef DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index 243542836..2636b20f2 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -1347,7 +1347,10 @@ public:
     WASM_UNREACHABLE("throw");
   }
   Flow visitRethrow(Rethrow* curr) {
+    // FIXME Update the implementation to match the new spec
     NOTE_ENTER("Rethrow");
+    WASM_UNREACHABLE("unimp");
+    /*
     Flow flow = visit(curr->exnref);
     if (flow.breaking()) {
       return flow;
@@ -1358,6 +1361,7 @@ public:
     }
     throwException(value);
     WASM_UNREACHABLE("rethrow");
+    */
   }
   Flow visitBrOnExn(BrOnExn* curr) {
     NOTE_ENTER("BrOnExn");
@@ -2943,6 +2947,9 @@ private:
       return {};
     }
     Flow visitTry(Try* curr) {
+      // FIXME Update the implementation to match the new spec
+      WASM_UNREACHABLE("unimp");
+      /*
       NOTE_ENTER("Try");
       try {
         return this->visit(curr->body);
@@ -2950,6 +2957,7 @@ private:
         instance.multiValues.push_back(e.exn);
         return this->visit(curr->catchBody);
       }
+      */
     }
     Flow visitPop(Pop* curr) {
       NOTE_ENTER("Pop");
diff --git a/src/wasm-stack.h b/src/wasm-stack.h
index 1bbf686d8..bd44ed72e 100644
--- a/src/wasm-stack.h
+++ b/src/wasm-stack.h
@@ -70,6 +70,7 @@ public:
     LoopEnd,    // the ending of a loop
     TryBegin,   // the beginning of a try
     Catch,      // the catch within a try
+    CatchAll,   // the catch_all within a try
     TryEnd      // the ending of a try
   } op;
 
@@ -106,7 +107,8 @@ public:
 
   void emitResultType(Type type);
   void emitIfElse(If* curr);
-  void emitCatch(Try* curr);
+  void emitCatch(Try* curr, Index i);
+  void emitCatchAll(Try* curr);
   // emit an end at the end of a block/loop/if/try
   void emitScopeEnd(Expression* curr);
   // emit an end at the end of a function
@@ -161,7 +163,12 @@ private:
   void emit(Expression* curr) { static_cast<SubType*>(this)->emit(curr); }
   void emitHeader() { static_cast<SubType*>(this)->emitHeader(); }
   void emitIfElse(If* curr) { static_cast<SubType*>(this)->emitIfElse(curr); }
-  void emitCatch(Try* curr) { static_cast<SubType*>(this)->emitCatch(curr); }
+  void emitCatch(Try* curr, Index i) {
+    static_cast<SubType*>(this)->emitCatch(curr, i);
+  }
+  void emitCatchAll(Try* curr) {
+    static_cast<SubType*>(this)->emitCatchAll(curr);
+  }
   void emitScopeEnd(Expression* curr) {
     static_cast<SubType*>(this)->emitScopeEnd(curr);
   }
@@ -328,8 +335,14 @@ void BinaryenIRWriter<SubType>::visitLoop(Loop* curr) {
 template<typename SubType> void BinaryenIRWriter<SubType>::visitTry(Try* curr) {
   emit(curr);
   visitPossibleBlockContents(curr->body);
-  emitCatch(curr);
-  visitPossibleBlockContents(curr->catchBody);
+  for (Index i = 0; i < curr->catchEvents.size(); i++) {
+    emitCatch(curr, i);
+    visitPossibleBlockContents(curr->catchBodies[i]);
+  }
+  if (curr->hasCatchAll()) {
+    emitCatchAll(curr);
+    visitPossibleBlockContents(curr->catchBodies.back());
+  }
   emitScopeEnd(curr);
   if (curr->type == Type::unreachable) {
     emitUnreachable();
@@ -360,7 +373,8 @@ public:
     writer.mapLocalsAndEmitHeader();
   }
   void emitIfElse(If* curr) { writer.emitIfElse(curr); }
-  void emitCatch(Try* curr) { writer.emitCatch(curr); }
+  void emitCatch(Try* curr, Index i) { writer.emitCatch(curr, i); }
+  void emitCatchAll(Try* curr) { writer.emitCatchAll(curr); }
   void emitScopeEnd(Expression* curr) { writer.emitScopeEnd(curr); }
   void emitFunctionEnd() {
     if (func->epilogLocation.size()) {
@@ -394,9 +408,12 @@ public:
   void emitIfElse(If* curr) {
     stackIR.push_back(makeStackInst(StackInst::IfElse, curr));
   }
-  void emitCatch(Try* curr) {
+  void emitCatch(Try* curr, Index i) {
     stackIR.push_back(makeStackInst(StackInst::Catch, curr));
   }
+  void emitCatchAll(Try* curr) {
+    stackIR.push_back(makeStackInst(StackInst::CatchAll, curr));
+  }
   void emitFunctionEnd() {}
   void emitUnreachable() {
     stackIR.push_back(makeStackInst(Builder(module).makeUnreachable()));
diff --git a/src/wasm-traversal.h b/src/wasm-traversal.h
index e3de27f62..28470c614 100644
--- a/src/wasm-traversal.h
+++ b/src/wasm-traversal.h
@@ -337,6 +337,7 @@ struct PostWalker : public Walker<SubType, VisitorType> {
 #define DELEGATE_FIELD_INT_ARRAY(id, name)
 #define DELEGATE_FIELD_LITERAL(id, name)
 #define DELEGATE_FIELD_NAME(id, name)
+#define DELEGATE_FIELD_NAME_VECTOR(id, name)
 #define DELEGATE_FIELD_SCOPE_NAME_DEF(id, name)
 #define DELEGATE_FIELD_SCOPE_NAME_USE(id, name)
 #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, name)
@@ -566,8 +567,11 @@ struct LinearExecutionWalker : public PostWalker<SubType, VisitorType> {
       case Expression::Id::TryId: {
         self->pushTask(SubType::doVisitTry, currp);
         self->pushTask(SubType::doNoteNonLinear, currp);
-        self->pushTask(SubType::scan, &curr->cast<Try>()->catchBody);
-        self->pushTask(SubType::doNoteNonLinear, currp);
+        auto& list = curr->cast<Try>()->catchBodies;
+        for (int i = int(list.size()) - 1; i >= 0; i--) {
+          self->pushTask(SubType::scan, &list[i]);
+          self->pushTask(SubType::doNoteNonLinear, currp);
+        }
         self->pushTask(SubType::scan, &curr->cast<Try>()->body);
         break;
       }
@@ -583,7 +587,6 @@ struct LinearExecutionWalker : public PostWalker<SubType, VisitorType> {
       case Expression::Id::RethrowId: {
         self->pushTask(SubType::doVisitRethrow, currp);
         self->pushTask(SubType::doNoteNonLinear, currp);
-        self->pushTask(SubType::scan, &curr->cast<Rethrow>()->exnref);
         break;
       }
       case Expression::Id::BrOnExnId: {
diff --git a/src/wasm.h b/src/wasm.h
index 29d2e9b5d..eeccd7be0 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -1253,11 +1253,15 @@ public:
 
 class Try : public SpecificExpression<Expression::TryId> {
 public:
-  Try(MixedArena& allocator) {}
+  Try(MixedArena& allocator) : catchEvents(allocator), catchBodies(allocator) {}
 
   Expression* body;
-  Expression* catchBody;
+  ArenaVector<Name> catchEvents;
+  ExpressionList catchBodies;
 
+  bool hasCatchAll() const {
+    return catchBodies.size() - catchEvents.size() == 1;
+  }
   void finalize();
   void finalize(Type type_);
 };
@@ -1276,7 +1280,7 @@ class Rethrow : public SpecificExpression<Expression::RethrowId> {
 public:
   Rethrow(MixedArena& allocator) {}
 
-  Expression* exnref;
+  Index depth;
 
   void finalize();
 };
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index beaed1b11..9b4794997 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -2128,7 +2128,7 @@ void WasmBinaryBuilder::processExpressions() {
       }
       auto peek = input[pos];
       if (peek == BinaryConsts::End || peek == BinaryConsts::Else ||
-          peek == BinaryConsts::Catch) {
+          peek == BinaryConsts::Catch || peek == BinaryConsts::CatchAll) {
         BYN_TRACE("== processExpressions finished with unreachable"
                   << std::endl);
         lastSeparator = BinaryConsts::ASTNodes(peek);
@@ -5494,7 +5494,8 @@ void WasmBinaryBuilder::visitTryOrTryInBlock(Expression*& out) {
   // blocks instead.
   curr->type = getType();
   curr->body = getBlockOrSingleton(curr->type);
-  if (lastSeparator != BinaryConsts::Catch) {
+  if (lastSeparator != BinaryConsts::Catch &&
+      lastSeparator != BinaryConsts::CatchAll) {
     throwError("No catch instruction within a try scope");
   }
 
@@ -5544,25 +5545,48 @@ void WasmBinaryBuilder::visitTryOrTryInBlock(Expression*& out) {
   //     )
   //   )
   // )
+
+  Builder builder(wasm);
   Name catchLabel = getNextLabel();
   breakStack.push_back({catchLabel, curr->type});
-  auto start = expressionStack.size();
 
-  Builder builder(wasm);
-  pushExpression(builder.makePop(Type::exnref));
+  auto readCatchBody = [&](Type eventType) {
+    auto start = expressionStack.size();
+    if (eventType != Type::none) {
+      pushExpression(builder.makePop(eventType));
+    }
+    processExpressions();
+    size_t end = expressionStack.size();
+    if (start > end) {
+      throwError("block cannot pop from outside");
+    }
+    if (end - start == 1) {
+      curr->catchBodies.push_back(popExpression());
+    } else {
+      auto* block = allocator.alloc<Block>();
+      pushBlockElements(block, curr->type, start);
+      block->finalize(curr->type);
+      curr->catchBodies.push_back(block);
+    }
+  };
 
-  processExpressions();
-  size_t end = expressionStack.size();
-  if (start > end) {
-    throwError("block cannot pop from outside");
-  }
-  if (end - start == 1) {
-    curr->catchBody = popExpression();
-  } else {
-    auto* block = allocator.alloc<Block>();
-    pushBlockElements(block, curr->type, start);
-    block->finalize(curr->type);
-    curr->catchBody = block;
+  while (lastSeparator == BinaryConsts::Catch ||
+         lastSeparator == BinaryConsts::CatchAll) {
+    if (lastSeparator == BinaryConsts::Catch) {
+      auto index = getU32LEB();
+      if (index >= wasm.events.size()) {
+        throwError("bad event index");
+      }
+      auto* event = wasm.events[index].get();
+      curr->catchEvents.push_back(event->name);
+      readCatchBody(event->sig.params);
+
+    } else { // catch_all
+      if (curr->hasCatchAll()) {
+        throwError("there should be at most one 'catch_all' clause per try");
+      }
+      readCatchBody(Type::none);
+    }
   }
   curr->finalize(curr->type);
 
@@ -5595,7 +5619,7 @@ void WasmBinaryBuilder::visitThrow(Throw* curr) {
 
 void WasmBinaryBuilder::visitRethrow(Rethrow* curr) {
   BYN_TRACE("zz node: Rethrow\n");
-  curr->exnref = popNonVoidExpression();
+  curr->depth = getU32LEB();
   curr->finalize();
 }
 
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index d76a3c49a..84576fde7 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -1947,13 +1947,20 @@ Expression* SExpressionWasmBuilder::makeRefEq(Element& s) {
 
 // try-catch-end is written in the folded wast format as
 // (try
-//   ...
+//  (do
+//    ...
+//  )
 //  (catch
 //    ...
 //  )
+//  ...
+//  (catch_all
+//    ...
+//  )
 // )
-// The parenthesis wrapping 'catch' is just a syntax and does not affect nested
-// depths of instructions within.
+// Any number of catch blocks can exist, including none. Zero or one catch_all
+// block can exist, and if it does, it should be at the end. There should be at
+// least one catch or catch_all body per try.
 Expression* SExpressionWasmBuilder::makeTry(Element& s) {
   auto ret = allocator.alloc<Try>();
   Index i = 1;
@@ -1966,15 +1973,38 @@ Expression* SExpressionWasmBuilder::makeTry(Element& s) {
   }
   auto label = nameMapper.pushLabelName(sName);
   Type type = parseOptionalResultType(s, i); // signature
+
   if (!elementStartsWith(*s[i], "do")) {
     throw ParseException(
       "try body should start with 'do'", s[i]->line, s[i]->col);
   }
-  ret->body = makeTryOrCatchBody(*s[i++], type, true);
-  if (!elementStartsWith(*s[i], "catch")) {
-    throw ParseException("catch clause does not exist", s[i]->line, s[i]->col);
+  ret->body = makeMaybeBlock(*s[i++], 1, type);
+
+  while (i < s.size() && elementStartsWith(*s[i], "catch")) {
+    Element& inner = *s[i++];
+    if (inner.size() < 3) {
+      throw ParseException("invalid catch block", inner.line, inner.col);
+    }
+    Name event = getEventName(*inner[1]);
+    if (!wasm.getEventOrNull(event)) {
+      throw ParseException("bad event name", inner[1]->line, inner[1]->col);
+    }
+    ret->catchEvents.push_back(getEventName(*inner[1]));
+    ret->catchBodies.push_back(makeMaybeBlock(inner, 2, type));
+  }
+
+  if (i < s.size() && elementStartsWith(*s[i], "catch_all")) {
+    ret->catchBodies.push_back(makeMaybeBlock(*s[i++], 1, type));
+  }
+
+  if (i != s.size()) {
+    throw ParseException(
+      "there should be at most one catch_all block at the end", s.line, s.col);
+  }
+  if (ret->catchBodies.empty()) {
+    throw ParseException("no catch bodies", s.line, s.col);
   }
-  ret->catchBody = makeTryOrCatchBody(*s[i++], type, false);
+
   ret->finalize(type);
   nameMapper.popLabelName(label);
   // create a break target if we must
@@ -1993,10 +2023,11 @@ SExpressionWasmBuilder::makeTryOrCatchBody(Element& s, Type type, bool isTry) {
   if (isTry && !elementStartsWith(s, "do")) {
     throw ParseException("invalid try do clause", s.line, s.col);
   }
-  if (!isTry && !elementStartsWith(s, "catch")) {
+  if (!isTry && !elementStartsWith(s, "catch") &&
+      !elementStartsWith(s, "catch_all")) {
     throw ParseException("invalid catch clause", s.line, s.col);
   }
-  if (s.size() == 1) { // (do) or (catch) without instructions
+  if (s.size() == 1) { // (do) / (catch) / (catch_all) without instructions
     return makeNop();
   }
   auto ret = allocator.alloc<Block>();
@@ -2027,7 +2058,7 @@ Expression* SExpressionWasmBuilder::makeThrow(Element& s) {
 
 Expression* SExpressionWasmBuilder::makeRethrow(Element& s) {
   auto ret = allocator.alloc<Rethrow>();
-  ret->exnref = parseExpression(*s[1]);
+  ret->depth = atoi(s[1]->str().c_str());
   ret->finalize();
   return ret;
 }
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index 049573fc5..c96ceabb6 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -1859,14 +1859,24 @@ void BinaryInstWriter::visitTry(Try* curr) {
   emitResultType(curr->type);
 }
 
-void BinaryInstWriter::emitCatch(Try* curr) {
+void BinaryInstWriter::emitCatch(Try* curr, Index i) {
   assert(!breakStack.empty());
   breakStack.pop_back();
   breakStack.emplace_back(IMPOSSIBLE_CONTINUE);
+  // TODO Fix handling of BinaryLocations for the new EH spec
   if (func && !sourceMap) {
     parent.writeExtraDebugLocation(curr, func, BinaryLocations::Catch);
   }
-  o << int8_t(BinaryConsts::Catch);
+  o << int8_t(BinaryConsts::Catch)
+    << U32LEB(parent.getEventIndex(curr->catchEvents[i]));
+}
+
+void BinaryInstWriter::emitCatchAll(Try* curr) {
+  assert(!breakStack.empty());
+  breakStack.pop_back();
+  breakStack.emplace_back(IMPOSSIBLE_CONTINUE);
+  // TODO Fix handling of BinaryLocations for the new EH spec
+  o << int8_t(BinaryConsts::CatchAll);
 }
 
 void BinaryInstWriter::visitThrow(Throw* curr) {
@@ -1874,7 +1884,7 @@ void BinaryInstWriter::visitThrow(Throw* curr) {
 }
 
 void BinaryInstWriter::visitRethrow(Rethrow* curr) {
-  o << int8_t(BinaryConsts::Rethrow);
+  o << int8_t(BinaryConsts::Rethrow) << U32LEB(curr->depth);
 }
 
 void BinaryInstWriter::visitBrOnExn(BrOnExn* curr) {
@@ -2200,23 +2210,29 @@ StackInst* StackIRGenerator::makeStackInst(StackInst::Op op,
 
 void StackIRToBinaryWriter::write() {
   writer.mapLocalsAndEmitHeader();
+  // Stack to track indices of catches within a try
+  SmallVector<Index, 4> catchIndexStack;
   for (auto* inst : *func->stackIR) {
     if (!inst) {
       continue; // a nullptr is just something we can skip
     }
     switch (inst->op) {
+      case StackInst::TryBegin:
+        catchIndexStack.push_back(0);
+        // fallthrough
       case StackInst::Basic:
       case StackInst::BlockBegin:
       case StackInst::IfBegin:
-      case StackInst::LoopBegin:
-      case StackInst::TryBegin: {
+      case StackInst::LoopBegin: {
         writer.visit(inst->origin);
         break;
       }
+      case StackInst::TryEnd:
+        catchIndexStack.pop_back();
+        // fallthrough
       case StackInst::BlockEnd:
       case StackInst::IfEnd:
-      case StackInst::LoopEnd:
-      case StackInst::TryEnd: {
+      case StackInst::LoopEnd: {
         writer.emitScopeEnd(inst->origin);
         break;
       }
@@ -2225,7 +2241,7 @@ void StackIRToBinaryWriter::write() {
         break;
       }
       case StackInst::Catch: {
-        writer.emitCatch(inst->origin->cast<Try>());
+        writer.emitCatch(inst->origin->cast<Try>(), catchIndexStack.back()++);
         break;
       }
       default:
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index b0fc4d9c8..064a151c3 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -2026,21 +2026,28 @@ void FunctionValidator::visitTry(Try* curr) {
       curr->type,
       curr->body,
       "try's type does not match try body's type");
-    shouldBeSubTypeOrFirstIsUnreachable(
-      curr->catchBody->type,
-      curr->type,
-      curr->catchBody,
-      "try's type does not match catch's body type");
+    for (auto catchBody : curr->catchBodies) {
+      shouldBeSubTypeOrFirstIsUnreachable(
+        catchBody->type,
+        curr->type,
+        catchBody,
+        "try's type does not match catch's body type");
+    }
   } else {
     shouldBeEqual(curr->body->type,
                   Type(Type::unreachable),
                   curr,
                   "unreachable try-catch must have unreachable try body");
-    shouldBeEqual(curr->catchBody->type,
-                  Type(Type::unreachable),
-                  curr,
-                  "unreachable try-catch must have unreachable catch body");
+    for (auto catchBody : curr->catchBodies) {
+      shouldBeEqual(catchBody->type,
+                    Type(Type::unreachable),
+                    curr,
+                    "unreachable try-catch must have unreachable catch body");
+    }
   }
+  shouldBeTrue(curr->catchBodies.size() - curr->catchEvents.size() <= 1,
+               curr,
+               "the number of catch blocks and events do not match");
 }
 
 void FunctionValidator::visitThrow(Throw* curr) {
@@ -2084,11 +2091,10 @@ void FunctionValidator::visitRethrow(Rethrow* curr) {
                 Type(Type::unreachable),
                 curr,
                 "rethrow's type must be unreachable");
-  shouldBeSubTypeOrFirstIsUnreachable(
-    curr->exnref->type,
-    Type::exnref,
-    curr->exnref,
-    "rethrow's argument must be exnref type or its subtype");
+  // TODO Allow non-zero depths and Validate the depth field. The current LLVM
+  // toolchain only generates depth 0 for C++ support.
+  shouldBeEqual(
+    curr->depth, (Index)0, curr, "rethrow only support depth 0 at the moment");
 }
 
 void FunctionValidator::visitBrOnExn(BrOnExn* curr) {
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index fb523e254..55b03c228 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -949,13 +949,19 @@ void RefEq::finalize() {
 }
 
 void Try::finalize() {
-  type = Type::getLeastUpperBound(body->type, catchBody->type);
+  type = body->type;
+  for (auto catchBody : catchBodies) {
+    type = Type::getLeastUpperBound(type, catchBody->type);
+  }
 }
 
 void Try::finalize(Type type_) {
   type = type_;
-  if (type == Type::none && body->type == Type::unreachable &&
-      catchBody->type == Type::unreachable) {
+  bool allUnreachable = body->type == Type::unreachable;
+  for (auto catchBody : catchBodies) {
+    allUnreachable &= catchBody->type == Type::unreachable;
+  }
+  if (type == Type::none && allUnreachable) {
     type = Type::unreachable;
   }
 }
diff --git a/test/binaryen.js/exception-handling.js b/test/binaryen.js/exception-handling.js
index 3f5f6de74..e6cadcf88 100644
--- a/test/binaryen.js/exception-handling.js
+++ b/test/binaryen.js/exception-handling.js
@@ -1,7 +1,9 @@
 function cleanInfo(info) {
   var ret = {};
   for (var x in info) {
-    if (x == 'id' || x == 'type' || x == 'name' || x == 'event') {
+    // Filter out address pointers and only print meaningful info
+    if (x == 'id' || x == 'type' || x == 'name' || x == 'event' ||
+        x == 'depth' || x == 'hasCatchAll') {
       ret[x] = info[x];
     }
   }
@@ -23,36 +25,31 @@ var event_ = module.addEvent("e", 0, binaryen.i32, binaryen.none);
 //     (throw $e (i32.const 0))
 //   )
 //   (catch
-//     ;; We don't support multi-value yet. Use locals instead.
-//     (local.set 0 (exnref.pop))
-//     (drop
-//       (block $l (result i32)
-//         (rethrow
-//           (br_on_exn $l $e (local.get 0))
-//         )
-//       )
-//     )
+//     (drop (pop i32))
+//     (rethrow 0)
 //   )
 // )
 var throw_ = module.throw("e", [module.i32.const(0)]);
-var br_on_exn = module.br_on_exn("l", "e", module.local.get(0, binaryen.exnref));
-var rethrow = module.rethrow(br_on_exn);
+var rethrow = module.rethrow(0);
 var try_ = module.try(
   throw_,
-  module.block(null, [
-    module.local.set(0, module.exnref.pop()),
-    module.drop(
-      module.block("l", [rethrow], binaryen.i32)
+  ["e"],
+  [
+    module.block(null,
+      [
+        module.drop(module.i32.pop()),
+        rethrow
+      ],
+      binaryen.none
     )
   ]
-  )
 );
-var func = module.addFunction("test", binaryen.none, binaryen.none, [binaryen.exnref], try_);
+
+var func = module.addFunction("test", binaryen.none, binaryen.none, [], try_);
 
 console.log(module.emitText());
 assert(module.validate());
 
 console.log("getExpressionInfo(throw) = " + stringify(throw_));
-console.log("getExpressionInfo(br_on_exn) = " + stringify(br_on_exn));
 console.log("getExpressionInfo(rethrow) = " + stringify(rethrow));
 console.log("getExpressionInfo(try) = " + stringify(try_));
diff --git a/test/binaryen.js/exception-handling.js.txt b/test/binaryen.js/exception-handling.js.txt
index 19861dd21..e7c72e6a7 100644
--- a/test/binaryen.js/exception-handling.js.txt
+++ b/test/binaryen.js/exception-handling.js.txt
@@ -3,32 +3,22 @@
  (type $i32_=>_none (func (param i32)))
  (event $e (attr 0) (param i32))
  (func $test
-  (local $0 exnref)
   (try
    (do
     (throw $e
      (i32.const 0)
     )
    )
-   (catch
-    (local.set $0
-     (pop exnref)
-    )
+   (catch $e
     (drop
-     (block $l (result i32)
-      (rethrow
-       (br_on_exn $l $e
-        (local.get $0)
-       )
-      )
-     )
+     (pop i32)
     )
+    (rethrow 0)
    )
   )
  )
 )
 
 getExpressionInfo(throw) = {"id":47,"type":1,"event":"e"}
-getExpressionInfo(br_on_exn) = {"id":49,"type":9,"name":"l","event":"e"}
-getExpressionInfo(rethrow) = {"id":48,"type":1}
-getExpressionInfo(try) = {"id":46,"type":0}
+getExpressionInfo(rethrow) = {"id":48,"type":1,"depth":0}
+getExpressionInfo(try) = {"id":46,"type":1,"hasCatchAll":0}
diff --git a/test/binaryen.js/expressions.js b/test/binaryen.js/expressions.js
index 61fc0a3ef..757d88b1b 100644
--- a/test/binaryen.js/expressions.js
+++ b/test/binaryen.js/expressions.js
@@ -1435,31 +1435,69 @@ console.log("# RefEq");
 console.log("# Try");
 (function testTry() {
   const module = new binaryen.Module();
+  module.addEvent("event1", 0, binaryen.none, binaryen.none);
+  module.addEvent("event2", 0, binaryen.none, binaryen.none);
+  module.addEvent("event3", 0, binaryen.none, binaryen.none);
 
   var body = module.i32.const(1);
-  var catchBody = module.i32.const(2);
-  const theTry = binaryen.Try(module.try(body, catchBody));
+  var catchBodies = [
+    module.i32.const(2),
+    module.i32.const(3)
+  ];
+  const theTry = binaryen.Try(module.try(body, ["event1"], catchBodies));
   assert(theTry instanceof binaryen.Try);
   assert(theTry instanceof binaryen.Expression);
   assert(theTry.body === body);
-  assert(theTry.catchBody === catchBody);
+  assertDeepEqual(theTry.catchBodies, catchBodies);
   assert(theTry.type === binaryen.i32);
+  assert(theTry.getNumCatchEvents() == 1);
+  assert(theTry.getNumCatchBodies() == 2);
+  assert(theTry.hasCatchAll() == 1);
+  console.log(theTry.toText());
 
-  theTry.body = body = module.i32.const(3);
+  theTry.body = body = module.i32.const(4);
   assert(theTry.body === body);
-  theTry.catchBody = catchBody = module.i32.const(4);
-  assert(theTry.catchBody === catchBody);
+  catchBodies = [
+    module.i32.const(5) // set
+    //remove
+  ];
+  theTry.setCatchBodies(catchBodies);
+  assertDeepEqual(theTry.catchBodies, catchBodies);
+  assertDeepEqual(theTry.getCatchBodies(), catchBodies);
+  console.log(theTry.toText());
+
+  theTry.insertCatchEventAt(1, "event2");
+  theTry.insertCatchBodyAt(0, module.i32.const(6));
+  assert(theTry.getNumCatchEvents() == 2);
+  assert(theTry.getNumCatchBodies() == 2);
+  assert(theTry.hasCatchAll() == 0);
+  console.log(theTry.toText());
+
+  assert(theTry.removeCatchEventAt(1) == "event2");
+  theTry.removeCatchBodyAt(1);
+  assert(theTry.getNumCatchEvents() == 1);
+  assert(theTry.getNumCatchBodies() == 1);
+  console.log(theTry.toText());
+
+  theTry.appendCatchEvent("event3");
+  theTry.appendCatchBody(module.drop(module.i32.const(7)));
+  assert(theTry.getCatchEventAt(0) == "event1");
+  assert(theTry.getCatchEventAt(1) == "event3");
+  theTry.setCatchEvents(["event2", "event3"]);
+  assertDeepEqual(theTry.getCatchEvents(), ["event2", "event3"]);
+  theTry.setCatchBodies([module.i32.const(8), module.i32.const(9)]);
+  assert(theTry.getCatchEventAt(0) == "event2");
+  assert(theTry.getCatchEventAt(1) == "event3");
+  theTry.setCatchEventAt(1, "event1");
+  theTry.setCatchBodyAt(1, module.i32.const(10));
+  assert(theTry.getCatchEventAt(1) == "event1");
+  console.log(theTry.toText());
+
   theTry.type = binaryen.f64;
   theTry.finalize();
   assert(theTry.type === binaryen.i32);
 
   console.log(theTry.toText());
-  assert(
-    theTry.toText()
-    ==
-    "(try (result i32)\n (do\n  (i32.const 3)\n )\n (catch\n  (i32.const 4)\n )\n)\n"
-  );
-
   module.dispose();
 })();
 
@@ -1512,15 +1550,14 @@ console.log("# Rethrow");
 (function testRethrow() {
   const module = new binaryen.Module();
 
-  var exnref = module.local.get(1, binaryen.exnref);
-  const theRethrow = binaryen.Rethrow(module.rethrow(exnref));
+  const theRethrow = binaryen.Rethrow(module.rethrow(0));
   assert(theRethrow instanceof binaryen.Rethrow);
   assert(theRethrow instanceof binaryen.Expression);
-  assert(theRethrow.exnref === exnref);
+  assert(theRethrow.depth === 0);
   assert(theRethrow.type === binaryen.unreachable);
 
-  theRethrow.exnref = exnref = module.local.get(2, binaryen.exnref);
-  assert(theRethrow.exnref === exnref);
+  theRethrow.depth = 1
+  assert(theRethrow.depth === 1);
   theRethrow.type = binaryen.f64;
   theRethrow.finalize();
   assert(theRethrow.type === binaryen.unreachable);
@@ -1529,7 +1566,7 @@ console.log("# Rethrow");
   assert(
     theRethrow.toText()
     ==
-    "(rethrow\n (local.get $2)\n)\n"
+    "(rethrow 1)\n"
   );
 
   module.dispose();
diff --git a/test/binaryen.js/expressions.js.txt b/test/binaryen.js/expressions.js.txt
index ba946b296..d6c090d18 100644
--- a/test/binaryen.js/expressions.js.txt
+++ b/test/binaryen.js/expressions.js.txt
@@ -219,11 +219,68 @@
 # Try
 (try (result i32)
  (do
+  (i32.const 1)
+ )
+ (catch $event1
+  (i32.const 2)
+ )
+ (catch_all
   (i32.const 3)
  )
- (catch
+)
+
+(try (result i32)
+ (do
   (i32.const 4)
  )
+ (catch $event1
+  (i32.const 5)
+ )
+)
+
+(try (result i32)
+ (do
+  (i32.const 4)
+ )
+ (catch $event1
+  (i32.const 6)
+ )
+ (catch $event2
+  (i32.const 5)
+ )
+)
+
+(try (result i32)
+ (do
+  (i32.const 4)
+ )
+ (catch $event1
+  (i32.const 6)
+ )
+)
+
+(try (result i32)
+ (do
+  (i32.const 4)
+ )
+ (catch $event2
+  (i32.const 8)
+ )
+ (catch $event1
+  (i32.const 10)
+ )
+)
+
+(try (result i32)
+ (do
+  (i32.const 4)
+ )
+ (catch $event2
+  (i32.const 8)
+ )
+ (catch $event1
+  (i32.const 10)
+ )
 )
 
 # Throw
@@ -233,9 +290,7 @@
 )
 
 # Rethrow
-(rethrow
- (local.get $2)
-)
+(rethrow 1)
 
 # BrOnExn
 (br_on_exn $bar $event2
diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js
index 146335130..8e7e81f26 100644
--- a/test/binaryen.js/kitchen-sink.js
+++ b/test/binaryen.js/kitchen-sink.js
@@ -547,18 +547,8 @@ function test_core() {
     // Exception handling
     module.try(
       module.throw("a-event", [module.i32.const(0)]),
-      module.block(null, [
-        module.local.set(5, module.exnref.pop()),
-        module.drop(
-          module.block("try-block", [
-            module.rethrow(
-              module.br_on_exn("try-block", "a-event",
-                module.local.get(5, binaryen.exnref)),
-            )
-          ], binaryen.i32)
-        )
-      ]
-      )
+      ["a-event"],
+      [module.drop(module.i32.pop())]
     ),
 
     // Atomics
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
index 907d490fe..ef15d8a00 100644
--- a/test/binaryen.js/kitchen-sink.js.txt
+++ b/test/binaryen.js/kitchen-sink.js.txt
@@ -1865,18 +1865,9 @@ getExpressionInfo(tuple[3])={"id":14,"type":5,"value":3.7}
          (i32.const 0)
         )
        )
-       (catch
-        (local.set $5
-         (pop exnref)
-        )
+       (catch $a-event
         (drop
-         (block $try-block (result i32)
-          (rethrow
-           (br_on_exn $try-block $a-event
-            (local.get $5)
-           )
-          )
-         )
+         (pop i32)
         )
        )
       )
@@ -3737,18 +3728,9 @@ getExpressionInfo(tuple[3])={"id":14,"type":5,"value":3.7}
          (i32.const 0)
         )
        )
-       (catch
-        (local.set $5
-         (pop exnref)
-        )
+       (catch $a-event
         (drop
-         (block $try-block (result i32)
-          (rethrow
-           (br_on_exn $try-block $a-event
-            (local.get $5)
-           )
-          )
-         )
+         (pop i32)
         )
        )
       )
diff --git a/test/binaryen.js/sideffects.js b/test/binaryen.js/sideffects.js
index bfb5404c2..cb0e8ac7f 100644
--- a/test/binaryen.js/sideffects.js
+++ b/test/binaryen.js/sideffects.js
@@ -108,7 +108,7 @@ assert(
 
 assert(
   binaryen.getSideEffects(
-    module.drop(module.exnref.pop()),
+    module.drop(module.i32.pop()),
     module.getFeatures()
   )
   ==
diff --git a/test/break-within-catch.wasm b/test/break-within-catch.wasm
index 90b08f9a9..39a0cafb2 100644
--- a/test/break-within-catch.wasm
+++ b/test/break-within-catch.wasm
diff --git a/test/break-within-catch.wasm.fromBinary b/test/break-within-catch.wasm.fromBinary
index 82ab6e717..d7e2dc57b 100644
--- a/test/break-within-catch.wasm.fromBinary
+++ b/test/break-within-catch.wasm.fromBinary
@@ -1,14 +1,16 @@
 (module
  (type $none_=>_none (func))
+ (type $i32_=>_none (func (param i32)))
+ (event $event$0 (attr 0) (param i32))
  (func $0
   (block $label$2
    (try
     (do
      (nop)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (br $label$2)
     )
diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c
index 79cbabca3..58b1e00aa 100644
--- a/test/example/c-api-kitchen-sink.c
+++ b/test/example/c-api-kitchen-sink.c
@@ -325,40 +325,18 @@ void test_core() {
   //   (do
   //     (throw $a-event (i32.const 0))
   //   )
-  //   (catch
-  //     ;; We don't support multi-value yet. Use locals instead.
-  //     (local.set 0 (exnref.pop))
-  //     (drop
-  //       (block $try-block (result i32)
-  //         (rethrow
-  //           (br_on_exn $try-block $a-event (local.get 5))
-  //         )
-  //       )
-  //     )
+  //   (catch $a-event
+  //     (drop (i32 pop))
   //   )
+  //   (catch_all)
   // )
   BinaryenExpressionRef tryBody = BinaryenThrow(
     module, "a-event", (BinaryenExpressionRef[]){makeInt32(module, 0)}, 1);
-  BinaryenExpressionRef catchBody = BinaryenBlock(
-    module,
-    NULL,
-    (BinaryenExpressionRef[]){
-      BinaryenLocalSet(module, 5, BinaryenPop(module, BinaryenTypeExnref())),
-      BinaryenDrop(
-        module,
-        BinaryenBlock(module,
-                      "try-block",
-                      (BinaryenExpressionRef[]){BinaryenRethrow(
-                        module,
-                        BinaryenBrOnExn(
-                          module,
-                          "try-block",
-                          "a-event",
-                          BinaryenLocalGet(module, 5, BinaryenTypeExnref())))},
-                      1,
-                      BinaryenTypeInt32()))},
-    2,
-    BinaryenTypeNone());
+  BinaryenExpressionRef catchBody =
+    BinaryenDrop(module, BinaryenPop(module, BinaryenTypeInt32()));
+  BinaryenExpressionRef catchAllBody = BinaryenNop(module);
+  BinaryenExpressionRef catchBodies[] = {catchBody, catchAllBody};
+  const char* catchEvents[] = {"a-event"};
 
   BinaryenType i32 = BinaryenTypeInt32();
   BinaryenType i64 = BinaryenTypeInt64();
@@ -747,7 +725,7 @@ void test_core() {
                   BinaryenRefNull(module, BinaryenTypeEqref()),
                   BinaryenRefNull(module, BinaryenTypeEqref())),
     // Exception handling
-    BinaryenTry(module, tryBody, catchBody),
+    BinaryenTry(module, tryBody, catchEvents, 1, catchBodies, 2),
     // Atomics
     BinaryenAtomicStore(
       module,
diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt
index 083fa1ce5..7fa387daa 100644
--- a/test/example/c-api-kitchen-sink.txt
+++ b/test/example/c-api-kitchen-sink.txt
@@ -1771,20 +1771,14 @@ BinaryenFeatureAll: 8191
          (i32.const 0)
         )
        )
-       (catch
-        (local.set $5
-         (pop exnref)
-        )
+       (catch $a-event
         (drop
-         (block $try-block (result i32)
-          (rethrow
-           (br_on_exn $try-block $a-event
-            (local.get $5)
-           )
-          )
-         )
+         (pop i32)
         )
        )
+       (catch_all
+        (nop)
+       )
       )
       (i32.atomic.store
        (i32.const 0)
diff --git a/test/exception-handling.wast b/test/exception-handling.wast
index 862b82d88..72eb0be4a 100644
--- a/test/exception-handling.wast
+++ b/test/exception-handling.wast
@@ -1,6 +1,7 @@
 (module
-  (event $e0 (attr 0) (param i32))
-  (event $e1 (attr 0) (param externref))
+  (event $e-i32 (attr 0) (param i32))
+  (event $e-i64 (attr 0) (param i64))
+  (event $e-i32-i64 (attr 0) (param i32 i64))
 
   (func $exnref_test (param $0 exnref) (result exnref)
     (local.get $0)
@@ -9,20 +10,27 @@
   (func $foo)
   (func $bar)
 
-  (func $eh_test (local $exn exnref)
+  (func $eh_test (local $x (i32 i64))
+    ;; Simple try-catch
     (try
       (do
-        (throw $e0 (i32.const 0))
+        (throw $e-i32 (i32.const 0))
       )
-      (catch
-        ;; Multi-value is not available yet, so block can't take a value from
-        ;; stack. So this uses locals for now.
-        (local.set $exn (pop exnref))
+      (catch $e-i32
+        (drop (pop i32))
+      )
+    )
+
+    ;; try-catch with multivalue event
+    (try
+      (do
+        (throw $e-i32-i64 (i32.const 0) (i64.const 0))
+      )
+      (catch $e-i32-i64
+        (local.set $x (pop i32 i64))
         (drop
-          (block $l0 (result i32)
-            (rethrow
-              (br_on_exn $l0 $e0 (local.get $exn))
-            )
+          (tuple.extract 0
+            (local.get $x)
           )
         )
       )
@@ -33,7 +41,8 @@
       (do
         (br $l1)
       )
-      (catch
+      (catch $e-i32
+        (drop (pop i32))
         (br $l1)
       )
     )
@@ -41,8 +50,8 @@
     ;; Empty try body
     (try
       (do)
-      (catch
-        (drop (pop exnref))
+      (catch $e-i32
+        (drop (pop i32))
       )
     )
 
@@ -52,11 +61,60 @@
         (call $foo)
         (call $bar)
       )
-      (catch
-        (drop (pop exnref))
+      (catch $e-i32
+        (drop (pop i32))
+        (call $foo)
+        (call $bar)
+      )
+    )
+
+    ;; Multiple catch clauses
+    (try
+      (do
+        (throw $e-i32 (i32.const 0))
+      )
+      (catch $e-i32
+        (drop (pop i32))
+      )
+      (catch $e-i64
+        (drop (pop i64))
+      )
+    )
+
+    ;; Single catch-all clause
+    (try
+      (do
+        (throw $e-i32 (i32.const 0))
+      )
+      (catch_all)
+    )
+
+    ;; catch and catch-all clauses together
+    (try
+      (do
+        (throw $e-i32 (i32.const 0))
+      )
+      (catch $e-i32
+        (drop (pop i32))
+      )
+      (catch $e-i64
+        (drop (pop i64))
+      )
+      (catch_all
         (call $foo)
         (call $bar)
       )
     )
+
+    ;; rethrow
+    (try
+      (do
+        (throw $e-i32 (i32.const 0))
+      )
+      (catch $e-i32
+        (drop (pop i32))
+        (rethrow 0)
+      )
+    )
   )
 )
diff --git a/test/exception-handling.wast.from-wast b/test/exception-handling.wast.from-wast
index 9fd06c0b1..64d78d54e 100644
--- a/test/exception-handling.wast.from-wast
+++ b/test/exception-handling.wast.from-wast
@@ -1,10 +1,12 @@
 (module
  (type $none_=>_none (func))
  (type $i32_=>_none (func (param i32)))
- (type $externref_=>_none (func (param externref)))
+ (type $i64_=>_none (func (param i64)))
+ (type $i32_i64_=>_none (func (param i32 i64)))
  (type $exnref_=>_exnref (func (param exnref) (result exnref)))
- (event $e0 (attr 0) (param i32))
- (event $e1 (attr 0) (param externref))
+ (event $e-i32 (attr 0) (param i32))
+ (event $e-i64 (attr 0) (param i64))
+ (event $e-i32-i64 (attr 0) (param i32 i64))
  (func $exnref_test (param $0 exnref) (result exnref)
   (local.get $0)
  )
@@ -15,24 +17,33 @@
   (nop)
  )
  (func $eh_test
-  (local $exn exnref)
+  (local $x (i32 i64))
   (try
    (do
-    (throw $e0
+    (throw $e-i32
      (i32.const 0)
     )
    )
-   (catch
-    (local.set $exn
-     (pop exnref)
+   (catch $e-i32
+    (drop
+     (pop i32)
+    )
+   )
+  )
+  (try
+   (do
+    (throw $e-i32-i64
+     (i32.const 0)
+     (i64.const 0)
+    )
+   )
+   (catch $e-i32-i64
+    (local.set $x
+     (pop i32 i64)
     )
     (drop
-     (block $l0 (result i32)
-      (rethrow
-       (br_on_exn $l0 $e0
-        (local.get $exn)
-       )
-      )
+     (tuple.extract 0
+      (local.get $x)
      )
     )
    )
@@ -42,7 +53,10 @@
     (do
      (br $l1)
     )
-    (catch
+    (catch $e-i32
+     (drop
+      (pop i32)
+     )
      (br $l1)
     )
    )
@@ -51,9 +65,9 @@
    (do
     (nop)
    )
-   (catch
+   (catch $e-i32
     (drop
-     (pop exnref)
+     (pop i32)
     )
    )
   )
@@ -62,13 +76,74 @@
     (call $foo)
     (call $bar)
    )
-   (catch
+   (catch $e-i32
+    (drop
+     (pop i32)
+    )
+    (call $foo)
+    (call $bar)
+   )
+  )
+  (try
+   (do
+    (throw $e-i32
+     (i32.const 0)
+    )
+   )
+   (catch $e-i32
+    (drop
+     (pop i32)
+    )
+   )
+   (catch $e-i64
+    (drop
+     (pop i64)
+    )
+   )
+  )
+  (try
+   (do
+    (throw $e-i32
+     (i32.const 0)
+    )
+   )
+   (catch_all
+    (nop)
+   )
+  )
+  (try
+   (do
+    (throw $e-i32
+     (i32.const 0)
+    )
+   )
+   (catch $e-i32
     (drop
-     (pop exnref)
+     (pop i32)
     )
+   )
+   (catch $e-i64
+    (drop
+     (pop i64)
+    )
+   )
+   (catch_all
     (call $foo)
     (call $bar)
    )
   )
+  (try
+   (do
+    (throw $e-i32
+     (i32.const 0)
+    )
+   )
+   (catch $e-i32
+    (drop
+     (pop i32)
+    )
+    (rethrow 0)
+   )
+  )
  )
 )
diff --git a/test/exception-handling.wast.fromBinary b/test/exception-handling.wast.fromBinary
index 4e1895593..292827970 100644
--- a/test/exception-handling.wast.fromBinary
+++ b/test/exception-handling.wast.fromBinary
@@ -1,10 +1,12 @@
 (module
  (type $none_=>_none (func))
  (type $i32_=>_none (func (param i32)))
- (type $externref_=>_none (func (param externref)))
+ (type $i64_=>_none (func (param i64)))
+ (type $i32_i64_=>_none (func (param i32 i64)))
  (type $exnref_=>_exnref (func (param exnref) (result exnref)))
  (event $event$0 (attr 0) (param i32))
- (event $event$1 (attr 0) (param externref))
+ (event $event$1 (attr 0) (param i64))
+ (event $event$2 (attr 0) (param i32 i64))
  (func $exnref_test (param $0 exnref) (result exnref)
   (local.get $0)
  )
@@ -15,38 +17,72 @@
   (nop)
  )
  (func $eh_test
-  (local $exn exnref)
+  (local $x i32)
+  (local $1 i64)
+  (local $2 (i32 i64))
+  (local $3 i32)
+  (local $4 i32)
   (try
    (do
     (throw $event$0
      (i32.const 0)
     )
    )
-   (catch
-    (local.set $exn
-     (pop exnref)
-    )
+   (catch $event$0
     (drop
-     (block $label$3 (result i32)
-      (rethrow
-       (br_on_exn $label$3 $event$0
-        (local.get $exn)
+     (pop i32)
+    )
+   )
+  )
+  (try
+   (do
+    (throw $event$2
+     (i32.const 0)
+     (i64.const 0)
+    )
+   )
+   (catch $event$2
+    (local.set $2
+     (pop i32 i64)
+    )
+    (local.set $x
+     (block (result i32)
+      (local.set $3
+       (tuple.extract 0
+        (local.get $2)
+       )
+      )
+      (local.set $1
+       (tuple.extract 1
+        (local.get $2)
        )
       )
+      (local.get $3)
+     )
+    )
+    (drop
+     (block (result i32)
+      (local.set $4
+       (local.get $x)
+      )
+      (drop
+       (local.get $1)
+      )
+      (local.get $4)
      )
     )
    )
   )
-  (block $label$4
+  (block $label$5
    (try
     (do
-     (br $label$4)
+     (br $label$5)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
-     (br $label$4)
+     (br $label$5)
     )
    )
   )
@@ -54,9 +90,9 @@
    (do
     (nop)
    )
-   (catch
+   (catch $event$0
     (drop
-     (pop exnref)
+     (pop i32)
     )
    )
   )
@@ -65,14 +101,75 @@
     (call $foo)
     (call $bar)
    )
-   (catch
+   (catch $event$0
     (drop
-     (pop exnref)
+     (pop i32)
     )
     (call $foo)
     (call $bar)
    )
   )
+  (try
+   (do
+    (throw $event$0
+     (i32.const 0)
+    )
+   )
+   (catch $event$0
+    (drop
+     (pop i32)
+    )
+   )
+   (catch $event$1
+    (drop
+     (pop i64)
+    )
+   )
+  )
+  (try
+   (do
+    (throw $event$0
+     (i32.const 0)
+    )
+   )
+   (catch_all
+    (nop)
+   )
+  )
+  (try
+   (do
+    (throw $event$0
+     (i32.const 0)
+    )
+   )
+   (catch $event$0
+    (drop
+     (pop i32)
+    )
+   )
+   (catch $event$1
+    (drop
+     (pop i64)
+    )
+   )
+   (catch_all
+    (call $foo)
+    (call $bar)
+   )
+  )
+  (try
+   (do
+    (throw $event$0
+     (i32.const 0)
+    )
+   )
+   (catch $event$0
+    (drop
+     (pop i32)
+    )
+    (rethrow 0)
+   )
+  )
  )
 )
 
diff --git a/test/exception-handling.wast.fromBinary.noDebugInfo b/test/exception-handling.wast.fromBinary.noDebugInfo
index 0b5a7d896..1f1ebdb6f 100644
--- a/test/exception-handling.wast.fromBinary.noDebugInfo
+++ b/test/exception-handling.wast.fromBinary.noDebugInfo
@@ -1,10 +1,12 @@
 (module
  (type $none_=>_none (func))
  (type $i32_=>_none (func (param i32)))
- (type $externref_=>_none (func (param externref)))
+ (type $i64_=>_none (func (param i64)))
+ (type $i32_i64_=>_none (func (param i32 i64)))
  (type $exnref_=>_exnref (func (param exnref) (result exnref)))
  (event $event$0 (attr 0) (param i32))
- (event $event$1 (attr 0) (param externref))
+ (event $event$1 (attr 0) (param i64))
+ (event $event$2 (attr 0) (param i32 i64))
  (func $0 (param $0 exnref) (result exnref)
   (local.get $0)
  )
@@ -15,38 +17,72 @@
   (nop)
  )
  (func $3
-  (local $0 exnref)
+  (local $0 i32)
+  (local $1 i64)
+  (local $2 (i32 i64))
+  (local $3 i32)
+  (local $4 i32)
   (try
    (do
     (throw $event$0
      (i32.const 0)
     )
    )
-   (catch
+   (catch $event$0
+    (drop
+     (pop i32)
+    )
+   )
+  )
+  (try
+   (do
+    (throw $event$2
+     (i32.const 0)
+     (i64.const 0)
+    )
+   )
+   (catch $event$2
+    (local.set $2
+     (pop i32 i64)
+    )
     (local.set $0
-     (pop exnref)
+     (block (result i32)
+      (local.set $3
+       (tuple.extract 0
+        (local.get $2)
+       )
+      )
+      (local.set $1
+       (tuple.extract 1
+        (local.get $2)
+       )
+      )
+      (local.get $3)
+     )
     )
     (drop
-     (block $label$3 (result i32)
-      (rethrow
-       (br_on_exn $label$3 $event$0
-        (local.get $0)
-       )
+     (block (result i32)
+      (local.set $4
+       (local.get $0)
+      )
+      (drop
+       (local.get $1)
       )
+      (local.get $4)
      )
     )
    )
   )
-  (block $label$4
+  (block $label$5
    (try
     (do
-     (br $label$4)
+     (br $label$5)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
-     (br $label$4)
+     (br $label$5)
     )
    )
   )
@@ -54,9 +90,9 @@
    (do
     (nop)
    )
-   (catch
+   (catch $event$0
     (drop
-     (pop exnref)
+     (pop i32)
     )
    )
   )
@@ -65,14 +101,75 @@
     (call $1)
     (call $2)
    )
-   (catch
+   (catch $event$0
     (drop
-     (pop exnref)
+     (pop i32)
     )
     (call $1)
     (call $2)
    )
   )
+  (try
+   (do
+    (throw $event$0
+     (i32.const 0)
+    )
+   )
+   (catch $event$0
+    (drop
+     (pop i32)
+    )
+   )
+   (catch $event$1
+    (drop
+     (pop i64)
+    )
+   )
+  )
+  (try
+   (do
+    (throw $event$0
+     (i32.const 0)
+    )
+   )
+   (catch_all
+    (nop)
+   )
+  )
+  (try
+   (do
+    (throw $event$0
+     (i32.const 0)
+    )
+   )
+   (catch $event$0
+    (drop
+     (pop i32)
+    )
+   )
+   (catch $event$1
+    (drop
+     (pop i64)
+    )
+   )
+   (catch_all
+    (call $1)
+    (call $2)
+   )
+  )
+  (try
+   (do
+    (throw $event$0
+     (i32.const 0)
+    )
+   )
+   (catch $event$0
+    (drop
+     (pop i32)
+    )
+    (rethrow 0)
+   )
+  )
  )
 )
 
diff --git a/test/passes/code-pushing_all-features.txt b/test/passes/code-pushing_all-features.txt
index 30eb7e458..1f975a2dd 100644
--- a/test/passes/code-pushing_all-features.txt
+++ b/test/passes/code-pushing_all-features.txt
@@ -40,7 +40,7 @@
    )
   )
  )
- (func $can-push-past-throw-within-try
+ (func $can-push-past-try
   (local $x i32)
   (block $out
    (try
@@ -49,9 +49,9 @@
       (i32.const 0)
      )
     )
-    (catch
+    (catch_all
      (drop
-      (pop exnref)
+      (pop i32)
      )
     )
    )
@@ -69,6 +69,36 @@
    )
   )
  )
+ (func $foo
+  (nop)
+ )
+ (func $cant-push-past-try
+  (local $x i32)
+  (block $out
+   (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)
+   )
+  )
+ )
  (func $cant-push-past-rethrow-within-catch
   (local $x i32)
   (block $out
@@ -81,10 +111,8 @@
       (i32.const 0)
      )
     )
-    (catch
-     (rethrow
-      (pop exnref)
-     )
+    (catch_all
+     (rethrow 0)
     )
    )
    (drop
diff --git a/test/passes/code-pushing_all-features.wast b/test/passes/code-pushing_all-features.wast
index b67b98d7e..0d18afcc5 100644
--- a/test/passes/code-pushing_all-features.wast
+++ b/test/passes/code-pushing_all-features.wast
@@ -25,18 +25,39 @@
     )
   )
 
-  (func $can-push-past-throw-within-try
+  (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
+      ;; to be caught by the inner catch_all
       (local.set $x (i32.const 1))
       (try
         (do
           (throw $e (i32.const 0))
         )
-        (catch
-          (drop (pop exnref))
+        (catch_all
+          (drop (pop i32))
+        )
+      )
+      (drop (i32.const 1))
+      (br_if $out (i32.const 2))
+      (drop (local.get $x))
+    )
+  )
+
+  (func $foo)
+  (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))
@@ -49,14 +70,14 @@
     (local $x i32)
     (block $out
       ;; This local.set cannot be pushed down, because there is 'rethrow' within
-      ;; the inner catch
+      ;; the inner catch_all
       (local.set $x (i32.const 1))
       (try
         (do
           (throw $e (i32.const 0))
         )
-        (catch
-          (rethrow (pop exnref))
+        (catch_all
+          (rethrow 0)
         )
       )
       (drop (i32.const 1))
diff --git a/test/passes/dce_all-features.txt b/test/passes/dce_all-features.txt
index 4088d5a34..447077b6c 100644
--- a/test/passes/dce_all-features.txt
+++ b/test/passes/dce_all-features.txt
@@ -551,10 +551,8 @@
    (do
     (unreachable)
    )
-   (catch
-    (drop
-     (pop exnref)
-    )
+   (catch_all
+    (nop)
    )
   )
   (call $foo)
@@ -564,7 +562,7 @@
    (do
     (nop)
    )
-   (catch
+   (catch_all
     (unreachable)
    )
   )
@@ -575,7 +573,7 @@
    (do
     (unreachable)
    )
-   (catch
+   (catch_all
     (unreachable)
    )
   )
@@ -591,9 +589,7 @@
  (func $rethrow
   (block $label$0
    (block $label$1
-    (rethrow
-     (ref.null exn)
-    )
+    (rethrow 0)
    )
   )
  )
@@ -624,7 +620,7 @@
    (do
     (unreachable)
    )
-   (catch
+   (catch_all
     (unreachable)
    )
   )
diff --git a/test/passes/dce_all-features.wast b/test/passes/dce_all-features.wast
index 9ebcccb60..fac6d7623 100644
--- a/test/passes/dce_all-features.wast
+++ b/test/passes/dce_all-features.wast
@@ -746,11 +746,7 @@
       (do
         (unreachable)
       )
-      (catch
-        (drop
-          (pop exnref)
-        )
-      )
+      (catch_all)
     )
     (call $foo) ;; shouldn't be dce'd
   )
@@ -758,7 +754,7 @@
   (func $catch_unreachable
     (try
       (do)
-      (catch
+      (catch_all
         (unreachable)
       )
     )
@@ -770,7 +766,7 @@
       (do
         (unreachable)
       )
-      (catch
+      (catch_all
         (unreachable)
       )
     )
@@ -799,9 +795,7 @@
         (if
           (i32.clz
             (block $label$1 (result i32)
-              (rethrow
-                (ref.null exn)
-              )
+              (rethrow 0)
             )
           )
           (nop)
@@ -835,7 +829,7 @@
       (do
         (unreachable)
       )
-      (catch
+      (catch_all
         (unreachable)
       )
     )
diff --git a/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.txt b/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.txt
index 28348883a..fb9e2907b 100644
--- a/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.txt
+++ b/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.txt
@@ -3,20 +3,15 @@
  (type $i32_=>_none (func (param i32)))
  (event $e0 (attr 0) (param i32))
  (func $eh
-  (local $exn exnref)
   try
    i32.const 0
    throw $e0
   catch
    
-   local.set $exn
-   block $l0 (result i32)
-    local.get $exn
-    br_on_exn $l0 $e0
-    rethrow
-   end
    drop
+   rethrow 0
   end
+  unreachable
  )
 )
 (module
@@ -24,26 +19,17 @@
  (type $i32_=>_none (func (param i32)))
  (event $e0 (attr 0) (param i32))
  (func $eh (; has Stack IR ;)
-  (local $exn exnref)
   (try
    (do
     (throw $e0
      (i32.const 0)
     )
    )
-   (catch
-    (local.set $exn
-     (pop exnref)
-    )
+   (catch $e0
     (drop
-     (block $l0 (result i32)
-      (rethrow
-       (br_on_exn $l0 $e0
-        (local.get $exn)
-       )
-      )
-     )
+     (pop i32)
     )
+    (rethrow 0)
    )
   )
  )
diff --git a/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.wast b/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.wast
index e2bbfff2d..7dbb4aa72 100644
--- a/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.wast
+++ b/test/passes/generate-stack-ir_optimize-stack-ir_print-stack-ir_all-features.wast
@@ -1,20 +1,14 @@
 (module
   (event $e0 (attr 0) (param i32))
 
-  (func $eh (local $exn exnref)
+  (func $eh
     (try
       (do
         (throw $e0 (i32.const 0))
       )
-      (catch
-        (local.set $exn (pop exnref))
-        (drop
-          (block $l0 (result i32)
-            (rethrow
-              (br_on_exn $l0 $e0 (local.get $exn))
-            )
-          )
-        )
+      (catch $e0
+        (drop (pop i32))
+        (rethrow 0)
       )
     )
   )
diff --git a/test/passes/instrument-locals_all-features_disable-typed-function-references.txt b/test/passes/instrument-locals_all-features_disable-typed-function-references.txt
index d027f54a0..5fc177d9d 100644
--- a/test/passes/instrument-locals_all-features_disable-typed-function-references.txt
+++ b/test/passes/instrument-locals_all-features_disable-typed-function-references.txt
@@ -11,6 +11,7 @@
  (type $i32_i32_eqref_=>_eqref (func (param i32 i32 eqref) (result eqref)))
  (type $i32_i32_i31ref_=>_i31ref (func (param i32 i32 i31ref) (result i31ref)))
  (type $none_=>_none (func))
+ (type $i32_=>_none (func (param i32)))
  (import "env" "get_i32" (func $get_i32 (param i32 i32 i32) (result i32)))
  (import "env" "get_i64" (func $get_i64 (param i32 i32 i64) (result i64)))
  (import "env" "get_f32" (func $get_f32 (param i32 i32 f32) (result f32)))
@@ -33,6 +34,7 @@
  (import "env" "set_i31ref" (func $set_i31ref (param i32 i32 i31ref) (result i31ref)))
  (import "env" "get_v128" (func $get_v128 (param i32 i32 v128) (result v128)))
  (import "env" "set_v128" (func $set_v128 (param i32 i32 v128) (result v128)))
+ (event $e (attr 0) (param i32))
  (func $test
   (local $x i32)
   (local $y i64)
@@ -242,29 +244,9 @@
    (do
     (nop)
    )
-   (catch
-    (local.set $F
-     (pop funcref)
-    )
-   )
-  )
-  (try
-   (do
-    (nop)
-   )
-   (catch
-    (local.set $X
-     (pop externref)
-    )
-   )
-  )
-  (try
-   (do
-    (nop)
-   )
-   (catch
-    (local.set $E
-     (pop exnref)
+   (catch $e
+    (local.set $x
+     (pop i32)
     )
    )
   )
diff --git a/test/passes/instrument-locals_all-features_disable-typed-function-references.wast b/test/passes/instrument-locals_all-features_disable-typed-function-references.wast
index c709630b5..53b2349fa 100644
--- a/test/passes/instrument-locals_all-features_disable-typed-function-references.wast
+++ b/test/passes/instrument-locals_all-features_disable-typed-function-references.wast
@@ -1,4 +1,6 @@
 (module
+  (event $e (attr 0) (param i32))
+
   (func $test
     (local $x i32)
     (local $y i64)
@@ -44,20 +46,8 @@
     ;; Pop instructions should not be instrumented
     (try
       (do)
-      (catch
-        (local.set $F (pop funcref))
-      )
-    )
-    (try
-      (do)
-      (catch
-        (local.set $X (pop externref))
-      )
-    )
-    (try
-      (do)
-      (catch
-        (local.set $E (pop exnref))
+      (catch $e
+        (local.set $x (pop i32))
       )
     )
 
diff --git a/test/passes/optimize-instructions_all-features.txt b/test/passes/optimize-instructions_all-features.txt
index 5a2ede97a..df60ebfaa 100644
--- a/test/passes/optimize-instructions_all-features.txt
+++ b/test/passes/optimize-instructions_all-features.txt
@@ -5687,10 +5687,7 @@
     (do
      (i32.const 123)
     )
-    (catch
-     (drop
-      (pop exnref)
-     )
+    (catch_all
      (i32.const 456)
     )
    )
diff --git a/test/passes/optimize-instructions_all-features.wast b/test/passes/optimize-instructions_all-features.wast
index d90dd7aeb..191189f70 100644
--- a/test/passes/optimize-instructions_all-features.wast
+++ b/test/passes/optimize-instructions_all-features.wast
@@ -6160,10 +6160,7 @@
             )
           )
         )
-        (catch
-          (drop
-            (pop exnref)
-          )
+        (catch_all
           (i32.eqz
             (i32.eqz
               (i32.const 456)
diff --git a/test/passes/remove-unused-module-elements_all-features.txt b/test/passes/remove-unused-module-elements_all-features.txt
index 81382e4f4..0873cfee4 100644
--- a/test/passes/remove-unused-module-elements_all-features.txt
+++ b/test/passes/remove-unused-module-elements_all-features.txt
@@ -279,34 +279,23 @@
  )
 )
 (module
- (type $i32_=>_none (func (param i32)))
  (type $none_=>_none (func))
+ (type $i32_=>_none (func (param i32)))
  (type $i64_=>_none (func (param i64)))
  (event $e-export (attr 0) (param i64))
  (event $e-throw (attr 0) (param i32))
- (event $e-bronexn (attr 0) (param i32))
  (export "e-export" (event $e-export))
  (start $start)
  (func $start
-  (local $exn exnref)
   (try
    (do
     (throw $e-throw
      (i32.const 0)
     )
    )
-   (catch
-    (local.set $exn
-     (pop exnref)
-    )
+   (catch $e-catch
     (drop
-     (block $l0 (result i32)
-      (rethrow
-       (br_on_exn $l0 $e-bronexn
-        (local.get $exn)
-       )
-      )
-     )
+     (pop i32)
     )
    )
   )
diff --git a/test/passes/remove-unused-module-elements_all-features.wast b/test/passes/remove-unused-module-elements_all-features.wast
index bf9d5c7ff..c70dc1495 100644
--- a/test/passes/remove-unused-module-elements_all-features.wast
+++ b/test/passes/remove-unused-module-elements_all-features.wast
@@ -266,24 +266,17 @@
  (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-bronexn (attr 0) (type $0))  ;; cannot be removed (used in br_on_exn)
+ (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 (local $exn exnref) (; 0 ;)
+ (func $start
   (try
    (do
     (throw $e-throw (i32.const 0))
    )
-   (catch
-    (local.set $exn (pop exnref))
-    (drop
-     (block $l0 (result i32)
-      (rethrow
-       (br_on_exn $l0 $e-bronexn (local.get $exn))
-      )
-     )
-    )
+   (catch $e-catch
+    (drop (pop i32))
    )
   )
  )
diff --git a/test/passes/remove-unused-names_code-folding_all-features.txt b/test/passes/remove-unused-names_code-folding_all-features.txt
index 9736c3c0a..2f78a83e7 100644
--- a/test/passes/remove-unused-names_code-folding_all-features.txt
+++ b/test/passes/remove-unused-names_code-folding_all-features.txt
@@ -1,9 +1,10 @@
 (module
  (type $none_=>_none (func))
  (type $none_=>_i32 (func (result i32)))
+ (type $i32_=>_none (func (param i32)))
  (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
- (type $none_=>_exnref (func (result exnref)))
+ (event $e-i32 (attr 0) (param i32))
  (event $e (attr 0) (param))
  (func $ifs
   (if
@@ -1710,8 +1711,7 @@
    (i32.const 2)
   )
  )
- (func $exnref_pop-test
-  (local $exn exnref)
+ (func $pop-test
   (block $folding-inner0
    (try
     (do
@@ -1719,17 +1719,17 @@
       (do
        (nop)
       )
-      (catch
-       (local.set $exn
-        (pop exnref)
+      (catch $e-i32
+       (drop
+        (pop i32)
        )
        (br $folding-inner0)
       )
      )
     )
-    (catch
-     (local.set $exn
-      (pop exnref)
+    (catch $e-i32
+     (drop
+      (pop i32)
      )
      (br $folding-inner0)
     )
@@ -1791,7 +1791,7 @@
  (func $foo
   (nop)
  )
- (func $try-call-optimize-terminating-tails (result exnref)
+ (func $try-call-optimize-terminating-tails (result i32)
   (try
    (do
     (call $foo)
@@ -1799,26 +1799,22 @@
     (call $foo)
     (call $foo)
     (return
-     (ref.null exn)
+     (i32.const 0)
     )
    )
-   (catch
-    (drop
-     (pop exnref)
-    )
+   (catch_all
     (call $foo)
     (call $foo)
     (call $foo)
     (call $foo)
     (return
-     (ref.null exn)
+     (i32.const 0)
     )
    )
   )
-  (ref.null exn)
+  (i32.const 0)
  )
  (func $try-call-optimize-expression-tails
-  (local $exn exnref)
   (block $x
    (try
     (do
@@ -1827,10 +1823,7 @@
      (call $foo)
      (br $x)
     )
-    (catch
-     (local.set $exn
-      (pop exnref)
-     )
+    (catch_all
      (call $foo)
      (call $foo)
      (call $foo)
diff --git a/test/passes/remove-unused-names_code-folding_all-features.wast b/test/passes/remove-unused-names_code-folding_all-features.wast
index 823ed45eb..387b8600b 100644
--- a/test/passes/remove-unused-names_code-folding_all-features.wast
+++ b/test/passes/remove-unused-names_code-folding_all-features.wast
@@ -1192,15 +1192,15 @@
     )
   )
 
-  (func $exnref_pop-test (local $exn exnref)
+  (event $e-i32 (attr 0) (param i32))
+  (func $pop-test
     (try
       (do
         (try
           (do)
-          (catch
-            ;; Expressions containing (pop exnref) should NOT be taken out and
-            ;; folded.
-            (local.set $exn (pop exnref))
+          (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))
@@ -1208,8 +1208,8 @@
           )
         )
       )
-      (catch
-        (local.set $exn (pop exnref))
+      (catch $e-i32
+        (drop (pop i32))
         (drop (i32.const 111))
         (drop (i32.const 222))
         (drop (i32.const 333))
@@ -1246,7 +1246,7 @@
   )
 
   (func $foo)
-  (func $try-call-optimize-terminating-tails (result exnref)
+  (func $try-call-optimize-terminating-tails (result i32)
     (try
       (do
         ;; Expressions that can throw should NOT be taken out of 'try' scope.
@@ -1254,21 +1254,20 @@
         (call $foo)
         (call $foo)
         (call $foo)
-        (return (ref.null exn))
+        (return (i32.const 0))
       )
-      (catch
-        (drop (pop exnref))
+      (catch_all
         (call $foo)
         (call $foo)
         (call $foo)
         (call $foo)
-        (return (ref.null exn))
+        (return (i32.const 0))
       )
     )
-    (ref.null exn)
+    (i32.const 0)
   )
 
-  (func $try-call-optimize-expression-tails (local $exn exnref)
+  (func $try-call-optimize-expression-tails
     (block $x
       (try
         (do
@@ -1278,8 +1277,7 @@
           (call $foo)
           (br $x)
         )
-        (catch
-          (local.set $exn (pop exnref))
+        (catch_all
           (call $foo)
           (call $foo)
           (call $foo)
diff --git a/test/passes/remove-unused-names_merge-blocks_all-features.txt b/test/passes/remove-unused-names_merge-blocks_all-features.txt
index 90a56d32d..46d45d3fe 100644
--- a/test/passes/remove-unused-names_merge-blocks_all-features.txt
+++ b/test/passes/remove-unused-names_merge-blocks_all-features.txt
@@ -1711,13 +1711,6 @@
    (i32.const 3)
   )
  )
- (func $rethrow
-  (local $0 exnref)
-  (call $foo)
-  (rethrow
-   (local.get $0)
-  )
- )
  (func $br_on_exn (result i32)
   (local $0 exnref)
   (block $label$0 (result i32)
diff --git a/test/passes/remove-unused-names_merge-blocks_all-features.wast b/test/passes/remove-unused-names_merge-blocks_all-features.wast
index 9a6840650..6869db6ad 100644
--- a/test/passes/remove-unused-names_merge-blocks_all-features.wast
+++ b/test/passes/remove-unused-names_merge-blocks_all-features.wast
@@ -1571,16 +1571,6 @@
     )
   )
 
-  ;; 'call $foo' within 'block' of `rethrow' can be hoisted
-  (func $rethrow (local $0 exnref)
-    (rethrow
-      (block (result exnref)
-        (call $foo)
-        (local.get $0)
-      )
-    )
-  )
-
   ;; 'call $foo' within 'block' of `br_on_exn' can be hoisted
   (func $br_on_exn (result i32) (local $0 exnref)
     (block $label$0 (result i32)
diff --git a/test/passes/remove-unused-names_optimize-instructions_all-features.txt b/test/passes/remove-unused-names_optimize-instructions_all-features.txt
index 8b7fc343b..cf1e44132 100644
--- a/test/passes/remove-unused-names_optimize-instructions_all-features.txt
+++ b/test/passes/remove-unused-names_optimize-instructions_all-features.txt
@@ -10,15 +10,13 @@
   (local $x1 i32)
   (local $x2 i32)
   (local $x3 i32)
+  (local $x4 i32)
   (local.set $x0
    (try (result i32)
     (do
      (i32.const 1)
     )
-    (catch
-     (drop
-      (pop exnref)
-     )
+    (catch_all
      (i32.const 3)
     )
    )
@@ -32,10 +30,7 @@
      (call $dummy)
      (i32.const 1)
     )
-    (catch
-     (drop
-      (pop exnref)
-     )
+    (catch_all
      (i32.const 3)
     )
    )
@@ -55,36 +50,59 @@
         (i32.const 0)
        )
       )
-      (catch
+      (catch $e
        (drop
-        (pop exnref)
+        (pop i32)
        )
       )
      )
      (i32.const 1)
     )
-    (catch
+    (catch $e
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (i32.const 3)
     )
    )
   )
   (drop
-   (local.get $x2)
+   (i32.and
+    (local.get $x2)
+    (i32.const 7)
+   )
   )
   (local.set $x3
    (try (result i32)
     (do
      (try
       (do
+       (throw $e
+        (i32.const 0)
+       )
+      )
+      (catch_all
        (nop)
       )
-      (catch
-       (drop
-        (pop exnref)
-       )
+     )
+     (i32.const 1)
+    )
+    (catch_all
+     (i32.const 3)
+    )
+   )
+  )
+  (drop
+   (local.get $x3)
+  )
+  (local.set $x4
+   (try (result i32)
+    (do
+     (try
+      (do
+       (nop)
+      )
+      (catch_all
        (throw $e
         (i32.const 0)
        )
@@ -92,17 +110,14 @@
      )
      (i32.const 1)
     )
-    (catch
-     (drop
-      (pop exnref)
-     )
+    (catch_all
      (i32.const 3)
     )
    )
   )
   (drop
    (i32.and
-    (local.get $x3)
+    (local.get $x4)
     (i32.const 7)
    )
   )
diff --git a/test/passes/remove-unused-names_optimize-instructions_all-features.wast b/test/passes/remove-unused-names_optimize-instructions_all-features.wast
index 7c75c2bcf..e08c42169 100644
--- a/test/passes/remove-unused-names_optimize-instructions_all-features.wast
+++ b/test/passes/remove-unused-names_optimize-instructions_all-features.wast
@@ -7,6 +7,7 @@
     (local $x1 i32)
     (local $x2 i32)
     (local $x3 i32)
+    (local $x4 i32)
 
     ;; try - try body does not throw, can
     (local.set $x0
@@ -14,8 +15,7 @@
         (do
           (i32.const 1)
         )
-        (catch
-          (drop (pop exnref))
+        (catch_all
           (i32.const 3)
         )
       )
@@ -29,15 +29,15 @@
           (call $dummy)
           (i32.const 1)
         )
-        (catch
-          (drop (pop exnref))
+        (catch_all
           (i32.const 3)
         )
       )
     )
     (drop (i32.and (local.get $x1) (i32.const 7)))
 
-    ;; nested try - inner try may throw but will be caught by inner catch, can
+    ;; nested try - inner try may throw and may not be caught by inner catch,
+    ;; can't
     (local.set $x2
       (try (result i32)
         (do
@@ -45,39 +45,57 @@
             (do
               (throw $e (i32.const 0))
             )
-            (catch
-              (drop (pop exnref))
+            (catch $e
+              (drop (pop i32))
             )
           )
           (i32.const 1)
         )
-        (catch
-          (drop (pop exnref))
+        (catch $e
+          (drop (pop i32))
           (i32.const 3)
         )
       )
     )
     (drop (i32.and (local.get $x2) (i32.const 7)))
 
-    ;; nested try - inner catch may throw, can't
+    ;; nested try - inner try may throw but will be caught by inner catch_all,
+    ;; can
     (local.set $x3
       (try (result i32)
         (do
           (try
-            (do)
-            (catch
-              (drop (pop exnref))
+            (do
               (throw $e (i32.const 0))
             )
+            (catch_all)
           )
           (i32.const 1)
         )
-        (catch
-          (drop (pop exnref))
+        (catch_all
           (i32.const 3)
         )
       )
     )
     (drop (i32.and (local.get $x3) (i32.const 7)))
+
+    ;; nested try - inner catch_all may throw, can't
+    (local.set $x4
+      (try (result i32)
+        (do
+          (try
+            (do)
+            (catch_all
+              (throw $e (i32.const 0))
+            )
+          )
+          (i32.const 1)
+        )
+        (catch_all
+          (i32.const 3)
+        )
+      )
+    )
+    (drop (i32.and (local.get $x4) (i32.const 7)))
   )
 )
diff --git a/test/passes/rse_all-features.txt b/test/passes/rse_all-features.txt
index 95773bb23..8ad883d9f 100644
--- a/test/passes/rse_all-features.txt
+++ b/test/passes/rse_all-features.txt
@@ -3,7 +3,6 @@
  (type $i32_=>_none (func (param i32)))
  (type $i32_i32_=>_none (func (param i32 i32)))
  (type $i32_f64_=>_none (func (param i32 f64)))
- (event $e (attr 0) (param i32))
  (func $basic (param $x i32) (param $y f64)
   (local $a f32)
   (local $b i64)
@@ -475,136 +474,4 @@
    )
   )
  )
- (func $try1
-  (local $x i32)
-  (try
-   (do
-    (nop)
-   )
-   (catch
-    (drop
-     (pop exnref)
-    )
-    (local.set $x
-     (i32.const 1)
-    )
-   )
-  )
-  (local.set $x
-   (i32.const 1)
-  )
- )
- (func $try2
-  (local $x i32)
-  (try
-   (do
-    (throw $e
-     (i32.const 0)
-    )
-    (local.set $x
-     (i32.const 1)
-    )
-   )
-   (catch
-    (drop
-     (pop exnref)
-    )
-   )
-  )
-  (local.set $x
-   (i32.const 1)
-  )
- )
- (func $try3
-  (local $x i32)
-  (try
-   (do
-    (throw $e
-     (i32.const 0)
-    )
-   )
-   (catch
-    (drop
-     (pop exnref)
-    )
-    (local.set $x
-     (i32.const 1)
-    )
-   )
-  )
-  (drop
-   (i32.const 1)
-  )
- )
- (func $foo
-  (nop)
- )
- (func $try4
-  (local $x i32)
-  (try
-   (do
-    (call $foo)
-    (local.set $x
-     (i32.const 1)
-    )
-   )
-   (catch
-    (drop
-     (pop exnref)
-    )
-   )
-  )
-  (local.set $x
-   (i32.const 1)
-  )
- )
- (func $try5
-  (local $x i32)
-  (try
-   (do
-    (local.set $x
-     (i32.const 1)
-    )
-    (call $foo)
-   )
-   (catch
-    (drop
-     (pop exnref)
-    )
-   )
-  )
-  (drop
-   (i32.const 1)
-  )
- )
- (func $nested-try
-  (local $x i32)
-  (try
-   (do
-    (try
-     (do
-      (throw $e
-       (i32.const 0)
-      )
-     )
-     (catch
-      (rethrow
-       (pop exnref)
-      )
-     )
-    )
-   )
-   (catch
-    (drop
-     (pop exnref)
-    )
-    (local.set $x
-     (i32.const 1)
-    )
-   )
-  )
-  (drop
-   (i32.const 1)
-  )
- )
 )
diff --git a/test/passes/rse_all-features.wast b/test/passes/rse_all-features.wast
index d77dae379..94470ef53 100644
--- a/test/passes/rse_all-features.wast
+++ b/test/passes/rse_all-features.wast
@@ -287,89 +287,90 @@
    )
   )
 
-  (event $e (attr 0) (param i32))
-  (func $try1
-    (local $x i32)
-    (try
-      (do)
-      (catch
-        (drop (pop exnref))
-        (local.set $x (i32.const 1))
-      )
-    )
-    (local.set $x (i32.const 1)) ;; should NOT be dropped
-  )
-  (func $try2
-    (local $x i32)
-    (try
-      (do
-        (throw $e (i32.const 0))
-        (local.set $x (i32.const 1))
-      )
-      (catch
-        (drop (pop exnref))
-      )
-    )
-    (local.set $x (i32.const 1)) ;; should NOT be dropped
-  )
-  (func $try3
-    (local $x i32)
-    (try
-      (do
-        (throw $e (i32.const 0))
-      )
-      (catch
-        (drop (pop exnref))
-        (local.set $x (i32.const 1))
-      )
-    )
-    (local.set $x (i32.const 1)) ;; should be dropped
-  )
-  (func $foo)
-  (func $try4
-    (local $x i32)
-    (try
-      (do
-        (call $foo)
-        (local.set $x (i32.const 1))
-      )
-      (catch
-        (drop (pop exnref))
-      )
-    )
-    (local.set $x (i32.const 1)) ;; should NOT be dropped
-  )
-  (func $try5
-    (local $x i32)
-    (try
-      (do
-        (local.set $x (i32.const 1))
-        (call $foo)
-      )
-      (catch
-        (drop (pop exnref))
-      )
-    )
-    (local.set $x (i32.const 1)) ;; should be dropped
-  )
-  (func $nested-try
-    (local $x i32)
-    (try
-      (do
-        (try
-          (do
-            (throw $e (i32.const 0))
-          )
-          (catch
-            (rethrow (pop exnref))
-          )
-        )
-      )
-      (catch
-        (drop (pop exnref))
-        (local.set $x (i32.const 1))
-      )
-    )
-    (local.set $x (i32.const 1)) ;; should be dropped
-  )
+;; FIXME Reenable these tests after fixing CFG traversal for EH
+;;  (event $e (attr 0) (param i32))
+;;  (func $try1
+;;    (local $x i32)
+;;    (try
+;;      (do)
+;;      (catch
+;;        (drop (pop exnref))
+;;        (local.set $x (i32.const 1))
+;;      )
+;;    )
+;;    (local.set $x (i32.const 1)) ;; should NOT be dropped
+;;  )
+;;  (func $try2
+;;    (local $x i32)
+;;    (try
+;;      (do
+;;        (throw $e (i32.const 0))
+;;        (local.set $x (i32.const 1))
+;;      )
+;;      (catch
+;;        (drop (pop exnref))
+;;      )
+;;    )
+;;    (local.set $x (i32.const 1)) ;; should NOT be dropped
+;;  )
+;;  (func $try3
+;;    (local $x i32)
+;;    (try
+;;      (do
+;;        (throw $e (i32.const 0))
+;;      )
+;;      (catch
+;;        (drop (pop exnref))
+;;        (local.set $x (i32.const 1))
+;;      )
+;;    )
+;;    (local.set $x (i32.const 1)) ;; should be dropped
+;;  )
+;;  (func $foo)
+;;  (func $try4
+;;    (local $x i32)
+;;    (try
+;;      (do
+;;        (call $foo)
+;;        (local.set $x (i32.const 1))
+;;      )
+;;      (catch
+;;        (drop (pop exnref))
+;;      )
+;;    )
+;;    (local.set $x (i32.const 1)) ;; should NOT be dropped
+;;  )
+;;  (func $try5
+;;    (local $x i32)
+;;    (try
+;;      (do
+;;        (local.set $x (i32.const 1))
+;;        (call $foo)
+;;      )
+;;      (catch
+;;        (drop (pop exnref))
+;;      )
+;;    )
+;;    (local.set $x (i32.const 1)) ;; should be dropped
+;;  )
+;;  (func $nested-try
+;;    (local $x i32)
+;;    (try
+;;      (do
+;;        (try
+;;          (do
+;;            (throw $e (i32.const 0))
+;;          )
+;;          (catch
+;;            (rethrow (pop exnref))
+;;          )
+;;        )
+;;      )
+;;      (catch
+;;        (drop (pop exnref))
+;;        (local.set $x (i32.const 1))
+;;      )
+;;    )
+;;    (local.set $x (i32.const 1)) ;; should be dropped
+;;  )
 )
diff --git a/test/passes/simplify-locals_all-features.txt b/test/passes/simplify-locals_all-features.txt
index 8587e115c..2604ad88d 100644
--- a/test/passes/simplify-locals_all-features.txt
+++ b/test/passes/simplify-locals_all-features.txt
@@ -1896,12 +1896,14 @@
 )
 (module
  (type $none_=>_none (func))
+ (type $i32_=>_none (func (param i32)))
  (type $exnref_=>_none (func (param exnref)))
- (type $i32_exnref_=>_none (func (param i32 exnref)))
+ (type $i32_i32_=>_none (func (param i32 i32)))
  (type $none_=>_i32 (func (result i32)))
  (type $none_=>_exnref (func (result exnref)))
  (event $event$0 (attr 0) (param))
  (event $event$1 (attr 0) (param exnref))
+ (event $e-i32 (attr 0) (param i32))
  (func $unoptimizable-br_on_exn-block (result exnref)
   (local $0 exnref)
   (block $label$0
@@ -1923,36 +1925,18 @@
    )
   )
  )
- (func $rethrow-trap
-  (local $0 i32)
-  (drop
-   (block $label$1 (result i32)
-    (try
-     (do
-      (rethrow
-       (ref.null exn)
-      )
-     )
-     (catch
-      (nop)
-     )
-    )
-    (i32.const 0)
-   )
-  )
- )
- (func $foo (param $0 i32) (param $1 exnref)
+ (func $foo (param $0 i32) (param $1 i32)
   (nop)
  )
  (func $pop-cannot-be-sinked
-  (local $0 exnref)
+  (local $0 i32)
   (try
    (do
     (nop)
    )
-   (catch
+   (catch $e-i32
     (local.set $0
-     (pop exnref)
+     (pop i32)
     )
     (call $foo
      (i32.const 3)
@@ -1962,21 +1946,21 @@
   )
  )
  (func $pop-within-catch-can-be-sinked
-  (local $0 exnref)
+  (local $0 i32)
   (try
    (do
     (nop)
    )
-   (catch
+   (catch_all
     (nop)
     (call $foo
      (i32.const 3)
-     (try (result exnref)
+     (try (result i32)
       (do
-       (ref.null exn)
+       (i32.const 0)
       )
-      (catch
-       (pop exnref)
+      (catch $e-i32
+       (pop i32)
       )
      )
     )
@@ -1997,9 +1981,9 @@
      (local.get $0)
     )
    )
-   (catch
+   (catch $e-i32
     (drop
-     (pop exnref)
+     (pop i32)
     )
    )
   )
@@ -2013,9 +1997,9 @@
      (i32.const 3)
     )
    )
-   (catch
+   (catch $e-i32
     (drop
-     (pop exnref)
+     (pop i32)
     )
    )
   )
diff --git a/test/passes/simplify-locals_all-features.wast b/test/passes/simplify-locals_all-features.wast
index 61150edc1..13ff13679 100644
--- a/test/passes/simplify-locals_all-features.wast
+++ b/test/passes/simplify-locals_all-features.wast
@@ -1698,29 +1698,15 @@
     )
   )
 
-  (func $rethrow-trap (local $0 i32)
-    ;; This dead local.set cannot be replaced with a nop because rethrow can
-    ;; trap.
-    (local.set $0
-      (block $label$1 (result i32)
-        (try
-          (do (rethrow (ref.null exn)))
-          (catch)
-        )
-        (i32.const 0)
-      )
-    )
-  )
-
-  (func $foo (param i32 exnref))
-  (func $pop-cannot-be-sinked (local $0 exnref)
+  (event $e-i32 (attr 0) (param i32))
+  (func $foo (param i32 i32))
+  (func $pop-cannot-be-sinked (local $0 i32)
     (try
       (do)
-      (catch
-        ;; This (local.set $0) of (pop exnref) cannot be sinked to
-        ;; (local.get $0) below, because pop exnref should follow right after
-        ;; 'catch'.
-        (local.set $0 (pop exnref))
+      (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)
@@ -1729,17 +1715,17 @@
     )
   )
 
-  (func $pop-within-catch-can-be-sinked (local $0 exnref)
+  (func $pop-within-catch-can-be-sinked (local $0 i32)
     (try
       (do)
-      (catch
+      (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 exnref)
-            (do (ref.null exn))
-            (catch (pop exnref))
+          (try (result i32)
+            (do (i32.const 0))
+            (catch $e-i32 (pop i32))
           )
         )
         (call $foo
@@ -1761,8 +1747,8 @@
       (do
         (drop (local.get $0))
       )
-      (catch
-        (drop (pop exnref))
+      (catch $e-i32
+        (drop (pop i32))
       )
     )
   )
@@ -1776,8 +1762,8 @@
       (do
         (drop (local.get $0))
       )
-      (catch
-        (drop (pop exnref))
+      (catch $e-i32
+        (drop (pop i32))
       )
     )
   )
diff --git a/test/passes/vacuum_all-features.txt b/test/passes/vacuum_all-features.txt
index 0b9d70ca4..82fb7e506 100644
--- a/test/passes/vacuum_all-features.txt
+++ b/test/passes/vacuum_all-features.txt
@@ -438,10 +438,11 @@
  (type $none_=>_none (func))
  (type $i32_=>_none (func (param i32)))
  (event $e (attr 0) (param i32))
+ (event $e2 (attr 0) (param i32))
  (func $try-test
   (nop)
  )
- (func $inner-try-test
+ (func $inner-try-catch_all-test
   (local $0 i32)
   (try
    (do
@@ -449,16 +450,40 @@
      (i32.const 0)
     )
    )
-   (catch
-    (drop
-     (pop exnref)
-    )
+   (catch_all
     (local.set $0
      (i32.const 1)
     )
    )
   )
  )
+ (func $inner-try-catch-test
+  (local $0 i32)
+  (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)
+    )
+   )
+  )
+ )
  (func $br-in-catch
   (unreachable)
  )
diff --git a/test/passes/vacuum_all-features.wast b/test/passes/vacuum_all-features.wast
index 9eb13b55f..94f952f5d 100644
--- a/test/passes/vacuum_all-features.wast
+++ b/test/passes/vacuum_all-features.wast
@@ -798,35 +798,56 @@
 
 (module
   (event $e (attr 0) (param i32))
+  (event $e2 (attr 0) (param i32))
   ;; When try body does not throw, try-body can be replaced with the try body
   (func $try-test
     (try
       (do
         (drop (i32.const 0))
       )
-      (catch
-        (drop (pop exnref))
+      (catch $e
+        (drop (pop i32))
       )
     )
   )
 
-  ;; The exception thrown in the inner try is caught by the inner catch, so the
-  ;; outer try body does not throw and the outer try-catch can be removed
-  (func $inner-try-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
+  (func $inner-try-catch_all-test (local $0 i32)
     (try
       (do
         (try
           (do
             (throw $e (i32.const 0))
           )
-          (catch
-            (drop (pop exnref))
+          (catch_all
             (local.set $0 (i32.const 1))
           )
         )
       )
-      (catch
-        (drop (pop exnref))
+      (catch $e
+        (drop (pop i32))
+      )
+    )
+  )
+
+  ;; The exception thrown in the inner try will not be caught by the inner
+  ;; catch, so the outer try-catch cannot be removed
+  (func $inner-try-catch-test (local $0 i32)
+    (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))
       )
     )
   )
@@ -840,8 +861,8 @@
         (do
           (unreachable)
         )
-        (catch
-          (drop (pop exnref))
+        (catch $e
+          (drop (pop i32))
           (br $label$1)
         )
       )
diff --git a/test/reference-types.wast b/test/reference-types.wast
index ddc3550c5..bd19aa5c5 100644
--- a/test/reference-types.wast
+++ b/test/reference-types.wast
@@ -38,6 +38,8 @@
   (global $global_anyref4 (mut anyref) (ref.func $foo))
   (global $global_anyref5 (mut anyref) (ref.null exn))
 
+  (event $e-i32 (attr 0) (param i32))
+
   (func $test
     (local $local_externref externref)
     (local $local_funcref funcref)
@@ -462,8 +464,8 @@
         (do
           (local.get $local_externref)
         )
-        (catch
-          (drop (pop exnref))
+        (catch $e-i32
+          (drop (pop i32))
           (ref.null extern)
         )
       )
@@ -473,8 +475,8 @@
         (do
           (ref.func $foo)
         )
-        (catch
-          (drop (pop exnref))
+        (catch $e-i32
+          (drop (pop i32))
           (ref.null func)
         )
       )
@@ -484,8 +486,9 @@
         (do
           (ref.null exn)
         )
-        (catch
-          (pop exnref)
+        (catch $e-i32
+          (drop (pop i32))
+          (ref.null exn)
         )
       )
     )
@@ -496,8 +499,8 @@
         (do
           (local.get $local_externref)
         )
-        (catch
-          (drop (pop exnref))
+        (catch $e-i32
+          (drop (pop i32))
           (ref.func $foo)
         )
       )
@@ -507,8 +510,9 @@
         (do
           (local.get $local_externref)
         )
-        (catch
-          (pop exnref)
+        (catch $e-i32
+          (drop (pop i32))
+          (local.get $local_exnref)
         )
       )
     )
@@ -517,8 +521,8 @@
         (do
           (ref.func $foo)
         )
-        (catch
-          (drop (pop exnref))
+        (catch $e-i32
+          (drop (pop i32))
           (local.get $local_externref)
         )
       )
@@ -528,8 +532,9 @@
         (do
           (ref.func $foo)
         )
-        (catch
-          (pop exnref)
+        (catch $e-i32
+          (drop (pop i32))
+          (local.get $local_exnref)
         )
       )
     )
@@ -538,8 +543,8 @@
         (do
           (ref.null exn)
         )
-        (catch
-          (drop (pop exnref))
+        (catch $e-i32
+          (drop (pop i32))
           (local.get $local_externref)
         )
       )
@@ -549,8 +554,8 @@
         (do
           (ref.null exn)
         )
-        (catch
-          (drop (pop exnref))
+        (catch $e-i32
+          (drop (pop i32))
           (ref.func $foo)
         )
       )
diff --git a/test/reference-types.wast.from-wast b/test/reference-types.wast.from-wast
index 6a4bfede6..9deee6a15 100644
--- a/test/reference-types.wast.from-wast
+++ b/test/reference-types.wast.from-wast
@@ -8,6 +8,7 @@
  (type $none_=>_externref (func (result externref)))
  (type $none_=>_exnref (func (result exnref)))
  (type $none_=>_none (func))
+ (type $i32_=>_none (func (param i32)))
  (type $externref_=>_funcref (func (param externref) (result funcref)))
  (import "env" "import_global" (global $import_global externref))
  (import "env" "import_func" (func $import_func (param externref) (result funcref)))
@@ -22,6 +23,7 @@
  (global $global_anyref3 (mut anyref) (ref.null func))
  (global $global_anyref4 (mut anyref) (ref.func $foo))
  (global $global_anyref5 (mut anyref) (ref.null exn))
+ (event $e-i32 (attr 0) (param i32))
  (export "export_func" (func $import_func))
  (export "export_global" (global $import_global))
  (func $take_externref (param $0 externref)
@@ -700,9 +702,9 @@
     (do
      (local.get $local_externref)
     )
-    (catch
+    (catch $e-i32
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.null extern)
     )
@@ -713,9 +715,9 @@
     (do
      (ref.func $foo)
     )
-    (catch
+    (catch $e-i32
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.null func)
     )
@@ -726,8 +728,11 @@
     (do
      (ref.null exn)
     )
-    (catch
-     (pop exnref)
+    (catch $e-i32
+     (drop
+      (pop i32)
+     )
+     (ref.null exn)
     )
    )
   )
@@ -736,9 +741,9 @@
     (do
      (local.get $local_externref)
     )
-    (catch
+    (catch $e-i32
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.func $foo)
     )
@@ -749,8 +754,11 @@
     (do
      (local.get $local_externref)
     )
-    (catch
-     (pop exnref)
+    (catch $e-i32
+     (drop
+      (pop i32)
+     )
+     (local.get $local_exnref)
     )
    )
   )
@@ -759,9 +767,9 @@
     (do
      (ref.func $foo)
     )
-    (catch
+    (catch $e-i32
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (local.get $local_externref)
     )
@@ -772,8 +780,11 @@
     (do
      (ref.func $foo)
     )
-    (catch
-     (pop exnref)
+    (catch $e-i32
+     (drop
+      (pop i32)
+     )
+     (local.get $local_exnref)
     )
    )
   )
@@ -782,9 +793,9 @@
     (do
      (ref.null exn)
     )
-    (catch
+    (catch $e-i32
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (local.get $local_externref)
     )
@@ -795,9 +806,9 @@
     (do
      (ref.null exn)
     )
-    (catch
+    (catch $e-i32
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.func $foo)
     )
diff --git a/test/reference-types.wast.fromBinary b/test/reference-types.wast.fromBinary
index a540048f9..50d403caf 100644
--- a/test/reference-types.wast.fromBinary
+++ b/test/reference-types.wast.fromBinary
@@ -8,6 +8,7 @@
  (type $none_=>_externref (func (result externref)))
  (type $none_=>_exnref (func (result exnref)))
  (type $none_=>_none (func))
+ (type $i32_=>_none (func (param i32)))
  (type $externref_=>_funcref (func (param externref) (result funcref)))
  (import "env" "import_global" (global $import_global externref))
  (import "env" "import_func" (func $import_func (param externref) (result funcref)))
@@ -22,6 +23,7 @@
  (global $global_anyref3 (mut anyref) (ref.null func))
  (global $global_anyref4 (mut anyref) (ref.func $foo))
  (global $global_anyref5 (mut anyref) (ref.null exn))
+ (event $event$0 (attr 0) (param i32))
  (export "export_func" (func $import_func))
  (export "export_global" (global $import_global))
  (func $take_externref (param $0 externref)
@@ -700,9 +702,9 @@
     (do
      (local.get $local_funcref)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.null extern)
     )
@@ -713,9 +715,9 @@
     (do
      (ref.func $foo)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.null func)
     )
@@ -726,8 +728,11 @@
     (do
      (ref.null exn)
     )
-    (catch
-     (pop exnref)
+    (catch $event$0
+     (drop
+      (pop i32)
+     )
+     (ref.null exn)
     )
    )
   )
@@ -736,9 +741,9 @@
     (do
      (local.get $local_funcref)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.func $foo)
     )
@@ -749,8 +754,11 @@
     (do
      (local.get $local_funcref)
     )
-    (catch
-     (pop exnref)
+    (catch $event$0
+     (drop
+      (pop i32)
+     )
+     (local.get $local_exnref)
     )
    )
   )
@@ -759,9 +767,9 @@
     (do
      (ref.func $foo)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (local.get $local_funcref)
     )
@@ -772,8 +780,11 @@
     (do
      (ref.func $foo)
     )
-    (catch
-     (pop exnref)
+    (catch $event$0
+     (drop
+      (pop i32)
+     )
+     (local.get $local_exnref)
     )
    )
   )
@@ -782,9 +793,9 @@
     (do
      (ref.null exn)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (local.get $local_funcref)
     )
@@ -795,9 +806,9 @@
     (do
      (ref.null exn)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.func $foo)
     )
diff --git a/test/reference-types.wast.fromBinary.noDebugInfo b/test/reference-types.wast.fromBinary.noDebugInfo
index 9baf18af5..d60129e01 100644
--- a/test/reference-types.wast.fromBinary.noDebugInfo
+++ b/test/reference-types.wast.fromBinary.noDebugInfo
@@ -8,6 +8,7 @@
  (type $none_=>_externref (func (result externref)))
  (type $none_=>_exnref (func (result exnref)))
  (type $none_=>_none (func))
+ (type $i32_=>_none (func (param i32)))
  (type $externref_=>_funcref (func (param externref) (result funcref)))
  (import "env" "import_global" (global $gimport$0 externref))
  (import "env" "import_func" (func $fimport$0 (param externref) (result funcref)))
@@ -22,6 +23,7 @@
  (global $global$6 (mut anyref) (ref.null func))
  (global $global$7 (mut anyref) (ref.func $4))
  (global $global$8 (mut anyref) (ref.null exn))
+ (event $event$0 (attr 0) (param i32))
  (export "export_func" (func $fimport$0))
  (export "export_global" (global $gimport$0))
  (func $0 (param $0 externref)
@@ -700,9 +702,9 @@
     (do
      (local.get $1)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.null extern)
     )
@@ -713,9 +715,9 @@
     (do
      (ref.func $4)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.null func)
     )
@@ -726,8 +728,11 @@
     (do
      (ref.null exn)
     )
-    (catch
-     (pop exnref)
+    (catch $event$0
+     (drop
+      (pop i32)
+     )
+     (ref.null exn)
     )
    )
   )
@@ -736,9 +741,9 @@
     (do
      (local.get $1)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.func $4)
     )
@@ -749,8 +754,11 @@
     (do
      (local.get $1)
     )
-    (catch
-     (pop exnref)
+    (catch $event$0
+     (drop
+      (pop i32)
+     )
+     (local.get $2)
     )
    )
   )
@@ -759,9 +767,9 @@
     (do
      (ref.func $4)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (local.get $1)
     )
@@ -772,8 +780,11 @@
     (do
      (ref.func $4)
     )
-    (catch
-     (pop exnref)
+    (catch $event$0
+     (drop
+      (pop i32)
+     )
+     (local.get $2)
     )
    )
   )
@@ -782,9 +793,9 @@
     (do
      (ref.null exn)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (local.get $1)
     )
@@ -795,9 +806,9 @@
     (do
      (ref.null exn)
     )
-    (catch
+    (catch $event$0
      (drop
-      (pop exnref)
+      (pop i32)
      )
      (ref.func $4)
     )