StaticAnalyzer/Core/CoreEngine.cpp

229 void CoreEngine::dispatchWorkItem(ExplodedNode* Pred, ProgramPoint Loc,
234       HandleBlockEdge(Loc.castAs<BlockEdge>(), Pred);
238       HandleBlockEntrance(Loc.castAs<BlockEntrance>(), Pred);
247       SubEng.processCallEnter(CEnter, Pred);
252       SubEng.processCallExit(Pred);
256       assert(Pred->hasSinglePred() &&
258       ExplodedNode *PNode = Pred->getFirstPred();
259       dispatchWorkItem(Pred, PNode->getLocation(), WU);
267       HandlePostStmt(WU.getBlock(), WU.getIndex(), Pred);
284 void CoreEngine::HandleBlockEdge(const BlockEdge &L, ExplodedNode *Pred) {
287   NodeBuilderContext BuilderCtx(*this, Blk, Pred);
290   const LocationContext *LC = Pred->getLocationContext();
302     SubEng.processEndOfFunction(BuilderCtx, Pred);
310   BlockEntrance BE(Blk, Pred->getLocationContext());
311   NodeBuilderWithSinks nodeBuilder(Pred, dstNodes, BuilderCtx, BE);
312   SubEng.processCFGBlockEntrance(L, nodeBuilder, Pred);
316     nodeBuilder.generateNode(Pred->State, Pred);
324                                        ExplodedNode *Pred) {
327   const LocationContext *LC = Pred->getLocationContext();
336     NodeBuilderContext Ctx(*this, L.getBlock(), Pred);
337     SubEng.processCFGElement(*E, Pred, 0, &Ctx);
340     HandleBlockExit(L.getBlock(), Pred);
343 void CoreEngine::HandleBlockExit(const CFGBlock * B, ExplodedNode *Pred) {
352             cast<CXXBindTemporaryExpr>(B->getTerminator().getStmt()), B, Pred);
357         HandleStaticInit(cast<DeclStmt>(Term), B, Pred);
361         HandleBranch(cast<BinaryOperator>(Term)->getLHS(), Term, B, Pred);
367                      Term, B, Pred);
374         HandleBranch(cast<ChooseExpr>(Term)->getCond(), Term, B, Pred);
383             generateNode(BlockEdge(B, succ, Pred->getLocationContext()),
384                          Pred->State, Pred);
391         HandleBranch(cast<DoStmt>(Term)->getCond(), Term, B, Pred);
395         HandleBranch(cast<CXXForRangeStmt>(Term)->getCond(), Term, B, Pred);
399         HandleBranch(cast<ForStmt>(Term)->getCond(), Term, B, Pred);
408         HandleBranch(cast<IfStmt>(Term)->getCond(), Term, B, Pred);
416            builder(Pred, B, cast<IndirectGotoStmt>(Term)->getTarget(),
434         HandleBranch(Term, Term, B, Pred);
439         SwitchNodeBuilder builder(Pred, B, cast<SwitchStmt>(Term)->getCond(),
447         HandleBranch(cast<WhileStmt>(Term)->getCond(), Term, B, Pred);
455   generateNode(BlockEdge(B, *(B->succ_begin()), Pred->getLocationContext()),
456                Pred->State, Pred);
460                                 const CFGBlock * B, ExplodedNode *Pred) {
462   NodeBuilderContext Ctx(*this, B, Pred);
464   SubEng.processBranch(Cond, Term, Ctx, Pred, Dst,
472                                               ExplodedNode *Pred) {
474   NodeBuilderContext Ctx(*this, B, Pred);
476   SubEng.processCleanupTemporaryBranch(BTE, Ctx, Pred, Dst, *(B->succ_begin()),
483                                   ExplodedNode *Pred) {
485   NodeBuilderContext Ctx(*this, B, Pred);
487   SubEng.processStaticInitializer(DS, Ctx, Pred, Dst,
495                                   ExplodedNode *Pred) {
500     HandleBlockExit(B, Pred);
502     NodeBuilderContext Ctx(*this, B, Pred);
503     SubEng.processCFGElement((*B)[StmtIdx], Pred, StmtIdx, &Ctx);
511                               ExplodedNode *Pred) {
516   if (Pred)
517     Node->addPredecessor(Pred, G); // Link 'Node' with its predecessor.
674       Eng.G.getNode(BlockEdge(Src, I.getBlock(), Pred->getLocationContext()),
676   Succ->addPredecessor(Pred, Eng.G);
694       Eng.G.getNode(BlockEdge(Src, I.getBlock(), Pred->getLocationContext()),
696   Succ->addPredecessor(Pred, Eng.G);
719       Eng.G.getNode(BlockEdge(Src, DefaultBlock, Pred->getLocationContext()),
721   Succ->addPredecessor(Pred, Eng.G);