From ae0a5ff542ab51f64b5132916fce4779b5dbe179 Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Thu, 19 Nov 2026 10:26:37 -0800 Subject: [PATCH] [DAE2] Preserve unreachability of noreturn calls When DAE2 removes an unused concrete result from a call to a function that never returns, changing the call type to none drops the unreachability information that downstream passes like GUFA rely on. Track neverReturns for direct functions and indirect call signature trees, append an unreachable after calls whose removed results never return, and let Collector infer unreachable types for multi-element blocks. --- src/passes/DeadArgumentElimination2.cpp | 121 ++++++-- .../lit/passes/dae2-results-control-flow.wast | 17 +- test/lit/passes/dae2-results-indirect.wast | 252 ++++++++++++++++ test/lit/passes/dae2-results-returns.wast | 275 +++++++++++++++++- 4 files changed, 630 insertions(+), 35 deletions(-) diff --git a/src/passes/DeadArgumentElimination2.cpp b/src/passes/DeadArgumentElimination2.cpp index 0f976a2bb16..ad5c4c10617 100644 --- a/src/passes/DeadArgumentElimination2.cpp +++ b/src/passes/DeadArgumentElimination2.cpp @@ -43,6 +43,7 @@ #include "analysis/lattices/bool.h" #include "ir/effects.h" +#include "ir/gc-type-utils.h" #include "ir/intrinsics.h" #include "ir/label-utils.h" #include "ir/local-graph.h" @@ -208,6 +209,10 @@ struct FunctionInfo { // from none to unreachable, requiring enclosing expressions to be // refinalized. bool refinalize = false; + + // Whether this function can never return normally (e.g. always traps/throws + // or loops, is marked @binaryen.noreturn, or has an uninhabitable result). + bool neverReturns = false; }; // Analysis results and call graph information for a tree of related function @@ -220,6 +225,10 @@ struct RootFuncTypeInfo { // Analysis result for the function result. Used::Element resultUsage; + // Whether all referenced functions in this type tree can never return + // normally. (This will be set to false if any referenced function returns.) + bool neverReturns = true; + // The list of referenced functions with types in this tree. When a parameter // in this type tree is used, the parameter becomes used in these functions // and vice versa. @@ -401,6 +410,9 @@ struct GraphBuilder : public WalkerPass> { bool optimizeReferencedFuncs; + // Whether this function has at least one potentially normal return path. + bool canReturn = false; + GraphBuilder(const Used& used, const std::unordered_map& funcIndices, std::vector& funcInfos, @@ -413,11 +425,29 @@ struct GraphBuilder : public WalkerPass> { used, funcIndices, funcInfos, optimizeReferencedFuncs); } + static bool hasUnreachableOperand(const ExpressionList& operands) { + return std::any_of(operands.begin(), operands.end(), [](Expression* op) { + return op->type == Type::unreachable; + }); + } + void runOnFunction(Module* wasm, Function* func) override { assert(index == Index(-1)); index = funcIndices.at(func->name); localGraph.emplace(func); WalkerPass>::runOnFunction(wasm, func); + if (func->body->type != Type::unreachable) { + canReturn = true; + } + if (!canReturn) { + funcInfos[index].neverReturns = true; + } + } + + void visitReturn(Return* curr) { + if (!curr->value || curr->value->type != Type::unreachable) { + canReturn = true; + } } void visitRefFunc(RefFunc* curr) { @@ -634,6 +664,9 @@ struct GraphBuilder : public WalkerPass> { target->type.getHeapType()); } } + if (curr->isReturn && !hasUnreachableOperand(curr->operands)) { + canReturn = true; + } auto* callee = getModule()->getFunction(curr->target); if (callee->getResults().isConcrete()) { Location source = FuncResultLoc{funcIndices.at(curr->target)}; @@ -646,7 +679,15 @@ struct GraphBuilder : public WalkerPass> { } } - void handleIndirectCall(Expression* curr, HeapType type, bool isReturn) { + void handleIndirectCall(Expression* curr, + HeapType type, + bool isReturn, + Expression* target, + const ExpressionList& operands) { + if (isReturn && target->type != Type::unreachable && + !hasUnreachableOperand(operands)) { + canReturn = true; + } auto sig = type.getSignature(); if (sig.results.isConcrete()) { HeapType rootType = getRootType(type); @@ -665,13 +706,18 @@ struct GraphBuilder : public WalkerPass> { } void visitCallIndirect(CallIndirect* curr) { - handleIndirectCall(curr, curr->heapType, curr->isReturn); + handleIndirectCall( + curr, curr->heapType, curr->isReturn, curr->target, curr->operands); } void visitCallRef(CallRef* curr) { auto targetType = curr->target->type; if (targetType.isSignature()) { - handleIndirectCall(curr, targetType.getHeapType(), curr->isReturn); + handleIndirectCall(curr, + targetType.getHeapType(), + curr->isReturn, + curr->target, + curr->operands); } } }; @@ -695,6 +741,16 @@ void DAE2::analyzeModule() { // Find additional function references at the module level. builder.walkModuleCode(wasm); + // Mark functions with uninhabitable results or @binaryen.noreturn as never + // returning even if their bodies appear to reach the end. + for (Index i = 0; i < wasm->functions.size(); ++i) { + auto* func = wasm->functions[i].get(); + if (GCTypeUtils::isTriviallyUninhabitable(func->getResults()) || + Intrinsics::getAnnotations(func).noReturn) { + funcInfos[i].neverReturns = true; + } + } + // Update the locations for which we observed direct usage. for (Index i = 0; i < wasm->functions.size(); ++i) { auto& info = funcInfos[i]; @@ -806,7 +862,11 @@ void DAE2::prepareReverseGraph() { funcInfos[i].paramSources.resize(funcInfos[i].paramUsages.size()); if (funcInfos[i].referenced) { auto root = getRootType(wasm->functions[i]->type.getHeapType()); - getTypeTreeInfo(root).referencedFuncs.push_back(i); + auto& typeTreeInfo = getTypeTreeInfo(root); + typeTreeInfo.referencedFuncs.push_back(i); + if (!funcInfos[i].neverReturns) { + typeTreeInfo.neverReturns = false; + } } } for (Index callerIndex = 0; callerIndex < funcInfos.size(); ++callerIndex) { @@ -1274,13 +1334,35 @@ struct Optimizer replaceCurrent(block); } - void visitCall(Call* curr) { - auto& calleeInfo = parent.funcInfos[parent.funcIndices.at(curr->target)]; - if (!calleeInfo.resultUsage && curr->type.isConcrete()) { + void finishCall(Expression* curr, + ExpressionList& operands, + bool hasUsedResult, + const Params& paramUsages, + bool neverReturns) { + bool removedResult = false; + if (!hasUsedResult && curr->type.isConcrete()) { curr->type = Type::none; markParentsRemoved(); + removedResult = true; + } + removeOperands(curr, operands, paramUsages); + // Removing a concrete result from a call that can never return loses + // unreachability unless we append an unreachable after the call. + if (removedResult && neverReturns && + getCurrent()->type != Type::unreachable) { + Builder builder(*getModule()); + replaceCurrent( + builder.makeSequence(getCurrent(), builder.makeUnreachable())); } - removeOperands(curr, curr->operands, calleeInfo.paramUsages); + } + + void visitCall(Call* curr) { + auto& calleeInfo = parent.funcInfos[parent.funcIndices.at(curr->target)]; + finishCall(curr, + curr->operands, + calleeInfo.resultUsage, + calleeInfo.paramUsages, + calleeInfo.neverReturns); } void handleIndirectCall(Expression* curr, @@ -1290,21 +1372,12 @@ struct Optimizer return; } auto it = parent.typeTreeInfos.find(getRootType(type)); - if (it == parent.typeTreeInfos.end()) { - // No analysis results for this type, so none of its parameters or results - // are used. - if (curr->type.isConcrete()) { - curr->type = Type::none; - markParentsRemoved(); - } - removeOperands(curr, operands, {}); - } else { - if (!it->second.resultUsage && curr->type.isConcrete()) { - curr->type = Type::none; - markParentsRemoved(); - } - removeOperands(curr, operands, it->second.paramUsages); - } + assert(it != parent.typeTreeInfos.end()); + finishCall(curr, + operands, + it->second.resultUsage, + it->second.paramUsages, + it->second.neverReturns); } void visitCallRef(CallRef* curr) { @@ -1418,7 +1491,7 @@ Expression* Optimizer::getReplacement(Expression* curr) { result = exprs[0]; break; default: - result = builder.makeBlock(exprs, Type::none); + result = builder.makeBlock(exprs); break; } exprs.clear(); diff --git a/test/lit/passes/dae2-results-control-flow.wast b/test/lit/passes/dae2-results-control-flow.wast index 586971a01e0..946be19cc16 100644 --- a/test/lit/passes/dae2-results-control-flow.wast +++ b/test/lit/passes/dae2-results-control-flow.wast @@ -294,7 +294,10 @@ ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: (then ;; CHECK-NEXT: (unreachable) - ;; CHECK-NEXT: (call $callee) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call $callee) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (else ;; CHECK-NEXT: (unreachable) @@ -340,8 +343,11 @@ (unreachable) ) ;; CHECK: (func $caller (type $2) (param $x i32) (param $ref (ref $sig)) - ;; CHECK-NEXT: (call_ref $sig - ;; CHECK-NEXT: (local.get $ref) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call_ref $sig + ;; CHECK-NEXT: (local.get $ref) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (drop ;; CHECK-NEXT: (block @@ -349,7 +355,10 @@ ;; CHECK-NEXT: (local.get $x) ;; CHECK-NEXT: (then ;; CHECK-NEXT: (unreachable) - ;; CHECK-NEXT: (call $callee) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call $callee) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (else ;; CHECK-NEXT: (unreachable) diff --git a/test/lit/passes/dae2-results-indirect.wast b/test/lit/passes/dae2-results-indirect.wast index 66dadf17303..4b95b8c72a5 100644 --- a/test/lit/passes/dae2-results-indirect.wast +++ b/test/lit/passes/dae2-results-indirect.wast @@ -587,3 +587,255 @@ (global.set $g (call $callee)) ) ) + +(module + (rec + ;; CHECK: (type $empty (sub (func))) + + ;; CHECK: (type $tail_sig (sub (func (param i32)))) + + ;; CHECK: (type $mixed (sub (func))) + + ;; CHECK: (type $all_trap (sub (func))) + (type $all_trap (sub (func (param i32) (result i32)))) + (type $mixed (sub (func (result i32)))) + (type $empty (sub (func (param i64) (result i32)))) + (type $tail_sig (sub (func (param i32) (result i32)))) + ) + + ;; CHECK: (import "env" "effect" (func $effect (type $10) (result i32))) + (import "env" "effect" (func $effect (result i32))) + + ;; CHECK: (table $t 6 6 funcref) + (table $t funcref (elem $trap1 $trap2 $ret $trap3 $tail_unreachable $tail_indirect_unreachable)) + + ;; CHECK: (func $trap1 (type $all_trap) + ;; CHECK-NEXT: (local $x i32) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $trap1 (type $all_trap) (param $x i32) (result i32) + ;; All referenced functions in $all_trap never return. + (unreachable) + ) + + ;; CHECK: (func $trap2 (type $all_trap) + ;; CHECK-NEXT: (local $x i32) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $trap2 (type $all_trap) (param $x i32) (result i32) + ;; Exercises multi-operand hasUnreachableOperand hitting both false and true. + (return_call $trap_two + (local.get $x) + (unreachable) + ) + ) + + ;; CHECK: (func $trap_two (type $0) + ;; CHECK-NEXT: (local $b i32) + ;; CHECK-NEXT: (local $a i32) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $trap_two (param $a i32) (param $b i32) (result i32) + (unreachable) + ) + + ;; CHECK: (func $ret (type $mixed) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i32.const 1) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $ret (type $mixed) (result i32) + ;; Returns normally, preventing noreturn inference for $mixed callers. + (i32.const 1) + ) + + ;; CHECK: (func $trap3 (type $mixed) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $trap3 (type $mixed) (result i32) + (unreachable) + ) + + ;; CHECK: (func $tail_unreachable (type $tail_sig) (param $x i32) + ;; CHECK-NEXT: (return_call_ref $tail_sig + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: (ref.func $tail_unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $tail_unreachable (type $tail_sig) (param $x i32) (result i32) + ;; Unreachable operand in return_call_ref keeps neverReturns true. + (return_call_ref $tail_sig + (unreachable) + (ref.func $tail_unreachable) + ) + ) + + ;; CHECK: (func $tail_indirect_unreachable (type $tail_sig) (param $x i32) + ;; CHECK-NEXT: (if + ;; CHECK-NEXT: (local.get $x) + ;; CHECK-NEXT: (then + ;; CHECK-NEXT: (return_call_indirect $t (type $tail_sig) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (else + ;; CHECK-NEXT: (return_call_indirect $t (type $tail_sig) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $tail_indirect_unreachable (type $tail_sig) (param $x i32) (result i32) + ;; Unreachable target or operand in return_call_indirect keeps neverReturns true. + (if + (local.get $x) + (then + (return_call_indirect $t (type $tail_sig) + (i32.const 0) + (unreachable) + ) + ) + (else + (return_call_indirect $t (type $tail_sig) + (unreachable) + (i32.const 0) + ) + ) + ) + ) + + ;; CHECK: (func $mixed_tail_indirect (type $0) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (return_call_indirect $t (type $all_trap) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $mixed_tail_indirect (result i32) + ;; Reachable indirect tail call keeps neverReturns false even when its + ;; targets never return. + (return_call_indirect $t (type $all_trap) + (i32.const 0) + (i32.const 0) + ) + ) + + ;; CHECK: (func $mixed_tail_ref (type $0) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (return_call_ref $all_trap + ;; CHECK-NEXT: (ref.func $trap1) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $mixed_tail_ref (result i32) + ;; Reachable return_call_ref keeps neverReturns false. + (return_call_ref $all_trap + (i32.const 0) + (ref.func $trap1) + ) + ) + + ;; CHECK: (func $caller_trap_ref (type $11) (param $ref_trap (ref null $all_trap)) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (call_ref $all_trap + ;; CHECK-NEXT: (local.get $ref_trap) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $caller_trap_ref (param $ref_trap (ref null $all_trap)) + (drop + (call_ref $all_trap + (i32.const 0) + (local.get $ref_trap) + ) + ) + ) + + ;; CHECK: (func $caller_trap_indirect (type $0) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (call_indirect $t (type $all_trap) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $caller_trap_indirect + (drop + (call_indirect $t (type $all_trap) + (i32.const 0) + (i32.const 0) + ) + ) + ) + + ;; CHECK: (func $caller_mixed (type $12) (param $ref_mixed (ref null $mixed)) + ;; CHECK-NEXT: (call_ref $mixed + ;; CHECK-NEXT: (local.get $ref_mixed) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $caller_mixed (param $ref_mixed (ref null $mixed)) + (drop + (call_ref $mixed + (local.get $ref_mixed) + ) + ) + ) + + ;; CHECK: (func $caller_empty (type $13) (param $ref_empty (ref null $empty)) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i64.const 0) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (call_ref $empty + ;; CHECK-NEXT: (local.get $ref_empty) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $caller_empty (param $ref_empty (ref null $empty)) + (drop + (call_ref $empty + (i64.const 0) + (local.get $ref_empty) + ) + ) + ) + + ;; CHECK: (func $caller_tail (type $14) (param $ref_tail (ref null $tail_sig)) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call_ref $tail_sig + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: (local.get $ref_tail) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (call $mixed_tail_indirect) + ;; CHECK-NEXT: (call $mixed_tail_ref) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (call $effect) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $caller_tail (param $ref_tail (ref null $tail_sig)) + (drop + (call_ref $tail_sig + (i32.const 0) + (local.get $ref_tail) + ) + ) + (drop (call $mixed_tail_indirect)) + (drop (call $mixed_tail_ref)) + (drop (call $effect)) + ) +) diff --git a/test/lit/passes/dae2-results-returns.wast b/test/lit/passes/dae2-results-returns.wast index 58e3ddb428f..44e030c638a 100644 --- a/test/lit/passes/dae2-results-returns.wast +++ b/test/lit/passes/dae2-results-returns.wast @@ -330,10 +330,13 @@ ;; CHECK: (global $g (mut f64) (f64.const 0)) (global $g (mut f64) (f64.const 0)) ;; CHECK: (func $caller (type $0) - ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (global.get $g) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (global.get $g) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (call $callee) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (call $callee) + ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) (func $caller (result f64) ;; Fallthrough call where callee and caller return types are eliminated. @@ -356,14 +359,17 @@ (global $g (mut f64) (f64.const 0)) ;; CHECK: (func $caller (type $0) ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (block (result f64) + ;; CHECK-NEXT: (block ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: (block ;; CHECK-NEXT: (block - ;; CHECK-NEXT: (drop - ;; CHECK-NEXT: (global.get $g) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (global.get $g) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (call $callee) ;; CHECK-NEXT: ) - ;; CHECK-NEXT: (call $callee) + ;; CHECK-NEXT: (unreachable) ;; CHECK-NEXT: ) ;; CHECK-NEXT: (return) ;; CHECK-NEXT: ) @@ -387,3 +393,258 @@ (unreachable) ) ) + +(module + ;; CHECK: (import "env" "effect" (func $effect (type $0) (result i32))) + (import "env" "effect" (func $effect (result i32))) + ;; CHECK: (import "env" "impossible" (func $impossible (type $3) (result (ref none)))) + (import "env" "impossible" (func $impossible (result (ref none)))) + + ;; CHECK: (func $noreturn (type $1) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (call $effect) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $noreturn (result i32) + ;; Never returns normally: body is unreachable and there are no returns. + (block + (drop (call $effect)) + (unreachable) + ) + ) + + ;; CHECK: (func $uninhabited (type $1) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (call $impossible) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $uninhabited (result (ref none)) + ;; Result type is trivially uninhabitable, so the call can never return even + ;; though the body type is not unreachable. + (call $impossible) + ) + + ;; CHECK: (@binaryen.noreturn) + ;; CHECK-NEXT: (func $annotated (type $1) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i32.const 7) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (@binaryen.noreturn) + (func $annotated (result i32) + ;; Marked @binaryen.noreturn, so callers should be marked unreachable even + ;; though the body computes a value. + (i32.const 7) + ) + + ;; CHECK: (func $direct_return (type $4) (param $cond i32) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (block (result i32) + ;; CHECK-NEXT: (if + ;; CHECK-NEXT: (local.get $cond) + ;; CHECK-NEXT: (then + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i32.const 1) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (return) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $direct_return (param $cond i32) (result i32) + ;; Has a reachable return before unreachable, so neverReturns must stay false. + (if + (local.get $cond) + (then + (return (i32.const 1)) + ) + ) + (unreachable) + ) + + ;; CHECK: (func $void_helper (type $4) (param $cond i32) + ;; CHECK-NEXT: (if + ;; CHECK-NEXT: (local.get $cond) + ;; CHECK-NEXT: (then + ;; CHECK-NEXT: (return) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $void_helper (param $cond i32) + ;; Exercises explicit void return (no value) keeping canReturn true. + (if + (local.get $cond) + (then + (return) + ) + ) + (unreachable) + ) + + ;; CHECK: (func $dead_return (type $1) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: (return) + ;; CHECK-NEXT: ) + (func $dead_return (result i32) + ;; Explicit return with an unreachable value cannot actually return. + (return (unreachable)) + ) + + ;; CHECK: (func $helper (type $1) + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (i32.const 42) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $helper (result i32) + (i32.const 42) + ) + + ;; CHECK: (func $tail_return (type $1) + ;; CHECK-NEXT: (return_call $helper) + ;; CHECK-NEXT: ) + (func $tail_return (result i32) + ;; Reachable tail call can return, so neverReturns must stay false. + (return_call $helper) + ) + + ;; CHECK: (func $dead_tail_return (type $1) + ;; CHECK-NEXT: (return_call $direct_return + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $dead_tail_return (result i32) + ;; Tail call with an unreachable operand cannot return. + (return_call $direct_return + (unreachable) + ) + ) + + ;; CHECK: (func $caller_noreturn_add (type $0) (result i32) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (drop + ;; CHECK-NEXT: (call $effect) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call $noreturn) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + (func $caller_noreturn_add (export "caller_noreturn_add") (result i32) + ;; Multi-child dropped expression containing a noreturn call tests both + ;; call-site unreachable insertion and Collector preserving unreachable. + (drop + (i32.add + (call $effect) + (call $noreturn) + ) + ) + (i32.const 0) + ) + + ;; CHECK: (func $caller_uninhabited (type $0) (result i32) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call $uninhabited) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + (func $caller_uninhabited (export "caller_uninhabited") (result i32) + (drop (call $uninhabited)) + (i32.const 0) + ) + + ;; CHECK: (func $caller_annotated (type $0) (result i32) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call $annotated) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + (func $caller_annotated (export "caller_annotated") (result i32) + (drop (call $annotated)) + (i32.const 0) + ) + + ;; CHECK: (func $caller_direct_return (type $0) (result i32) + ;; CHECK-NEXT: (call $direct_return + ;; CHECK-NEXT: (call $effect) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (call $void_helper + ;; CHECK-NEXT: (call $effect) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + (func $caller_direct_return (export "caller_direct_return") (result i32) + (drop (call $direct_return (call $effect))) + (call $void_helper (call $effect)) + (i32.const 0) + ) + + ;; CHECK: (func $caller_dead_return (type $0) (result i32) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call $dead_return) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + (func $caller_dead_return (export "caller_dead_return") (result i32) + (drop (call $dead_return)) + (i32.const 0) + ) + + ;; CHECK: (func $caller_tail_return (type $0) (result i32) + ;; CHECK-NEXT: (call $tail_return) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + (func $caller_tail_return (export "caller_tail_return") (result i32) + (drop (call $tail_return)) + (i32.const 0) + ) + + ;; CHECK: (func $caller_dead_tail_return (type $0) (result i32) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call $dead_tail_return) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + (func $caller_dead_tail_return (export "caller_dead_tail_return") (result i32) + (drop (call $dead_tail_return)) + (i32.const 0) + ) + + ;; CHECK: (func $caller_nested_noreturn (type $0) (result i32) + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (block + ;; CHECK-NEXT: (call $noreturn) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + (func $caller_nested_noreturn (export "caller_nested_noreturn") (result i32) + ;; Passing a noreturn call directly into a parameter of another noreturn call + ;; leaves removeOperands's result already unreachable before the outer check. + (drop + (call $unused_param + (call $noreturn) + ) + ) + (i32.const 0) + ) + + ;; CHECK: (func $unused_param (type $1) + ;; CHECK-NEXT: (local $unused i32) + ;; CHECK-NEXT: (unreachable) + ;; CHECK-NEXT: ) + (func $unused_param (param $unused i32) (result i32) + (unreachable) + ) +)