[NFC] Refactor GUFA's NullLocation and CaughtExnRefLocation into RootLocation (#7822)

Both locations are just roots in the graph: sources of info that we will never
learn any more about, and hence fixed.

Author: kripken

src/ir/possible-contents.cpp

@@ -891,15 +891,25 @@ struct InfoCollector
     handleIndirectCall(curr, curr->target->type);
   }
 
-  // Creates a location for a null of a particular type and adds a root for it.
-  // Such roots are where the default value of an i32 local comes from, or the
-  // value in a ref.null.
-  Location getNullLocation(Type type) {
-    auto location = NullLocation{type};
-    addRoot(location, PossibleContents::literal(Literal::makeZero(type)));
+  // Creates a location for a root of a particular type, creating a RootLocation
+  // and marking it as a root.
+  Location getRootLocation(Type type, PossibleContents rootValue) {
+    auto location = RootLocation{type};
+    addRoot(location, rootValue);
     return location;
   }
 
+  // Creates a root location, settings its value by the type.
+  Location getRootLocation(Type type) {
+    return getRootLocation(type, PossibleContents::fromType(type));
+  }
+
+  // Makes a root location containing a null.
+  Location getNullLocation(Type type) {
+    return getRootLocation(type,
+                           PossibleContents::literal(Literal::makeZero(type)));
+  }
+
   // Iterates over a list of children and adds links from them. The target of
   // those link is created using a function that is passed in, which receives
   // the index of the child.
@@ -1220,9 +1230,7 @@ struct InfoCollector
       }
 
       if (curr->catchRefs[tagIndex]) {
-        auto location = CaughtExnRefLocation{};
-        addRoot(location,
-                PossibleContents::fromType(Type(HeapType::exn, NonNullable)));
+        auto location = getRootLocation(Type(HeapType::exn, NonNullable));
         info.links.push_back(
           {location, getBreakTargetLocation(target, exnrefIndex)});
       }
@@ -3062,8 +3070,8 @@ void Flower::dump(Location location) {
     std::cout << "  sigparamloc " << '\n';
   } else if (auto* loc = std::get_if<SignatureResultLocation>(&location)) {
     std::cout << "  sigresultloc " << loc->type << " : " << loc->index << '\n';
-  } else if (auto* loc = std::get_if<NullLocation>(&location)) {
-    std::cout << "  Nullloc " << loc->type << '\n';
+  } else if (auto* loc = std::get_if<RootLocation>(&location)) {
+    std::cout << "  rootloc " << loc->type << '\n';
   } else {
     std::cout << "  (other)\n";
   }

src/ir/possible-contents.h

@@ -500,20 +500,17 @@ struct TagLocation {
   }
 };
 
-// The location of an exnref materialized by a catch_ref or catch_all_ref clause
-// of a try_table. No data is stored here. exnrefs contain a tag and a payload
-// at run-time, as well as potential metadata such as stack traces, but we don't
-// track that. So this is the same as NullLocation in a way: we just need *a*
-// source of contents for places that receive an exnref.
-struct CaughtExnRefLocation {
-  bool operator==(const CaughtExnRefLocation& other) const { return true; }
-};
-
-// A null value. This is used as the location of the default value of a var in a
-// function, a null written to a struct field in struct.new_with_default, etc.
-struct NullLocation {
+// A root value. This is used as the location of the default value of a var in a
+// function, a null written to a struct field in struct.new_with_default, an
+// exnref from a catch etc. - in all these cases, we know
+//
+//  1. The value (which might be a null, or "anything of this type").
+//  2. That the value will never change; we can learn nothing more here.
+//  3. That all roots of this type can share the same location.
+//
+struct RootLocation {
   Type type;
-  bool operator==(const NullLocation& other) const {
+  bool operator==(const RootLocation& other) const {
     return type == other.type;
   }
 };
@@ -555,8 +552,7 @@ using Location = std::variant<ExpressionLocation,
                               SignatureResultLocation,
                               DataLocation,
                               TagLocation,
-                              CaughtExnRefLocation,
-                              NullLocation,
+                              RootLocation,
                               ConeReadLocation>;
 
 } // namespace wasm
@@ -637,14 +633,8 @@ template<> struct hash<wasm::TagLocation> {
   }
 };
 
-template<> struct hash<wasm::CaughtExnRefLocation> {
-  size_t operator()(const wasm::CaughtExnRefLocation& loc) const {
-    return std::hash<const void*>()("caught-exnref-location");
-  }
-};
-
-template<> struct hash<wasm::NullLocation> {
-  size_t operator()(const wasm::NullLocation& loc) const {
+template<> struct hash<wasm::RootLocation> {
+  size_t operator()(const wasm::RootLocation& loc) const {
     return std::hash<wasm::Type>{}(loc.type);
   }
 };