[analyzer] Helper method for checking whether two symbolic values are equal

[george.karpenkov]

Summary

Add a helper for checking equality to SValBuilder

[NoQ]

lib/StaticAnalyzer/Core/SValBuilder.cpp

417

Hmm.

"Saying that LHS is unequal to RHS is not definitely true". Which means it's either false or unknown. Which means they're either equal or not known to be unequal. Which is not what we want. We want to make sure that they cannot be unequal.

427

I don't think you need explicit casts here.

[george.karpenkov]

lib/StaticAnalyzer/Core/SValBuilder.cpp

417

Great point!

427

otherwise this method would just call itself recursively.

[NoQ]

lib/StaticAnalyzer/Core/SValBuilder.cpp

427

Whoops.

427

Maybe remove this method then?

[george.karpenkov]

"Saying that LHS is unequal to RHS is not definitely true". Which means it's either false or unknown. Which means they're either equal or not known to be unequal. Which is not what we want. We want to make sure that they cannot be unequal.

After thinking about this a bit more, saying that two things are equal is ambiguous in a three-valued logic (are we saying they are definitely equal or that they could be equal?)
Let's do it in a different way.

lib/StaticAnalyzer/Core/SValBuilder.cpp

427

But then I would not be able to call it from evalEQ.

include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h

public:
   virtual SVal simplifySVal(ProgramStateRef State, SVal Val) = 0;
   
   /// Constructs a symbolic expression for two non-location values.
   SVal makeSymExprValNN(ProgramStateRef state, BinaryOperator::Opcode op,
                       NonLoc lhs, NonLoc rhs, QualType resultTy);
 
   SVal evalBinOp(ProgramStateRef state, BinaryOperator::Opcode op,
                  SVal lhs, SVal rhs, QualType type);
-  
+  /// \return Whether values in \p lhs and \p rhs are equal at \p state.
+  bool areEqual(ProgramStateRef state, SVal lhs, SVal rhs);
+
+  SVal evalEQ(ProgramStateRef state, SVal lhs, SVal rhs);
+
   DefinedOrUnknownSVal evalEQ(ProgramStateRef state, DefinedOrUnknownSVal lhs,
                               DefinedOrUnknownSVal rhs);
 
   ASTContext &getContext() { return Context; }
   const ASTContext &getContext() const { return Context; }
 
   ProgramStateManager &getStateManager() { return StateMgr; }
   

lib/StaticAnalyzer/Core/SValBuilder.cpp

if (Optional<Loc> RV = rhs.getAs<Loc>()) {
     // Commute the operands.
     return evalBinOpLN(state, op, *RV, lhs.castAs<NonLoc>(), type);
   }
 
   return evalBinOpNN(state, op, lhs.castAs<NonLoc>(), rhs.castAs<NonLoc>(),
                      type);
 }
 
+bool SValBuilder::areEqual(ProgramStateRef state, SVal lhs, SVal rhs) {
+  return state->isNull(evalEQ(state, lhs, rhs)).isConstrainedFalse();
+}
+
+SVal SValBuilder::evalEQ(ProgramStateRef state, SVal lhs, SVal rhs) {
+  return evalBinOp(state, BO_EQ, lhs, rhs, getConditionType());
+}
+
 DefinedOrUnknownSVal SValBuilder::evalEQ(ProgramStateRef state,
                                          DefinedOrUnknownSVal lhs,
                                          DefinedOrUnknownSVal rhs) {
-  return evalBinOp(state, BO_EQ, lhs, rhs, getConditionType())
+  return evalEQ(state, static_cast<SVal>(lhs), static_cast<SVal>(rhs))
       .castAs<DefinedOrUnknownSVal>();
 }
 
 /// Recursively check if the pointer types are equal modulo const, volatile,
 /// and restrict qualifiers. Also, assume that all types are similar to 'void'.
 /// Assumes the input types are canonical.
 static bool shouldBeModeledWithNoOp(ASTContext &Context, QualType ToTy,
                                                          QualType FromTy) {