[Wasm GC] Support non-nullable locals in the "1a" form (#4959)

An overview of this is in the README in the diff here (conveniently, it is near the
top of the diff). Basically, we fix up nn locals after each pass, by default. This keeps
things easy to reason about - what validates is what is valid wasm - but there are
some minor nuances as mentioned there, in particular, we ignore nameless blocks
(which are commonly added by various passes; ignoring them means we can keep
more locals non-nullable).

The key addition here is LocalStructuralDominance which checks which local
indexes have the "structural dominance" property of 1a, that is, that each get has
a set in its block or an outer block that precedes it. I optimized that function quite
a lot to reduce the overhead of running that logic after each pass. The overhead
is something like 2% on J2Wasm and 0% on Dart (0%, because in this mode we
shrink code size, so there is less work actually, and it balances out).

Since we run fixups after each pass, this PR removes logic to manually call the
fixup code from various places we used to call it (like eh-utils and various passes).

Various passes are now marked as requiresNonNullableLocalFixups => false.
That lets us skip running the fixups after them, which we normally do automatically.
This helps avoid overhead. Most passes still need the fixups, though - any pass
that adds a local, or a named block, or moves code around, likely does.

This removes a hack in SimplifyLocals that is no longer needed. Before we
worked to avoid moving a set into a try, as it might not validate. Now, we just do it
and let fixups happen automatically if they need to: in the common code they
probably don't, so the extra complexity seems not worth it.

Also removes a hack from StackIR. That hack tried to avoid roundtrip adding a
nondefaultable local. But we have the logic to fix that up now, and opts will
likely keep it non-nullable as well.

Various tests end up updated here because now a local can be non-nullable -
previous fixups are no longer needed.

Note that this doesn't remove the gc-nn-locals feature. That has been useful for
testing, and may still be useful in the future - it basically just allows nn locals in
all positions (that can't read the null default value at the entry). We can consider
removing it separately.

Fixes #4824

1 files changed, 72 insertions, 35 deletions

diff --git a/test/lit/passes/heap2local.wast b/test/lit/passes/heap2local.wast
index b7ed9bd0f..6fd744278 100644
--- a/test/lit/passes/heap2local.wast
+++ b/test/lit/passes/heap2local.wast
@@ -392,8 +392,8 @@
   )
 
   ;; CHECK:      (func $nondefaultable
-  ;; CHECK-NEXT:  (local $0 (ref null $struct.A))
-  ;; CHECK-NEXT:  (local $1 (ref null $struct.A))
+  ;; CHECK-NEXT:  (local $0 (ref $struct.A))
+  ;; CHECK-NEXT:  (local $1 (ref $struct.A))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block (result (ref $struct.A))
   ;; CHECK-NEXT:    (drop
@@ -402,22 +402,18 @@
   ;; CHECK-NEXT:       (struct.new_default $struct.A)
   ;; CHECK-NEXT:      )
   ;; CHECK-NEXT:      (local.set $0
-  ;; CHECK-NEXT:       (ref.as_non_null
-  ;; CHECK-NEXT:        (local.get $1)
-  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (local.get $1)
   ;; CHECK-NEXT:      )
   ;; CHECK-NEXT:      (ref.null $struct.nondefaultable)
   ;; CHECK-NEXT:     )
   ;; CHECK-NEXT:    )
-  ;; CHECK-NEXT:    (ref.as_non_null
-  ;; CHECK-NEXT:     (local.get $0)
-  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (local.get $0)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   ;; NOMNL:      (func $nondefaultable (type $none_=>_none)
-  ;; NOMNL-NEXT:  (local $0 (ref null $struct.A))
-  ;; NOMNL-NEXT:  (local $1 (ref null $struct.A))
+  ;; NOMNL-NEXT:  (local $0 (ref $struct.A))
+  ;; NOMNL-NEXT:  (local $1 (ref $struct.A))
   ;; NOMNL-NEXT:  (drop
   ;; NOMNL-NEXT:   (block (result (ref $struct.A))
   ;; NOMNL-NEXT:    (drop
@@ -426,23 +422,17 @@
   ;; NOMNL-NEXT:       (struct.new_default $struct.A)
   ;; NOMNL-NEXT:      )
   ;; NOMNL-NEXT:      (local.set $0
-  ;; NOMNL-NEXT:       (ref.as_non_null
-  ;; NOMNL-NEXT:        (local.get $1)
-  ;; NOMNL-NEXT:       )
+  ;; NOMNL-NEXT:       (local.get $1)
   ;; NOMNL-NEXT:      )
   ;; NOMNL-NEXT:      (ref.null $struct.nondefaultable)
   ;; NOMNL-NEXT:     )
   ;; NOMNL-NEXT:    )
-  ;; NOMNL-NEXT:    (ref.as_non_null
-  ;; NOMNL-NEXT:     (local.get $0)
-  ;; NOMNL-NEXT:    )
+  ;; NOMNL-NEXT:    (local.get $0)
   ;; NOMNL-NEXT:   )
   ;; NOMNL-NEXT:  )
   ;; NOMNL-NEXT: )
   (func $nondefaultable
-    ;; We do not optimize structs with nondefaultable types that we cannot
-    ;; handle.
-    ;; TODO: We should be able to handle this after #4824 is resolved.
+    ;; The non-nullable types here can fit in locals.
     (drop
       (struct.get $struct.nondefaultable 0
         (struct.new $struct.nondefaultable
@@ -1459,8 +1449,8 @@
   )
 
   ;; CHECK:      (func $non-nullable (param $a (ref $struct.A))
-  ;; CHECK-NEXT:  (local $1 (ref null $struct.A))
-  ;; CHECK-NEXT:  (local $2 (ref null $struct.A))
+  ;; CHECK-NEXT:  (local $1 (ref $struct.A))
+  ;; CHECK-NEXT:  (local $2 (ref $struct.A))
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block (result (ref $struct.A))
   ;; CHECK-NEXT:    (drop
@@ -1469,22 +1459,18 @@
   ;; CHECK-NEXT:       (local.get $a)
   ;; CHECK-NEXT:      )
   ;; CHECK-NEXT:      (local.set $1
-  ;; CHECK-NEXT:       (ref.as_non_null
-  ;; CHECK-NEXT:        (local.get $2)
-  ;; CHECK-NEXT:       )
+  ;; CHECK-NEXT:       (local.get $2)
   ;; CHECK-NEXT:      )
   ;; CHECK-NEXT:      (ref.null $struct.nondefaultable)
   ;; CHECK-NEXT:     )
   ;; CHECK-NEXT:    )
-  ;; CHECK-NEXT:    (ref.as_non_null
-  ;; CHECK-NEXT:     (local.get $1)
-  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (local.get $1)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   ;; NOMNL:      (func $non-nullable (type $ref|$struct.A|_=>_none) (param $a (ref $struct.A))
-  ;; NOMNL-NEXT:  (local $1 (ref null $struct.A))
-  ;; NOMNL-NEXT:  (local $2 (ref null $struct.A))
+  ;; NOMNL-NEXT:  (local $1 (ref $struct.A))
+  ;; NOMNL-NEXT:  (local $2 (ref $struct.A))
   ;; NOMNL-NEXT:  (drop
   ;; NOMNL-NEXT:   (block (result (ref $struct.A))
   ;; NOMNL-NEXT:    (drop
@@ -1493,16 +1479,12 @@
   ;; NOMNL-NEXT:       (local.get $a)
   ;; NOMNL-NEXT:      )
   ;; NOMNL-NEXT:      (local.set $1
-  ;; NOMNL-NEXT:       (ref.as_non_null
-  ;; NOMNL-NEXT:        (local.get $2)
-  ;; NOMNL-NEXT:       )
+  ;; NOMNL-NEXT:       (local.get $2)
   ;; NOMNL-NEXT:      )
   ;; NOMNL-NEXT:      (ref.null $struct.nonnullable)
   ;; NOMNL-NEXT:     )
   ;; NOMNL-NEXT:    )
-  ;; NOMNL-NEXT:    (ref.as_non_null
-  ;; NOMNL-NEXT:     (local.get $1)
-  ;; NOMNL-NEXT:    )
+  ;; NOMNL-NEXT:    (local.get $1)
   ;; NOMNL-NEXT:   )
   ;; NOMNL-NEXT:  )
   ;; NOMNL-NEXT: )
@@ -2826,4 +2808,59 @@
       )
     )
   )
+
+  ;; CHECK:      (func $non-nullable-local (result anyref)
+  ;; CHECK-NEXT:  (local $0 (ref null $struct.A))
+  ;; CHECK-NEXT:  (local $1 i32)
+  ;; CHECK-NEXT:  (local $2 f64)
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (block (result (ref null $struct.A))
+  ;; CHECK-NEXT:    (local.set $1
+  ;; CHECK-NEXT:     (i32.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (local.set $2
+  ;; CHECK-NEXT:     (f64.const 0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:    (ref.null $struct.A)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (unreachable)
+  ;; CHECK-NEXT:  (ref.as_non_null
+  ;; CHECK-NEXT:   (local.get $0)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; NOMNL:      (func $non-nullable-local (type $none_=>_anyref) (result anyref)
+  ;; NOMNL-NEXT:  (local $0 (ref null $struct.A))
+  ;; NOMNL-NEXT:  (local $1 i32)
+  ;; NOMNL-NEXT:  (local $2 f64)
+  ;; NOMNL-NEXT:  (drop
+  ;; NOMNL-NEXT:   (block (result (ref null $struct.A))
+  ;; NOMNL-NEXT:    (local.set $1
+  ;; NOMNL-NEXT:     (i32.const 0)
+  ;; NOMNL-NEXT:    )
+  ;; NOMNL-NEXT:    (local.set $2
+  ;; NOMNL-NEXT:     (f64.const 0)
+  ;; NOMNL-NEXT:    )
+  ;; NOMNL-NEXT:    (ref.null $struct.A)
+  ;; NOMNL-NEXT:   )
+  ;; NOMNL-NEXT:  )
+  ;; NOMNL-NEXT:  (unreachable)
+  ;; NOMNL-NEXT:  (ref.as_non_null
+  ;; NOMNL-NEXT:   (local.get $0)
+  ;; NOMNL-NEXT:  )
+  ;; NOMNL-NEXT: )
+  (func $non-nullable-local (result anyref)
+   (local $0 (ref $struct.A))
+   ;; The local.get here is in unreachable code, which means we won't do
+   ;; anything to it. But when we remove the local.set during optimization (we
+   ;; can replace it with new locals for the fields of $struct.A), we must make
+   ;; sure that validation still passes, that is, since the local.get is
+   ;; around we must have a local.set for it, or it must become nullable (which
+   ;; is what the fixup will do).
+   (local.set $0
+    (struct.new_default $struct.A)
+   )
+   (unreachable)
+   (local.get $0)
+  )
 )