Hi, Per. This does look very good, though like Hans said you should probably
run it through clang-format to make sure it matches up with the LLVM style.
Additionally, I think this is better as a syntactic checker, using
RecursiveASTVisitor: the same advice I gave Anders for the StringPlusChar
checker, and the approach he took for the SizeofOnExpression checker.
Beyond that, some local comments:
+//== EqualCompareChecker.cpp - Compare equal expression checker--*- C++
-*--==//
Nitpick: put a space after the summary. Actually, since the file's extension is
.cpp, you don't need the -*- C++ -*- part at all...you can just fill the rest
of the line with dashes.
+// This defines EqualCompareChecker, a check that
+// warns if equal expression on both side of compare in statement.
Please make this a Doxygen file comment, as described here:
http://llvm.org/docs/CodingStandards.html#file-headers
+ return !unaryop1->isIncrementDecrementOp();
Even though this actually does something ("++x == ++x"), it's not well-defined
anyway (specifically, either one could go first), so I'd still like to catch
this as a copy-paste error. What do you think?
+ if (Op != BO_LT &&
+ Op != BO_GT &&
+ Op != BO_LE &&
+ Op != BO_GE &&
+ Op != BO_EQ &&
+ Op != BO_NE)
+ return;
There's shorthand for this: BinaryOperator::isComparisonOp.
+ /*
+ * Special case for floating point representation.
+ *
We prefer single comments in source, even for long code blocks.
http://llvm.org/docs/CodingStandards.html#comment-formatting
+ Expr* LHS = B->getLHS()->IgnoreParenImpCasts();
In general in the analyzer we prefer to make as many AST pointers const as we
can (i.e. "const Expr *LHS").
+ else if ((floatlit1)&&(floatlit2)) {
I can't see anyone ever writing "if (0.9 == 1.0)". Let's not worry about the
two-floating-point-literals case.
+ if (((Op == BO_EQ)||(Op == BO_LE)||(Op == BO_GE)))
+ reportBug(( "\'"
+ + B->getOpcodeStr().str()
+ + "\' compare of equal expressions, "
+ "always evaluates to true").c_str(),
+ C.getState(), C);
+ else
+ reportBug(( "\'"
+ + B->getOpcodeStr().str()
+ + "\' compare of equal expressions, "
+ "always evaluates to false").c_str(),
+ C.getState(), C);
I think it's okay to leave the comparison operator out of the message here.
"Comparison of identical expressions always evaluates to {true,false}" is fine;
if the report is emitted at the BinaryOperator itself, it will get attached to
the operator loc.
One last question: what's the performance implication of this check? You might
want to wait until you've rewritten it as a syntactic checker to test this, but
I'm concerned about the cost of walking and comparing all expressions. The
short-circuiting logic in here is very good, though, so maybe it's not an issue.
Thanks, Hans (and Nico), for reviewing this. Thanks, Per, for working on it!
Jordan
On Sep 20, 2013, at 3:06 , Per Viberg <[email protected]> wrote:
>
> Hello,
>
> please review attached patch. The patch adds a check that warns for
> comparison of equal expressions.
>
> example:
> x + 1 == x +1;
>
> best regards,
> Per
>
> .......................................................................................................................
> Per Viberg Senior Engineer
> Evidente ES East AB Warfvinges väg 34 SE-112 51 Stockholm Sweden
> Phone: +46 (0)8 402 79 00
> Mobile: +46 (0)70 912 42 52
> E-mail: [email protected]
>
> www.evidente.se
> This e-mail, which might contain confidential information, is addressed to
> the above stated person/company. If you are not the correct addressee,
> employee or in any other way the person concerned, please notify the sender
> immediately. At the same time, please delete this e-mail and destroy any
> prints. Thank You.
Index: lib/StaticAnalyzer/Checkers/EqualCompareChecker.cpp
===================================================================
--- lib/StaticAnalyzer/Checkers/EqualCompareChecker.cpp (revision 0)
+++ lib/StaticAnalyzer/Checkers/EqualCompareChecker.cpp (revision 0)
@@ -0,0 +1,218 @@
+//== EqualCompareChecker.cpp - Compare equal expression checker--*- C++ -*--==//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This defines EqualCompareChecker, a check that
+// warns if equal expression on both side of compare in statement.
+//
+//===----------------------------------------------------------------------===//
+
+
+#include "ClangSACheckers.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/Checker.h"
+#include "clang/StaticAnalyzer/Core/CheckerManager.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
+
+using namespace clang;
+using namespace ento;
+
+
+namespace {
+class EqualCompareChecker : public Checker< check::PreStmt<BinaryOperator> > {
+ mutable OwningPtr<BuiltinBug> BT;
+ void reportBug(const char *Msg,
+ ProgramStateRef StateZero,
+ CheckerContext &C) const ;
+public:
+ void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
+};
+} // end anonymous namespace
+
+void EqualCompareChecker::reportBug(const char *Msg,
+ ProgramStateRef StateZero,
+ CheckerContext &C) const {
+ if (ExplodedNode *N = C.generateSink(StateZero)) {
+ if (!BT)
+ BT.reset(new BuiltinBug("Compare of equal expressions"));
+
+ BugReport *R = new BugReport(*BT, Msg, N);
+ bugreporter::trackNullOrUndefValue(N, bugreporter::GetDenomExpr(N), *R);
+ C.emitReport(R);
+ }
+}
+
+static bool isSameExpr(const ASTContext &Ctx, Expr *Expr1, Expr *Expr2) {
+ // different class => not same expression
+ if (Expr1->getStmtClass() != Expr2->getStmtClass())
+ return false;
+
+ // side effects => don't warn even if expressions are same
+ if (Expr1->HasSideEffects(Ctx))
+ return false;
+
+ // is expression based on macro => don't warn even if expressions are same
+ if ((Expr1->getExprLoc().isMacroID()) || (Expr2->getExprLoc().isMacroID()))
+ return false;
+
+ // Are all children the same?
+ Expr::child_iterator I1 = Expr1->child_begin();
+ Expr::child_iterator I2 = Expr2->child_begin();
+ while (I1 != Expr1->child_end() && I2 != Expr2->child_end()) {
+ Expr *Child1 = dyn_cast<Expr>(*I1);
+ Expr *Child2 = dyn_cast<Expr>(*I2);
+ if (!Child1 || !Child2 || !isSameExpr(Ctx,Child1,Child2))
+ return false;
+ ++I1;
+ ++I2;
+ }
+ // different number of children (TODO: is this a redundant condition)
+ if (I1 != Expr1->child_end())
+ return false;
+ if (I2 != Expr2->child_end())
+ return false;
+
+ switch (Expr1->getStmtClass()) {
+ default:
+ return false;
+ case Stmt::ArraySubscriptExprClass:
+ case Stmt::CStyleCastExprClass:
+ case Stmt::ImplicitCastExprClass:
+ case Stmt::ParenExprClass:
+ return true; // we know all children are the same
+ case Stmt::BinaryOperatorClass: {
+ BinaryOperator *binop1 = dyn_cast<BinaryOperator>(Expr1);
+ BinaryOperator *binop2 = dyn_cast<BinaryOperator>(Expr2);
+ return binop1->getOpcode() == binop2->getOpcode();
+ }
+ case Stmt::CharacterLiteralClass: {
+ CharacterLiteral *charlit1 = dyn_cast<CharacterLiteral>(Expr1);
+ CharacterLiteral *charlit2 = dyn_cast<CharacterLiteral>(Expr2);
+ return charlit1->getValue() == charlit2->getValue();
+ }
+ case Stmt::DeclRefExprClass: {
+ DeclRefExpr *declref1 = dyn_cast<DeclRefExpr>(Expr1);
+ DeclRefExpr *declref2 = dyn_cast<DeclRefExpr>(Expr2);
+ return declref1->getDecl() == declref2->getDecl();
+ }
+ case Stmt::IntegerLiteralClass: {
+ IntegerLiteral *intlit1 = dyn_cast<IntegerLiteral>(Expr1);
+ IntegerLiteral *intlit2 = dyn_cast<IntegerLiteral>(Expr2);
+ return intlit1->getValue() == intlit2->getValue();
+ }
+ case Stmt::FloatingLiteralClass: {
+ FloatingLiteral *floatlit1 = dyn_cast<FloatingLiteral>(Expr1);
+ FloatingLiteral *floatlit2 = dyn_cast<FloatingLiteral>(Expr2);
+ return floatlit1->getValue().bitwiseIsEqual(floatlit2->getValue());
+ }
+ case Stmt::MemberExprClass: {
+ MemberExpr *memberexpr1 = dyn_cast<MemberExpr>(Expr1);
+ MemberExpr *memberexpr2 = dyn_cast<MemberExpr>(Expr2);
+ return memberexpr1->getMemberDecl() == memberexpr2->getMemberDecl();
+ }
+ case Stmt::UnaryOperatorClass: {
+ UnaryOperator *unaryop1 = dyn_cast<UnaryOperator>(Expr1);
+ UnaryOperator *unaryop2 = dyn_cast<UnaryOperator>(Expr2);
+ if (unaryop1->getOpcode() != unaryop2->getOpcode())
+ return false;
+ return !unaryop1->isIncrementDecrementOp();
+ }
+ }
+}
+
+
+
+void EqualCompareChecker::checkPreStmt(const BinaryOperator *B,
+ CheckerContext &C) const {
+ bool isSameExpression;
+ BinaryOperator::Opcode Op = B->getOpcode();
+ //if it is not relational operator
+ if (Op != BO_LT &&
+ Op != BO_GT &&
+ Op != BO_LE &&
+ Op != BO_GE &&
+ Op != BO_EQ &&
+ Op != BO_NE)
+ return;
+
+ /*
+ * Special case for floating point representation.
+ *
+ * If expressions on both side of comparison operator are of type floating
+ * value, then for some comparison operator no warning shall be reported even
+ * if the expressions are identical from a symbolic point of view. Comparison
+ * between expressions, declared variables and literals are treated
+ * differently.
+ *
+ * != and == between float literals that have same value should NOT warn
+ * < > between float literals that have the same value SHOULD warn
+ *
+ * != and == between the same float declaration should NOT warn
+ * < > between the same float declaration SHOULD warn
+ *
+ * != and == between eq. expressions that evaluates into float should NOT warn
+ * < > between eq. expressions that evaluates into float should NOT warn
+ *
+ *
+ *
+ * */
+ Expr* LHS = B->getLHS()->IgnoreParenImpCasts();
+ Expr* RHS = B->getRHS()->IgnoreParenImpCasts();
+
+ DeclRefExpr *declref1 = dyn_cast<DeclRefExpr>(LHS);
+ DeclRefExpr *declref2 = dyn_cast<DeclRefExpr>(RHS);
+ FloatingLiteral *floatlit1 = dyn_cast<FloatingLiteral>(LHS);
+ FloatingLiteral *floatlit2 = dyn_cast<FloatingLiteral>(RHS);
+ if ((declref1)&&(declref2)) {
+ if ( (declref1->getType()->hasFloatingRepresentation())
+ &&(declref2->getType()->hasFloatingRepresentation())) {
+ if (declref1->getDecl()==declref2->getDecl()) {
+ if ((Op == BO_EQ)||(Op == BO_NE)) {
+ return;
+ }
+ }
+ }
+ }
+ else if ((floatlit1)&&(floatlit2)) {
+ if (floatlit1->getValue().bitwiseIsEqual(floatlit2->getValue())) {
+ if ((Op == BO_EQ)||(Op == BO_NE)) {
+ return;
+ }
+ }
+ }
+ //if any side of comparison still has floatingpointrepresentation,
+ //then it's an expression-> don't warn
+ //(here only LHS is checked since RHS will be implicit casted to float)
+ else if (LHS->getType()->hasFloatingRepresentation()) {
+ return;
+ }
+ else {//No special case with floating point representation, report as usual
+ }
+
+ isSameExpression = isSameExpr(C.getASTContext(), B->getLHS(),B->getRHS());
+ if (isSameExpression) {
+ if (((Op == BO_EQ)||(Op == BO_LE)||(Op == BO_GE)))
+ reportBug(( "\'"
+ + B->getOpcodeStr().str()
+ + "\' compare of equal expressions, "
+ "always evaluates to true").c_str(),
+ C.getState(), C);
+ else
+ reportBug(( "\'"
+ + B->getOpcodeStr().str()
+ + "\' compare of equal expressions, "
+ "always evaluates to false").c_str(),
+ C.getState(), C);
+ }
+}
+
+void ento::registerEqualCompareChecker(CheckerManager &mgr) {
+ mgr.registerChecker<EqualCompareChecker>();
+}
+
+
Index: lib/StaticAnalyzer/Checkers/CMakeLists.txt
===================================================================
--- lib/StaticAnalyzer/Checkers/CMakeLists.txt (revision 190657)
+++ lib/StaticAnalyzer/Checkers/CMakeLists.txt (arbetskopia)
@@ -31,6 +31,7 @@
DivZeroChecker.cpp
DynamicTypePropagation.cpp
ExprInspectionChecker.cpp
+ EqualCompareChecker.cpp
FixedAddressChecker.cpp
GenericTaintChecker.cpp
IdempotentOperationChecker.cpp
Index: lib/StaticAnalyzer/Checkers/Checkers.td
===================================================================
--- lib/StaticAnalyzer/Checkers/Checkers.td (revision 190657)
+++ lib/StaticAnalyzer/Checkers/Checkers.td (arbetskopia)
@@ -100,6 +100,10 @@
HelpText<"Check for cast from non-struct pointer to struct pointer">,
DescFile<"CastToStructChecker.cpp">;
+def EqualCompareChecker : Checker<"EqualCompare">,
+ HelpText<"Warn about comparison of equal expressions">,
+ DescFile<"EqualCompareChecker.cpp">;
+
def FixedAddressChecker : Checker<"FixedAddr">,
HelpText<"Check for assignment of a fixed address to a pointer">,
DescFile<"FixedAddressChecker.cpp">;
Index: test/Analysis/equal-compare.cpp
===================================================================
--- test/Analysis/equal-compare.cpp (revision 0)
+++ test/Analysis/equal-compare.cpp (revision 0)
@@ -0,0 +1,863 @@
+// RUN: %clang_cc1 -analyze -analyzer-checker=core,alpha.core.EqualCompare -verify %s
+
+/*only one expected warning per function allowed at the very end*/
+
+/* '!=' operator*/
+
+/* '!=' with float */
+int checkNotEqualFloatLiteralCompare1(void) {
+ return (5.14F != 5.14F); // no warning
+}
+
+int checkNotEqualFloatLiteralCompare2(void) {
+ return (6.14F != 7.14F); // no warning
+}
+
+int checkNotEqualFloatDeclCompare1(void) {
+ float f = 7.1F;
+ float g = 7.1F;
+ return (f != g); // no warning
+}
+
+int checkNotEqualFloatDeclCompare12(void) {
+ float f = 7.1F;
+ return (f != f); // no warning
+}
+
+int checkNotEqualFloatDeclCompare3(void) {
+ float f = 7.1F;
+ return (f != 7.1F); // no warning
+}
+
+int checkNotEqualFloatDeclCompare4(void) {
+ float f = 7.1F;
+ return (7.1F != f); // no warning
+}
+
+int checkNotEqualFloatDeclCompare5(void) {
+ float f = 7.1F;
+ int t = 7;
+ return (t != f); // no warning
+}
+
+int checkNotEqualFloatDeclCompare6(void) {
+ float f = 7.1F;
+ int t = 7;
+ return (f != t); // no warning
+}
+
+
+
+int checkNotEqualCastFloatDeclCompare11(void) {
+ float f = 7.1F;
+ return ((int)f != (int)f); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+}
+int checkNotEqualCastFloatDeclCompare12(void) {
+ float f = 7.1F;
+ return ((char)f != (int)f); // no warning
+}
+int checkNotEqualBinaryOpFloatCompare1(void) {
+ int res;
+ float f= 3.14F;
+ res = (f + 3.14F != f + 3.14F); // no warning
+ return (0);
+}
+int checkNotEqualBinaryOpFloatCompare2(void) {
+ float f = 7.1F;
+ float g = 7.1F;
+ return (f + 3.14F != g + 3.14F); // no warning
+}
+int checkNotEqualBinaryOpFloatCompare3(void) {
+ int res;
+ float f= 3.14F;
+ res = ((int)f + 3.14F != (int)f + 3.14F); // no warning
+ return (0);
+}
+int checkNotEqualBinaryOpFloatCompare4(void) {
+ int res;
+ float f= 3.14F;
+ res = ((int)f + 3.14F != (char)f + 3.14F); // no warning
+ return (0);
+}
+
+int checkNotEqualNestedBinaryOpFloatCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ float f= 3.14F;
+ res = (((int)f + (3.14F - u)*t) != ((int)f + (3.14F - u)*t)); // no warning
+ return (0);
+}
+
+int checkNotEqualNestedBinaryOpFloatCompare2(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ float f= 3.14F;
+ res = (((int)f + (u - 3.14F)*t) != ((int)f + (3.14F - u)*t)); // no warning
+ return (0);
+}
+
+/* end '!=' with float*/
+
+/* '!=' with int*/
+
+int checkNotEqualIntLiteralCompare1(void) {
+ return (5 != 5); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+}
+
+int checkNotEqualIntLiteralCompare2(void) {
+ return (6 != 7); // no warning
+}
+
+int checkNotEqualIntDeclCompare1(void) {
+ int f = 7;
+ int g = 7;
+ return (f != g); // no warning
+}
+
+int checkNotEqualIntDeclCompare3(void) {
+ int f = 7;
+ return (f != 7); // no warning
+}
+
+int checkNotEqualIntDeclCompare4(void) {
+ int f = 7;
+ return (7 != f); // no warning
+}
+
+int checkNotEqualCastIntDeclCompare11(void) {
+ int f = 7;
+ return ((int)f != (int)f); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+}
+int checkNotEqualCastIntDeclCompare12(void) {
+ int f = 7;
+ return ((char)f != (int)f); // no warning
+}
+int checkNotEqualBinaryOpIntCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 4;
+ res = (f + 4 != f + 4); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+int checkNotEqualBinaryOpIntCompare2(void) {
+ int f = 7;
+ int g = 7;
+ return (f + 4 != g + 4); // no warning
+}
+
+
+int checkNotEqualBinaryOpIntCompare3(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 4;
+ res = ((int)f + 4 != (int)f + 4); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+int checkNotEqualBinaryOpIntCompare4(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 4;
+ res = ((int)f + 4 != (char)f + 4); // no warning
+ return (0);
+}
+int checkNotEqualBinaryOpIntCompare5(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ res = (u + t != u + t); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+
+int checkNotEqualNestedBinaryOpIntCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (3 - u)*t) != ((int)f + (3 - u)*t)); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+
+int checkNotEqualNestedBinaryOpIntCompare2(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (u - 3)*t) != ((int)f + (3 - u)*t)); // no warning
+ return (0);
+}
+/* end '!=' int */
+
+
+
+/* '!=' with int pointer */
+
+int checkNotEqualIntPointerLiteralCompare1(void) {
+ int* p = 0;
+ return (p != 0); // no warning
+}
+
+int checkNotEqualIntPointerLiteralCompare2(void) {
+ return (6 != 7); // no warning
+}
+
+int checkNotEqualIntPointerDeclCompare1(void) {
+ int k = 3;
+ int* f = &k;
+ int* g = &k;
+ return (f != g); // no warning
+}
+
+int checkNotEqualCastIntPointerDeclCompare11(void) {
+ int k = 7;
+ int* f = &k;
+ return ((int*)f != (int*)f); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+}
+int checkNotEqualCastIntPointerDeclCompare12(void) {
+ int k = 7;
+ int* f = &k;
+ return ((int*)((char*)f) != (int*)f); // no warning
+}
+int checkNotEqualBinaryOpIntPointerCompare1(void) {
+ int k = 7;
+ int res;
+ int* f= &k;
+ res = (f + 4 != f + 4); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+int checkNotEqualBinaryOpIntPointerCompare2(void) {
+ int k = 7;
+ int* f = &k;
+ int* g = &k;
+ return (f + 4 != g + 4); // no warning
+}
+
+
+int checkNotEqualBinaryOpIntPointerCompare3(void) {
+ int k = 7;
+ int res;
+ int* f= &k;
+ res = ((int*)f + 4 != (int*)f + 4); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+int checkNotEqualBinaryOpIntPointerCompare4(void) {
+ int k = 7;
+ int res;
+ int* f= &k;
+ res = ((int*)f + 4 != (int*)((char*)f) + 4); // no warning
+ return (0);
+}
+
+int checkNotEqualNestedBinaryOpIntPointerCompare1(void) {
+ int res;
+ int k = 7;
+ int t= 1;
+ int* u= &k+2;
+ int* f= &k+3;
+ res = ((f + (3)*t) != (f + (3)*t)); // expected-warning {{'!=' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+
+int checkNotEqualNestedBinaryOpIntPointerCompare2(void) {
+ int res;
+ int k = 7;
+ int t= 1;
+ int* u= &k+2;
+ int* f= &k+3;
+ res = (((3)*t + f) != (f + (3)*t)); // no warning
+ return (0);
+}
+/* end '!=' int* */
+
+/* end '!=' */
+
+
+
+/* EQ operator */
+
+int checkEqualIntPointerDeclCompare(void) {
+ int k = 3;
+ int* f = &k;
+ int* g = &k;
+ return (f == g); // no warning
+}
+
+int checkEqualIntPointerDeclCompare0(void) {
+ int k = 3;
+ int* f = &k;
+ return (f+1 == f+1); // expected-warning {{'==' compare of equal expressions, always evaluates to true}}
+}
+
+/* EQ with float*/
+
+int checkEqualFloatLiteralCompare1(void) {
+ return (5.14F == 5.14F); // no warning
+}
+
+int checkEqualFloatLiteralCompare2(void) {
+ return (6.14F == 7.14F); // no warning
+}
+
+int checkEqualFloatDeclCompare1(void) {
+ float f = 7.1F;
+ float g = 7.1F;
+ return (f == g); // no warning
+}
+
+int checkEqualFloatDeclCompare12(void) {
+ float f = 7.1F;
+ return (f == f); // no warning
+}
+
+
+int checkEqualFloatDeclCompare3(void) {
+ float f = 7.1F;
+ return (f == 7.1F); // no warning
+}
+
+int checkEqualFloatDeclCompare4(void) {
+ float f = 7.1F;
+ return (7.1F == f); // no warning
+}
+
+int checkEqualFloatDeclCompare5(void) {
+ float f = 7.1F;
+ int t = 7;
+ return (t == f); // no warning
+}
+
+int checkEqualFloatDeclCompare6(void) {
+ float f = 7.1F;
+ int t = 7;
+ return (f == t); // no warning
+}
+
+
+
+
+int checkEqualCastFloatDeclCompare11(void) {
+ float f = 7.1F;
+ return ((int)f == (int)f); // expected-warning {{'==' compare of equal expressions, always evaluates to true}}
+}
+int checkEqualCastFloatDeclCompare12(void) {
+ float f = 7.1F;
+ return ((char)f == (int)f); // no warning
+}
+int checkEqualBinaryOpFloatCompare1(void) {
+ int res;
+ float f= 3.14F;
+ res = (f + 3.14F == f + 3.14F); // no warning
+ return (0);
+}
+int checkEqualBinaryOpFloatCompare2(void) {
+ float f = 7.1F;
+ float g = 7.1F;
+ return (f + 3.14F == g + 3.14F); // no warning
+}
+int checkEqualBinaryOpFloatCompare3(void) {
+ int res;
+ float f= 3.14F;
+ res = ((int)f + 3.14F == (int)f + 3.14F); // no warning
+ return (0);
+}
+int checkEqualBinaryOpFloatCompare4(void) {
+ int res;
+ float f= 3.14F;
+ res = ((int)f + 3.14F == (char)f + 3.14F); // no warning
+ return (0);
+}
+
+int checkEqualNestedBinaryOpFloatCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ float f= 3.14F;
+ res = (((int)f + (3.14F - u)*t) == ((int)f + (3.14F - u)*t)); // no warning
+ return (0);
+}
+
+int checkEqualNestedBinaryOpFloatCompare2(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ float f= 3.14F;
+ res = (((int)f + (u - 3.14F)*t) == ((int)f + (3.14F - u)*t)); // no warning
+ return (0);
+}
+
+
+
+/* Equal with int*/
+
+int checkEqualIntLiteralCompare1(void) {
+ return (5 == 5); // expected-warning {{'==' compare of equal expressions, always evaluates to true}}
+}
+
+int checkEqualIntLiteralCompare2(void) {
+ return (6 == 7); // no warning
+}
+
+int checkEqualIntDeclCompare1(void) {
+ int f = 7;
+ int g = 7;
+ return (f == g); // no warning
+}
+
+int checkEqualCastIntDeclCompare11(void) {
+ int f = 7;
+ return ((int)f == (int)f); // expected-warning {{'==' compare of equal expressions, always evaluates to true}}
+}
+int checkEqualCastIntDeclCompare12(void) {
+ int f = 7;
+ return ((char)f == (int)f); // no warning
+}
+
+int checkEqualIntDeclCompare3(void) {
+ int f = 7;
+ return (f == 7); // no warning
+}
+
+int checkEqualIntDeclCompare4(void) {
+ int f = 7;
+ return (7 == f); // no warning
+}
+
+int checkEqualBinaryOpIntCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 4;
+ res = (f + 4 == f + 4); // expected-warning {{'==' compare of equal expressions, always evaluates to true}}
+ return (0);
+}
+int checkEqualBinaryOpIntCompare2(void) {
+ int f = 7;
+ int g = 7;
+ return (f + 4 == g + 4); // no warning
+}
+
+
+int checkEqualBinaryOpIntCompare3(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 4;
+ res = ((int)f + 4 == (int)f + 4); // expected-warning {{'==' compare of equal expressions, always evaluates to true}}
+ return (0);
+
+}
+int checkEqualBinaryOpIntCompare4(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 4;
+ res = ((int)f + 4 == (char)f + 4); // no warning
+ return (0);
+}
+int checkEqualBinaryOpIntCompare5(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ res = (u + t == u + t); // expected-warning {{'==' compare of equal expressions, always evaluates to true}}
+ return (0);
+}
+
+int checkEqualNestedBinaryOpIntCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (3 - u)*t) == ((int)f + (3 - u)*t)); // expected-warning {{'==' compare of equal expressions, always evaluates to true}}
+ return (0);
+}
+
+int checkEqualNestedBinaryOpIntCompare2(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (u - 3)*t) == ((int)f + (3 - u)*t)); // no warning
+ return (0);
+}
+/* end EQ int */
+
+/* end EQ */
+
+
+/* LT */
+
+/* LT with float */
+
+int checkLessThanFloatLiteralCompare1(void) {
+ return (5.14F < 5.14F); // expected-warning {{'<' compare of equal expressions, always evaluates to false}}
+}
+
+int checkLessThanFloatLiteralCompare2(void) {
+ return (6.14F < 7.14F); // no warning
+}
+
+int checkLessThanFloatDeclCompare1(void) {
+ float f = 7.1F;
+ float g = 7.1F;
+ return (f < g); // no warning
+}
+
+int checkLessThanFloatDeclCompare12(void) {
+ float f = 7.1F;
+ return (f < f); // expected-warning {{'<' compare of equal expressions, always evaluates to false}}
+}
+
+int checkLessThanFloatDeclCompare3(void) {
+ float f = 7.1F;
+ return (f < 7.1F); // no warning
+}
+
+int checkLessThanFloatDeclCompare4(void) {
+ float f = 7.1F;
+ return (7.1F < f); // no warning
+}
+
+int checkLessThanFloatDeclCompare5(void) {
+ float f = 7.1F;
+ int t = 7;
+ return (t < f); // no warning
+}
+
+int checkLessThanFloatDeclCompare6(void) {
+ float f = 7.1F;
+ int t = 7;
+ return (f < t); // no warning
+}
+
+
+int checkLessThanCastFloatDeclCompare11(void) {
+ float f = 7.1F;
+ return ((int)f < (int)f); // expected-warning {{'<' compare of equal expressions, always evaluates to false}}
+}
+int checkLessThanCastFloatDeclCompare12(void) {
+ float f = 7.1F;
+ return ((char)f < (int)f); // no warning
+}
+int checkLessThanBinaryOpFloatCompare1(void) {
+ int res;
+ float f= 3.14F;
+ res = (f + 3.14F < f + 3.14F); // no warning
+ return (0);
+}
+int checkLessThanBinaryOpFloatCompare2(void) {
+ float f = 7.1F;
+ float g = 7.1F;
+ return (f + 3.14F < g + 3.14F); // no warning
+}
+int checkLessThanBinaryOpFloatCompare3(void) {
+ int res;
+ float f= 3.14F;
+ res = ((int)f + 3.14F < (int)f + 3.14F); // no warning
+ return (0);
+}
+int checkLessThanBinaryOpFloatCompare4(void) {
+ int res;
+ float f= 3.14F;
+ res = ((int)f + 3.14F < (char)f + 3.14F); // no warning
+ return (0);
+}
+
+int checkLessThanNestedBinaryOpFloatCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ float f= 3.14F;
+ res = (((int)f + (3.14F - u)*t) < ((int)f + (3.14F - u)*t)); // no warning
+ return (0);
+}
+
+int checkLessThanNestedBinaryOpFloatCompare2(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ float f= 3.14F;
+ res = (((int)f + (u - 3.14F)*t) < ((int)f + (3.14F - u)*t)); // no warning
+ return (0);
+}
+
+/* end LT with float */
+
+/* LT with int */
+
+
+int checkLessThanIntLiteralCompare1(void) {
+ return (5 < 5); // expected-warning {{'<' compare of equal expressions, always evaluates to false}}
+}
+
+int checkLessThanIntLiteralCompare2(void) {
+ return (6 < 7); // no warning
+}
+
+int checkLessThanIntDeclCompare1(void) {
+ int f = 7;
+ int g = 7;
+ return (f < g); // no warning
+}
+
+int checkLessThanIntDeclCompare3(void) {
+ int f = 7;
+ return (f < 7); // no warning
+}
+
+int checkLessThanIntDeclCompare4(void) {
+ int f = 7;
+ return (7 < f); // no warning
+}
+
+int checkLessThanIntDeclCompare5(void) {
+ int f = 7;
+ int t = 7;
+ return (t < f); // no warning
+}
+
+int checkLessThanIntDeclCompare6(void) {
+ int f = 7;
+ int t = 7;
+ return (f < t); // no warning
+}
+
+int checkLessThanCastIntDeclCompare11(void) {
+ int f = 7;
+ return ((int)f < (int)f); // expected-warning {{'<' compare of equal expressions, always evaluates to false}}
+}
+int checkLessThanCastIntDeclCompare12(void) {
+ int f = 7;
+ return ((char)f < (int)f); // no warning
+}
+int checkLessThanBinaryOpIntCompare1(void) {
+ int res;
+ int f= 3;
+ res = (f + 3 < f + 3); // expected-warning {{'<' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+int checkLessThanBinaryOpIntCompare2(void) {
+ int f = 7;
+ int g = 7;
+ return (f + 3 < g + 3); // no warning
+}
+int checkLessThanBinaryOpIntCompare3(void) {
+ int res;
+ int f= 3;
+ res = ((int)f + 3 < (int)f + 3); // expected-warning {{'<' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+int checkLessThanBinaryOpIntCompare4(void) {
+ int res;
+ int f= 3;
+ res = ((int)f + 3 < (char)f + 3); // no warning
+ return (0);
+}
+
+int checkLessThanNestedBinaryOpIntCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (3 - u)*t) < ((int)f + (3 - u)*t)); // expected-warning {{'<' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+
+int checkLessThanNestedBinaryOpIntCompare2(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (u - 3)*t) < ((int)f + (3 - u)*t)); // no warning
+ return (0);
+}
+
+/* end LT with int */
+
+/* end LT */
+
+
+/* GT */
+
+/* GT with float */
+
+int checkGreaterThanFloatLiteralCompare1(void) {
+ return (5.14F > 5.14F); // expected-warning {{'>' compare of equal expressions, always evaluates to false}}
+}
+
+int checkGreaterThanFloatLiteralCompare2(void) {
+ return (6.14F > 7.14F); // no warning
+}
+
+int checkGreaterThanFloatDeclCompare1(void) {
+ float f = 7.1F;
+ float g = 7.1F;
+
+ return (f > g); // no warning
+}
+
+int checkGreaterThanFloatDeclCompare12(void) {
+ float f = 7.1F;
+ return (f > f); // expected-warning {{'>' compare of equal expressions, always evaluates to false}}
+}
+
+
+int checkGreaterThanFloatDeclCompare3(void) {
+ float f = 7.1F;
+ return (f > 7.1F); // no warning
+}
+
+int checkGreaterThanFloatDeclCompare4(void) {
+ float f = 7.1F;
+ return (7.1F > f); // no warning
+}
+
+int checkGreaterThanFloatDeclCompare5(void) {
+ float f = 7.1F;
+ int t = 7;
+ return (t > f); // no warning
+}
+
+int checkGreaterThanFloatDeclCompare6(void) {
+ float f = 7.1F;
+ int t = 7;
+ return (f > t); // no warning
+}
+
+int checkGreaterThanCastFloatDeclCompare11(void) {
+ float f = 7.1F;
+ return ((int)f > (int)f); // expected-warning {{'>' compare of equal expressions, always evaluates to false}}
+}
+int checkGreaterThanCastFloatDeclCompare12(void) {
+ float f = 7.1F;
+ return ((char)f > (int)f); // no warning
+}
+int checkGreaterThanBinaryOpFloatCompare1(void) {
+ int res;
+ float f= 3.14F;
+ res = (f + 3.14F > f + 3.14F); // no warning
+ return (0);
+}
+int checkGreaterThanBinaryOpFloatCompare2(void) {
+ float f = 7.1F;
+ float g = 7.1F;
+ return (f + 3.14F > g + 3.14F); // no warning
+}
+int checkGreaterThanBinaryOpFloatCompare3(void) {
+ int res;
+ float f= 3.14F;
+ res = ((int)f + 3.14F > (int)f + 3.14F); // no warning
+ return (0);
+}
+int checkGreaterThanBinaryOpFloatCompare4(void) {
+ int res;
+ float f= 3.14F;
+ res = ((int)f + 3.14F > (char)f + 3.14F); // no warning
+ return (0);
+}
+
+int checkGreaterThanNestedBinaryOpFloatCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ float f= 3.14F;
+ res = (((int)f + (3.14F - u)*t) > ((int)f + (3.14F - u)*t)); // no warning
+ return (0);
+}
+
+int checkGreaterThanNestedBinaryOpFloatCompare2(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ float f= 3.14F;
+ res = (((int)f + (u - 3.14F)*t) > ((int)f + (3.14F - u)*t)); // no warning
+ return (0);
+}
+
+/* end GT with float */
+
+/* GT with int */
+
+
+int checkGreaterThanIntLiteralCompare1(void) {
+ return (5 > 5); // expected-warning {{'>' compare of equal expressions, always evaluates to false}}
+}
+
+int checkGreaterThanIntLiteralCompare2(void) {
+ return (6 > 7); // no warning
+}
+
+int checkGreaterThanIntDeclCompare1(void) {
+ int f = 7;
+ int g = 7;
+
+ return (f > g); // no warning
+}
+
+int checkGreaterThanIntDeclCompare3(void) {
+ int f = 7;
+ return (f > 7); // no warning
+}
+
+int checkGreaterThanIntDeclCompare4(void) {
+ int f = 7;
+ return (7 > f); // no warning
+}
+
+int checkGreaterThanCastIntDeclCompare11(void) {
+ int f = 7;
+ return ((int)f > (int)f); // expected-warning {{'>' compare of equal expressions, always evaluates to false}}
+}
+int checkGreaterThanCastIntDeclCompare12(void) {
+ int f = 7;
+ return ((char)f > (int)f); // no warning
+}
+int checkGreaterThanBinaryOpIntCompare1(void) {
+ int res;
+ int f= 3;
+ res = (f + 3 > f + 3); // expected-warning {{'>' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+int checkGreaterThanBinaryOpIntCompare2(void) {
+ int f = 7;
+ int g = 7;
+ return (f + 3 > g + 3); // no warning
+}
+int checkGreaterThanBinaryOpIntCompare3(void) {
+ int res;
+ int f= 3;
+ res = ((int)f + 3 > (int)f + 3); // expected-warning {{'>' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+int checkGreaterThanBinaryOpIntCompare4(void) {
+ int res;
+ int f= 3;
+ res = ((int)f + 3 > (char)f + 3); // no warning
+ return (0);
+}
+
+int checkGreaterThanNestedBinaryOpIntCompare1(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (3 - u)*t) > ((int)f + (3 - u)*t)); // expected-warning {{'>' compare of equal expressions, always evaluates to false}}
+ return (0);
+}
+
+int checkGreaterThanNestedBinaryOpIntCompare2(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (u - 3)*t) > ((int)f + (3 - u)*t)); // no warning
+ return (0);
+}
+
+/* end GT with int */
+
+/* end GT */
+
Index: test/Analysis/array-struct-region.cpp
===================================================================
--- test/Analysis/array-struct-region.cpp (revision 190657)
+++ test/Analysis/array-struct-region.cpp (arbetskopia)
@@ -21,7 +21,7 @@
#if __cplusplus
const struct S *operator -(const struct S &s) { return &s; }
-bool operator ~(const struct S &s) { return &s != &s; }
+bool operator ~(const struct S &s) { return (&s) != &s; }
#endif
> _______________________________________________
> cfe-commits mailing list
> [email protected]
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
_______________________________________________
cfe-commits mailing list
[email protected]
http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
