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
SignedBitwiseCheck(StringRef Name,ClangTidyContext * Context)20 SignedBitwiseCheck::SignedBitwiseCheck(StringRef Name,
21 ClangTidyContext *Context)
22 : ClangTidyCheck(Name, Context),
23 IgnorePositiveIntegerLiterals(
24 Options.get("IgnorePositiveIntegerLiterals", false)) {}
25
storeOptions(ClangTidyOptions::OptionMap & Opts)26 void SignedBitwiseCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
27 Options.store(Opts, "IgnorePositiveIntegerLiterals",
28 IgnorePositiveIntegerLiterals);
29 }
30
registerMatchers(MatchFinder * Finder)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
check(const MatchFinder::MatchResult & Result)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 Location;
84
85 if (const auto *UnaryOp = N.getNodeAs<UnaryOperator>("unary-signed")) {
86 IsUnary = true;
87 Location = UnaryOp->getBeginLoc();
88 } else {
89 if (const auto *BinaryOp =
90 N.getNodeAs<BinaryOperator>("binary-no-sign-interference"))
91 Location = BinaryOp->getBeginLoc();
92 else if (const auto *BinaryOp =
93 N.getNodeAs<BinaryOperator>("binary-sign-interference"))
94 Location = BinaryOp->getBeginLoc();
95 else
96 llvm_unreachable("unexpected matcher result");
97 }
98 diag(Location, "use of a signed integer operand with a "
99 "%select{binary|unary}0 bitwise operator")
100 << IsUnary << SignedOperand->getSourceRange();
101 }
102
103 } // namespace hicpp
104 } // namespace tidy
105 } // namespace clang
106