clang 19.0.0git
CheckerHelpers.cpp
Go to the documentation of this file.
1//===---- CheckerHelpers.cpp - Helper functions for checkers ----*- C++ -*-===//
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// This file defines several static functions for use in checkers.
10//
11//===----------------------------------------------------------------------===//
12
14#include "clang/AST/Decl.h"
15#include "clang/AST/Expr.h"
18#include <optional>
19
20namespace clang {
21
22namespace ento {
23
24// Recursively find any substatements containing macros
25bool containsMacro(const Stmt *S) {
26 if (S->getBeginLoc().isMacroID())
27 return true;
28
29 if (S->getEndLoc().isMacroID())
30 return true;
31
32 for (const Stmt *Child : S->children())
33 if (Child && containsMacro(Child))
34 return true;
35
36 return false;
37}
38
39// Recursively find any substatements containing enum constants
40bool containsEnum(const Stmt *S) {
41 const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(S);
42
43 if (DR && isa<EnumConstantDecl>(DR->getDecl()))
44 return true;
45
46 for (const Stmt *Child : S->children())
47 if (Child && containsEnum(Child))
48 return true;
49
50 return false;
51}
52
53// Recursively find any substatements containing static vars
54bool containsStaticLocal(const Stmt *S) {
55 const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(S);
56
57 if (DR)
58 if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl()))
59 if (VD->isStaticLocal())
60 return true;
61
62 for (const Stmt *Child : S->children())
63 if (Child && containsStaticLocal(Child))
64 return true;
65
66 return false;
67}
68
69// Recursively find any substatements containing __builtin_offsetof
71 if (isa<OffsetOfExpr>(S))
72 return true;
73
74 for (const Stmt *Child : S->children())
75 if (Child && containsBuiltinOffsetOf(Child))
76 return true;
77
78 return false;
79}
80
81// Extract lhs and rhs from assignment statement
82std::pair<const clang::VarDecl *, const clang::Expr *>
84 const VarDecl *VD = nullptr;
85 const Expr *RHS = nullptr;
86
87 if (auto Assign = dyn_cast_or_null<BinaryOperator>(S)) {
88 if (Assign->isAssignmentOp()) {
89 // Ordinary assignment
90 RHS = Assign->getRHS();
91 if (auto DE = dyn_cast_or_null<DeclRefExpr>(Assign->getLHS()))
92 VD = dyn_cast_or_null<VarDecl>(DE->getDecl());
93 }
94 } else if (auto PD = dyn_cast_or_null<DeclStmt>(S)) {
95 // Initialization
96 assert(PD->isSingleDecl() && "We process decls one by one");
97 VD = cast<VarDecl>(PD->getSingleDecl());
98 RHS = VD->getAnyInitializer();
99 }
100
101 return std::make_pair(VD, RHS);
102}
103
105 const auto *AttrType = Type->getAs<AttributedType>();
106 if (!AttrType)
108 if (AttrType->getAttrKind() == attr::TypeNullable)
110 else if (AttrType->getAttrKind() == attr::TypeNonNull)
113}
114
115std::optional<int> tryExpandAsInteger(StringRef Macro, const Preprocessor &PP) {
116 const auto *MacroII = PP.getIdentifierInfo(Macro);
117 if (!MacroII)
118 return std::nullopt;
119 const MacroInfo *MI = PP.getMacroInfo(MacroII);
120 if (!MI)
121 return std::nullopt;
122
123 // Filter out parens.
124 std::vector<Token> FilteredTokens;
125 FilteredTokens.reserve(MI->tokens().size());
126 for (auto &T : MI->tokens())
127 if (!T.isOneOf(tok::l_paren, tok::r_paren))
128 FilteredTokens.push_back(T);
129
130 // Parse an integer at the end of the macro definition.
131 const Token &T = FilteredTokens.back();
132 // FIXME: EOF macro token coming from a PCH file on macOS while marked as
133 // literal, doesn't contain any literal data
134 if (!T.isLiteral() || !T.getLiteralData())
135 return std::nullopt;
136 StringRef ValueStr = StringRef(T.getLiteralData(), T.getLength());
137 llvm::APInt IntValue;
138 constexpr unsigned AutoSenseRadix = 0;
139 if (ValueStr.getAsInteger(AutoSenseRadix, IntValue))
140 return std::nullopt;
141
142 // Parse an optional minus sign.
143 size_t Size = FilteredTokens.size();
144 if (Size >= 2) {
145 if (FilteredTokens[Size - 2].is(tok::minus))
146 IntValue = -IntValue;
147 }
148
149 return IntValue.getSExtValue();
150}
151
153 bool IsBinary) {
154 llvm::StringMap<BinaryOperatorKind> BinOps{
155#define BINARY_OPERATION(Name, Spelling) {Spelling, BO_##Name},
156#include "clang/AST/OperationKinds.def"
157 };
158 llvm::StringMap<UnaryOperatorKind> UnOps{
159#define UNARY_OPERATION(Name, Spelling) {Spelling, UO_##Name},
160#include "clang/AST/OperationKinds.def"
161 };
162
163 switch (OOK) {
164#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
165 case OO_##Name: \
166 if (IsBinary) { \
167 auto BinOpIt = BinOps.find(Spelling); \
168 if (BinOpIt != BinOps.end()) \
169 return OperatorKind(BinOpIt->second); \
170 else \
171 llvm_unreachable("operator was expected to be binary but is not"); \
172 } else { \
173 auto UnOpIt = UnOps.find(Spelling); \
174 if (UnOpIt != UnOps.end()) \
175 return OperatorKind(UnOpIt->second); \
176 else \
177 llvm_unreachable("operator was expected to be unary but is not"); \
178 } \
179 break;
180#include "clang/Basic/OperatorKinds.def"
181 default:
182 llvm_unreachable("unexpected operator kind");
183 }
184}
185
186std::optional<SVal> getPointeeVal(SVal PtrSVal, ProgramStateRef State) {
187 if (const auto *Ptr = PtrSVal.getAsRegion()) {
188 return State->getSVal(Ptr);
189 }
190 return std::nullopt;
191}
192
193} // namespace ento
194} // namespace clang
Defines the clang::Preprocessor interface.
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:5623
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1260
ValueDecl * getDecl()
Definition: Expr.h:1328
This represents one expression.
Definition: Expr.h:110
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
ArrayRef< Token > tokens() const
Definition: MacroInfo.h:249
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:128
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
A (possibly-)qualified type.
Definition: Type.h:940
Stmt - This represents one statement.
Definition: Stmt.h:84
Token - This structure provides full information about a lexed token.
Definition: Token.h:36
The base class of the type hierarchy.
Definition: Type.h:1827
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:8146
Represents a variable declaration or definition.
Definition: Decl.h:918
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
Definition: Decl.h:1345
SVal - This represents a symbolic expression, which can be either an L-value or an R-value.
Definition: SVals.h:55
const MemRegion * getAsRegion() const
Definition: SVals.cpp:120
bool containsEnum(const Stmt *S)
Nullability getNullabilityAnnotation(QualType Type)
Get nullability annotation for a given type.
bool containsStaticLocal(const Stmt *S)
std::pair< const clang::VarDecl *, const clang::Expr * > parseAssignment(const Stmt *S)
OperatorKind operationKindFromOverloadedOperator(OverloadedOperatorKind OOK, bool IsBinary)
bool containsBuiltinOffsetOf(const Stmt *S)
std::optional< SVal > getPointeeVal(SVal PtrSVal, ProgramStateRef State)
std::optional< int > tryExpandAsInteger(StringRef Macro, const Preprocessor &PP)
Try to parse the value of a defined preprocessor macro.
bool containsMacro(const Stmt *S)
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
const FunctionProtoType * T