Some more knowledge functions.

libevmcore/ExpressionClasses.cpp

@@ -84,24 +84,35 @@ ExpressionClasses::Id ExpressionClasses::find(
 bool ExpressionClasses::knownToBeDifferent(ExpressionClasses::Id _a, ExpressionClasses::Id _b)
 {
 	// Try to simplify "_a - _b" and return true iff the value is a non-zero constant.
-	map<unsigned, Expression const*> matchGroups;
-	Pattern constant(Push);
-	constant.setMatchGroup(1, matchGroups);
-	Id difference = find(Instruction::SUB, {_a, _b});
-	return constant.matches(representative(difference), *this) && constant.d() != u256(0);
+	return knownNonZero(find(Instruction::SUB, {_a, _b}));
 }
 
 bool ExpressionClasses::knownToBeDifferentBy32(ExpressionClasses::Id _a, ExpressionClasses::Id _b)
 {
 	// Try to simplify "_a - _b" and return true iff the value is at least 32 away from zero.
+	u256 const* v = knownConstant(find(Instruction::SUB, {_a, _b}));
+	// forbidden interval is ["-31", 31]
+	return v && *v + 31 > u256(62);
+}
+
+bool ExpressionClasses::knownZero(Id _c)
+{
+	return Pattern(u256(0)).matches(representative(_c), *this);
+}
+
+bool ExpressionClasses::knownNonZero(Id _c)
+{
+	return Pattern(u256(0)).matches(representative(find(Instruction::ISZERO, {_c})), *this);
+}
+
+u256 const* ExpressionClasses::knownConstant(Id _c)
+{
 	map<unsigned, Expression const*> matchGroups;
 	Pattern constant(Push);
 	constant.setMatchGroup(1, matchGroups);
-	Id difference = find(Instruction::SUB, {_a, _b});
-	if (!constant.matches(representative(difference), *this))
-		return false;
-	// forbidden interval is ["-31", 31]
-	return constant.d() + 31 > u256(62);
+	if (!constant.matches(representative(_c), *this))
+		return nullptr;
+	return &constant.d();
 }
 
 string ExpressionClasses::fullDAGToString(ExpressionClasses::Id _id) const

libevmcore/ExpressionClasses.h

@@ -78,6 +78,15 @@ public:
 	bool knownToBeDifferent(Id _a, Id _b);
 	/// Similar to @a knownToBeDifferent but require that abs(_a - b) >= 32.
 	bool knownToBeDifferentBy32(Id _a, Id _b);
+	/// @returns true if the value of the given class is known to be zero.
+	/// @note that this is not the negariot of knownNonZero
+	bool knownZero(Id _c);
+	/// @returns true if the value of the given class is known to be nonzero.
+	/// @note that this is not the negariot of knownZero
+	bool knownNonZero(Id _c);
+	/// @returns a pointer to the value if the given class is known to be a constant,
+	/// and a nullptr otherwise.
+	u256 const* knownConstant(Id _c);
 
 	std::string fullDAGToString(Id _id) const;
 
@@ -131,7 +140,7 @@ public:
 	/// @returns the id of the matched expression if this pattern is part of a match group.
 	Id id() const { return matchGroupValue().id; }
 	/// @returns the data of the matched expression if this pattern is part of a match group.
-	u256 d() const { return matchGroupValue().item->data(); }
+	u256 const& d() const { return matchGroupValue().item->data(); }
 
 	std::string toString() const;