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) + ) +)