CheckerManager.cpp revision 42e95acef35f4633119be1c1381e88878c966502
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 21using namespace clang; 22using namespace ento; 23 24bool 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 42void 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 56void 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 81void 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 93template <typename CHECK_CTX> 94static 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 135namespace { 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. 166void 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 177namespace { 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. 205void 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 218namespace { 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. 248void 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 261namespace { 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 297void 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 308namespace { 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. 337void 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 346void 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. 356void CheckerManager::runCheckersForEndPath(NodeBuilderContext &BC, 357 ExplodedNodeSet &Dst, 358 ExprEngine &Eng) { 359 ExplodedNode *Pred = BC.Pred; 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 376namespace { 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. 401void 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. 412void 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 418namespace { 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. 450void 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. 461bool 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. 470ProgramStateRef 471CheckerManager::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. 488ProgramStateRef 489CheckerManager::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. 503void 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. 550void 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 558void 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 570void CheckerManager::_registerForDecl(CheckDeclFunc checkfn, 571 HandlesDeclFunc isForDeclFn) { 572 DeclCheckerInfo info = { checkfn, isForDeclFn }; 573 DeclCheckers.push_back(info); 574} 575 576void CheckerManager::_registerForBody(CheckDeclFunc checkfn) { 577 BodyCheckers.push_back(checkfn); 578} 579 580//===----------------------------------------------------------------------===// 581// Internal registration functions for path-sensitive checking. 582//===----------------------------------------------------------------------===// 583 584void CheckerManager::_registerForPreStmt(CheckStmtFunc checkfn, 585 HandlesStmtFunc isForStmtFn) { 586 StmtCheckerInfo info = { checkfn, isForStmtFn, /*IsPreVisit*/true }; 587 StmtCheckers.push_back(info); 588} 589void CheckerManager::_registerForPostStmt(CheckStmtFunc checkfn, 590 HandlesStmtFunc isForStmtFn) { 591 StmtCheckerInfo info = { checkfn, isForStmtFn, /*IsPreVisit*/false }; 592 StmtCheckers.push_back(info); 593} 594 595void CheckerManager::_registerForPreObjCMessage(CheckObjCMessageFunc checkfn) { 596 PreObjCMessageCheckers.push_back(checkfn); 597} 598void CheckerManager::_registerForPostObjCMessage(CheckObjCMessageFunc checkfn) { 599 PostObjCMessageCheckers.push_back(checkfn); 600} 601 602void CheckerManager::_registerForPreCall(CheckCallFunc checkfn) { 603 PreCallCheckers.push_back(checkfn); 604} 605void CheckerManager::_registerForPostCall(CheckCallFunc checkfn) { 606 PostCallCheckers.push_back(checkfn); 607} 608 609void CheckerManager::_registerForLocation(CheckLocationFunc checkfn) { 610 LocationCheckers.push_back(checkfn); 611} 612 613void CheckerManager::_registerForBind(CheckBindFunc checkfn) { 614 BindCheckers.push_back(checkfn); 615} 616 617void CheckerManager::_registerForEndAnalysis(CheckEndAnalysisFunc checkfn) { 618 EndAnalysisCheckers.push_back(checkfn); 619} 620 621void CheckerManager::_registerForEndPath(CheckEndPathFunc checkfn) { 622 EndPathCheckers.push_back(checkfn); 623} 624 625void CheckerManager::_registerForBranchCondition( 626 CheckBranchConditionFunc checkfn) { 627 BranchConditionCheckers.push_back(checkfn); 628} 629 630void CheckerManager::_registerForLiveSymbols(CheckLiveSymbolsFunc checkfn) { 631 LiveSymbolsCheckers.push_back(checkfn); 632} 633 634void CheckerManager::_registerForDeadSymbols(CheckDeadSymbolsFunc checkfn) { 635 DeadSymbolsCheckers.push_back(checkfn); 636} 637 638void CheckerManager::_registerForRegionChanges(CheckRegionChangesFunc checkfn, 639 WantsRegionChangeUpdateFunc wantUpdateFn) { 640 RegionChangesCheckerInfo info = {checkfn, wantUpdateFn}; 641 RegionChangesCheckers.push_back(info); 642} 643 644void CheckerManager::_registerForEvalAssume(EvalAssumeFunc checkfn) { 645 EvalAssumeCheckers.push_back(checkfn); 646} 647 648void CheckerManager::_registerForEvalCall(EvalCallFunc checkfn) { 649 EvalCallCheckers.push_back(checkfn); 650} 651 652void CheckerManager::_registerForEndOfTranslationUnit( 653 CheckEndOfTranslationUnit checkfn) { 654 EndOfTranslationUnitCheckers.push_back(checkfn); 655} 656 657//===----------------------------------------------------------------------===// 658// Implementation details. 659//===----------------------------------------------------------------------===// 660 661CheckerManager::CachedStmtCheckers * 662CheckerManager::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 684CheckerManager::~CheckerManager() { 685 for (unsigned i = 0, e = CheckerDtors.size(); i != e; ++i) 686 CheckerDtors[i](); 687} 688