Lines Matching refs:Pred
289 void ExprEngine::processCFGElement(const CFGElement E, ExplodedNode *Pred,
291 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
297 ProcessStmt(const_cast<Stmt*>(E.castAs<CFGStmt>().getStmt()), Pred);
300 ProcessInitializer(E.castAs<CFGInitializer>().getInitializer(), Pred);
304 Pred);
311 ProcessImplicitDtor(E.castAs<CFGImplicitDtor>(), Pred);
318 const ExplodedNode *Pred,
326 if (Pred->getLocation().getAs<BlockEntrance>())
343 void ExprEngine::removeDead(ExplodedNode *Pred, ExplodedNodeSet &Out,
359 ProgramStateRef CleanedState = Pred->getState();
387 StmtNodeBuilder Bldr(Pred, Out, *currBldrCtx);
388 Bldr.generateNode(DiagnosticStmt, Pred, CleanedState, &cleanupTag, K);
394 getCheckerManager().runCheckersForDeadSymbols(CheckedSet, Pred, SymReaper,
409 assert(StateMgr.haveEqualEnvironments(CheckerState, Pred->getState()) &&
412 assert(StateMgr.haveEqualStores(CheckerState, Pred->getState()) &&
426 ExplodedNode *Pred) {
437 if (shouldRemoveDeadBindings(AMgr, S, Pred, Pred->getLocationContext())){
438 removeDead(Pred, CleanedStates, currStmt, Pred->getLocationContext());
440 CleanedStates.Add(Pred);
457 ExplodedNode *Pred) {
466 cast<StackFrameContext>(Pred->getLocationContext());
470 ProgramStateRef State = Pred->getState();
473 ExplodedNodeSet Tmp(Pred);
519 assert(*Tmp.begin() == Pred && "have not generated any new nodes yet");
523 evalBind(Tmp, Init, Pred, FieldLoc, InitVal, /*isInit=*/true, &PP);
545 ExplodedNode *Pred) {
549 ProcessAutomaticObjDtor(D.castAs<CFGAutomaticObjDtor>(), Pred, Dst);
552 ProcessBaseDtor(D.castAs<CFGBaseDtor>(), Pred, Dst);
555 ProcessMemberDtor(D.castAs<CFGMemberDtor>(), Pred, Dst);
558 ProcessTemporaryDtor(D.castAs<CFGTemporaryDtor>(), Pred, Dst);
561 ProcessDeleteDtor(D.castAs<CFGDeleteDtor>(), Pred, Dst);
572 ExplodedNode *Pred) {
580 VisitCXXNewAllocatorCall(NE, Pred, Dst);
582 NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
583 const LocationContext *LCtx = Pred->getLocationContext();
585 Bldr.generateNode(PP, Pred->getState(), Pred);
591 ExplodedNode *Pred,
596 ProgramStateRef state = Pred->getState();
597 SVal dest = state->getLValue(varDecl, Pred->getLocationContext());
606 Pred, Dst);
610 ExplodedNode *Pred,
612 ProgramStateRef State = Pred->getState();
613 const LocationContext *LCtx = Pred->getLocationContext();
627 NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
628 Bldr.generateNode(PP, Pred->getState(), Pred);
635 Pred, Dst);
639 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
640 const LocationContext *LCtx = Pred->getLocationContext();
645 SVal ThisVal = Pred->getState()->getSVal(ThisPtr);
654 CurDtor->getBody(), /*IsBase=*/ true, Pred, Dst);
658 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
660 ProgramStateRef State = Pred->getState();
661 const LocationContext *LCtx = Pred->getLocationContext();
671 CurDtor->getBody(), /*IsBase=*/false, Pred, Dst);
675 ExplodedNode *Pred,
678 StmtNodeBuilder StmtBldr(Pred, CleanDtorState, *currBldrCtx);
679 ProgramStateRef State = Pred->getState();
681 std::make_pair(D.getBindTemporaryExpr(), Pred->getStackFrame()))) {
685 std::make_pair(D.getBindTemporaryExpr(), Pred->getStackFrame()));
687 StmtBldr.generateNode(D.getBindTemporaryExpr(), Pred, State);
694 CleanDtorState.empty() ? Pred : *CleanDtorState.begin();
703 ExplodedNode *Pred,
707 BranchNodeBuilder TempDtorBuilder(Pred, Dst, BldCtx, DstT, DstF);
708 if (Pred->getState()->contains<InitializedTemporariesSet>(
709 std::make_pair(BTE, Pred->getStackFrame()))) {
711 TempDtorBuilder.generateNode(Pred->getState(), true, Pred);
714 TempDtorBuilder.generateNode(Pred->getState(), false, Pred);
744 void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
750 StmtNodeBuilder Bldr(Pred, DstTop, *currBldrCtx);
784 const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
858 ProgramStateRef state = Pred->getState();
859 state = state->BindExpr(S, Pred->getLocationContext(),
861 Bldr.generateNode(S, Pred, state);
866 Bldr.takeNodes(Pred);
867 VisitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(S), Pred, Dst);
876 Bldr.takeNodes(Pred);
878 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
929 Bldr.takeNodes(Pred);
931 getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
939 Bldr.takeNodes(Pred);
941 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
965 const LocationContext *LCtx = Pred->getLocationContext();
987 Bldr.takeNodes(Pred);
990 getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
1015 Bldr.takeNodes(Pred);
1016 VisitLvalArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Pred, Dst);
1021 Bldr.takeNodes(Pred);
1022 VisitGCCAsmStmt(cast<GCCAsmStmt>(S), Pred, Dst);
1027 Bldr.takeNodes(Pred);
1028 VisitMSAsmStmt(cast<MSAsmStmt>(S), Pred, Dst);
1033 Bldr.takeNodes(Pred);
1034 VisitBlockExpr(cast<BlockExpr>(S), Pred, Dst);
1040 Bldr.takeNodes(Pred);
1041 VisitLambdaExpr(cast<LambdaExpr>(S), Pred, Dst);
1044 const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
1052 Bldr.takeNodes(Pred);
1053 VisitLogicalExpr(B, Pred, Dst);
1058 ProgramStateRef state = Pred->getState();
1059 Bldr.generateNode(B, Pred,
1060 state->BindExpr(B, Pred->getLocationContext(),
1062 Pred->getLocationContext())));
1066 Bldr.takeNodes(Pred);
1071 VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
1075 VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
1089 ProgramStateRef State = Pred->getState();
1090 const LocationContext *LCtx = Pred->getLocationContext();
1094 Pred = Bldr.generateNode(OCE, Pred, NewState, /*Tag=*/nullptr,
1097 if (!Pred)
1107 Bldr.takeNodes(Pred);
1108 VisitCallExpr(cast<CallExpr>(S), Pred, Dst);
1114 Bldr.takeNodes(Pred);
1115 VisitCXXCatchStmt(cast<CXXCatchStmt>(S), Pred, Dst);
1122 Bldr.takeNodes(Pred);
1123 VisitCXXConstructExpr(cast<CXXConstructExpr>(S), Pred, Dst);
1129 Bldr.takeNodes(Pred);
1131 VisitCXXNewExpr(cast<CXXNewExpr>(S), Pred, PostVisit);
1138 Bldr.takeNodes(Pred);
1141 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
1154 Bldr.takeNodes(Pred);
1156 VisitGuardedExpr(C, C->getLHS(), C->getRHS(), Pred, Dst);
1162 Bldr.takeNodes(Pred);
1163 VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
1168 Bldr.takeNodes(Pred);
1169 VisitCompoundLiteralExpr(cast<CompoundLiteralExpr>(S), Pred, Dst);
1175 Bldr.takeNodes(Pred);
1178 VisitGuardedExpr(C, C->getTrueExpr(), C->getFalseExpr(), Pred, Dst);
1184 Bldr.takeNodes(Pred);
1185 VisitCXXThisExpr(cast<CXXThisExpr>(S), Pred, Dst);
1190 Bldr.takeNodes(Pred);
1192 VisitCommonDeclRefExpr(DE, DE->getDecl(), Pred, Dst);
1198 Bldr.takeNodes(Pred);
1199 VisitDeclStmt(cast<DeclStmt>(S), Pred, Dst);
1211 Bldr.takeNodes(Pred);
1215 getCheckerManager().runCheckersForPreStmt(dstPrevisit, Pred, C, *this);
1231 Bldr.takeNodes(Pred);
1233 CreateCXXTemporaryObject(MTE, Pred, Dst);
1239 Bldr.takeNodes(Pred);
1240 VisitInitListExpr(cast<InitListExpr>(S), Pred, Dst);
1245 Bldr.takeNodes(Pred);
1246 VisitMemberExpr(cast<MemberExpr>(S), Pred, Dst);
1251 Bldr.takeNodes(Pred);
1252 VisitAtomicExpr(cast<AtomicExpr>(S), Pred, Dst);
1257 Bldr.takeNodes(Pred);
1258 VisitLvalObjCIvarRefExpr(cast<ObjCIvarRefExpr>(S), Pred, Dst);
1263 Bldr.takeNodes(Pred);
1264 VisitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(S), Pred, Dst);
1269 Bldr.takeNodes(Pred);
1270 VisitObjCMessage(cast<ObjCMessageExpr>(S), Pred, Dst);
1278 Bldr.generateSink(S, Pred, Pred->getState());
1282 Bldr.takeNodes(Pred);
1283 VisitReturnStmt(cast<ReturnStmt>(S), Pred, Dst);
1288 Bldr.takeNodes(Pred);
1289 VisitOffsetOfExpr(cast<OffsetOfExpr>(S), Pred, Dst);
1294 Bldr.takeNodes(Pred);
1296 Pred, Dst);
1311 ProgramStateRef state = Pred->getState();
1312 Bldr.generateNode(SE, Pred,
1313 state->BindExpr(SE, Pred->getLocationContext(),
1315 Pred->getLocationContext())));
1321 Bldr.takeNodes(Pred);
1325 VisitUnaryOperator(U, Pred, Tmp);
1329 VisitUnaryOperator(U, Pred, Dst);
1335 Bldr.takeNodes(Pred);
1336 ProgramStateRef state = Pred->getState();
1339 SVal V = state->getSVal(Result, Pred->getLocationContext());
1340 Bldr.generateNode(S, Pred,
1341 state->BindExpr(S, Pred->getLocationContext(), V));
1344 Bldr.generateNode(S, Pred,
1345 state->BindExpr(S, Pred->getLocationContext(),
1420 ExplodedNode *Pred) {
1421 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1433 const LocationContext *LCtx = Pred->getLocationContext();
1435 getWidenedLoopState(Pred->getState(), LCtx, BlockCount, Term);
1436 nodeBuilder.generateNode(WidenedState, Pred);
1444 nodeBuilder.generateSink(Pred->getState(), Pred, &tag);
1448 const LocationContext *CalleeLC = Pred->getLocation().getLocationContext();
1460 replayWithoutInlining(Pred, CalleeLC)))
1580 ExplodedNode *Pred,
1586 const LocationContext *LCtx = Pred->getLocationContext();
1592 BranchNodeBuilder NullCondBldr(Pred, Dst, BldCtx, DstT, DstF);
1594 NullCondBldr.generateNode(Pred->getState(), true, Pred);
1608 Pred, *this);
1682 ExplodedNode *Pred,
1686 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1690 ProgramStateRef state = Pred->getState();
1692 BranchNodeBuilder builder(Pred, Dst, BuilderCtx, DstT, DstF);
1698 builder.generateNode(state, initHasRun, Pred);
1749 static bool stackFrameDoesNotContainInitializedTemporaries(ExplodedNode &Pred) {
1750 const StackFrameContext* Frame = Pred.getStackFrame();
1752 Pred.getState()->get<InitializedTemporariesSet>();
1765 ExplodedNode *Pred,
1769 getCheckerManager().runCheckersForBeginFunction(Dst, L, Pred, *this);
1775 ExplodedNode *Pred) {
1776 // FIXME: Assert that stackFrameDoesNotContainInitializedTemporaries(*Pred)).
1779 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1780 StateMgr.EndPath(Pred->getState());
1783 if (Pred->getLocationContext()->inTopFrame()) {
1786 removeDeadOnEndOfFunction(BC, Pred, AfterRemovedDead);
1794 getCheckerManager().runCheckersForEndFunction(BC, Dst, Pred, *this);
1885 ExplodedNode *Pred,
1887 StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
1889 ProgramStateRef state = Pred->getState();
1890 const LocationContext *LCtx = Pred->getLocationContext();
1896 const LocationContext *LocCtxt = Pred->getLocationContext();
1938 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
1945 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V));
1950 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
1961 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
1971 ExplodedNode *Pred,
1978 getCheckerManager().runCheckersForPreStmt(checkerPreStmt, Pred, A, *this);
1998 void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred,
2003 getCheckerManager().runCheckersForPreStmt(CheckedSet, Pred, M, *this);
2014 VisitCommonDeclRefExpr(M, Member, Pred, EvalSet);
2079 void ExprEngine::VisitAtomicExpr(const AtomicExpr *AE, ExplodedNode *Pred,
2082 getCheckerManager().runCheckersForPreStmt(AfterPreSet, Pred, AE, *this);
2229 ExplodedNode *Pred,
2233 const LocationContext *LC = Pred->getLocationContext();
2240 getCheckerManager().runCheckersForBind(CheckedSet, Pred, location, Val,
2250 ProgramStateRef state = Pred->getState();
2252 Bldr.generateNode(L, state, Pred);
2290 ExplodedNode *Pred,
2299 evalLocation(Tmp, AssignE, LocationE, Pred, state, location, tag, false);
2314 ExplodedNode *Pred,
2333 evalLoadCommon(Tmp, NodeEx, BoundEx, Pred, state,
2347 evalLoadCommon(Dst, NodeEx, BoundEx, Pred, state, location, tag, LoadTy);
2353 ExplodedNode *Pred,
2362 evalLocation(Tmp, NodeEx, BoundEx, Pred, state, location, tag, true);
2390 ExplodedNode *Pred,
2395 StmtNodeBuilder BldrTop(Pred, Dst, *currBldrCtx);
2402 BldrTop.takeNodes(Pred);
2403 StmtNodeBuilder Bldr(Pred, Src, *currBldrCtx);
2404 if (Pred->getState() != state) {
2415 Bldr.generateNode(NodeEx, Pred, state, &tag);
2440 ExplodedNode *Pred = *I;
2444 ProgramPoint P = Pred->getLocation();
2449 ProgramStateRef state = Pred->getState();
2450 SVal V = state->getSVal(Ex, Pred->getLocationContext());
2462 StateTrue = StateTrue->BindExpr(Ex, Pred->getLocationContext(), Val);
2463 Bldr.generateNode(Ex, Pred, StateTrue, tags.first);
2469 StateFalse = StateFalse->BindExpr(Ex, Pred->getLocationContext(), Val);
2470 Bldr.generateNode(Ex, Pred, StateFalse, tags.second);
2476 void ExprEngine::VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred,
2478 StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
2486 ProgramStateRef state = Pred->getState();
2489 SVal X = state->getSVal(O, Pred->getLocationContext());
2496 Bldr.generateNode(A, Pred, state);
2499 void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
2501 StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
2502 Bldr.generateNode(A, Pred, Pred->getState());