1 //===--- IntegerTypesCheck.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 "IntegerTypesCheck.h"
10 #include "clang/AST/ASTContext.h"
11 #include "clang/ASTMatchers/ASTMatchFinder.h"
12 #include "clang/ASTMatchers/ASTMatchers.h"
13 #include "clang/Basic/AttrKinds.h"
14 #include "clang/Basic/CharInfo.h"
15 #include "clang/Basic/IdentifierTable.h"
16 #include "clang/Basic/TargetInfo.h"
17 #include "clang/Lex/Lexer.h"
18
19 namespace clang {
20
21 using namespace ast_matchers;
22
getTokenAtLoc(SourceLocation Loc,const MatchFinder::MatchResult & MatchResult,IdentifierTable & IdentTable)23 static Token getTokenAtLoc(SourceLocation Loc,
24 const MatchFinder::MatchResult &MatchResult,
25 IdentifierTable &IdentTable) {
26 Token Tok;
27 if (Lexer::getRawToken(Loc, Tok, *MatchResult.SourceManager,
28 MatchResult.Context->getLangOpts(), false))
29 return Tok;
30
31 if (Tok.is(tok::raw_identifier)) {
32 IdentifierInfo &Info = IdentTable.get(Tok.getRawIdentifier());
33 Tok.setIdentifierInfo(&Info);
34 Tok.setKind(Info.getTokenID());
35 }
36 return Tok;
37 }
38
39 namespace tidy {
40 namespace google {
41 namespace runtime {
42
IntegerTypesCheck(StringRef Name,ClangTidyContext * Context)43 IntegerTypesCheck::IntegerTypesCheck(StringRef Name, ClangTidyContext *Context)
44 : ClangTidyCheck(Name, Context),
45 UnsignedTypePrefix(Options.get("UnsignedTypePrefix", "uint")),
46 SignedTypePrefix(Options.get("SignedTypePrefix", "int")),
47 TypeSuffix(Options.get("TypeSuffix", "")) {}
48
storeOptions(ClangTidyOptions::OptionMap & Opts)49 void IntegerTypesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
50 Options.store(Opts, "UnsignedTypePrefix", UnsignedTypePrefix);
51 Options.store(Opts, "SignedTypePrefix", SignedTypePrefix);
52 Options.store(Opts, "TypeSuffix", TypeSuffix);
53 }
54
registerMatchers(MatchFinder * Finder)55 void IntegerTypesCheck::registerMatchers(MatchFinder *Finder) {
56 // Match any integer types, unless they are passed to a printf-based API:
57 //
58 // http://google.github.io/styleguide/cppguide.html#64-bit_Portability
59 // "Where possible, avoid passing arguments of types specified by
60 // bitwidth typedefs to printf-based APIs."
61 Finder->addMatcher(typeLoc(loc(isInteger()),
62 unless(hasAncestor(callExpr(
63 callee(functionDecl(hasAttr(attr::Format)))))))
64 .bind("tl"),
65 this);
66 IdentTable = std::make_unique<IdentifierTable>(getLangOpts());
67 }
68
check(const MatchFinder::MatchResult & Result)69 void IntegerTypesCheck::check(const MatchFinder::MatchResult &Result) {
70 auto TL = *Result.Nodes.getNodeAs<TypeLoc>("tl");
71 SourceLocation Loc = TL.getBeginLoc();
72
73 if (Loc.isInvalid() || Loc.isMacroID())
74 return;
75
76 // Look through qualification.
77 if (auto QualLoc = TL.getAs<QualifiedTypeLoc>())
78 TL = QualLoc.getUnqualifiedLoc();
79
80 auto BuiltinLoc = TL.getAs<BuiltinTypeLoc>();
81 if (!BuiltinLoc)
82 return;
83
84 Token Tok = getTokenAtLoc(Loc, Result, *IdentTable);
85 // Ensure the location actually points to one of the builting integral type
86 // names we're interested in. Otherwise, we might be getting this match from
87 // implicit code (e.g. an implicit assignment operator of a class containing
88 // an array of non-POD types).
89 if (!Tok.isOneOf(tok::kw_short, tok::kw_long, tok::kw_unsigned,
90 tok::kw_signed))
91 return;
92
93 bool IsSigned;
94 unsigned Width;
95 const TargetInfo &TargetInfo = Result.Context->getTargetInfo();
96
97 // Look for uses of short, long, long long and their unsigned versions.
98 switch (BuiltinLoc.getTypePtr()->getKind()) {
99 case BuiltinType::Short:
100 Width = TargetInfo.getShortWidth();
101 IsSigned = true;
102 break;
103 case BuiltinType::Long:
104 Width = TargetInfo.getLongWidth();
105 IsSigned = true;
106 break;
107 case BuiltinType::LongLong:
108 Width = TargetInfo.getLongLongWidth();
109 IsSigned = true;
110 break;
111 case BuiltinType::UShort:
112 Width = TargetInfo.getShortWidth();
113 IsSigned = false;
114 break;
115 case BuiltinType::ULong:
116 Width = TargetInfo.getLongWidth();
117 IsSigned = false;
118 break;
119 case BuiltinType::ULongLong:
120 Width = TargetInfo.getLongLongWidth();
121 IsSigned = false;
122 break;
123 default:
124 return;
125 }
126
127 // We allow "unsigned short port" as that's reasonably common and required by
128 // the sockets API.
129 const StringRef Port = "unsigned short port";
130 const char *Data = Result.SourceManager->getCharacterData(Loc);
131 if (!std::strncmp(Data, Port.data(), Port.size()) &&
132 !isIdentifierBody(Data[Port.size()]))
133 return;
134
135 std::string Replacement =
136 ((IsSigned ? SignedTypePrefix : UnsignedTypePrefix) + Twine(Width) +
137 TypeSuffix)
138 .str();
139
140 // We don't add a fix-it as changing the type can easily break code,
141 // e.g. when a function requires a 'long' argument on all platforms.
142 // QualTypes are printed with implicit quotes.
143 diag(Loc, "consider replacing %0 with '%1'") << BuiltinLoc.getType()
144 << Replacement;
145 }
146
147 } // namespace runtime
148 } // namespace google
149 } // namespace tidy
150 } // namespace clang
151