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