[analyzer] Add IdenticalExprChecker, to find copy-pasted code.
This syntactic checker looks for expressions on both sides of comparison operators that are structurally the same. As a special case, the floating-point idiom "x != x" for "isnan(x)" is left alone. Currently this only checks comparison operators, but in the future we could extend this to include logical operators or chained if-conditionals. Checker by Per Viberg! llvm-svn: 194236
This commit is contained in:
parent
1a4ae202c7
commit
51327f9237
|
@ -33,6 +33,7 @@ add_clang_library(clangStaticAnalyzerCheckers
|
|||
FixedAddressChecker.cpp
|
||||
GenericTaintChecker.cpp
|
||||
IdempotentOperationChecker.cpp
|
||||
IdenticalExprChecker.cpp
|
||||
IvarInvalidationChecker.cpp
|
||||
LLVMConventionsChecker.cpp
|
||||
MacOSKeychainAPIChecker.cpp
|
||||
|
|
|
@ -100,6 +100,10 @@ def CastToStructChecker : Checker<"CastToStruct">,
|
|||
HelpText<"Check for cast from non-struct pointer to struct pointer">,
|
||||
DescFile<"CastToStructChecker.cpp">;
|
||||
|
||||
def IdenticalExprChecker : Checker<"IdenticalExpr">,
|
||||
HelpText<"Warn about unintended use of identical expressions in operators">,
|
||||
DescFile<"IdenticalExprChecker.cpp">;
|
||||
|
||||
def FixedAddressChecker : Checker<"FixedAddr">,
|
||||
HelpText<"Check for assignment of a fixed address to a pointer">,
|
||||
DescFile<"FixedAddressChecker.cpp">;
|
||||
|
|
|
@ -0,0 +1,222 @@
|
|||
//== IdenticalExprChecker.cpp - Identical 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 IdenticalExprChecker, a check that warns about
|
||||
/// unintended use of identical expressions.
|
||||
///
|
||||
/// It checks for use of identical expressions with comparison operators.
|
||||
///
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#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 isIdenticalExpr(const ASTContext &Ctx, const Expr *Expr1,
|
||||
const Expr *Expr2);
|
||||
//===----------------------------------------------------------------------===//
|
||||
// FindIdenticalExprVisitor - Identify nodes using identical expressions.
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
class FindIdenticalExprVisitor
|
||||
: public RecursiveASTVisitor<FindIdenticalExprVisitor> {
|
||||
public:
|
||||
explicit FindIdenticalExprVisitor(BugReporter &B, AnalysisDeclContext *A)
|
||||
: BR(B), AC(A) {}
|
||||
// FindIdenticalExprVisitor only visits nodes
|
||||
// that are binary operators.
|
||||
bool VisitBinaryOperator(const BinaryOperator *B);
|
||||
|
||||
private:
|
||||
BugReporter &BR;
|
||||
AnalysisDeclContext *AC;
|
||||
};
|
||||
|
||||
bool FindIdenticalExprVisitor::VisitBinaryOperator(const BinaryOperator *B) {
|
||||
BinaryOperator::Opcode Op = B->getOpcode();
|
||||
if (!BinaryOperator::isComparisonOp(Op))
|
||||
return true;
|
||||
//
|
||||
// Special case for floating-point representation.
|
||||
//
|
||||
// If expressions on both sides of comparison operator are of type float,
|
||||
// then for some comparison operators 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 the 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.
|
||||
//
|
||||
const Expr *LHS = B->getLHS()->IgnoreParenImpCasts();
|
||||
const Expr *RHS = B->getRHS()->IgnoreParenImpCasts();
|
||||
|
||||
const DeclRefExpr *DeclRef1 = dyn_cast<DeclRefExpr>(LHS);
|
||||
const DeclRefExpr *DeclRef2 = dyn_cast<DeclRefExpr>(RHS);
|
||||
const FloatingLiteral *FloatLit1 = dyn_cast<FloatingLiteral>(LHS);
|
||||
const 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 operator still has floating-point
|
||||
// representation, 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.
|
||||
}
|
||||
|
||||
if (isIdenticalExpr(AC->getASTContext(), B->getLHS(), B->getRHS())) {
|
||||
PathDiagnosticLocation ELoc =
|
||||
PathDiagnosticLocation::createOperatorLoc(B, BR.getSourceManager());
|
||||
StringRef Message;
|
||||
if (((Op == BO_EQ) || (Op == BO_LE) || (Op == BO_GE)))
|
||||
Message = "comparison of identical expressions always evaluates to true";
|
||||
else
|
||||
Message = "comparison of identical expressions always evaluates to false";
|
||||
BR.EmitBasicReport(AC->getDecl(), "Compare of identical expressions",
|
||||
categories::LogicError, Message, ELoc);
|
||||
}
|
||||
// We want to visit ALL nodes (subexpressions of binary comparison
|
||||
// expressions too) that contains comparison operators.
|
||||
// True is always returned to traverse ALL nodes.
|
||||
return true;
|
||||
}
|
||||
/// \brief Determines whether two expression trees are identical regarding
|
||||
/// operators and symbols.
|
||||
///
|
||||
/// Exceptions: expressions containing macros or functions with possible side
|
||||
/// effects are never considered identical.
|
||||
/// Limitations: (t + u) and (u + t) are not considered identical.
|
||||
/// t*(u + t) and t*u + t*t are not considered identical.
|
||||
///
|
||||
static bool isIdenticalExpr(const ASTContext &Ctx, const Expr *Expr1,
|
||||
const Expr *Expr2) {
|
||||
// If Expr1 & Expr2 are of different class then they are not
|
||||
// identical expression.
|
||||
if (Expr1->getStmtClass() != Expr2->getStmtClass())
|
||||
return false;
|
||||
// If Expr1 has side effects then don't warn even if expressions
|
||||
// are identical.
|
||||
if (Expr1->HasSideEffects(Ctx))
|
||||
return false;
|
||||
// Is expression is based on macro then don't warn even if
|
||||
// the expressions are identical.
|
||||
if ((Expr1->getExprLoc().isMacroID()) || (Expr2->getExprLoc().isMacroID()))
|
||||
return false;
|
||||
// If all children of two expressions are identical, return true.
|
||||
Expr::const_child_iterator I1 = Expr1->child_begin();
|
||||
Expr::const_child_iterator I2 = Expr2->child_begin();
|
||||
while (I1 != Expr1->child_end() && I2 != Expr2->child_end()) {
|
||||
const Expr *Child1 = dyn_cast<Expr>(*I1);
|
||||
const Expr *Child2 = dyn_cast<Expr>(*I2);
|
||||
if (!Child1 || !Child2 || !isIdenticalExpr(Ctx, Child1, Child2))
|
||||
return false;
|
||||
++I1;
|
||||
++I2;
|
||||
}
|
||||
// If there are different number of children in the expressions, return false.
|
||||
// (TODO: check if this is 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;
|
||||
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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// FindIdenticalExprChecker
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
class FindIdenticalExprChecker : public Checker<check::ASTCodeBody> {
|
||||
public:
|
||||
void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
|
||||
BugReporter &BR) const {
|
||||
FindIdenticalExprVisitor Visitor(BR, Mgr.getAnalysisDeclContext(D));
|
||||
Visitor.TraverseDecl(const_cast<Decl *>(D));
|
||||
}
|
||||
};
|
||||
|
||||
void ento::registerIdenticalExprChecker(CheckerManager &Mgr) {
|
||||
Mgr.registerChecker<FindIdenticalExprChecker>();
|
||||
}
|
|
@ -21,7 +21,7 @@ struct S {
|
|||
|
||||
#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
|
||||
|
||||
|
||||
|
|
|
@ -0,0 +1,942 @@
|
|||
// RUN: %clang_cc1 -analyze -analyzer-checker=core,alpha.core.IdenticalExpr -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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical 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 identical expressions always evaluates to false}}
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* end GT with int */
|
||||
|
||||
/* end GT */
|
Loading…
Reference in New Issue