Hello,
changed patch according to review comments.
Please review revised 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/Checkers.td
===================================================================
--- lib/StaticAnalyzer/Checkers/Checkers.td (revision 191949)
+++ lib/StaticAnalyzer/Checkers/Checkers.td (working copy)
@@ -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: lib/StaticAnalyzer/Checkers/EqualCompareChecker.cpp
===================================================================
--- lib/StaticAnalyzer/Checkers/EqualCompareChecker.cpp (revision 0)
+++ lib/StaticAnalyzer/Checkers/EqualCompareChecker.cpp (working copy)
@@ -0,0 +1,223 @@
+//== EqualCompareChecker.cpp - Compare equal expression checker-------------==//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This defines EqualCompareChecker, a check that warns if
+/// there are equal expressions on both side of a comparison in a 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"
+#include "clang/AST/RecursiveASTVisitor.h"
+
+using namespace clang;
+using namespace ento;
+
+static bool isSameExpr(const ASTContext &Ctx, Expr *Expr1, Expr *Expr2);
+//===----------------------------------------------------------------------===//
+// FindEqualCompareVisitor - Identify nodes with compare expressions.
+//===----------------------------------------------------------------------===//
+
+class FindEqualCompareVisitor
+ : public RecursiveASTVisitor<FindEqualCompareVisitor> {
+public:
+ explicit FindEqualCompareVisitor(BugReporter &br, AnalysisDeclContext *ac)
+ : BR(br), AC(ac) {}
+
+ // only visit nodes that are binary expressions
+ bool VisitBinaryOperator(BinaryOperator *B);
+
+private:
+ BugReporter &BR;
+ AnalysisDeclContext *AC;
+};
+
+bool FindEqualCompareVisitor::VisitBinaryOperator(BinaryOperator *B) {
+ bool isSameExpression;
+ BinaryOperator::Opcode Op = B->getOpcode();
+ if (!BinaryOperator::isComparisonOp(Op))
+ return true;
+
+ //
+ // 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 true;
+ }
+ }
+ }
+ } else if ((floatlit1) && (floatlit2)) {
+ if (floatlit1->getValue().bitwiseIsEqual(floatlit2->getValue())) {
+ if ((Op == BO_EQ) || (Op == BO_NE)) {
+ return true;
+ }
+ }
+ } else if (LHS->getType()->hasFloatingRepresentation()) {
+ // 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)
+ return true;
+ } else { // No special case with floating point representation, report as
+ // usual
+ }
+
+ isSameExpression = isSameExpr(AC->getASTContext(), B->getLHS(), B->getRHS());
+ if (isSameExpression) {
+ PathDiagnosticLocation ELoc =
+ PathDiagnosticLocation::createOperatorLoc(B, BR.getSourceManager());
+ if (((Op == BO_EQ) || (Op == BO_LE) || (Op == BO_GE)))
+ BR.EmitBasicReport(AC->getDecl(), "Compare of equal expressions",
+ categories::LogicError,
+ "Comparison of equal expressions "
+ "always evaluates to true",
+ ELoc);
+ else
+ BR.EmitBasicReport(AC->getDecl(), "Compare of equal expressions",
+ categories::LogicError,
+ "Comparison of equal expressions "
+ "always evaluates to false",
+ ELoc);
+ }
+ // We want to visit ALL nodes (subexpressions of binary comparison
+ // expressions too) that contains comparison operators,
+ // thus always return true to traverse ALL nodes
+ return true;
+}
+
+// Determine whether two expression trees are identical
+// regarding operators and symbols.
+// Exceptions: expressions containing macros or functions
+// with possible side effects are never considered equal.
+// Limitations: (t + u) and (u + t) are not considered equal.
+// t*(u + t) and t*u + t*t are not considered equal.
+//
+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: {
+ const BinaryOperator *binop1 = dyn_cast<BinaryOperator>(Expr1);
+ const BinaryOperator *binop2 = dyn_cast<BinaryOperator>(Expr2);
+ return binop1->getOpcode() == binop2->getOpcode();
+ }
+ case Stmt::CharacterLiteralClass: {
+ const CharacterLiteral *charlit1 = dyn_cast<CharacterLiteral>(Expr1);
+ const CharacterLiteral *charlit2 = dyn_cast<CharacterLiteral>(Expr2);
+ return charlit1->getValue() == charlit2->getValue();
+ }
+ case Stmt::DeclRefExprClass: {
+ const DeclRefExpr *declref1 = dyn_cast<DeclRefExpr>(Expr1);
+ const DeclRefExpr *declref2 = dyn_cast<DeclRefExpr>(Expr2);
+ return declref1->getDecl() == declref2->getDecl();
+ }
+ case Stmt::IntegerLiteralClass: {
+ const IntegerLiteral *intlit1 = dyn_cast<IntegerLiteral>(Expr1);
+ const IntegerLiteral *intlit2 = dyn_cast<IntegerLiteral>(Expr2);
+ return intlit1->getValue() == intlit2->getValue();
+ }
+ case Stmt::FloatingLiteralClass: {
+ const FloatingLiteral *floatlit1 = dyn_cast<FloatingLiteral>(Expr1);
+ const FloatingLiteral *floatlit2 = dyn_cast<FloatingLiteral>(Expr2);
+ return floatlit1->getValue().bitwiseIsEqual(floatlit2->getValue());
+ }
+ case Stmt::MemberExprClass: {
+ const MemberExpr *memberexpr1 = dyn_cast<MemberExpr>(Expr1);
+ const MemberExpr *memberexpr2 = dyn_cast<MemberExpr>(Expr2);
+ return memberexpr1->getMemberDecl() == memberexpr2->getMemberDecl();
+ }
+ case Stmt::UnaryOperatorClass: {
+ const UnaryOperator *unaryop1 = dyn_cast<UnaryOperator>(Expr1);
+ const UnaryOperator *unaryop2 = dyn_cast<UnaryOperator>(Expr2);
+ if (unaryop1->getOpcode() != unaryop2->getOpcode())
+ return false;
+ return !unaryop1->isIncrementDecrementOp();
+ }
+ }
+}
+
+//===----------------------------------------------------------------------===//
+// FindEqualCompareChecker
+//===----------------------------------------------------------------------===//
+
+class FindEqualCompareChecker : public Checker<check::ASTCodeBody> {
+public:
+
+ void checkASTCodeBody(const Decl *D, AnalysisManager &mgr,
+ BugReporter &BR) const {
+ FindEqualCompareVisitor Visitor(BR, mgr.getAnalysisDeclContext(D));
+ Visitor.TraverseDecl(const_cast<Decl *>(D));
+ }
+};
+
+void ento::registerEqualCompareChecker(CheckerManager &mgr) {
+ mgr.registerChecker<FindEqualCompareChecker>();
+}
Index: lib/StaticAnalyzer/Checkers/CMakeLists.txt
===================================================================
--- lib/StaticAnalyzer/Checkers/CMakeLists.txt (revision 191949)
+++ lib/StaticAnalyzer/Checkers/CMakeLists.txt (working copy)
@@ -30,6 +30,7 @@
DivZeroChecker.cpp
DynamicTypePropagation.cpp
ExprInspectionChecker.cpp
+ EqualCompareChecker.cpp
FixedAddressChecker.cpp
GenericTaintChecker.cpp
IdempotentOperationChecker.cpp
Index: test/Analysis/array-struct-region.cpp
===================================================================
--- test/Analysis/array-struct-region.cpp (revision 191949)
+++ test/Analysis/array-struct-region.cpp (working copy)
@@ -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
Index: test/Analysis/equal-compare.cpp
===================================================================
--- test/Analysis/equal-compare.cpp (revision 0)
+++ test/Analysis/equal-compare.cpp (working copy)
@@ -0,0 +1,943 @@
+// 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 {{Comparison 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);
+}
+
+int checkNotEqualNestedBinaryOpFloatCompare3(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)*(f + t != f + t))); // no warning
+ return (0);
+}
+
+
+
+
+/* end '!=' with float*/
+
+/* '!=' with int*/
+
+int checkNotEqualIntLiteralCompare1(void) {
+ return (5 != 5); // expected-warning {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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);
+}
+
+int checkNotEqualNestedBinaryOpIntCompare3(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (u - 3)*t) != ((int)f + (3 - u)*(t + 1 != t + 1))); // expected-warning {{Comparison of equal expressions always evaluates to false}}
+ 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 {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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);
+}
+
+int checkEqualNestedBinaryOpFloatCompare3(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)*(f + t == f + t))); // no warning
+ return (0);
+}
+
+
+
+
+
+/* Equal with int*/
+
+int checkEqualIntLiteralCompare1(void) {
+ return (5 == 5); // expected-warning {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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);
+}
+
+int checkEqualNestedBinaryOpIntCompare3(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (u - 3)*t) == ((int)f + (3 - u)*(t + 1 == t + 1))); // expected-warning {{Comparison of equal expressions always evaluates to true}}
+ return (0);
+}
+
+
+/* end EQ int */
+
+/* end EQ */
+
+
+/* LT */
+
+/* LT with float */
+
+int checkLessThanFloatLiteralCompare1(void) {
+ return (5.14F < 5.14F); // expected-warning {{Comparison 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 {{Comparison 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 {{Comparison 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);
+}
+
+int checkLessThanNestedBinaryOpFloatCompare3(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)*(f + t < f + t))); // no warning
+ return (0);
+}
+
+/* end LT with float */
+
+/* LT with int */
+
+
+int checkLessThanIntLiteralCompare1(void) {
+ return (5 < 5); // expected-warning {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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);
+}
+
+int checkLessThanNestedBinaryOpIntCompare3(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (u - 3)*t) < ((int)f + (3 - u)*(t + u < t + u))); // expected-warning {{Comparison of equal expressions always evaluates to false}}
+ return (0);
+}
+
+/* end LT with int */
+
+/* end LT */
+
+
+/* GT */
+
+/* GT with float */
+
+int checkGreaterThanFloatLiteralCompare1(void) {
+ return (5.14F > 5.14F); // expected-warning {{Comparison 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 {{Comparison 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 {{Comparison 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);
+}
+
+int checkGreaterThanNestedBinaryOpFloatCompare3(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)*(f + t > f + t))); // no warning
+ return (0);
+}
+
+/* end GT with float */
+
+/* GT with int */
+
+
+int checkGreaterThanIntLiteralCompare1(void) {
+ return (5 > 5); // expected-warning {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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 {{Comparison 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);
+}
+
+int checkGreaterThanNestedBinaryOpIntCompare3(void) {
+ int res;
+ int t= 1;
+ int u= 2;
+ int f= 3;
+ res = (((int)f + (u - 3)*t) > ((int)f + (3 - u)*(t + u > t + u))); // expected-warning {{Comparison of equal expressions always evaluates to false}}
+ return (0);
+}
+
+/* end GT with int */
+
+/* end GT */
+
_______________________________________________
cfe-commits mailing list
[email protected]
http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
