From e46b80278760574ea126c2359d17fa8d344d0ccd Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Mon, 12 Jan 2026 18:54:25 -0800 Subject: [PATCH 1/6] Do not recollect types in ReorderTypes ReorderTypes previously collected the module types and their counts, even though it already extends GlobalTypeRewriter, which also collects the module types in its constructor. Not only did this duplicate work, it was also a subtle source of bugs because ReorderTypes and GlobalTypeRewriter collected types slightly differently. ReorderTypes collected the binary types and GlobalTypeRewriter collected the used IR types. This could result in different types being collected for the same multivalue control flow signatures, causing an assertion failure when a type was seemingly missing from the collected info. Fix the problem and make the pass more efficient by simply not collecting the types two separate times. --- src/passes/ReorderTypes.cpp | 12 +++--------- test/lit/passes/reorder-types.wast | 25 +++++++++++++++++++++++++ 2 files changed, 28 insertions(+), 9 deletions(-) diff --git a/src/passes/ReorderTypes.cpp b/src/passes/ReorderTypes.cpp index d2ac65127a8..4a8e7593c5f 100644 --- a/src/passes/ReorderTypes.cpp +++ b/src/passes/ReorderTypes.cpp @@ -33,8 +33,6 @@ namespace { struct ReorderingTypeRewriter : GlobalTypeRewriter { using InfoMap = InsertOrderedMap; - InfoMap& typeInfo; - // Use a simpler cost calculation so the effects can be seen with smaller test // cases. bool forTesting; @@ -45,8 +43,8 @@ struct ReorderingTypeRewriter : GlobalTypeRewriter { static constexpr float maxFactor = 1.0; static constexpr Index numFactors = 21; - ReorderingTypeRewriter(Module& wasm, InfoMap& typeInfo, bool forTesting) - : GlobalTypeRewriter(wasm), typeInfo(typeInfo), forTesting(forTesting) {} + ReorderingTypeRewriter(Module& wasm, bool forTesting) + : GlobalTypeRewriter(wasm), forTesting(forTesting) {} std::vector getSortedTypes(PredecessorGraph preds) override { auto numTypes = preds.size(); @@ -150,11 +148,7 @@ struct ReorderTypes : Pass { Fatal() << "ReorderTypes requires --closed-world"; } - // Collect the use counts for each type. - auto typeInfo = ModuleUtils::collectHeapTypeInfo( - *module, ModuleUtils::TypeInclusion::BinaryTypes); - - ReorderingTypeRewriter(*module, typeInfo, forTesting).update(); + ReorderingTypeRewriter(*module, forTesting).update(); } }; diff --git a/test/lit/passes/reorder-types.wast b/test/lit/passes/reorder-types.wast index f4c5be93281..c5b8a13ef9e 100644 --- a/test/lit/passes/reorder-types.wast +++ b/test/lit/passes/reorder-types.wast @@ -391,3 +391,28 @@ (local (ref $Y)) ) ) + +(module + ;; Regression test. ReorderTypes used to collect the types used in the binary + ;; for their counts, which in this case includes $multi because it is part of + ;; the rec group. However, GlobalTypeRewriter separately collected only the + ;; used IR types, which includes a standalone function type instead of $multi. + ;; The sort then tried to lookup the count for the standalone function type + ;; and crashed when it couldn't find it. + (rec + (type $multi (func (result (ref $A) (ref $B)))) + ;; CHECK: (rec + ;; CHECK-NEXT: (type $A (sub (struct))) + (type $A (sub (struct))) + ;; CHECK: (type $B (sub $A (struct))) + (type $B (sub $A (struct))) + ) + ;; CHECK: (func $test (type $3) (param $0 i32) (result (ref $A) (ref $B)) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $test (param i32) (result (ref $A) (ref $B)) + (block (type $multi) (result (ref $A) (ref $B)) + (unreachable) + ) + ) +) From c9470db86e2a4aade5b26fa659f56b861b9f0ef7 Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Mon, 12 Jan 2026 18:59:43 -0800 Subject: [PATCH 2/6] [NFC] Minor improvements around type collection Update a comment to better match the code and tweak a loop to avoid repeated work. --- src/ir/module-utils.cpp | 4 +++- src/ir/type-updating.cpp | 3 +-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/ir/module-utils.cpp b/src/ir/module-utils.cpp index 5abbbecc01d..f51abc56a41 100644 --- a/src/ir/module-utils.cpp +++ b/src/ir/module-utils.cpp @@ -565,15 +565,17 @@ InsertOrderedMap collectHeapTypeInfo( // We've found all the types there are to find without considering more // control flow types. Consider one more control flow type and repeat. - for (; controlFlowIt != info.controlFlowSignatures.end(); ++controlFlowIt) { + while (controlFlowIt != info.controlFlowSignatures.end()) { auto& [sig, count] = *controlFlowIt; if (auto it = seenSigs.find(sig); it != seenSigs.end()) { info.info[it->second].useCount += count; + ++controlFlowIt; } else { // We've never seen this signature before, so add a type for it. HeapType type(sig); noteNewType(type); info.info[type].useCount += count; + ++controlFlowIt; break; } } diff --git a/src/ir/type-updating.cpp b/src/ir/type-updating.cpp index d402cd221cc..01aeb2dd1cb 100644 --- a/src/ir/type-updating.cpp +++ b/src/ir/type-updating.cpp @@ -55,8 +55,7 @@ void GlobalTypeRewriter::update() { GlobalTypeRewriter::PredecessorGraph GlobalTypeRewriter::getPrivatePredecessors() { - // Check if a type is private, looking for its info (if there is none, it is - // not private). + // Check if a type is private based on its collected info. auto isPublic = [&](HeapType type) { auto it = typeInfo.find(type); assert(it != typeInfo.end()); From 970fa6508c0d0d9ba06e1425382d8b3eb4175e2d Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Mon, 12 Jan 2026 19:01:50 -0800 Subject: [PATCH 3/6] Fuzz --reorder-types --- scripts/fuzz_opt.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/scripts/fuzz_opt.py b/scripts/fuzz_opt.py index b6eda7ce929..735c7d65469 100755 --- a/scripts/fuzz_opt.py +++ b/scripts/fuzz_opt.py @@ -2462,6 +2462,7 @@ def write_commands(commands, filename): ("--remove-unused-types",), ("--reorder-functions",), ("--reorder-locals",), + ("--reorder-types",), ("--flatten", "--rereloop",), ("--roundtrip",), ("--rse",), @@ -2496,6 +2497,7 @@ def write_commands(commands, filename): ("--abstract-type-refining",), ("--cfp",), ("--cfp-reftest",), + ("--reorder-types",), ("--type-finalizing",), ("--type-unfinalizing",), ("--type-ssa",), From 04937d42b08d0cc09b1220d3c9cd8942ef101bf8 Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Tue, 13 Jan 2026 17:36:40 -0800 Subject: [PATCH 4/6] remove unnecessary using --- src/passes/ReorderTypes.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/passes/ReorderTypes.cpp b/src/passes/ReorderTypes.cpp index 4a8e7593c5f..e120822da51 100644 --- a/src/passes/ReorderTypes.cpp +++ b/src/passes/ReorderTypes.cpp @@ -31,8 +31,6 @@ namespace wasm { namespace { struct ReorderingTypeRewriter : GlobalTypeRewriter { - using InfoMap = InsertOrderedMap; - // Use a simpler cost calculation so the effects can be seen with smaller test // cases. bool forTesting; From ac8bab21faea545d49eb8cf96a40801a0509ee54 Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Tue, 13 Jan 2026 17:44:20 -0800 Subject: [PATCH 5/6] improve --- src/ir/module-utils.cpp | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/ir/module-utils.cpp b/src/ir/module-utils.cpp index f51abc56a41..2e434e84d2b 100644 --- a/src/ir/module-utils.cpp +++ b/src/ir/module-utils.cpp @@ -566,16 +566,14 @@ InsertOrderedMap collectHeapTypeInfo( // We've found all the types there are to find without considering more // control flow types. Consider one more control flow type and repeat. while (controlFlowIt != info.controlFlowSignatures.end()) { - auto& [sig, count] = *controlFlowIt; + auto& [sig, count] = *controlFlowIt++; if (auto it = seenSigs.find(sig); it != seenSigs.end()) { info.info[it->second].useCount += count; - ++controlFlowIt; } else { // We've never seen this signature before, so add a type for it. HeapType type(sig); noteNewType(type); info.info[type].useCount += count; - ++controlFlowIt; break; } } From c69066fef0439228e1fa01d8b309844a0260518e Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Tue, 13 Jan 2026 17:49:32 -0800 Subject: [PATCH 6/6] update tests --- test/lit/basic/exception-handling.wast | 132 +++++------ test/lit/basic/extra-branch-values.wast | 188 ++++++++-------- test/lit/basic/stack_switching_resume.wast | 24 +- .../basic/stack_switching_resume_throw.wast | 48 ++-- test/lit/basic/types-function-references.wast | 78 +++---- test/lit/br_if_cont_uncastable.wast | 12 +- test/lit/cast-and-recast-tuple.wast | 20 +- test/lit/passes/O3_stack-switching.wast | 8 +- test/lit/passes/coalesce-locals-gc.wast | 24 +- test/lit/passes/dae-typessa-repeat-types.wast | 14 +- test/lit/passes/gufa-cast-all.wast | 16 +- test/lit/passes/gufa-refs.wast | 12 +- test/lit/passes/merge-blocks-eh.wast | 8 +- test/lit/passes/precompute-gc.wast | 18 +- test/lit/passes/remove-unused-brs.wast | 4 +- test/lit/passes/stack-ir-eh.wast | 4 +- test/lit/wat-kitchen-sink.wast | 206 +++++++++--------- 17 files changed, 408 insertions(+), 408 deletions(-) diff --git a/test/lit/basic/exception-handling.wast b/test/lit/basic/exception-handling.wast index 6b1518b65b4..0a0dd3e8904 100644 --- a/test/lit/basic/exception-handling.wast +++ b/test/lit/basic/exception-handling.wast @@ -12,55 +12,55 @@ (module ;; CHECK-TEXT: (type $0 (func)) - ;; CHECK-TEXT: (type $1 (func (result i32 i64))) + ;; CHECK-TEXT: (type $1 (func (result exnref))) - ;; CHECK-TEXT: (type $2 (func (result i32 i64 exnref))) + ;; CHECK-TEXT: (type $2 (func (result i32))) - ;; CHECK-TEXT: (type $3 (func (result exnref))) + ;; CHECK-TEXT: (type $3 (func (result i32 i64))) - ;; CHECK-TEXT: (type $4 (func (result i32))) + ;; CHECK-TEXT: (type $4 (func (result i32 i64 exnref))) - ;; CHECK-TEXT: (type $5 (func (result i32 exnref))) + ;; CHECK-TEXT: (type $5 (func (param i32))) - ;; CHECK-TEXT: (type $6 (func (param i32))) + ;; CHECK-TEXT: (type $6 (func (param i64))) - ;; CHECK-TEXT: (type $7 (func (param i64))) + ;; CHECK-TEXT: (type $7 (func (param i32 i64))) - ;; CHECK-TEXT: (type $8 (func (param i32 i64))) + ;; CHECK-TEXT: (type $8 (func (param eqref))) - ;; CHECK-TEXT: (type $9 (func (param eqref))) + ;; CHECK-TEXT: (type $9 (func (result i32 exnref))) - ;; CHECK-TEXT: (tag $e-i32 (type $6) (param i32)) + ;; CHECK-TEXT: (tag $e-i32 (type $5) (param i32)) ;; CHECK-BIN: (type $0 (func)) - ;; CHECK-BIN: (type $1 (func (result i32 i64))) + ;; CHECK-BIN: (type $1 (func (result exnref))) - ;; CHECK-BIN: (type $2 (func (result i32 i64 exnref))) + ;; CHECK-BIN: (type $2 (func (result i32))) - ;; CHECK-BIN: (type $3 (func (result exnref))) + ;; CHECK-BIN: (type $3 (func (result i32 i64))) - ;; CHECK-BIN: (type $4 (func (result i32))) + ;; CHECK-BIN: (type $4 (func (result i32 i64 exnref))) - ;; CHECK-BIN: (type $5 (func (result i32 exnref))) + ;; CHECK-BIN: (type $5 (func (param i32))) - ;; CHECK-BIN: (type $6 (func (param i32))) + ;; CHECK-BIN: (type $6 (func (param i64))) - ;; CHECK-BIN: (type $7 (func (param i64))) + ;; CHECK-BIN: (type $7 (func (param i32 i64))) - ;; CHECK-BIN: (type $8 (func (param i32 i64))) + ;; CHECK-BIN: (type $8 (func (param eqref))) - ;; CHECK-BIN: (type $9 (func (param eqref))) + ;; CHECK-BIN: (type $9 (func (result i32 exnref))) - ;; CHECK-BIN: (tag $e-i32 (type $6) (param i32)) + ;; CHECK-BIN: (tag $e-i32 (type $5) (param i32)) (tag $e-i32 (param i32)) - ;; CHECK-TEXT: (tag $e-i64 (type $7) (param i64)) - ;; CHECK-BIN: (tag $e-i64 (type $7) (param i64)) + ;; CHECK-TEXT: (tag $e-i64 (type $6) (param i64)) + ;; CHECK-BIN: (tag $e-i64 (type $6) (param i64)) (tag $e-i64 (param i64)) - ;; CHECK-TEXT: (tag $e-i32-i64 (type $8) (param i32 i64)) - ;; CHECK-BIN: (tag $e-i32-i64 (type $8) (param i32 i64)) + ;; CHECK-TEXT: (tag $e-i32-i64 (type $7) (param i32 i64)) + ;; CHECK-BIN: (tag $e-i32-i64 (type $7) (param i32 i64)) (tag $e-i32-i64 (param i32 i64)) - ;; CHECK-TEXT: (tag $e-eqref (type $9) (param eqref)) - ;; CHECK-BIN: (tag $e-eqref (type $9) (param eqref)) + ;; CHECK-TEXT: (tag $e-eqref (type $8) (param eqref)) + ;; CHECK-BIN: (tag $e-eqref (type $8) (param eqref)) (tag $e-eqref (param (ref null eq))) ;; CHECK-TEXT: (tag $e-empty (type $0)) ;; CHECK-BIN: (tag $e-empty (type $0)) @@ -72,7 +72,7 @@ ;; CHECK-BIN-NEXT: ) (func $foo) - ;; CHECK-TEXT: (func $exnref-nullexnref-test (type $3) (result exnref) + ;; CHECK-TEXT: (func $exnref-nullexnref-test (type $1) (result exnref) ;; CHECK-TEXT-NEXT: (local $exn exnref) ;; CHECK-TEXT-NEXT: (local $null-exn nullexnref) ;; CHECK-TEXT-NEXT: (if (result exnref) @@ -93,7 +93,7 @@ ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $exnref-nullexnref-test (type $3) (result exnref) + ;; CHECK-BIN: (func $exnref-nullexnref-test (type $1) (result exnref) ;; CHECK-BIN-NEXT: (local $exn exnref) ;; CHECK-BIN-NEXT: (local $null-exn nullexnref) ;; CHECK-BIN-NEXT: (if (result exnref) @@ -156,7 +156,7 @@ ) ) - ;; CHECK-TEXT: (func $simple-try-table-and-throw (type $4) (result i32) + ;; CHECK-TEXT: (func $simple-try-table-and-throw (type $2) (result i32) ;; CHECK-TEXT-NEXT: (block $l-catch (result i32) ;; CHECK-TEXT-NEXT: (try_table (catch $e-i32 $l-catch) ;; CHECK-TEXT-NEXT: (throw $e-i32 @@ -165,7 +165,7 @@ ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $simple-try-table-and-throw (type $4) (result i32) + ;; CHECK-BIN: (func $simple-try-table-and-throw (type $2) (result i32) ;; CHECK-BIN-NEXT: (block $block (result i32) ;; CHECK-BIN-NEXT: (try_table (catch $e-i32 $block) ;; CHECK-BIN-NEXT: (throw $e-i32 @@ -219,9 +219,9 @@ ;; CHECK-TEXT: (func $try-table-multivalue-tag (type $0) ;; CHECK-TEXT-NEXT: (block $outer ;; CHECK-TEXT-NEXT: (tuple.drop 3 - ;; CHECK-TEXT-NEXT: (block $l-catch-ref (type $2) (result i32 i64 exnref) + ;; CHECK-TEXT-NEXT: (block $l-catch-ref (type $4) (result i32 i64 exnref) ;; CHECK-TEXT-NEXT: (tuple.drop 2 - ;; CHECK-TEXT-NEXT: (block $l-catch (type $1) (result i32 i64) + ;; CHECK-TEXT-NEXT: (block $l-catch (type $3) (result i32 i64) ;; CHECK-TEXT-NEXT: (try_table (catch $e-i32-i64 $l-catch) (catch_ref $e-i32-i64 $l-catch-ref) ;; CHECK-TEXT-NEXT: (throw $e-i32-i64 ;; CHECK-TEXT-NEXT: (i32.const 0) @@ -247,13 +247,13 @@ ;; CHECK-BIN-NEXT: (local.set $scratch_4 ;; CHECK-BIN-NEXT: (tuple.extract 3 0 ;; CHECK-BIN-NEXT: (local.tee $scratch_2 - ;; CHECK-BIN-NEXT: (block $block1 (type $2) (result i32 i64 exnref) + ;; CHECK-BIN-NEXT: (block $block1 (type $4) (result i32 i64 exnref) ;; CHECK-BIN-NEXT: (drop ;; CHECK-BIN-NEXT: (block (result i32) ;; CHECK-BIN-NEXT: (local.set $scratch_1 ;; CHECK-BIN-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NEXT: (local.tee $scratch - ;; CHECK-BIN-NEXT: (block $block (type $1) (result i32 i64) + ;; CHECK-BIN-NEXT: (block $block (type $3) (result i32 i64) ;; CHECK-BIN-NEXT: (try_table (catch $e-i32-i64 $block) (catch_ref $e-i32-i64 $block1) ;; CHECK-BIN-NEXT: (throw $e-i32-i64 ;; CHECK-BIN-NEXT: (i32.const 0) @@ -396,7 +396,7 @@ ;; CHECK-TEXT-NEXT: (drop ;; CHECK-TEXT-NEXT: (block $l-catch (result i32) ;; CHECK-TEXT-NEXT: (tuple.drop 2 - ;; CHECK-TEXT-NEXT: (block $l-catch-ref (type $5) (result i32 exnref) + ;; CHECK-TEXT-NEXT: (block $l-catch-ref (type $9) (result i32 exnref) ;; CHECK-TEXT-NEXT: (block $l-catch-all ;; CHECK-TEXT-NEXT: (throw_ref ;; CHECK-TEXT-NEXT: (block $l-catch-all-ref (result exnref) @@ -427,7 +427,7 @@ ;; CHECK-BIN-NEXT: (local.set $scratch_1 ;; CHECK-BIN-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NEXT: (local.tee $scratch - ;; CHECK-BIN-NEXT: (block $block1 (type $5) (result i32 exnref) + ;; CHECK-BIN-NEXT: (block $block1 (type $9) (result i32 exnref) ;; CHECK-BIN-NEXT: (block $block2 ;; CHECK-BIN-NEXT: (throw_ref ;; CHECK-BIN-NEXT: (block $block3 (result exnref) @@ -491,9 +491,9 @@ ;; CHECK-TEXT: (func $try-table-all-catch-clauses-multivalue-tag (type $0) ;; CHECK-TEXT-NEXT: (block $outer ;; CHECK-TEXT-NEXT: (tuple.drop 2 - ;; CHECK-TEXT-NEXT: (block $l-catch (type $1) (result i32 i64) + ;; CHECK-TEXT-NEXT: (block $l-catch (type $3) (result i32 i64) ;; CHECK-TEXT-NEXT: (tuple.drop 3 - ;; CHECK-TEXT-NEXT: (block $l-catch-ref (type $2) (result i32 i64 exnref) + ;; CHECK-TEXT-NEXT: (block $l-catch-ref (type $4) (result i32 i64 exnref) ;; CHECK-TEXT-NEXT: (block $l-catch-all ;; CHECK-TEXT-NEXT: (throw_ref ;; CHECK-TEXT-NEXT: (block $l-catch-all-ref (result exnref) @@ -525,13 +525,13 @@ ;; CHECK-BIN-NEXT: (local.set $scratch_4 ;; CHECK-BIN-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NEXT: (local.tee $scratch_3 - ;; CHECK-BIN-NEXT: (block $block (type $1) (result i32 i64) + ;; CHECK-BIN-NEXT: (block $block (type $3) (result i32 i64) ;; CHECK-BIN-NEXT: (drop ;; CHECK-BIN-NEXT: (block (result i32) ;; CHECK-BIN-NEXT: (local.set $scratch_2 ;; CHECK-BIN-NEXT: (tuple.extract 3 0 ;; CHECK-BIN-NEXT: (local.tee $scratch - ;; CHECK-BIN-NEXT: (block $block1 (type $2) (result i32 i64 exnref) + ;; CHECK-BIN-NEXT: (block $block1 (type $4) (result i32 i64 exnref) ;; CHECK-BIN-NEXT: (block $block2 ;; CHECK-BIN-NEXT: (throw_ref ;; CHECK-BIN-NEXT: (block $block3 (result exnref) @@ -612,7 +612,7 @@ ) ) - ;; CHECK-TEXT: (func $try-table-with-label-and-br (type $4) (result i32) + ;; CHECK-TEXT: (func $try-table-with-label-and-br (type $2) (result i32) ;; CHECK-TEXT-NEXT: (block $l-catch (result i32) ;; CHECK-TEXT-NEXT: (block $l (result i32) ;; CHECK-TEXT-NEXT: (try_table (result i32) (catch $e-i32 $l-catch) @@ -623,7 +623,7 @@ ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $try-table-with-label-and-br (type $4) (result i32) + ;; CHECK-BIN: (func $try-table-with-label-and-br (type $2) (result i32) ;; CHECK-BIN-NEXT: (block $block (result i32) ;; CHECK-BIN-NEXT: (block $block1 (result i32) ;; CHECK-BIN-NEXT: (try_table (result i32) (catch $e-i32 $block) @@ -642,7 +642,7 @@ ) ) - ;; CHECK-TEXT: (func $nested-try-table (type $3) (result exnref) + ;; CHECK-TEXT: (func $nested-try-table (type $1) (result exnref) ;; CHECK-TEXT-NEXT: (block $l-catch-outer (result exnref) ;; CHECK-TEXT-NEXT: (drop ;; CHECK-TEXT-NEXT: (block $l-catch-inner (result i32) @@ -668,7 +668,7 @@ ;; CHECK-TEXT-NEXT: (ref.null noexn) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $nested-try-table (type $3) (result exnref) + ;; CHECK-BIN: (func $nested-try-table (type $1) (result exnref) ;; CHECK-BIN-NEXT: (block $block (result exnref) ;; CHECK-BIN-NEXT: (drop ;; CHECK-BIN-NEXT: (block $block1 (result i32) @@ -722,38 +722,38 @@ ) ;; CHECK-BIN-NODEBUG: (type $0 (func)) -;; CHECK-BIN-NODEBUG: (type $1 (func (result i32 i64))) +;; CHECK-BIN-NODEBUG: (type $1 (func (result exnref))) -;; CHECK-BIN-NODEBUG: (type $2 (func (result i32 i64 exnref))) +;; CHECK-BIN-NODEBUG: (type $2 (func (result i32))) -;; CHECK-BIN-NODEBUG: (type $3 (func (result exnref))) +;; CHECK-BIN-NODEBUG: (type $3 (func (result i32 i64))) -;; CHECK-BIN-NODEBUG: (type $4 (func (result i32))) +;; CHECK-BIN-NODEBUG: (type $4 (func (result i32 i64 exnref))) -;; CHECK-BIN-NODEBUG: (type $5 (func (result i32 exnref))) +;; CHECK-BIN-NODEBUG: (type $5 (func (param i32))) -;; CHECK-BIN-NODEBUG: (type $6 (func (param i32))) +;; CHECK-BIN-NODEBUG: (type $6 (func (param i64))) -;; CHECK-BIN-NODEBUG: (type $7 (func (param i64))) +;; CHECK-BIN-NODEBUG: (type $7 (func (param i32 i64))) -;; CHECK-BIN-NODEBUG: (type $8 (func (param i32 i64))) +;; CHECK-BIN-NODEBUG: (type $8 (func (param eqref))) -;; CHECK-BIN-NODEBUG: (type $9 (func (param eqref))) +;; CHECK-BIN-NODEBUG: (type $9 (func (result i32 exnref))) -;; CHECK-BIN-NODEBUG: (tag $tag$0 (type $6) (param i32)) +;; CHECK-BIN-NODEBUG: (tag $tag$0 (type $5) (param i32)) -;; CHECK-BIN-NODEBUG: (tag $tag$1 (type $7) (param i64)) +;; CHECK-BIN-NODEBUG: (tag $tag$1 (type $6) (param i64)) -;; CHECK-BIN-NODEBUG: (tag $tag$2 (type $8) (param i32 i64)) +;; CHECK-BIN-NODEBUG: (tag $tag$2 (type $7) (param i32 i64)) -;; CHECK-BIN-NODEBUG: (tag $tag$3 (type $9) (param eqref)) +;; CHECK-BIN-NODEBUG: (tag $tag$3 (type $8) (param eqref)) ;; CHECK-BIN-NODEBUG: (tag $tag$4 (type $0)) ;; CHECK-BIN-NODEBUG: (func $0 (type $0) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $1 (type $3) (result exnref) +;; CHECK-BIN-NODEBUG: (func $1 (type $1) (result exnref) ;; CHECK-BIN-NODEBUG-NEXT: (local $0 exnref) ;; CHECK-BIN-NODEBUG-NEXT: (local $1 nullexnref) ;; CHECK-BIN-NODEBUG-NEXT: (if (result exnref) @@ -784,7 +784,7 @@ ;; CHECK-BIN-NODEBUG-NEXT: (unreachable) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $3 (type $4) (result i32) +;; CHECK-BIN-NODEBUG: (func $3 (type $2) (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (block $block (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (try_table (catch $tag$0 $block) ;; CHECK-BIN-NODEBUG-NEXT: (throw $tag$0 @@ -820,13 +820,13 @@ ;; CHECK-BIN-NODEBUG-NEXT: (local.set $scratch_4 ;; CHECK-BIN-NODEBUG-NEXT: (tuple.extract 3 0 ;; CHECK-BIN-NODEBUG-NEXT: (local.tee $scratch_2 -;; CHECK-BIN-NODEBUG-NEXT: (block $block1 (type $2) (result i32 i64 exnref) +;; CHECK-BIN-NODEBUG-NEXT: (block $block1 (type $4) (result i32 i64 exnref) ;; CHECK-BIN-NODEBUG-NEXT: (drop ;; CHECK-BIN-NODEBUG-NEXT: (block (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (local.set $scratch_1 ;; CHECK-BIN-NODEBUG-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NODEBUG-NEXT: (local.tee $scratch -;; CHECK-BIN-NODEBUG-NEXT: (block $block (type $1) (result i32 i64) +;; CHECK-BIN-NODEBUG-NEXT: (block $block (type $3) (result i32 i64) ;; CHECK-BIN-NODEBUG-NEXT: (try_table (catch $tag$2 $block) (catch_ref $tag$2 $block1) ;; CHECK-BIN-NODEBUG-NEXT: (throw $tag$2 ;; CHECK-BIN-NODEBUG-NEXT: (i32.const 0) @@ -907,7 +907,7 @@ ;; CHECK-BIN-NODEBUG-NEXT: (local.set $scratch_1 ;; CHECK-BIN-NODEBUG-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NODEBUG-NEXT: (local.tee $scratch -;; CHECK-BIN-NODEBUG-NEXT: (block $block1 (type $5) (result i32 exnref) +;; CHECK-BIN-NODEBUG-NEXT: (block $block1 (type $9) (result i32 exnref) ;; CHECK-BIN-NODEBUG-NEXT: (block $block2 ;; CHECK-BIN-NODEBUG-NEXT: (throw_ref ;; CHECK-BIN-NODEBUG-NEXT: (block $block3 (result exnref) @@ -950,13 +950,13 @@ ;; CHECK-BIN-NODEBUG-NEXT: (local.set $scratch_4 ;; CHECK-BIN-NODEBUG-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NODEBUG-NEXT: (local.tee $scratch_3 -;; CHECK-BIN-NODEBUG-NEXT: (block $block (type $1) (result i32 i64) +;; CHECK-BIN-NODEBUG-NEXT: (block $block (type $3) (result i32 i64) ;; CHECK-BIN-NODEBUG-NEXT: (drop ;; CHECK-BIN-NODEBUG-NEXT: (block (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (local.set $scratch_2 ;; CHECK-BIN-NODEBUG-NEXT: (tuple.extract 3 0 ;; CHECK-BIN-NODEBUG-NEXT: (local.tee $scratch -;; CHECK-BIN-NODEBUG-NEXT: (block $block1 (type $2) (result i32 i64 exnref) +;; CHECK-BIN-NODEBUG-NEXT: (block $block1 (type $4) (result i32 i64 exnref) ;; CHECK-BIN-NODEBUG-NEXT: (block $block2 ;; CHECK-BIN-NODEBUG-NEXT: (throw_ref ;; CHECK-BIN-NODEBUG-NEXT: (block $block3 (result exnref) @@ -1007,7 +1007,7 @@ ;; CHECK-BIN-NODEBUG-NEXT: ) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $9 (type $4) (result i32) +;; CHECK-BIN-NODEBUG: (func $9 (type $2) (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (block $block (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (block $block1 (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (try_table (result i32) (catch $tag$0 $block) @@ -1019,7 +1019,7 @@ ;; CHECK-BIN-NODEBUG-NEXT: ) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $10 (type $3) (result exnref) +;; CHECK-BIN-NODEBUG: (func $10 (type $1) (result exnref) ;; CHECK-BIN-NODEBUG-NEXT: (block $block (result exnref) ;; CHECK-BIN-NODEBUG-NEXT: (drop ;; CHECK-BIN-NODEBUG-NEXT: (block $block1 (result i32) diff --git a/test/lit/basic/extra-branch-values.wast b/test/lit/basic/extra-branch-values.wast index 6989bf62ca9..ca840036818 100644 --- a/test/lit/basic/extra-branch-values.wast +++ b/test/lit/basic/extra-branch-values.wast @@ -23,18 +23,18 @@ ;; OPT_O: (import "env" "eqref" (global $eqref (mut eqref))) (import "env" "eqref" (global $eqref (mut eqref))) - ;; CHECK: (import "env" "use-i32-any" (func $use-i32-any (type $15) (param i32 (ref any)))) - ;; OPT_O: (import "env" "use-i32-any" (func $use-i32-any (type $15) (param i32 (ref any)))) + ;; CHECK: (import "env" "use-i32-any" (func $use-i32-any (type $13) (param i32 (ref any)))) + ;; OPT_O: (import "env" "use-i32-any" (func $use-i32-any (type $11) (param i32 (ref any)))) (import "env" "use-i32-any" (func $use-i32-any (param i32 (ref any)))) - ;; CHECK: (tag $e (type $7) (param i32)) - ;; OPT_O: (tag $e (type $5) (param i32)) + ;; CHECK: (tag $e (type $4) (param i32)) + ;; OPT_O: (tag $e (type $4) (param i32)) (tag $e (param i32)) - ;; CHECK: (tag $e2 (type $7) (param i32)) - ;; OPT_O: (tag $e2 (type $5) (param i32)) + ;; CHECK: (tag $e2 (type $4) (param i32)) + ;; OPT_O: (tag $e2 (type $4) (param i32)) (tag $e2 (param i32)) - ;; CHECK: (func $br_on_null-one (type $8) (param $0 i32) (param $1 anyref) (result i32) + ;; CHECK: (func $br_on_null-one (type $5) (param $0 i32) (param $1 anyref) (result i32) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -76,7 +76,7 @@ ;; CHECK-NEXT: (local.get $scratch_3) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_null-one (type $6) (param $0 i32) (param $1 anyref) (result i32) + ;; OPT_O: (func $br_on_null-one (type $5) (param $0 i32) (param $1 anyref) (result i32) ;; OPT_O-NEXT: (block $block (result i32) ;; OPT_O-NEXT: (block $block0 ;; OPT_O-NEXT: (global.set $any @@ -105,14 +105,14 @@ end ) - ;; CHECK: (func $br_on_null-two (type $16) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64) + ;; CHECK: (func $br_on_null-two (type $14) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_4 (tuple i32 i64)) ;; CHECK-NEXT: (local $scratch_5 i64) ;; CHECK-NEXT: (local $scratch_6 (ref any)) ;; CHECK-NEXT: (local $scratch_7 (tuple i32 i64)) ;; CHECK-NEXT: (local $scratch_8 i32) - ;; CHECK-NEXT: (block $block (type $13) (result i32 i64) + ;; CHECK-NEXT: (block $block (type $26) (result i32 i64) ;; CHECK-NEXT: (block $block0 ;; CHECK-NEXT: (local.set $scratch_4 ;; CHECK-NEXT: (tuple.make 2 @@ -166,9 +166,9 @@ ;; CHECK-NEXT: (local.get $scratch_4) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_null-two (type $16) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64) + ;; OPT_O: (func $br_on_null-two (type $12) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64) ;; OPT_O-NEXT: (local $3 (tuple i32 i64)) - ;; OPT_O-NEXT: (block $block (type $11) (result i32 i64) + ;; OPT_O-NEXT: (block $block (type $24) (result i32 i64) ;; OPT_O-NEXT: (local.set $3 ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) @@ -215,7 +215,7 @@ end ) - ;; CHECK: (func $br_on_non_null-one (type $9) (param $0 i32) (param $1 anyref) (result i32 (ref any)) + ;; CHECK: (func $br_on_non_null-one (type $6) (param $0 i32) (param $1 anyref) (result i32 (ref any)) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -254,8 +254,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_non_null-one (type $7) (param $0 i32) (param $1 anyref) (result i32 (ref any)) - ;; OPT_O-NEXT: (block $block (type $1) (result i32 (ref any)) + ;; OPT_O: (func $br_on_non_null-one (type $6) (param $0 i32) (param $1 anyref) (result i32 (ref any)) + ;; OPT_O-NEXT: (block $block (type $2) (result i32 (ref any)) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (block $block0 (result (ref any)) @@ -286,14 +286,14 @@ end ) - ;; CHECK: (func $br_on_non_null-two (type $10) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 (ref any)) + ;; CHECK: (func $br_on_non_null-two (type $7) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 (ref any)) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_4 (tuple i32 i64)) ;; CHECK-NEXT: (local $scratch_5 i64) ;; CHECK-NEXT: (local $scratch_6 (tuple i32 i64)) ;; CHECK-NEXT: (local $scratch_7 i32) ;; CHECK-NEXT: (local $scratch_8 (ref any)) - ;; CHECK-NEXT: (block $block (type $4) (result i32 i64 (ref any)) + ;; CHECK-NEXT: (block $block (type $10) (result i32 i64 (ref any)) ;; CHECK-NEXT: (local.set $scratch_8 ;; CHECK-NEXT: (block $block0 (result (ref any)) ;; CHECK-NEXT: (local.set $scratch_4 @@ -350,8 +350,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_non_null-two (type $8) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 (ref any)) - ;; OPT_O-NEXT: (block $block (type $4) (result i32 i64 (ref any)) + ;; OPT_O: (func $br_on_non_null-two (type $7) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 (ref any)) + ;; OPT_O-NEXT: (block $block (type $10) (result i32 i64 (ref any)) ;; OPT_O-NEXT: (tuple.make 3 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (local.get $1) @@ -390,7 +390,7 @@ end ) - ;; CHECK: (func $br_on_cast-one (type $2) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; CHECK: (func $br_on_cast-one (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -441,7 +441,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_cast-one (type $3) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; OPT_O: (func $br_on_cast-one (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $block (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) @@ -476,7 +476,7 @@ end ) - ;; CHECK: (func $br_on_cast-two (type $17) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 eqref) + ;; CHECK: (func $br_on_cast-two (type $15) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_4 (tuple i32 i64)) ;; CHECK-NEXT: (local $scratch_5 i64) @@ -484,7 +484,7 @@ ;; CHECK-NEXT: (local $scratch_7 (tuple i32 i64)) ;; CHECK-NEXT: (local $scratch_8 i32) ;; CHECK-NEXT: (local $scratch_9 eqref) - ;; CHECK-NEXT: (block $block (type $14) (result i32 i64 eqref) + ;; CHECK-NEXT: (block $block (type $27) (result i32 i64 eqref) ;; CHECK-NEXT: (local.set $scratch_9 ;; CHECK-NEXT: (block $block0 (result eqref) ;; CHECK-NEXT: (local.set $scratch_4 @@ -549,8 +549,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_cast-two (type $17) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 eqref) - ;; OPT_O-NEXT: (block $block (type $12) (result i32 i64 eqref) + ;; OPT_O: (func $br_on_cast-two (type $13) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 eqref) + ;; OPT_O-NEXT: (block $block (type $25) (result i32 i64 eqref) ;; OPT_O-NEXT: (tuple.make 3 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (local.get $1) @@ -592,14 +592,14 @@ end ) - ;; CHECK: (func $br_on_cast-nn (type $18) (param $0 i32) (param $1 (ref any)) (result i32 (ref eq)) + ;; CHECK: (func $br_on_cast-nn (type $16) (param $0 i32) (param $1 (ref any)) (result i32 (ref eq)) ;; CHECK-NEXT: (local $scratch (ref any)) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) ;; CHECK-NEXT: (local $scratch_5 (ref any)) ;; CHECK-NEXT: (local $scratch_6 i32) ;; CHECK-NEXT: (local $scratch_7 (ref eq)) - ;; CHECK-NEXT: (block $block (type $5) (result i32 (ref eq)) + ;; CHECK-NEXT: (block $block (type $11) (result i32 (ref eq)) ;; CHECK-NEXT: (local.set $scratch_7 ;; CHECK-NEXT: (block $block0 (result (ref eq)) ;; CHECK-NEXT: (local.set $scratch_3 @@ -643,8 +643,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_cast-nn (type $18) (param $0 i32) (param $1 (ref any)) (result i32 (ref eq)) - ;; OPT_O-NEXT: (block $block (type $2) (result i32 (ref eq)) + ;; OPT_O: (func $br_on_cast-nn (type $14) (param $0 i32) (param $1 (ref any)) (result i32 (ref eq)) + ;; OPT_O-NEXT: (block $block (type $3) (result i32 (ref eq)) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (block $block0 (result (ref eq)) @@ -678,14 +678,14 @@ end ) - ;; CHECK: (func $br_on_cast-to-nn (type $19) (param $0 i32) (param $1 anyref) (result i32 (ref eq)) + ;; CHECK: (func $br_on_cast-to-nn (type $17) (param $0 i32) (param $1 anyref) (result i32 (ref eq)) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) ;; CHECK-NEXT: (local $scratch_5 anyref) ;; CHECK-NEXT: (local $scratch_6 i32) ;; CHECK-NEXT: (local $scratch_7 (ref eq)) - ;; CHECK-NEXT: (block $block (type $5) (result i32 (ref eq)) + ;; CHECK-NEXT: (block $block (type $11) (result i32 (ref eq)) ;; CHECK-NEXT: (local.set $scratch_7 ;; CHECK-NEXT: (block $block0 (result (ref eq)) ;; CHECK-NEXT: (local.set $scratch_3 @@ -729,8 +729,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_cast-to-nn (type $19) (param $0 i32) (param $1 anyref) (result i32 (ref eq)) - ;; OPT_O-NEXT: (block $block (type $2) (result i32 (ref eq)) + ;; OPT_O: (func $br_on_cast-to-nn (type $15) (param $0 i32) (param $1 anyref) (result i32 (ref eq)) + ;; OPT_O-NEXT: (block $block (type $3) (result i32 (ref eq)) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (block $block0 (result (ref eq)) @@ -764,7 +764,7 @@ end ) - ;; CHECK: (func $br_on_cast_fail-one (type $9) (param $0 i32) (param $1 anyref) (result i32 (ref any)) + ;; CHECK: (func $br_on_cast_fail-one (type $6) (param $0 i32) (param $1 anyref) (result i32 (ref any)) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -815,8 +815,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_cast_fail-one (type $7) (param $0 i32) (param $1 anyref) (result i32 (ref any)) - ;; OPT_O-NEXT: (block $block (type $1) (result i32 (ref any)) + ;; OPT_O: (func $br_on_cast_fail-one (type $6) (param $0 i32) (param $1 anyref) (result i32 (ref any)) + ;; OPT_O-NEXT: (block $block (type $2) (result i32 (ref any)) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (block $block0 (result (ref any)) @@ -850,7 +850,7 @@ end ) - ;; CHECK: (func $br_on_cast_fail-two (type $10) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 (ref any)) + ;; CHECK: (func $br_on_cast_fail-two (type $7) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 (ref any)) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_4 (tuple i32 i64)) ;; CHECK-NEXT: (local $scratch_5 i64) @@ -858,7 +858,7 @@ ;; CHECK-NEXT: (local $scratch_7 (tuple i32 i64)) ;; CHECK-NEXT: (local $scratch_8 i32) ;; CHECK-NEXT: (local $scratch_9 (ref any)) - ;; CHECK-NEXT: (block $block (type $4) (result i32 i64 (ref any)) + ;; CHECK-NEXT: (block $block (type $10) (result i32 i64 (ref any)) ;; CHECK-NEXT: (local.set $scratch_9 ;; CHECK-NEXT: (block $block0 (result (ref any)) ;; CHECK-NEXT: (local.set $scratch_4 @@ -923,8 +923,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_cast_fail-two (type $8) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 (ref any)) - ;; OPT_O-NEXT: (block $block (type $4) (result i32 i64 (ref any)) + ;; OPT_O: (func $br_on_cast_fail-two (type $7) (param $0 i32) (param $1 i64) (param $2 anyref) (result i32 i64 (ref any)) + ;; OPT_O-NEXT: (block $block (type $10) (result i32 i64 (ref any)) ;; OPT_O-NEXT: (tuple.make 3 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (local.get $1) @@ -966,7 +966,7 @@ end ) - ;; CHECK: (func $br_on_cast_fail-nn (type $20) (param $0 i32) (param $1 (ref any)) (result i32 (ref any)) + ;; CHECK: (func $br_on_cast_fail-nn (type $18) (param $0 i32) (param $1 (ref any)) (result i32 (ref any)) ;; CHECK-NEXT: (local $scratch (ref any)) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -1017,8 +1017,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_cast_fail-nn (type $20) (param $0 i32) (param $1 (ref any)) (result i32 (ref any)) - ;; OPT_O-NEXT: (block $block (type $1) (result i32 (ref any)) + ;; OPT_O: (func $br_on_cast_fail-nn (type $16) (param $0 i32) (param $1 (ref any)) (result i32 (ref any)) + ;; OPT_O-NEXT: (block $block (type $2) (result i32 (ref any)) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (block $block0 (result (ref any)) @@ -1052,14 +1052,14 @@ end ) - ;; CHECK: (func $br_on_cast_fail-to-nn (type $11) (param $0 i32) (param $1 anyref) (result i32 anyref) + ;; CHECK: (func $br_on_cast_fail-to-nn (type $8) (param $0 i32) (param $1 anyref) (result i32 anyref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) ;; CHECK-NEXT: (local $scratch_5 (ref eq)) ;; CHECK-NEXT: (local $scratch_6 i32) ;; CHECK-NEXT: (local $scratch_7 anyref) - ;; CHECK-NEXT: (block $block (type $1) (result i32 anyref) + ;; CHECK-NEXT: (block $block (type $2) (result i32 anyref) ;; CHECK-NEXT: (local.set $scratch_7 ;; CHECK-NEXT: (block $block0 (result anyref) ;; CHECK-NEXT: (local.set $scratch_3 @@ -1103,8 +1103,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $br_on_cast_fail-to-nn (type $9) (param $0 i32) (param $1 anyref) (result i32 anyref) - ;; OPT_O-NEXT: (block $block (type $13) (result i32 anyref) + ;; OPT_O: (func $br_on_cast_fail-to-nn (type $8) (param $0 i32) (param $1 anyref) (result i32 anyref) + ;; OPT_O-NEXT: (block $block (type $26) (result i32 anyref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (block $block0 (result anyref) @@ -1138,7 +1138,7 @@ end ) - ;; CHECK: (func $unreachable-fallthrough (type $8) (param $0 i32) (param $1 anyref) (result i32) + ;; CHECK: (func $unreachable-fallthrough (type $5) (param $0 i32) (param $1 anyref) (result i32) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -1187,7 +1187,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: (local.get $scratch_7) ;; CHECK-NEXT: ) - ;; OPT_O: (func $unreachable-fallthrough (type $6) (param $0 i32) (param $1 anyref) (result i32) + ;; OPT_O: (func $unreachable-fallthrough (type $5) (param $0 i32) (param $1 anyref) (result i32) ;; OPT_O-NEXT: (drop ;; OPT_O-NEXT: (block $l0 (result (ref any)) ;; OPT_O-NEXT: (br_on_non_null $l0 @@ -1210,7 +1210,7 @@ drop ) - ;; CHECK: (func $matching-branches (type $21) (param $0 i32) (param $1 anyref) (param $2 i32) (param $3 anyref) (result i32 eqref) + ;; CHECK: (func $matching-branches (type $19) (param $0 i32) (param $1 anyref) (param $2 i32) (param $3 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_5 i32) ;; CHECK-NEXT: (local $scratch_6 i32) @@ -1292,7 +1292,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $matching-branches (type $21) (param $0 i32) (param $1 anyref) (param $2 i32) (param $3 anyref) (result i32 eqref) + ;; OPT_O: (func $matching-branches (type $17) (param $0 i32) (param $1 anyref) (param $2 i32) (param $3 anyref) (result i32 eqref) ;; OPT_O-NEXT: (local $4 eqref) ;; OPT_O-NEXT: (block $block (type $0) (result i32 eqref) ;; OPT_O-NEXT: (local.set $4 @@ -1347,7 +1347,7 @@ end ) - ;; CHECK: (func $different-branches (type $22) (param $0 i32) (param $1 anyref) (param $2 i32) (param $3 eqref) (param $4 anyref) (result i32 eqref) + ;; CHECK: (func $different-branches (type $20) (param $0 i32) (param $1 anyref) (param $2 i32) (param $3 eqref) (param $4 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_6 i32) ;; CHECK-NEXT: (local $scratch_7 i32) @@ -1451,7 +1451,7 @@ ;; CHECK-NEXT: (local.get $scratch_11) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $different-branches (type $22) (param $0 i32) (param $1 anyref) (param $2 i32) (param $3 eqref) (param $4 anyref) (result i32 eqref) + ;; OPT_O: (func $different-branches (type $18) (param $0 i32) (param $1 anyref) (param $2 i32) (param $3 eqref) (param $4 anyref) (result i32 eqref) ;; OPT_O-NEXT: (local $5 (tuple i32 eqref)) ;; OPT_O-NEXT: (block $block (type $0) (result i32 eqref) ;; OPT_O-NEXT: (block $block1 @@ -1520,7 +1520,7 @@ end ) - ;; CHECK: (func $different-branches-2 (type $23) (param $0 i32) (param $1 eqref) (param $2 anyref) (param $3 i32) (param $4 anyref) (result i32 eqref) + ;; CHECK: (func $different-branches-2 (type $21) (param $0 i32) (param $1 eqref) (param $2 anyref) (param $3 i32) (param $4 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_6 (tuple i32 eqref)) ;; CHECK-NEXT: (local $scratch_7 eqref) @@ -1624,7 +1624,7 @@ ;; CHECK-NEXT: (local.get $scratch_6) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $different-branches-2 (type $23) (param $0 i32) (param $1 eqref) (param $2 anyref) (param $3 i32) (param $4 anyref) (result i32 eqref) + ;; OPT_O: (func $different-branches-2 (type $19) (param $0 i32) (param $1 eqref) (param $2 anyref) (param $3 i32) (param $4 anyref) (result i32 eqref) ;; OPT_O-NEXT: (local $5 (tuple i32 eqref)) ;; OPT_O-NEXT: (block $block (type $0) (result i32 eqref) ;; OPT_O-NEXT: (block $block0 @@ -1693,7 +1693,7 @@ end ) - ;; CHECK: (func $nested-branches (type $24) (param $0 i32) (param $1 anyref) (param $2 anyref) (result i32) + ;; CHECK: (func $nested-branches (type $22) (param $0 i32) (param $1 anyref) (param $2 anyref) (result i32) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_4 i32) ;; CHECK-NEXT: (local $scratch_5 i32) @@ -1788,7 +1788,7 @@ ;; CHECK-NEXT: (local.get $scratch_8) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $nested-branches (type $24) (param $0 i32) (param $1 anyref) (param $2 anyref) (result i32) + ;; OPT_O: (func $nested-branches (type $20) (param $0 i32) (param $1 anyref) (param $2 anyref) (result i32) ;; OPT_O-NEXT: (block $block1 (result i32) ;; OPT_O-NEXT: (block $block10 ;; OPT_O-NEXT: (br $block1 @@ -1840,7 +1840,7 @@ end ) - ;; CHECK: (func $with-block-param (type $25) (param $0 i64) (param $1 anyref) (result i64 eqref) + ;; CHECK: (func $with-block-param (type $23) (param $0 i64) (param $1 anyref) (result i64 eqref) ;; CHECK-NEXT: (local $scratch i64) ;; CHECK-NEXT: (local $scratch_3 anyref) ;; CHECK-NEXT: (local $scratch_4 i64) @@ -1851,7 +1851,7 @@ ;; CHECK-NEXT: (local.set $scratch ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (block $block (type $6) (result i64 eqref) + ;; CHECK-NEXT: (block $block (type $12) (result i64 eqref) ;; CHECK-NEXT: (local.set $scratch_8 ;; CHECK-NEXT: (block $block0 (result eqref) ;; CHECK-NEXT: (local.set $scratch_4 @@ -1895,8 +1895,8 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $with-block-param (type $25) (param $0 i64) (param $1 anyref) (result i64 eqref) - ;; OPT_O-NEXT: (block $block (type $14) (result i64 eqref) + ;; OPT_O: (func $with-block-param (type $21) (param $0 i64) (param $1 anyref) (result i64 eqref) + ;; OPT_O-NEXT: (block $block (type $27) (result i64 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (block $block0 (result eqref) @@ -1930,7 +1930,7 @@ end ) - ;; CHECK: (func $loop (type $26) (param $0 i32) (param $1 anyref) + ;; CHECK: (func $loop (type $24) (param $0 i32) (param $1 anyref) ;; CHECK-NEXT: (local $scratch (tuple i32 anyref)) ;; CHECK-NEXT: (local $scratch_3 (tuple i32 anyref)) ;; CHECK-NEXT: (local $scratch_4 anyref) @@ -1948,7 +1948,7 @@ ;; CHECK-NEXT: (loop $label2 ;; CHECK-NEXT: (block $label3 ;; CHECK-NEXT: (local.set $scratch - ;; CHECK-NEXT: (block $label (type $1) (result i32 anyref) + ;; CHECK-NEXT: (block $label (type $2) (result i32 anyref) ;; CHECK-NEXT: (block $label1 ;; CHECK-NEXT: (local.set $scratch_9 ;; CHECK-NEXT: (block $label0 (result anyref) @@ -2002,7 +2002,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $loop (type $26) (param $0 i32) (param $1 anyref) + ;; OPT_O: (func $loop (type $22) (param $0 i32) (param $1 anyref) ;; OPT_O-NEXT: (loop $label2 ;; OPT_O-NEXT: (block $label3 ;; OPT_O-NEXT: (local.set $1 @@ -2032,7 +2032,7 @@ end ) - ;; CHECK: (func $loop-results (type $11) (param $0 i32) (param $1 anyref) (result i32 anyref) + ;; CHECK: (func $loop-results (type $8) (param $0 i32) (param $1 anyref) (result i32 anyref) ;; CHECK-NEXT: (local $scratch (tuple i32 anyref)) ;; CHECK-NEXT: (local $scratch_3 (tuple i32 anyref)) ;; CHECK-NEXT: (local $scratch_4 anyref) @@ -2046,12 +2046,12 @@ ;; CHECK-NEXT: (local.get $1) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (loop $label2 (type $1) (result i32 anyref) - ;; CHECK-NEXT: (block $label3 (type $1) (result i32 anyref) + ;; CHECK-NEXT: (loop $label2 (type $2) (result i32 anyref) + ;; CHECK-NEXT: (block $label3 (type $2) (result i32 anyref) ;; CHECK-NEXT: (local.set $scratch - ;; CHECK-NEXT: (block $label (type $1) (result i32 anyref) + ;; CHECK-NEXT: (block $label (type $2) (result i32 anyref) ;; CHECK-NEXT: (br $label3 - ;; CHECK-NEXT: (block $label1 (type $1) (result i32 anyref) + ;; CHECK-NEXT: (block $label1 (type $2) (result i32 anyref) ;; CHECK-NEXT: (local.set $scratch_8 ;; CHECK-NEXT: (block $label0 (result anyref) ;; CHECK-NEXT: (local.set $scratch_5 @@ -2098,7 +2098,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $loop-results (type $9) (param $0 i32) (param $1 anyref) (result i32 anyref) + ;; OPT_O: (func $loop-results (type $8) (param $0 i32) (param $1 anyref) (result i32 anyref) ;; OPT_O-NEXT: (local $2 (tuple i32 anyref)) ;; OPT_O-NEXT: (local $3 eqref) ;; OPT_O-NEXT: (local.set $2 @@ -2107,12 +2107,12 @@ ;; OPT_O-NEXT: (local.get $1) ;; OPT_O-NEXT: ) ;; OPT_O-NEXT: ) - ;; OPT_O-NEXT: (loop $label2 (type $1) (result i32 (ref any)) - ;; OPT_O-NEXT: (block $label3 (type $1) (result i32 (ref any)) + ;; OPT_O-NEXT: (loop $label2 (type $2) (result i32 (ref any)) + ;; OPT_O-NEXT: (block $label3 (type $2) (result i32 (ref any)) ;; OPT_O-NEXT: (local.set $2 ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (br $label3 - ;; OPT_O-NEXT: (block $label1 (type $1) (result i32 (ref any)) + ;; OPT_O-NEXT: (block $label1 (type $2) (result i32 (ref any)) ;; OPT_O-NEXT: (local.set $3 ;; OPT_O-NEXT: (block $label0 (result eqref) ;; OPT_O-NEXT: (br $label1 @@ -2153,7 +2153,7 @@ end ) - ;; CHECK: (func $if (type $12) (param $0 i32) (param $1 i32) (param $2 anyref) (result i32 eqref) + ;; CHECK: (func $if (type $9) (param $0 i32) (param $1 i32) (param $2 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_4 i32) ;; CHECK-NEXT: (local $scratch_5 i32) @@ -2215,7 +2215,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $if (type $10) (param $0 i32) (param $1 i32) (param $2 anyref) (result i32 eqref) + ;; OPT_O: (func $if (type $9) (param $0 i32) (param $1 i32) (param $2 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $1) @@ -2265,7 +2265,7 @@ end ) - ;; CHECK: (func $else (type $12) (param $0 i32) (param $1 i32) (param $2 anyref) (result i32 eqref) + ;; CHECK: (func $else (type $9) (param $0 i32) (param $1 i32) (param $2 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_4 i32) ;; CHECK-NEXT: (local $scratch_5 i32) @@ -2327,7 +2327,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $else (type $10) (param $0 i32) (param $1 i32) (param $2 anyref) (result i32 eqref) + ;; OPT_O: (func $else (type $9) (param $0 i32) (param $1 i32) (param $2 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $1) @@ -2377,7 +2377,7 @@ end ) - ;; CHECK: (func $if-else-params (type $27) (param $0 i32) (param $1 i32) (param $2 anyref) (param $3 anyref) (result i32 eqref) + ;; CHECK: (func $if-else-params (type $25) (param $0 i32) (param $1 i32) (param $2 anyref) (param $3 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch i32) ;; CHECK-NEXT: (local $scratch_5 anyref) ;; CHECK-NEXT: (local $scratch_6 i32) @@ -2468,7 +2468,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $if-else-params (type $27) (param $0 i32) (param $1 i32) (param $2 anyref) (param $3 anyref) (result i32 eqref) + ;; OPT_O: (func $if-else-params (type $23) (param $0 i32) (param $1 i32) (param $2 anyref) (param $3 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) @@ -2520,7 +2520,7 @@ end ) - ;; CHECK: (func $try-catch (type $2) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; CHECK: (func $try-catch (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -2573,7 +2573,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $try-catch (type $3) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; OPT_O: (func $try-catch (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) @@ -2617,7 +2617,7 @@ end ) - ;; CHECK: (func $try-catch_all (type $2) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; CHECK: (func $try-catch_all (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -2670,7 +2670,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $try-catch_all (type $3) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; OPT_O: (func $try-catch_all (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) @@ -2715,7 +2715,7 @@ end ) - ;; CHECK: (func $try-delegate (type $2) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; CHECK: (func $try-delegate (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -2763,7 +2763,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $try-delegate (type $3) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; OPT_O: (func $try-delegate (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) @@ -2800,7 +2800,7 @@ delegate 0 ) - ;; CHECK: (func $try-everything-params (type $2) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; CHECK: (func $try-everything-params (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch i32) ;; CHECK-NEXT: (local $scratch_3 anyref) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -2869,7 +2869,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $try-everything-params (type $3) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; OPT_O: (func $try-everything-params (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) @@ -2930,7 +2930,7 @@ end ) - ;; CHECK: (func $try_table (type $2) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; CHECK: (func $try_table (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -2975,7 +2975,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $try_table (type $3) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; OPT_O: (func $try_table (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) @@ -3009,7 +3009,7 @@ end ) - ;; CHECK: (func $try_table-params (type $2) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; CHECK: (func $try_table-params (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch i32) ;; CHECK-NEXT: (local $scratch_3 anyref) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -3058,13 +3058,13 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $try_table-params (type $3) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; OPT_O: (func $try_table-params (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (block $label0 (result eqref) ;; OPT_O-NEXT: (br $label - ;; OPT_O-NEXT: (try_table (type $2) (result i32 (ref eq)) + ;; OPT_O-NEXT: (try_table (type $3) (result i32 (ref eq)) ;; OPT_O-NEXT: (call $use-i32-any ;; OPT_O-NEXT: (local.get $0) ;; OPT_O-NEXT: (br_on_cast $label0 anyref eqref @@ -3092,7 +3092,7 @@ end ) - ;; CHECK: (func $branch-to-func (type $2) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; CHECK: (func $branch-to-func (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; CHECK-NEXT: (local $scratch anyref) ;; CHECK-NEXT: (local $scratch_3 i32) ;; CHECK-NEXT: (local $scratch_4 i32) @@ -3143,7 +3143,7 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) - ;; OPT_O: (func $branch-to-func (type $3) (param $0 i32) (param $1 anyref) (result i32 eqref) + ;; OPT_O: (func $branch-to-func (type $1) (param $0 i32) (param $1 anyref) (result i32 eqref) ;; OPT_O-NEXT: (block $label (type $0) (result i32 eqref) ;; OPT_O-NEXT: (tuple.make 2 ;; OPT_O-NEXT: (local.get $0) diff --git a/test/lit/basic/stack_switching_resume.wast b/test/lit/basic/stack_switching_resume.wast index b80e1e2fa93..10116ce31f4 100644 --- a/test/lit/basic/stack_switching_resume.wast +++ b/test/lit/basic/stack_switching_resume.wast @@ -23,14 +23,14 @@ ;; CHECK-BINARY: (type $3 (func (param (ref $ct)) (result i32))) ;; CHECK-BINARY: (tag $t (result i32)) - ;; CHECK-TEXT: (type $2 (func (result i32 (ref $ct)))) + ;; CHECK-TEXT: (type $2 (func (param (ref $ct)) (result i32))) - ;; CHECK-TEXT: (type $3 (func (param (ref $ct)) (result i32))) + ;; CHECK-TEXT: (type $3 (func (result i32 (ref $ct)))) ;; CHECK-TEXT: (tag $t (type $ft) (param i32) (result i32)) - ;; CHECK-BIN: (type $2 (func (result i32 (ref $ct)))) + ;; CHECK-BIN: (type $2 (func (param (ref $ct)) (result i32))) - ;; CHECK-BIN: (type $3 (func (param (ref $ct)) (result i32))) + ;; CHECK-BIN: (type $3 (func (result i32 (ref $ct)))) ;; CHECK-BIN: (tag $t (type $ft) (param i32) (result i32)) (tag $t (param i32) (result i32)) @@ -48,9 +48,9 @@ ;; CHECK-BINARY-NEXT: ) ;; CHECK-BINARY-NEXT: (i32.const 123) ;; CHECK-BINARY-NEXT: ) - ;; CHECK-TEXT: (func $go (type $3) (param $x (ref $ct)) (result i32) + ;; CHECK-TEXT: (func $go (type $2) (param $x (ref $ct)) (result i32) ;; CHECK-TEXT-NEXT: (tuple.extract 2 0 - ;; CHECK-TEXT-NEXT: (block $handler (type $2) (result i32 (ref $ct)) + ;; CHECK-TEXT-NEXT: (block $handler (type $3) (result i32 (ref $ct)) ;; CHECK-TEXT-NEXT: (return ;; CHECK-TEXT-NEXT: (resume $ct (on $t $handler) ;; CHECK-TEXT-NEXT: (i32.const 123) @@ -60,13 +60,13 @@ ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $go (type $3) (param $x (ref $ct)) (result i32) + ;; CHECK-BIN: (func $go (type $2) (param $x (ref $ct)) (result i32) ;; CHECK-BIN-NEXT: (local $scratch (tuple i32 (ref $ct))) ;; CHECK-BIN-NEXT: (local $scratch_2 i32) ;; CHECK-BIN-NEXT: (local.set $scratch_2 ;; CHECK-BIN-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NEXT: (local.tee $scratch - ;; CHECK-BIN-NEXT: (block $block (type $2) (result i32 (ref $ct)) + ;; CHECK-BIN-NEXT: (block $block (type $3) (result i32 (ref $ct)) ;; CHECK-BIN-NEXT: (return ;; CHECK-BIN-NEXT: (resume $ct (on $t $block) ;; CHECK-BIN-NEXT: (i32.const 123) @@ -125,19 +125,19 @@ ;; CHECK-BIN-NODEBUG: (type $1 (cont $0)) -;; CHECK-BIN-NODEBUG: (type $2 (func (result i32 (ref $1)))) +;; CHECK-BIN-NODEBUG: (type $2 (func (param (ref $1)) (result i32))) -;; CHECK-BIN-NODEBUG: (type $3 (func (param (ref $1)) (result i32))) +;; CHECK-BIN-NODEBUG: (type $3 (func (result i32 (ref $1)))) ;; CHECK-BIN-NODEBUG: (tag $tag$0 (type $0) (param i32) (result i32)) -;; CHECK-BIN-NODEBUG: (func $0 (type $3) (param $0 (ref $1)) (result i32) +;; CHECK-BIN-NODEBUG: (func $0 (type $2) (param $0 (ref $1)) (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (local $scratch (tuple i32 (ref $1))) ;; CHECK-BIN-NODEBUG-NEXT: (local $scratch_2 i32) ;; CHECK-BIN-NODEBUG-NEXT: (local.set $scratch_2 ;; CHECK-BIN-NODEBUG-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NODEBUG-NEXT: (local.tee $scratch -;; CHECK-BIN-NODEBUG-NEXT: (block $block (type $2) (result i32 (ref $1)) +;; CHECK-BIN-NODEBUG-NEXT: (block $block (type $3) (result i32 (ref $1)) ;; CHECK-BIN-NODEBUG-NEXT: (return ;; CHECK-BIN-NODEBUG-NEXT: (resume $1 (on $tag$0 $block) ;; CHECK-BIN-NODEBUG-NEXT: (i32.const 123) diff --git a/test/lit/basic/stack_switching_resume_throw.wast b/test/lit/basic/stack_switching_resume_throw.wast index 64a2ae62b6f..cc5de8ef406 100644 --- a/test/lit/basic/stack_switching_resume_throw.wast +++ b/test/lit/basic/stack_switching_resume_throw.wast @@ -17,32 +17,32 @@ ;; CHECK-BIN: (type $ct (cont $ft)) (type $ct (cont $ft)) - ;; CHECK-TEXT: (type $2 (func (result i32 (ref $ct)))) + ;; CHECK-TEXT: (type $2 (func (param i64))) - ;; CHECK-TEXT: (type $3 (func (param i64))) + ;; CHECK-TEXT: (type $3 (func (param (ref $ct)) (result i32))) - ;; CHECK-TEXT: (type $4 (func (param (ref $ct)) (result i32))) + ;; CHECK-TEXT: (type $4 (func (result i32))) - ;; CHECK-TEXT: (type $5 (func (result i32))) + ;; CHECK-TEXT: (type $5 (func (result i32 (ref $ct)))) ;; CHECK-TEXT: (tag $t (type $ft) (param i32) (result i32)) - ;; CHECK-BIN: (type $2 (func (result i32 (ref $ct)))) + ;; CHECK-BIN: (type $2 (func (param i64))) - ;; CHECK-BIN: (type $3 (func (param i64))) + ;; CHECK-BIN: (type $3 (func (param (ref $ct)) (result i32))) - ;; CHECK-BIN: (type $4 (func (param (ref $ct)) (result i32))) + ;; CHECK-BIN: (type $4 (func (result i32))) - ;; CHECK-BIN: (type $5 (func (result i32))) + ;; CHECK-BIN: (type $5 (func (result i32 (ref $ct)))) ;; CHECK-BIN: (tag $t (type $ft) (param i32) (result i32)) (tag $t (param i32) (result i32)) - ;; CHECK-TEXT: (tag $e (type $3) (param i64)) - ;; CHECK-BIN: (tag $e (type $3) (param i64)) + ;; CHECK-TEXT: (tag $e (type $2) (param i64)) + ;; CHECK-BIN: (tag $e (type $2) (param i64)) (tag $e (param i64)) - ;; CHECK-TEXT: (func $go (type $4) (param $x (ref $ct)) (result i32) + ;; CHECK-TEXT: (func $go (type $3) (param $x (ref $ct)) (result i32) ;; CHECK-TEXT-NEXT: (tuple.extract 2 0 - ;; CHECK-TEXT-NEXT: (block $handler (type $2) (result i32 (ref $ct)) + ;; CHECK-TEXT-NEXT: (block $handler (type $5) (result i32 (ref $ct)) ;; CHECK-TEXT-NEXT: (return ;; CHECK-TEXT-NEXT: (resume_throw $ct $e (on $t $handler) ;; CHECK-TEXT-NEXT: (i64.const 123) @@ -52,13 +52,13 @@ ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $go (type $4) (param $x (ref $ct)) (result i32) + ;; CHECK-BIN: (func $go (type $3) (param $x (ref $ct)) (result i32) ;; CHECK-BIN-NEXT: (local $scratch (tuple i32 (ref $ct))) ;; CHECK-BIN-NEXT: (local $scratch_2 i32) ;; CHECK-BIN-NEXT: (local.set $scratch_2 ;; CHECK-BIN-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NEXT: (local.tee $scratch - ;; CHECK-BIN-NEXT: (block $block (type $2) (result i32 (ref $ct)) + ;; CHECK-BIN-NEXT: (block $block (type $5) (result i32 (ref $ct)) ;; CHECK-BIN-NEXT: (return ;; CHECK-BIN-NEXT: (resume_throw $ct $e (on $t $block) ;; CHECK-BIN-NEXT: (i64.const 123) @@ -90,7 +90,7 @@ ) ) - ;; CHECK-TEXT: (func $unreachable (type $5) (result i32) + ;; CHECK-TEXT: (func $unreachable (type $4) (result i32) ;; CHECK-TEXT-NEXT: (block ;; (replaces unreachable ResumeThrow we can't emit) ;; CHECK-TEXT-NEXT: (drop ;; CHECK-TEXT-NEXT: (i64.const 123) @@ -101,7 +101,7 @@ ;; CHECK-TEXT-NEXT: (unreachable) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $unreachable (type $5) (result i32) + ;; CHECK-BIN: (func $unreachable (type $4) (result i32) ;; CHECK-BIN-NEXT: (drop ;; CHECK-BIN-NEXT: (i64.const 123) ;; CHECK-BIN-NEXT: ) @@ -118,25 +118,25 @@ ;; CHECK-BIN-NODEBUG: (type $1 (cont $0)) -;; CHECK-BIN-NODEBUG: (type $2 (func (result i32 (ref $1)))) +;; CHECK-BIN-NODEBUG: (type $2 (func (param i64))) -;; CHECK-BIN-NODEBUG: (type $3 (func (param i64))) +;; CHECK-BIN-NODEBUG: (type $3 (func (param (ref $1)) (result i32))) -;; CHECK-BIN-NODEBUG: (type $4 (func (param (ref $1)) (result i32))) +;; CHECK-BIN-NODEBUG: (type $4 (func (result i32))) -;; CHECK-BIN-NODEBUG: (type $5 (func (result i32))) +;; CHECK-BIN-NODEBUG: (type $5 (func (result i32 (ref $1)))) ;; CHECK-BIN-NODEBUG: (tag $tag$0 (type $0) (param i32) (result i32)) -;; CHECK-BIN-NODEBUG: (tag $tag$1 (type $3) (param i64)) +;; CHECK-BIN-NODEBUG: (tag $tag$1 (type $2) (param i64)) -;; CHECK-BIN-NODEBUG: (func $0 (type $4) (param $0 (ref $1)) (result i32) +;; CHECK-BIN-NODEBUG: (func $0 (type $3) (param $0 (ref $1)) (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (local $scratch (tuple i32 (ref $1))) ;; CHECK-BIN-NODEBUG-NEXT: (local $scratch_2 i32) ;; CHECK-BIN-NODEBUG-NEXT: (local.set $scratch_2 ;; CHECK-BIN-NODEBUG-NEXT: (tuple.extract 2 0 ;; CHECK-BIN-NODEBUG-NEXT: (local.tee $scratch -;; CHECK-BIN-NODEBUG-NEXT: (block $block (type $2) (result i32 (ref $1)) +;; CHECK-BIN-NODEBUG-NEXT: (block $block (type $5) (result i32 (ref $1)) ;; CHECK-BIN-NODEBUG-NEXT: (return ;; CHECK-BIN-NODEBUG-NEXT: (resume_throw $1 $tag$1 (on $tag$0 $block) ;; CHECK-BIN-NODEBUG-NEXT: (i64.const 123) @@ -155,7 +155,7 @@ ;; CHECK-BIN-NODEBUG-NEXT: (local.get $scratch_2) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $1 (type $5) (result i32) +;; CHECK-BIN-NODEBUG: (func $1 (type $4) (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (drop ;; CHECK-BIN-NODEBUG-NEXT: (i64.const 123) ;; CHECK-BIN-NODEBUG-NEXT: ) diff --git a/test/lit/basic/types-function-references.wast b/test/lit/basic/types-function-references.wast index 8997e1a3af0..dfff790bc18 100644 --- a/test/lit/basic/types-function-references.wast +++ b/test/lit/basic/types-function-references.wast @@ -10,10 +10,10 @@ ;; RUN: cat %t.bin.nodebug.wast | filecheck %s --check-prefix=CHECK-BIN-NODEBUG (module - ;; CHECK-TEXT: (type $mixed_results (func (result anyref f32 anyref f32))) - ;; CHECK-TEXT: (type $i32-i32 (func (param i32) (result i32))) + ;; CHECK-TEXT: (type $mixed_results (func (result anyref f32 anyref f32))) + ;; CHECK-TEXT: (type $void (func)) ;; CHECK-BIN: (type $mixed_results (func (result anyref f32 anyref f32))) @@ -22,26 +22,22 @@ ;; CHECK-BIN: (type $void (func)) (type $void (func)) ;; inline ref type in result - ;; CHECK-TEXT: (type $3 (func (result i32 (ref null $mixed_results) f64))) - ;; CHECK-TEXT: (type $_=>_eqref (func (result eqref))) - ;; CHECK-BIN: (type $3 (func (result i32 (ref null $mixed_results) f64))) - ;; CHECK-BIN: (type $_=>_eqref (func (result eqref))) (type $_=>_eqref (func (result eqref))) - ;; CHECK-TEXT: (type $5 (func (param (ref $i32-i32)) (result i32))) + ;; CHECK-TEXT: (type $4 (func (param (ref $i32-i32)) (result i32))) - ;; CHECK-TEXT: (type $6 (func (param (ref null $i32-i32)) (result i32))) + ;; CHECK-TEXT: (type $5 (func (param (ref null $i32-i32)) (result i32))) - ;; CHECK-TEXT: (type $7 (func (result i32))) + ;; CHECK-TEXT: (type $6 (func (result i32))) ;; CHECK-TEXT: (type $f64_=>_ref_null<_->_eqref> (func (param f64) (result (ref null $_=>_eqref)))) - ;; CHECK-BIN: (type $5 (func (param (ref $i32-i32)) (result i32))) + ;; CHECK-BIN: (type $4 (func (param (ref $i32-i32)) (result i32))) - ;; CHECK-BIN: (type $6 (func (param (ref null $i32-i32)) (result i32))) + ;; CHECK-BIN: (type $5 (func (param (ref null $i32-i32)) (result i32))) - ;; CHECK-BIN: (type $7 (func (result i32))) + ;; CHECK-BIN: (type $6 (func (result i32))) ;; CHECK-BIN: (type $f64_=>_ref_null<_->_eqref> (func (param f64) (result (ref null $_=>_eqref)))) (type $f64_=>_ref_null<_->_eqref> (func (param f64) (result (ref null $_=>_eqref)))) @@ -52,7 +48,9 @@ (type $mixed_results (func (result anyref f32 anyref f32))) (type $i32-i32 (func (param i32) (result i32))) - ;; CHECK-TEXT: (type $10 (func (param (ref null $mixed_results)))) + ;; CHECK-TEXT: (type $9 (func (param (ref null $mixed_results)))) + + ;; CHECK-TEXT: (type $10 (func (result i32 (ref null $mixed_results) f64))) ;; CHECK-TEXT: (elem declare func $call-ref $call-ref-more) @@ -61,7 +59,9 @@ ;; CHECK-TEXT-NEXT: (ref.func $call-ref) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (type $10 (func (param (ref null $mixed_results)))) + ;; CHECK-BIN: (type $9 (func (param (ref null $mixed_results)))) + + ;; CHECK-BIN: (type $10 (func (result i32 (ref null $mixed_results) f64))) ;; CHECK-BIN: (elem declare func $call-ref $call-ref-more) @@ -104,13 +104,13 @@ (call_ref $i32-i32 (i32.const 42) (ref.func $call-ref-more)) ) - ;; CHECK-TEXT: (func $call_from-param (type $5) (param $f (ref $i32-i32)) (result i32) + ;; CHECK-TEXT: (func $call_from-param (type $4) (param $f (ref $i32-i32)) (result i32) ;; CHECK-TEXT-NEXT: (call_ref $i32-i32 ;; CHECK-TEXT-NEXT: (i32.const 42) ;; CHECK-TEXT-NEXT: (local.get $f) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $call_from-param (type $5) (param $f (ref $i32-i32)) (result i32) + ;; CHECK-BIN: (func $call_from-param (type $4) (param $f (ref $i32-i32)) (result i32) ;; CHECK-BIN-NEXT: (call_ref $i32-i32 ;; CHECK-BIN-NEXT: (i32.const 42) ;; CHECK-BIN-NEXT: (local.get $f) @@ -120,13 +120,13 @@ (call_ref $i32-i32 (i32.const 42) (local.get $f)) ) - ;; CHECK-TEXT: (func $call_from-param-null (type $6) (param $f (ref null $i32-i32)) (result i32) + ;; CHECK-TEXT: (func $call_from-param-null (type $5) (param $f (ref null $i32-i32)) (result i32) ;; CHECK-TEXT-NEXT: (call_ref $i32-i32 ;; CHECK-TEXT-NEXT: (i32.const 42) ;; CHECK-TEXT-NEXT: (local.get $f) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $call_from-param-null (type $6) (param $f (ref null $i32-i32)) (result i32) + ;; CHECK-BIN: (func $call_from-param-null (type $5) (param $f (ref null $i32-i32)) (result i32) ;; CHECK-BIN-NEXT: (call_ref $i32-i32 ;; CHECK-BIN-NEXT: (i32.const 42) ;; CHECK-BIN-NEXT: (local.get $f) @@ -136,7 +136,7 @@ (call_ref $i32-i32 (i32.const 42) (local.get $f)) ) - ;; CHECK-TEXT: (func $call_from-local-null (type $7) (result i32) + ;; CHECK-TEXT: (func $call_from-local-null (type $6) (result i32) ;; CHECK-TEXT-NEXT: (local $f (ref null $i32-i32)) ;; CHECK-TEXT-NEXT: (local.set $f ;; CHECK-TEXT-NEXT: (ref.func $call-ref-more) @@ -146,7 +146,7 @@ ;; CHECK-TEXT-NEXT: (local.get $f) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $call_from-local-null (type $7) (result i32) + ;; CHECK-BIN: (func $call_from-local-null (type $6) (result i32) ;; CHECK-BIN-NEXT: (local $f (ref null $i32-i32)) ;; CHECK-BIN-NEXT: (local.set $f ;; CHECK-BIN-NEXT: (ref.func $call-ref-more) @@ -186,7 +186,7 @@ ;; CHECK-TEXT: (func $type-only-in-tuple-block (type $void) ;; CHECK-TEXT-NEXT: (tuple.drop 3 - ;; CHECK-TEXT-NEXT: (block $block (type $3) (result i32 (ref null $mixed_results) f64) + ;; CHECK-TEXT-NEXT: (block $block (type $10) (result i32 (ref null $mixed_results) f64) ;; CHECK-TEXT-NEXT: (unreachable) ;; CHECK-TEXT-NEXT: ) ;; CHECK-TEXT-NEXT: ) @@ -200,7 +200,7 @@ ;; CHECK-BIN-NEXT: (local.set $scratch_2 ;; CHECK-BIN-NEXT: (tuple.extract 3 0 ;; CHECK-BIN-NEXT: (local.tee $scratch - ;; CHECK-BIN-NEXT: (block (type $3) (result i32 (ref null $mixed_results) f64) + ;; CHECK-BIN-NEXT: (block (type $10) (result i32 (ref null $mixed_results) f64) ;; CHECK-BIN-NEXT: (unreachable) ;; CHECK-BIN-NEXT: ) ;; CHECK-BIN-NEXT: ) @@ -307,7 +307,7 @@ (local $r6 funcref) ) - ;; CHECK-TEXT: (func $mvp-types-first-param (type $10) (param $r0 (ref null $mixed_results)) + ;; CHECK-TEXT: (func $mvp-types-first-param (type $9) (param $r0 (ref null $mixed_results)) ;; CHECK-TEXT-NEXT: (local $i1 i32) ;; CHECK-TEXT-NEXT: (local $r1 (ref null $mixed_results)) ;; CHECK-TEXT-NEXT: (local $r2 (ref null $mixed_results)) @@ -318,7 +318,7 @@ ;; CHECK-TEXT-NEXT: (local $r5 anyref) ;; CHECK-TEXT-NEXT: (local $r6 funcref) ;; CHECK-TEXT-NEXT: ) - ;; CHECK-BIN: (func $mvp-types-first-param (type $10) (param $r0 (ref null $mixed_results)) + ;; CHECK-BIN: (func $mvp-types-first-param (type $9) (param $r0 (ref null $mixed_results)) ;; CHECK-BIN-NEXT: (local $i1 i32) ;; CHECK-BIN-NEXT: (local $i2 i64) ;; CHECK-BIN-NEXT: (local $i3 i64) @@ -349,21 +349,21 @@ ;; CHECK-BIN-NODEBUG: (type $2 (func)) -;; CHECK-BIN-NODEBUG: (type $3 (func (result i32 (ref null $0) f64))) +;; CHECK-BIN-NODEBUG: (type $3 (func (result eqref))) -;; CHECK-BIN-NODEBUG: (type $4 (func (result eqref))) +;; CHECK-BIN-NODEBUG: (type $4 (func (param (ref $1)) (result i32))) -;; CHECK-BIN-NODEBUG: (type $5 (func (param (ref $1)) (result i32))) +;; CHECK-BIN-NODEBUG: (type $5 (func (param (ref null $1)) (result i32))) -;; CHECK-BIN-NODEBUG: (type $6 (func (param (ref null $1)) (result i32))) +;; CHECK-BIN-NODEBUG: (type $6 (func (result i32))) -;; CHECK-BIN-NODEBUG: (type $7 (func (result i32))) +;; CHECK-BIN-NODEBUG: (type $7 (func (param f64) (result (ref null $3)))) -;; CHECK-BIN-NODEBUG: (type $8 (func (param f64) (result (ref null $4)))) +;; CHECK-BIN-NODEBUG: (type $8 (func (result anyref))) -;; CHECK-BIN-NODEBUG: (type $9 (func (result anyref))) +;; CHECK-BIN-NODEBUG: (type $9 (func (param (ref null $0)))) -;; CHECK-BIN-NODEBUG: (type $10 (func (param (ref null $0)))) +;; CHECK-BIN-NODEBUG: (type $10 (func (result i32 (ref null $0) f64))) ;; CHECK-BIN-NODEBUG: (elem declare func $0 $2) @@ -386,21 +386,21 @@ ;; CHECK-BIN-NODEBUG-NEXT: ) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $3 (type $5) (param $0 (ref $1)) (result i32) +;; CHECK-BIN-NODEBUG: (func $3 (type $4) (param $0 (ref $1)) (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (call_ref $1 ;; CHECK-BIN-NODEBUG-NEXT: (i32.const 42) ;; CHECK-BIN-NODEBUG-NEXT: (local.get $0) ;; CHECK-BIN-NODEBUG-NEXT: ) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $4 (type $6) (param $0 (ref null $1)) (result i32) +;; CHECK-BIN-NODEBUG: (func $4 (type $5) (param $0 (ref null $1)) (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (call_ref $1 ;; CHECK-BIN-NODEBUG-NEXT: (i32.const 42) ;; CHECK-BIN-NODEBUG-NEXT: (local.get $0) ;; CHECK-BIN-NODEBUG-NEXT: ) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $5 (type $7) (result i32) +;; CHECK-BIN-NODEBUG: (func $5 (type $6) (result i32) ;; CHECK-BIN-NODEBUG-NEXT: (local $0 (ref null $1)) ;; CHECK-BIN-NODEBUG-NEXT: (local.set $0 ;; CHECK-BIN-NODEBUG-NEXT: (ref.func $2) @@ -411,14 +411,14 @@ ;; CHECK-BIN-NODEBUG-NEXT: ) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $6 (type $8) (param $0 f64) (result (ref null $4)) +;; CHECK-BIN-NODEBUG: (func $6 (type $7) (param $0 f64) (result (ref null $3)) ;; CHECK-BIN-NODEBUG-NEXT: (ref.null nofunc) ;; CHECK-BIN-NODEBUG-NEXT: ) ;; CHECK-BIN-NODEBUG: (func $7 (type $2) ;; CHECK-BIN-NODEBUG-NEXT: (local $0 i32) ;; CHECK-BIN-NODEBUG-NEXT: (local $1 f64) -;; CHECK-BIN-NODEBUG-NEXT: (local $2 (ref null $9)) +;; CHECK-BIN-NODEBUG-NEXT: (local $2 (ref null $8)) ;; CHECK-BIN-NODEBUG-NEXT: ) ;; CHECK-BIN-NODEBUG: (func $8 (type $2) @@ -430,7 +430,7 @@ ;; CHECK-BIN-NODEBUG-NEXT: (local.set $scratch_2 ;; CHECK-BIN-NODEBUG-NEXT: (tuple.extract 3 0 ;; CHECK-BIN-NODEBUG-NEXT: (local.tee $scratch -;; CHECK-BIN-NODEBUG-NEXT: (block (type $3) (result i32 (ref null $0) f64) +;; CHECK-BIN-NODEBUG-NEXT: (block (type $10) (result i32 (ref null $0) f64) ;; CHECK-BIN-NODEBUG-NEXT: (unreachable) ;; CHECK-BIN-NODEBUG-NEXT: ) ;; CHECK-BIN-NODEBUG-NEXT: ) @@ -480,7 +480,7 @@ ;; CHECK-BIN-NODEBUG-NEXT: (local $8 funcref) ;; CHECK-BIN-NODEBUG-NEXT: ) -;; CHECK-BIN-NODEBUG: (func $11 (type $10) (param $0 (ref null $0)) +;; CHECK-BIN-NODEBUG: (func $11 (type $9) (param $0 (ref null $0)) ;; CHECK-BIN-NODEBUG-NEXT: (local $1 i32) ;; CHECK-BIN-NODEBUG-NEXT: (local $2 i64) ;; CHECK-BIN-NODEBUG-NEXT: (local $3 i64) diff --git a/test/lit/br_if_cont_uncastable.wast b/test/lit/br_if_cont_uncastable.wast index 7b323426126..b33b99989a7 100644 --- a/test/lit/br_if_cont_uncastable.wast +++ b/test/lit/br_if_cont_uncastable.wast @@ -21,7 +21,7 @@ (nop) ) - ;; CHECK: (func $br_if_gc (type $4) (param $ref (ref any)) (result anyref) + ;; CHECK: (func $br_if_gc (type $3) (param $ref (ref any)) (result anyref) ;; CHECK-NEXT: (block $block (result anyref) ;; CHECK-NEXT: (call $receive_any ;; CHECK-NEXT: (ref.cast (ref any) @@ -47,7 +47,7 @@ ) ) - ;; CHECK: (func $br_if_cont (type $5) (result contref) + ;; CHECK: (func $br_if_cont (type $4) (result contref) ;; CHECK-NEXT: (local $0 (ref (exact $cont))) ;; CHECK-NEXT: (local $1 i32) ;; CHECK-NEXT: (local $scratch (ref (exact $cont))) @@ -93,19 +93,19 @@ ) ) - ;; CHECK: (func $receive_any (type $6) (param $0 (ref any)) + ;; CHECK: (func $receive_any (type $5) (param $0 (ref any)) ;; CHECK-NEXT: ) (func $receive_any (param (ref any)) ) - ;; CHECK: (func $receive_cont (type $7) (param $0 (ref $cont)) + ;; CHECK: (func $receive_cont (type $6) (param $0 (ref $cont)) ;; CHECK-NEXT: ) (func $receive_cont (param (ref $cont)) ) ;; As above, but with tuples. - ;; CHECK: (func $br_if_gc_tuple (type $8) (param $ref (ref any)) (result anyref i32) + ;; CHECK: (func $br_if_gc_tuple (type $7) (param $ref (ref any)) (result anyref i32) ;; CHECK-NEXT: (local $1 (ref any)) ;; CHECK-NEXT: (local $2 i32) ;; CHECK-NEXT: (local $3 i32) @@ -113,7 +113,7 @@ ;; CHECK-NEXT: (local $scratch_5 (ref any)) ;; CHECK-NEXT: (local $scratch_6 (tuple (ref any) i32)) ;; CHECK-NEXT: (local $scratch_7 (ref any)) - ;; CHECK-NEXT: (block $block (type $3) (result anyref i32) + ;; CHECK-NEXT: (block $block (type $8) (result anyref i32) ;; CHECK-NEXT: (local.set $1 ;; CHECK-NEXT: (block (result (ref any)) ;; CHECK-NEXT: (local.set $scratch_5 diff --git a/test/lit/cast-and-recast-tuple.wast b/test/lit/cast-and-recast-tuple.wast index 5bc4b19ccfe..be07847f43c 100644 --- a/test/lit/cast-and-recast-tuple.wast +++ b/test/lit/cast-and-recast-tuple.wast @@ -16,10 +16,10 @@ (type $B (sub $A (struct))) ) - ;; CHECK: (func $test-local-tuple-1 (type $3) (param $B (ref $B)) (param $x i32) (result anyref i32) + ;; CHECK: (func $test-local-tuple-1 (type $2) (param $B (ref $B)) (param $x i32) (result anyref i32) ;; CHECK-NEXT: (local $scratch (tuple (ref $B) i32)) ;; CHECK-NEXT: (local $scratch_3 (ref $B)) - ;; CHECK-NEXT: (block $block (type $2) (result (ref $A) i32) + ;; CHECK-NEXT: (block $block (type $3) (result (ref $A) i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result (ref $B)) ;; CHECK-NEXT: (local.set $scratch_3 @@ -65,12 +65,12 @@ ) ) - ;; CHECK: (func $test-local-tuple-2 (type $7) (param $B (ref $B)) (param $x i32) (result i32 i32) + ;; CHECK: (func $test-local-tuple-2 (type $4) (param $B (ref $B)) (param $x i32) (result i32 i32) ;; CHECK-NEXT: (local $temp i32) ;; CHECK-NEXT: (local $3 i32) ;; CHECK-NEXT: (local $scratch (tuple i32 i32)) ;; CHECK-NEXT: (local $scratch_5 i32) - ;; CHECK-NEXT: (block $block (type $4) (result i32 i32) + ;; CHECK-NEXT: (block $block (type $6) (result i32 i32) ;; CHECK-NEXT: (local.set $temp ;; CHECK-NEXT: (block (result i32) ;; CHECK-NEXT: (local.set $scratch_5 @@ -115,12 +115,12 @@ ) ) - ;; CHECK: (func $test-local-tuple-3 (type $3) (param $B (ref $B)) (param $x i32) (result anyref i32) + ;; CHECK: (func $test-local-tuple-3 (type $2) (param $B (ref $B)) (param $x i32) (result anyref i32) ;; CHECK-NEXT: (local $temp (ref $B)) ;; CHECK-NEXT: (local $3 i32) ;; CHECK-NEXT: (local $scratch (tuple (ref $B) i32)) ;; CHECK-NEXT: (local $scratch_5 (ref $B)) - ;; CHECK-NEXT: (block $block (type $5) (result (ref $B) i32) + ;; CHECK-NEXT: (block $block (type $7) (result (ref $B) i32) ;; CHECK-NEXT: (local.set $temp ;; CHECK-NEXT: (block (result (ref $B)) ;; CHECK-NEXT: (local.set $scratch_5 @@ -165,7 +165,7 @@ ) ) - ;; CHECK: (func $test-local-tuple-4-bad (type $3) (param $B (ref $B)) (param $x i32) (result anyref i32) + ;; CHECK: (func $test-local-tuple-4-bad (type $2) (param $B (ref $B)) (param $x i32) (result anyref i32) ;; CHECK-NEXT: (local $temp (ref $B)) ;; CHECK-NEXT: (local $3 (ref $B)) ;; CHECK-NEXT: (local $4 i32) @@ -176,7 +176,7 @@ ;; CHECK-NEXT: (local $scratch_9 (tuple (ref $B) i32)) ;; CHECK-NEXT: (local $scratch_10 (ref $B)) ;; CHECK-NEXT: (local $scratch_11 (ref $B)) - ;; CHECK-NEXT: (block $block (type $2) (result (ref $A) i32) + ;; CHECK-NEXT: (block $block (type $3) (result (ref $A) i32) ;; CHECK-NEXT: (local.set $3 ;; CHECK-NEXT: (block (result (ref $B)) ;; CHECK-NEXT: (local.set $scratch_8 @@ -256,7 +256,7 @@ ) ) - ;; CHECK: (func $test-local-tuple-4-bad-dupes (type $8) (param $B (ref $B)) (param $x i32) (result i32 anyref i32) + ;; CHECK: (func $test-local-tuple-4-bad-dupes (type $5) (param $B (ref $B)) (param $x i32) (result i32 anyref i32) ;; CHECK-NEXT: (local $temp (ref $B)) ;; CHECK-NEXT: (local $3 (ref $B)) ;; CHECK-NEXT: (local $4 (ref $B)) @@ -275,7 +275,7 @@ ;; CHECK-NEXT: (local $scratch_17 (ref $B)) ;; CHECK-NEXT: (local $scratch_18 i32) ;; CHECK-NEXT: (local $scratch_19 (ref $B)) - ;; CHECK-NEXT: (block $block (type $6) (result i32 (ref $A) i32) + ;; CHECK-NEXT: (block $block (type $8) (result i32 (ref $A) i32) ;; CHECK-NEXT: (local.set $10 ;; CHECK-NEXT: (block (result i32) ;; CHECK-NEXT: (local.set $scratch_13 diff --git a/test/lit/passes/O3_stack-switching.wast b/test/lit/passes/O3_stack-switching.wast index d928f6614b2..f69c4a04276 100644 --- a/test/lit/passes/O3_stack-switching.wast +++ b/test/lit/passes/O3_stack-switching.wast @@ -19,12 +19,12 @@ (type $cont (cont $function_1)) ;; CHECK: (type $fiber (struct (field $handlers (ref $handlers)) (field $cont (ref $cont)))) (type $fiber (struct (field $handlers (ref $handlers)) (field $cont (ref $cont)))) - ;; CHECK: (tag $exception (type $8) (param (ref eq))) + ;; CHECK: (tag $exception (type $7) (param (ref eq))) (tag $exception (param (ref eq))) - ;; CHECK: (tag $effect (type $9) (param (ref eq)) (result (ref eq) (ref eq))) + ;; CHECK: (tag $effect (type $8) (param (ref eq)) (result (ref eq) (ref eq))) (tag $effect (param (ref eq)) (result (ref eq) (ref eq))) - ;; CHECK: (func $resume (type $10) (param $0 (ref $fiber)) (param $1 (ref $closure)) (param $2 (ref eq)) (result (ref eq)) + ;; CHECK: (func $resume (type $9) (param $0 (ref $fiber)) (param $1 (ref $closure)) (param $2 (ref eq)) (result (ref eq)) ;; CHECK-NEXT: (local $3 (tuple (ref eq) (ref $cont))) ;; CHECK-NEXT: (local $4 (ref $handlers)) ;; CHECK-NEXT: (local $5 (ref $closure_2)) @@ -33,7 +33,7 @@ ;; CHECK-NEXT: (return_call_ref $function_2 ;; CHECK-NEXT: (tuple.extract 2 0 ;; CHECK-NEXT: (local.tee $3 - ;; CHECK-NEXT: (block $handle_effect (type $7) (result (ref eq) (ref $cont)) + ;; CHECK-NEXT: (block $handle_effect (type $10) (result (ref eq) (ref $cont)) ;; CHECK-NEXT: (return_call_ref $function_1 ;; CHECK-NEXT: (try_table (result (ref eq)) (catch $exception $handle_exception) ;; CHECK-NEXT: (resume $cont (on $effect $handle_effect) diff --git a/test/lit/passes/coalesce-locals-gc.wast b/test/lit/passes/coalesce-locals-gc.wast index 59232d1b4a5..5f7b2cf5f8e 100644 --- a/test/lit/passes/coalesce-locals-gc.wast +++ b/test/lit/passes/coalesce-locals-gc.wast @@ -25,7 +25,7 @@ (global $nn-tuple-global (mut (tuple (ref any) i32)) (tuple.make 2 (ref.i31 (i32.const 0)) (i32.const 1))) - ;; CHECK: (func $test-dead-get-non-nullable (type $7) (param $0 (ref struct)) + ;; CHECK: (func $test-dead-get-non-nullable (type $6) (param $0 (ref struct)) ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result (ref struct)) @@ -43,7 +43,7 @@ ) ) - ;; CHECK: (func $br_on_null (type $8) (param $0 (ref null $array)) (result (ref null $array)) + ;; CHECK: (func $br_on_null (type $7) (param $0 (ref null $array)) (result (ref null $array)) ;; CHECK-NEXT: (block $label$1 (result (ref null $array)) ;; CHECK-NEXT: (block $label$2 ;; CHECK-NEXT: (br $label$1 @@ -79,7 +79,7 @@ ) ) - ;; CHECK: (func $nn-dead (type $3) + ;; CHECK: (func $nn-dead (type $2) ;; CHECK-NEXT: (local $0 funcref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.func $nn-dead) @@ -118,7 +118,7 @@ ) ) - ;; CHECK: (func $nn-dead-nameless (type $3) + ;; CHECK: (func $nn-dead-nameless (type $2) ;; CHECK-NEXT: (local $0 (ref func)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (ref.func $nn-dead) @@ -149,7 +149,7 @@ ) ) - ;; CHECK: (func $unreachable-get-null (type $3) + ;; CHECK: (func $unreachable-get-null (type $2) ;; CHECK-NEXT: (local $0 anyref) ;; CHECK-NEXT: (local $1 i31ref) ;; CHECK-NEXT: (unreachable) @@ -178,12 +178,12 @@ ) ) - ;; CHECK: (func $unreachable-get-tuple (type $3) + ;; CHECK: (func $unreachable-get-tuple (type $2) ;; CHECK-NEXT: (local $0 (tuple anyref i32)) ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (tuple.extract 2 0 - ;; CHECK-NEXT: (block (type $6) (result anyref i32) + ;; CHECK-NEXT: (block (type $11) (result anyref i32) ;; CHECK-NEXT: (tuple.make 2 ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: (i32.const 0) @@ -242,7 +242,7 @@ ) ) - ;; CHECK: (func $replace-i31-local (type $9) (result i32) + ;; CHECK: (func $replace-i31-local (type $8) (result i32) ;; CHECK-NEXT: (local $0 i31ref) ;; CHECK-NEXT: (i32.add ;; CHECK-NEXT: (unreachable) @@ -272,7 +272,7 @@ ) ) - ;; CHECK: (func $replace-struct-param (type $10) (param $0 f64) (param $1 (ref null $A)) (result f32) + ;; CHECK: (func $replace-struct-param (type $9) (param $0 f64) (param $1 (ref null $A)) (result f32) ;; CHECK-NEXT: (call $replace-struct-param ;; CHECK-NEXT: (block (result f64) ;; CHECK-NEXT: (unreachable) @@ -300,7 +300,7 @@ ) ) - ;; CHECK: (func $test (type $11) (param $0 (ref any)) (result (ref any) i32) + ;; CHECK: (func $test (type $10) (param $0 (ref any)) (result (ref any) i32) ;; CHECK-NEXT: (local $1 (tuple anyref i32)) ;; CHECK-NEXT: (tuple.drop 2 ;; CHECK-NEXT: (tuple.make 2 @@ -328,9 +328,9 @@ ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (global.set $nn-tuple-global - ;; CHECK-NEXT: (block (type $1) (result (ref any) i32) + ;; CHECK-NEXT: (block (type $4) (result (ref any) i32) ;; CHECK-NEXT: (local.set $1 - ;; CHECK-NEXT: (if (type $1) (result (ref any) i32) + ;; CHECK-NEXT: (if (type $4) (result (ref any) i32) ;; CHECK-NEXT: (i32.const 0) ;; CHECK-NEXT: (then ;; CHECK-NEXT: (tuple.make 2 diff --git a/test/lit/passes/dae-typessa-repeat-types.wast b/test/lit/passes/dae-typessa-repeat-types.wast index d03e7e1a1f1..7072d215cac 100644 --- a/test/lit/passes/dae-typessa-repeat-types.wast +++ b/test/lit/passes/dae-typessa-repeat-types.wast @@ -5,13 +5,13 @@ ;; CHECK: (type $struct (struct)) (type $struct (struct)) - ;; CHECK: (type $1 (func (result i32 (ref (exact $struct))))) - ;; CHECK: (type $array (sub (array (mut i32)))) (type $array (sub (array (mut i32)))) ;; Trigger TypeSSA - ;; CHECK: (type $3 (func)) + ;; CHECK: (type $2 (func)) + + ;; CHECK: (type $3 (func (result i32 (ref (exact $struct))))) ;; CHECK: (type $array_1 (sub $array (array (mut i32)))) @@ -28,7 +28,7 @@ ) ) - ;; CHECK: (func $caller (type $3) + ;; CHECK: (func $caller (type $2) ;; CHECK-NEXT: (call $callee) ;; CHECK-NEXT: ) (func $caller @@ -40,14 +40,14 @@ ) ) - ;; CHECK: (func $callee (type $3) + ;; CHECK: (func $callee (type $2) ;; CHECK-NEXT: (local $0 anyref) ;; CHECK-NEXT: (tuple.drop 2 - ;; CHECK-NEXT: (block (type $1) (result i32 (ref (exact $struct))) + ;; CHECK-NEXT: (block (type $3) (result i32 (ref (exact $struct))) ;; CHECK-NEXT: (local.set $0 ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (block (type $1) (result i32 (ref (exact $struct))) + ;; CHECK-NEXT: (block (type $3) (result i32 (ref (exact $struct))) ;; CHECK-NEXT: (tuple.make 2 ;; CHECK-NEXT: (i32.const 0) ;; CHECK-NEXT: (struct.new_default $struct) diff --git a/test/lit/passes/gufa-cast-all.wast b/test/lit/passes/gufa-cast-all.wast index 812ba58f7f2..28248674883 100644 --- a/test/lit/passes/gufa-cast-all.wast +++ b/test/lit/passes/gufa-cast-all.wast @@ -191,18 +191,18 @@ ;; As above, but with an exported tag. Also test a tag with multiple params. (module - ;; CHECK: (type $0 (func (result i32 f64))) + ;; CHECK: (type $0 (func (param i32 f64))) - ;; CHECK: (type $1 (func (param i32 f64))) + ;; CHECK: (type $1 (func (param i32))) - ;; CHECK: (type $2 (func (param i32))) + ;; CHECK: (type $2 (func)) - ;; CHECK: (type $3 (func)) + ;; CHECK: (type $3 (func (result i32 f64))) - ;; CHECK: (import "fuzzing-support" "throw" (func $throw (type $2) (param i32))) + ;; CHECK: (import "fuzzing-support" "throw" (func $throw (type $1) (param i32))) (import "fuzzing-support" "throw" (func $throw (param i32))) - ;; CHECK: (tag $tag (type $1) (param i32 f64)) + ;; CHECK: (tag $tag (type $0) (param i32 f64)) (tag $tag (param i32 f64)) ;; CHECK: (export "func" (func $func)) @@ -210,9 +210,9 @@ ;; CHECK: (export "tag" (tag $tag)) (export "tag" (tag $tag)) - ;; CHECK: (func $func (type $3) + ;; CHECK: (func $func (type $2) ;; CHECK-NEXT: (tuple.drop 2 - ;; CHECK-NEXT: (block $block (type $0) (result i32 f64) + ;; CHECK-NEXT: (block $block (type $3) (result i32 f64) ;; CHECK-NEXT: (try_table (catch $tag $block) ;; CHECK-NEXT: (call $throw ;; CHECK-NEXT: (i32.const 1) diff --git a/test/lit/passes/gufa-refs.wast b/test/lit/passes/gufa-refs.wast index 0166bdae678..9907fd90c23 100644 --- a/test/lit/passes/gufa-refs.wast +++ b/test/lit/passes/gufa-refs.wast @@ -6056,17 +6056,17 @@ ) (module - ;; CHECK: (type $0 (func (result i64 nullref i32))) - ;; CHECK: (type $array (sub (array (mut i8)))) (type $array (sub (array (mut i8)))) - ;; CHECK: (type $2 (func)) + ;; CHECK: (type $1 (func)) + + ;; CHECK: (type $2 (func (result i64 nullref i32))) ;; CHECK: (global $global (ref null $array) (array.new_fixed $array 0)) (global $global (ref null $array) (array.new_fixed $array 0)) - ;; CHECK: (func $test-set-bottom (type $2) + ;; CHECK: (func $test-set-bottom (type $1) ;; CHECK-NEXT: (block ;; (replaces unreachable ArraySet we can't emit) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block (result nullref) @@ -6099,9 +6099,9 @@ ) ) - ;; CHECK: (func $loop-tuple-br_on (type $2) + ;; CHECK: (func $loop-tuple-br_on (type $1) ;; CHECK-NEXT: (tuple.drop 3 - ;; CHECK-NEXT: (loop $loop (type $0) (result i64 nullref i32) + ;; CHECK-NEXT: (loop $loop (type $2) (result i64 nullref i32) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block ;; CHECK-NEXT: (drop diff --git a/test/lit/passes/merge-blocks-eh.wast b/test/lit/passes/merge-blocks-eh.wast index 75fecd532db..df1ba0c826d 100644 --- a/test/lit/passes/merge-blocks-eh.wast +++ b/test/lit/passes/merge-blocks-eh.wast @@ -8,10 +8,10 @@ ;; CHECK: (tag $empty (type $0)) (tag $empty) - ;; CHECK: (tag $i32 (type $3) (param i32)) + ;; CHECK: (tag $i32 (type $1) (param i32)) (tag $i32 (param i32)) - ;; CHECK: (tag $exnref (type $4) (param exnref)) + ;; CHECK: (tag $exnref (type $2) (param exnref)) (tag $exnref (param exnref)) ;; CHECK: (func $drop-block-try_catch_all_ref (type $0) @@ -78,7 +78,7 @@ ;; CHECK: (func $drop-block-try_catch_all_i32 (type $0) ;; CHECK-NEXT: (tuple.drop 2 - ;; CHECK-NEXT: (block $catch (type $1) (result i32 exnref) + ;; CHECK-NEXT: (block $catch (type $3) (result i32 exnref) ;; CHECK-NEXT: (try_table (catch_ref $i32 $catch) ;; CHECK-NEXT: (call $import) ;; CHECK-NEXT: (unreachable) @@ -100,7 +100,7 @@ ;; CHECK: (func $drop-block-try_catch_multi_partial (type $0) ;; CHECK-NEXT: (tuple.drop 2 - ;; CHECK-NEXT: (block $outer (type $2) (result i32 (ref exn)) + ;; CHECK-NEXT: (block $outer (type $4) (result i32 (ref exn)) ;; CHECK-NEXT: (block $inner ;; CHECK-NEXT: (try_table (catch_ref $i32 $outer) (catch_all $inner) ;; CHECK-NEXT: (call $import) diff --git a/test/lit/passes/precompute-gc.wast b/test/lit/passes/precompute-gc.wast index e07dfd398e6..6f5b1af41b3 100644 --- a/test/lit/passes/precompute-gc.wast +++ b/test/lit/passes/precompute-gc.wast @@ -245,7 +245,7 @@ (struct.get $struct 0 (local.get $x)) ) ) - ;; CHECK: (func $ref-comparisons (type $13) (param $x (ref null $struct)) (param $y (ref null $struct)) + ;; CHECK: (func $ref-comparisons (type $12) (param $x (ref null $struct)) (param $y (ref null $struct)) ;; CHECK-NEXT: (local $z (ref null $struct)) ;; CHECK-NEXT: (local $w (ref null $struct)) ;; CHECK-NEXT: (call $log @@ -425,7 +425,7 @@ (local.get $tempresult) ) - ;; CHECK: (func $propagate-different-params (type $14) (param $input1 (ref $empty)) (param $input2 (ref $empty)) (result i32) + ;; CHECK: (func $propagate-different-params (type $13) (param $input1 (ref $empty)) (param $input2 (ref $empty)) (result i32) ;; CHECK-NEXT: (local $tempresult i32) ;; CHECK-NEXT: (local.set $tempresult ;; CHECK-NEXT: (ref.eq @@ -749,7 +749,7 @@ ) ) - ;; CHECK: (func $helper (type $15) (param $0 i32) (result i32) + ;; CHECK: (func $helper (type $14) (param $0 i32) (result i32) ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) (func $helper (param i32) (result i32) @@ -827,14 +827,14 @@ ) ) - ;; CHECK: (func $receive-f64 (type $16) (param $0 f64) + ;; CHECK: (func $receive-f64 (type $15) (param $0 f64) ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) (func $receive-f64 (param f64) (unreachable) ) - ;; CHECK: (func $odd-cast-and-get-non-null (type $17) (param $temp (ref $func-return-i32)) + ;; CHECK: (func $odd-cast-and-get-non-null (type $16) (param $temp (ref $func-return-i32)) ;; CHECK-NEXT: (local.set $temp ;; CHECK-NEXT: (ref.cast (ref nofunc) ;; CHECK-NEXT: (ref.func $receive-f64) @@ -883,7 +883,7 @@ ) ) - ;; CHECK: (func $br_on_cast-on-creation (type $18) (result (ref $empty)) + ;; CHECK: (func $br_on_cast-on-creation (type $17) (result (ref $empty)) ;; CHECK-NEXT: (block $label (result (ref (exact $empty))) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (br_on_cast $label (ref (exact $empty)) (ref (exact $empty)) @@ -982,7 +982,7 @@ ) ) - ;; CHECK: (func $remove-set (type $19) (result (ref func)) + ;; CHECK: (func $remove-set (type $18) (result (ref func)) ;; CHECK-NEXT: (local $nn funcref) ;; CHECK-NEXT: (local $i i32) ;; CHECK-NEXT: (loop $loop @@ -1025,7 +1025,7 @@ ) ) - ;; CHECK: (func $strings (type $20) (param $param (ref string)) + ;; CHECK: (func $strings (type $19) (param $param (ref string)) ;; CHECK-NEXT: (local $s (ref string)) ;; CHECK-NEXT: (local.set $s ;; CHECK-NEXT: (string.const "hello, world") @@ -1180,7 +1180,7 @@ ) ) - ;; CHECK: (func $get-nonnullable-in-unreachable-tuple (type $21) (result anyref i32) + ;; CHECK: (func $get-nonnullable-in-unreachable-tuple (type $20) (result anyref i32) ;; CHECK-NEXT: (local $x (tuple (ref any) i32)) ;; CHECK-NEXT: (local.tee $x ;; CHECK-NEXT: (unreachable) diff --git a/test/lit/passes/remove-unused-brs.wast b/test/lit/passes/remove-unused-brs.wast index da8c61cc941..fad136272ef 100644 --- a/test/lit/passes/remove-unused-brs.wast +++ b/test/lit/passes/remove-unused-brs.wast @@ -5,7 +5,7 @@ (module ;; Regression test in which we need to calculate a proper LUB. - ;; CHECK: (func $selectify-fresh-lub (type $5) (param $x i32) (result anyref) + ;; CHECK: (func $selectify-fresh-lub (type $4) (param $x i32) (result anyref) ;; CHECK-NEXT: (select (result i31ref) ;; CHECK-NEXT: (ref.null none) ;; CHECK-NEXT: (ref.i31 @@ -600,7 +600,7 @@ ;; CHECK: (func $restructure-select-no-multivalue (type $1) ;; CHECK-NEXT: (local $x i32) ;; CHECK-NEXT: (tuple.drop 2 - ;; CHECK-NEXT: (block $block (type $4) (result i32 i32) + ;; CHECK-NEXT: (block $block (type $5) (result i32 i32) ;; CHECK-NEXT: (tuple.drop 2 ;; CHECK-NEXT: (br_if $block ;; CHECK-NEXT: (tuple.make 2 diff --git a/test/lit/passes/stack-ir-eh.wast b/test/lit/passes/stack-ir-eh.wast index 0165bdc1341..781b3b660b8 100644 --- a/test/lit/passes/stack-ir-eh.wast +++ b/test/lit/passes/stack-ir-eh.wast @@ -3,7 +3,7 @@ ;; RUN: -all --print-stack-ir | filecheck %s (module - ;; CHECK: (tag $e-i32 (type $2) (param i32)) + ;; CHECK: (tag $e-i32 (type $1) (param i32)) (tag $e-i32 (param i32)) ;; CHECK: (func $foo (type $0) @@ -13,7 +13,7 @@ ;; CHECK: (func $test (type $0) ;; CHECK-NEXT: block $outer ;; CHECK-NEXT: block $l-catch (result i32) - ;; CHECK-NEXT: block $l-catch-ref (type $1) (result i32 exnref) + ;; CHECK-NEXT: block $l-catch-ref (type $2) (result i32 exnref) ;; CHECK-NEXT: block $l-catch-all ;; CHECK-NEXT: block $l-catch-all-ref (result exnref) ;; CHECK-NEXT: try_table (catch $e-i32 $l-catch) (catch_ref $e-i32 $l-catch-ref) (catch_all $l-catch-all) (catch_all_ref $l-catch-all-ref) diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast index 547278be4a0..9e3c6171f4b 100644 --- a/test/lit/wat-kitchen-sink.wast +++ b/test/lit/wat-kitchen-sink.wast @@ -76,12 +76,6 @@ ;; CHECK: (type $31 (func (param i64 v128))) - ;; CHECK: (type $32 (func (result structref arrayref))) - - ;; CHECK: (type $33 (func (result arrayref structref))) - - ;; CHECK: (type $34 (func (result i32 i64 (ref null $simple-cont)))) - ;; CHECK: (type $cont-bind-before-func (func (param i32 i64 i32 i64) (result f32))) ;; CHECK: (type $cont-bind-before (cont $cont-bind-before-func)) @@ -136,93 +130,93 @@ (type $simple-cont (cont $simple)) ;; CHECK: (type $all-types (struct (field externref) (field (ref extern)) (field (ref null (shared extern))) (field (ref (shared extern))) (field funcref) (field (ref func)) (field (ref null (shared func))) (field (ref (shared func))) (field anyref) (field (ref any)) (field (ref null (shared any))) (field (ref (shared any))) (field eqref) (field (ref eq)) (field (ref null (shared eq))) (field (ref (shared eq))) (field i31ref) (field (ref i31)) (field (ref null (shared i31))) (field (ref (shared i31))) (field structref) (field (ref struct)) (field (ref null (shared struct))) (field (ref (shared struct))) (field arrayref) (field (ref array)) (field (ref null (shared array))) (field (ref (shared array))) (field exnref) (field (ref exn)) (field (ref null (shared exn))) (field (ref (shared exn))) (field stringref) (field (ref string)) (field (ref null (shared string))) (field (ref (shared string))) (field contref) (field (ref cont)) (field (ref null (shared cont))) (field (ref (shared cont))) (field nullref) (field (ref none)) (field (ref null (shared none))) (field (ref (shared none))) (field nullexternref) (field (ref noextern)) (field (ref null (shared noextern))) (field (ref (shared noextern))) (field nullfuncref) (field (ref nofunc)) (field (ref null (shared nofunc))) (field (ref (shared nofunc))) (field nullexnref) (field (ref noexn)) (field (ref null (shared noexn))) (field (ref (shared noexn))) (field nullcontref) (field (ref nocont)) (field (ref null (shared nocont))) (field (ref (shared nocont))))) - ;; CHECK: (type $49 (func (param i32 i32))) + ;; CHECK: (type $46 (func (param i32 i32))) - ;; CHECK: (type $50 (func (param exnref))) + ;; CHECK: (type $47 (func (param exnref))) - ;; CHECK: (type $51 (func (result anyref anyref))) + ;; CHECK: (type $48 (func (result anyref anyref))) - ;; CHECK: (type $52 (func (param i32 i32 f64 f64))) + ;; CHECK: (type $49 (func (param i32 i32 f64 f64))) - ;; CHECK: (type $53 (func (param i64))) + ;; CHECK: (type $50 (func (param i64))) - ;; CHECK: (type $54 (func (param v128) (result i32))) + ;; CHECK: (type $51 (func (param v128) (result i32))) - ;; CHECK: (type $55 (func (param v128 v128) (result v128))) + ;; CHECK: (type $52 (func (param v128 v128) (result v128))) - ;; CHECK: (type $56 (func (param v128 v128 v128) (result v128))) + ;; CHECK: (type $53 (func (param v128 v128 v128) (result v128))) - ;; CHECK: (type $57 (func (param i32 i32 i64 i64))) + ;; CHECK: (type $54 (func (param i32 i32 i64 i64))) - ;; CHECK: (type $58 (func (param i64) (result i32 i64))) + ;; CHECK: (type $55 (func (param i64) (result i32 i64))) - ;; CHECK: (type $59 (func (param anyref) (result i32))) + ;; CHECK: (type $56 (func (param anyref) (result i32))) - ;; CHECK: (type $60 (func (param eqref eqref) (result i32))) + ;; CHECK: (type $57 (func (param eqref eqref) (result i32))) - ;; CHECK: (type $61 (func (param i32) (result i31ref))) + ;; CHECK: (type $58 (func (param i32) (result i31ref))) - ;; CHECK: (type $62 (func (param i31ref))) + ;; CHECK: (type $59 (func (param i31ref))) - ;; CHECK: (type $63 (func (param i32 i64) (result (ref $pair)))) + ;; CHECK: (type $60 (func (param i32 i64) (result (ref $pair)))) - ;; CHECK: (type $64 (func (result (ref $pair)))) + ;; CHECK: (type $61 (func (result (ref $pair)))) - ;; CHECK: (type $65 (func (param (ref $pair)) (result i32))) + ;; CHECK: (type $62 (func (param (ref $pair)) (result i32))) - ;; CHECK: (type $66 (func (param (ref $pair)) (result i64))) + ;; CHECK: (type $63 (func (param (ref $pair)) (result i64))) - ;; CHECK: (type $67 (func (param (ref null $pair)) (result i32))) + ;; CHECK: (type $64 (func (param (ref null $pair)) (result i32))) - ;; CHECK: (type $68 (func (param (ref $pair) i32))) + ;; CHECK: (type $65 (func (param (ref $pair) i32))) - ;; CHECK: (type $69 (func (param (ref $pair) i64))) + ;; CHECK: (type $66 (func (param (ref $pair) i64))) - ;; CHECK: (type $70 (func (param (ref null $pair) i64))) + ;; CHECK: (type $67 (func (param (ref null $pair) i64))) - ;; CHECK: (type $71 (func (param i64 i32) (result (ref $a1)))) + ;; CHECK: (type $68 (func (param i64 i32) (result (ref $a1)))) - ;; CHECK: (type $72 (func (param i32) (result (ref $a1)))) + ;; CHECK: (type $69 (func (param i32) (result (ref $a1)))) - ;; CHECK: (type $73 (func (param i32 i32) (result (ref $a1)))) + ;; CHECK: (type $70 (func (param i32 i32) (result (ref $a1)))) - ;; CHECK: (type $74 (func (param (ref $a1) i32) (result i64))) + ;; CHECK: (type $71 (func (param (ref $a1) i32) (result i64))) - ;; CHECK: (type $75 (func (param (ref $packed-i8) i32) (result i32))) + ;; CHECK: (type $72 (func (param (ref $packed-i8) i32) (result i32))) - ;; CHECK: (type $76 (func (param (ref $packed-i16) i32) (result i32))) + ;; CHECK: (type $73 (func (param (ref $packed-i16) i32) (result i32))) - ;; CHECK: (type $77 (func (param (ref $a2) i32 f32))) + ;; CHECK: (type $74 (func (param (ref $a2) i32 f32))) - ;; CHECK: (type $78 (func (param arrayref) (result i32))) + ;; CHECK: (type $75 (func (param arrayref) (result i32))) - ;; CHECK: (type $79 (func (param (ref $a2) i32 (ref $a2) i32 i32))) + ;; CHECK: (type $76 (func (param (ref $a2) i32 (ref $a2) i32 i32))) - ;; CHECK: (type $80 (func (param (ref $a2) i32 f32 i32))) + ;; CHECK: (type $77 (func (param (ref $a2) i32 f32 i32))) - ;; CHECK: (type $81 (func (param (ref $a2) i32 i32 i32))) + ;; CHECK: (type $78 (func (param (ref $a2) i32 i32 i32))) - ;; CHECK: (type $82 (func (param (ref $any-array) i32 i32 i32))) + ;; CHECK: (type $79 (func (param (ref $any-array) i32 i32 i32))) - ;; CHECK: (type $83 (func (param externref))) + ;; CHECK: (type $80 (func (param externref))) - ;; CHECK: (type $84 (func (param (ref $packed-i8) i32 i32) (result stringref))) + ;; CHECK: (type $81 (func (param (ref $packed-i8) i32 i32) (result stringref))) - ;; CHECK: (type $85 (func (param i32) (result stringref))) + ;; CHECK: (type $82 (func (param i32) (result stringref))) - ;; CHECK: (type $86 (func (result (ref string)))) + ;; CHECK: (type $83 (func (result (ref string)))) - ;; CHECK: (type $87 (func (param stringref))) + ;; CHECK: (type $84 (func (param stringref))) - ;; CHECK: (type $88 (func (param stringref (ref $packed-i16) i32) (result i32))) + ;; CHECK: (type $85 (func (param stringref (ref $packed-i16) i32) (result i32))) - ;; CHECK: (type $89 (func (param stringref stringref) (result (ref string)))) + ;; CHECK: (type $86 (func (param stringref stringref) (result (ref string)))) - ;; CHECK: (type $90 (func (param stringref i32) (result i32))) + ;; CHECK: (type $87 (func (param stringref i32) (result i32))) - ;; CHECK: (type $91 (func (param stringref i32 i32) (result (ref string)))) + ;; CHECK: (type $88 (func (param stringref i32 i32) (result (ref string)))) - ;; CHECK: (type $92 (func (param (ref $simple-cont)))) + ;; CHECK: (type $89 (func (param (ref $simple-cont)))) ;; CHECK: (type $to-f32-cont (cont $to-f32)) (type $to-f32-cont (cont $to-f32)) @@ -249,11 +243,17 @@ ;; imported memories (memory (export "mem") (export "mem2") (import "" "mem") 0) - ;; CHECK: (type $94 (func (param (ref $simple)) (result (ref $simple-cont)))) + ;; CHECK: (type $91 (func (param (ref $simple)) (result (ref $simple-cont)))) + + ;; CHECK: (type $92 (func (param (ref $cont-bind-before)) (result (ref $simple-cont)))) + + ;; CHECK: (type $93 (func (param (ref $s0) (ref $s1) (ref $s2) (ref $s3) (ref $s4) (ref $s5) (ref $s6) (ref $s7) (ref $s8) (ref $a0) (ref $a1) (ref $a2) (ref $a3) (ref $subvoid) (ref $submany) (ref $all-types)))) + + ;; CHECK: (type $94 (func (result structref arrayref))) - ;; CHECK: (type $95 (func (param (ref $cont-bind-before)) (result (ref $simple-cont)))) + ;; CHECK: (type $95 (func (result arrayref structref))) - ;; CHECK: (type $96 (func (param (ref $s0) (ref $s1) (ref $s2) (ref $s3) (ref $s4) (ref $s5) (ref $s6) (ref $s7) (ref $s8) (ref $a0) (ref $a1) (ref $a2) (ref $a3) (ref $subvoid) (ref $submany) (ref $all-types)))) + ;; CHECK: (type $96 (func (result i32 i64 (ref null $simple-cont)))) ;; CHECK: (import "" "mem" (memory $mimport$0 0)) @@ -920,7 +920,7 @@ drop ) - ;; CHECK: (func $locals (type $49) (param $0 i32) (param $x i32) + ;; CHECK: (func $locals (type $46) (param $0 i32) (param $x i32) ;; CHECK-NEXT: (local $2 i32) ;; CHECK-NEXT: (local $y i32) ;; CHECK-NEXT: (drop @@ -2558,7 +2558,7 @@ ) ) - ;; CHECK: (func $try-table-throw-ref (type $50) (param $0 exnref) + ;; CHECK: (func $try-table-throw-ref (type $47) (param $0 exnref) ;; CHECK-NEXT: (throw_ref ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -2984,10 +2984,10 @@ end ) - ;; CHECK: (func $br-table-multivalue-glb (type $51) (result anyref anyref) - ;; CHECK-NEXT: (block $a (type $33) (result arrayref structref) + ;; CHECK: (func $br-table-multivalue-glb (type $48) (result anyref anyref) + ;; CHECK-NEXT: (block $a (type $95) (result arrayref structref) ;; CHECK-NEXT: (return - ;; CHECK-NEXT: (block $b (type $32) (result structref arrayref) + ;; CHECK-NEXT: (block $b (type $94) (result structref arrayref) ;; CHECK-NEXT: (br_table $a $b ;; CHECK-NEXT: (tuple.make 2 ;; CHECK-NEXT: (ref.null none) @@ -3034,7 +3034,7 @@ end ) - ;; CHECK: (func $binary (type $52) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64) + ;; CHECK: (func $binary (type $49) (param $0 i32) (param $1 i32) (param $2 f64) (param $3 f64) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (i32.add ;; CHECK-NEXT: (local.get $0) @@ -3059,7 +3059,7 @@ drop ) - ;; CHECK: (func $unary (type $53) (param $0 i64) + ;; CHECK: (func $unary (type $50) (param $0 i64) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (i64.eqz ;; CHECK-NEXT: (local.get $0) @@ -3425,7 +3425,7 @@ drop ) - ;; CHECK: (func $simd-extract (type $54) (param $0 v128) (result i32) + ;; CHECK: (func $simd-extract (type $51) (param $0 v128) (result i32) ;; CHECK-NEXT: (i32x4.extract_lane 3 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -3447,7 +3447,7 @@ i32x4.replace_lane 2 ) - ;; CHECK: (func $simd-shuffle (type $55) (param $0 v128) (param $1 v128) (result v128) + ;; CHECK: (func $simd-shuffle (type $52) (param $0 v128) (param $1 v128) (result v128) ;; CHECK-NEXT: (i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -3459,7 +3459,7 @@ i8x16.shuffle 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23 ) - ;; CHECK: (func $simd-ternary (type $56) (param $0 v128) (param $1 v128) (param $2 v128) (result v128) + ;; CHECK: (func $simd-ternary (type $53) (param $0 v128) (param $1 v128) (param $2 v128) (result v128) ;; CHECK-NEXT: (v128.bitselect ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -3569,7 +3569,7 @@ data.drop $passive ) - ;; CHECK: (func $memory-copy (type $57) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64) + ;; CHECK: (func $memory-copy (type $54) (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i64) ;; CHECK-NEXT: (memory.copy $mimport$0 $mimport$0 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -3664,7 +3664,7 @@ return ) - ;; CHECK: (func $return-two-first-unreachable (type $58) (param $0 i64) (result i32 i64) + ;; CHECK: (func $return-two-first-unreachable (type $55) (param $0 i64) (result i32 i64) ;; CHECK-NEXT: (return ;; CHECK-NEXT: (tuple.make 2 ;; CHECK-NEXT: (unreachable) @@ -3717,7 +3717,7 @@ return ) - ;; CHECK: (func $ref-is-null (type $59) (param $0 anyref) (result i32) + ;; CHECK: (func $ref-is-null (type $56) (param $0 anyref) (result i32) ;; CHECK-NEXT: (ref.is_null ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -3761,7 +3761,7 @@ throw $tag-pair ) - ;; CHECK: (func $ref-eq (type $60) (param $0 eqref) (param $1 eqref) (result i32) + ;; CHECK: (func $ref-eq (type $57) (param $0 eqref) (param $1 eqref) (result i32) ;; CHECK-NEXT: (ref.eq ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -3938,7 +3938,7 @@ table.copy 2 $funcs ) - ;; CHECK: (func $i31-new (type $61) (param $0 i32) (result i31ref) + ;; CHECK: (func $i31-new (type $58) (param $0 i32) (result i31ref) ;; CHECK-NEXT: (ref.i31 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -3948,7 +3948,7 @@ ref.i31 ) - ;; CHECK: (func $i31-get (type $62) (param $0 i31ref) + ;; CHECK: (func $i31-get (type $59) (param $0 i31ref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (i31.get_s ;; CHECK-NEXT: (local.get $0) @@ -4217,7 +4217,7 @@ drop ) - ;; CHECK: (func $struct-new (type $63) (param $0 i32) (param $1 i64) (result (ref $pair)) + ;; CHECK: (func $struct-new (type $60) (param $0 i32) (param $1 i64) (result (ref $pair)) ;; CHECK-NEXT: (struct.new $pair ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4229,14 +4229,14 @@ struct.new $pair ) - ;; CHECK: (func $struct-new-default (type $64) (result (ref $pair)) + ;; CHECK: (func $struct-new-default (type $61) (result (ref $pair)) ;; CHECK-NEXT: (struct.new_default $pair) ;; CHECK-NEXT: ) (func $struct-new-default (result (ref $pair)) struct.new_default 14 ) - ;; CHECK: (func $struct-get-0 (type $65) (param $0 (ref $pair)) (result i32) + ;; CHECK: (func $struct-get-0 (type $62) (param $0 (ref $pair)) (result i32) ;; CHECK-NEXT: (struct.get $pair $first ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -4246,7 +4246,7 @@ struct.get 14 0 ) - ;; CHECK: (func $struct-get-1 (type $66) (param $0 (ref $pair)) (result i64) + ;; CHECK: (func $struct-get-1 (type $63) (param $0 (ref $pair)) (result i64) ;; CHECK-NEXT: (struct.get $pair $second ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -4256,7 +4256,7 @@ struct.get $pair 1 ) - ;; CHECK: (func $struct-get-named (type $67) (param $0 (ref null $pair)) (result i32) + ;; CHECK: (func $struct-get-named (type $64) (param $0 (ref null $pair)) (result i32) ;; CHECK-NEXT: (struct.get $pair $first ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -4266,7 +4266,7 @@ struct.get $pair $first ) - ;; CHECK: (func $struct-set-0 (type $68) (param $0 (ref $pair)) (param $1 i32) + ;; CHECK: (func $struct-set-0 (type $65) (param $0 (ref $pair)) (param $1 i32) ;; CHECK-NEXT: (struct.set $pair $first ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4278,7 +4278,7 @@ struct.set $pair 0 ) - ;; CHECK: (func $struct-set-1 (type $69) (param $0 (ref $pair)) (param $1 i64) + ;; CHECK: (func $struct-set-1 (type $66) (param $0 (ref $pair)) (param $1 i64) ;; CHECK-NEXT: (struct.set $pair $second ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4290,7 +4290,7 @@ struct.set 14 1 ) - ;; CHECK: (func $struct-set-named (type $70) (param $0 (ref null $pair)) (param $1 i64) + ;; CHECK: (func $struct-set-named (type $67) (param $0 (ref null $pair)) (param $1 i64) ;; CHECK-NEXT: (struct.set $pair $second ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4302,7 +4302,7 @@ struct.set 14 $second ) - ;; CHECK: (func $array-new (type $71) (param $0 i64) (param $1 i32) (result (ref $a1)) + ;; CHECK: (func $array-new (type $68) (param $0 i64) (param $1 i32) (result (ref $a1)) ;; CHECK-NEXT: (array.new $a1 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4314,7 +4314,7 @@ array.new $a1 ) - ;; CHECK: (func $array-new-default (type $72) (param $0 i32) (result (ref $a1)) + ;; CHECK: (func $array-new-default (type $69) (param $0 i32) (result (ref $a1)) ;; CHECK-NEXT: (array.new_default $a1 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -4324,7 +4324,7 @@ array.new_default 11 ) - ;; CHECK: (func $array-new-data (type $73) (param $0 i32) (param $1 i32) (result (ref $a1)) + ;; CHECK: (func $array-new-data (type $70) (param $0 i32) (param $1 i32) (result (ref $a1)) ;; CHECK-NEXT: (array.new_data $a1 $implicit-data ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4358,7 +4358,7 @@ drop ) - ;; CHECK: (func $array-get (type $74) (param $0 (ref $a1)) (param $1 i32) (result i64) + ;; CHECK: (func $array-get (type $71) (param $0 (ref $a1)) (param $1 i32) (result i64) ;; CHECK-NEXT: (array.get $a1 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4370,7 +4370,7 @@ array.get $a1 ) - ;; CHECK: (func $array-get-s (type $75) (param $0 (ref $packed-i8)) (param $1 i32) (result i32) + ;; CHECK: (func $array-get-s (type $72) (param $0 (ref $packed-i8)) (param $1 i32) (result i32) ;; CHECK-NEXT: (array.get_s $packed-i8 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4382,7 +4382,7 @@ array.get_s 15 ) - ;; CHECK: (func $array-get-u (type $76) (param $0 (ref $packed-i16)) (param $1 i32) (result i32) + ;; CHECK: (func $array-get-u (type $73) (param $0 (ref $packed-i16)) (param $1 i32) (result i32) ;; CHECK-NEXT: (array.get_u $packed-i16 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4394,7 +4394,7 @@ array.get_u $packed-i16 ) - ;; CHECK: (func $array-set (type $77) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) + ;; CHECK: (func $array-set (type $74) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) ;; CHECK-NEXT: (array.set $a2 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4408,7 +4408,7 @@ array.set $a2 ) - ;; CHECK: (func $array-len (type $78) (param $0 arrayref) (result i32) + ;; CHECK: (func $array-len (type $75) (param $0 arrayref) (result i32) ;; CHECK-NEXT: (array.len ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -4418,7 +4418,7 @@ array.len ) - ;; CHECK: (func $array-copy (type $79) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32) + ;; CHECK: (func $array-copy (type $76) (param $0 (ref $a2)) (param $1 i32) (param $2 (ref $a2)) (param $3 i32) (param $4 i32) ;; CHECK-NEXT: (array.copy $a2 $a2 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4436,7 +4436,7 @@ array.copy $a2 $a2 ) - ;; CHECK: (func $array-fill (type $80) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32) + ;; CHECK: (func $array-fill (type $77) (param $0 (ref $a2)) (param $1 i32) (param $2 f32) (param $3 i32) ;; CHECK-NEXT: (array.fill $a2 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4452,7 +4452,7 @@ array.fill $a2 ) - ;; CHECK: (func $array-init-data (type $81) (param $0 (ref $a2)) (param $1 i32) (param $2 i32) (param $3 i32) + ;; CHECK: (func $array-init-data (type $78) (param $0 (ref $a2)) (param $1 i32) (param $2 i32) (param $3 i32) ;; CHECK-NEXT: (array.init_data $a2 $implicit-data ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4468,7 +4468,7 @@ array.init_data $a2 0 ) - ;; CHECK: (func $array-init-elem (type $82) (param $0 (ref $any-array)) (param $1 i32) (param $2 i32) (param $3 i32) + ;; CHECK: (func $array-init-elem (type $79) (param $0 (ref $any-array)) (param $1 i32) (param $2 i32) (param $3 i32) ;; CHECK-NEXT: (array.init_elem $any-array $passive-2 ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4497,7 +4497,7 @@ drop ) - ;; CHECK: (func $any-convert-extern (type $83) (param $0 externref) + ;; CHECK: (func $any-convert-extern (type $80) (param $0 externref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (any.convert_extern ;; CHECK-NEXT: (local.get $0) @@ -4523,7 +4523,7 @@ drop ) - ;; CHECK: (func $string-new-gc (type $84) (param $0 (ref $packed-i8)) (param $1 i32) (param $2 i32) (result stringref) + ;; CHECK: (func $string-new-gc (type $81) (param $0 (ref $packed-i8)) (param $1 i32) (param $2 i32) (result stringref) ;; CHECK-NEXT: (string.new_lossy_utf8_array ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4537,7 +4537,7 @@ string.new_lossy_utf8_array ) - ;; CHECK: (func $string-new-code-point (type $85) (param $0 i32) (result stringref) + ;; CHECK: (func $string-new-code-point (type $82) (param $0 i32) (result stringref) ;; CHECK-NEXT: (string.from_code_point ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: ) @@ -4547,7 +4547,7 @@ string.from_code_point ) - ;; CHECK: (func $string-const (type $86) (result (ref string)) + ;; CHECK: (func $string-const (type $83) (result (ref string)) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (string.const "foobar") ;; CHECK-NEXT: ) @@ -4559,7 +4559,7 @@ string.const "\00\00\00" ) - ;; CHECK: (func $string-measure (type $87) (param $0 stringref) + ;; CHECK: (func $string-measure (type $84) (param $0 stringref) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (string.measure_utf8 ;; CHECK-NEXT: (local.get $0) @@ -4580,7 +4580,7 @@ drop ) - ;; CHECK: (func $string-encode-gc (type $88) (param $0 stringref) (param $1 (ref $packed-i16)) (param $2 i32) (result i32) + ;; CHECK: (func $string-encode-gc (type $85) (param $0 stringref) (param $1 (ref $packed-i16)) (param $2 i32) (result i32) ;; CHECK-NEXT: (string.encode_wtf16_array ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4594,7 +4594,7 @@ string.encode_wtf16_array ) - ;; CHECK: (func $string-concat (type $89) (param $0 stringref) (param $1 stringref) (result (ref string)) + ;; CHECK: (func $string-concat (type $86) (param $0 stringref) (param $1 stringref) (result (ref string)) ;; CHECK-NEXT: (string.concat ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4630,7 +4630,7 @@ string.compare ) - ;; CHECK: (func $string-get (type $90) (param $0 stringref) (param $1 i32) (result i32) + ;; CHECK: (func $string-get (type $87) (param $0 stringref) (param $1 i32) (result i32) ;; CHECK-NEXT: (stringview_wtf16.get_codeunit ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4642,7 +4642,7 @@ stringview_wtf16.get_codeunit ) - ;; CHECK: (func $string-slice (type $91) (param $0 stringref) (param $1 i32) (param $2 i32) (result (ref string)) + ;; CHECK: (func $string-slice (type $88) (param $0 stringref) (param $1 i32) (param $2 i32) (result (ref string)) ;; CHECK-NEXT: (stringview_wtf16.slice ;; CHECK-NEXT: (local.get $0) ;; CHECK-NEXT: (local.get $1) @@ -4943,13 +4943,13 @@ ) ) - ;; CHECK: (func $resume (type $92) (param $ct (ref $simple-cont)) + ;; CHECK: (func $resume (type $89) (param $ct (ref $simple-cont)) ;; CHECK-NEXT: (local $f f32) ;; CHECK-NEXT: (block $label ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block $block (result (ref $to-f32-cont)) ;; CHECK-NEXT: (tuple.drop 3 - ;; CHECK-NEXT: (block $block1 (type $34) (result i32 i64 (ref null $simple-cont)) + ;; CHECK-NEXT: (block $block1 (type $96) (result i32 i64 (ref null $simple-cont)) ;; CHECK-NEXT: (local.set $f ;; CHECK-NEXT: (resume $simple-cont (on $empty $block) (on $tag-pair-to-pair $block1) ;; CHECK-NEXT: (i32.const 0) @@ -4982,7 +4982,7 @@ br 0 ) - ;; CHECK: (func $contnew (type $94) (param $f (ref $simple)) (result (ref $simple-cont)) + ;; CHECK: (func $contnew (type $91) (param $f (ref $simple)) (result (ref $simple-cont)) ;; CHECK-NEXT: (cont.new $simple-cont ;; CHECK-NEXT: (local.get $f) ;; CHECK-NEXT: ) @@ -4992,7 +4992,7 @@ cont.new $simple-cont ) - ;; CHECK: (func $contbind (type $95) (param $c (ref $cont-bind-before)) (result (ref $simple-cont)) + ;; CHECK: (func $contbind (type $92) (param $c (ref $cont-bind-before)) (result (ref $simple-cont)) ;; CHECK-NEXT: (cont.bind $cont-bind-before $simple-cont ;; CHECK-NEXT: (i32.const 123) ;; CHECK-NEXT: (i64.const 123) @@ -5117,7 +5117,7 @@ drop ) - ;; CHECK: (func $use-types (type $96) (param $0 (ref $s0)) (param $1 (ref $s1)) (param $2 (ref $s2)) (param $3 (ref $s3)) (param $4 (ref $s4)) (param $5 (ref $s5)) (param $6 (ref $s6)) (param $7 (ref $s7)) (param $8 (ref $s8)) (param $9 (ref $a0)) (param $10 (ref $a1)) (param $11 (ref $a2)) (param $12 (ref $a3)) (param $13 (ref $subvoid)) (param $14 (ref $submany)) (param $15 (ref $all-types)) + ;; CHECK: (func $use-types (type $93) (param $0 (ref $s0)) (param $1 (ref $s1)) (param $2 (ref $s2)) (param $3 (ref $s3)) (param $4 (ref $s4)) (param $5 (ref $s5)) (param $6 (ref $s6)) (param $7 (ref $s7)) (param $8 (ref $s8)) (param $9 (ref $a0)) (param $10 (ref $a1)) (param $11 (ref $a2)) (param $12 (ref $a3)) (param $13 (ref $subvoid)) (param $14 (ref $submany)) (param $15 (ref $all-types)) ;; CHECK-NEXT: ) (func $use-types (param (ref $s0))