contrib/llvm/tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h

   1 //===--- CheckerManager.h - Static Analyzer Checker Manager -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Defines the Static Analyzer Checker Manager.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_STATICANALYZER_CORE_CHECKERMANAGER_H
  15 #define LLVM_CLANG_STATICANALYZER_CORE_CHECKERMANAGER_H
  16
  17 #include "clang/Analysis/ProgramPoint.h"
  18 #include "clang/Basic/LangOptions.h"
  19 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
  20 #include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
  21 #include "llvm/ADT/DenseMap.h"
  22 #include "llvm/ADT/SmallVector.h"
  23 #include <utility>
  24 #include <vector>
  25
  26 namespace clang {
  27   class Decl;
  28   class Stmt;
  29   class CallExpr;
  30
  31 namespace ento {
  32   class CheckerBase;
  33   class CheckerRegistry;
  34   class ExprEngine;
  35   class AnalysisManager;
  36   class BugReporter;
  37   class CheckerContext;
  38   class ObjCMethodCall;
  39   class SVal;
  40   class ExplodedNode;
  41   class ExplodedNodeSet;
  42   class ExplodedGraph;
  43   class ProgramState;
  44   class NodeBuilder;
  45   struct NodeBuilderContext;
  46   class MemRegion;
  47   class SymbolReaper;
  48
  49 template <typename T> class CheckerFn;
  50
  51 template <typename RET, typename... Ps>
  52 class CheckerFn<RET(Ps...)> {
  53   typedef RET (*Func)(void *, Ps...);
  54   Func Fn;
  55 public:
  56   CheckerBase *Checker;
  57   CheckerFn(CheckerBase *checker, Func fn) : Fn(fn), Checker(checker) { }
  58   RET operator()(Ps... ps) const {
  59     return Fn(Checker, ps...);
  60   }
  61 };
  62
  63 /// \brief Describes the different reasons a pointer escapes
  64 /// during analysis.
  65 enum PointerEscapeKind {
  66   /// A pointer escapes due to binding its value to a location
  67   /// that the analyzer cannot track.
  68   PSK_EscapeOnBind,
  69
  70   /// The pointer has been passed to a function call directly.
  71   PSK_DirectEscapeOnCall,
  72
  73   /// The pointer has been passed to a function indirectly.
  74   /// For example, the pointer is accessible through an
  75   /// argument to a function.
  76   PSK_IndirectEscapeOnCall,
  77
  78   /// The reason for pointer escape is unknown. For example,
  79   /// a region containing this pointer is invalidated.
  80   PSK_EscapeOther
  81 };
  82
  83 // This wrapper is used to ensure that only StringRefs originating from the
  84 // CheckerRegistry are used as check names. We want to make sure all check
  85 // name strings have a lifetime that keeps them alive at least until the path
  86 // diagnostics have been processed.
  87 class CheckName {
  88   StringRef Name;
  89   friend class ::clang::ento::CheckerRegistry;
  90   explicit CheckName(StringRef Name) : Name(Name) {}
  91
  92 public:
  93   CheckName() = default;
  94   StringRef getName() const { return Name; }
  95 };
  96
  97 enum class ObjCMessageVisitKind {
  98   Pre,
  99   Post,
 100   MessageNil
 101 };
 102
 103 class CheckerManager {
 104   const LangOptions LangOpts;
 105   AnalyzerOptions &AOptions;
 106   CheckName CurrentCheckName;
 107
 108 public:
 109   CheckerManager(const LangOptions &langOpts, AnalyzerOptions &AOptions)
 110       : LangOpts(langOpts), AOptions(AOptions) {}
 111
 112   ~CheckerManager();
 113
 114   void setCurrentCheckName(CheckName name) { CurrentCheckName = name; }
 115   CheckName getCurrentCheckName() const { return CurrentCheckName; }
 116
 117   bool hasPathSensitiveCheckers() const;
 118
 119   void finishedCheckerRegistration();
 120
 121   const LangOptions &getLangOpts() const { return LangOpts; }
 122   AnalyzerOptions &getAnalyzerOptions() { return AOptions; }
 123
 124   typedef CheckerBase *CheckerRef;
 125   typedef const void *CheckerTag;
 126   typedef CheckerFn<void ()> CheckerDtor;
 127
 128 //===----------------------------------------------------------------------===//
 129 // registerChecker
 130 //===----------------------------------------------------------------------===//
 131
 132   /// \brief Used to register checkers.
 133   ///
 134   /// \returns a pointer to the checker object.
 135   template <typename CHECKER>
 136   CHECKER *registerChecker() {
 137     CheckerTag tag = getTag<CHECKER>();
 138     CheckerRef &ref = CheckerTags[tag];
 139     if (ref)
 140       return static_cast<CHECKER *>(ref); // already registered.
 141
 142     CHECKER *checker = new CHECKER();
 143     checker->Name = CurrentCheckName;
 144     CheckerDtors.push_back(CheckerDtor(checker, destruct<CHECKER>));
 145     CHECKER::_register(checker, *this);
 146     ref = checker;
 147     return checker;
 148   }
 149
 150   template <typename CHECKER>
 151   CHECKER *registerChecker(AnalyzerOptions &AOpts) {
 152     CheckerTag tag = getTag<CHECKER>();
 153     CheckerRef &ref = CheckerTags[tag];
 154     if (ref)
 155       return static_cast<CHECKER *>(ref); // already registered.
 156
 157     CHECKER *checker = new CHECKER(AOpts);
 158     checker->Name = CurrentCheckName;
 159     CheckerDtors.push_back(CheckerDtor(checker, destruct<CHECKER>));
 160     CHECKER::_register(checker, *this);
 161     ref = checker;
 162     return checker;
 163   }
 164
 165 //===----------------------------------------------------------------------===//
 166 // Functions for running checkers for AST traversing..
 167 //===----------------------------------------------------------------------===//
 168
 169   /// \brief Run checkers handling Decls.
 170   void runCheckersOnASTDecl(const Decl *D, AnalysisManager& mgr,
 171                             BugReporter &BR);
 172
 173   /// \brief Run checkers handling Decls containing a Stmt body.
 174   void runCheckersOnASTBody(const Decl *D, AnalysisManager& mgr,
 175                             BugReporter &BR);
 176
 177 //===----------------------------------------------------------------------===//
 178 // Functions for running checkers for path-sensitive checking.
 179 //===----------------------------------------------------------------------===//
 180
 181   /// \brief Run checkers for pre-visiting Stmts.
 182   ///
 183   /// The notification is performed for every explored CFGElement, which does
 184   /// not include the control flow statements such as IfStmt.
 185   ///
 186   /// \sa runCheckersForBranchCondition, runCheckersForPostStmt
 187   void runCheckersForPreStmt(ExplodedNodeSet &Dst,
 188                              const ExplodedNodeSet &Src,
 189                              const Stmt *S,
 190                              ExprEngine &Eng) {
 191     runCheckersForStmt(/*isPreVisit=*/true, Dst, Src, S, Eng);
 192   }
 193
 194   /// \brief Run checkers for post-visiting Stmts.
 195   ///
 196   /// The notification is performed for every explored CFGElement, which does
 197   /// not include the control flow statements such as IfStmt.
 198   ///
 199   /// \sa runCheckersForBranchCondition, runCheckersForPreStmt
 200   void runCheckersForPostStmt(ExplodedNodeSet &Dst,
 201                               const ExplodedNodeSet &Src,
 202                               const Stmt *S,
 203                               ExprEngine &Eng,
 204                               bool wasInlined = false) {
 205     runCheckersForStmt(/*isPreVisit=*/false, Dst, Src, S, Eng, wasInlined);
 206   }
 207
 208   /// \brief Run checkers for visiting Stmts.
 209   void runCheckersForStmt(bool isPreVisit,
 210                           ExplodedNodeSet &Dst, const ExplodedNodeSet &Src,
 211                           const Stmt *S, ExprEngine &Eng,
 212                           bool wasInlined = false);
 213
 214   /// \brief Run checkers for pre-visiting obj-c messages.
 215   void runCheckersForPreObjCMessage(ExplodedNodeSet &Dst,
 216                                     const ExplodedNodeSet &Src,
 217                                     const ObjCMethodCall &msg,
 218                                     ExprEngine &Eng) {
 219     runCheckersForObjCMessage(ObjCMessageVisitKind::Pre, Dst, Src, msg, Eng);
 220   }
 221
 222   /// \brief Run checkers for post-visiting obj-c messages.
 223   void runCheckersForPostObjCMessage(ExplodedNodeSet &Dst,
 224                                      const ExplodedNodeSet &Src,
 225                                      const ObjCMethodCall &msg,
 226                                      ExprEngine &Eng,
 227                                      bool wasInlined = false) {
 228     runCheckersForObjCMessage(ObjCMessageVisitKind::Post, Dst, Src, msg, Eng,
 229                               wasInlined);
 230   }
 231
 232   /// \brief Run checkers for visiting an obj-c message to nil.
 233   void runCheckersForObjCMessageNil(ExplodedNodeSet &Dst,
 234                                     const ExplodedNodeSet &Src,
 235                                     const ObjCMethodCall &msg,
 236                                     ExprEngine &Eng) {
 237     runCheckersForObjCMessage(ObjCMessageVisitKind::MessageNil, Dst, Src, msg,
 238                               Eng);
 239   }
 240
 241
 242   /// \brief Run checkers for visiting obj-c messages.
 243   void runCheckersForObjCMessage(ObjCMessageVisitKind visitKind,
 244                                  ExplodedNodeSet &Dst,
 245                                  const ExplodedNodeSet &Src,
 246                                  const ObjCMethodCall &msg, ExprEngine &Eng,
 247                                  bool wasInlined = false);
 248
 249   /// \brief Run checkers for pre-visiting obj-c messages.
 250   void runCheckersForPreCall(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src,
 251                              const CallEvent &Call, ExprEngine &Eng) {
 252     runCheckersForCallEvent(/*isPreVisit=*/true, Dst, Src, Call, Eng);
 253   }
 254
 255   /// \brief Run checkers for post-visiting obj-c messages.
 256   void runCheckersForPostCall(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src,
 257                               const CallEvent &Call, ExprEngine &Eng,
 258                               bool wasInlined = false) {
 259     runCheckersForCallEvent(/*isPreVisit=*/false, Dst, Src, Call, Eng,
 260                             wasInlined);
 261   }
 262
 263   /// \brief Run checkers for visiting obj-c messages.
 264   void runCheckersForCallEvent(bool isPreVisit, ExplodedNodeSet &Dst,
 265                                const ExplodedNodeSet &Src,
 266                                const CallEvent &Call, ExprEngine &Eng,
 267                                bool wasInlined = false);
 268
 269   /// \brief Run checkers for load/store of a location.
 270   void runCheckersForLocation(ExplodedNodeSet &Dst,
 271                               const ExplodedNodeSet &Src,
 272                               SVal location,
 273                               bool isLoad,
 274                               const Stmt *NodeEx,
 275                               const Stmt *BoundEx,
 276                               ExprEngine &Eng);
 277
 278   /// \brief Run checkers for binding of a value to a location.
 279   void runCheckersForBind(ExplodedNodeSet &Dst,
 280                           const ExplodedNodeSet &Src,
 281                           SVal location, SVal val,
 282                           const Stmt *S, ExprEngine &Eng,
 283                           const ProgramPoint &PP);
 284
 285   /// \brief Run checkers for end of analysis.
 286   void runCheckersForEndAnalysis(ExplodedGraph &G, BugReporter &BR,
 287                                  ExprEngine &Eng);
 288
 289   /// \brief Run checkers on begining of function.
 290   void runCheckersForBeginFunction(ExplodedNodeSet &Dst,
 291                                    const BlockEdge &L,
 292                                    ExplodedNode *Pred,
 293                                    ExprEngine &Eng);
 294
 295   /// \brief Run checkers on end of function.
 296   void runCheckersForEndFunction(NodeBuilderContext &BC,
 297                                  ExplodedNodeSet &Dst,
 298                                  ExplodedNode *Pred,
 299                                  ExprEngine &Eng);
 300
 301   /// \brief Run checkers for branch condition.
 302   void runCheckersForBranchCondition(const Stmt *condition,
 303                                      ExplodedNodeSet &Dst, ExplodedNode *Pred,
 304                                      ExprEngine &Eng);
 305
 306   /// \brief Run checkers for live symbols.
 307   ///
 308   /// Allows modifying SymbolReaper object. For example, checkers can explicitly
 309   /// register symbols of interest as live. These symbols will not be marked
 310   /// dead and removed.
 311   void runCheckersForLiveSymbols(ProgramStateRef state,
 312                                  SymbolReaper &SymReaper);
 313
 314   /// \brief Run checkers for dead symbols.
 315   ///
 316   /// Notifies checkers when symbols become dead. For example, this allows
 317   /// checkers to aggressively clean up/reduce the checker state and produce
 318   /// precise diagnostics.
 319   void runCheckersForDeadSymbols(ExplodedNodeSet &Dst,
 320                                  const ExplodedNodeSet &Src,
 321                                  SymbolReaper &SymReaper, const Stmt *S,
 322                                  ExprEngine &Eng,
 323                                  ProgramPoint::Kind K);
 324
 325   /// \brief Run checkers for region changes.
 326   ///
 327   /// This corresponds to the check::RegionChanges callback.
 328   /// \param state The current program state.
 329   /// \param invalidated A set of all symbols potentially touched by the change.
 330   /// \param ExplicitRegions The regions explicitly requested for invalidation.
 331   ///   For example, in the case of a function call, these would be arguments.
 332   /// \param Regions The transitive closure of accessible regions,
 333   ///   i.e. all regions that may have been touched by this change.
 334   /// \param Call The call expression wrapper if the regions are invalidated
 335   ///   by a call.
 336   ProgramStateRef
 337   runCheckersForRegionChanges(ProgramStateRef state,
 338                               const InvalidatedSymbols *invalidated,
 339                               ArrayRef<const MemRegion *> ExplicitRegions,
 340                               ArrayRef<const MemRegion *> Regions,
 341                               const CallEvent *Call);
 342
 343   /// \brief Run checkers when pointers escape.
 344   ///
 345   /// This notifies the checkers about pointer escape, which occurs whenever
 346   /// the analyzer cannot track the symbol any more. For example, as a
 347   /// result of assigning a pointer into a global or when it's passed to a
 348   /// function call the analyzer cannot model.
 349   ///
 350   /// \param State The state at the point of escape.
 351   /// \param Escaped The list of escaped symbols.
 352   /// \param Call The corresponding CallEvent, if the symbols escape as
 353   ///        parameters to the given call.
 354   /// \param Kind The reason of pointer escape.
 355   /// \param ITraits Information about invalidation for a particular
 356   ///        region/symbol.
 357   /// \returns Checkers can modify the state by returning a new one.
 358   ProgramStateRef
 359   runCheckersForPointerEscape(ProgramStateRef State,
 360                               const InvalidatedSymbols &Escaped,
 361                               const CallEvent *Call,
 362                               PointerEscapeKind Kind,
 363                              RegionAndSymbolInvalidationTraits *ITraits);
 364
 365   /// \brief Run checkers for handling assumptions on symbolic values.
 366   ProgramStateRef runCheckersForEvalAssume(ProgramStateRef state,
 367                                            SVal Cond, bool Assumption);
 368
 369   /// \brief Run checkers for evaluating a call.
 370   ///
 371   /// Warning: Currently, the CallEvent MUST come from a CallExpr!
 372   void runCheckersForEvalCall(ExplodedNodeSet &Dst,
 373                               const ExplodedNodeSet &Src,
 374                               const CallEvent &CE, ExprEngine &Eng);
 375
 376   /// \brief Run checkers for the entire Translation Unit.
 377   void runCheckersOnEndOfTranslationUnit(const TranslationUnitDecl *TU,
 378                                          AnalysisManager &mgr,
 379                                          BugReporter &BR);
 380
 381   /// \brief Run checkers for debug-printing a ProgramState.
 382   ///
 383   /// Unlike most other callbacks, any checker can simply implement the virtual
 384   /// method CheckerBase::printState if it has custom data to print.
 385   /// \param Out The output stream
 386   /// \param State The state being printed
 387   /// \param NL The preferred representation of a newline.
 388   /// \param Sep The preferred separator between different kinds of data.
 389   void runCheckersForPrintState(raw_ostream &Out, ProgramStateRef State,
 390                                 const char *NL, const char *Sep);
 391
 392 //===----------------------------------------------------------------------===//
 393 // Internal registration functions for AST traversing.
 394 //===----------------------------------------------------------------------===//
 395
 396   // Functions used by the registration mechanism, checkers should not touch
 397   // these directly.
 398
 399   typedef CheckerFn<void (const Decl *, AnalysisManager&, BugReporter &)>
 400       CheckDeclFunc;
 401
 402   typedef bool (*HandlesDeclFunc)(const Decl *D);
 403   void _registerForDecl(CheckDeclFunc checkfn, HandlesDeclFunc isForDeclFn);
 404
 405   void _registerForBody(CheckDeclFunc checkfn);
 406
 407 //===----------------------------------------------------------------------===//
 408 // Internal registration functions for path-sensitive checking.
 409 //===----------------------------------------------------------------------===//
 410
 411   typedef CheckerFn<void (const Stmt *, CheckerContext &)> CheckStmtFunc;
 412
 413   typedef CheckerFn<void (const ObjCMethodCall &, CheckerContext &)>
 414       CheckObjCMessageFunc;
 415
 416   typedef CheckerFn<void (const CallEvent &, CheckerContext &)>
 417       CheckCallFunc;
 418
 419   typedef CheckerFn<void (const SVal &location, bool isLoad,
 420                           const Stmt *S,
 421                           CheckerContext &)>
 422       CheckLocationFunc;
 423
 424   typedef CheckerFn<void (const SVal &location, const SVal &val,
 425                           const Stmt *S, CheckerContext &)>
 426       CheckBindFunc;
 427
 428   typedef CheckerFn<void (ExplodedGraph &, BugReporter &, ExprEngine &)>
 429       CheckEndAnalysisFunc;
 430
 431   typedef CheckerFn<void (CheckerContext &)>
 432       CheckBeginFunctionFunc;
 433
 434   typedef CheckerFn<void (CheckerContext &)>
 435       CheckEndFunctionFunc;
 436
 437   typedef CheckerFn<void (const Stmt *, CheckerContext &)>
 438       CheckBranchConditionFunc;
 439
 440   typedef CheckerFn<void (SymbolReaper &, CheckerContext &)>
 441       CheckDeadSymbolsFunc;
 442
 443   typedef CheckerFn<void (ProgramStateRef,SymbolReaper &)> CheckLiveSymbolsFunc;
 444
 445   typedef CheckerFn<ProgramStateRef (ProgramStateRef,
 446                                 const InvalidatedSymbols *symbols,
 447                                 ArrayRef<const MemRegion *> ExplicitRegions,
 448                                 ArrayRef<const MemRegion *> Regions,
 449                                 const CallEvent *Call)>
 450       CheckRegionChangesFunc;
 451
 452   typedef CheckerFn<ProgramStateRef (ProgramStateRef,
 453                                      const InvalidatedSymbols &Escaped,
 454                                      const CallEvent *Call,
 455                                      PointerEscapeKind Kind,
 456                                      RegionAndSymbolInvalidationTraits *ITraits)>
 457       CheckPointerEscapeFunc;
 458
 459   typedef CheckerFn<ProgramStateRef (ProgramStateRef,
 460                                           const SVal &cond, bool assumption)>
 461       EvalAssumeFunc;
 462
 463   typedef CheckerFn<bool (const CallExpr *, CheckerContext &)>
 464       EvalCallFunc;
 465
 466   typedef CheckerFn<void (const TranslationUnitDecl *,
 467                           AnalysisManager&, BugReporter &)>
 468       CheckEndOfTranslationUnit;
 469
 470   typedef bool (*HandlesStmtFunc)(const Stmt *D);
 471   void _registerForPreStmt(CheckStmtFunc checkfn,
 472                            HandlesStmtFunc isForStmtFn);
 473   void _registerForPostStmt(CheckStmtFunc checkfn,
 474                             HandlesStmtFunc isForStmtFn);
 475
 476   void _registerForPreObjCMessage(CheckObjCMessageFunc checkfn);
 477   void _registerForPostObjCMessage(CheckObjCMessageFunc checkfn);
 478
 479   void _registerForObjCMessageNil(CheckObjCMessageFunc checkfn);
 480
 481   void _registerForPreCall(CheckCallFunc checkfn);
 482   void _registerForPostCall(CheckCallFunc checkfn);
 483
 484   void _registerForLocation(CheckLocationFunc checkfn);
 485
 486   void _registerForBind(CheckBindFunc checkfn);
 487
 488   void _registerForEndAnalysis(CheckEndAnalysisFunc checkfn);
 489
 490   void _registerForBeginFunction(CheckEndFunctionFunc checkfn);
 491   void _registerForEndFunction(CheckEndFunctionFunc checkfn);
 492
 493   void _registerForBranchCondition(CheckBranchConditionFunc checkfn);
 494
 495   void _registerForLiveSymbols(CheckLiveSymbolsFunc checkfn);
 496
 497   void _registerForDeadSymbols(CheckDeadSymbolsFunc checkfn);
 498
 499   void _registerForRegionChanges(CheckRegionChangesFunc checkfn);
 500
 501   void _registerForPointerEscape(CheckPointerEscapeFunc checkfn);
 502
 503   void _registerForConstPointerEscape(CheckPointerEscapeFunc checkfn);
 504
 505   void _registerForEvalAssume(EvalAssumeFunc checkfn);
 506
 507   void _registerForEvalCall(EvalCallFunc checkfn);
 508
 509   void _registerForEndOfTranslationUnit(CheckEndOfTranslationUnit checkfn);
 510
 511 //===----------------------------------------------------------------------===//
 512 // Internal registration functions for events.
 513 //===----------------------------------------------------------------------===//
 514
 515   typedef void *EventTag;
 516   typedef CheckerFn<void (const void *event)> CheckEventFunc;
 517
 518   template <typename EVENT>
 519   void _registerListenerForEvent(CheckEventFunc checkfn) {
 520     EventInfo &info = Events[getTag<EVENT>()];
 521     info.Checkers.push_back(checkfn);
 522   }
 523
 524   template <typename EVENT>
 525   void _registerDispatcherForEvent() {
 526     EventInfo &info = Events[getTag<EVENT>()];
 527     info.HasDispatcher = true;
 528   }
 529
 530   template <typename EVENT>
 531   void _dispatchEvent(const EVENT &event) const {
 532     EventsTy::const_iterator I = Events.find(getTag<EVENT>());
 533     if (I == Events.end())
 534       return;
 535     const EventInfo &info = I->second;
 536     for (unsigned i = 0, e = info.Checkers.size(); i != e; ++i)
 537       info.Checkers[i](&event);
 538   }
 539
 540 //===----------------------------------------------------------------------===//
 541 // Implementation details.
 542 //===----------------------------------------------------------------------===//
 543
 544 private:
 545   template <typename CHECKER>
 546   static void destruct(void *obj) { delete static_cast<CHECKER *>(obj); }
 547
 548   template <typename T>
 549   static void *getTag() { static int tag; return &tag; }
 550
 551   llvm::DenseMap<CheckerTag, CheckerRef> CheckerTags;
 552
 553   std::vector<CheckerDtor> CheckerDtors;
 554
 555   struct DeclCheckerInfo {
 556     CheckDeclFunc CheckFn;
 557     HandlesDeclFunc IsForDeclFn;
 558   };
 559   std::vector<DeclCheckerInfo> DeclCheckers;
 560
 561   std::vector<CheckDeclFunc> BodyCheckers;
 562
 563   typedef SmallVector<CheckDeclFunc, 4> CachedDeclCheckers;
 564   typedef llvm::DenseMap<unsigned, CachedDeclCheckers> CachedDeclCheckersMapTy;
 565   CachedDeclCheckersMapTy CachedDeclCheckersMap;
 566
 567   struct StmtCheckerInfo {
 568     CheckStmtFunc CheckFn;
 569     HandlesStmtFunc IsForStmtFn;
 570     bool IsPreVisit;
 571   };
 572   std::vector<StmtCheckerInfo> StmtCheckers;
 573
 574   typedef SmallVector<CheckStmtFunc, 4> CachedStmtCheckers;
 575   typedef llvm::DenseMap<unsigned, CachedStmtCheckers> CachedStmtCheckersMapTy;
 576   CachedStmtCheckersMapTy CachedStmtCheckersMap;
 577
 578   const CachedStmtCheckers &getCachedStmtCheckersFor(const Stmt *S,
 579                                                      bool isPreVisit);
 580
 581   /// Returns the checkers that have registered for callbacks of the
 582   /// given \p Kind.
 583   const std::vector<CheckObjCMessageFunc> &
 584   getObjCMessageCheckers(ObjCMessageVisitKind Kind);
 585
 586   std::vector<CheckObjCMessageFunc> PreObjCMessageCheckers;
 587   std::vector<CheckObjCMessageFunc> PostObjCMessageCheckers;
 588   std::vector<CheckObjCMessageFunc> ObjCMessageNilCheckers;
 589
 590   std::vector<CheckCallFunc> PreCallCheckers;
 591   std::vector<CheckCallFunc> PostCallCheckers;
 592
 593   std::vector<CheckLocationFunc> LocationCheckers;
 594
 595   std::vector<CheckBindFunc> BindCheckers;
 596
 597   std::vector<CheckEndAnalysisFunc> EndAnalysisCheckers;
 598
 599   std::vector<CheckBeginFunctionFunc> BeginFunctionCheckers;
 600   std::vector<CheckEndFunctionFunc> EndFunctionCheckers;
 601
 602   std::vector<CheckBranchConditionFunc> BranchConditionCheckers;
 603
 604   std::vector<CheckLiveSymbolsFunc> LiveSymbolsCheckers;
 605
 606   std::vector<CheckDeadSymbolsFunc> DeadSymbolsCheckers;
 607
 608   std::vector<CheckRegionChangesFunc> RegionChangesCheckers;
 609
 610   std::vector<CheckPointerEscapeFunc> PointerEscapeCheckers;
 611
 612   std::vector<EvalAssumeFunc> EvalAssumeCheckers;
 613
 614   std::vector<EvalCallFunc> EvalCallCheckers;
 615
 616   std::vector<CheckEndOfTranslationUnit> EndOfTranslationUnitCheckers;
 617
 618   struct EventInfo {
 619     SmallVector<CheckEventFunc, 4> Checkers;
 620     bool HasDispatcher;
 621     EventInfo() : HasDispatcher(false) { }
 622   };
 623
 624   typedef llvm::DenseMap<EventTag, EventInfo> EventsTy;
 625   EventsTy Events;
 626 };
 627
 628 } // end ento namespace
 629
 630 } // end clang namespace
 631
 632 #endif