1//===- AnalysisOrderChecker - Print callbacks called ------------*- 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 checker prints callbacks that are called during analysis.
10// This is required to ensure that callbacks are fired in order
11// and do not duplicate or get lost.
12// Feel free to extend this checker with any callback you need to check.
13//
14//===----------------------------------------------------------------------===//
15
16#include "clang/AST/ExprCXX.h"
17#include "clang/Analysis/CFGStmtMap.h"
18#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
19#include "clang/StaticAnalyzer/Core/Checker.h"
20#include "clang/StaticAnalyzer/Core/CheckerManager.h"
21#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
22#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
23
24using namespace clang;
25using namespace ento;
26
27namespace {
28
29class AnalysisOrderChecker
30 : public Checker<
31 check::PreStmt<CastExpr>, check::PostStmt<CastExpr>,
32 check::PreStmt<ArraySubscriptExpr>,
33 check::PostStmt<ArraySubscriptExpr>, check::PreStmt<CXXNewExpr>,
34 check::PostStmt<CXXNewExpr>, check::PreStmt<CXXDeleteExpr>,
35 check::PostStmt<CXXDeleteExpr>, check::PreStmt<CXXConstructExpr>,
36 check::PostStmt<CXXConstructExpr>, check::PreStmt<OffsetOfExpr>,
37 check::PostStmt<OffsetOfExpr>, check::PreCall, check::PostCall,
38 check::EndFunction, check::EndAnalysis, check::NewAllocator,
39 check::Bind, check::PointerEscape, check::RegionChanges,
40 check::LiveSymbols, eval::Call> {
41
42 bool isCallbackEnabled(const AnalyzerOptions &Opts,
43 StringRef CallbackName) const {
44 return Opts.getCheckerBooleanOption(C: this, OptionName: "*") ||
45 Opts.getCheckerBooleanOption(C: this, OptionName: CallbackName);
46 }
47
48 bool isCallbackEnabled(CheckerContext &C, StringRef CallbackName) const {
49 AnalyzerOptions &Opts = C.getAnalysisManager().getAnalyzerOptions();
50 return isCallbackEnabled(Opts, CallbackName);
51 }
52
53 bool isCallbackEnabled(ProgramStateRef State, StringRef CallbackName) const {
54 AnalyzerOptions &Opts = State->getStateManager().getOwningEngine()
55 .getAnalysisManager().getAnalyzerOptions();
56 return isCallbackEnabled(Opts, CallbackName);
57 }
58
59public:
60 void checkPreStmt(const CastExpr *CE, CheckerContext &C) const {
61 if (isCallbackEnabled(C, CallbackName: "PreStmtCastExpr"))
62 llvm::errs() << "PreStmt<CastExpr> (Kind : " << CE->getCastKindName()
63 << ")\n";
64 }
65
66 void checkPostStmt(const CastExpr *CE, CheckerContext &C) const {
67 if (isCallbackEnabled(C, CallbackName: "PostStmtCastExpr"))
68 llvm::errs() << "PostStmt<CastExpr> (Kind : " << CE->getCastKindName()
69 << ")\n";
70 }
71
72 void checkPreStmt(const ArraySubscriptExpr *SubExpr,
73 CheckerContext &C) const {
74 if (isCallbackEnabled(C, CallbackName: "PreStmtArraySubscriptExpr"))
75 llvm::errs() << "PreStmt<ArraySubscriptExpr>\n";
76 }
77
78 void checkPostStmt(const ArraySubscriptExpr *SubExpr,
79 CheckerContext &C) const {
80 if (isCallbackEnabled(C, CallbackName: "PostStmtArraySubscriptExpr"))
81 llvm::errs() << "PostStmt<ArraySubscriptExpr>\n";
82 }
83
84 void checkPreStmt(const CXXNewExpr *NE, CheckerContext &C) const {
85 if (isCallbackEnabled(C, CallbackName: "PreStmtCXXNewExpr"))
86 llvm::errs() << "PreStmt<CXXNewExpr>\n";
87 }
88
89 void checkPostStmt(const CXXNewExpr *NE, CheckerContext &C) const {
90 if (isCallbackEnabled(C, CallbackName: "PostStmtCXXNewExpr"))
91 llvm::errs() << "PostStmt<CXXNewExpr>\n";
92 }
93
94 void checkPreStmt(const CXXDeleteExpr *NE, CheckerContext &C) const {
95 if (isCallbackEnabled(C, CallbackName: "PreStmtCXXDeleteExpr"))
96 llvm::errs() << "PreStmt<CXXDeleteExpr>\n";
97 }
98
99 void checkPostStmt(const CXXDeleteExpr *NE, CheckerContext &C) const {
100 if (isCallbackEnabled(C, CallbackName: "PostStmtCXXDeleteExpr"))
101 llvm::errs() << "PostStmt<CXXDeleteExpr>\n";
102 }
103
104 void checkPreStmt(const CXXConstructExpr *NE, CheckerContext &C) const {
105 if (isCallbackEnabled(C, CallbackName: "PreStmtCXXConstructExpr"))
106 llvm::errs() << "PreStmt<CXXConstructExpr>\n";
107 }
108
109 void checkPostStmt(const CXXConstructExpr *NE, CheckerContext &C) const {
110 if (isCallbackEnabled(C, CallbackName: "PostStmtCXXConstructExpr"))
111 llvm::errs() << "PostStmt<CXXConstructExpr>\n";
112 }
113
114 void checkPreStmt(const OffsetOfExpr *OOE, CheckerContext &C) const {
115 if (isCallbackEnabled(C, CallbackName: "PreStmtOffsetOfExpr"))
116 llvm::errs() << "PreStmt<OffsetOfExpr>\n";
117 }
118
119 void checkPostStmt(const OffsetOfExpr *OOE, CheckerContext &C) const {
120 if (isCallbackEnabled(C, CallbackName: "PostStmtOffsetOfExpr"))
121 llvm::errs() << "PostStmt<OffsetOfExpr>\n";
122 }
123
124 bool evalCall(const CallEvent &Call, CheckerContext &C) const {
125 if (isCallbackEnabled(C, CallbackName: "EvalCall")) {
126 llvm::errs() << "EvalCall";
127 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(Val: Call.getDecl()))
128 llvm::errs() << " (" << ND->getQualifiedNameAsString() << ')';
129 llvm::errs() << " {argno: " << Call.getNumArgs() << '}';
130 llvm::errs() << " [" << Call.getKindAsString() << ']';
131 llvm::errs() << '\n';
132 return true;
133 }
134 return false;
135 }
136
137 void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
138 if (isCallbackEnabled(C, CallbackName: "PreCall")) {
139 llvm::errs() << "PreCall";
140 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(Val: Call.getDecl()))
141 llvm::errs() << " (" << ND->getQualifiedNameAsString() << ')';
142 llvm::errs() << " [" << Call.getKindAsString() << ']';
143 llvm::errs() << '\n';
144 }
145 }
146
147 void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
148 if (isCallbackEnabled(C, CallbackName: "PostCall")) {
149 llvm::errs() << "PostCall";
150 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(Val: Call.getDecl()))
151 llvm::errs() << " (" << ND->getQualifiedNameAsString() << ')';
152 llvm::errs() << " [" << Call.getKindAsString() << ']';
153 llvm::errs() << '\n';
154 }
155 }
156
157 void checkEndFunction(const ReturnStmt *S, CheckerContext &C) const {
158 if (isCallbackEnabled(C, CallbackName: "EndFunction")) {
159 llvm::errs() << "EndFunction\nReturnStmt: " << (S ? "yes" : "no") << "\n";
160 if (!S)
161 return;
162
163 llvm::errs() << "CFGElement: ";
164 CFGStmtMap *Map = C.getCurrentAnalysisDeclContext()->getCFGStmtMap();
165 CFGElement LastElement = Map->getBlock(S)->back();
166
167 if (LastElement.getAs<CFGStmt>())
168 llvm::errs() << "CFGStmt\n";
169 else if (LastElement.getAs<CFGAutomaticObjDtor>())
170 llvm::errs() << "CFGAutomaticObjDtor\n";
171 }
172 }
173
174 void checkEndAnalysis(ExplodedGraph &G, BugReporter &BR,
175 ExprEngine &Eng) const {
176 if (isCallbackEnabled(Opts: BR.getAnalyzerOptions(), CallbackName: "EndAnalysis"))
177 llvm::errs() << "EndAnalysis\n";
178 }
179
180 void checkNewAllocator(const CXXAllocatorCall &Call,
181 CheckerContext &C) const {
182 if (isCallbackEnabled(C, CallbackName: "NewAllocator"))
183 llvm::errs() << "NewAllocator\n";
184 }
185
186 void checkBind(SVal Loc, SVal Val, const Stmt *S, CheckerContext &C) const {
187 if (isCallbackEnabled(C, CallbackName: "Bind"))
188 llvm::errs() << "Bind\n";
189 }
190
191 void checkLiveSymbols(ProgramStateRef State, SymbolReaper &SymReaper) const {
192 if (isCallbackEnabled(State, CallbackName: "LiveSymbols"))
193 llvm::errs() << "LiveSymbols\n";
194 }
195
196 ProgramStateRef
197 checkRegionChanges(ProgramStateRef State,
198 const InvalidatedSymbols *Invalidated,
199 ArrayRef<const MemRegion *> ExplicitRegions,
200 ArrayRef<const MemRegion *> Regions,
201 const LocationContext *LCtx, const CallEvent *Call) const {
202 if (isCallbackEnabled(State, CallbackName: "RegionChanges"))
203 llvm::errs() << "RegionChanges\n";
204 return State;
205 }
206
207 ProgramStateRef checkPointerEscape(ProgramStateRef State,
208 const InvalidatedSymbols &Escaped,
209 const CallEvent *Call,
210 PointerEscapeKind Kind) const {
211 if (isCallbackEnabled(State, CallbackName: "PointerEscape"))
212 llvm::errs() << "PointerEscape\n";
213 return State;
214 }
215};
216} // end anonymous namespace
217
218//===----------------------------------------------------------------------===//
219// Registration.
220//===----------------------------------------------------------------------===//
221
222void ento::registerAnalysisOrderChecker(CheckerManager &mgr) {
223 mgr.registerChecker<AnalysisOrderChecker>();
224}
225
226bool ento::shouldRegisterAnalysisOrderChecker(const CheckerManager &mgr) {
227 return true;
228}
229