StaticAnalyzer/Core/ExprEngineC.cpp

56     ProgramStateRef state = (*it)->getState();
58     SVal LeftV = state->getSVal(LHS, LCtx);
59     SVal RightV = state->getSVal(RHS, LCtx);
74       evalStore(Tmp2, B, LHS, *it, state->BindExpr(B, LCtx, ExprVal),
96         state = createTemporaryRegionIfNeeded(state, LCtx, LHS);
100       SVal Result = evalBinOp(state, Op, LeftV, RightV, B->getType());
102         state = state->BindExpr(B, LCtx, Result);
105         state = escapeValues(state, LeftV, PSK_EscapeOther);
106         state = escapeValues(state, RightV, PSK_EscapeOther);
109       Bldr.generateNode(B, *it, state);
134     evalLoad(Tmp, B, LHS, *it, state, location);
139       state = (*I)->getState();
141       SVal V = state->getSVal(LHS, LCtx);
158       SVal Result = svalBuilder.evalCast(evalBinOp(state, Op, V, RightV, CTy),
184         state = state->BindExpr(B, LCtx, location);
186         state = state->BindExpr(B, LCtx, Result);
188       evalStore(Tmp2, B, LHS, *I, state, location, LHSVal);
260     ProgramStateRef state, const Expr* Ex, const LocationContext* LCtx,
271   SVal OrigV = state->getSVal(Ex, LCtx);
276   state = state->BindExpr(CastE, LCtx, V);
278     state = escapeValues(state, OrigV, PSK_EscapeOther);
280   Bldr.generateNode(CastE, Pred, state);
282   return state;
286     ProgramStateRef state, const LocationContext* LCtx, const CastExpr* CastE,
295   state = state->BindExpr(CastE, LCtx, result);
296   Bldr.generateNode(CastE, Pred, state);
298   return state;
311       ProgramStateRef state = subExprNode->getState();
313       evalLoad(Dst, CastE, CastE, subExprNode, state, state->getSVal(Ex, LCtx));
330     ProgramStateRef state = Pred->getState();
357         ProgramStateRef state = Pred->getState();
359         SVal V = state->getSVal(Ex, LCtx);
360         state = state->BindExpr(CastE, LCtx, V);
361         Bldr.generateNode(CastE, Pred, state);
366         SVal V = state->getSVal(Ex, LCtx);
371           state = state->BindExpr(CastE, LCtx, V);
372           Bldr.generateNode(CastE, Pred, state);
376         state =
377             handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
388         SVal V = state->getSVal(Ex, LCtx);
390           state = state->BindExpr(CastE, LCtx, UnknownVal());
391           Bldr.generateNode(CastE, Pred, state);
395         state =
396             handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
425         state =
426             handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
431         SVal V = state->getSVal(Ex, LCtx);
432         V = svalBuilder.evalIntegralCast(state, V, T, ExTy);
433         state = state->BindExpr(CastE, LCtx, V);
434         Bldr.generateNode(CastE, Pred, state);
440         SVal val = state->getSVal(Ex, LCtx);
442         state = state->BindExpr(CastE, LCtx, val);
443         Bldr.generateNode(CastE, Pred, state);
448         SVal val = state->getSVal(Ex, LCtx);
468             Bldr.generateSink(CastE, Pred, state);
472             state = state->BindExpr(CastE, LCtx, svalBuilder.makeNull());
480             state = state->BindExpr(CastE, LCtx, NewSym);
483             state = state->BindExpr(CastE, LCtx, val);
485         Bldr.generateNode(CastE, Pred, state);
489         SVal val = state->getSVal(Ex, LCtx);
506         state = state->BindExpr(CastE, LCtx, val);
507         Bldr.generateNode(CastE, Pred, state);
512         state = state->BindExpr(CastE, LCtx, V);
513         Bldr.generateNode(CastE, Pred, state);
518         state = state->BindExpr(CastE, LCtx, V);
519         Bldr.generateNode(CastE, Pred, state);
525         SVal V = state->getSVal(Ex, LCtx);
531           state = state->BindExpr(CastE, LCtx, CastedPTMSV);
532           Bldr.generateNode(CastE, Pred, state);
536         state = handleLVectorSplat(state, LCtx, CastE, Bldr, Pred);
542         state = handleLVectorSplat(state, LCtx, CastE, Bldr, Pred);
594     ProgramStateRef state = N->getState();
600       // Note in the state that the initialization has occurred.
602       SVal InitVal = state->getSVal(InitEx, LC);
605       if (getObjectUnderConstruction(state, DS, LC)) {
606         state = finishObjectConstruction(state, DS, LC);
609         B.generateNode(DS, UpdatedN, state);
626         evalBind(Dst2, DS, UpdatedN, state->getLValue(VD, LC), InitVal, true);
631       B.generateNode(DS, N, state);
642   // It doesn't produce any state splits.
659   ProgramStateRef state = Pred->getState();
667     Bldr.generateNode(B, Pred, state);
678       Bldr.generateNode(B, Pred, state);
686     Bldr.generateNode(B, Pred, state);
729   Bldr.generateNode(B, Pred, state->BindExpr(B, Pred->getLocationContext(), X));
737   ProgramStateRef state = Pred->getState();
751       B.generateNode(IE, Pred, state->BindExpr(IE, LCtx, V));
757       SVal V = state->getSVal(cast<Expr>(*it), LCtx);
762                    state->BindExpr(IE, LCtx,
776     V = state->getSVal(IE->getInit(0), LCtx);
778   B.generateNode(IE, Pred, state->BindExpr(IE, LCtx, V));
789   ProgramStateRef state = Pred->getState();
794   ProgramStateRef SrcState = state;
798       // If the state N has multiple predecessors P, it means that successors
842   B.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V, true));
897     ProgramStateRef state = (*I)->getState();
898     state = state->BindExpr(Ex, (*I)->getLocationContext(),
901     Bldr.generateNode(Ex, *I, state);
918   ProgramStateRef state = (*I)->getState();
920   Bldr.generateNode(U, *I, state->BindExpr(U, LCtx,
921                                            state->getSVal(Ex, LCtx)));
954       ProgramStateRef state = (*I)->getState();
956       Bldr.generateNode(U, *I, state->BindExpr(U, LCtx,
957                                                state->getSVal(Ex, LCtx)));
969       ProgramStateRef state = (*I)->getState();
972       Bldr.generateNode(U, *I, state->BindExpr(U, LCtx, X));
1008       ProgramStateRef state = (*I)->getState();
1012       SVal V = state->getSVal(Ex, LCtx);
1015         Bldr.generateNode(U, *I, state->BindExpr(U, LCtx, V));
1024           state = state->BindExpr(U, LCtx, evalComplement(V.castAs<NonLoc>()));
1028           state = state->BindExpr(U, LCtx, evalMinus(V.castAs<NonLoc>()));
1038             Result = evalBinOp(state, BO_EQ, *LV, X, U->getType());
1044             Result = evalBinOp(state, BO_EQ, V.castAs<NonLoc>(), X,
1048           state = state->BindExpr(U, LCtx, Result);
1051       Bldr.generateNode(U, *I, state);
1068   ProgramStateRef state = Pred->getState();
1069   SVal loc = state->getSVal(Ex, LCtx);
1073   evalLoad(Tmp, U, Ex, Pred, state, loc);
1079     state = (*I)->getState();
1081     SVal V2_untested = state->getSVal(Ex, LCtx);
1085       state = state->BindExpr(U, LCtx, V2_untested);
1090       evalStore(Dst3, U, Ex, *I, state, loc, V2_untested);
1120       Result = evalBinOp(state, Op, V2, RHS, U->getType());
1134         svalBuilder.evalEQ(state, V2,svalBuilder.makeZeroVal(U->getType()));
1136         if (!state->assume(Constraint, true)) {
1139           Constraint = svalBuilder.evalEQ(state, SymVal,
1142           state = state->assume(Constraint, false);
1143           assert(state);
1151       state = state->BindExpr(U, LCtx, loc);
1153       state = state->BindExpr(U, LCtx, U->isPostfix() ? V2 : Result);
1158     evalStore(Dst3, U, Ex, *I, state, loc, Result);