[GC] Add a TypeRefiningGUFA pass (#7433)

This variation of TypeRefining uses GUFA to determine what types to refine
struct fields to. GUFA does a (slow) whole-program analysis which can infer
things the normal pass cannot, e.g. refinements that contain cycles through
things like locals or globals.

This is mainly a proof of concept, as it is pretty slow to compute GUFA just
for this, and while I see improvements on real-world code, they are minor.
If we find that the benefits here are worth it, a larger refactoring could
do this optimization in the existing GUFA pass (which already does the
computation of the graph anyhow).

Author: kripken

scripts/fuzz_opt.py

@@ -2005,6 +2005,7 @@ def write_commands(commands, filename):
     ("--tuple-optimization",),
     ("--type-finalizing",),
     ("--type-refining",),
+    ("--type-refining-gufa",),
     ("--type-merging",),
     ("--type-ssa",),
     ("--type-unfinalizing",),
@@ -2014,6 +2015,7 @@ def write_commands(commands, filename):
 
 # TODO: Fix these passes so that they still work without --closed-world!
 requires_closed_world = {("--type-refining",),
+                         ("--type-refining-gufa",),
                          ("--signature-pruning",),
                          ("--signature-refining",),
                          ("--gto",),

src/passes/TypeRefining.cpp

@@ -18,8 +18,15 @@
 // Apply more specific subtypes to type fields where possible, where all the
 // writes to that field in the entire program allow doing so.
 //
+// TODO: handle arrays and not just structs.
+//
+// The GUFA variant of this uses GUFA to infer types, which performs a (slow)
+// whole-program inference, rather than just scan struct/array operations by
+// themselves.
+//
 
 #include "ir/lubs.h"
+#include "ir/possible-contents.h"
 #include "ir/struct-utils.h"
 #include "ir/type-updating.h"
 #include "ir/utils.h"
@@ -104,8 +111,16 @@ struct TypeRefining : public Pass {
   // Only affects GC type declarations and struct.gets.
   bool requiresNonNullableLocalFixups() override { return false; }
 
+  bool gufa;
+
+  TypeRefining(bool gufa) : gufa(gufa) {}
+
+  // The final information we inferred about struct usage, that we then use to
+  // optimize.
   StructUtils::StructValuesMap<FieldInfo> finalInfos;
 
+  using Propagator = StructUtils::TypeHierarchyPropagator<FieldInfo>;
+
   void run(Module* module) override {
     if (!module->features.hasGC()) {
       return;
@@ -115,6 +130,20 @@ struct TypeRefining : public Pass {
       Fatal() << "TypeRefining requires --closed-world";
     }
 
+    Propagator propagator(*module);
+
+    // Compute our main data structure, finalInfos, either normally or using
+    // GUFA.
+    if (!gufa) {
+      computeFinalInfos(module, propagator);
+    } else {
+      computeFinalInfosGUFA(module, propagator);
+    }
+
+    useFinalInfos(module, propagator);
+  }
+
+  void computeFinalInfos(Module* module, Propagator& propagator) {
     // Find and analyze struct operations inside each function.
     StructUtils::FunctionStructValuesMap<FieldInfo> functionNewInfos(*module),
       functionSetGetInfos(*module);
@@ -132,14 +161,39 @@ struct TypeRefining : public Pass {
     // able to contain that type. Propagate things written using set to subtypes
     // as well, as the reference might be to a supertype if the field is present
     // there.
-    StructUtils::TypeHierarchyPropagator<FieldInfo> propagator(*module);
     propagator.propagateToSuperTypes(combinedNewInfos);
     propagator.propagateToSuperAndSubTypes(combinedSetGetInfos);
 
     // Combine everything together.
     combinedNewInfos.combineInto(finalInfos);
     combinedSetGetInfos.combineInto(finalInfos);
+  }
+
+  void computeFinalInfosGUFA(Module* module, Propagator& propagator) {
+    // Compute the oracle, then simply apply it.
+    // TODO: Consider doing this in GUFA.cpp, where we already computed the
+    //       oracle. That would require refactoring out the rest of this pass to
+    //       a shared location. Alternatively, perhaps we can reuse the computed
+    //       oracle, but any pass that changes anything would need to invalidate
+    //       it...
+    ContentOracle oracle(*module, getPassOptions());
+    auto allTypes = ModuleUtils::collectHeapTypes(*module);
+    for (auto type : allTypes) {
+      if (type.isStruct()) {
+        auto& fields = type.getStruct().fields;
+        auto& infos = finalInfos[type];
+        for (Index i = 0; i < fields.size(); i++) {
+          auto gufaType = oracle.getContents(DataLocation{type, i}).getType();
+          infos[i] = LUBFinder(gufaType);
+        }
+      }
+    }
+
+    // Propagate to supertypes, so no field is less refined than its super.
+    propagator.propagateToSuperTypes(finalInfos);
+  }
 
+  void useFinalInfos(Module* module, Propagator& propagator) {
     // While we do the following work, see if we have anything to optimize, so
     // that we can avoid wasteful work later if not.
     bool canOptimize = false;
@@ -427,6 +481,7 @@ struct TypeRefining : public Pass {
 
 } // anonymous namespace
 
-Pass* createTypeRefiningPass() { return new TypeRefining(); }
+Pass* createTypeRefiningPass() { return new TypeRefining(false); }
+Pass* createTypeRefiningGUFAPass() { return new TypeRefining(true); }
 
 } // namespace wasm

src/passes/pass.cpp

@@ -214,6 +214,10 @@ void PassRegistry::registerPasses() {
   registerPass("type-refining",
                "apply more specific subtypes to type fields where possible",
                createTypeRefiningPass);
+  registerPass("type-refining-gufa",
+               "apply more specific subtypes to type fields where possible "
+               "(using GUFA)",
+               createTypeRefiningGUFAPass);
   registerPass(
     "heap2local", "replace GC allocations with locals", createHeap2LocalPass);
   registerPass("heap-store-optimization",

src/passes/passes.h

@@ -183,6 +183,7 @@ Pass* createTrapModeJS();
 Pass* createTupleOptimizationPass();
 Pass* createTypeGeneralizingPass();
 Pass* createTypeRefiningPass();
+Pass* createTypeRefiningGUFAPass();
 Pass* createTypeFinalizingPass();
 Pass* createTypeMergingPass();
 Pass* createTypeSSAPass();

test/lit/help/wasm-metadce.test

@@ -554,6 +554,10 @@
 ;; CHECK-NEXT:   --type-refining                               apply more specific subtypes to
 ;; CHECK-NEXT:                                                 type fields where possible
 ;; CHECK-NEXT:
+;; CHECK-NEXT:   --type-refining-gufa                          apply more specific subtypes to
+;; CHECK-NEXT:                                                 type fields where possible
+;; CHECK-NEXT:                                                 (using GUFA)
+;; CHECK-NEXT:
 ;; CHECK-NEXT:   --type-ssa                                    create new nominal types to help
 ;; CHECK-NEXT:                                                 other optimizations
 ;; CHECK-NEXT:

test/lit/help/wasm-opt.test

@@ -566,6 +566,10 @@
 ;; CHECK-NEXT:   --type-refining                               apply more specific subtypes to
 ;; CHECK-NEXT:                                                 type fields where possible
 ;; CHECK-NEXT:
+;; CHECK-NEXT:   --type-refining-gufa                          apply more specific subtypes to
+;; CHECK-NEXT:                                                 type fields where possible
+;; CHECK-NEXT:                                                 (using GUFA)
+;; CHECK-NEXT:
 ;; CHECK-NEXT:   --type-ssa                                    create new nominal types to help
 ;; CHECK-NEXT:                                                 other optimizations
 ;; CHECK-NEXT:

test/lit/help/wasm2js.test

@@ -518,6 +518,10 @@
 ;; CHECK-NEXT:   --type-refining                               apply more specific subtypes to
 ;; CHECK-NEXT:                                                 type fields where possible
 ;; CHECK-NEXT:
+;; CHECK-NEXT:   --type-refining-gufa                          apply more specific subtypes to
+;; CHECK-NEXT:                                                 type fields where possible
+;; CHECK-NEXT:                                                 (using GUFA)
+;; CHECK-NEXT:
 ;; CHECK-NEXT:   --type-ssa                                    create new nominal types to help
 ;; CHECK-NEXT:                                                 other optimizations
 ;; CHECK-NEXT: