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   AnalyzerOptionsRef AOptions;
 106   CheckName CurrentCheckName;
 107
 108 public:
 109   CheckerManager(const LangOptions &langOpts, AnalyzerOptionsRef AOptions)
 110       : LangOpts(langOpts), AOptions(std::move(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 True if at least one checker wants to check region changes.
 326   bool wantsRegionChangeUpdate(ProgramStateRef state);
 327
 328   /// \brief Run checkers for region changes.
 329   ///
 330   /// This corresponds to the check::RegionChanges callback.
 331   /// \param state The current program state.
 332   /// \param invalidated A set of all symbols potentially touched by the change.
 333   /// \param ExplicitRegions The regions explicitly requested for invalidation.
 334   ///   For example, in the case of a function call, these would be arguments.
 335   /// \param Regions The transitive closure of accessible regions,
 336   ///   i.e. all regions that may have been touched by this change.
 337   /// \param Call The call expression wrapper if the regions are invalidated
 338   ///   by a call.
 339   ProgramStateRef
 340   runCheckersForRegionChanges(ProgramStateRef state,
 341                               const InvalidatedSymbols *invalidated,
 342                               ArrayRef<const MemRegion *> ExplicitRegions,
 343                               ArrayRef<const MemRegion *> Regions,
 344                               const CallEvent *Call);
 345
 346   /// \brief Run checkers when pointers escape.
 347   ///
 348   /// This notifies the checkers about pointer escape, which occurs whenever
 349   /// the analyzer cannot track the symbol any more. For example, as a
 350   /// result of assigning a pointer into a global or when it's passed to a
 351   /// function call the analyzer cannot model.
 352   ///
 353   /// \param State The state at the point of escape.
 354   /// \param Escaped The list of escaped symbols.
 355   /// \param Call The corresponding CallEvent, if the symbols escape as
 356   ///        parameters to the given call.
 357   /// \param Kind The reason of pointer escape.
 358   /// \param ITraits Information about invalidation for a particular
 359   ///        region/symbol.
 360   /// \returns Checkers can modify the state by returning a new one.
 361   ProgramStateRef
 362   runCheckersForPointerEscape(ProgramStateRef State,
 363                               const InvalidatedSymbols &Escaped,
 364                               const CallEvent *Call,
 365                               PointerEscapeKind Kind,
 366                              RegionAndSymbolInvalidationTraits *ITraits);
 367
 368   /// \brief Run checkers for handling assumptions on symbolic values.
 369   ProgramStateRef runCheckersForEvalAssume(ProgramStateRef state,
 370                                            SVal Cond, bool Assumption);
 371
 372   /// \brief Run checkers for evaluating a call.
 373   ///
 374   /// Warning: Currently, the CallEvent MUST come from a CallExpr!
 375   void runCheckersForEvalCall(ExplodedNodeSet &Dst,
 376                               const ExplodedNodeSet &Src,
 377                               const CallEvent &CE, ExprEngine &Eng);
 378
 379   /// \brief Run checkers for the entire Translation Unit.
 380   void runCheckersOnEndOfTranslationUnit(const TranslationUnitDecl *TU,
 381                                          AnalysisManager &mgr,
 382                                          BugReporter &BR);
 383
 384   /// \brief Run checkers for debug-printing a ProgramState.
 385   ///
 386   /// Unlike most other callbacks, any checker can simply implement the virtual
 387   /// method CheckerBase::printState if it has custom data to print.
 388   /// \param Out The output stream
 389   /// \param State The state being printed
 390   /// \param NL The preferred representation of a newline.
 391   /// \param Sep The preferred separator between different kinds of data.
 392   void runCheckersForPrintState(raw_ostream &Out, ProgramStateRef State,
 393                                 const char *NL, const char *Sep);
 394
 395 //===----------------------------------------------------------------------===//
 396 // Internal registration functions for AST traversing.
 397 //===----------------------------------------------------------------------===//
 398
 399   // Functions used by the registration mechanism, checkers should not touch
 400   // these directly.
 401
 402   typedef CheckerFn<void (const Decl *, AnalysisManager&, BugReporter &)>
 403       CheckDeclFunc;
 404
 405   typedef bool (*HandlesDeclFunc)(const Decl *D);
 406   void _registerForDecl(CheckDeclFunc checkfn, HandlesDeclFunc isForDeclFn);
 407
 408   void _registerForBody(CheckDeclFunc checkfn);
 409
 410 //===----------------------------------------------------------------------===//
 411 // Internal registration functions for path-sensitive checking.
 412 //===----------------------------------------------------------------------===//
 413
 414   typedef CheckerFn<void (const Stmt *, CheckerContext &)> CheckStmtFunc;
 415
 416   typedef CheckerFn<void (const ObjCMethodCall &, CheckerContext &)>
 417       CheckObjCMessageFunc;
 418
 419   typedef CheckerFn<void (const CallEvent &, CheckerContext &)>
 420       CheckCallFunc;
 421
 422   typedef CheckerFn<void (const SVal &location, bool isLoad,
 423                           const Stmt *S,
 424                           CheckerContext &)>
 425       CheckLocationFunc;
 426
 427   typedef CheckerFn<void (const SVal &location, const SVal &val,
 428                           const Stmt *S, CheckerContext &)>
 429       CheckBindFunc;
 430
 431   typedef CheckerFn<void (ExplodedGraph &, BugReporter &, ExprEngine &)>
 432       CheckEndAnalysisFunc;
 433
 434   typedef CheckerFn<void (CheckerContext &)>
 435       CheckBeginFunctionFunc;
 436
 437   typedef CheckerFn<void (CheckerContext &)>
 438       CheckEndFunctionFunc;
 439
 440   typedef CheckerFn<void (const Stmt *, CheckerContext &)>
 441       CheckBranchConditionFunc;
 442
 443   typedef CheckerFn<void (SymbolReaper &, CheckerContext &)>
 444       CheckDeadSymbolsFunc;
 445
 446   typedef CheckerFn<void (ProgramStateRef,SymbolReaper &)> CheckLiveSymbolsFunc;
 447
 448   typedef CheckerFn<ProgramStateRef (ProgramStateRef,
 449                                 const InvalidatedSymbols *symbols,
 450                                 ArrayRef<const MemRegion *> ExplicitRegions,
 451                                 ArrayRef<const MemRegion *> Regions,
 452                                 const CallEvent *Call)>
 453       CheckRegionChangesFunc;
 454
 455   typedef CheckerFn<bool (ProgramStateRef)> WantsRegionChangeUpdateFunc;
 456
 457   typedef CheckerFn<ProgramStateRef (ProgramStateRef,
 458                                      const InvalidatedSymbols &Escaped,
 459                                      const CallEvent *Call,
 460                                      PointerEscapeKind Kind,
 461                                      RegionAndSymbolInvalidationTraits *ITraits)>
 462       CheckPointerEscapeFunc;
 463
 464   typedef CheckerFn<ProgramStateRef (ProgramStateRef,
 465                                           const SVal &cond, bool assumption)>
 466       EvalAssumeFunc;
 467
 468   typedef CheckerFn<bool (const CallExpr *, CheckerContext &)>
 469       EvalCallFunc;
 470
 471   typedef CheckerFn<void (const TranslationUnitDecl *,
 472                           AnalysisManager&, BugReporter &)>
 473       CheckEndOfTranslationUnit;
 474
 475   typedef bool (*HandlesStmtFunc)(const Stmt *D);
 476   void _registerForPreStmt(CheckStmtFunc checkfn,
 477                            HandlesStmtFunc isForStmtFn);
 478   void _registerForPostStmt(CheckStmtFunc checkfn,
 479                             HandlesStmtFunc isForStmtFn);
 480
 481   void _registerForPreObjCMessage(CheckObjCMessageFunc checkfn);
 482   void _registerForPostObjCMessage(CheckObjCMessageFunc checkfn);
 483
 484   void _registerForObjCMessageNil(CheckObjCMessageFunc checkfn);
 485
 486   void _registerForPreCall(CheckCallFunc checkfn);
 487   void _registerForPostCall(CheckCallFunc checkfn);
 488
 489   void _registerForLocation(CheckLocationFunc checkfn);
 490
 491   void _registerForBind(CheckBindFunc checkfn);
 492
 493   void _registerForEndAnalysis(CheckEndAnalysisFunc checkfn);
 494
 495   void _registerForBeginFunction(CheckEndFunctionFunc checkfn);
 496   void _registerForEndFunction(CheckEndFunctionFunc checkfn);
 497
 498   void _registerForBranchCondition(CheckBranchConditionFunc checkfn);
 499
 500   void _registerForLiveSymbols(CheckLiveSymbolsFunc checkfn);
 501
 502   void _registerForDeadSymbols(CheckDeadSymbolsFunc checkfn);
 503
 504   void _registerForRegionChanges(CheckRegionChangesFunc checkfn,
 505                                  WantsRegionChangeUpdateFunc wantUpdateFn);
 506
 507   void _registerForPointerEscape(CheckPointerEscapeFunc checkfn);
 508
 509   void _registerForConstPointerEscape(CheckPointerEscapeFunc checkfn);
 510
 511   void _registerForEvalAssume(EvalAssumeFunc checkfn);
 512
 513   void _registerForEvalCall(EvalCallFunc checkfn);
 514
 515   void _registerForEndOfTranslationUnit(CheckEndOfTranslationUnit checkfn);
 516
 517 //===----------------------------------------------------------------------===//
 518 // Internal registration functions for events.
 519 //===----------------------------------------------------------------------===//
 520
 521   typedef void *EventTag;
 522   typedef CheckerFn<void (const void *event)> CheckEventFunc;
 523
 524   template <typename EVENT>
 525   void _registerListenerForEvent(CheckEventFunc checkfn) {
 526     EventInfo &info = Events[getTag<EVENT>()];
 527     info.Checkers.push_back(checkfn);
 528   }
 529
 530   template <typename EVENT>
 531   void _registerDispatcherForEvent() {
 532     EventInfo &info = Events[getTag<EVENT>()];
 533     info.HasDispatcher = true;
 534   }
 535
 536   template <typename EVENT>
 537   void _dispatchEvent(const EVENT &event) const {
 538     EventsTy::const_iterator I = Events.find(getTag<EVENT>());
 539     if (I == Events.end())
 540       return;
 541     const EventInfo &info = I->second;
 542     for (unsigned i = 0, e = info.Checkers.size(); i != e; ++i)
 543       info.Checkers[i](&event);
 544   }
 545
 546 //===----------------------------------------------------------------------===//
 547 // Implementation details.
 548 //===----------------------------------------------------------------------===//
 549
 550 private:
 551   template <typename CHECKER>
 552   static void destruct(void *obj) { delete static_cast<CHECKER *>(obj); }
 553
 554   template <typename T>
 555   static void *getTag() { static int tag; return &tag; }
 556
 557   llvm::DenseMap<CheckerTag, CheckerRef> CheckerTags;
 558
 559   std::vector<CheckerDtor> CheckerDtors;
 560
 561   struct DeclCheckerInfo {
 562     CheckDeclFunc CheckFn;
 563     HandlesDeclFunc IsForDeclFn;
 564   };
 565   std::vector<DeclCheckerInfo> DeclCheckers;
 566
 567   std::vector<CheckDeclFunc> BodyCheckers;
 568
 569   typedef SmallVector<CheckDeclFunc, 4> CachedDeclCheckers;
 570   typedef llvm::DenseMap<unsigned, CachedDeclCheckers> CachedDeclCheckersMapTy;
 571   CachedDeclCheckersMapTy CachedDeclCheckersMap;
 572
 573   struct StmtCheckerInfo {
 574     CheckStmtFunc CheckFn;
 575     HandlesStmtFunc IsForStmtFn;
 576     bool IsPreVisit;
 577   };
 578   std::vector<StmtCheckerInfo> StmtCheckers;
 579
 580   typedef SmallVector<CheckStmtFunc, 4> CachedStmtCheckers;
 581   typedef llvm::DenseMap<unsigned, CachedStmtCheckers> CachedStmtCheckersMapTy;
 582   CachedStmtCheckersMapTy CachedStmtCheckersMap;
 583
 584   const CachedStmtCheckers &getCachedStmtCheckersFor(const Stmt *S,
 585                                                      bool isPreVisit);
 586
 587   /// Returns the checkers that have registered for callbacks of the
 588   /// given \p Kind.
 589   const std::vector<CheckObjCMessageFunc> &
 590   getObjCMessageCheckers(ObjCMessageVisitKind Kind);
 591
 592   std::vector<CheckObjCMessageFunc> PreObjCMessageCheckers;
 593   std::vector<CheckObjCMessageFunc> PostObjCMessageCheckers;
 594   std::vector<CheckObjCMessageFunc> ObjCMessageNilCheckers;
 595
 596   std::vector<CheckCallFunc> PreCallCheckers;
 597   std::vector<CheckCallFunc> PostCallCheckers;
 598
 599   std::vector<CheckLocationFunc> LocationCheckers;
 600
 601   std::vector<CheckBindFunc> BindCheckers;
 602
 603   std::vector<CheckEndAnalysisFunc> EndAnalysisCheckers;
 604
 605   std::vector<CheckBeginFunctionFunc> BeginFunctionCheckers;
 606   std::vector<CheckEndFunctionFunc> EndFunctionCheckers;
 607
 608   std::vector<CheckBranchConditionFunc> BranchConditionCheckers;
 609
 610   std::vector<CheckLiveSymbolsFunc> LiveSymbolsCheckers;
 611
 612   std::vector<CheckDeadSymbolsFunc> DeadSymbolsCheckers;
 613
 614   struct RegionChangesCheckerInfo {
 615     CheckRegionChangesFunc CheckFn;
 616     WantsRegionChangeUpdateFunc WantUpdateFn;
 617   };
 618   std::vector<RegionChangesCheckerInfo> RegionChangesCheckers;
 619
 620   std::vector<CheckPointerEscapeFunc> PointerEscapeCheckers;
 621
 622   std::vector<EvalAssumeFunc> EvalAssumeCheckers;
 623
 624   std::vector<EvalCallFunc> EvalCallCheckers;
 625
 626   std::vector<CheckEndOfTranslationUnit> EndOfTranslationUnitCheckers;
 627
 628   struct EventInfo {
 629     SmallVector<CheckEventFunc, 4> Checkers;
 630     bool HasDispatcher;
 631     EventInfo() : HasDispatcher(false) { }
 632   };
 633
 634   typedef llvm::DenseMap<EventTag, EventInfo> EventsTy;
 635   EventsTy Events;
 636 };
 637
 638 } // end ento namespace
 639
 640 } // end clang namespace
 641
 642 #endif