StaticAnalyzer/Core/CoreEngine.cpp

154 void CoreEngine::dispatchWorkItem(ExplodedNode* Pred, ProgramPoint Loc,
159       HandleBlockEdge(Loc.castAs<BlockEdge>(), Pred);
163       HandleBlockEntrance(Loc.castAs<BlockEntrance>(), Pred);
171       HandleCallEnter(Loc.castAs<CallEnter>(), Pred);
175       SubEng.processCallExit(Pred);
179       assert(Pred->hasSinglePred() &&
181       ExplodedNode *PNode = Pred->getFirstPred();
182       dispatchWorkItem(Pred, PNode->getLocation(), WU);
192       HandlePostStmt(WU.getBlock(), WU.getIndex(), Pred);
209 void CoreEngine::HandleBlockEdge(const BlockEdge &L, ExplodedNode *Pred) {
211   NodeBuilderContext BuilderCtx(*this, Blk, Pred);
214   const LocationContext *LC = Pred->getLocationContext();
232     NodeBuilder Bldr(Pred, Dst, BuilderCtx);
233     Pred = Bldr.generateNode(P, Pred->getState(), Pred);
234     if (!Pred)
256     SubEng.processEndOfFunction(BuilderCtx, Pred, RS);
264   BlockEntrance BE(Blk, Pred->getLocationContext());
265   NodeBuilderWithSinks nodeBuilder(Pred, dstNodes, BuilderCtx, BE);
266   SubEng.processCFGBlockEntrance(L, nodeBuilder, Pred);
270     nodeBuilder.generateNode(Pred->State, Pred);
278                                        ExplodedNode *Pred) {
280   const LocationContext *LC = Pred->getLocationContext();
289     NodeBuilderContext Ctx(*this, L.getBlock(), Pred);
290     SubEng.processCFGElement(*E, Pred, 0, &Ctx);
293     HandleBlockExit(L.getBlock(), Pred);
296 void CoreEngine::HandleBlockExit(const CFGBlock * B, ExplodedNode *Pred) {
304             cast<CXXBindTemporaryExpr>(Term), B, Pred);
309         HandleStaticInit(cast<DeclStmt>(Term), B, Pred);
313         HandleBranch(cast<BinaryOperator>(Term)->getLHS(), Term, B, Pred);
319                      Term, B, Pred);
326         HandleBranch(cast<ChooseExpr>(Term)->getCond(), Term, B, Pred);
335             generateNode(BlockEdge(B, succ, Pred->getLocationContext()),
336                          Pred->State, Pred);
342         HandleBranch(cast<DoStmt>(Term)->getCond(), Term, B, Pred);
346         HandleBranch(cast<CXXForRangeStmt>(Term)->getCond(), Term, B, Pred);
350         HandleBranch(cast<ForStmt>(Term)->getCond(), Term, B, Pred);
359         HandleBranch(cast<IfStmt>(Term)->getCond(), Term, B, Pred);
367            builder(Pred, B, cast<IndirectGotoStmt>(Term)->getTarget(),
385         HandleBranch(Term, Term, B, Pred);
389         SwitchNodeBuilder builder(Pred, B, cast<SwitchStmt>(Term)->getCond(),
397         HandleBranch(cast<WhileStmt>(Term)->getCond(), Term, B, Pred);
408     HandleVirtualBaseBranch(B, Pred);
415   generateNode(BlockEdge(B, *(B->succ_begin()), Pred->getLocationContext()),
416                Pred->State, Pred);
419 void CoreEngine::HandleCallEnter(const CallEnter &CE, ExplodedNode *Pred) {
420   NodeBuilderContext BuilderCtx(*this, CE.getEntry(), Pred);
421   SubEng.processCallEnter(BuilderCtx, CE, Pred);
425                                 const CFGBlock * B, ExplodedNode *Pred) {
427   NodeBuilderContext Ctx(*this, B, Pred);
429   SubEng.processBranch(Cond, Ctx, Pred, Dst, *(B->succ_begin()),
437                                               ExplodedNode *Pred) {
439   NodeBuilderContext Ctx(*this, B, Pred);
441   SubEng.processCleanupTemporaryBranch(BTE, Ctx, Pred, Dst, *(B->succ_begin()),
448                                   ExplodedNode *Pred) {
450   NodeBuilderContext Ctx(*this, B, Pred);
452   SubEng.processStaticInitializer(DS, Ctx, Pred, Dst,
459                                 ExplodedNode *Pred) {
464     HandleBlockExit(B, Pred);
466     NodeBuilderContext Ctx(*this, B, Pred);
467     SubEng.processCFGElement((*B)[StmtIdx], Pred, StmtIdx, &Ctx);
472                                          ExplodedNode *Pred) {
473   const LocationContext *LCtx = Pred->getLocationContext();
480       HandleBlockEdge(Loc, Pred);
491   HandleBlockEdge(Loc, Pred);
498                               ExplodedNode *Pred) {
502   if (Pred)
503     Node->addPredecessor(Pred, G); // Link 'Node' with its predecessor.
653       Eng.G.getNode(BlockEdge(Src, I.getBlock(), Pred->getLocationContext()),
655   Succ->addPredecessor(Pred, Eng.G);
671       Eng.G.getNode(BlockEdge(Src, I.getBlock(), Pred->getLocationContext()),
673   Succ->addPredecessor(Pred, Eng.G);
695       Eng.G.getNode(BlockEdge(Src, DefaultBlock, Pred->getLocationContext()),
697   Succ->addPredecessor(Pred, Eng.G);