1 //===- AnalysisOrderChecker - Print callbacks called ------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This checker prints callbacks that are called during analysis.
11 // This is required to ensure that callbacks are fired in order
12 // and do not duplicate or get lost.
13 // Feel free to extend this checker with any callback you need to check.
14 //
15 //===----------------------------------------------------------------------===//
16
17 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
18 #include "clang/AST/ExprCXX.h"
19 #include "clang/Analysis/CFGStmtMap.h"
20 #include "clang/StaticAnalyzer/Core/Checker.h"
21 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
22 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
23 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
24
25 using namespace clang;
26 using namespace ento;
27
28 namespace {
29
30 class AnalysisOrderChecker
31 : public Checker<check::PreStmt<CastExpr>,
32 check::PostStmt<CastExpr>,
33 check::PreStmt<ArraySubscriptExpr>,
34 check::PostStmt<ArraySubscriptExpr>,
35 check::PreStmt<CXXNewExpr>,
36 check::PostStmt<CXXNewExpr>,
37 check::PreStmt<OffsetOfExpr>,
38 check::PostStmt<OffsetOfExpr>,
39 check::PreCall,
40 check::PostCall,
41 check::EndFunction,
42 check::NewAllocator,
43 check::Bind,
44 check::RegionChanges,
45 check::LiveSymbols> {
46
isCallbackEnabled(AnalyzerOptions & Opts,StringRef CallbackName) const47 bool isCallbackEnabled(AnalyzerOptions &Opts, StringRef CallbackName) const {
48 return Opts.getCheckerBooleanOption("*", false, this) ||
49 Opts.getCheckerBooleanOption(CallbackName, false, this);
50 }
51
isCallbackEnabled(CheckerContext & C,StringRef CallbackName) const52 bool isCallbackEnabled(CheckerContext &C, StringRef CallbackName) const {
53 AnalyzerOptions &Opts = C.getAnalysisManager().getAnalyzerOptions();
54 return isCallbackEnabled(Opts, CallbackName);
55 }
56
isCallbackEnabled(ProgramStateRef State,StringRef CallbackName) const57 bool isCallbackEnabled(ProgramStateRef State, StringRef CallbackName) const {
58 AnalyzerOptions &Opts = State->getStateManager().getOwningEngine()
59 .getAnalysisManager().getAnalyzerOptions();
60 return isCallbackEnabled(Opts, CallbackName);
61 }
62
63 public:
checkPreStmt(const CastExpr * CE,CheckerContext & C) const64 void checkPreStmt(const CastExpr *CE, CheckerContext &C) const {
65 if (isCallbackEnabled(C, "PreStmtCastExpr"))
66 llvm::errs() << "PreStmt<CastExpr> (Kind : " << CE->getCastKindName()
67 << ")\n";
68 }
69
checkPostStmt(const CastExpr * CE,CheckerContext & C) const70 void checkPostStmt(const CastExpr *CE, CheckerContext &C) const {
71 if (isCallbackEnabled(C, "PostStmtCastExpr"))
72 llvm::errs() << "PostStmt<CastExpr> (Kind : " << CE->getCastKindName()
73 << ")\n";
74 }
75
checkPreStmt(const ArraySubscriptExpr * SubExpr,CheckerContext & C) const76 void checkPreStmt(const ArraySubscriptExpr *SubExpr,
77 CheckerContext &C) const {
78 if (isCallbackEnabled(C, "PreStmtArraySubscriptExpr"))
79 llvm::errs() << "PreStmt<ArraySubscriptExpr>\n";
80 }
81
checkPostStmt(const ArraySubscriptExpr * SubExpr,CheckerContext & C) const82 void checkPostStmt(const ArraySubscriptExpr *SubExpr,
83 CheckerContext &C) const {
84 if (isCallbackEnabled(C, "PostStmtArraySubscriptExpr"))
85 llvm::errs() << "PostStmt<ArraySubscriptExpr>\n";
86 }
87
checkPreStmt(const CXXNewExpr * NE,CheckerContext & C) const88 void checkPreStmt(const CXXNewExpr *NE, CheckerContext &C) const {
89 if (isCallbackEnabled(C, "PreStmtCXXNewExpr"))
90 llvm::errs() << "PreStmt<CXXNewExpr>\n";
91 }
92
checkPostStmt(const CXXNewExpr * NE,CheckerContext & C) const93 void checkPostStmt(const CXXNewExpr *NE, CheckerContext &C) const {
94 if (isCallbackEnabled(C, "PostStmtCXXNewExpr"))
95 llvm::errs() << "PostStmt<CXXNewExpr>\n";
96 }
97
checkPreStmt(const OffsetOfExpr * OOE,CheckerContext & C) const98 void checkPreStmt(const OffsetOfExpr *OOE, CheckerContext &C) const {
99 if (isCallbackEnabled(C, "PreStmtOffsetOfExpr"))
100 llvm::errs() << "PreStmt<OffsetOfExpr>\n";
101 }
102
checkPostStmt(const OffsetOfExpr * OOE,CheckerContext & C) const103 void checkPostStmt(const OffsetOfExpr *OOE, CheckerContext &C) const {
104 if (isCallbackEnabled(C, "PostStmtOffsetOfExpr"))
105 llvm::errs() << "PostStmt<OffsetOfExpr>\n";
106 }
107
checkPreCall(const CallEvent & Call,CheckerContext & C) const108 void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
109 if (isCallbackEnabled(C, "PreCall")) {
110 llvm::errs() << "PreCall";
111 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(Call.getDecl()))
112 llvm::errs() << " (" << ND->getQualifiedNameAsString() << ')';
113 llvm::errs() << '\n';
114 }
115 }
116
checkPostCall(const CallEvent & Call,CheckerContext & C) const117 void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
118 if (isCallbackEnabled(C, "PostCall")) {
119 llvm::errs() << "PostCall";
120 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(Call.getDecl()))
121 llvm::errs() << " (" << ND->getQualifiedNameAsString() << ')';
122 llvm::errs() << '\n';
123 }
124 }
125
checkEndFunction(const ReturnStmt * S,CheckerContext & C) const126 void checkEndFunction(const ReturnStmt *S, CheckerContext &C) const {
127 if (isCallbackEnabled(C, "EndFunction")) {
128 llvm::errs() << "EndFunction\nReturnStmt: " << (S ? "yes" : "no") << "\n";
129 if (!S)
130 return;
131
132 llvm::errs() << "CFGElement: ";
133 CFGStmtMap *Map = C.getCurrentAnalysisDeclContext()->getCFGStmtMap();
134 CFGElement LastElement = Map->getBlock(S)->back();
135
136 if (LastElement.getAs<CFGStmt>())
137 llvm::errs() << "CFGStmt\n";
138 else if (LastElement.getAs<CFGAutomaticObjDtor>())
139 llvm::errs() << "CFGAutomaticObjDtor\n";
140 }
141 }
142
checkNewAllocator(const CXXNewExpr * CNE,SVal Target,CheckerContext & C) const143 void checkNewAllocator(const CXXNewExpr *CNE, SVal Target,
144 CheckerContext &C) const {
145 if (isCallbackEnabled(C, "NewAllocator"))
146 llvm::errs() << "NewAllocator\n";
147 }
148
checkBind(SVal Loc,SVal Val,const Stmt * S,CheckerContext & C) const149 void checkBind(SVal Loc, SVal Val, const Stmt *S, CheckerContext &C) const {
150 if (isCallbackEnabled(C, "Bind"))
151 llvm::errs() << "Bind\n";
152 }
153
checkLiveSymbols(ProgramStateRef State,SymbolReaper & SymReaper) const154 void checkLiveSymbols(ProgramStateRef State, SymbolReaper &SymReaper) const {
155 if (isCallbackEnabled(State, "LiveSymbols"))
156 llvm::errs() << "LiveSymbols\n";
157 }
158
159 ProgramStateRef
checkRegionChanges(ProgramStateRef State,const InvalidatedSymbols * Invalidated,ArrayRef<const MemRegion * > ExplicitRegions,ArrayRef<const MemRegion * > Regions,const LocationContext * LCtx,const CallEvent * Call) const160 checkRegionChanges(ProgramStateRef State,
161 const InvalidatedSymbols *Invalidated,
162 ArrayRef<const MemRegion *> ExplicitRegions,
163 ArrayRef<const MemRegion *> Regions,
164 const LocationContext *LCtx, const CallEvent *Call) const {
165 if (isCallbackEnabled(State, "RegionChanges"))
166 llvm::errs() << "RegionChanges\n";
167 return State;
168 }
169 };
170 } // end anonymous namespace
171
172 //===----------------------------------------------------------------------===//
173 // Registration.
174 //===----------------------------------------------------------------------===//
175
registerAnalysisOrderChecker(CheckerManager & mgr)176 void ento::registerAnalysisOrderChecker(CheckerManager &mgr) {
177 mgr.registerChecker<AnalysisOrderChecker>();
178 }
179