1 //== Checker.h - Registration mechanism for checkers -------------*- C++ -*--=//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines Checker, used to create and register checkers.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_SA_CORE_CHECKER
15 #define LLVM_CLANG_SA_CORE_CHECKER
17 #include "clang/Analysis/ProgramPoint.h"
18 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
19 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
20 #include "llvm/Support/Casting.h"
29 static void _register(void *checker, CheckerManager &mgr) { }
32 template <typename DECL>
34 template <typename CHECKER>
35 static void _checkDecl(void *checker, const Decl *D, AnalysisManager& mgr,
37 ((const CHECKER *)checker)->checkASTDecl(llvm::cast<DECL>(D), mgr, BR);
40 static bool _handlesDecl(const Decl *D) {
41 return llvm::isa<DECL>(D);
44 template <typename CHECKER>
45 static void _register(CHECKER *checker, CheckerManager &mgr) {
46 mgr._registerForDecl(CheckerManager::CheckDeclFunc(checker,
53 template <typename CHECKER>
54 static void _checkBody(void *checker, const Decl *D, AnalysisManager& mgr,
56 ((const CHECKER *)checker)->checkASTCodeBody(D, mgr, BR);
60 template <typename CHECKER>
61 static void _register(CHECKER *checker, CheckerManager &mgr) {
62 mgr._registerForBody(CheckerManager::CheckDeclFunc(checker,
63 _checkBody<CHECKER>));
67 class EndOfTranslationUnit {
68 template <typename CHECKER>
69 static void _checkEndOfTranslationUnit(void *checker,
70 const TranslationUnitDecl *TU,
73 ((const CHECKER *)checker)->checkEndOfTranslationUnit(TU, mgr, BR);
77 template <typename CHECKER>
78 static void _register(CHECKER *checker, CheckerManager &mgr){
79 mgr._registerForEndOfTranslationUnit(
80 CheckerManager::CheckEndOfTranslationUnit(checker,
81 _checkEndOfTranslationUnit<CHECKER>));
85 template <typename STMT>
87 template <typename CHECKER>
88 static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
89 ((const CHECKER *)checker)->checkPreStmt(llvm::cast<STMT>(S), C);
92 static bool _handlesStmt(const Stmt *S) {
93 return llvm::isa<STMT>(S);
96 template <typename CHECKER>
97 static void _register(CHECKER *checker, CheckerManager &mgr) {
98 mgr._registerForPreStmt(CheckerManager::CheckStmtFunc(checker,
104 template <typename STMT>
106 template <typename CHECKER>
107 static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
108 ((const CHECKER *)checker)->checkPostStmt(llvm::cast<STMT>(S), C);
111 static bool _handlesStmt(const Stmt *S) {
112 return llvm::isa<STMT>(S);
115 template <typename CHECKER>
116 static void _register(CHECKER *checker, CheckerManager &mgr) {
117 mgr._registerForPostStmt(CheckerManager::CheckStmtFunc(checker,
118 _checkStmt<CHECKER>),
123 class PreObjCMessage {
124 template <typename CHECKER>
125 static void _checkObjCMessage(void *checker, const ObjCMethodCall &msg,
127 ((const CHECKER *)checker)->checkPreObjCMessage(msg, C);
131 template <typename CHECKER>
132 static void _register(CHECKER *checker, CheckerManager &mgr) {
133 mgr._registerForPreObjCMessage(
134 CheckerManager::CheckObjCMessageFunc(checker, _checkObjCMessage<CHECKER>));
138 class PostObjCMessage {
139 template <typename CHECKER>
140 static void _checkObjCMessage(void *checker, const ObjCMethodCall &msg,
142 ((const CHECKER *)checker)->checkPostObjCMessage(msg, C);
146 template <typename CHECKER>
147 static void _register(CHECKER *checker, CheckerManager &mgr) {
148 mgr._registerForPostObjCMessage(
149 CheckerManager::CheckObjCMessageFunc(checker, _checkObjCMessage<CHECKER>));
154 template <typename CHECKER>
155 static void _checkCall(void *checker, const CallEvent &msg,
157 ((const CHECKER *)checker)->checkPreCall(msg, C);
161 template <typename CHECKER>
162 static void _register(CHECKER *checker, CheckerManager &mgr) {
163 mgr._registerForPreCall(
164 CheckerManager::CheckCallFunc(checker, _checkCall<CHECKER>));
169 template <typename CHECKER>
170 static void _checkCall(void *checker, const CallEvent &msg,
172 ((const CHECKER *)checker)->checkPostCall(msg, C);
176 template <typename CHECKER>
177 static void _register(CHECKER *checker, CheckerManager &mgr) {
178 mgr._registerForPostCall(
179 CheckerManager::CheckCallFunc(checker, _checkCall<CHECKER>));
184 template <typename CHECKER>
185 static void _checkLocation(void *checker,
186 const SVal &location, bool isLoad, const Stmt *S,
188 ((const CHECKER *)checker)->checkLocation(location, isLoad, S, C);
192 template <typename CHECKER>
193 static void _register(CHECKER *checker, CheckerManager &mgr) {
194 mgr._registerForLocation(
195 CheckerManager::CheckLocationFunc(checker, _checkLocation<CHECKER>));
200 template <typename CHECKER>
201 static void _checkBind(void *checker,
202 const SVal &location, const SVal &val, const Stmt *S,
204 ((const CHECKER *)checker)->checkBind(location, val, S, C);
208 template <typename CHECKER>
209 static void _register(CHECKER *checker, CheckerManager &mgr) {
210 mgr._registerForBind(
211 CheckerManager::CheckBindFunc(checker, _checkBind<CHECKER>));
216 template <typename CHECKER>
217 static void _checkEndAnalysis(void *checker, ExplodedGraph &G,
218 BugReporter &BR, ExprEngine &Eng) {
219 ((const CHECKER *)checker)->checkEndAnalysis(G, BR, Eng);
223 template <typename CHECKER>
224 static void _register(CHECKER *checker, CheckerManager &mgr) {
225 mgr._registerForEndAnalysis(
226 CheckerManager::CheckEndAnalysisFunc(checker, _checkEndAnalysis<CHECKER>));
231 template <typename CHECKER>
232 static void _checkEndPath(void *checker,
234 ((const CHECKER *)checker)->checkEndPath(C);
238 template <typename CHECKER>
239 static void _register(CHECKER *checker, CheckerManager &mgr) {
240 mgr._registerForEndPath(
241 CheckerManager::CheckEndPathFunc(checker, _checkEndPath<CHECKER>));
245 class BranchCondition {
246 template <typename CHECKER>
247 static void _checkBranchCondition(void *checker, const Stmt *Condition,
248 CheckerContext & C) {
249 ((const CHECKER *)checker)->checkBranchCondition(Condition, C);
253 template <typename CHECKER>
254 static void _register(CHECKER *checker, CheckerManager &mgr) {
255 mgr._registerForBranchCondition(
256 CheckerManager::CheckBranchConditionFunc(checker,
257 _checkBranchCondition<CHECKER>));
262 template <typename CHECKER>
263 static void _checkLiveSymbols(void *checker, ProgramStateRef state,
265 ((const CHECKER *)checker)->checkLiveSymbols(state, SR);
269 template <typename CHECKER>
270 static void _register(CHECKER *checker, CheckerManager &mgr) {
271 mgr._registerForLiveSymbols(
272 CheckerManager::CheckLiveSymbolsFunc(checker, _checkLiveSymbols<CHECKER>));
277 template <typename CHECKER>
278 static void _checkDeadSymbols(void *checker,
279 SymbolReaper &SR, CheckerContext &C) {
280 ((const CHECKER *)checker)->checkDeadSymbols(SR, C);
284 template <typename CHECKER>
285 static void _register(CHECKER *checker, CheckerManager &mgr) {
286 mgr._registerForDeadSymbols(
287 CheckerManager::CheckDeadSymbolsFunc(checker, _checkDeadSymbols<CHECKER>));
291 class RegionChanges {
292 template <typename CHECKER>
293 static ProgramStateRef
294 _checkRegionChanges(void *checker,
295 ProgramStateRef state,
296 const StoreManager::InvalidatedSymbols *invalidated,
297 ArrayRef<const MemRegion *> Explicits,
298 ArrayRef<const MemRegion *> Regions,
299 const CallEvent *Call) {
300 return ((const CHECKER *)checker)->checkRegionChanges(state, invalidated,
301 Explicits, Regions, Call);
303 template <typename CHECKER>
304 static bool _wantsRegionChangeUpdate(void *checker,
305 ProgramStateRef state) {
306 return ((const CHECKER *)checker)->wantsRegionChangeUpdate(state);
310 template <typename CHECKER>
311 static void _register(CHECKER *checker, CheckerManager &mgr) {
312 mgr._registerForRegionChanges(
313 CheckerManager::CheckRegionChangesFunc(checker,
314 _checkRegionChanges<CHECKER>),
315 CheckerManager::WantsRegionChangeUpdateFunc(checker,
316 _wantsRegionChangeUpdate<CHECKER>));
320 template <typename EVENT>
322 template <typename CHECKER>
323 static void _checkEvent(void *checker, const void *event) {
324 ((const CHECKER *)checker)->checkEvent(*(const EVENT *)event);
327 template <typename CHECKER>
328 static void _register(CHECKER *checker, CheckerManager &mgr) {
329 mgr._registerListenerForEvent<EVENT>(
330 CheckerManager::CheckEventFunc(checker, _checkEvent<CHECKER>));
334 } // end check namespace
339 template <typename CHECKER>
340 static ProgramStateRef _evalAssume(void *checker,
341 ProgramStateRef state,
344 return ((const CHECKER *)checker)->evalAssume(state, cond, assumption);
348 template <typename CHECKER>
349 static void _register(CHECKER *checker, CheckerManager &mgr) {
350 mgr._registerForEvalAssume(
351 CheckerManager::EvalAssumeFunc(checker, _evalAssume<CHECKER>));
356 template <typename CHECKER>
357 static bool _evalCall(void *checker, const CallExpr *CE, CheckerContext &C) {
358 return ((const CHECKER *)checker)->evalCall(CE, C);
362 template <typename CHECKER>
363 static void _register(CHECKER *checker, CheckerManager &mgr) {
364 mgr._registerForEvalCall(
365 CheckerManager::EvalCallFunc(checker, _evalCall<CHECKER>));
370 template <typename CHECKER>
371 static bool _inlineCall(void *checker, const CallExpr *CE,
374 ExplodedNodeSet &Dst) {
375 return ((const CHECKER *)checker)->inlineCall(CE, Eng, Pred, Dst);
379 template <typename CHECKER>
380 static void _register(CHECKER *checker, CheckerManager &mgr) {
381 mgr._registerForInlineCall(
382 CheckerManager::InlineCallFunc(checker, _inlineCall<CHECKER>));
386 } // end eval namespace
388 class CheckerBase : public ProgramPointTag {
390 StringRef getTagDescription() const;
392 /// See CheckerManager::runCheckersForPrintState.
393 virtual void printState(raw_ostream &Out, ProgramStateRef State,
394 const char *NL, const char *Sep) const { }
397 template <typename CHECK1, typename CHECK2=check::_VoidCheck,
398 typename CHECK3=check::_VoidCheck, typename CHECK4=check::_VoidCheck,
399 typename CHECK5=check::_VoidCheck, typename CHECK6=check::_VoidCheck,
400 typename CHECK7=check::_VoidCheck, typename CHECK8=check::_VoidCheck,
401 typename CHECK9=check::_VoidCheck, typename CHECK10=check::_VoidCheck,
402 typename CHECK11=check::_VoidCheck,typename CHECK12=check::_VoidCheck,
403 typename CHECK13=check::_VoidCheck,typename CHECK14=check::_VoidCheck,
404 typename CHECK15=check::_VoidCheck,typename CHECK16=check::_VoidCheck,
405 typename CHECK17=check::_VoidCheck,typename CHECK18=check::_VoidCheck,
406 typename CHECK19=check::_VoidCheck,typename CHECK20=check::_VoidCheck,
407 typename CHECK21=check::_VoidCheck,typename CHECK22=check::_VoidCheck,
408 typename CHECK23=check::_VoidCheck,typename CHECK24=check::_VoidCheck>
412 class Checker<check::_VoidCheck>
415 virtual void anchor();
417 static void _register(void *checker, CheckerManager &mgr) { }
420 template <typename CHECK1, typename CHECK2, typename CHECK3, typename CHECK4,
421 typename CHECK5, typename CHECK6, typename CHECK7, typename CHECK8,
422 typename CHECK9, typename CHECK10,typename CHECK11,typename CHECK12,
423 typename CHECK13,typename CHECK14,typename CHECK15,typename CHECK16,
424 typename CHECK17,typename CHECK18,typename CHECK19,typename CHECK20,
425 typename CHECK21,typename CHECK22,typename CHECK23,typename CHECK24>
428 public Checker<CHECK2, CHECK3, CHECK4, CHECK5, CHECK6, CHECK7,
429 CHECK8, CHECK9, CHECK10,CHECK11,CHECK12,CHECK13,
430 CHECK14,CHECK15,CHECK16,CHECK17,CHECK18,CHECK19,
431 CHECK20,CHECK21,CHECK22,CHECK23,CHECK24> {
433 template <typename CHECKER>
434 static void _register(CHECKER *checker, CheckerManager &mgr) {
435 CHECK1::_register(checker, mgr);
436 Checker<CHECK2, CHECK3, CHECK4, CHECK5, CHECK6, CHECK7,
437 CHECK8, CHECK9, CHECK10,CHECK11,CHECK12,CHECK13,
438 CHECK14,CHECK15,CHECK16,CHECK17,CHECK18,CHECK19,
439 CHECK20,CHECK21,CHECK22,CHECK23,CHECK24>::_register(checker, mgr);
443 template <typename EVENT>
444 class EventDispatcher {
447 EventDispatcher() : Mgr(0) { }
449 template <typename CHECKER>
450 static void _register(CHECKER *checker, CheckerManager &mgr) {
451 mgr._registerDispatcherForEvent<EVENT>();
452 static_cast<EventDispatcher<EVENT> *>(checker)->Mgr = &mgr;
455 void dispatchEvent(const EVENT &event) const {
456 Mgr->_dispatchEvent(event);
460 /// \brief We dereferenced a location that may be null.
461 struct ImplicitNullDerefEvent {
464 ExplodedNode *SinkNode;
468 } // end ento namespace
470 } // end clang namespace