diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index 7e9add5a793..8f74502ad57 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -297,6 +297,8 @@ template<typename Ctx> struct TypeParserCtx {
 
 struct NullInstrParserCtx {
   using ExprT = Ok;
+  using CatchT = Ok;
+  using CatchListT = Ok;
 
   using FieldIdxT = Ok;
   using FuncIdxT = Ok;
@@ -362,6 +364,17 @@ struct NullInstrParserCtx {
   Result<> visitDelegate(Index, LabelIdxT) { return Ok{}; }
   Result<> visitEnd() { return Ok{}; }
 
+  CatchListT makeCatchList() { return Ok{}; }
+  void appendCatch(CatchListT&, CatchT) {}
+  CatchT makeCatch(TagIdxT, LabelIdxT) { return Ok{}; }
+  CatchT makeCatchRef(TagIdxT, LabelIdxT) { return Ok{}; }
+  CatchT makeCatchAll(LabelIdxT) { return Ok{}; }
+  CatchT makeCatchAllRef(LabelIdxT) { return Ok{}; }
+  template<typename BlockTypeT>
+  Result<> makeTryTable(Index, std::optional<Name>, BlockTypeT, CatchListT) {
+    return Ok{};
+  }
+
   Result<> makeUnreachable(Index) { return Ok{}; }
   Result<> makeNop(Index) { return Ok{}; }
   Result<> makeBinary(Index, BinaryOp) { return Ok{}; }
@@ -1023,6 +1036,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
   using ExprT = Expression*;
   using ElemListT = std::vector<Expression*>;
 
+  struct CatchInfo;
+  using CatchT = CatchInfo;
+  using CatchListT = std::vector<CatchInfo>;
+
   using FieldIdxT = Index;
   using FuncIdxT = Name;
   using LocalIdxT = Index;
@@ -1106,6 +1123,21 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
 
   TableTypeT makeTableType(LimitsT, Type) { return Ok{}; }
 
+  struct CatchInfo {
+    Name tag;
+    Index label;
+    bool isRef;
+  };
+
+  std::vector<CatchInfo> makeCatchList() { return {}; }
+  void appendCatch(std::vector<CatchInfo>& list, CatchInfo info) {
+    list.push_back(info);
+  }
+  CatchInfo makeCatch(Name tag, Index label) { return {tag, label, false}; }
+  CatchInfo makeCatchRef(Name tag, Index label) { return {tag, label, true}; }
+  CatchInfo makeCatchAll(Index label) { return {{}, label, false}; }
+  CatchInfo makeCatchAllRef(Index label) { return {{}, label, true}; }
+
   Result<HeapTypeT> getHeapTypeFromIdx(Index idx) {
     if (idx >= types.size()) {
       return in.err("type index out of bounds");
@@ -1374,6 +1406,26 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
       irBuilder.makeTry(label ? *label : Name{}, type.getSignature().results));
   }
 
+  Result<> makeTryTable(Index pos,
+                        std::optional<Name> label,
+                        HeapType type,
+                        const std::vector<CatchInfo>& info) {
+    std::vector<Name> tags;
+    std::vector<Index> labels;
+    std::vector<bool> isRefs;
+    for (auto& info : info) {
+      tags.push_back(info.tag);
+      labels.push_back(info.label);
+      isRefs.push_back(info.isRef);
+    }
+    return withLoc(pos,
+                   irBuilder.makeTryTable(label ? *label : Name{},
+                                          type.getSignature().results,
+                                          tags,
+                                          labels,
+                                          isRefs));
+  }
+
   Result<> visitCatch(Index pos, Name tag) {
     return withLoc(pos, irBuilder.visitCatch(tag));
   }
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index 10894a7cf07..73a7d0035db 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -60,6 +60,8 @@ template<typename Ctx> MaybeResult<> block(Ctx&, bool);
 template<typename Ctx> MaybeResult<> ifelse(Ctx&, bool);
 template<typename Ctx> MaybeResult<> loop(Ctx&, bool);
 template<typename Ctx> MaybeResult<> trycatch(Ctx&, bool);
+template<typename Ctx> MaybeResult<typename Ctx::CatchT> catchinstr(Ctx&);
+template<typename Ctx> MaybeResult<> trytable(Ctx&, bool);
 template<typename Ctx> Result<> makeUnreachable(Ctx&, Index);
 template<typename Ctx> Result<> makeNop(Ctx&, Index);
 template<typename Ctx> Result<> makeBinary(Ctx&, Index, BinaryOp op);
@@ -657,7 +659,7 @@ template<typename Ctx> Result<uint32_t> tupleArity(Ctx& ctx) {
 // Instructions
 // ============
 
-// blockinstr ::= block | loop | if-else | try-catch
+// blockinstr ::= block | loop | if-else | try-catch | try_table
 template<typename Ctx> MaybeResult<> foldedBlockinstr(Ctx& ctx) {
   if (auto i = block(ctx, true)) {
     return i;
@@ -671,7 +673,9 @@ template<typename Ctx> MaybeResult<> foldedBlockinstr(Ctx& ctx) {
   if (auto i = trycatch(ctx, true)) {
     return i;
   }
-  // TODO: Other block instructions
+  if (auto i = trytable(ctx, true)) {
+    return i;
+  }
   return {};
 }
 
@@ -688,7 +692,9 @@ template<typename Ctx> MaybeResult<> unfoldedBlockinstr(Ctx& ctx) {
   if (auto i = trycatch(ctx, false)) {
     return i;
   }
-  // TODO: Other block instructions
+  if (auto i = trytable(ctx, false)) {
+    return i;
+  }
   return {};
 }
 
@@ -1159,6 +1165,81 @@ template<typename Ctx> MaybeResult<> trycatch(Ctx& ctx, bool folded) {
   return ctx.visitEnd();
 }
 
+template<typename Ctx> MaybeResult<typename Ctx::CatchT> catchinstr(Ctx& ctx) {
+  typename Ctx::CatchT result;
+  if (ctx.in.takeSExprStart("catch"sv)) {
+    auto tag = tagidx(ctx);
+    CHECK_ERR(tag);
+    auto label = labelidx(ctx);
+    CHECK_ERR(label);
+    result = ctx.makeCatch(*tag, *label);
+  } else if (ctx.in.takeSExprStart("catch_ref"sv)) {
+    auto tag = tagidx(ctx);
+    CHECK_ERR(tag);
+    auto label = labelidx(ctx);
+    CHECK_ERR(label);
+    result = ctx.makeCatchRef(*tag, *label);
+  } else if (ctx.in.takeSExprStart("catch_all"sv)) {
+    auto label = labelidx(ctx);
+    CHECK_ERR(label);
+    result = ctx.makeCatchAll(*label);
+  } else if (ctx.in.takeSExprStart("catch_all_ref"sv)) {
+    auto label = labelidx(ctx);
+    CHECK_ERR(label);
+    result = ctx.makeCatchAllRef(*label);
+  } else {
+    return {};
+  }
+
+  if (!ctx.in.takeRParen()) {
+    return ctx.in.err("expected ')' at end of catch clause");
+  }
+
+  return result;
+}
+
+// trytable ::= 'try_table' label blocktype catchinstr* instr* end id?
+//            | '(' 'try_table' label blocktype catchinstr* instr* ')'
+template<typename Ctx> MaybeResult<> trytable(Ctx& ctx, bool folded) {
+  auto pos = ctx.in.getPos();
+
+  if ((folded && !ctx.in.takeSExprStart("try_table"sv)) ||
+      (!folded && !ctx.in.takeKeyword("try_table"sv))) {
+    return {};
+  }
+
+  auto label = ctx.in.takeID();
+
+  auto type = blocktype(ctx);
+  CHECK_ERR(type);
+
+  auto catches = ctx.makeCatchList();
+  while (auto c = catchinstr(ctx)) {
+    CHECK_ERR(c);
+    ctx.appendCatch(catches, *c);
+  }
+
+  CHECK_ERR(ctx.makeTryTable(pos, label, *type, catches));
+
+  CHECK_ERR(instrs(ctx));
+
+  if (folded) {
+    if (!ctx.in.takeRParen()) {
+      return ctx.in.err("expected ')' at end of try_table");
+    }
+  } else {
+    if (!ctx.in.takeKeyword("end"sv)) {
+      return ctx.in.err("expected 'end' at end of try_table");
+    }
+
+    auto id = ctx.in.takeID();
+    if (id && id != label) {
+      return ctx.in.err("end label does not match try_table label");
+    }
+  }
+  return ctx.visitEnd();
+}
+
 template<typename Ctx> Result<> makeUnreachable(Ctx& ctx, Index pos) {
   return ctx.makeUnreachable(pos);
 }
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index 4b54680141d..343ef998e61 100644
--- a/src/wasm-ir-builder.h
+++ b/src/wasm-ir-builder.h
@@ -65,6 +65,8 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   [[nodiscard]] Result<> visitElse();
   [[nodiscard]] Result<> visitLoopStart(Loop* iff);
   [[nodiscard]] Result<> visitTryStart(Try* tryy, Name label = {});
+  [[nodiscard]] Result<> visitTryTableStart(TryTable* trytable,
+                                            Name label = {});
   [[nodiscard]] Result<> visitCatch(Name tag);
   [[nodiscard]] Result<> visitCatchAll();
   [[nodiscard]] Result<> visitDelegate(Index label);
@@ -155,7 +157,11 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   [[nodiscard]] Result<> makeTableFill(Name table);
   [[nodiscard]] Result<> makeTableCopy(Name destTable, Name srcTable);
   [[nodiscard]] Result<> makeTry(Name label, Type type);
-  // [[nodiscard]] Result<> makeTryTable();
+  [[nodiscard]] Result<> makeTryTable(Name label,
+                                      Type type,
+                                      const std::vector<Name>& tags,
+                                      const std::vector<Index>& labels,
+                                      const std::vector<bool>& isRefs);
   [[nodiscard]] Result<> makeThrow(Name tag);
   [[nodiscard]] Result<> makeRethrow(Index label);
   // [[nodiscard]] Result<> makeThrowRef();
@@ -264,6 +270,10 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
       Try* tryy;
       Name originalLabel;
     };
+    struct TryTableScope {
+      TryTable* trytable;
+      Name originalLabel;
+    };
     using Scope = std::variant<NoScope,
                                FuncScope,
                                BlockScope,
@@ -272,7 +282,8 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
                                LoopScope,
                                TryScope,
                                CatchScope,
-                               CatchAllScope>;
+                               CatchAllScope,
+                               TryTableScope>;
 
     // The control flow structure we are building expressions for.
     Scope scope;
@@ -312,6 +323,9 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
     static ScopeCtx makeCatchAll(Try* tryy, Name originalLabel, Name label) {
       return ScopeCtx(CatchAllScope{tryy, originalLabel}, label);
     }
+    static ScopeCtx makeTryTable(TryTable* trytable, Name originalLabel = {}) {
+      return ScopeCtx(TryTableScope{trytable, originalLabel});
+    }
 
     bool isNone() { return std::get_if<NoScope>(&scope); }
     Function* getFunction() {
@@ -362,6 +376,12 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
       }
       return nullptr;
     }
+    TryTable* getTryTable() {
+      if (auto* tryTableScope = std::get_if<TryTableScope>(&scope)) {
+        return tryTableScope->trytable;
+      }
+      return nullptr;
+    }
     Type getResultType() {
       if (auto* func = getFunction()) {
         return func->type.getSignature().results;
@@ -387,6 +407,9 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
       if (auto* tryy = getCatchAll()) {
         return tryy->type;
       }
+      if (auto* trytable = getTryTable()) {
+        return trytable->type;
+      }
       WASM_UNREACHABLE("unexpected scope kind");
     }
     Name getOriginalLabel() {
@@ -414,6 +437,9 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
       if (auto* catchAllScope = std::get_if<CatchAllScope>(&scope)) {
         return catchAllScope->originalLabel;
       }
+      if (auto* tryTableScope = std::get_if<TryTableScope>(&scope)) {
+        return tryTableScope->originalLabel;
+      }
       WASM_UNREACHABLE("unexpected scope kind");
     }
   };
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
index dc80d6af557..14b9046efde 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/src/wasm/wasm-ir-builder.cpp
@@ -624,6 +624,11 @@ Result<> IRBuilder::visitTryStart(Try* tryy, Name label) {
   return Ok{};
 }
 
+Result<> IRBuilder::visitTryTableStart(TryTable* trytable, Name label) {
+  pushScope(ScopeCtx::makeTryTable(trytable, label));
+  return Ok{};
+}
+
 Result<Expression*> IRBuilder::finishScope(Block* block) {
   if (scopeStack.empty() || scopeStack.back().isNone()) {
     return Err{"unexpected end of scope"};
@@ -895,6 +900,10 @@ Result<> IRBuilder::visitEnd() {
     tryy->catchBodies.push_back(*expr);
     tryy->finalize(tryy->type);
     push(maybeWrapForLabel(tryy));
+  } else if (auto* trytable = scope.getTryTable()) {
+    trytable->body = *expr;
+    trytable->finalize(trytable->type, &wasm);
+    push(maybeWrapForLabel(trytable));
   } else {
     WASM_UNREACHABLE("unexpected scope kind");
   }
@@ -1347,7 +1356,23 @@ Result<> IRBuilder::makeTry(Name label, Type type) {
   return visitTryStart(tryy, label);
 }
 
-// Result<> IRBuilder::makeTryTable() {}
+Result<> IRBuilder::makeTryTable(Name label,
+                                 Type type,
+                                 const std::vector<Name>& tags,
+                                 const std::vector<Index>& labels,
+                                 const std::vector<bool>& isRefs) {
+  auto* trytable = wasm.allocator.alloc<TryTable>();
+  trytable->type = type;
+  trytable->catchTags.set(tags);
+  trytable->catchRefs.set(isRefs);
+  trytable->catchDests.reserve(labels.size());
+  for (auto label : labels) {
+    auto name = getLabelName(label);
+    CHECK_ERR(name);
+    trytable->catchDests.push_back(*name);
+  }
+  return visitTryTableStart(trytable, label);
+}
 
 Result<> IRBuilder::makeThrow(Name tag) {
   Throw curr(wasm.allocator);
diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
index 8c0c8fb8077..99bbf6fdc9d 100644
--- a/test/lit/wat-kitchen-sink.wast
+++ b/test/lit/wat-kitchen-sink.wast
@@ -46,131 +46,133 @@
 
  ;; CHECK:      (type $a0 (array i32))
 
- ;; CHECK:      (type $17 (func (result i64)))
+ ;; CHECK:      (type $17 (func (result exnref)))
 
- ;; CHECK:      (type $18 (func (result i64 f32)))
+ ;; CHECK:      (type $18 (func (result i64)))
 
- ;; CHECK:      (type $19 (func (param i32 i32 i32)))
+ ;; CHECK:      (type $19 (func (result i64 f32)))
 
- ;; CHECK:      (type $20 (func (param v128 i32) (result v128)))
+ ;; CHECK:      (type $20 (func (param i32 i32 i32)))
+
+ ;; CHECK:      (type $21 (func (param v128 i32) (result v128)))
 
  ;; CHECK:      (type $packed-i16 (array (mut i16)))
 
  ;; CHECK:      (type $any-array (array (mut anyref)))
 
- ;; CHECK:      (type $23 (func (param stringref)))
+ ;; CHECK:      (type $24 (func (param stringref)))
 
- ;; CHECK:      (type $24 (func (param stringref stringref) (result i32)))
+ ;; CHECK:      (type $25 (func (param stringref stringref) (result i32)))
 
- ;; CHECK:      (type $25 (func (param i32 i64) (result f32)))
+ ;; CHECK:      (type $26 (func (param i32 i64) (result f32)))
 
- ;; CHECK:      (type $26 (func (param i64 v128) (result v128)))
+ ;; CHECK:      (type $27 (func (param i64 v128) (result v128)))
 
- ;; CHECK:      (type $27 (func (param i64 v128)))
+ ;; CHECK:      (type $28 (func (param i64 v128)))
 
- ;; CHECK:      (type $28 (func (param i32 i32)))
+ ;; CHECK:      (type $29 (func (param i32 i32)))
 
- ;; CHECK:      (type $29 (func (param i32 i32 f64 f64)))
+ ;; CHECK:      (type $30 (func (param i32 i32 f64 f64)))
 
- ;; CHECK:      (type $30 (func (param i64)))
+ ;; CHECK:      (type $31 (func (param i64)))
 
- ;; CHECK:      (type $31 (func (param v128) (result i32)))
+ ;; CHECK:      (type $32 (func (param v128) (result i32)))
 
- ;; CHECK:      (type $32 (func (param v128 v128) (result v128)))
+ ;; CHECK:      (type $33 (func (param v128 v128) (result v128)))
 
- ;; CHECK:      (type $33 (func (param v128 v128 v128) (result v128)))
+ ;; CHECK:      (type $34 (func (param v128 v128 v128) (result v128)))
 
- ;; CHECK:      (type $34 (func (param i32 i32 i64 i64)))
+ ;; CHECK:      (type $35 (func (param i32 i32 i64 i64)))
 
- ;; CHECK:      (type $35 (func (param i32) (result i32)))
+ ;; CHECK:      (type $36 (func (param i32) (result i32)))
 
- ;; CHECK:      (type $36 (func (param i32 i64) (result i32 i64)))
+ ;; CHECK:      (type $37 (func (param i32 i64) (result i32 i64)))
 
- ;; CHECK:      (type $37 (func (param i64) (result i32 i64)))
+ ;; CHECK:      (type $38 (func (param i64) (result i32 i64)))
 
- ;; CHECK:      (type $38 (func (param i32) (result i32 i64)))
+ ;; CHECK:      (type $39 (func (param i32) (result i32 i64)))
 
- ;; CHECK:      (type $39 (func (param anyref) (result i32)))
+ ;; CHECK:      (type $40 (func (param anyref) (result i32)))
 
- ;; CHECK:      (type $40 (func (param eqref eqref) (result i32)))
+ ;; CHECK:      (type $41 (func (param eqref eqref) (result i32)))
 
- ;; CHECK:      (type $41 (func (param i32) (result i31ref)))
+ ;; CHECK:      (type $42 (func (param i32) (result i31ref)))
 
- ;; CHECK:      (type $42 (func (param i31ref)))
+ ;; CHECK:      (type $43 (func (param i31ref)))
 
- ;; CHECK:      (type $43 (func (param i32 i64) (result (ref $pair))))
+ ;; CHECK:      (type $44 (func (param i32 i64) (result (ref $pair))))
 
- ;; CHECK:      (type $44 (func (result (ref $pair))))
+ ;; CHECK:      (type $45 (func (result (ref $pair))))
 
- ;; CHECK:      (type $45 (func (param (ref $pair)) (result i32)))
+ ;; CHECK:      (type $46 (func (param (ref $pair)) (result i32)))
 
- ;; CHECK:      (type $46 (func (param (ref $pair)) (result i64)))
+ ;; CHECK:      (type $47 (func (param (ref $pair)) (result i64)))
 
- ;; CHECK:      (type $47 (func (param (ref $pair) i32)))
+ ;; CHECK:      (type $48 (func (param (ref $pair) i32)))
 
- ;; CHECK:      (type $48 (func (param (ref $pair) i64)))
+ ;; CHECK:      (type $49 (func (param (ref $pair) i64)))
 
- ;; CHECK:      (type $49 (func (param i64 i32) (result (ref $a1))))
+ ;; CHECK:      (type $50 (func (param i64 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $50 (func (param i32) (result (ref $a1))))
+ ;; CHECK:      (type $51 (func (param i32) (result (ref $a1))))
 
- ;; CHECK:      (type $51 (func (param i32 i32) (result (ref $a1))))
+ ;; CHECK:      (type $52 (func (param i32 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $52 (func (param (ref $a1) i32) (result i64)))
+ ;; CHECK:      (type $53 (func (param (ref $a1) i32) (result i64)))
 
- ;; CHECK:      (type $53 (func (param (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $54 (func (param (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $54 (func (param (ref $packed-i16) i32) (result i32)))
+ ;; CHECK:      (type $55 (func (param (ref $packed-i16) i32) (result i32)))
 
- ;; CHECK:      (type $55 (func (param (ref $a2) i32 f32)))
+ ;; CHECK:      (type $56 (func (param (ref $a2) i32 f32)))
 
- ;; CHECK:      (type $56 (func (param arrayref) (result i32)))
+ ;; CHECK:      (type $57 (func (param arrayref) (result i32)))
 
- ;; CHECK:      (type $57 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
+ ;; CHECK:      (type $58 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
 
- ;; CHECK:      (type $58 (func (param (ref $a2) i32 f32 i32)))
+ ;; CHECK:      (type $59 (func (param (ref $a2) i32 f32 i32)))
 
- ;; CHECK:      (type $59 (func (param (ref $a2) i32 i32 i32)))
+ ;; CHECK:      (type $60 (func (param (ref $a2) i32 i32 i32)))
 
- ;; CHECK:      (type $60 (func (param (ref $any-array) i32 i32 i32)))
+ ;; CHECK:      (type $61 (func (param (ref $any-array) i32 i32 i32)))
 
- ;; CHECK:      (type $61 (func (param externref)))
+ ;; CHECK:      (type $62 (func (param externref)))
 
- ;; CHECK:      (type $62 (func (param i32 i32) (result stringref)))
+ ;; CHECK:      (type $63 (func (param i32 i32) (result stringref)))
 
- ;; CHECK:      (type $63 (func (param (ref $packed-i8) i32 i32) (result stringref)))
+ ;; CHECK:      (type $64 (func (param (ref $packed-i8) i32 i32) (result stringref)))
 
- ;; CHECK:      (type $64 (func (param i32) (result stringref)))
+ ;; CHECK:      (type $65 (func (param i32) (result stringref)))
 
- ;; CHECK:      (type $65 (func (result (ref string))))
+ ;; CHECK:      (type $66 (func (result (ref string))))
 
- ;; CHECK:      (type $66 (func (param stringref) (result i32)))
+ ;; CHECK:      (type $67 (func (param stringref) (result i32)))
 
- ;; CHECK:      (type $67 (func (param stringview_wtf16) (result i32)))
+ ;; CHECK:      (type $68 (func (param stringview_wtf16) (result i32)))
 
- ;; CHECK:      (type $68 (func (param stringref (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $69 (func (param stringref (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $69 (func (param stringref stringref) (result (ref string))))
+ ;; CHECK:      (type $70 (func (param stringref stringref) (result (ref string))))
 
- ;; CHECK:      (type $70 (func (param stringref) (result stringview_wtf8)))
+ ;; CHECK:      (type $71 (func (param stringref) (result stringview_wtf8)))
 
- ;; CHECK:      (type $71 (func (param stringref) (result (ref stringview_wtf16))))
+ ;; CHECK:      (type $72 (func (param stringref) (result (ref stringview_wtf16))))
 
- ;; CHECK:      (type $72 (func (param stringref) (result stringview_iter)))
+ ;; CHECK:      (type $73 (func (param stringref) (result stringview_iter)))
 
- ;; CHECK:      (type $73 (func (param (ref stringview_wtf8) i32 i32) (result i32)))
+ ;; CHECK:      (type $74 (func (param (ref stringview_wtf8) i32 i32) (result i32)))
 
- ;; CHECK:      (type $74 (func (param stringview_wtf16 i32) (result i32)))
+ ;; CHECK:      (type $75 (func (param stringview_wtf16 i32) (result i32)))
 
- ;; CHECK:      (type $75 (func (param stringview_iter) (result i32)))
+ ;; CHECK:      (type $76 (func (param stringview_iter) (result i32)))
 
- ;; CHECK:      (type $76 (func (param stringview_iter i32) (result i32)))
+ ;; CHECK:      (type $77 (func (param stringview_iter i32) (result i32)))
 
- ;; CHECK:      (type $77 (func (param (ref stringview_iter) i32) (result i32)))
+ ;; CHECK:      (type $78 (func (param (ref stringview_iter) i32) (result i32)))
 
- ;; CHECK:      (type $78 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))
+ ;; CHECK:      (type $79 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))
 
- ;; CHECK:      (type $79 (func (param stringview_iter i32) (result (ref string))))
+ ;; CHECK:      (type $80 (func (param stringview_iter i32) (result (ref string))))
 
  ;; CHECK:      (type $s2 (struct (field i32)))
  (type $s2 (struct i32))
@@ -234,7 +236,7 @@
 
  ;; imported memories
  (memory (export "mem") (export "mem2") (import "" "mem") 0)
- ;; CHECK:      (type $91 (func (param (ref $s0) (ref $s1) (ref $s2) (ref $s3) (ref $s4) (ref $s5) (ref $s6) (ref $s7) (ref $s8) (ref $a0) (ref $a1) (ref $a2) (ref $a3) (ref $subvoid) (ref $submany) (ref $all-types))))
+ ;; CHECK:      (type $92 (func (param (ref $s0) (ref $s1) (ref $s2) (ref $s3) (ref $s4) (ref $s5) (ref $s6) (ref $s7) (ref $s8) (ref $a0) (ref $a1) (ref $a2) (ref $a3) (ref $subvoid) (ref $submany) (ref $all-types))))
 
  ;; CHECK:      (import "" "mem" (memory $mimport$0 0))
 
@@ -370,7 +372,7 @@
  ;; CHECK:      (elem $passive-2 anyref (struct.new_default $s0) (struct.new_default $s0))
  (elem $passive-2 anyref (item struct.new $s0) (struct.new $s0))
 
- ;; CHECK:      (elem declare func $ref-func $ref-is-null $table-fill $table-grow $table-set)
+ ;; CHECK:      (elem declare func $ref-func $table-fill $table-grow $table-set)
  (elem declare func 0 1 2 3)
 
  (elem $declare-2 declare funcref (item ref.func 0) (ref.func 1) (item (ref.func 2)))
@@ -878,7 +880,7 @@
   drop
  )
 
- ;; CHECK:      (func $locals (type $28) (param $0 i32) (param $x i32)
+ ;; CHECK:      (func $locals (type $29) (param $0 i32) (param $x i32)
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (drop
@@ -2362,6 +2364,130 @@
   end
  )
 
+ ;; CHECK:      (func $try-table (type $void)
+ ;; CHECK-NEXT:  (try_table
+ ;; CHECK-NEXT:   (nop)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $try-table
+  try_table
+   nop
+  end
+ )
+
+ ;; CHECK:      (func $try-table-catch (type $void)
+ ;; CHECK-NEXT:  (block $label
+ ;; CHECK-NEXT:   (try_table (catch $empty $label)
+ ;; CHECK-NEXT:    (nop)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $try-table-catch
+  try_table (catch $empty 0)
+   nop
+  end
+ )
+
+ ;; CHECK:      (func $try-table-catch-ref (type $17) (result exnref)
+ ;; CHECK-NEXT:  (block $label (result exnref)
+ ;; CHECK-NEXT:   (try_table (result exnref) (catch_ref $empty $label)
+ ;; CHECK-NEXT:    (unreachable)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $try-table-catch-ref (result exnref)
+  try_table (result exnref) (catch_ref $empty 0)
+   unreachable
+  end
+ )
+
+ ;; CHECK:      (func $try-table-catch-all (type $void)
+ ;; CHECK-NEXT:  (block $label
+ ;; CHECK-NEXT:   (try_table (catch_all $label)
+ ;; CHECK-NEXT:    (nop)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $try-table-catch-all
+  try_table (catch_all 0)
+   nop
+  end
+ )
+
+ ;; CHECK:      (func $try-table-catch-all-ref (type $17) (result exnref)
+ ;; CHECK-NEXT:  (block $label (result exnref)
+ ;; CHECK-NEXT:   (try_table (result exnref) (catch_all_ref $label)
+ ;; CHECK-NEXT:    (unreachable)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $try-table-catch-all-ref (result exnref)
+  try_table (result exnref) (catch_all_ref 0)
+   unreachable
+  end
+ )
+
+ ;; CHECK:      (func $try-table-all (type $void)
+ ;; CHECK-NEXT:  (block $catch
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (block $catch_ref (result exnref)
+ ;; CHECK-NEXT:     (block $catch_all
+ ;; CHECK-NEXT:      (drop
+ ;; CHECK-NEXT:       (block $catch_all_ref (result exnref)
+ ;; CHECK-NEXT:        (block $try
+ ;; CHECK-NEXT:         (try_table (catch $empty $catch) (catch_ref $empty $catch_ref) (catch_all $catch_all) (catch_all_ref $catch_all_ref)
+ ;; CHECK-NEXT:          (br $try)
+ ;; CHECK-NEXT:         )
+ ;; CHECK-NEXT:        )
+ ;; CHECK-NEXT:        (unreachable)
+ ;; CHECK-NEXT:       )
+ ;; CHECK-NEXT:      )
+ ;; CHECK-NEXT:     )
+ ;; CHECK-NEXT:     (unreachable)
+ ;; CHECK-NEXT:    )
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $try-table-all
+  block $catch
+   block $catch_ref (result exnref)
+    block $catch_all
+     block $catch_all_ref (result exnref)
+      try_table $try (catch $empty $catch)
+                     (catch_ref $empty $catch_ref)
+                     (catch_all $catch_all)
+                     (catch_all_ref $catch_all_ref)
+       br $try
+      end $try
+      unreachable
+     end $catch_all_ref
+     drop
+    end $catch_all
+    unreachable
+   end $catch_ref
+   drop
+  end $catch
+ )
+
+ ;; CHECK:      (func $try-table-folded (type $void)
+ ;; CHECK-NEXT:  (block $label
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (block $try (result i32)
+ ;; CHECK-NEXT:     (try_table (result i32) (catch $empty $label)
+ ;; CHECK-NEXT:      (i32.const 0)
+ ;; CHECK-NEXT:     )
+ ;; CHECK-NEXT:    )
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $try-table-folded
+  (drop
+   (try_table $try (result i32) (catch $empty 0)
+    (i32.const 0)
+   )
+  )
+ )
+
  ;; CHECK:      (func $label-siblings (type $void)
  ;; CHECK-NEXT:  (block $l
  ;; CHECK-NEXT:   (br $l)
@@ -2584,7 +2710,7 @@
   br_if 0
  )
 
- ;; CHECK:      (func $br_if-value (type $17) (result i64)
+ ;; CHECK:      (func $br_if-value (type $18) (result i64)
  ;; CHECK-NEXT:  (block $l (result i64)
  ;; CHECK-NEXT:   (br_if $l
  ;; CHECK-NEXT:    (i64.const 0)
@@ -2600,8 +2726,8 @@
   end
  )
 
- ;; CHECK:      (func $br_if-multivalue (type $18) (result i64 f32)
- ;; CHECK-NEXT:  (block $l (type $18) (result i64 f32)
+ ;; CHECK:      (func $br_if-multivalue (type $19) (result i64 f32)
+ ;; CHECK-NEXT:  (block $l (type $19) (result i64 f32)
  ;; CHECK-NEXT:   (br_if $l
  ;; CHECK-NEXT:    (tuple.make 2
  ;; CHECK-NEXT:     (i64.const 0)
@@ -2620,7 +2746,7 @@
   end
  )
 
- ;; CHECK:      (func $br_if-loop (type $17) (result i64)
+ ;; CHECK:      (func $br_if-loop (type $18) (result i64)
  ;; CHECK-NEXT:  (local $scratch i64)
  ;; CHECK-NEXT:  (loop $l (result i64)
  ;; CHECK-NEXT:   (local.set $scratch
@@ -2770,7 +2896,7 @@
   end
  )
 
- ;; CHECK:      (func $binary (type $29) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
+ ;; CHECK:      (func $binary (type $30) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $0)
@@ -2795,7 +2921,7 @@
   drop
  )
 
- ;; CHECK:      (func $unary (type $30) (param $0 i64)
+ ;; CHECK:      (func $unary (type $31) (param $0 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.eqz
  ;; CHECK-NEXT:    (local.get $0)
@@ -2808,7 +2934,7 @@
   drop
  )
 
- ;; CHECK:      (func $select (type $19) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $select (type $20) (param $0 i32) (param $1 i32) (param $2 i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (select
  ;; CHECK-NEXT:    (local.get $0)
@@ -3090,7 +3216,7 @@
   atomic.fence
  )
 
- ;; CHECK:      (func $simd-extract (type $31) (param $0 v128) (result i32)
+ ;; CHECK:      (func $simd-extract (type $32) (param $0 v128) (result i32)
  ;; CHECK-NEXT:  (i32x4.extract_lane 3
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3100,7 +3226,7 @@
   i32x4.extract_lane 3
  )
 
- ;; CHECK:      (func $simd-replace (type $20) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-replace (type $21) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i32x4.replace_lane 2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3112,7 +3238,7 @@
   i32x4.replace_lane 2
  )
 
- ;; CHECK:      (func $simd-shuffle (type $32) (param $0 v128) (param $1 v128) (result v128)
+ ;; CHECK:      (func $simd-shuffle (type $33) (param $0 v128) (param $1 v128) (result v128)
  ;; CHECK-NEXT:  (i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3124,7 +3250,7 @@
   i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
  )
 
- ;; CHECK:      (func $simd-ternary (type $33) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ ;; CHECK:      (func $simd-ternary (type $34) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
  ;; CHECK-NEXT:  (v128.bitselect
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3138,7 +3264,7 @@
   v128.bitselect
  )
 
- ;; CHECK:      (func $simd-shift (type $20) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-shift (type $21) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i8x16.shl
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3193,7 +3319,7 @@
   v128.store64_lane 5 align=4 0
  )
 
- ;; CHECK:      (func $memory-init (type $19) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $memory-init (type $20) (param $0 i32) (param $1 i32) (param $2 i32)
  ;; CHECK-NEXT:  (memory.init $mem-i32 $passive
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3234,7 +3360,7 @@
   data.drop $passive
  )
 
- ;; CHECK:      (func $memory-copy (type $34) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64)
+ ;; CHECK:      (func $memory-copy (type $35) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64)
  ;; CHECK-NEXT:  (memory.copy $mimport$0 $mimport$0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3305,7 +3431,7 @@
   return
  )
 
- ;; CHECK:      (func $return-one (type $35) (param $0 i32) (result i32)
+ ;; CHECK:      (func $return-one (type $36) (param $0 i32) (result i32)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3315,7 +3441,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two (type $36) (param $0 i32) (param $1 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two (type $37) (param $0 i32) (param $1 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (local.get $0)
@@ -3329,7 +3455,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-first-unreachable (type $37) (param $0 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two-first-unreachable (type $38) (param $0 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (unreachable)
@@ -3343,7 +3469,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-second-unreachable (type $38) (param $0 i32) (result i32 i64)
+ ;; CHECK:      (func $return-two-second-unreachable (type $39) (param $0 i32) (result i32 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3360,7 +3486,7 @@
   return
  )
 
- ;; CHECK:      (func $ref-is-null (type $39) (param $0 anyref) (result i32)
+ ;; CHECK:      (func $ref-is-null (type $40) (param $0 anyref) (result i32)
  ;; CHECK-NEXT:  (ref.is_null
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3375,13 +3501,13 @@
  ;; CHECK-NEXT:   (ref.func $ref-func)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (ref.func $ref-is-null)
+ ;; CHECK-NEXT:   (ref.func $ref-func)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $ref-func
   ref.func $ref-func
   drop
-  ref.func 142
+  ref.func 150
   drop
  )
 
@@ -3404,7 +3530,7 @@
   throw $tag-pair
  )
 
- ;; CHECK:      (func $ref-eq (type $40) (param $0 eqref) (param $1 eqref) (result i32)
+ ;; CHECK:      (func $ref-eq (type $41) (param $0 eqref) (param $1 eqref) (result i32)
  ;; CHECK-NEXT:  (ref.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3581,7 +3707,7 @@
   table.copy 2 $funcs
  )
 
- ;; CHECK:      (func $i31-new (type $41) (param $0 i32) (result i31ref)
+ ;; CHECK:      (func $i31-new (type $42) (param $0 i32) (result i31ref)
  ;; CHECK-NEXT:  (ref.i31
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3591,7 +3717,7 @@
   ref.i31
  )
 
- ;; CHECK:      (func $i31-get (type $42) (param $0 i31ref)
+ ;; CHECK:      (func $i31-get (type $43) (param $0 i31ref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i31.get_s
  ;; CHECK-NEXT:    (local.get $0)
@@ -3810,7 +3936,7 @@
   drop
  )
 
- ;; CHECK:      (func $struct-new (type $43) (param $0 i32) (param $1 i64) (result (ref $pair))
+ ;; CHECK:      (func $struct-new (type $44) (param $0 i32) (param $1 i64) (result (ref $pair))
  ;; CHECK-NEXT:  (struct.new $pair
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3822,14 +3948,14 @@
   struct.new $pair
  )
 
- ;; CHECK:      (func $struct-new-default (type $44) (result (ref $pair))
+ ;; CHECK:      (func $struct-new-default (type $45) (result (ref $pair))
  ;; CHECK-NEXT:  (struct.new_default $pair)
  ;; CHECK-NEXT: )
  (func $struct-new-default (result (ref $pair))
   struct.new_default 14
  )
 
- ;; CHECK:      (func $struct-get-0 (type $45) (param $0 (ref $pair)) (result i32)
+ ;; CHECK:      (func $struct-get-0 (type $46) (param $0 (ref $pair)) (result i32)
  ;; CHECK-NEXT:  (struct.get $pair 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3839,7 +3965,7 @@
   struct.get 14 0
  )
 
- ;; CHECK:      (func $struct-get-1 (type $46) (param $0 (ref $pair)) (result i64)
+ ;; CHECK:      (func $struct-get-1 (type $47) (param $0 (ref $pair)) (result i64)
  ;; CHECK-NEXT:  (struct.get $pair 1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3849,7 +3975,7 @@
   struct.get $pair 1
  )
 
- ;; CHECK:      (func $struct-set-0 (type $47) (param $0 (ref $pair)) (param $1 i32)
+ ;; CHECK:      (func $struct-set-0 (type $48) (param $0 (ref $pair)) (param $1 i32)
  ;; CHECK-NEXT:  (struct.set $pair 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3861,7 +3987,7 @@
   struct.set $pair 0
  )
 
- ;; CHECK:      (func $struct-set-1 (type $48) (param $0 (ref $pair)) (param $1 i64)
+ ;; CHECK:      (func $struct-set-1 (type $49) (param $0 (ref $pair)) (param $1 i64)
  ;; CHECK-NEXT:  (struct.set $pair 1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3873,7 +3999,7 @@
   struct.set 14 1
  )
 
- ;; CHECK:      (func $array-new (type $49) (param $0 i64) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new (type $50) (param $0 i64) (param $1 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3885,7 +4011,7 @@
   array.new $a1
  )
 
- ;; CHECK:      (func $array-new-default (type $50) (param $0 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-default (type $51) (param $0 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new_default $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3895,7 +4021,7 @@
   array.new_default 11
  )
 
- ;; CHECK:      (func $array-new-data (type $51) (param $0 i32) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-data (type $52) (param $0 i32) (param $1 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new_data $a1 $implicit-data
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3929,7 +4055,7 @@
   drop
  )
 
- ;; CHECK:      (func $array-get (type $52) (param $0 (ref $a1)) (param $1 i32) (result i64)
+ ;; CHECK:      (func $array-get (type $53) (param $0 (ref $a1)) (param $1 i32) (result i64)
  ;; CHECK-NEXT:  (array.get $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3941,7 +4067,7 @@
   array.get $a1
  )
 
- ;; CHECK:      (func $array-get-s (type $53) (param $0 (ref $packed-i8)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-s (type $54) (param $0 (ref $packed-i8)) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (array.get_s $packed-i8
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3953,7 +4079,7 @@
   array.get_s 15
  )
 
- ;; CHECK:      (func $array-get-u (type $54) (param $0 (ref $packed-i16)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-u (type $55) (param $0 (ref $packed-i16)) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (array.get_u $packed-i16
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3965,7 +4091,7 @@
   array.get_u $packed-i16
  )
 
- ;; CHECK:      (func $array-set (type $55) (param $0 (ref $a2)) (param $1 i32) (param $2 f32)
+ ;; CHECK:      (func $array-set (type $56) (param $0 (ref $a2)) (param $1 i32) (param $2 f32)
  ;; CHECK-NEXT:  (array.set $a2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3979,7 +4105,7 @@
   array.set $a2
  )
 
- ;; CHECK:      (func $array-len (type $56) (param $0 arrayref) (result i32)
+ ;; CHECK:      (func $array-len (type $57) (param $0 arrayref) (result i32)
  ;; CHECK-NEXT:  (array.len
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3989,7 +4115,7 @@
   array.len
  )
 
- ;; CHECK:      (func $array-copy (type $57) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32)
+ ;; CHECK:      (func $array-copy (type $58) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32)
  ;; CHECK-NEXT:  (array.copy $a2 $a2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4007,7 +4133,7 @@
   array.copy $a2 $a2
  )
 
- ;; CHECK:      (func $array-fill (type $58) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32)
+ ;; CHECK:      (func $array-fill (type $59) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32)
  ;; CHECK-NEXT:  (array.fill $a2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4023,7 +4149,7 @@
   array.fill $a2
  )
 
- ;; CHECK:      (func $array-init-data (type $59) (param $0 (ref $a2)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $array-init-data (type $60) (param $0 (ref $a2)) (param $1 i32) (param $2 i32) (param $3 i32)
  ;; CHECK-NEXT:  (array.init_data $a2 $implicit-data
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4039,7 +4165,7 @@
   array.init_data $a2 0
  )
 
- ;; CHECK:      (func $array-init-elem (type $60) (param $0 (ref $any-array)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $array-init-elem (type $61) (param $0 (ref $any-array)) (param $1 i32) (param $2 i32) (param $3 i32)
  ;; CHECK-NEXT:  (array.init_elem $any-array $passive-2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4068,7 +4194,7 @@
   drop
  )
 
- ;; CHECK:      (func $any-convert-extern (type $61) (param $0 externref)
+ ;; CHECK:      (func $any-convert-extern (type $62) (param $0 externref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (extern.internalize
  ;; CHECK-NEXT:    (local.get $0)
@@ -4094,7 +4220,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-new (type $62) (param $0 i32) (param $1 i32) (result stringref)
+ ;; CHECK:      (func $string-new (type $63) (param $0 i32) (param $1 i32) (result stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.new_utf8_try
  ;; CHECK-NEXT:    (local.get $0)
@@ -4136,7 +4262,7 @@
   string.new_wtf16
  )
 
- ;; CHECK:      (func $string-new-gc (type $63) (param $0 (ref $packed-i8)) (param $1 i32) (param $2 i32) (result stringref)
+ ;; CHECK:      (func $string-new-gc (type $64) (param $0 (ref $packed-i8)) (param $1 i32) (param $2 i32) (result stringref)
  ;; CHECK-NEXT:  (string.new_utf8_array
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4150,7 +4276,7 @@
   string.new_utf8_array
  )
 
- ;; CHECK:      (func $string-new-code-point (type $64) (param $0 i32) (result stringref)
+ ;; CHECK:      (func $string-new-code-point (type $65) (param $0 i32) (result stringref)
  ;; CHECK-NEXT:  (string.from_code_point
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4160,7 +4286,7 @@
   string.from_code_point
  )
 
- ;; CHECK:      (func $string-const (type $65) (result (ref string))
+ ;; CHECK:      (func $string-const (type $66) (result (ref string))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.const "foobar")
  ;; CHECK-NEXT:  )
@@ -4172,7 +4298,7 @@
   string.const "\00\00\00"
  )
 
- ;; CHECK:      (func $string-measure (type $23) (param $0 stringref)
+ ;; CHECK:      (func $string-measure (type $24) (param $0 stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.measure_wtf8
  ;; CHECK-NEXT:    (local.get $0)
@@ -4209,7 +4335,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-hash (type $66) (param $0 stringref) (result i32)
+ ;; CHECK:      (func $string-hash (type $67) (param $0 stringref) (result i32)
  ;; CHECK-NEXT:  (string.hash
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4219,7 +4345,7 @@
   string.hash
  )
 
- ;; CHECK:      (func $stringview-length (type $67) (param $0 stringview_wtf16) (result i32)
+ ;; CHECK:      (func $stringview-length (type $68) (param $0 stringview_wtf16) (result i32)
  ;; CHECK-NEXT:  (stringview_wtf16.length
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4229,7 +4355,7 @@
   stringview_wtf16.length
  )
 
- ;; CHECK:      (func $string-encode (type $23) (param $0 stringref)
+ ;; CHECK:      (func $string-encode (type $24) (param $0 stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.encode_wtf8
  ;; CHECK-NEXT:    (local.get $0)
@@ -4274,7 +4400,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-encode-gc (type $68) (param $0 stringref) (param $1 (ref $packed-i8)) (param $2 i32) (result i32)
+ ;; CHECK:      (func $string-encode-gc (type $69) (param $0 stringref) (param $1 (ref $packed-i8)) (param $2 i32) (result i32)
  ;; CHECK-NEXT:  (string.encode_wtf8_array
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4288,7 +4414,7 @@
   string.encode_wtf8_array
  )
 
- ;; CHECK:      (func $string-concat (type $69) (param $0 stringref) (param $1 stringref) (result (ref string))
+ ;; CHECK:      (func $string-concat (type $70) (param $0 stringref) (param $1 stringref) (result (ref string))
  ;; CHECK-NEXT:  (string.concat
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4300,7 +4426,7 @@
   string.concat
  )
 
- ;; CHECK:      (func $string-eq (type $24) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK:      (func $string-eq (type $25) (param $0 stringref) (param $1 stringref) (result i32)
  ;; CHECK-NEXT:  (string.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4312,7 +4438,7 @@
   string.eq
  )
 
- ;; CHECK:      (func $string-compare (type $24) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK:      (func $string-compare (type $25) (param $0 stringref) (param $1 stringref) (result i32)
  ;; CHECK-NEXT:  (string.compare
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4324,7 +4450,7 @@
   string.compare
  )
 
- ;; CHECK:      (func $string-as-wtf8 (type $70) (param $0 stringref) (result stringview_wtf8)
+ ;; CHECK:      (func $string-as-wtf8 (type $71) (param $0 stringref) (result stringview_wtf8)
  ;; CHECK-NEXT:  (string.as_wtf8
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4334,7 +4460,7 @@
   string.as_wtf8
  )
 
- ;; CHECK:      (func $string-as-wtf16 (type $71) (param $0 stringref) (result (ref stringview_wtf16))
+ ;; CHECK:      (func $string-as-wtf16 (type $72) (param $0 stringref) (result (ref stringview_wtf16))
  ;; CHECK-NEXT:  (string.as_wtf16
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4344,7 +4470,7 @@
   string.as_wtf16
  )
 
- ;; CHECK:      (func $string-as-iter (type $72) (param $0 stringref) (result stringview_iter)
+ ;; CHECK:      (func $string-as-iter (type $73) (param $0 stringref) (result stringview_iter)
  ;; CHECK-NEXT:  (string.as_iter
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4354,7 +4480,7 @@
   string.as_iter
  )
 
- ;; CHECK:      (func $string-advance (type $73) (param $0 (ref stringview_wtf8)) (param $1 i32) (param $2 i32) (result i32)
+ ;; CHECK:      (func $string-advance (type $74) (param $0 (ref stringview_wtf8)) (param $1 i32) (param $2 i32) (result i32)
  ;; CHECK-NEXT:  (stringview_wtf8.advance
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4368,7 +4494,7 @@
   stringview_wtf8.advance
  )
 
- ;; CHECK:      (func $string-get (type $74) (param $0 stringview_wtf16) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-get (type $75) (param $0 stringview_wtf16) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (stringview_wtf16.get_codeunit
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4380,7 +4506,7 @@
   stringview_wtf16.get_codeunit
  )
 
- ;; CHECK:      (func $string-iter-next (type $75) (param $0 stringview_iter) (result i32)
+ ;; CHECK:      (func $string-iter-next (type $76) (param $0 stringview_iter) (result i32)
  ;; CHECK-NEXT:  (stringview_iter.next
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4390,7 +4516,7 @@
   stringview_iter.next
  )
 
- ;; CHECK:      (func $string-iter-advance (type $76) (param $0 stringview_iter) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-iter-advance (type $77) (param $0 stringview_iter) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (stringview_iter.advance
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4402,7 +4528,7 @@
   stringview_iter.advance
  )
 
- ;; CHECK:      (func $string-iter-rewind (type $77) (param $0 (ref stringview_iter)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-iter-rewind (type $78) (param $0 (ref stringview_iter)) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (stringview_iter.rewind
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4414,7 +4540,7 @@
   stringview_iter.rewind
  )
 
- ;; CHECK:      (func $string-slice (type $78) (param $0 stringview_wtf8) (param $1 stringview_wtf16) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $string-slice (type $79) (param $0 stringview_wtf8) (param $1 stringview_wtf16) (param $2 i32) (param $3 i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (stringview_wtf8.slice
  ;; CHECK-NEXT:    (local.get $0)
@@ -4443,7 +4569,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-iter-slice (type $79) (param $0 stringview_iter) (param $1 i32) (result (ref string))
+ ;; CHECK:      (func $string-iter-slice (type $80) (param $0 stringview_iter) (param $1 i32) (result (ref string))
  ;; CHECK-NEXT:  (stringview_iter.slice
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4455,7 +4581,7 @@
   stringview_iter.slice
  )
 
- ;; CHECK:      (func $call (type $25) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $call (type $26) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (call $call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4467,7 +4593,7 @@
   call $call
  )
 
- ;; CHECK:      (func $return_call (type $25) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $return_call (type $26) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (return_call $return_call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4508,7 +4634,7 @@
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (call_indirect $timport$0 (type $26)
+ ;; CHECK-NEXT:   (call_indirect $timport$0 (type $27)
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:    (local.get $0)
@@ -4570,7 +4696,7 @@
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (call_indirect $timport$0 (type $26)
+ ;; CHECK-NEXT:   (call_indirect $timport$0 (type $27)
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:    (local.get $0)
@@ -4642,7 +4768,7 @@
  ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $27)
+ ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $28)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $0)
@@ -4701,7 +4827,7 @@
  ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $27)
+ ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $28)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $0)
@@ -4742,7 +4868,7 @@
   )
  )
 
- ;; CHECK:      (func $use-types (type $91) (param $0 (ref $s0)) (param $1 (ref $s1)) (param $2 (ref $s2)) (param $3 (ref $s3)) (param $4 (ref $s4)) (param $5 (ref $s5)) (param $6 (ref $s6)) (param $7 (ref $s7)) (param $8 (ref $s8)) (param $9 (ref $a0)) (param $10 (ref $a1)) (param $11 (ref $a2)) (param $12 (ref $a3)) (param $13 (ref $subvoid)) (param $14 (ref $submany)) (param $15 (ref $all-types))
+ ;; CHECK:      (func $use-types (type $92) (param $0 (ref $s0)) (param $1 (ref $s1)) (param $2 (ref $s2)) (param $3 (ref $s3)) (param $4 (ref $s4)) (param $5 (ref $s5)) (param $6 (ref $s6)) (param $7 (ref $s7)) (param $8 (ref $s8)) (param $9 (ref $a0)) (param $10 (ref $a1)) (param $11 (ref $a2)) (param $12 (ref $a3)) (param $13 (ref $subvoid)) (param $14 (ref $submany)) (param $15 (ref $all-types))
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
  (func $use-types