From ad6cbcf8c31033b41984a345416233e546fff0eb Mon Sep 17 00:00:00 2001 From: Thomas Lively Date: Thu, 19 Nov 2026 10:13:30 -0800 Subject: [PATCH] [DAE2] Skip redundant non-nullable local fixups Optimizer already fixes up non-nullable locals whose parameters were removed before global type rewriting runs. Override requiresNonNullableLocalFixups() on DAE2 to skip PassRunner's redundant whole-module fixup pass. --- src/passes/DeadArgumentElimination2.cpp | 4 ++ test/lit/passes/dae2.wast | 59 +++++++++++++++++++++++++ 2 files changed, 63 insertions(+) diff --git a/src/passes/DeadArgumentElimination2.cpp b/src/passes/DeadArgumentElimination2.cpp index e40f1379272..0f976a2bb16 100644 --- a/src/passes/DeadArgumentElimination2.cpp +++ b/src/passes/DeadArgumentElimination2.cpp @@ -247,6 +247,10 @@ struct DAE2 : public Pass { // This pass changes locals and parameters. bool invalidatesDWARF() override { return true; } + // Optimizer already handles non-nullable local fixups on modified functions + // before global type rewriting updates referenced function types. + bool requiresNonNullableLocalFixups() override { return false; } + // Analysis lattice. Used used; diff --git a/test/lit/passes/dae2.wast b/test/lit/passes/dae2.wast index 94d184f8486..8390b0089cb 100644 --- a/test/lit/passes/dae2.wast +++ b/test/lit/passes/dae2.wast @@ -3599,6 +3599,65 @@ ) ) +(module + ;; CHECK: (type $0 (func (param i32))) + + ;; CHECK: (global $g (mut anyref) (ref.null none)) + (global $g (mut anyref) (ref.null none)) + + ;; CHECK: (func $test (type $0) (param $x i32) + ;; CHECK-NEXT: (local $unused anyref) + ;; CHECK-NEXT: (if + ;; CHECK-NEXT: (local.get $x) + ;; CHECK-NEXT: (then + ;; CHECK-NEXT: (local.set $unused + ;; CHECK-NEXT: (ref.i31 + ;; CHECK-NEXT: (i32.const 0) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (else + ;; CHECK-NEXT: (local.set $unused + ;; CHECK-NEXT: (ref.i31 + ;; CHECK-NEXT: (i32.const 1) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: (global.set $g + ;; CHECK-NEXT: (ref.as_non_null + ;; CHECK-NEXT: (local.get $unused) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + ;; CHECK-NEXT: ) + (func $test (param $unused (ref any)) (param $x i32) + ;; The initial parameter value is never read because both arms overwrite + ;; $unused before the global.set. Removing the parameter turns $unused into + ;; a non-nullable local whose sets do not structurally dominate the get, so + ;; Optimizer must handle the fixup internally. + (if + (local.get $x) + (then + (local.set $unused + (ref.i31 + (i32.const 0) + ) + ) + ) + (else + (local.set $unused + (ref.i31 + (i32.const 1) + ) + ) + ) + ) + (global.set $g + (local.get $unused) + ) + ) +) + (module ;; CHECK: (type $struct (struct)) (type $struct (struct))