Add a ConstraintAnalysis pass

src/ir/constraint.cpp

@@ -77,6 +77,12 @@ Result provesPair(const Constraint& a, const Constraint& b) {
 } // anonymous namespace
 
 Result AndedConstraintSet::proves(const Constraint& condition) const {
+  if (provesEverything()) {
+    return True;
+  }
+  // Note we do not need to handle the provesNothing case in a special way: the
+  // loop below finds nothing.
+
   // Sometimes a single constraint is enough to determine the condition.
   for (auto& c : *this) {
     auto result = provesPair(c, condition);
@@ -92,11 +98,15 @@ Result AndedConstraintSet::proves(const Constraint& condition) const {
 }
 
 Result AndedConstraintSet::proves(const AndedConstraintSet& other) const {
-  if (other.empty()) {
-    // The empty set of constraints is always true.
+  if (provesEverything()) {
     return True;
   }
 
+  if (other.provesEverything()) {
+    // We are not a contradiction, but other is, so we prove it false.
+    return False;
+  }
+
   bool hasUnknown = false;
 
   for (auto& c : other) {
@@ -114,6 +124,17 @@ Result AndedConstraintSet::proves(const AndedConstraintSet& other) const {
 }
 
 void AndedConstraintSet::approximateAnd(const Constraint& c) {
+  if (provesEverything()) {
+    // Nothing to add.
+    return;
+  }
+
+  if (proves(c) == False) {
+    // We are now a contradiction.
+    isContradiction = true;
+    return;
+  }
+
   if (size() < MaxConstraints) {
     push_back(c);
     return;
@@ -125,13 +146,19 @@ void AndedConstraintSet::approximateAnd(const Constraint& c) {
 }
 
 void AndedConstraintSet::approximateOr(const AndedConstraintSet& other) {
-  // If one is empty (no constraints, everything is true, and we can prove
-  // nothing useful) then it does not add anything to the other.
-  if (empty()) {
+  // If one proves everything, the only thing that matters is the other.
+  if (provesEverything()) {
     *this = other;
     return;
   }
-  if (other.empty()) {
+  if (other.provesEverything()) {
+    return;
+  }
+
+  // If one proves nothing, neither does the combination.
+  if (provesNothing() || other.provesNothing()) {
+    clear();
+    assert(provesNothing());
     return;
   }
 
@@ -153,4 +180,114 @@ void AndedConstraintSet::approximateOr(const AndedConstraintSet& other) {
   clear();
 }
 
+std::optional<LocalConstraint> LocalConstraint::parse(Expression* curr) {
+  auto parseEqZArgument =
+    [&](Expression* value) -> std::optional<LocalConstraint> {
+    if (auto* get = value->dynCast<LocalGet>()) {
+      // Canonicalize EqZ to Eq of 0.
+      auto value = Literal::makeZero(get->type);
+      return LocalConstraint{get->index, Constraint{Abstract::Eq, {value}}};
+    }
+    // TODO: Recursively parse and reverse a constraint
+    return {};
+  };
+
+  if (auto* unary = curr->dynCast<Unary>()) {
+    if (Abstract::getUnary(unary->type, Abstract::EqZ) == unary->op) {
+      return parseEqZArgument(unary->value);
+    }
+    return {};
+  }
+
+  if (auto* refIsNull = curr->dynCast<RefIsNull>()) {
+    return parseEqZArgument(refIsNull->value);
+  }
+
+  // Parse a get or a constant.
+  auto parseTerm = [&](Expression* expr) -> std::optional<Term> {
+    if (auto* get = expr->dynCast<LocalGet>()) {
+      return Term{get->index};
+    }
+    if (Properties::isSingleConstantExpression(expr)) {
+      return Term{Properties::getLiteral(expr)};
+    }
+    return {};
+  };
+
+  auto parseBinaryArguments =
+    [&](Abstract::Op op,
+        Expression* left,
+        Expression* right) -> std::optional<LocalConstraint> {
+    // The left must be a get.
+    if (auto* get = left->dynCast<LocalGet>()) {
+      // The right can be any term.
+      if (auto value = parseTerm(right)) {
+        return LocalConstraint{get->index, Constraint{op, *value}};
+      }
+    }
+    return {};
+  };
+
+  if (auto* binary = curr->dynCast<Binary>()) {
+    // The operation must be one we recognize.
+    for (auto op : {Abstract::Eq, Abstract::Ne}) {
+      if (Abstract::getBinary(binary->type, op) == binary->op) {
+        return parseBinaryArguments(op, binary->left, binary->right);
+      }
+    }
+    return {};
+  }
+
+  if (auto* refEq = curr->dynCast<RefEq>()) {
+    return parseBinaryArguments(Abstract::Eq, refEq->left, refEq->right);
+  }
+
+  return {};
+}
+
+void LocalConstraintMap::approximateOr(const LocalConstraintMap& other) {
+  for (auto& [local, constraints] : other) {
+    if (auto iter = find(local); iter != end()) {
+      // This is in both: OR them.
+      iter->second.approximateOr(constraints);
+    } else {
+      // This is only in other, so apply it.
+      (*this)[local] = constraints;
+    }
+  }
+
+  // Remove things only in us.
+  std::erase_if(*this, [&](const auto& item) {
+    const auto& [local, constraints] = item;
+    return !other.contains(local);
+  });
+}
+
+std::ostream& operator<<(std::ostream& o, const Constraint& constraint) {
+  o << "Constraint{" << /*constraint.op <<*/ ", ";
+  if (auto* c = std::get_if<Literal>(&constraint.term)) {
+    o << *c;
+  } else if (auto* i = std::get_if<Index>(&constraint.term)) {
+    o << "Index(" << *i << ')';
+  }
+  o << '}';
+  return o;
+}
+
+std::ostream& operator<<(std::ostream& o,
+                         const AndedConstraintSet& constraints) {
+  o << "AndedConstraintSet{";
+  bool first = true;
+  for (auto& constraint : constraints) {
+    if (first) {
+      first = false;
+    } else {
+      o << ", ";
+    }
+    o << constraint;
+  }
+  o << '}';
+  return o;
+}
+
 } // namespace wasm::constraint

src/ir/constraint.h

@@ -60,6 +60,30 @@ enum Result { True, False, Unknown };
 // about, which looks like a local, but it could be a global or a struct field
 // or anything else in general.
 struct AndedConstraintSet : inplace_vector<Constraint, MaxConstraints> {
+  // We could represent a contradiction using two constraints that contradict
+  // each other (== 0 && != 0), but for simplicity we mark this explicitly.
+  //
+  // A contradiction is the default value here, because it represents
+  // unreachable code: if (x == 0 && x != 0) { .. unreachable ..}. That is, we
+  // assume we represent the constraints in code that has not been reached,
+  // until something changes.
+  bool isContradiction = true;
+
+  // Proving everything (even contradictions) is equivalent to being a
+  // contradiction. (This and provesNothing can be seen as the top/bottom of a
+  // lattice, if one wants to think of things that way.)
+  bool provesEverything() const { return isContradiction; }
+
+  // An empty set of contradictions means we know nothing, and so anything is
+  // possible, and we can prove nothing.
+  bool provesNothing() const { return empty(); }
+
+  void setProvesNothing() {
+    clear();
+    isContradiction = false;
+    assert(provesNothing());
+  }
+
   // Check a condition against this set, that is, whether the existing
   // constraints prove that it must be true, false, or unknown: whether
   //
@@ -119,8 +143,44 @@ struct AndedConstraintSet : inplace_vector<Constraint, MaxConstraints> {
   //
   // If we become too imprecise, we lose the ability to imply anything useful.
   void approximateOr(const AndedConstraintSet& other);
+
+  // Set a constraint, replacing all previous state.
+  void set(const Constraint& c) {
+    setProvesNothing();
+    push_back(c);
+  }
 };
 
+// A local plus a constraint on it.
+struct LocalConstraint {
+  Index local;
+  Constraint constraint;
+
+  // Try to parse BinaryenIR into a local to which a constraint is applied. For
+  // example
+  //
+  //   (i32.eq (local.get $r) (i32.const 10))
+  //
+  // parses into
+  //
+  //   LocalConstraint($r, { x == 10 })
+  //
+  static std::optional<LocalConstraint> parse(Expression* curr);
+};
+
+// A map of locals and their constraints.
+struct LocalConstraintMap
+  : public std::unordered_map<Index, AndedConstraintSet> {
+  // Perform an OR as above. When a local only appears in one map, we treat it
+  // as if it contains a contradiction there, that is, as if the code is
+  // unreachable.
+  void approximateOr(const LocalConstraintMap& other);
+};
+
+std::ostream& operator<<(std::ostream& o, const Constraint& constraint);
+std::ostream& operator<<(std::ostream& o,
+                         const AndedConstraintSet& constraints);
+
 } // namespace wasm::constraint
 
 #endif // wasm_ir_constraint_h

src/passes/CMakeLists.txt

@@ -26,6 +26,7 @@ set(passes_SOURCES
   CodeFolding.cpp
   ConstantFieldPropagation.cpp
   ConstHoisting.cpp
+  ConstraintAnalysis.cpp
   DataFlowOpts.cpp
   DeadArgumentElimination.cpp
   DeadArgumentElimination2.cpp