1 //===--- CheckerManager.cpp - Static Analyzer Checker Manager -------------===//
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 // Defines the Static Analyzer Checker Manager.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
15 #include "clang/StaticAnalyzer/Core/Checker.h"
16 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
17 #include "clang/StaticAnalyzer/Core/PathSensitive/ObjCMessage.h"
18 #include "clang/Analysis/ProgramPoint.h"
19 #include "clang/AST/DeclBase.h"
20 
21 using namespace clang;
22 using namespace ento;
23 
24 bool CheckerManager::hasPathSensitiveCheckers() const {
25   return !StmtCheckers.empty()              ||
26          !PreObjCMessageCheckers.empty()    ||
27          !PostObjCMessageCheckers.empty()   ||
28          !LocationCheckers.empty()          ||
29          !BindCheckers.empty()              ||
30          !EndAnalysisCheckers.empty()       ||
31          !EndPathCheckers.empty()           ||
32          !BranchConditionCheckers.empty()   ||
33          !LiveSymbolsCheckers.empty()       ||
34          !DeadSymbolsCheckers.empty()       ||
35          !RegionChangesCheckers.empty()     ||
36          !EvalAssumeCheckers.empty()        ||
37          !EvalCallCheckers.empty()          ||
38          !InlineCallCheckers.empty();
39 }
40 
41 void CheckerManager::finishedCheckerRegistration() {
42 #ifndef NDEBUG
43   // Make sure that for every event that has listeners, there is at least
44   // one dispatcher registered for it.
45   for (llvm::DenseMap<EventTag, EventInfo>::iterator
46          I = Events.begin(), E = Events.end(); I != E; ++I)
47     assert(I->second.HasDispatcher && "No dispatcher registered for an event");
48 #endif
49 }
50 
51 //===----------------------------------------------------------------------===//
52 // Functions for running checkers for AST traversing..
53 //===----------------------------------------------------------------------===//
54 
55 void CheckerManager::runCheckersOnASTDecl(const Decl *D, AnalysisManager& mgr,
56                                           BugReporter &BR) {
57   assert(D);
58 
59   unsigned DeclKind = D->getKind();
60   CachedDeclCheckers *checkers = 0;
61   CachedDeclCheckersMapTy::iterator CCI = CachedDeclCheckersMap.find(DeclKind);
62   if (CCI != CachedDeclCheckersMap.end()) {
63     checkers = &(CCI->second);
64   } else {
65     // Find the checkers that should run for this Decl and cache them.
66     checkers = &CachedDeclCheckersMap[DeclKind];
67     for (unsigned i = 0, e = DeclCheckers.size(); i != e; ++i) {
68       DeclCheckerInfo &info = DeclCheckers[i];
69       if (info.IsForDeclFn(D))
70         checkers->push_back(info.CheckFn);
71     }
72   }
73 
74   assert(checkers);
75   for (CachedDeclCheckers::iterator
76          I = checkers->begin(), E = checkers->end(); I != E; ++I)
77     (*I)(D, mgr, BR);
78 }
79 
80 void CheckerManager::runCheckersOnASTBody(const Decl *D, AnalysisManager& mgr,
81                                           BugReporter &BR) {
82   assert(D && D->hasBody());
83 
84   for (unsigned i = 0, e = BodyCheckers.size(); i != e; ++i)
85     BodyCheckers[i](D, mgr, BR);
86 }
87 
88 //===----------------------------------------------------------------------===//
89 // Functions for running checkers for path-sensitive checking.
90 //===----------------------------------------------------------------------===//
91 
92 template <typename CHECK_CTX>
93 static void expandGraphWithCheckers(CHECK_CTX checkCtx,
94                                     ExplodedNodeSet &Dst,
95                                     const ExplodedNodeSet &Src) {
96   const NodeBuilderContext &BldrCtx = checkCtx.Eng.getBuilderContext();
97   if (Src.empty())
98     return;
99 
100   typename CHECK_CTX::CheckersTy::const_iterator
101       I = checkCtx.checkers_begin(), E = checkCtx.checkers_end();
102   if (I == E) {
103     Dst.insert(Src);
104     return;
105   }
106 
107   ExplodedNodeSet Tmp1, Tmp2;
108   const ExplodedNodeSet *PrevSet = &Src;
109 
110   for (; I != E; ++I) {
111     ExplodedNodeSet *CurrSet = 0;
112     if (I+1 == E)
113       CurrSet = &Dst;
114     else {
115       CurrSet = (PrevSet == &Tmp1) ? &Tmp2 : &Tmp1;
116       CurrSet->clear();
117     }
118 
119     NodeBuilder B(*PrevSet, *CurrSet, BldrCtx);
120     for (ExplodedNodeSet::iterator NI = PrevSet->begin(), NE = PrevSet->end();
121          NI != NE; ++NI) {
122       checkCtx.runChecker(*I, B, *NI);
123     }
124 
125     // If all the produced transitions are sinks, stop.
126     if (CurrSet->empty())
127       return;
128 
129     // Update which NodeSet is the current one.
130     PrevSet = CurrSet;
131   }
132 }
133 
134 namespace {
135   struct CheckStmtContext {
136     typedef SmallVectorImpl<CheckerManager::CheckStmtFunc> CheckersTy;
137     bool IsPreVisit;
138     const CheckersTy &Checkers;
139     const Stmt *S;
140     ExprEngine &Eng;
141     bool wasInlined;
142 
143     CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
144     CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
145 
146     CheckStmtContext(bool isPreVisit, const CheckersTy &checkers,
147                      const Stmt *s, ExprEngine &eng, bool wasInlined = false)
148       : IsPreVisit(isPreVisit), Checkers(checkers), S(s), Eng(eng),
149         wasInlined(wasInlined) {}
150 
151     void runChecker(CheckerManager::CheckStmtFunc checkFn,
152                     NodeBuilder &Bldr, ExplodedNode *Pred) {
153       // FIXME: Remove respondsToCallback from CheckerContext;
154       ProgramPoint::Kind K =  IsPreVisit ? ProgramPoint::PreStmtKind :
155                                            ProgramPoint::PostStmtKind;
156       const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
157                                 Pred->getLocationContext(), checkFn.Checker);
158       CheckerContext C(Bldr, Eng, Pred, L, wasInlined);
159       checkFn(S, C);
160     }
161   };
162 }
163 
164 /// \brief Run checkers for visiting Stmts.
165 void CheckerManager::runCheckersForStmt(bool isPreVisit,
166                                         ExplodedNodeSet &Dst,
167                                         const ExplodedNodeSet &Src,
168                                         const Stmt *S,
169                                         ExprEngine &Eng,
170                                         bool wasInlined) {
171   CheckStmtContext C(isPreVisit, *getCachedStmtCheckersFor(S, isPreVisit),
172                      S, Eng, wasInlined);
173   expandGraphWithCheckers(C, Dst, Src);
174 }
175 
176 namespace {
177   struct CheckObjCMessageContext {
178     typedef std::vector<CheckerManager::CheckObjCMessageFunc> CheckersTy;
179     bool IsPreVisit;
180     const CheckersTy &Checkers;
181     const ObjCMessage &Msg;
182     ExprEngine &Eng;
183 
184     CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
185     CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
186 
187     CheckObjCMessageContext(bool isPreVisit, const CheckersTy &checkers,
188                             const ObjCMessage &msg, ExprEngine &eng)
189       : IsPreVisit(isPreVisit), Checkers(checkers), Msg(msg), Eng(eng) { }
190 
191     void runChecker(CheckerManager::CheckObjCMessageFunc checkFn,
192                     NodeBuilder &Bldr, ExplodedNode *Pred) {
193       ProgramPoint::Kind K =  IsPreVisit ? ProgramPoint::PreStmtKind :
194                                            ProgramPoint::PostStmtKind;
195       const ProgramPoint &L =
196         ProgramPoint::getProgramPoint(Msg.getMessageExpr(),
197                                       K, Pred->getLocationContext(),
198                                       checkFn.Checker);
199       CheckerContext C(Bldr, Eng, Pred, L);
200 
201       checkFn(Msg, C);
202     }
203   };
204 }
205 
206 /// \brief Run checkers for visiting obj-c messages.
207 void CheckerManager::runCheckersForObjCMessage(bool isPreVisit,
208                                                ExplodedNodeSet &Dst,
209                                                const ExplodedNodeSet &Src,
210                                                const ObjCMessage &msg,
211                                                ExprEngine &Eng) {
212   CheckObjCMessageContext C(isPreVisit,
213                             isPreVisit ? PreObjCMessageCheckers
214                                        : PostObjCMessageCheckers,
215                             msg, Eng);
216   expandGraphWithCheckers(C, Dst, Src);
217 }
218 
219 namespace {
220   struct CheckLocationContext {
221     typedef std::vector<CheckerManager::CheckLocationFunc> CheckersTy;
222     const CheckersTy &Checkers;
223     SVal Loc;
224     bool IsLoad;
225     const Stmt *S;
226     ExprEngine &Eng;
227 
228     CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
229     CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
230 
231     CheckLocationContext(const CheckersTy &checkers,
232                          SVal loc, bool isLoad, const Stmt *s, ExprEngine &eng)
233       : Checkers(checkers), Loc(loc), IsLoad(isLoad), S(s), Eng(eng) { }
234 
235     void runChecker(CheckerManager::CheckLocationFunc checkFn,
236                     NodeBuilder &Bldr, ExplodedNode *Pred) {
237       ProgramPoint::Kind K =  IsLoad ? ProgramPoint::PreLoadKind :
238                                        ProgramPoint::PreStoreKind;
239       const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
240                                 Pred->getLocationContext(), checkFn.Checker);
241       CheckerContext C(Bldr, Eng, Pred, L);
242 
243       checkFn(Loc, IsLoad, S, C);
244     }
245   };
246 }
247 
248 /// \brief Run checkers for load/store of a location.
249 
250 void CheckerManager::runCheckersForLocation(ExplodedNodeSet &Dst,
251                                             const ExplodedNodeSet &Src,
252                                             SVal location, bool isLoad,
253                                             const Stmt *S, ExprEngine &Eng) {
254   CheckLocationContext C(LocationCheckers, location, isLoad, S, Eng);
255   expandGraphWithCheckers(C, Dst, Src);
256 }
257 
258 namespace {
259   struct CheckBindContext {
260     typedef std::vector<CheckerManager::CheckBindFunc> CheckersTy;
261     const CheckersTy &Checkers;
262     SVal Loc;
263     SVal Val;
264     const Stmt *S;
265     ExprEngine &Eng;
266     ProgramPoint::Kind PointKind;
267 
268     CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
269     CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
270 
271     CheckBindContext(const CheckersTy &checkers,
272                      SVal loc, SVal val, const Stmt *s, ExprEngine &eng,
273                      ProgramPoint::Kind PK)
274       : Checkers(checkers), Loc(loc), Val(val), S(s), Eng(eng), PointKind(PK) {}
275 
276     void runChecker(CheckerManager::CheckBindFunc checkFn,
277                     NodeBuilder &Bldr, ExplodedNode *Pred) {
278       const ProgramPoint &L = ProgramPoint::getProgramPoint(S, PointKind,
279                                 Pred->getLocationContext(), checkFn.Checker);
280       CheckerContext C(Bldr, Eng, Pred, L);
281 
282       checkFn(Loc, Val, S, C);
283     }
284   };
285 }
286 
287 /// \brief Run checkers for binding of a value to a location.
288 void CheckerManager::runCheckersForBind(ExplodedNodeSet &Dst,
289                                         const ExplodedNodeSet &Src,
290                                         SVal location, SVal val,
291                                         const Stmt *S, ExprEngine &Eng,
292                                         ProgramPoint::Kind PointKind) {
293   CheckBindContext C(BindCheckers, location, val, S, Eng, PointKind);
294   expandGraphWithCheckers(C, Dst, Src);
295 }
296 
297 void CheckerManager::runCheckersForEndAnalysis(ExplodedGraph &G,
298                                                BugReporter &BR,
299                                                ExprEngine &Eng) {
300   for (unsigned i = 0, e = EndAnalysisCheckers.size(); i != e; ++i)
301     EndAnalysisCheckers[i](G, BR, Eng);
302 }
303 
304 /// \brief Run checkers for end of path.
305 // Note, We do not chain the checker output (like in expandGraphWithCheckers)
306 // for this callback since end of path nodes are expected to be final.
307 void CheckerManager::runCheckersForEndPath(NodeBuilderContext &BC,
308                                            ExplodedNodeSet &Dst,
309                                            ExprEngine &Eng) {
310   ExplodedNode *Pred = BC.Pred;
311 
312   // We define the builder outside of the loop bacause if at least one checkers
313   // creates a sucsessor for Pred, we do not need to generate an
314   // autotransition for it.
315   NodeBuilder Bldr(Pred, Dst, BC);
316   for (unsigned i = 0, e = EndPathCheckers.size(); i != e; ++i) {
317     CheckEndPathFunc checkFn = EndPathCheckers[i];
318 
319     const ProgramPoint &L = BlockEntrance(BC.Block,
320                                           Pred->getLocationContext(),
321                                           checkFn.Checker);
322     CheckerContext C(Bldr, Eng, Pred, L);
323     checkFn(C);
324   }
325 }
326 
327 namespace {
328   struct CheckBranchConditionContext {
329     typedef std::vector<CheckerManager::CheckBranchConditionFunc> CheckersTy;
330     const CheckersTy &Checkers;
331     const Stmt *Condition;
332     ExprEngine &Eng;
333 
334     CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
335     CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
336 
337     CheckBranchConditionContext(const CheckersTy &checkers,
338                                 const Stmt *Cond, ExprEngine &eng)
339       : Checkers(checkers), Condition(Cond), Eng(eng) {}
340 
341     void runChecker(CheckerManager::CheckBranchConditionFunc checkFn,
342                     NodeBuilder &Bldr, ExplodedNode *Pred) {
343       ProgramPoint L = PostCondition(Condition, Pred->getLocationContext(),
344                                      checkFn.Checker);
345       CheckerContext C(Bldr, Eng, Pred, L);
346       checkFn(Condition, C);
347     }
348   };
349 }
350 
351 /// \brief Run checkers for branch condition.
352 void CheckerManager::runCheckersForBranchCondition(const Stmt *Condition,
353                                                    ExplodedNodeSet &Dst,
354                                                    ExplodedNode *Pred,
355                                                    ExprEngine &Eng) {
356   ExplodedNodeSet Src;
357   Src.insert(Pred);
358   CheckBranchConditionContext C(BranchConditionCheckers, Condition, Eng);
359   expandGraphWithCheckers(C, Dst, Src);
360 }
361 
362 /// \brief Run checkers for live symbols.
363 void CheckerManager::runCheckersForLiveSymbols(ProgramStateRef state,
364                                                SymbolReaper &SymReaper) {
365   for (unsigned i = 0, e = LiveSymbolsCheckers.size(); i != e; ++i)
366     LiveSymbolsCheckers[i](state, SymReaper);
367 }
368 
369 namespace {
370   struct CheckDeadSymbolsContext {
371     typedef std::vector<CheckerManager::CheckDeadSymbolsFunc> CheckersTy;
372     const CheckersTy &Checkers;
373     SymbolReaper &SR;
374     const Stmt *S;
375     ExprEngine &Eng;
376 
377     CheckersTy::const_iterator checkers_begin() { return Checkers.begin(); }
378     CheckersTy::const_iterator checkers_end() { return Checkers.end(); }
379 
380     CheckDeadSymbolsContext(const CheckersTy &checkers, SymbolReaper &sr,
381                             const Stmt *s, ExprEngine &eng)
382       : Checkers(checkers), SR(sr), S(s), Eng(eng) { }
383 
384     void runChecker(CheckerManager::CheckDeadSymbolsFunc checkFn,
385                     NodeBuilder &Bldr, ExplodedNode *Pred) {
386       ProgramPoint::Kind K = ProgramPoint::PostPurgeDeadSymbolsKind;
387       const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
388                                 Pred->getLocationContext(), checkFn.Checker);
389       CheckerContext C(Bldr, Eng, Pred, L);
390 
391       checkFn(SR, C);
392     }
393   };
394 }
395 
396 /// \brief Run checkers for dead symbols.
397 void CheckerManager::runCheckersForDeadSymbols(ExplodedNodeSet &Dst,
398                                                const ExplodedNodeSet &Src,
399                                                SymbolReaper &SymReaper,
400                                                const Stmt *S,
401                                                ExprEngine &Eng) {
402   CheckDeadSymbolsContext C(DeadSymbolsCheckers, SymReaper, S, Eng);
403   expandGraphWithCheckers(C, Dst, Src);
404 }
405 
406 /// \brief True if at least one checker wants to check region changes.
407 bool CheckerManager::wantsRegionChangeUpdate(ProgramStateRef state) {
408   for (unsigned i = 0, e = RegionChangesCheckers.size(); i != e; ++i)
409     if (RegionChangesCheckers[i].WantUpdateFn(state))
410       return true;
411 
412   return false;
413 }
414 
415 /// \brief Run checkers for region changes.
416 ProgramStateRef
417 CheckerManager::runCheckersForRegionChanges(ProgramStateRef state,
418                             const StoreManager::InvalidatedSymbols *invalidated,
419                                     ArrayRef<const MemRegion *> ExplicitRegions,
420                                           ArrayRef<const MemRegion *> Regions,
421                                           const CallOrObjCMessage *Call) {
422   for (unsigned i = 0, e = RegionChangesCheckers.size(); i != e; ++i) {
423     // If any checker declares the state infeasible (or if it starts that way),
424     // bail out.
425     if (!state)
426       return NULL;
427     state = RegionChangesCheckers[i].CheckFn(state, invalidated,
428                                              ExplicitRegions, Regions, Call);
429   }
430   return state;
431 }
432 
433 /// \brief Run checkers for handling assumptions on symbolic values.
434 ProgramStateRef
435 CheckerManager::runCheckersForEvalAssume(ProgramStateRef state,
436                                          SVal Cond, bool Assumption) {
437   for (unsigned i = 0, e = EvalAssumeCheckers.size(); i != e; ++i) {
438     // If any checker declares the state infeasible (or if it starts that way),
439     // bail out.
440     if (!state)
441       return NULL;
442     state = EvalAssumeCheckers[i](state, Cond, Assumption);
443   }
444   return state;
445 }
446 
447 /// \brief Run checkers for evaluating a call.
448 /// Only one checker will evaluate the call.
449 void CheckerManager::runCheckersForEvalCall(ExplodedNodeSet &Dst,
450                                             const ExplodedNodeSet &Src,
451                                             const CallExpr *CE,
452                                             ExprEngine &Eng,
453                                             GraphExpander *defaultEval) {
454   if (EvalCallCheckers.empty()   &&
455       InlineCallCheckers.empty() &&
456       defaultEval == 0) {
457     Dst.insert(Src);
458     return;
459   }
460 
461   for (ExplodedNodeSet::iterator
462          NI = Src.begin(), NE = Src.end(); NI != NE; ++NI) {
463 
464     ExplodedNode *Pred = *NI;
465     bool anyEvaluated = false;
466 
467     // First, check if any of the InlineCall callbacks can evaluate the call.
468     assert(InlineCallCheckers.size() <= 1 &&
469            "InlineCall is a special hacky callback to allow intrusive"
470            "evaluation of the call (which simulates inlining). It is "
471            "currently only used by OSAtomicChecker and should go away "
472            "at some point.");
473     for (std::vector<InlineCallFunc>::iterator
474            EI = InlineCallCheckers.begin(), EE = InlineCallCheckers.end();
475          EI != EE; ++EI) {
476       ExplodedNodeSet checkDst;
477       bool evaluated = (*EI)(CE, Eng, Pred, checkDst);
478       assert(!(evaluated && anyEvaluated)
479              && "There are more than one checkers evaluating the call");
480       if (evaluated) {
481         anyEvaluated = true;
482         Dst.insert(checkDst);
483 #ifdef NDEBUG
484         break; // on release don't check that no other checker also evals.
485 #endif
486       }
487     }
488 
489 #ifdef NDEBUG // on release don't check that no other checker also evals.
490     if (anyEvaluated) {
491       break;
492     }
493 #endif
494 
495     ExplodedNodeSet checkDst;
496     NodeBuilder B(Pred, checkDst, Eng.getBuilderContext());
497     // Next, check if any of the EvalCall callbacks can evaluate the call.
498     for (std::vector<EvalCallFunc>::iterator
499            EI = EvalCallCheckers.begin(), EE = EvalCallCheckers.end();
500          EI != EE; ++EI) {
501       ProgramPoint::Kind K = ProgramPoint::PostStmtKind;
502       const ProgramPoint &L = ProgramPoint::getProgramPoint(CE, K,
503                                 Pred->getLocationContext(), EI->Checker);
504       bool evaluated = false;
505       { // CheckerContext generates transitions(populates checkDest) on
506         // destruction, so introduce the scope to make sure it gets properly
507         // populated.
508         CheckerContext C(B, Eng, Pred, L);
509         evaluated = (*EI)(CE, C);
510       }
511       assert(!(evaluated && anyEvaluated)
512              && "There are more than one checkers evaluating the call");
513       if (evaluated) {
514         anyEvaluated = true;
515         Dst.insert(checkDst);
516 #ifdef NDEBUG
517         break; // on release don't check that no other checker also evals.
518 #endif
519       }
520     }
521 
522     // If none of the checkers evaluated the call, ask ExprEngine to handle it.
523     if (!anyEvaluated) {
524       if (defaultEval)
525         defaultEval->expandGraph(Dst, Pred);
526       else
527         Dst.insert(Pred);
528     }
529   }
530 }
531 
532 /// \brief Run checkers for the entire Translation Unit.
533 void CheckerManager::runCheckersOnEndOfTranslationUnit(
534                                                   const TranslationUnitDecl *TU,
535                                                   AnalysisManager &mgr,
536                                                   BugReporter &BR) {
537   for (unsigned i = 0, e = EndOfTranslationUnitCheckers.size(); i != e; ++i)
538     EndOfTranslationUnitCheckers[i](TU, mgr, BR);
539 }
540 
541 void CheckerManager::runCheckersForPrintState(raw_ostream &Out,
542                                               ProgramStateRef State,
543                                               const char *NL, const char *Sep) {
544   for (llvm::DenseMap<CheckerTag, CheckerRef>::iterator
545         I = CheckerTags.begin(), E = CheckerTags.end(); I != E; ++I)
546     I->second->printState(Out, State, NL, Sep);
547 }
548 
549 //===----------------------------------------------------------------------===//
550 // Internal registration functions for AST traversing.
551 //===----------------------------------------------------------------------===//
552 
553 void CheckerManager::_registerForDecl(CheckDeclFunc checkfn,
554                                       HandlesDeclFunc isForDeclFn) {
555   DeclCheckerInfo info = { checkfn, isForDeclFn };
556   DeclCheckers.push_back(info);
557 }
558 
559 void CheckerManager::_registerForBody(CheckDeclFunc checkfn) {
560   BodyCheckers.push_back(checkfn);
561 }
562 
563 //===----------------------------------------------------------------------===//
564 // Internal registration functions for path-sensitive checking.
565 //===----------------------------------------------------------------------===//
566 
567 void CheckerManager::_registerForPreStmt(CheckStmtFunc checkfn,
568                                          HandlesStmtFunc isForStmtFn) {
569   StmtCheckerInfo info = { checkfn, isForStmtFn, /*IsPreVisit*/true };
570   StmtCheckers.push_back(info);
571 }
572 void CheckerManager::_registerForPostStmt(CheckStmtFunc checkfn,
573                                           HandlesStmtFunc isForStmtFn) {
574   StmtCheckerInfo info = { checkfn, isForStmtFn, /*IsPreVisit*/false };
575   StmtCheckers.push_back(info);
576 }
577 
578 void CheckerManager::_registerForPreObjCMessage(CheckObjCMessageFunc checkfn) {
579   PreObjCMessageCheckers.push_back(checkfn);
580 }
581 void CheckerManager::_registerForPostObjCMessage(CheckObjCMessageFunc checkfn) {
582   PostObjCMessageCheckers.push_back(checkfn);
583 }
584 
585 void CheckerManager::_registerForLocation(CheckLocationFunc checkfn) {
586   LocationCheckers.push_back(checkfn);
587 }
588 
589 void CheckerManager::_registerForBind(CheckBindFunc checkfn) {
590   BindCheckers.push_back(checkfn);
591 }
592 
593 void CheckerManager::_registerForEndAnalysis(CheckEndAnalysisFunc checkfn) {
594   EndAnalysisCheckers.push_back(checkfn);
595 }
596 
597 void CheckerManager::_registerForEndPath(CheckEndPathFunc checkfn) {
598   EndPathCheckers.push_back(checkfn);
599 }
600 
601 void CheckerManager::_registerForBranchCondition(
602                                              CheckBranchConditionFunc checkfn) {
603   BranchConditionCheckers.push_back(checkfn);
604 }
605 
606 void CheckerManager::_registerForLiveSymbols(CheckLiveSymbolsFunc checkfn) {
607   LiveSymbolsCheckers.push_back(checkfn);
608 }
609 
610 void CheckerManager::_registerForDeadSymbols(CheckDeadSymbolsFunc checkfn) {
611   DeadSymbolsCheckers.push_back(checkfn);
612 }
613 
614 void CheckerManager::_registerForRegionChanges(CheckRegionChangesFunc checkfn,
615                                      WantsRegionChangeUpdateFunc wantUpdateFn) {
616   RegionChangesCheckerInfo info = {checkfn, wantUpdateFn};
617   RegionChangesCheckers.push_back(info);
618 }
619 
620 void CheckerManager::_registerForEvalAssume(EvalAssumeFunc checkfn) {
621   EvalAssumeCheckers.push_back(checkfn);
622 }
623 
624 void CheckerManager::_registerForEvalCall(EvalCallFunc checkfn) {
625   EvalCallCheckers.push_back(checkfn);
626 }
627 
628 void CheckerManager::_registerForInlineCall(InlineCallFunc checkfn) {
629   InlineCallCheckers.push_back(checkfn);
630 }
631 
632 void CheckerManager::_registerForEndOfTranslationUnit(
633                                             CheckEndOfTranslationUnit checkfn) {
634   EndOfTranslationUnitCheckers.push_back(checkfn);
635 }
636 
637 //===----------------------------------------------------------------------===//
638 // Implementation details.
639 //===----------------------------------------------------------------------===//
640 
641 CheckerManager::CachedStmtCheckers *
642 CheckerManager::getCachedStmtCheckersFor(const Stmt *S, bool isPreVisit) {
643   assert(S);
644 
645   CachedStmtCheckersKey key(S->getStmtClass(), isPreVisit);
646   CachedStmtCheckers *checkers = 0;
647   CachedStmtCheckersMapTy::iterator CCI = CachedStmtCheckersMap.find(key);
648   if (CCI != CachedStmtCheckersMap.end()) {
649     checkers = &(CCI->second);
650   } else {
651     // Find the checkers that should run for this Stmt and cache them.
652     checkers = &CachedStmtCheckersMap[key];
653     for (unsigned i = 0, e = StmtCheckers.size(); i != e; ++i) {
654       StmtCheckerInfo &info = StmtCheckers[i];
655       if (info.IsPreVisit == isPreVisit && info.IsForStmtFn(S))
656         checkers->push_back(info.CheckFn);
657     }
658   }
659 
660   assert(checkers);
661   return checkers;
662 }
663 
664 CheckerManager::~CheckerManager() {
665   for (unsigned i = 0, e = CheckerDtors.size(); i != e; ++i)
666     CheckerDtors[i]();
667 }
668 
669 // Anchor for the vtable.
670 GraphExpander::~GraphExpander() { }
671