Coverage Report

Created: 2020-09-22 08:39

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp
Line
Count
Source (jump to first uncovered line)
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
7
                        BugReporter &BR) const {
37
7
    if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {
38
7
      CFGDomTree Dom;
39
7
      Dom.buildDominatorTree(AC->getCFG());
40
7
      Dom.dump();
41
7
    }
42
7
  }
43
};
44
}
45
46
2
void ento::registerDominatorsTreeDumper(CheckerManager &mgr) {
47
2
  mgr.registerChecker<DominatorsTreeDumper>();
48
2
}
49
50
4
bool ento::shouldRegisterDominatorsTreeDumper(const CheckerManager &mgr) {
51
4
  return true;
52
4
}
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
7
                        BugReporter &BR) const {
63
7
    if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {
64
7
      CFGPostDomTree Dom;
65
7
      Dom.buildDominatorTree(AC->getCFG());
66
7
      Dom.dump();
67
7
    }
68
7
  }
69
};
70
}
71
72
2
void ento::registerPostDominatorsTreeDumper(CheckerManager &mgr) {
73
2
  mgr.registerChecker<PostDominatorsTreeDumper>();
74
2
}
75
76
4
bool ento::shouldRegisterPostDominatorsTreeDumper(const CheckerManager &mgr) {
77
4
  return true;
78
4
}
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
7
                        BugReporter &BR) const {
89
7
    if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {
90
7
      ControlDependencyCalculator Dom(AC->getCFG());
91
7
      Dom.dump();
92
7
    }
93
7
  }
94
};
95
}
96
97
2
void ento::registerControlDependencyTreeDumper(CheckerManager &mgr) {
98
2
  mgr.registerChecker<ControlDependencyTreeDumper>();
99
2
}
100
101
4
bool ento::shouldRegisterControlDependencyTreeDumper(const CheckerManager &mgr) {
102
4
  return true;
103
4
}
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
0
                        BugReporter &BR) const {
114
0
    if (LiveVariables* L = mgr.getAnalysis<LiveVariables>(D)) {
115
0
      L->dumpBlockLiveness(mgr.getSourceManager());
116
0
    }
117
0
  }
118
};
119
}
120
121
0
void ento::registerLiveVariablesDumper(CheckerManager &mgr) {
122
0
  mgr.registerChecker<LiveVariablesDumper>();
123
0
}
124
125
0
bool ento::shouldRegisterLiveVariablesDumper(const CheckerManager &mgr) {
126
0
  return true;
127
0
}
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
10
                        BugReporter &BR) const {
138
10
    if (LiveVariables *L = Mgr.getAnalysis<RelaxedLiveVariables>(D))
139
10
      L->dumpExprLiveness(Mgr.getSourceManager());
140
10
  }
141
};
142
}
143
144
2
void ento::registerLiveExpressionsDumper(CheckerManager &mgr) {
145
2
  mgr.registerChecker<LiveExpressionsDumper>();
146
2
}
147
148
4
bool ento::shouldRegisterLiveExpressionsDumper(const CheckerManager &mgr) {
149
4
  return true;
150
4
}
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
0
                        BugReporter &BR) const {
161
0
    if (CFG *cfg = mgr.getCFG(D)) {
162
0
      cfg->viewCFG(mgr.getLangOpts());
163
0
    }
164
0
  }
165
};
166
}
167
168
0
void ento::registerCFGViewer(CheckerManager &mgr) {
169
0
  mgr.registerChecker<CFGViewer>();
170
0
}
171
172
0
bool ento::shouldRegisterCFGViewer(const CheckerManager &mgr) {
173
0
  return true;
174
0
}
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
760
                        BugReporter &BR) const {
185
760
    PrintingPolicy Policy(mgr.getLangOpts());
186
760
    Policy.TerseOutput = true;
187
760
    Policy.PolishForDeclaration = true;
188
760
    D->print(llvm::errs(), Policy);
189
190
760
    if (CFG *cfg = mgr.getCFG(D)) {
191
760
      cfg->dump(mgr.getLangOpts(),
192
760
                llvm::sys::Process::StandardErrHasColors());
193
760
    }
194
760
  }
195
};
196
}
197
198
37
void ento::registerCFGDumper(CheckerManager &mgr) {
199
37
  mgr.registerChecker<CFGDumper>();
200
37
}
201
202
74
bool ento::shouldRegisterCFGDumper(const CheckerManager &mgr) {
203
74
  return true;
204
74
}
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
0
                    BugReporter &BR) const {
215
0
    CallGraph CG;
216
0
    CG.addToCallGraph(const_cast<TranslationUnitDecl*>(TU));
217
0
    CG.viewGraph();
218
0
  }
219
};
220
}
221
222
0
void ento::registerCallGraphViewer(CheckerManager &mgr) {
223
0
  mgr.registerChecker<CallGraphViewer>();
224
0
}
225
226
0
bool ento::shouldRegisterCallGraphViewer(const CheckerManager &mgr) {
227
0
  return true;
228
0
}
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
2
                    BugReporter &BR) const {
239
2
    CallGraph CG;
240
2
    CG.addToCallGraph(const_cast<TranslationUnitDecl*>(TU));
241
2
    CG.dump();
242
2
  }
243
};
244
}
245
246
2
void ento::registerCallGraphDumper(CheckerManager &mgr) {
247
2
  mgr.registerChecker<CallGraphDumper>();
248
2
}
249
250
4
bool ento::shouldRegisterCallGraphDumper(const CheckerManager &mgr) {
251
4
  return true;
252
4
}
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
2.40k
                          const Table::MapEntryTy *const *RHS) {
264
2.40k
    return (*LHS)->getKey().compare((*RHS)->getKey());
265
2.40k
  }
266
267
public:
268
  void checkEndOfTranslationUnit(const TranslationUnitDecl *TU,
269
                                 AnalysisManager& mgr,
270
3
                                 BugReporter &BR) const {
271
3
    const Table &Config = mgr.options.Config;
272
273
3
    SmallVector<const Table::MapEntryTy *, 32> Keys;
274
354
    for (Table::const_iterator I = Config.begin(), E = Config.end(); I != E;
275
351
         ++I)
276
351
      Keys.push_back(&*I);
277
3
    llvm::array_pod_sort(Keys.begin(), Keys.end(), compareEntry);
278
279
3
    llvm::errs() << "[config]\n";
280
354
    for (unsigned I = 0, E = Keys.size(); I != E; 
++I351
)
281
351
      llvm::errs() << Keys[I]->getKey() << " = "
282
339
                   << (Keys[I]->second.empty() ? 
"\"\""12
: Keys[I]->second)
283
351
                   << '\n';
284
3
  }
285
};
286
}
287
288
3
void ento::registerConfigDumper(CheckerManager &mgr) {
289
3
  mgr.registerChecker<ConfigDumper>();
290
3
}
291
292
6
bool ento::shouldRegisterConfigDumper(const CheckerManager &mgr) {
293
6
  return true;
294
6
}
295
296
//===----------------------------------------------------------------------===//
297
// ExplodedGraph Viewer
298
//===----------------------------------------------------------------------===//
299
300
namespace {
301
class ExplodedGraphViewer : public Checker< check::EndAnalysis > {
302
public:
303
0
  ExplodedGraphViewer() {}
304
0
  void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,ExprEngine &Eng) const {
305
0
    Eng.ViewGraph(0);
306
0
  }
307
};
308
309
}
310
311
0
void ento::registerExplodedGraphViewer(CheckerManager &mgr) {
312
0
  mgr.registerChecker<ExplodedGraphViewer>();
313
0
}
314
315
0
bool ento::shouldRegisterExplodedGraphViewer(const CheckerManager &mgr) {
316
0
  return true;
317
0
}
318
319
//===----------------------------------------------------------------------===//
320
// Emits a report for every Stmt that the analyzer visits.
321
//===----------------------------------------------------------------------===//
322
323
namespace {
324
325
class ReportStmts : public Checker<check::PreStmt<Stmt>> {
326
  BuiltinBug BT_stmtLoc{this, "Statement"};
327
328
public:
329
6
  void checkPreStmt(const Stmt *S, CheckerContext &C) const {
330
6
    ExplodedNode *Node = C.generateNonFatalErrorNode();
331
6
    if (!Node)
332
0
      return;
333
334
6
    auto Report =
335
6
        std::make_unique<PathSensitiveBugReport>(BT_stmtLoc, "Statement", Node);
336
337
6
    C.emitReport(std::move(Report));
338
6
  }
339
};
340
341
} // end of anonymous namespace
342
343
1
void ento::registerReportStmts(CheckerManager &mgr) {
344
1
  mgr.registerChecker<ReportStmts>();
345
1
}
346
347
2
bool ento::shouldRegisterReportStmts(const CheckerManager &mgr) {
348
2
  return true;
349
2
}