Allow GSI to work with supertype globals (#7594)

GSI previously only optimized globals whose types were the same as their
initializer's types to ensure the glboal types were equality comparable.
However, this is an overly conservative restriction because the global
can have any type up to eqref without causing problems. Update the
restriction to be more precise.

This will help the GSI tests continue working once `struct.new` is typed
as exact.

Author: tlively

src/passes/GlobalStructInference.cpp

@@ -137,12 +137,9 @@ struct GlobalStructInference : public Pass {
 
       auto type = global->init->type.getHeapType();
 
-      // The global's declared type must match the init's type. If not, say if
-      // we had a global declared as type |any| but that contains (ref $A), then
-      // that is not something we can optimize, as ref.eq on a global.get of
-      // that global will not validate. (This should not be a problem after
-      // GlobalSubtyping runs, which will specialize the type of the global.)
-      if (global->type != global->init->type) {
+      // The global's declared type must be equality comparable.
+      if (auto eq = wasm::HeapTypes::eq.getBasic(type.getShared());
+          !Type::isSubType(global->type, Type(eq, Nullable))) {
         unoptimizable.insert(type);
         continue;
       }

test/lit/passes/gsi.wast

@@ -2156,3 +2156,88 @@
     )
   )
 )
+
+;; The basic case, but now the globals have type eqref. This should still work.
+(module
+  ;; CHECK:      (type $struct (struct (field i32)))
+  (type $struct (struct i32))
+
+  ;; CHECK:      (type $1 (func (param (ref null $struct))))
+
+  ;; CHECK:      (global $global1 eqref (struct.new $struct
+  ;; CHECK-NEXT:  (i32.const 42)
+  ;; CHECK-NEXT: ))
+  (global $global1 eqref (struct.new $struct
+    (i32.const 42)
+  ))
+
+  ;; CHECK:      (global $global2 eqref (struct.new $struct
+  ;; CHECK-NEXT:  (i32.const 1337)
+  ;; CHECK-NEXT: ))
+  (global $global2 eqref (struct.new $struct
+    (i32.const 1337)
+  ))
+
+  ;; CHECK:      (func $test (type $1) (param $struct (ref null $struct))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (select
+  ;; CHECK-NEXT:    (i32.const 42)
+  ;; CHECK-NEXT:    (i32.const 1337)
+  ;; CHECK-NEXT:    (ref.eq
+  ;; CHECK-NEXT:     (ref.as_non_null
+  ;; CHECK-NEXT:      (local.get $struct)
+  ;; CHECK-NEXT:     )
+  ;; CHECK-NEXT:     (global.get $global1)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (param $struct (ref null $struct))
+    ;; We can infer that this get can reference either $global1 or $global2,
+    ;; and nothing else (aside from a null), and can emit a select between
+    ;; those values.
+    (drop
+      (struct.get $struct 0
+        (local.get $struct)
+      )
+    )
+  )
+)
+
+;; Same, but now the globals have type anyref, so they are not comparable and we
+;; cannot optimize.
+(module
+  ;; CHECK:      (type $struct (struct (field i32)))
+  (type $struct (struct i32))
+
+  ;; CHECK:      (type $1 (func (param (ref null $struct))))
+
+  ;; CHECK:      (global $global1 anyref (struct.new $struct
+  ;; CHECK-NEXT:  (i32.const 42)
+  ;; CHECK-NEXT: ))
+  (global $global1 anyref (struct.new $struct
+    (i32.const 42)
+  ))
+
+  ;; CHECK:      (global $global2 anyref (struct.new $struct
+  ;; CHECK-NEXT:  (i32.const 1337)
+  ;; CHECK-NEXT: ))
+  (global $global2 anyref (struct.new $struct
+    (i32.const 1337)
+  ))
+
+  ;; CHECK:      (func $test (type $1) (param $struct (ref null $struct))
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (struct.get $struct 0
+  ;; CHECK-NEXT:    (local.get $struct)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $test (param $struct (ref null $struct))
+    (drop
+      (struct.get $struct 0
+        (local.get $struct)
+      )
+    )
+  )
+)