Add a MarkNoReturn pass

scripts/fuzz_opt.py

@@ -2723,6 +2723,7 @@ def write_commands(commands, filename):
     ("--generate-stack-ir",),
     ("--licm",),
     ("--local-subtyping",),
+    ("--mark-noreturn",),
     ("--memory-packing",),
     ("--merge-blocks",),
     ('--merge-locals',),

src/ir/lubs.cpp

@@ -23,17 +23,20 @@ namespace wasm {
 
 namespace LUB {
 
-LUBFinder getResultsLUB(Function* func, Module& wasm) {
+LUBFinder getResultsLUB(Function* func, Module& wasm, Mode mode) {
   LUBFinder lub;
 
-  if (!wasm.features.hasGC()) {
-    return lub;
-  }
-
   Type originalType = func->getResults();
-  if (!originalType.hasRef()) {
-    // Nothing to refine.
-    return lub;
+
+  if (mode == RefinableTypesOnly) {
+    if (!wasm.features.hasGC()) {
+      return lub;
+    }
+
+    if (!originalType.hasRef()) {
+      // Nothing to refine.
+      return lub;
+    }
   }
 
   // Before we do anything, we must refinalize the function, because otherwise
@@ -57,8 +60,13 @@ LUBFinder getResultsLUB(Function* func, Module& wasm) {
 
     Finder(Module& wasm, LUBFinder& lub) : wasm(wasm), lub(lub) {}
 
-    void visitReturn(Return* curr) { lub.note(curr->value->type); }
+    void visitReturn(Return* curr) {
+      lub.note(curr->value ? curr->value->type : Type::none);
+    }
     void visitCall(Call* curr) {
+      // TODO: propagation through calls (if the called function does not
+      //       return, we do not; also the tail-called function's results can
+      //       be taken into account)
       if (curr->isReturn) {
         lub.note(wasm.getFunction(curr->target)->getResults());
       }

src/ir/lubs.h

@@ -65,7 +65,20 @@ namespace LUB {
 // it does a refinalize in order to be able to compute the new types. We could
 // roll back that change, but it's not harmful and can help, so we keep it
 // regardless.
-LUBFinder getResultsLUB(Function* func, Module& wasm);
+enum Mode {
+  // In the default mode, we only look for types we can refine: GC types. This
+  // is used in passes that refine function results.
+  RefinableTypesOnly,
+
+  // We can also look for all results, including MVP types and none (no result).
+  // These cannot be normally refined, but we may find that that there is no
+  // return at all, in which case their effective return type is unreachable,
+  // and callers know that calls to them do not return.
+  AllResults
+};
+
+LUBFinder
+getResultsLUB(Function* func, Module& wasm, Mode mode = RefinableTypesOnly);
 
 } // namespace LUB
 

src/passes/CMakeLists.txt

@@ -68,6 +68,7 @@ set(passes_SOURCES
   LoopInvariantCodeMotion.cpp
   MakeSharedObjects.cpp
   MarkJSCalled.cpp
+  MarkNoReturn.cpp
   Memory64Lowering.cpp
   MemoryPacking.cpp
   MergeBlocks.cpp

src/passes/MarkNoReturn.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//
+// Applies @binaryen.noreturn to relevant functions. The OptimizeNoReturn pass
+// can then use that information.
+//
+// This pass is not run by default, as then the annotations would persist if the
+// user forgets to strip them. TODO: perhaps run this by default but also clean
+// up the annotations at the end of the pipeline?
+//
+
+#include "ir/lubs.h"
+#include "pass.h"
+#include "wasm.h"
+
+namespace wasm {
+
+struct MarkNoReturn : public Pass {
+  void run(Module* module) override {
+    // MarkNoReturn itself cannot be function-parallel, as it adds
+    // annotations, which could race with passes that read them. We are
+    // therefore a module-level pass, internally parallel.
+    struct Inner : public WalkerPass<PostWalker<Inner>> {
+      bool isFunctionParallel() override { return true; }
+
+      std::unique_ptr<Pass> create() override {
+        return std::make_unique<Inner>();
+      }
+
+      void doWalkFunction(Function* func) {
+        if (!LUB::getResultsLUB(func, *getModule(), LUB::AllResults).noted()) {
+          func->funcAnnotations.noReturn = true;
+        }
+      }
+    };
+
+    Inner().run(getPassRunner(), module);
+  }
+};
+
+Pass* createMarkNoReturnPass() { return new MarkNoReturn(); }
+
+} // namespace wasm

src/passes/pass.cpp

@@ -286,6 +286,9 @@ void PassRegistry::registerPasses() {
   registerPass("mark-js-called",
                "mark js called functions (using configureAll) as doing so",
                createMarkJSCalledPass);
+  registerPass("mark-noreturn",
+               "mark functions that do not return, enabling later opts",
+               createMarkNoReturnPass);
   registerPass("memory64-lowering",
                "lower loads and stores to a 64-bit memory to instead use a "
                "32-bit one",

src/passes/passes.h

@@ -90,6 +90,7 @@ Pass* createLLVMMemoryCopyFillLoweringPass();
 Pass* createLoopInvariantCodeMotionPass();
 Pass* createMakeSharedObjectsPass();
 Pass* createMarkJSCalledPass();
+Pass* createMarkNoReturnPass();
 Pass* createMemory64LoweringPass();
 Pass* createMemoryPackingPass();
 Pass* createMergeBlocksPass();

test/lit/help/wasm-metadce.test

@@ -265,6 +265,9 @@
 ;; CHECK-NEXT:   --mark-js-called                              mark js called functions (using 
 ;; CHECK-NEXT:                                                 configureAll) as doing so
 ;; CHECK-EMPTY:
+;; CHECK-NEXT:   --mark-noreturn                               mark functions that do not 
+;; CHECK-NEXT:                                                 return, enabling later opts
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --memory-packing                              packs memory into separate 
 ;; CHECK-NEXT:                                                 segments, skipping zeros
 ;; CHECK-EMPTY:

test/lit/help/wasm-opt.test

@@ -310,6 +310,9 @@
 ;; CHECK-NEXT:   --mark-js-called                              mark js called functions (using 
 ;; CHECK-NEXT:                                                 configureAll) as doing so
 ;; CHECK-EMPTY:
+;; CHECK-NEXT:   --mark-noreturn                               mark functions that do not 
+;; CHECK-NEXT:                                                 return, enabling later opts
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --memory-packing                              packs memory into separate 
 ;; CHECK-NEXT:                                                 segments, skipping zeros
 ;; CHECK-EMPTY:

test/lit/help/wasm2js.test

@@ -229,6 +229,9 @@
 ;; CHECK-NEXT:   --mark-js-called                              mark js called functions (using 
 ;; CHECK-NEXT:                                                 configureAll) as doing so
 ;; CHECK-EMPTY:
+;; CHECK-NEXT:   --mark-noreturn                               mark functions that do not 
+;; CHECK-NEXT:                                                 return, enabling later opts
+;; CHECK-EMPTY:
 ;; CHECK-NEXT:   --memory-packing                              packs memory into separate 
 ;; CHECK-NEXT:                                                 segments, skipping zeros
 ;; CHECK-EMPTY:

test/lit/passes/mark-noreturn.wast

@@ -0,0 +1,62 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
+
+;; RUN: foreach %s %t wasm-opt --mark-noreturn -all -S -o - | filecheck %s
+
+(module
+ ;; CHECK:      (type $0 (func))
+
+ ;; CHECK:      (type $1 (func (result i32)))
+
+ ;; CHECK:      (type $2 (func (result anyref)))
+
+ ;; CHECK:      (func $none (type $0)
+ ;; CHECK-NEXT:  (nop)
+ ;; CHECK-NEXT: )
+ (func $none
+  ;; Nothing happens here.
+  (nop)
+ )
+
+ ;; CHECK:      (@binaryen.noreturn)
+ ;; CHECK-NEXT: (func $none-noreturn (type $0)
+ ;; CHECK-NEXT:  (unreachable)
+ ;; CHECK-NEXT: )
+ (func $none-noreturn
+  ;; This never returns, and will be annotated with @binaryen.noreturn.
+  (unreachable)
+ )
+
+ ;; CHECK:      (func $i32 (type $1) (result i32)
+ ;; CHECK-NEXT:  (i32.const 42)
+ ;; CHECK-NEXT: )
+ (func $i32 (result i32)
+  ;; Nothing happens here.
+  (i32.const 42)
+ )
+
+ ;; CHECK:      (@binaryen.noreturn)
+ ;; CHECK-NEXT: (func $i32-noreturn (type $1) (result i32)
+ ;; CHECK-NEXT:  (unreachable)
+ ;; CHECK-NEXT: )
+ (func $i32-noreturn (result i32)
+  ;; This never returns, and will be annotated with @binaryen.noreturn.
+  (unreachable)
+ )
+
+ ;; CHECK:      (func $gc (type $2) (result anyref)
+ ;; CHECK-NEXT:  (ref.null none)
+ ;; CHECK-NEXT: )
+ (func $gc (result anyref)
+  ;; Nothing happens here.
+  (ref.null any)
+ )
+
+ ;; CHECK:      (@binaryen.noreturn)
+ ;; CHECK-NEXT: (func $gc-noreturn (type $2) (result anyref)
+ ;; CHECK-NEXT:  (unreachable)
+ ;; CHECK-NEXT: )
+ (func $gc-noreturn (result anyref)
+  ;; This never returns, and will be annotated with @binaryen.noreturn.
+  (unreachable)
+ )
+)