diff --git a/clang/include/clang/Analysis/PathSensitive/BasicValueFactory.h b/clang/include/clang/Analysis/PathSensitive/BasicValueFactory.h index 29957a7996f9..0edcde35bc8c 100644 --- a/clang/include/clang/Analysis/PathSensitive/BasicValueFactory.h +++ b/clang/include/clang/Analysis/PathSensitive/BasicValueFactory.h @@ -27,7 +27,7 @@ namespace llvm { namespace clang { -class RVal; +class SVal; class BasicValueFactory { typedef llvm::FoldingSet > @@ -42,12 +42,12 @@ class BasicValueFactory { APSIntSetTy APSIntSet; SymIntCSetTy SymIntCSet; - void* PersistentRVals; - void* PersistentRValPairs; + void* PersistentSVals; + void* PersistentSValPairs; public: BasicValueFactory(ASTContext& ctx, llvm::BumpPtrAllocator& Alloc) - : Ctx(ctx), BPAlloc(Alloc), PersistentRVals(0), PersistentRValPairs(0) {} + : Ctx(ctx), BPAlloc(Alloc), PersistentSVals(0), PersistentSValPairs(0) {} ~BasicValueFactory(); @@ -72,13 +72,13 @@ public: const llvm::APSInt& V1, const llvm::APSInt& V2); - const std::pair& - getPersistentRValWithData(const RVal& V, uintptr_t Data); + const std::pair& + getPersistentSValWithData(const SVal& V, uintptr_t Data); - const std::pair& - getPersistentRValPair(const RVal& V1, const RVal& V2); + const std::pair& + getPersistentSValPair(const SVal& V1, const SVal& V2); - const RVal* getPersistentRVal(RVal X); + const SVal* getPersistentSVal(SVal X); }; } // end clang namespace diff --git a/clang/include/clang/Analysis/PathSensitive/ConstraintManager.h b/clang/include/clang/Analysis/PathSensitive/ConstraintManager.h index 25c9260a72c3..71ae247f5773 100644 --- a/clang/include/clang/Analysis/PathSensitive/ConstraintManager.h +++ b/clang/include/clang/Analysis/PathSensitive/ConstraintManager.h @@ -25,14 +25,14 @@ namespace clang { class GRState; class GRStateManager; -class RVal; +class SVal; class SymbolID; class ConstraintManager { public: virtual ~ConstraintManager(); - virtual const GRState* Assume(const GRState* St, RVal Cond, bool Assumption, - bool& isFeasible) = 0; + virtual const GRState* Assume(const GRState* St, SVal Cond, + bool Assumption, bool& isFeasible) = 0; virtual const GRState* AddNE(const GRState* St, SymbolID sym, const llvm::APSInt& V) = 0; diff --git a/clang/include/clang/Analysis/PathSensitive/Environment.h b/clang/include/clang/Analysis/PathSensitive/Environment.h index f1556a9be29c..c04252e6e842 100644 --- a/clang/include/clang/Analysis/PathSensitive/Environment.h +++ b/clang/include/clang/Analysis/PathSensitive/Environment.h @@ -36,7 +36,7 @@ private: friend class EnvironmentManager; // Type definitions. - typedef llvm::ImmutableMap BindingsTy; + typedef llvm::ImmutableMap BindingsTy; // Data. BindingsTy SubExprBindings; @@ -55,28 +55,28 @@ public: beb_iterator beb_begin() const { return BlkExprBindings.begin(); } beb_iterator beb_end() const { return BlkExprBindings.end(); } - RVal LookupSubExpr(Expr* E) const { - const RVal* X = SubExprBindings.lookup(E); + SVal LookupSubExpr(Expr* E) const { + const SVal* X = SubExprBindings.lookup(E); return X ? *X : UnknownVal(); } - RVal LookupBlkExpr(Expr* E) const { - const RVal* X = BlkExprBindings.lookup(E); + SVal LookupBlkExpr(Expr* E) const { + const SVal* X = BlkExprBindings.lookup(E); return X ? *X : UnknownVal(); } - RVal LookupExpr(Expr* E) const { - const RVal* X = SubExprBindings.lookup(E); + SVal LookupExpr(Expr* E) const { + const SVal* X = SubExprBindings.lookup(E); if (X) return *X; X = BlkExprBindings.lookup(E); return X ? *X : UnknownVal(); } - RVal GetRVal(Expr* Ex, BasicValueFactory& BasicVals) const; - RVal GetRVal(const Expr* Ex, BasicValueFactory& BasicVals) const { - return GetRVal(const_cast(Ex), BasicVals); + SVal GetSVal(Expr* Ex, BasicValueFactory& BasicVals) const; + SVal GetSVal(const Expr* Ex, BasicValueFactory& BasicVals) const { + return GetSVal(const_cast(Ex), BasicVals); } - RVal GetBlkExprRVal(Expr* Ex, BasicValueFactory& BasicVals) const; + SVal GetBlkExprSVal(Expr* Ex, BasicValueFactory& BasicVals) const; /// Profile - Profile the contents of an Environment object for use /// in a FoldingSet. @@ -120,11 +120,11 @@ public: return Environment(F.Remove(Env.SubExprBindings, E), Env.BlkExprBindings); } - Environment AddBlkExpr(const Environment& Env, Expr* E, RVal V) { - return Environment(Env.SubExprBindings, F.Add(Env.BlkExprBindings, E, V)); + Environment AddBlkExpr(const Environment& Env, Expr* E, SVal V) { + return Environment(Env.SubExprBindings, F.Add(Env.BlkExprBindings, E, V)); } - Environment AddSubExpr(const Environment& Env, Expr* E, RVal V) { + Environment AddSubExpr(const Environment& Env, Expr* E, SVal V) { return Environment(F.Add(Env.SubExprBindings, E, V), Env.BlkExprBindings); } @@ -139,7 +139,7 @@ public: return Environment(F.GetEmptyMap(), F.GetEmptyMap()); } - Environment SetRVal(const Environment& Env, Expr* E, RVal V, + Environment SetSVal(const Environment& Env, Expr* E, SVal V, bool isBlkExpr, bool Invalidate); Environment RemoveDeadBindings(Environment Env, Stmt* Loc, diff --git a/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h b/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h index 5fc63224d85f..8af359321015 100644 --- a/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h +++ b/clang/include/clang/Analysis/PathSensitive/GRExprEngine.h @@ -252,11 +252,11 @@ public: } bool isImplicitBadDivide(const NodeTy* N) const { - return N->isSink() && ImplicitBadDivides.count(const_cast(N)) != 0; + return N->isSink() && ImplicitBadDivides.count(const_cast(N)) != 0; } bool isExplicitBadDivide(const NodeTy* N) const { - return N->isSink() && ExplicitBadDivides.count(const_cast(N)) != 0; + return N->isSink() && ExplicitBadDivides.count(const_cast(N)) != 0; } bool isNoReturnCall(const NodeTy* N) const { @@ -402,52 +402,52 @@ protected: public: - const GRState* SetRVal(const GRState* St, Expr* Ex, RVal V) { - return StateMgr.SetRVal(St, Ex, V); + const GRState* SetSVal(const GRState* St, Expr* Ex, SVal V) { + return StateMgr.SetSVal(St, Ex, V); } - const GRState* SetRVal(const GRState* St, const Expr* Ex, RVal V) { - return SetRVal(St, const_cast(Ex), V); + const GRState* SetSVal(const GRState* St, const Expr* Ex, SVal V) { + return SetSVal(St, const_cast(Ex), V); } protected: - const GRState* SetBlkExprRVal(const GRState* St, Expr* Ex, RVal V) { - return StateMgr.SetRVal(St, Ex, V, true, false); + const GRState* SetBlkExprSVal(const GRState* St, Expr* Ex, SVal V) { + return StateMgr.SetSVal(St, Ex, V, true, false); } - const GRState* SetRVal(const GRState* St, LVal LV, RVal V) { - return StateMgr.SetRVal(St, LV, V); + const GRState* SetSVal(const GRState* St, Loc LV, SVal V) { + return StateMgr.SetSVal(St, LV, V); } - RVal GetRVal(const GRState* St, Expr* Ex) { - return StateMgr.GetRVal(St, Ex); + SVal GetSVal(const GRState* St, Expr* Ex) { + return StateMgr.GetSVal(St, Ex); } - RVal GetRVal(const GRState* St, const Expr* Ex) { - return GetRVal(St, const_cast(Ex)); + SVal GetSVal(const GRState* St, const Expr* Ex) { + return GetSVal(St, const_cast(Ex)); } - RVal GetBlkExprRVal(const GRState* St, Expr* Ex) { - return StateMgr.GetBlkExprRVal(St, Ex); + SVal GetBlkExprSVal(const GRState* St, Expr* Ex) { + return StateMgr.GetBlkExprSVal(St, Ex); } - RVal GetRVal(const GRState* St, LVal LV, QualType T = QualType()) { - return StateMgr.GetRVal(St, LV, T); + SVal GetSVal(const GRState* St, Loc LV, QualType T = QualType()) { + return StateMgr.GetSVal(St, LV, T); } - inline NonLVal MakeConstantVal(uint64_t X, Expr* Ex) { - return NonLVal::MakeVal(getBasicVals(), X, Ex->getType()); + inline NonLoc MakeConstantVal(uint64_t X, Expr* Ex) { + return NonLoc::MakeVal(getBasicVals(), X, Ex->getType()); } /// Assume - Create new state by assuming that a given expression /// is true or false. - const GRState* Assume(const GRState* St, RVal Cond, bool Assumption, + const GRState* Assume(const GRState* St, SVal Cond, bool Assumption, bool& isFeasible) { return StateMgr.Assume(St, Cond, Assumption, isFeasible); } - const GRState* Assume(const GRState* St, LVal Cond, bool Assumption, + const GRState* Assume(const GRState* St, Loc Cond, bool Assumption, bool& isFeasible) { return StateMgr.Assume(St, Cond, Assumption, isFeasible); } @@ -539,44 +539,44 @@ protected: bool asLValue); bool CheckDivideZero(Expr* Ex, const GRState* St, NodeTy* Pred, - RVal Denom); + SVal Denom); - RVal EvalCast(RVal X, QualType CastT) { + SVal EvalCast(SVal X, QualType CastT) { if (X.isUnknownOrUndef()) return X; - if (isa(X)) - return getTF().EvalCast(*this, cast(X), CastT); + if (isa(X)) + return getTF().EvalCast(*this, cast(X), CastT); else - return getTF().EvalCast(*this, cast(X), CastT); + return getTF().EvalCast(*this, cast(X), CastT); } - RVal EvalMinus(UnaryOperator* U, RVal X) { - return X.isValid() ? getTF().EvalMinus(*this, U, cast(X)) : X; + SVal EvalMinus(UnaryOperator* U, SVal X) { + return X.isValid() ? getTF().EvalMinus(*this, U, cast(X)) : X; } - RVal EvalComplement(RVal X) { - return X.isValid() ? getTF().EvalComplement(*this, cast(X)) : X; + SVal EvalComplement(SVal X) { + return X.isValid() ? getTF().EvalComplement(*this, cast(X)) : X; } - RVal EvalBinOp(BinaryOperator::Opcode Op, NonLVal L, NonLVal R) { + SVal EvalBinOp(BinaryOperator::Opcode Op, NonLoc L, NonLoc R) { return R.isValid() ? getTF().DetermEvalBinOpNN(getStateManager(), Op, L, R) : R; } - RVal EvalBinOp(BinaryOperator::Opcode Op, NonLVal L, RVal R) { + SVal EvalBinOp(BinaryOperator::Opcode Op, NonLoc L, SVal R) { return R.isValid() ? getTF().DetermEvalBinOpNN(getStateManager(), Op, L, - cast(R)) : R; + cast(R)) : R; } void EvalBinOp(ExplodedNodeSet& Dst, Expr* Ex, - BinaryOperator::Opcode Op, NonLVal L, NonLVal R, + BinaryOperator::Opcode Op, NonLoc L, NonLoc R, ExplodedNode* Pred); void EvalBinOp(GRStateSet& OStates, const GRState* St, Expr* Ex, - BinaryOperator::Opcode Op, NonLVal L, NonLVal R); + BinaryOperator::Opcode Op, NonLoc L, NonLoc R); - RVal EvalBinOp(BinaryOperator::Opcode Op, RVal L, RVal R) { + SVal EvalBinOp(BinaryOperator::Opcode Op, SVal L, SVal R) { if (L.isUndef() || R.isUndef()) return UndefinedVal(); @@ -584,30 +584,30 @@ protected: if (L.isUnknown() || R.isUnknown()) return UnknownVal(); - if (isa(L)) { - if (isa(R)) - return getTF().EvalBinOp(*this, Op, cast(L), cast(R)); + if (isa(L)) { + if (isa(R)) + return getTF().EvalBinOp(*this, Op, cast(L), cast(R)); else - return getTF().EvalBinOp(*this, Op, cast(L), cast(R)); + return getTF().EvalBinOp(*this, Op, cast(L), cast(R)); } - if (isa(R)) { + if (isa(R)) { // Support pointer arithmetic where the increment/decrement operand // is on the left and the pointer on the right. assert (Op == BinaryOperator::Add || Op == BinaryOperator::Sub); // Commute the operands. - return getTF().EvalBinOp(*this, Op, cast(R), - cast(L)); + return getTF().EvalBinOp(*this, Op, cast(R), + cast(L)); } else - return getTF().DetermEvalBinOpNN(getStateManager(), Op, cast(L), - cast(R)); + return getTF().DetermEvalBinOpNN(getStateManager(), Op, cast(L), + cast(R)); } - void EvalCall(NodeSet& Dst, CallExpr* CE, RVal L, NodeTy* Pred) { + void EvalCall(NodeSet& Dst, CallExpr* CE, SVal L, NodeTy* Pred) { assert (Builder && "GRStmtNodeBuilder must be defined."); getTF().EvalCall(Dst, *this, *Builder, CE, L, Pred); } @@ -618,24 +618,25 @@ protected: } void EvalStore(NodeSet& Dst, Expr* E, NodeTy* Pred, const GRState* St, - RVal TargetLV, RVal Val); + SVal TargetLV, SVal Val); void EvalStore(NodeSet& Dst, Expr* E, Expr* StoreE, NodeTy* Pred, - const GRState* St, RVal TargetLV, RVal Val); + const GRState* St, SVal TargetLV, SVal Val); // FIXME: The "CheckOnly" option exists only because Array and Field // loads aren't fully implemented. Eventually this option will go away. void EvalLoad(NodeSet& Dst, Expr* Ex, NodeTy* Pred, - const GRState* St, RVal location, bool CheckOnly = false); + const GRState* St, SVal location, bool CheckOnly = false); const GRState* EvalLocation(Expr* Ex, NodeTy* Pred, - const GRState* St, RVal location, - bool isLoad = false); + const GRState* St, SVal location, + bool isLoad = false); void EvalReturn(NodeSet& Dst, ReturnStmt* s, NodeTy* Pred); - const GRState* MarkBranch(const GRState* St, Stmt* Terminator, bool branchTaken); + const GRState* MarkBranch(const GRState* St, Stmt* Terminator, + bool branchTaken); }; } // end clang namespace diff --git a/clang/include/clang/Analysis/PathSensitive/GRState.h b/clang/include/clang/Analysis/PathSensitive/GRState.h index 841927bf3e50..331c8301cdb5 100644 --- a/clang/include/clang/Analysis/PathSensitive/GRState.h +++ b/clang/include/clang/Analysis/PathSensitive/GRState.h @@ -61,7 +61,7 @@ template struct GRStateTrait { }; //===----------------------------------------------------------------------===// -// GRState- An ImmutableMap type Stmt*/Decl*/Symbols to RVals. +// GRState- An ImmutableMap type Stmt*/Decl*/Symbols to SVals. //===----------------------------------------------------------------------===// /// GRState - This class encapsulates the actual data values for @@ -129,7 +129,7 @@ public: Profile(ID, this); } - RVal LookupExpr(Expr* E) const { + SVal LookupExpr(Expr* E) const { return Env.LookupExpr(E); } @@ -174,7 +174,7 @@ public: // Tags used for the Generic Data Map. struct NullDerefTag { static int TagInt; - typedef const RVal* data_type; + typedef const SVal* data_type; }; }; @@ -251,7 +251,7 @@ private: /// a particular function. This is used to unique states. llvm::FoldingSet StateSet; - /// ValueMgr - Object that manages the data for all created RVals. + /// ValueMgr - Object that manages the data for all created SVals. BasicValueFactory BasicVals; /// SymMgr - Object that manages the symbol information. @@ -268,7 +268,7 @@ private: CFG& cfg; /// TF - Object that represents a bundle of transfer functions - /// for manipulating and creating RVals. + /// for manipulating and creating SVals. GRTransferFuncs* TF; /// Liveness - live-variables information of the ValueDecl* and block-level @@ -282,8 +282,8 @@ private: } // FIXME: Remove when we do lazy initializaton of variable bindings. -// const GRState* BindVar(const GRState* St, VarDecl* D, RVal V) { -// return SetRVal(St, getLVal(D), V); +// const GRState* BindVar(const GRState* St, VarDecl* D, SVal V) { +// return SetSVal(St, getLoc(D), V); // } public: @@ -342,44 +342,44 @@ public: } // Get the lvalue for a variable reference. - RVal GetLValue(const GRState* St, const VarDecl* D) { + SVal GetLValue(const GRState* St, const VarDecl* D) { return StoreMgr->getLValueVar(St, D); } // Get the lvalue for an ivar reference. - RVal GetLValue(const GRState* St, const ObjCIvarDecl* D, RVal Base) { + SVal GetLValue(const GRState* St, const ObjCIvarDecl* D, SVal Base) { return StoreMgr->getLValueIvar(St, D, Base); } // Get the lvalue for a field reference. - RVal GetLValue(const GRState* St, const FieldDecl* D, RVal Base) { + SVal GetLValue(const GRState* St, const FieldDecl* D, SVal Base) { return StoreMgr->getLValueField(St, D, Base); } // Get the lvalue for an array index. - RVal GetLValue(const GRState* St, RVal Base, RVal Idx) { + SVal GetLValue(const GRState* St, SVal Base, SVal Idx) { return StoreMgr->getLValueElement(St, Base, Idx); } // Methods that query & manipulate the Environment. - RVal GetRVal(const GRState* St, Expr* Ex) { - return St->getEnvironment().GetRVal(Ex, BasicVals); + SVal GetSVal(const GRState* St, Expr* Ex) { + return St->getEnvironment().GetSVal(Ex, BasicVals); } - RVal GetRVal(const GRState* St, const Expr* Ex) { - return St->getEnvironment().GetRVal(Ex, BasicVals); + SVal GetSVal(const GRState* St, const Expr* Ex) { + return St->getEnvironment().GetSVal(Ex, BasicVals); } - RVal GetBlkExprRVal(const GRState* St, Expr* Ex) { - return St->getEnvironment().GetBlkExprRVal(Ex, BasicVals); + SVal GetBlkExprSVal(const GRState* St, Expr* Ex) { + return St->getEnvironment().GetBlkExprSVal(Ex, BasicVals); } - const GRState* SetRVal(const GRState* St, Expr* Ex, RVal V, + const GRState* SetSVal(const GRState* St, Expr* Ex, SVal V, bool isBlkExpr, bool Invalidate) { const Environment& OldEnv = St->getEnvironment(); - Environment NewEnv = EnvMgr.SetRVal(OldEnv, Ex, V, isBlkExpr, Invalidate); + Environment NewEnv = EnvMgr.SetSVal(OldEnv, Ex, V, isBlkExpr, Invalidate); if (NewEnv == OldEnv) return St; @@ -389,7 +389,7 @@ public: return getPersistentState(NewSt); } - const GRState* SetRVal(const GRState* St, Expr* Ex, RVal V, + const GRState* SetSVal(const GRState* St, Expr* Ex, SVal V, bool Invalidate = true) { bool isBlkExpr = false; @@ -403,7 +403,7 @@ public: return St; } - return SetRVal(St, Ex, V, isBlkExpr, Invalidate); + return SetSVal(St, Ex, V, isBlkExpr, Invalidate); } // Methods that manipulate the GDM. @@ -421,21 +421,21 @@ public: } - RVal GetRVal(const GRState* St, LVal LV, QualType T = QualType()) { - return StoreMgr->GetRVal(St->getStore(), LV, T); + SVal GetSVal(const GRState* St, Loc LV, QualType T = QualType()) { + return StoreMgr->GetSVal(St->getStore(), LV, T); } - void SetRVal(GRState& St, LVal LV, RVal V) { - St.St = StoreMgr->SetRVal(St.St, LV, V); + void SetSVal(GRState& St, Loc LV, SVal V) { + St.St = StoreMgr->SetSVal(St.St, LV, V); } - const GRState* SetRVal(const GRState* St, LVal LV, RVal V); + const GRState* SetSVal(const GRState* St, Loc LV, SVal V); - void Unbind(GRState& St, LVal LV) { + void Unbind(GRState& St, Loc LV) { St.St = StoreMgr->Remove(St.St, LV); } - const GRState* Unbind(const GRState* St, LVal LV); + const GRState* Unbind(const GRState* St, Loc LV); const GRState* getPersistentState(GRState& Impl); @@ -482,7 +482,7 @@ public: return GRStateTrait::MakeContext(p); } - const GRState* Assume(const GRState* St, RVal Cond, bool Assumption, + const GRState* Assume(const GRState* St, SVal Cond, bool Assumption, bool& isFeasible) { return ConstraintMgr->Assume(St, Cond, Assumption, isFeasible); } @@ -510,33 +510,33 @@ public: operator const GRState*() const { return St; } GRStateManager& getManager() const { return *Mgr; } - RVal GetRVal(Expr* Ex) { - return Mgr->GetRVal(St, Ex); + SVal GetSVal(Expr* Ex) { + return Mgr->GetSVal(St, Ex); } - RVal GetBlkExprRVal(Expr* Ex) { - return Mgr->GetBlkExprRVal(St, Ex); + SVal GetBlkExprSVal(Expr* Ex) { + return Mgr->GetBlkExprSVal(St, Ex); } - RVal GetRVal(LVal LV, QualType T = QualType()) { - return Mgr->GetRVal(St, LV, T); + SVal GetSVal(Loc LV, QualType T = QualType()) { + return Mgr->GetSVal(St, LV, T); } - GRStateRef SetRVal(Expr* Ex, RVal V, bool isBlkExpr, bool Invalidate) { - return GRStateRef(Mgr->SetRVal(St, Ex, V, isBlkExpr, Invalidate), *Mgr); + GRStateRef SetSVal(Expr* Ex, SVal V, bool isBlkExpr, bool Invalidate) { + return GRStateRef(Mgr->SetSVal(St, Ex, V, isBlkExpr, Invalidate), *Mgr); } - GRStateRef SetRVal(Expr* Ex, RVal V, bool Invalidate = true) { - return GRStateRef(Mgr->SetRVal(St, Ex, V, Invalidate), *Mgr); + GRStateRef SetSVal(Expr* Ex, SVal V, bool Invalidate = true) { + return GRStateRef(Mgr->SetSVal(St, Ex, V, Invalidate), *Mgr); } - GRStateRef SetRVal(LVal LV, RVal V) { + GRStateRef SetSVal(Loc LV, SVal V) { GRState StImpl = *St; - Mgr->SetRVal(StImpl, LV, V); + Mgr->SetSVal(StImpl, LV, V); return GRStateRef(Mgr->getPersistentState(StImpl), *Mgr); } - GRStateRef Unbind(LVal LV) { + GRStateRef Unbind(Loc LV) { return GRStateRef(Mgr->Unbind(St, LV), *Mgr); } @@ -591,7 +591,7 @@ public: } // Lvalue methods. - RVal GetLValue(const VarDecl* VD) { + SVal GetLValue(const VarDecl* VD) { return Mgr->GetLValue(St, VD); } diff --git a/clang/include/clang/Analysis/PathSensitive/GRTransferFuncs.h b/clang/include/clang/Analysis/PathSensitive/GRTransferFuncs.h index ad12328edafe..ebb0c4ef6488 100644 --- a/clang/include/clang/Analysis/PathSensitive/GRTransferFuncs.h +++ b/clang/include/clang/Analysis/PathSensitive/GRTransferFuncs.h @@ -32,9 +32,9 @@ class GRTransferFuncs { protected: - virtual RVal DetermEvalBinOpNN(GRStateManager& StateMgr, + virtual SVal DetermEvalBinOpNN(GRStateManager& StateMgr, BinaryOperator::Opcode Op, - NonLVal L, NonLVal R) { + NonLoc L, NonLoc R) { return UnknownVal(); } @@ -48,34 +48,34 @@ public: // Casts. - virtual RVal EvalCast(GRExprEngine& Engine, NonLVal V, QualType CastT) =0; - virtual RVal EvalCast(GRExprEngine& Engine, LVal V, QualType CastT) = 0; + virtual SVal EvalCast(GRExprEngine& Engine, NonLoc V, QualType CastT) =0; + virtual SVal EvalCast(GRExprEngine& Engine, Loc V, QualType CastT) = 0; // Unary Operators. - virtual RVal EvalMinus(GRExprEngine& Engine, UnaryOperator* U, NonLVal X) = 0; + virtual SVal EvalMinus(GRExprEngine& Engine, UnaryOperator* U, NonLoc X) = 0; - virtual RVal EvalComplement(GRExprEngine& Engine, NonLVal X) = 0; + virtual SVal EvalComplement(GRExprEngine& Engine, NonLoc X) = 0; // Binary Operators. virtual void EvalBinOpNN(GRStateSet& OStates, GRStateManager& StateMgr, const GRState* St, Expr* Ex, - BinaryOperator::Opcode Op, NonLVal L, NonLVal R); + BinaryOperator::Opcode Op, NonLoc L, NonLoc R); - virtual RVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op, - LVal L, LVal R) = 0; + virtual SVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op, + Loc L, Loc R) = 0; // Pointer arithmetic. - virtual RVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op, - LVal L, NonLVal R) = 0; + virtual SVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op, + Loc L, NonLoc R) = 0; // Calls. virtual void EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Engine, GRStmtNodeBuilder& Builder, - CallExpr* CE, RVal L, + CallExpr* CE, SVal L, ExplodedNode* Pred) {} virtual void EvalObjCMessageExpr(ExplodedNodeSet& Dst, @@ -88,12 +88,12 @@ public: /// EvalStore - Evaluate the effects of a store, creating a new node /// the represents the effect of binding 'Val' to the location 'TargetLV'. - // TargetLV is guaranteed to either be an UnknownVal or an LVal. + // TargetLV is guaranteed to either be an UnknownVal or an Loc. virtual void EvalStore(ExplodedNodeSet& Dst, GRExprEngine& Engine, GRStmtNodeBuilder& Builder, Expr* E, ExplodedNode* Pred, - const GRState* St, RVal TargetLV, RVal Val); + const GRState* St, SVal TargetLV, SVal Val); // End-of-path and dead symbol notification. @@ -121,7 +121,7 @@ public: virtual const GRState* EvalAssume(GRStateManager& VMgr, const GRState* St, - RVal Cond, bool Assumption, + SVal Cond, bool Assumption, bool& isFeasible) { return St; } diff --git a/clang/include/clang/Analysis/PathSensitive/RValues.h b/clang/include/clang/Analysis/PathSensitive/RValues.h index e41113d6c7f6..c1ee0e0e9002 100644 --- a/clang/include/clang/Analysis/PathSensitive/RValues.h +++ b/clang/include/clang/Analysis/PathSensitive/RValues.h @@ -1,4 +1,4 @@ -//== RValues.h - Abstract RValues for Path-Sens. Value Tracking -*- C++ -*--==// +//== SValues.h - Abstract Values for Static Analysis ---------*- C++ -*--==// // // The LLVM Compiler Infrastructure // @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file defines RVal, LVal, and NonLVal, classes that represent +// This file defines SVal, Loc, and NonLoc, classes that represent // abstract r-values for use with path-sensitive value tracking. // //===----------------------------------------------------------------------===// @@ -19,17 +19,17 @@ #include "llvm/Support/Casting.h" //==------------------------------------------------------------------------==// -// Base RVal types. -//==------------------------------------------------------------------------==// +// Base SVal types. +//==------------------------------------------------------------------------==// namespace clang { class MemRegion; class GRStateManager; -class RVal { +class SVal { public: - enum BaseKind { UndefinedKind, UnknownKind, LValKind, NonLValKind }; + enum BaseKind { UndefinedKind, UnknownKind, LocKind, NonLocKind }; enum { BaseBits = 2, BaseMask = 0x3 }; protected: @@ -37,18 +37,18 @@ protected: unsigned Kind; protected: - RVal(const void* d, bool isLVal, unsigned ValKind) + SVal(const void* d, bool isLoc, unsigned ValKind) : Data(const_cast(d)), - Kind((isLVal ? LValKind : NonLValKind) | (ValKind << BaseBits)) {} + Kind((isLoc ? LocKind : NonLocKind) | (ValKind << BaseBits)) {} - explicit RVal(BaseKind k, void* D = NULL) + explicit SVal(BaseKind k, void* D = NULL) : Data(D), Kind(k) {} public: - ~RVal() {}; + ~SVal() {}; - /// BufferTy - A temporary buffer to hold a set of RVals. - typedef llvm::SmallVector BufferTy; + /// BufferTy - A temporary buffer to hold a set of SVals. + typedef llvm::SmallVector BufferTy; inline unsigned getRawKind() const { return Kind; } inline BaseKind getBaseKind() const { return (BaseKind) (Kind & BaseMask); } @@ -59,16 +59,16 @@ public: ID.AddPointer(reinterpret_cast(Data)); } - inline bool operator==(const RVal& R) const { + inline bool operator==(const SVal& R) const { return getRawKind() == R.getRawKind() && Data == R.Data; } - inline bool operator!=(const RVal& R) const { + inline bool operator!=(const SVal& R) const { return !(*this == R); } - static RVal GetSymbolValue(SymbolManager& SymMgr, VarDecl *D); + static SVal GetSymbolValue(SymbolManager& SymMgr, VarDecl *D); inline bool isUnknown() const { return getRawKind() == UnknownKind; @@ -96,134 +96,134 @@ public: symbol_iterator symbol_end() const; // Implement isa support. - static inline bool classof(const RVal*) { return true; } + static inline bool classof(const SVal*) { return true; } }; -class UnknownVal : public RVal { +class UnknownVal : public SVal { public: - UnknownVal() : RVal(UnknownKind) {} + UnknownVal() : SVal(UnknownKind) {} - static inline bool classof(const RVal* V) { + static inline bool classof(const SVal* V) { return V->getBaseKind() == UnknownKind; } }; -class UndefinedVal : public RVal { +class UndefinedVal : public SVal { public: - UndefinedVal() : RVal(UndefinedKind) {} - UndefinedVal(void* D) : RVal(UndefinedKind, D) {} + UndefinedVal() : SVal(UndefinedKind) {} + UndefinedVal(void* D) : SVal(UndefinedKind, D) {} - static inline bool classof(const RVal* V) { + static inline bool classof(const SVal* V) { return V->getBaseKind() == UndefinedKind; } void* getData() const { return Data; } }; -class NonLVal : public RVal { +class NonLoc : public SVal { protected: - NonLVal(unsigned SubKind, const void* d) : RVal(d, false, SubKind) {} + NonLoc(unsigned SubKind, const void* d) : SVal(d, false, SubKind) {} public: void print(std::ostream& Out) const; - // Utility methods to create NonLVals. - static NonLVal MakeVal(BasicValueFactory& BasicVals, uint64_t X, QualType T); + // Utility methods to create NonLocs. + static NonLoc MakeVal(BasicValueFactory& BasicVals, uint64_t X, QualType T); - static NonLVal MakeVal(BasicValueFactory& BasicVals, IntegerLiteral* I); + static NonLoc MakeVal(BasicValueFactory& BasicVals, IntegerLiteral* I); - static NonLVal MakeIntTruthVal(BasicValueFactory& BasicVals, bool b); + static NonLoc MakeIntTruthVal(BasicValueFactory& BasicVals, bool b); // Implement isa support. - static inline bool classof(const RVal* V) { - return V->getBaseKind() == NonLValKind; + static inline bool classof(const SVal* V) { + return V->getBaseKind() == NonLocKind; } }; -class LVal : public RVal { +class Loc : public SVal { protected: - LVal(unsigned SubKind, const void* D) - : RVal(const_cast(D), true, SubKind) {} + Loc(unsigned SubKind, const void* D) + : SVal(const_cast(D), true, SubKind) {} // Equality operators. - NonLVal EQ(BasicValueFactory& BasicVals, const LVal& R) const; - NonLVal NE(BasicValueFactory& BasicVals, const LVal& R) const; + NonLoc EQ(BasicValueFactory& BasicVals, const Loc& R) const; + NonLoc NE(BasicValueFactory& BasicVals, const Loc& R) const; public: void print(std::ostream& Out) const; - static LVal MakeVal(AddrLabelExpr* E); + static Loc MakeVal(AddrLabelExpr* E); - static LVal MakeVal(StringLiteral* S); + static Loc MakeVal(StringLiteral* S); // Implement isa support. - static inline bool classof(const RVal* V) { - return V->getBaseKind() == LValKind; + static inline bool classof(const SVal* V) { + return V->getBaseKind() == LocKind; } - static inline bool IsLValType(QualType T) { + static inline bool IsLocType(QualType T) { return T->isPointerType() || T->isObjCQualifiedIdType() || T->isBlockPointerType(); } }; //==------------------------------------------------------------------------==// -// Subclasses of NonLVal. -//==------------------------------------------------------------------------==// +// Subclasses of NonLoc. +//==------------------------------------------------------------------------==// -namespace nonlval { +namespace nonloc { enum Kind { ConcreteIntKind, SymbolValKind, SymIntConstraintValKind, - LValAsIntegerKind }; + LocAsIntegerKind }; -class SymbolVal : public NonLVal { +class SymbolVal : public NonLoc { public: SymbolVal(unsigned SymID) - : NonLVal(SymbolValKind, reinterpret_cast((uintptr_t) SymID)) {} + : NonLoc(SymbolValKind, reinterpret_cast((uintptr_t) SymID)) {} SymbolID getSymbol() const { return (SymbolID) reinterpret_cast(Data); } - static inline bool classof(const RVal* V) { - return V->getBaseKind() == NonLValKind && + static inline bool classof(const SVal* V) { + return V->getBaseKind() == NonLocKind && V->getSubKind() == SymbolValKind; } - static inline bool classof(const NonLVal* V) { + static inline bool classof(const NonLoc* V) { return V->getSubKind() == SymbolValKind; } }; -class SymIntConstraintVal : public NonLVal { +class SymIntConstraintVal : public NonLoc { public: SymIntConstraintVal(const SymIntConstraint& C) - : NonLVal(SymIntConstraintValKind, reinterpret_cast(&C)) {} + : NonLoc(SymIntConstraintValKind, reinterpret_cast(&C)) {} const SymIntConstraint& getConstraint() const { return *reinterpret_cast(Data); } - static inline bool classof(const RVal* V) { - return V->getBaseKind() == NonLValKind && + static inline bool classof(const SVal* V) { + return V->getBaseKind() == NonLocKind && V->getSubKind() == SymIntConstraintValKind; } - static inline bool classof(const NonLVal* V) { + static inline bool classof(const NonLoc* V) { return V->getSubKind() == SymIntConstraintValKind; } }; -class ConcreteInt : public NonLVal { +class ConcreteInt : public NonLoc { public: - ConcreteInt(const llvm::APSInt& V) : NonLVal(ConcreteIntKind, &V) {} + ConcreteInt(const llvm::APSInt& V) : NonLoc(ConcreteIntKind, &V) {} const llvm::APSInt& getValue() const { return *static_cast(Data); } // Transfer functions for binary/unary operations on ConcreteInts. - RVal EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op, + SVal EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op, const ConcreteInt& R) const; ConcreteInt EvalComplement(BasicValueFactory& BasicVals) const; @@ -231,105 +231,105 @@ public: ConcreteInt EvalMinus(BasicValueFactory& BasicVals, UnaryOperator* U) const; // Implement isa support. - static inline bool classof(const RVal* V) { - return V->getBaseKind() == NonLValKind && + static inline bool classof(const SVal* V) { + return V->getBaseKind() == NonLocKind && V->getSubKind() == ConcreteIntKind; } - static inline bool classof(const NonLVal* V) { + static inline bool classof(const NonLoc* V) { return V->getSubKind() == ConcreteIntKind; } }; -class LValAsInteger : public NonLVal { - LValAsInteger(const std::pair& data) : - NonLVal(LValAsIntegerKind, &data) { - assert (isa(data.first)); +class LocAsInteger : public NonLoc { + LocAsInteger(const std::pair& data) : + NonLoc(LocAsIntegerKind, &data) { + assert (isa(data.first)); } public: - LVal getLVal() const { - return cast(((std::pair*) Data)->first); + Loc getLoc() const { + return cast(((std::pair*) Data)->first); } - const LVal& getPersistentLVal() const { - const RVal& V = ((std::pair*) Data)->first; - return cast(V); + const Loc& getPersistentLoc() const { + const SVal& V = ((std::pair*) Data)->first; + return cast(V); } unsigned getNumBits() const { - return ((std::pair*) Data)->second; + return ((std::pair*) Data)->second; } // Implement isa support. - static inline bool classof(const RVal* V) { - return V->getBaseKind() == NonLValKind && - V->getSubKind() == LValAsIntegerKind; + static inline bool classof(const SVal* V) { + return V->getBaseKind() == NonLocKind && + V->getSubKind() == LocAsIntegerKind; } - static inline bool classof(const NonLVal* V) { - return V->getSubKind() == LValAsIntegerKind; + static inline bool classof(const NonLoc* V) { + return V->getSubKind() == LocAsIntegerKind; } - static inline LValAsInteger Make(BasicValueFactory& Vals, LVal V, + static inline LocAsInteger Make(BasicValueFactory& Vals, Loc V, unsigned Bits) { - return LValAsInteger(Vals.getPersistentRValWithData(V, Bits)); + return LocAsInteger(Vals.getPersistentSValWithData(V, Bits)); } }; -} // end namespace clang::nonlval +} // end namespace clang::nonloc //==------------------------------------------------------------------------==// -// Subclasses of LVal. -//==------------------------------------------------------------------------==// +// Subclasses of Loc. +//==------------------------------------------------------------------------==// -namespace lval { +namespace loc { enum Kind { SymbolValKind, GotoLabelKind, MemRegionKind, FuncValKind, ConcreteIntKind, StringLiteralValKind }; -class SymbolVal : public LVal { +class SymbolVal : public Loc { public: SymbolVal(unsigned SymID) - : LVal(SymbolValKind, reinterpret_cast((uintptr_t) SymID)) {} + : Loc(SymbolValKind, reinterpret_cast((uintptr_t) SymID)) {} SymbolID getSymbol() const { return (SymbolID) reinterpret_cast(Data); } - static inline bool classof(const RVal* V) { - return V->getBaseKind() == LValKind && + static inline bool classof(const SVal* V) { + return V->getBaseKind() == LocKind && V->getSubKind() == SymbolValKind; } - static inline bool classof(const LVal* V) { + static inline bool classof(const Loc* V) { return V->getSubKind() == SymbolValKind; } }; -class GotoLabel : public LVal { +class GotoLabel : public Loc { public: - GotoLabel(LabelStmt* Label) : LVal(GotoLabelKind, Label) {} + GotoLabel(LabelStmt* Label) : Loc(GotoLabelKind, Label) {} LabelStmt* getLabel() const { return static_cast(Data); } - static inline bool classof(const RVal* V) { - return V->getBaseKind() == LValKind && + static inline bool classof(const SVal* V) { + return V->getBaseKind() == LocKind && V->getSubKind() == GotoLabelKind; } - static inline bool classof(const LVal* V) { + static inline bool classof(const Loc* V) { return V->getSubKind() == GotoLabelKind; } }; -class MemRegionVal : public LVal { +class MemRegionVal : public Loc { public: - MemRegionVal(const MemRegion* r) : LVal(MemRegionKind, r) {} + MemRegionVal(const MemRegion* r) : Loc(MemRegionKind, r) {} MemRegion* getRegion() const { return static_cast(Data); @@ -344,19 +344,19 @@ public: } // Implement isa support. - static inline bool classof(const RVal* V) { - return V->getBaseKind() == LValKind && + static inline bool classof(const SVal* V) { + return V->getBaseKind() == LocKind && V->getSubKind() == MemRegionKind; } - static inline bool classof(const LVal* V) { + static inline bool classof(const Loc* V) { return V->getSubKind() == MemRegionKind; } }; -class FuncVal : public LVal { +class FuncVal : public Loc { public: - FuncVal(const FunctionDecl* fd) : LVal(FuncValKind, fd) {} + FuncVal(const FunctionDecl* fd) : Loc(FuncValKind, fd) {} FunctionDecl* getDecl() const { return static_cast(Data); @@ -371,57 +371,57 @@ public: } // Implement isa support. - static inline bool classof(const RVal* V) { - return V->getBaseKind() == LValKind && + static inline bool classof(const SVal* V) { + return V->getBaseKind() == LocKind && V->getSubKind() == FuncValKind; } - static inline bool classof(const LVal* V) { + static inline bool classof(const Loc* V) { return V->getSubKind() == FuncValKind; } }; -class ConcreteInt : public LVal { +class ConcreteInt : public Loc { public: - ConcreteInt(const llvm::APSInt& V) : LVal(ConcreteIntKind, &V) {} + ConcreteInt(const llvm::APSInt& V) : Loc(ConcreteIntKind, &V) {} const llvm::APSInt& getValue() const { return *static_cast(Data); } // Transfer functions for binary/unary operations on ConcreteInts. - RVal EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op, + SVal EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op, const ConcreteInt& R) const; // Implement isa support. - static inline bool classof(const RVal* V) { - return V->getBaseKind() == LValKind && + static inline bool classof(const SVal* V) { + return V->getBaseKind() == LocKind && V->getSubKind() == ConcreteIntKind; } - static inline bool classof(const LVal* V) { + static inline bool classof(const Loc* V) { return V->getSubKind() == ConcreteIntKind; } }; -class StringLiteralVal : public LVal { +class StringLiteralVal : public Loc { public: - StringLiteralVal(StringLiteral* L) : LVal(StringLiteralValKind, L) {} + StringLiteralVal(StringLiteral* L) : Loc(StringLiteralValKind, L) {} StringLiteral* getLiteral() const { return (StringLiteral*) Data; } // Implement isa support. - static inline bool classof(const RVal* V) { - return V->getBaseKind() == LValKind && + static inline bool classof(const SVal* V) { + return V->getBaseKind() == LocKind && V->getSubKind() == StringLiteralValKind; } - static inline bool classof(const LVal* V) { + static inline bool classof(const Loc* V) { return V->getSubKind() == StringLiteralValKind; } }; -} // end clang::lval namespace +} // end clang::loc namespace } // end clang namespace #endif diff --git a/clang/include/clang/Analysis/PathSensitive/Store.h b/clang/include/clang/Analysis/PathSensitive/Store.h index 60c8f5285539..3acb789a24f8 100644 --- a/clang/include/clang/Analysis/PathSensitive/Store.h +++ b/clang/include/clang/Analysis/PathSensitive/Store.h @@ -40,21 +40,22 @@ public: typedef llvm::DenseSet DeadSymbolsTy; virtual ~StoreManager() {} - virtual RVal GetRVal(Store St, LVal LV, QualType T = QualType()) = 0; - virtual Store SetRVal(Store St, LVal LV, RVal V) = 0; - virtual Store Remove(Store St, LVal LV) = 0; + virtual SVal GetSVal(Store St, Loc LV, QualType T = QualType()) = 0; + virtual Store SetSVal(Store St, Loc LV, SVal V) = 0; + virtual Store Remove(Store St, Loc LV) = 0; virtual Store getInitialStore() = 0; virtual MemRegionManager& getRegionManager() = 0; - virtual RVal getLValueVar(const GRState* St, const VarDecl* VD) = 0; + virtual SVal getLValueVar(const GRState* St, const VarDecl* VD) = 0; - virtual RVal getLValueIvar(const GRState* St, const ObjCIvarDecl* D, - RVal Base)=0; + virtual SVal getLValueIvar(const GRState* St, const ObjCIvarDecl* D, + SVal Base)=0; - virtual RVal getLValueField(const GRState* St, const FieldDecl* D, - RVal Base) = 0; + virtual SVal getLValueField(const GRState* St, const FieldDecl* D, + SVal Base) = 0; - virtual RVal getLValueElement(const GRState* St, RVal Base, RVal Offset) = 0; + virtual SVal getLValueElement(const GRState* St, + SVal Base, SVal Offset) = 0; virtual Store @@ -64,7 +65,8 @@ public: virtual Store AddDecl(Store store, const VarDecl* VD, Expr* Ex, - RVal InitVal = UndefinedVal(), unsigned Count = 0) = 0; + SVal InitVal = UndefinedVal(), + unsigned Count = 0) = 0; virtual void print(Store store, std::ostream& Out, const char* nl, const char *sep) = 0; @@ -73,7 +75,7 @@ public: public: virtual ~BindingsHandler(); virtual bool HandleBinding(StoreManager& SMgr, Store store, - MemRegion* R, RVal val) = 0; + MemRegion* R, SVal val) = 0; }; /// iterBindings - Iterate over the bindings in the Store. diff --git a/clang/include/clang/Analysis/PathSensitive/SymbolManager.h b/clang/include/clang/Analysis/PathSensitive/SymbolManager.h index 0f6476100c49..e4ccbf0d43b2 100644 --- a/clang/include/clang/Analysis/PathSensitive/SymbolManager.h +++ b/clang/include/clang/Analysis/PathSensitive/SymbolManager.h @@ -198,7 +198,7 @@ public: } }; -// Constraints on symbols. Usually wrapped by RValues. +// Constraints on symbols. Usually wrapped by SValues. class SymIntConstraint : public llvm::FoldingSetNode { SymbolID Symbol; diff --git a/clang/lib/Analysis/BasicConstraintManager.cpp b/clang/lib/Analysis/BasicConstraintManager.cpp index 8d391bbb58c0..aab1f5e7eb15 100644 --- a/clang/lib/Analysis/BasicConstraintManager.cpp +++ b/clang/lib/Analysis/BasicConstraintManager.cpp @@ -33,19 +33,19 @@ class VISIBILITY_HIDDEN BasicConstraintManager : public ConstraintManager { public: BasicConstraintManager(GRStateManager& statemgr) : StateMgr(statemgr) {} - virtual const GRState* Assume(const GRState* St, RVal Cond, + virtual const GRState* Assume(const GRState* St, SVal Cond, bool Assumption, bool& isFeasible); - const GRState* Assume(const GRState* St, LVal Cond, bool Assumption, + const GRState* Assume(const GRState* St, Loc Cond, bool Assumption, bool& isFeasible); - const GRState* AssumeAux(const GRState* St, LVal Cond,bool Assumption, + const GRState* AssumeAux(const GRState* St, Loc Cond,bool Assumption, bool& isFeasible); - const GRState* Assume(const GRState* St, NonLVal Cond, bool Assumption, + const GRState* Assume(const GRState* St, NonLoc Cond, bool Assumption, bool& isFeasible); - const GRState* AssumeAux(const GRState* St, NonLVal Cond, bool Assumption, + const GRState* AssumeAux(const GRState* St, NonLoc Cond, bool Assumption, bool& isFeasible); const GRState* AssumeSymInt(const GRState* St, bool Assumption, @@ -92,52 +92,52 @@ ConstraintManager* clang::CreateBasicConstraintManager(GRStateManager& StateMgr) return new BasicConstraintManager(StateMgr); } -const GRState* BasicConstraintManager::Assume(const GRState* St, RVal Cond, +const GRState* BasicConstraintManager::Assume(const GRState* St, SVal Cond, bool Assumption, bool& isFeasible) { if (Cond.isUnknown()) { isFeasible = true; return St; } - if (isa(Cond)) - return Assume(St, cast(Cond), Assumption, isFeasible); + if (isa(Cond)) + return Assume(St, cast(Cond), Assumption, isFeasible); else - return Assume(St, cast(Cond), Assumption, isFeasible); + return Assume(St, cast(Cond), Assumption, isFeasible); } -const GRState* BasicConstraintManager::Assume(const GRState* St, LVal Cond, +const GRState* BasicConstraintManager::Assume(const GRState* St, Loc Cond, bool Assumption, bool& isFeasible) { St = AssumeAux(St, Cond, Assumption, isFeasible); // TF->EvalAssume(*this, St, Cond, Assumption, isFeasible) return St; } -const GRState* BasicConstraintManager::AssumeAux(const GRState* St, LVal Cond, +const GRState* BasicConstraintManager::AssumeAux(const GRState* St, Loc Cond, bool Assumption, bool& isFeasible) { BasicValueFactory& BasicVals = StateMgr.getBasicVals(); switch (Cond.getSubKind()) { default: - assert (false && "'Assume' not implemented for this LVal."); + assert (false && "'Assume' not implemented for this Loc."); return St; - case lval::SymbolValKind: + case loc::SymbolValKind: if (Assumption) - return AssumeSymNE(St, cast(Cond).getSymbol(), + return AssumeSymNE(St, cast(Cond).getSymbol(), BasicVals.getZeroWithPtrWidth(), isFeasible); else - return AssumeSymEQ(St, cast(Cond).getSymbol(), + return AssumeSymEQ(St, cast(Cond).getSymbol(), BasicVals.getZeroWithPtrWidth(), isFeasible); - case lval::MemRegionKind: - case lval::FuncValKind: - case lval::GotoLabelKind: - case lval::StringLiteralValKind: + case loc::MemRegionKind: + case loc::FuncValKind: + case loc::GotoLabelKind: + case loc::StringLiteralValKind: isFeasible = Assumption; return St; - case lval::ConcreteIntKind: { - bool b = cast(Cond).getValue() != 0; + case loc::ConcreteIntKind: { + bool b = cast(Cond).getValue() != 0; isFeasible = b ? Assumption : !Assumption; return St; } @@ -145,7 +145,7 @@ const GRState* BasicConstraintManager::AssumeAux(const GRState* St, LVal Cond, } const GRState* -BasicConstraintManager::Assume(const GRState* St, NonLVal Cond, bool Assumption, +BasicConstraintManager::Assume(const GRState* St, NonLoc Cond, bool Assumption, bool& isFeasible) { St = AssumeAux(St, Cond, Assumption, isFeasible); // TF->EvalAssume() does nothing now. @@ -153,17 +153,17 @@ BasicConstraintManager::Assume(const GRState* St, NonLVal Cond, bool Assumption, } const GRState* -BasicConstraintManager::AssumeAux(const GRState* St,NonLVal Cond, +BasicConstraintManager::AssumeAux(const GRState* St,NonLoc Cond, bool Assumption, bool& isFeasible) { BasicValueFactory& BasicVals = StateMgr.getBasicVals(); SymbolManager& SymMgr = StateMgr.getSymbolManager(); switch (Cond.getSubKind()) { default: - assert(false && "'Assume' not implemented for this NonLVal"); + assert(false && "'Assume' not implemented for this NonLoc"); - case nonlval::SymbolValKind: { - nonlval::SymbolVal& SV = cast(Cond); + case nonloc::SymbolValKind: { + nonloc::SymbolVal& SV = cast(Cond); SymbolID sym = SV.getSymbol(); if (Assumption) @@ -174,20 +174,20 @@ BasicConstraintManager::AssumeAux(const GRState* St,NonLVal Cond, isFeasible); } - case nonlval::SymIntConstraintValKind: + case nonloc::SymIntConstraintValKind: return AssumeSymInt(St, Assumption, - cast(Cond).getConstraint(), + cast(Cond).getConstraint(), isFeasible); - case nonlval::ConcreteIntKind: { - bool b = cast(Cond).getValue() != 0; + case nonloc::ConcreteIntKind: { + bool b = cast(Cond).getValue() != 0; isFeasible = b ? Assumption : !Assumption; return St; } - case nonlval::LValAsIntegerKind: - return AssumeAux(St, cast(Cond).getLVal(), + case nonloc::LocAsIntegerKind: + return AssumeAux(St, cast(Cond).getLoc(), Assumption, isFeasible); } // end switch } diff --git a/clang/lib/Analysis/BasicObjCFoundationChecks.cpp b/clang/lib/Analysis/BasicObjCFoundationChecks.cpp index b3f534d1af01..8e322189e628 100644 --- a/clang/lib/Analysis/BasicObjCFoundationChecks.cpp +++ b/clang/lib/Analysis/BasicObjCFoundationChecks.cpp @@ -118,7 +118,7 @@ class VISIBILITY_HIDDEN BasicObjCFoundationChecks : public GRSimpleAPICheck { typedef std::vector ErrorsTy; ErrorsTy Errors; - RVal GetRVal(const GRState* St, Expr* E) { return VMgr->GetRVal(St, E); } + SVal GetSVal(const GRState* St, Expr* E) { return VMgr->GetSVal(St, E); } bool isNSString(ObjCInterfaceType* T, const char* suffix); bool AuditNSString(NodeTy* N, ObjCMessageExpr* ME); @@ -193,8 +193,8 @@ bool BasicObjCFoundationChecks::Audit(ExplodedNode* N, return false; } -static inline bool isNil(RVal X) { - return isa(X); +static inline bool isNil(SVal X) { + return isa(X); } //===----------------------------------------------------------------------===// @@ -214,7 +214,7 @@ bool BasicObjCFoundationChecks::CheckNilArg(NodeTy* N, unsigned Arg) { Expr * E = ME->getArg(Arg); - if (isNil(GetRVal(N->getState(), E))) { + if (isNil(GetSVal(N->getState(), E))) { WarnNilArg(N, ME, Arg); return true; } @@ -350,7 +350,7 @@ class VISIBILITY_HIDDEN AuditCFNumberCreate : public GRSimpleAPICheck { IdentifierInfo* II; GRStateManager* VMgr; - RVal GetRVal(const GRState* St, Expr* E) { return VMgr->GetRVal(St, E); } + SVal GetSVal(const GRState* St, Expr* E) { return VMgr->GetSVal(St, E); } public: @@ -468,18 +468,18 @@ static const char* GetCFNumberTypeStr(uint64_t i) { bool AuditCFNumberCreate::Audit(ExplodedNode* N,GRStateManager&){ CallExpr* CE = cast(cast(N->getLocation()).getStmt()); Expr* Callee = CE->getCallee(); - RVal CallV = GetRVal(N->getState(), Callee); - lval::FuncVal* FuncV = dyn_cast(&CallV); + SVal CallV = GetSVal(N->getState(), Callee); + loc::FuncVal* FuncV = dyn_cast(&CallV); if (!FuncV || FuncV->getDecl()->getIdentifier() != II || CE->getNumArgs()!=3) return false; // Get the value of the "theType" argument. - RVal TheTypeVal = GetRVal(N->getState(), CE->getArg(1)); + SVal TheTypeVal = GetSVal(N->getState(), CE->getArg(1)); // FIXME: We really should allow ranges of valid theType values, and // bifurcate the state appropriately. - nonlval::ConcreteInt* V = dyn_cast(&TheTypeVal); + nonloc::ConcreteInt* V = dyn_cast(&TheTypeVal); if (!V) return false; @@ -494,11 +494,11 @@ bool AuditCFNumberCreate::Audit(ExplodedNode* N,GRStateManager&){ // 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. - RVal TheValueExpr = GetRVal(N->getState(), CE->getArg(2)); + SVal TheValueExpr = GetSVal(N->getState(), 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. - lval::MemRegionVal* LV = dyn_cast(&TheValueExpr); + loc::MemRegionVal* LV = dyn_cast(&TheValueExpr); if (!LV) return false; diff --git a/clang/lib/Analysis/BasicStore.cpp b/clang/lib/Analysis/BasicStore.cpp index 9d8a9acda509..7998ef4613f3 100644 --- a/clang/lib/Analysis/BasicStore.cpp +++ b/clang/lib/Analysis/BasicStore.cpp @@ -19,7 +19,7 @@ using namespace clang; -typedef llvm::ImmutableMap VarBindingsTy; +typedef llvm::ImmutableMap VarBindingsTy; namespace { @@ -34,23 +34,23 @@ public: virtual ~BasicStoreManager() {} - virtual RVal GetRVal(Store St, LVal LV, QualType T); - virtual Store SetRVal(Store St, LVal LV, RVal V); - virtual Store Remove(Store St, LVal LV); + virtual SVal GetSVal(Store St, Loc LV, QualType T); + virtual Store SetSVal(Store St, Loc LV, SVal V); + virtual Store Remove(Store St, Loc LV); virtual Store getInitialStore(); virtual MemRegionManager& getRegionManager() { return MRMgr; } // FIXME: Investigate what is using this. This method should be removed. - virtual LVal getLVal(const VarDecl* VD) { - return lval::MemRegionVal(MRMgr.getVarRegion(VD)); + virtual Loc getLoc(const VarDecl* VD) { + return loc::MemRegionVal(MRMgr.getVarRegion(VD)); } - RVal getLValueVar(const GRState* St, const VarDecl* VD); - RVal getLValueIvar(const GRState* St, const ObjCIvarDecl* D, RVal Base); - RVal getLValueField(const GRState* St, const FieldDecl* D, RVal Base); - RVal getLValueElement(const GRState* St, RVal Base, RVal Offset); + SVal getLValueVar(const GRState* St, const VarDecl* VD); + SVal getLValueIvar(const GRState* St, const ObjCIvarDecl* D, SVal Base); + SVal getLValueField(const GRState* St, const FieldDecl* D, SVal Base); + SVal getLValueElement(const GRState* St, SVal Base, SVal Offset); virtual Store RemoveDeadBindings(Store store, Stmt* Loc, const LiveVariables& Live, @@ -61,7 +61,7 @@ public: virtual Store AddDecl(Store store, const VarDecl* VD, Expr* Ex, - RVal InitVal = UndefinedVal(), unsigned Count = 0); + SVal InitVal = UndefinedVal(), unsigned Count = 0); static inline VarBindingsTy GetVarBindings(Store store) { return VarBindingsTy(static_cast(store)); @@ -78,27 +78,27 @@ public: StoreManager* clang::CreateBasicStoreManager(GRStateManager& StMgr) { return new BasicStoreManager(StMgr); } -RVal BasicStoreManager::getLValueVar(const GRState* St, const VarDecl* VD) { - return lval::MemRegionVal(MRMgr.getVarRegion(VD)); +SVal BasicStoreManager::getLValueVar(const GRState* St, const VarDecl* VD) { + return loc::MemRegionVal(MRMgr.getVarRegion(VD)); } -RVal BasicStoreManager::getLValueIvar(const GRState* St, const ObjCIvarDecl* D, - RVal Base) { +SVal BasicStoreManager::getLValueIvar(const GRState* St, const ObjCIvarDecl* D, + SVal Base) { return UnknownVal(); } -RVal BasicStoreManager::getLValueField(const GRState* St, const FieldDecl* D, - RVal Base) { +SVal BasicStoreManager::getLValueField(const GRState* St, const FieldDecl* D, + SVal Base) { return UnknownVal(); } -RVal BasicStoreManager::getLValueElement(const GRState* St, RVal Base, - RVal Offset) { +SVal BasicStoreManager::getLValueElement(const GRState* St, SVal Base, + SVal Offset) { return UnknownVal(); } -RVal BasicStoreManager::GetRVal(Store St, LVal LV, QualType T) { +SVal BasicStoreManager::GetSVal(Store St, Loc LV, QualType T) { if (isa(LV)) return UnknownVal(); @@ -107,9 +107,9 @@ RVal BasicStoreManager::GetRVal(Store St, LVal LV, QualType T) { switch (LV.getSubKind()) { - case lval::MemRegionKind: { + case loc::MemRegionKind: { VarRegion* R = - dyn_cast(cast(LV).getRegion()); + dyn_cast(cast(LV).getRegion()); if (!R) return UnknownVal(); @@ -119,34 +119,34 @@ RVal BasicStoreManager::GetRVal(Store St, LVal LV, QualType T) { return T ? *T : UnknownVal(); } - case lval::SymbolValKind: + case loc::SymbolValKind: return UnknownVal(); - case lval::ConcreteIntKind: - // Some clients may call GetRVal with such an option simply because - // they are doing a quick scan through their LVals (potentially to + case loc::ConcreteIntKind: + // Some clients may call GetSVal with such an option simply because + // they are doing a quick scan through their Locs (potentially to // invalidate their bindings). Just return Undefined. return UndefinedVal(); - case lval::FuncValKind: + case loc::FuncValKind: return LV; - case lval::StringLiteralValKind: + case loc::StringLiteralValKind: // FIXME: Implement better support for fetching characters from strings. return UnknownVal(); default: - assert (false && "Invalid LVal."); + assert (false && "Invalid Loc."); break; } return UnknownVal(); } -Store BasicStoreManager::SetRVal(Store store, LVal LV, RVal V) { +Store BasicStoreManager::SetSVal(Store store, Loc LV, SVal V) { switch (LV.getSubKind()) { - case lval::MemRegionKind: { + case loc::MemRegionKind: { VarRegion* R = - dyn_cast(cast(LV).getRegion()); + dyn_cast(cast(LV).getRegion()); if (!R) return store; @@ -157,16 +157,16 @@ Store BasicStoreManager::SetRVal(Store store, LVal LV, RVal V) { : VBFactory.Add(B, R->getDecl(), V).getRoot(); } default: - assert ("SetRVal for given LVal type not yet implemented."); + assert ("SetSVal for given Loc type not yet implemented."); return store; } } -Store BasicStoreManager::Remove(Store store, LVal LV) { +Store BasicStoreManager::Remove(Store store, Loc LV) { switch (LV.getSubKind()) { - case lval::MemRegionKind: { + case loc::MemRegionKind: { VarRegion* R = - dyn_cast(cast(LV).getRegion()); + dyn_cast(cast(LV).getRegion()); if (!R) return store; @@ -175,7 +175,7 @@ Store BasicStoreManager::Remove(Store store, LVal LV) { return VBFactory.Remove(B,R->getDecl()).getRoot(); } default: - assert ("Remove for given LVal type not yet implemented."); + assert ("Remove for given Loc type not yet implemented."); return store; } } @@ -187,13 +187,13 @@ BasicStoreManager::RemoveDeadBindings(Store store, Stmt* Loc, LiveSymbolsTy& LSymbols, DeadSymbolsTy& DSymbols) { VarBindingsTy B = GetVarBindings(store); - typedef RVal::symbol_iterator symbol_iterator; + typedef SVal::symbol_iterator symbol_iterator; // Iterate over the variable bindings. for (VarBindingsTy::iterator I=B.begin(), E=B.end(); I!=E ; ++I) if (Liveness.isLive(Loc, I.getKey())) { RegionRoots.push_back(MRMgr.getVarRegion(I.getKey())); - RVal X = I.getData(); + SVal X = I.getData(); for (symbol_iterator SI=X.symbol_begin(), SE=X.symbol_end(); SI!=SE; ++SI) LSymbols.insert(*SI); @@ -212,15 +212,15 @@ BasicStoreManager::RemoveDeadBindings(Store store, Stmt* Loc, Marked.insert(R); // FIXME: Do we need the QualType here, since regions are partially // typed? - RVal X = GetRVal(store, lval::MemRegionVal(R), QualType()); + SVal X = GetSVal(store, loc::MemRegionVal(R), QualType()); for (symbol_iterator SI=X.symbol_begin(), SE=X.symbol_end(); SI!=SE; ++SI) LSymbols.insert(*SI); - if (!isa(X)) + if (!isa(X)) continue; - const lval::MemRegionVal& LVD = cast(X); + const loc::MemRegionVal& LVD = cast(X); RegionRoots.push_back(cast(LVD.getRegion())); } @@ -229,8 +229,8 @@ BasicStoreManager::RemoveDeadBindings(Store store, Stmt* Loc, const VarRegion* R = cast(MRMgr.getVarRegion(I.getKey())); if (!Marked.count(R)) { - store = Remove(store, lval::MemRegionVal(R)); - RVal X = I.getData(); + store = Remove(store, loc::MemRegionVal(R)); + SVal X = I.getData(); for (symbol_iterator SI=X.symbol_begin(), SE=X.symbol_end(); SI!=SE; ++SI) if (!LSymbols.count(*SI)) DSymbols.insert(*SI); @@ -260,15 +260,15 @@ Store BasicStoreManager::getInitialStore() { // Only handle pointers and integers for now. QualType T = VD->getType(); - if (LVal::IsLValType(T) || T->isIntegerType()) { + if (Loc::IsLocType(T) || T->isIntegerType()) { // Initialize globals and parameters to symbolic values. // Initialize local variables to undefined. - RVal X = (VD->hasGlobalStorage() || isa(VD) || + SVal X = (VD->hasGlobalStorage() || isa(VD) || isa(VD)) - ? RVal::GetSymbolValue(StateMgr.getSymbolManager(), VD) + ? SVal::GetSymbolValue(StateMgr.getSymbolManager(), VD) : UndefinedVal(); - St = SetRVal(St, lval::MemRegionVal(MRMgr.getVarRegion(VD)), X); + St = SetSVal(St, loc::MemRegionVal(MRMgr.getVarRegion(VD)), X); } } } @@ -277,7 +277,7 @@ Store BasicStoreManager::getInitialStore() { Store BasicStoreManager::AddDecl(Store store, const VarDecl* VD, Expr* Ex, - RVal InitVal, unsigned Count) { + SVal InitVal, unsigned Count) { BasicValueFactory& BasicVals = StateMgr.getBasicVals(); SymbolManager& SymMgr = StateMgr.getSymbolManager(); @@ -307,35 +307,35 @@ Store BasicStoreManager::AddDecl(Store store, // unsigned) zero; if (!Ex) { QualType T = VD->getType(); - if (LVal::IsLValType(T)) - store = SetRVal(store, getLVal(VD), - lval::ConcreteInt(BasicVals.getValue(0, T))); + if (Loc::IsLocType(T)) + store = SetSVal(store, getLoc(VD), + loc::ConcreteInt(BasicVals.getValue(0, T))); else if (T->isIntegerType()) - store = SetRVal(store, getLVal(VD), - nonlval::ConcreteInt(BasicVals.getValue(0, T))); + store = SetSVal(store, getLoc(VD), + nonloc::ConcreteInt(BasicVals.getValue(0, T))); else { // assert(0 && "ignore other types of variables"); } } else { - store = SetRVal(store, getLVal(VD), InitVal); + store = SetSVal(store, getLoc(VD), InitVal); } } } else { // Process local scalar variables. QualType T = VD->getType(); - if (LVal::IsLValType(T) || T->isIntegerType()) { - RVal V = Ex ? InitVal : UndefinedVal(); + if (Loc::IsLocType(T) || T->isIntegerType()) { + SVal V = Ex ? InitVal : UndefinedVal(); if (Ex && InitVal.isUnknown()) { // EXPERIMENTAL: "Conjured" symbols. SymbolID Sym = SymMgr.getConjuredSymbol(Ex, Count); - V = LVal::IsLValType(Ex->getType()) - ? cast(lval::SymbolVal(Sym)) - : cast(nonlval::SymbolVal(Sym)); + V = Loc::IsLocType(Ex->getType()) + ? cast(loc::SymbolVal(Sym)) + : cast(nonloc::SymbolVal(Sym)); } - store = SetRVal(store, getLVal(VD), V); + store = SetSVal(store, getLoc(VD), V); } } diff --git a/clang/lib/Analysis/BasicValueFactory.cpp b/clang/lib/Analysis/BasicValueFactory.cpp index a9bb2cec4bda..e20cf1678925 100644 --- a/clang/lib/Analysis/BasicValueFactory.cpp +++ b/clang/lib/Analysis/BasicValueFactory.cpp @@ -18,31 +18,31 @@ using namespace clang; -typedef std::pair RValData; -typedef std::pair RValPair; +typedef std::pair SValData; +typedef std::pair SValPair; namespace llvm { -template<> struct FoldingSetTrait { - static inline void Profile(const RValData& X, llvm::FoldingSetNodeID& ID) { +template<> struct FoldingSetTrait { + static inline void Profile(const SValData& X, llvm::FoldingSetNodeID& ID) { X.first.Profile(ID); ID.AddPointer( (void*) X.second); } }; -template<> struct FoldingSetTrait { - static inline void Profile(const RValPair& X, llvm::FoldingSetNodeID& ID) { +template<> struct FoldingSetTrait { + static inline void Profile(const SValPair& X, llvm::FoldingSetNodeID& ID) { X.first.Profile(ID); X.second.Profile(ID); } }; } -typedef llvm::FoldingSet > - PersistentRValsTy; +typedef llvm::FoldingSet > + PersistentSValsTy; -typedef llvm::FoldingSet > - PersistentRValPairsTy; +typedef llvm::FoldingSet > + PersistentSValPairsTy; BasicValueFactory::~BasicValueFactory() { // Note that the dstor for the contents of APSIntSet will never be called, @@ -51,8 +51,8 @@ BasicValueFactory::~BasicValueFactory() { for (APSIntSetTy::iterator I=APSIntSet.begin(), E=APSIntSet.end(); I!=E; ++I) I->getValue().~APSInt(); - delete (PersistentRValsTy*) PersistentRVals; - delete (PersistentRValPairsTy*) PersistentRValPairs; + delete (PersistentSValsTy*) PersistentSVals; + delete (PersistentSValPairsTy*) PersistentSValPairs; } const llvm::APSInt& BasicValueFactory::getValue(const llvm::APSInt& X) { @@ -197,20 +197,20 @@ BasicValueFactory::EvaluateAPSInt(BinaryOperator::Opcode Op, } -const std::pair& -BasicValueFactory::getPersistentRValWithData(const RVal& V, uintptr_t Data) { +const std::pair& +BasicValueFactory::getPersistentSValWithData(const SVal& V, uintptr_t Data) { // Lazily create the folding set. - if (!PersistentRVals) PersistentRVals = new PersistentRValsTy(); + if (!PersistentSVals) PersistentSVals = new PersistentSValsTy(); llvm::FoldingSetNodeID ID; void* InsertPos; V.Profile(ID); ID.AddPointer((void*) Data); - PersistentRValsTy& Map = *((PersistentRValsTy*) PersistentRVals); + PersistentSValsTy& Map = *((PersistentSValsTy*) PersistentSVals); - typedef llvm::FoldingSetNodeWrapper FoldNodeTy; + typedef llvm::FoldingSetNodeWrapper FoldNodeTy; FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos); if (!P) { @@ -222,20 +222,20 @@ BasicValueFactory::getPersistentRValWithData(const RVal& V, uintptr_t Data) { return P->getValue(); } -const std::pair& -BasicValueFactory::getPersistentRValPair(const RVal& V1, const RVal& V2) { +const std::pair& +BasicValueFactory::getPersistentSValPair(const SVal& V1, const SVal& V2) { // Lazily create the folding set. - if (!PersistentRValPairs) PersistentRValPairs = new PersistentRValPairsTy(); + if (!PersistentSValPairs) PersistentSValPairs = new PersistentSValPairsTy(); llvm::FoldingSetNodeID ID; void* InsertPos; V1.Profile(ID); V2.Profile(ID); - PersistentRValPairsTy& Map = *((PersistentRValPairsTy*) PersistentRValPairs); + PersistentSValPairsTy& Map = *((PersistentSValPairsTy*) PersistentSValPairs); - typedef llvm::FoldingSetNodeWrapper FoldNodeTy; + typedef llvm::FoldingSetNodeWrapper FoldNodeTy; FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos); if (!P) { @@ -247,8 +247,8 @@ BasicValueFactory::getPersistentRValPair(const RVal& V1, const RVal& V2) { return P->getValue(); } -const RVal* BasicValueFactory::getPersistentRVal(RVal X) { - return &getPersistentRValWithData(X, 0).first; +const SVal* BasicValueFactory::getPersistentSVal(SVal X) { + return &getPersistentSValWithData(X, 0).first; } diff --git a/clang/lib/Analysis/BugReporter.cpp b/clang/lib/Analysis/BugReporter.cpp index 834567136f46..0663ddde4170 100644 --- a/clang/lib/Analysis/BugReporter.cpp +++ b/clang/lib/Analysis/BugReporter.cpp @@ -292,7 +292,7 @@ MakeReportGraph(ExplodedGraph* G, ExplodedNode* N) { static VarDecl* GetMostRecentVarDeclBinding(ExplodedNode* N, GRStateManager& VMgr, - RVal X) { + SVal X) { for ( ; N ; N = N->pred_empty() ? 0 : *N->pred_begin()) { @@ -306,7 +306,7 @@ static VarDecl* GetMostRecentVarDeclBinding(ExplodedNode* N, if (!DR) continue; - RVal Y = VMgr.GetRVal(N->getState(), DR); + SVal Y = VMgr.GetSVal(N->getState(), DR); if (X != Y) continue; @@ -341,13 +341,13 @@ public: PathDiagnostic& pd, BugReporter& br) : Sym(sym), PrevSt(prevst), S(s), VMgr(vmgr), Pred(pred), PD(pd), BR(br) {} - bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, RVal V) { + bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal V) { SymbolID ScanSym; - if (lval::SymbolVal* SV = dyn_cast(&V)) + if (loc::SymbolVal* SV = dyn_cast(&V)) ScanSym = SV->getSymbol(); - else if (nonlval::SymbolVal* SV = dyn_cast(&V)) + else if (nonloc::SymbolVal* SV = dyn_cast(&V)) ScanSym = SV->getSymbol(); else return true; @@ -356,7 +356,7 @@ public: return true; // Check if the previous state has this binding. - RVal X = VMgr.GetRVal(PrevSt, lval::MemRegionVal(R)); + SVal X = VMgr.GetSVal(PrevSt, loc::MemRegionVal(R)); if (X == V) // Same binding? return true; @@ -443,12 +443,12 @@ public: PathDiagnostic& pd) : N(n), S(s), BR(br), PD(pd) {} - bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, RVal V) { + bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal V) { SymbolID ScanSym; - if (lval::SymbolVal* SV = dyn_cast(&V)) + if (loc::SymbolVal* SV = dyn_cast(&V)) ScanSym = SV->getSymbol(); - else if (nonlval::SymbolVal* SV = dyn_cast(&V)) + else if (nonloc::SymbolVal* SV = dyn_cast(&V)) ScanSym = SV->getSymbol(); else return true; diff --git a/clang/lib/Analysis/CFRefCount.cpp b/clang/lib/Analysis/CFRefCount.cpp index c63529aa0559..9d632314b2dd 100644 --- a/clang/lib/Analysis/CFRefCount.cpp +++ b/clang/lib/Analysis/CFRefCount.cpp @@ -1297,7 +1297,7 @@ public: virtual void EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Eng, GRStmtNodeBuilder& Builder, - CallExpr* CE, RVal L, + CallExpr* CE, SVal L, ExplodedNode* Pred); @@ -1319,7 +1319,7 @@ public: GRExprEngine& Engine, GRStmtNodeBuilder& Builder, Expr* E, ExplodedNode* Pred, - const GRState* St, RVal TargetLV, RVal Val); + const GRState* St, SVal TargetLV, SVal Val); // End-of-path. virtual void EvalEndPath(GRExprEngine& Engine, @@ -1343,7 +1343,7 @@ public: // Assumptions. virtual const GRState* EvalAssume(GRStateManager& VMgr, - const GRState* St, RVal Cond, + const GRState* St, SVal Cond, bool Assumption, bool& isFeasible); // Error iterators. @@ -1473,10 +1473,10 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst, SymbolID ErrorSym = 0; for (ExprIterator I = arg_beg; I != arg_end; ++I, ++idx) { - RVal V = state.GetRVal(*I); + SVal V = state.GetSVal(*I); - if (isa(V)) { - SymbolID Sym = cast(V).getSymbol(); + if (isa(V)) { + SymbolID Sym = cast(V).getSymbol(); if (RefBindings::data_type* T = state.get(Sym)) if (Update(state, Sym, *T, GetArgE(Summ, idx), hasErr)) { ErrorExpr = *I; @@ -1484,12 +1484,12 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst, break; } } - else if (isa(V)) { + else if (isa(V)) { #if 0 // Nuke all arguments passed by reference. - StateMgr.Unbind(StVals, cast(V)); + StateMgr.Unbind(StVals, cast(V)); #else - if (lval::MemRegionVal* MR = dyn_cast(&V)) { + if (loc::MemRegionVal* MR = dyn_cast(&V)) { if (GetArgE(Summ, idx) == DoNothingByRef) continue; @@ -1506,10 +1506,10 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst, // disambiguate conjured symbols. // Is the invalidated variable something that we were tracking? - RVal X = state.GetRVal(*MR); + SVal X = state.GetSVal(*MR); - if (isa(X)) { - SymbolID Sym = cast(X).getSymbol(); + if (isa(X)) { + SymbolID Sym = cast(X).getSymbol(); state = state.remove(Sym); } @@ -1521,29 +1521,29 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst, SymbolID NewSym = Eng.getSymbolManager().getConjuredSymbol(*I, T, Count); - state = state.SetRVal(*MR, - LVal::IsLValType(T) - ? cast(lval::SymbolVal(NewSym)) - : cast(nonlval::SymbolVal(NewSym))); + state = state.SetSVal(*MR, + Loc::IsLocType(T) + ? cast(loc::SymbolVal(NewSym)) + : cast(nonloc::SymbolVal(NewSym))); } else - state = state.SetRVal(*MR, UnknownVal()); + state = state.SetSVal(*MR, UnknownVal()); } else { // Nuke all other arguments passed by reference. - state = state.Unbind(cast(V)); + state = state.Unbind(cast(V)); } #endif } - else if (isa(V)) - state = state.Unbind(cast(V).getLVal()); + else if (isa(V)) + state = state.Unbind(cast(V).getLoc()); } // Evaluate the effect on the message receiver. if (!ErrorExpr && Receiver) { - RVal V = state.GetRVal(Receiver); - if (isa(V)) { - SymbolID Sym = cast(V).getSymbol(); + SVal V = state.GetSVal(Receiver); + if (isa(V)) { + SymbolID Sym = cast(V).getSymbol(); if (const RefVal* T = state.get(Sym)) if (Update(state, Sym, *T, GetReceiverE(Summ), hasErr)) { ErrorExpr = Receiver; @@ -1576,11 +1576,11 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst, unsigned Count = Builder.getCurrentBlockCount(); SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count); - RVal X = LVal::IsLValType(Ex->getType()) - ? cast(lval::SymbolVal(Sym)) - : cast(nonlval::SymbolVal(Sym)); + SVal X = Loc::IsLocType(Ex->getType()) + ? cast(loc::SymbolVal(Sym)) + : cast(nonloc::SymbolVal(Sym)); - state = state.SetRVal(Ex, X, false); + state = state.SetSVal(Ex, X, false); } break; @@ -1589,15 +1589,15 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst, unsigned idx = RE.getIndex(); assert (arg_end >= arg_beg); assert (idx < (unsigned) (arg_end - arg_beg)); - RVal V = state.GetRVal(*(arg_beg+idx)); - state = state.SetRVal(Ex, V, false); + SVal V = state.GetSVal(*(arg_beg+idx)); + state = state.SetSVal(Ex, V, false); break; } case RetEffect::ReceiverAlias: { assert (Receiver); - RVal V = state.GetRVal(Receiver); - state = state.SetRVal(Ex, V, false); + SVal V = state.GetSVal(Receiver); + state = state.SetSVal(Ex, V, false); break; } @@ -1608,7 +1608,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst, QualType RetT = GetReturnType(Ex, Eng.getContext()); state = state.set(Sym, RefVal::makeOwned(RetT)); - state = state.SetRVal(Ex, lval::SymbolVal(Sym), false); + state = state.SetSVal(Ex, loc::SymbolVal(Sym), false); #if 0 RefBindings B = GetRefBindings(StImpl); @@ -1628,7 +1628,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst, QualType RetT = GetReturnType(Ex, Eng.getContext()); state = state.set(Sym, RefVal::makeNotOwned(RetT)); - state = state.SetRVal(Ex, lval::SymbolVal(Sym), false); + state = state.SetSVal(Ex, loc::SymbolVal(Sym), false); break; } } @@ -1644,11 +1644,11 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& Dst, void CFRefCount::EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Eng, GRStmtNodeBuilder& Builder, - CallExpr* CE, RVal L, + CallExpr* CE, SVal L, ExplodedNode* Pred) { - RetainSummary* Summ = !isa(L) ? 0 - : Summaries.getSummary(cast(L).getDecl()); + RetainSummary* Summ = !isa(L) ? 0 + : Summaries.getSummary(cast(L).getDecl()); EvalSummary(Dst, Eng, Builder, CE, 0, Summ, CE->arg_begin(), CE->arg_end(), Pred); @@ -1669,10 +1669,10 @@ void CFRefCount::EvalObjCMessageExpr(ExplodedNodeSet& Dst, // FIXME: Wouldn't it be great if this code could be reduced? It's just // a chain of lookups. const GRState* St = Builder.GetState(Pred); - RVal V = Eng.getStateManager().GetRVal(St, Receiver ); + SVal V = Eng.getStateManager().GetSVal(St, Receiver ); - if (isa(V)) { - SymbolID Sym = cast(V).getSymbol(); + if (isa(V)) { + SymbolID Sym = cast(V).getSymbol(); if (const RefVal* T = St->get(Sym)) { QualType Ty = T->getType(); @@ -1702,29 +1702,29 @@ void CFRefCount::EvalStore(ExplodedNodeSet& Dst, GRExprEngine& Eng, GRStmtNodeBuilder& Builder, Expr* E, ExplodedNode* Pred, - const GRState* St, RVal TargetLV, RVal Val) { + const GRState* St, SVal TargetLV, SVal Val) { // Check if we have a binding for "Val" and if we are storing it to something // we don't understand or otherwise the value "escapes" the function. - if (!isa(Val)) + if (!isa(Val)) return; // Are we storing to something that causes the value to "escape"? bool escapes = false; - if (!isa(TargetLV)) + if (!isa(TargetLV)) escapes = true; else { - MemRegion* R = cast(TargetLV).getRegion(); + MemRegion* R = cast(TargetLV).getRegion(); escapes = !Eng.getStateManager().hasStackStorage(R); } if (!escapes) return; - SymbolID Sym = cast(Val).getSymbol(); + SymbolID Sym = cast(Val).getSymbol(); GRStateRef state(St, Eng.getStateManager()); @@ -1849,13 +1849,13 @@ void CFRefCount::EvalReturn(ExplodedNodeSet& Dst, if (!RetE) return; GRStateRef state(Builder.GetState(Pred), Eng.getStateManager()); - RVal V = state.GetRVal(RetE); + SVal V = state.GetSVal(RetE); - if (!isa(V)) + if (!isa(V)) return; // Get the reference count binding (if any). - SymbolID Sym = cast(V).getSymbol(); + SymbolID Sym = cast(V).getSymbol(); const RefVal* T = state.get(Sym); if (!T) @@ -1892,7 +1892,7 @@ void CFRefCount::EvalReturn(ExplodedNodeSet& Dst, const GRState* CFRefCount::EvalAssume(GRStateManager& VMgr, const GRState* St, - RVal Cond, bool Assumption, + SVal Cond, bool Assumption, bool& isFeasible) { // FIXME: We may add to the interface of EvalAssume the list of symbols @@ -2303,9 +2303,9 @@ PathDiagnosticPiece* CFRefReport::VisitNode(ExplodedNode* N, for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I!=E; ++I) if (Expr* Exp = dyn_cast_or_null(*I)) { - RVal X = VSM.GetRVal(CurrSt, Exp); + SVal X = VSM.GetSVal(CurrSt, Exp); - if (lval::SymbolVal* SV = dyn_cast(&X)) + if (loc::SymbolVal* SV = dyn_cast(&X)) if (SV->getSymbol() == Sym) { P->addRange(Exp->getSourceRange()); break; } @@ -2324,12 +2324,12 @@ class VISIBILITY_HIDDEN FindUniqueBinding : public: FindUniqueBinding(SymbolID sym) : Sym(sym), Binding(0), First(true) {} - bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, RVal val) { - if (const lval::SymbolVal* SV = dyn_cast(&val)) { + bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal val) { + if (const loc::SymbolVal* SV = dyn_cast(&val)) { if (SV->getSymbol() != Sym) return true; } - else if (const nonlval::SymbolVal* SV=dyn_cast(&val)) { + else if (const nonloc::SymbolVal* SV=dyn_cast(&val)) { if (SV->getSymbol() != Sym) return true; } diff --git a/clang/lib/Analysis/CheckNSError.cpp b/clang/lib/Analysis/CheckNSError.cpp index 6e52dd952d97..38d32a731dd9 100644 --- a/clang/lib/Analysis/CheckNSError.cpp +++ b/clang/lib/Analysis/CheckNSError.cpp @@ -216,11 +216,11 @@ void NSErrorCheck::CheckParamDeref(VarDecl* Param, GRStateRef rootState, GRExprEngine& Eng, GRBugReporter& BR, bool isNSErrorWarning) { - RVal ParamRVal = rootState.GetLValue(Param); + SVal ParamSVal = rootState.GetLValue(Param); - // FIXME: For now assume that ParamRVal is symbolic. We need to generalize + // FIXME: For now assume that ParamSVal is symbolic. We need to generalize // this later. - lval::SymbolVal* SV = dyn_cast(&ParamRVal); + loc::SymbolVal* SV = dyn_cast(&ParamSVal); if (!SV) return; // Iterate over the implicit-null dereferences. @@ -228,8 +228,8 @@ void NSErrorCheck::CheckParamDeref(VarDecl* Param, GRStateRef rootState, E=Eng.implicit_null_derefs_end(); I!=E; ++I) { GRStateRef state = GRStateRef((*I)->getState(), Eng.getStateManager()); - const RVal* X = state.get(); - const lval::SymbolVal* SVX = dyn_cast_or_null(X); + const SVal* X = state.get(); + const loc::SymbolVal* SVX = dyn_cast_or_null(X); if (!SVX || SVX->getSymbol() != SV->getSymbol()) continue; // Emit an error. diff --git a/clang/lib/Analysis/Environment.cpp b/clang/lib/Analysis/Environment.cpp index f86c4fea7165..a9afa6d86bd0 100644 --- a/clang/lib/Analysis/Environment.cpp +++ b/clang/lib/Analysis/Environment.cpp @@ -18,14 +18,14 @@ using namespace clang; -RVal Environment::GetRVal(Expr* E, BasicValueFactory& BasicVals) const { +SVal Environment::GetSVal(Expr* E, BasicValueFactory& BasicVals) const { for (;;) { switch (E->getStmtClass()) { case Stmt::AddrLabelExprClass: - return LVal::MakeVal(cast(E)); + return Loc::MakeVal(cast(E)); // ParenExprs are no-ops. @@ -35,15 +35,15 @@ RVal Environment::GetRVal(Expr* E, BasicValueFactory& BasicVals) const { case Stmt::CharacterLiteralClass: { CharacterLiteral* C = cast(E); - return NonLVal::MakeVal(BasicVals, C->getValue(), C->getType()); + return NonLoc::MakeVal(BasicVals, C->getValue(), C->getType()); } case Stmt::IntegerLiteralClass: { - return NonLVal::MakeVal(BasicVals, cast(E)); + return NonLoc::MakeVal(BasicVals, cast(E)); } case Stmt::StringLiteralClass: - return LVal::MakeVal(cast(E)); + return Loc::MakeVal(cast(E)); // Casts where the source and target type are the same // are no-ops. We blast through these to get the descendant @@ -73,18 +73,18 @@ RVal Environment::GetRVal(Expr* E, BasicValueFactory& BasicVals) const { return LookupExpr(E); } -RVal Environment::GetBlkExprRVal(Expr* E, BasicValueFactory& BasicVals) const { +SVal Environment::GetBlkExprSVal(Expr* E, BasicValueFactory& BasicVals) const { E = E->IgnoreParens(); switch (E->getStmtClass()) { case Stmt::CharacterLiteralClass: { CharacterLiteral* C = cast(E); - return NonLVal::MakeVal(BasicVals, C->getValue(), C->getType()); + return NonLoc::MakeVal(BasicVals, C->getValue(), C->getType()); } case Stmt::IntegerLiteralClass: { - return NonLVal::MakeVal(BasicVals, cast(E)); + return NonLoc::MakeVal(BasicVals, cast(E)); } default: @@ -92,7 +92,7 @@ RVal Environment::GetBlkExprRVal(Expr* E, BasicValueFactory& BasicVals) const { } } -Environment EnvironmentManager::SetRVal(const Environment& Env, Expr* E, RVal V, +Environment EnvironmentManager::SetSVal(const Environment& Env, Expr* E, SVal V, bool isBlkExpr, bool Invalidate) { assert (E); @@ -121,25 +121,25 @@ EnvironmentManager::RemoveDeadBindings(Environment Env, Stmt* Loc, Expr* BlkExpr = I.getKey(); if (Liveness.isLive(Loc, BlkExpr)) { - RVal X = I.getData(); + SVal X = I.getData(); // If the block expr's value is a memory region, then mark that region. - if (isa(X)) - DRoots.push_back(cast(X).getRegion()); + if (isa(X)) + DRoots.push_back(cast(X).getRegion()); // Mark all symbols in the block expr's value. - for (RVal::symbol_iterator SI = X.symbol_begin(), SE = X.symbol_end(); + for (SVal::symbol_iterator SI = X.symbol_begin(), SE = X.symbol_end(); SI != SE; ++SI) { LSymbols.insert(*SI); } } else { // The block expr is dead. - RVal X = I.getData(); + SVal X = I.getData(); // Do not misclean LogicalExpr or ConditionalOperator. It is dead at the // beginning of itself, but we need its UndefinedVal to determine its - // RVal. + // SVal. if (X.isUndef() && cast(X).getData()) continue; diff --git a/clang/lib/Analysis/GRExprEngine.cpp b/clang/lib/Analysis/GRExprEngine.cpp index bc7a00a54696..d8ab4b127566 100644 --- a/clang/lib/Analysis/GRExprEngine.cpp +++ b/clang/lib/Analysis/GRExprEngine.cpp @@ -302,7 +302,7 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) { } else if (B->getOpcode() == BinaryOperator::Comma) { const GRState* St = GetState(Pred); - MakeNode(Dst, B, Pred, SetRVal(St, B, GetRVal(St, B->getRHS()))); + MakeNode(Dst, B, Pred, SetSVal(St, B, GetSVal(St, B->getRHS()))); break; } @@ -385,7 +385,7 @@ void GRExprEngine::Visit(Stmt* S, NodeTy* Pred, NodeSet& Dst) { assert (!SE->getSubStmt()->body_empty()); if (Expr* LastExpr = dyn_cast(*SE->getSubStmt()->body_rbegin())) - MakeNode(Dst, SE, Pred, SetRVal(St, SE, GetRVal(St, LastExpr))); + MakeNode(Dst, SE, Pred, SetSVal(St, SE, GetSVal(St, LastExpr))); else Dst.Add(Pred); @@ -473,7 +473,7 @@ const GRState* GRExprEngine::MarkBranch(const GRState* St, (Op == BinaryOperator::LOr && !branchTaken) ? B->getRHS() : B->getLHS(); - return SetBlkExprRVal(St, B, UndefinedVal(Ex)); + return SetBlkExprSVal(St, B, UndefinedVal(Ex)); } case Stmt::ConditionalOperatorClass: { // ?: @@ -490,7 +490,7 @@ const GRState* GRExprEngine::MarkBranch(const GRState* St, else Ex = C->getRHS(); - return SetBlkExprRVal(St, C, UndefinedVal(Ex)); + return SetBlkExprSVal(St, C, UndefinedVal(Ex)); } case Stmt::ChooseExprClass: { // ?: @@ -498,7 +498,7 @@ const GRState* GRExprEngine::MarkBranch(const GRState* St, ChooseExpr* C = cast(Terminator); Expr* Ex = branchTaken ? C->getLHS() : C->getRHS(); - return SetBlkExprRVal(St, C, UndefinedVal(Ex)); + return SetBlkExprSVal(St, C, UndefinedVal(Ex)); } } } @@ -516,18 +516,18 @@ void GRExprEngine::ProcessBranch(Expr* Condition, Stmt* Term, return; } - RVal V = GetRVal(PrevState, Condition); + SVal V = GetSVal(PrevState, Condition); switch (V.getBaseKind()) { default: break; - case RVal::UnknownKind: + case SVal::UnknownKind: builder.generateNode(MarkBranch(PrevState, Term, true), true); builder.generateNode(MarkBranch(PrevState, Term, false), false); return; - case RVal::UndefinedKind: { + case SVal::UndefinedKind: { NodeTy* N = builder.generateNode(PrevState, true); if (N) { @@ -566,7 +566,7 @@ void GRExprEngine::ProcessBranch(Expr* Condition, Stmt* Term, void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) { const GRState* St = builder.getState(); - RVal V = GetRVal(St, builder.getTarget()); + SVal V = GetSVal(St, builder.getTarget()); // Three possibilities: // @@ -577,8 +577,8 @@ void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) { typedef IndirectGotoNodeBuilder::iterator iterator; - if (isa(V)) { - LabelStmt* L = cast(V).getLabel(); + if (isa(V)) { + LabelStmt* L = cast(V).getLabel(); for (iterator I=builder.begin(), E=builder.end(); I != E; ++I) { if (I.getLabel() == L) { @@ -591,7 +591,7 @@ void GRExprEngine::ProcessIndirectGoto(IndirectGotoNodeBuilder& builder) { return; } - if (isa(V) || isa(V)) { + if (isa(V) || isa(V)) { // Dispatch to the first target and mark it as a sink. NodeTy* N = builder.generateNode(builder.begin(), St, true); UndefBranches.insert(N); @@ -613,7 +613,7 @@ void GRExprEngine::VisitGuardedExpr(Expr* Ex, Expr* L, Expr* R, assert (Ex == CurrentStmt && getCFG().isBlkExpr(Ex)); const GRState* St = GetState(Pred); - RVal X = GetBlkExprRVal(St, Ex); + SVal X = GetBlkExprSVal(St, Ex); assert (X.isUndef()); @@ -621,10 +621,10 @@ void GRExprEngine::VisitGuardedExpr(Expr* Ex, Expr* L, Expr* R, assert (SE); - X = GetBlkExprRVal(St, SE); + X = GetBlkExprSVal(St, SE); // Make sure that we invalidate the previous binding. - MakeNode(Dst, Ex, Pred, StateMgr.SetRVal(St, Ex, X, true, true)); + MakeNode(Dst, Ex, Pred, StateMgr.SetSVal(St, Ex, X, true, true)); } /// ProcessSwitch - Called by GRCoreEngine. Used to generate successor @@ -635,7 +635,7 @@ void GRExprEngine::ProcessSwitch(SwitchNodeBuilder& builder) { const GRState* St = builder.getState(); Expr* CondE = builder.getCondition(); - RVal CondV = GetRVal(St, CondE); + SVal CondV = GetSVal(St, CondE); if (CondV.isUndef()) { NodeTy* N = builder.generateDefaultCaseNode(St, true); @@ -683,9 +683,9 @@ void GRExprEngine::ProcessSwitch(SwitchNodeBuilder& builder) { // This should be easy once we have "ranges" for NonLVals. do { - nonlval::ConcreteInt CaseVal(getBasicVals().getValue(V1)); + nonloc::ConcreteInt CaseVal(getBasicVals().getValue(V1)); - RVal Res = EvalBinOp(BinaryOperator::EQ, CondV, CaseVal); + SVal Res = EvalBinOp(BinaryOperator::EQ, CondV, CaseVal); // Now "assume" that the case matches. @@ -698,7 +698,7 @@ void GRExprEngine::ProcessSwitch(SwitchNodeBuilder& builder) { // If CondV evaluates to a constant, then we know that this // is the *only* case that we can take, so stop evaluating the // others. - if (isa(CondV)) + if (isa(CondV)) return; } @@ -741,7 +741,7 @@ void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred, assert (B == CurrentStmt && getCFG().isBlkExpr(B)); const GRState* St = GetState(Pred); - RVal X = GetBlkExprRVal(St, B); + SVal X = GetBlkExprSVal(St, B); assert (X.isUndef()); @@ -751,12 +751,12 @@ void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred, if (Ex == B->getRHS()) { - X = GetBlkExprRVal(St, Ex); + X = GetBlkExprSVal(St, Ex); // Handle undefined values. if (X.isUndef()) { - MakeNode(Dst, B, Pred, SetBlkExprRVal(St, B, X)); + MakeNode(Dst, B, Pred, SetBlkExprSVal(St, B, X)); return; } @@ -772,14 +772,14 @@ void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred, if (isFeasible) MakeNode(Dst, B, Pred, - SetBlkExprRVal(NewState, B, MakeConstantVal(1U, B))); + SetBlkExprSVal(NewState, B, MakeConstantVal(1U, B))); isFeasible = false; NewState = Assume(St, X, false, isFeasible); if (isFeasible) MakeNode(Dst, B, Pred, - SetBlkExprRVal(NewState, B, MakeConstantVal(0U, B))); + SetBlkExprSVal(NewState, B, MakeConstantVal(0U, B))); } else { // We took the LHS expression. Depending on whether we are '&&' or @@ -787,7 +787,7 @@ void GRExprEngine::VisitLogicalExpr(BinaryOperator* B, NodeTy* Pred, // the short-circuiting. X = MakeConstantVal( B->getOpcode() == BinaryOperator::LAnd ? 0U : 1U, B); - MakeNode(Dst, B, Pred, SetBlkExprRVal(St, B, X)); + MakeNode(Dst, B, Pred, SetBlkExprSVal(St, B, X)); } } @@ -804,7 +804,7 @@ void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* Ex, NodeTy* Pred, NodeSet& Dst, if (const VarDecl* VD = dyn_cast(D)) { - RVal V = StateMgr.GetLValue(St, VD); + SVal V = StateMgr.GetLValue(St, VD); if (VD->getType()->isArrayType()) { // C++ standard says array of type T should be implicitly converted to @@ -813,12 +813,12 @@ void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* Ex, NodeTy* Pred, NodeSet& Dst, // this in a transfer function in the future. We represent both lvalue and // rvalue of array of type T as the corresponding MemRegionVal of it. - MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, V)); + MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, V)); return; } if (asLValue) - MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, V)); + MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, V)); else EvalLoad(Dst, Ex, Pred, St, V); return; @@ -827,17 +827,17 @@ void GRExprEngine::VisitDeclRefExpr(DeclRefExpr* Ex, NodeTy* Pred, NodeSet& Dst, assert(!asLValue && "EnumConstantDecl does not have lvalue."); BasicValueFactory& BasicVals = StateMgr.getBasicVals(); - RVal V = nonlval::ConcreteInt(BasicVals.getValue(ED->getInitVal())); - MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, V)); + SVal V = nonloc::ConcreteInt(BasicVals.getValue(ED->getInitVal())); + MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, V)); return; } else if (const FunctionDecl* FD = dyn_cast(D)) { - // We return the lval::FuncVal for an FunctionDecl in both rvalue + // We return the loc::FuncVal for an FunctionDecl in both rvalue // and lvalue contexts. // FIXME: Does this need to be revised? We were getting cases in // real code that did this. - RVal V = lval::FuncVal(FD); - MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, V)); + SVal V = loc::FuncVal(FD); + MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, V)); return; } @@ -860,10 +860,10 @@ void GRExprEngine::VisitArraySubscriptExpr(ArraySubscriptExpr* A, NodeTy* Pred, for (NodeSet::iterator I2=Tmp2.begin(), E2=Tmp2.end(); I2!=E2; ++I2) { const GRState* St = GetState(*I2); - RVal V = StateMgr.GetLValue(St, GetRVal(St, Base), GetRVal(St, Idx)); + SVal V = StateMgr.GetLValue(St, GetSVal(St, Base), GetSVal(St, Idx)); if (asLValue) - MakeNode(Dst, A, *I2, SetRVal(St, A, V)); + MakeNode(Dst, A, *I2, SetSVal(St, A, V)); else EvalLoad(Dst, A, *I2, St, V); } @@ -883,17 +883,17 @@ void GRExprEngine::VisitMemberExpr(MemberExpr* M, NodeTy* Pred, // FIXME: Should we insert some assumption logic in here to determine // if "Base" is a valid piece of memory? Before we put this assumption // later when using FieldOffset lvals (which we no longer have). - RVal L = StateMgr.GetLValue(St, M->getMemberDecl(), GetRVal(St, Base)); + SVal L = StateMgr.GetLValue(St, M->getMemberDecl(), GetSVal(St, Base)); if (asLValue) - MakeNode(Dst, M, *I, SetRVal(St, M, L)); + MakeNode(Dst, M, *I, SetSVal(St, M, L)); else EvalLoad(Dst, M, *I, St, L); } } void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, NodeTy* Pred, - const GRState* St, RVal location, RVal Val) { + const GRState* St, SVal location, SVal Val) { assert (Builder && "GRStmtNodeBuilder must be defined."); @@ -925,7 +925,7 @@ void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, NodeTy* Pred, } void GRExprEngine::EvalLoad(NodeSet& Dst, Expr* Ex, NodeTy* Pred, - const GRState* St, RVal location, + const GRState* St, SVal location, bool CheckOnly) { // Evaluate the location (checks for bad dereferences). @@ -948,15 +948,15 @@ void GRExprEngine::EvalLoad(NodeSet& Dst, Expr* Ex, NodeTy* Pred, MakeNode(Dst, Ex, Pred, St, K); else if (location.isUnknown()) { // This is important. We must nuke the old binding. - MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, UnknownVal()), K); + MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, UnknownVal()), K); } else - MakeNode(Dst, Ex, Pred, SetRVal(St, Ex, GetRVal(St, cast(location), + MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, GetSVal(St, cast(location), Ex->getType())), K); } void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, Expr* StoreE, NodeTy* Pred, - const GRState* St, RVal location, RVal Val) { + const GRState* St, SVal location, SVal Val) { NodeSet TmpDst; EvalStore(TmpDst, StoreE, Pred, St, location, Val); @@ -967,7 +967,7 @@ void GRExprEngine::EvalStore(NodeSet& Dst, Expr* Ex, Expr* StoreE, NodeTy* Pred, const GRState* GRExprEngine::EvalLocation(Expr* Ex, NodeTy* Pred, const GRState* St, - RVal location, bool isLoad) { + SVal location, bool isLoad) { // Check for loads/stores from/to undefined values. if (location.isUndef()) { @@ -992,7 +992,7 @@ const GRState* GRExprEngine::EvalLocation(Expr* Ex, NodeTy* Pred, // // We add these assumptions. - LVal LV = cast(location); + Loc LV = cast(location); // "Assume" that the pointer is not NULL. @@ -1008,7 +1008,7 @@ const GRState* GRExprEngine::EvalLocation(Expr* Ex, NodeTy* Pred, if (isFeasibleNull) { // Use the Generic Data Map to mark in the state what lval was null. - const RVal* PersistentLV = getBasicVals().getPersistentRVal(LV); + const SVal* PersistentLV = getBasicVals().getPersistentSVal(LV); StNull = StNull.set(PersistentLV); // We don't use "MakeNode" here because the node will be a sink @@ -1066,14 +1066,14 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred, for (NodeSet::iterator DI = DstTmp.begin(), DE = DstTmp.end(); DI!=DE; ++DI) { const GRState* St = GetState(*DI); - RVal L = GetRVal(St, Callee); + SVal L = GetSVal(St, Callee); // FIXME: Add support for symbolic function calls (calls involving // function pointer values that are symbolic). // Check for undefined control-flow or calls to NULL. - if (L.isUndef() || isa(L)) { + if (L.isUndef() || isa(L)) { NodeTy* N = Builder->generateNode(CE, St, *DI); if (N) { @@ -1088,9 +1088,9 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred, SaveAndRestore OldSink(Builder->BuildSinks); - if (isa(L)) { + if (isa(L)) { - FunctionDecl* FD = cast(L).getDecl(); + FunctionDecl* FD = cast(L).getDecl(); if (FD->getAttr()) Builder->BuildSinks = true; @@ -1113,10 +1113,10 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred, if (!memcmp(s, "panic", 5)) Builder->BuildSinks = true; else if (!memcmp(s, "error", 5)) { if (CE->getNumArgs() > 0) { - RVal X = GetRVal(St, *CE->arg_begin()); + SVal X = GetSVal(St, *CE->arg_begin()); // FIXME: use Assume to inspect the possible symbolic value of // X. Also check the specific signature of error(). - nonlval::ConcreteInt* CI = dyn_cast(&X); + nonloc::ConcreteInt* CI = dyn_cast(&X); if (CI && CI->getValue() != 0) Builder->BuildSinks = true; } @@ -1168,17 +1168,17 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred, // Evaluate the call. - if (isa(L)) { + if (isa(L)) { - IdentifierInfo* Info = cast(L).getDecl()->getIdentifier(); + IdentifierInfo* Info = cast(L).getDecl()->getIdentifier(); if (unsigned id = Info->getBuiltinID()) switch (id) { case Builtin::BI__builtin_expect: { // For __builtin_expect, just return the value of the subexpression. assert (CE->arg_begin() != CE->arg_end()); - RVal X = GetRVal(St, *(CE->arg_begin())); - MakeNode(Dst, CE, *DI, SetRVal(St, CE, X)); + SVal X = GetSVal(St, *(CE->arg_begin())); + MakeNode(Dst, CE, *DI, SetSVal(St, CE, X)); continue; } @@ -1194,7 +1194,7 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred, for (CallExpr::arg_iterator I = CE->arg_begin(), E = CE->arg_end(); I != E; ++I) { - if (GetRVal(GetState(*DI), *I).isUndef()) { + if (GetSVal(GetState(*DI), *I).isUndef()) { NodeTy* N = Builder->generateNode(CE, GetState(*DI), *DI); if (N) { @@ -1239,11 +1239,11 @@ void GRExprEngine::VisitObjCIvarRefExpr(ObjCIvarRefExpr* Ex, for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) { const GRState* St = GetState(*I); - RVal BaseVal = GetRVal(St, Base); - RVal location = StateMgr.GetLValue(St, Ex->getDecl(), BaseVal); + SVal BaseVal = GetSVal(St, Base); + SVal location = StateMgr.GetLValue(St, Ex->getDecl(), BaseVal); if (asLValue) - MakeNode(Dst, Ex, *I, SetRVal(St, Ex, location)); + MakeNode(Dst, Ex, *I, SetSVal(St, Ex, location)); else EvalLoad(Dst, Ex, *I, St, location); } @@ -1303,7 +1303,7 @@ void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME, if (Expr* Receiver = ME->getReceiver()) { - RVal L = GetRVal(St, Receiver); + SVal L = GetSVal(St, Receiver); // Check for undefined control-flow or calls to NULL. @@ -1374,7 +1374,7 @@ void GRExprEngine::VisitObjCMessageExprDispatchHelper(ObjCMessageExpr* ME, for (ObjCMessageExpr::arg_iterator I = ME->arg_begin(), E = ME->arg_end(); I != E; ++I) { - if (GetRVal(St, *I).isUndef()) { + if (GetSVal(St, *I).isUndef()) { // Generate an error node for passing an uninitialized/undefined value // as an argument to a message expression. This node is a sink. @@ -1442,7 +1442,7 @@ void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, NodeTy* Pred, NodeSet& Dst){ for (NodeSet::iterator I1 = S1.begin(), E1 = S1.end(); I1 != E1; ++I1) { NodeTy* N = *I1; const GRState* St = GetState(N); - RVal V = GetRVal(St, Ex); + SVal V = GetSVal(St, Ex); // Unknown? @@ -1454,7 +1454,7 @@ void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, NodeTy* Pred, NodeSet& Dst){ // Undefined? if (V.isUndef()) { - MakeNode(Dst, CastE, N, SetRVal(St, CastE, V)); + MakeNode(Dst, CastE, N, SetSVal(St, CastE, V)); continue; } @@ -1463,35 +1463,35 @@ void GRExprEngine::VisitCast(Expr* CastE, Expr* Ex, NodeTy* Pred, NodeSet& Dst){ if (C.getCanonicalType(T).getUnqualifiedType() == C.getCanonicalType(ExTy).getUnqualifiedType()) { - MakeNode(Dst, CastE, N, SetRVal(St, CastE, V)); + MakeNode(Dst, CastE, N, SetSVal(St, CastE, V)); continue; } // Check for casts from pointers to integers. - if (T->isIntegerType() && LVal::IsLValType(ExTy)) { + if (T->isIntegerType() && Loc::IsLocType(ExTy)) { unsigned bits = getContext().getTypeSize(ExTy); // FIXME: Determine if the number of bits of the target type is // equal or exceeds the number of bits to store the pointer value. // If not, flag an error. - V = nonlval::LValAsInteger::Make(getBasicVals(), cast(V), bits); - MakeNode(Dst, CastE, N, SetRVal(St, CastE, V)); + V = nonloc::LocAsInteger::Make(getBasicVals(), cast(V), bits); + MakeNode(Dst, CastE, N, SetSVal(St, CastE, V)); continue; } // Check for casts from integers to pointers. - if (LVal::IsLValType(T) && ExTy->isIntegerType()) - if (nonlval::LValAsInteger *LV = dyn_cast(&V)) { + if (Loc::IsLocType(T) && ExTy->isIntegerType()) + if (nonloc::LocAsInteger *LV = dyn_cast(&V)) { // Just unpackage the lval and return it. - V = LV->getLVal(); - MakeNode(Dst, CastE, N, SetRVal(St, CastE, V)); + V = LV->getLoc(); + MakeNode(Dst, CastE, N, SetSVal(St, CastE, V)); continue; } // All other cases. - MakeNode(Dst, CastE, N, SetRVal(St, CastE, EvalCast(V, CastE->getType()))); + MakeNode(Dst, CastE, N, SetSVal(St, CastE, EvalCast(V, CastE->getType()))); } } @@ -1559,8 +1559,8 @@ void GRExprEngine::VisitSizeOfAlignOfTypeExpr(SizeOfAlignOfTypeExpr* Ex, amt = getContext().getTypeAlign(T) / 8; MakeNode(Dst, Ex, Pred, - SetRVal(GetState(Pred), Ex, - NonLVal::MakeVal(getBasicVals(), amt, Ex->getType()))); + SetSVal(GetState(Pred), Ex, + NonLoc::MakeVal(getBasicVals(), amt, Ex->getType()))); } @@ -1581,10 +1581,10 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) { const GRState* St = GetState(*I); - RVal location = GetRVal(St, Ex); + SVal location = GetSVal(St, Ex); if (asLValue) - MakeNode(Dst, U, *I, SetRVal(St, U, location)); + MakeNode(Dst, U, *I, SetSVal(St, U, location)); else EvalLoad(Dst, U, *I, St, location); } @@ -1600,7 +1600,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) { - // FIXME: We don't have complex RValues yet. + // FIXME: We don't have complex SValues yet. if (Ex->getType()->isAnyComplexType()) { // Just report "Unknown." Dst.Add(*I); @@ -1610,7 +1610,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, // For all other types, UnaryOperator::Real is an identity operation. assert (U->getType() == Ex->getType()); const GRState* St = GetState(*I); - MakeNode(Dst, U, *I, SetRVal(St, U, GetRVal(St, Ex))); + MakeNode(Dst, U, *I, SetSVal(St, U, GetSVal(St, Ex))); } return; @@ -1623,7 +1623,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, Visit(Ex, Pred, Tmp); for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) { - // FIXME: We don't have complex RValues yet. + // FIXME: We don't have complex SValues yet. if (Ex->getType()->isAnyComplexType()) { // Just report "Unknown." Dst.Add(*I); @@ -1633,8 +1633,8 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, // For all other types, UnaryOperator::Float returns 0. assert (Ex->getType()->isIntegerType()); const GRState* St = GetState(*I); - RVal X = NonLVal::MakeVal(getBasicVals(), 0, Ex->getType()); - MakeNode(Dst, U, *I, SetRVal(St, U, X)); + SVal X = NonLoc::MakeVal(getBasicVals(), 0, Ex->getType()); + MakeNode(Dst, U, *I, SetSVal(St, U, X)); } return; @@ -1659,7 +1659,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) { const GRState* St = GetState(*I); - MakeNode(Dst, U, *I, SetRVal(St, U, GetRVal(St, Ex))); + MakeNode(Dst, U, *I, SetSVal(St, U, GetSVal(St, Ex))); } return; @@ -1674,8 +1674,8 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) { const GRState* St = GetState(*I); - RVal V = GetRVal(St, Ex); - St = SetRVal(St, U, V); + SVal V = GetSVal(St, Ex); + St = SetSVal(St, U, V); MakeNode(Dst, U, *I, St); } @@ -1695,7 +1695,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, const GRState* St = GetState(*I); // Get the value of the subexpression. - RVal V = GetRVal(St, Ex); + SVal V = GetSVal(St, Ex); // Perform promotions. // FIXME: This is the right thing to do, but it currently breaks @@ -1703,7 +1703,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, // V = EvalCast(V, U->getType()); if (V.isUnknownOrUndef()) { - MakeNode(Dst, U, *I, SetRVal(St, U, V)); + MakeNode(Dst, U, *I, SetSVal(St, U, V)); continue; } @@ -1714,12 +1714,12 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, case UnaryOperator::Not: // FIXME: Do we need to handle promotions? - St = SetRVal(St, U, EvalComplement(cast(V))); + St = SetSVal(St, U, EvalComplement(cast(V))); break; case UnaryOperator::Minus: // FIXME: Do we need to handle promotions? - St = SetRVal(St, U, EvalMinus(U, cast(V))); + St = SetSVal(St, U, EvalMinus(U, cast(V))); break; case UnaryOperator::LNot: @@ -1729,18 +1729,18 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, // Note: technically we do "E == 0", but this is the same in the // transfer functions as "0 == E". - if (isa(V)) { - lval::ConcreteInt X(getBasicVals().getZeroWithPtrWidth()); - RVal Result = EvalBinOp(BinaryOperator::EQ, cast(V), X); - St = SetRVal(St, U, Result); + if (isa(V)) { + loc::ConcreteInt X(getBasicVals().getZeroWithPtrWidth()); + SVal Result = EvalBinOp(BinaryOperator::EQ, cast(V), X); + St = SetSVal(St, U, Result); } else { - nonlval::ConcreteInt X(getBasicVals().getValue(0, Ex->getType())); + nonloc::ConcreteInt X(getBasicVals().getValue(0, Ex->getType())); #if 0 - RVal Result = EvalBinOp(BinaryOperator::EQ, cast(V), X); - St = SetRVal(St, U, Result); + SVal Result = EvalBinOp(BinaryOperator::EQ, cast(V), X); + St = SetSVal(St, U, Result); #else - EvalBinOp(Dst, U, BinaryOperator::EQ, cast(V), X, *I); + EvalBinOp(Dst, U, BinaryOperator::EQ, cast(V), X, *I); continue; #endif } @@ -1765,7 +1765,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, uint64_t size = getContext().getTypeSize(T) / 8; const GRState* St = GetState(Pred); - St = SetRVal(St, U, NonLVal::MakeVal(getBasicVals(), size, U->getType())); + St = SetSVal(St, U, NonLoc::MakeVal(getBasicVals(), size, U->getType())); MakeNode(Dst, U, Pred, St); return; @@ -1782,7 +1782,7 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, for (NodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I!=E; ++I) { const GRState* St = GetState(*I); - RVal V1 = GetRVal(St, Ex); + SVal V1 = GetSVal(St, Ex); // Perform a load. NodeSet Tmp2; @@ -1791,11 +1791,11 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, for (NodeSet::iterator I2 = Tmp2.begin(), E2 = Tmp2.end(); I2!=E2; ++I2) { St = GetState(*I2); - RVal V2 = GetRVal(St, Ex); + SVal V2 = GetSVal(St, Ex); // Propagate unknown and undefined values. if (V2.isUnknownOrUndef()) { - MakeNode(Dst, U, *I2, SetRVal(St, U, V2)); + MakeNode(Dst, U, *I2, SetSVal(St, U, V2)); continue; } @@ -1804,8 +1804,8 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred, BinaryOperator::Opcode Op = U->isIncrementOp() ? BinaryOperator::Add : BinaryOperator::Sub; - RVal Result = EvalBinOp(Op, V2, MakeConstantVal(1U, U)); - St = SetRVal(St, U, U->isPostfix() ? V2 : Result); + SVal Result = EvalBinOp(Op, V2, MakeConstantVal(1U, U)); + St = SetSVal(St, U, U->isPostfix() ? V2 : Result); // Perform the store. EvalStore(Dst, U, *I2, St, V1, Result); @@ -1842,7 +1842,7 @@ void GRExprEngine::VisitAsmStmtHelperInputs(AsmStmt* A, if (I == E) { // We have processed both the inputs and the outputs. All of the outputs - // should evaluate to LVals. Nuke all of their values. + // should evaluate to Locs. Nuke all of their values. // FIXME: Some day in the future it would be nice to allow a "plug-in" // which interprets the inline asm and stores proper results in the @@ -1853,11 +1853,11 @@ void GRExprEngine::VisitAsmStmtHelperInputs(AsmStmt* A, for (AsmStmt::outputs_iterator OI = A->begin_outputs(), OE = A->end_outputs(); OI != OE; ++OI) { - RVal X = GetRVal(St, *OI); - assert (!isa(X)); // Should be an Lval, or unknown, undef. + SVal X = GetSVal(St, *OI); + assert (!isa(X)); // Should be an Lval, or unknown, undef. - if (isa(X)) - St = SetRVal(St, cast(X), UnknownVal()); + if (isa(X)) + St = SetSVal(St, cast(X), UnknownVal()); } MakeNode(Dst, A, Pred, St); @@ -1909,12 +1909,12 @@ void GRExprEngine::VisitReturnStmt(ReturnStmt* S, NodeTy* Pred, NodeSet& Dst) { Visit(R, Pred, Tmp); for (NodeSet::iterator I=Tmp.begin(), E=Tmp.end(); I!=E; ++I) { - RVal X = GetRVal((*I)->getState(), R); + SVal X = GetSVal((*I)->getState(), R); - if (isa(X)) { + if (isa(X)) { // Determine if the value is on the stack. - const MemRegion* R = cast(&X)->getRegion(); + const MemRegion* R = cast(&X)->getRegion(); if (R && getStateManager().hasStackStorage(R)) { @@ -1946,7 +1946,7 @@ void GRExprEngine::VisitReturnStmt(ReturnStmt* S, NodeTy* Pred, NodeSet& Dst) { //===----------------------------------------------------------------------===// bool GRExprEngine::CheckDivideZero(Expr* Ex, const GRState* St, - NodeTy* Pred, RVal Denom) { + NodeTy* Pred, SVal Denom) { // Divide by undefined? (potentially zero) @@ -2003,7 +2003,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B, for (NodeSet::iterator I1=Tmp1.begin(), E1=Tmp1.end(); I1 != E1; ++I1) { - RVal LeftV = GetRVal((*I1)->getState(), LHS); + SVal LeftV = GetSVal((*I1)->getState(), LHS); // Process the RHS. @@ -2015,7 +2015,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B, for (NodeSet::iterator I2=Tmp2.begin(), E2=Tmp2.end(); I2 != E2; ++I2) { const GRState* St = GetState(*I2); - RVal RightV = GetRVal(St, RHS); + SVal RightV = GetSVal(St, RHS); BinaryOperator::Opcode Op = B->getOpcode(); switch (Op) { @@ -2028,15 +2028,15 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B, unsigned Count = Builder->getCurrentBlockCount(); SymbolID Sym = SymMgr.getConjuredSymbol(B->getRHS(), Count); - RightV = LVal::IsLValType(B->getRHS()->getType()) - ? cast(lval::SymbolVal(Sym)) - : cast(nonlval::SymbolVal(Sym)); + RightV = Loc::IsLocType(B->getRHS()->getType()) + ? cast(loc::SymbolVal(Sym)) + : cast(nonloc::SymbolVal(Sym)); } // Simulate the effects of a "store": bind the value of the RHS // to the L-Value represented by the LHS. - EvalStore(Dst, B, LHS, *I2, SetRVal(St, B, RightV), LeftV, RightV); + EvalStore(Dst, B, LHS, *I2, SetSVal(St, B, RightV), LeftV, RightV); continue; } @@ -2059,7 +2059,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B, // Process non-assignements except commas or short-circuited // logical expressions (LAnd and LOr). - RVal Result = EvalBinOp(Op, LeftV, RightV); + SVal Result = EvalBinOp(Op, LeftV, RightV); if (Result.isUnknown()) { Dst.Add(*I2); @@ -2081,7 +2081,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B, // Otherwise, create a new node. - MakeNode(Dst, B, *I2, SetRVal(St, B, Result)); + MakeNode(Dst, B, *I2, SetSVal(St, B, Result)); continue; } } @@ -2096,23 +2096,23 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B, // Perform a load (the LHS). This performs the checks for // null dereferences, and so on. NodeSet Tmp3; - RVal location = GetRVal(St, LHS); + SVal location = GetSVal(St, LHS); EvalLoad(Tmp3, LHS, *I2, St, location); for (NodeSet::iterator I3=Tmp3.begin(), E3=Tmp3.end(); I3!=E3; ++I3) { St = GetState(*I3); - RVal V = GetRVal(St, LHS); + SVal V = GetSVal(St, LHS); // Propagate undefined values (left-side). if (V.isUndef()) { - EvalStore(Dst, B, LHS, *I3, SetRVal(St, B, V), location, V); + EvalStore(Dst, B, LHS, *I3, SetSVal(St, B, V), location, V); continue; } // Propagate unknown values (left and right-side). if (RightV.isUnknown() || V.isUnknown()) { - EvalStore(Dst, B, LHS, *I3, SetRVal(St, B, UnknownVal()), location, + EvalStore(Dst, B, LHS, *I3, SetSVal(St, B, UnknownVal()), location, UnknownVal()); continue; } @@ -2139,13 +2139,13 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B, } else if (RightV.isUndef()) { // Propagate undefined values (right-side). - EvalStore(Dst, B, LHS, *I3, SetRVal(St, B, RightV), location, RightV); + EvalStore(Dst, B, LHS, *I3, SetSVal(St, B, RightV), location, RightV); continue; } // Compute the result of the operation. - RVal Result = EvalCast(EvalBinOp(Op, V, RightV), B->getType()); + SVal Result = EvalCast(EvalBinOp(Op, V, RightV), B->getType()); if (Result.isUndef()) { @@ -2159,7 +2159,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B, continue; } - EvalStore(Dst, B, LHS, *I3, SetRVal(St, B, Result), location, Result); + EvalStore(Dst, B, LHS, *I3, SetSVal(St, B, Result), location, Result); } } } @@ -2171,7 +2171,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B, void GRExprEngine::EvalBinOp(ExplodedNodeSet& Dst, Expr* Ex, BinaryOperator::Opcode Op, - NonLVal L, NonLVal R, + NonLoc L, NonLoc R, ExplodedNode* Pred) { GRStateSet OStates; @@ -2183,7 +2183,7 @@ void GRExprEngine::EvalBinOp(ExplodedNodeSet& Dst, Expr* Ex, void GRExprEngine::EvalBinOp(GRStateSet& OStates, const GRState* St, Expr* Ex, BinaryOperator::Opcode Op, - NonLVal L, NonLVal R) { + NonLoc L, NonLoc R) { GRStateSet::AutoPopulate AP(OStates, St); if (R.isValid()) getTF().EvalBinOpNN(OStates, StateMgr, St, Ex, Op, L, R); @@ -2263,7 +2263,7 @@ struct VISIBILITY_HIDDEN DOTGraphTraits : else if (GraphPrintCheckerState->isUndefDeref(N)) Out << "\\|Dereference of undefialied value.\\l"; else if (GraphPrintCheckerState->isUndefStore(N)) - Out << "\\|Store to Undefined LVal."; + Out << "\\|Store to Undefined Loc."; else if (GraphPrintCheckerState->isExplicitBadDivide(N)) Out << "\\|Explicit divide-by zero or undefined value."; else if (GraphPrintCheckerState->isImplicitBadDivide(N)) diff --git a/clang/lib/Analysis/GRExprEngineInternalChecks.cpp b/clang/lib/Analysis/GRExprEngineInternalChecks.cpp index d61998c5a410..c313697b9eab 100644 --- a/clang/lib/Analysis/GRExprEngineInternalChecks.cpp +++ b/clang/lib/Analysis/GRExprEngineInternalChecks.cpp @@ -194,8 +194,8 @@ public: assert (E && "Return expression cannot be NULL"); // Get the value associated with E. - lval::MemRegionVal V = - cast(Eng.getStateManager().GetRVal(N->getState(), + loc::MemRegionVal V = + cast(Eng.getStateManager().GetSVal(N->getState(), E)); // Generate a report for this bug. @@ -235,7 +235,7 @@ class VISIBILITY_HIDDEN UndefBranch : public BuiltinBug { return Ex; } - bool MatchesCriteria(Expr* Ex) { return VM.GetRVal(St, Ex).isUndef(); } + bool MatchesCriteria(Expr* Ex) { return VM.GetSVal(St, Ex).isUndef(); } }; public: @@ -303,12 +303,12 @@ public: CallExpr* CE = cast(cast(N->getLocation()).getStmt()); const GRState* state = N->getState(); - RVal X = VMgr.GetRVal(state, CE->getCallee()); + SVal X = VMgr.GetSVal(state, CE->getCallee()); - if (!isa(X)) + if (!isa(X)) return false; - FunctionDecl* FD = dyn_cast(cast(X).getDecl()); + FunctionDecl* FD = dyn_cast(cast(X).getDecl()); const NonNullAttr* Att = FD->getAttr(); if (!Att) diff --git a/clang/lib/Analysis/GRSimpleVals.cpp b/clang/lib/Analysis/GRSimpleVals.cpp index 07ec3e8bffce..2b1d9b59fa66 100644 --- a/clang/lib/Analysis/GRSimpleVals.cpp +++ b/clang/lib/Analysis/GRSimpleVals.cpp @@ -36,32 +36,32 @@ GRTransferFuncs* clang::MakeGRSimpleValsTF() { return new GRSimpleVals(); } // Transfer function for Casts. //===----------------------------------------------------------------------===// -RVal GRSimpleVals::EvalCast(GRExprEngine& Eng, NonLVal X, QualType T) { +SVal GRSimpleVals::EvalCast(GRExprEngine& Eng, NonLoc X, QualType T) { - if (!isa(X)) + if (!isa(X)) return UnknownVal(); - bool isLValType = LVal::IsLValType(T); + bool isLocType = Loc::IsLocType(T); // Only handle casts from integers to integers. - if (!isLValType && !T->isIntegerType()) + if (!isLocType && !T->isIntegerType()) return UnknownVal(); BasicValueFactory& BasicVals = Eng.getBasicVals(); - llvm::APSInt V = cast(X).getValue(); - V.setIsUnsigned(T->isUnsignedIntegerType() || LVal::IsLValType(T)); + llvm::APSInt V = cast(X).getValue(); + V.setIsUnsigned(T->isUnsignedIntegerType() || Loc::IsLocType(T)); V.extOrTrunc(Eng.getContext().getTypeSize(T)); - if (isLValType) - return lval::ConcreteInt(BasicVals.getValue(V)); + if (isLocType) + return loc::ConcreteInt(BasicVals.getValue(V)); else - return nonlval::ConcreteInt(BasicVals.getValue(V)); + return nonloc::ConcreteInt(BasicVals.getValue(V)); } // Casts. -RVal GRSimpleVals::EvalCast(GRExprEngine& Eng, LVal X, QualType T) { +SVal GRSimpleVals::EvalCast(GRExprEngine& Eng, Loc X, QualType T) { // Casts from pointers -> pointers, just return the lval. // @@ -69,43 +69,43 @@ RVal GRSimpleVals::EvalCast(GRExprEngine& Eng, LVal X, QualType T) { // can be introduced by the frontend for corner cases, e.g // casting from va_list* to __builtin_va_list&. // - if (LVal::IsLValType(T) || T->isReferenceType()) + if (Loc::IsLocType(T) || T->isReferenceType()) return X; assert (T->isIntegerType()); - if (!isa(X)) + if (!isa(X)) return UnknownVal(); BasicValueFactory& BasicVals = Eng.getBasicVals(); - llvm::APSInt V = cast(X).getValue(); - V.setIsUnsigned(T->isUnsignedIntegerType() || LVal::IsLValType(T)); + llvm::APSInt V = cast(X).getValue(); + V.setIsUnsigned(T->isUnsignedIntegerType() || Loc::IsLocType(T)); V.extOrTrunc(Eng.getContext().getTypeSize(T)); - return nonlval::ConcreteInt(BasicVals.getValue(V)); + return nonloc::ConcreteInt(BasicVals.getValue(V)); } // Unary operators. -RVal GRSimpleVals::EvalMinus(GRExprEngine& Eng, UnaryOperator* U, NonLVal X){ +SVal GRSimpleVals::EvalMinus(GRExprEngine& Eng, UnaryOperator* U, NonLoc X){ switch (X.getSubKind()) { - case nonlval::ConcreteIntKind: - return cast(X).EvalMinus(Eng.getBasicVals(), U); + case nonloc::ConcreteIntKind: + return cast(X).EvalMinus(Eng.getBasicVals(), U); default: return UnknownVal(); } } -RVal GRSimpleVals::EvalComplement(GRExprEngine& Eng, NonLVal X) { +SVal GRSimpleVals::EvalComplement(GRExprEngine& Eng, NonLoc X) { switch (X.getSubKind()) { - case nonlval::ConcreteIntKind: - return cast(X).EvalComplement(Eng.getBasicVals()); + case nonloc::ConcreteIntKind: + return cast(X).EvalComplement(Eng.getBasicVals()); default: return UnknownVal(); @@ -123,9 +123,9 @@ static unsigned char LNotOpMap[] = { (unsigned char) BinaryOperator::EQ /* NE => EQ */ }; -RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr, +SVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr, BinaryOperator::Opcode Op, - NonLVal L, NonLVal R) { + NonLoc L, NonLoc R) { BasicValueFactory& BasicVals = StateMgr.getBasicVals(); unsigned subkind = L.getSubKind(); @@ -136,14 +136,14 @@ RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr, default: return UnknownVal(); - case nonlval::SymIntConstraintValKind: { + case nonloc::SymIntConstraintValKind: { // Logical not? if (!(Op == BinaryOperator::EQ && R.isZeroConstant())) return UnknownVal(); const SymIntConstraint& C = - cast(L).getConstraint(); + cast(L).getConstraint(); BinaryOperator::Opcode Opc = C.getOpcode(); @@ -163,19 +163,19 @@ RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr, const SymIntConstraint& CNew = BasicVals.getConstraint(C.getSymbol(), Opc, C.getInt()); - return nonlval::SymIntConstraintVal(CNew); + return nonloc::SymIntConstraintVal(CNew); } - case nonlval::ConcreteIntKind: + case nonloc::ConcreteIntKind: - if (isa(R)) { - const nonlval::ConcreteInt& L_CI = cast(L); - const nonlval::ConcreteInt& R_CI = cast(R); + if (isa(R)) { + const nonloc::ConcreteInt& L_CI = cast(L); + const nonloc::ConcreteInt& R_CI = cast(R); return L_CI.EvalBinOp(BasicVals, Op, R_CI); } else { subkind = R.getSubKind(); - NonLVal tmp = R; + NonLoc tmp = R; R = L; L = tmp; @@ -191,13 +191,13 @@ RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr, continue; } - case nonlval::SymbolValKind: - if (isa(R)) { + case nonloc::SymbolValKind: + if (isa(R)) { const SymIntConstraint& C = - BasicVals.getConstraint(cast(L).getSymbol(), Op, - cast(R).getValue()); + BasicVals.getConstraint(cast(L).getSymbol(), Op, + cast(R).getValue()); - return nonlval::SymIntConstraintVal(C); + return nonloc::SymIntConstraintVal(C); } else return UnknownVal(); @@ -208,8 +208,8 @@ RVal GRSimpleVals::DetermEvalBinOpNN(GRStateManager& StateMgr, // Binary Operators (except assignments and comma). -RVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op, - LVal L, LVal R) { +SVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op, + Loc L, Loc R) { switch (Op) { @@ -226,52 +226,52 @@ RVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op, // Pointer arithmetic. -RVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op, - LVal L, NonLVal R) { +SVal GRSimpleVals::EvalBinOp(GRExprEngine& Eng, BinaryOperator::Opcode Op, + Loc L, NonLoc R) { return UnknownVal(); } -// Equality operators for LVals. +// Equality operators for Locs. -RVal GRSimpleVals::EvalEQ(GRExprEngine& Eng, LVal L, LVal R) { +SVal GRSimpleVals::EvalEQ(GRExprEngine& Eng, Loc L, Loc R) { BasicValueFactory& BasicVals = Eng.getBasicVals(); switch (L.getSubKind()) { default: - assert(false && "EQ not implemented for this LVal."); + assert(false && "EQ not implemented for this Loc."); return UnknownVal(); - case lval::ConcreteIntKind: + case loc::ConcreteIntKind: - if (isa(R)) { - bool b = cast(L).getValue() == - cast(R).getValue(); + if (isa(R)) { + bool b = cast(L).getValue() == + cast(R).getValue(); - return NonLVal::MakeIntTruthVal(BasicVals, b); + return NonLoc::MakeIntTruthVal(BasicVals, b); } - else if (isa(R)) { + else if (isa(R)) { const SymIntConstraint& C = - BasicVals.getConstraint(cast(R).getSymbol(), + BasicVals.getConstraint(cast(R).getSymbol(), BinaryOperator::EQ, - cast(L).getValue()); + cast(L).getValue()); - return nonlval::SymIntConstraintVal(C); + return nonloc::SymIntConstraintVal(C); } break; - case lval::SymbolValKind: { + case loc::SymbolValKind: { - if (isa(R)) { + if (isa(R)) { const SymIntConstraint& C = - BasicVals.getConstraint(cast(L).getSymbol(), + BasicVals.getConstraint(cast(L).getSymbol(), BinaryOperator::EQ, - cast(R).getValue()); + cast(R).getValue()); - return nonlval::SymIntConstraintVal(C); + return nonloc::SymIntConstraintVal(C); } // FIXME: Implement == for lval Symbols. This is mainly useful @@ -282,53 +282,53 @@ RVal GRSimpleVals::EvalEQ(GRExprEngine& Eng, LVal L, LVal R) { return UnknownVal(); } - case lval::MemRegionKind: - case lval::FuncValKind: - case lval::GotoLabelKind: - case lval::StringLiteralValKind: - return NonLVal::MakeIntTruthVal(BasicVals, L == R); + case loc::MemRegionKind: + case loc::FuncValKind: + case loc::GotoLabelKind: + case loc::StringLiteralValKind: + return NonLoc::MakeIntTruthVal(BasicVals, L == R); } - return NonLVal::MakeIntTruthVal(BasicVals, false); + return NonLoc::MakeIntTruthVal(BasicVals, false); } -RVal GRSimpleVals::EvalNE(GRExprEngine& Eng, LVal L, LVal R) { +SVal GRSimpleVals::EvalNE(GRExprEngine& Eng, Loc L, Loc R) { BasicValueFactory& BasicVals = Eng.getBasicVals(); switch (L.getSubKind()) { default: - assert(false && "NE not implemented for this LVal."); + assert(false && "NE not implemented for this Loc."); return UnknownVal(); - case lval::ConcreteIntKind: + case loc::ConcreteIntKind: - if (isa(R)) { - bool b = cast(L).getValue() != - cast(R).getValue(); + if (isa(R)) { + bool b = cast(L).getValue() != + cast(R).getValue(); - return NonLVal::MakeIntTruthVal(BasicVals, b); + return NonLoc::MakeIntTruthVal(BasicVals, b); } - else if (isa(R)) { + else if (isa(R)) { const SymIntConstraint& C = - BasicVals.getConstraint(cast(R).getSymbol(), + BasicVals.getConstraint(cast(R).getSymbol(), BinaryOperator::NE, - cast(L).getValue()); + cast(L).getValue()); - return nonlval::SymIntConstraintVal(C); + return nonloc::SymIntConstraintVal(C); } break; - case lval::SymbolValKind: { - if (isa(R)) { + case loc::SymbolValKind: { + if (isa(R)) { const SymIntConstraint& C = - BasicVals.getConstraint(cast(L).getSymbol(), + BasicVals.getConstraint(cast(L).getSymbol(), BinaryOperator::NE, - cast(R).getValue()); + cast(R).getValue()); - return nonlval::SymIntConstraintVal(C); + return nonloc::SymIntConstraintVal(C); } // FIXME: Implement != for lval Symbols. This is mainly useful @@ -341,14 +341,14 @@ RVal GRSimpleVals::EvalNE(GRExprEngine& Eng, LVal L, LVal R) { break; } - case lval::MemRegionKind: - case lval::FuncValKind: - case lval::GotoLabelKind: - case lval::StringLiteralValKind: - return NonLVal::MakeIntTruthVal(BasicVals, L != R); + case loc::MemRegionKind: + case loc::FuncValKind: + case loc::GotoLabelKind: + case loc::StringLiteralValKind: + return NonLoc::MakeIntTruthVal(BasicVals, L != R); } - return NonLVal::MakeIntTruthVal(BasicVals, true); + return NonLoc::MakeIntTruthVal(BasicVals, true); } //===----------------------------------------------------------------------===// @@ -358,23 +358,23 @@ RVal GRSimpleVals::EvalNE(GRExprEngine& Eng, LVal L, LVal R) { void GRSimpleVals::EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Eng, GRStmtNodeBuilder& Builder, - CallExpr* CE, RVal L, + CallExpr* CE, SVal L, ExplodedNode* Pred) { GRStateManager& StateMgr = Eng.getStateManager(); const GRState* St = Builder.GetState(Pred); - // Invalidate all arguments passed in by reference (LVals). + // Invalidate all arguments passed in by reference (Locs). for (CallExpr::arg_iterator I = CE->arg_begin(), E = CE->arg_end(); I != E; ++I) { - RVal V = StateMgr.GetRVal(St, *I); + SVal V = StateMgr.GetSVal(St, *I); - if (isa(V)) - St = StateMgr.SetRVal(St, cast(V), UnknownVal()); - else if (isa(V)) - St = StateMgr.SetRVal(St, cast(V).getLVal(), + if (isa(V)) + St = StateMgr.SetSVal(St, cast(V), UnknownVal()); + else if (isa(V)) + St = StateMgr.SetSVal(St, cast(V).getLoc(), UnknownVal()); } @@ -385,11 +385,11 @@ void GRSimpleVals::EvalCall(ExplodedNodeSet& Dst, unsigned Count = Builder.getCurrentBlockCount(); SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(CE, Count); - RVal X = LVal::IsLValType(CE->getType()) - ? cast(lval::SymbolVal(Sym)) - : cast(nonlval::SymbolVal(Sym)); + SVal X = Loc::IsLocType(CE->getType()) + ? cast(loc::SymbolVal(Sym)) + : cast(nonloc::SymbolVal(Sym)); - St = StateMgr.SetRVal(St, CE, X, Eng.getCFG().isBlkExpr(CE), false); + St = StateMgr.SetSVal(St, CE, X, Eng.getCFG().isBlkExpr(CE), false); } Builder.MakeNode(Dst, CE, Pred, St); @@ -415,10 +415,10 @@ void GRSimpleVals::EvalObjCMessageExpr(ExplodedNodeSet& Dst, for (ObjCMessageExpr::arg_iterator I = ME->arg_begin(), E = ME->arg_end(); I != E; ++I) { - RVal V = StateMgr.GetRVal(St, *I); + SVal V = StateMgr.GetSVal(St, *I); - if (isa(V)) - St = StateMgr.SetRVal(St, cast(V), UnknownVal()); + if (isa(V)) + St = StateMgr.SetSVal(St, cast(V), UnknownVal()); } Builder.MakeNode(Dst, ME, Pred, St); diff --git a/clang/lib/Analysis/GRSimpleVals.h b/clang/lib/Analysis/GRSimpleVals.h index 720ccc1f2039..ee32e8a99d0d 100644 --- a/clang/lib/Analysis/GRSimpleVals.h +++ b/clang/lib/Analysis/GRSimpleVals.h @@ -27,9 +27,9 @@ class ASTContext; class GRSimpleVals : public GRTransferFuncs { protected: - virtual RVal DetermEvalBinOpNN(GRStateManager& StateMgr, + virtual SVal DetermEvalBinOpNN(GRStateManager& StateMgr, BinaryOperator::Opcode Op, - NonLVal L, NonLVal R); + NonLoc L, NonLoc R); public: GRSimpleVals() {} @@ -37,31 +37,31 @@ public: // Casts. - virtual RVal EvalCast(GRExprEngine& Engine, NonLVal V, QualType CastT); - virtual RVal EvalCast(GRExprEngine& Engine, LVal V, QualType CastT); + virtual SVal EvalCast(GRExprEngine& Engine, NonLoc V, QualType CastT); + virtual SVal EvalCast(GRExprEngine& Engine, Loc V, QualType CastT); // Unary Operators. - virtual RVal EvalMinus(GRExprEngine& Engine, UnaryOperator* U, NonLVal X); + virtual SVal EvalMinus(GRExprEngine& Engine, UnaryOperator* U, NonLoc X); - virtual RVal EvalComplement(GRExprEngine& Engine, NonLVal X); + virtual SVal EvalComplement(GRExprEngine& Engine, NonLoc X); // Binary Operators. - virtual RVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op, - LVal L, LVal R); + virtual SVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op, + Loc L, Loc R); // Pointer arithmetic. - virtual RVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op, - LVal L, NonLVal R); + virtual SVal EvalBinOp(GRExprEngine& Engine, BinaryOperator::Opcode Op, + Loc L, NonLoc R); // Calls. virtual void EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Engine, GRStmtNodeBuilder& Builder, - CallExpr* CE, RVal L, + CallExpr* CE, SVal L, ExplodedNode* Pred); virtual void EvalObjCMessageExpr(ExplodedNodeSet& Dst, @@ -77,10 +77,10 @@ public: protected: - // Equality operators for LVals. + // Equality operators for Locs. - RVal EvalEQ(GRExprEngine& Engine, LVal L, LVal R); - RVal EvalNE(GRExprEngine& Engine, LVal L, LVal R); + SVal EvalEQ(GRExprEngine& Engine, Loc L, Loc R); + SVal EvalNE(GRExprEngine& Engine, Loc L, Loc R); }; } // end clang namespace diff --git a/clang/lib/Analysis/GRState.cpp b/clang/lib/Analysis/GRState.cpp index 49bc24aa7de9..09275e28a78f 100644 --- a/clang/lib/Analysis/GRState.cpp +++ b/clang/lib/Analysis/GRState.cpp @@ -59,11 +59,11 @@ GRStateManager::RemoveDeadBindings(const GRState* St, Stmt* Loc, LSymbols, DSymbols); } -const GRState* GRStateManager::SetRVal(const GRState* St, LVal LV, - RVal V) { +const GRState* GRStateManager::SetSVal(const GRState* St, Loc LV, + SVal V) { Store OldStore = St->getStore(); - Store NewStore = StoreMgr->SetRVal(OldStore, LV, V); + Store NewStore = StoreMgr->SetSVal(OldStore, LV, V); if (NewStore == OldStore) return St; @@ -80,7 +80,7 @@ const GRState* GRStateManager::AddDecl(const GRState* St, const VarDecl* VD, if (Ex) NewStore = StoreMgr->AddDecl(OldStore, VD, Ex, - GetRVal(St, Ex), Count); + GetSVal(St, Ex), Count); else NewStore = StoreMgr->AddDecl(OldStore, VD, Ex); @@ -92,7 +92,7 @@ const GRState* GRStateManager::AddDecl(const GRState* St, const VarDecl* VD, return getPersistentState(NewSt); } -const GRState* GRStateManager::Unbind(const GRState* St, LVal LV) { +const GRState* GRStateManager::Unbind(const GRState* St, Loc LV) { Store OldStore = St->getStore(); Store NewStore = StoreMgr->Remove(OldStore, LV); @@ -240,18 +240,18 @@ const GRState* GRStateManager::addGDM(const GRState* St, void* Key, void* Data){ bool GRStateManager::isEqual(const GRState* state, Expr* Ex, const llvm::APSInt& Y) { - RVal V = GetRVal(state, Ex); + SVal V = GetSVal(state, Ex); - if (lval::ConcreteInt* X = dyn_cast(&V)) + if (loc::ConcreteInt* X = dyn_cast(&V)) return X->getValue() == Y; - if (nonlval::ConcreteInt* X = dyn_cast(&V)) + if (nonloc::ConcreteInt* X = dyn_cast(&V)) return X->getValue() == Y; - if (nonlval::SymbolVal* X = dyn_cast(&V)) + if (nonloc::SymbolVal* X = dyn_cast(&V)) return ConstraintMgr->isEqual(state, X->getSymbol(), Y); - if (lval::SymbolVal* X = dyn_cast(&V)) + if (loc::SymbolVal* X = dyn_cast(&V)) return ConstraintMgr->isEqual(state, X->getSymbol(), Y); return false; diff --git a/clang/lib/Analysis/GRTransferFuncs.cpp b/clang/lib/Analysis/GRTransferFuncs.cpp index 03292d1c49b3..4b8e42ed9d1c 100644 --- a/clang/lib/Analysis/GRTransferFuncs.cpp +++ b/clang/lib/Analysis/GRTransferFuncs.cpp @@ -23,7 +23,7 @@ void GRTransferFuncs::EvalStore(ExplodedNodeSet& Dst, GRExprEngine& Eng, GRStmtNodeBuilder& Builder, Expr* E, ExplodedNode* Pred, - const GRState* St, RVal TargetLV, RVal Val) { + const GRState* St, SVal TargetLV, SVal Val) { // This code basically matches the "safety-net" logic of GRExprEngine: // bind Val to TargetLV, and create a new node. We replicate it here @@ -35,14 +35,14 @@ void GRTransferFuncs::EvalStore(ExplodedNodeSet& Dst, Builder.MakeNode(Dst, E, Pred, St); else Builder.MakeNode(Dst, E, Pred, - Eng.getStateManager().SetRVal(St, cast(TargetLV), Val)); + Eng.getStateManager().SetSVal(St, cast(TargetLV), Val)); } void GRTransferFuncs::EvalBinOpNN(GRStateSet& OStates, GRStateManager& StateMgr, const GRState *St, Expr* Ex, BinaryOperator::Opcode Op, - NonLVal L, NonLVal R) { + NonLoc L, NonLoc R) { - OStates.Add(StateMgr.SetRVal(St, Ex, DetermEvalBinOpNN(StateMgr, Op, L, R))); + OStates.Add(StateMgr.SetSVal(St, Ex, DetermEvalBinOpNN(StateMgr, Op, L, R))); } diff --git a/clang/lib/Analysis/RValues.cpp b/clang/lib/Analysis/RValues.cpp index 551945ce26ed..db1a8403fb82 100644 --- a/clang/lib/Analysis/RValues.cpp +++ b/clang/lib/Analysis/RValues.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file defines RVal, LVal, and NonLVal, classes that represent +// This file defines SVal, Loc, and NonLoc, classes that represent // abstract r-values for use with path-sensitive value tracking. // //===----------------------------------------------------------------------===// @@ -25,23 +25,23 @@ using llvm::APSInt; // Symbol Iteration. //===----------------------------------------------------------------------===// -RVal::symbol_iterator RVal::symbol_begin() const { +SVal::symbol_iterator SVal::symbol_begin() const { // FIXME: This is a rat's nest. Cleanup. - if (isa(this)) + if (isa(this)) return (symbol_iterator) (&Data); - else if (isa(this)) + else if (isa(this)) return (symbol_iterator) (&Data); - else if (isa(this)) { + else if (isa(this)) { const SymIntConstraint& C = - cast(this)->getConstraint(); + cast(this)->getConstraint(); return (symbol_iterator) &C.getSymbol(); } - else if (isa(this)) { - const nonlval::LValAsInteger& V = cast(*this); - return V.getPersistentLVal().symbol_begin(); + else if (isa(this)) { + const nonloc::LocAsInteger& V = cast(*this); + return V.getPersistentLoc().symbol_begin(); } // FIXME: We need to iterate over the symbols of regions. @@ -49,7 +49,7 @@ RVal::symbol_iterator RVal::symbol_begin() const { return NULL; } -RVal::symbol_iterator RVal::symbol_end() const { +SVal::symbol_iterator SVal::symbol_end() const { symbol_iterator X = symbol_begin(); return X ? X+1 : NULL; } @@ -58,56 +58,56 @@ RVal::symbol_iterator RVal::symbol_end() const { // Useful predicates. //===----------------------------------------------------------------------===// -bool RVal::isZeroConstant() const { - if (isa(*this)) - return cast(*this).getValue() == 0; - else if (isa(*this)) - return cast(*this).getValue() == 0; +bool SVal::isZeroConstant() const { + if (isa(*this)) + return cast(*this).getValue() == 0; + else if (isa(*this)) + return cast(*this).getValue() == 0; else return false; } //===----------------------------------------------------------------------===// -// Transfer function dispatch for Non-LVals. +// Transfer function dispatch for Non-Locs. //===----------------------------------------------------------------------===// -RVal nonlval::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals, +SVal nonloc::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op, - const nonlval::ConcreteInt& R) const { + const nonloc::ConcreteInt& R) const { const llvm::APSInt* X = BasicVals.EvaluateAPSInt(Op, getValue(), R.getValue()); if (X) - return nonlval::ConcreteInt(*X); + return nonloc::ConcreteInt(*X); else return UndefinedVal(); } // Bitwise-Complement. -nonlval::ConcreteInt -nonlval::ConcreteInt::EvalComplement(BasicValueFactory& BasicVals) const { +nonloc::ConcreteInt +nonloc::ConcreteInt::EvalComplement(BasicValueFactory& BasicVals) const { return BasicVals.getValue(~getValue()); } // Unary Minus. -nonlval::ConcreteInt -nonlval::ConcreteInt::EvalMinus(BasicValueFactory& BasicVals, UnaryOperator* U) const { +nonloc::ConcreteInt +nonloc::ConcreteInt::EvalMinus(BasicValueFactory& BasicVals, UnaryOperator* U) const { assert (U->getType() == U->getSubExpr()->getType()); assert (U->getType()->isIntegerType()); return BasicVals.getValue(-getValue()); } //===----------------------------------------------------------------------===// -// Transfer function dispatch for LVals. +// Transfer function dispatch for Locs. //===----------------------------------------------------------------------===// -RVal -lval::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op, - const lval::ConcreteInt& R) const { +SVal +loc::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcode Op, + const loc::ConcreteInt& R) const { assert (Op == BinaryOperator::Add || Op == BinaryOperator::Sub || (Op >= BinaryOperator::LT && Op <= BinaryOperator::NE)); @@ -115,180 +115,180 @@ lval::ConcreteInt::EvalBinOp(BasicValueFactory& BasicVals, BinaryOperator::Opcod const llvm::APSInt* X = BasicVals.EvaluateAPSInt(Op, getValue(), R.getValue()); if (X) - return lval::ConcreteInt(*X); + return loc::ConcreteInt(*X); else return UndefinedVal(); } -NonLVal LVal::EQ(BasicValueFactory& BasicVals, const LVal& R) const { +NonLoc Loc::EQ(BasicValueFactory& BasicVals, const Loc& R) const { switch (getSubKind()) { default: - assert(false && "EQ not implemented for this LVal."); + assert(false && "EQ not implemented for this Loc."); break; - case lval::ConcreteIntKind: - if (isa(R)) { - bool b = cast(this)->getValue() == - cast(R).getValue(); + case loc::ConcreteIntKind: + if (isa(R)) { + bool b = cast(this)->getValue() == + cast(R).getValue(); - return NonLVal::MakeIntTruthVal(BasicVals, b); + return NonLoc::MakeIntTruthVal(BasicVals, b); } - else if (isa(R)) { + else if (isa(R)) { const SymIntConstraint& C = - BasicVals.getConstraint(cast(R).getSymbol(), + BasicVals.getConstraint(cast(R).getSymbol(), BinaryOperator::EQ, - cast(this)->getValue()); + cast(this)->getValue()); - return nonlval::SymIntConstraintVal(C); + return nonloc::SymIntConstraintVal(C); } break; - case lval::SymbolValKind: { - if (isa(R)) { + case loc::SymbolValKind: { + if (isa(R)) { const SymIntConstraint& C = - BasicVals.getConstraint(cast(this)->getSymbol(), + BasicVals.getConstraint(cast(this)->getSymbol(), BinaryOperator::EQ, - cast(R).getValue()); + cast(R).getValue()); - return nonlval::SymIntConstraintVal(C); + return nonloc::SymIntConstraintVal(C); } - assert (!isa(R) && "FIXME: Implement unification."); + assert (!isa(R) && "FIXME: Implement unification."); break; } - case lval::MemRegionKind: - if (isa(R)) { - bool b = cast(*this) == cast(R); - return NonLVal::MakeIntTruthVal(BasicVals, b); + case loc::MemRegionKind: + if (isa(R)) { + bool b = cast(*this) == cast(R); + return NonLoc::MakeIntTruthVal(BasicVals, b); } break; } - return NonLVal::MakeIntTruthVal(BasicVals, false); + return NonLoc::MakeIntTruthVal(BasicVals, false); } -NonLVal LVal::NE(BasicValueFactory& BasicVals, const LVal& R) const { +NonLoc Loc::NE(BasicValueFactory& BasicVals, const Loc& R) const { switch (getSubKind()) { default: - assert(false && "NE not implemented for this LVal."); + assert(false && "NE not implemented for this Loc."); break; - case lval::ConcreteIntKind: - if (isa(R)) { - bool b = cast(this)->getValue() != - cast(R).getValue(); + case loc::ConcreteIntKind: + if (isa(R)) { + bool b = cast(this)->getValue() != + cast(R).getValue(); - return NonLVal::MakeIntTruthVal(BasicVals, b); + return NonLoc::MakeIntTruthVal(BasicVals, b); } - else if (isa(R)) { + else if (isa(R)) { const SymIntConstraint& C = - BasicVals.getConstraint(cast(R).getSymbol(), + BasicVals.getConstraint(cast(R).getSymbol(), BinaryOperator::NE, - cast(this)->getValue()); + cast(this)->getValue()); - return nonlval::SymIntConstraintVal(C); + return nonloc::SymIntConstraintVal(C); } break; - case lval::SymbolValKind: { - if (isa(R)) { + case loc::SymbolValKind: { + if (isa(R)) { const SymIntConstraint& C = - BasicVals.getConstraint(cast(this)->getSymbol(), + BasicVals.getConstraint(cast(this)->getSymbol(), BinaryOperator::NE, - cast(R).getValue()); + cast(R).getValue()); - return nonlval::SymIntConstraintVal(C); + return nonloc::SymIntConstraintVal(C); } - assert (!isa(R) && "FIXME: Implement sym !=."); + assert (!isa(R) && "FIXME: Implement sym !=."); break; } - case lval::MemRegionKind: - if (isa(R)) { - bool b = cast(*this)==cast(R); - return NonLVal::MakeIntTruthVal(BasicVals, b); + case loc::MemRegionKind: + if (isa(R)) { + bool b = cast(*this)==cast(R); + return NonLoc::MakeIntTruthVal(BasicVals, b); } break; } - return NonLVal::MakeIntTruthVal(BasicVals, true); + return NonLoc::MakeIntTruthVal(BasicVals, true); } //===----------------------------------------------------------------------===// -// Utility methods for constructing Non-LVals. +// Utility methods for constructing Non-Locs. //===----------------------------------------------------------------------===// -NonLVal NonLVal::MakeVal(BasicValueFactory& BasicVals, uint64_t X, QualType T) { - return nonlval::ConcreteInt(BasicVals.getValue(X, T)); +NonLoc NonLoc::MakeVal(BasicValueFactory& BasicVals, uint64_t X, QualType T) { + return nonloc::ConcreteInt(BasicVals.getValue(X, T)); } -NonLVal NonLVal::MakeVal(BasicValueFactory& BasicVals, IntegerLiteral* I) { +NonLoc NonLoc::MakeVal(BasicValueFactory& BasicVals, IntegerLiteral* I) { - return nonlval::ConcreteInt(BasicVals.getValue(APSInt(I->getValue(), + return nonloc::ConcreteInt(BasicVals.getValue(APSInt(I->getValue(), I->getType()->isUnsignedIntegerType()))); } -NonLVal NonLVal::MakeIntTruthVal(BasicValueFactory& BasicVals, bool b) { - return nonlval::ConcreteInt(BasicVals.getTruthValue(b)); +NonLoc NonLoc::MakeIntTruthVal(BasicValueFactory& BasicVals, bool b) { + return nonloc::ConcreteInt(BasicVals.getTruthValue(b)); } -RVal RVal::GetSymbolValue(SymbolManager& SymMgr, VarDecl* D) { +SVal SVal::GetSymbolValue(SymbolManager& SymMgr, VarDecl* D) { QualType T = D->getType(); - if (LVal::IsLValType(T)) - return lval::SymbolVal(SymMgr.getSymbol(D)); + if (Loc::IsLocType(T)) + return loc::SymbolVal(SymMgr.getSymbol(D)); - return nonlval::SymbolVal(SymMgr.getSymbol(D)); + return nonloc::SymbolVal(SymMgr.getSymbol(D)); } //===----------------------------------------------------------------------===// -// Utility methods for constructing LVals. +// Utility methods for constructing Locs. //===----------------------------------------------------------------------===// -LVal LVal::MakeVal(AddrLabelExpr* E) { return lval::GotoLabel(E->getLabel()); } +Loc Loc::MakeVal(AddrLabelExpr* E) { return loc::GotoLabel(E->getLabel()); } -LVal LVal::MakeVal(StringLiteral* S) { - return lval::StringLiteralVal(S); +Loc Loc::MakeVal(StringLiteral* S) { + return loc::StringLiteralVal(S); } //===----------------------------------------------------------------------===// // Pretty-Printing. //===----------------------------------------------------------------------===// -void RVal::printStdErr() const { print(*llvm::cerr.stream()); } +void SVal::printStdErr() const { print(*llvm::cerr.stream()); } -void RVal::print(std::ostream& Out) const { +void SVal::print(std::ostream& Out) const { switch (getBaseKind()) { case UnknownKind: Out << "Invalid"; break; - case NonLValKind: - cast(this)->print(Out); break; + case NonLocKind: + cast(this)->print(Out); break; - case LValKind: - cast(this)->print(Out); break; + case LocKind: + cast(this)->print(Out); break; case UndefinedKind: Out << "Undefined"; break; default: - assert (false && "Invalid RVal."); + assert (false && "Invalid SVal."); } } @@ -316,25 +316,25 @@ static void printOpcode(std::ostream& Out, BinaryOperator::Opcode Op) { } } -void NonLVal::print(std::ostream& Out) const { +void NonLoc::print(std::ostream& Out) const { switch (getSubKind()) { - case nonlval::ConcreteIntKind: - Out << cast(this)->getValue().getZExtValue(); + case nonloc::ConcreteIntKind: + Out << cast(this)->getValue().getZExtValue(); - if (cast(this)->getValue().isUnsigned()) + if (cast(this)->getValue().isUnsigned()) Out << 'U'; break; - case nonlval::SymbolValKind: - Out << '$' << cast(this)->getSymbol(); + case nonloc::SymbolValKind: + Out << '$' << cast(this)->getSymbol(); break; - case nonlval::SymIntConstraintValKind: { - const nonlval::SymIntConstraintVal& C = - *cast(this); + case nonloc::SymIntConstraintValKind: { + const nonloc::SymIntConstraintVal& C = + *cast(this); Out << '$' << C.getConstraint().getSymbol() << ' '; printOpcode(Out, C.getConstraint().getOpcode()); @@ -346,54 +346,54 @@ void NonLVal::print(std::ostream& Out) const { break; } - case nonlval::LValAsIntegerKind: { - const nonlval::LValAsInteger& C = *cast(this); - C.getLVal().print(Out); + case nonloc::LocAsIntegerKind: { + const nonloc::LocAsInteger& C = *cast(this); + C.getLoc().print(Out); Out << " [as " << C.getNumBits() << " bit integer]"; break; } default: - assert (false && "Pretty-printed not implemented for this NonLVal."); + assert (false && "Pretty-printed not implemented for this NonLoc."); break; } } -void LVal::print(std::ostream& Out) const { +void Loc::print(std::ostream& Out) const { switch (getSubKind()) { - case lval::ConcreteIntKind: - Out << cast(this)->getValue().getZExtValue() - << " (LVal)"; + case loc::ConcreteIntKind: + Out << cast(this)->getValue().getZExtValue() + << " (Loc)"; break; - case lval::SymbolValKind: - Out << '$' << cast(this)->getSymbol(); + case loc::SymbolValKind: + Out << '$' << cast(this)->getSymbol(); break; - case lval::GotoLabelKind: + case loc::GotoLabelKind: Out << "&&" - << cast(this)->getLabel()->getID()->getName(); + << cast(this)->getLabel()->getID()->getName(); break; - case lval::MemRegionKind: - Out << '&' << cast(this)->getRegion()->getString(); + case loc::MemRegionKind: + Out << '&' << cast(this)->getRegion()->getString(); break; - case lval::FuncValKind: + case loc::FuncValKind: Out << "function " - << cast(this)->getDecl()->getIdentifier()->getName(); + << cast(this)->getDecl()->getIdentifier()->getName(); break; - case lval::StringLiteralValKind: + case loc::StringLiteralValKind: Out << "literal \"" - << cast(this)->getLiteral()->getStrData() + << cast(this)->getLiteral()->getStrData() << "\""; break; default: - assert (false && "Pretty-printing not implemented for this LVal."); + assert (false && "Pretty-printing not implemented for this Loc."); break; } } diff --git a/clang/lib/Analysis/RegionStore.cpp b/clang/lib/Analysis/RegionStore.cpp index 7004c5558e42..6757f43ae106 100644 --- a/clang/lib/Analysis/RegionStore.cpp +++ b/clang/lib/Analysis/RegionStore.cpp @@ -23,7 +23,7 @@ using namespace clang; -typedef llvm::ImmutableMap RegionBindingsTy; +typedef llvm::ImmutableMap RegionBindingsTy; namespace { @@ -38,7 +38,7 @@ public: virtual ~RegionStoreManager() {} - Store SetRVal(Store St, LVal LV, RVal V); + Store SetSVal(Store St, Loc LV, SVal V); Store getInitialStore(); @@ -49,10 +49,10 @@ public: } // end anonymous namespace -Store RegionStoreManager::SetRVal(Store store, LVal LV, RVal V) { - assert(LV.getSubKind() == lval::MemRegionKind); +Store RegionStoreManager::SetSVal(Store store, Loc LV, SVal V) { + assert(LV.getSubKind() == loc::MemRegionKind); - MemRegion* R = cast(LV).getRegion(); + MemRegion* R = cast(LV).getRegion(); if (!R) return store; @@ -79,16 +79,16 @@ Store RegionStoreManager::getInitialStore() { QualType T = VD->getType(); // Only handle pointers and integers for now. - if (LVal::IsLValType(T) || T->isIntegerType()) { + if (Loc::IsLocType(T) || T->isIntegerType()) { MemRegion* R = MRMgr.getVarRegion(VD); // Initialize globals and parameters to symbolic values. // Initialize local variables to undefined. - RVal X = (VD->hasGlobalStorage() || isa(VD) || + SVal X = (VD->hasGlobalStorage() || isa(VD) || isa(VD)) - ? RVal::GetSymbolValue(StateMgr.getSymbolManager(), VD) + ? SVal::GetSymbolValue(StateMgr.getSymbolManager(), VD) : UndefinedVal(); - St = SetRVal(St, lval::MemRegionVal(R), X); + St = SetSVal(St, loc::MemRegionVal(R), X); } } }