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