1 //==- DebugCheckers.cpp - Debugging 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 checkers that display debugging information.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
14 #include "clang/Analysis/Analyses/Dominators.h"
15 #include "clang/Analysis/Analyses/LiveVariables.h"
16 #include "clang/Analysis/CallGraph.h"
17 #include "clang/StaticAnalyzer/Core/Checker.h"
18 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
19 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
20 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
21 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
22 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
23 #include "llvm/Support/Process.h"
24 
25 using namespace clang;
26 using namespace ento;
27 
28 //===----------------------------------------------------------------------===//
29 // DominatorsTreeDumper
30 //===----------------------------------------------------------------------===//
31 
32 namespace {
33 class DominatorsTreeDumper : public Checker<check::ASTCodeBody> {
34 public:
35   void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
36                         BugReporter &BR) const {
37     if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {
38       CFGDomTree Dom;
39       Dom.buildDominatorTree(AC->getCFG());
40       Dom.dump();
41     }
42   }
43 };
44 }
45 
46 void ento::registerDominatorsTreeDumper(CheckerManager &mgr) {
47   mgr.registerChecker<DominatorsTreeDumper>();
48 }
49 
50 bool ento::shouldRegisterDominatorsTreeDumper(const CheckerManager &mgr) {
51   return true;
52 }
53 
54 //===----------------------------------------------------------------------===//
55 // PostDominatorsTreeDumper
56 //===----------------------------------------------------------------------===//
57 
58 namespace {
59 class PostDominatorsTreeDumper : public Checker<check::ASTCodeBody> {
60 public:
61   void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
62                         BugReporter &BR) const {
63     if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {
64       CFGPostDomTree Dom;
65       Dom.buildDominatorTree(AC->getCFG());
66       Dom.dump();
67     }
68   }
69 };
70 }
71 
72 void ento::registerPostDominatorsTreeDumper(CheckerManager &mgr) {
73   mgr.registerChecker<PostDominatorsTreeDumper>();
74 }
75 
76 bool ento::shouldRegisterPostDominatorsTreeDumper(const CheckerManager &mgr) {
77   return true;
78 }
79 
80 //===----------------------------------------------------------------------===//
81 // ControlDependencyTreeDumper
82 //===----------------------------------------------------------------------===//
83 
84 namespace {
85 class ControlDependencyTreeDumper : public Checker<check::ASTCodeBody> {
86 public:
87   void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
88                         BugReporter &BR) const {
89     if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {
90       ControlDependencyCalculator Dom(AC->getCFG());
91       Dom.dump();
92     }
93   }
94 };
95 }
96 
97 void ento::registerControlDependencyTreeDumper(CheckerManager &mgr) {
98   mgr.registerChecker<ControlDependencyTreeDumper>();
99 }
100 
101 bool ento::shouldRegisterControlDependencyTreeDumper(const CheckerManager &mgr) {
102   return true;
103 }
104 
105 //===----------------------------------------------------------------------===//
106 // LiveVariablesDumper
107 //===----------------------------------------------------------------------===//
108 
109 namespace {
110 class LiveVariablesDumper : public Checker<check::ASTCodeBody> {
111 public:
112   void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
113                         BugReporter &BR) const {
114     if (LiveVariables* L = mgr.getAnalysis<LiveVariables>(D)) {
115       L->dumpBlockLiveness(mgr.getSourceManager());
116     }
117   }
118 };
119 }
120 
121 void ento::registerLiveVariablesDumper(CheckerManager &mgr) {
122   mgr.registerChecker<LiveVariablesDumper>();
123 }
124 
125 bool ento::shouldRegisterLiveVariablesDumper(const CheckerManager &mgr) {
126   return true;
127 }
128 
129 //===----------------------------------------------------------------------===//
130 // LiveStatementsDumper
131 //===----------------------------------------------------------------------===//
132 
133 namespace {
134 class LiveExpressionsDumper : public Checker<check::ASTCodeBody> {
135 public:
136   void checkASTCodeBody(const Decl *D, AnalysisManager& Mgr,
137                         BugReporter &BR) const {
138     if (LiveVariables *L = Mgr.getAnalysis<RelaxedLiveVariables>(D))
139       L->dumpExprLiveness(Mgr.getSourceManager());
140   }
141 };
142 }
143 
144 void ento::registerLiveExpressionsDumper(CheckerManager &mgr) {
145   mgr.registerChecker<LiveExpressionsDumper>();
146 }
147 
148 bool ento::shouldRegisterLiveExpressionsDumper(const CheckerManager &mgr) {
149   return true;
150 }
151 
152 //===----------------------------------------------------------------------===//
153 // CFGViewer
154 //===----------------------------------------------------------------------===//
155 
156 namespace {
157 class CFGViewer : public Checker<check::ASTCodeBody> {
158 public:
159   void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
160                         BugReporter &BR) const {
161     if (CFG *cfg = mgr.getCFG(D)) {
162       cfg->viewCFG(mgr.getLangOpts());
163     }
164   }
165 };
166 }
167 
168 void ento::registerCFGViewer(CheckerManager &mgr) {
169   mgr.registerChecker<CFGViewer>();
170 }
171 
172 bool ento::shouldRegisterCFGViewer(const CheckerManager &mgr) {
173   return true;
174 }
175 
176 //===----------------------------------------------------------------------===//
177 // CFGDumper
178 //===----------------------------------------------------------------------===//
179 
180 namespace {
181 class CFGDumper : public Checker<check::ASTCodeBody> {
182 public:
183   void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
184                         BugReporter &BR) const {
185     PrintingPolicy Policy(mgr.getLangOpts());
186     Policy.TerseOutput = true;
187     Policy.PolishForDeclaration = true;
188     D->print(llvm::errs(), Policy);
189 
190     if (CFG *cfg = mgr.getCFG(D)) {
191       cfg->dump(mgr.getLangOpts(),
192                 llvm::sys::Process::StandardErrHasColors());
193     }
194   }
195 };
196 }
197 
198 void ento::registerCFGDumper(CheckerManager &mgr) {
199   mgr.registerChecker<CFGDumper>();
200 }
201 
202 bool ento::shouldRegisterCFGDumper(const CheckerManager &mgr) {
203   return true;
204 }
205 
206 //===----------------------------------------------------------------------===//
207 // CallGraphViewer
208 //===----------------------------------------------------------------------===//
209 
210 namespace {
211 class CallGraphViewer : public Checker< check::ASTDecl<TranslationUnitDecl> > {
212 public:
213   void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr,
214                     BugReporter &BR) const {
215     CallGraph CG;
216     CG.addToCallGraph(const_cast<TranslationUnitDecl*>(TU));
217     CG.viewGraph();
218   }
219 };
220 }
221 
222 void ento::registerCallGraphViewer(CheckerManager &mgr) {
223   mgr.registerChecker<CallGraphViewer>();
224 }
225 
226 bool ento::shouldRegisterCallGraphViewer(const CheckerManager &mgr) {
227   return true;
228 }
229 
230 //===----------------------------------------------------------------------===//
231 // CallGraphDumper
232 //===----------------------------------------------------------------------===//
233 
234 namespace {
235 class CallGraphDumper : public Checker< check::ASTDecl<TranslationUnitDecl> > {
236 public:
237   void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr,
238                     BugReporter &BR) const {
239     CallGraph CG;
240     CG.addToCallGraph(const_cast<TranslationUnitDecl*>(TU));
241     CG.dump();
242   }
243 };
244 }
245 
246 void ento::registerCallGraphDumper(CheckerManager &mgr) {
247   mgr.registerChecker<CallGraphDumper>();
248 }
249 
250 bool ento::shouldRegisterCallGraphDumper(const CheckerManager &mgr) {
251   return true;
252 }
253 
254 //===----------------------------------------------------------------------===//
255 // ConfigDumper
256 //===----------------------------------------------------------------------===//
257 
258 namespace {
259 class ConfigDumper : public Checker< check::EndOfTranslationUnit > {
260   typedef AnalyzerOptions::ConfigTable Table;
261 
262   static int compareEntry(const Table::MapEntryTy *const *LHS,
263                           const Table::MapEntryTy *const *RHS) {
264     return (*LHS)->getKey().compare((*RHS)->getKey());
265   }
266 
267 public:
268   void checkEndOfTranslationUnit(const TranslationUnitDecl *TU,
269                                  AnalysisManager& mgr,
270                                  BugReporter &BR) const {
271     const Table &Config = mgr.options.Config;
272 
273     SmallVector<const Table::MapEntryTy *, 32> Keys;
274     for (const auto &Entry : Config)
275       Keys.push_back(&Entry);
276     llvm::array_pod_sort(Keys.begin(), Keys.end(), compareEntry);
277 
278     llvm::errs() << "[config]\n";
279     for (unsigned I = 0, E = Keys.size(); I != E; ++I)
280       llvm::errs() << Keys[I]->getKey() << " = "
281                    << (Keys[I]->second.empty() ? "\"\"" : Keys[I]->second)
282                    << '\n';
283   }
284 };
285 }
286 
287 void ento::registerConfigDumper(CheckerManager &mgr) {
288   mgr.registerChecker<ConfigDumper>();
289 }
290 
291 bool ento::shouldRegisterConfigDumper(const CheckerManager &mgr) {
292   return true;
293 }
294 
295 //===----------------------------------------------------------------------===//
296 // ExplodedGraph Viewer
297 //===----------------------------------------------------------------------===//
298 
299 namespace {
300 class ExplodedGraphViewer : public Checker< check::EndAnalysis > {
301 public:
302   ExplodedGraphViewer() {}
303   void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,ExprEngine &Eng) const {
304     Eng.ViewGraph(false);
305   }
306 };
307 
308 }
309 
310 void ento::registerExplodedGraphViewer(CheckerManager &mgr) {
311   mgr.registerChecker<ExplodedGraphViewer>();
312 }
313 
314 bool ento::shouldRegisterExplodedGraphViewer(const CheckerManager &mgr) {
315   return true;
316 }
317 
318 //===----------------------------------------------------------------------===//
319 // Emits a report for every Stmt that the analyzer visits.
320 //===----------------------------------------------------------------------===//
321 
322 namespace {
323 
324 class ReportStmts : public Checker<check::PreStmt<Stmt>> {
325   BugType BT_stmtLoc{this, "Statement"};
326 
327 public:
328   void checkPreStmt(const Stmt *S, CheckerContext &C) const {
329     ExplodedNode *Node = C.generateNonFatalErrorNode();
330     if (!Node)
331       return;
332 
333     auto Report =
334         std::make_unique<PathSensitiveBugReport>(BT_stmtLoc, "Statement", Node);
335 
336     C.emitReport(std::move(Report));
337   }
338 };
339 
340 } // end of anonymous namespace
341 
342 void ento::registerReportStmts(CheckerManager &mgr) {
343   mgr.registerChecker<ReportStmts>();
344 }
345 
346 bool ento::shouldRegisterReportStmts(const CheckerManager &mgr) {
347   return true;
348 }
349