diff options
| author | Thomas Lively <tlively@google.com> | 2023-09-08 20:08:33 -0500 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2023-09-09 01:08:33 +0000 |
| commit | 4e58466b40b65cda399b4749105f0ce10f48f62b (patch) | |
| tree | 9e34ae5ed464d87d75683603171e7b2645015568 /test/lit | |
| parent | 90571051b3d6f89eab184df3d4dd716472a6cd7c (diff) | |
| download | binaryen-4e58466b40b65cda399b4749105f0ce10f48f62b.tar.gz binaryen-4e58466b40b65cda399b4749105f0ce10f48f62b.tar.bz2 binaryen-4e58466b40b65cda399b4749105f0ce10f48f62b.zip | |
Make final types the default (#5918)
Match the spec and parse the shorthand binary and text formats as final and emit
final types without supertypes using the shorthands as well. This is a
potentially-breaking change, since the text and binary shorthands can no longer
be used to define types that have subtypes.
Also make TypeBuilder entries final by default to better match the spec and
update the internal APIs to use the "open" terminology rather than "final"
terminology. Future changes will update the text format to use the standard "sub
open" rather than the current "sub final" keywords. The exception is the new wat
parser, which supporst "sub open" as of this change, since it didn't support
final types at all previously.
Diffstat (limited to 'test/lit')
53 files changed, 601 insertions, 603 deletions
diff --git a/test/lit/fuzz-types.test b/test/lit/fuzz-types.test index 494aa996f..ae5c00019 100644 --- a/test/lit/fuzz-types.test +++ b/test/lit/fuzz-types.test @@ -1,59 +1,60 @@ ;; RUN: wasm-fuzz-types -v --seed=0 | filecheck %s -;; CHECK: Built 20 types: +;; CHECK: Running with seed 0 +;; CHECK-NEXT: Built 20 types: ;; CHECK-NEXT: (rec -;; CHECK-NEXT: (type $0 (struct (field i32))) -;; CHECK-NEXT: (type $1 (func (param (ref $2)) (result externref))) -;; CHECK-NEXT: (type $2 (struct )) +;; CHECK-NEXT: (type $0 (sub (struct (field i32)))) +;; CHECK-NEXT: (type $1 (sub (func (param (ref $2)) (result externref)))) +;; CHECK-NEXT: (type $2 (sub (struct ))) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (rec ;; CHECK-NEXT: (type $3 (sub $0 (struct (field i32) (field (ref $5)) (field (ref $5))))) -;; CHECK-NEXT: (type $4 (sub final $3 (struct (field i32) (field (ref $5)) (field (ref $5)) (field i8) (field (ref null $13)) (field (mut i64))))) -;; CHECK-NEXT: (type $5 (array (mut f64))) -;; CHECK-NEXT: (type $6 (sub final $1 (func (param anyref) (result externref)))) -;; CHECK-NEXT: (type $7 (sub $2 (struct (field (mut (ref null $14))) (field (ref $3))))) +;; CHECK-NEXT: (type $4 (sub $3 (struct (field i32) (field (ref $5)) (field (ref $5)) (field i8) (field (ref null $13)) (field (mut i64))))) +;; CHECK-NEXT: (type $5 (sub (array (mut f64)))) +;; CHECK-NEXT: (type $6 (sub $1 (func (param anyref) (result externref)))) +;; CHECK-NEXT: (type $7 (sub final $2 (struct (field (mut (ref null $14))) (field (ref $3))))) ;; CHECK-NEXT: (type $8 (sub $1 (func (param (ref struct)) (result (ref extern))))) ;; CHECK-NEXT: (type $9 (sub $5 (array (mut f64)))) -;; CHECK-NEXT: (type $10 (sub $8 (func (param (ref any)) (result (ref noextern))))) -;; CHECK-NEXT: (type $11 (array (mut anyref))) +;; CHECK-NEXT: (type $10 (sub final $8 (func (param (ref any)) (result (ref noextern))))) +;; CHECK-NEXT: (type $11 (sub (array (mut anyref)))) ;; CHECK-NEXT: (type $12 (sub $2 (struct (field (mut f64))))) -;; CHECK-NEXT: (type $13 (sub $1 (func (param (ref $2)) (result (ref extern))))) +;; CHECK-NEXT: (type $13 (sub final $1 (func (param (ref $2)) (result (ref extern))))) ;; CHECK-NEXT: (type $14 (array (mut (ref null $14)))) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (rec -;; CHECK-NEXT: (type $15 (sub $11 (array (mut anyref)))) -;; CHECK-NEXT: (type $16 (sub $12 (struct (field (mut f64))))) -;; CHECK-NEXT: (type $17 (sub final (struct (field f32) (field (mut i32)) (field i8) (field (ref array))))) -;; CHECK-NEXT: (type $18 (sub final $11 (array (mut anyref)))) -;; CHECK-NEXT: (type $19 (sub $9 (array (mut f64)))) +;; CHECK-NEXT: (type $15 (sub final $11 (array (mut anyref)))) +;; CHECK-NEXT: (type $16 (sub final $12 (struct (field (mut f64))))) +;; CHECK-NEXT: (type $17 (sub (struct (field f32) (field (mut i32)) (field i8) (field (ref array))))) +;; CHECK-NEXT: (type $18 (sub $11 (array (mut anyref)))) +;; CHECK-NEXT: (type $19 (sub final $9 (array (mut f64)))) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ;; CHECK-NEXT: Inhabitable types: ;; CHECK-NEXT: ;; CHECK-NEXT: Built 20 types: ;; CHECK-NEXT: (rec -;; CHECK-NEXT: (type $0 (struct (field i32))) -;; CHECK-NEXT: (type $1 (func (param (ref $2)) (result externref))) -;; CHECK-NEXT: (type $2 (struct )) +;; CHECK-NEXT: (type $0 (sub (struct (field i32)))) +;; CHECK-NEXT: (type $1 (sub (func (param (ref $2)) (result externref)))) +;; CHECK-NEXT: (type $2 (sub (struct ))) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (rec ;; CHECK-NEXT: (type $3 (sub $0 (struct (field i32) (field (ref $5)) (field (ref $5))))) -;; CHECK-NEXT: (type $4 (sub final $3 (struct (field i32) (field (ref $5)) (field (ref $5)) (field i8) (field (ref null $13)) (field (mut i64))))) -;; CHECK-NEXT: (type $5 (array (mut f64))) -;; CHECK-NEXT: (type $6 (sub final $1 (func (param anyref) (result externref)))) -;; CHECK-NEXT: (type $7 (sub $2 (struct (field (mut (ref null $14))) (field (ref $3))))) +;; CHECK-NEXT: (type $4 (sub $3 (struct (field i32) (field (ref $5)) (field (ref $5)) (field i8) (field (ref null $13)) (field (mut i64))))) +;; CHECK-NEXT: (type $5 (sub (array (mut f64)))) +;; CHECK-NEXT: (type $6 (sub $1 (func (param anyref) (result externref)))) +;; CHECK-NEXT: (type $7 (sub final $2 (struct (field (mut (ref null $14))) (field (ref $3))))) ;; CHECK-NEXT: (type $8 (sub $1 (func (param (ref struct)) (result (ref extern))))) ;; CHECK-NEXT: (type $9 (sub $5 (array (mut f64)))) -;; CHECK-NEXT: (type $10 (sub $8 (func (param (ref any)) (result (ref noextern))))) -;; CHECK-NEXT: (type $11 (array (mut anyref))) +;; CHECK-NEXT: (type $10 (sub final $8 (func (param (ref any)) (result (ref noextern))))) +;; CHECK-NEXT: (type $11 (sub (array (mut anyref)))) ;; CHECK-NEXT: (type $12 (sub $2 (struct (field (mut f64))))) -;; CHECK-NEXT: (type $13 (sub $1 (func (param (ref $2)) (result (ref extern))))) +;; CHECK-NEXT: (type $13 (sub final $1 (func (param (ref $2)) (result (ref extern))))) ;; CHECK-NEXT: (type $14 (array (mut (ref null $14)))) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (rec -;; CHECK-NEXT: (type $15 (sub $11 (array (mut anyref)))) -;; CHECK-NEXT: (type $16 (sub $12 (struct (field (mut f64))))) -;; CHECK-NEXT: (type $17 (sub final (struct (field f32) (field (mut i32)) (field i8) (field (ref array))))) -;; CHECK-NEXT: (type $18 (sub final $11 (array (mut anyref)))) -;; CHECK-NEXT: (type $19 (sub $9 (array (mut f64)))) -;; CHECK-NEXT: ) +;; CHECK-NEXT: (type $15 (sub final $11 (array (mut anyref)))) +;; CHECK-NEXT: (type $16 (sub final $12 (struct (field (mut f64))))) +;; CHECK-NEXT: (type $17 (sub (struct (field f32) (field (mut i32)) (field i8) (field (ref array))))) +;; CHECK-NEXT: (type $18 (sub $11 (array (mut anyref)))) +;; CHECK-NEXT: (type $19 (sub final $9 (array (mut f64)))) +) diff --git a/test/lit/isorecursive-good.wast b/test/lit/isorecursive-good.wast index 10dc7726b..43caeb7d1 100644 --- a/test/lit/isorecursive-good.wast +++ b/test/lit/isorecursive-good.wast @@ -6,7 +6,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $super-struct (struct (field i32))) + ;; CHECK-NEXT: (type $super-struct (sub (struct (field i32)))) (type $super-struct (sub (struct i32))) ;; CHECK: (type $sub-struct (sub $super-struct (struct (field i32) (field i64)))) (type $sub-struct (sub $super-struct (struct i32 i64))) @@ -16,7 +16,7 @@ (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $super-array (array (ref $super-struct))) + ;; CHECK-NEXT: (type $super-array (sub (array (ref $super-struct)))) (type $super-array (sub (array (ref $super-struct)))) ;; CHECK: (type $sub-array (sub $super-array (array (ref $sub-struct)))) (type $sub-array (sub $super-array (array (ref $sub-struct)))) @@ -26,7 +26,7 @@ (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $super-func (func (param (ref $sub-array)) (result (ref $super-array)))) + ;; CHECK-NEXT: (type $super-func (sub (func (param (ref $sub-array)) (result (ref $super-array))))) (type $super-func (sub (func (param (ref $sub-array)) (result (ref $super-array))))) ;; CHECK: (type $sub-func (sub $super-func (func (param (ref $super-array)) (result (ref $sub-array))))) (type $sub-func (sub $super-func (func (param (ref $super-array)) (result (ref $sub-array))))) @@ -34,7 +34,7 @@ (type $final-func (sub final $sub-func (func (param (ref $super-array)) (result (ref $final-array))))) ) - ;; CHECK: (type $final-root (sub final (struct ))) + ;; CHECK: (type $final-root (struct )) (type $final-root (sub final (struct))) ;; CHECK: (func $make-super-struct (type $6) (result (ref $super-struct)) diff --git a/test/lit/isorecursive-output-ordering.wast b/test/lit/isorecursive-output-ordering.wast index 5379cec44..43bda9a21 100644 --- a/test/lit/isorecursive-output-ordering.wast +++ b/test/lit/isorecursive-output-ordering.wast @@ -9,22 +9,22 @@ (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $unused-6 (struct )) + ;; CHECK-NEXT: (type $unused-6 (sub (struct ))) - ;; CHECK: (type $used-a-bit (struct )) + ;; CHECK: (type $used-a-bit (sub (struct ))) ;; CHECK: (rec - ;; CHECK-NEXT: (type $unused-1 (struct )) + ;; CHECK-NEXT: (type $unused-1 (sub (struct ))) (type $unused-1 (struct_subtype data)) - ;; CHECK: (type $unused-2 (struct )) + ;; CHECK: (type $unused-2 (sub (struct ))) (type $unused-2 (struct_subtype data)) - ;; CHECK: (type $unused-3 (struct )) + ;; CHECK: (type $unused-3 (sub (struct ))) (type $unused-3 (struct_subtype data)) - ;; CHECK: (type $unused-4 (struct )) + ;; CHECK: (type $unused-4 (sub (struct ))) (type $unused-4 (struct_subtype data)) - ;; CHECK: (type $used-a-lot (struct )) + ;; CHECK: (type $used-a-lot (sub (struct ))) (type $used-a-lot (struct_subtype data)) - ;; CHECK: (type $unused-5 (struct )) + ;; CHECK: (type $unused-5 (sub (struct ))) (type $unused-5 (struct_subtype data)) ) @@ -47,9 +47,9 @@ (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $leaf (struct )) + ;; CHECK-NEXT: (type $leaf (sub (struct ))) (type $leaf (struct_subtype data)) - ;; CHECK: (type $unused (struct )) + ;; CHECK: (type $unused (sub (struct ))) (type $unused (struct_subtype data)) ) @@ -57,12 +57,12 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $shrub (sub $leaf (struct ))) - ;; CHECK: (type $used-a-ton (struct )) + ;; CHECK: (type $used-a-ton (sub (struct ))) ;; CHECK: (rec - ;; CHECK-NEXT: (type $twig (struct )) + ;; CHECK-NEXT: (type $twig (sub (struct ))) (type $twig (struct_subtype data)) - ;; CHECK: (type $used-a-bit (struct (field (ref $leaf)))) + ;; CHECK: (type $used-a-bit (sub (struct (field (ref $leaf))))) (type $used-a-bit (struct_subtype (ref $leaf) data)) ) @@ -73,7 +73,7 @@ (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $root (struct )) + ;; CHECK-NEXT: (type $root (sub (struct ))) (type $root (struct_subtype data)) ;; CHECK: (type $used-a-lot (sub $twig (struct ))) (type $used-a-lot (struct_subtype $twig)) @@ -99,7 +99,7 @@ ;; Test that basic heap type children do not trigger assertions. (rec - ;; CHECK: (type $contains-basic (struct (field (ref any)))) + ;; CHECK: (type $contains-basic (sub (struct (field (ref any))))) (type $contains-basic (struct_subtype (ref any) data)) ) diff --git a/test/lit/isorecursive-singleton-group.wast b/test/lit/isorecursive-singleton-group.wast index 0f73477b9..6462b0288 100644 --- a/test/lit/isorecursive-singleton-group.wast +++ b/test/lit/isorecursive-singleton-group.wast @@ -10,7 +10,7 @@ (rec - ;; CHECK: (type $singleton (struct )) + ;; CHECK: (type $singleton (sub (struct ))) (type $singleton (struct_subtype data)) ) diff --git a/test/lit/isorecursive-whole-group.wast b/test/lit/isorecursive-whole-group.wast index 14ce524ff..4900d0ad9 100644 --- a/test/lit/isorecursive-whole-group.wast +++ b/test/lit/isorecursive-whole-group.wast @@ -9,9 +9,9 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $used (struct )) + ;; CHECK-NEXT: (type $used (sub (struct ))) (type $used (struct_subtype data)) - ;; CHECK: (type $unused (struct )) + ;; CHECK: (type $unused (sub (struct ))) (type $unused (struct_subtype data)) ) diff --git a/test/lit/parse-nominal-types-extends.wast b/test/lit/parse-nominal-types-extends.wast index 51341dfd0..5ce3ffa91 100644 --- a/test/lit/parse-nominal-types-extends.wast +++ b/test/lit/parse-nominal-types-extends.wast @@ -7,8 +7,8 @@ ;; void function type (module - ;; CHECK: (type $super (func)) - (type $super (func)) + ;; CHECK: (type $super (sub (func))) + (type $super (sub (func))) ;; CHECK: (type $sub (sub $super (func))) (type $sub (func) (extends $super)) @@ -19,8 +19,8 @@ ;; function type with params and results (module - ;; CHECK: (type $super (func (param i32) (result i32))) - (type $super (func (param i32) (result i32))) + ;; CHECK: (type $super (sub (func (param i32) (result i32)))) + (type $super (sub (func (param i32) (result i32)))) ;; CHECK: (type $sub (sub $super (func (param i32) (result i32)))) (type $sub (func (param i32) (result i32)) (extends $super)) @@ -31,8 +31,8 @@ ;; empty struct type (module - ;; CHECK: (type $super (struct )) - (type $super (struct)) + ;; CHECK: (type $super (sub (struct ))) + (type $super (sub (struct))) ;; CHECK: (type $sub (sub $super (struct ))) (type $sub (struct) (extends $super)) @@ -43,8 +43,8 @@ ;; struct type with fields (module - ;; CHECK: (type $super (struct (field i32) (field i64))) - (type $super (struct (field i32) i64)) + ;; CHECK: (type $super (sub (struct (field i32) (field i64)))) + (type $super (sub (struct (field i32) i64))) ;; CHECK: (type $sub (sub $super (struct (field i32) (field i64)))) (type $sub (struct i32 (field i64)) (extends $super)) @@ -55,8 +55,8 @@ ;; array type (module - ;; CHECK: (type $super (array i8)) - (type $super (array i8)) + ;; CHECK: (type $super (sub (array i8))) + (type $super (sub (array i8))) ;; CHECK: (type $sub (sub $super (array i8))) (type $sub (array i8) (extends $super)) diff --git a/test/lit/parse-nominal-types.wast b/test/lit/parse-nominal-types.wast index f43c12950..2b753303e 100644 --- a/test/lit/parse-nominal-types.wast +++ b/test/lit/parse-nominal-types.wast @@ -7,7 +7,7 @@ ;; void function type (module - ;; CHECK: (type $super (func)) + ;; CHECK: (type $super (sub (func))) (type $super (func_subtype func)) ;; CHECK: (type $sub (sub $super (func))) @@ -19,7 +19,7 @@ ;; function type with params and results (module - ;; CHECK: (type $super (func (param i32) (result i32))) + ;; CHECK: (type $super (sub (func (param i32) (result i32)))) (type $super (func_subtype (param i32) (result i32) func)) ;; CHECK: (type $sub (sub $super (func (param i32) (result i32)))) @@ -31,7 +31,7 @@ ;; empty struct type (module - ;; CHECK: (type $super (struct )) + ;; CHECK: (type $super (sub (struct ))) (type $super (struct_subtype data)) ;; CHECK: (type $sub (sub $super (struct ))) @@ -43,7 +43,7 @@ ;; struct type with fields (module - ;; CHECK: (type $super (struct (field i32) (field i64))) + ;; CHECK: (type $super (sub (struct (field i32) (field i64)))) (type $super (struct_subtype (field i32) i64 data)) ;; CHECK: (type $sub (sub $super (struct (field i32) (field i64)))) @@ -55,7 +55,7 @@ ;; array type (module - ;; CHECK: (type $super (array i8)) + ;; CHECK: (type $super (sub (array i8))) (type $super (array_subtype i8 data)) ;; CHECK: (type $sub (sub $super (array i8))) diff --git a/test/lit/passes/abstract-type-refining.wast b/test/lit/passes/abstract-type-refining.wast index 64b7ff214..274909605 100644 --- a/test/lit/passes/abstract-type-refining.wast +++ b/test/lit/passes/abstract-type-refining.wast @@ -14,13 +14,13 @@ ;; NO_TNH: (rec ;; NO_TNH-NEXT: (type $0 (func)) - ;; NO_TNH: (type $A (struct )) - (type $A (struct)) + ;; NO_TNH: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; YESTNH: (rec ;; YESTNH-NEXT: (type $0 (func)) - ;; YESTNH: (type $B (struct )) + ;; YESTNH: (type $B (sub (struct ))) ;; NO_TNH: (type $B (sub $A (struct ))) (type $B (struct_subtype $A)) @@ -264,10 +264,10 @@ (module (rec ;; YESTNH: (rec - ;; YESTNH-NEXT: (type $A (struct )) + ;; YESTNH-NEXT: (type $A (sub (struct ))) ;; NO_TNH: (rec - ;; NO_TNH-NEXT: (type $A (struct )) - (type $A (struct)) + ;; NO_TNH-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; YESTNH: (type $B1 (sub $A (struct ))) @@ -362,13 +362,13 @@ (module (rec ;; NO_TNH: (rec - ;; NO_TNH-NEXT: (type $A (struct )) - (type $A (struct)) + ;; NO_TNH-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) (type $B (struct_subtype $A)) ;; YESTNH: (rec - ;; YESTNH-NEXT: (type $B1 (struct )) + ;; YESTNH-NEXT: (type $B1 (sub (struct ))) ;; NO_TNH: (type $B1 (sub $A (struct ))) (type $B1 (struct_subtype $A)) ;; this is a new type ) @@ -449,14 +449,14 @@ ;; A chain, $A :> $B :> $C, where we can optimize $A all the way to $C. (module ;; NO_TNH: (rec - ;; NO_TNH-NEXT: (type $A (struct )) - (type $A (struct)) + ;; NO_TNH-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; NO_TNH: (type $B (sub $A (struct ))) (type $B (struct_subtype $A)) ;; YESTNH: (rec - ;; YESTNH-NEXT: (type $C (struct )) + ;; YESTNH-NEXT: (type $C (sub (struct ))) ;; NO_TNH: (type $C (sub $B (struct ))) (type $C (struct_subtype $B)) @@ -537,7 +537,7 @@ ;; created here. No type needs to be emitted in the output. (module (rec - (type $A (struct)) + (type $A (sub (struct))) (type $B (struct_subtype $A)) @@ -824,8 +824,8 @@ ;; NO_TNH: (rec ;; NO_TNH-NEXT: (type $0 (func (param anyref))) - ;; NO_TNH: (type $A (struct )) - (type $A (struct)) + ;; NO_TNH: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; NO_TNH: (type $B (sub $A (struct ))) (type $B (struct_subtype $A)) @@ -833,7 +833,7 @@ ;; YESTNH: (rec ;; YESTNH-NEXT: (type $0 (func (param anyref))) - ;; YESTNH: (type $C1 (struct )) + ;; YESTNH: (type $C1 (sub (struct ))) ;; NO_TNH: (type $C1 (sub $B (struct ))) (type $C1 (struct_subtype $B)) @@ -986,10 +986,10 @@ ;; Function subtyping, which is a TODO - for now we do nothing. (module ;; YESTNH: (rec - ;; YESTNH-NEXT: (type $A (func)) + ;; YESTNH-NEXT: (type $A (sub (func))) ;; NO_TNH: (rec - ;; NO_TNH-NEXT: (type $A (func)) - (type $A (func)) + ;; NO_TNH-NEXT: (type $A (sub (func))) + (type $A (sub (func))) ;; YESTNH: (type $B (sub $A (func))) ;; NO_TNH: (type $B (sub $A (func))) @@ -1079,9 +1079,9 @@ ;; As above, but now the functions are also public types (exported). We should ;; be careful here in the future even when we do optimize function types. (module - ;; YESTNH: (type $A (func)) - ;; NO_TNH: (type $A (func)) - (type $A (func)) + ;; YESTNH: (type $A (sub (func))) + ;; NO_TNH: (type $A (sub (func))) + (type $A (sub (func))) ;; YESTNH: (rec ;; YESTNH-NEXT: (type $1 (func (param funcref))) @@ -1198,12 +1198,12 @@ ;; YESTNH: (rec ;; YESTNH-NEXT: (type $0 (func (param anyref))) - ;; YESTNH: (type $A (array (mut i32))) + ;; YESTNH: (type $A (sub (array (mut i32)))) ;; NO_TNH: (rec ;; NO_TNH-NEXT: (type $0 (func (param anyref))) - ;; NO_TNH: (type $A (array (mut i32))) - (type $A (array (mut i32))) + ;; NO_TNH: (type $A (sub (array (mut i32)))) + (type $A (sub (array (mut i32)))) ;; YESTNH: (type $B (sub $A (array (mut i32)))) ;; NO_TNH: (type $B (sub $A (array (mut i32)))) diff --git a/test/lit/passes/cfp.wast b/test/lit/passes/cfp.wast index d49c8b755..4236a16c6 100644 --- a/test/lit/passes/cfp.wast +++ b/test/lit/passes/cfp.wast @@ -549,8 +549,8 @@ (module ;; CHECK: (type $0 (func)) - ;; CHECK: (type $struct (struct (field i32))) - (type $struct (struct i32)) + ;; CHECK: (type $struct (sub (struct (field i32)))) + (type $struct (sub (struct i32))) ;; CHECK: (type $substruct (sub $struct (struct (field i32)))) (type $substruct (struct_subtype i32 $struct)) @@ -594,8 +594,8 @@ ;; will optimize the result to the only possible value. (In practice, though, ;; it will trap anyhow.) (module - ;; CHECK: (type $struct (struct (field (mut i32)))) - (type $struct (struct (mut i32))) + ;; CHECK: (type $struct (sub (struct (field (mut i32))))) + (type $struct (sub (struct (mut i32)))) ;; CHECK: (type $1 (func (param (ref null $struct)))) ;; CHECK: (type $substruct (sub $struct (struct (field (mut i32))))) @@ -652,8 +652,8 @@ (module ;; CHECK: (type $0 (func)) - ;; CHECK: (type $struct (struct (field i32))) - (type $struct (struct i32)) + ;; CHECK: (type $struct (sub (struct (field i32)))) + (type $struct (sub (struct i32))) ;; CHECK: (type $substruct (sub $struct (struct (field i32) (field f64)))) (type $substruct (struct_subtype i32 f64 $struct)) @@ -700,8 +700,8 @@ ;; Subtyping: Create both a subtype and a supertype, with identical constants ;; for the shared field, and get the supertype. (module - ;; CHECK: (type $struct (struct (field i32))) - (type $struct (struct i32)) + ;; CHECK: (type $struct (sub (struct (field i32)))) + (type $struct (sub (struct i32))) ;; CHECK: (type $1 (func)) ;; CHECK: (type $substruct (sub $struct (struct (field i32) (field f64)))) @@ -760,8 +760,8 @@ ;; for the shared field, preventing optimization, as a get of the ;; supertype may receive an instance of the subtype. (module - ;; CHECK: (type $struct (struct (field i32))) - (type $struct (struct i32)) + ;; CHECK: (type $struct (sub (struct (field i32)))) + (type $struct (sub (struct i32))) ;; CHECK: (type $1 (func)) ;; CHECK: (type $substruct (sub $struct (struct (field i32) (field f64)))) @@ -817,8 +817,8 @@ ;; one value, so we can optimize. (module - ;; CHECK: (type $struct (struct (field i32))) - (type $struct (struct i32)) + ;; CHECK: (type $struct (sub (struct (field i32)))) + (type $struct (sub (struct i32))) ;; CHECK: (type $substruct (sub $struct (struct (field i32) (field f64)))) (type $substruct (struct_subtype i32 f64 $struct)) @@ -876,8 +876,8 @@ ;; As above, but add a set of $struct. The set prevents the optimization. (module - ;; CHECK: (type $struct (struct (field (mut i32)))) - (type $struct (struct (mut i32))) + ;; CHECK: (type $struct (sub (struct (field (mut i32))))) + (type $struct (sub (struct (mut i32)))) ;; CHECK: (type $substruct (sub $struct (struct (field (mut i32)) (field f64)))) (type $substruct (struct_subtype (mut i32) f64 $struct)) @@ -939,8 +939,8 @@ ;; Multi-level subtyping, check that we propagate not just to the immediate ;; supertype but all the way as needed. (module - ;; CHECK: (type $struct1 (struct (field i32))) - (type $struct1 (struct i32)) + ;; CHECK: (type $struct1 (sub (struct (field i32)))) + (type $struct1 (sub (struct i32))) ;; CHECK: (type $struct2 (sub $struct1 (struct (field i32) (field f64)))) (type $struct2 (struct_subtype i32 f64 $struct1)) @@ -1074,8 +1074,8 @@ ;; different values in the sub-most type. Create the top and bottom types, but ;; not the middle one. (module - ;; CHECK: (type $struct1 (struct (field i32) (field i32))) - (type $struct1 (struct i32 i32)) + ;; CHECK: (type $struct1 (sub (struct (field i32) (field i32)))) + (type $struct1 (sub (struct i32 i32))) ;; CHECK: (type $struct2 (sub $struct1 (struct (field i32) (field i32) (field f64) (field f64)))) (type $struct2 (struct_subtype i32 i32 f64 f64 $struct1)) @@ -1304,8 +1304,8 @@ ;; Multi-level subtyping with a different value in the middle of the chain. We ;; can only optimize $struct3. (module - ;; CHECK: (type $struct1 (struct (field (mut i32)))) - (type $struct1 (struct (mut i32))) + ;; CHECK: (type $struct1 (sub (struct (field (mut i32))))) + (type $struct1 (sub (struct (mut i32)))) ;; CHECK: (type $struct2 (sub $struct1 (struct (field (mut i32)) (field f64)))) (type $struct2 (struct_subtype (mut i32) f64 $struct1)) ;; CHECK: (type $struct3 (sub $struct2 (struct (field (mut i32)) (field f64) (field anyref)))) @@ -1401,8 +1401,8 @@ ;; but also a set. That prevents all optimizations. (module - ;; CHECK: (type $struct1 (struct (field (mut i32)))) - (type $struct1 (struct (mut i32))) + ;; CHECK: (type $struct1 (sub (struct (field (mut i32))))) + (type $struct1 (sub (struct (mut i32)))) ;; CHECK: (type $struct2 (sub $struct1 (struct (field (mut i32)) (field f64)))) (type $struct2 (struct_subtype (mut i32) f64 $struct1)) @@ -1627,8 +1627,8 @@ ;; sets, and the final subtype C has a create and a get. The set to A should ;; apply to it, preventing optimization. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (mut i32))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (mut i32)))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (struct_subtype (mut i32) $A)) @@ -2226,8 +2226,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (struct_subtype (field (mut i32)) $A)) ) diff --git a/test/lit/passes/coalesce-locals-gc.wast b/test/lit/passes/coalesce-locals-gc.wast index fdd2b0e60..6e3381e8e 100644 --- a/test/lit/passes/coalesce-locals-gc.wast +++ b/test/lit/passes/coalesce-locals-gc.wast @@ -3,7 +3,7 @@ ;; RUN: | filecheck %s (module - ;; CHECK: (type $A (struct (field structref))) + ;; CHECK: (type $A (sub (struct (field structref)))) ;; CHECK: (type $array (array (mut i8))) (type $array (array (mut i8))) diff --git a/test/lit/passes/dae-gc-refine-params.wast b/test/lit/passes/dae-gc-refine-params.wast index cf3e75ebe..7a7a30954 100644 --- a/test/lit/passes/dae-gc-refine-params.wast +++ b/test/lit/passes/dae-gc-refine-params.wast @@ -2,8 +2,8 @@ ;; RUN: wasm-opt %s -all --dae -S -o - | filecheck %s (module - ;; CHECK: (type ${} (struct )) - (type ${} (struct)) + ;; CHECK: (type ${} (sub (struct ))) + (type ${} (sub (struct))) ;; CHECK: (type ${i32} (sub ${} (struct (field i32)))) (type ${i32} (struct_subtype (field i32) ${})) diff --git a/test/lit/passes/dae-gc-refine-return.wast b/test/lit/passes/dae-gc-refine-return.wast index bab22b2cb..a071cfc93 100644 --- a/test/lit/passes/dae-gc-refine-return.wast +++ b/test/lit/passes/dae-gc-refine-return.wast @@ -2,8 +2,8 @@ ;; RUN: wasm-opt %s -all --dae -S -o - | filecheck %s (module - ;; CHECK: (type ${} (struct )) - (type ${} (struct)) + ;; CHECK: (type ${} (sub (struct ))) + (type ${} (sub (struct))) ;; CHECK: (type $return_{} (func (result (ref ${})))) (type $return_{} (func (result (ref ${})))) diff --git a/test/lit/passes/dae_tnh.wast b/test/lit/passes/dae_tnh.wast index ea2d95433..a5b1f2f2a 100644 --- a/test/lit/passes/dae_tnh.wast +++ b/test/lit/passes/dae_tnh.wast @@ -5,7 +5,7 @@ (module ;; CHECK: (type $0 (func)) - ;; CHECK: (type $struct (struct (field i32))) + ;; CHECK: (type $struct (sub (struct (field i32)))) (type $struct (struct_subtype (field i32) data)) ;; CHECK: (type $2 (func (param (ref null $struct)))) diff --git a/test/lit/passes/gsi.wast b/test/lit/passes/gsi.wast index 559050f1f..00a2f6c60 100644 --- a/test/lit/passes/gsi.wast +++ b/test/lit/passes/gsi.wast @@ -667,7 +667,7 @@ ;; A subtype is not optimizable, which prevents $struct from being optimized. (module - ;; CHECK: (type $struct (struct (field i32))) + ;; CHECK: (type $struct (sub (struct (field i32)))) (type $struct (struct_subtype i32 data)) ;; CHECK: (type $1 (func (param (ref null $struct)))) @@ -718,7 +718,7 @@ ;; A *super*-type is not optimizable, but that does not block us, and we can ;; optimize. (module - ;; CHECK: (type $super-struct (struct (field i32))) + ;; CHECK: (type $super-struct (sub (struct (field i32)))) (type $super-struct (struct_subtype i32 data)) ;; CHECK: (type $struct (sub $super-struct (struct (field i32)))) @@ -776,7 +776,7 @@ ;; One global for each of the type and the subtype. The optimization will pick ;; between their 2 values. (module - ;; CHECK: (type $super-struct (struct (field i32))) + ;; CHECK: (type $super-struct (sub (struct (field i32)))) (type $super-struct (struct_subtype i32 data)) ;; CHECK: (type $struct (sub $super-struct (struct (field i32)))) @@ -887,7 +887,7 @@ ;; One global each for two subtypes of a common supertype, and one for the ;; supertype. (module - ;; CHECK: (type $super-struct (struct (field i32))) + ;; CHECK: (type $super-struct (sub (struct (field i32)))) (type $super-struct (struct_subtype i32 data)) ;; CHECK: (type $struct1 (sub $super-struct (struct (field i32) (field f32)))) @@ -980,7 +980,7 @@ ;; As above, but now the subtypes each have 2 values, and we can optimize. (module - ;; CHECK: (type $super-struct (struct (field i32))) + ;; CHECK: (type $super-struct (sub (struct (field i32)))) (type $super-struct (struct_subtype i32 data)) ;; CHECK: (type $struct1 (sub $super-struct (struct (field i32) (field f32)))) @@ -1228,7 +1228,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field i32))) + ;; CHECK-NEXT: (type $struct (sub (struct (field i32)))) (type $struct (struct_subtype i32 data)) ;; CHECK: (type $sub-struct1 (sub $struct (struct (field i32)))) @@ -1282,7 +1282,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field i32))) + ;; CHECK-NEXT: (type $struct (sub (struct (field i32)))) (type $struct (struct_subtype i32 data)) ;; CHECK: (type $sub-struct1 (sub $struct (struct (field i32)))) @@ -1339,7 +1339,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field i32))) + ;; CHECK-NEXT: (type $struct (sub (struct (field i32)))) (type $struct (struct_subtype i32 data)) ;; CHECK: (type $sub-struct1 (sub $struct (struct (field i32)))) @@ -1394,8 +1394,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field funcref))) - (type $A (struct (field funcref))) + ;; CHECK-NEXT: (type $A (sub (struct (field funcref)))) + (type $A (sub (struct (field funcref)))) ;; CHECK: (type $B (sub $A (struct (field (ref func))))) (type $B (sub $A (struct (field (ref func))))) ) diff --git a/test/lit/passes/gsi_vacuum_precompute.wast b/test/lit/passes/gsi_vacuum_precompute.wast index 8f4067446..1cbf47032 100644 --- a/test/lit/passes/gsi_vacuum_precompute.wast +++ b/test/lit/passes/gsi_vacuum_precompute.wast @@ -22,11 +22,11 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $vtable (struct (field funcref))) + ;; CHECK-NEXT: (type $vtable (sub (struct (field funcref)))) (type $vtable (struct_subtype (field funcref) data)) - ;; CHECK: (type $itable1 (struct (field (ref $vtable)))) + ;; CHECK: (type $itable1 (sub (struct (field (ref $vtable))))) (type $itable1 (struct_subtype (field (ref $vtable)) data)) - ;; CHECK: (type $itable2 (struct (field (ref $vtable)))) + ;; CHECK: (type $itable2 (sub (struct (field (ref $vtable))))) (type $itable2 (struct_subtype (field (ref $vtable)) data)) ) diff --git a/test/lit/passes/gto-mutability.wast b/test/lit/passes/gto-mutability.wast index 0ffa0e2d8..4be26c348 100644 --- a/test/lit/passes/gto-mutability.wast +++ b/test/lit/passes/gto-mutability.wast @@ -431,8 +431,8 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func (param (ref null $super) (ref null $sub)))) - ;; CHECK: (type $super (struct (field i32))) - (type $super (struct (field (mut i32)))) + ;; CHECK: (type $super (sub (struct (field i32)))) + (type $super (sub (struct (field (mut i32))))) ;; CHECK: (type $sub (sub $super (struct (field i32)))) (type $sub (struct_subtype (field (mut i32)) $super)) @@ -485,8 +485,8 @@ (module ;; As above, but add a write in the super, which prevents optimization. - ;; CHECK: (type $super (struct (field (mut i32)))) - (type $super (struct (field (mut i32)))) + ;; CHECK: (type $super (sub (struct (field (mut i32))))) + (type $super (sub (struct (field (mut i32))))) ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) (type $sub (struct_subtype (field (mut i32)) $super)) @@ -550,8 +550,8 @@ ;; As above, but add a write in the sub, which prevents optimization. - ;; CHECK: (type $super (struct (field (mut i32)))) - (type $super (struct (field (mut i32)))) + ;; CHECK: (type $super (sub (struct (field (mut i32))))) + (type $super (sub (struct (field (mut i32))))) ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) (type $sub (struct_subtype (field (mut i32)) $super)) diff --git a/test/lit/passes/gto-removals.wast b/test/lit/passes/gto-removals.wast index 43a81a5e2..34e29b71d 100644 --- a/test/lit/passes/gto-removals.wast +++ b/test/lit/passes/gto-removals.wast @@ -6,7 +6,7 @@ ;; removed. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct )) + ;; CHECK-NEXT: (type $struct (sub (struct ))) (type $struct (struct_subtype (field (mut funcref)) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -22,7 +22,7 @@ ;; A write does not keep a field from being removed. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct )) + ;; CHECK-NEXT: (type $struct (sub (struct ))) (type $struct (struct_subtype (field (mut funcref)) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -53,7 +53,7 @@ ;; A new does not keep a field from being removed. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct )) + ;; CHECK-NEXT: (type $struct (sub (struct ))) (type $struct (struct_subtype (field (mut funcref)) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -77,7 +77,7 @@ ;; A new_default does not keep a field from being removed. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct )) + ;; CHECK-NEXT: (type $struct (sub (struct ))) (type $struct (struct_subtype (field (mut funcref)) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -100,7 +100,7 @@ ;; A read *does* keep a field from being removed. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field funcref))) + ;; CHECK-NEXT: (type $struct (sub (struct (field funcref)))) (type $struct (struct_subtype (field (mut funcref)) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -128,11 +128,11 @@ ;; A struct with all fields marked mutable. ;; CHECK: (rec - ;; CHECK-NEXT: (type $imm-struct (struct (field $rw i32) (field $rw-2 i32))) + ;; CHECK-NEXT: (type $imm-struct (sub (struct (field $rw i32) (field $rw-2 i32)))) ;; CHECK: (type $1 (func (param (ref $imm-struct)))) - ;; CHECK: (type $mut-struct (struct (field $r i32) (field $rw (mut i32)) (field $r-2 i32) (field $rw-2 (mut i32)))) + ;; CHECK: (type $mut-struct (sub (struct (field $r i32) (field $rw (mut i32)) (field $r-2 i32) (field $rw-2 (mut i32))))) (type $mut-struct (struct_subtype (field $r (mut i32)) (field $w (mut i32)) (field $rw (mut i32)) (field $r-2 (mut i32)) (field $w-2 (mut i32)) (field $rw-2 (mut i32)) data)) ;; A similar struct but with all fields marked immutable, and the only @@ -283,7 +283,7 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $vtable (struct (field $v1 funcref) (field $v2 funcref))) + ;; CHECK: (type $vtable (sub (struct (field $v1 funcref) (field $v2 funcref)))) (type $vtable (struct_subtype (field $v0 funcref) (field $v1 funcref) (field $v2 funcref) (field $v3 funcref) (field $v4 funcref) data)) ;; CHECK: (global $vtable (ref $vtable) (struct.new $vtable @@ -358,7 +358,7 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $vtable (struct (field $v1 i64) (field $v2 f32))) + ;; CHECK: (type $vtable (sub (struct (field $v1 i64) (field $v2 f32)))) (type $vtable (struct_subtype (field $v0 i32) (field $v1 i64) (field $v2 f32) (field $v3 f64) (field $v4 anyref) data)) ;; CHECK: (global $vtable (ref $vtable) (struct.new $vtable @@ -635,7 +635,7 @@ ;; the subtypes can always add fields at the end (and only at the end). (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $parent (struct (field i32) (field i64))) + ;; CHECK-NEXT: (type $parent (sub (struct (field i32) (field i64)))) (type $parent (struct_subtype (field i32) (field i64) (field f32) (field f64) data)) ;; CHECK: (type $child (sub $parent (struct (field i32) (field i64) (field f32) (field f64) (field anyref)))) @@ -685,7 +685,7 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $parent (struct (field i32) (field i64) (field (mut f32)))) + ;; CHECK-NEXT: (type $parent (sub (struct (field i32) (field i64) (field (mut f32))))) (type $parent (struct_subtype (field (mut i32)) (field (mut i64)) (field (mut f32)) (field (mut f64)) data)) ;; CHECK: (type $child (sub $parent (struct (field i32) (field i64) (field (mut f32)) (field f64) (field anyref)))) @@ -743,7 +743,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $parent (struct (field i32))) + ;; CHECK-NEXT: (type $parent (sub (struct (field i32)))) (type $parent (struct_subtype (field i32) data)) ;; CHECK: (type $child1 (sub $parent (struct (field i32)))) (type $child1 (struct_subtype (field i32) $parent)) @@ -770,7 +770,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $parent (struct )) + ;; CHECK-NEXT: (type $parent (sub (struct ))) (type $parent (struct_subtype (field i32) data)) ;; CHECK: (type $child2 (sub $parent (struct ))) @@ -802,7 +802,7 @@ ;; CHECK: (type $2 (func)) - ;; CHECK: (type ${mut:i8} (struct )) + ;; CHECK: (type ${mut:i8} (sub (struct ))) (type ${mut:i8} (struct_subtype (field (mut i8)) data)) ;; CHECK: (type $4 (func (param (ref null ${mut:i8})))) diff --git a/test/lit/passes/gto_and_cfp_in_O.wast b/test/lit/passes/gto_and_cfp_in_O.wast index 0253e0791..ae0b11ee2 100644 --- a/test/lit/passes/gto_and_cfp_in_O.wast +++ b/test/lit/passes/gto_and_cfp_in_O.wast @@ -8,7 +8,7 @@ ;; open world we do not run them. (module - ;; OPEN_WORLD: (type $struct (struct (field (mut funcref)) (field (mut i32)))) + ;; OPEN_WORLD: (type $struct (sub (struct (field (mut funcref)) (field (mut i32))))) (type $struct (struct_subtype (field (mut funcref)) (field (mut i32)) data)) ;; OPEN_WORLD: (type $1 (func)) diff --git a/test/lit/passes/gufa-cast-all.wast b/test/lit/passes/gufa-cast-all.wast index 5ef52037f..21103089d 100644 --- a/test/lit/passes/gufa-cast-all.wast +++ b/test/lit/passes/gufa-cast-all.wast @@ -6,8 +6,8 @@ ;; CHECK: (type $none_=>_none (func)) (type $none_=>_none (func)) - ;; CHECK: (type $A (struct )) - (type $A (struct)) + ;; CHECK: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; CHECK: (type $B (sub $A (struct ))) (type $B (sub $A (struct))) diff --git a/test/lit/passes/gufa-refs.wast b/test/lit/passes/gufa-refs.wast index b300843cb..0e081637b 100644 --- a/test/lit/passes/gufa-refs.wast +++ b/test/lit/passes/gufa-refs.wast @@ -923,10 +923,10 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct )) + ;; CHECK-NEXT: (type $struct (sub (struct ))) (type $struct (struct_subtype data)) - ;; CHECK: (type $parent (struct (field (mut (ref null $struct))))) + ;; CHECK: (type $parent (sub (struct (field (mut (ref null $struct)))))) (type $parent (struct_subtype (field (mut (ref null $struct))) data)) ;; CHECK: (type $child (sub $parent (struct (field (mut (ref null $struct))) (field (mut (ref null $struct)))))) (type $child (struct_subtype (field (mut (ref null $struct))) (field (mut (ref null $struct))) $parent)) @@ -1201,9 +1201,9 @@ ;; Exact types: Writes to the parent class do not confuse us. (module - ;; CHECK: (type $struct (struct )) + ;; CHECK: (type $struct (sub (struct ))) (type $struct (struct_subtype data)) - ;; CHECK: (type $parent (struct (field (mut (ref null $struct))))) + ;; CHECK: (type $parent (sub (struct (field (mut (ref null $struct)))))) (type $parent (struct_subtype (field (mut (ref null $struct))) data)) ;; CHECK: (type $child (sub $parent (struct (field (mut (ref null $struct))) (field i32)))) (type $child (struct_subtype (field (mut (ref null $struct))) (field i32) $parent)) @@ -1285,7 +1285,7 @@ ;; Write values to the parent *and* the child and read from the child. (module - ;; CHECK: (type $parent (struct (field (mut i32)))) + ;; CHECK: (type $parent (sub (struct (field (mut i32))))) (type $parent (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $child (sub $parent (struct (field (mut i32)) (field i32)))) (type $child (struct_subtype (field (mut i32)) (field i32) $parent)) @@ -1377,7 +1377,7 @@ ;; As above, but the $parent local can now contain a child too. (module - ;; CHECK: (type $parent (struct (field (mut i32)))) + ;; CHECK: (type $parent (sub (struct (field (mut i32))))) (type $parent (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $child (sub $parent (struct (field (mut i32)) (field i32)))) (type $child (struct_subtype (field (mut i32)) (field i32) $parent)) @@ -1460,7 +1460,7 @@ ;; As above, but now the parent and child happen to agree on the aliased value. (module - ;; CHECK: (type $parent (struct (field (mut i32)))) + ;; CHECK: (type $parent (sub (struct (field (mut i32))))) (type $parent (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $child (sub $parent (struct (field (mut i32)) (field i32)))) (type $child (struct_subtype (field (mut i32)) (field i32) $parent)) @@ -1538,13 +1538,13 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $nothing (array (mut anyref))) + ;; CHECK-NEXT: (type $nothing (sub (array (mut anyref)))) (type $nothing (array_subtype (mut (ref null any)) data)) - ;; CHECK: (type $null (array (mut anyref))) + ;; CHECK: (type $null (sub (array (mut anyref)))) (type $null (array_subtype (mut (ref null any)) data)) - ;; CHECK: (type $something (array (mut anyref))) + ;; CHECK: (type $something (sub (array (mut anyref)))) (type $something (array_subtype (mut (ref null any)) data)) ;; CHECK: (type $something-child (sub $something (array (mut anyref)))) @@ -2203,7 +2203,7 @@ ) (module - ;; CHECK: (type ${} (struct )) + ;; CHECK: (type ${} (sub (struct ))) (type ${} (struct_subtype data)) ;; CHECK: (type $1 (func (result (ref ${})))) @@ -2239,13 +2239,13 @@ (module ;; CHECK: (type $0 (func)) - ;; CHECK: (type $A (struct (field i32))) + ;; CHECK: (type $A (sub (struct (field i32)))) (type $A (struct_subtype (field i32) data)) - ;; CHECK: (type $B (struct (field i64))) + ;; CHECK: (type $B (sub (struct (field i64)))) (type $B (struct_subtype (field i64) data)) - ;; CHECK: (type $C (struct (field f32))) + ;; CHECK: (type $C (sub (struct (field f32)))) (type $C (struct_subtype (field f32) data)) - ;; CHECK: (type $D (struct (field f64))) + ;; CHECK: (type $D (sub (struct (field f64)))) (type $D (struct_subtype (field f64) data)) ;; CHECK: (func $many-types (type $0) @@ -2312,7 +2312,7 @@ ;; locations being properly noticed, both from global locations (the global's ;; init) and a function ($create). (module - ;; CHECK: (type $vtable-A (struct (field funcref) (field funcref) (field funcref))) + ;; CHECK: (type $vtable-A (sub (struct (field funcref) (field funcref) (field funcref)))) (type $vtable-A (struct_subtype (field (ref null func)) (field (ref null func)) (field (ref null func)) data)) ;; CHECK: (type $1 (func)) @@ -2395,7 +2395,7 @@ ) (module - ;; CHECK: (type $struct (struct (field i32))) + ;; CHECK: (type $struct (sub (struct (field i32)))) (type $struct (struct_subtype (field i32) data)) ;; CHECK: (type $1 (func)) @@ -2446,7 +2446,7 @@ ;; Casts. (module - ;; CHECK: (type $struct (struct (field i32))) + ;; CHECK: (type $struct (sub (struct (field i32)))) (type $struct (struct_subtype (field i32) data)) ;; CHECK: (type $substruct (sub $struct (struct (field i32) (field i32)))) (type $substruct (struct_subtype (field i32) (field i32) $struct)) @@ -2457,7 +2457,7 @@ ;; CHECK: (type $4 (func (param i32))) - ;; CHECK: (type $other (struct )) + ;; CHECK: (type $other (sub (struct ))) (type $other (struct_subtype data)) ;; CHECK: (type $6 (func (result i32))) @@ -3347,7 +3347,7 @@ ;; Test ref.eq on globals. (module - ;; CHECK: (type $A (struct (field i32))) + ;; CHECK: (type $A (sub (struct (field i32)))) (type $A (struct_subtype (field i32) data)) (type $B (struct_subtype (field i32) $A)) @@ -3511,11 +3511,11 @@ ) (module - ;; CHECK: (type $A (struct (field i32))) + ;; CHECK: (type $A (sub (struct (field i32)))) (type $A (struct_subtype (field i32) data)) - ;; CHECK: (type $B (struct (field (ref $A)))) + ;; CHECK: (type $B (sub (struct (field (ref $A))))) (type $B (struct_subtype (ref $A) data)) - ;; CHECK: (type $C (struct (field (ref $B)))) + ;; CHECK: (type $C (sub (struct (field (ref $B))))) (type $C (struct_subtype (ref $B) data)) ;; CHECK: (type $3 (func (result i32))) @@ -3564,7 +3564,7 @@ ;; ref.as* test. (module - ;; CHECK: (type $A (struct (field i32))) + ;; CHECK: (type $A (sub (struct (field i32)))) (type $A (struct_subtype (field i32) data)) ;; CHECK: (type $B (sub $A (struct (field i32) (field f64)))) (type $B (struct_subtype (field i32) (field f64) $A)) @@ -3610,7 +3610,7 @@ ) (module - ;; CHECK: (type $A (struct (field i32))) + ;; CHECK: (type $A (sub (struct (field i32)))) (type $A (struct_subtype (field i32) data)) ;; CHECK: (type $1 (func (result i32))) @@ -4223,7 +4223,7 @@ ) (module - ;; CHECK: (type $struct (struct (field (mut i32)))) + ;; CHECK: (type $struct (sub (struct (field (mut i32))))) (type $struct (struct_subtype (mut i32) data)) ;; CHECK: (type $substruct (sub $struct (struct (field (mut i32)) (field f64)))) @@ -4299,7 +4299,7 @@ ;; As above, but we can no longer infer an exact type for the struct.set on the ;; global $something. (module - ;; CHECK: (type $struct (struct (field (mut i32)))) + ;; CHECK: (type $struct (sub (struct (field (mut i32))))) (type $struct (struct_subtype (mut i32) data)) ;; CHECK: (type $substruct (sub $struct (struct (field (mut i32)) (field f64)))) @@ -4377,7 +4377,7 @@ ;; As above, but change the constants in the first field in all cases to 10. Now ;; we can optimize. (module - ;; CHECK: (type $struct (struct (field (mut i32)))) + ;; CHECK: (type $struct (sub (struct (field (mut i32))))) (type $struct (struct_subtype (mut i32) data)) ;; CHECK: (type $substruct (sub $struct (struct (field (mut i32)) (field f64)))) @@ -4585,7 +4585,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) + ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) (type $A (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (struct_subtype (field (mut i32)) $A)) @@ -4693,7 +4693,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) + ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) (type $A (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (struct_subtype (field (mut i32)) $A)) @@ -4801,7 +4801,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) + ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) (type $A (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (struct_subtype (field (mut i32)) $A)) @@ -4915,7 +4915,7 @@ ;; Cone writes. (module - ;; CHECK: (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) (type $A (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (struct_subtype (field (mut i32)) $A)) @@ -5013,7 +5013,7 @@ ;; As above, but write a different value. (module - ;; CHECK: (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) (type $A (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (struct_subtype (field (mut i32)) $A)) @@ -5112,7 +5112,7 @@ ;; As above, but write a different cone. (module - ;; CHECK: (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) (type $A (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (struct_subtype (field (mut i32)) $A)) @@ -5212,7 +5212,7 @@ ;; Tests for proper inference of imported etc. values - we do know their type, ;; at least. (module - ;; CHECK: (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) (type $A (struct_subtype (field (mut i32)) data)) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) @@ -5646,8 +5646,8 @@ ) (module - ;; CHECK: (type $A (struct )) - (type $A (struct)) + ;; CHECK: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; CHECK: (type $B (sub $A (struct ))) (type $B (sub $A (struct))) @@ -5683,8 +5683,8 @@ ;; A situation that we need traps-never-happens to optimize. Here we do nothing, ;; while in gufa-tnh we test with that flag. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $1 (func (param (ref null $A)))) diff --git a/test/lit/passes/gufa-tnh-closed.wast b/test/lit/passes/gufa-tnh-closed.wast index 44d16c99b..790663af4 100644 --- a/test/lit/passes/gufa-tnh-closed.wast +++ b/test/lit/passes/gufa-tnh-closed.wast @@ -231,8 +231,8 @@ ;; As above, but now the second possible function is of a subtype. We still ;; cannot optimize a call to the parent, but we can for the child. (module - ;; CHECK: (type $A (func)) - (type $A (func)) + ;; CHECK: (type $A (sub (func))) + (type $A (sub (func))) ;; CHECK: (type $B (sub $A (func))) (type $B (sub $A (func))) @@ -296,8 +296,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct )) - (type $X (struct)) + ;; CHECK-NEXT: (type $X (sub (struct ))) + (type $X (sub (struct))) ;; CHECK: (type $Y1 (sub $X (struct ))) (type $Y1 (sub $X (struct))) @@ -421,8 +421,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct )) - (type $X (struct)) + ;; CHECK-NEXT: (type $X (sub (struct ))) + (type $X (sub (struct))) ;; CHECK: (type $Y1 (sub $X (struct ))) (type $Y1 (sub $X (struct))) @@ -659,8 +659,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct )) - (type $X (struct)) + ;; CHECK-NEXT: (type $X (sub (struct ))) + (type $X (sub (struct))) ;; CHECK: (type $Y1 (sub $X (struct ))) (type $Y1 (sub $X (struct))) @@ -885,8 +885,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct )) - (type $X (struct)) + ;; CHECK-NEXT: (type $X (sub (struct ))) + (type $X (sub (struct))) ;; CHECK: (type $Y1 (sub $X (struct ))) (type $Y1 (sub $X (struct))) @@ -1041,8 +1041,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct )) - (type $X (struct)) + ;; CHECK-NEXT: (type $X (sub (struct ))) + (type $X (sub (struct))) ;; CHECK: (type $Y1 (sub $X (struct ))) (type $Y1 (sub $X (struct))) diff --git a/test/lit/passes/gufa-tnh.wast b/test/lit/passes/gufa-tnh.wast index e41a3f49c..fb9348365 100644 --- a/test/lit/passes/gufa-tnh.wast +++ b/test/lit/passes/gufa-tnh.wast @@ -157,8 +157,8 @@ ) (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -286,8 +286,8 @@ ;; A local.tee by itself, without a cast. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -372,8 +372,8 @@ ;; As above, but add a local.tee etc. in the called function. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -449,8 +449,8 @@ ;; As above, but now add some control flow before the cast in the function. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $1 (func (param (ref null $A)))) @@ -511,8 +511,8 @@ ;; As above, but make the cast uninteresting so we do not optimize. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -564,8 +564,8 @@ ;; As above, but two casts in the called function. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -631,8 +631,8 @@ ;; Multiple parameters with control flow between them. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -734,8 +734,8 @@ ;; As above, but without the cast in the middle of the called function. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -831,8 +831,8 @@ ;; As above, but with a different control flow transfer in the caller, a call. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -916,8 +916,8 @@ ;; As above, but with yet another control flow transfer, using an if. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -1011,8 +1011,8 @@ ;; A cast that will fail. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -1111,8 +1111,8 @@ ;; Verify we do not propagate *less*-refined information. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -1322,8 +1322,8 @@ ;; Refine a type to unreachable. B1 and B2 are sibling subtypes of A, and the ;; caller passes in a B1 that is cast in the function to B2. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) (rec ;; CHECK: (type $1 (func (param (ref null $A)))) @@ -1408,8 +1408,8 @@ (module ;; CHECK: (type $0 (func)) - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -1442,8 +1442,8 @@ ;; Check all combinations of types passed to a nullable cast. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -1545,8 +1545,8 @@ ;; Check all combinations of types passed to a *non*-nullable cast. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (field (mut i32)))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (field (mut i32))))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (sub $A (struct (field (mut i32))))) @@ -1960,8 +1960,8 @@ (module ;; CHECK: (type $0 (func)) - ;; CHECK: (type $A (struct )) - (type $A (struct)) + ;; CHECK: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; CHECK: (type $B (sub $A (struct ))) (type $B (sub $A (struct))) diff --git a/test/lit/passes/gufa-vs-cfp.wast b/test/lit/passes/gufa-vs-cfp.wast index 2589290c6..3ed490628 100644 --- a/test/lit/passes/gufa-vs-cfp.wast +++ b/test/lit/passes/gufa-vs-cfp.wast @@ -496,8 +496,8 @@ ;; subtype, the get must trap anyhow (the reference it receives can ;; only be null in this closed world). (module - ;; CHECK: (type $struct (struct (field i32))) - (type $struct (struct i32)) + ;; CHECK: (type $struct (sub (struct (field i32)))) + (type $struct (sub (struct i32))) (type $substruct (struct_subtype i32 $struct)) ;; CHECK: (type $1 (func (result (ref $struct)))) @@ -543,8 +543,8 @@ ;; however, cannot write to the subtype, so we still know that any reads from ;; the subtype must trap. (module - ;; CHECK: (type $struct (struct (field (mut i32)))) - (type $struct (struct (mut i32))) + ;; CHECK: (type $struct (sub (struct (field (mut i32))))) + (type $struct (sub (struct (mut i32)))) (type $substruct (struct_subtype (mut i32) $struct)) ;; CHECK: (type $1 (func)) @@ -602,8 +602,8 @@ ;; to a read of the subtype. Still, no actual instance of the subtype can ;; appear in the get, so we can optimize to an unreachable. (module - ;; CHECK: (type $struct (struct (field (mut i32)))) - (type $struct (struct (mut i32))) + ;; CHECK: (type $struct (sub (struct (field (mut i32))))) + (type $struct (sub (struct (mut i32)))) (type $substruct (struct_subtype (mut i32) $struct)) ;; CHECK: (type $1 (func)) @@ -655,7 +655,7 @@ ;; Subtyping: Create a subtype and get a supertype. The get must receive a ;; reference to the subtype and so we can infer the value of the get. (module - (type $struct (struct i32)) + (type $struct (sub (struct i32))) (type $substruct (struct_subtype i32 f64 $struct)) @@ -681,8 +681,8 @@ ;; Subtyping: Create both a subtype and a supertype, with identical constants ;; for the shared field, and get the supertype. (module - ;; CHECK: (type $struct (struct (field i32))) - (type $struct (struct i32)) + ;; CHECK: (type $struct (sub (struct (field i32)))) + (type $struct (sub (struct i32))) ;; CHECK: (type $1 (func (result i32))) ;; CHECK: (type $2 (func)) @@ -735,8 +735,8 @@ ;; for the shared field, preventing optimization, as a get of the ;; supertype may receive an instance of the subtype. (module - ;; CHECK: (type $struct (struct (field i32))) - (type $struct (struct i32)) + ;; CHECK: (type $struct (sub (struct (field i32)))) + (type $struct (sub (struct i32))) ;; CHECK: (type $1 (func (result i32))) ;; CHECK: (type $2 (func)) @@ -786,8 +786,8 @@ ;; shared between the types, but we only create the subtype with ;; one value, so we can optimize. (module - ;; CHECK: (type $struct (struct (field i32))) - (type $struct (struct i32)) + ;; CHECK: (type $struct (sub (struct (field i32)))) + (type $struct (sub (struct i32))) ;; CHECK: (type $substruct (sub $struct (struct (field i32) (field f64)))) (type $substruct (struct_subtype i32 f64 $struct)) @@ -843,8 +843,8 @@ ;; As above, but add a set of $struct. The set prevents the optimization. (module - ;; CHECK: (type $struct (struct (field (mut i32)))) - (type $struct (struct (mut i32))) + ;; CHECK: (type $struct (sub (struct (field (mut i32))))) + (type $struct (sub (struct (mut i32)))) ;; CHECK: (type $substruct (sub $struct (struct (field (mut i32)) (field f64)))) (type $substruct (struct_subtype (mut i32) f64 $struct)) @@ -917,8 +917,8 @@ ;; As above, but now the constant in the set agrees with the substruct value, ;; so we can optimize. (module - ;; CHECK: (type $struct (struct (field (mut i32)))) - (type $struct (struct (mut i32))) + ;; CHECK: (type $struct (sub (struct (field (mut i32))))) + (type $struct (sub (struct (mut i32)))) ;; CHECK: (type $substruct (sub $struct (struct (field (mut i32)) (field f64)))) (type $substruct (struct_subtype (mut i32) f64 $struct)) @@ -996,7 +996,7 @@ ;; Multi-level subtyping, check that we propagate not just to the immediate ;; supertype but all the way as needed. (module - ;; CHECK: (type $struct1 (struct (field i32))) + ;; CHECK: (type $struct1 (sub (struct (field i32)))) (type $struct1 (struct_subtype i32 data)) ;; CHECK: (type $struct2 (sub $struct1 (struct (field i32) (field f64)))) @@ -1137,8 +1137,8 @@ ;; different values in the sub-most type. Create the top and bottom types, but ;; not the middle one. (module - ;; CHECK: (type $struct1 (struct (field i32) (field i32))) - (type $struct1 (struct i32 i32)) + ;; CHECK: (type $struct1 (sub (struct (field i32) (field i32)))) + (type $struct1 (sub (struct i32 i32))) ;; CHECK: (type $struct2 (sub $struct1 (struct (field i32) (field i32) (field f64) (field f64)))) (type $struct2 (struct_subtype i32 i32 f64 f64 $struct1)) @@ -1371,8 +1371,8 @@ ;; Multi-level subtyping with a different value in the middle of the chain. (module - ;; CHECK: (type $struct1 (struct (field (mut i32)))) - (type $struct1 (struct (mut i32))) + ;; CHECK: (type $struct1 (sub (struct (field (mut i32))))) + (type $struct1 (sub (struct (mut i32)))) ;; CHECK: (type $struct2 (sub $struct1 (struct (field (mut i32)) (field f64)))) (type $struct2 (struct_subtype (mut i32) f64 $struct1)) ;; CHECK: (type $2 (func)) @@ -1676,8 +1676,8 @@ ;; but also a set. We can see that the set just affects the middle class, ;; though, so it is not a problem. (module - ;; CHECK: (type $struct1 (struct (field (mut i32)))) - (type $struct1 (struct (mut i32))) + ;; CHECK: (type $struct1 (sub (struct (field (mut i32))))) + (type $struct1 (sub (struct (mut i32)))) ;; CHECK: (type $struct2 (sub $struct1 (struct (field (mut i32)) (field f64)))) (type $struct2 (struct_subtype (mut i32) f64 $struct1)) ;; CHECK: (type $struct3 (sub $struct2 (struct (field (mut i32)) (field f64) (field anyref)))) @@ -1792,8 +1792,8 @@ ;; As above, but the set is of a different value. (module - ;; CHECK: (type $struct1 (struct (field (mut i32)))) - (type $struct1 (struct (mut i32))) + ;; CHECK: (type $struct1 (sub (struct (field (mut i32))))) + (type $struct1 (sub (struct (mut i32)))) ;; CHECK: (type $struct2 (sub $struct1 (struct (field (mut i32)) (field f64)))) (type $struct2 (struct_subtype (mut i32) f64 $struct1)) ;; CHECK: (type $struct3 (sub $struct2 (struct (field (mut i32)) (field f64) (field anyref)))) @@ -2019,8 +2019,8 @@ ;; sets, and the final subtype C has a create and a get. The set to A should ;; apply to it, preventing optimization. (module - ;; CHECK: (type $A (struct (field (mut i32)))) - (type $A (struct (mut i32))) + ;; CHECK: (type $A (sub (struct (field (mut i32))))) + (type $A (sub (struct (mut i32)))) ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) (type $B (struct_subtype (mut i32) $A)) diff --git a/test/lit/passes/heap2local.wast b/test/lit/passes/heap2local.wast index ec5eaa3c6..6fa0e2a1f 100644 --- a/test/lit/passes/heap2local.wast +++ b/test/lit/passes/heap2local.wast @@ -1898,8 +1898,8 @@ ) (module - ;; CHECK: (type $A (struct (field (ref null $A)))) - (type $A (struct (field (ref null $A)))) + ;; CHECK: (type $A (sub (struct (field (ref null $A))))) + (type $A (sub (struct (field (ref null $A))))) ;; CHECK: (type $B (sub $A (struct (field (ref $A))))) (type $B (sub $A (struct (field (ref $A))))) diff --git a/test/lit/passes/inlining_vacuum_optimize-instructions.wast b/test/lit/passes/inlining_vacuum_optimize-instructions.wast index 0e153d57c..948fe467f 100644 --- a/test/lit/passes/inlining_vacuum_optimize-instructions.wast +++ b/test/lit/passes/inlining_vacuum_optimize-instructions.wast @@ -11,9 +11,9 @@ ;; which is temporarily inconsistent. We must be careful to avoid confusion ;; there. (module - ;; CHECK: (type $B (struct )) + ;; CHECK: (type $B (sub (struct ))) (type $B (struct_subtype data)) - ;; CHECK: (type $A (struct (field (ref null $B)))) + ;; CHECK: (type $A (sub (struct (field (ref null $B))))) (type $A (struct_subtype (field (ref null $B)) data)) ;; CHECK: (type $2 (func (param (ref null $A)))) diff --git a/test/lit/passes/local-subtyping.wast b/test/lit/passes/local-subtyping.wast index c5f3f408a..c86f4d645 100644 --- a/test/lit/passes/local-subtyping.wast +++ b/test/lit/passes/local-subtyping.wast @@ -14,7 +14,7 @@ (type $array (array_subtype i8 data)) - ;; CHECK: (type $ret-any (func (result anyref))) + ;; CHECK: (type $ret-any (sub (func (result anyref)))) (type $ret-any (sub (func (result anyref)))) ;; CHECK: (type $ret-i31 (sub $ret-any (func (result i31ref)))) (type $ret-i31 (sub $ret-any (func (result i31ref)))) diff --git a/test/lit/passes/merge-similar-functions_types.wast b/test/lit/passes/merge-similar-functions_types.wast index aa02abf2e..5c4364a14 100644 --- a/test/lit/passes/merge-similar-functions_types.wast +++ b/test/lit/passes/merge-similar-functions_types.wast @@ -6,7 +6,7 @@ ;; of $0 and $1, so we want to merge them and pass ref.funcs of $2 and $3. ;; However, their nominal types differ, so in nominal typing we cannot do so. (module - ;; CHECK: (type $type$0 (func)) + ;; CHECK: (type $type$0 (sub (func))) (type $type$0 (func_subtype func)) (type $type$1 (func_subtype func)) (type $type$2 (func_subtype func)) @@ -110,7 +110,7 @@ (module ;; As above, but now the nominal types do match, so we can optimize in all ;; modes. - ;; CHECK: (type $type$0 (func)) + ;; CHECK: (type $type$0 (sub (func))) (type $type$0 (func_subtype func)) (type $type$1 (func_subtype func)) (type $type$3 (func_subtype (param f32) (result f32) func)) diff --git a/test/lit/passes/monomorphize.wast b/test/lit/passes/monomorphize.wast index fc3388d89..858cb4bf5 100644 --- a/test/lit/passes/monomorphize.wast +++ b/test/lit/passes/monomorphize.wast @@ -7,8 +7,8 @@ ;; RUN: foreach %s %t wasm-opt --monomorphize -all -S -o - | filecheck %s --check-prefix CAREFUL (module - ;; ALWAYS: (type $A (struct )) - ;; CAREFUL: (type $A (struct )) + ;; ALWAYS: (type $A (sub (struct ))) + ;; CAREFUL: (type $A (sub (struct ))) (type $A (struct_subtype data)) ;; ALWAYS: (type $B (sub $A (struct ))) ;; CAREFUL: (type $B (sub $A (struct ))) @@ -124,10 +124,10 @@ ;; As above, but now the refinable function uses the local in a way that ;; requires a fixup. - ;; ALWAYS: (type $A (struct )) + ;; ALWAYS: (type $A (sub (struct ))) ;; CAREFUL: (type $0 (func)) - ;; CAREFUL: (type $A (struct )) + ;; CAREFUL: (type $A (sub (struct ))) (type $A (struct_subtype data)) ;; ALWAYS: (type $B (sub $A (struct ))) ;; CAREFUL: (type $B (sub $A (struct ))) @@ -204,10 +204,10 @@ (module ;; Multiple refinings of the same function, and of different functions. - ;; ALWAYS: (type $A (struct )) + ;; ALWAYS: (type $A (sub (struct ))) ;; CAREFUL: (type $0 (func)) - ;; CAREFUL: (type $A (struct )) + ;; CAREFUL: (type $A (sub (struct ))) (type $A (struct_subtype data)) ;; ALWAYS: (type $B (sub $A (struct ))) ;; CAREFUL: (type $B (sub $A (struct ))) @@ -327,8 +327,8 @@ ;; A case where even CAREFUL mode will monomorphize, as it helps the target ;; function get optimized better. - ;; ALWAYS: (type $A (struct )) - ;; CAREFUL: (type $A (struct )) + ;; ALWAYS: (type $A (sub (struct ))) + ;; CAREFUL: (type $A (sub (struct ))) (type $A (struct_subtype data)) ;; ALWAYS: (type $B (sub $A (struct ))) @@ -558,8 +558,8 @@ (module ;; Test that we avoid recursive calls. - ;; ALWAYS: (type $A (struct )) - ;; CAREFUL: (type $A (struct )) + ;; ALWAYS: (type $A (sub (struct ))) + ;; CAREFUL: (type $A (sub (struct ))) (type $A (struct_subtype data)) ;; ALWAYS: (type $1 (func (param (ref $A)))) diff --git a/test/lit/passes/optimize-casts-tnh.wast b/test/lit/passes/optimize-casts-tnh.wast index 02720995e..d5f83f024 100644 --- a/test/lit/passes/optimize-casts-tnh.wast +++ b/test/lit/passes/optimize-casts-tnh.wast @@ -2,7 +2,7 @@ ;; RUN: wasm-opt %s --optimize-casts -all -tnh -S -o - | filecheck %s (module - ;; CHECK: (type $A (struct )) + ;; CHECK: (type $A (sub (struct ))) (type $A (struct_subtype data)) ;; CHECK: (global $a (mut i32) (i32.const 0)) diff --git a/test/lit/passes/optimize-casts.wast b/test/lit/passes/optimize-casts.wast index 4c9e38df6..2854df3bb 100644 --- a/test/lit/passes/optimize-casts.wast +++ b/test/lit/passes/optimize-casts.wast @@ -2,7 +2,7 @@ ;; RUN: wasm-opt %s --optimize-casts -all -S -o - | filecheck %s (module - ;; CHECK: (type $A (struct )) + ;; CHECK: (type $A (sub (struct ))) (type $A (struct_subtype data)) ;; CHECK: (type $B (sub $A (struct ))) diff --git a/test/lit/passes/optimize-instructions-gc-iit.wast b/test/lit/passes/optimize-instructions-gc-iit.wast index 02a9c6f29..cc5e8aec9 100644 --- a/test/lit/passes/optimize-instructions-gc-iit.wast +++ b/test/lit/passes/optimize-instructions-gc-iit.wast @@ -8,9 +8,9 @@ ;; RUN: | filecheck %s --check-prefix TNH (module - ;; CHECK: (type $parent (struct (field i32))) - ;; TNH: (type $parent (struct (field i32))) - (type $parent (struct (field i32))) + ;; CHECK: (type $parent (sub (struct (field i32)))) + ;; TNH: (type $parent (sub (struct (field i32)))) + (type $parent (sub (struct (field i32)))) ;; CHECK: (type $child (sub $parent (struct (field i32) (field f64)))) ;; TNH: (type $child (sub $parent (struct (field i32) (field f64)))) (type $child (struct_subtype (field i32) (field f64) $parent)) @@ -200,9 +200,9 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct )) + ;; CHECK-NEXT: (type $A (sub (struct ))) ;; TNH: (rec - ;; TNH-NEXT: (type $A (struct )) + ;; TNH-NEXT: (type $A (sub (struct ))) (type $A (struct_subtype data)) ;; CHECK: (type $B (sub $A (struct (field (ref null $A))))) ;; TNH: (type $B (sub $A (struct (field (ref null $A))))) diff --git a/test/lit/passes/optimize-instructions-gc-tnh.wast b/test/lit/passes/optimize-instructions-gc-tnh.wast index 28177f306..9d55ef801 100644 --- a/test/lit/passes/optimize-instructions-gc-tnh.wast +++ b/test/lit/passes/optimize-instructions-gc-tnh.wast @@ -3,8 +3,8 @@ ;; RUN: wasm-opt %s --optimize-instructions -all -S -o - | filecheck %s --check-prefix NO_TNH (module - ;; TNH: (type $struct (struct (field (mut i32)))) - ;; NO_TNH: (type $struct (struct (field (mut i32)))) + ;; TNH: (type $struct (sub (struct (field (mut i32))))) + ;; NO_TNH: (type $struct (sub (struct (field (mut i32))))) (type $struct (struct_subtype (field (mut i32)) data)) ;; TNH: (type $void (func)) diff --git a/test/lit/passes/optimize-instructions-gc.wast b/test/lit/passes/optimize-instructions-gc.wast index 86306a27a..e62b64125 100644 --- a/test/lit/passes/optimize-instructions-gc.wast +++ b/test/lit/passes/optimize-instructions-gc.wast @@ -12,8 +12,8 @@ (field $i64 (mut i64)) )) - ;; CHECK: (type $A (struct (field i32))) - (type $A (struct (field i32))) + ;; CHECK: (type $A (sub (struct (field i32)))) + (type $A (sub (struct (field i32)))) ;; CHECK: (type $B (sub $A (struct (field i32) (field i32) (field f32)))) @@ -22,19 +22,19 @@ (type $B (struct_subtype (field i32) (field i32) (field f32) $A)) - ;; CHECK: (type $void (func)) - ;; CHECK: (type $B-child (sub $B (struct (field i32) (field i32) (field f32) (field i64)))) (type $B-child (struct_subtype (field i32) (field i32) (field f32) (field i64) $B)) (type $empty (struct)) + ;; CHECK: (type $void (sub (func))) + ;; CHECK: (type $void2 (sub $void (func))) ;; CHECK: (type $C (sub $A (struct (field i32) (field i32) (field f64)))) (type $C (struct_subtype (field i32) (field i32) (field f64) $A)) - (type $void (func)) + (type $void (sub (func))) (type $void2 (func_subtype $void)) @@ -46,7 +46,7 @@ ;; These functions test if an `if` with subtyped arms is correctly folded ;; 1. if its `ifTrue` and `ifFalse` arms are identical (can fold) - ;; CHECK: (func $if-arms-subtype-fold (type $25) (result anyref) + ;; CHECK: (func $if-arms-subtype-fold (type $26) (result anyref) ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: ) (func $if-arms-subtype-fold (result anyref) @@ -57,7 +57,7 @@ ) ) ;; 2. if its `ifTrue` and `ifFalse` arms are not identical (cannot fold) - ;; CHECK: (func $if-arms-subtype-nofold (type $26) (param $i31ref i31ref) (result anyref) + ;; CHECK: (func $if-arms-subtype-nofold (type $27) (param $i31ref i31ref) (result anyref) ;; CHECK-NEXT: (if (result anyref) ;; CHECK-NEXT: (i32.const 0) ;; CHECK-NEXT: (ref.null none) @@ -106,7 +106,7 @@ ) ;; Similar, but for arrays. - ;; CHECK: (func $store-trunc2 (type $14) (param $x (ref null $array)) + ;; CHECK: (func $store-trunc2 (type $15) (param $x (ref null $array)) ;; CHECK-NEXT: (array.set $array ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: (i32.const 0) @@ -123,7 +123,7 @@ ;; ref.is_null is not needed on a non-nullable value, and if something is ;; cast to its own type, we don't need that either, etc. - ;; CHECK: (func $unneeded_test (type $15) (param $struct (ref $struct)) (param $func (ref func)) (param $i31 (ref i31)) + ;; CHECK: (func $unneeded_test (type $16) (param $struct (ref $struct)) (param $func (ref func)) (param $i31 (ref i31)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result i32) ;; CHECK-NEXT: (drop @@ -166,7 +166,7 @@ ;; similar to $unneeded_is, but the values are nullable. we can at least ;; leave just the null check. - ;; CHECK: (func $unneeded_test_null (type $16) (param $struct (ref null $struct)) (param $func funcref) (param $i31 i31ref) + ;; CHECK: (func $unneeded_test_null (type $17) (param $struct (ref null $struct)) (param $func funcref) (param $i31 i31ref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.is_null ;; CHECK-NEXT: (local.get $struct) @@ -207,7 +207,7 @@ ;; ref.as_non_null is not needed on a non-nullable value, and if something is ;; a func we don't need that either etc., and can just return the value. - ;; CHECK: (func $unneeded_cast (type $15) (param $struct (ref $struct)) (param $func (ref func)) (param $i31 (ref i31)) + ;; CHECK: (func $unneeded_cast (type $16) (param $struct (ref $struct)) (param $func (ref func)) (param $i31 (ref i31)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.get $struct) ;; CHECK-NEXT: ) @@ -235,7 +235,7 @@ ;; similar to $unneeded_cast, but the values are nullable. we can turn the ;; more specific things into ref.as_non_null. - ;; CHECK: (func $unneeded_cast_null (type $16) (param $struct (ref null $struct)) (param $func funcref) (param $i31 i31ref) + ;; CHECK: (func $unneeded_cast_null (type $17) (param $struct (ref null $struct)) (param $func funcref) (param $i31 i31ref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.as_non_null ;; CHECK-NEXT: (local.get $struct) @@ -267,7 +267,7 @@ ) ) - ;; CHECK: (func $unneeded_unreachability (type $void) + ;; CHECK: (func $unneeded_unreachability (type $5) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.test (ref func) ;; CHECK-NEXT: (unreachable) @@ -292,7 +292,7 @@ ) ) - ;; CHECK: (func $redundant-non-null-casts (type $27) (param $x (ref null $struct)) (param $y (ref null $array)) (param $f (ref null $void)) + ;; CHECK: (func $redundant-non-null-casts (type $28) (param $x (ref null $struct)) (param $y (ref null $array)) (param $f (ref null $void)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.as_non_null ;; CHECK-NEXT: (local.get $x) @@ -379,7 +379,7 @@ ) ) - ;; CHECK: (func $get-eqref (type $28) (result eqref) + ;; CHECK: (func $get-eqref (type $29) (result eqref) ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) (func $get-eqref (result eqref) @@ -455,7 +455,7 @@ ) ) - ;; CHECK: (func $nothing (type $void) + ;; CHECK: (func $nothing (type $5) ;; CHECK-NEXT: (nop) ;; CHECK-NEXT: ) (func $nothing) @@ -570,7 +570,7 @@ ) ) - ;; CHECK: (func $flip-cast-of-as-non-null (type $17) (param $x anyref) + ;; CHECK: (func $flip-cast-of-as-non-null (type $18) (param $x anyref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.cast (ref $struct) ;; CHECK-NEXT: (local.get $x) @@ -623,7 +623,7 @@ ) ) ) - ;; CHECK: (func $flip-tee-of-as-non-null (type $17) (param $x anyref) + ;; CHECK: (func $flip-tee-of-as-non-null (type $18) (param $x anyref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.as_non_null ;; CHECK-NEXT: (local.tee $x @@ -643,7 +643,7 @@ ) ) - ;; CHECK: (func $flip-tee-of-as-non-null-non-nullable (type $29) (param $x (ref any)) (param $y anyref) + ;; CHECK: (func $flip-tee-of-as-non-null-non-nullable (type $30) (param $x (ref any)) (param $y anyref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $x ;; CHECK-NEXT: (ref.as_non_null @@ -664,7 +664,7 @@ ) ) ) - ;; CHECK: (func $ternary-identical-arms (type $30) (param $x i32) (param $y (ref null $struct)) (param $z (ref null $struct)) + ;; CHECK: (func $ternary-identical-arms (type $31) (param $x i32) (param $y (ref null $struct)) (param $z (ref null $struct)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.is_null ;; CHECK-NEXT: (if (result (ref null $struct)) @@ -684,7 +684,7 @@ ) ) ) - ;; CHECK: (func $select-identical-arms-but-side-effect (type $18) (param $x (ref null $struct)) (param $y (ref null $struct)) (param $z i32) + ;; CHECK: (func $select-identical-arms-but-side-effect (type $19) (param $x (ref null $struct)) (param $y (ref null $struct)) (param $z i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (select ;; CHECK-NEXT: (struct.get_u $struct $i8 @@ -711,7 +711,7 @@ ) ) ) - ;; CHECK: (func $ternary-identical-arms-no-side-effect (type $31) (param $x (ref $struct)) (param $y (ref $struct)) (param $z i32) + ;; CHECK: (func $ternary-identical-arms-no-side-effect (type $32) (param $x (ref $struct)) (param $y (ref $struct)) (param $z i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (struct.get_u $struct $i8 ;; CHECK-NEXT: (select (result (ref $struct)) @@ -736,7 +736,7 @@ ) ) ) - ;; CHECK: (func $if-identical-arms-with-side-effect (type $18) (param $x (ref null $struct)) (param $y (ref null $struct)) (param $z i32) + ;; CHECK: (func $if-identical-arms-with-side-effect (type $19) (param $x (ref null $struct)) (param $y (ref null $struct)) (param $z i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (struct.get_u $struct $i8 ;; CHECK-NEXT: (if (result (ref null $struct)) @@ -1055,7 +1055,7 @@ ) ) - ;; CHECK: (func $hoist-LUB-danger (type $32) (param $x i32) (param $b (ref $B)) (param $c (ref $C)) (result i32) + ;; CHECK: (func $hoist-LUB-danger (type $33) (param $x i32) (param $b (ref $B)) (param $c (ref $C)) (result i32) ;; CHECK-NEXT: (if (result i32) ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: (struct.get $B 1 @@ -1086,7 +1086,7 @@ ) ) - ;; CHECK: (func $incompatible-cast-of-non-null (type $33) (param $struct (ref $struct)) + ;; CHECK: (func $incompatible-cast-of-non-null (type $34) (param $struct (ref $struct)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result (ref none)) ;; CHECK-NEXT: (drop @@ -1204,7 +1204,7 @@ ) ) - ;; CHECK: (func $subtype-compatible (type $20) (param $A (ref null $A)) (param $B (ref null $B)) + ;; CHECK: (func $subtype-compatible (type $21) (param $A (ref null $A)) (param $B (ref null $B)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.test (ref $B) ;; CHECK-NEXT: (local.get $A) @@ -1284,7 +1284,7 @@ ) ) - ;; CHECK: (func $compatible-test-separate-fallthrough (type $11) (param $eqref eqref) (result i32) + ;; CHECK: (func $compatible-test-separate-fallthrough (type $12) (param $eqref eqref) (result i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $eqref ;; CHECK-NEXT: (block (result eqref) @@ -1318,7 +1318,7 @@ ) ) - ;; CHECK: (func $improvable-test-separate-fallthrough (type $11) (param $eqref eqref) (result i32) + ;; CHECK: (func $improvable-test-separate-fallthrough (type $12) (param $eqref eqref) (result i32) ;; CHECK-NEXT: (ref.test (ref i31) ;; CHECK-NEXT: (block (result eqref) ;; CHECK-NEXT: (ref.as_non_null @@ -1339,7 +1339,7 @@ ) ) - ;; CHECK: (func $incompatible-test-separate-fallthrough (type $11) (param $eqref eqref) (result i32) + ;; CHECK: (func $incompatible-test-separate-fallthrough (type $12) (param $eqref eqref) (result i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $eqref ;; CHECK-NEXT: (block (result eqref) @@ -1498,7 +1498,7 @@ ) ) - ;; CHECK: (func $ref.test-unreachable (type $34) (param $A (ref null $A)) + ;; CHECK: (func $ref.test-unreachable (type $35) (param $A (ref null $A)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.test (ref $A) ;; CHECK-NEXT: (unreachable) @@ -1525,7 +1525,7 @@ ) ) - ;; CHECK: (func $ref-cast-static-null (type $void) + ;; CHECK: (func $ref-cast-static-null (type $5) ;; CHECK-NEXT: (local $a (ref null $A)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.null none) @@ -1621,7 +1621,7 @@ ) ) - ;; CHECK: (func $ref-cast-static-general (type $20) (param $a (ref null $A)) (param $b (ref null $B)) + ;; CHECK: (func $ref-cast-static-general (type $21) (param $a (ref null $A)) (param $b (ref null $B)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.get $a) ;; CHECK-NEXT: ) @@ -1907,7 +1907,7 @@ ) ) - ;; CHECK: (func $ref-cast-static-fallthrough-remaining-impossible (type $21) (param $x (ref eq)) + ;; CHECK: (func $ref-cast-static-fallthrough-remaining-impossible (type $22) (param $x (ref eq)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block ;; CHECK-NEXT: (drop @@ -1942,7 +1942,7 @@ ) ) - ;; CHECK: (func $ref-cast-static-fallthrough-remaining-nonnull (type $21) (param $x (ref eq)) + ;; CHECK: (func $ref-cast-static-fallthrough-remaining-nonnull (type $22) (param $x (ref eq)) ;; CHECK-NEXT: (local $1 (ref $B)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result (ref $B)) @@ -2051,7 +2051,7 @@ ) ) - ;; CHECK: (func $ref-test-static-same-type (type $22) (param $nullable (ref null $A)) (param $non-nullable (ref $A)) + ;; CHECK: (func $ref-test-static-same-type (type $23) (param $nullable (ref null $A)) (param $non-nullable (ref $A)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (i32.eqz ;; CHECK-NEXT: (ref.is_null @@ -2084,7 +2084,7 @@ ) ) - ;; CHECK: (func $ref-test-static-subtype (type $12) (param $nullable (ref null $B)) (param $non-nullable (ref $B)) + ;; CHECK: (func $ref-test-static-subtype (type $13) (param $nullable (ref null $B)) (param $non-nullable (ref $B)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (i32.eqz ;; CHECK-NEXT: (ref.is_null @@ -2115,7 +2115,7 @@ ) ) - ;; CHECK: (func $ref-test-static-supertype (type $22) (param $nullable (ref null $A)) (param $non-nullable (ref $A)) + ;; CHECK: (func $ref-test-static-supertype (type $23) (param $nullable (ref null $A)) (param $non-nullable (ref $A)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.test (ref $B) ;; CHECK-NEXT: (local.get $nullable) @@ -2142,7 +2142,7 @@ ) ) - ;; CHECK: (func $ref-test-static-impossible (type $35) (param $nullable (ref null $array)) (param $non-nullable (ref $array)) + ;; CHECK: (func $ref-test-static-impossible (type $36) (param $nullable (ref null $array)) (param $non-nullable (ref $array)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result i32) ;; CHECK-NEXT: (drop @@ -2222,14 +2222,14 @@ ) ) - ;; CHECK: (func $impossible (type $36) (result (ref none)) + ;; CHECK: (func $impossible (type $37) (result (ref none)) ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) (func $impossible (result (ref none)) (unreachable) ) - ;; CHECK: (func $bottom-type-accessors (type $37) (param $bot (ref none)) (param $null nullref) + ;; CHECK: (func $bottom-type-accessors (type $38) (param $bot (ref none)) (param $null nullref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) @@ -2271,7 +2271,7 @@ ) ) - ;; CHECK: (func $ref-cast-heap-type (type $12) (param $null-b (ref null $B)) (param $b (ref $B)) + ;; CHECK: (func $ref-cast-heap-type (type $13) (param $null-b (ref null $B)) (param $b (ref $B)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.get $b) ;; CHECK-NEXT: ) @@ -2318,7 +2318,7 @@ ) ) - ;; CHECK: (func $ref-cast-heap-type-incompatible (type $12) (param $null-b (ref null $B)) (param $b (ref $B)) + ;; CHECK: (func $ref-cast-heap-type-incompatible (type $13) (param $null-b (ref null $B)) (param $b (ref $B)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result (ref none)) ;; CHECK-NEXT: (drop @@ -2377,7 +2377,7 @@ ) ) - ;; CHECK: (func $compatible-cast-separate-fallthrough (type $23) (param $eqref eqref) (result (ref i31)) + ;; CHECK: (func $compatible-cast-separate-fallthrough (type $24) (param $eqref eqref) (result (ref i31)) ;; CHECK-NEXT: (local $1 i31ref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $eqref @@ -2417,7 +2417,7 @@ ) ) - ;; CHECK: (func $compatible-cast-fallthrough-null-check (type $23) (param $eqref eqref) (result (ref i31)) + ;; CHECK: (func $compatible-cast-fallthrough-null-check (type $24) (param $eqref eqref) (result (ref i31)) ;; CHECK-NEXT: (local $1 i31ref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $eqref @@ -2449,7 +2449,7 @@ ) ) - ;; CHECK: (func $compatible-cast-separate-fallthrough-multiple-options-1 (type $24) (param $eqref eqref) (result (ref eq)) + ;; CHECK: (func $compatible-cast-separate-fallthrough-multiple-options-1 (type $25) (param $eqref eqref) (result (ref eq)) ;; CHECK-NEXT: (local $1 i31ref) ;; CHECK-NEXT: (block $outer (result (ref eq)) ;; CHECK-NEXT: (block (result (ref i31)) @@ -2507,7 +2507,7 @@ ) ) - ;; CHECK: (func $compatible-cast-separate-fallthrough-multiple-options-2 (type $24) (param $eqref eqref) (result (ref eq)) + ;; CHECK: (func $compatible-cast-separate-fallthrough-multiple-options-2 (type $25) (param $eqref eqref) (result (ref eq)) ;; CHECK-NEXT: (local $1 (ref i31)) ;; CHECK-NEXT: (block $outer (result (ref eq)) ;; CHECK-NEXT: (block (result (ref i31)) @@ -2562,7 +2562,7 @@ ) ) - ;; CHECK: (func $incompatible-cast-separate-fallthrough (type $38) (param $eqref eqref) (result structref) + ;; CHECK: (func $incompatible-cast-separate-fallthrough (type $39) (param $eqref eqref) (result structref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $eqref ;; CHECK-NEXT: (block (result (ref i31)) @@ -2699,7 +2699,7 @@ ) ) - ;; CHECK: (func $as_of_unreachable (type $39) (result (ref $A)) + ;; CHECK: (func $as_of_unreachable (type $40) (result (ref $A)) ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) (func $as_of_unreachable (result (ref $A)) @@ -2713,7 +2713,7 @@ ) ) - ;; CHECK: (func $cast-internalized-extern (type $40) (param $externref externref) + ;; CHECK: (func $cast-internalized-extern (type $41) (param $externref externref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.cast (ref $A) ;; CHECK-NEXT: (extern.internalize @@ -2735,7 +2735,7 @@ ) ) - ;; CHECK: (func $struct.set.null.fallthrough (type $void) + ;; CHECK: (func $struct.set.null.fallthrough (type $5) ;; CHECK-NEXT: (local $temp (ref null $struct)) ;; CHECK-NEXT: (block ;; (replaces something unreachable we can't emit) ;; CHECK-NEXT: (drop @@ -2764,7 +2764,7 @@ ) ) - ;; CHECK: (func $set.array.null (type $void) + ;; CHECK: (func $set.array.null (type $5) ;; CHECK-NEXT: (local $temp (ref none)) ;; CHECK-NEXT: (block ;; (replaces something unreachable we can't emit) ;; CHECK-NEXT: (drop @@ -2822,7 +2822,7 @@ ) ) - ;; CHECK: (func $refinalize.select.arm.flip (type $void) + ;; CHECK: (func $refinalize.select.arm.flip (type $5) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.cast (ref $void2) ;; CHECK-NEXT: (ref.func $refinalize.select.arm) @@ -2842,7 +2842,7 @@ ) ) - ;; CHECK: (func $refinalize.select.arm.unknown (type $41) (param $x i32) + ;; CHECK: (func $refinalize.select.arm.unknown (type $42) (param $x i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.cast (ref $void2) ;; CHECK-NEXT: (ref.func $refinalize.select.arm) @@ -2862,7 +2862,7 @@ ) ) - ;; CHECK: (func $non-null-bottom-ref (type $42) (result (ref func)) + ;; CHECK: (func $non-null-bottom-ref (type $43) (result (ref func)) ;; CHECK-NEXT: (local $0 funcref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (local.tee $0 @@ -2890,7 +2890,7 @@ ) ) - ;; CHECK: (func $non-null-bottom-cast (type $43) (result (ref nofunc)) + ;; CHECK: (func $non-null-bottom-cast (type $44) (result (ref nofunc)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.func $non-null-bottom-cast) ;; CHECK-NEXT: ) @@ -2960,7 +2960,7 @@ ) ) - ;; CHECK: (func $ref.test-fallthrough (type $void) + ;; CHECK: (func $ref.test-fallthrough (type $5) ;; CHECK-NEXT: (local $A (ref $A)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.test (ref $B) @@ -3048,7 +3048,7 @@ ) ) - ;; CHECK: (func $gc_to_unreachable_in_added_constants (type $void) + ;; CHECK: (func $gc_to_unreachable_in_added_constants (type $5) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (i32.wrap_i64 ;; CHECK-NEXT: (i64.add @@ -3089,7 +3089,7 @@ (unreachable) ) - ;; CHECK: (func $array-copy-non-null (type $14) (param $x (ref null $array)) + ;; CHECK: (func $array-copy-non-null (type $15) (param $x (ref null $array)) ;; CHECK-NEXT: (block $block ;; CHECK-NEXT: (array.copy $array $array ;; CHECK-NEXT: (ref.as_non_null diff --git a/test/lit/passes/remove-unused-brs-gc.wast b/test/lit/passes/remove-unused-brs-gc.wast index 625b31584..1bdd6f680 100644 --- a/test/lit/passes/remove-unused-brs-gc.wast +++ b/test/lit/passes/remove-unused-brs-gc.wast @@ -5,7 +5,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct )) + ;; CHECK-NEXT: (type $struct (sub (struct ))) (type $struct (sub (struct))) ;; CHECK: (type $struct2 (struct )) (type $struct2 (struct)) diff --git a/test/lit/passes/remove-unused-module-elements-refs.wast b/test/lit/passes/remove-unused-module-elements-refs.wast index ecb96c249..8a7ef42da 100644 --- a/test/lit/passes/remove-unused-module-elements-refs.wast +++ b/test/lit/passes/remove-unused-module-elements-refs.wast @@ -9,10 +9,10 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A-super (func)) + ;; CHECK-NEXT: (type $A-super (sub (func))) ;; OPEN_WORLD: (rec - ;; OPEN_WORLD-NEXT: (type $A-super (func)) - (type $A-super (func)) + ;; OPEN_WORLD-NEXT: (type $A-super (sub (func))) + (type $A-super (sub (func))) ;; CHECK: (type $A (sub $A-super (func))) ;; OPEN_WORLD: (type $A (sub $A-super (func))) @@ -634,8 +634,8 @@ ;; OPEN_WORLD: (type $void (func)) (type $void (func)) - ;; CHECK: (type $vtable (struct (field (ref $void)) (field (ref $void)))) - ;; OPEN_WORLD: (type $vtable (struct (field (ref $void)) (field (ref $void)))) + ;; CHECK: (type $vtable (sub (struct (field (ref $void)) (field (ref $void))))) + ;; OPEN_WORLD: (type $vtable (sub (struct (field (ref $void)) (field (ref $void))))) (type $vtable (struct_subtype (field (ref $void)) (field (ref $void)) data)) ;; CHECK: (global $vtable (ref $vtable) (struct.new $vtable @@ -754,12 +754,12 @@ ;; OPEN_WORLD: (type $void (func)) (type $void (func)) - ;; CHECK: (type $vtable (struct (field (ref $void)) (field (ref $void)))) - ;; OPEN_WORLD: (type $vtable (struct (field (ref $void)) (field (ref $void)))) + ;; CHECK: (type $vtable (sub (struct (field (ref $void)) (field (ref $void))))) + ;; OPEN_WORLD: (type $vtable (sub (struct (field (ref $void)) (field (ref $void))))) (type $vtable (struct_subtype (field (ref $void)) (field (ref $void)) data)) - ;; CHECK: (type $struct (struct (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)))) - ;; OPEN_WORLD: (type $struct (struct (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)))) + ;; CHECK: (type $struct (sub (struct (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable))))) + ;; OPEN_WORLD: (type $struct (sub (struct (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable))))) (type $struct (struct_subtype (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) (field (ref $vtable)) data)) ;; CHECK: (global $vtable (ref $vtable) (struct.new $vtable @@ -1070,8 +1070,8 @@ ;; OPEN_WORLD: (type $void (func)) (type $void (func)) - ;; CHECK: (type $vtable (struct (field (ref $void)) (field (ref $void)))) - ;; OPEN_WORLD: (type $vtable (struct (field (ref $void)) (field (ref $void)))) + ;; CHECK: (type $vtable (sub (struct (field (ref $void)) (field (ref $void))))) + ;; OPEN_WORLD: (type $vtable (sub (struct (field (ref $void)) (field (ref $void))))) (type $vtable (struct_subtype (field (ref $void)) (field (ref $void)) data)) ;; CHECK: (elem declare func $a $b $void) @@ -1174,8 +1174,8 @@ ;; OPEN_WORLD: (rec ;; OPEN_WORLD-NEXT: (type $vtable-func (func (param (ref $vtable)))) (type $vtable-func (func (param (ref $vtable)))) - ;; CHECK: (type $vtable (struct (field (ref $vtable-func)) (field (ref $vtable-func)))) - ;; OPEN_WORLD: (type $vtable (struct (field (ref $vtable-func)) (field (ref $vtable-func)))) + ;; CHECK: (type $vtable (sub (struct (field (ref $vtable-func)) (field (ref $vtable-func))))) + ;; OPEN_WORLD: (type $vtable (sub (struct (field (ref $vtable-func)) (field (ref $vtable-func))))) (type $vtable (struct_subtype (field (ref $vtable-func)) (field (ref $vtable-func)) data)) ) @@ -1368,9 +1368,9 @@ ;; OPEN_WORLD: (type $void (func)) (type $void (func)) - ;; CHECK: (type $struct (struct (field funcref))) - ;; OPEN_WORLD: (type $struct (struct (field funcref))) - (type $struct (struct (field funcref))) + ;; CHECK: (type $struct (sub (struct (field funcref)))) + ;; OPEN_WORLD: (type $struct (sub (struct (field funcref)))) + (type $struct (sub (struct (field funcref)))) ;; CHECK: (type $substruct (sub $struct (struct (field funcref)))) ;; OPEN_WORLD: (type $substruct (sub $struct (struct (field funcref)))) diff --git a/test/lit/passes/roundtrip-gc-types.wast b/test/lit/passes/roundtrip-gc-types.wast index e50fe7b44..c3b3e93c1 100644 --- a/test/lit/passes/roundtrip-gc-types.wast +++ b/test/lit/passes/roundtrip-gc-types.wast @@ -9,8 +9,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (ref $C)))) - (type $A (struct (field (ref $C)))) + ;; CHECK-NEXT: (type $A (sub (struct (field (ref $C))))) + (type $A (sub (struct (field (ref $C))))) ;; CHECK: (type $B (func (param (ref $A)) (result (ref $B)))) (type $B (func (param (ref $A)) (result (ref $B)))) diff --git a/test/lit/passes/rse-gc.wast b/test/lit/passes/rse-gc.wast index f1dfb6f78..1dbc61574 100644 --- a/test/lit/passes/rse-gc.wast +++ b/test/lit/passes/rse-gc.wast @@ -2,8 +2,8 @@ ;; RUN: wasm-opt %s --rse -all -S -o - | filecheck %s (module - ;; CHECK: (type $A (struct (field structref))) - (type $A (struct (field (ref null struct)))) + ;; CHECK: (type $A (sub (struct (field structref)))) + (type $A (sub (struct (field (ref null struct))))) ;; $B is a subtype of $A, and its field has a more refined type (it is non- ;; nullable). diff --git a/test/lit/passes/signature-pruning.wast b/test/lit/passes/signature-pruning.wast index 4f054295e..98ed94d4a 100644 --- a/test/lit/passes/signature-pruning.wast +++ b/test/lit/passes/signature-pruning.wast @@ -5,7 +5,7 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $sig (func (param i32 f64))) + ;; CHECK: (type $sig (sub (func (param i32 f64)))) (type $sig (func_subtype (param i32) (param i64) (param f32) (param f64) func)) (memory 1 1) @@ -71,7 +71,7 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $sig (func (param i64 f32))) + ;; CHECK: (type $sig (sub (func (param i64 f32)))) (type $sig (func_subtype (param i32) (param i64) (param f32) (param f64) func)) (memory 1 1) @@ -136,7 +136,7 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $sig (func (param i32 i64 f32))) + ;; CHECK: (type $sig (sub (func (param i32 i64 f32)))) (type $sig (func_subtype (param i32) (param i64) (param f32) (param f64) func)) (memory 1 1) @@ -213,7 +213,7 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $sig (func (param i32 i64 f32))) + ;; CHECK: (type $sig (sub (func (param i32 i64 f32)))) (type $sig (func_subtype (param i32) (param i64) (param f32) (param f64) func)) (memory 1 1) @@ -284,7 +284,7 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $sig (func)) + ;; CHECK: (type $sig (sub (func))) (type $sig (func_subtype (param i32) (param i64) (param f32) (param f64) func)) (memory 1 1) @@ -331,7 +331,7 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $sig (func)) + ;; CHECK: (type $sig (sub (func))) (type $sig (func_subtype (param i32) func)) (memory 1 1) @@ -375,7 +375,7 @@ ) (module - ;; CHECK: (type $sig (func)) + ;; CHECK: (type $sig (sub (func))) (type $sig (func_subtype (param i32) func)) (memory 1 1) @@ -393,12 +393,12 @@ ) (module - ;; CHECK: (type $sig (func (param i32))) + ;; CHECK: (type $sig (sub (func (param i32)))) (type $sig (func_subtype (param i32) func)) ;; As above, but now an import also uses this signature, which prevents us ;; from changing anything. - ;; CHECK: (import "out" "func" (func $import (type $sig) (param i32))) + ;; CHECK: (import "out" "func" (func $import (type $func.0) (param i32))) (import "out" "func" (func $import (type $sig) (param i32))) (memory 1 1) @@ -413,7 +413,7 @@ ) (module - ;; CHECK: (type $sig (func (param i32))) + ;; CHECK: (type $sig (sub (func (param i32)))) (type $sig (func_subtype (param i32) func)) (memory 1 1) @@ -445,9 +445,9 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $sig2 (func (param i32))) + ;; CHECK-NEXT: (type $sig2 (sub (func (param i32)))) - ;; CHECK: (type $sig (func)) + ;; CHECK: (type $sig (sub (func))) (type $sig (func_subtype (param i32) func)) (type $sig2 (func_subtype (param i32) func)) @@ -484,7 +484,7 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $sig (func)) + ;; CHECK: (type $sig (sub (func))) (type $sig (func_subtype (param i32) func)) (memory 1 1) @@ -558,7 +558,7 @@ ;; The presence of a table prevents us from doing any optimizations. (table 1 1 anyref) - ;; CHECK: (type $sig (func (param i32))) + ;; CHECK: (type $sig (sub (func (param i32)))) (type $sig (func_subtype (param i32) func)) ;; CHECK: (table $0 1 1 anyref) @@ -573,7 +573,7 @@ ;; Exports cannot be optimized in any way: we cannot remove parameters from ;; them, and also we cannot apply constant parameter values either. (module - ;; CHECK: (type $sig (func (param i32))) + ;; CHECK: (type $sig (sub (func (param i32)))) (type $sig (func_subtype (param i32) func)) ;; CHECK: (type $1 (func)) @@ -613,9 +613,9 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $sig2 (func)) + ;; CHECK-NEXT: (type $sig2 (sub (func))) - ;; CHECK: (type $sig1 (func)) + ;; CHECK: (type $sig1 (sub (func))) (type $sig1 (func_subtype (param i32) func)) (type $sig2 (func_subtype (param f64) func)) ) @@ -638,9 +638,9 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $sig-bar (func (param i32))) + ;; CHECK-NEXT: (type $sig-bar (sub (func (param i32)))) - ;; CHECK: (type $sig-foo (func)) + ;; CHECK: (type $sig-foo (sub (func))) (type $sig-foo (func_subtype (param i32) func)) (type $sig-bar (func_subtype (param i32) func)) ) @@ -706,9 +706,9 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $sig-bar (func (param funcref))) + ;; CHECK-NEXT: (type $sig-bar (sub (func (param funcref)))) - ;; CHECK: (type $sig-foo (func)) + ;; CHECK: (type $sig-foo (sub (func))) (type $sig-foo (func_subtype (param funcref) func)) (type $sig-bar (func_subtype (param funcref) func)) ) @@ -762,9 +762,9 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $sig-bar (func (param anyref))) + ;; CHECK-NEXT: (type $sig-bar (sub (func (param anyref)))) - ;; CHECK: (type $sig-foo (func)) + ;; CHECK: (type $sig-foo (sub (func))) (type $sig-foo (func_subtype (param anyref) func)) (type $sig-bar (func_subtype (param anyref) func)) ) @@ -882,19 +882,19 @@ ;; relationship. Atm we do not prune such "cycles" so we do not optimize here. ;; TODO (module - ;; CHECK: (type $struct.A (struct (field i32))) - (type $struct.A (struct (field i32))) - ;; CHECK: (type $array.A (array (ref $struct.A))) + ;; CHECK: (type $struct.A (sub (struct (field i32)))) + (type $struct.A (sub (struct (field i32)))) + ;; CHECK: (type $array.A (sub (array (ref $struct.A)))) ;; CHECK: (type $struct.B (sub $struct.A (struct (field i32) (field i64)))) (type $struct.B (struct_subtype (field i32) (field i64) $struct.A)) - (type $array.A (array (ref $struct.A))) + (type $array.A (sub (array (ref $struct.A)))) ;; CHECK: (type $array.B (sub $array.A (array (ref $struct.B)))) (type $array.B (array_subtype (ref $struct.B) $array.A)) - ;; CHECK: (type $func.A (func (param (ref $array.B)) (result (ref $array.A)))) - (type $func.A (func (param (ref $array.B)) (result (ref $array.A)))) + ;; CHECK: (type $func.A (sub (func (param (ref $array.B)) (result (ref $array.A))))) + (type $func.A (sub (func (param (ref $array.B)) (result (ref $array.A))))) ;; CHECK: (type $func.B (sub $func.A (func (param (ref $array.A)) (result (ref $array.B))))) (type $func.B (func_subtype (param (ref $array.A)) (result (ref $array.B)) $func.A)) diff --git a/test/lit/passes/signature-refining.wast b/test/lit/passes/signature-refining.wast index dbd64ab78..c09c837d2 100644 --- a/test/lit/passes/signature-refining.wast +++ b/test/lit/passes/signature-refining.wast @@ -13,7 +13,7 @@ ;; CHECK: (type $1 (func)) - ;; CHECK: (type $sig (func (param (ref $struct)))) + ;; CHECK: (type $sig (sub (func (param (ref $struct))))) (type $sig (func_subtype (param anyref) func)) ;; CHECK: (func $func (type $sig) (param $x (ref $struct)) @@ -43,7 +43,7 @@ ;; CHECK: (type $1 (func)) - ;; CHECK: (type $sig (func (param (ref $struct)))) + ;; CHECK: (type $sig (sub (func (param (ref $struct))))) (type $sig (func_subtype (param anyref) func)) ;; CHECK: (elem declare func $func) @@ -79,7 +79,7 @@ ;; CHECK: (type $1 (func)) - ;; CHECK: (type $sig (func (param eqref))) + ;; CHECK: (type $sig (sub (func (param eqref)))) (type $sig (func_subtype (param anyref) func)) ;; CHECK: (elem declare func $func) @@ -121,7 +121,7 @@ (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct )) + ;; CHECK-NEXT: (type $struct (sub (struct ))) ;; CHECK: (type $struct-sub2 (sub $struct (struct ))) @@ -129,10 +129,10 @@ ;; CHECK: (type $3 (func)) - ;; CHECK: (type $sig (func (param (ref $struct)))) + ;; CHECK: (type $sig (sub (func (param (ref $struct))))) (type $sig (func_subtype (param anyref) func)) - (type $struct (struct)) + (type $struct (sub (struct))) (type $struct-sub1 (struct_subtype $struct)) @@ -178,7 +178,7 @@ ;; CHECK: (type $1 (func)) - ;; CHECK: (type $sig (func (param (ref $struct)))) + ;; CHECK: (type $sig (sub (func (param (ref $struct))))) (type $sig (func_subtype (param anyref) func)) (type $struct (struct)) @@ -212,11 +212,11 @@ ;; to check for proper validation after the update. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (ref $sig)))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (ref $sig))))) ;; CHECK: (type $1 (func)) - ;; CHECK: (type $sig (func (param (ref $struct) (ref $sig)))) + ;; CHECK: (type $sig (sub (func (param (ref $struct) (ref $sig))))) (type $sig (func_subtype (param anyref funcref) func)) (type $struct (struct_subtype (field (ref $sig)) data)) @@ -282,7 +282,7 @@ ;; CHECK: (type $1 (func)) - ;; CHECK: (type $sig (func (param (ref $struct)))) + ;; CHECK: (type $sig (sub (func (param (ref $struct))))) (type $sig (func_subtype (param anyref) func)) ;; CHECK: (elem declare func $func) @@ -319,7 +319,7 @@ (type $struct (struct)) - ;; CHECK: (type $sig (func (param anyref))) + ;; CHECK: (type $sig (sub (func (param anyref)))) (type $sig (func_subtype (param anyref) func)) ;; CHECK: (type $1 (func)) @@ -352,7 +352,7 @@ (type $struct (struct)) - ;; CHECK: (type $sig (func (param anyref))) + ;; CHECK: (type $sig (sub (func (param anyref)))) (type $sig (func_subtype (param anyref) func)) ;; CHECK: (func $func (type $sig) (param $x anyref) @@ -371,9 +371,9 @@ ;; CHECK: (type $1 (func)) - ;; CHECK: (type $sig-2 (func (param eqref (ref $struct)))) + ;; CHECK: (type $sig-2 (sub (func (param eqref (ref $struct))))) - ;; CHECK: (type $sig-1 (func (param structref anyref))) + ;; CHECK: (type $sig-1 (sub (func (param structref anyref)))) (type $sig-1 (func_subtype (param anyref) (param anyref) func)) (type $sig-2 (func_subtype (param anyref) (param anyref) func)) ) @@ -442,7 +442,7 @@ (module ;; The presence of a table prevents us from doing any optimizations. - ;; CHECK: (type $sig (func (param anyref))) + ;; CHECK: (type $sig (sub (func (param anyref)))) (type $sig (func_subtype (param anyref) func)) ;; CHECK: (type $1 (func)) @@ -481,7 +481,7 @@ ;; CHECK: (type $1 (func)) - ;; CHECK: (type $sig (func (param (ref null $struct)))) + ;; CHECK: (type $sig (sub (func (param (ref null $struct))))) (type $sig (func_subtype (param anyref) func)) (type $struct (struct)) @@ -515,16 +515,16 @@ ;; CHECK: (rec ;; CHECK-NEXT: (type $0 (func)) - ;; CHECK: (type $sig-unreachable (func (result anyref))) + ;; CHECK: (type $sig-unreachable (sub (func (result anyref)))) - ;; CHECK: (type $sig-cannot-refine (func (result (ref func)))) + ;; CHECK: (type $sig-cannot-refine (sub (func (result (ref func))))) ;; CHECK: (type $struct (struct )) (type $struct (struct)) ;; This signature has a single function using it, which returns a more ;; refined type, and we can refine to that. - ;; CHECK: (type $sig-can-refine (func (result (ref $struct)))) + ;; CHECK: (type $sig-can-refine (sub (func (result (ref $struct))))) (type $sig-can-refine (func_subtype (result anyref) func)) ;; Also a single function, but no refinement is possible. @@ -614,7 +614,7 @@ ;; This signature has multiple functions using it, and some of them have nulls ;; which should be updated when we refine. - ;; CHECK: (type $sig (func (result (ref null $struct)))) + ;; CHECK: (type $sig (sub (func (result (ref null $struct))))) (type $sig (func_subtype (result anyref) func)) ;; CHECK: (func $func-1 (type $sig) (result (ref null $struct)) @@ -660,7 +660,7 @@ ;; Exports prevent optimization, so $func's type will not change here. (module - ;; CHECK: (type $sig (func (param anyref))) + ;; CHECK: (type $sig (sub (func (param anyref)))) ;; CHECK: (type $1 (func)) @@ -690,7 +690,7 @@ ) (module - ;; CHECK: (type $A (func (param i32))) + ;; CHECK: (type $A (sub (func (param i32)))) (type $A (func_subtype (param i32) func)) ;; CHECK: (type $B (sub $A (func (param i32)))) (type $B (func_subtype (param i32) $A)) @@ -783,8 +783,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (func (param (ref null $B)) (result (ref null $A)))) - (type $A (func (param (ref null $B)) (result (ref null $A)))) + ;; CHECK-NEXT: (type $A (sub (func (param (ref null $B)) (result (ref null $A))))) + (type $A (sub (func (param (ref null $B)) (result (ref null $A))))) ;; CHECK: (type $B (sub $A (func (param (ref null $A)) (result (ref null $B))))) (type $B (func_subtype (param (ref null $A)) (result (ref null $B)) $A)) ) @@ -805,8 +805,8 @@ ;; supertype. In this example, refining the child's anyref to nullref would ;; cause an error. (module - ;; CHECK: (type $parent (func (param anyref))) - (type $parent (func (param anyref))) + ;; CHECK: (type $parent (sub (func (param anyref)))) + (type $parent (sub (func (param anyref)))) ;; CHECK: (type $child (sub $parent (func (param anyref)))) (type $child (func_subtype (param anyref) $parent)) @@ -893,8 +893,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct )) - (type $A (struct)) + ;; CHECK-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; CHECK: (type $B (sub $A (struct ))) (type $B (sub $A (struct))) diff --git a/test/lit/passes/simplify-locals-gc.wast b/test/lit/passes/simplify-locals-gc.wast index 223657ae9..1de41e8e8 100644 --- a/test/lit/passes/simplify-locals-gc.wast +++ b/test/lit/passes/simplify-locals-gc.wast @@ -4,7 +4,7 @@ ;; RUN: | filecheck %s (module - ;; CHECK: (type $A (struct (field structref))) + ;; CHECK: (type $A (sub (struct (field structref)))) ;; CHECK: (type $B (sub $A (struct (field (ref struct))))) diff --git a/test/lit/passes/simplify-locals-strings.wast b/test/lit/passes/simplify-locals-strings.wast index 7e8f77c02..d36db96ae 100644 --- a/test/lit/passes/simplify-locals-strings.wast +++ b/test/lit/passes/simplify-locals-strings.wast @@ -5,9 +5,9 @@ (module (memory 10 10) - ;; CHECK: (type $array (array (mut i8))) + ;; CHECK: (type $array (sub (array (mut i8)))) (type $array (array_subtype (mut i8) data)) - ;; CHECK: (type $array16 (array (mut i16))) + ;; CHECK: (type $array16 (sub (array (mut i16)))) (type $array16 (array_subtype (mut i16) data)) ;; CHECK: (func $no-new-past-store (type $1) diff --git a/test/lit/passes/type-merging-tnh.wast b/test/lit/passes/type-merging-tnh.wast index c5ad4e760..9df11164f 100644 --- a/test/lit/passes/type-merging-tnh.wast +++ b/test/lit/passes/type-merging-tnh.wast @@ -4,8 +4,8 @@ ;; ref.cast does not inhibit merging if traps never happen. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct )) - (type $A (struct)) + ;; CHECK-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) (type $B (struct_subtype $A)) ;; CHECK: (type $1 (func (param (ref $A)) (result (ref $A)))) @@ -25,8 +25,8 @@ ;; Check that a ref.test still inhibits merging with -tnh. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct )) - (type $A (struct)) + ;; CHECK-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; CHECK: (type $B (sub $A (struct ))) (type $B (struct_subtype $A)) @@ -47,8 +47,8 @@ ;; Check that a br_on_cast still inhibits merging with -tnh. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct )) - (type $A (struct)) + ;; CHECK-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; CHECK: (type $B (sub $A (struct ))) (type $B (struct_subtype $A)) @@ -93,8 +93,8 @@ ;; call_indirect should not inhibit merging if traps never happen. (module - ;; CHECK: (type $A (func)) - (type $A (func)) + ;; CHECK: (type $A (sub (func))) + (type $A (sub (func))) (type $B (func_subtype $A)) (table 1 1 (ref null $A)) diff --git a/test/lit/passes/type-merging.wast b/test/lit/passes/type-merging.wast index 53582a586..4a68a9213 100644 --- a/test/lit/passes/type-merging.wast +++ b/test/lit/passes/type-merging.wast @@ -4,7 +4,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field anyref))) + ;; CHECK-NEXT: (type $A (sub (struct (field anyref)))) (type $A (struct_subtype (field anyref) data)) (type $B (struct_subtype (field anyref) $A)) ;; CHECK: (type $G (sub final $A (struct (field anyref)))) @@ -78,7 +78,7 @@ ;; Multiple levels of merging. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field i32))) + ;; CHECK-NEXT: (type $A (sub (struct (field i32)))) (type $A (struct_subtype (field i32) data)) (type $B (struct_subtype (field i32) $A)) (type $C (struct_subtype (field i32) $B)) @@ -122,7 +122,7 @@ ;; should remain the same as before, everything merged into either $A or $D. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field i32))) + ;; CHECK-NEXT: (type $A (sub (struct (field i32)))) (type $A (struct_subtype (field i32) data)) (type $B (struct_subtype (field i32) $A)) (type $C (struct_subtype (field i32) $B)) @@ -157,11 +157,11 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct )) - (type $X (struct)) + ;; CHECK-NEXT: (type $X (sub (struct ))) + (type $X (sub (struct))) (type $Y (struct_subtype $X)) - ;; CHECK: (type $A (struct (field (ref null $X)))) - (type $A (struct (field (ref null $X)))) + ;; CHECK: (type $A (sub (struct (field (ref null $X))))) + (type $A (sub (struct (field (ref null $X))))) (type $B (struct_subtype (field (ref null $Y)) $A)) ;; CHECK: (type $C (sub $A (struct (field (ref $X))))) (type $C (struct_subtype (field (ref $Y)) $A)) @@ -186,8 +186,8 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (ref null $A)))) - (type $A (struct (ref null $A))) + ;; CHECK-NEXT: (type $A (sub (struct (field (ref null $A))))) + (type $A (sub (struct (ref null $A)))) (type $B (struct_subtype (ref null $B) $A)) ;; CHECK: (type $1 (func)) @@ -208,12 +208,12 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct (field (ref null $A)) (field f32))) + ;; CHECK-NEXT: (type $X (sub (struct (field (ref null $A)) (field f32)))) - ;; CHECK: (type $A (struct (field (ref null $X)) (field i32))) - (type $A (struct (ref null $X) i32)) + ;; CHECK: (type $A (sub (struct (field (ref null $X)) (field i32)))) + (type $A (sub (struct (ref null $X) i32))) (type $B (struct_subtype (ref null $Y) i32 $A)) - (type $X (struct (ref null $A) f32)) + (type $X (sub (struct (ref null $A) f32))) (type $Y (struct_subtype (ref null $B) f32 $X)) ) @@ -239,10 +239,10 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (ref null $A)))) - (type $A (struct (ref null $X))) + ;; CHECK-NEXT: (type $A (sub (struct (field (ref null $A))))) + (type $A (sub (struct (ref null $X)))) (type $B (struct_subtype (ref null $Y) $A)) - (type $X (struct (ref null $A))) + (type $X (sub (struct (ref null $A)))) (type $Y (struct_subtype (ref null $B) $X)) ) @@ -325,12 +325,12 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct (field (ref null $A)))) + ;; CHECK-NEXT: (type $X (sub (struct (field (ref null $A))))) - ;; CHECK: (type $A (struct (field (ref null $X)))) - (type $A (struct (ref null $X))) + ;; CHECK: (type $A (sub (struct (field (ref null $X))))) + (type $A (sub (struct (ref null $X)))) (type $B (struct_subtype (ref null $Y) $A)) - (type $X (struct (ref null $A))) + (type $X (sub (struct (ref null $A)))) (type $Y (struct_subtype (ref null $B) $X)) ) @@ -481,12 +481,12 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct (field anyref))) - (type $X (struct anyref)) + ;; CHECK-NEXT: (type $X (sub (struct (field anyref)))) + (type $X (sub (struct anyref))) ;; CHECK: (type $Y (sub $X (struct (field eqref)))) (type $Y (struct_subtype eqref $X)) - ;; CHECK: (type $A (struct (field (ref null $X)))) - (type $A (struct (ref null $X))) + ;; CHECK: (type $A (sub (struct (field (ref null $X))))) + (type $A (sub (struct (ref null $X)))) ;; CHECK: (type $B (sub $A (struct (field (ref null $Y))))) (type $B (struct_subtype (ref null $Y) $A)) (type $C (struct_subtype (ref null $Y) $A)) @@ -511,8 +511,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field anyref))) - (type $A (struct anyref)) + ;; CHECK-NEXT: (type $A (sub (struct (field anyref)))) + (type $A (sub (struct anyref))) (type $B (struct_subtype eqref $A)) ;; CHECK: (type $C (sub $A (struct (field eqref)))) (type $C (struct_subtype eqref $A)) @@ -538,8 +538,8 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field anyref))) - (type $A (struct anyref)) + ;; CHECK-NEXT: (type $A (sub (struct (field anyref)))) + (type $A (sub (struct anyref))) (type $B (struct_subtype anyref $A)) (type $C (struct_subtype anyref $A)) (type $D (struct_subtype eqref $B)) @@ -574,19 +574,19 @@ (rec ;; These will get merged in the initial supertype merging stage. ;; CHECK: (rec - ;; CHECK-NEXT: (type $B' (struct (field (ref $A)))) + ;; CHECK-NEXT: (type $B' (sub (struct (field (ref $A))))) ;; CHECK: (type $C (sub $B' (struct (field (ref $A)) (field i32)))) ;; CHECK: (type $D' (sub $C (struct (field (ref $A)) (field i32) (field i32)))) - ;; CHECK: (type $A (struct )) - (type $A (struct)) + ;; CHECK: (type $A (sub (struct ))) + (type $A (sub (struct))) (type $A' (struct_subtype $A)) ;; These siblings will be merged only after $a and $a' are merged. - (type $B (struct (ref $A))) - (type $B' (struct (ref $A'))) + (type $B (sub (struct (ref $A)))) + (type $B' (sub (struct (ref $A')))) ;; These will get merged only after $b and $b' are merged. (type $C (struct_subtype (ref $A) i32 $B)) @@ -625,8 +625,8 @@ ;; Check that we refinalize properly. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct )) - (type $A (struct)) + ;; CHECK-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) (type $B (struct_subtype $A)) ;; CHECK: (type $1 (func (result (ref null $A)))) @@ -653,7 +653,7 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $C (struct (field (mut i32)))) + ;; CHECK-NEXT: (type $C (sub (struct (field (mut i32))))) ;; CHECK: (type $D (sub $C (struct (field (mut i32)) (field (mut i32))))) @@ -663,7 +663,7 @@ ;; CHECK: (type $I (array (mut (ref null $C)))) (type $I (array (mut (ref null $C)))) - (type $C (struct (field (mut i32)))) + (type $C (sub (struct (field (mut i32))))) (type $D (struct_subtype (field (mut i32)) (field (mut i32)) $C)) (type $E (struct_subtype (field (mut i32)) (field (mut i32)) $D)) (type $F (struct_subtype (field (mut i32)) (field (mut i32)) $E)) @@ -706,15 +706,15 @@ ;; Arrays (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $refarray (array anyref)) + ;; CHECK-NEXT: (type $refarray (sub (array anyref))) ;; CHECK: (type $sub-refarray-nn (sub $refarray (array (ref any)))) - ;; CHECK: (type $intarray (array (mut i32))) - (type $intarray (array (mut i32))) + ;; CHECK: (type $intarray (sub (array (mut i32)))) + (type $intarray (sub (array (mut i32)))) (type $sub-intarray (array_subtype (mut i32) $intarray)) - (type $refarray (array (ref null any))) + (type $refarray (sub (array (ref null any)))) (type $sub-refarray (array_subtype (ref null any) $refarray)) (type $sub-refarray-nn (array_subtype (ref any) $refarray)) @@ -750,8 +750,8 @@ ;; Function types (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $func (func (param eqref))) - (type $func (func (param eqref))) + ;; CHECK-NEXT: (type $func (sub (func (param eqref)))) + (type $func (sub (func (param eqref)))) (type $sub-func (func_subtype (param eqref) $func)) ;; CHECK: (type $sub-func-refined (sub $func (func (param anyref)))) (type $sub-func-refined (func_subtype (param anyref) $func)) @@ -776,8 +776,8 @@ ;; Check that public types are not merged. (module - ;; CHECK: (type $A (func)) - (type $A (func)) ;; public + ;; CHECK: (type $A (sub (func))) + (type $A (sub (func))) ;; public ;; CHECK: (type $B (sub $A (func))) (type $B (func_subtype $A)) ;; public (type $C (func_subtype $B)) ;; private @@ -825,8 +825,8 @@ ;; other way around, causing an assertion failure in type-updating.cpp. (module (rec - ;; CHECK: (type $A (func (param (ref null $A)) (result (ref null $A)))) - (type $A (func (param (ref null $B)) (result (ref null $A)))) + ;; CHECK: (type $A (sub (func (param (ref null $A)) (result (ref null $A))))) + (type $A (sub (func (param (ref null $B)) (result (ref null $A))))) (type $B (func_subtype (param (ref null $A)) (result (ref null $B)) $A)) ) @@ -844,18 +844,18 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct (field (ref $A)))) - - ;; CHECK: (type $A (struct )) - (type $A (struct)) + ;; CHECK-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) (type $B (struct_subtype $A)) + ;; CHECK: (type $X (struct (field (ref $A)))) (type $X (struct (ref $B))) + ;; CHECK: (type $A' (struct )) (type $A' (struct)) ) - ;; CHECK: (type $2 (func)) + ;; CHECK: (type $3 (func)) - ;; CHECK: (func $foo (type $2) - ;; CHECK-NEXT: (local $b (ref null $A)) + ;; CHECK: (func $foo (type $3) + ;; CHECK-NEXT: (local $b (ref null $A')) ;; CHECK-NEXT: (local $x (ref null $X)) ;; CHECK-NEXT: (nop) ;; CHECK-NEXT: ) @@ -872,12 +872,12 @@ ;; $x and $y are structurally identical, but won't be merged because there is ;; a cast to $y. ;; CHECK: (rec - ;; CHECK-NEXT: (type $b (struct (field (ref null $x)))) + ;; CHECK-NEXT: (type $b (sub (struct (field (ref null $x))))) ;; CHECK: (type $b1 (sub $b (struct (field (ref null $y))))) - ;; CHECK: (type $x (struct (field anyref))) - (type $x (struct anyref)) + ;; CHECK: (type $x (sub (struct (field anyref)))) + (type $x (sub (struct anyref))) ;; CHECK: (type $y (sub $x (struct (field anyref)))) (type $y (struct_subtype anyref $x)) @@ -887,7 +887,7 @@ ;; subtype of $b. ;; CHECK: (type $a (struct (field (ref null $y)))) (type $a (struct (ref null $y))) - (type $b (struct (ref null $x))) + (type $b (sub (struct (ref null $x)))) (type $b1 (struct_subtype (ref null $y) $b)) ) @@ -926,16 +926,16 @@ ;; TODO: Investigate why the rec group contains two of the same type below. (module (rec - (type $A (func (result (ref any) (ref $C)))) ;; CHECK: (rec - ;; CHECK-NEXT: (type $B (func)) - (type $B (func)) - (type $C (sub $B (func))) - ;; CHECK: (type $1 (func (result (ref any) (ref $B)))) + ;; CHECK-NEXT: (type $B (sub (func))) - ;; CHECK: (type $2 (func (result (ref any) (ref $B)))) + ;; CHECK: (type $1 (func (result (ref any) (ref $B)))) - ;; CHECK: (type $D (sub final $2 (func (result (ref any) (ref $B))))) + ;; CHECK: (type $A (sub (func (result (ref any) (ref $B))))) + (type $A (sub (func (result (ref any) (ref $C))))) + (type $B (sub (func))) + (type $C (sub $B (func))) + ;; CHECK: (type $D (sub final $A (func (result (ref any) (ref $B))))) (type $D (sub final $A (func (result (ref any) (ref $C))))) ) @@ -961,14 +961,14 @@ ;; was to manually split partitions that end up containing separate type trees. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $I (struct (field anyref))) + ;; CHECK-NEXT: (type $I (sub (struct (field anyref)))) (type $I (sub (struct (field anyref)))) ;; CHECK: (type $J (sub $I (struct (field eqref)))) (type $J (sub $I (struct (field eqref)))) ;; CHECK: (type $K (sub $J (struct (field i31ref)))) (type $K (sub $J (struct (field i31ref)))) (rec - ;; CHECK: (type $A (struct (field (ref null $A)) (field (ref null $I)))) + ;; CHECK: (type $A (sub (struct (field (ref null $A)) (field (ref null $I))))) (type $A (sub (struct (ref null $A) (ref null $I)))) ;; CHECK: (type $C (sub $A (struct (field (ref null $A)) (field (ref null $K))))) @@ -991,14 +991,14 @@ ;; Same as above, but with some additional types that can be merged. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $I (struct (field anyref))) + ;; CHECK-NEXT: (type $I (sub (struct (field anyref)))) (type $I (sub (struct (field anyref)))) ;; CHECK: (type $J (sub $I (struct (field eqref)))) (type $J (sub $I (struct (field eqref)))) ;; CHECK: (type $K (sub $J (struct (field i31ref)))) (type $K (sub $J (struct (field i31ref)))) (rec - ;; CHECK: (type $A (struct (field (ref null $A)) (field (ref null $I)))) + ;; CHECK: (type $A (sub (struct (field (ref null $A)) (field (ref null $I))))) (type $A (sub (struct (ref null $A) (ref null $I)))) (type $A' (sub $A (struct (ref null $A) (ref null $I)))) ;; CHECK: (type $C (sub $A (struct (field (ref null $A)) (field (ref null $K))))) @@ -1030,8 +1030,8 @@ ;; Check that a ref.test inhibits merging (ref.cast is already checked above). (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct )) - (type $A (struct)) + ;; CHECK-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; CHECK: (type $B (sub $A (struct ))) (type $B (struct_subtype $A)) @@ -1052,8 +1052,8 @@ ;; Check that a br_on_cast inhibits merging. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct )) - (type $A (struct)) + ;; CHECK-NEXT: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; CHECK: (type $B (sub $A (struct ))) (type $B (struct_subtype $A)) @@ -1099,8 +1099,8 @@ ;; Check that a call_indirect inhibits merging. (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (func)) - (type $A (func)) + ;; CHECK-NEXT: (type $A (sub (func))) + (type $A (sub (func))) ;; CHECK: (type $B (sub $A (func))) (type $B (func_subtype $A)) diff --git a/test/lit/passes/type-refining-isorecursive.wast b/test/lit/passes/type-refining-isorecursive.wast index 628282f46..ecc9b1f90 100644 --- a/test/lit/passes/type-refining-isorecursive.wast +++ b/test/lit/passes/type-refining-isorecursive.wast @@ -5,11 +5,11 @@ ;; The types should be refined to a set of three mutually recursive types. ;; CHECK: (rec - ;; CHECK-NEXT: (type $2 (struct (field nullexternref) (field (ref $0)))) + ;; CHECK-NEXT: (type $2 (sub (struct (field nullexternref) (field (ref $0))))) - ;; CHECK: (type $1 (struct (field nullfuncref) (field (ref $2)))) + ;; CHECK: (type $1 (sub (struct (field nullfuncref) (field (ref $2))))) - ;; CHECK: (type $0 (struct (field nullref) (field (ref $1)))) + ;; CHECK: (type $0 (sub (struct (field nullref) (field (ref $1))))) (type $0 (struct_subtype nullref anyref data)) (type $1 (struct_subtype nullfuncref anyref data)) (type $2 (struct_subtype nullexternref anyref data)) @@ -64,13 +64,13 @@ ;; correctly. ;; CHECK: (rec - ;; CHECK-NEXT: (type $0 (struct (field (ref null $all)) (field (ref $0)))) + ;; CHECK-NEXT: (type $0 (sub (struct (field (ref null $all)) (field (ref $0))))) ;; CHECK: (type $1 (sub $0 (struct (field (ref null $all)) (field (ref $0))))) ;; CHECK: (type $2 (sub $1 (struct (field (ref null $all)) (field (ref $0))))) - ;; CHECK: (type $all (struct (field i32) (field (ref $0)) (field (ref $1)) (field (ref $2)))) + ;; CHECK: (type $all (sub (struct (field i32) (field (ref $0)) (field (ref $1)) (field (ref $2))))) (type $all (struct_subtype i32 anyref anyref anyref data)) (type $0 (struct_subtype anyref anyref data)) diff --git a/test/lit/passes/type-refining.wast b/test/lit/passes/type-refining.wast index 8dab9bc7e..6d0c2257a 100644 --- a/test/lit/passes/type-refining.wast +++ b/test/lit/passes/type-refining.wast @@ -6,7 +6,7 @@ ;; write of the same type, and the last a write of a subtype, which will allow ;; us to specialize that one. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut anyref)) (field (mut (ref i31))) (field (mut (ref i31))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut anyref)) (field (mut (ref i31))) (field (mut (ref i31)))))) (type $struct (struct_subtype (field (mut anyref)) (field (mut (ref i31))) (field (mut anyref)) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -55,7 +55,7 @@ ;; default value being null. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut i31ref)))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut i31ref))))) (type $struct (struct_subtype (field (mut anyref)) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -90,7 +90,7 @@ (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref $struct)))))) (type $struct (struct_subtype (field (mut structref)) data)) ;; CHECK: (type $child-B (sub $struct (struct (field (mut (ref $struct)))))) @@ -131,7 +131,7 @@ (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref $child-A))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref $child-A)))))) (type $struct (struct_subtype (field (mut structref)) data)) ;; CHECK: (type $child-A (sub $struct (struct (field (mut (ref $child-A)))))) @@ -184,7 +184,7 @@ ;; $struct but not to $child. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref $struct)))))) (type $struct (struct_subtype (field (mut structref)) data)) ;; CHECK: (type $child (sub $struct (struct (field (mut (ref $struct)))))) @@ -218,7 +218,7 @@ ;; As above, but both writes are of $child, so we can optimize. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref $child))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref $child)))))) (type $struct (struct_subtype (field (mut structref)) data)) ;; CHECK: (type $child (sub $struct (struct (field (mut (ref $child)))))) @@ -255,7 +255,7 @@ ;; child's. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref $struct)))))) (type $struct (struct_subtype (field (mut structref)) data)) ;; CHECK: (type $child (sub $struct (struct (field (mut (ref $struct)))))) @@ -300,7 +300,7 @@ ;; testcase after this.) ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (ref $struct)))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (ref $struct))))) (type $struct (struct_subtype (field structref) data)) ;; CHECK: (type $child (sub $struct (struct (field (ref $child))))) @@ -340,7 +340,7 @@ ;; improvement!) ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref $struct)))))) (type $struct (struct_subtype (field (mut structref)) data)) ;; CHECK: (type $child (sub $struct (struct (field (mut (ref $struct)))))) @@ -380,7 +380,7 @@ ;; to $child. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref $struct)))))) (type $struct (struct_subtype (field (mut structref)) data)) ;; CHECK: (type $child (sub $struct (struct (field (mut (ref $struct))) (field (mut (ref $child)))))) @@ -421,7 +421,7 @@ ;; the old type). ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref $struct)))))) (type $struct (struct_subtype (field (mut structref)) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -455,12 +455,12 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (ref $Y)))) + ;; CHECK-NEXT: (type $A (sub (struct (field (ref $Y))))) ;; CHECK: (type $B (sub $A (struct (field (ref $Y))))) - ;; CHECK: (type $X (struct )) - (type $X (struct)) + ;; CHECK: (type $X (sub (struct ))) + (type $X (sub (struct))) ;; CHECK: (type $Y (sub $X (struct ))) (type $Y (struct_subtype $X)) @@ -509,13 +509,13 @@ (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $X (struct )) - (type $X (struct)) + ;; CHECK-NEXT: (type $X (sub (struct ))) + (type $X (sub (struct))) ;; CHECK: (type $Y (sub $X (struct ))) (type $Y (struct_subtype $X)) - ;; CHECK: (type $A (struct (field (ref $X)))) + ;; CHECK: (type $A (sub (struct (field (ref $X))))) (type $A (struct_subtype (field (ref $X)) data)) ;; CHECK: (type $B (sub $A (struct (field (ref $X))))) @@ -542,12 +542,12 @@ ) (module - ;; CHECK: (type $X (struct )) - (type $X (struct)) + ;; CHECK: (type $X (sub (struct ))) + (type $X (sub (struct))) ;; CHECK: (type $1 (func)) - ;; CHECK: (type $A (struct (field (ref $X)))) + ;; CHECK: (type $A (sub (struct (field (ref $X))))) ;; CHECK: (type $Y (sub $X (struct ))) (type $Y (struct_subtype $X)) @@ -582,7 +582,7 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref null $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref null $struct)))))) (type $struct (struct_subtype (field (mut (ref null struct))) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -616,7 +616,7 @@ ;; refine the field to nullable $struct. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref null $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref null $struct)))))) (type $struct (struct_subtype (field (mut (ref null struct))) data)) ;; CHECK: (type $child (sub $struct (struct (field (mut (ref null $struct)))))) (type $child (struct_subtype (field (mut (ref null struct))) $struct)) @@ -649,7 +649,7 @@ ;; As above, but now the null is in a parent. The result should be the same. ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref null $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref null $struct)))))) (type $struct (struct_subtype (field (mut (ref null struct))) data)) ;; CHECK: (type $child (sub $struct (struct (field (mut (ref null $struct)))))) (type $child (struct_subtype (field (mut (ref null struct))) $struct)) @@ -680,7 +680,7 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut nullref)))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut nullref))))) (type $struct (struct_subtype (field (mut (ref null struct))) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -701,7 +701,7 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref null $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref null $struct)))))) (type $struct (struct_subtype (field (mut (ref null struct))) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -730,7 +730,7 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref null $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref null $struct)))))) (type $struct (struct_subtype (field (mut (ref null struct))) data)) ;; CHECK: (type $1 (func (param (ref $struct)))) @@ -763,7 +763,7 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct (struct (field (mut (ref null $child))) (field (mut (ref null $struct))))) + ;; CHECK-NEXT: (type $struct (sub (struct (field (mut (ref null $child))) (field (mut (ref null $struct)))))) (type $struct (struct_subtype (field (mut (ref null struct))) (field (mut (ref null struct))) data)) ;; CHECK: (type $child (sub $struct (struct (field (mut (ref null $child))) (field (mut (ref null $struct)))))) @@ -819,13 +819,13 @@ ;; -> Leaf2-Outer[Leaf2-Inner] ;; CHECK: (rec - ;; CHECK-NEXT: (type $Root-Inner (struct )) - (type $Root-Inner (struct)) + ;; CHECK-NEXT: (type $Root-Inner (sub (struct ))) + (type $Root-Inner (sub (struct))) ;; CHECK: (type $Leaf1-Inner (sub $Root-Inner (struct (field i32)))) (type $Leaf1-Inner (struct_subtype (field i32) $Root-Inner)) - ;; CHECK: (type $Root-Outer (struct (field (ref $Leaf2-Inner)))) + ;; CHECK: (type $Root-Outer (sub (struct (field (ref $Leaf2-Inner))))) ;; CHECK: (type $Leaf1-Outer (sub $Root-Outer (struct (field (ref $Leaf2-Inner))))) @@ -897,7 +897,7 @@ ) (module - ;; CHECK: (type $A (struct (field (mut (ref null $A))))) + ;; CHECK: (type $A (sub (struct (field (mut (ref null $A)))))) (type $A (struct_subtype (field (mut (ref null $A))) data)) ;; CHECK: (type $1 (func (param (ref $A) (ref null $A)))) @@ -961,7 +961,7 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (ref null $A)))) + ;; CHECK-NEXT: (type $A (sub (struct (field (ref null $A))))) (type $A (struct_subtype (field (ref null $A)) data)) ;; CHECK: (type $B (sub $A (struct (field (ref null $B))))) (type $B (struct_subtype (field (ref null $A)) $A)) @@ -1012,7 +1012,7 @@ (module ;; CHECK: (rec - ;; CHECK-NEXT: (type $A (struct (field (mut (ref $A))))) + ;; CHECK-NEXT: (type $A (sub (struct (field (mut (ref $A)))))) (type $A (struct_subtype (field (mut (ref null $A))) data)) ;; CHECK: (type $1 (func (param (ref $A) (ref null $A)))) diff --git a/test/lit/passes/type-ssa.wast b/test/lit/passes/type-ssa.wast index f9fb5eb26..ae5b2c532 100644 --- a/test/lit/passes/type-ssa.wast +++ b/test/lit/passes/type-ssa.wast @@ -2,12 +2,9 @@ ;; RUN: foreach %s %t wasm-opt --type-ssa -all -S -o - | filecheck %s -;; Test in both isorecursive and nominal modes to make sure we create the new -;; types properly in both. - ;; Every struct.new here should get a new type. (module - ;; CHECK: (type $struct (struct (field i32))) + ;; CHECK: (type $struct (sub (struct (field i32)))) (type $struct (struct_subtype (field i32) data)) ;; CHECK: (type $1 (func)) @@ -77,7 +74,7 @@ ;; The same module as before, except that now the type is final, so we cannot ;; create any subtypes. (module - ;; CHECK: (type $struct (sub final (struct (field i32)))) + ;; CHECK: (type $struct (struct (field i32))) (type $struct (sub final (struct (field i32)))) ;; CHECK: (type $1 (func)) @@ -138,7 +135,7 @@ ;; CHECK: (type $0 (func (param anyref arrayref))) - ;; CHECK: (type $struct (struct (field anyref))) + ;; CHECK: (type $struct (sub (struct (field anyref)))) (type $struct (struct_subtype (field (ref null any)) data)) ;; CHECK: (rec @@ -208,13 +205,13 @@ ) (module - ;; CHECK: (type $array (array (mut anyref))) - (type $array (array (mut (ref null any)))) + ;; CHECK: (type $array (sub (array (mut anyref)))) + (type $array (sub (array (mut (ref null any))))) ;; CHECK: (type $1 (func (param (ref i31) anyref))) - ;; CHECK: (type $array-func (array (mut funcref))) - (type $array-func (array (mut funcref))) + ;; CHECK: (type $array-func (sub (array (mut funcref)))) + (type $array-func (sub (array (mut funcref)))) (elem func $array.new) @@ -369,15 +366,15 @@ ;; turn into a simple Literal). (We do optimize $empty and generate $empty$1, ;; but that is not important here.) (module - ;; CHECK: (type $empty (struct )) - (type $empty (struct)) + ;; CHECK: (type $empty (sub (struct ))) + (type $empty (sub (struct))) ;; CHECK: (type $empty$1 (sub $empty (struct ))) ;; CHECK: (type $2 (func (param anyref))) - ;; CHECK: (type $struct (struct (field externref) (field anyref) (field externref))) - (type $struct (struct externref anyref externref)) + ;; CHECK: (type $struct (sub (struct (field externref) (field anyref) (field externref)))) + (type $struct (sub (struct externref anyref externref))) ;; CHECK: (global $g (mut anyref) (struct.new_default $empty$1)) (global $g (mut anyref) (struct.new $empty)) @@ -422,8 +419,8 @@ ) (module - ;; CHECK: (type $array (array (mut f32))) - (type $array (array (mut f32))) + ;; CHECK: (type $array (sub (array (mut f32)))) + (type $array (sub (array (mut f32)))) ;; CHECK: (type $subarray (sub $array (array (mut f32)))) (type $subarray (array_subtype (mut f32) $array)) @@ -455,8 +452,8 @@ ) (module - ;; CHECK: (type $A (struct )) - (type $A (struct )) + ;; CHECK: (type $A (sub (struct ))) + (type $A (sub (struct))) ;; CHECK: (type $A$1 (sub $A (struct ))) diff --git a/test/lit/passes/type-ssa_and_merging.wast b/test/lit/passes/type-ssa_and_merging.wast index 63c0b86f2..46129e37f 100644 --- a/test/lit/passes/type-ssa_and_merging.wast +++ b/test/lit/passes/type-ssa_and_merging.wast @@ -10,13 +10,13 @@ ;; NOP: (rec ;; NOP-NEXT: (type $0 (func (param (ref $A)) (result i32))) - ;; NOP: (type $A (struct (field i32))) + ;; NOP: (type $A (sub (struct (field i32)))) ;; YES: (type $0 (func (result i32))) ;; YES: (rec ;; YES-NEXT: (type $1 (func (param (ref $A)))) - ;; YES: (type $A (struct )) + ;; YES: (type $A (sub (struct ))) (type $A (struct_subtype (field (mut i32)) data)) ;; NOP: (type $2 (func (result i32))) diff --git a/test/lit/recursive-types.wast b/test/lit/recursive-types.wast index fc3d83dc3..46b6d3c10 100644 --- a/test/lit/recursive-types.wast +++ b/test/lit/recursive-types.wast @@ -11,8 +11,8 @@ ;; CHECK: (type $type$0 (func (param (ref null $type$0)) (result (ref null $type$0)))) ;; CHECK: (rec - ;; CHECK-NEXT: (type $f3 (func (param (ref null $type$2)) (result (ref null $f3)))) - (type $f3 (func (param (ref null 4)) (result (ref null 3)))) + ;; CHECK-NEXT: (type $f3 (sub (func (param (ref null $type$2)) (result (ref null $f3))))) + (type $f3 (sub (func (param (ref null 4)) (result (ref null 3))))) (type (func_subtype (param (ref null 3)) (result (ref null 4)) $f3)) ) diff --git a/test/lit/strings.wast b/test/lit/strings.wast index fa9e7b712..fb86c484d 100644 --- a/test/lit/strings.wast +++ b/test/lit/strings.wast @@ -20,9 +20,9 @@ ;; CHECK: (type $2 (func (param stringref stringview_wtf8 stringview_wtf16 stringview_iter))) - ;; CHECK: (type $array (array (mut i8))) + ;; CHECK: (type $array (sub (array (mut i8)))) (type $array (array_subtype (mut i8) data)) - ;; CHECK: (type $array16 (array (mut i16))) + ;; CHECK: (type $array16 (sub (array (mut i16)))) (type $array16 (array_subtype (mut i16) data)) ;; CHECK: (type $5 (func (param stringref stringview_wtf8 stringview_wtf16 stringview_iter stringref stringview_wtf8 stringview_wtf16 stringview_iter (ref string) (ref stringview_wtf8) (ref stringview_wtf16) (ref stringview_iter)))) diff --git a/test/lit/subtype-chain.wast b/test/lit/subtype-chain.wast index 0dabd0f2f..882aadae6 100644 --- a/test/lit/subtype-chain.wast +++ b/test/lit/subtype-chain.wast @@ -7,8 +7,8 @@ ;; types. (module - ;; CHECK: (type $root (struct )) - (type $root (struct)) + ;; CHECK: (type $root (sub (struct ))) + (type $root (sub (struct))) ;; CHECK: (type $trunk (sub $root (struct (field i32)))) (type $trunk (struct_subtype i32 $root)) diff --git a/test/lit/subtypes.wast b/test/lit/subtypes.wast index 17ccb0ba2..20f605b5f 100644 --- a/test/lit/subtypes.wast +++ b/test/lit/subtypes.wast @@ -6,24 +6,24 @@ (module (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $super-struct (struct (field i32))) - (type $super-struct (struct i32)) + ;; CHECK-NEXT: (type $super-struct (sub (struct (field i32)))) + (type $super-struct (sub (struct i32))) ;; CHECK: (type $sub-struct (sub $super-struct (struct (field i32) (field i64)))) (type $sub-struct (struct_subtype i32 i64 $super-struct)) ) (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $super-array (array (ref $super-struct))) - (type $super-array (array (ref $super-struct))) + ;; CHECK-NEXT: (type $super-array (sub (array (ref $super-struct)))) + (type $super-array (sub (array (ref $super-struct)))) ;; CHECK: (type $sub-array (sub $super-array (array (ref $sub-struct)))) (type $sub-array (array_subtype (ref $sub-struct) $super-array)) ) (rec ;; CHECK: (rec - ;; CHECK-NEXT: (type $super-func (func (param (ref $sub-array)) (result (ref $super-array)))) - (type $super-func (func (param (ref $sub-array)) (result (ref $super-array)))) + ;; CHECK-NEXT: (type $super-func (sub (func (param (ref $sub-array)) (result (ref $super-array))))) + (type $super-func (sub (func (param (ref $sub-array)) (result (ref $super-array))))) ;; CHECK: (type $sub-func (sub $super-func (func (param (ref $super-array)) (result (ref $sub-array))))) (type $sub-func (func_subtype (param (ref $super-array)) (result (ref $sub-array)) $super-func)) ) diff --git a/test/lit/tail-call.wast b/test/lit/tail-call.wast index a2f96eeba..873d79034 100644 --- a/test/lit/tail-call.wast +++ b/test/lit/tail-call.wast @@ -33,8 +33,8 @@ ;; Check GC types and subtyping (module - ;; CHECK: (type $A (struct (field i32))) - (type $A (struct i32)) + ;; CHECK: (type $A (sub (struct (field i32)))) + (type $A (sub (struct i32))) ;; CHECK: (type $B (sub $A (struct (field i32) (field i32)))) (type $B (struct_subtype i32 i32 $A)) diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast index ddf35edcf..eb8d4f100 100644 --- a/test/lit/wat-kitchen-sink.wast +++ b/test/lit/wat-kitchen-sink.wast @@ -9,7 +9,7 @@ (type $ret2 (func (result i32 i32))) (rec - ;; CHECK: (type $void (func)) + ;; CHECK: (type $void (sub (func))) ;; CHECK: (type $pair (struct (field (mut i32)) (field (mut i64)))) @@ -33,7 +33,7 @@ ;; CHECK: (type $packed-i16 (array (mut i16))) - ;; CHECK: (type $many (func (param i32 i64 f32 f64) (result anyref (ref func)))) + ;; CHECK: (type $many (sub (func (param i32 i64 f32 f64) (result anyref (ref func))))) ;; CHECK: (type $14 (func (param i32 i32))) @@ -137,16 +137,16 @@ (type $packed-i16 (array (mut i16))) (rec - (type $void (func)) + (type $void (sub open (func))) ) - ;; CHECK: (type $subvoid (sub $void (func))) + ;; CHECK: (type $subvoid (sub final $void (func))) (type $subvoid (sub $void (func))) - (type $many (func (param $x i32) (param i64 f32) (param) (param $y f64) - (result anyref (ref func)))) + (type $many (sub open (func (param $x i32) (param i64 f32) (param) (param $y f64) + (result anyref (ref func))))) - ;; CHECK: (type $submany (sub $many (func (param i32 i64 f32 f64) (result anyref (ref func))))) + ;; CHECK: (type $submany (sub final $many (func (param i32 i64 f32 f64) (result anyref (ref func))))) (type $submany (sub $many (func (param i32 i64 f32 f64) (result anyref (ref func))))) ;; globals @@ -168,7 +168,7 @@ ;; CHECK: (import "mod" "" (global $gimport$1 (ref null $many))) - ;; CHECK: (import "mod" "f5" (func $fimport$1 (type $void))) + ;; CHECK: (import "mod" "f5" (func $fimport$1 (type $func.0))) ;; CHECK: (global $2 (mut i32) (i32.const 0)) |