[Parser] Pop past unreachables where possible (#6489)

We previously would eagerly drop all concretely typed expressions on the stack
when pushing an unreachable instruction. This was semantically correct and
closely modeled the semantics of unreachable instructions, which implicitly drop
the entire stack and start a new polymorphic stack. However, it also meant that
the structure of the parsed IR did not match the structure of the folded input,
which meant that tests involving unreachable children would not parse as
intended, preventing the test from testing the intended behavior.

For example, this wat:

```wasm
  (i32.add
   (i32.const 0)
   (unreachable)
  )
```

Would previously parse into this IR:

```wasm
  (drop
   (i32.const 0)
  )
  (i32.add
   (unreachable)
   (unreachable)
  )
```

To fix this problem, we need to stop eagerly dropping stack values when
encountering an unreachable instruction so we can still pop expressions pushed
before the unreachable as direct children of later instructions. In the example
above, we need to keep the `i32.const 0` on the stack so it is available to be
popped and become a child of the `i32.add`.

However, the naive solution of simply popping past unreachables would produce
invalid IR in some cases. For example, consider this wat:

```wasm
  f32.const 0
  unreachable
  i32.add
```

The naive solution would parse this wat into this IR:

```wasm
  (i32.add
   (f32.const 0)
   (unreachable)
  )
```

But we do not want to parse an `i32.add` with an `f32`-typed child. Neither do
we want to reject this input, since it is a perfectly valid Wasm fragment. In this
case, we actually want the old behavior of dropping the `f32.const` and
replacing it with another `unreachable` as the first child of the `i32.add`.

To both match the input structure where possible and also gracefully fall back
to the old behavior of dropping expressions prior to the unreachable, collect
constraints on the types of each child for each kind of expression and compare
them to the types of available expressions on the stack when an unreachable
instruction will be popped. When the constraints are satisfied, pop expressions
normally, even after popping the unreachable instruction. Otherwise, drop the
instructions that precede the unreachable instruction to ensure we parse valid
IR.

To collect the constraints, add a new `ChildTyper` utility that calls a
different callback for each kind of possible type constraint for each child. In
the future, this utility can be used to simplify the validator as well.

1 files changed, 190 insertions, 146 deletions

diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
index 10c58b603..eca4e0c8a 100644
--- a/test/lit/wat-kitchen-sink.wast
+++ b/test/lit/wat-kitchen-sink.wast
@@ -62,141 +62,147 @@
 
  ;; CHECK:      (type $24 (func (param v128 i32) (result v128)))
 
+ ;; CHECK:      (type $25 (func (param i32) (result i32 i64)))
+
  ;; CHECK:      (type $packed-i16 (array (mut i16)))
 
  ;; CHECK:      (type $any-array (array (mut anyref)))
 
- ;; CHECK:      (type $27 (func (param stringref)))
+ ;; CHECK:      (type $28 (func (param stringref)))
 
- ;; CHECK:      (type $28 (func (param stringref stringref) (result i32)))
+ ;; CHECK:      (type $29 (func (param stringref stringref) (result i32)))
 
- ;; CHECK:      (type $29 (func (param i64 v128) (result v128)))
+ ;; CHECK:      (type $30 (func (param i64 v128) (result v128)))
 
- ;; CHECK:      (type $30 (func (param i64 v128)))
+ ;; CHECK:      (type $31 (func (param i64 v128)))
 
  ;; CHECK:      (type $cont-bind-before-func (func (param i32 i64 i32 i64) (result f32)))
 
  ;; CHECK:      (type $cont-bind-before (cont $cont-bind-before-func))
 
- ;; CHECK:      (type $33 (func (result i32 i64 (ref null $simple-cont))))
+ ;; CHECK:      (type $34 (func (result structref arrayref)))
+
+ ;; CHECK:      (type $35 (func (result arrayref structref)))
 
- ;; CHECK:      (type $34 (func (param i32 i32)))
+ ;; CHECK:      (type $36 (func (result i32 i64 (ref null $simple-cont))))
 
- ;; CHECK:      (type $35 (func (param exnref)))
+ ;; CHECK:      (type $37 (func (param i32 i32)))
 
- ;; CHECK:      (type $36 (func (param i32 i32 f64 f64)))
+ ;; CHECK:      (type $38 (func (param exnref)))
 
- ;; CHECK:      (type $37 (func (param i64)))
+ ;; CHECK:      (type $39 (func (result anyref anyref)))
 
- ;; CHECK:      (type $38 (func (param v128) (result i32)))
+ ;; CHECK:      (type $40 (func (param i32 i32 f64 f64)))
 
- ;; CHECK:      (type $39 (func (param v128 v128) (result v128)))
+ ;; CHECK:      (type $41 (func (param i64)))
 
- ;; CHECK:      (type $40 (func (param v128 v128 v128) (result v128)))
+ ;; CHECK:      (type $42 (func (param v128) (result i32)))
 
- ;; CHECK:      (type $41 (func (param i32 i32 i64 i64)))
+ ;; CHECK:      (type $43 (func (param v128 v128) (result v128)))
 
- ;; CHECK:      (type $42 (func (param i32) (result i32)))
+ ;; CHECK:      (type $44 (func (param v128 v128 v128) (result v128)))
 
- ;; CHECK:      (type $43 (func (param i64) (result i32 i64)))
+ ;; CHECK:      (type $45 (func (param i32 i32 i64 i64)))
 
- ;; CHECK:      (type $44 (func (param i32) (result i32 i64)))
+ ;; CHECK:      (type $46 (func (param i32) (result i32)))
 
- ;; CHECK:      (type $45 (func (param anyref) (result i32)))
+ ;; CHECK:      (type $47 (func (param i64) (result i32 i64)))
 
- ;; CHECK:      (type $46 (func (param eqref eqref) (result i32)))
+ ;; CHECK:      (type $48 (func (param anyref) (result i32)))
 
- ;; CHECK:      (type $47 (func (param i32) (result i31ref)))
+ ;; CHECK:      (type $49 (func (param eqref eqref) (result i32)))
 
- ;; CHECK:      (type $48 (func (param i31ref)))
+ ;; CHECK:      (type $50 (func (param i32) (result i31ref)))
 
- ;; CHECK:      (type $49 (func (param i32 i64) (result (ref $pair))))
+ ;; CHECK:      (type $51 (func (param i31ref)))
 
- ;; CHECK:      (type $50 (func (result (ref $pair))))
+ ;; CHECK:      (type $52 (func (param i32 i64) (result (ref $pair))))
 
- ;; CHECK:      (type $51 (func (param (ref $pair)) (result i32)))
+ ;; CHECK:      (type $53 (func (result (ref $pair))))
 
- ;; CHECK:      (type $52 (func (param (ref $pair)) (result i64)))
+ ;; CHECK:      (type $54 (func (param (ref $pair)) (result i32)))
 
- ;; CHECK:      (type $53 (func (param (ref null $pair)) (result i32)))
+ ;; CHECK:      (type $55 (func (param (ref $pair)) (result i64)))
 
- ;; CHECK:      (type $54 (func (param (ref $pair) i32)))
+ ;; CHECK:      (type $56 (func (param (ref null $pair)) (result i32)))
 
- ;; CHECK:      (type $55 (func (param (ref $pair) i64)))
+ ;; CHECK:      (type $57 (func (param (ref $pair) i32)))
 
- ;; CHECK:      (type $56 (func (param (ref null $pair) i64)))
+ ;; CHECK:      (type $58 (func (param (ref $pair) i64)))
 
- ;; CHECK:      (type $57 (func (param i64 i32) (result (ref $a1))))
+ ;; CHECK:      (type $59 (func (param (ref null $pair) i64)))
 
- ;; CHECK:      (type $58 (func (param i32) (result (ref $a1))))
+ ;; CHECK:      (type $60 (func (param i64 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $59 (func (param i32 i32) (result (ref $a1))))
+ ;; CHECK:      (type $61 (func (param i32) (result (ref $a1))))
 
- ;; CHECK:      (type $60 (func (param (ref $a1) i32) (result i64)))
+ ;; CHECK:      (type $62 (func (param i32 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $61 (func (param (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $63 (func (param (ref $a1) i32) (result i64)))
 
- ;; CHECK:      (type $62 (func (param (ref $packed-i16) i32) (result i32)))
+ ;; CHECK:      (type $64 (func (param (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $63 (func (param (ref $a2) i32 f32)))
+ ;; CHECK:      (type $65 (func (param (ref $packed-i16) i32) (result i32)))
 
- ;; CHECK:      (type $64 (func (param arrayref) (result i32)))
+ ;; CHECK:      (type $66 (func (param (ref $a2) i32 f32)))
 
- ;; CHECK:      (type $65 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
+ ;; CHECK:      (type $67 (func (param arrayref) (result i32)))
 
- ;; CHECK:      (type $66 (func (param (ref $a2) i32 f32 i32)))
+ ;; CHECK:      (type $68 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
 
- ;; CHECK:      (type $67 (func (param (ref $a2) i32 i32 i32)))
+ ;; CHECK:      (type $69 (func (param (ref $a2) i32 f32 i32)))
 
- ;; CHECK:      (type $68 (func (param (ref $any-array) i32 i32 i32)))
+ ;; CHECK:      (type $70 (func (param (ref $a2) i32 i32 i32)))
 
- ;; CHECK:      (type $69 (func (param externref)))
+ ;; CHECK:      (type $71 (func (param (ref $any-array) i32 i32 i32)))
 
- ;; CHECK:      (type $70 (func (param i32 i32) (result stringref)))
+ ;; CHECK:      (type $72 (func (param externref)))
 
- ;; CHECK:      (type $71 (func (param (ref $packed-i8) i32 i32) (result stringref)))
+ ;; CHECK:      (type $73 (func (param i32 i32) (result stringref)))
 
- ;; CHECK:      (type $72 (func (param i32) (result stringref)))
+ ;; CHECK:      (type $74 (func (param (ref $packed-i8) i32 i32) (result stringref)))
 
- ;; CHECK:      (type $73 (func (result (ref string))))
+ ;; CHECK:      (type $75 (func (param i32) (result stringref)))
 
- ;; CHECK:      (type $74 (func (param stringref) (result i32)))
+ ;; CHECK:      (type $76 (func (result (ref string))))
 
- ;; CHECK:      (type $75 (func (param stringview_wtf16) (result i32)))
+ ;; CHECK:      (type $77 (func (param stringref) (result i32)))
 
- ;; CHECK:      (type $76 (func (param stringref (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $78 (func (param stringview_wtf16) (result i32)))
 
- ;; CHECK:      (type $77 (func (param stringref stringref) (result (ref string))))
+ ;; CHECK:      (type $79 (func (param stringref (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $78 (func (param stringref) (result stringview_wtf8)))
+ ;; CHECK:      (type $80 (func (param stringref stringref) (result (ref string))))
 
- ;; CHECK:      (type $79 (func (param stringref) (result (ref stringview_wtf16))))
+ ;; CHECK:      (type $81 (func (param stringref) (result stringview_wtf8)))
 
- ;; CHECK:      (type $80 (func (param stringref) (result stringview_iter)))
+ ;; CHECK:      (type $82 (func (param stringref) (result (ref stringview_wtf16))))
 
- ;; CHECK:      (type $81 (func (param (ref stringview_wtf8) i32 i32) (result i32)))
+ ;; CHECK:      (type $83 (func (param stringref) (result stringview_iter)))
 
- ;; CHECK:      (type $82 (func (param stringview_wtf16 i32) (result i32)))
+ ;; CHECK:      (type $84 (func (param (ref stringview_wtf8) i32 i32) (result i32)))
 
- ;; CHECK:      (type $83 (func (param stringview_iter) (result i32)))
+ ;; CHECK:      (type $85 (func (param stringview_wtf16 i32) (result i32)))
 
- ;; CHECK:      (type $84 (func (param stringview_iter i32) (result i32)))
+ ;; CHECK:      (type $86 (func (param stringview_iter) (result i32)))
 
- ;; CHECK:      (type $85 (func (param (ref stringview_iter) i32) (result i32)))
+ ;; CHECK:      (type $87 (func (param stringview_iter i32) (result i32)))
 
- ;; CHECK:      (type $86 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))
+ ;; CHECK:      (type $88 (func (param (ref stringview_iter) i32) (result i32)))
 
- ;; CHECK:      (type $87 (func (param stringview_iter i32) (result (ref string))))
+ ;; CHECK:      (type $89 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))
 
- ;; CHECK:      (type $88 (func (param (ref $simple-cont))))
+ ;; CHECK:      (type $90 (func (param stringview_iter i32) (result (ref string))))
+
+ ;; CHECK:      (type $91 (func (param (ref $simple-cont))))
 
  ;; CHECK:      (type $to-f32 (func (result f32)))
 
  ;; CHECK:      (type $to-f32-cont (cont $to-f32))
 
- ;; CHECK:      (type $91 (func (param (ref $simple)) (result (ref $simple-cont))))
+ ;; CHECK:      (type $94 (func (param (ref $simple)) (result (ref $simple-cont))))
 
- ;; CHECK:      (type $92 (func (param (ref $cont-bind-before)) (result (ref $simple-cont))))
+ ;; CHECK:      (type $95 (func (param (ref $cont-bind-before)) (result (ref $simple-cont))))
 
  ;; CHECK:      (type $s2 (struct (field i32)))
  (type $s2 (struct i32))
@@ -272,7 +278,7 @@
 
  ;; imported memories
  (memory (export "mem") (export "mem2") (import "" "mem") 0)
- ;; CHECK:      (type $104 (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 $107 (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))
 
@@ -424,7 +430,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 $table-fill $table-grow $table-set)
+ ;; CHECK:      (elem declare func $ref-func $ref-is-null $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)))
@@ -714,11 +720,8 @@
  )
 
  ;; CHECK:      (func $add-unreachable-2 (type $1) (result i32)
- ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (i32.const 1)
- ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (i32.add
- ;; CHECK-NEXT:   (unreachable)
+ ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
@@ -823,17 +826,16 @@
  )
 
  ;; CHECK:      (func $add-twice-unreachable (type $ret2) (result i32 i32)
- ;; CHECK-NEXT:  (i32.add
- ;; CHECK-NEXT:   (unreachable)
- ;; CHECK-NEXT:   (i32.const 2)
- ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:  (tuple.make 2
+ ;; CHECK-NEXT:   (i32.add
+ ;; CHECK-NEXT:    (unreachable)
+ ;; CHECK-NEXT:    (i32.const 2)
+ ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (i32.const 3)
  ;; CHECK-NEXT:    (i32.const 4)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $add-twice-unreachable (type $ret2)
   unreachable
@@ -851,14 +853,13 @@
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (unreachable)
- ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:  (tuple.make 2
+ ;; CHECK-NEXT:   (unreachable)
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (i32.const 3)
  ;; CHECK-NEXT:    (i32.const 4)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $add-twice-unreachable-2 (type $ret2)
   i32.const 1
@@ -949,7 +950,7 @@
   drop
  )
 
- ;; CHECK:      (func $locals (type $34) (param $0 i32) (param $x i32)
+ ;; CHECK:      (func $locals (type $37) (param $0 i32) (param $x i32)
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (drop
@@ -2602,7 +2603,7 @@
   )
  )
 
- ;; CHECK:      (func $try-table-throw-ref (type $35) (param $0 exnref)
+ ;; CHECK:      (func $try-table-throw-ref (type $38) (param $0 exnref)
  ;; CHECK-NEXT:  (throw_ref
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2998,6 +2999,34 @@
   end
  )
 
+ ;; CHECK:      (func $br-table-multivalue-glb (type $39) (result anyref anyref)
+ ;; CHECK-NEXT:  (block $a (type $35) (result arrayref structref)
+ ;; CHECK-NEXT:   (return
+ ;; CHECK-NEXT:    (block $b (type $34) (result structref arrayref)
+ ;; CHECK-NEXT:     (br_table $a $b
+ ;; CHECK-NEXT:      (tuple.make 2
+ ;; CHECK-NEXT:       (ref.null none)
+ ;; CHECK-NEXT:       (ref.null none)
+ ;; CHECK-NEXT:      )
+ ;; CHECK-NEXT:      (unreachable)
+ ;; CHECK-NEXT:     )
+ ;; CHECK-NEXT:    )
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $br-table-multivalue-glb (result anyref anyref)
+  block $a (result arrayref structref)
+   block $b (result structref arrayref)
+    ref.null none
+    ref.null none
+    tuple.make 2
+    unreachable
+    br_table $a $b
+   end
+   return
+  end
+ )
+
  ;; CHECK:      (func $br-table-loop (type $1) (result i32)
  ;; CHECK-NEXT:  (loop $a (result i32)
  ;; CHECK-NEXT:   (loop $b (result i32)
@@ -3020,7 +3049,7 @@
   end
  )
 
- ;; CHECK:      (func $binary (type $36) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
+ ;; CHECK:      (func $binary (type $40) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $0)
@@ -3045,7 +3074,7 @@
   drop
  )
 
- ;; CHECK:      (func $unary (type $37) (param $0 i64)
+ ;; CHECK:      (func $unary (type $41) (param $0 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.eqz
  ;; CHECK-NEXT:    (local.get $0)
@@ -3394,7 +3423,7 @@
   drop
  )
 
- ;; CHECK:      (func $simd-extract (type $38) (param $0 v128) (result i32)
+ ;; CHECK:      (func $simd-extract (type $42) (param $0 v128) (result i32)
  ;; CHECK-NEXT:  (i32x4.extract_lane 3
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3416,7 +3445,7 @@
   i32x4.replace_lane 2
  )
 
- ;; CHECK:      (func $simd-shuffle (type $39) (param $0 v128) (param $1 v128) (result v128)
+ ;; CHECK:      (func $simd-shuffle (type $43) (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)
@@ -3428,7 +3457,7 @@
   i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
  )
 
- ;; CHECK:      (func $simd-ternary (type $40) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ ;; CHECK:      (func $simd-ternary (type $44) (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)
@@ -3538,7 +3567,7 @@
   data.drop $passive
  )
 
- ;; CHECK:      (func $memory-copy (type $41) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64)
+ ;; CHECK:      (func $memory-copy (type $45) (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)
@@ -3609,7 +3638,7 @@
   return
  )
 
- ;; CHECK:      (func $return-one (type $42) (param $0 i32) (result i32)
+ ;; CHECK:      (func $return-one (type $46) (param $0 i32) (result i32)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3633,7 +3662,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-first-unreachable (type $43) (param $0 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two-first-unreachable (type $47) (param $0 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (unreachable)
@@ -3647,7 +3676,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-second-unreachable (type $44) (param $0 i32) (result i32 i64)
+ ;; CHECK:      (func $return-two-second-unreachable (type $25) (param $0 i32) (result i32 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3661,6 +3690,21 @@
   return
  )
 
+ ;; CHECK:      (func $return-two-second-unreachable-tuple (type $25) (param $0 i32) (result i32 i64)
+ ;; CHECK-NEXT:  (return
+ ;; CHECK-NEXT:   (tuple.make 2
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:    (unreachable)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $return-two-second-unreachable-tuple (param i32) (result i32 i64)
+  local.get 0
+  unreachable
+  tuple.make 2
+  return
+ )
+
  ;; CHECK:      (func $return-multivalue (type $3) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (call $return-multivalue)
@@ -3671,7 +3715,7 @@
   return
  )
 
- ;; CHECK:      (func $ref-is-null (type $45) (param $0 anyref) (result i32)
+ ;; CHECK:      (func $ref-is-null (type $48) (param $0 anyref) (result i32)
  ;; CHECK-NEXT:  (ref.is_null
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3686,13 +3730,13 @@
  ;; CHECK-NEXT:   (ref.func $ref-func)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (ref.func $ref-func)
+ ;; CHECK-NEXT:   (ref.func $ref-is-null)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $ref-func
   ref.func $ref-func
   drop
-  ref.func 157
+  ref.func 158
   drop
  )
 
@@ -3715,7 +3759,7 @@
   throw $tag-pair
  )
 
- ;; CHECK:      (func $ref-eq (type $46) (param $0 eqref) (param $1 eqref) (result i32)
+ ;; CHECK:      (func $ref-eq (type $49) (param $0 eqref) (param $1 eqref) (result i32)
  ;; CHECK-NEXT:  (ref.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3892,7 +3936,7 @@
   table.copy 2 $funcs
  )
 
- ;; CHECK:      (func $i31-new (type $47) (param $0 i32) (result i31ref)
+ ;; CHECK:      (func $i31-new (type $50) (param $0 i32) (result i31ref)
  ;; CHECK-NEXT:  (ref.i31
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3902,7 +3946,7 @@
   ref.i31
  )
 
- ;; CHECK:      (func $i31-get (type $48) (param $0 i31ref)
+ ;; CHECK:      (func $i31-get (type $51) (param $0 i31ref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i31.get_s
  ;; CHECK-NEXT:    (local.get $0)
@@ -4121,7 +4165,7 @@
   drop
  )
 
- ;; CHECK:      (func $struct-new (type $49) (param $0 i32) (param $1 i64) (result (ref $pair))
+ ;; CHECK:      (func $struct-new (type $52) (param $0 i32) (param $1 i64) (result (ref $pair))
  ;; CHECK-NEXT:  (struct.new $pair
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4133,14 +4177,14 @@
   struct.new $pair
  )
 
- ;; CHECK:      (func $struct-new-default (type $50) (result (ref $pair))
+ ;; CHECK:      (func $struct-new-default (type $53) (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 $51) (param $0 (ref $pair)) (result i32)
+ ;; CHECK:      (func $struct-get-0 (type $54) (param $0 (ref $pair)) (result i32)
  ;; CHECK-NEXT:  (struct.get $pair $first
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4150,7 +4194,7 @@
   struct.get 14 0
  )
 
- ;; CHECK:      (func $struct-get-1 (type $52) (param $0 (ref $pair)) (result i64)
+ ;; CHECK:      (func $struct-get-1 (type $55) (param $0 (ref $pair)) (result i64)
  ;; CHECK-NEXT:  (struct.get $pair $second
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4160,7 +4204,7 @@
   struct.get $pair 1
  )
 
- ;; CHECK:      (func $struct-get-named (type $53) (param $0 (ref null $pair)) (result i32)
+ ;; CHECK:      (func $struct-get-named (type $56) (param $0 (ref null $pair)) (result i32)
  ;; CHECK-NEXT:  (struct.get $pair $first
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4170,7 +4214,7 @@
   struct.get $pair $first
  )
 
- ;; CHECK:      (func $struct-set-0 (type $54) (param $0 (ref $pair)) (param $1 i32)
+ ;; CHECK:      (func $struct-set-0 (type $57) (param $0 (ref $pair)) (param $1 i32)
  ;; CHECK-NEXT:  (struct.set $pair $first
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4182,7 +4226,7 @@
   struct.set $pair 0
  )
 
- ;; CHECK:      (func $struct-set-1 (type $55) (param $0 (ref $pair)) (param $1 i64)
+ ;; CHECK:      (func $struct-set-1 (type $58) (param $0 (ref $pair)) (param $1 i64)
  ;; CHECK-NEXT:  (struct.set $pair $second
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4194,7 +4238,7 @@
   struct.set 14 1
  )
 
- ;; CHECK:      (func $struct-set-named (type $56) (param $0 (ref null $pair)) (param $1 i64)
+ ;; CHECK:      (func $struct-set-named (type $59) (param $0 (ref null $pair)) (param $1 i64)
  ;; CHECK-NEXT:  (struct.set $pair $second
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4206,7 +4250,7 @@
   struct.set 14 $second
  )
 
- ;; CHECK:      (func $array-new (type $57) (param $0 i64) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new (type $60) (param $0 i64) (param $1 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4218,7 +4262,7 @@
   array.new $a1
  )
 
- ;; CHECK:      (func $array-new-default (type $58) (param $0 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-default (type $61) (param $0 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new_default $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4228,7 +4272,7 @@
   array.new_default 11
  )
 
- ;; CHECK:      (func $array-new-data (type $59) (param $0 i32) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-data (type $62) (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)
@@ -4262,7 +4306,7 @@
   drop
  )
 
- ;; CHECK:      (func $array-get (type $60) (param $0 (ref $a1)) (param $1 i32) (result i64)
+ ;; CHECK:      (func $array-get (type $63) (param $0 (ref $a1)) (param $1 i32) (result i64)
  ;; CHECK-NEXT:  (array.get $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4274,7 +4318,7 @@
   array.get $a1
  )
 
- ;; CHECK:      (func $array-get-s (type $61) (param $0 (ref $packed-i8)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-s (type $64) (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)
@@ -4286,7 +4330,7 @@
   array.get_s 15
  )
 
- ;; CHECK:      (func $array-get-u (type $62) (param $0 (ref $packed-i16)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-u (type $65) (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)
@@ -4298,7 +4342,7 @@
   array.get_u $packed-i16
  )
 
- ;; CHECK:      (func $array-set (type $63) (param $0 (ref $a2)) (param $1 i32) (param $2 f32)
+ ;; CHECK:      (func $array-set (type $66) (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)
@@ -4312,7 +4356,7 @@
   array.set $a2
  )
 
- ;; CHECK:      (func $array-len (type $64) (param $0 arrayref) (result i32)
+ ;; CHECK:      (func $array-len (type $67) (param $0 arrayref) (result i32)
  ;; CHECK-NEXT:  (array.len
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4322,7 +4366,7 @@
   array.len
  )
 
- ;; CHECK:      (func $array-copy (type $65) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32)
+ ;; CHECK:      (func $array-copy (type $68) (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)
@@ -4340,7 +4384,7 @@
   array.copy $a2 $a2
  )
 
- ;; CHECK:      (func $array-fill (type $66) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32)
+ ;; CHECK:      (func $array-fill (type $69) (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)
@@ -4356,7 +4400,7 @@
   array.fill $a2
  )
 
- ;; CHECK:      (func $array-init-data (type $67) (param $0 (ref $a2)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $array-init-data (type $70) (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)
@@ -4372,7 +4416,7 @@
   array.init_data $a2 0
  )
 
- ;; CHECK:      (func $array-init-elem (type $68) (param $0 (ref $any-array)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $array-init-elem (type $71) (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)
@@ -4401,7 +4445,7 @@
   drop
  )
 
- ;; CHECK:      (func $any-convert-extern (type $69) (param $0 externref)
+ ;; CHECK:      (func $any-convert-extern (type $72) (param $0 externref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (extern.internalize
  ;; CHECK-NEXT:    (local.get $0)
@@ -4427,7 +4471,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-new (type $70) (param $0 i32) (param $1 i32) (result stringref)
+ ;; CHECK:      (func $string-new (type $73) (param $0 i32) (param $1 i32) (result stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.new_utf8_try
  ;; CHECK-NEXT:    (local.get $0)
@@ -4469,7 +4513,7 @@
   string.new_wtf16
  )
 
- ;; CHECK:      (func $string-new-gc (type $71) (param $0 (ref $packed-i8)) (param $1 i32) (param $2 i32) (result stringref)
+ ;; CHECK:      (func $string-new-gc (type $74) (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)
@@ -4483,7 +4527,7 @@
   string.new_utf8_array
  )
 
- ;; CHECK:      (func $string-new-code-point (type $72) (param $0 i32) (result stringref)
+ ;; CHECK:      (func $string-new-code-point (type $75) (param $0 i32) (result stringref)
  ;; CHECK-NEXT:  (string.from_code_point
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4493,7 +4537,7 @@
   string.from_code_point
  )
 
- ;; CHECK:      (func $string-const (type $73) (result (ref string))
+ ;; CHECK:      (func $string-const (type $76) (result (ref string))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.const "foobar")
  ;; CHECK-NEXT:  )
@@ -4505,7 +4549,7 @@
   string.const "\00\00\00"
  )
 
- ;; CHECK:      (func $string-measure (type $27) (param $0 stringref)
+ ;; CHECK:      (func $string-measure (type $28) (param $0 stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.measure_wtf8
  ;; CHECK-NEXT:    (local.get $0)
@@ -4542,7 +4586,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-hash (type $74) (param $0 stringref) (result i32)
+ ;; CHECK:      (func $string-hash (type $77) (param $0 stringref) (result i32)
  ;; CHECK-NEXT:  (string.hash
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4552,7 +4596,7 @@
   string.hash
  )
 
- ;; CHECK:      (func $stringview-length (type $75) (param $0 stringview_wtf16) (result i32)
+ ;; CHECK:      (func $stringview-length (type $78) (param $0 stringview_wtf16) (result i32)
  ;; CHECK-NEXT:  (stringview_wtf16.length
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4562,7 +4606,7 @@
   stringview_wtf16.length
  )
 
- ;; CHECK:      (func $string-encode (type $27) (param $0 stringref)
+ ;; CHECK:      (func $string-encode (type $28) (param $0 stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.encode_wtf8
  ;; CHECK-NEXT:    (local.get $0)
@@ -4607,7 +4651,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-encode-gc (type $76) (param $0 stringref) (param $1 (ref $packed-i8)) (param $2 i32) (result i32)
+ ;; CHECK:      (func $string-encode-gc (type $79) (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)
@@ -4621,7 +4665,7 @@
   string.encode_wtf8_array
  )
 
- ;; CHECK:      (func $string-concat (type $77) (param $0 stringref) (param $1 stringref) (result (ref string))
+ ;; CHECK:      (func $string-concat (type $80) (param $0 stringref) (param $1 stringref) (result (ref string))
  ;; CHECK-NEXT:  (string.concat
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4633,7 +4677,7 @@
   string.concat
  )
 
- ;; CHECK:      (func $string-eq (type $28) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK:      (func $string-eq (type $29) (param $0 stringref) (param $1 stringref) (result i32)
  ;; CHECK-NEXT:  (string.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4645,7 +4689,7 @@
   string.eq
  )
 
- ;; CHECK:      (func $string-compare (type $28) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK:      (func $string-compare (type $29) (param $0 stringref) (param $1 stringref) (result i32)
  ;; CHECK-NEXT:  (string.compare
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4657,7 +4701,7 @@
   string.compare
  )
 
- ;; CHECK:      (func $string-as-wtf8 (type $78) (param $0 stringref) (result stringview_wtf8)
+ ;; CHECK:      (func $string-as-wtf8 (type $81) (param $0 stringref) (result stringview_wtf8)
  ;; CHECK-NEXT:  (string.as_wtf8
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4667,7 +4711,7 @@
   string.as_wtf8
  )
 
- ;; CHECK:      (func $string-as-wtf16 (type $79) (param $0 stringref) (result (ref stringview_wtf16))
+ ;; CHECK:      (func $string-as-wtf16 (type $82) (param $0 stringref) (result (ref stringview_wtf16))
  ;; CHECK-NEXT:  (string.as_wtf16
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4677,7 +4721,7 @@
   string.as_wtf16
  )
 
- ;; CHECK:      (func $string-as-iter (type $80) (param $0 stringref) (result stringview_iter)
+ ;; CHECK:      (func $string-as-iter (type $83) (param $0 stringref) (result stringview_iter)
  ;; CHECK-NEXT:  (string.as_iter
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4687,7 +4731,7 @@
   string.as_iter
  )
 
- ;; CHECK:      (func $string-advance (type $81) (param $0 (ref stringview_wtf8)) (param $1 i32) (param $2 i32) (result i32)
+ ;; CHECK:      (func $string-advance (type $84) (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)
@@ -4701,7 +4745,7 @@
   stringview_wtf8.advance
  )
 
- ;; CHECK:      (func $string-get (type $82) (param $0 stringview_wtf16) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-get (type $85) (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)
@@ -4713,7 +4757,7 @@
   stringview_wtf16.get_codeunit
  )
 
- ;; CHECK:      (func $string-iter-next (type $83) (param $0 stringview_iter) (result i32)
+ ;; CHECK:      (func $string-iter-next (type $86) (param $0 stringview_iter) (result i32)
  ;; CHECK-NEXT:  (stringview_iter.next
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4723,7 +4767,7 @@
   stringview_iter.next
  )
 
- ;; CHECK:      (func $string-iter-advance (type $84) (param $0 stringview_iter) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-iter-advance (type $87) (param $0 stringview_iter) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (stringview_iter.advance
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4735,7 +4779,7 @@
   stringview_iter.advance
  )
 
- ;; CHECK:      (func $string-iter-rewind (type $85) (param $0 (ref stringview_iter)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-iter-rewind (type $88) (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)
@@ -4747,7 +4791,7 @@
   stringview_iter.rewind
  )
 
- ;; CHECK:      (func $string-slice (type $86) (param $0 stringview_wtf8) (param $1 stringview_wtf16) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $string-slice (type $89) (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)
@@ -4776,7 +4820,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-iter-slice (type $87) (param $0 stringview_iter) (param $1 i32) (result (ref string))
+ ;; CHECK:      (func $string-iter-slice (type $90) (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)
@@ -4841,7 +4885,7 @@
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (call_indirect $timport$0 (type $29)
+ ;; CHECK-NEXT:   (call_indirect $timport$0 (type $30)
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:    (local.get $0)
@@ -4903,7 +4947,7 @@
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (call_indirect $timport$0 (type $29)
+ ;; CHECK-NEXT:   (call_indirect $timport$0 (type $30)
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:    (local.get $0)
@@ -4975,7 +5019,7 @@
  ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $30)
+ ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $31)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $0)
@@ -5034,7 +5078,7 @@
  ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $30)
+ ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $31)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $0)
@@ -5075,14 +5119,14 @@
   )
  )
 
- ;; CHECK:      (func $resume (type $88) (param $ct (ref $simple-cont))
+ ;; CHECK:      (func $resume (type $91) (param $ct (ref $simple-cont))
  ;; CHECK-NEXT:  (local $f f32)
  ;; CHECK-NEXT:  (block $label_1
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (block $label (result (ref $to-f32-cont))
  ;; CHECK-NEXT:      (tuple.drop 3
- ;; CHECK-NEXT:       (block $label_0 (type $33) (result i32 i64 (ref null $simple-cont))
+ ;; CHECK-NEXT:       (block $label_0 (type $36) (result i32 i64 (ref null $simple-cont))
  ;; CHECK-NEXT:        (local.set $f
  ;; CHECK-NEXT:         (resume $simple-cont (tag $empty $label) (tag $tag-pair-to-pair $label_0)
  ;; CHECK-NEXT:          (i32.const 0)
@@ -5116,7 +5160,7 @@
   br 0
  )
 
- ;; CHECK:      (func $contnew (type $91) (param $f (ref $simple)) (result (ref $simple-cont))
+ ;; CHECK:      (func $contnew (type $94) (param $f (ref $simple)) (result (ref $simple-cont))
  ;; CHECK-NEXT:  (cont.new $simple-cont
  ;; CHECK-NEXT:   (local.get $f)
  ;; CHECK-NEXT:  )
@@ -5126,7 +5170,7 @@
    cont.new $simple-cont
  )
 
- ;; CHECK:      (func $contbind (type $92) (param $c (ref $cont-bind-before)) (result (ref $simple-cont))
+ ;; CHECK:      (func $contbind (type $95) (param $c (ref $cont-bind-before)) (result (ref $simple-cont))
  ;; CHECK-NEXT:  (cont.bind $cont-bind-before $simple-cont
  ;; CHECK-NEXT:   (i32.const 123)
  ;; CHECK-NEXT:   (i64.const 123)
@@ -5239,7 +5283,7 @@
   drop
  )
 
- ;; CHECK:      (func $use-types (type $104) (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 $107) (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