contrib/llvm/tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp

   1 //=-- ExprEngineC.cpp - ExprEngine support for C expressions ----*- C++ -*-===//
   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 //  This file defines ExprEngine's support for C expressions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/ExprCXX.h"
  15 #include "clang/AST/DeclCXX.h"
  16 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  17 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
  18
  19 using namespace clang;
  20 using namespace ento;
  21 using llvm::APSInt;
  22
  23 /// \brief Optionally conjure and return a symbol for offset when processing
  24 /// an expression \p Expression.
  25 /// If \p Other is a location, conjure a symbol for \p Symbol
  26 /// (offset) if it is unknown so that memory arithmetic always
  27 /// results in an ElementRegion.
  28 /// \p Count The number of times the current basic block was visited.
  29 static SVal conjureOffsetSymbolOnLocation(
  30     SVal Symbol, SVal Other, Expr* Expression, SValBuilder &svalBuilder,
  31     unsigned Count, const LocationContext *LCtx) {
  32   QualType Ty = Expression->getType();
  33   if (Other.getAs<Loc>() &&
  34       Ty->isIntegralOrEnumerationType() &&
  35       Symbol.isUnknown()) {
  36     return svalBuilder.conjureSymbolVal(Expression, LCtx, Ty, Count);
  37   }
  38   return Symbol;
  39 }
  40
  41 void ExprEngine::VisitBinaryOperator(const BinaryOperator* B,
  42                                      ExplodedNode *Pred,
  43                                      ExplodedNodeSet &Dst) {
  44
  45   Expr *LHS = B->getLHS()->IgnoreParens();
  46   Expr *RHS = B->getRHS()->IgnoreParens();
  47
  48   // FIXME: Prechecks eventually go in ::Visit().
  49   ExplodedNodeSet CheckedSet;
  50   ExplodedNodeSet Tmp2;
  51   getCheckerManager().runCheckersForPreStmt(CheckedSet, Pred, B, *this);
  52
  53   // With both the LHS and RHS evaluated, process the operation itself.
  54   for (ExplodedNodeSet::iterator it=CheckedSet.begin(), ei=CheckedSet.end();
  55          it != ei; ++it) {
  56
  57     ProgramStateRef state = (*it)->getState();
  58     const LocationContext *LCtx = (*it)->getLocationContext();
  59     SVal LeftV = state->getSVal(LHS, LCtx);
  60     SVal RightV = state->getSVal(RHS, LCtx);
  61
  62     BinaryOperator::Opcode Op = B->getOpcode();
  63
  64     if (Op == BO_Assign) {
  65       // EXPERIMENTAL: "Conjured" symbols.
  66       // FIXME: Handle structs.
  67       if (RightV.isUnknown()) {
  68         unsigned Count = currBldrCtx->blockCount();
  69         RightV = svalBuilder.conjureSymbolVal(nullptr, B->getRHS(), LCtx,
  70                                               Count);
  71       }
  72       // Simulate the effects of a "store":  bind the value of the RHS
  73       // to the L-Value represented by the LHS.
  74       SVal ExprVal = B->isGLValue() ? LeftV : RightV;
  75       evalStore(Tmp2, B, LHS, *it, state->BindExpr(B, LCtx, ExprVal),
  76                 LeftV, RightV);
  77       continue;
  78     }
  79
  80     if (!B->isAssignmentOp()) {
  81       StmtNodeBuilder Bldr(*it, Tmp2, *currBldrCtx);
  82
  83       if (B->isAdditiveOp()) {
  84         // TODO: This can be removed after we enable history tracking with
  85         // SymSymExpr.
  86         unsigned Count = currBldrCtx->blockCount();
  87         RightV = conjureOffsetSymbolOnLocation(
  88             RightV, LeftV, RHS, svalBuilder, Count, LCtx);
  89         LeftV = conjureOffsetSymbolOnLocation(
  90             LeftV, RightV, LHS, svalBuilder, Count, LCtx);
  91       }
  92
  93       // Although we don't yet model pointers-to-members, we do need to make
  94       // sure that the members of temporaries have a valid 'this' pointer for
  95       // other checks.
  96       if (B->getOpcode() == BO_PtrMemD)
  97         state = createTemporaryRegionIfNeeded(state, LCtx, LHS);
  98
  99       // Process non-assignments except commas or short-circuited
 100       // logical expressions (LAnd and LOr).
 101       SVal Result = evalBinOp(state, Op, LeftV, RightV, B->getType());
 102       if (!Result.isUnknown()) {
 103         state = state->BindExpr(B, LCtx, Result);
 104       }
 105
 106       Bldr.generateNode(B, *it, state);
 107       continue;
 108     }
 109
 110     assert (B->isCompoundAssignmentOp());
 111
 112     switch (Op) {
 113       default:
 114         llvm_unreachable("Invalid opcode for compound assignment.");
 115       case BO_MulAssign: Op = BO_Mul; break;
 116       case BO_DivAssign: Op = BO_Div; break;
 117       case BO_RemAssign: Op = BO_Rem; break;
 118       case BO_AddAssign: Op = BO_Add; break;
 119       case BO_SubAssign: Op = BO_Sub; break;
 120       case BO_ShlAssign: Op = BO_Shl; break;
 121       case BO_ShrAssign: Op = BO_Shr; break;
 122       case BO_AndAssign: Op = BO_And; break;
 123       case BO_XorAssign: Op = BO_Xor; break;
 124       case BO_OrAssign:  Op = BO_Or;  break;
 125     }
 126
 127     // Perform a load (the LHS).  This performs the checks for
 128     // null dereferences, and so on.
 129     ExplodedNodeSet Tmp;
 130     SVal location = LeftV;
 131     evalLoad(Tmp, B, LHS, *it, state, location);
 132
 133     for (ExplodedNodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I != E;
 134          ++I) {
 135
 136       state = (*I)->getState();
 137       const LocationContext *LCtx = (*I)->getLocationContext();
 138       SVal V = state->getSVal(LHS, LCtx);
 139
 140       // Get the computation type.
 141       QualType CTy =
 142         cast<CompoundAssignOperator>(B)->getComputationResultType();
 143       CTy = getContext().getCanonicalType(CTy);
 144
 145       QualType CLHSTy =
 146         cast<CompoundAssignOperator>(B)->getComputationLHSType();
 147       CLHSTy = getContext().getCanonicalType(CLHSTy);
 148
 149       QualType LTy = getContext().getCanonicalType(LHS->getType());
 150
 151       // Promote LHS.
 152       V = svalBuilder.evalCast(V, CLHSTy, LTy);
 153
 154       // Compute the result of the operation.
 155       SVal Result = svalBuilder.evalCast(evalBinOp(state, Op, V, RightV, CTy),
 156                                          B->getType(), CTy);
 157
 158       // EXPERIMENTAL: "Conjured" symbols.
 159       // FIXME: Handle structs.
 160
 161       SVal LHSVal;
 162
 163       if (Result.isUnknown()) {
 164         // The symbolic value is actually for the type of the left-hand side
 165         // expression, not the computation type, as this is the value the
 166         // LValue on the LHS will bind to.
 167         LHSVal = svalBuilder.conjureSymbolVal(nullptr, B->getRHS(), LCtx, LTy,
 168                                               currBldrCtx->blockCount());
 169         // However, we need to convert the symbol to the computation type.
 170         Result = svalBuilder.evalCast(LHSVal, CTy, LTy);
 171       }
 172       else {
 173         // The left-hand side may bind to a different value then the
 174         // computation type.
 175         LHSVal = svalBuilder.evalCast(Result, LTy, CTy);
 176       }
 177
 178       // In C++, assignment and compound assignment operators return an
 179       // lvalue.
 180       if (B->isGLValue())
 181         state = state->BindExpr(B, LCtx, location);
 182       else
 183         state = state->BindExpr(B, LCtx, Result);
 184
 185       evalStore(Tmp2, B, LHS, *I, state, location, LHSVal);
 186     }
 187   }
 188
 189   // FIXME: postvisits eventually go in ::Visit()
 190   getCheckerManager().runCheckersForPostStmt(Dst, Tmp2, B, *this);
 191 }
 192
 193 void ExprEngine::VisitBlockExpr(const BlockExpr *BE, ExplodedNode *Pred,
 194                                 ExplodedNodeSet &Dst) {
 195
 196   CanQualType T = getContext().getCanonicalType(BE->getType());
 197
 198   const BlockDecl *BD = BE->getBlockDecl();
 199   // Get the value of the block itself.
 200   SVal V = svalBuilder.getBlockPointer(BD, T,
 201                                        Pred->getLocationContext(),
 202                                        currBldrCtx->blockCount());
 203
 204   ProgramStateRef State = Pred->getState();
 205
 206   // If we created a new MemRegion for the block, we should explicitly bind
 207   // the captured variables.
 208   if (const BlockDataRegion *BDR =
 209       dyn_cast_or_null<BlockDataRegion>(V.getAsRegion())) {
 210
 211     BlockDataRegion::referenced_vars_iterator I = BDR->referenced_vars_begin(),
 212                                               E = BDR->referenced_vars_end();
 213
 214     auto CI = BD->capture_begin();
 215     auto CE = BD->capture_end();
 216     for (; I != E; ++I) {
 217       const VarRegion *capturedR = I.getCapturedRegion();
 218       const VarRegion *originalR = I.getOriginalRegion();
 219
 220       // If the capture had a copy expression, use the result of evaluating
 221       // that expression, otherwise use the original value.
 222       // We rely on the invariant that the block declaration's capture variables
 223       // are a prefix of the BlockDataRegion's referenced vars (which may include
 224       // referenced globals, etc.) to enable fast lookup of the capture for a
 225       // given referenced var.
 226       const Expr *copyExpr = nullptr;
 227       if (CI != CE) {
 228         assert(CI->getVariable() == capturedR->getDecl());
 229         copyExpr = CI->getCopyExpr();
 230         CI++;
 231       }
 232
 233       if (capturedR != originalR) {
 234         SVal originalV;
 235         const LocationContext *LCtx = Pred->getLocationContext();
 236         if (copyExpr) {
 237           originalV = State->getSVal(copyExpr, LCtx);
 238         } else {
 239           originalV = State->getSVal(loc::MemRegionVal(originalR));
 240         }
 241         State = State->bindLoc(loc::MemRegionVal(capturedR), originalV, LCtx);
 242       }
 243     }
 244   }
 245
 246   ExplodedNodeSet Tmp;
 247   StmtNodeBuilder Bldr(Pred, Tmp, *currBldrCtx);
 248   Bldr.generateNode(BE, Pred,
 249                     State->BindExpr(BE, Pred->getLocationContext(), V),
 250                     nullptr, ProgramPoint::PostLValueKind);
 251
 252   // FIXME: Move all post/pre visits to ::Visit().
 253   getCheckerManager().runCheckersForPostStmt(Dst, Tmp, BE, *this);
 254 }
 255
 256 ProgramStateRef ExprEngine::handleLValueBitCast(
 257     ProgramStateRef state, const Expr* Ex, const LocationContext* LCtx,
 258     QualType T, QualType ExTy, const CastExpr* CastE, StmtNodeBuilder& Bldr,
 259     ExplodedNode* Pred) {
 260   // Delegate to SValBuilder to process.
 261   SVal V = state->getSVal(Ex, LCtx);
 262   V = svalBuilder.evalCast(V, T, ExTy);
 263   // Negate the result if we're treating the boolean as a signed i1
 264   if (CastE->getCastKind() == CK_BooleanToSignedIntegral)
 265     V = evalMinus(V);
 266   state = state->BindExpr(CastE, LCtx, V);
 267   Bldr.generateNode(CastE, Pred, state);
 268
 269   return state;
 270 }
 271
 272 ProgramStateRef ExprEngine::handleLVectorSplat(
 273     ProgramStateRef state, const LocationContext* LCtx, const CastExpr* CastE,
 274     StmtNodeBuilder &Bldr, ExplodedNode* Pred) {
 275   // Recover some path sensitivity by conjuring a new value.
 276   QualType resultType = CastE->getType();
 277   if (CastE->isGLValue())
 278     resultType = getContext().getPointerType(resultType);
 279   SVal result = svalBuilder.conjureSymbolVal(nullptr, CastE, LCtx,
 280                                              resultType,
 281                                              currBldrCtx->blockCount());
 282   state = state->BindExpr(CastE, LCtx, result);
 283   Bldr.generateNode(CastE, Pred, state);
 284
 285   return state;
 286 }
 287
 288 void ExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex,
 289                            ExplodedNode *Pred, ExplodedNodeSet &Dst) {
 290
 291   ExplodedNodeSet dstPreStmt;
 292   getCheckerManager().runCheckersForPreStmt(dstPreStmt, Pred, CastE, *this);
 293
 294   if (CastE->getCastKind() == CK_LValueToRValue) {
 295     for (ExplodedNodeSet::iterator I = dstPreStmt.begin(), E = dstPreStmt.end();
 296          I!=E; ++I) {
 297       ExplodedNode *subExprNode = *I;
 298       ProgramStateRef state = subExprNode->getState();
 299       const LocationContext *LCtx = subExprNode->getLocationContext();
 300       evalLoad(Dst, CastE, CastE, subExprNode, state, state->getSVal(Ex, LCtx));
 301     }
 302     return;
 303   }
 304
 305   // All other casts.
 306   QualType T = CastE->getType();
 307   QualType ExTy = Ex->getType();
 308
 309   if (const ExplicitCastExpr *ExCast=dyn_cast_or_null<ExplicitCastExpr>(CastE))
 310     T = ExCast->getTypeAsWritten();
 311
 312   StmtNodeBuilder Bldr(dstPreStmt, Dst, *currBldrCtx);
 313   for (ExplodedNodeSet::iterator I = dstPreStmt.begin(), E = dstPreStmt.end();
 314        I != E; ++I) {
 315
 316     Pred = *I;
 317     ProgramStateRef state = Pred->getState();
 318     const LocationContext *LCtx = Pred->getLocationContext();
 319
 320     switch (CastE->getCastKind()) {
 321       case CK_LValueToRValue:
 322         llvm_unreachable("LValueToRValue casts handled earlier.");
 323       case CK_ToVoid:
 324         continue;
 325         // The analyzer doesn't do anything special with these casts,
 326         // since it understands retain/release semantics already.
 327       case CK_ARCProduceObject:
 328       case CK_ARCConsumeObject:
 329       case CK_ARCReclaimReturnedObject:
 330       case CK_ARCExtendBlockObject: // Fall-through.
 331       case CK_CopyAndAutoreleaseBlockObject:
 332         // The analyser can ignore atomic casts for now, although some future
 333         // checkers may want to make certain that you're not modifying the same
 334         // value through atomic and nonatomic pointers.
 335       case CK_AtomicToNonAtomic:
 336       case CK_NonAtomicToAtomic:
 337         // True no-ops.
 338       case CK_NoOp:
 339       case CK_ConstructorConversion:
 340       case CK_UserDefinedConversion:
 341       case CK_FunctionToPointerDecay:
 342       case CK_BuiltinFnToFnPtr: {
 343         // Copy the SVal of Ex to CastE.
 344         ProgramStateRef state = Pred->getState();
 345         const LocationContext *LCtx = Pred->getLocationContext();
 346         SVal V = state->getSVal(Ex, LCtx);
 347         state = state->BindExpr(CastE, LCtx, V);
 348         Bldr.generateNode(CastE, Pred, state);
 349         continue;
 350       }
 351       case CK_MemberPointerToBoolean:
 352       case CK_PointerToBoolean: {
 353         SVal V = state->getSVal(Ex, LCtx);
 354         auto PTMSV = V.getAs<nonloc::PointerToMember>();
 355         if (PTMSV)
 356           V = svalBuilder.makeTruthVal(!PTMSV->isNullMemberPointer(), ExTy);
 357         if (V.isUndef() || PTMSV) {
 358           state = state->BindExpr(CastE, LCtx, V);
 359           Bldr.generateNode(CastE, Pred, state);
 360           continue;
 361         }
 362         // Explicitly proceed with default handler for this case cascade.
 363         state =
 364             handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
 365         continue;
 366       }
 367       case CK_Dependent:
 368       case CK_ArrayToPointerDecay:
 369       case CK_BitCast:
 370       case CK_AddressSpaceConversion:
 371       case CK_BooleanToSignedIntegral:
 372       case CK_NullToPointer:
 373       case CK_IntegralToPointer:
 374       case CK_PointerToIntegral: {
 375         SVal V = state->getSVal(Ex, LCtx);
 376         if (V.getAs<nonloc::PointerToMember>()) {
 377           state = state->BindExpr(CastE, LCtx, UnknownVal());
 378           Bldr.generateNode(CastE, Pred, state);
 379           continue;
 380         }
 381         // Explicitly proceed with default handler for this case cascade.
 382         state =
 383             handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
 384         continue;
 385       }
 386       case CK_IntegralToBoolean:
 387       case CK_IntegralToFloating:
 388       case CK_FloatingToIntegral:
 389       case CK_FloatingToBoolean:
 390       case CK_FloatingCast:
 391       case CK_FloatingRealToComplex:
 392       case CK_FloatingComplexToReal:
 393       case CK_FloatingComplexToBoolean:
 394       case CK_FloatingComplexCast:
 395       case CK_FloatingComplexToIntegralComplex:
 396       case CK_IntegralRealToComplex:
 397       case CK_IntegralComplexToReal:
 398       case CK_IntegralComplexToBoolean:
 399       case CK_IntegralComplexCast:
 400       case CK_IntegralComplexToFloatingComplex:
 401       case CK_CPointerToObjCPointerCast:
 402       case CK_BlockPointerToObjCPointerCast:
 403       case CK_AnyPointerToBlockPointerCast:
 404       case CK_ObjCObjectLValueCast:
 405       case CK_ZeroToOCLEvent:
 406       case CK_ZeroToOCLQueue:
 407       case CK_IntToOCLSampler:
 408       case CK_LValueBitCast: {
 409         state =
 410             handleLValueBitCast(state, Ex, LCtx, T, ExTy, CastE, Bldr, Pred);
 411         continue;
 412       }
 413       case CK_IntegralCast: {
 414         // Delegate to SValBuilder to process.
 415         SVal V = state->getSVal(Ex, LCtx);
 416         V = svalBuilder.evalIntegralCast(state, V, T, ExTy);
 417         state = state->BindExpr(CastE, LCtx, V);
 418         Bldr.generateNode(CastE, Pred, state);
 419         continue;
 420       }
 421       case CK_DerivedToBase:
 422       case CK_UncheckedDerivedToBase: {
 423         // For DerivedToBase cast, delegate to the store manager.
 424         SVal val = state->getSVal(Ex, LCtx);
 425         val = getStoreManager().evalDerivedToBase(val, CastE);
 426         state = state->BindExpr(CastE, LCtx, val);
 427         Bldr.generateNode(CastE, Pred, state);
 428         continue;
 429       }
 430       // Handle C++ dyn_cast.
 431       case CK_Dynamic: {
 432         SVal val = state->getSVal(Ex, LCtx);
 433
 434         // Compute the type of the result.
 435         QualType resultType = CastE->getType();
 436         if (CastE->isGLValue())
 437           resultType = getContext().getPointerType(resultType);
 438
 439         bool Failed = false;
 440
 441         // Check if the value being cast evaluates to 0.
 442         if (val.isZeroConstant())
 443           Failed = true;
 444         // Else, evaluate the cast.
 445         else
 446           val = getStoreManager().attemptDownCast(val, T, Failed);
 447
 448         if (Failed) {
 449           if (T->isReferenceType()) {
 450             // A bad_cast exception is thrown if input value is a reference.
 451             // Currently, we model this, by generating a sink.
 452             Bldr.generateSink(CastE, Pred, state);
 453             continue;
 454           } else {
 455             // If the cast fails on a pointer, bind to 0.
 456             state = state->BindExpr(CastE, LCtx, svalBuilder.makeNull());
 457           }
 458         } else {
 459           // If we don't know if the cast succeeded, conjure a new symbol.
 460           if (val.isUnknown()) {
 461             DefinedOrUnknownSVal NewSym =
 462               svalBuilder.conjureSymbolVal(nullptr, CastE, LCtx, resultType,
 463                                            currBldrCtx->blockCount());
 464             state = state->BindExpr(CastE, LCtx, NewSym);
 465           } else
 466             // Else, bind to the derived region value.
 467             state = state->BindExpr(CastE, LCtx, val);
 468         }
 469         Bldr.generateNode(CastE, Pred, state);
 470         continue;
 471       }
 472       case CK_BaseToDerived: {
 473         SVal val = state->getSVal(Ex, LCtx);
 474         QualType resultType = CastE->getType();
 475         if (CastE->isGLValue())
 476           resultType = getContext().getPointerType(resultType);
 477
 478         bool Failed = false;
 479
 480         if (!val.isConstant()) {
 481           val = getStoreManager().attemptDownCast(val, T, Failed);
 482         }
 483
 484         // Failed to cast or the result is unknown, fall back to conservative.
 485         if (Failed || val.isUnknown()) {
 486           val =
 487             svalBuilder.conjureSymbolVal(nullptr, CastE, LCtx, resultType,
 488                                          currBldrCtx->blockCount());
 489         }
 490         state = state->BindExpr(CastE, LCtx, val);
 491         Bldr.generateNode(CastE, Pred, state);
 492         continue;
 493       }
 494       case CK_NullToMemberPointer: {
 495         SVal V = svalBuilder.getMemberPointer(nullptr);
 496         state = state->BindExpr(CastE, LCtx, V);
 497         Bldr.generateNode(CastE, Pred, state);
 498         continue;
 499       }
 500       case CK_DerivedToBaseMemberPointer:
 501       case CK_BaseToDerivedMemberPointer:
 502       case CK_ReinterpretMemberPointer: {
 503         SVal V = state->getSVal(Ex, LCtx);
 504         if (auto PTMSV = V.getAs<nonloc::PointerToMember>()) {
 505           SVal CastedPTMSV = svalBuilder.makePointerToMember(
 506               getBasicVals().accumCXXBase(
 507                   llvm::make_range<CastExpr::path_const_iterator>(
 508                       CastE->path_begin(), CastE->path_end()), *PTMSV));
 509           state = state->BindExpr(CastE, LCtx, CastedPTMSV);
 510           Bldr.generateNode(CastE, Pred, state);
 511           continue;
 512         }
 513         // Explicitly proceed with default handler for this case cascade.
 514         state = handleLVectorSplat(state, LCtx, CastE, Bldr, Pred);
 515         continue;
 516       }
 517       // Various C++ casts that are not handled yet.
 518       case CK_ToUnion:
 519       case CK_VectorSplat: {
 520         state = handleLVectorSplat(state, LCtx, CastE, Bldr, Pred);
 521         continue;
 522       }
 523     }
 524   }
 525 }
 526
 527 void ExprEngine::VisitCompoundLiteralExpr(const CompoundLiteralExpr *CL,
 528                                           ExplodedNode *Pred,
 529                                           ExplodedNodeSet &Dst) {
 530   StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
 531
 532   ProgramStateRef State = Pred->getState();
 533   const LocationContext *LCtx = Pred->getLocationContext();
 534
 535   const Expr *Init = CL->getInitializer();
 536   SVal V = State->getSVal(CL->getInitializer(), LCtx);
 537
 538   if (isa<CXXConstructExpr>(Init) || isa<CXXStdInitializerListExpr>(Init)) {
 539     // No work needed. Just pass the value up to this expression.
 540   } else {
 541     assert(isa<InitListExpr>(Init));
 542     Loc CLLoc = State->getLValue(CL, LCtx);
 543     State = State->bindLoc(CLLoc, V, LCtx);
 544
 545     if (CL->isGLValue())
 546       V = CLLoc;
 547   }
 548
 549   B.generateNode(CL, Pred, State->BindExpr(CL, LCtx, V));
 550 }
 551
 552 void ExprEngine::VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred,
 553                                ExplodedNodeSet &Dst) {
 554   // Assumption: The CFG has one DeclStmt per Decl.
 555   const VarDecl *VD = dyn_cast_or_null<VarDecl>(*DS->decl_begin());
 556
 557   if (!VD) {
 558     //TODO:AZ: remove explicit insertion after refactoring is done.
 559     Dst.insert(Pred);
 560     return;
 561   }
 562
 563   // FIXME: all pre/post visits should eventually be handled by ::Visit().
 564   ExplodedNodeSet dstPreVisit;
 565   getCheckerManager().runCheckersForPreStmt(dstPreVisit, Pred, DS, *this);
 566
 567   ExplodedNodeSet dstEvaluated;
 568   StmtNodeBuilder B(dstPreVisit, dstEvaluated, *currBldrCtx);
 569   for (ExplodedNodeSet::iterator I = dstPreVisit.begin(), E = dstPreVisit.end();
 570        I!=E; ++I) {
 571     ExplodedNode *N = *I;
 572     ProgramStateRef state = N->getState();
 573     const LocationContext *LC = N->getLocationContext();
 574
 575     // Decls without InitExpr are not initialized explicitly.
 576     if (const Expr *InitEx = VD->getInit()) {
 577
 578       // Note in the state that the initialization has occurred.
 579       ExplodedNode *UpdatedN = N;
 580       SVal InitVal = state->getSVal(InitEx, LC);
 581
 582       assert(DS->isSingleDecl());
 583       if (auto *CtorExpr = findDirectConstructorForCurrentCFGElement()) {
 584         assert(InitEx->IgnoreImplicit() == CtorExpr);
 585         (void)CtorExpr;
 586         // We constructed the object directly in the variable.
 587         // No need to bind anything.
 588         B.generateNode(DS, UpdatedN, state);
 589       } else {
 590         // We bound the temp obj region to the CXXConstructExpr. Now recover
 591         // the lazy compound value when the variable is not a reference.
 592         if (AMgr.getLangOpts().CPlusPlus && VD->getType()->isRecordType() &&
 593             !VD->getType()->isReferenceType()) {
 594           if (Optional<loc::MemRegionVal> M =
 595                   InitVal.getAs<loc::MemRegionVal>()) {
 596             InitVal = state->getSVal(M->getRegion());
 597             assert(InitVal.getAs<nonloc::LazyCompoundVal>());
 598           }
 599         }
 600
 601         // Recover some path-sensitivity if a scalar value evaluated to
 602         // UnknownVal.
 603         if (InitVal.isUnknown()) {
 604           QualType Ty = InitEx->getType();
 605           if (InitEx->isGLValue()) {
 606             Ty = getContext().getPointerType(Ty);
 607           }
 608
 609           InitVal = svalBuilder.conjureSymbolVal(nullptr, InitEx, LC, Ty,
 610                                                  currBldrCtx->blockCount());
 611         }
 612
 613
 614         B.takeNodes(UpdatedN);
 615         ExplodedNodeSet Dst2;
 616         evalBind(Dst2, DS, UpdatedN, state->getLValue(VD, LC), InitVal, true);
 617         B.addNodes(Dst2);
 618       }
 619     }
 620     else {
 621       B.generateNode(DS, N, state);
 622     }
 623   }
 624
 625   getCheckerManager().runCheckersForPostStmt(Dst, B.getResults(), DS, *this);
 626 }
 627
 628 void ExprEngine::VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
 629                                   ExplodedNodeSet &Dst) {
 630   assert(B->getOpcode() == BO_LAnd ||
 631          B->getOpcode() == BO_LOr);
 632
 633   StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
 634   ProgramStateRef state = Pred->getState();
 635
 636   if (B->getType()->isVectorType()) {
 637     // FIXME: We do not model vector arithmetic yet. When adding support for
 638     // that, note that the CFG-based reasoning below does not apply, because
 639     // logical operators on vectors are not short-circuit. Currently they are
 640     // modeled as short-circuit in Clang CFG but this is incorrect.
 641     // Do not set the value for the expression. It'd be UnknownVal by default.
 642     Bldr.generateNode(B, Pred, state);
 643     return;
 644   }
 645
 646   ExplodedNode *N = Pred;
 647   while (!N->getLocation().getAs<BlockEntrance>()) {
 648     ProgramPoint P = N->getLocation();
 649     assert(P.getAs<PreStmt>()|| P.getAs<PreStmtPurgeDeadSymbols>());
 650     (void) P;
 651     assert(N->pred_size() == 1);
 652     N = *N->pred_begin();
 653   }
 654   assert(N->pred_size() == 1);
 655   N = *N->pred_begin();
 656   BlockEdge BE = N->getLocation().castAs<BlockEdge>();
 657   SVal X;
 658
 659   // Determine the value of the expression by introspecting how we
 660   // got this location in the CFG.  This requires looking at the previous
 661   // block we were in and what kind of control-flow transfer was involved.
 662   const CFGBlock *SrcBlock = BE.getSrc();
 663   // The only terminator (if there is one) that makes sense is a logical op.
 664   CFGTerminator T = SrcBlock->getTerminator();
 665   if (const BinaryOperator *Term = cast_or_null<BinaryOperator>(T.getStmt())) {
 666     (void) Term;
 667     assert(Term->isLogicalOp());
 668     assert(SrcBlock->succ_size() == 2);
 669     // Did we take the true or false branch?
 670     unsigned constant = (*SrcBlock->succ_begin() == BE.getDst()) ? 1 : 0;
 671     X = svalBuilder.makeIntVal(constant, B->getType());
 672   }
 673   else {
 674     // If there is no terminator, by construction the last statement
 675     // in SrcBlock is the value of the enclosing expression.
 676     // However, we still need to constrain that value to be 0 or 1.
 677     assert(!SrcBlock->empty());
 678     CFGStmt Elem = SrcBlock->rbegin()->castAs<CFGStmt>();
 679     const Expr *RHS = cast<Expr>(Elem.getStmt());
 680     SVal RHSVal = N->getState()->getSVal(RHS, Pred->getLocationContext());
 681
 682     if (RHSVal.isUndef()) {
 683       X = RHSVal;
 684     } else {
 685       // We evaluate "RHSVal != 0" expression which result in 0 if the value is
 686       // known to be false, 1 if the value is known to be true and a new symbol
 687       // when the assumption is unknown.
 688       nonloc::ConcreteInt Zero(getBasicVals().getValue(0, B->getType()));
 689       X = evalBinOp(N->getState(), BO_NE,
 690                     svalBuilder.evalCast(RHSVal, B->getType(), RHS->getType()),
 691                     Zero, B->getType());
 692     }
 693   }
 694   Bldr.generateNode(B, Pred, state->BindExpr(B, Pred->getLocationContext(), X));
 695 }
 696
 697 void ExprEngine::VisitInitListExpr(const InitListExpr *IE,
 698                                    ExplodedNode *Pred,
 699                                    ExplodedNodeSet &Dst) {
 700   StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
 701
 702   ProgramStateRef state = Pred->getState();
 703   const LocationContext *LCtx = Pred->getLocationContext();
 704   QualType T = getContext().getCanonicalType(IE->getType());
 705   unsigned NumInitElements = IE->getNumInits();
 706
 707   if (!IE->isGLValue() &&
 708       (T->isArrayType() || T->isRecordType() || T->isVectorType() ||
 709        T->isAnyComplexType())) {
 710     llvm::ImmutableList<SVal> vals = getBasicVals().getEmptySValList();
 711
 712     // Handle base case where the initializer has no elements.
 713     // e.g: static int* myArray[] = {};
 714     if (NumInitElements == 0) {
 715       SVal V = svalBuilder.makeCompoundVal(T, vals);
 716       B.generateNode(IE, Pred, state->BindExpr(IE, LCtx, V));
 717       return;
 718     }
 719
 720     for (InitListExpr::const_reverse_iterator it = IE->rbegin(),
 721          ei = IE->rend(); it != ei; ++it) {
 722       SVal V = state->getSVal(cast<Expr>(*it), LCtx);
 723       vals = getBasicVals().prependSVal(V, vals);
 724     }
 725
 726     B.generateNode(IE, Pred,
 727                    state->BindExpr(IE, LCtx,
 728                                    svalBuilder.makeCompoundVal(T, vals)));
 729     return;
 730   }
 731
 732   // Handle scalars: int{5} and int{} and GLvalues.
 733   // Note, if the InitListExpr is a GLvalue, it means that there is an address
 734   // representing it, so it must have a single init element.
 735   assert(NumInitElements <= 1);
 736
 737   SVal V;
 738   if (NumInitElements == 0)
 739     V = getSValBuilder().makeZeroVal(T);
 740   else
 741     V = state->getSVal(IE->getInit(0), LCtx);
 742
 743   B.generateNode(IE, Pred, state->BindExpr(IE, LCtx, V));
 744 }
 745
 746 void ExprEngine::VisitGuardedExpr(const Expr *Ex,
 747                                   const Expr *L,
 748                                   const Expr *R,
 749                                   ExplodedNode *Pred,
 750                                   ExplodedNodeSet &Dst) {
 751   assert(L && R);
 752
 753   StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
 754   ProgramStateRef state = Pred->getState();
 755   const LocationContext *LCtx = Pred->getLocationContext();
 756   const CFGBlock *SrcBlock = nullptr;
 757
 758   // Find the predecessor block.
 759   ProgramStateRef SrcState = state;
 760   for (const ExplodedNode *N = Pred ; N ; N = *N->pred_begin()) {
 761     ProgramPoint PP = N->getLocation();
 762     if (PP.getAs<PreStmtPurgeDeadSymbols>() || PP.getAs<BlockEntrance>()) {
 763       assert(N->pred_size() == 1);
 764       continue;
 765     }
 766     SrcBlock = PP.castAs<BlockEdge>().getSrc();
 767     SrcState = N->getState();
 768     break;
 769   }
 770
 771   assert(SrcBlock && "missing function entry");
 772
 773   // Find the last expression in the predecessor block.  That is the
 774   // expression that is used for the value of the ternary expression.
 775   bool hasValue = false;
 776   SVal V;
 777
 778   for (CFGElement CE : llvm::reverse(*SrcBlock)) {
 779     if (Optional<CFGStmt> CS = CE.getAs<CFGStmt>()) {
 780       const Expr *ValEx = cast<Expr>(CS->getStmt());
 781       ValEx = ValEx->IgnoreParens();
 782
 783       // For GNU extension '?:' operator, the left hand side will be an
 784       // OpaqueValueExpr, so get the underlying expression.
 785       if (const OpaqueValueExpr *OpaqueEx = dyn_cast<OpaqueValueExpr>(L))
 786         L = OpaqueEx->getSourceExpr();
 787
 788       // If the last expression in the predecessor block matches true or false
 789       // subexpression, get its the value.
 790       if (ValEx == L->IgnoreParens() || ValEx == R->IgnoreParens()) {
 791         hasValue = true;
 792         V = SrcState->getSVal(ValEx, LCtx);
 793       }
 794       break;
 795     }
 796   }
 797
 798   if (!hasValue)
 799     V = svalBuilder.conjureSymbolVal(nullptr, Ex, LCtx,
 800                                      currBldrCtx->blockCount());
 801
 802   // Generate a new node with the binding from the appropriate path.
 803   B.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V, true));
 804 }
 805
 806 void ExprEngine::
 807 VisitOffsetOfExpr(const OffsetOfExpr *OOE,
 808                   ExplodedNode *Pred, ExplodedNodeSet &Dst) {
 809   StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
 810   APSInt IV;
 811   if (OOE->EvaluateAsInt(IV, getContext())) {
 812     assert(IV.getBitWidth() == getContext().getTypeSize(OOE->getType()));
 813     assert(OOE->getType()->isBuiltinType());
 814     assert(OOE->getType()->getAs<BuiltinType>()->isInteger());
 815     assert(IV.isSigned() == OOE->getType()->isSignedIntegerType());
 816     SVal X = svalBuilder.makeIntVal(IV);
 817     B.generateNode(OOE, Pred,
 818                    Pred->getState()->BindExpr(OOE, Pred->getLocationContext(),
 819                                               X));
 820   }
 821   // FIXME: Handle the case where __builtin_offsetof is not a constant.
 822 }
 823
 824
 825 void ExprEngine::
 826 VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Ex,
 827                               ExplodedNode *Pred,
 828                               ExplodedNodeSet &Dst) {
 829   // FIXME: Prechecks eventually go in ::Visit().
 830   ExplodedNodeSet CheckedSet;
 831   getCheckerManager().runCheckersForPreStmt(CheckedSet, Pred, Ex, *this);
 832
 833   ExplodedNodeSet EvalSet;
 834   StmtNodeBuilder Bldr(CheckedSet, EvalSet, *currBldrCtx);
 835
 836   QualType T = Ex->getTypeOfArgument();
 837
 838   for (ExplodedNodeSet::iterator I = CheckedSet.begin(), E = CheckedSet.end();
 839        I != E; ++I) {
 840     if (Ex->getKind() == UETT_SizeOf) {
 841       if (!T->isIncompleteType() && !T->isConstantSizeType()) {
 842         assert(T->isVariableArrayType() && "Unknown non-constant-sized type.");
 843
 844         // FIXME: Add support for VLA type arguments and VLA expressions.
 845         // When that happens, we should probably refactor VLASizeChecker's code.
 846         continue;
 847       } else if (T->getAs<ObjCObjectType>()) {
 848         // Some code tries to take the sizeof an ObjCObjectType, relying that
 849         // the compiler has laid out its representation.  Just report Unknown
 850         // for these.
 851         continue;
 852       }
 853     }
 854
 855     APSInt Value = Ex->EvaluateKnownConstInt(getContext());
 856     CharUnits amt = CharUnits::fromQuantity(Value.getZExtValue());
 857
 858     ProgramStateRef state = (*I)->getState();
 859     state = state->BindExpr(Ex, (*I)->getLocationContext(),
 860                             svalBuilder.makeIntVal(amt.getQuantity(),
 861                                                    Ex->getType()));
 862     Bldr.generateNode(Ex, *I, state);
 863   }
 864
 865   getCheckerManager().runCheckersForPostStmt(Dst, EvalSet, Ex, *this);
 866 }
 867
 868 void ExprEngine::handleUOExtension(ExplodedNodeSet::iterator I,
 869                                    const UnaryOperator *U,
 870                                    StmtNodeBuilder &Bldr) {
 871   // FIXME: We can probably just have some magic in Environment::getSVal()
 872   // that propagates values, instead of creating a new node here.
 873   //
 874   // Unary "+" is a no-op, similar to a parentheses.  We still have places
 875   // where it may be a block-level expression, so we need to
 876   // generate an extra node that just propagates the value of the
 877   // subexpression.
 878   const Expr *Ex = U->getSubExpr()->IgnoreParens();
 879   ProgramStateRef state = (*I)->getState();
 880   const LocationContext *LCtx = (*I)->getLocationContext();
 881   Bldr.generateNode(U, *I, state->BindExpr(U, LCtx,
 882                                            state->getSVal(Ex, LCtx)));
 883 }
 884
 885 void ExprEngine::VisitUnaryOperator(const UnaryOperator* U, ExplodedNode *Pred,
 886                                     ExplodedNodeSet &Dst) {
 887   // FIXME: Prechecks eventually go in ::Visit().
 888   ExplodedNodeSet CheckedSet;
 889   getCheckerManager().runCheckersForPreStmt(CheckedSet, Pred, U, *this);
 890
 891   ExplodedNodeSet EvalSet;
 892   StmtNodeBuilder Bldr(CheckedSet, EvalSet, *currBldrCtx);
 893
 894   for (ExplodedNodeSet::iterator I = CheckedSet.begin(), E = CheckedSet.end();
 895        I != E; ++I) {
 896     switch (U->getOpcode()) {
 897     default: {
 898       Bldr.takeNodes(*I);
 899       ExplodedNodeSet Tmp;
 900       VisitIncrementDecrementOperator(U, *I, Tmp);
 901       Bldr.addNodes(Tmp);
 902       break;
 903     }
 904     case UO_Real: {
 905       const Expr *Ex = U->getSubExpr()->IgnoreParens();
 906
 907       // FIXME: We don't have complex SValues yet.
 908       if (Ex->getType()->isAnyComplexType()) {
 909         // Just report "Unknown."
 910         break;
 911       }
 912
 913       // For all other types, UO_Real is an identity operation.
 914       assert (U->getType() == Ex->getType());
 915       ProgramStateRef state = (*I)->getState();
 916       const LocationContext *LCtx = (*I)->getLocationContext();
 917       Bldr.generateNode(U, *I, state->BindExpr(U, LCtx,
 918                                                state->getSVal(Ex, LCtx)));
 919       break;
 920     }
 921
 922     case UO_Imag: {
 923       const Expr *Ex = U->getSubExpr()->IgnoreParens();
 924       // FIXME: We don't have complex SValues yet.
 925       if (Ex->getType()->isAnyComplexType()) {
 926         // Just report "Unknown."
 927         break;
 928       }
 929       // For all other types, UO_Imag returns 0.
 930       ProgramStateRef state = (*I)->getState();
 931       const LocationContext *LCtx = (*I)->getLocationContext();
 932       SVal X = svalBuilder.makeZeroVal(Ex->getType());
 933       Bldr.generateNode(U, *I, state->BindExpr(U, LCtx, X));
 934       break;
 935     }
 936
 937     case UO_AddrOf: {
 938       // Process pointer-to-member address operation.
 939       const Expr *Ex = U->getSubExpr()->IgnoreParens();
 940       if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex)) {
 941         const ValueDecl *VD = DRE->getDecl();
 942
 943         if (isa<CXXMethodDecl>(VD) || isa<FieldDecl>(VD)) {
 944           ProgramStateRef State = (*I)->getState();
 945           const LocationContext *LCtx = (*I)->getLocationContext();
 946           SVal SV = svalBuilder.getMemberPointer(cast<DeclaratorDecl>(VD));
 947           Bldr.generateNode(U, *I, State->BindExpr(U, LCtx, SV));
 948           break;
 949         }
 950       }
 951       // Explicitly proceed with default handler for this case cascade.
 952       handleUOExtension(I, U, Bldr);
 953       break;
 954     }
 955     case UO_Plus:
 956       assert(!U->isGLValue());
 957       // FALL-THROUGH.
 958     case UO_Deref:
 959     case UO_Extension: {
 960       handleUOExtension(I, U, Bldr);
 961       break;
 962     }
 963
 964     case UO_LNot:
 965     case UO_Minus:
 966     case UO_Not: {
 967       assert (!U->isGLValue());
 968       const Expr *Ex = U->getSubExpr()->IgnoreParens();
 969       ProgramStateRef state = (*I)->getState();
 970       const LocationContext *LCtx = (*I)->getLocationContext();
 971
 972       // Get the value of the subexpression.
 973       SVal V = state->getSVal(Ex, LCtx);
 974
 975       if (V.isUnknownOrUndef()) {
 976         Bldr.generateNode(U, *I, state->BindExpr(U, LCtx, V));
 977         break;
 978       }
 979
 980       switch (U->getOpcode()) {
 981         default:
 982           llvm_unreachable("Invalid Opcode.");
 983         case UO_Not:
 984           // FIXME: Do we need to handle promotions?
 985           state = state->BindExpr(U, LCtx, evalComplement(V.castAs<NonLoc>()));
 986           break;
 987         case UO_Minus:
 988           // FIXME: Do we need to handle promotions?
 989           state = state->BindExpr(U, LCtx, evalMinus(V.castAs<NonLoc>()));
 990           break;
 991         case UO_LNot:
 992           // C99 6.5.3.3: "The expression !E is equivalent to (0==E)."
 993           //
 994           //  Note: technically we do "E == 0", but this is the same in the
 995           //    transfer functions as "0 == E".
 996           SVal Result;
 997           if (Optional<Loc> LV = V.getAs<Loc>()) {
 998             Loc X = svalBuilder.makeNullWithType(Ex->getType());
 999             Result = evalBinOp(state, BO_EQ, *LV, X, U->getType());
1000           } else if (Ex->getType()->isFloatingType()) {
1001             // FIXME: handle floating point types.
1002             Result = UnknownVal();
1003           } else {
1004             nonloc::ConcreteInt X(getBasicVals().getValue(0, Ex->getType()));
1005             Result = evalBinOp(state, BO_EQ, V.castAs<NonLoc>(), X,
1006                                U->getType());
1007           }
1008
1009           state = state->BindExpr(U, LCtx, Result);
1010           break;
1011       }
1012       Bldr.generateNode(U, *I, state);
1013       break;
1014     }
1015     }
1016   }
1017
1018   getCheckerManager().runCheckersForPostStmt(Dst, EvalSet, U, *this);
1019 }
1020
1021 void ExprEngine::VisitIncrementDecrementOperator(const UnaryOperator* U,
1022                                                  ExplodedNode *Pred,
1023                                                  ExplodedNodeSet &Dst) {
1024   // Handle ++ and -- (both pre- and post-increment).
1025   assert (U->isIncrementDecrementOp());
1026   const Expr *Ex = U->getSubExpr()->IgnoreParens();
1027
1028   const LocationContext *LCtx = Pred->getLocationContext();
1029   ProgramStateRef state = Pred->getState();
1030   SVal loc = state->getSVal(Ex, LCtx);
1031
1032   // Perform a load.
1033   ExplodedNodeSet Tmp;
1034   evalLoad(Tmp, U, Ex, Pred, state, loc);
1035
1036   ExplodedNodeSet Dst2;
1037   StmtNodeBuilder Bldr(Tmp, Dst2, *currBldrCtx);
1038   for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end();I!=E;++I) {
1039
1040     state = (*I)->getState();
1041     assert(LCtx == (*I)->getLocationContext());
1042     SVal V2_untested = state->getSVal(Ex, LCtx);
1043
1044     // Propagate unknown and undefined values.
1045     if (V2_untested.isUnknownOrUndef()) {
1046       state = state->BindExpr(U, LCtx, V2_untested);
1047
1048       // Perform the store, so that the uninitialized value detection happens.
1049       Bldr.takeNodes(*I);
1050       ExplodedNodeSet Dst3;
1051       evalStore(Dst3, U, U, *I, state, loc, V2_untested);
1052       Bldr.addNodes(Dst3);
1053
1054       continue;
1055     }
1056     DefinedSVal V2 = V2_untested.castAs<DefinedSVal>();
1057
1058     // Handle all other values.
1059     BinaryOperator::Opcode Op = U->isIncrementOp() ? BO_Add : BO_Sub;
1060
1061     // If the UnaryOperator has non-location type, use its type to create the
1062     // constant value. If the UnaryOperator has location type, create the
1063     // constant with int type and pointer width.
1064     SVal RHS;
1065
1066     if (U->getType()->isAnyPointerType())
1067       RHS = svalBuilder.makeArrayIndex(1);
1068     else if (U->getType()->isIntegralOrEnumerationType())
1069       RHS = svalBuilder.makeIntVal(1, U->getType());
1070     else
1071       RHS = UnknownVal();
1072
1073     SVal Result = evalBinOp(state, Op, V2, RHS, U->getType());
1074
1075     // Conjure a new symbol if necessary to recover precision.
1076     if (Result.isUnknown()){
1077       DefinedOrUnknownSVal SymVal =
1078         svalBuilder.conjureSymbolVal(nullptr, U, LCtx,
1079                                      currBldrCtx->blockCount());
1080       Result = SymVal;
1081
1082       // If the value is a location, ++/-- should always preserve
1083       // non-nullness.  Check if the original value was non-null, and if so
1084       // propagate that constraint.
1085       if (Loc::isLocType(U->getType())) {
1086         DefinedOrUnknownSVal Constraint =
1087         svalBuilder.evalEQ(state, V2,svalBuilder.makeZeroVal(U->getType()));
1088
1089         if (!state->assume(Constraint, true)) {
1090           // It isn't feasible for the original value to be null.
1091           // Propagate this constraint.
1092           Constraint = svalBuilder.evalEQ(state, SymVal,
1093                                        svalBuilder.makeZeroVal(U->getType()));
1094
1095
1096           state = state->assume(Constraint, false);
1097           assert(state);
1098         }
1099       }
1100     }
1101
1102     // Since the lvalue-to-rvalue conversion is explicit in the AST,
1103     // we bind an l-value if the operator is prefix and an lvalue (in C++).
1104     if (U->isGLValue())
1105       state = state->BindExpr(U, LCtx, loc);
1106     else
1107       state = state->BindExpr(U, LCtx, U->isPostfix() ? V2 : Result);
1108
1109     // Perform the store.
1110     Bldr.takeNodes(*I);
1111     ExplodedNodeSet Dst3;
1112     evalStore(Dst3, U, U, *I, state, loc, Result);
1113     Bldr.addNodes(Dst3);
1114   }
1115   Dst.insert(Dst2);
1116 }