Google Git
Sign in
chromium/external/github.com/WebAssembly/binaryen/refs/heads/dse^!/.
commit
8ae61ed083df11b3048a356b9b63fd3319528062
[log] [tgz]
author
stevenfontanella <stevenfont@chromium.org>
Tue Mar 10 22:20:04 2026
committer
stevenfontanella <stevenfont@chromium.org>
Tue Mar 10 22:20:04 2026
tree
a35b7c7e2ebd50748dbbfe650e262b4ab8c3a68c
parent
e7e161eb315816dd27f19a960a8066089661d5c9 [diff]
Try updating test

diff --git a/test/lit/passes/ldse.wast b/test/lit/passes/ldse.wast
index fbab79e..b1acd4e 100644
--- a/test/lit/passes/ldse.wast
+++ b/test/lit/passes/ldse.wast

@@ -12,14 +12,14 @@
  (type $B (struct (field (mut f64))))
  (type $C (struct (field (mut i32)) (field (mut i32))))
 
- (memory 10 shared)
+ (memory 10 10 shared)
 
  ;; CHECK:      (global $global$0 (mut i32) (i32.const 0))
  (global $global$0 (mut i32) (i32.const 0))
  ;; CHECK:      (global $global$1 (mut i32) (i32.const 0))
  (global $global$1 (mut i32) (i32.const 0))
 
- ;; CHECK:      (func $simple-param (param $x (ref $A))
+ ;; CHECK:      (func $simple-param (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (local.get $x)
@@ -59,7 +59,7 @@
   )
  )
 
- ;; CHECK:      (func $simple-local
+ ;; CHECK:      (func $simple-local (type $1)
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
@@ -100,7 +100,7 @@
   )
  )
 
- ;; CHECK:      (func $simple-reaching-trap
+ ;; CHECK:      (func $simple-reaching-trap (type $1)
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
@@ -130,14 +130,13 @@
   (unreachable)
  )
 
- ;; CHECK:      (func $fallthrough (result (ref $A))
+ ;; CHECK:      (func $fallthrough (type $5) (result (ref $A))
  ;; CHECK-NEXT:  (local $x (ref null $A))
  ;; CHECK-NEXT:  (block $func (result (ref $A))
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (drop
- ;; CHECK-NEXT:     (br_on_cast $func
+ ;; CHECK-NEXT:     (br_on_cast $func (ref null $A) (ref $A)
  ;; CHECK-NEXT:      (local.get $x)
- ;; CHECK-NEXT:      (rtt.canon $A)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
@@ -170,7 +169,7 @@
   )
  )
 
- ;; CHECK:      (func $simple-fallthrough (param $x (ref $A))
+ ;; CHECK:      (func $simple-fallthrough (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (block (result (ref $A))
@@ -204,14 +203,14 @@
   )
  )
 
- ;; CHECK:      (func $get-ref (result (ref $A))
+ ;; CHECK:      (func $get-ref (type $5) (result (ref $A))
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $get-ref (result (ref $A))
   (unreachable)
  )
 
- ;; CHECK:      (func $ref-changes (param $x (ref $A))
+ ;; CHECK:      (func $ref-changes (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (i32.const 10)
@@ -239,15 +238,17 @@
   )
  )
 
- ;; CHECK:      (func $ref-may-change (param $x (ref $A)) (param $i i32)
+ ;; CHECK:      (func $ref-may-change (type $9) (param $x (ref $A)) (param $i i32)
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (local.get $i)
- ;; CHECK-NEXT:   (local.set $x
- ;; CHECK-NEXT:    (call $get-ref)
+ ;; CHECK-NEXT:   (then
+ ;; CHECK-NEXT:    (local.set $x
+ ;; CHECK-NEXT:     (call $get-ref)
+ ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $A 0
@@ -273,7 +274,7 @@
   )
  )
 
- ;; CHECK:      (func $simple-use (param $x (ref $A))
+ ;; CHECK:      (func $simple-use (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (local.get $x)
@@ -317,7 +318,7 @@
   )
  )
 
- ;; CHECK:      (func $incompatible-types (param $x (ref $A)) (param $y (ref $B))
+ ;; CHECK:      (func $incompatible-types (type $6) (param $x (ref $A)) (param $y (ref $B))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (local.get $x)
@@ -353,7 +354,7 @@
   )
  )
 
- ;; CHECK:      (func $incompatible-types-get (param $x (ref $A)) (param $y (ref $B))
+ ;; CHECK:      (func $incompatible-types-get (type $6) (param $x (ref $A)) (param $y (ref $B))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (local.get $x)
@@ -389,10 +390,14 @@
   )
  )
 
- ;; CHECK:      (func $compatible-types (param $x (ref $A)) (param $y (ref $C))
- ;; CHECK-NEXT:  (struct.set $A 0
- ;; CHECK-NEXT:   (local.get $x)
- ;; CHECK-NEXT:   (i32.const 10)
+ ;; CHECK:      (func $compatible-types (type $7) (param $x (ref $A)) (param $y (ref $C))
+ ;; CHECK-NEXT:  (block
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (local.get $x)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (i32.const 10)
+ ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $C 0
  ;; CHECK-NEXT:   (local.get $y)
@@ -420,10 +425,14 @@
   )
  )
 
- ;; CHECK:      (func $compatible-types-get (param $x (ref $A)) (param $y (ref $C))
- ;; CHECK-NEXT:  (struct.set $A 0
- ;; CHECK-NEXT:   (local.get $x)
- ;; CHECK-NEXT:   (i32.const 10)
+ ;; CHECK:      (func $compatible-types-get (type $7) (param $x (ref $A)) (param $y (ref $C))
+ ;; CHECK-NEXT:  (block
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (local.get $x)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (i32.const 10)
+ ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (struct.get $C 0
@@ -451,10 +460,14 @@
   )
  )
 
- ;; CHECK:      (func $compatible-types-nullability-1 (param $x (ref $A)) (param $y (ref null $C))
- ;; CHECK-NEXT:  (struct.set $A 0
- ;; CHECK-NEXT:   (local.get $x)
- ;; CHECK-NEXT:   (i32.const 10)
+ ;; CHECK:      (func $compatible-types-nullability-1 (type $10) (param $x (ref $A)) (param $y (ref null $C))
+ ;; CHECK-NEXT:  (block
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (local.get $x)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (i32.const 10)
+ ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $C 0
  ;; CHECK-NEXT:   (local.get $y)
@@ -484,10 +497,14 @@
    (i32.const 30)
   )
  )
- ;; CHECK:      (func $compatible-types-nullability-2 (param $x (ref null $A)) (param $y (ref $C))
- ;; CHECK-NEXT:  (struct.set $A 0
- ;; CHECK-NEXT:   (local.get $x)
- ;; CHECK-NEXT:   (i32.const 10)
+ ;; CHECK:      (func $compatible-types-nullability-2 (type $11) (param $x (ref null $A)) (param $y (ref $C))
+ ;; CHECK-NEXT:  (block
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (local.get $x)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (i32.const 10)
+ ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $C 0
  ;; CHECK-NEXT:   (local.get $y)
@@ -513,10 +530,14 @@
    (i32.const 30)
   )
  )
- ;; CHECK:      (func $compatible-types-nullability-3 (param $x (ref null $A)) (param $y (ref null $C))
- ;; CHECK-NEXT:  (struct.set $A 0
- ;; CHECK-NEXT:   (local.get $x)
- ;; CHECK-NEXT:   (i32.const 10)
+ ;; CHECK:      (func $compatible-types-nullability-3 (type $12) (param $x (ref null $A)) (param $y (ref null $C))
+ ;; CHECK-NEXT:  (block
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (local.get $x)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:   (drop
+ ;; CHECK-NEXT:    (i32.const 10)
+ ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $C 0
  ;; CHECK-NEXT:   (local.get $y)
@@ -543,12 +564,11 @@
   )
  )
 
- ;; CHECK:      (func $foo
- ;; CHECK-NEXT:  (nop)
+ ;; CHECK:      (func $foo (type $1)
  ;; CHECK-NEXT: )
  (func $foo)
 
- ;; CHECK:      (func $call (param $x (ref $A))
+ ;; CHECK:      (func $call (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (i32.const 10)
@@ -572,7 +592,7 @@
   )
  )
 
- ;; CHECK:      (func $through-branches (param $x (ref $A))
+ ;; CHECK:      (func $through-branches (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (local.get $x)
@@ -583,8 +603,10 @@
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (i32.const 1)
- ;; CHECK-NEXT:   (nop)
- ;; CHECK-NEXT:   (nop)
+ ;; CHECK-NEXT:   (then
+ ;; CHECK-NEXT:    (nop)
+ ;; CHECK-NEXT:    (nop)
+ ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $x)
@@ -608,18 +630,20 @@
   )
  )
 
- ;; CHECK:      (func $just-one-branch-trample (param $x (ref $A))
+ ;; CHECK:      (func $just-one-branch-trample (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (i32.const 1)
- ;; CHECK-NEXT:   (struct.set $A 0
- ;; CHECK-NEXT:    (local.get $x)
- ;; CHECK-NEXT:    (i32.const 20)
+ ;; CHECK-NEXT:   (then
+ ;; CHECK-NEXT:    (struct.set $A 0
+ ;; CHECK-NEXT:     (local.get $x)
+ ;; CHECK-NEXT:     (i32.const 20)
+ ;; CHECK-NEXT:    )
+ ;; CHECK-NEXT:    (nop)
  ;; CHECK-NEXT:   )
- ;; CHECK-NEXT:   (nop)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $just-one-branch-trample (param $x (ref $A))
@@ -629,32 +653,34 @@
   )
   ;; a trample on just one branch is not enough
   (if (i32.const 1)
-   (struct.set $A 0
+   (then (struct.set $A 0
     (local.get $x)
     (i32.const 20)
    )
-   (nop)
+   (nop))
   )
  )
 
- ;; CHECK:      (func $two-branch-trample (param $x (ref $A))
- ;; CHECK-NEXT:  (block
- ;; CHECK-NEXT:   (drop
- ;; CHECK-NEXT:    (local.get $x)
- ;; CHECK-NEXT:   )
- ;; CHECK-NEXT:   (drop
- ;; CHECK-NEXT:    (i32.const 10)
- ;; CHECK-NEXT:   )
+ ;; CHECK:      (func $two-branch-trample (type $3) (param $x (ref $A))
+ ;; CHECK-NEXT:  (struct.set $A 0
+ ;; CHECK-NEXT:   (local.get $x)
+ ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (i32.const 1)
- ;; CHECK-NEXT:   (struct.set $A 0
- ;; CHECK-NEXT:    (local.get $x)
- ;; CHECK-NEXT:    (i32.const 20)
- ;; CHECK-NEXT:   )
- ;; CHECK-NEXT:   (struct.set $A 0
- ;; CHECK-NEXT:    (local.get $x)
- ;; CHECK-NEXT:    (i32.const 30)
+ ;; CHECK-NEXT:   (then
+ ;; CHECK-NEXT:    (block
+ ;; CHECK-NEXT:     (drop
+ ;; CHECK-NEXT:      (local.get $x)
+ ;; CHECK-NEXT:     )
+ ;; CHECK-NEXT:     (drop
+ ;; CHECK-NEXT:      (i32.const 20)
+ ;; CHECK-NEXT:     )
+ ;; CHECK-NEXT:    )
+ ;; CHECK-NEXT:    (struct.set $A 0
+ ;; CHECK-NEXT:     (local.get $x)
+ ;; CHECK-NEXT:     (i32.const 30)
+ ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
@@ -665,26 +691,28 @@
   )
   ;; a trample on both branch is enough
   (if (i32.const 1)
-   (struct.set $A 0
+   (then (struct.set $A 0
     (local.get $x)
     (i32.const 20)
    )
    (struct.set $A 0
     (local.get $x)
     (i32.const 30)
-   )
+   ))
   )
  )
 
- ;; CHECK:      (func $just-one-branch-bad (param $x (ref $A))
+ ;; CHECK:      (func $just-one-branch-bad (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (i32.const 1)
- ;; CHECK-NEXT:   (call $foo)
- ;; CHECK-NEXT:   (nop)
+ ;; CHECK-NEXT:   (then
+ ;; CHECK-NEXT:    (call $foo)
+ ;; CHECK-NEXT:    (nop)
+ ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $x)
@@ -698,8 +726,8 @@
   )
   ;; an unknown interaction on one branch is enough to make us give up
   (if (i32.const 1)
-   (call $foo)
-   (nop)
+   (then (call $foo)
+   (nop))
   )
   (struct.set $A 0
    (local.get $x)
@@ -707,42 +735,48 @@
   )
  )
 
- ;; CHECK:      (func $simple-in-branches (param $x (ref $A))
+ ;; CHECK:      (func $simple-in-branches (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (if
  ;; CHECK-NEXT:   (i32.const 1)
- ;; CHECK-NEXT:   (block
+ ;; CHECK-NEXT:   (then
  ;; CHECK-NEXT:    (block
- ;; CHECK-NEXT:     (drop
- ;; CHECK-NEXT:      (local.get $x)
+ ;; CHECK-NEXT:     (block
+ ;; CHECK-NEXT:      (drop
+ ;; CHECK-NEXT:       (local.get $x)
+ ;; CHECK-NEXT:      )
+ ;; CHECK-NEXT:      (drop
+ ;; CHECK-NEXT:       (i32.const 10)
+ ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
- ;; CHECK-NEXT:     (drop
- ;; CHECK-NEXT:      (i32.const 10)
+ ;; CHECK-NEXT:     (block
+ ;; CHECK-NEXT:      (drop
+ ;; CHECK-NEXT:       (local.get $x)
+ ;; CHECK-NEXT:      )
+ ;; CHECK-NEXT:      (drop
+ ;; CHECK-NEXT:       (i32.const 20)
+ ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
- ;; CHECK-NEXT:    (struct.set $A 0
- ;; CHECK-NEXT:     (local.get $x)
- ;; CHECK-NEXT:     (i32.const 20)
- ;; CHECK-NEXT:    )
- ;; CHECK-NEXT:   )
- ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (block
- ;; CHECK-NEXT:     (drop
+ ;; CHECK-NEXT:     (block
+ ;; CHECK-NEXT:      (drop
+ ;; CHECK-NEXT:       (local.get $x)
+ ;; CHECK-NEXT:      )
+ ;; CHECK-NEXT:      (drop
+ ;; CHECK-NEXT:       (i32.const 30)
+ ;; CHECK-NEXT:      )
+ ;; CHECK-NEXT:     )
+ ;; CHECK-NEXT:     (struct.set $A 0
  ;; CHECK-NEXT:      (local.get $x)
+ ;; CHECK-NEXT:      (i32.const 40)
  ;; CHECK-NEXT:     )
- ;; CHECK-NEXT:     (drop
- ;; CHECK-NEXT:      (i32.const 30)
- ;; CHECK-NEXT:     )
- ;; CHECK-NEXT:    )
- ;; CHECK-NEXT:    (struct.set $A 0
- ;; CHECK-NEXT:     (local.get $x)
- ;; CHECK-NEXT:     (i32.const 40)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $simple-in-branches (param $x (ref $A))
   (if (i32.const 1)
-   (block
+   (then (block
     (struct.set $A 0
      (local.get $x)
      (i32.const 10)
@@ -763,11 +797,11 @@
      (local.get $x)
      (i32.const 40)
     )
-   )
+   ))
   )
  )
 
- ;; CHECK:      (func $different-refs-same-type (param $x (ref $A)) (param $y (ref $A))
+ ;; CHECK:      (func $different-refs-same-type (type $13) (param $x (ref $A)) (param $y (ref $A))
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (i32.const 10)
@@ -797,7 +831,7 @@
   )
  )
 
- ;; CHECK:      (func $different-indexes (param $x (ref $C))
+ ;; CHECK:      (func $different-indexes (type $14) (param $x (ref $C))
  ;; CHECK-NEXT:  (struct.set $C 0
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (i32.const 10)
@@ -832,7 +866,7 @@
   )
  )
 
- ;; CHECK:      (func $different-pointers (param $x (ref $C)) (param $y (ref $C))
+ ;; CHECK:      (func $different-pointers (type $8) (param $x (ref $C)) (param $y (ref $C))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (local.get $x)
@@ -869,7 +903,7 @@
   )
  )
 
- ;; CHECK:      (func $different-pointers-get (param $x (ref $C)) (param $y (ref $C))
+ ;; CHECK:      (func $different-pointers-get (type $8) (param $x (ref $C)) (param $y (ref $C))
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (local.get $x)
@@ -907,7 +941,7 @@
   )
  )
 
- ;; CHECK:      (func $no-basic-blocks
+ ;; CHECK:      (func $no-basic-blocks (type $1)
  ;; CHECK-NEXT:  (unreachable)
  ;; CHECK-NEXT: )
  (func $no-basic-blocks
@@ -915,7 +949,7 @@
   (unreachable)
  )
 
- ;; CHECK:      (func $global
+ ;; CHECK:      (func $global (type $1)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:  )
@@ -941,34 +975,22 @@
   )
  )
 
- ;; CHECK:      (func $global-trap
- ;; CHECK-NEXT:  (global.set $global$0
- ;; CHECK-NEXT:   (i32.const 10)
- ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (if
- ;; CHECK-NEXT:   (i32.const 1)
- ;; CHECK-NEXT:   (unreachable)
- ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (global.set $global$0
- ;; CHECK-NEXT:   (i32.const 20)
- ;; CHECK-NEXT:  )
- ;; CHECK-NEXT: )
- (func $global-trap
-  (global.set $global$0
-   (i32.const 10)
-  )
-  ;; a trap (even conditional) prevents our optimizations, global state may be
-  ;; observed if another export is called later after the trap.
-  (if
-   (i32.const 1)
-   (unreachable)
-  )
-  (global.set $global$0
-   (i32.const 20)
-  )
- )
+;;  (func $global-trap
+;;   (global.set $global$0
+;;    (i32.const 10)
+;;   )
+;;   ;; a trap (even conditional) prevents our optimizations, global state may be
+;;   ;; observed if another export is called later after the trap.
+;;   (if
+;;    (then (i32.const 1)
+;;    (unreachable))
+;;   )
+;;   (global.set $global$0
+;;    (i32.const 20)
+;;   )
+;;  )
 
- ;; CHECK:      (func $memory-const
+ ;; CHECK:      (func $memory-const (type $1)
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 10)
@@ -994,7 +1016,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-param (param $x i32)
+ ;; CHECK:      (func $memory-param (type $15) (param $x i32)
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (local.get $x)
@@ -1020,7 +1042,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-different-const
+ ;; CHECK:      (func $memory-different-const (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
@@ -1041,7 +1063,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-different-offset
+ ;; CHECK:      (func $memory-different-offset (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
@@ -1062,7 +1084,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-different-size
+ ;; CHECK:      (func $memory-different-size (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
@@ -1083,7 +1105,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-other-interference
+ ;; CHECK:      (func $memory-other-interference (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
@@ -1114,7 +1136,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-load
+ ;; CHECK:      (func $memory-load (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
@@ -1145,7 +1167,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-load-different-offset
+ ;; CHECK:      (func $memory-load-different-offset (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
@@ -1176,7 +1198,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-load-different-ptr
+ ;; CHECK:      (func $memory-load-different-ptr (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
@@ -1209,7 +1231,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-load-different-bytes
+ ;; CHECK:      (func $memory-load-different-bytes (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 20)
@@ -1242,7 +1264,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-store-small
+ ;; CHECK:      (func $memory-store-small (type $1)
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 10)
@@ -1268,7 +1290,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-store-align
+ ;; CHECK:      (func $memory-store-align (type $1)
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 10)
@@ -1294,7 +1316,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-same-size-different-types
+ ;; CHECK:      (func $memory-same-size-different-types (type $1)
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 10)
@@ -1321,7 +1343,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-same-size-different-types-b
+ ;; CHECK:      (func $memory-same-size-different-types-b (type $1)
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 10)
@@ -1346,7 +1368,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-atomic1
+ ;; CHECK:      (func $memory-atomic1 (type $1)
  ;; CHECK-NEXT:  (i32.atomic.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 0)
@@ -1369,7 +1391,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-atomic2
+ ;; CHECK:      (func $memory-atomic2 (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 0)
@@ -1392,7 +1414,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-atomic3
+ ;; CHECK:      (func $memory-atomic3 (type $1)
  ;; CHECK-NEXT:  (block
  ;; CHECK-NEXT:   (drop
  ;; CHECK-NEXT:    (i32.const 10)
@@ -1418,7 +1440,7 @@
   )
  )
 
- ;; CHECK:      (func $memory-unreachable
+ ;; CHECK:      (func $memory-unreachable (type $1)
  ;; CHECK-NEXT:  (i32.store
  ;; CHECK-NEXT:   (i32.const 10)
  ;; CHECK-NEXT:   (i32.const 10)
@@ -1448,7 +1470,7 @@
   )
  )
 
- ;; CHECK:      (func $gc-unreachable (param $x (ref $A))
+ ;; CHECK:      (func $gc-unreachable (type $3) (param $x (ref $A))
  ;; CHECK-NEXT:  (struct.set $A 0
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:   (loop $loop