From d80f800d2985e6bff7e0148e10c8996e447a8c85 Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Fri, 1 Sep 2023 15:05:54 -0700 Subject: [PATCH 1/3] Make final types the default 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. --- CHANGELOG.md | 2 + src/binaryen-c.cpp | 3 + src/binaryen-c.h | 3 + src/ir/type-updating.cpp | 2 +- src/passes/TypeMerging.cpp | 4 +- src/passes/TypeSSA.cpp | 4 +- src/tools/fuzzing/heap-types.cpp | 6 +- src/tools/wasm-fuzz-types.cpp | 2 +- src/wasm-type.h | 8 +- src/wasm/wasm-binary.cpp | 15 +- src/wasm/wasm-s-parser.cpp | 7 +- src/wasm/wasm-type.cpp | 21 ++- src/wasm/wat-parser.cpp | 6 + test/ctor-eval/gc-2.wast.out | 2 +- test/ctor-eval/gc.wast.out | 2 +- test/example/c-api-kitchen-sink.c | 6 +- test/example/c-api-kitchen-sink.txt | 6 +- test/gtest/possible-contents.cpp | 13 +- test/gtest/type-builder.cpp | 108 ++++++------- test/lit/fuzz-types.test | 65 ++++---- test/lit/isorecursive-good.wast | 8 +- test/lit/isorecursive-output-ordering.wast | 30 ++-- test/lit/isorecursive-singleton-group.wast | 2 +- test/lit/isorecursive-whole-group.wast | 4 +- test/lit/parse-nominal-types-extends.wast | 20 +-- test/lit/parse-nominal-types.wast | 10 +- test/lit/passes/abstract-type-refining.wast | 50 +++--- test/lit/passes/cfp.wast | 52 +++--- test/lit/passes/coalesce-locals-gc.wast | 2 +- test/lit/passes/dae-gc-refine-params.wast | 4 +- test/lit/passes/dae-gc-refine-return.wast | 4 +- test/lit/passes/dae_tnh.wast | 2 +- test/lit/passes/gsi.wast | 20 +-- test/lit/passes/gsi_vacuum_precompute.wast | 6 +- test/lit/passes/gto-mutability.wast | 12 +- test/lit/passes/gto-removals.wast | 28 ++-- test/lit/passes/gto_and_cfp_in_O.wast | 2 +- test/lit/passes/gufa-cast-all.wast | 4 +- test/lit/passes/gufa-refs.wast | 78 ++++----- test/lit/passes/gufa-tnh-closed.wast | 24 +-- test/lit/passes/gufa-tnh.wast | 68 ++++---- test/lit/passes/gufa-vs-cfp.wast | 56 +++---- test/lit/passes/heap2local.wast | 4 +- ...inlining_vacuum_optimize-instructions.wast | 4 +- test/lit/passes/local-subtyping.wast | 2 +- .../passes/merge-similar-functions_types.wast | 4 +- test/lit/passes/monomorphize.wast | 20 +-- test/lit/passes/optimize-casts-tnh.wast | 2 +- test/lit/passes/optimize-casts.wast | 2 +- .../passes/optimize-instructions-gc-iit.wast | 10 +- .../passes/optimize-instructions-gc-tnh.wast | 4 +- test/lit/passes/optimize-instructions-gc.wast | 116 +++++++------- test/lit/passes/remove-unused-brs-gc.wast | 2 +- .../remove-unused-module-elements-refs.wast | 32 ++-- test/lit/passes/roundtrip-gc-types.wast | 4 +- test/lit/passes/rse-gc.wast | 4 +- test/lit/passes/signature-pruning.wast | 58 +++---- test/lit/passes/signature-refining.wast | 56 +++---- test/lit/passes/simplify-locals-gc.wast | 2 +- test/lit/passes/simplify-locals-strings.wast | 4 +- test/lit/passes/type-merging-tnh.wast | 16 +- test/lit/passes/type-merging.wast | 150 +++++++++--------- .../passes/type-refining-isorecursive.wast | 10 +- test/lit/passes/type-refining.wast | 66 ++++---- test/lit/passes/type-ssa.wast | 71 ++++----- test/lit/passes/type-ssa_and_merging.wast | 12 +- test/lit/recursive-types.wast | 4 +- test/lit/strings.wast | 4 +- test/lit/subtype-chain.wast | 4 +- test/lit/subtypes.wast | 12 +- test/lit/tail-call.wast | 4 +- test/lit/wat-kitchen-sink.wast | 16 +- test/passes/Oz_fuzz-exec_all-features.txt | 2 +- test/passes/Oz_fuzz-exec_all-features.wast | 2 +- test/spec/ref_cast.wast | 2 +- test/subtypes.wast | 10 +- test/subtypes.wast.from-wast | 6 +- test/subtypes.wast.fromBinary | 6 +- test/subtypes.wast.fromBinary.noDebugInfo | 6 +- 79 files changed, 749 insertions(+), 755 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 50072ebb385..a6db554e38d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,8 @@ Current Trunk and as a convenience. - The nonstandard, experimental gc-nn-locals feature has been removed now that standard non-nullable locals are supported. +- Heap types are now final by default and openness must be opted into both in + the text and binary formats as well as in the TypeBuilder API. v114 ---- diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp index 59b01032dc4..fd00c25c047 100644 --- a/src/binaryen-c.cpp +++ b/src/binaryen-c.cpp @@ -6413,6 +6413,9 @@ void TypeBuilderSetSubType(TypeBuilderRef builder, BinaryenHeapType superType) { ((TypeBuilder*)builder)->setSubType(index, HeapType(superType)); } +void TypeBuilderSetOpen(TypeBuilderRef builder, BinaryenIndex index) { + ((TypeBuilder*)builder)->setOpen(index); +} void TypeBuilderCreateRecGroup(TypeBuilderRef builder, BinaryenIndex index, BinaryenIndex length) { diff --git a/src/binaryen-c.h b/src/binaryen-c.h index 2288eb5ca99..f4f4f2d7438 100644 --- a/src/binaryen-c.h +++ b/src/binaryen-c.h @@ -3572,6 +3572,9 @@ BINARYEN_API BinaryenType TypeBuilderGetTempRefType(TypeBuilderRef builder, BINARYEN_API void TypeBuilderSetSubType(TypeBuilderRef builder, BinaryenIndex index, BinaryenHeapType superType); +// Sets the type at `index` to be open (i.e. non-final). +BINARYEN_API void TypeBuilderSetOpen(TypeBuilderRef builder, + BinaryenIndex index); // Creates a new recursion group in the range `index` inclusive to `index + // length` exclusive. Recursion groups must not overlap. BINARYEN_API void TypeBuilderCreateRecGroup(TypeBuilderRef builder, diff --git a/src/ir/type-updating.cpp b/src/ir/type-updating.cpp index 0bc14763b96..cca0d23605e 100644 --- a/src/ir/type-updating.cpp +++ b/src/ir/type-updating.cpp @@ -72,7 +72,7 @@ GlobalTypeRewriter::TypeMap GlobalTypeRewriter::rebuildTypes() { // Create the temporary heap types. i = 0; for (auto [type, _] : typeIndices) { - typeBuilder[i].setFinal(type.isFinal()); + typeBuilder[i].setOpen(type.isOpen()); if (type.isSignature()) { auto sig = type.getSignature(); TypeList newParams, newResults; diff --git a/src/passes/TypeMerging.cpp b/src/passes/TypeMerging.cpp index ea1fa7916dd..3d7a032b58a 100644 --- a/src/passes/TypeMerging.cpp +++ b/src/passes/TypeMerging.cpp @@ -538,7 +538,7 @@ bool shapeEq(HeapType a, HeapType b) { // Check whether `a` and `b` have the same top-level structure, including the // position and identity of any children that are not included as transitions // in the DFA, i.e. any children that are not nontrivial references. - if (a.isFinal() != b.isFinal()) { + if (a.isOpen() != b.isOpen()) { return false; } if (a.isStruct() && b.isStruct()) { @@ -554,7 +554,7 @@ bool shapeEq(HeapType a, HeapType b) { } size_t shapeHash(HeapType a) { - size_t digest = hash(a.isFinal()); + size_t digest = hash(a.isOpen()); if (a.isStruct()) { rehash(digest, 0); hash_combine(digest, shapeHash(a.getStruct())); diff --git a/src/passes/TypeSSA.cpp b/src/passes/TypeSSA.cpp index f44df96e123..1105c5b12bf 100644 --- a/src/passes/TypeSSA.cpp +++ b/src/passes/TypeSSA.cpp @@ -110,7 +110,7 @@ std::vector ensureTypesAreInNewRecGroup(RecGroup recGroup, if (auto super = type.getSuperType()) { builder[i].subTypeOf(*super); } - builder[i].setFinal(type.isFinal()); + builder[i].setOpen(type.isOpen()); } // Implement the hash as a struct with "random" fields, and add it. @@ -311,7 +311,7 @@ struct TypeSSA : public Pass { return false; } - if (curr->type.getHeapType().isFinal()) { + if (!curr->type.getHeapType().isOpen()) { // We can't create new subtypes of a final type anyway. return false; } diff --git a/src/tools/fuzzing/heap-types.cpp b/src/tools/fuzzing/heap-types.cpp index 2f77c57653e..c8980cbe863 100644 --- a/src/tools/fuzzing/heap-types.cpp +++ b/src/tools/fuzzing/heap-types.cpp @@ -87,9 +87,7 @@ struct HeapTypeGeneratorImpl { // Types without nontrivial subtypes may be marked final. for (Index i = 0; i < builder.size(); ++i) { - if (subtypeIndices[i].size() == 1 && rand.oneIn(2)) { - builder[i].setFinal(); - } + builder[i].setOpen(subtypeIndices[i].size() > 1 || rand.oneIn(2)); } // Initialize the recursion groups. @@ -894,7 +892,7 @@ std::vector Inhabitator::build() { builder[i].subTypeOf(*super); } } - builder[i].setFinal(types[i].isFinal()); + builder[i].setOpen(types[i].isOpen()); } auto built = builder.build(); diff --git a/src/tools/wasm-fuzz-types.cpp b/src/tools/wasm-fuzz-types.cpp index 50f1e1e3c83..2be8aa5e7d7 100644 --- a/src/tools/wasm-fuzz-types.cpp +++ b/src/tools/wasm-fuzz-types.cpp @@ -264,7 +264,7 @@ void Fuzzer::checkCanonicalization() { // Set finality for (size_t i = 0; i < types.size(); ++i) { - builder[i].setFinal(types[i].isFinal()); + builder[i].setOpen(types[i].isOpen()); } // Set up recursion groups and record group ends to ensure we only select diff --git a/src/wasm-type.h b/src/wasm-type.h index 0d41d0cc2ab..927e378456f 100644 --- a/src/wasm-type.h +++ b/src/wasm-type.h @@ -361,7 +361,7 @@ class HeapType { bool isArray() const; bool isString() const; bool isBottom() const; - bool isFinal() const; + bool isOpen() const; Signature getSignature() const; const Struct& getStruct() const; @@ -587,7 +587,7 @@ struct TypeBuilder { // not overlap or go out of bounds. void createRecGroup(size_t i, size_t length); - void setFinal(size_t i, bool final = true); + void setOpen(size_t i, bool open = true); enum class ErrorReason { // There is a cycle in the supertype relation. @@ -650,8 +650,8 @@ struct TypeBuilder { builder.setSubType(index, other); return *this; } - Entry& setFinal(bool final = true) { - builder.setFinal(index, final); + Entry& setOpen(bool open = true) { + builder.setOpen(index, open); return *this; } }; diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp index 7a0a08885bf..f7fa6acf49f 100644 --- a/src/wasm/wasm-binary.cpp +++ b/src/wasm/wasm-binary.cpp @@ -265,13 +265,11 @@ void WasmBinaryWriter::writeTypes() { // Emit the type definition. BYN_TRACE("write " << type << std::endl); auto super = type.getSuperType(); - // TODO: Use the binary shorthand for final types once we parse MVP - // signatures as final. - if (type.isFinal() || super || hasSubtypes[i]) { - if (type.isFinal()) { - o << S32LEB(BinaryConsts::EncodedType::SubFinal); - } else { + if (super || type.isOpen()) { + if (type.isOpen()) { o << S32LEB(BinaryConsts::EncodedType::Sub); + } else { + o << S32LEB(BinaryConsts::EncodedType::SubFinal); } if (super) { o << U32LEB(1); @@ -2268,9 +2266,8 @@ void WasmBinaryReader::readTypes() { std::optional superIndex; if (form == BinaryConsts::EncodedType::Sub || form == BinaryConsts::EncodedType::SubFinal) { - if (form == BinaryConsts::EncodedType::SubFinal) { - // TODO: Interpret type definitions without any `sub` as final as well. - builder[i].setFinal(); + if (form == BinaryConsts::EncodedType::Sub) { + builder[i].setOpen(); } uint32_t supers = getU32LEB(); if (supers > 0) { diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp index b6b9a40fbd6..e30901c5b0a 100644 --- a/src/wasm/wasm-s-parser.cpp +++ b/src/wasm/wasm-s-parser.cpp @@ -929,8 +929,9 @@ void SExpressionWasmBuilder::preParseHeapTypes(Element& module) { if (kind == SUB) { Index i = 1; if (*def[i] == FINAL) { - builder[index].setFinal(); ++i; + } else { + builder[index].setOpen(); } if (def[i]->dollared()) { super = def[i]; @@ -959,6 +960,7 @@ void SExpressionWasmBuilder::preParseHeapTypes(Element& module) { if (kind == FUNC) { builder[index] = parseSignatureDef(def, 0); } else if (kind == FUNC_SUBTYPE) { + builder[index].setOpen(); builder[index] = parseSignatureDef(def, 1); super = def[def.size() - 1]; if (!super->dollared() && super->str() == FUNC) { @@ -968,6 +970,7 @@ void SExpressionWasmBuilder::preParseHeapTypes(Element& module) { } else if (kind == STRUCT) { builder[index] = parseStructDef(def, index, 0); } else if (kind == STRUCT_SUBTYPE) { + builder[index].setOpen(); builder[index] = parseStructDef(def, index, 1); super = def[def.size() - 1]; if (!super->dollared() && super->str() == DATA) { @@ -977,6 +980,7 @@ void SExpressionWasmBuilder::preParseHeapTypes(Element& module) { } else if (kind == ARRAY) { builder[index] = parseArrayDef(def); } else if (kind == ARRAY_SUBTYPE) { + builder[index].setOpen(); builder[index] = parseArrayDef(def); super = def[def.size() - 1]; if (!super->dollared() && super->str() == DATA) { @@ -993,6 +997,7 @@ void SExpressionWasmBuilder::preParseHeapTypes(Element& module) { } } else if (elementStartsWith(elem[elem.size() - 1], EXTENDS)) { // '(' 'extends' $supertype ')' + builder[index].setOpen(); Element& extends = *elem[elem.size() - 1]; super = extends[1]; } diff --git a/src/wasm/wasm-type.cpp b/src/wasm/wasm-type.cpp index 0c4e7b04981..ba38231b6d4 100644 --- a/src/wasm/wasm-type.cpp +++ b/src/wasm/wasm-type.cpp @@ -85,7 +85,7 @@ struct HeapTypeInfo { // Used in assertions to ensure that temporary types don't leak into the // global store. bool isTemp = false; - bool isFinal = false; + bool isOpen = false; // The supertype of this HeapType, if it exists. HeapTypeInfo* supertype = nullptr; // The recursion group of this type or null if the recursion group is trivial @@ -1180,11 +1180,11 @@ bool HeapType::isBottom() const { return false; } -bool HeapType::isFinal() const { +bool HeapType::isOpen() const { if (isBasic()) { return false; } else { - return getHeapTypeInfo(*this)->isFinal; + return getHeapTypeInfo(*this)->isOpen; } } @@ -1771,13 +1771,12 @@ std::ostream& TypePrinter::print(HeapType type) { os << "(; temp ;) "; } - // TODO: Use shorthand for final types once we parse MVP signatures as final. bool useSub = false; auto super = type.getSuperType(); - if (super || type.isFinal()) { + if (super || type.isOpen()) { useSub = true; os << "(sub "; - if (type.isFinal()) { + if (!type.isOpen()) { os << "final "; } if (super) { @@ -1946,7 +1945,7 @@ size_t RecGroupHasher::hash(const HeapTypeInfo& info) const { if (info.supertype) { hash_combine(digest, hash(HeapType(uintptr_t(info.supertype)))); } - wasm::rehash(digest, info.isFinal); + wasm::rehash(digest, info.isOpen); wasm::rehash(digest, info.kind); switch (info.kind) { case HeapTypeInfo::SignatureKind: @@ -2069,7 +2068,7 @@ bool RecGroupEquator::eq(const HeapTypeInfo& a, const HeapTypeInfo& b) const { return false; } } - if (a.isFinal != b.isFinal) { + if (a.isOpen != b.isOpen) { return false; } if (a.kind != b.kind) { @@ -2325,15 +2324,15 @@ void TypeBuilder::createRecGroup(size_t index, size_t length) { {RecGroup(uintptr_t(groupInfo.get())), std::move(groupInfo)}); } -void TypeBuilder::setFinal(size_t i, bool final) { +void TypeBuilder::setOpen(size_t i, bool open) { assert(i < size() && "index out of bounds"); - impl->entries[i].info->isFinal = final; + impl->entries[i].info->isOpen = open; } namespace { bool isValidSupertype(const HeapTypeInfo& sub, const HeapTypeInfo& super) { - if (super.isFinal) { + if (!super.isOpen) { return false; } if (sub.kind != super.kind) { diff --git a/src/wasm/wat-parser.cpp b/src/wasm/wat-parser.cpp index 3961cbb7f1a..bdd1af0d86b 100644 --- a/src/wasm/wat-parser.cpp +++ b/src/wasm/wat-parser.cpp @@ -849,6 +849,7 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx { void addFuncType(SignatureT) {} void addStructType(StructT) {} void addArrayType(ArrayT) {} + void setOpen() {} Result<> addSubtype(Index) { return Ok{}; } void finishSubtype(Name name, Index pos) { subtypeDefs.push_back({name, pos, Index(subtypeDefs.size())}); @@ -1078,6 +1079,8 @@ struct ParseTypeDefsCtx : TypeParserCtx { void addArrayType(ArrayT& type) { builder[index] = type; } + void setOpen() { builder[index].setOpen(); } + Result<> addSubtype(Index super) { if (super >= builder.size()) { return in.err("supertype index out of bounds"); @@ -3463,6 +3466,9 @@ template MaybeResult<> subtype(Ctx& ctx) { } if (ctx.in.takeSExprStart("sub"sv)) { + if (ctx.in.takeKeyword("open"sv)) { + ctx.setOpen(); + } if (auto super = maybeTypeidx(ctx)) { CHECK_ERR(super); CHECK_ERR(ctx.addSubtype(*super)); diff --git a/test/ctor-eval/gc-2.wast.out b/test/ctor-eval/gc-2.wast.out index 22b68c33da3..cec7f943057 100644 --- a/test/ctor-eval/gc-2.wast.out +++ b/test/ctor-eval/gc-2.wast.out @@ -1,5 +1,5 @@ (module - (type $struct (struct (field i32))) + (type $struct (sub (struct (field i32)))) (type $1 (func (result i32))) (global $ctor-eval$global_4 (ref $struct) (struct.new $struct (i32.const 9999) diff --git a/test/ctor-eval/gc.wast.out b/test/ctor-eval/gc.wast.out index 783d27f73db..8999d475690 100644 --- a/test/ctor-eval/gc.wast.out +++ b/test/ctor-eval/gc.wast.out @@ -1,5 +1,5 @@ (module - (type $struct (struct (field i32))) + (type $struct (sub (struct (field i32)))) (type $1 (func (param anyref))) (type $2 (func (result i32))) (type $3 (func)) diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c index 36e6776f7da..c2c5d6e31a6 100644 --- a/test/example/c-api-kitchen-sink.c +++ b/test/example/c-api-kitchen-sink.c @@ -2160,6 +2160,7 @@ void test_typebuilder() { tempArrayType, BinaryenPackedTypeNotPacked(), true); + TypeBuilderSetOpen(builder, tempArrayIndex); // Create a recursive struct with a field of its own type const BinaryenIndex tempStructIndex = 1; @@ -2173,6 +2174,7 @@ void test_typebuilder() { bool fieldMutables[] = {true}; TypeBuilderSetStructType( builder, tempStructIndex, fieldTypes, fieldPackedTypes, fieldMutables, 1); + TypeBuilderSetOpen(builder, tempStructIndex); } // Create a recursive signature with parameter and result including its own @@ -2189,6 +2191,7 @@ void test_typebuilder() { tempSignatureIndex, TypeBuilderGetTempTupleType(builder, (BinaryenType*)¶mTypes, 2), tempSignatureType); + TypeBuilderSetOpen(builder, tempSignatureIndex); } // Create a subtype (with an additional immutable packed field) @@ -2209,11 +2212,10 @@ void test_typebuilder() { fieldPackedTypes, fieldMutables, 2); + TypeBuilderSetOpen(builder, tempSubStructIndex); } TypeBuilderSetSubType(builder, tempSubStructIndex, tempStructHeapType); - // TODO: Rtts (post-MVP?) - // Build the type hierarchy and dispose the builder BinaryenHeapType heapTypes[4]; BinaryenIndex errorIndex; diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt index cde0e02793b..d84e9c8881b 100644 --- a/test/example/c-api-kitchen-sink.txt +++ b/test/example/c-api-kitchen-sink.txt @@ -3166,9 +3166,9 @@ TypeBuilderErrorReasonForwardSupertypeReference: 2 TypeBuilderErrorReasonForwardChildReference: 3 module with recursive GC types: (module - (type $SomeArray (array (mut (ref null $SomeArray)))) - (type $SomeSignature (func (param (ref null $SomeSignature) (ref null $SomeArray)) (result (ref null $SomeSignature)))) - (type $SomeStruct (struct (field $SomeField (mut (ref null $SomeStruct))))) + (type $SomeArray (sub (array (mut (ref null $SomeArray))))) + (type $SomeSignature (sub (func (param (ref null $SomeSignature) (ref null $SomeArray)) (result (ref null $SomeSignature))))) + (type $SomeStruct (sub (struct (field $SomeField (mut (ref null $SomeStruct)))))) (type $3 (func)) (type $SomeSubStruct (sub $SomeStruct (struct (field $SomeField (mut (ref null $SomeStruct))) (field $SomePackedField i8)))) (func $test (type $3) diff --git a/test/gtest/possible-contents.cpp b/test/gtest/possible-contents.cpp index 1092a825bdb..1838ad3ab31 100644 --- a/test/gtest/possible-contents.cpp +++ b/test/gtest/possible-contents.cpp @@ -539,14 +539,11 @@ TEST_F(PossibleContentsTest, TestStructCones) { */ TypeBuilder builder(5); builder.createRecGroup(0, 5); - builder.setHeapType(0, Struct(FieldList{})); - builder.setHeapType(1, Struct(FieldList{})); - builder.setHeapType(2, Struct(FieldList{})); - builder.setHeapType(3, Struct(FieldList{})); - builder.setHeapType(4, Struct(FieldList{})); - builder.setSubType(1, builder.getTempHeapType(0)); - builder.setSubType(2, builder.getTempHeapType(0)); - builder.setSubType(3, builder.getTempHeapType(2)); + builder[0].setOpen() = Struct(FieldList{}); + builder[1].setOpen().subTypeOf(builder[0]) = Struct(FieldList{}); + builder[2].setOpen().subTypeOf(builder[0]) = Struct(FieldList{}); + builder[3].setOpen().subTypeOf(builder[2]) = Struct(FieldList{}); + builder[4].setOpen() = Struct(FieldList{}); auto result = builder.build(); ASSERT_TRUE(result); auto types = *result; diff --git a/test/gtest/type-builder.cpp b/test/gtest/type-builder.cpp index d64d94699ac..0184eb074dd 100644 --- a/test/gtest/type-builder.cpp +++ b/test/gtest/type-builder.cpp @@ -261,7 +261,7 @@ TEST_F(TypeTest, InvalidFinalSupertype) { TypeBuilder builder(2); builder[0] = Struct{}; builder[1] = Struct{}; - builder[0].setFinal(); + builder[0].setOpen(false); builder[1].subTypeOf(builder[0]); auto result = builder.build(); @@ -426,19 +426,16 @@ TEST_F(TypeTest, CanonicalizeSelfReferences) { TEST_F(TypeTest, CanonicalizeSupertypes) { TypeBuilder builder(6); - builder[0] = Struct{}; - builder[1] = Struct{}; + builder[0].setOpen() = Struct{}; + builder[1].setOpen() = Struct{}; // Type with a supertype - builder[2] = Struct{}; - builder[2].subTypeOf(builder[0]); + builder[2].setOpen().subTypeOf(builder[0]) = Struct{}; // Type with the same supertype after canonicalization. - builder[3] = Struct{}; - builder[3].subTypeOf(builder[1]); + builder[3].setOpen().subTypeOf(builder[1]) = Struct{}; // Type with a different supertype - builder[4] = Struct{}; - builder[4].subTypeOf(builder[2]); + builder[4].setOpen().subTypeOf(builder[2]) = Struct{}; // Type with no supertype - builder[5] = Struct{}; + builder[5].setOpen() = Struct{}; auto result = builder.build(); ASSERT_TRUE(result); @@ -455,16 +452,15 @@ TEST_F(TypeTest, CanonicalizeFinal) { // Types are different if their finality flag is different. TypeBuilder builder(2); builder[0] = Struct{}; - builder[1] = Struct{}; - builder[0].setFinal(); + builder[1].setOpen() = Struct{}; auto result = builder.build(); ASSERT_TRUE(result); auto built = *result; EXPECT_NE(built[0], built[1]); - EXPECT_TRUE(built[0].isFinal()); - EXPECT_FALSE(built[1].isFinal()); + EXPECT_TRUE(!built[0].isOpen()); + EXPECT_FALSE(!built[1].isOpen()); } TEST_F(TypeTest, HeapTypeConstructors) { @@ -500,21 +496,21 @@ TEST_F(TypeTest, CanonicalizeTypesBeforeSubtyping) { TypeBuilder builder(6); // A rec group builder.createRecGroup(0, 2); - builder[0] = Struct{}; - builder[1] = Struct{}; + builder[0].setOpen() = Struct{}; + builder[1].setOpen() = Struct{}; builder[1].subTypeOf(builder[0]); // The same rec group again builder.createRecGroup(2, 2); - builder[2] = Struct{}; - builder[3] = Struct{}; + builder[2].setOpen() = Struct{}; + builder[3].setOpen() = Struct{}; builder[3].subTypeOf(builder[2]); // This subtyping only validates if the previous two groups are deduplicated // before checking subtype validity. - builder[4] = + builder[4].setOpen() = Struct({Field(builder.getTempRefType(builder[0], Nullable), Immutable)}); - builder[5] = + builder[5].setOpen() = Struct({Field(builder.getTempRefType(builder[3], Nullable), Immutable)}); builder[5].subTypeOf(builder[4]); @@ -754,9 +750,8 @@ TEST_F(TypeTest, TestHeapTypeRelations) { { // Immutable array fields are covariant. TypeBuilder builder(2); - builder[0] = Array(Field(anyref, Immutable)); - builder[1] = Array(Field(eqref, Immutable)); - builder[1].subTypeOf(builder[0]); + builder[0].setOpen() = Array(Field(anyref, Immutable)); + builder[1].setOpen().subTypeOf(builder[0]) = Array(Field(eqref, Immutable)); auto results = builder.build(); ASSERT_TRUE(results); auto built = *results; @@ -766,9 +761,9 @@ TEST_F(TypeTest, TestHeapTypeRelations) { { // Depth subtyping TypeBuilder builder(2); - builder[0] = Struct({Field(anyref, Immutable)}); - builder[1] = Struct({Field(eqref, Immutable)}); - builder[1].subTypeOf(builder[0]); + builder[0].setOpen() = Struct({Field(anyref, Immutable)}); + builder[1].setOpen().subTypeOf(builder[0]) = + Struct({Field(eqref, Immutable)}); auto results = builder.build(); ASSERT_TRUE(results); auto built = *results; @@ -778,9 +773,9 @@ TEST_F(TypeTest, TestHeapTypeRelations) { { // Width subtyping TypeBuilder builder(2); - builder[0] = Struct({Field(anyref, Immutable)}); - builder[1] = Struct({Field(anyref, Immutable), Field(anyref, Immutable)}); - builder[1].subTypeOf(builder[0]); + builder[0].setOpen() = Struct({Field(anyref, Immutable)}); + builder[1].setOpen().subTypeOf(builder[0]) = + Struct({Field(anyref, Immutable), Field(anyref, Immutable)}); auto results = builder.build(); ASSERT_TRUE(results); auto built = *results; @@ -792,12 +787,12 @@ TEST_F(TypeTest, TestHeapTypeRelations) { TypeBuilder builder(4); auto ref0 = builder.getTempRefType(builder[0], Nullable); auto ref1 = builder.getTempRefType(builder[1], Nullable); - builder[0] = Struct({Field(anyref, Immutable)}); - builder[1] = Struct({Field(eqref, Immutable)}); - builder[2] = Struct({Field(ref0, Immutable)}); - builder[3] = Struct({Field(ref1, Immutable)}); - builder[1].subTypeOf(builder[0]); - builder[3].subTypeOf(builder[2]); + builder[0].setOpen() = Struct({Field(anyref, Immutable)}); + builder[1].setOpen().subTypeOf(builder[0]) = + Struct({Field(eqref, Immutable)}); + builder[2].setOpen() = Struct({Field(ref0, Immutable)}); + builder[3].setOpen().subTypeOf(builder[2]) = + Struct({Field(ref1, Immutable)}); auto results = builder.build(); ASSERT_TRUE(results); auto built = *results; @@ -809,9 +804,9 @@ TEST_F(TypeTest, TestHeapTypeRelations) { TypeBuilder builder(2); auto ref0 = builder.getTempRefType(builder[0], Nullable); auto ref1 = builder.getTempRefType(builder[1], Nullable); - builder[0] = Struct({Field(ref0, Immutable)}); - builder[1] = Struct({Field(ref1, Immutable)}); - builder[1].subTypeOf(builder[0]); + builder[0].setOpen() = Struct({Field(ref0, Immutable)}); + builder[1].setOpen().subTypeOf(builder[0]) = + Struct({Field(ref1, Immutable)}); auto results = builder.build(); ASSERT_TRUE(results); auto built = *results; @@ -868,8 +863,8 @@ TEST_F(TypeTest, TestSubTypes) { // Build type types, the second of which is a subtype. TypeBuilder builder(2); - builder[0] = Struct({Field(anyref, Immutable)}); - builder[1] = Struct({Field(eqref, Immutable)}); + builder[0].setOpen() = Struct({Field(anyref, Immutable)}); + builder[1].setOpen() = Struct({Field(eqref, Immutable)}); builder[1].subTypeOf(builder[0]); auto result = builder.build(); @@ -902,7 +897,7 @@ TEST_F(TypeTest, TestExistingSuperType) { Type A1; { TypeBuilder builder(1); - builder[0] = Struct(); + builder[0].setOpen() = Struct(); auto result = builder.build(); ASSERT_TRUE(result); auto built = *result; @@ -913,7 +908,7 @@ TEST_F(TypeTest, TestExistingSuperType) { Type A2; { TypeBuilder builder(1); - builder[0] = Struct(); + builder[0].setOpen() = Struct(); auto result = builder.build(); ASSERT_TRUE(result); auto built = *result; @@ -924,8 +919,7 @@ TEST_F(TypeTest, TestExistingSuperType) { Type B1; { TypeBuilder builder(1); - builder[0] = Struct(); - builder.setSubType(0, A1.getHeapType()); + builder[0].setOpen().subTypeOf(A1.getHeapType()) = Struct(); auto result = builder.build(); ASSERT_TRUE(result); auto built = *result; @@ -936,8 +930,7 @@ TEST_F(TypeTest, TestExistingSuperType) { Type B2; { TypeBuilder builder(1); - builder[0] = Struct(); - builder.setSubType(0, A2.getHeapType()); + builder[0].setOpen().subTypeOf(A2.getHeapType()) = Struct(); auto result = builder.build(); ASSERT_TRUE(result); auto built = *result; @@ -959,9 +952,8 @@ TEST_F(TypeTest, TestMaxStructDepths) { HeapType A, B; { TypeBuilder builder(2); - builder[0] = Struct(); - builder[1] = Struct(); - builder.setSubType(1, builder.getTempHeapType(0)); + builder[0].setOpen() = Struct(); + builder[1].setOpen().subTypeOf(builder[0]) = Struct(); auto result = builder.build(); ASSERT_TRUE(result); auto built = *result; @@ -1004,10 +996,9 @@ TEST_F(TypeTest, TestDepth) { HeapType A, B, C; { TypeBuilder builder(3); - builder[0] = Struct(); - builder[1] = Struct(); - builder[2] = Array(Field(Type::i32, Immutable)); - builder.setSubType(1, builder.getTempHeapType(0)); + builder[0].setOpen() = Struct(); + builder[1].setOpen().subTypeOf(builder[0]) = Struct(); + builder[2].setOpen() = Array(Field(Type::i32, Immutable)); auto result = builder.build(); ASSERT_TRUE(result); auto built = *result; @@ -1054,13 +1045,10 @@ TEST_F(TypeTest, TestIterSubTypes) { HeapType A, B, C, D; { TypeBuilder builder(4); - builder[0] = Struct(); - builder[1] = Struct(); - builder[2] = Struct(); - builder[3] = Struct(); - builder.setSubType(1, builder.getTempHeapType(0)); - builder.setSubType(2, builder.getTempHeapType(0)); - builder.setSubType(3, builder.getTempHeapType(2)); + builder[0].setOpen() = Struct(); + builder[1].setOpen().subTypeOf(builder[0]) = Struct(); + builder[2].setOpen().subTypeOf(builder[0]) = Struct(); + builder[3].setOpen().subTypeOf(builder[2]) = Struct(); auto result = builder.build(); ASSERT_TRUE(result); auto built = *result; diff --git a/test/lit/fuzz-types.test b/test/lit/fuzz-types.test index 494aa996f46..ae5c0001900 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 10dc7726bcc..43caeb7d1f2 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 5379cec44d4..43bda9a21b6 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 0f73477b951..6462b028847 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 14ce524ff73..4900d0ad991 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 51341dfd092..5ce3ffa919f 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 f43c12950aa..2b753303e7e 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 64b7ff214d7..27490960504 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 d49c8b75599..4236a16c69a 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 fdd2b0e607f..6e3381e8e29 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 cf3e75ebeca..7a7a3095403 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 bab22b2cb11..a071cfc9342 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 ea2d95433a5..a5b1f2f2ada 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 559050f1f1b..00a2f6c604b 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 8f40674468b..1cbf47032b5 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 0ffa0e2d80e..4be26c34888 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 43a81a5e26a..34e29b71dfb 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 0253e079195..ae0b11ee278 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 5ef52037f08..21103089dbb 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 b300843cb8a..0e081637b15 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 44d16c99b94..790663af4f1 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 e41a3f49cee..fb934836515 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 2589290c63b..3ed49062868 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 ec5eaa3c6b8..6fa0e2a1fcc 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 0e153d57cda..948fe467ff4 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 c5f3f408ac5..c86f4d645fa 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 aa02abf2ebd..5c4364a143d 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 fc3388d897e..858cb4bf5c6 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 02720995ed3..d5f83f0249e 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 4c9e38df64e..2854df3bba0 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 02a9c6f299d..cc5e8aec9e8 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 28177f306e1..9d55ef8015f 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 86306a27a29..e62b64125e3 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 625b315846b..1bdd6f68018 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 ecb96c249fb..8a7ef42daa4 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 e50fe7b4402..c3b3e93c128 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 f1dfb6f78c1..1dbc615748c 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 4f054295ec1..98ed94d4abf 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 dbd64ab7810..c09c837d270 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 223657ae9bc..1de41e8e835 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 7e8f77c02cb..d36db96ae07 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 c5ad4e76062..9df11164f70 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 53582a586b9..4a68a9213bd 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 628282f46c8..ecc9b1f900d 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 8dab9bc7e8a..6d0c2257ab5 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 f9fb5eb2623..5aaf63edfda 100644 --- a/test/lit/passes/type-ssa.wast +++ b/test/lit/passes/type-ssa.wast @@ -7,21 +7,21 @@ ;; 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)) ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct$1 (sub $struct (struct (field i32)))) + ;; CHECK-NEXT: (type $struct$1 (sub final $struct (struct (field i32)))) - ;; CHECK: (type $struct$2 (sub $struct (struct (field i32)))) + ;; CHECK: (type $struct$2 (sub final $struct (struct (field i32)))) - ;; CHECK: (type $struct$3 (sub $struct (struct (field i32)))) + ;; CHECK: (type $struct$3 (sub final $struct (struct (field i32)))) - ;; CHECK: (type $struct$4 (sub $struct (struct (field i32)))) + ;; CHECK: (type $struct$4 (sub final $struct (struct (field i32)))) - ;; CHECK: (type $struct$5 (sub $struct (struct (field i32)))) + ;; CHECK: (type $struct$5 (sub final $struct (struct (field i32)))) ;; CHECK: (global $g (ref $struct) (struct.new $struct$4 ;; CHECK-NEXT: (i32.const 42) @@ -77,7 +77,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,15 +138,15 @@ ;; 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 - ;; CHECK-NEXT: (type $struct$1 (sub $struct (struct (field anyref)))) + ;; CHECK-NEXT: (type $struct$1 (sub final $struct (struct (field anyref)))) - ;; CHECK: (type $struct$2 (sub $struct (struct (field anyref)))) + ;; CHECK: (type $struct$2 (sub final $struct (struct (field anyref)))) - ;; CHECK: (type $struct$3 (sub $struct (struct (field anyref)))) + ;; CHECK: (type $struct$3 (sub final $struct (struct (field anyref)))) ;; CHECK: (func $foo (type $0) (param $any anyref) (param $array arrayref) ;; CHECK-NEXT: (drop @@ -208,28 +208,28 @@ ) (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) ;; CHECK: (rec - ;; CHECK-NEXT: (type $array$1 (sub $array (array (mut anyref)))) + ;; CHECK-NEXT: (type $array$1 (sub final $array (array (mut anyref)))) - ;; CHECK: (type $array$2 (sub $array (array (mut anyref)))) + ;; CHECK: (type $array$2 (sub final $array (array (mut anyref)))) - ;; CHECK: (type $array$3 (sub $array (array (mut anyref)))) + ;; CHECK: (type $array$3 (sub final $array (array (mut anyref)))) - ;; CHECK: (type $array-func$4 (sub $array-func (array (mut funcref)))) + ;; CHECK: (type $array-func$4 (sub final $array-func (array (mut funcref)))) - ;; CHECK: (type $array$5 (sub $array (array (mut anyref)))) + ;; CHECK: (type $array$5 (sub final $array (array (mut anyref)))) - ;; CHECK: (type $array$6 (sub $array (array (mut anyref)))) + ;; CHECK: (type $array$6 (sub final $array (array (mut anyref)))) ;; CHECK: (type $9 (func)) @@ -372,17 +372,15 @@ ;; CHECK: (type $empty (struct )) (type $empty (struct)) - ;; CHECK: (type $empty$1 (sub $empty (struct ))) - - ;; CHECK: (type $2 (func (param anyref))) + ;; CHECK: (type $1 (func (param anyref))) ;; CHECK: (type $struct (struct (field externref) (field anyref) (field externref))) (type $struct (struct externref anyref externref)) - ;; CHECK: (global $g (mut anyref) (struct.new_default $empty$1)) + ;; CHECK: (global $g (mut anyref) (struct.new_default $empty)) (global $g (mut anyref) (struct.new $empty)) - ;; CHECK: (func $0 (type $2) (param $param anyref) + ;; CHECK: (func $0 (type $1) (param $param anyref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (struct.new $struct ;; CHECK-NEXT: (extern.externalize @@ -422,18 +420,15 @@ ) (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)) ;; CHECK: (type $2 (func (param (ref $subarray)))) - ;; CHECK: (rec - ;; CHECK-NEXT: (type $array$1 (sub $array (array (mut f32)))) - - ;; CHECK: (type $4 (struct (field (mut i32)) (field (mut i32)) (field (mut f64)) (field (mut f64)) (field (mut i32)) (field (mut f64)) (field (mut f64)) (field (mut i32)) (field (mut i32)) (field (mut i32)) (field (mut i32)))) + ;; CHECK: (type $array$1 (sub final $array (array (mut f32)))) ;; CHECK: (func $1 (type $2) (param $ref (ref $subarray)) ;; CHECK-NEXT: (drop @@ -458,15 +453,13 @@ ;; CHECK: (type $A (struct )) (type $A (struct )) - ;; CHECK: (type $A$1 (sub $A (struct ))) - - ;; CHECK: (type $2 (func (result (ref $A)))) + ;; CHECK: (type $1 (func (result (ref $A)))) - ;; CHECK: (func $0 (type $2) (result (ref $A)) - ;; CHECK-NEXT: (block $label (result (ref $A$1)) + ;; CHECK: (func $0 (type $1) (result (ref $A)) + ;; CHECK-NEXT: (block $label (result (ref $A)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (br_on_cast $label (ref $A$1) (ref $A$1) - ;; CHECK-NEXT: (struct.new_default $A$1) + ;; CHECK-NEXT: (br_on_cast $label (ref $A) (ref $A) + ;; CHECK-NEXT: (struct.new_default $A) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (unreachable) diff --git a/test/lit/passes/type-ssa_and_merging.wast b/test/lit/passes/type-ssa_and_merging.wast index 63c0b86f2b5..2cc72c618b4 100644 --- a/test/lit/passes/type-ssa_and_merging.wast +++ b/test/lit/passes/type-ssa_and_merging.wast @@ -10,21 +10,21 @@ ;; 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))) ;; NOP: (import "a" "b" (func $import (type $2) (result i32))) - ;; YES: (type $A$2 (sub $A (struct ))) + ;; YES: (type $A$2 (sub final $A (struct ))) - ;; YES: (type $A$1 (sub $A (struct ))) + ;; YES: (type $A$1 (sub final $A (struct ))) ;; YES: (import "a" "b" (func $import (type $0) (result i32))) (import "a" "b" (func $import (result i32))) @@ -46,7 +46,7 @@ ;; YES: (func $main1 (type $0) (result i32) ;; YES-NEXT: (call $get-a-1 - ;; YES-NEXT: (struct.new_default $A) + ;; YES-NEXT: (struct.new_default $A$2) ;; YES-NEXT: ) ;; YES-NEXT: (i32.const 42) ;; YES-NEXT: ) @@ -66,7 +66,7 @@ ;; NOP-NEXT: ) ;; YES: (func $main2 (type $0) (result i32) ;; YES-NEXT: (call $get-a-2 - ;; YES-NEXT: (struct.new_default $A) + ;; YES-NEXT: (struct.new_default $A$2) ;; YES-NEXT: ) ;; YES-NEXT: (i32.const 1337) ;; YES-NEXT: ) diff --git a/test/lit/recursive-types.wast b/test/lit/recursive-types.wast index fc3d83dc3db..46b6d3c10e5 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 fa9e7b7128c..fb86c484d11 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 0dabd0f2f2f..882aadae6db 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 17ccb0ba2b4..20f605b5f03 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 a2f96eeba55..873d79034da 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 ddf35edcff6..eb8d4f100e6 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)) diff --git a/test/passes/Oz_fuzz-exec_all-features.txt b/test/passes/Oz_fuzz-exec_all-features.txt index 2f6fd3d8735..439515e0d71 100644 --- a/test/passes/Oz_fuzz-exec_all-features.txt +++ b/test/passes/Oz_fuzz-exec_all-features.txt @@ -58,7 +58,7 @@ (module (type $bytes (array (mut i8))) (type $void_func (func)) - (type $struct (struct (field (mut i32)))) + (type $struct (sub (struct (field (mut i32))))) (type $3 (func (param i32))) (type $extendedstruct (sub $struct (struct (field (mut i32)) (field f64)))) (type $int_func (func (result i32))) diff --git a/test/passes/Oz_fuzz-exec_all-features.wast b/test/passes/Oz_fuzz-exec_all-features.wast index 5c48c4d3fe0..a693f009852 100644 --- a/test/passes/Oz_fuzz-exec_all-features.wast +++ b/test/passes/Oz_fuzz-exec_all-features.wast @@ -1,5 +1,5 @@ (module - (type $struct (struct (mut i32))) + (type $struct (sub (struct (mut i32)))) (type $extendedstruct (struct_subtype (mut i32) f64 $struct)) (type $bytes (array (mut i8))) diff --git a/test/spec/ref_cast.wast b/test/spec/ref_cast.wast index d68baf45e9b..1a09a68f3c9 100644 --- a/test/spec/ref_cast.wast +++ b/test/spec/ref_cast.wast @@ -1,5 +1,5 @@ (module - (type $t0 (struct)) + (type $t0 (sub (struct))) (type $t1 (struct_subtype (field i32) $t0)) (type $t1' (struct_subtype (field i32) $t1)) (type $t2 (struct_subtype (field i32) (field i32) $t1)) diff --git a/test/subtypes.wast b/test/subtypes.wast index 0562d6cb242..0076f7eb302 100644 --- a/test/subtypes.wast +++ b/test/subtypes.wast @@ -3,13 +3,13 @@ ;; Arrays (type $vector-i32 (array i32)) - (type $vector-any (array (ref any))) + (type $vector-any (sub (array (ref any)))) (type $vector-i31 (array_subtype (ref i31) $vector-any)) ;; Structs - (type $struct-any (struct + (type $struct-any (sub (struct (field (ref any)) - )) + ))) (type $struct-i31 (struct_subtype (field (ref i31)) $struct-any @@ -21,9 +21,9 @@ )) ;; Recursive structs - (type $struct-rec-one (struct + (type $struct-rec-one (sub (struct (field (ref $struct-rec-one)) - )) + ))) (type $struct-rec-two (struct_subtype (field (ref $struct-rec-two)) (field (ref $struct-rec-two)) diff --git a/test/subtypes.wast.from-wast b/test/subtypes.wast.from-wast index 0b6ede8a704..1304c0c3146 100644 --- a/test/subtypes.wast.from-wast +++ b/test/subtypes.wast.from-wast @@ -1,11 +1,11 @@ (module - (type $struct-rec-one (struct (field (ref $struct-rec-one)))) + (type $struct-rec-one (sub (struct (field (ref $struct-rec-one))))) (type $struct-rec-two (sub $struct-rec-one (struct (field (ref $struct-rec-two)) (field (ref $struct-rec-two))))) (type $vector-i32 (array i32)) - (type $struct-any (struct (field (ref any)))) + (type $struct-any (sub (struct (field (ref any))))) (type $struct-i31 (sub $struct-any (struct (field (ref i31))))) (type $5 (func (param (ref $vector-i32) (ref null $vector-i32)))) - (type $vector-any (array (ref any))) + (type $vector-any (sub (array (ref any)))) (type $vector-i31 (sub $vector-any (array (ref i31)))) (type $8 (func (param (ref $vector-i31) (ref $vector-any)))) (type $9 (func (param (ref $struct-i31) (ref $struct-any)))) diff --git a/test/subtypes.wast.fromBinary b/test/subtypes.wast.fromBinary index 70fe93e954b..6a3ef7345f8 100644 --- a/test/subtypes.wast.fromBinary +++ b/test/subtypes.wast.fromBinary @@ -1,11 +1,11 @@ (module - (type $struct-rec-one (struct (field (ref $struct-rec-one)))) + (type $struct-rec-one (sub (struct (field (ref $struct-rec-one))))) (type $struct-rec-two (sub $struct-rec-one (struct (field (ref $struct-rec-two)) (field (ref $struct-rec-two))))) (type $vector-i32 (array i32)) - (type $struct-any (struct (field (ref any)))) + (type $struct-any (sub (struct (field (ref any))))) (type $struct-i31 (sub $struct-any (struct (field (ref i31))))) (type $5 (func (param (ref $vector-i32) (ref null $vector-i32)))) - (type $vector-any (array (ref any))) + (type $vector-any (sub (array (ref any)))) (type $vector-i31 (sub $vector-any (array (ref i31)))) (type $8 (func (param (ref $vector-i31) (ref $vector-any)))) (type $9 (func (param (ref $struct-i31) (ref $struct-any)))) diff --git a/test/subtypes.wast.fromBinary.noDebugInfo b/test/subtypes.wast.fromBinary.noDebugInfo index 6776298dd62..29e5755552f 100644 --- a/test/subtypes.wast.fromBinary.noDebugInfo +++ b/test/subtypes.wast.fromBinary.noDebugInfo @@ -1,11 +1,11 @@ (module - (type $0 (struct (field (ref $0)))) + (type $0 (sub (struct (field (ref $0))))) (type $1 (sub $0 (struct (field (ref $1)) (field (ref $1))))) (type $2 (array i32)) - (type $3 (struct (field (ref any)))) + (type $3 (sub (struct (field (ref any))))) (type $4 (sub $3 (struct (field (ref i31))))) (type $5 (func (param (ref $2) (ref null $2)))) - (type $6 (array (ref any))) + (type $6 (sub (array (ref any)))) (type $7 (sub $6 (array (ref i31)))) (type $8 (func (param (ref $7) (ref $6)))) (type $9 (func (param (ref $4) (ref $3)))) From 06ced96d51a2a7d95563461b42bcf22f08fd90ab Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Fri, 8 Sep 2023 08:26:35 -0700 Subject: [PATCH 2/3] update type ssa tests --- test/lit/passes/type-ssa.wast | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/test/lit/passes/type-ssa.wast b/test/lit/passes/type-ssa.wast index 5aaf63edfda..ba5a6246500 100644 --- a/test/lit/passes/type-ssa.wast +++ b/test/lit/passes/type-ssa.wast @@ -2,9 +2,6 @@ ;; 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 (sub (struct (field i32)))) @@ -369,18 +366,20 @@ ;; 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 final $empty (struct ))) - ;; CHECK: (type $1 (func (param anyref))) + ;; 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)) + ;; CHECK: (global $g (mut anyref) (struct.new_default $empty$1)) (global $g (mut anyref) (struct.new $empty)) - ;; CHECK: (func $0 (type $1) (param $param anyref) + ;; CHECK: (func $0 (type $2) (param $param anyref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (struct.new $struct ;; CHECK-NEXT: (extern.externalize @@ -450,16 +449,18 @@ ) (module - ;; CHECK: (type $A (struct )) - (type $A (struct )) + ;; CHECK: (type $A (sub (struct ))) + (type $A (sub (struct))) + + ;; CHECK: (type $A$1 (sub final $A (struct ))) - ;; CHECK: (type $1 (func (result (ref $A)))) + ;; CHECK: (type $2 (func (result (ref $A)))) - ;; CHECK: (func $0 (type $1) (result (ref $A)) - ;; CHECK-NEXT: (block $label (result (ref $A)) + ;; CHECK: (func $0 (type $2) (result (ref $A)) + ;; CHECK-NEXT: (block $label (result (ref $A$1)) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (br_on_cast $label (ref $A) (ref $A) - ;; CHECK-NEXT: (struct.new_default $A) + ;; CHECK-NEXT: (br_on_cast $label (ref $A$1) (ref $A$1) + ;; CHECK-NEXT: (struct.new_default $A$1) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (unreachable) From 6c0b376262dd590a29cc06b7285f2753d82ad043 Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Fri, 8 Sep 2023 12:26:24 -0700 Subject: [PATCH 3/3] make typeSSA types open --- src/passes/TypeSSA.cpp | 1 + test/lit/passes/type-ssa.wast | 37 ++++++++++++----------- test/lit/passes/type-ssa_and_merging.wast | 8 ++--- 3 files changed, 25 insertions(+), 21 deletions(-) diff --git a/src/passes/TypeSSA.cpp b/src/passes/TypeSSA.cpp index 1105c5b12bf..cb8f0f04987 100644 --- a/src/passes/TypeSSA.cpp +++ b/src/passes/TypeSSA.cpp @@ -255,6 +255,7 @@ struct TypeSSA : public Pass { builder[i] = oldType.getArray(); } builder[i].subTypeOf(oldType); + builder[i].setOpen(); } builder.createRecGroup(0, num); auto result = builder.build(); diff --git a/test/lit/passes/type-ssa.wast b/test/lit/passes/type-ssa.wast index ba5a6246500..ae5b2c53226 100644 --- a/test/lit/passes/type-ssa.wast +++ b/test/lit/passes/type-ssa.wast @@ -10,15 +10,15 @@ ;; CHECK: (type $1 (func)) ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct$1 (sub final $struct (struct (field i32)))) + ;; CHECK-NEXT: (type $struct$1 (sub $struct (struct (field i32)))) - ;; CHECK: (type $struct$2 (sub final $struct (struct (field i32)))) + ;; CHECK: (type $struct$2 (sub $struct (struct (field i32)))) - ;; CHECK: (type $struct$3 (sub final $struct (struct (field i32)))) + ;; CHECK: (type $struct$3 (sub $struct (struct (field i32)))) - ;; CHECK: (type $struct$4 (sub final $struct (struct (field i32)))) + ;; CHECK: (type $struct$4 (sub $struct (struct (field i32)))) - ;; CHECK: (type $struct$5 (sub final $struct (struct (field i32)))) + ;; CHECK: (type $struct$5 (sub $struct (struct (field i32)))) ;; CHECK: (global $g (ref $struct) (struct.new $struct$4 ;; CHECK-NEXT: (i32.const 42) @@ -139,11 +139,11 @@ (type $struct (struct_subtype (field (ref null any)) data)) ;; CHECK: (rec - ;; CHECK-NEXT: (type $struct$1 (sub final $struct (struct (field anyref)))) + ;; CHECK-NEXT: (type $struct$1 (sub $struct (struct (field anyref)))) - ;; CHECK: (type $struct$2 (sub final $struct (struct (field anyref)))) + ;; CHECK: (type $struct$2 (sub $struct (struct (field anyref)))) - ;; CHECK: (type $struct$3 (sub final $struct (struct (field anyref)))) + ;; CHECK: (type $struct$3 (sub $struct (struct (field anyref)))) ;; CHECK: (func $foo (type $0) (param $any anyref) (param $array arrayref) ;; CHECK-NEXT: (drop @@ -216,17 +216,17 @@ (elem func $array.new) ;; CHECK: (rec - ;; CHECK-NEXT: (type $array$1 (sub final $array (array (mut anyref)))) + ;; CHECK-NEXT: (type $array$1 (sub $array (array (mut anyref)))) - ;; CHECK: (type $array$2 (sub final $array (array (mut anyref)))) + ;; CHECK: (type $array$2 (sub $array (array (mut anyref)))) - ;; CHECK: (type $array$3 (sub final $array (array (mut anyref)))) + ;; CHECK: (type $array$3 (sub $array (array (mut anyref)))) - ;; CHECK: (type $array-func$4 (sub final $array-func (array (mut funcref)))) + ;; CHECK: (type $array-func$4 (sub $array-func (array (mut funcref)))) - ;; CHECK: (type $array$5 (sub final $array (array (mut anyref)))) + ;; CHECK: (type $array$5 (sub $array (array (mut anyref)))) - ;; CHECK: (type $array$6 (sub final $array (array (mut anyref)))) + ;; CHECK: (type $array$6 (sub $array (array (mut anyref)))) ;; CHECK: (type $9 (func)) @@ -369,7 +369,7 @@ ;; CHECK: (type $empty (sub (struct ))) (type $empty (sub (struct))) - ;; CHECK: (type $empty$1 (sub final $empty (struct ))) + ;; CHECK: (type $empty$1 (sub $empty (struct ))) ;; CHECK: (type $2 (func (param anyref))) @@ -427,7 +427,10 @@ ;; CHECK: (type $2 (func (param (ref $subarray)))) - ;; CHECK: (type $array$1 (sub final $array (array (mut f32)))) + ;; CHECK: (rec + ;; CHECK-NEXT: (type $array$1 (sub $array (array (mut f32)))) + + ;; CHECK: (type $4 (struct (field (mut i32)) (field (mut i32)) (field (mut f64)) (field (mut f64)) (field (mut i32)) (field (mut f64)) (field (mut f64)) (field (mut i32)) (field (mut i32)) (field (mut i32)) (field (mut i32)))) ;; CHECK: (func $1 (type $2) (param $ref (ref $subarray)) ;; CHECK-NEXT: (drop @@ -452,7 +455,7 @@ ;; CHECK: (type $A (sub (struct ))) (type $A (sub (struct))) - ;; CHECK: (type $A$1 (sub final $A (struct ))) + ;; CHECK: (type $A$1 (sub $A (struct ))) ;; CHECK: (type $2 (func (result (ref $A)))) diff --git a/test/lit/passes/type-ssa_and_merging.wast b/test/lit/passes/type-ssa_and_merging.wast index 2cc72c618b4..46129e37f9b 100644 --- a/test/lit/passes/type-ssa_and_merging.wast +++ b/test/lit/passes/type-ssa_and_merging.wast @@ -22,9 +22,9 @@ ;; NOP: (type $2 (func (result i32))) ;; NOP: (import "a" "b" (func $import (type $2) (result i32))) - ;; YES: (type $A$2 (sub final $A (struct ))) + ;; YES: (type $A$2 (sub $A (struct ))) - ;; YES: (type $A$1 (sub final $A (struct ))) + ;; YES: (type $A$1 (sub $A (struct ))) ;; YES: (import "a" "b" (func $import (type $0) (result i32))) (import "a" "b" (func $import (result i32))) @@ -46,7 +46,7 @@ ;; YES: (func $main1 (type $0) (result i32) ;; YES-NEXT: (call $get-a-1 - ;; YES-NEXT: (struct.new_default $A$2) + ;; YES-NEXT: (struct.new_default $A) ;; YES-NEXT: ) ;; YES-NEXT: (i32.const 42) ;; YES-NEXT: ) @@ -66,7 +66,7 @@ ;; NOP-NEXT: ) ;; YES: (func $main2 (type $0) (result i32) ;; YES-NEXT: (call $get-a-2 - ;; YES-NEXT: (struct.new_default $A$2) + ;; YES-NEXT: (struct.new_default $A) ;; YES-NEXT: ) ;; YES-NEXT: (i32.const 1337) ;; YES-NEXT: )