clang-tools-extra/clang-tidy/hicpp/SignedBitwiseCheck.cpp

   1 //===--- SignedBitwiseCheck.cpp - clang-tidy-------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "SignedBitwiseCheck.h"
  10 #include "clang/AST/ASTContext.h"
  11 #include "clang/ASTMatchers/ASTMatchFinder.h"
  12
  13 using namespace clang::ast_matchers;
  14 using namespace clang::ast_matchers::internal;
  15
  16 namespace clang {
  17 namespace tidy {
  18 namespace hicpp {
  19
  20 SignedBitwiseCheck::SignedBitwiseCheck(StringRef Name,
  21                                        ClangTidyContext *Context)
  22     : ClangTidyCheck(Name, Context),
  23       IgnorePositiveIntegerLiterals(
  24           Options.get("IgnorePositiveIntegerLiterals", false)) {}
  25
  26 void SignedBitwiseCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
  27   Options.store(Opts, "IgnorePositiveIntegerLiterals",
  28                 IgnorePositiveIntegerLiterals);
  29 }
  30
  31 void SignedBitwiseCheck::registerMatchers(MatchFinder *Finder) {
  32   const auto SignedIntegerOperand =
  33       (IgnorePositiveIntegerLiterals
  34            ? expr(ignoringImpCasts(hasType(isSignedInteger())),
  35                   unless(integerLiteral()))
  36            : expr(ignoringImpCasts(hasType(isSignedInteger()))))
  37           .bind("signed-operand");
  38
  39   // The standard [bitmask.types] allows some integral types to be implemented
  40   // as signed types. Exclude these types from diagnosing for bitwise or(|) and
  41   // bitwise and(&). Shifting and complementing such values is still not
  42   // allowed.
  43   const auto BitmaskType = namedDecl(
  44       hasAnyName("::std::locale::category", "::std::ctype_base::mask",
  45                  "::std::ios_base::fmtflags", "::std::ios_base::iostate",
  46                  "::std::ios_base::openmode"));
  47   const auto IsStdBitmask = ignoringImpCasts(declRefExpr(hasType(BitmaskType)));
  48
  49   // Match binary bitwise operations on signed integer arguments.
  50   Finder->addMatcher(
  51       binaryOperator(hasAnyOperatorName("^", "|", "&", "^=", "|=", "&="),
  52
  53                      unless(allOf(hasLHS(IsStdBitmask), hasRHS(IsStdBitmask))),
  54
  55                      hasEitherOperand(SignedIntegerOperand),
  56                      hasLHS(hasType(isInteger())), hasRHS(hasType(isInteger())))
  57           .bind("binary-no-sign-interference"),
  58       this);
  59
  60   // Shifting and complement is not allowed for any signed integer type because
  61   // the sign bit may corrupt the result.
  62   Finder->addMatcher(
  63       binaryOperator(hasAnyOperatorName("<<", ">>", "<<=", ">>="),
  64                      hasEitherOperand(SignedIntegerOperand),
  65                      hasLHS(hasType(isInteger())), hasRHS(hasType(isInteger())))
  66           .bind("binary-sign-interference"),
  67       this);
  68
  69   // Match unary operations on signed integer types.
  70   Finder->addMatcher(
  71       unaryOperator(hasOperatorName("~"), hasUnaryOperand(SignedIntegerOperand))
  72           .bind("unary-signed"),
  73       this);
  74 }
  75
  76 void SignedBitwiseCheck::check(const MatchFinder::MatchResult &Result) {
  77   const ast_matchers::BoundNodes &N = Result.Nodes;
  78   const auto *SignedOperand = N.getNodeAs<Expr>("signed-operand");
  79   assert(SignedOperand &&
  80          "No signed operand found in problematic bitwise operations");
  81
  82   bool IsUnary = false;
  83   SourceLocation OperatorLoc;
  84
  85   if (const auto *UnaryOp = N.getNodeAs<UnaryOperator>("unary-signed")) {
  86     IsUnary = true;
  87     OperatorLoc = UnaryOp->getOperatorLoc();
  88   } else {
  89     if (const auto *BinaryOp =
  90             N.getNodeAs<BinaryOperator>("binary-no-sign-interference"))
  91       OperatorLoc = BinaryOp->getOperatorLoc();
  92     else if (const auto *BinaryOp =
  93                  N.getNodeAs<BinaryOperator>("binary-sign-interference"))
  94       OperatorLoc = BinaryOp->getOperatorLoc();
  95     else
  96       llvm_unreachable("unexpected matcher result");
  97   }
  98   diag(SignedOperand->getBeginLoc(), "use of a signed integer operand with a "
  99                                      "%select{binary|unary}0 bitwise operator")
 100       << IsUnary << SignedOperand->getSourceRange() << OperatorLoc;
 101 }
 102
 103 } // namespace hicpp
 104 } // namespace tidy
 105 } // namespace clang