head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.9 netbsd-11-0-RC3:1.1.1.9 netbsd-11-0-RC2:1.1.1.9 netbsd-11-0-RC1:1.1.1.9 perseant-exfatfs-base-20250801:1.1.1.9 netbsd-11:1.1.1.9.0.10 netbsd-11-base:1.1.1.9 netbsd-10-1-RELEASE:1.1.1.9 perseant-exfatfs-base-20240630:1.1.1.9 perseant-exfatfs:1.1.1.9.0.8 perseant-exfatfs-base:1.1.1.9 netbsd-8-3-RELEASE:1.1.1.7 netbsd-9-4-RELEASE:1.1.1.8 netbsd-10-0-RELEASE:1.1.1.9 netbsd-10-0-RC6:1.1.1.9 netbsd-10-0-RC5:1.1.1.9 netbsd-10-0-RC4:1.1.1.9 netbsd-10-0-RC3:1.1.1.9 netbsd-10-0-RC2:1.1.1.9 netbsd-10-0-RC1:1.1.1.9 netbsd-10:1.1.1.9.0.6 netbsd-10-base:1.1.1.9 netbsd-9-3-RELEASE:1.1.1.8 cjep_sun2x:1.1.1.9.0.4 cjep_sun2x-base:1.1.1.9 cjep_staticlib_x-base1:1.1.1.9 netbsd-9-2-RELEASE:1.1.1.8 cjep_staticlib_x:1.1.1.9.0.2 cjep_staticlib_x-base:1.1.1.9 netbsd-9-1-RELEASE:1.1.1.8 phil-wifi-20200421:1.1.1.9 phil-wifi-20200411:1.1.1.9 phil-wifi-20200406:1.1.1.9 netbsd-8-2-RELEASE:1.1.1.7 netbsd-9-0-RELEASE:1.1.1.8 netbsd-9-0-RC2:1.1.1.8 netbsd-9-0-RC1:1.1.1.8 netbsd-9:1.1.1.8.0.2 netbsd-9-base:1.1.1.8 phil-wifi-20190609:1.1.1.8 netbsd-8-1-RELEASE:1.1.1.7 netbsd-8-1-RC1:1.1.1.7 pgoyette-compat-merge-20190127:1.1.1.7.14.1 pgoyette-compat-20190127:1.1.1.8 pgoyette-compat-20190118:1.1.1.8 pgoyette-compat-1226:1.1.1.8 pgoyette-compat-1126:1.1.1.8 pgoyette-compat-1020:1.1.1.8 pgoyette-compat-0930:1.1.1.8 pgoyette-compat-0906:1.1.1.8 netbsd-7-2-RELEASE:1.1.1.5.2.1 pgoyette-compat-0728:1.1.1.8 clang-337282:1.1.1.8 netbsd-8-0-RELEASE:1.1.1.7 phil-wifi:1.1.1.7.0.16 phil-wifi-base:1.1.1.7 pgoyette-compat-0625:1.1.1.7 netbsd-8-0-RC2:1.1.1.7 pgoyette-compat-0521:1.1.1.7 pgoyette-compat-0502:1.1.1.7 pgoyette-compat-0422:1.1.1.7 netbsd-8-0-RC1:1.1.1.7 pgoyette-compat-0415:1.1.1.7 pgoyette-compat-0407:1.1.1.7 pgoyette-compat-0330:1.1.1.7 pgoyette-compat-0322:1.1.1.7 pgoyette-compat-0315:1.1.1.7 netbsd-7-1-2-RELEASE:1.1.1.5.2.1 pgoyette-compat:1.1.1.7.0.14 pgoyette-compat-base:1.1.1.7 netbsd-7-1-1-RELEASE:1.1.1.5.2.1 clang-319952:1.1.1.7 matt-nb8-mediatek:1.1.1.7.0.12 matt-nb8-mediatek-base:1.1.1.7 clang-309604:1.1.1.7 perseant-stdc-iso10646:1.1.1.7.0.10 perseant-stdc-iso10646-base:1.1.1.7 netbsd-8:1.1.1.7.0.8 netbsd-8-base:1.1.1.7 prg-localcount2-base3:1.1.1.7 prg-localcount2-base2:1.1.1.7 prg-localcount2-base1:1.1.1.7 prg-localcount2:1.1.1.7.0.6 prg-localcount2-base:1.1.1.7 pgoyette-localcount-20170426:1.1.1.7 bouyer-socketcan-base1:1.1.1.7 pgoyette-localcount-20170320:1.1.1.7 netbsd-7-1:1.1.1.5.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.5.2.1 netbsd-7-1-RC2:1.1.1.5.2.1 clang-294123:1.1.1.7 netbsd-7-nhusb-base-20170116:1.1.1.5.2.1 bouyer-socketcan:1.1.1.7.0.4 bouyer-socketcan-base:1.1.1.7 clang-291444:1.1.1.7 pgoyette-localcount-20170107:1.1.1.7 netbsd-7-1-RC1:1.1.1.5.2.1 pgoyette-localcount-20161104:1.1.1.7 netbsd-7-0-2-RELEASE:1.1.1.5.2.1 localcount-20160914:1.1.1.7 netbsd-7-nhusb:1.1.1.5.2.1.0.4 netbsd-7-nhusb-base:1.1.1.5.2.1 clang-280599:1.1.1.7 pgoyette-localcount-20160806:1.1.1.7 pgoyette-localcount-20160726:1.1.1.7 pgoyette-localcount:1.1.1.7.0.2 pgoyette-localcount-base:1.1.1.7 netbsd-7-0-1-RELEASE:1.1.1.5.2.1 clang-261930:1.1.1.7 netbsd-7-0:1.1.1.5.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.5.2.1 netbsd-7-0-RC3:1.1.1.5.2.1 netbsd-7-0-RC2:1.1.1.5.2.1 netbsd-7-0-RC1:1.1.1.5.2.1 clang-237755:1.1.1.6 clang-232565:1.1.1.6 clang-227398:1.1.1.6 tls-maxphys-base:1.1.1.5 tls-maxphys:1.1.1.5.0.4 netbsd-7:1.1.1.5.0.2 netbsd-7-base:1.1.1.5 clang-215315:1.1.1.5 clang-209886:1.1.1.5 yamt-pagecache:1.1.1.4.0.4 yamt-pagecache-base9:1.1.1.4 tls-earlyentropy:1.1.1.4.0.2 tls-earlyentropy-base:1.1.1.5 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.4 riastradh-drm2-base3:1.1.1.4 clang-202566:1.1.1.4 clang-201163:1.1.1.3 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.52; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.39.30; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.25; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.03.04.19.55.01; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid 29z1hJonZISIXprx; 1.1.1.5 date 2014.05.30.18.14.44; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 8q0kdlBlCn09GACx; 1.1.1.6 date 2015.01.29.19.57.30; author joerg; state Exp; branches; next 1.1.1.7; commitid mlISSizlPKvepX7y; 1.1.1.7 date 2016.02.27.22.12.06; author joerg; state Exp; branches 1.1.1.7.14.1 1.1.1.7.16.1; next 1.1.1.8; commitid tIimz3oDlh1NpBWy; 1.1.1.8 date 2018.07.17.18.31.07; author joerg; state Exp; branches; next 1.1.1.9; commitid wDzL46ALjrCZgwKA; 1.1.1.9 date 2019.11.13.22.19.28; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.4.2.1 date 2014.08.10.07.08.10; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.4.4.1 date 2014.03.04.19.55.01; author yamt; state dead; branches; next 1.1.1.4.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.4.2 date 2014.05.22.16.18.31; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.2.1 date 2015.06.04.20.04.30; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.5.4.1 date 2014.05.30.18.14.44; author tls; state dead; branches; next 1.1.1.5.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.5.4.2 date 2014.08.19.23.47.31; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.14.1 date 2018.07.28.04.33.23; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.7.16.1 date 2019.06.10.21.45.28; author christos; state Exp; branches; next 1.1.1.7.16.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.7.16.2 date 2020.04.13.07.46.38; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//== 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. //===----------------------------------------------------------------------===// namespace { class FindIdenticalExprVisitor : public RecursiveASTVisitor { 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; }; } // end anonymous namespace 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(LHS); const DeclRefExpr *DeclRef2 = dyn_cast(RHS); const FloatingLiteral *FloatLit1 = dyn_cast(LHS); const FloatingLiteral *FloatLit2 = dyn_cast(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(*I1); const Expr *Child2 = dyn_cast(*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(Expr1); const BinaryOperator *BinOp2 = dyn_cast(Expr2); return BinOp1->getOpcode() == BinOp2->getOpcode(); } case Stmt::CharacterLiteralClass: { const CharacterLiteral *CharLit1 = dyn_cast(Expr1); const CharacterLiteral *CharLit2 = dyn_cast(Expr2); return CharLit1->getValue() == CharLit2->getValue(); } case Stmt::DeclRefExprClass: { const DeclRefExpr *DeclRef1 = dyn_cast(Expr1); const DeclRefExpr *DeclRef2 = dyn_cast(Expr2); return DeclRef1->getDecl() == DeclRef2->getDecl(); } case Stmt::IntegerLiteralClass: { const IntegerLiteral *IntLit1 = dyn_cast(Expr1); const IntegerLiteral *IntLit2 = dyn_cast(Expr2); return IntLit1->getValue() == IntLit2->getValue(); } case Stmt::FloatingLiteralClass: { const FloatingLiteral *FloatLit1 = dyn_cast(Expr1); const FloatingLiteral *FloatLit2 = dyn_cast(Expr2); return FloatLit1->getValue().bitwiseIsEqual(FloatLit2->getValue()); } case Stmt::MemberExprClass: { const MemberExpr *MemberExpr1 = dyn_cast(Expr1); const MemberExpr *MemberExpr2 = dyn_cast(Expr2); return MemberExpr1->getMemberDecl() == MemberExpr2->getMemberDecl(); } case Stmt::UnaryOperatorClass: { const UnaryOperator *UnaryOp1 = dyn_cast(Expr1); const UnaryOperator *UnaryOp2 = dyn_cast(Expr2); if (UnaryOp1->getOpcode() != UnaryOp2->getOpcode()) return false; return !UnaryOp1->isIncrementDecrementOp(); } } } //===----------------------------------------------------------------------===// // FindIdenticalExprChecker //===----------------------------------------------------------------------===// namespace { class FindIdenticalExprChecker : public Checker { public: void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr, BugReporter &BR) const { FindIdenticalExprVisitor Visitor(BR, Mgr.getAnalysisDeclContext(D)); Visitor.TraverseDecl(const_cast(D)); } }; } // end anonymous namespace void ento::registerIdenticalExprChecker(CheckerManager &Mgr) { Mgr.registerChecker(); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d14 1 a14 2 /// It checks for use of identical expressions with comparison operators and /// inside conditional expressions. d29 1 a29 1 const Expr *Expr2, bool IgnoreSideEffects = false); d41 1 a41 1 // that are binary operators or conditional operators. a42 1 bool VisitConditionalOperator(const ConditionalOperator *C); a120 28 bool FindIdenticalExprVisitor::VisitConditionalOperator( const ConditionalOperator *C) { // Check if expressions in conditional expression are identical // from a symbolic point of view. if (isIdenticalExpr(AC->getASTContext(), C->getTrueExpr(), C->getFalseExpr(), true)) { PathDiagnosticLocation ELoc = PathDiagnosticLocation::createConditionalColonLoc( C, BR.getSourceManager()); SourceRange Sr[2]; Sr[0] = C->getTrueExpr()->getSourceRange(); Sr[1] = C->getFalseExpr()->getSourceRange(); BR.EmitBasicReport( AC->getDecl(), "Identical expressions in conditional expression", categories::LogicError, "identical expressions on both sides of ':' in conditional expression", ELoc, Sr); } // We want to visit ALL nodes (expressions in conditional // expressions too) that contains conditional operators, // thus always return true to traverse ALL nodes. return true; } d130 1 a130 1 const Expr *Expr2, bool IgnoreSideEffects) { d137 1 a137 1 if (!IgnoreSideEffects && Expr1->HasSideEffects(Ctx)) d139 1 a139 1 // If either expression comes from a macro then don't warn even if d149 1 a149 2 if (!Child1 || !Child2 || !isIdenticalExpr(Ctx, Child1, Child2, IgnoreSideEffects)) a163 1 case Stmt::CallExprClass: d170 2 a171 2 const BinaryOperator *BinOp1 = cast(Expr1); const BinaryOperator *BinOp2 = cast(Expr2); d175 2 a176 2 const CharacterLiteral *CharLit1 = cast(Expr1); const CharacterLiteral *CharLit2 = cast(Expr2); d180 2 a181 2 const DeclRefExpr *DeclRef1 = cast(Expr1); const DeclRefExpr *DeclRef2 = cast(Expr2); d185 2 a186 2 const IntegerLiteral *IntLit1 = cast(Expr1); const IntegerLiteral *IntLit2 = cast(Expr2); d190 2 a191 2 const FloatingLiteral *FloatLit1 = cast(Expr1); const FloatingLiteral *FloatLit2 = cast(Expr2); d195 2 a196 2 const MemberExpr *MemberExpr1 = cast(Expr1); const MemberExpr *MemberExpr2 = cast(Expr2); d200 5 a204 3 const UnaryOperator *UnaryOp1 = cast(Expr1); const UnaryOperator *UnaryOp2 = cast(Expr2); return UnaryOp1->getOpcode() == UnaryOp2->getOpcode(); @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @a19 1 #include "clang/AST/RecursiveASTVisitor.h" d24 1 @ 1.1.1.4 log @Import Clang 3.5svn r202566. @ text @d29 2 a30 2 static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1, const Stmt *Stmt2, bool IgnoreSideEffects = false); a37 3 BugReporter &BR; const CheckerBase *Checker; AnalysisDeclContext *AC; d39 2 a40 4 explicit FindIdenticalExprVisitor(BugReporter &B, const CheckerBase *Checker, AnalysisDeclContext *A) : BR(B), Checker(Checker), AC(A) {} d42 1 a42 2 // that are binary operators, if statements or // conditional operators. a43 1 bool VisitIfStmt(const IfStmt *I); d47 2 a48 4 void reportIdenticalExpr(const BinaryOperator *B, bool CheckBitwise, ArrayRef Sr); void checkBitwiseOrLogicalOp(const BinaryOperator *B, bool CheckBitwise); void checkComparisonOp(const BinaryOperator *B); a51 79 void FindIdenticalExprVisitor::reportIdenticalExpr(const BinaryOperator *B, bool CheckBitwise, ArrayRef Sr) { StringRef Message; if (CheckBitwise) Message = "identical expressions on both sides of bitwise operator"; else Message = "identical expressions on both sides of logical operator"; PathDiagnosticLocation ELoc = PathDiagnosticLocation::createOperatorLoc(B, BR.getSourceManager()); BR.EmitBasicReport(AC->getDecl(), Checker, "Use of identical expressions", categories::LogicError, Message, ELoc, Sr); } void FindIdenticalExprVisitor::checkBitwiseOrLogicalOp(const BinaryOperator *B, bool CheckBitwise) { SourceRange Sr[2]; const Expr *LHS = B->getLHS(); const Expr *RHS = B->getRHS(); // Split operators as long as we still have operators to split on. We will // get called for every binary operator in an expression so there is no need // to check every one against each other here, just the right most one with // the others. while (const BinaryOperator *B2 = dyn_cast(LHS)) { if (B->getOpcode() != B2->getOpcode()) break; if (isIdenticalStmt(AC->getASTContext(), RHS, B2->getRHS())) { Sr[0] = RHS->getSourceRange(); Sr[1] = B2->getRHS()->getSourceRange(); reportIdenticalExpr(B, CheckBitwise, Sr); } LHS = B2->getLHS(); } if (isIdenticalStmt(AC->getASTContext(), RHS, LHS)) { Sr[0] = RHS->getSourceRange(); Sr[1] = LHS->getSourceRange(); reportIdenticalExpr(B, CheckBitwise, Sr); } } bool FindIdenticalExprVisitor::VisitIfStmt(const IfStmt *I) { const Stmt *Stmt1 = I->getThen(); const Stmt *Stmt2 = I->getElse(); if (!Stmt1 || !Stmt2) return true; // Special handling for code like: // // if (b) { // i = 1; // } else // i = 1; if (const CompoundStmt *CompStmt = dyn_cast(Stmt1)) { if (CompStmt->size() == 1) Stmt1 = CompStmt->body_back(); } if (const CompoundStmt *CompStmt = dyn_cast(Stmt2)) { if (CompStmt->size() == 1) Stmt2 = CompStmt->body_back(); } if (isIdenticalStmt(AC->getASTContext(), Stmt1, Stmt2, true)) { PathDiagnosticLocation ELoc = PathDiagnosticLocation::createBegin(I, BR.getSourceManager(), AC); BR.EmitBasicReport(AC->getDecl(), Checker, "Identical branches", categories::LogicError, "true and false branches are identical", ELoc); } return true; } d54 2 a55 19 if (BinaryOperator::isBitwiseOp(Op)) checkBitwiseOrLogicalOp(B, true); if (BinaryOperator::isLogicalOp(Op)) checkBitwiseOrLogicalOp(B, false); if (BinaryOperator::isComparisonOp(Op)) checkComparisonOp(B); // 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; } void FindIdenticalExprVisitor::checkComparisonOp(const BinaryOperator *B) { BinaryOperator::Opcode Op = B->getOpcode(); d88 1 a88 1 return; d95 1 a95 1 return; d102 1 a102 1 return; d107 1 a107 1 if (isIdenticalStmt(AC->getASTContext(), B->getLHS(), B->getRHS())) { d115 1 a115 2 BR.EmitBasicReport(AC->getDecl(), Checker, "Compare of identical expressions", d118 4 d130 1 a130 1 if (isIdenticalStmt(AC->getASTContext(), C->getTrueExpr(), d140 1 a140 2 AC->getDecl(), Checker, "Identical expressions in conditional expression", d151 1 a151 1 /// \brief Determines whether two statement trees are identical regarding d159 29 a187 6 static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1, const Stmt *Stmt2, bool IgnoreSideEffects) { if (!Stmt1 || !Stmt2) { if (!Stmt1 && !Stmt2) return true; d189 1 a189 5 } // If Stmt1 & Stmt2 are of different class then they are not // identical statements. if (Stmt1->getStmtClass() != Stmt2->getStmtClass()) d192 1 a192 31 const Expr *Expr1 = dyn_cast(Stmt1); const Expr *Expr2 = dyn_cast(Stmt2); if (Expr1 && Expr2) { // If Stmt1 has side effects then don't warn even if expressions // are identical. if (!IgnoreSideEffects && Expr1->HasSideEffects(Ctx)) return false; // If either expression comes from a 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()) { if (!*I1 || !*I2 || !isIdenticalStmt(Ctx, *I1, *I2, IgnoreSideEffects)) return false; ++I1; ++I2; } // If there are different number of children in the statements, return // false. if (I1 != Expr1->child_end()) return false; if (I2 != Expr2->child_end()) return false; } switch (Stmt1->getStmtClass()) { d197 1 a199 33 case Stmt::BreakStmtClass: case Stmt::ContinueStmtClass: case Stmt::NullStmtClass: return true; case Stmt::CStyleCastExprClass: { const CStyleCastExpr* CastExpr1 = cast(Stmt1); const CStyleCastExpr* CastExpr2 = cast(Stmt2); return CastExpr1->getTypeAsWritten() == CastExpr2->getTypeAsWritten(); } case Stmt::ReturnStmtClass: { const ReturnStmt *ReturnStmt1 = cast(Stmt1); const ReturnStmt *ReturnStmt2 = cast(Stmt2); return isIdenticalStmt(Ctx, ReturnStmt1->getRetValue(), ReturnStmt2->getRetValue(), IgnoreSideEffects); } case Stmt::ForStmtClass: { const ForStmt *ForStmt1 = cast(Stmt1); const ForStmt *ForStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, ForStmt1->getInit(), ForStmt2->getInit(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, ForStmt1->getCond(), ForStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, ForStmt1->getInc(), ForStmt2->getInc(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, ForStmt1->getBody(), ForStmt2->getBody(), IgnoreSideEffects)) return false; a200 59 } case Stmt::DoStmtClass: { const DoStmt *DStmt1 = cast(Stmt1); const DoStmt *DStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, DStmt1->getCond(), DStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, DStmt1->getBody(), DStmt2->getBody(), IgnoreSideEffects)) return false; return true; } case Stmt::WhileStmtClass: { const WhileStmt *WStmt1 = cast(Stmt1); const WhileStmt *WStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, WStmt1->getCond(), WStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, WStmt1->getBody(), WStmt2->getBody(), IgnoreSideEffects)) return false; return true; } case Stmt::IfStmtClass: { const IfStmt *IStmt1 = cast(Stmt1); const IfStmt *IStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, IStmt1->getCond(), IStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, IStmt1->getThen(), IStmt2->getThen(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, IStmt1->getElse(), IStmt2->getElse(), IgnoreSideEffects)) return false; return true; } case Stmt::CompoundStmtClass: { const CompoundStmt *CompStmt1 = cast(Stmt1); const CompoundStmt *CompStmt2 = cast(Stmt2); if (CompStmt1->size() != CompStmt2->size()) return false; CompoundStmt::const_body_iterator I1 = CompStmt1->body_begin(); CompoundStmt::const_body_iterator I2 = CompStmt2->body_begin(); while (I1 != CompStmt1->body_end() && I2 != CompStmt2->body_end()) { if (!isIdenticalStmt(Ctx, *I1, *I2, IgnoreSideEffects)) return false; ++I1; ++I2; } return true; } case Stmt::CompoundAssignOperatorClass: d202 2 a203 2 const BinaryOperator *BinOp1 = cast(Stmt1); const BinaryOperator *BinOp2 = cast(Stmt2); d207 2 a208 2 const CharacterLiteral *CharLit1 = cast(Stmt1); const CharacterLiteral *CharLit2 = cast(Stmt2); d212 2 a213 2 const DeclRefExpr *DeclRef1 = cast(Stmt1); const DeclRefExpr *DeclRef2 = cast(Stmt2); d217 2 a218 2 const IntegerLiteral *IntLit1 = cast(Stmt1); const IntegerLiteral *IntLit2 = cast(Stmt2); d222 2 a223 2 const FloatingLiteral *FloatLit1 = cast(Stmt1); const FloatingLiteral *FloatLit2 = cast(Stmt2); a225 5 case Stmt::StringLiteralClass: { const StringLiteral *StringLit1 = cast(Stmt1); const StringLiteral *StringLit2 = cast(Stmt2); return StringLit1->getString() == StringLit2->getString(); } d227 3 a229 3 const MemberExpr *MemberStmt1 = cast(Stmt1); const MemberExpr *MemberStmt2 = cast(Stmt2); return MemberStmt1->getMemberDecl() == MemberStmt2->getMemberDecl(); d232 2 a233 2 const UnaryOperator *UnaryOp1 = cast(Stmt1); const UnaryOperator *UnaryOp2 = cast(Stmt2); d248 1 a248 1 FindIdenticalExprVisitor Visitor(BR, this, Mgr.getAnalysisDeclContext(D)); @ 1.1.1.4.2.1 log @Rebase. @ text @a110 24 // Check for identical conditions: // // if (b) { // foo1(); // } else if (b) { // foo2(); // } if (Stmt1 && Stmt2) { const Expr *Cond1 = I->getCond(); const Stmt *Else = Stmt2; while (const IfStmt *I2 = dyn_cast_or_null(Else)) { const Expr *Cond2 = I2->getCond(); if (isIdenticalStmt(AC->getASTContext(), Cond1, Cond2, false)) { SourceRange Sr = Cond1->getSourceRange(); PathDiagnosticLocation ELoc(Cond2, BR.getSourceManager(), AC); BR.EmitBasicReport(AC->getDecl(), Checker, "Identical conditions", categories::LogicError, "expression is identical to previous condition", ELoc, Sr); } Else = I2->getElse(); } } @ 1.1.1.5 log @Import Clang 3.5svn r209886. @ text @a110 24 // Check for identical conditions: // // if (b) { // foo1(); // } else if (b) { // foo2(); // } if (Stmt1 && Stmt2) { const Expr *Cond1 = I->getCond(); const Stmt *Else = Stmt2; while (const IfStmt *I2 = dyn_cast_or_null(Else)) { const Expr *Cond2 = I2->getCond(); if (isIdenticalStmt(AC->getASTContext(), Cond1, Cond2, false)) { SourceRange Sr = Cond1->getSourceRange(); PathDiagnosticLocation ELoc(Cond2, BR.getSourceManager(), AC); BR.EmitBasicReport(AC->getDecl(), Checker, "Identical conditions", categories::LogicError, "expression is identical to previous condition", ELoc, Sr); } Else = I2->getElse(); } } @ 1.1.1.5.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d448 1 a448 6 llvm::APInt I1 = IntLit1->getValue(); llvm::APInt I2 = IntLit2->getValue(); if (I1.getBitWidth() != I2.getBitWidth()) return false; return I1 == I2; d458 1 a458 1 return StringLit1->getBytes() == StringLit2->getBytes(); @ 1.1.1.6 log @Import Clang 3.6RC1 r227398. @ text @d448 1 a448 6 llvm::APInt I1 = IntLit1->getValue(); llvm::APInt I2 = IntLit2->getValue(); if (I1.getBitWidth() != I2.getBitWidth()) return false; return I1 == I2; d458 1 a458 1 return StringLit1->getBytes() == StringLit2->getBytes(); @ 1.1.1.7 log @Import Clang 3.8.0rc3 r261930. @ text @d99 1 a99 1 a110 18 // Check for identical inner condition: // // if (x<10) { // if (x<10) { // .. if (const CompoundStmt *CS = dyn_cast(Stmt1)) { if (!CS->body_empty()) { const IfStmt *InnerIf = dyn_cast(*CS->body_begin()); if (InnerIf && isIdenticalStmt(AC->getASTContext(), I->getCond(), InnerIf->getCond(), /*ignoreSideEffects=*/ false)) { PathDiagnosticLocation ELoc(InnerIf->getCond(), BR.getSourceManager(), AC); BR.EmitBasicReport(AC->getDecl(), Checker, "Identical conditions", categories::LogicError, "conditions of the inner and outer statements are identical", ELoc); } } } d290 3 a292 1 return !Stmt1 && !Stmt2; a334 1 case Stmt::OMPArraySectionExprClass: @ 1.1.1.7.16.1 log @Sync with HEAD @ text @d11 1 a11 1 /// This defines IdenticalExprChecker, a check that warns about d258 1 a258 4 if (Op == BO_Cmp) Message = "comparison of identical expressions always evaluates to " "'equal'"; else if (((Op == BO_EQ) || (Op == BO_LE) || (Op == BO_GE))) d296 1 a296 1 /// Determines whether two statement trees are identical regarding @ 1.1.1.7.16.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.7.14.1 log @Sync with HEAD @ text @d11 1 a11 1 /// This defines IdenticalExprChecker, a check that warns about d258 1 a258 4 if (Op == BO_Cmp) Message = "comparison of identical expressions always evaluates to " "'equal'"; else if (((Op == BO_EQ) || (Op == BO_LE) || (Op == BO_GE))) d296 1 a296 1 /// Determines whether two statement trees are identical regarding @ 1.1.1.8 log @Import clang r337282 from trunk @ text @d11 1 a11 1 /// This defines IdenticalExprChecker, a check that warns about d258 1 a258 4 if (Op == BO_Cmp) Message = "comparison of identical expressions always evaluates to " "'equal'"; else if (((Op == BO_EQ) || (Op == BO_LE) || (Op == BO_GE))) d296 1 a296 1 /// Determines whether two statement trees are identical regarding @ 1.1.1.9 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.5.4.1 log @file IdenticalExprChecker.cpp was added on branch tls-maxphys on 2014-08-19 23:47:31 +0000 @ text @d1 490 @ 1.1.1.5.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 490 //== 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 and /// inside conditional expressions. /// //===----------------------------------------------------------------------===// #include "ClangSACheckers.h" #include "clang/AST/RecursiveASTVisitor.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; static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1, const Stmt *Stmt2, bool IgnoreSideEffects = false); //===----------------------------------------------------------------------===// // FindIdenticalExprVisitor - Identify nodes using identical expressions. //===----------------------------------------------------------------------===// namespace { class FindIdenticalExprVisitor : public RecursiveASTVisitor { BugReporter &BR; const CheckerBase *Checker; AnalysisDeclContext *AC; public: explicit FindIdenticalExprVisitor(BugReporter &B, const CheckerBase *Checker, AnalysisDeclContext *A) : BR(B), Checker(Checker), AC(A) {} // FindIdenticalExprVisitor only visits nodes // that are binary operators, if statements or // conditional operators. bool VisitBinaryOperator(const BinaryOperator *B); bool VisitIfStmt(const IfStmt *I); bool VisitConditionalOperator(const ConditionalOperator *C); private: void reportIdenticalExpr(const BinaryOperator *B, bool CheckBitwise, ArrayRef Sr); void checkBitwiseOrLogicalOp(const BinaryOperator *B, bool CheckBitwise); void checkComparisonOp(const BinaryOperator *B); }; } // end anonymous namespace void FindIdenticalExprVisitor::reportIdenticalExpr(const BinaryOperator *B, bool CheckBitwise, ArrayRef Sr) { StringRef Message; if (CheckBitwise) Message = "identical expressions on both sides of bitwise operator"; else Message = "identical expressions on both sides of logical operator"; PathDiagnosticLocation ELoc = PathDiagnosticLocation::createOperatorLoc(B, BR.getSourceManager()); BR.EmitBasicReport(AC->getDecl(), Checker, "Use of identical expressions", categories::LogicError, Message, ELoc, Sr); } void FindIdenticalExprVisitor::checkBitwiseOrLogicalOp(const BinaryOperator *B, bool CheckBitwise) { SourceRange Sr[2]; const Expr *LHS = B->getLHS(); const Expr *RHS = B->getRHS(); // Split operators as long as we still have operators to split on. We will // get called for every binary operator in an expression so there is no need // to check every one against each other here, just the right most one with // the others. while (const BinaryOperator *B2 = dyn_cast(LHS)) { if (B->getOpcode() != B2->getOpcode()) break; if (isIdenticalStmt(AC->getASTContext(), RHS, B2->getRHS())) { Sr[0] = RHS->getSourceRange(); Sr[1] = B2->getRHS()->getSourceRange(); reportIdenticalExpr(B, CheckBitwise, Sr); } LHS = B2->getLHS(); } if (isIdenticalStmt(AC->getASTContext(), RHS, LHS)) { Sr[0] = RHS->getSourceRange(); Sr[1] = LHS->getSourceRange(); reportIdenticalExpr(B, CheckBitwise, Sr); } } bool FindIdenticalExprVisitor::VisitIfStmt(const IfStmt *I) { const Stmt *Stmt1 = I->getThen(); const Stmt *Stmt2 = I->getElse(); // Check for identical conditions: // // if (b) { // foo1(); // } else if (b) { // foo2(); // } if (Stmt1 && Stmt2) { const Expr *Cond1 = I->getCond(); const Stmt *Else = Stmt2; while (const IfStmt *I2 = dyn_cast_or_null(Else)) { const Expr *Cond2 = I2->getCond(); if (isIdenticalStmt(AC->getASTContext(), Cond1, Cond2, false)) { SourceRange Sr = Cond1->getSourceRange(); PathDiagnosticLocation ELoc(Cond2, BR.getSourceManager(), AC); BR.EmitBasicReport(AC->getDecl(), Checker, "Identical conditions", categories::LogicError, "expression is identical to previous condition", ELoc, Sr); } Else = I2->getElse(); } } if (!Stmt1 || !Stmt2) return true; // Special handling for code like: // // if (b) { // i = 1; // } else // i = 1; if (const CompoundStmt *CompStmt = dyn_cast(Stmt1)) { if (CompStmt->size() == 1) Stmt1 = CompStmt->body_back(); } if (const CompoundStmt *CompStmt = dyn_cast(Stmt2)) { if (CompStmt->size() == 1) Stmt2 = CompStmt->body_back(); } if (isIdenticalStmt(AC->getASTContext(), Stmt1, Stmt2, true)) { PathDiagnosticLocation ELoc = PathDiagnosticLocation::createBegin(I, BR.getSourceManager(), AC); BR.EmitBasicReport(AC->getDecl(), Checker, "Identical branches", categories::LogicError, "true and false branches are identical", ELoc); } return true; } bool FindIdenticalExprVisitor::VisitBinaryOperator(const BinaryOperator *B) { BinaryOperator::Opcode Op = B->getOpcode(); if (BinaryOperator::isBitwiseOp(Op)) checkBitwiseOrLogicalOp(B, true); if (BinaryOperator::isLogicalOp(Op)) checkBitwiseOrLogicalOp(B, false); if (BinaryOperator::isComparisonOp(Op)) checkComparisonOp(B); // 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; } void FindIdenticalExprVisitor::checkComparisonOp(const BinaryOperator *B) { BinaryOperator::Opcode Op = B->getOpcode(); // // 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(LHS); const DeclRefExpr *DeclRef2 = dyn_cast(RHS); const FloatingLiteral *FloatLit1 = dyn_cast(LHS); const FloatingLiteral *FloatLit2 = dyn_cast(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; } } } 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; } else { // No special case with floating-point representation, report as usual. } if (isIdenticalStmt(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(), Checker, "Compare of identical expressions", categories::LogicError, Message, ELoc); } } bool FindIdenticalExprVisitor::VisitConditionalOperator( const ConditionalOperator *C) { // Check if expressions in conditional expression are identical // from a symbolic point of view. if (isIdenticalStmt(AC->getASTContext(), C->getTrueExpr(), C->getFalseExpr(), true)) { PathDiagnosticLocation ELoc = PathDiagnosticLocation::createConditionalColonLoc( C, BR.getSourceManager()); SourceRange Sr[2]; Sr[0] = C->getTrueExpr()->getSourceRange(); Sr[1] = C->getFalseExpr()->getSourceRange(); BR.EmitBasicReport( AC->getDecl(), Checker, "Identical expressions in conditional expression", categories::LogicError, "identical expressions on both sides of ':' in conditional expression", ELoc, Sr); } // We want to visit ALL nodes (expressions in conditional // expressions too) that contains conditional operators, // thus always return true to traverse ALL nodes. return true; } /// \brief Determines whether two statement 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 isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1, const Stmt *Stmt2, bool IgnoreSideEffects) { if (!Stmt1 || !Stmt2) { if (!Stmt1 && !Stmt2) return true; return false; } // If Stmt1 & Stmt2 are of different class then they are not // identical statements. if (Stmt1->getStmtClass() != Stmt2->getStmtClass()) return false; const Expr *Expr1 = dyn_cast(Stmt1); const Expr *Expr2 = dyn_cast(Stmt2); if (Expr1 && Expr2) { // If Stmt1 has side effects then don't warn even if expressions // are identical. if (!IgnoreSideEffects && Expr1->HasSideEffects(Ctx)) return false; // If either expression comes from a 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()) { if (!*I1 || !*I2 || !isIdenticalStmt(Ctx, *I1, *I2, IgnoreSideEffects)) return false; ++I1; ++I2; } // If there are different number of children in the statements, return // false. if (I1 != Expr1->child_end()) return false; if (I2 != Expr2->child_end()) return false; } switch (Stmt1->getStmtClass()) { default: return false; case Stmt::CallExprClass: case Stmt::ArraySubscriptExprClass: case Stmt::ImplicitCastExprClass: case Stmt::ParenExprClass: case Stmt::BreakStmtClass: case Stmt::ContinueStmtClass: case Stmt::NullStmtClass: return true; case Stmt::CStyleCastExprClass: { const CStyleCastExpr* CastExpr1 = cast(Stmt1); const CStyleCastExpr* CastExpr2 = cast(Stmt2); return CastExpr1->getTypeAsWritten() == CastExpr2->getTypeAsWritten(); } case Stmt::ReturnStmtClass: { const ReturnStmt *ReturnStmt1 = cast(Stmt1); const ReturnStmt *ReturnStmt2 = cast(Stmt2); return isIdenticalStmt(Ctx, ReturnStmt1->getRetValue(), ReturnStmt2->getRetValue(), IgnoreSideEffects); } case Stmt::ForStmtClass: { const ForStmt *ForStmt1 = cast(Stmt1); const ForStmt *ForStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, ForStmt1->getInit(), ForStmt2->getInit(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, ForStmt1->getCond(), ForStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, ForStmt1->getInc(), ForStmt2->getInc(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, ForStmt1->getBody(), ForStmt2->getBody(), IgnoreSideEffects)) return false; return true; } case Stmt::DoStmtClass: { const DoStmt *DStmt1 = cast(Stmt1); const DoStmt *DStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, DStmt1->getCond(), DStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, DStmt1->getBody(), DStmt2->getBody(), IgnoreSideEffects)) return false; return true; } case Stmt::WhileStmtClass: { const WhileStmt *WStmt1 = cast(Stmt1); const WhileStmt *WStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, WStmt1->getCond(), WStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, WStmt1->getBody(), WStmt2->getBody(), IgnoreSideEffects)) return false; return true; } case Stmt::IfStmtClass: { const IfStmt *IStmt1 = cast(Stmt1); const IfStmt *IStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, IStmt1->getCond(), IStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, IStmt1->getThen(), IStmt2->getThen(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, IStmt1->getElse(), IStmt2->getElse(), IgnoreSideEffects)) return false; return true; } case Stmt::CompoundStmtClass: { const CompoundStmt *CompStmt1 = cast(Stmt1); const CompoundStmt *CompStmt2 = cast(Stmt2); if (CompStmt1->size() != CompStmt2->size()) return false; CompoundStmt::const_body_iterator I1 = CompStmt1->body_begin(); CompoundStmt::const_body_iterator I2 = CompStmt2->body_begin(); while (I1 != CompStmt1->body_end() && I2 != CompStmt2->body_end()) { if (!isIdenticalStmt(Ctx, *I1, *I2, IgnoreSideEffects)) return false; ++I1; ++I2; } return true; } case Stmt::CompoundAssignOperatorClass: case Stmt::BinaryOperatorClass: { const BinaryOperator *BinOp1 = cast(Stmt1); const BinaryOperator *BinOp2 = cast(Stmt2); return BinOp1->getOpcode() == BinOp2->getOpcode(); } case Stmt::CharacterLiteralClass: { const CharacterLiteral *CharLit1 = cast(Stmt1); const CharacterLiteral *CharLit2 = cast(Stmt2); return CharLit1->getValue() == CharLit2->getValue(); } case Stmt::DeclRefExprClass: { const DeclRefExpr *DeclRef1 = cast(Stmt1); const DeclRefExpr *DeclRef2 = cast(Stmt2); return DeclRef1->getDecl() == DeclRef2->getDecl(); } case Stmt::IntegerLiteralClass: { const IntegerLiteral *IntLit1 = cast(Stmt1); const IntegerLiteral *IntLit2 = cast(Stmt2); return IntLit1->getValue() == IntLit2->getValue(); } case Stmt::FloatingLiteralClass: { const FloatingLiteral *FloatLit1 = cast(Stmt1); const FloatingLiteral *FloatLit2 = cast(Stmt2); return FloatLit1->getValue().bitwiseIsEqual(FloatLit2->getValue()); } case Stmt::StringLiteralClass: { const StringLiteral *StringLit1 = cast(Stmt1); const StringLiteral *StringLit2 = cast(Stmt2); return StringLit1->getString() == StringLit2->getString(); } case Stmt::MemberExprClass: { const MemberExpr *MemberStmt1 = cast(Stmt1); const MemberExpr *MemberStmt2 = cast(Stmt2); return MemberStmt1->getMemberDecl() == MemberStmt2->getMemberDecl(); } case Stmt::UnaryOperatorClass: { const UnaryOperator *UnaryOp1 = cast(Stmt1); const UnaryOperator *UnaryOp2 = cast(Stmt2); return UnaryOp1->getOpcode() == UnaryOp2->getOpcode(); } } } //===----------------------------------------------------------------------===// // FindIdenticalExprChecker //===----------------------------------------------------------------------===// namespace { class FindIdenticalExprChecker : public Checker { public: void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr, BugReporter &BR) const { FindIdenticalExprVisitor Visitor(BR, this, Mgr.getAnalysisDeclContext(D)); Visitor.TraverseDecl(const_cast(D)); } }; } // end anonymous namespace void ento::registerIdenticalExprChecker(CheckerManager &Mgr) { Mgr.registerChecker(); } @ 1.1.1.4.4.1 log @file IdenticalExprChecker.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:31 +0000 @ text @d1 466 @ 1.1.1.4.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 466 //== 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 and /// inside conditional expressions. /// //===----------------------------------------------------------------------===// #include "ClangSACheckers.h" #include "clang/AST/RecursiveASTVisitor.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; static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1, const Stmt *Stmt2, bool IgnoreSideEffects = false); //===----------------------------------------------------------------------===// // FindIdenticalExprVisitor - Identify nodes using identical expressions. //===----------------------------------------------------------------------===// namespace { class FindIdenticalExprVisitor : public RecursiveASTVisitor { BugReporter &BR; const CheckerBase *Checker; AnalysisDeclContext *AC; public: explicit FindIdenticalExprVisitor(BugReporter &B, const CheckerBase *Checker, AnalysisDeclContext *A) : BR(B), Checker(Checker), AC(A) {} // FindIdenticalExprVisitor only visits nodes // that are binary operators, if statements or // conditional operators. bool VisitBinaryOperator(const BinaryOperator *B); bool VisitIfStmt(const IfStmt *I); bool VisitConditionalOperator(const ConditionalOperator *C); private: void reportIdenticalExpr(const BinaryOperator *B, bool CheckBitwise, ArrayRef Sr); void checkBitwiseOrLogicalOp(const BinaryOperator *B, bool CheckBitwise); void checkComparisonOp(const BinaryOperator *B); }; } // end anonymous namespace void FindIdenticalExprVisitor::reportIdenticalExpr(const BinaryOperator *B, bool CheckBitwise, ArrayRef Sr) { StringRef Message; if (CheckBitwise) Message = "identical expressions on both sides of bitwise operator"; else Message = "identical expressions on both sides of logical operator"; PathDiagnosticLocation ELoc = PathDiagnosticLocation::createOperatorLoc(B, BR.getSourceManager()); BR.EmitBasicReport(AC->getDecl(), Checker, "Use of identical expressions", categories::LogicError, Message, ELoc, Sr); } void FindIdenticalExprVisitor::checkBitwiseOrLogicalOp(const BinaryOperator *B, bool CheckBitwise) { SourceRange Sr[2]; const Expr *LHS = B->getLHS(); const Expr *RHS = B->getRHS(); // Split operators as long as we still have operators to split on. We will // get called for every binary operator in an expression so there is no need // to check every one against each other here, just the right most one with // the others. while (const BinaryOperator *B2 = dyn_cast(LHS)) { if (B->getOpcode() != B2->getOpcode()) break; if (isIdenticalStmt(AC->getASTContext(), RHS, B2->getRHS())) { Sr[0] = RHS->getSourceRange(); Sr[1] = B2->getRHS()->getSourceRange(); reportIdenticalExpr(B, CheckBitwise, Sr); } LHS = B2->getLHS(); } if (isIdenticalStmt(AC->getASTContext(), RHS, LHS)) { Sr[0] = RHS->getSourceRange(); Sr[1] = LHS->getSourceRange(); reportIdenticalExpr(B, CheckBitwise, Sr); } } bool FindIdenticalExprVisitor::VisitIfStmt(const IfStmt *I) { const Stmt *Stmt1 = I->getThen(); const Stmt *Stmt2 = I->getElse(); if (!Stmt1 || !Stmt2) return true; // Special handling for code like: // // if (b) { // i = 1; // } else // i = 1; if (const CompoundStmt *CompStmt = dyn_cast(Stmt1)) { if (CompStmt->size() == 1) Stmt1 = CompStmt->body_back(); } if (const CompoundStmt *CompStmt = dyn_cast(Stmt2)) { if (CompStmt->size() == 1) Stmt2 = CompStmt->body_back(); } if (isIdenticalStmt(AC->getASTContext(), Stmt1, Stmt2, true)) { PathDiagnosticLocation ELoc = PathDiagnosticLocation::createBegin(I, BR.getSourceManager(), AC); BR.EmitBasicReport(AC->getDecl(), Checker, "Identical branches", categories::LogicError, "true and false branches are identical", ELoc); } return true; } bool FindIdenticalExprVisitor::VisitBinaryOperator(const BinaryOperator *B) { BinaryOperator::Opcode Op = B->getOpcode(); if (BinaryOperator::isBitwiseOp(Op)) checkBitwiseOrLogicalOp(B, true); if (BinaryOperator::isLogicalOp(Op)) checkBitwiseOrLogicalOp(B, false); if (BinaryOperator::isComparisonOp(Op)) checkComparisonOp(B); // 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; } void FindIdenticalExprVisitor::checkComparisonOp(const BinaryOperator *B) { BinaryOperator::Opcode Op = B->getOpcode(); // // 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(LHS); const DeclRefExpr *DeclRef2 = dyn_cast(RHS); const FloatingLiteral *FloatLit1 = dyn_cast(LHS); const FloatingLiteral *FloatLit2 = dyn_cast(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; } } } 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; } else { // No special case with floating-point representation, report as usual. } if (isIdenticalStmt(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(), Checker, "Compare of identical expressions", categories::LogicError, Message, ELoc); } } bool FindIdenticalExprVisitor::VisitConditionalOperator( const ConditionalOperator *C) { // Check if expressions in conditional expression are identical // from a symbolic point of view. if (isIdenticalStmt(AC->getASTContext(), C->getTrueExpr(), C->getFalseExpr(), true)) { PathDiagnosticLocation ELoc = PathDiagnosticLocation::createConditionalColonLoc( C, BR.getSourceManager()); SourceRange Sr[2]; Sr[0] = C->getTrueExpr()->getSourceRange(); Sr[1] = C->getFalseExpr()->getSourceRange(); BR.EmitBasicReport( AC->getDecl(), Checker, "Identical expressions in conditional expression", categories::LogicError, "identical expressions on both sides of ':' in conditional expression", ELoc, Sr); } // We want to visit ALL nodes (expressions in conditional // expressions too) that contains conditional operators, // thus always return true to traverse ALL nodes. return true; } /// \brief Determines whether two statement 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 isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1, const Stmt *Stmt2, bool IgnoreSideEffects) { if (!Stmt1 || !Stmt2) { if (!Stmt1 && !Stmt2) return true; return false; } // If Stmt1 & Stmt2 are of different class then they are not // identical statements. if (Stmt1->getStmtClass() != Stmt2->getStmtClass()) return false; const Expr *Expr1 = dyn_cast(Stmt1); const Expr *Expr2 = dyn_cast(Stmt2); if (Expr1 && Expr2) { // If Stmt1 has side effects then don't warn even if expressions // are identical. if (!IgnoreSideEffects && Expr1->HasSideEffects(Ctx)) return false; // If either expression comes from a 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()) { if (!*I1 || !*I2 || !isIdenticalStmt(Ctx, *I1, *I2, IgnoreSideEffects)) return false; ++I1; ++I2; } // If there are different number of children in the statements, return // false. if (I1 != Expr1->child_end()) return false; if (I2 != Expr2->child_end()) return false; } switch (Stmt1->getStmtClass()) { default: return false; case Stmt::CallExprClass: case Stmt::ArraySubscriptExprClass: case Stmt::ImplicitCastExprClass: case Stmt::ParenExprClass: case Stmt::BreakStmtClass: case Stmt::ContinueStmtClass: case Stmt::NullStmtClass: return true; case Stmt::CStyleCastExprClass: { const CStyleCastExpr* CastExpr1 = cast(Stmt1); const CStyleCastExpr* CastExpr2 = cast(Stmt2); return CastExpr1->getTypeAsWritten() == CastExpr2->getTypeAsWritten(); } case Stmt::ReturnStmtClass: { const ReturnStmt *ReturnStmt1 = cast(Stmt1); const ReturnStmt *ReturnStmt2 = cast(Stmt2); return isIdenticalStmt(Ctx, ReturnStmt1->getRetValue(), ReturnStmt2->getRetValue(), IgnoreSideEffects); } case Stmt::ForStmtClass: { const ForStmt *ForStmt1 = cast(Stmt1); const ForStmt *ForStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, ForStmt1->getInit(), ForStmt2->getInit(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, ForStmt1->getCond(), ForStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, ForStmt1->getInc(), ForStmt2->getInc(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, ForStmt1->getBody(), ForStmt2->getBody(), IgnoreSideEffects)) return false; return true; } case Stmt::DoStmtClass: { const DoStmt *DStmt1 = cast(Stmt1); const DoStmt *DStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, DStmt1->getCond(), DStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, DStmt1->getBody(), DStmt2->getBody(), IgnoreSideEffects)) return false; return true; } case Stmt::WhileStmtClass: { const WhileStmt *WStmt1 = cast(Stmt1); const WhileStmt *WStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, WStmt1->getCond(), WStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, WStmt1->getBody(), WStmt2->getBody(), IgnoreSideEffects)) return false; return true; } case Stmt::IfStmtClass: { const IfStmt *IStmt1 = cast(Stmt1); const IfStmt *IStmt2 = cast(Stmt2); if (!isIdenticalStmt(Ctx, IStmt1->getCond(), IStmt2->getCond(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, IStmt1->getThen(), IStmt2->getThen(), IgnoreSideEffects)) return false; if (!isIdenticalStmt(Ctx, IStmt1->getElse(), IStmt2->getElse(), IgnoreSideEffects)) return false; return true; } case Stmt::CompoundStmtClass: { const CompoundStmt *CompStmt1 = cast(Stmt1); const CompoundStmt *CompStmt2 = cast(Stmt2); if (CompStmt1->size() != CompStmt2->size()) return false; CompoundStmt::const_body_iterator I1 = CompStmt1->body_begin(); CompoundStmt::const_body_iterator I2 = CompStmt2->body_begin(); while (I1 != CompStmt1->body_end() && I2 != CompStmt2->body_end()) { if (!isIdenticalStmt(Ctx, *I1, *I2, IgnoreSideEffects)) return false; ++I1; ++I2; } return true; } case Stmt::CompoundAssignOperatorClass: case Stmt::BinaryOperatorClass: { const BinaryOperator *BinOp1 = cast(Stmt1); const BinaryOperator *BinOp2 = cast(Stmt2); return BinOp1->getOpcode() == BinOp2->getOpcode(); } case Stmt::CharacterLiteralClass: { const CharacterLiteral *CharLit1 = cast(Stmt1); const CharacterLiteral *CharLit2 = cast(Stmt2); return CharLit1->getValue() == CharLit2->getValue(); } case Stmt::DeclRefExprClass: { const DeclRefExpr *DeclRef1 = cast(Stmt1); const DeclRefExpr *DeclRef2 = cast(Stmt2); return DeclRef1->getDecl() == DeclRef2->getDecl(); } case Stmt::IntegerLiteralClass: { const IntegerLiteral *IntLit1 = cast(Stmt1); const IntegerLiteral *IntLit2 = cast(Stmt2); return IntLit1->getValue() == IntLit2->getValue(); } case Stmt::FloatingLiteralClass: { const FloatingLiteral *FloatLit1 = cast(Stmt1); const FloatingLiteral *FloatLit2 = cast(Stmt2); return FloatLit1->getValue().bitwiseIsEqual(FloatLit2->getValue()); } case Stmt::StringLiteralClass: { const StringLiteral *StringLit1 = cast(Stmt1); const StringLiteral *StringLit2 = cast(Stmt2); return StringLit1->getString() == StringLit2->getString(); } case Stmt::MemberExprClass: { const MemberExpr *MemberStmt1 = cast(Stmt1); const MemberExpr *MemberStmt2 = cast(Stmt2); return MemberStmt1->getMemberDecl() == MemberStmt2->getMemberDecl(); } case Stmt::UnaryOperatorClass: { const UnaryOperator *UnaryOp1 = cast(Stmt1); const UnaryOperator *UnaryOp2 = cast(Stmt2); return UnaryOp1->getOpcode() == UnaryOp2->getOpcode(); } } } //===----------------------------------------------------------------------===// // FindIdenticalExprChecker //===----------------------------------------------------------------------===// namespace { class FindIdenticalExprChecker : public Checker { public: void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr, BugReporter &BR) const { FindIdenticalExprVisitor Visitor(BR, this, Mgr.getAnalysisDeclContext(D)); Visitor.TraverseDecl(const_cast(D)); } }; } // end anonymous namespace void ento::registerIdenticalExprChecker(CheckerManager &Mgr) { Mgr.registerChecker(); } @