Handle arbitrary copies in CFP (#7900)

We previously special-cased copies from a field to itself in CFP.
Generalize the analysis to handle copies from any field in any type to
any field in any type. Along with this change, make the entire analysis
more precise by explicit analyzing the written values, analyzing the
readable values that result from the written values, then propagating
readable values back to the writable values via copies and iterating
until a fixed point. Use custom propagation logic after applying the
copies the first time to minimize the amount of work done when
propagating.

Author: tlively

src/ir/possible-constant.h

@@ -20,6 +20,7 @@
 #include <variant>
 
 #include "ir/properties.h"
+#include "support/utilities.h"
 #include "wasm-builder.h"
 #include "wasm.h"
 
@@ -85,6 +86,45 @@ struct PossibleConstantValues {
   // identify a constant value here.
   void noteUnknown() { value = Many(); }
 
+  // Modify the possible constant to account for being written to or read from a
+  // possibly-packed field. When used to model a read, `isSigned` controls
+  // whether the value will be sign-extended or not.
+  void packForField(const Field& field, bool isSigned = false) {
+    if (field.type != Type::i32 || !field.isPacked()) {
+      return;
+    }
+    if (!isConstant()) {
+      // Nothing to pack.
+      return;
+    }
+    if (isConstantGlobal()) {
+      // Cannot track global and bit masking simultaneously, so give up.
+      noteUnknown();
+      return;
+    }
+    assert(isConstantLiteral());
+    auto val = getConstantLiteral();
+    assert(val.type == Type::i32);
+    switch (field.packedType) {
+      case Field::i8:
+        if (isSigned) {
+          value = val.extendS8();
+        } else {
+          value = val.and_(Literal(uint32_t(0xff)));
+        }
+        break;
+      case Field::i16:
+        if (isSigned) {
+          value = val.extendS16();
+        } else {
+          value = val.and_(Literal(uint32_t(0xffff)));
+        }
+        break;
+      case Field::not_packed:
+        WASM_UNREACHABLE("unexpected packed type");
+    }
+  }
+
   // Combine the information in a given PossibleConstantValues to this one. This
   // is the same as if we have called note*() on us with all the history of
   // calls to that other object.
@@ -109,28 +149,6 @@ struct PossibleConstantValues {
       return true;
     }
 
-    // Nulls compare equal, and we could consider any of the input nulls as the
-    // combination of the two (as any of them would be valid to place in the
-    // location we are working to optimize). In order to have simple symmetric
-    // behavior here, which does not depend on the order of the inputs, use the
-    // LUB.
-    if (isNull() && other.isNull()) {
-      auto type = getConstantLiteral().type.getHeapType();
-      auto otherType = other.getConstantLiteral().type.getHeapType();
-      auto lub = HeapType::getLeastUpperBound(type, otherType);
-      if (!lub) {
-        // TODO: Remove this workaround once we have bottom types to assign to
-        // null literals.
-        value = Many();
-        return true;
-      }
-      if (*lub != type) {
-        value = Literal::makeNull(*lub);
-        return true;
-      }
-      return false;
-    }
-
     return false;
   }