[Parser] Parse br_if correctly (#6202)

The new text parser and IRBuilder were previously not differentiating between
`br` and `br_if`. Handle `br_if` correctly by popping and assigning a condition.

9 files changed, 234 insertions, 146 deletions

diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
index f716302d0..9d6e58481 100755
--- a/scripts/gen-s-parser.py
+++ b/scripts/gen-s-parser.py
@@ -24,8 +24,8 @@ instructions = [
     ("if",             "makeIf(s)"),
     ("then",           "makeThenOrElse(s)"),
     ("else",           "makeThenOrElse(s)"),
-    ("br",             "makeBreak(s)"),
-    ("br_if",          "makeBreak(s)"),
+    ("br",             "makeBreak(s, false)"),
+    ("br_if",          "makeBreak(s, true)"),
     ("br_table",       "makeBreakTable(s)"),
     ("return",         "makeReturn(s)"),
     ("call",           "makeCall(s, /*isReturn=*/false)"),
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 2c284d561..cef0a6b92 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -102,12 +102,12 @@ switch (buf[0]) {
       case 'r': {
         switch (buf[2]) {
           case '\0':
-            if (op == "br"sv) { return makeBreak(s); }
+            if (op == "br"sv) { return makeBreak(s, false); }
             goto parse_error;
           case '_': {
             switch (buf[3]) {
               case 'i':
-                if (op == "br_if"sv) { return makeBreak(s); }
+                if (op == "br_if"sv) { return makeBreak(s, true); }
                 goto parse_error;
               case 'o': {
                 switch (buf[6]) {
@@ -3749,7 +3749,7 @@ switch (buf[0]) {
     switch (buf[2]) {
       case '\0':
         if (op == "br"sv) {
-          CHECK_ERR(makeBreak(ctx, pos));
+          CHECK_ERR(makeBreak(ctx, pos, false));
           return Ok{};
         }
         goto parse_error;
@@ -3757,7 +3757,7 @@ switch (buf[0]) {
         switch (buf[3]) {
           case 'i':
             if (op == "br_if"sv) {
-              CHECK_ERR(makeBreak(ctx, pos));
+              CHECK_ERR(makeBreak(ctx, pos, true));
               return Ok{};
             }
             goto parse_error;
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index 1cefb288d..f489a2c05 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -411,7 +411,7 @@ struct NullInstrParserCtx {
   Result<> makeCallIndirect(Index, TableIdxT*, TypeUseT, bool) {
     return Ok{};
   }
-  Result<> makeBreak(Index, LabelIdxT) { return Ok{}; }
+  Result<> makeBreak(Index, LabelIdxT, bool) { return Ok{}; }
   Result<> makeSwitch(Index, const std::vector<LabelIdxT>&, LabelIdxT) {
     return Ok{};
   }
@@ -1586,8 +1586,8 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return withLoc(pos, irBuilder.makeCallIndirect(*t, type, isReturn));
   }
 
-  Result<> makeBreak(Index pos, Index label) {
-    return withLoc(pos, irBuilder.makeBreak(label));
+  Result<> makeBreak(Index pos, Index label, bool isConditional) {
+    return withLoc(pos, irBuilder.makeBreak(label, isConditional));
   }
 
   Result<>
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index 601007036..28110a628 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -104,7 +104,7 @@ template<typename Ctx> Result<> makeMemoryFill(Ctx&, Index);
 template<typename Ctx> Result<> makePop(Ctx&, Index);
 template<typename Ctx> Result<> makeCall(Ctx&, Index, bool isReturn);
 template<typename Ctx> Result<> makeCallIndirect(Ctx&, Index, bool isReturn);
-template<typename Ctx> Result<> makeBreak(Ctx&, Index);
+template<typename Ctx> Result<> makeBreak(Ctx&, Index, bool isConditional);
 template<typename Ctx> Result<> makeBreakTable(Ctx&, Index);
 template<typename Ctx> Result<> makeReturn(Ctx&, Index);
 template<typename Ctx> Result<> makeRefNull(Ctx&, Index);
@@ -1432,10 +1432,11 @@ Result<> makeCallIndirect(Ctx& ctx, Index pos, bool isReturn) {
   return ctx.makeCallIndirect(pos, table.getPtr(), *type, isReturn);
 }
 
-template<typename Ctx> Result<> makeBreak(Ctx& ctx, Index pos) {
+template<typename Ctx>
+Result<> makeBreak(Ctx& ctx, Index pos, bool isConditional) {
   auto label = labelidx(ctx);
   CHECK_ERR(label);
-  return ctx.makeBreak(pos, *label);
+  return ctx.makeBreak(pos, *label, isConditional);
 }
 
 template<typename Ctx> Result<> makeBreakTable(Ctx& ctx, Index pos) {
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
index 5add042a6..4b5468014 100644
--- a/src/wasm-ir-builder.h
+++ b/src/wasm-ir-builder.h
@@ -87,7 +87,7 @@ public:
   [[nodiscard]] Result<> makeBlock(Name label, Type type);
   [[nodiscard]] Result<> makeIf(Name label, Type type);
   [[nodiscard]] Result<> makeLoop(Name label, Type type);
-  [[nodiscard]] Result<> makeBreak(Index label);
+  [[nodiscard]] Result<> makeBreak(Index label, bool isConditional);
   [[nodiscard]] Result<> makeSwitch(const std::vector<Index>& labels,
                                     Index defaultLabel);
   // Unlike Builder::makeCall, this assumes the function already exists.
diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h
index 7921378de..849632ceb 100644
--- a/src/wasm-s-parser.h
+++ b/src/wasm-s-parser.h
@@ -270,7 +270,7 @@ private:
   }
   enum class LabelType { Break, Exception };
   Name getLabel(Element& s, LabelType labelType = LabelType::Break);
-  Expression* makeBreak(Element& s);
+  Expression* makeBreak(Element& s, bool isConditional);
   Expression* makeBreakTable(Element& s);
   Expression* makeReturn(Element& s);
   Expression* makeRefNull(Element& s);
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
index 43a989c6e..e8a2a2386 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/src/wasm/wasm-ir-builder.cpp
@@ -430,6 +430,11 @@ Result<Expression*> IRBuilder::getBranchValue(Name labelName,
 }
 
 Result<> IRBuilder::visitBreak(Break* curr, std::optional<Index> label) {
+  if (curr->condition) {
+    auto cond = pop();
+    CHECK_ERR(cond);
+    curr->condition = *cond;
+  }
   auto value = getBranchValue(curr->name, label);
   CHECK_ERR(value);
   curr->value = *value;
@@ -961,13 +966,15 @@ Result<> IRBuilder::makeLoop(Name label, Type type) {
   return visitLoopStart(loop);
 }
 
-Result<> IRBuilder::makeBreak(Index label) {
+Result<> IRBuilder::makeBreak(Index label, bool isConditional) {
   auto name = getLabelName(label);
   CHECK_ERR(name);
   Break curr;
   curr.name = *name;
+  // Use a dummy condition value if we need to pop a condition.
+  curr.condition = isConditional ? &curr : nullptr;
   CHECK_ERR(visitBreak(&curr, label));
-  push(builder.makeBreak(curr.name, curr.value));
+  push(builder.makeBreak(curr.name, curr.value, curr.condition));
   return Ok{};
 }
 
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 9270a19b0..9dbfc88c2 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -2580,7 +2580,7 @@ Name SExpressionWasmBuilder::getLabel(Element& s, LabelType labelType) {
   }
 }
 
-Expression* SExpressionWasmBuilder::makeBreak(Element& s) {
+Expression* SExpressionWasmBuilder::makeBreak(Element& s, bool isConditional) {
   auto ret = allocator.alloc<Break>();
   size_t i = 1;
   ret->name = getLabel(*s[i]);
@@ -2588,7 +2588,7 @@ Expression* SExpressionWasmBuilder::makeBreak(Element& s) {
   if (i == s.size()) {
     return ret;
   }
-  if (elementStartsWith(s, BR_IF)) {
+  if (isConditional) {
     if (i + 1 < s.size()) {
       ret->value = parseExpression(s[i]);
       i++;
diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
index 19915b130..1a6eaa14e 100644
--- a/test/lit/wat-kitchen-sink.wast
+++ b/test/lit/wat-kitchen-sink.wast
@@ -46,127 +46,131 @@
 
  ;; CHECK:      (type $a0 (array i32))
 
- ;; CHECK:      (type $17 (func (param i32 i32 i32)))
+ ;; CHECK:      (type $17 (func (result i64 f32)))
 
- ;; CHECK:      (type $18 (func (param v128 i32) (result v128)))
+ ;; CHECK:      (type $18 (func (param i32 i32 i32)))
+
+ ;; CHECK:      (type $19 (func (param v128 i32) (result v128)))
 
  ;; CHECK:      (type $packed-i16 (array (mut i16)))
 
  ;; CHECK:      (type $any-array (array (mut anyref)))
 
- ;; CHECK:      (type $21 (func (param stringref)))
+ ;; CHECK:      (type $22 (func (param stringref)))
+
+ ;; CHECK:      (type $23 (func (param stringref stringref) (result i32)))
 
- ;; CHECK:      (type $22 (func (param stringref stringref) (result i32)))
+ ;; CHECK:      (type $24 (func (param i32 i64) (result f32)))
 
- ;; CHECK:      (type $23 (func (param i32 i64) (result f32)))
+ ;; CHECK:      (type $25 (func (param i64 v128) (result v128)))
 
- ;; CHECK:      (type $24 (func (param i64 v128) (result v128)))
+ ;; CHECK:      (type $26 (func (param i64 v128)))
 
- ;; CHECK:      (type $25 (func (param i64 v128)))
+ ;; CHECK:      (type $27 (func (param i32 i32)))
 
- ;; CHECK:      (type $26 (func (param i32 i32)))
+ ;; CHECK:      (type $28 (func (result i64)))
 
- ;; CHECK:      (type $27 (func (param i32 i32 f64 f64)))
+ ;; CHECK:      (type $29 (func (param i32 i32 f64 f64)))
 
- ;; CHECK:      (type $28 (func (param i64)))
+ ;; CHECK:      (type $30 (func (param i64)))
 
- ;; CHECK:      (type $29 (func (param v128) (result i32)))
+ ;; CHECK:      (type $31 (func (param v128) (result i32)))
 
- ;; CHECK:      (type $30 (func (param v128 v128) (result v128)))
+ ;; CHECK:      (type $32 (func (param v128 v128) (result v128)))
 
- ;; CHECK:      (type $31 (func (param v128 v128 v128) (result v128)))
+ ;; CHECK:      (type $33 (func (param v128 v128 v128) (result v128)))
 
- ;; CHECK:      (type $32 (func (param i32 i32 i64 i64)))
+ ;; CHECK:      (type $34 (func (param i32 i32 i64 i64)))
 
- ;; CHECK:      (type $33 (func (param i32) (result i32)))
+ ;; CHECK:      (type $35 (func (param i32) (result i32)))
 
- ;; CHECK:      (type $34 (func (param i32 i64) (result i32 i64)))
+ ;; CHECK:      (type $36 (func (param i32 i64) (result i32 i64)))
 
- ;; CHECK:      (type $35 (func (param i64) (result i32 i64)))
+ ;; CHECK:      (type $37 (func (param i64) (result i32 i64)))
 
- ;; CHECK:      (type $36 (func (param i32) (result i32 i64)))
+ ;; CHECK:      (type $38 (func (param i32) (result i32 i64)))
 
- ;; CHECK:      (type $37 (func (param anyref) (result i32)))
+ ;; CHECK:      (type $39 (func (param anyref) (result i32)))
 
- ;; CHECK:      (type $38 (func (param eqref eqref) (result i32)))
+ ;; CHECK:      (type $40 (func (param eqref eqref) (result i32)))
 
- ;; CHECK:      (type $39 (func (param i32) (result i31ref)))
+ ;; CHECK:      (type $41 (func (param i32) (result i31ref)))
 
- ;; CHECK:      (type $40 (func (param i31ref)))
+ ;; CHECK:      (type $42 (func (param i31ref)))
 
- ;; CHECK:      (type $41 (func (param i32 i64) (result (ref $pair))))
+ ;; CHECK:      (type $43 (func (param i32 i64) (result (ref $pair))))
 
- ;; CHECK:      (type $42 (func (result (ref $pair))))
+ ;; CHECK:      (type $44 (func (result (ref $pair))))
 
- ;; CHECK:      (type $43 (func (param (ref $pair)) (result i32)))
+ ;; CHECK:      (type $45 (func (param (ref $pair)) (result i32)))
 
- ;; CHECK:      (type $44 (func (param (ref $pair)) (result i64)))
+ ;; CHECK:      (type $46 (func (param (ref $pair)) (result i64)))
 
- ;; CHECK:      (type $45 (func (param (ref $pair) i32)))
+ ;; CHECK:      (type $47 (func (param (ref $pair) i32)))
 
- ;; CHECK:      (type $46 (func (param (ref $pair) i64)))
+ ;; CHECK:      (type $48 (func (param (ref $pair) i64)))
 
- ;; CHECK:      (type $47 (func (param i64 i32) (result (ref $a1))))
+ ;; CHECK:      (type $49 (func (param i64 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $48 (func (param i32) (result (ref $a1))))
+ ;; CHECK:      (type $50 (func (param i32) (result (ref $a1))))
 
- ;; CHECK:      (type $49 (func (param i32 i32) (result (ref $a1))))
+ ;; CHECK:      (type $51 (func (param i32 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $50 (func (param (ref $a1) i32) (result i64)))
+ ;; CHECK:      (type $52 (func (param (ref $a1) i32) (result i64)))
 
- ;; CHECK:      (type $51 (func (param (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $53 (func (param (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $52 (func (param (ref $packed-i16) i32) (result i32)))
+ ;; CHECK:      (type $54 (func (param (ref $packed-i16) i32) (result i32)))
 
- ;; CHECK:      (type $53 (func (param (ref $a2) i32 f32)))
+ ;; CHECK:      (type $55 (func (param (ref $a2) i32 f32)))
 
- ;; CHECK:      (type $54 (func (param arrayref) (result i32)))
+ ;; CHECK:      (type $56 (func (param arrayref) (result i32)))
 
- ;; CHECK:      (type $55 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
+ ;; CHECK:      (type $57 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
 
- ;; CHECK:      (type $56 (func (param (ref $a2) i32 f32 i32)))
+ ;; CHECK:      (type $58 (func (param (ref $a2) i32 f32 i32)))
 
- ;; CHECK:      (type $57 (func (param (ref $a2) i32 i32 i32)))
+ ;; CHECK:      (type $59 (func (param (ref $a2) i32 i32 i32)))
 
- ;; CHECK:      (type $58 (func (param (ref $any-array) i32 i32 i32)))
+ ;; CHECK:      (type $60 (func (param (ref $any-array) i32 i32 i32)))
 
- ;; CHECK:      (type $59 (func (param externref)))
+ ;; CHECK:      (type $61 (func (param externref)))
 
- ;; CHECK:      (type $60 (func (param i32 i32) (result stringref)))
+ ;; CHECK:      (type $62 (func (param i32 i32) (result stringref)))
 
- ;; CHECK:      (type $61 (func (param (ref $packed-i8) i32 i32) (result stringref)))
+ ;; CHECK:      (type $63 (func (param (ref $packed-i8) i32 i32) (result stringref)))
 
- ;; CHECK:      (type $62 (func (param i32) (result stringref)))
+ ;; CHECK:      (type $64 (func (param i32) (result stringref)))
 
- ;; CHECK:      (type $63 (func (result (ref string))))
+ ;; CHECK:      (type $65 (func (result (ref string))))
 
- ;; CHECK:      (type $64 (func (param stringref) (result i32)))
+ ;; CHECK:      (type $66 (func (param stringref) (result i32)))
 
- ;; CHECK:      (type $65 (func (param stringview_wtf16) (result i32)))
+ ;; CHECK:      (type $67 (func (param stringview_wtf16) (result i32)))
 
- ;; CHECK:      (type $66 (func (param stringref (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $68 (func (param stringref (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $67 (func (param stringref stringref) (result (ref string))))
+ ;; CHECK:      (type $69 (func (param stringref stringref) (result (ref string))))
 
- ;; CHECK:      (type $68 (func (param stringref) (result stringview_wtf8)))
+ ;; CHECK:      (type $70 (func (param stringref) (result stringview_wtf8)))
 
- ;; CHECK:      (type $69 (func (param stringref) (result (ref stringview_wtf16))))
+ ;; CHECK:      (type $71 (func (param stringref) (result (ref stringview_wtf16))))
 
- ;; CHECK:      (type $70 (func (param stringref) (result stringview_iter)))
+ ;; CHECK:      (type $72 (func (param stringref) (result stringview_iter)))
 
- ;; CHECK:      (type $71 (func (param (ref stringview_wtf8) i32 i32) (result i32)))
+ ;; CHECK:      (type $73 (func (param (ref stringview_wtf8) i32 i32) (result i32)))
 
- ;; CHECK:      (type $72 (func (param stringview_wtf16 i32) (result i32)))
+ ;; CHECK:      (type $74 (func (param stringview_wtf16 i32) (result i32)))
 
- ;; CHECK:      (type $73 (func (param stringview_iter) (result i32)))
+ ;; CHECK:      (type $75 (func (param stringview_iter) (result i32)))
 
- ;; CHECK:      (type $74 (func (param stringview_iter i32) (result i32)))
+ ;; CHECK:      (type $76 (func (param stringview_iter i32) (result i32)))
 
- ;; CHECK:      (type $75 (func (param (ref stringview_iter) i32) (result i32)))
+ ;; CHECK:      (type $77 (func (param (ref stringview_iter) i32) (result i32)))
 
- ;; CHECK:      (type $76 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))
+ ;; CHECK:      (type $78 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))
 
- ;; CHECK:      (type $77 (func (param stringview_iter i32) (result (ref string))))
+ ;; CHECK:      (type $79 (func (param stringview_iter i32) (result (ref string))))
 
  ;; CHECK:      (type $s2 (struct (field i32)))
  (type $s2 (struct i32))
@@ -212,7 +216,7 @@
 
  ;; imported memories
  (memory (export "mem") (export "mem2") (import "" "mem") 0)
- ;; CHECK:      (type $88 (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))))
+ ;; CHECK:      (type $90 (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))))
 
  ;; CHECK:      (import "" "mem" (memory $mimport$0 0))
 
@@ -856,7 +860,7 @@
   drop
  )
 
- ;; CHECK:      (func $locals (type $26) (param $0 i32) (param $x i32)
+ ;; CHECK:      (func $locals (type $27) (param $0 i32) (param $x i32)
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (drop
@@ -2522,6 +2526,82 @@
   br 0
  )
 
+ ;; CHECK:      (func $br_if (type $void)
+ ;; CHECK-NEXT:  (block $l
+ ;; CHECK-NEXT:   (br_if $l
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $br_if
+  block $l
+   i32.const 0
+   br_if $l
+  end
+ )
+
+ ;; CHECK:      (func $br_if-index (type $void)
+ ;; CHECK-NEXT:  (block $label
+ ;; CHECK-NEXT:   (br_if $label
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $br_if-index
+  block
+   i32.const 0
+   br_if 0
+  end
+ )
+
+ ;; CHECK:      (func $br_if-return (type $void)
+ ;; CHECK-NEXT:  (block $label
+ ;; CHECK-NEXT:   (br_if $label
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $br_if-return
+  i32.const 0
+  br_if 0
+ )
+
+ ;; CHECK:      (func $br_if-value (type $28) (result i64)
+ ;; CHECK-NEXT:  (block $l (result i64)
+ ;; CHECK-NEXT:   (br_if $l
+ ;; CHECK-NEXT:    (i64.const 0)
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $br_if-value (result i64)
+  block $l (result i64)
+   i64.const 0
+   i32.const 1
+   br_if $l
+  end
+ )
+
+ ;; CHECK:      (func $br_if-multivalue (type $17) (result i64 f32)
+ ;; CHECK-NEXT:  (block $l (type $17) (result i64 f32)
+ ;; CHECK-NEXT:   (br_if $l
+ ;; CHECK-NEXT:    (tuple.make 2
+ ;; CHECK-NEXT:     (i64.const 0)
+ ;; CHECK-NEXT:     (f32.const 1)
+ ;; CHECK-NEXT:    )
+ ;; CHECK-NEXT:    (i32.const 2)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $br_if-multivalue (result i64 f32)
+  block $l (result i64 f32)
+   i64.const 0
+   f32.const 1
+   i32.const 2
+   br_if $l
+  end
+ )
+
  ;; CHECK:      (func $br-table (type $void)
  ;; CHECK-NEXT:  (block $a
  ;; CHECK-NEXT:   (block $b
@@ -2631,7 +2711,7 @@
  )
 
 
- ;; CHECK:      (func $binary (type $27) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
+ ;; CHECK:      (func $binary (type $29) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $0)
@@ -2656,7 +2736,7 @@
   drop
  )
 
- ;; CHECK:      (func $unary (type $28) (param $0 i64)
+ ;; CHECK:      (func $unary (type $30) (param $0 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.eqz
  ;; CHECK-NEXT:    (local.get $0)
@@ -2669,7 +2749,7 @@
   drop
  )
 
- ;; CHECK:      (func $select (type $17) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $select (type $18) (param $0 i32) (param $1 i32) (param $2 i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (select
  ;; CHECK-NEXT:    (local.get $0)
@@ -2951,7 +3031,7 @@
   atomic.fence
  )
 
- ;; CHECK:      (func $simd-extract (type $29) (param $0 v128) (result i32)
+ ;; CHECK:      (func $simd-extract (type $31) (param $0 v128) (result i32)
  ;; CHECK-NEXT:  (i32x4.extract_lane 3
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2961,7 +3041,7 @@
   i32x4.extract_lane 3
  )
 
- ;; CHECK:      (func $simd-replace (type $18) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-replace (type $19) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i32x4.replace_lane 2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -2973,7 +3053,7 @@
   i32x4.replace_lane 2
  )
 
- ;; CHECK:      (func $simd-shuffle (type $30) (param $0 v128) (param $1 v128) (result v128)
+ ;; CHECK:      (func $simd-shuffle (type $32) (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)
@@ -2985,7 +3065,7 @@
   i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
  )
 
- ;; CHECK:      (func $simd-ternary (type $31) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ ;; CHECK:      (func $simd-ternary (type $33) (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)
@@ -2999,7 +3079,7 @@
   v128.bitselect
  )
 
- ;; CHECK:      (func $simd-shift (type $18) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-shift (type $19) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i8x16.shl
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3054,7 +3134,7 @@
   v128.store64_lane 5 align=4 0
  )
 
- ;; CHECK:      (func $memory-init (type $17) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $memory-init (type $18) (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)
@@ -3095,7 +3175,7 @@
   data.drop $passive
  )
 
- ;; CHECK:      (func $memory-copy (type $32) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64)
+ ;; CHECK:      (func $memory-copy (type $34) (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)
@@ -3166,7 +3246,7 @@
   return
  )
 
- ;; CHECK:      (func $return-one (type $33) (param $0 i32) (result i32)
+ ;; CHECK:      (func $return-one (type $35) (param $0 i32) (result i32)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3176,7 +3256,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two (type $34) (param $0 i32) (param $1 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two (type $36) (param $0 i32) (param $1 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (local.get $0)
@@ -3190,7 +3270,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-first-unreachable (type $35) (param $0 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two-first-unreachable (type $37) (param $0 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (unreachable)
@@ -3204,7 +3284,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-second-unreachable (type $36) (param $0 i32) (result i32 i64)
+ ;; CHECK:      (func $return-two-second-unreachable (type $38) (param $0 i32) (result i32 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3221,7 +3301,7 @@
   return
  )
 
- ;; CHECK:      (func $ref-is-null (type $37) (param $0 anyref) (result i32)
+ ;; CHECK:      (func $ref-is-null (type $39) (param $0 anyref) (result i32)
  ;; CHECK-NEXT:  (ref.is_null
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3242,7 +3322,7 @@
  (func $ref-func
   ref.func $ref-func
   drop
-  ref.func 135
+  ref.func 140
   drop
  )
 
@@ -3265,7 +3345,7 @@
   throw $tag-pair
  )
 
- ;; CHECK:      (func $ref-eq (type $38) (param $0 eqref) (param $1 eqref) (result i32)
+ ;; CHECK:      (func $ref-eq (type $40) (param $0 eqref) (param $1 eqref) (result i32)
  ;; CHECK-NEXT:  (ref.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3442,7 +3522,7 @@
   table.copy 2 $funcs
  )
 
- ;; CHECK:      (func $i31-new (type $39) (param $0 i32) (result i31ref)
+ ;; CHECK:      (func $i31-new (type $41) (param $0 i32) (result i31ref)
  ;; CHECK-NEXT:  (ref.i31
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3452,7 +3532,7 @@
   ref.i31
  )
 
- ;; CHECK:      (func $i31-get (type $40) (param $0 i31ref)
+ ;; CHECK:      (func $i31-get (type $42) (param $0 i31ref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i31.get_s
  ;; CHECK-NEXT:    (local.get $0)
@@ -3671,7 +3751,7 @@
   drop
  )
 
- ;; CHECK:      (func $struct-new (type $41) (param $0 i32) (param $1 i64) (result (ref $pair))
+ ;; CHECK:      (func $struct-new (type $43) (param $0 i32) (param $1 i64) (result (ref $pair))
  ;; CHECK-NEXT:  (struct.new $pair
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3683,14 +3763,14 @@
   struct.new $pair
  )
 
- ;; CHECK:      (func $struct-new-default (type $42) (result (ref $pair))
+ ;; CHECK:      (func $struct-new-default (type $44) (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 $43) (param $0 (ref $pair)) (result i32)
+ ;; CHECK:      (func $struct-get-0 (type $45) (param $0 (ref $pair)) (result i32)
  ;; CHECK-NEXT:  (struct.get $pair 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3700,7 +3780,7 @@
   struct.get 14 0
  )
 
- ;; CHECK:      (func $struct-get-1 (type $44) (param $0 (ref $pair)) (result i64)
+ ;; CHECK:      (func $struct-get-1 (type $46) (param $0 (ref $pair)) (result i64)
  ;; CHECK-NEXT:  (struct.get $pair 1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3710,7 +3790,7 @@
   struct.get $pair 1
  )
 
- ;; CHECK:      (func $struct-set-0 (type $45) (param $0 (ref $pair)) (param $1 i32)
+ ;; CHECK:      (func $struct-set-0 (type $47) (param $0 (ref $pair)) (param $1 i32)
  ;; CHECK-NEXT:  (struct.set $pair 0
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3722,7 +3802,7 @@
   struct.set $pair 0
  )
 
- ;; CHECK:      (func $struct-set-1 (type $46) (param $0 (ref $pair)) (param $1 i64)
+ ;; CHECK:      (func $struct-set-1 (type $48) (param $0 (ref $pair)) (param $1 i64)
  ;; CHECK-NEXT:  (struct.set $pair 1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3734,7 +3814,7 @@
   struct.set 14 1
  )
 
- ;; CHECK:      (func $array-new (type $47) (param $0 i64) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new (type $49) (param $0 i64) (param $1 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3746,7 +3826,7 @@
   array.new $a1
  )
 
- ;; CHECK:      (func $array-new-default (type $48) (param $0 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-default (type $50) (param $0 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new_default $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3756,7 +3836,7 @@
   array.new_default 11
  )
 
- ;; CHECK:      (func $array-new-data (type $49) (param $0 i32) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-data (type $51) (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)
@@ -3790,7 +3870,7 @@
   drop
  )
 
- ;; CHECK:      (func $array-get (type $50) (param $0 (ref $a1)) (param $1 i32) (result i64)
+ ;; CHECK:      (func $array-get (type $52) (param $0 (ref $a1)) (param $1 i32) (result i64)
  ;; CHECK-NEXT:  (array.get $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3802,7 +3882,7 @@
   array.get $a1
  )
 
- ;; CHECK:      (func $array-get-s (type $51) (param $0 (ref $packed-i8)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-s (type $53) (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)
@@ -3814,7 +3894,7 @@
   array.get_s 15
  )
 
- ;; CHECK:      (func $array-get-u (type $52) (param $0 (ref $packed-i16)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-u (type $54) (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)
@@ -3826,7 +3906,7 @@
   array.get_u $packed-i16
  )
 
- ;; CHECK:      (func $array-set (type $53) (param $0 (ref $a2)) (param $1 i32) (param $2 f32)
+ ;; CHECK:      (func $array-set (type $55) (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)
@@ -3840,7 +3920,7 @@
   array.set $a2
  )
 
- ;; CHECK:      (func $array-len (type $54) (param $0 arrayref) (result i32)
+ ;; CHECK:      (func $array-len (type $56) (param $0 arrayref) (result i32)
  ;; CHECK-NEXT:  (array.len
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3850,7 +3930,7 @@
   array.len
  )
 
- ;; CHECK:      (func $array-copy (type $55) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32)
+ ;; CHECK:      (func $array-copy (type $57) (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)
@@ -3868,7 +3948,7 @@
   array.copy $a2 $a2
  )
 
- ;; CHECK:      (func $array-fill (type $56) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32)
+ ;; CHECK:      (func $array-fill (type $58) (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)
@@ -3884,7 +3964,7 @@
   array.fill $a2
  )
 
- ;; CHECK:      (func $array-init-data (type $57) (param $0 (ref $a2)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $array-init-data (type $59) (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)
@@ -3900,7 +3980,7 @@
   array.init_data $a2 0
  )
 
- ;; CHECK:      (func $array-init-elem (type $58) (param $0 (ref $any-array)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $array-init-elem (type $60) (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)
@@ -3929,7 +4009,7 @@
   drop
  )
 
- ;; CHECK:      (func $any-convert-extern (type $59) (param $0 externref)
+ ;; CHECK:      (func $any-convert-extern (type $61) (param $0 externref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (extern.internalize
  ;; CHECK-NEXT:    (local.get $0)
@@ -3955,7 +4035,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-new (type $60) (param $0 i32) (param $1 i32) (result stringref)
+ ;; CHECK:      (func $string-new (type $62) (param $0 i32) (param $1 i32) (result stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.new_utf8_try
  ;; CHECK-NEXT:    (local.get $0)
@@ -3997,7 +4077,7 @@
   string.new_wtf16
  )
 
- ;; CHECK:      (func $string-new-gc (type $61) (param $0 (ref $packed-i8)) (param $1 i32) (param $2 i32) (result stringref)
+ ;; CHECK:      (func $string-new-gc (type $63) (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)
@@ -4011,7 +4091,7 @@
   string.new_utf8_array
  )
 
- ;; CHECK:      (func $string-new-code-point (type $62) (param $0 i32) (result stringref)
+ ;; CHECK:      (func $string-new-code-point (type $64) (param $0 i32) (result stringref)
  ;; CHECK-NEXT:  (string.from_code_point
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4021,7 +4101,7 @@
   string.from_code_point
  )
 
- ;; CHECK:      (func $string-const (type $63) (result (ref string))
+ ;; CHECK:      (func $string-const (type $65) (result (ref string))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.const "foobar")
  ;; CHECK-NEXT:  )
@@ -4033,7 +4113,7 @@
   string.const "\00\00\00"
  )
 
- ;; CHECK:      (func $string-measure (type $21) (param $0 stringref)
+ ;; CHECK:      (func $string-measure (type $22) (param $0 stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.measure_wtf8
  ;; CHECK-NEXT:    (local.get $0)
@@ -4070,7 +4150,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-hash (type $64) (param $0 stringref) (result i32)
+ ;; CHECK:      (func $string-hash (type $66) (param $0 stringref) (result i32)
  ;; CHECK-NEXT:  (string.hash
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4080,7 +4160,7 @@
   string.hash
  )
 
- ;; CHECK:      (func $stringview-length (type $65) (param $0 stringview_wtf16) (result i32)
+ ;; CHECK:      (func $stringview-length (type $67) (param $0 stringview_wtf16) (result i32)
  ;; CHECK-NEXT:  (stringview_wtf16.length
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4090,7 +4170,7 @@
   stringview_wtf16.length
  )
 
- ;; CHECK:      (func $string-encode (type $21) (param $0 stringref)
+ ;; CHECK:      (func $string-encode (type $22) (param $0 stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.encode_wtf8
  ;; CHECK-NEXT:    (local.get $0)
@@ -4135,7 +4215,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-encode-gc (type $66) (param $0 stringref) (param $1 (ref $packed-i8)) (param $2 i32) (result i32)
+ ;; CHECK:      (func $string-encode-gc (type $68) (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)
@@ -4149,7 +4229,7 @@
   string.encode_wtf8_array
  )
 
- ;; CHECK:      (func $string-concat (type $67) (param $0 stringref) (param $1 stringref) (result (ref string))
+ ;; CHECK:      (func $string-concat (type $69) (param $0 stringref) (param $1 stringref) (result (ref string))
  ;; CHECK-NEXT:  (string.concat
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4161,7 +4241,7 @@
   string.concat
  )
 
- ;; CHECK:      (func $string-eq (type $22) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK:      (func $string-eq (type $23) (param $0 stringref) (param $1 stringref) (result i32)
  ;; CHECK-NEXT:  (string.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4173,7 +4253,7 @@
   string.eq
  )
 
- ;; CHECK:      (func $string-compare (type $22) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK:      (func $string-compare (type $23) (param $0 stringref) (param $1 stringref) (result i32)
  ;; CHECK-NEXT:  (string.compare
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4185,7 +4265,7 @@
   string.compare
  )
 
- ;; CHECK:      (func $string-as-wtf8 (type $68) (param $0 stringref) (result stringview_wtf8)
+ ;; CHECK:      (func $string-as-wtf8 (type $70) (param $0 stringref) (result stringview_wtf8)
  ;; CHECK-NEXT:  (string.as_wtf8
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4195,7 +4275,7 @@
   string.as_wtf8
  )
 
- ;; CHECK:      (func $string-as-wtf16 (type $69) (param $0 stringref) (result (ref stringview_wtf16))
+ ;; CHECK:      (func $string-as-wtf16 (type $71) (param $0 stringref) (result (ref stringview_wtf16))
  ;; CHECK-NEXT:  (string.as_wtf16
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4205,7 +4285,7 @@
   string.as_wtf16
  )
 
- ;; CHECK:      (func $string-as-iter (type $70) (param $0 stringref) (result stringview_iter)
+ ;; CHECK:      (func $string-as-iter (type $72) (param $0 stringref) (result stringview_iter)
  ;; CHECK-NEXT:  (string.as_iter
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4215,7 +4295,7 @@
   string.as_iter
  )
 
- ;; CHECK:      (func $string-advance (type $71) (param $0 (ref stringview_wtf8)) (param $1 i32) (param $2 i32) (result i32)
+ ;; CHECK:      (func $string-advance (type $73) (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)
@@ -4229,7 +4309,7 @@
   stringview_wtf8.advance
  )
 
- ;; CHECK:      (func $string-get (type $72) (param $0 stringview_wtf16) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-get (type $74) (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)
@@ -4241,7 +4321,7 @@
   stringview_wtf16.get_codeunit
  )
 
- ;; CHECK:      (func $string-iter-next (type $73) (param $0 stringview_iter) (result i32)
+ ;; CHECK:      (func $string-iter-next (type $75) (param $0 stringview_iter) (result i32)
  ;; CHECK-NEXT:  (stringview_iter.next
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4251,7 +4331,7 @@
   stringview_iter.next
  )
 
- ;; CHECK:      (func $string-iter-advance (type $74) (param $0 stringview_iter) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-iter-advance (type $76) (param $0 stringview_iter) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (stringview_iter.advance
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4263,7 +4343,7 @@
   stringview_iter.advance
  )
 
- ;; CHECK:      (func $string-iter-rewind (type $75) (param $0 (ref stringview_iter)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-iter-rewind (type $77) (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)
@@ -4275,7 +4355,7 @@
   stringview_iter.rewind
  )
 
- ;; CHECK:      (func $string-slice (type $76) (param $0 stringview_wtf8) (param $1 stringview_wtf16) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $string-slice (type $78) (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)
@@ -4304,7 +4384,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-iter-slice (type $77) (param $0 stringview_iter) (param $1 i32) (result (ref string))
+ ;; CHECK:      (func $string-iter-slice (type $79) (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)
@@ -4316,7 +4396,7 @@
   stringview_iter.slice
  )
 
- ;; CHECK:      (func $call (type $23) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $call (type $24) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (call $call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4328,7 +4408,7 @@
   call $call
  )
 
- ;; CHECK:      (func $return_call (type $23) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $return_call (type $24) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (return_call $return_call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4369,7 +4449,7 @@
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (call_indirect $timport$0 (type $24)
+ ;; CHECK-NEXT:   (call_indirect $timport$0 (type $25)
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:    (local.get $0)
@@ -4431,7 +4511,7 @@
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (call_indirect $timport$0 (type $24)
+ ;; CHECK-NEXT:   (call_indirect $timport$0 (type $25)
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:    (local.get $0)
@@ -4503,7 +4583,7 @@
  ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $25)
+ ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $26)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $0)
@@ -4562,7 +4642,7 @@
  ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $25)
+ ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $26)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $0)
@@ -4603,7 +4683,7 @@
   )
  )
 
- ;; CHECK:      (func $use-types (type $88) (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))
+ ;; CHECK:      (func $use-types (type $90) (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))
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )
  (func $use-types