Index: examples/analyzer-plugin/MainCallChecker.cpp =================================================================== --- examples/analyzer-plugin/MainCallChecker.cpp +++ examples/analyzer-plugin/MainCallChecker.cpp @@ -16,10 +16,8 @@ } // end anonymous namespace void MainCallChecker::checkPreStmt(const CallExpr *CE, CheckerContext &C) const { - const ProgramStateRef state = C.getState(); - const LocationContext *LC = C.getLocationContext(); const Expr *Callee = CE->getCallee(); - const FunctionDecl *FD = state->getSVal(Callee, LC).getAsFunctionDecl(); + const FunctionDecl *FD = C.getSVal(Callee).getAsFunctionDecl(); if (!FD) return; Index: include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h =================================================================== --- include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h +++ include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h @@ -193,7 +193,7 @@ /// \brief Get the value of arbitrary expressions at this point in the path. SVal getSVal(const Stmt *S) const { - return getState()->getSVal(S, getLocationContext()); + return Pred->getSVal(S); } /// \brief Returns true if the value of \p E is greater than or equal to \p Index: include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h =================================================================== --- include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h +++ include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h @@ -156,6 +156,11 @@ return Location.getAs(); } + /// Get the value of an arbitrary expression at this node. + SVal getSVal(const Stmt *S) const { + return getState()->getSVal(S, getLocationContext()); + } + static void Profile(llvm::FoldingSetNodeID &ID, const ProgramPoint &Loc, const ProgramStateRef &state, Index: lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp +++ lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp @@ -436,8 +436,7 @@ return; // Get the value of the "theType" argument. - const LocationContext *LCtx = C.getLocationContext(); - SVal TheTypeVal = state->getSVal(CE->getArg(1), LCtx); + SVal TheTypeVal = C.getSVal(CE->getArg(1)); // FIXME: We really should allow ranges of valid theType values, and // bifurcate the state appropriately. @@ -457,7 +456,7 @@ // Look at the value of the integer being passed by reference. Essentially // we want to catch cases where the value passed in is not equal to the // size of the type being created. - SVal TheValueExpr = state->getSVal(CE->getArg(2), LCtx); + SVal TheValueExpr = C.getSVal(CE->getArg(2)); // FIXME: Eventually we should handle arbitrary locations. We can do this // by having an enhanced memory model that does low-level typing. @@ -571,7 +570,7 @@ // Get the argument's value. const Expr *Arg = CE->getArg(0); - SVal ArgVal = state->getSVal(Arg, C.getLocationContext()); + SVal ArgVal = C.getSVal(Arg); Optional DefArgVal = ArgVal.getAs(); if (!DefArgVal) return; @@ -977,8 +976,7 @@ if (!State) return nullptr; - SymbolRef CollectionS = - State->getSVal(FCS->getCollection(), C.getLocationContext()).getAsSymbol(); + SymbolRef CollectionS = C.getSVal(FCS->getCollection()).getAsSymbol(); return assumeCollectionNonEmpty(C, State, CollectionS, Assumption); } @@ -1206,7 +1204,7 @@ ObjCNonNilReturnValueChecker::assumeExprIsNonNull(const Expr *NonNullExpr, ProgramStateRef State, CheckerContext &C) const { - SVal Val = State->getSVal(NonNullExpr, C.getLocationContext()); + SVal Val = C.getSVal(NonNullExpr); if (Optional DV = Val.getAs()) return State->assume(*DV, true); return State; Index: lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp +++ lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp @@ -43,7 +43,7 @@ case Builtin::BI__builtin_assume: { assert (CE->arg_begin() != CE->arg_end()); - SVal ArgSVal = state->getSVal(CE->getArg(0), LCtx); + SVal ArgSVal = C.getSVal(CE->getArg(0)); if (ArgSVal.isUndef()) return true; // Return true to model purity. @@ -68,7 +68,7 @@ // __builtin_addressof is going from a reference to a pointer, but those // are represented the same way in the analyzer. assert (CE->arg_begin() != CE->arg_end()); - SVal X = state->getSVal(*(CE->arg_begin()), LCtx); + SVal X = C.getSVal(*(CE->arg_begin())); C.addTransition(state->BindExpr(CE, LCtx, X)); return true; } @@ -84,7 +84,7 @@ // SVal of the argument directly. If we save the extent in bits, we // cannot represent values like symbol*8. DefinedOrUnknownSVal Size = - state->getSVal(*(CE->arg_begin()), LCtx).castAs(); + C.getSVal(*(CE->arg_begin())).castAs(); SValBuilder& svalBuilder = C.getSValBuilder(); DefinedOrUnknownSVal Extent = R->getExtent(svalBuilder); Index: lib/StaticAnalyzer/Checkers/CStringChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/CStringChecker.cpp +++ lib/StaticAnalyzer/Checkers/CStringChecker.cpp @@ -366,7 +366,7 @@ QualType PtrTy = Ctx.getPointerType(Ctx.CharTy); // Check that the first buffer is non-null. - SVal BufVal = state->getSVal(FirstBuf, LCtx); + SVal BufVal = C.getSVal(FirstBuf); state = checkNonNull(C, state, FirstBuf, BufVal); if (!state) return nullptr; @@ -378,7 +378,7 @@ // Get the access length and make sure it is known. // FIXME: This assumes the caller has already checked that the access length // is positive. And that it's unsigned. - SVal LengthVal = state->getSVal(Size, LCtx); + SVal LengthVal = C.getSVal(Size); Optional Length = LengthVal.getAs(); if (!Length) return state; @@ -2149,7 +2149,7 @@ if (!MR) continue; - SVal StrVal = state->getSVal(Init, C.getLocationContext()); + SVal StrVal = C.getSVal(Init); assert(StrVal.isValid() && "Initializer string is unknown or undefined"); DefinedOrUnknownSVal strLength = getCStringLength(C, state, Init, StrVal).castAs(); Index: lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp +++ lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp @@ -101,7 +101,7 @@ return; ProgramStateRef state = C.getState(); - const MemRegion *R = state->getSVal(E, C.getLocationContext()).getAsRegion(); + const MemRegion *R = C.getSVal(E).getAsRegion(); if (!R) return; Index: lib/StaticAnalyzer/Checkers/ChrootChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/ChrootChecker.cpp +++ lib/StaticAnalyzer/Checkers/ChrootChecker.cpp @@ -105,7 +105,7 @@ // After chdir("/"), enter the jail, set the enum value JAIL_ENTERED. const Expr *ArgExpr = CE->getArg(0); - SVal ArgVal = state->getSVal(ArgExpr, C.getLocationContext()); + SVal ArgVal = C.getSVal(ArgExpr); if (const MemRegion *R = ArgVal.getAsRegion()) { R = R->StripCasts(); Index: lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp +++ lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp @@ -110,8 +110,6 @@ if (Satisfied) return nullptr; - ProgramStateRef State = N->getState(); - const LocationContext *LC = N->getLocationContext(); const Stmt *S = PathDiagnosticLocation::getStmt(N); if (!S) return nullptr; @@ -128,7 +126,7 @@ } // Region associated with the current cast expression. - const MemRegion *M = State->getSVal(CastE, LC).getAsRegion(); + const MemRegion *M = N->getSVal(CastE).getAsRegion(); if (!M) return nullptr; Index: lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp +++ lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp @@ -57,7 +57,7 @@ if (!B->getRHS()->getType()->isScalarType()) return; - SVal Denom = C.getState()->getSVal(B->getRHS(), C.getLocationContext()); + SVal Denom = C.getSVal(B->getRHS()); Optional DV = Denom.getAs(); // Divide-by-undefined handled in the generic checking for uses of Index: lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp +++ lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp @@ -562,7 +562,7 @@ DestObjectPtrType->isUnspecialized()) return; - SymbolRef Sym = State->getSVal(CE, C.getLocationContext()).getAsSymbol(); + SymbolRef Sym = C.getSVal(CE).getAsSymbol(); if (!Sym) return; Index: lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp +++ lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp @@ -44,8 +44,7 @@ if (!T->isPointerType()) return; - ProgramStateRef state = C.getState(); - SVal RV = state->getSVal(B->getRHS(), C.getLocationContext()); + SVal RV = C.getSVal(B->getRHS()); if (!RV.isConstant() || RV.isZeroConstant()) return; Index: lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp +++ lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp @@ -468,7 +468,7 @@ Optional GenericTaintChecker::getPointedToSVal(CheckerContext &C, const Expr *Arg) { ProgramStateRef State = C.getState(); - SVal AddrVal = State->getSVal(Arg->IgnoreParens(), C.getLocationContext()); + SVal AddrVal = C.getSVal(Arg->IgnoreParens()); if (AddrVal.isUnknownOrUndef()) return None; @@ -621,7 +621,7 @@ bool GenericTaintChecker::isStdin(const Expr *E, CheckerContext &C) { ProgramStateRef State = C.getState(); - SVal Val = State->getSVal(E, C.getLocationContext()); + SVal Val = C.getSVal(E); // stdin is a pointer, so it would be a region. const MemRegion *MemReg = Val.getAsRegion(); Index: lib/StaticAnalyzer/Checkers/IteratorChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/IteratorChecker.cpp +++ lib/StaticAnalyzer/Checkers/IteratorChecker.cpp @@ -355,12 +355,11 @@ CheckerContext &C) const { /* Transfer iterator state to temporary objects */ auto State = C.getState(); - const auto *LCtx = C.getLocationContext(); const auto *Pos = - getIteratorPosition(State, State->getSVal(MTE->GetTemporaryExpr(), LCtx)); + getIteratorPosition(State, C.getSVal(MTE->GetTemporaryExpr())); if (!Pos) return; - State = setIteratorPosition(State, State->getSVal(MTE, LCtx), *Pos); + State = setIteratorPosition(State, C.getSVal(MTE), *Pos); C.addTransition(State); } Index: lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp +++ lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp @@ -1018,7 +1018,7 @@ return nullptr; ProgramStateRef State = Succ->getState(); - SVal LiteralSVal = State->getSVal(LiteralExpr, Succ->getLocationContext()); + SVal LiteralSVal = Succ->getSVal(LiteralExpr); if (LiteralSVal.getAsRegion() != NonLocalizedString) return nullptr; Index: lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp +++ lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp @@ -202,7 +202,7 @@ static SymbolRef getAsPointeeSymbol(const Expr *Expr, CheckerContext &C) { ProgramStateRef State = C.getState(); - SVal ArgV = State->getSVal(Expr, C.getLocationContext()); + SVal ArgV = C.getSVal(Expr); if (Optional X = ArgV.getAs()) { StoreManager& SM = C.getStoreManager(); @@ -297,7 +297,7 @@ // Check the argument to the deallocator. const Expr *ArgExpr = CE->getArg(paramIdx); - SVal ArgSVal = State->getSVal(ArgExpr, C.getLocationContext()); + SVal ArgSVal = C.getSVal(ArgExpr); // Undef is reported by another checker. if (ArgSVal.isUndef()) @@ -426,8 +426,7 @@ // allocated value symbol, since our diagnostics depend on the value // returned by the call. Ex: Data should only be freed if noErr was // returned during allocation.) - SymbolRef RetStatusSymbol = - State->getSVal(CE, C.getLocationContext()).getAsSymbol(); + SymbolRef RetStatusSymbol = C.getSVal(CE).getAsSymbol(); C.getSymbolManager().addSymbolDependency(V, RetStatusSymbol); // Track the allocated value in the checker state. Index: lib/StaticAnalyzer/Checkers/MallocChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/MallocChecker.cpp +++ lib/StaticAnalyzer/Checkers/MallocChecker.cpp @@ -758,7 +758,7 @@ return None; const Expr *FlagsEx = CE->getArg(CE->getNumArgs() - 1); - const SVal V = State->getSVal(FlagsEx, C.getLocationContext()); + const SVal V = C.getSVal(FlagsEx); if (!V.getAs()) { // The case where 'V' can be a location can only be due to a bad header, // so in this case bail out. @@ -972,8 +972,7 @@ assert(Arg); - Optional DefArgVal = - State->getSVal(Arg, C.getLocationContext()).getAs(); + Optional DefArgVal = C.getSVal(Arg).getAs(); if (!DefArgVal) return State; @@ -988,7 +987,7 @@ State->assume(SvalBuilder.evalEQ(State, *DefArgVal, Zero)); if (TrueState && !FalseState) { - SVal retVal = State->getSVal(E, C.getLocationContext()); + SVal retVal = C.getSVal(E); SymbolRef Sym = retVal.getAsLocSymbol(); if (!Sym) return State; @@ -1092,7 +1091,7 @@ const SubRegion *Region; if (NE->isArray()) { const Expr *SizeExpr = NE->getArraySize(); - ElementCount = State->getSVal(SizeExpr, C.getLocationContext()); + ElementCount = C.getSVal(SizeExpr); // Store the extent size for the (symbolic)region // containing the elements. Region = (State->getSVal(NE, LCtx)) @@ -1212,8 +1211,7 @@ if (!State) return nullptr; - return MallocMemAux(C, CE, State->getSVal(SizeEx, C.getLocationContext()), - Init, State, Family); + return MallocMemAux(C, CE, C.getSVal(SizeEx), Init, State, Family); } ProgramStateRef MallocChecker::MallocMemAux(CheckerContext &C, @@ -1268,7 +1266,7 @@ return nullptr; // Get the return value. - SVal retVal = State->getSVal(E, C.getLocationContext()); + SVal retVal = C.getSVal(E); // We expect the malloc functions to return a pointer. if (!retVal.getAs()) @@ -1457,7 +1455,7 @@ if (!State) return nullptr; - SVal ArgVal = State->getSVal(ArgExpr, C.getLocationContext()); + SVal ArgVal = C.getSVal(ArgExpr); if (!ArgVal.getAs()) return nullptr; DefinedOrUnknownSVal location = ArgVal.castAs(); @@ -2084,8 +2082,7 @@ return nullptr; const Expr *arg0Expr = CE->getArg(0); - const LocationContext *LCtx = C.getLocationContext(); - SVal Arg0Val = State->getSVal(arg0Expr, LCtx); + SVal Arg0Val = C.getSVal(arg0Expr); if (!Arg0Val.getAs()) return nullptr; DefinedOrUnknownSVal arg0Val = Arg0Val.castAs(); @@ -2099,7 +2096,7 @@ const Expr *Arg1 = CE->getArg(1); // Get the value of the size argument. - SVal TotalSize = State->getSVal(Arg1, LCtx); + SVal TotalSize = C.getSVal(Arg1); if (SuffixWithN) TotalSize = evalMulForBufferSize(C, Arg1, CE->getArg(2)); if (!TotalSize.getAs()) @@ -2133,7 +2130,7 @@ // Get the from and to pointer symbols as in toPtr = realloc(fromPtr, size). assert(!PrtIsNull); SymbolRef FromPtr = arg0Val.getAsSymbol(); - SVal RetVal = State->getSVal(CE, LCtx); + SVal RetVal = C.getSVal(CE); SymbolRef ToPtr = RetVal.getAsSymbol(); if (!FromPtr || !ToPtr) return nullptr; @@ -2406,7 +2403,7 @@ // Check if we are returning a symbol. ProgramStateRef State = C.getState(); - SVal RetVal = State->getSVal(E, C.getLocationContext()); + SVal RetVal = C.getSVal(E); SymbolRef Sym = RetVal.getAsSymbol(); if (!Sym) // If we are returning a field of the allocated struct or an array element, @@ -2436,8 +2433,7 @@ ProgramStateRef state = C.getState(); const BlockDataRegion *R = - cast(state->getSVal(BE, - C.getLocationContext()).getAsRegion()); + cast(C.getSVal(BE).getAsRegion()); BlockDataRegion::referenced_vars_iterator I = R->referenced_vars_begin(), E = R->referenced_vars_end(); Index: lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp +++ lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp @@ -560,8 +560,7 @@ if (State->get()) return; - auto RetSVal = - State->getSVal(S, C.getLocationContext()).getAs(); + auto RetSVal = C.getSVal(S).getAs(); if (!RetSVal) return; @@ -977,8 +976,7 @@ if (DestNullability == Nullability::Unspecified) return; - auto RegionSVal = - State->getSVal(CE, C.getLocationContext()).getAs(); + auto RegionSVal = C.getSVal(CE).getAs(); const MemRegion *Region = getTrackRegion(*RegionSVal); if (!Region) return; Index: lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp +++ lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp @@ -39,7 +39,7 @@ const Expr *Ex = S->getSynchExpr(); ProgramStateRef state = C.getState(); - SVal V = state->getSVal(Ex, C.getLocationContext()); + SVal V = C.getSVal(Ex); // Uninitialized value used for the mutex? if (V.getAs()) { Index: lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp +++ lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp @@ -39,7 +39,7 @@ } inline SymbolRef getArraySym(const Expr *E, CheckerContext &C) const { - SVal ArrayRef = C.getState()->getSVal(E, C.getLocationContext()); + SVal ArrayRef = C.getSVal(E); SymbolRef ArraySym = ArrayRef.getAsSymbol(); return ArraySym; } @@ -66,13 +66,13 @@ void ObjCContainersChecker::addSizeInfo(const Expr *Array, const Expr *Size, CheckerContext &C) const { ProgramStateRef State = C.getState(); - SVal SizeV = State->getSVal(Size, C.getLocationContext()); + SVal SizeV = C.getSVal(Size); // Undefined is reported by another checker. if (SizeV.isUnknownOrUndef()) return; // Get the ArrayRef symbol. - SVal ArrayRef = State->getSVal(Array, C.getLocationContext()); + SVal ArrayRef = C.getSVal(Array); SymbolRef ArraySym = ArrayRef.getAsSymbol(); if (!ArraySym) return; @@ -128,7 +128,7 @@ // Get the index. const Expr *IdxExpr = CE->getArg(1); - SVal IdxVal = State->getSVal(IdxExpr, C.getLocationContext()); + SVal IdxVal = C.getSVal(IdxExpr); if (IdxVal.isUnknownOrUndef()) return; DefinedSVal Idx = IdxVal.castAs(); Index: lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp +++ lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp @@ -132,7 +132,7 @@ /// points to and is an object that did not come from the result of calling /// an initializer. static bool isInvalidSelf(const Expr *E, CheckerContext &C) { - SVal exprVal = C.getState()->getSVal(E, C.getLocationContext()); + SVal exprVal = C.getSVal(E); if (!hasSelfFlag(exprVal, SelfFlag_Self, C)) return false; // value did not come from 'self'. if (hasSelfFlag(exprVal, SelfFlag_InitRes, C)) @@ -183,7 +183,7 @@ // value out when we return from this method. state = state->set(true); - SVal V = state->getSVal(Msg.getOriginExpr(), C.getLocationContext()); + SVal V = C.getSVal(Msg.getOriginExpr()); addSelfFlag(state, V, SelfFlag_InitRes, C); return; } Index: lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp +++ lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp @@ -154,8 +154,7 @@ return; ProgramStateRef State = C.getState(); - const MemRegion *Region = - State->getSVal(E, C.getLocationContext()).getAsRegion(); + const MemRegion *Region = C.getSVal(E).getAsRegion(); if (!Region) return; if (PointedNeeded) @@ -227,7 +226,7 @@ if (AllocFunctions.count(FunI) == 0) return; - SVal SV = State->getSVal(CE, C.getLocationContext()); + SVal SV = C.getSVal(CE); const MemRegion *Region = SV.getAsRegion(); if (!Region) return; @@ -248,7 +247,7 @@ AllocKind Kind = getKindOfNewOp(NE, FD); ProgramStateRef State = C.getState(); - SVal AllocedVal = State->getSVal(NE, C.getLocationContext()); + SVal AllocedVal = C.getSVal(NE); const MemRegion *Region = AllocedVal.getAsRegion(); if (!Region) return; @@ -263,7 +262,7 @@ const Expr *CastedExpr = CE->getSubExpr(); ProgramStateRef State = C.getState(); - SVal CastedVal = State->getSVal(CastedExpr, C.getLocationContext()); + SVal CastedVal = C.getSVal(CastedExpr); const MemRegion *Region = CastedVal.getAsRegion(); if (!Region) @@ -281,7 +280,7 @@ const Expr *CastedExpr = CE->getSubExpr(); ProgramStateRef State = C.getState(); - SVal CastedVal = State->getSVal(CastedExpr, C.getLocationContext()); + SVal CastedVal = C.getSVal(CastedExpr); const MemRegion *Region = CastedVal.getAsRegion(); if (!Region) @@ -304,8 +303,7 @@ void PointerArithChecker::checkPreStmt(const ArraySubscriptExpr *SubsExpr, CheckerContext &C) const { - ProgramStateRef State = C.getState(); - SVal Idx = State->getSVal(SubsExpr->getIdx(), C.getLocationContext()); + SVal Idx = C.getSVal(SubsExpr->getIdx()); // Indexing with 0 is OK. if (Idx.isZeroConstant()) @@ -324,14 +322,14 @@ ProgramStateRef State = C.getState(); if (Rhs->getType()->isIntegerType() && Lhs->getType()->isPointerType()) { - SVal RHSVal = State->getSVal(Rhs, C.getLocationContext()); + SVal RHSVal = C.getSVal(Rhs); if (State->isNull(RHSVal).isConstrainedTrue()) return; reportPointerArithMisuse(Lhs, C, !BOp->isAdditiveOp()); } // The int += ptr; case is not valid C++. if (Lhs->getType()->isIntegerType() && Rhs->getType()->isPointerType()) { - SVal LHSVal = State->getSVal(Lhs, C.getLocationContext()); + SVal LHSVal = C.getSVal(Lhs); if (State->isNull(LHSVal).isConstrainedTrue()) return; reportPointerArithMisuse(Rhs, C); Index: lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp +++ lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp @@ -39,10 +39,8 @@ if (B->getOpcode() != BO_Sub) return; - ProgramStateRef state = C.getState(); - const LocationContext *LCtx = C.getLocationContext(); - SVal LV = state->getSVal(B->getLHS(), LCtx); - SVal RV = state->getSVal(B->getRHS(), LCtx); + SVal LV = C.getSVal(B->getLHS()); + SVal RV = C.getSVal(B->getRHS()); const MemRegion *LR = LV.getAsRegion(); const MemRegion *RR = RV.getAsRegion(); Index: lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp +++ lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp @@ -109,8 +109,6 @@ void PthreadLockChecker::checkPostStmt(const CallExpr *CE, CheckerContext &C) const { - ProgramStateRef state = C.getState(); - const LocationContext *LCtx = C.getLocationContext(); StringRef FName = C.getCalleeName(CE); if (FName.empty()) return; @@ -121,34 +119,31 @@ if (FName == "pthread_mutex_lock" || FName == "pthread_rwlock_rdlock" || FName == "pthread_rwlock_wrlock") - AcquireLock(C, CE, state->getSVal(CE->getArg(0), LCtx), - false, PthreadSemantics); + AcquireLock(C, CE, C.getSVal(CE->getArg(0)), false, PthreadSemantics); else if (FName == "lck_mtx_lock" || FName == "lck_rw_lock_exclusive" || FName == "lck_rw_lock_shared") - AcquireLock(C, CE, state->getSVal(CE->getArg(0), LCtx), - false, XNUSemantics); + AcquireLock(C, CE, C.getSVal(CE->getArg(0)), false, XNUSemantics); else if (FName == "pthread_mutex_trylock" || FName == "pthread_rwlock_tryrdlock" || FName == "pthread_rwlock_trywrlock") - AcquireLock(C, CE, state->getSVal(CE->getArg(0), LCtx), + AcquireLock(C, CE, C.getSVal(CE->getArg(0)), true, PthreadSemantics); else if (FName == "lck_mtx_try_lock" || FName == "lck_rw_try_lock_exclusive" || FName == "lck_rw_try_lock_shared") - AcquireLock(C, CE, state->getSVal(CE->getArg(0), LCtx), - true, XNUSemantics); + AcquireLock(C, CE, C.getSVal(CE->getArg(0)), true, XNUSemantics); else if (FName == "pthread_mutex_unlock" || FName == "pthread_rwlock_unlock" || FName == "lck_mtx_unlock" || FName == "lck_rw_done") - ReleaseLock(C, CE, state->getSVal(CE->getArg(0), LCtx)); + ReleaseLock(C, CE, C.getSVal(CE->getArg(0))); else if (FName == "pthread_mutex_destroy") - DestroyLock(C, CE, state->getSVal(CE->getArg(0), LCtx), PthreadSemantics); + DestroyLock(C, CE, C.getSVal(CE->getArg(0)), PthreadSemantics); else if (FName == "lck_mtx_destroy") - DestroyLock(C, CE, state->getSVal(CE->getArg(0), LCtx), XNUSemantics); + DestroyLock(C, CE, C.getSVal(CE->getArg(0)), XNUSemantics); else if (FName == "pthread_mutex_init") - InitLock(C, CE, state->getSVal(CE->getArg(0), LCtx)); + InitLock(C, CE, C.getSVal(CE->getArg(0))); } // When a lock is destroyed, in some semantics(like PthreadSemantics) we are not @@ -232,7 +227,7 @@ if (sym) state = resolvePossiblyDestroyedMutex(state, lockR, sym); - SVal X = state->getSVal(CE, C.getLocationContext()); + SVal X = C.getSVal(CE); if (X.isUnknownOrUndef()) return; Index: lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp +++ lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp @@ -2799,9 +2799,7 @@ return; ProgramStateRef state = C.getState(); - const BlockDataRegion *R = - cast(state->getSVal(BE, - C.getLocationContext()).getAsRegion()); + auto *R = cast(C.getSVal(BE).getAsRegion()); BlockDataRegion::referenced_vars_iterator I = R->referenced_vars_begin(), E = R->referenced_vars_end(); @@ -2851,7 +2849,7 @@ } ProgramStateRef state = C.getState(); - SymbolRef Sym = state->getSVal(CE, C.getLocationContext()).getAsLocSymbol(); + SymbolRef Sym = C.getSVal(CE).getAsLocSymbol(); if (!Sym) return; const RefVal* T = getRefBinding(state, Sym); @@ -2874,7 +2872,7 @@ ProgramStateRef state = C.getState(); const ExplodedNode *pred = C.getPredecessor(); for (const Stmt *Child : Ex->children()) { - SVal V = state->getSVal(Child, pred->getLocationContext()); + SVal V = pred->getSVal(Child); if (SymbolRef sym = V.getAsSymbol()) if (const RefVal* T = getRefBinding(state, sym)) { RefVal::Kind hasErr = (RefVal::Kind) 0; @@ -2913,10 +2911,9 @@ void RetainCountChecker::checkPostStmt(const ObjCBoxedExpr *Ex, CheckerContext &C) const { const ExplodedNode *Pred = C.getPredecessor(); - const LocationContext *LCtx = Pred->getLocationContext(); ProgramStateRef State = Pred->getState(); - if (SymbolRef Sym = State->getSVal(Ex, LCtx).getAsSymbol()) { + if (SymbolRef Sym = Pred->getSVal(Ex).getAsSymbol()) { QualType ResultTy = Ex->getType(); State = setRefBinding(State, Sym, RefVal::makeNotOwned(RetEffect::ObjC, ResultTy)); Index: lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp +++ lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp @@ -40,7 +40,7 @@ if (!RetE) return; - SVal V = state->getSVal(RetE, C.getLocationContext()); + SVal V = C.getSVal(RetE); const MemRegion *R = V.getAsRegion(); const ElementRegion *ER = dyn_cast_or_null(R); Index: lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp +++ lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp @@ -255,8 +255,7 @@ return; RetE = RetE->IgnoreParens(); - const LocationContext *LCtx = C.getLocationContext(); - SVal V = C.getState()->getSVal(RetE, LCtx); + SVal V = C.getSVal(RetE); const MemRegion *R = V.getAsRegion(); if (!R) return; Index: lib/StaticAnalyzer/Checkers/StreamChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/StreamChecker.cpp +++ lib/StaticAnalyzer/Checkers/StreamChecker.cpp @@ -242,22 +242,19 @@ void StreamChecker::Fread(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(3), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(3)), state, C)) return; } void StreamChecker::Fwrite(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(3), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(3)), state, C)) return; } void StreamChecker::Fseek(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!(state = CheckNullStream(state->getSVal(CE->getArg(0), - C.getLocationContext()), state, C))) + if (!(state = CheckNullStream(C.getSVal(CE->getArg(0)), state, C))) return; // Check the legality of the 'whence' argument of 'fseek'. SVal Whence = state->getSVal(CE->getArg(2), C.getLocationContext()); @@ -283,57 +280,49 @@ void StreamChecker::Ftell(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C)) return; } void StreamChecker::Rewind(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C)) return; } void StreamChecker::Fgetpos(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C)) return; } void StreamChecker::Fsetpos(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C)) return; } void StreamChecker::Clearerr(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C)) return; } void StreamChecker::Feof(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C)) return; } void StreamChecker::Ferror(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C)) return; } void StreamChecker::Fileno(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef state = C.getState(); - if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()), - state, C)) + if (!CheckNullStream(C.getSVal(CE->getArg(0)), state, C)) return; } @@ -363,8 +352,7 @@ ProgramStateRef StreamChecker::CheckDoubleClose(const CallExpr *CE, ProgramStateRef state, CheckerContext &C) const { - SymbolRef Sym = - state->getSVal(CE->getArg(0), C.getLocationContext()).getAsSymbol(); + SymbolRef Sym = C.getSVal(CE->getArg(0)).getAsSymbol(); if (!Sym) return state; Index: lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp +++ lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp @@ -114,8 +114,7 @@ if (!E) return nullptr; - ProgramStateRef State = Succ->getState(); - SVal S = State->getSVal(E, Succ->getLocationContext()); + SVal S = Succ->getSVal(E); if (ZeroSymbol == S.getAsSymbol() && SFC == Succ->getStackFrame()) { Satisfied = true; Index: lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp +++ lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp @@ -59,7 +59,7 @@ void UndefBranchChecker::checkBranchCondition(const Stmt *Condition, CheckerContext &Ctx) const { - SVal X = Ctx.getState()->getSVal(Condition, Ctx.getLocationContext()); + SVal X = Ctx.getSVal(Condition); if (X.isUndef()) { // Generate a sink node, which implicitly marks both outgoing branches as // infeasible. Index: lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp +++ lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp @@ -55,9 +55,7 @@ return; ProgramStateRef state = C.getState(); - const BlockDataRegion *R = - cast(state->getSVal(BE, - C.getLocationContext()).getAsRegion()); + auto *R = cast(C.getSVal(BE).getAsRegion()); BlockDataRegion::referenced_vars_iterator I = R->referenced_vars_begin(), E = R->referenced_vars_end(); Index: lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp +++ lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp @@ -37,12 +37,11 @@ static bool isArrayIndexOutOfBounds(CheckerContext &C, const Expr *Ex) { ProgramStateRef state = C.getState(); - const LocationContext *LCtx = C.getLocationContext(); if (!isa(Ex)) return false; - SVal Loc = state->getSVal(Ex, LCtx); + SVal Loc = C.getSVal(Ex); if (!Loc.isValid()) return false; @@ -66,9 +65,7 @@ void UndefResultChecker::checkPostStmt(const BinaryOperator *B, CheckerContext &C) const { - ProgramStateRef state = C.getState(); - const LocationContext *LCtx = C.getLocationContext(); - if (state->getSVal(B, LCtx).isUndef()) { + if (C.getSVal(B).isUndef()) { // Do not report assignments of uninitialized values inside swap functions. // This should allow to swap partially uninitialized structs @@ -92,11 +89,11 @@ const Expr *Ex = nullptr; bool isLeft = true; - if (state->getSVal(B->getLHS(), LCtx).isUndef()) { + if (C.getSVal(B->getLHS()).isUndef()) { Ex = B->getLHS()->IgnoreParenCasts(); isLeft = true; } - else if (state->getSVal(B->getRHS(), LCtx).isUndef()) { + else if (C.getSVal(B->getRHS()).isUndef()) { Ex = B->getRHS()->IgnoreParenCasts(); isLeft = false; } Index: lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp +++ lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp @@ -70,8 +70,7 @@ if (const BinaryOperator *B = dyn_cast(StoreE)) { if (B->isCompoundAssignmentOp()) { - ProgramStateRef state = C.getState(); - if (state->getSVal(B->getLHS(), C.getLocationContext()).isUndef()) { + if (C.getSVal(B->getLHS()).isUndef()) { str = "The left expression of the compound assignment is an " "uninitialized value. The computed value will also be garbage"; ex = B->getLHS(); Index: lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp +++ lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp @@ -194,7 +194,7 @@ // Now check if oflags has O_CREAT set. const Expr *oflagsEx = CE->getArg(FlagsArgIndex); - const SVal V = state->getSVal(oflagsEx, C.getLocationContext()); + const SVal V = C.getSVal(oflagsEx); if (!V.getAs()) { // The case where 'V' can be a location can only be due to a bad header, // so in this case bail out. @@ -248,8 +248,7 @@ // Check if the first argument is stack allocated. If so, issue a warning // because that's likely to be bad news. ProgramStateRef state = C.getState(); - const MemRegion *R = - state->getSVal(CE->getArg(0), C.getLocationContext()).getAsRegion(); + const MemRegion *R = C.getSVal(CE->getArg(0)).getAsRegion(); if (!R || !isa(R->getMemorySpace())) return; @@ -336,7 +335,7 @@ ProgramStateRef state = C.getState(); ProgramStateRef trueState = nullptr, falseState = nullptr; const Expr *arg = CE->getArg(sizeArg); - SVal argVal = state->getSVal(arg, C.getLocationContext()); + SVal argVal = C.getSVal(arg); if (argVal.isUnknownOrUndef()) return; @@ -364,7 +363,7 @@ unsigned int i; for (i = 0; i < nArgs; i++) { const Expr *arg = CE->getArg(i); - SVal argVal = state->getSVal(arg, C.getLocationContext()); + SVal argVal = C.getSVal(arg); if (argVal.isUnknownOrUndef()) { if (i == 0) continue; Index: lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp +++ lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp @@ -94,7 +94,7 @@ // FIXME: Handle multi-dimensional VLAs. const Expr *SE = VLA->getSizeExpr(); ProgramStateRef state = C.getState(); - SVal sizeV = state->getSVal(SE, C.getLocationContext()); + SVal sizeV = C.getSVal(SE); if (sizeV.isUndef()) { reportBug(VLA_Garbage, SE, state, C); Index: lib/StaticAnalyzer/Checkers/ValistChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/ValistChecker.cpp +++ lib/StaticAnalyzer/Checkers/ValistChecker.cpp @@ -189,7 +189,7 @@ CheckerContext &C) const { ProgramStateRef State = C.getState(); const Expr *VASubExpr = VAA->getSubExpr(); - SVal VAListSVal = State->getSVal(VASubExpr, C.getLocationContext()); + SVal VAListSVal = C.getSVal(VASubExpr); bool Symbolic; const MemRegion *VAList = getVAListAsRegion(VAListSVal, VASubExpr, Symbolic, C); Index: lib/StaticAnalyzer/Core/BugReporterVisitors.cpp =================================================================== --- lib/StaticAnalyzer/Core/BugReporterVisitors.cpp +++ lib/StaticAnalyzer/Core/BugReporterVisitors.cpp @@ -399,7 +399,7 @@ // Check the return value. ProgramStateRef State = Node->getState(); - SVal RetVal = State->getSVal(S, Node->getLocationContext()); + SVal RetVal = Node->getSVal(S); // Handle cases where a reference is returned and then immediately used. if (cast(S)->isGLValue()) @@ -881,7 +881,7 @@ if (VR) { // See if we can get the BlockVarRegion. ProgramStateRef State = StoreSite->getState(); - SVal V = State->getSVal(S, PS->getLocationContext()); + SVal V = StoreSite->getSVal(S); if (const BlockDataRegion *BDR = dyn_cast_or_null(V.getAsRegion())) { if (const VarRegion *OriginalR = BDR->getOriginalRegion(VR)) { @@ -1268,7 +1268,7 @@ if (Inner && ExplodedGraph::isInterestingLValueExpr(Inner)) { const ExplodedNode *LVNode = findNodeForExpression(N, Inner); ProgramStateRef LVState = LVNode->getState(); - SVal LVal = LVState->getSVal(Inner, LVNode->getLocationContext()); + SVal LVal = LVNode->getSVal(Inner); const MemRegion *RR = getLocationRegionIfReference(Inner, N); bool LVIsNull = LVState->isNull(LVal).isConstrainedTrue(); @@ -1287,7 +1287,7 @@ // If the LVal is null, check if we are dealing with null reference. // For those, we want to track the location of the reference. const MemRegion *R = (RR && LVIsNull) ? RR : - LVState->getSVal(Inner, LVNode->getLocationContext()).getAsRegion(); + LVNode->getSVal(Inner).getAsRegion(); if (R) { // Mark both the variable region and its contents as interesting. @@ -1370,7 +1370,7 @@ return nullptr; if (const Expr *Receiver = ME->getInstanceReceiver()) { ProgramStateRef state = N->getState(); - SVal V = state->getSVal(Receiver, N->getLocationContext()); + SVal V = N->getSVal(Receiver); if (state->isNull(V).isConstrainedTrue()) return Receiver; } @@ -1426,8 +1426,7 @@ const Stmt *Head = WorkList.front(); WorkList.pop_front(); - ProgramStateRef state = N->getState(); - ProgramStateManager &StateMgr = state->getStateManager(); + ProgramStateManager &StateMgr = N->getState()->getStateManager(); if (const DeclRefExpr *DR = dyn_cast(Head)) { if (const VarDecl *VD = dyn_cast(DR->getDecl())) { @@ -1435,7 +1434,7 @@ StateMgr.getRegionManager().getVarRegion(VD, N->getLocationContext()); // What did we load? - SVal V = state->getSVal(S, N->getLocationContext()); + SVal V = N->getSVal(S); if (V.getAs() || V.getAs()) { // Register a new visitor with the BugReport. Index: lib/StaticAnalyzer/Core/CheckerContext.cpp =================================================================== --- lib/StaticAnalyzer/Core/CheckerContext.cpp +++ lib/StaticAnalyzer/Core/CheckerContext.cpp @@ -20,9 +20,8 @@ using namespace ento; const FunctionDecl *CheckerContext::getCalleeDecl(const CallExpr *CE) const { - ProgramStateRef State = getState(); const Expr *Callee = CE->getCallee(); - SVal L = State->getSVal(Callee, Pred->getLocationContext()); + SVal L = Pred->getSVal(Callee); return L.getAsFunctionDecl(); } Index: lib/StaticAnalyzer/Core/PathDiagnostic.cpp =================================================================== --- lib/StaticAnalyzer/Core/PathDiagnostic.cpp +++ lib/StaticAnalyzer/Core/PathDiagnostic.cpp @@ -1199,12 +1199,10 @@ return getMessageForSymbolNotFound(); // Check if one of the parameters are set to the interesting symbol. - ProgramStateRef State = N->getState(); - const LocationContext *LCtx = N->getLocationContext(); unsigned ArgIndex = 0; for (CallExpr::const_arg_iterator I = CE->arg_begin(), E = CE->arg_end(); I != E; ++I, ++ArgIndex){ - SVal SV = State->getSVal(*I, LCtx); + SVal SV = N->getSVal(*I); // Check if the variable corresponding to the symbol is passed by value. SymbolRef AS = SV.getAsLocSymbol(); @@ -1214,7 +1212,7 @@ // Check if the parameter is a pointer to the symbol. if (Optional Reg = SV.getAs()) { - SVal PSV = State->getSVal(Reg->getRegion()); + SVal PSV = N->getState()->getSVal(Reg->getRegion()); SymbolRef AS = PSV.getAsLocSymbol(); if (AS == Sym) { return getMessageForArg(*I, ArgIndex); @@ -1223,7 +1221,7 @@ } // Check if we are returning the interesting symbol. - SVal SV = State->getSVal(CE, LCtx); + SVal SV = N->getSVal(CE); SymbolRef RetSym = SV.getAsLocSymbol(); if (RetSym == Sym) { return getMessageForReturn(CE);