[Parser] Parse `resume` (#6295)

1 files changed, 202 insertions, 142 deletions

diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
index 3d12d5d71..770c08665 100644
--- a/test/lit/wat-kitchen-sink.wast
+++ b/test/lit/wat-kitchen-sink.wast
@@ -46,139 +46,149 @@
 
  ;; CHECK:      (type $a0 (array i32))
 
- ;; CHECK:      (type $17 (func (result exnref)))
+ ;; CHECK:      (type $simple (func (param i32 i64) (result f32)))
 
- ;; CHECK:      (type $18 (func (result i64)))
+ ;; CHECK:      (type $simple-cont (cont $simple))
 
- ;; CHECK:      (type $19 (func (result i64 f32)))
+ ;; CHECK:      (type $19 (func (param i32 i64) (result i32 i64)))
 
- ;; CHECK:      (type $20 (func (param i32 i32 i32)))
+ ;; CHECK:      (type $20 (func (result exnref)))
 
- ;; CHECK:      (type $21 (func (param v128 i32) (result v128)))
+ ;; CHECK:      (type $21 (func (result i64)))
+
+ ;; CHECK:      (type $22 (func (result i64 f32)))
+
+ ;; CHECK:      (type $23 (func (param i32 i32 i32)))
+
+ ;; CHECK:      (type $24 (func (param v128 i32) (result v128)))
 
  ;; CHECK:      (type $packed-i16 (array (mut i16)))
 
  ;; CHECK:      (type $any-array (array (mut anyref)))
 
- ;; CHECK:      (type $24 (func (param stringref)))
+ ;; CHECK:      (type $27 (func (param stringref)))
+
+ ;; CHECK:      (type $28 (func (param stringref stringref) (result i32)))
 
- ;; CHECK:      (type $25 (func (param stringref stringref) (result i32)))
+ ;; CHECK:      (type $29 (func (param i64 v128) (result v128)))
 
- ;; CHECK:      (type $26 (func (param i32 i64) (result f32)))
+ ;; CHECK:      (type $30 (func (param i64 v128)))
 
- ;; CHECK:      (type $27 (func (param i64 v128) (result v128)))
+ ;; CHECK:      (type $31 (func (result i32 i64 (ref null $simple-cont))))
 
- ;; CHECK:      (type $28 (func (param i64 v128)))
+ ;; CHECK:      (type $32 (func (param i32 i32)))
 
- ;; CHECK:      (type $29 (func (param i32 i32)))
+ ;; CHECK:      (type $33 (func (param exnref)))
 
- ;; CHECK:      (type $30 (func (param exnref)))
+ ;; CHECK:      (type $34 (func (param i32 i32 f64 f64)))
 
- ;; CHECK:      (type $31 (func (param i32 i32 f64 f64)))
+ ;; CHECK:      (type $35 (func (param i64)))
 
- ;; CHECK:      (type $32 (func (param i64)))
+ ;; CHECK:      (type $36 (func (param v128) (result i32)))
 
- ;; CHECK:      (type $33 (func (param v128) (result i32)))
+ ;; CHECK:      (type $37 (func (param v128 v128) (result v128)))
 
- ;; CHECK:      (type $34 (func (param v128 v128) (result v128)))
+ ;; CHECK:      (type $38 (func (param v128 v128 v128) (result v128)))
 
- ;; CHECK:      (type $35 (func (param v128 v128 v128) (result v128)))
+ ;; CHECK:      (type $39 (func (param i32 i32 i64 i64)))
 
- ;; CHECK:      (type $36 (func (param i32 i32 i64 i64)))
+ ;; CHECK:      (type $40 (func (param i32) (result i32)))
 
- ;; CHECK:      (type $37 (func (param i32) (result i32)))
+ ;; CHECK:      (type $41 (func (param i64) (result i32 i64)))
 
- ;; CHECK:      (type $38 (func (param i32 i64) (result i32 i64)))
+ ;; CHECK:      (type $42 (func (param i32) (result i32 i64)))
 
- ;; CHECK:      (type $39 (func (param i64) (result i32 i64)))
+ ;; CHECK:      (type $43 (func (param anyref) (result i32)))
 
- ;; CHECK:      (type $40 (func (param i32) (result i32 i64)))
+ ;; CHECK:      (type $44 (func (param eqref eqref) (result i32)))
 
- ;; CHECK:      (type $41 (func (param anyref) (result i32)))
+ ;; CHECK:      (type $45 (func (param i32) (result i31ref)))
 
- ;; CHECK:      (type $42 (func (param eqref eqref) (result i32)))
+ ;; CHECK:      (type $46 (func (param i31ref)))
 
- ;; CHECK:      (type $43 (func (param i32) (result i31ref)))
+ ;; CHECK:      (type $47 (func (param i32 i64) (result (ref $pair))))
 
- ;; CHECK:      (type $44 (func (param i31ref)))
+ ;; CHECK:      (type $48 (func (result (ref $pair))))
 
- ;; CHECK:      (type $45 (func (param i32 i64) (result (ref $pair))))
+ ;; CHECK:      (type $49 (func (param (ref $pair)) (result i32)))
 
- ;; CHECK:      (type $46 (func (result (ref $pair))))
+ ;; CHECK:      (type $50 (func (param (ref $pair)) (result i64)))
 
- ;; CHECK:      (type $47 (func (param (ref $pair)) (result i32)))
+ ;; CHECK:      (type $51 (func (param (ref null $pair)) (result i32)))
 
- ;; CHECK:      (type $48 (func (param (ref $pair)) (result i64)))
+ ;; CHECK:      (type $52 (func (param (ref $pair) i32)))
 
- ;; CHECK:      (type $49 (func (param (ref null $pair)) (result i32)))
+ ;; CHECK:      (type $53 (func (param (ref $pair) i64)))
 
- ;; CHECK:      (type $50 (func (param (ref $pair) i32)))
+ ;; CHECK:      (type $54 (func (param (ref null $pair) i64)))
 
- ;; CHECK:      (type $51 (func (param (ref $pair) i64)))
+ ;; CHECK:      (type $55 (func (param i64 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $52 (func (param (ref null $pair) i64)))
+ ;; CHECK:      (type $56 (func (param i32) (result (ref $a1))))
 
- ;; CHECK:      (type $53 (func (param i64 i32) (result (ref $a1))))
+ ;; CHECK:      (type $57 (func (param i32 i32) (result (ref $a1))))
 
- ;; CHECK:      (type $54 (func (param i32) (result (ref $a1))))
+ ;; CHECK:      (type $58 (func (param (ref $a1) i32) (result i64)))
 
- ;; CHECK:      (type $55 (func (param i32 i32) (result (ref $a1))))
+ ;; CHECK:      (type $59 (func (param (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $56 (func (param (ref $a1) i32) (result i64)))
+ ;; CHECK:      (type $60 (func (param (ref $packed-i16) i32) (result i32)))
 
- ;; CHECK:      (type $57 (func (param (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $61 (func (param (ref $a2) i32 f32)))
 
- ;; CHECK:      (type $58 (func (param (ref $packed-i16) i32) (result i32)))
+ ;; CHECK:      (type $62 (func (param arrayref) (result i32)))
 
- ;; CHECK:      (type $59 (func (param (ref $a2) i32 f32)))
+ ;; CHECK:      (type $63 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
 
- ;; CHECK:      (type $60 (func (param arrayref) (result i32)))
+ ;; CHECK:      (type $64 (func (param (ref $a2) i32 f32 i32)))
 
- ;; CHECK:      (type $61 (func (param (ref $a2) i32 (ref $a2) i32 i32)))
+ ;; CHECK:      (type $65 (func (param (ref $a2) i32 i32 i32)))
 
- ;; CHECK:      (type $62 (func (param (ref $a2) i32 f32 i32)))
+ ;; CHECK:      (type $66 (func (param (ref $any-array) i32 i32 i32)))
 
- ;; CHECK:      (type $63 (func (param (ref $a2) i32 i32 i32)))
+ ;; CHECK:      (type $67 (func (param externref)))
 
- ;; CHECK:      (type $64 (func (param (ref $any-array) i32 i32 i32)))
+ ;; CHECK:      (type $68 (func (param i32 i32) (result stringref)))
 
- ;; CHECK:      (type $65 (func (param externref)))
+ ;; CHECK:      (type $69 (func (param (ref $packed-i8) i32 i32) (result stringref)))
 
- ;; CHECK:      (type $66 (func (param i32 i32) (result stringref)))
+ ;; CHECK:      (type $70 (func (param i32) (result stringref)))
 
- ;; CHECK:      (type $67 (func (param (ref $packed-i8) i32 i32) (result stringref)))
+ ;; CHECK:      (type $71 (func (result (ref string))))
 
- ;; CHECK:      (type $68 (func (param i32) (result stringref)))
+ ;; CHECK:      (type $72 (func (param stringref) (result i32)))
 
- ;; CHECK:      (type $69 (func (result (ref string))))
+ ;; CHECK:      (type $73 (func (param stringview_wtf16) (result i32)))
 
- ;; CHECK:      (type $70 (func (param stringref) (result i32)))
+ ;; CHECK:      (type $74 (func (param stringref (ref $packed-i8) i32) (result i32)))
 
- ;; CHECK:      (type $71 (func (param stringview_wtf16) (result i32)))
+ ;; CHECK:      (type $75 (func (param stringref stringref) (result (ref string))))
 
- ;; CHECK:      (type $72 (func (param stringref (ref $packed-i8) i32) (result i32)))
+ ;; CHECK:      (type $76 (func (param stringref) (result stringview_wtf8)))
 
- ;; CHECK:      (type $73 (func (param stringref stringref) (result (ref string))))
+ ;; CHECK:      (type $77 (func (param stringref) (result (ref stringview_wtf16))))
 
- ;; CHECK:      (type $74 (func (param stringref) (result stringview_wtf8)))
+ ;; CHECK:      (type $78 (func (param stringref) (result stringview_iter)))
 
- ;; CHECK:      (type $75 (func (param stringref) (result (ref stringview_wtf16))))
+ ;; CHECK:      (type $79 (func (param (ref stringview_wtf8) i32 i32) (result i32)))
 
- ;; CHECK:      (type $76 (func (param stringref) (result stringview_iter)))
+ ;; CHECK:      (type $80 (func (param stringview_wtf16 i32) (result i32)))
 
- ;; CHECK:      (type $77 (func (param (ref stringview_wtf8) i32 i32) (result i32)))
+ ;; CHECK:      (type $81 (func (param stringview_iter) (result i32)))
 
- ;; CHECK:      (type $78 (func (param stringview_wtf16 i32) (result i32)))
+ ;; CHECK:      (type $82 (func (param stringview_iter i32) (result i32)))
 
- ;; CHECK:      (type $79 (func (param stringview_iter) (result i32)))
+ ;; CHECK:      (type $83 (func (param (ref stringview_iter) i32) (result i32)))
 
- ;; CHECK:      (type $80 (func (param stringview_iter i32) (result i32)))
+ ;; CHECK:      (type $84 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))
 
- ;; CHECK:      (type $81 (func (param (ref stringview_iter) i32) (result i32)))
+ ;; CHECK:      (type $85 (func (param stringview_iter i32) (result (ref string))))
 
- ;; CHECK:      (type $82 (func (param stringview_wtf8 stringview_wtf16 i32 i32)))
+ ;; CHECK:      (type $86 (func (param (ref $simple-cont))))
 
- ;; CHECK:      (type $83 (func (param stringview_iter i32) (result (ref string))))
+ ;; CHECK:      (type $to-f32 (func (result f32)))
+
+ ;; CHECK:      (type $to-f32-cont (cont $to-f32))
 
  ;; CHECK:      (type $s2 (struct (field i32)))
  (type $s2 (struct i32))
@@ -216,12 +226,18 @@
  ;; CHECK:      (type $subvoid (sub final $void (func)))
  (type $subvoid (sub final $void (func)))
 
+ (type $simple (func (param $x i32) (param $y i64) (result f32)))
+ (type $to-f32 (func (result f32)))
+
  (type $many (sub (func (param $x i32) (param i64 f32) (param) (param $y f64)
                              (result anyref (ref func)))))
 
  ;; CHECK:      (type $submany (sub final $many (func (param i32 i64 f32 f64) (result anyref (ref func)))))
  (type $submany (sub final $many (func (param i32 i64 f32 f64) (result anyref (ref func)))))
 
+ (type $simple-cont (cont $simple))
+ (type $to-f32-cont (cont $to-f32))
+
  ;; CHECK:      (type $all-types (struct (field externref) (field (ref extern)) (field funcref) (field (ref func)) (field anyref) (field (ref any)) (field eqref) (field (ref eq)) (field i31ref) (field (ref i31)) (field structref) (field (ref struct)) (field arrayref) (field (ref array)) (field exnref) (field (ref exn)) (field stringref) (field (ref string)) (field stringview_wtf8) (field (ref stringview_wtf8)) (field stringview_wtf16) (field (ref stringview_wtf16)) (field stringview_iter) (field (ref stringview_iter)) (field nullref) (field (ref none)) (field nullexternref) (field (ref noextern)) (field nullfuncref) (field (ref nofunc)) (field nullexnref) (field (ref noexn))))
  (type $all-types (struct externref (ref extern)
                           funcref (ref func)
@@ -242,7 +258,7 @@
 
  ;; imported memories
  (memory (export "mem") (export "mem2") (import "" "mem") 0)
- ;; CHECK:      (type $95 (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 $100 (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))
 
@@ -403,6 +419,9 @@
  ;; CHECK:      (tag $tag-pair (param i32 i64))
  (tag $tag-pair (param i32 i64))
 
+ ;; CHECK:      (tag $tag-pair-to-pair (param i32 i64) (result i32 i64))
+ (tag $tag-pair-to-pair (param i32 i64) (result i32 i64))
+
  ;; explicit exports
  (export "exported-func" (func 0))
  ;; CHECK:      (export "mem" (memory $mimport$0))
@@ -901,7 +920,7 @@
   drop
  )
 
- ;; CHECK:      (func $locals (type $29) (param $0 i32) (param $x i32)
+ ;; CHECK:      (func $locals (type $32) (param $0 i32) (param $x i32)
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local $y i32)
  ;; CHECK-NEXT:  (drop
@@ -2454,7 +2473,7 @@
   end
  )
 
- ;; CHECK:      (func $try-table-catch-ref (type $17) (result exnref)
+ ;; CHECK:      (func $try-table-catch-ref (type $20) (result exnref)
  ;; CHECK-NEXT:  (block $label (result exnref)
  ;; CHECK-NEXT:   (try_table (result exnref) (catch_ref $empty $label)
  ;; CHECK-NEXT:    (unreachable)
@@ -2480,7 +2499,7 @@
   end
  )
 
- ;; CHECK:      (func $try-table-catch-all-ref (type $17) (result exnref)
+ ;; CHECK:      (func $try-table-catch-all-ref (type $20) (result exnref)
  ;; CHECK-NEXT:  (block $label (result exnref)
  ;; CHECK-NEXT:   (try_table (result exnref) (catch_all_ref $label)
  ;; CHECK-NEXT:    (unreachable)
@@ -2554,7 +2573,7 @@
   )
  )
 
- ;; CHECK:      (func $try-table-throw-ref (type $30) (param $0 exnref)
+ ;; CHECK:      (func $try-table-throw-ref (type $33) (param $0 exnref)
  ;; CHECK-NEXT:  (throw_ref
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -2786,7 +2805,7 @@
   br_if 0
  )
 
- ;; CHECK:      (func $br_if-value (type $18) (result i64)
+ ;; CHECK:      (func $br_if-value (type $21) (result i64)
  ;; CHECK-NEXT:  (block $l (result i64)
  ;; CHECK-NEXT:   (br_if $l
  ;; CHECK-NEXT:    (i64.const 0)
@@ -2802,8 +2821,8 @@
   end
  )
 
- ;; CHECK:      (func $br_if-multivalue (type $19) (result i64 f32)
- ;; CHECK-NEXT:  (block $l (type $19) (result i64 f32)
+ ;; CHECK:      (func $br_if-multivalue (type $22) (result i64 f32)
+ ;; CHECK-NEXT:  (block $l (type $22) (result i64 f32)
  ;; CHECK-NEXT:   (br_if $l
  ;; CHECK-NEXT:    (tuple.make 2
  ;; CHECK-NEXT:     (i64.const 0)
@@ -2822,7 +2841,7 @@
   end
  )
 
- ;; CHECK:      (func $br_if-loop (type $18) (result i64)
+ ;; CHECK:      (func $br_if-loop (type $21) (result i64)
  ;; CHECK-NEXT:  (local $scratch i64)
  ;; CHECK-NEXT:  (loop $l (result i64)
  ;; CHECK-NEXT:   (local.set $scratch
@@ -2972,7 +2991,7 @@
   end
  )
 
- ;; CHECK:      (func $binary (type $31) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
+ ;; CHECK:      (func $binary (type $34) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.add
  ;; CHECK-NEXT:    (local.get $0)
@@ -2997,7 +3016,7 @@
   drop
  )
 
- ;; CHECK:      (func $unary (type $32) (param $0 i64)
+ ;; CHECK:      (func $unary (type $35) (param $0 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i64.eqz
  ;; CHECK-NEXT:    (local.get $0)
@@ -3010,7 +3029,7 @@
   drop
  )
 
- ;; CHECK:      (func $select (type $20) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $select (type $23) (param $0 i32) (param $1 i32) (param $2 i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (select
  ;; CHECK-NEXT:    (local.get $0)
@@ -3346,7 +3365,7 @@
   drop
  )
 
- ;; CHECK:      (func $simd-extract (type $33) (param $0 v128) (result i32)
+ ;; CHECK:      (func $simd-extract (type $36) (param $0 v128) (result i32)
  ;; CHECK-NEXT:  (i32x4.extract_lane 3
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3356,7 +3375,7 @@
   i32x4.extract_lane 3
  )
 
- ;; CHECK:      (func $simd-replace (type $21) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-replace (type $24) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i32x4.replace_lane 2
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3368,7 +3387,7 @@
   i32x4.replace_lane 2
  )
 
- ;; CHECK:      (func $simd-shuffle (type $34) (param $0 v128) (param $1 v128) (result v128)
+ ;; CHECK:      (func $simd-shuffle (type $37) (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)
@@ -3380,7 +3399,7 @@
   i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23
  )
 
- ;; CHECK:      (func $simd-ternary (type $35) (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+ ;; CHECK:      (func $simd-ternary (type $38) (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)
@@ -3394,7 +3413,7 @@
   v128.bitselect
  )
 
- ;; CHECK:      (func $simd-shift (type $21) (param $0 v128) (param $1 i32) (result v128)
+ ;; CHECK:      (func $simd-shift (type $24) (param $0 v128) (param $1 i32) (result v128)
  ;; CHECK-NEXT:  (i8x16.shl
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3449,7 +3468,7 @@
   v128.store64_lane 5 align=4 0
  )
 
- ;; CHECK:      (func $memory-init (type $20) (param $0 i32) (param $1 i32) (param $2 i32)
+ ;; CHECK:      (func $memory-init (type $23) (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)
@@ -3490,7 +3509,7 @@
   data.drop $passive
  )
 
- ;; CHECK:      (func $memory-copy (type $36) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64)
+ ;; CHECK:      (func $memory-copy (type $39) (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)
@@ -3561,7 +3580,7 @@
   return
  )
 
- ;; CHECK:      (func $return-one (type $37) (param $0 i32) (result i32)
+ ;; CHECK:      (func $return-one (type $40) (param $0 i32) (result i32)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3571,7 +3590,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two (type $38) (param $0 i32) (param $1 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two (type $19) (param $0 i32) (param $1 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (local.get $0)
@@ -3585,7 +3604,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-first-unreachable (type $39) (param $0 i64) (result i32 i64)
+ ;; CHECK:      (func $return-two-first-unreachable (type $41) (param $0 i64) (result i32 i64)
  ;; CHECK-NEXT:  (return
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (unreachable)
@@ -3599,7 +3618,7 @@
   return
  )
 
- ;; CHECK:      (func $return-two-second-unreachable (type $40) (param $0 i32) (result i32 i64)
+ ;; CHECK:      (func $return-two-second-unreachable (type $42) (param $0 i32) (result i32 i64)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3616,7 +3635,7 @@
   return
  )
 
- ;; CHECK:      (func $ref-is-null (type $41) (param $0 anyref) (result i32)
+ ;; CHECK:      (func $ref-is-null (type $43) (param $0 anyref) (result i32)
  ;; CHECK-NEXT:  (ref.is_null
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3660,7 +3679,7 @@
   throw $tag-pair
  )
 
- ;; CHECK:      (func $ref-eq (type $42) (param $0 eqref) (param $1 eqref) (result i32)
+ ;; CHECK:      (func $ref-eq (type $44) (param $0 eqref) (param $1 eqref) (result i32)
  ;; CHECK-NEXT:  (ref.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -3837,7 +3856,7 @@
   table.copy 2 $funcs
  )
 
- ;; CHECK:      (func $i31-new (type $43) (param $0 i32) (result i31ref)
+ ;; CHECK:      (func $i31-new (type $45) (param $0 i32) (result i31ref)
  ;; CHECK-NEXT:  (ref.i31
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -3847,7 +3866,7 @@
   ref.i31
  )
 
- ;; CHECK:      (func $i31-get (type $44) (param $0 i31ref)
+ ;; CHECK:      (func $i31-get (type $46) (param $0 i31ref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i31.get_s
  ;; CHECK-NEXT:    (local.get $0)
@@ -4066,7 +4085,7 @@
   drop
  )
 
- ;; CHECK:      (func $struct-new (type $45) (param $0 i32) (param $1 i64) (result (ref $pair))
+ ;; CHECK:      (func $struct-new (type $47) (param $0 i32) (param $1 i64) (result (ref $pair))
  ;; CHECK-NEXT:  (struct.new $pair
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4078,14 +4097,14 @@
   struct.new $pair
  )
 
- ;; CHECK:      (func $struct-new-default (type $46) (result (ref $pair))
+ ;; CHECK:      (func $struct-new-default (type $48) (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 $47) (param $0 (ref $pair)) (result i32)
+ ;; CHECK:      (func $struct-get-0 (type $49) (param $0 (ref $pair)) (result i32)
  ;; CHECK-NEXT:  (struct.get $pair $first
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4095,7 +4114,7 @@
   struct.get 14 0
  )
 
- ;; CHECK:      (func $struct-get-1 (type $48) (param $0 (ref $pair)) (result i64)
+ ;; CHECK:      (func $struct-get-1 (type $50) (param $0 (ref $pair)) (result i64)
  ;; CHECK-NEXT:  (struct.get $pair $second
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4105,7 +4124,7 @@
   struct.get $pair 1
  )
 
- ;; CHECK:      (func $struct-get-named (type $49) (param $0 (ref null $pair)) (result i32)
+ ;; CHECK:      (func $struct-get-named (type $51) (param $0 (ref null $pair)) (result i32)
  ;; CHECK-NEXT:  (struct.get $pair $first
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4115,7 +4134,7 @@
   struct.get $pair $first
  )
 
- ;; CHECK:      (func $struct-set-0 (type $50) (param $0 (ref $pair)) (param $1 i32)
+ ;; CHECK:      (func $struct-set-0 (type $52) (param $0 (ref $pair)) (param $1 i32)
  ;; CHECK-NEXT:  (struct.set $pair $first
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4127,7 +4146,7 @@
   struct.set $pair 0
  )
 
- ;; CHECK:      (func $struct-set-1 (type $51) (param $0 (ref $pair)) (param $1 i64)
+ ;; CHECK:      (func $struct-set-1 (type $53) (param $0 (ref $pair)) (param $1 i64)
  ;; CHECK-NEXT:  (struct.set $pair $second
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4139,7 +4158,7 @@
   struct.set 14 1
  )
 
- ;; CHECK:      (func $struct-set-named (type $52) (param $0 (ref null $pair)) (param $1 i64)
+ ;; CHECK:      (func $struct-set-named (type $54) (param $0 (ref null $pair)) (param $1 i64)
  ;; CHECK-NEXT:  (struct.set $pair $second
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4151,7 +4170,7 @@
   struct.set 14 $second
  )
 
- ;; CHECK:      (func $array-new (type $53) (param $0 i64) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new (type $55) (param $0 i64) (param $1 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4163,7 +4182,7 @@
   array.new $a1
  )
 
- ;; CHECK:      (func $array-new-default (type $54) (param $0 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-default (type $56) (param $0 i32) (result (ref $a1))
  ;; CHECK-NEXT:  (array.new_default $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4173,7 +4192,7 @@
   array.new_default 11
  )
 
- ;; CHECK:      (func $array-new-data (type $55) (param $0 i32) (param $1 i32) (result (ref $a1))
+ ;; CHECK:      (func $array-new-data (type $57) (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)
@@ -4207,7 +4226,7 @@
   drop
  )
 
- ;; CHECK:      (func $array-get (type $56) (param $0 (ref $a1)) (param $1 i32) (result i64)
+ ;; CHECK:      (func $array-get (type $58) (param $0 (ref $a1)) (param $1 i32) (result i64)
  ;; CHECK-NEXT:  (array.get $a1
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4219,7 +4238,7 @@
   array.get $a1
  )
 
- ;; CHECK:      (func $array-get-s (type $57) (param $0 (ref $packed-i8)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-s (type $59) (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)
@@ -4231,7 +4250,7 @@
   array.get_s 15
  )
 
- ;; CHECK:      (func $array-get-u (type $58) (param $0 (ref $packed-i16)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $array-get-u (type $60) (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)
@@ -4243,7 +4262,7 @@
   array.get_u $packed-i16
  )
 
- ;; CHECK:      (func $array-set (type $59) (param $0 (ref $a2)) (param $1 i32) (param $2 f32)
+ ;; CHECK:      (func $array-set (type $61) (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)
@@ -4257,7 +4276,7 @@
   array.set $a2
  )
 
- ;; CHECK:      (func $array-len (type $60) (param $0 arrayref) (result i32)
+ ;; CHECK:      (func $array-len (type $62) (param $0 arrayref) (result i32)
  ;; CHECK-NEXT:  (array.len
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4267,7 +4286,7 @@
   array.len
  )
 
- ;; CHECK:      (func $array-copy (type $61) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32)
+ ;; CHECK:      (func $array-copy (type $63) (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)
@@ -4285,7 +4304,7 @@
   array.copy $a2 $a2
  )
 
- ;; CHECK:      (func $array-fill (type $62) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32)
+ ;; CHECK:      (func $array-fill (type $64) (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)
@@ -4301,7 +4320,7 @@
   array.fill $a2
  )
 
- ;; CHECK:      (func $array-init-data (type $63) (param $0 (ref $a2)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $array-init-data (type $65) (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)
@@ -4317,7 +4336,7 @@
   array.init_data $a2 0
  )
 
- ;; CHECK:      (func $array-init-elem (type $64) (param $0 (ref $any-array)) (param $1 i32) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $array-init-elem (type $66) (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)
@@ -4346,7 +4365,7 @@
   drop
  )
 
- ;; CHECK:      (func $any-convert-extern (type $65) (param $0 externref)
+ ;; CHECK:      (func $any-convert-extern (type $67) (param $0 externref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (extern.internalize
  ;; CHECK-NEXT:    (local.get $0)
@@ -4372,7 +4391,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-new (type $66) (param $0 i32) (param $1 i32) (result stringref)
+ ;; CHECK:      (func $string-new (type $68) (param $0 i32) (param $1 i32) (result stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.new_utf8_try
  ;; CHECK-NEXT:    (local.get $0)
@@ -4414,7 +4433,7 @@
   string.new_wtf16
  )
 
- ;; CHECK:      (func $string-new-gc (type $67) (param $0 (ref $packed-i8)) (param $1 i32) (param $2 i32) (result stringref)
+ ;; CHECK:      (func $string-new-gc (type $69) (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)
@@ -4428,7 +4447,7 @@
   string.new_utf8_array
  )
 
- ;; CHECK:      (func $string-new-code-point (type $68) (param $0 i32) (result stringref)
+ ;; CHECK:      (func $string-new-code-point (type $70) (param $0 i32) (result stringref)
  ;; CHECK-NEXT:  (string.from_code_point
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4438,7 +4457,7 @@
   string.from_code_point
  )
 
- ;; CHECK:      (func $string-const (type $69) (result (ref string))
+ ;; CHECK:      (func $string-const (type $71) (result (ref string))
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.const "foobar")
  ;; CHECK-NEXT:  )
@@ -4450,7 +4469,7 @@
   string.const "\00\00\00"
  )
 
- ;; CHECK:      (func $string-measure (type $24) (param $0 stringref)
+ ;; CHECK:      (func $string-measure (type $27) (param $0 stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.measure_wtf8
  ;; CHECK-NEXT:    (local.get $0)
@@ -4487,7 +4506,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-hash (type $70) (param $0 stringref) (result i32)
+ ;; CHECK:      (func $string-hash (type $72) (param $0 stringref) (result i32)
  ;; CHECK-NEXT:  (string.hash
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4497,7 +4516,7 @@
   string.hash
  )
 
- ;; CHECK:      (func $stringview-length (type $71) (param $0 stringview_wtf16) (result i32)
+ ;; CHECK:      (func $stringview-length (type $73) (param $0 stringview_wtf16) (result i32)
  ;; CHECK-NEXT:  (stringview_wtf16.length
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4507,7 +4526,7 @@
   stringview_wtf16.length
  )
 
- ;; CHECK:      (func $string-encode (type $24) (param $0 stringref)
+ ;; CHECK:      (func $string-encode (type $27) (param $0 stringref)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (string.encode_wtf8
  ;; CHECK-NEXT:    (local.get $0)
@@ -4552,7 +4571,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-encode-gc (type $72) (param $0 stringref) (param $1 (ref $packed-i8)) (param $2 i32) (result i32)
+ ;; CHECK:      (func $string-encode-gc (type $74) (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)
@@ -4566,7 +4585,7 @@
   string.encode_wtf8_array
  )
 
- ;; CHECK:      (func $string-concat (type $73) (param $0 stringref) (param $1 stringref) (result (ref string))
+ ;; CHECK:      (func $string-concat (type $75) (param $0 stringref) (param $1 stringref) (result (ref string))
  ;; CHECK-NEXT:  (string.concat
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4578,7 +4597,7 @@
   string.concat
  )
 
- ;; CHECK:      (func $string-eq (type $25) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK:      (func $string-eq (type $28) (param $0 stringref) (param $1 stringref) (result i32)
  ;; CHECK-NEXT:  (string.eq
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4590,7 +4609,7 @@
   string.eq
  )
 
- ;; CHECK:      (func $string-compare (type $25) (param $0 stringref) (param $1 stringref) (result i32)
+ ;; CHECK:      (func $string-compare (type $28) (param $0 stringref) (param $1 stringref) (result i32)
  ;; CHECK-NEXT:  (string.compare
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4602,7 +4621,7 @@
   string.compare
  )
 
- ;; CHECK:      (func $string-as-wtf8 (type $74) (param $0 stringref) (result stringview_wtf8)
+ ;; CHECK:      (func $string-as-wtf8 (type $76) (param $0 stringref) (result stringview_wtf8)
  ;; CHECK-NEXT:  (string.as_wtf8
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4612,7 +4631,7 @@
   string.as_wtf8
  )
 
- ;; CHECK:      (func $string-as-wtf16 (type $75) (param $0 stringref) (result (ref stringview_wtf16))
+ ;; CHECK:      (func $string-as-wtf16 (type $77) (param $0 stringref) (result (ref stringview_wtf16))
  ;; CHECK-NEXT:  (string.as_wtf16
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4622,7 +4641,7 @@
   string.as_wtf16
  )
 
- ;; CHECK:      (func $string-as-iter (type $76) (param $0 stringref) (result stringview_iter)
+ ;; CHECK:      (func $string-as-iter (type $78) (param $0 stringref) (result stringview_iter)
  ;; CHECK-NEXT:  (string.as_iter
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4632,7 +4651,7 @@
   string.as_iter
  )
 
- ;; CHECK:      (func $string-advance (type $77) (param $0 (ref stringview_wtf8)) (param $1 i32) (param $2 i32) (result i32)
+ ;; CHECK:      (func $string-advance (type $79) (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)
@@ -4646,7 +4665,7 @@
   stringview_wtf8.advance
  )
 
- ;; CHECK:      (func $string-get (type $78) (param $0 stringview_wtf16) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-get (type $80) (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)
@@ -4658,7 +4677,7 @@
   stringview_wtf16.get_codeunit
  )
 
- ;; CHECK:      (func $string-iter-next (type $79) (param $0 stringview_iter) (result i32)
+ ;; CHECK:      (func $string-iter-next (type $81) (param $0 stringview_iter) (result i32)
  ;; CHECK-NEXT:  (stringview_iter.next
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
@@ -4668,7 +4687,7 @@
   stringview_iter.next
  )
 
- ;; CHECK:      (func $string-iter-advance (type $80) (param $0 stringview_iter) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-iter-advance (type $82) (param $0 stringview_iter) (param $1 i32) (result i32)
  ;; CHECK-NEXT:  (stringview_iter.advance
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4680,7 +4699,7 @@
   stringview_iter.advance
  )
 
- ;; CHECK:      (func $string-iter-rewind (type $81) (param $0 (ref stringview_iter)) (param $1 i32) (result i32)
+ ;; CHECK:      (func $string-iter-rewind (type $83) (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)
@@ -4692,7 +4711,7 @@
   stringview_iter.rewind
  )
 
- ;; CHECK:      (func $string-slice (type $82) (param $0 stringview_wtf8) (param $1 stringview_wtf16) (param $2 i32) (param $3 i32)
+ ;; CHECK:      (func $string-slice (type $84) (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)
@@ -4721,7 +4740,7 @@
   drop
  )
 
- ;; CHECK:      (func $string-iter-slice (type $83) (param $0 stringview_iter) (param $1 i32) (result (ref string))
+ ;; CHECK:      (func $string-iter-slice (type $85) (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)
@@ -4733,7 +4752,7 @@
   stringview_iter.slice
  )
 
- ;; CHECK:      (func $call (type $26) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $call (type $simple) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (call $call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4745,7 +4764,7 @@
   call $call
  )
 
- ;; CHECK:      (func $return_call (type $26) (param $0 i32) (param $1 i64) (result f32)
+ ;; CHECK:      (func $return_call (type $simple) (param $0 i32) (param $1 i64) (result f32)
  ;; CHECK-NEXT:  (return_call $return_call
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:   (local.get $1)
@@ -4786,7 +4805,7 @@
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (call_indirect $timport$0 (type $27)
+ ;; CHECK-NEXT:   (call_indirect $timport$0 (type $29)
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:    (local.get $0)
@@ -4848,7 +4867,7 @@
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (call_indirect $timport$0 (type $27)
+ ;; CHECK-NEXT:   (call_indirect $timport$0 (type $29)
  ;; CHECK-NEXT:    (local.get $1)
  ;; CHECK-NEXT:    (local.get $2)
  ;; CHECK-NEXT:    (local.get $0)
@@ -4920,7 +4939,7 @@
  ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $28)
+ ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $30)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $0)
@@ -4979,7 +4998,7 @@
  ;; CHECK-NEXT:  (return_call_indirect $funcs (type $void)
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $28)
+ ;; CHECK-NEXT:  (return_call_indirect $timport$0 (type $30)
  ;; CHECK-NEXT:   (local.get $1)
  ;; CHECK-NEXT:   (local.get $2)
  ;; CHECK-NEXT:   (local.get $0)
@@ -5020,7 +5039,48 @@
   )
  )
 
- ;; CHECK:      (func $use-types (type $95) (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 $resume (type $86) (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 $31) (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)
+ ;; CHECK-NEXT:          (i64.const 1)
+ ;; CHECK-NEXT:          (local.get $ct)
+ ;; CHECK-NEXT:         )
+ ;; CHECK-NEXT:        )
+ ;; CHECK-NEXT:        (unreachable)
+ ;; CHECK-NEXT:       )
+ ;; CHECK-NEXT:      )
+ ;; CHECK-NEXT:      (unreachable)
+ ;; CHECK-NEXT:     )
+ ;; CHECK-NEXT:    )
+ ;; CHECK-NEXT:    (br $label_1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $resume (param $ct (ref $simple-cont))
+  (local $f f32)
+  block (result (ref $to-f32-cont))
+   block (result i32 i64 (ref null $simple-cont))
+    i32.const 0
+    i64.const 1
+    local.get $ct
+    resume $simple-cont (tag $empty 1) (tag $tag-pair-to-pair 0)
+    local.set $f
+    unreachable
+   end
+   unreachable
+  end
+  br 0
+ )
+
+ ;; CHECK:      (func $use-types (type $100) (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