[Wasm GC] Update nulls to allow finding better LUBs (#4340)

It is common in GC code to have stuff like this:

x = null;
..
x = Data();

Nulls in wasm have a type, and if that initial null has say anyref then
before this PR we would keep the type of x as anyref. However,
while nulls have types, all null values are identical, and so we can
in fact change x's type to a nullable reference of Data, by also
changing the null's type to something more specific.

LUBFinder now has an API that can return the best possible LUB
so far, and that can be told to update nulls if we decide that the
new LUB is worth using. This updates the passes using LUBFinder
to use the new API. Note how TypeRefining becomes simpler
because the special logic it had in a subclass of LUBFinder is now
part of the main class (it used to remember if there was a null
default; LUBFinder now handles both a null default as well as
other nulls).

This requires some changes to existing tests to avoid them from
optimizing using nulls in ways that ends up not testing the
original intent. Specifically the dae-gc-refine-params.wast now
has calls to get a null of a type, instead of just having a ref.null
of that type (which could be optimized now). And
dae-gc-refine-return uses locals instead of ref.nulls.

1 files changed, 49 insertions, 0 deletions

diff --git a/test/lit/passes/local-subtyping.wast b/test/lit/passes/local-subtyping.wast
index f655eba1e..99a59d005 100644
--- a/test/lit/passes/local-subtyping.wast
+++ b/test/lit/passes/local-subtyping.wast
@@ -3,6 +3,12 @@
 ;; RUN:   | filecheck %s
 
 (module
+  ;; CHECK:      (type ${} (struct ))
+  (type ${} (struct_subtype data))
+
+  ;; CHECK:      (type ${i32} (struct (field i32)))
+  (type ${i32} (struct_subtype (field i32) data))
+
   ;; CHECK:      (import "out" "i32" (func $i32 (result i32)))
   (import "out" "i32" (func $i32 (result i32)))
   ;; CHECK:      (import "out" "i64" (func $i64 (result i64)))
@@ -333,4 +339,47 @@
     )
     (unreachable)
   )
+
+  ;; CHECK:      (func $update-nulls
+  ;; CHECK-NEXT:  (local $x (ref null ${}))
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (ref.null ${})
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (ref.null ${})
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (struct.new_default ${})
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (ref.null ${})
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (ref.null ${})
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (ref.null ${})
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (ref.null ${i32})
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $update-nulls
+    (local $x anyref)
+    (local.set $x (ref.null any))
+    (local.set $x (ref.null eq))
+    ;; All the nulls can be changed into other nulls here, for the new LUB,
+    ;; which will be ${}
+    (local.set $x (struct.new ${}))
+    (local.set $x (ref.null data))
+    ;; Note that this func null is even of a type that is incompatible with the
+    ;; new lub (func vs data). Still, we can just update it along with the
+    ;; others.
+    (local.set $x (ref.null func))
+    ;; This null is equal to the LUB we'll find, and will not change.
+    (local.set $x (ref.null ${}))
+    ;; This null is more specific than the LUB we'll find, and will not change,
+    ;; as there is no point to making something less specific in type.
+    (local.set $x (ref.null ${i32}))
+  )
 )