[cfe-commits] r57671 - in /cfe/trunk: include/clang/Analysis/PathSensitive/ lib/Analysis/

Zhongxing Xu xuzhongxing at gmail.com
Thu Oct 16 22:57:07 PDT 2008


Author: zhongxingxu
Date: Fri Oct 17 00:57:07 2008
New Revision: 57671

URL: http://llvm.org/viewvc/llvm-project?rev=57671&view=rev
Log:
This patch did the following renaming. There should be no functional changes.
RVal => SVal
LVal => Loc
NonLVal => NonLoc
lval => loc
nonlval => nonloc

Modified:
    cfe/trunk/include/clang/Analysis/PathSensitive/BasicValueFactory.h
    cfe/trunk/include/clang/Analysis/PathSensitive/ConstraintManager.h
    cfe/trunk/include/clang/Analysis/PathSensitive/Environment.h
    cfe/trunk/include/clang/Analysis/PathSensitive/GRExprEngine.h
    cfe/trunk/include/clang/Analysis/PathSensitive/GRState.h
    cfe/trunk/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
    cfe/trunk/include/clang/Analysis/PathSensitive/RValues.h
    cfe/trunk/include/clang/Analysis/PathSensitive/Store.h
    cfe/trunk/include/clang/Analysis/PathSensitive/SymbolManager.h
    cfe/trunk/lib/Analysis/BasicConstraintManager.cpp
    cfe/trunk/lib/Analysis/BasicObjCFoundationChecks.cpp
    cfe/trunk/lib/Analysis/BasicStore.cpp
    cfe/trunk/lib/Analysis/BasicValueFactory.cpp
    cfe/trunk/lib/Analysis/BugReporter.cpp
    cfe/trunk/lib/Analysis/CFRefCount.cpp
    cfe/trunk/lib/Analysis/CheckNSError.cpp
    cfe/trunk/lib/Analysis/Environment.cpp
    cfe/trunk/lib/Analysis/GRExprEngine.cpp
    cfe/trunk/lib/Analysis/GRExprEngineInternalChecks.cpp
    cfe/trunk/lib/Analysis/GRSimpleVals.cpp
    cfe/trunk/lib/Analysis/GRSimpleVals.h
    cfe/trunk/lib/Analysis/GRState.cpp
    cfe/trunk/lib/Analysis/GRTransferFuncs.cpp
    cfe/trunk/lib/Analysis/RValues.cpp
    cfe/trunk/lib/Analysis/RegionStore.cpp

Modified: cfe/trunk/include/clang/Analysis/PathSensitive/BasicValueFactory.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/PathSensitive/BasicValueFactory.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/include/clang/Analysis/PathSensitive/BasicValueFactory.h (original)
+++ cfe/trunk/include/clang/Analysis/PathSensitive/BasicValueFactory.h Fri Oct 17 00:57:07 2008
@@ -27,7 +27,7 @@
 
 namespace clang {
   
-class RVal;
+class SVal;
   
 class BasicValueFactory {
   typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<llvm::APSInt> >
@@ -42,12 +42,12 @@
 
   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 @@
                                      const llvm::APSInt& V1,
                                      const llvm::APSInt& V2);
   
-  const std::pair<RVal, uintptr_t>&
-  getPersistentRValWithData(const RVal& V, uintptr_t Data);
+  const std::pair<SVal, uintptr_t>&
+  getPersistentSValWithData(const SVal& V, uintptr_t Data);
   
-  const std::pair<RVal, RVal>&
-  getPersistentRValPair(const RVal& V1, const RVal& V2);  
+  const std::pair<SVal, SVal>&
+  getPersistentSValPair(const SVal& V1, const SVal& V2);  
   
-  const RVal* getPersistentRVal(RVal X);
+  const SVal* getPersistentSVal(SVal X);
 };
 
 } // end clang namespace

Modified: cfe/trunk/include/clang/Analysis/PathSensitive/ConstraintManager.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/PathSensitive/ConstraintManager.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/include/clang/Analysis/PathSensitive/ConstraintManager.h (original)
+++ cfe/trunk/include/clang/Analysis/PathSensitive/ConstraintManager.h Fri Oct 17 00:57:07 2008
@@ -25,14 +25,14 @@
 
 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;

Modified: cfe/trunk/include/clang/Analysis/PathSensitive/Environment.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/PathSensitive/Environment.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/include/clang/Analysis/PathSensitive/Environment.h (original)
+++ cfe/trunk/include/clang/Analysis/PathSensitive/Environment.h Fri Oct 17 00:57:07 2008
@@ -36,7 +36,7 @@
   friend class EnvironmentManager;
   
   // Type definitions.
-  typedef llvm::ImmutableMap<Expr*,RVal> BindingsTy;
+  typedef llvm::ImmutableMap<Expr*,SVal> BindingsTy;
 
   // Data.
   BindingsTy SubExprBindings;
@@ -55,28 +55,28 @@
   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<Expr*>(Ex), BasicVals);
+  SVal GetSVal(Expr* Ex, BasicValueFactory& BasicVals) const;
+  SVal GetSVal(const Expr* Ex, BasicValueFactory& BasicVals) const {
+    return GetSVal(const_cast<Expr*>(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 @@
     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 @@
     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,

Modified: cfe/trunk/include/clang/Analysis/PathSensitive/GRExprEngine.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/PathSensitive/GRExprEngine.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/include/clang/Analysis/PathSensitive/GRExprEngine.h (original)
+++ cfe/trunk/include/clang/Analysis/PathSensitive/GRExprEngine.h Fri Oct 17 00:57:07 2008
@@ -252,11 +252,11 @@
   }
   
   bool isImplicitBadDivide(const NodeTy* N) const {
-    return N->isSink() && ImplicitBadDivides.count(const_cast<NodeTy*>(N)) != 0; 
+    return N->isSink() && ImplicitBadDivides.count(const_cast<NodeTy*>(N)) != 0;
   }
   
   bool isExplicitBadDivide(const NodeTy* N) const {
-    return N->isSink() && ExplicitBadDivides.count(const_cast<NodeTy*>(N)) != 0; 
+    return N->isSink() && ExplicitBadDivides.count(const_cast<NodeTy*>(N)) != 0;
   }
   
   bool isNoReturnCall(const NodeTy* N) const {
@@ -402,52 +402,52 @@
   
 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<Expr*>(Ex), V);
+  const GRState* SetSVal(const GRState* St, const Expr* Ex, SVal V) {
+    return SetSVal(St, const_cast<Expr*>(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<Expr*>(Ex));
+  SVal GetSVal(const GRState* St, const Expr* Ex) {
+    return GetSVal(St, const_cast<Expr*>(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 @@
                           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<LVal>(X))
-      return getTF().EvalCast(*this, cast<LVal>(X), CastT);
+    if (isa<Loc>(X))
+      return getTF().EvalCast(*this, cast<Loc>(X), CastT);
     else
-      return getTF().EvalCast(*this, cast<NonLVal>(X), CastT);
+      return getTF().EvalCast(*this, cast<NonLoc>(X), CastT);
   }
   
-  RVal EvalMinus(UnaryOperator* U, RVal X) {
-    return X.isValid() ? getTF().EvalMinus(*this, U, cast<NonLVal>(X)) : X;
+  SVal EvalMinus(UnaryOperator* U, SVal X) {
+    return X.isValid() ? getTF().EvalMinus(*this, U, cast<NonLoc>(X)) : X;
   }
   
-  RVal EvalComplement(RVal X) {
-    return X.isValid() ? getTF().EvalComplement(*this, cast<NonLVal>(X)) : X;
+  SVal EvalComplement(SVal X) {
+    return X.isValid() ? getTF().EvalComplement(*this, cast<NonLoc>(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<NonLVal>(R)) : R;
+                                                   cast<NonLoc>(R)) : R;
   }
   
   void EvalBinOp(ExplodedNodeSet<GRState>& Dst, Expr* Ex,
-                 BinaryOperator::Opcode Op, NonLVal L, NonLVal R,
+                 BinaryOperator::Opcode Op, NonLoc L, NonLoc R,
                  ExplodedNode<GRState>* 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 @@
     if (L.isUnknown() || R.isUnknown())
       return UnknownVal();
 
-    if (isa<LVal>(L)) {
-      if (isa<LVal>(R))
-        return getTF().EvalBinOp(*this, Op, cast<LVal>(L), cast<LVal>(R));
+    if (isa<Loc>(L)) {
+      if (isa<Loc>(R))
+        return getTF().EvalBinOp(*this, Op, cast<Loc>(L), cast<Loc>(R));
       else
-        return getTF().EvalBinOp(*this, Op, cast<LVal>(L), cast<NonLVal>(R));
+        return getTF().EvalBinOp(*this, Op, cast<Loc>(L), cast<NonLoc>(R));
     }
 
-    if (isa<LVal>(R)) {
+    if (isa<Loc>(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<LVal>(R),
-                               cast<NonLVal>(L));
+      return getTF().EvalBinOp(*this, Op, cast<Loc>(R),
+                               cast<NonLoc>(L));
     }
     else
-      return getTF().DetermEvalBinOpNN(getStateManager(), Op, cast<NonLVal>(L),
-                                       cast<NonLVal>(R));
+      return getTF().DetermEvalBinOpNN(getStateManager(), Op, cast<NonLoc>(L),
+                                       cast<NonLoc>(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 @@
   }
   
   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

Modified: cfe/trunk/include/clang/Analysis/PathSensitive/GRState.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/PathSensitive/GRState.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/include/clang/Analysis/PathSensitive/GRState.h (original)
+++ cfe/trunk/include/clang/Analysis/PathSensitive/GRState.h Fri Oct 17 00:57:07 2008
@@ -61,7 +61,7 @@
 };
 
 //===----------------------------------------------------------------------===//
-// 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 @@
     Profile(ID, this);
   }
   
-  RVal LookupExpr(Expr* E) const {
+  SVal LookupExpr(Expr* E) const {
     return Env.LookupExpr(E);
   }
   
@@ -174,7 +174,7 @@
   // 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 @@
   ///  a particular function.  This is used to unique states.
   llvm::FoldingSet<GRState> 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 @@
   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 @@
   }
   
   // 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 @@
   }
   
   // 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 @@
     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 @@
         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 @@
   }
     
   
-  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 @@
     return GRStateTrait<T>::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 @@
   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 @@
   }
   
   // Lvalue methods.
-  RVal GetLValue(const VarDecl* VD) {
+  SVal GetLValue(const VarDecl* VD) {
     return Mgr->GetLValue(St, VD);
   }
   

Modified: cfe/trunk/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/PathSensitive/GRTransferFuncs.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/include/clang/Analysis/PathSensitive/GRTransferFuncs.h (original)
+++ cfe/trunk/include/clang/Analysis/PathSensitive/GRTransferFuncs.h Fri Oct 17 00:57:07 2008
@@ -32,9 +32,9 @@
 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 @@
   
   // 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<GRState>& Dst,
                         GRExprEngine& Engine,
                         GRStmtNodeBuilder<GRState>& Builder,
-                        CallExpr* CE, RVal L,
+                        CallExpr* CE, SVal L,
                         ExplodedNode<GRState>* Pred) {}
   
   virtual void EvalObjCMessageExpr(ExplodedNodeSet<GRState>& Dst,
@@ -88,12 +88,12 @@
   
   /// 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<GRState>& Dst,
                          GRExprEngine& Engine,
                          GRStmtNodeBuilder<GRState>& Builder,
                          Expr* E, ExplodedNode<GRState>* 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 @@
   
   virtual const GRState* EvalAssume(GRStateManager& VMgr,
                                        const GRState* St,
-                                       RVal Cond, bool Assumption,
+                                       SVal Cond, bool Assumption,
                                        bool& isFeasible) {
     return St;
   }

Modified: cfe/trunk/include/clang/Analysis/PathSensitive/RValues.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/PathSensitive/RValues.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/include/clang/Analysis/PathSensitive/RValues.h (original)
+++ cfe/trunk/include/clang/Analysis/PathSensitive/RValues.h Fri Oct 17 00:57:07 2008
@@ -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 @@
   unsigned Kind;
   
 protected:
-  RVal(const void* d, bool isLVal, unsigned ValKind)
+  SVal(const void* d, bool isLoc, unsigned ValKind)
   : Data(const_cast<void*>(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<RVal,5> BufferTy;
+  /// BufferTy - A temporary buffer to hold a set of SVals.
+  typedef llvm::SmallVector<SVal,5> BufferTy;
   
   inline unsigned getRawKind() const { return Kind; }
   inline BaseKind getBaseKind() const { return (BaseKind) (Kind & BaseMask); }
@@ -59,16 +59,16 @@
     ID.AddPointer(reinterpret_cast<void*>(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 @@
   symbol_iterator symbol_end() const;  
   
   // Implement isa<T> 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<T> 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<void*>(D), true, SubKind) {}
+  Loc(unsigned SubKind, const void* D)
+    : SVal(const_cast<void*>(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<T> 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<void*>((uintptr_t) SymID)) {}
+    : NonLoc(SymbolValKind, reinterpret_cast<void*>((uintptr_t) SymID)) {}
   
   SymbolID getSymbol() const {
     return (SymbolID) reinterpret_cast<uintptr_t>(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<const void*>(&C)) {}
+    : NonLoc(SymIntConstraintValKind, reinterpret_cast<const void*>(&C)) {}
 
   const SymIntConstraint& getConstraint() const {
     return *reinterpret_cast<SymIntConstraint*>(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<llvm::APSInt*>(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 @@
   ConcreteInt EvalMinus(BasicValueFactory& BasicVals, UnaryOperator* U) const;
   
   // Implement isa<T> 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<RVal, uintptr_t>& data) :
-    NonLVal(LValAsIntegerKind, &data) {
-      assert (isa<LVal>(data.first));
+class LocAsInteger : public NonLoc {
+  LocAsInteger(const std::pair<SVal, uintptr_t>& data) :
+    NonLoc(LocAsIntegerKind, &data) {
+      assert (isa<Loc>(data.first));
     }
   
 public:
     
-  LVal getLVal() const {
-    return cast<LVal>(((std::pair<RVal, uintptr_t>*) Data)->first);
+  Loc getLoc() const {
+    return cast<Loc>(((std::pair<SVal, uintptr_t>*) Data)->first);
   }
   
-  const LVal& getPersistentLVal() const {
-    const RVal& V = ((std::pair<RVal, uintptr_t>*) Data)->first;
-    return cast<LVal>(V);
+  const Loc& getPersistentLoc() const {
+    const SVal& V = ((std::pair<SVal, uintptr_t>*) Data)->first;
+    return cast<Loc>(V);
   }    
   
   unsigned getNumBits() const {
-    return ((std::pair<RVal, unsigned>*) Data)->second;
+    return ((std::pair<SVal, unsigned>*) Data)->second;
   }
   
   // Implement isa<T> 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<void*>((uintptr_t) SymID)) {}
+  : Loc(SymbolValKind, reinterpret_cast<void*>((uintptr_t) SymID)) {}
   
   SymbolID getSymbol() const {
     return (SymbolID) reinterpret_cast<uintptr_t>(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<LabelStmt*>(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<MemRegion*>(Data);
@@ -344,19 +344,19 @@
   }
   
   // Implement isa<T> 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<FunctionDecl*>(Data);
@@ -371,57 +371,57 @@
   }
   
   // Implement isa<T> 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<llvm::APSInt*>(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<T> 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<T> 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

Modified: cfe/trunk/include/clang/Analysis/PathSensitive/Store.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/PathSensitive/Store.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/include/clang/Analysis/PathSensitive/Store.h (original)
+++ cfe/trunk/include/clang/Analysis/PathSensitive/Store.h Fri Oct 17 00:57:07 2008
@@ -40,21 +40,22 @@
   typedef llvm::DenseSet<SymbolID>          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 @@
 
   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:    
     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.

Modified: cfe/trunk/include/clang/Analysis/PathSensitive/SymbolManager.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/PathSensitive/SymbolManager.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/include/clang/Analysis/PathSensitive/SymbolManager.h (original)
+++ cfe/trunk/include/clang/Analysis/PathSensitive/SymbolManager.h Fri Oct 17 00:57:07 2008
@@ -198,7 +198,7 @@
   }  
 };
 
-// Constraints on symbols.  Usually wrapped by RValues.
+// Constraints on symbols.  Usually wrapped by SValues.
 
 class SymIntConstraint : public llvm::FoldingSetNode {
   SymbolID Symbol;

Modified: cfe/trunk/lib/Analysis/BasicConstraintManager.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/BasicConstraintManager.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/BasicConstraintManager.cpp (original)
+++ cfe/trunk/lib/Analysis/BasicConstraintManager.cpp Fri Oct 17 00:57:07 2008
@@ -33,19 +33,19 @@
 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 @@
   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<NonLVal>(Cond))
-    return Assume(St, cast<NonLVal>(Cond), Assumption, isFeasible);
+  if (isa<NonLoc>(Cond))
+    return Assume(St, cast<NonLoc>(Cond), Assumption, isFeasible);
   else
-    return Assume(St, cast<LVal>(Cond), Assumption, isFeasible);
+    return Assume(St, cast<Loc>(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<lval::SymbolVal>(Cond).getSymbol(),
+      return AssumeSymNE(St, cast<loc::SymbolVal>(Cond).getSymbol(),
                          BasicVals.getZeroWithPtrWidth(), isFeasible);
     else
-      return AssumeSymEQ(St, cast<lval::SymbolVal>(Cond).getSymbol(),
+      return AssumeSymEQ(St, cast<loc::SymbolVal>(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<lval::ConcreteInt>(Cond).getValue() != 0;
+  case loc::ConcreteIntKind: {
+    bool b = cast<loc::ConcreteInt>(Cond).getValue() != 0;
     isFeasible = b ? Assumption : !Assumption;
     return St;
   }
@@ -145,7 +145,7 @@
 }
 
 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 @@
 }
 
 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<nonlval::SymbolVal>(Cond);
+  case nonloc::SymbolValKind: {
+    nonloc::SymbolVal& SV = cast<nonloc::SymbolVal>(Cond);
     SymbolID sym = SV.getSymbol();
 
     if (Assumption)
@@ -174,20 +174,20 @@
                          isFeasible);
   }
 
-  case nonlval::SymIntConstraintValKind:
+  case nonloc::SymIntConstraintValKind:
     return
       AssumeSymInt(St, Assumption,
-                   cast<nonlval::SymIntConstraintVal>(Cond).getConstraint(),
+                   cast<nonloc::SymIntConstraintVal>(Cond).getConstraint(),
                    isFeasible);
 
-  case nonlval::ConcreteIntKind: {
-    bool b = cast<nonlval::ConcreteInt>(Cond).getValue() != 0;
+  case nonloc::ConcreteIntKind: {
+    bool b = cast<nonloc::ConcreteInt>(Cond).getValue() != 0;
     isFeasible = b ? Assumption : !Assumption;
     return St;
   }
 
-  case nonlval::LValAsIntegerKind:
-    return AssumeAux(St, cast<nonlval::LValAsInteger>(Cond).getLVal(),
+  case nonloc::LocAsIntegerKind:
+    return AssumeAux(St, cast<nonloc::LocAsInteger>(Cond).getLoc(),
                      Assumption, isFeasible);
   } // end switch
 }

Modified: cfe/trunk/lib/Analysis/BasicObjCFoundationChecks.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/BasicObjCFoundationChecks.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/BasicObjCFoundationChecks.cpp (original)
+++ cfe/trunk/lib/Analysis/BasicObjCFoundationChecks.cpp Fri Oct 17 00:57:07 2008
@@ -118,7 +118,7 @@
   typedef std::vector<BugReport*> 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 @@
   return false;
 }
 
-static inline bool isNil(RVal X) {
-  return isa<lval::ConcreteInt>(X);  
+static inline bool isNil(SVal X) {
+  return isa<loc::ConcreteInt>(X);  
 }
 
 //===----------------------------------------------------------------------===//
@@ -214,7 +214,7 @@
   
   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 @@
   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 @@
 bool AuditCFNumberCreate::Audit(ExplodedNode<GRState>* N,GRStateManager&){  
   CallExpr* CE = cast<CallExpr>(cast<PostStmt>(N->getLocation()).getStmt());
   Expr* Callee = CE->getCallee();  
-  RVal CallV = GetRVal(N->getState(), Callee);  
-  lval::FuncVal* FuncV = dyn_cast<lval::FuncVal>(&CallV);
+  SVal CallV = GetSVal(N->getState(), Callee);  
+  loc::FuncVal* FuncV = dyn_cast<loc::FuncVal>(&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<nonlval::ConcreteInt>(&TheTypeVal);
+  nonloc::ConcreteInt* V = dyn_cast<nonloc::ConcreteInt>(&TheTypeVal);
   
   if (!V)
     return false;
@@ -494,11 +494,11 @@
   // 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<lval::MemRegionVal>(&TheValueExpr);
+  loc::MemRegionVal* LV = dyn_cast<loc::MemRegionVal>(&TheValueExpr);
 
   if (!LV)
     return false;

Modified: cfe/trunk/lib/Analysis/BasicStore.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/BasicStore.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/BasicStore.cpp (original)
+++ cfe/trunk/lib/Analysis/BasicStore.cpp Fri Oct 17 00:57:07 2008
@@ -19,7 +19,7 @@
 
 using namespace clang;
 
-typedef llvm::ImmutableMap<const VarDecl*,RVal> VarBindingsTy;  
+typedef llvm::ImmutableMap<const VarDecl*,SVal> VarBindingsTy;  
 
 namespace {
   
@@ -34,23 +34,23 @@
   
   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 @@
 
   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<const VarBindingsTy::TreeTy*>(store));
@@ -78,27 +78,27 @@
 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<UnknownVal>(LV))
     return UnknownVal();
@@ -107,9 +107,9 @@
   
   switch (LV.getSubKind()) {
 
-    case lval::MemRegionKind: {
+    case loc::MemRegionKind: {
       VarRegion* R =
-        dyn_cast<VarRegion>(cast<lval::MemRegionVal>(LV).getRegion());
+        dyn_cast<VarRegion>(cast<loc::MemRegionVal>(LV).getRegion());
       
       if (!R)
         return UnknownVal();
@@ -119,34 +119,34 @@
       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<VarRegion>(cast<lval::MemRegionVal>(LV).getRegion());
+        dyn_cast<VarRegion>(cast<loc::MemRegionVal>(LV).getRegion());
       
       if (!R)
         return store;
@@ -157,16 +157,16 @@
         : 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<VarRegion>(cast<lval::MemRegionVal>(LV).getRegion());
+      dyn_cast<VarRegion>(cast<loc::MemRegionVal>(LV).getRegion());
       
       if (!R)
         return store;
@@ -175,7 +175,7 @@
       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 @@
                           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 @@
     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<lval::MemRegionVal>(X))
+    if (!isa<loc::MemRegionVal>(X))
       continue;
     
-    const lval::MemRegionVal& LVD = cast<lval::MemRegionVal>(X);
+    const loc::MemRegionVal& LVD = cast<loc::MemRegionVal>(X);
     RegionRoots.push_back(cast<VarRegion>(LVD.getRegion()));
   }
   
@@ -229,8 +229,8 @@
     const VarRegion* R = cast<VarRegion>(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 @@
 
       // 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<ParmVarDecl>(VD) ||
+        SVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
                   isa<ImplicitParamDecl>(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::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 @@
       //     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<RVal>(lval::SymbolVal(Sym))
-          : cast<RVal>(nonlval::SymbolVal(Sym));
+        V = Loc::IsLocType(Ex->getType())
+          ? cast<SVal>(loc::SymbolVal(Sym))
+          : cast<SVal>(nonloc::SymbolVal(Sym));
       }
 
-      store = SetRVal(store, getLVal(VD), V);
+      store = SetSVal(store, getLoc(VD), V);
     }
   }
 

Modified: cfe/trunk/lib/Analysis/BasicValueFactory.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/BasicValueFactory.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/BasicValueFactory.cpp (original)
+++ cfe/trunk/lib/Analysis/BasicValueFactory.cpp Fri Oct 17 00:57:07 2008
@@ -18,31 +18,31 @@
 
 using namespace clang;
 
-typedef std::pair<RVal, uintptr_t> RValData;
-typedef std::pair<RVal, RVal> RValPair;
+typedef std::pair<SVal, uintptr_t> SValData;
+typedef std::pair<SVal, SVal> SValPair;
 
 
 namespace llvm {
-template<> struct FoldingSetTrait<RValData> {
-  static inline void Profile(const RValData& X, llvm::FoldingSetNodeID& ID) {
+template<> struct FoldingSetTrait<SValData> {
+  static inline void Profile(const SValData& X, llvm::FoldingSetNodeID& ID) {
     X.first.Profile(ID);
     ID.AddPointer( (void*) X.second);
   }
 };
   
-template<> struct FoldingSetTrait<RValPair> {
-  static inline void Profile(const RValPair& X, llvm::FoldingSetNodeID& ID) {
+template<> struct FoldingSetTrait<SValPair> {
+  static inline void Profile(const SValPair& X, llvm::FoldingSetNodeID& ID) {
     X.first.Profile(ID);
     X.second.Profile(ID);
   }
 };
 }
 
-typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<RValData> >
-  PersistentRValsTy;
+typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<SValData> >
+  PersistentSValsTy;
 
-typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<RValPair> >
-  PersistentRValPairsTy;
+typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<SValPair> >
+  PersistentSValPairsTy;
 
 BasicValueFactory::~BasicValueFactory() {
   // Note that the dstor for the contents of APSIntSet will never be called,
@@ -51,8 +51,8 @@
   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 @@
 }
 
 
-const std::pair<RVal, uintptr_t>&
-BasicValueFactory::getPersistentRValWithData(const RVal& V, uintptr_t Data) {
+const std::pair<SVal, uintptr_t>&
+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<RValData> FoldNodeTy;
+  typedef llvm::FoldingSetNodeWrapper<SValData> FoldNodeTy;
   FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos);
   
   if (!P) {  
@@ -222,20 +222,20 @@
   return P->getValue();
 }
 
-const std::pair<RVal, RVal>&
-BasicValueFactory::getPersistentRValPair(const RVal& V1, const RVal& V2) {
+const std::pair<SVal, SVal>&
+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<RValPair> FoldNodeTy;
+  typedef llvm::FoldingSetNodeWrapper<SValPair> FoldNodeTy;
   FoldNodeTy* P = Map.FindNodeOrInsertPos(ID, InsertPos);
   
   if (!P) {  
@@ -247,8 +247,8 @@
   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;
 }  
 
 

Modified: cfe/trunk/lib/Analysis/BugReporter.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/BugReporter.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/BugReporter.cpp (original)
+++ cfe/trunk/lib/Analysis/BugReporter.cpp Fri Oct 17 00:57:07 2008
@@ -292,7 +292,7 @@
 
 static VarDecl* GetMostRecentVarDeclBinding(ExplodedNode<GRState>* N,
                                             GRStateManager& VMgr,
-                                            RVal X) {
+                                            SVal X) {
   
   for ( ; N ; N = N->pred_empty() ? 0 : *N->pred_begin()) {
     
@@ -306,7 +306,7 @@
     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 @@
                        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<lval::SymbolVal>(&V))
+    if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&V))
       ScanSym = SV->getSymbol();
-    else if (nonlval::SymbolVal* SV = dyn_cast<nonlval::SymbolVal>(&V))
+    else if (nonloc::SymbolVal* SV = dyn_cast<nonloc::SymbolVal>(&V))
       ScanSym = SV->getSymbol();
     else
       return true;
@@ -356,7 +356,7 @@
       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 @@
                      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<lval::SymbolVal>(&V))
+    if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&V))
       ScanSym = SV->getSymbol();
-    else if (nonlval::SymbolVal* SV = dyn_cast<nonlval::SymbolVal>(&V))
+    else if (nonloc::SymbolVal* SV = dyn_cast<nonloc::SymbolVal>(&V))
       ScanSym = SV->getSymbol();
     else
       return true;

Modified: cfe/trunk/lib/Analysis/CFRefCount.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/CFRefCount.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/CFRefCount.cpp (original)
+++ cfe/trunk/lib/Analysis/CFRefCount.cpp Fri Oct 17 00:57:07 2008
@@ -1297,7 +1297,7 @@
   virtual void EvalCall(ExplodedNodeSet<GRState>& Dst,
                         GRExprEngine& Eng,
                         GRStmtNodeBuilder<GRState>& Builder,
-                        CallExpr* CE, RVal L,
+                        CallExpr* CE, SVal L,
                         ExplodedNode<GRState>* Pred);  
   
   
@@ -1319,7 +1319,7 @@
                          GRExprEngine& Engine,
                          GRStmtNodeBuilder<GRState>& Builder,
                          Expr* E, ExplodedNode<GRState>* 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 @@
   // 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 @@
   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<lval::SymbolVal>(V)) {
-      SymbolID Sym = cast<lval::SymbolVal>(V).getSymbol();
+    if (isa<loc::SymbolVal>(V)) {
+      SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
       if (RefBindings::data_type* T = state.get<RefBindings>(Sym))
         if (Update(state, Sym, *T, GetArgE(Summ, idx), hasErr)) {
           ErrorExpr = *I;
@@ -1484,12 +1484,12 @@
           break;
         }
     }  
-    else if (isa<LVal>(V)) {
+    else if (isa<Loc>(V)) {
 #if 0
       // Nuke all arguments passed by reference.
-      StateMgr.Unbind(StVals, cast<LVal>(V));
+      StateMgr.Unbind(StVals, cast<Loc>(V));
 #else
-      if (lval::MemRegionVal* MR = dyn_cast<lval::MemRegionVal>(&V)) {
+      if (loc::MemRegionVal* MR = dyn_cast<loc::MemRegionVal>(&V)) {
 
         if (GetArgE(Summ, idx) == DoNothingByRef)
           continue;
@@ -1506,10 +1506,10 @@
         //  disambiguate conjured symbols. 
 
         // Is the invalidated variable something that we were tracking?
-        RVal X = state.GetRVal(*MR);
+        SVal X = state.GetSVal(*MR);
         
-        if (isa<lval::SymbolVal>(X)) {
-          SymbolID Sym = cast<lval::SymbolVal>(X).getSymbol();
+        if (isa<loc::SymbolVal>(X)) {
+          SymbolID Sym = cast<loc::SymbolVal>(X).getSymbol();
           state = state.remove<RefBindings>(Sym);
         }
         
@@ -1521,29 +1521,29 @@
           SymbolID NewSym =
             Eng.getSymbolManager().getConjuredSymbol(*I, T, Count);
           
-          state = state.SetRVal(*MR,
-                                LVal::IsLValType(T)
-                                ? cast<RVal>(lval::SymbolVal(NewSym))
-                                : cast<RVal>(nonlval::SymbolVal(NewSym)));
+          state = state.SetSVal(*MR,
+                                Loc::IsLocType(T)
+                                ? cast<SVal>(loc::SymbolVal(NewSym))
+                                : cast<SVal>(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<LVal>(V));
+        state = state.Unbind(cast<Loc>(V));
       }
 #endif
     }
-    else if (isa<nonlval::LValAsInteger>(V))
-      state = state.Unbind(cast<nonlval::LValAsInteger>(V).getLVal());
+    else if (isa<nonloc::LocAsInteger>(V))
+      state = state.Unbind(cast<nonloc::LocAsInteger>(V).getLoc());
   } 
   
   // Evaluate the effect on the message receiver.  
   if (!ErrorExpr && Receiver) {
-    RVal V = state.GetRVal(Receiver);
-    if (isa<lval::SymbolVal>(V)) {
-      SymbolID Sym = cast<lval::SymbolVal>(V).getSymbol();
+    SVal V = state.GetSVal(Receiver);
+    if (isa<loc::SymbolVal>(V)) {
+      SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
       if (const RefVal* T = state.get<RefBindings>(Sym))
         if (Update(state, Sym, *T, GetReceiverE(Summ), hasErr)) {
           ErrorExpr = Receiver;
@@ -1576,11 +1576,11 @@
         unsigned Count = Builder.getCurrentBlockCount();
         SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
         
-        RVal X = LVal::IsLValType(Ex->getType())
-               ? cast<RVal>(lval::SymbolVal(Sym)) 
-               : cast<RVal>(nonlval::SymbolVal(Sym));
+        SVal X = Loc::IsLocType(Ex->getType())
+               ? cast<SVal>(loc::SymbolVal(Sym)) 
+               : cast<SVal>(nonloc::SymbolVal(Sym));
         
-        state = state.SetRVal(Ex, X, false);
+        state = state.SetSVal(Ex, X, false);
       }      
       
       break;
@@ -1589,15 +1589,15 @@
       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 @@
       QualType RetT = GetReturnType(Ex, Eng.getContext());
       
       state = state.set<RefBindings>(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 @@
       QualType RetT = GetReturnType(Ex, Eng.getContext());
       
       state = state.set<RefBindings>(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::EvalCall(ExplodedNodeSet<GRState>& Dst,
                           GRExprEngine& Eng,
                           GRStmtNodeBuilder<GRState>& Builder,
-                          CallExpr* CE, RVal L,
+                          CallExpr* CE, SVal L,
                           ExplodedNode<GRState>* Pred) {
 
-  RetainSummary* Summ = !isa<lval::FuncVal>(L) ? 0
-                      : Summaries.getSummary(cast<lval::FuncVal>(L).getDecl());
+  RetainSummary* Summ = !isa<loc::FuncVal>(L) ? 0
+                      : Summaries.getSummary(cast<loc::FuncVal>(L).getDecl());
   
   EvalSummary(Dst, Eng, Builder, CE, 0, Summ,
               CE->arg_begin(), CE->arg_end(), Pred);
@@ -1669,10 +1669,10 @@
     // 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<lval::SymbolVal>(V)) {
-      SymbolID Sym = cast<lval::SymbolVal>(V).getSymbol();
+    if (isa<loc::SymbolVal>(V)) {
+      SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
       
       if (const RefVal* T  = St->get<RefBindings>(Sym)) {
         QualType Ty = T->getType();
@@ -1702,29 +1702,29 @@
                            GRExprEngine& Eng,
                            GRStmtNodeBuilder<GRState>& Builder,
                            Expr* E, ExplodedNode<GRState>* 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<lval::SymbolVal>(Val))
+  if (!isa<loc::SymbolVal>(Val))
     return;
   
   // Are we storing to something that causes the value to "escape"?
   
   bool escapes = false;
   
-  if (!isa<lval::MemRegionVal>(TargetLV))
+  if (!isa<loc::MemRegionVal>(TargetLV))
     escapes = true;
   else {
-    MemRegion* R = cast<lval::MemRegionVal>(TargetLV).getRegion();
+    MemRegion* R = cast<loc::MemRegionVal>(TargetLV).getRegion();
     escapes = !Eng.getStateManager().hasStackStorage(R);
   }
   
   if (!escapes)
     return;
   
-  SymbolID Sym = cast<lval::SymbolVal>(Val).getSymbol();
+  SymbolID Sym = cast<loc::SymbolVal>(Val).getSymbol();
   
   GRStateRef state(St, Eng.getStateManager());
   
@@ -1849,13 +1849,13 @@
   if (!RetE) return;
   
   GRStateRef state(Builder.GetState(Pred), Eng.getStateManager());
-  RVal V = state.GetRVal(RetE);
+  SVal V = state.GetSVal(RetE);
   
-  if (!isa<lval::SymbolVal>(V))
+  if (!isa<loc::SymbolVal>(V))
     return;
   
   // Get the reference count binding (if any).
-  SymbolID Sym = cast<lval::SymbolVal>(V).getSymbol();
+  SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
   const RefVal* T = state.get<RefBindings>(Sym);
   
   if (!T)
@@ -1892,7 +1892,7 @@
 
 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 @@
   
   for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I!=E; ++I)
     if (Expr* Exp = dyn_cast_or_null<Expr>(*I)) {
-      RVal X = VSM.GetRVal(CurrSt, Exp);
+      SVal X = VSM.GetSVal(CurrSt, Exp);
       
-      if (lval::SymbolVal* SV = dyn_cast<lval::SymbolVal>(&X))
+      if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&X))
         if (SV->getSymbol() == Sym) {
           P->addRange(Exp->getSourceRange()); break;
         }
@@ -2324,12 +2324,12 @@
   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<lval::SymbolVal>(&val)) {
+  bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal val) {
+    if (const loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&val)) {
       if (SV->getSymbol() != Sym) 
         return true;
     }
-    else if (const nonlval::SymbolVal* SV=dyn_cast<nonlval::SymbolVal>(&val)) {
+    else if (const nonloc::SymbolVal* SV=dyn_cast<nonloc::SymbolVal>(&val)) {
       if (SV->getSymbol() != Sym)
         return true;
     }

Modified: cfe/trunk/lib/Analysis/CheckNSError.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/CheckNSError.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/CheckNSError.cpp (original)
+++ cfe/trunk/lib/Analysis/CheckNSError.cpp Fri Oct 17 00:57:07 2008
@@ -216,11 +216,11 @@
                                    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<lval::SymbolVal>(&ParamRVal);
+  loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&ParamSVal);
   if (!SV) return;
   
   // Iterate over the implicit-null dereferences.
@@ -228,8 +228,8 @@
        E=Eng.implicit_null_derefs_end(); I!=E; ++I) {
     
     GRStateRef state = GRStateRef((*I)->getState(), Eng.getStateManager());
-    const RVal* X = state.get<GRState::NullDerefTag>();    
-    const lval::SymbolVal* SVX = dyn_cast_or_null<lval::SymbolVal>(X);
+    const SVal* X = state.get<GRState::NullDerefTag>();    
+    const loc::SymbolVal* SVX = dyn_cast_or_null<loc::SymbolVal>(X);
     if (!SVX || SVX->getSymbol() != SV->getSymbol()) continue;
 
     // Emit an error.

Modified: cfe/trunk/lib/Analysis/Environment.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/Environment.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/Environment.cpp (original)
+++ cfe/trunk/lib/Analysis/Environment.cpp Fri Oct 17 00:57:07 2008
@@ -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<AddrLabelExpr>(E));
+        return Loc::MakeVal(cast<AddrLabelExpr>(E));
         
         // ParenExprs are no-ops.
         
@@ -35,15 +35,15 @@
         
       case Stmt::CharacterLiteralClass: {
         CharacterLiteral* C = cast<CharacterLiteral>(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<IntegerLiteral>(E));
+        return NonLoc::MakeVal(BasicVals, cast<IntegerLiteral>(E));
       }
         
       case Stmt::StringLiteralClass:
-        return LVal::MakeVal(cast<StringLiteral>(E));
+        return Loc::MakeVal(cast<StringLiteral>(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 @@
   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<CharacterLiteral>(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<IntegerLiteral>(E));
+      return NonLoc::MakeVal(BasicVals, cast<IntegerLiteral>(E));
     }
       
     default:
@@ -92,7 +92,7 @@
   }
 }
 
-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 @@
     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<lval::MemRegionVal>(X))
-        DRoots.push_back(cast<lval::MemRegionVal>(X).getRegion());
+      if (isa<loc::MemRegionVal>(X))
+        DRoots.push_back(cast<loc::MemRegionVal>(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<UndefinedVal>(X).getData())
         continue;

Modified: cfe/trunk/lib/Analysis/GRExprEngine.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/GRExprEngine.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/GRExprEngine.cpp (original)
+++ cfe/trunk/lib/Analysis/GRExprEngine.cpp Fri Oct 17 00:57:07 2008
@@ -302,7 +302,7 @@
       }
       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 @@
       assert (!SE->getSubStmt()->body_empty());
       
       if (Expr* LastExpr = dyn_cast<Expr>(*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 @@
                  (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 @@
       else
         Ex = C->getRHS();
       
-      return SetBlkExprRVal(St, C, UndefinedVal(Ex));
+      return SetBlkExprSVal(St, C, UndefinedVal(Ex));
     }
       
     case Stmt::ChooseExprClass: { // ?:
@@ -498,7 +498,7 @@
       ChooseExpr* C = cast<ChooseExpr>(Terminator);
       
       Expr* Ex = branchTaken ? C->getLHS() : C->getRHS();      
-      return SetBlkExprRVal(St, C, UndefinedVal(Ex));
+      return SetBlkExprSVal(St, C, UndefinedVal(Ex));
     }
   }
 }
@@ -516,18 +516,18 @@
     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::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 @@
   
   typedef IndirectGotoNodeBuilder::iterator iterator;
 
-  if (isa<lval::GotoLabel>(V)) {
-    LabelStmt* L = cast<lval::GotoLabel>(V).getLabel();
+  if (isa<loc::GotoLabel>(V)) {
+    LabelStmt* L = cast<loc::GotoLabel>(V).getLabel();
     
     for (iterator I=builder.begin(), E=builder.end(); I != E; ++I) {
       if (I.getLabel() == L) {
@@ -591,7 +591,7 @@
     return;
   }
 
-  if (isa<lval::ConcreteInt>(V) || isa<UndefinedVal>(V)) {
+  if (isa<loc::ConcreteInt>(V) || isa<UndefinedVal>(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 @@
   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 @@
   
   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 @@
   
   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 @@
     //  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 @@
         // 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<nonlval::ConcreteInt>(CondV))
+        if (isa<nonloc::ConcreteInt>(CondV))
           return;
       }
       
@@ -741,7 +741,7 @@
   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 @@
   
   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 @@
     
     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 @@
     // 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 @@
 
   if (const VarDecl* VD = dyn_cast<VarDecl>(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 @@
       // 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 @@
     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<FunctionDecl>(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 @@
       
     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 @@
     // 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::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 @@
     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<LVal>(location),
+    MakeNode(Dst, Ex, Pred, SetSVal(St, Ex, GetSVal(St, cast<Loc>(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 @@
 
 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 @@
   // 
   // We add these assumptions.
   
-  LVal LV = cast<LVal>(location);    
+  Loc LV = cast<Loc>(location);    
   
   // "Assume" that the pointer is not NULL.
   
@@ -1008,7 +1008,7 @@
   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<GRState::NullDerefTag>(PersistentLV);
     
     // We don't use "MakeNode" here because the node will be a sink
@@ -1066,14 +1066,14 @@
   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<lval::ConcreteInt>(L)) {      
+    if (L.isUndef() || isa<loc::ConcreteInt>(L)) {      
       NodeTy* N = Builder->generateNode(CE, St, *DI);
       
       if (N) {
@@ -1088,9 +1088,9 @@
     
     SaveAndRestore<bool> OldSink(Builder->BuildSinks);
     
-    if (isa<lval::FuncVal>(L)) {      
+    if (isa<loc::FuncVal>(L)) {      
       
-      FunctionDecl* FD = cast<lval::FuncVal>(L).getDecl();
+      FunctionDecl* FD = cast<loc::FuncVal>(L).getDecl();
       
       if (FD->getAttr<NoReturnAttr>())
         Builder->BuildSinks = true;
@@ -1113,10 +1113,10 @@
             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<nonlval::ConcreteInt>(&X);
+                nonloc::ConcreteInt* CI = dyn_cast<nonloc::ConcreteInt>(&X);
                 if (CI && CI->getValue() != 0)
                   Builder->BuildSinks = true;
               }
@@ -1168,17 +1168,17 @@
     
     // Evaluate the call.
 
-    if (isa<lval::FuncVal>(L)) {
+    if (isa<loc::FuncVal>(L)) {
       
-      IdentifierInfo* Info = cast<lval::FuncVal>(L).getDecl()->getIdentifier();
+      IdentifierInfo* Info = cast<loc::FuncVal>(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 @@
     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 @@
   
   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 @@
   
   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 @@
   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 @@
   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 @@
     // 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 @@
     
     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<LVal>(V), bits);
-      MakeNode(Dst, CastE, N, SetRVal(St, CastE, V));
+      V = nonloc::LocAsInteger::Make(getBasicVals(), cast<Loc>(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<nonlval::LValAsInteger>(&V)) {
+    if (Loc::IsLocType(T) && ExTy->isIntegerType())
+      if (nonloc::LocAsInteger *LV = dyn_cast<nonloc::LocAsInteger>(&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 @@
     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 @@
       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 @@
       
       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 @@
         // 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 @@
       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 @@
         // 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 @@
       
       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 @@
      
       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 @@
         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 @@
         // 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 @@
             
           case UnaryOperator::Not:
             // FIXME: Do we need to handle promotions?
-            St = SetRVal(St, U, EvalComplement(cast<NonLVal>(V)));
+            St = SetSVal(St, U, EvalComplement(cast<NonLoc>(V)));
             break;            
             
           case UnaryOperator::Minus:
             // FIXME: Do we need to handle promotions?
-            St = SetRVal(St, U, EvalMinus(U, cast<NonLVal>(V)));
+            St = SetSVal(St, U, EvalMinus(U, cast<NonLoc>(V)));
             break;   
             
           case UnaryOperator::LNot:   
@@ -1729,18 +1729,18 @@
             //  Note: technically we do "E == 0", but this is the same in the
             //    transfer functions as "0 == E".
             
-            if (isa<LVal>(V)) {
-              lval::ConcreteInt X(getBasicVals().getZeroWithPtrWidth());
-              RVal Result = EvalBinOp(BinaryOperator::EQ, cast<LVal>(V), X);
-              St = SetRVal(St, U, Result);
+            if (isa<Loc>(V)) {
+              loc::ConcreteInt X(getBasicVals().getZeroWithPtrWidth());
+              SVal Result = EvalBinOp(BinaryOperator::EQ, cast<Loc>(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<NonLVal>(V), X);
-              St = SetRVal(St, U, Result);
+              SVal Result = EvalBinOp(BinaryOperator::EQ, cast<NonLoc>(V), X);
+              St = SetSVal(St, U, Result);
 #else
-              EvalBinOp(Dst, U, BinaryOperator::EQ, cast<NonLVal>(V), X, *I);
+              EvalBinOp(Dst, U, BinaryOperator::EQ, cast<NonLoc>(V), X, *I);
               continue;
 #endif
             }
@@ -1765,7 +1765,7 @@
         
       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 @@
   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 @@
     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 @@
       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 @@
   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 @@
     for (AsmStmt::outputs_iterator OI = A->begin_outputs(),
                                    OE = A->end_outputs(); OI != OE; ++OI) {
       
-      RVal X = GetRVal(St, *OI);      
-      assert (!isa<NonLVal>(X));  // Should be an Lval, or unknown, undef.
+      SVal X = GetSVal(St, *OI);      
+      assert (!isa<NonLoc>(X));  // Should be an Lval, or unknown, undef.
       
-      if (isa<LVal>(X))
-        St = SetRVal(St, cast<LVal>(X), UnknownVal());
+      if (isa<Loc>(X))
+        St = SetSVal(St, cast<Loc>(X), UnknownVal());
     }
     
     MakeNode(Dst, A, Pred, St);
@@ -1909,12 +1909,12 @@
     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<lval::MemRegionVal>(X)) {
+      if (isa<loc::MemRegionVal>(X)) {
         
         // Determine if the value is on the stack.
-        const MemRegion* R = cast<lval::MemRegionVal>(&X)->getRegion();
+        const MemRegion* R = cast<loc::MemRegionVal>(&X)->getRegion();
 
         if (R && getStateManager().hasStackStorage(R)) {
         
@@ -1946,7 +1946,7 @@
 //===----------------------------------------------------------------------===//
 
 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 @@
 
   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 @@
     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 @@
             unsigned Count = Builder->getCurrentBlockCount();
             SymbolID Sym = SymMgr.getConjuredSymbol(B->getRHS(), Count);
             
-            RightV = LVal::IsLValType(B->getRHS()->getType()) 
-                   ? cast<RVal>(lval::SymbolVal(Sym)) 
-                   : cast<RVal>(nonlval::SymbolVal(Sym));            
+            RightV = Loc::IsLocType(B->getRHS()->getType()) 
+                   ? cast<SVal>(loc::SymbolVal(Sym)) 
+                   : cast<SVal>(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 @@
           // 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 @@
           
           // 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 @@
       // 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 @@
         }
         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 @@
           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::EvalBinOp(ExplodedNodeSet<GRState>& Dst, Expr* Ex,
                              BinaryOperator::Opcode Op,
-                             NonLVal L, NonLVal R,
+                             NonLoc L, NonLoc R,
                              ExplodedNode<GRState>* Pred) {
 
   GRStateSet OStates;
@@ -2183,7 +2183,7 @@
 
 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 @@
         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))

Modified: cfe/trunk/lib/Analysis/GRExprEngineInternalChecks.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/GRExprEngineInternalChecks.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/GRExprEngineInternalChecks.cpp (original)
+++ cfe/trunk/lib/Analysis/GRExprEngineInternalChecks.cpp Fri Oct 17 00:57:07 2008
@@ -194,8 +194,8 @@
       assert (E && "Return expression cannot be NULL");
       
       // Get the value associated with E.
-      lval::MemRegionVal V =
-        cast<lval::MemRegionVal>(Eng.getStateManager().GetRVal(N->getState(),
+      loc::MemRegionVal V =
+        cast<loc::MemRegionVal>(Eng.getStateManager().GetSVal(N->getState(),
                                                                E));
       
       // Generate a report for this bug.
@@ -235,7 +235,7 @@
       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 @@
     CallExpr* CE = cast<CallExpr>(cast<PostStmt>(N->getLocation()).getStmt());
     const GRState* state = N->getState();
     
-    RVal X = VMgr.GetRVal(state, CE->getCallee());
+    SVal X = VMgr.GetSVal(state, CE->getCallee());
     
-    if (!isa<lval::FuncVal>(X))
+    if (!isa<loc::FuncVal>(X))
       return false;
     
-    FunctionDecl* FD = dyn_cast<FunctionDecl>(cast<lval::FuncVal>(X).getDecl());
+    FunctionDecl* FD = dyn_cast<FunctionDecl>(cast<loc::FuncVal>(X).getDecl());
     const NonNullAttr* Att = FD->getAttr<NonNullAttr>();
     
     if (!Att)

Modified: cfe/trunk/lib/Analysis/GRSimpleVals.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/GRSimpleVals.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/GRSimpleVals.cpp (original)
+++ cfe/trunk/lib/Analysis/GRSimpleVals.cpp Fri Oct 17 00:57:07 2008
@@ -36,32 +36,32 @@
 // Transfer function for Casts.
 //===----------------------------------------------------------------------===//
 
-RVal GRSimpleVals::EvalCast(GRExprEngine& Eng, NonLVal X, QualType T) {
+SVal GRSimpleVals::EvalCast(GRExprEngine& Eng, NonLoc X, QualType T) {
   
-  if (!isa<nonlval::ConcreteInt>(X))
+  if (!isa<nonloc::ConcreteInt>(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<nonlval::ConcreteInt>(X).getValue();
-  V.setIsUnsigned(T->isUnsignedIntegerType() || LVal::IsLValType(T));
+  llvm::APSInt V = cast<nonloc::ConcreteInt>(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 @@
   //   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<lval::ConcreteInt>(X))
+  if (!isa<loc::ConcreteInt>(X))
     return UnknownVal();
   
   BasicValueFactory& BasicVals = Eng.getBasicVals();
   
-  llvm::APSInt V = cast<lval::ConcreteInt>(X).getValue();
-  V.setIsUnsigned(T->isUnsignedIntegerType() || LVal::IsLValType(T));
+  llvm::APSInt V = cast<loc::ConcreteInt>(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<nonlval::ConcreteInt>(X).EvalMinus(Eng.getBasicVals(), U);
+    case nonloc::ConcreteIntKind:
+      return cast<nonloc::ConcreteInt>(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<nonlval::ConcreteInt>(X).EvalComplement(Eng.getBasicVals());
+    case nonloc::ConcreteIntKind:
+      return cast<nonloc::ConcreteInt>(X).EvalComplement(Eng.getBasicVals());
       
     default:
       return UnknownVal();
@@ -123,9 +123,9 @@
   (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 @@
       default:
         return UnknownVal();
         
-      case nonlval::SymIntConstraintValKind: {
+      case nonloc::SymIntConstraintValKind: {
         
         // Logical not?        
         if (!(Op == BinaryOperator::EQ && R.isZeroConstant()))
           return UnknownVal();
         
         const SymIntConstraint& C =
-          cast<nonlval::SymIntConstraintVal>(L).getConstraint();
+          cast<nonloc::SymIntConstraintVal>(L).getConstraint();
         
         BinaryOperator::Opcode Opc = C.getOpcode();
         
@@ -163,19 +163,19 @@
         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<nonlval::ConcreteInt>(R)) {          
-          const nonlval::ConcreteInt& L_CI = cast<nonlval::ConcreteInt>(L);
-          const nonlval::ConcreteInt& R_CI = cast<nonlval::ConcreteInt>(R);
+        if (isa<nonloc::ConcreteInt>(R)) {          
+          const nonloc::ConcreteInt& L_CI = cast<nonloc::ConcreteInt>(L);
+          const nonloc::ConcreteInt& R_CI = cast<nonloc::ConcreteInt>(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 @@
           continue;
         }
         
-      case nonlval::SymbolValKind:
-        if (isa<nonlval::ConcreteInt>(R)) {
+      case nonloc::SymbolValKind:
+        if (isa<nonloc::ConcreteInt>(R)) {
           const SymIntConstraint& C =
-            BasicVals.getConstraint(cast<nonlval::SymbolVal>(L).getSymbol(), Op,
-                                    cast<nonlval::ConcreteInt>(R).getValue());
+            BasicVals.getConstraint(cast<nonloc::SymbolVal>(L).getSymbol(), Op,
+                                    cast<nonloc::ConcreteInt>(R).getValue());
           
-          return nonlval::SymIntConstraintVal(C);
+          return nonloc::SymIntConstraintVal(C);
         }
         else
           return UnknownVal();
@@ -208,8 +208,8 @@
 
 // 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 @@
 
 // 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<lval::ConcreteInt>(R)) {
-        bool b = cast<lval::ConcreteInt>(L).getValue() ==
-                 cast<lval::ConcreteInt>(R).getValue();
+      if (isa<loc::ConcreteInt>(R)) {
+        bool b = cast<loc::ConcreteInt>(L).getValue() ==
+                 cast<loc::ConcreteInt>(R).getValue();
         
-        return NonLVal::MakeIntTruthVal(BasicVals, b);
+        return NonLoc::MakeIntTruthVal(BasicVals, b);
       }
-      else if (isa<lval::SymbolVal>(R)) {
+      else if (isa<loc::SymbolVal>(R)) {
         
         const SymIntConstraint& C =
-          BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(),
+          BasicVals.getConstraint(cast<loc::SymbolVal>(R).getSymbol(),
                                BinaryOperator::EQ,
-                               cast<lval::ConcreteInt>(L).getValue());
+                               cast<loc::ConcreteInt>(L).getValue());
         
-        return nonlval::SymIntConstraintVal(C);
+        return nonloc::SymIntConstraintVal(C);
       }
       
       break;
       
-    case lval::SymbolValKind: {
+    case loc::SymbolValKind: {
 
-      if (isa<lval::ConcreteInt>(R)) {          
+      if (isa<loc::ConcreteInt>(R)) {          
         const SymIntConstraint& C =
-          BasicVals.getConstraint(cast<lval::SymbolVal>(L).getSymbol(),
+          BasicVals.getConstraint(cast<loc::SymbolVal>(L).getSymbol(),
                                BinaryOperator::EQ,
-                               cast<lval::ConcreteInt>(R).getValue());
+                               cast<loc::ConcreteInt>(R).getValue());
         
-        return nonlval::SymIntConstraintVal(C);
+        return nonloc::SymIntConstraintVal(C);
       }
       
       // FIXME: Implement == for lval Symbols.  This is mainly useful
@@ -282,53 +282,53 @@
       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<lval::ConcreteInt>(R)) {
-        bool b = cast<lval::ConcreteInt>(L).getValue() !=
-                 cast<lval::ConcreteInt>(R).getValue();
+      if (isa<loc::ConcreteInt>(R)) {
+        bool b = cast<loc::ConcreteInt>(L).getValue() !=
+                 cast<loc::ConcreteInt>(R).getValue();
         
-        return NonLVal::MakeIntTruthVal(BasicVals, b);
+        return NonLoc::MakeIntTruthVal(BasicVals, b);
       }
-      else if (isa<lval::SymbolVal>(R)) {        
+      else if (isa<loc::SymbolVal>(R)) {        
         const SymIntConstraint& C =
-          BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(),
+          BasicVals.getConstraint(cast<loc::SymbolVal>(R).getSymbol(),
                                   BinaryOperator::NE,
-                                  cast<lval::ConcreteInt>(L).getValue());
+                                  cast<loc::ConcreteInt>(L).getValue());
         
-        return nonlval::SymIntConstraintVal(C);
+        return nonloc::SymIntConstraintVal(C);
       }
       
       break;
       
-    case lval::SymbolValKind: {
-      if (isa<lval::ConcreteInt>(R)) {          
+    case loc::SymbolValKind: {
+      if (isa<loc::ConcreteInt>(R)) {          
         const SymIntConstraint& C =
-          BasicVals.getConstraint(cast<lval::SymbolVal>(L).getSymbol(),
+          BasicVals.getConstraint(cast<loc::SymbolVal>(L).getSymbol(),
                                   BinaryOperator::NE,
-                                  cast<lval::ConcreteInt>(R).getValue());
+                                  cast<loc::ConcreteInt>(R).getValue());
         
-        return nonlval::SymIntConstraintVal(C);
+        return nonloc::SymIntConstraintVal(C);
       }
       
       // FIXME: Implement != for lval Symbols.  This is mainly useful
@@ -341,14 +341,14 @@
       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 @@
 void GRSimpleVals::EvalCall(ExplodedNodeSet<GRState>& Dst,
                             GRExprEngine& Eng,
                             GRStmtNodeBuilder<GRState>& Builder,
-                            CallExpr* CE, RVal L,
+                            CallExpr* CE, SVal L,
                             ExplodedNode<GRState>* 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<LVal>(V))
-      St = StateMgr.SetRVal(St, cast<LVal>(V), UnknownVal());
-    else if (isa<nonlval::LValAsInteger>(V))
-      St = StateMgr.SetRVal(St, cast<nonlval::LValAsInteger>(V).getLVal(),
+    if (isa<Loc>(V))
+      St = StateMgr.SetSVal(St, cast<Loc>(V), UnknownVal());
+    else if (isa<nonloc::LocAsInteger>(V))
+      St = StateMgr.SetSVal(St, cast<nonloc::LocAsInteger>(V).getLoc(),
                             UnknownVal());
     
   }
@@ -385,11 +385,11 @@
     unsigned Count = Builder.getCurrentBlockCount();
     SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(CE, Count);
         
-    RVal X = LVal::IsLValType(CE->getType())
-             ? cast<RVal>(lval::SymbolVal(Sym)) 
-             : cast<RVal>(nonlval::SymbolVal(Sym));
+    SVal X = Loc::IsLocType(CE->getType())
+             ? cast<SVal>(loc::SymbolVal(Sym)) 
+             : cast<SVal>(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 @@
   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<LVal>(V))
-      St = StateMgr.SetRVal(St, cast<LVal>(V), UnknownVal());
+    if (isa<Loc>(V))
+      St = StateMgr.SetSVal(St, cast<Loc>(V), UnknownVal());
   }
   
   Builder.MakeNode(Dst, ME, Pred, St);

Modified: cfe/trunk/lib/Analysis/GRSimpleVals.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/GRSimpleVals.h?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/GRSimpleVals.h (original)
+++ cfe/trunk/lib/Analysis/GRSimpleVals.h Fri Oct 17 00:57:07 2008
@@ -27,9 +27,9 @@
 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 @@
   
   // 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<GRState>& Dst,
                         GRExprEngine& Engine,
                         GRStmtNodeBuilder<GRState>& Builder,
-                        CallExpr* CE, RVal L,
+                        CallExpr* CE, SVal L,
                         ExplodedNode<GRState>* Pred);
   
   virtual void EvalObjCMessageExpr(ExplodedNodeSet<GRState>& Dst,
@@ -77,10 +77,10 @@
   
 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

Modified: cfe/trunk/lib/Analysis/GRState.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/GRState.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/GRState.cpp (original)
+++ cfe/trunk/lib/Analysis/GRState.cpp Fri Oct 17 00:57:07 2008
@@ -59,11 +59,11 @@
                                            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 @@
 
   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 @@
   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 @@
 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<lval::ConcreteInt>(&V))
+  if (loc::ConcreteInt* X = dyn_cast<loc::ConcreteInt>(&V))
     return X->getValue() == Y;
 
-  if (nonlval::ConcreteInt* X = dyn_cast<nonlval::ConcreteInt>(&V))
+  if (nonloc::ConcreteInt* X = dyn_cast<nonloc::ConcreteInt>(&V))
     return X->getValue() == Y;
     
-  if (nonlval::SymbolVal* X = dyn_cast<nonlval::SymbolVal>(&V))
+  if (nonloc::SymbolVal* X = dyn_cast<nonloc::SymbolVal>(&V))
     return ConstraintMgr->isEqual(state, X->getSymbol(), Y);
   
-  if (lval::SymbolVal* X = dyn_cast<lval::SymbolVal>(&V))
+  if (loc::SymbolVal* X = dyn_cast<loc::SymbolVal>(&V))
     return ConstraintMgr->isEqual(state, X->getSymbol(), Y);
   
   return false;

Modified: cfe/trunk/lib/Analysis/GRTransferFuncs.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/GRTransferFuncs.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/GRTransferFuncs.cpp (original)
+++ cfe/trunk/lib/Analysis/GRTransferFuncs.cpp Fri Oct 17 00:57:07 2008
@@ -23,7 +23,7 @@
                                 GRExprEngine& Eng,
                                 GRStmtNodeBuilder<GRState>& Builder,
                                 Expr* E, ExplodedNode<GRState>* 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 @@
     Builder.MakeNode(Dst, E, Pred, St);
   else
     Builder.MakeNode(Dst, E, Pred,
-                Eng.getStateManager().SetRVal(St, cast<LVal>(TargetLV), Val));    
+                Eng.getStateManager().SetSVal(St, cast<Loc>(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)));
 }

Modified: cfe/trunk/lib/Analysis/RValues.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/RValues.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/RValues.cpp (original)
+++ cfe/trunk/lib/Analysis/RValues.cpp Fri Oct 17 00:57:07 2008
@@ -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 @@
 // 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<lval::SymbolVal>(this))
+  if (isa<loc::SymbolVal>(this))
     return (symbol_iterator) (&Data);
-  else if (isa<nonlval::SymbolVal>(this))
+  else if (isa<nonloc::SymbolVal>(this))
     return (symbol_iterator) (&Data);
-  else if (isa<nonlval::SymIntConstraintVal>(this)) {
+  else if (isa<nonloc::SymIntConstraintVal>(this)) {
     const SymIntConstraint& C =
-      cast<nonlval::SymIntConstraintVal>(this)->getConstraint();
+      cast<nonloc::SymIntConstraintVal>(this)->getConstraint();
     
     return (symbol_iterator) &C.getSymbol();
   }
-  else if (isa<nonlval::LValAsInteger>(this)) {
-    const nonlval::LValAsInteger& V = cast<nonlval::LValAsInteger>(*this);
-    return  V.getPersistentLVal().symbol_begin();
+  else if (isa<nonloc::LocAsInteger>(this)) {
+    const nonloc::LocAsInteger& V = cast<nonloc::LocAsInteger>(*this);
+    return V.getPersistentLoc().symbol_begin();
   }
   
   // FIXME: We need to iterate over the symbols of regions.
@@ -49,7 +49,7 @@
   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 @@
 // Useful predicates.
 //===----------------------------------------------------------------------===//
 
-bool RVal::isZeroConstant() const {
-  if (isa<lval::ConcreteInt>(*this))
-    return cast<lval::ConcreteInt>(*this).getValue() == 0;
-  else if (isa<nonlval::ConcreteInt>(*this))
-    return cast<nonlval::ConcreteInt>(*this).getValue() == 0;
+bool SVal::isZeroConstant() const {
+  if (isa<loc::ConcreteInt>(*this))
+    return cast<loc::ConcreteInt>(*this).getValue() == 0;
+  else if (isa<nonloc::ConcreteInt>(*this))
+    return cast<nonloc::ConcreteInt>(*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 @@
   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<lval::ConcreteInt>(R)) {
-        bool b = cast<lval::ConcreteInt>(this)->getValue() ==
-                 cast<lval::ConcreteInt>(R).getValue();
+    case loc::ConcreteIntKind:
+      if (isa<loc::ConcreteInt>(R)) {
+        bool b = cast<loc::ConcreteInt>(this)->getValue() ==
+                 cast<loc::ConcreteInt>(R).getValue();
         
-        return NonLVal::MakeIntTruthVal(BasicVals, b);
+        return NonLoc::MakeIntTruthVal(BasicVals, b);
       }
-      else if (isa<lval::SymbolVal>(R)) {
+      else if (isa<loc::SymbolVal>(R)) {
         
         const SymIntConstraint& C =
-          BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(),
+          BasicVals.getConstraint(cast<loc::SymbolVal>(R).getSymbol(),
                                BinaryOperator::EQ,
-                               cast<lval::ConcreteInt>(this)->getValue());
+                               cast<loc::ConcreteInt>(this)->getValue());
         
-        return nonlval::SymIntConstraintVal(C);        
+        return nonloc::SymIntConstraintVal(C);        
       }
       
       break;
       
-      case lval::SymbolValKind: {
-        if (isa<lval::ConcreteInt>(R)) {
+      case loc::SymbolValKind: {
+        if (isa<loc::ConcreteInt>(R)) {
           
           const SymIntConstraint& C =
-            BasicVals.getConstraint(cast<lval::SymbolVal>(this)->getSymbol(),
+            BasicVals.getConstraint(cast<loc::SymbolVal>(this)->getSymbol(),
                                  BinaryOperator::EQ,
-                                 cast<lval::ConcreteInt>(R).getValue());
+                                 cast<loc::ConcreteInt>(R).getValue());
           
-          return nonlval::SymIntConstraintVal(C);
+          return nonloc::SymIntConstraintVal(C);
         }
         
-        assert (!isa<lval::SymbolVal>(R) && "FIXME: Implement unification.");
+        assert (!isa<loc::SymbolVal>(R) && "FIXME: Implement unification.");
         
         break;
       }
       
-      case lval::MemRegionKind:
-      if (isa<lval::MemRegionVal>(R)) {        
-        bool b = cast<lval::MemRegionVal>(*this) == cast<lval::MemRegionVal>(R);
-        return NonLVal::MakeIntTruthVal(BasicVals, b);
+      case loc::MemRegionKind:
+      if (isa<loc::MemRegionVal>(R)) {        
+        bool b = cast<loc::MemRegionVal>(*this) == cast<loc::MemRegionVal>(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<lval::ConcreteInt>(R)) {
-        bool b = cast<lval::ConcreteInt>(this)->getValue() !=
-                 cast<lval::ConcreteInt>(R).getValue();
+    case loc::ConcreteIntKind:
+      if (isa<loc::ConcreteInt>(R)) {
+        bool b = cast<loc::ConcreteInt>(this)->getValue() !=
+                 cast<loc::ConcreteInt>(R).getValue();
         
-        return NonLVal::MakeIntTruthVal(BasicVals, b);
+        return NonLoc::MakeIntTruthVal(BasicVals, b);
       }
-      else if (isa<lval::SymbolVal>(R)) {
+      else if (isa<loc::SymbolVal>(R)) {
         
         const SymIntConstraint& C =
-        BasicVals.getConstraint(cast<lval::SymbolVal>(R).getSymbol(),
+        BasicVals.getConstraint(cast<loc::SymbolVal>(R).getSymbol(),
                              BinaryOperator::NE,
-                             cast<lval::ConcreteInt>(this)->getValue());
+                             cast<loc::ConcreteInt>(this)->getValue());
         
-        return nonlval::SymIntConstraintVal(C);        
+        return nonloc::SymIntConstraintVal(C);        
       }
       
       break;
       
-      case lval::SymbolValKind: {
-        if (isa<lval::ConcreteInt>(R)) {
+      case loc::SymbolValKind: {
+        if (isa<loc::ConcreteInt>(R)) {
           
           const SymIntConstraint& C =
-          BasicVals.getConstraint(cast<lval::SymbolVal>(this)->getSymbol(),
+          BasicVals.getConstraint(cast<loc::SymbolVal>(this)->getSymbol(),
                                BinaryOperator::NE,
-                               cast<lval::ConcreteInt>(R).getValue());
+                               cast<loc::ConcreteInt>(R).getValue());
           
-          return nonlval::SymIntConstraintVal(C);
+          return nonloc::SymIntConstraintVal(C);
         }
         
-        assert (!isa<lval::SymbolVal>(R) && "FIXME: Implement sym !=.");
+        assert (!isa<loc::SymbolVal>(R) && "FIXME: Implement sym !=.");
         
         break;
       }
       
-      case lval::MemRegionKind:
-        if (isa<lval::MemRegionVal>(R)) {        
-          bool b = cast<lval::MemRegionVal>(*this)==cast<lval::MemRegionVal>(R);
-          return NonLVal::MakeIntTruthVal(BasicVals, b);
+      case loc::MemRegionKind:
+        if (isa<loc::MemRegionVal>(R)) {        
+          bool b = cast<loc::MemRegionVal>(*this)==cast<loc::MemRegionVal>(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<NonLVal>(this)->print(Out); break;
+    case NonLocKind:
+      cast<NonLoc>(this)->print(Out); break;
       
-    case LValKind:
-      cast<LVal>(this)->print(Out); break;
+    case LocKind:
+      cast<Loc>(this)->print(Out); break;
       
     case UndefinedKind:
       Out << "Undefined"; break;
       
     default:
-      assert (false && "Invalid RVal.");
+      assert (false && "Invalid SVal.");
   }
 }
 
@@ -316,25 +316,25 @@
   }        
 }
 
-void NonLVal::print(std::ostream& Out) const {
+void NonLoc::print(std::ostream& Out) const {
 
   switch (getSubKind()) {  
 
-    case nonlval::ConcreteIntKind:
-      Out << cast<nonlval::ConcreteInt>(this)->getValue().getZExtValue();
+    case nonloc::ConcreteIntKind:
+      Out << cast<nonloc::ConcreteInt>(this)->getValue().getZExtValue();
 
-      if (cast<nonlval::ConcreteInt>(this)->getValue().isUnsigned())
+      if (cast<nonloc::ConcreteInt>(this)->getValue().isUnsigned())
         Out << 'U';
       
       break;
       
-    case nonlval::SymbolValKind:
-      Out << '$' << cast<nonlval::SymbolVal>(this)->getSymbol();
+    case nonloc::SymbolValKind:
+      Out << '$' << cast<nonloc::SymbolVal>(this)->getSymbol();
       break;
      
-    case nonlval::SymIntConstraintValKind: {
-      const nonlval::SymIntConstraintVal& C = 
-        *cast<nonlval::SymIntConstraintVal>(this);
+    case nonloc::SymIntConstraintValKind: {
+      const nonloc::SymIntConstraintVal& C = 
+        *cast<nonloc::SymIntConstraintVal>(this);
       
       Out << '$' << C.getConstraint().getSymbol() << ' ';
       printOpcode(Out, C.getConstraint().getOpcode());
@@ -346,54 +346,54 @@
       break;
     }
     
-    case nonlval::LValAsIntegerKind: {
-      const nonlval::LValAsInteger& C = *cast<nonlval::LValAsInteger>(this);
-      C.getLVal().print(Out);
+    case nonloc::LocAsIntegerKind: {
+      const nonloc::LocAsInteger& C = *cast<nonloc::LocAsInteger>(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<lval::ConcreteInt>(this)->getValue().getZExtValue()
-          << " (LVal)";
+    case loc::ConcreteIntKind:
+      Out << cast<loc::ConcreteInt>(this)->getValue().getZExtValue()
+          << " (Loc)";
       break;
       
-    case lval::SymbolValKind:
-      Out << '$' << cast<lval::SymbolVal>(this)->getSymbol();
+    case loc::SymbolValKind:
+      Out << '$' << cast<loc::SymbolVal>(this)->getSymbol();
       break;
       
-    case lval::GotoLabelKind:
+    case loc::GotoLabelKind:
       Out << "&&"
-          << cast<lval::GotoLabel>(this)->getLabel()->getID()->getName();
+          << cast<loc::GotoLabel>(this)->getLabel()->getID()->getName();
       break;
 
-    case lval::MemRegionKind:
-      Out << '&' << cast<lval::MemRegionVal>(this)->getRegion()->getString();
+    case loc::MemRegionKind:
+      Out << '&' << cast<loc::MemRegionVal>(this)->getRegion()->getString();
       break;
       
-    case lval::FuncValKind:
+    case loc::FuncValKind:
       Out << "function " 
-          << cast<lval::FuncVal>(this)->getDecl()->getIdentifier()->getName();
+          << cast<loc::FuncVal>(this)->getDecl()->getIdentifier()->getName();
       break;
       
-    case lval::StringLiteralValKind:
+    case loc::StringLiteralValKind:
       Out << "literal \""
-          << cast<lval::StringLiteralVal>(this)->getLiteral()->getStrData()
+          << cast<loc::StringLiteralVal>(this)->getLiteral()->getStrData()
           << "\"";
       break;
       
     default:
-      assert (false && "Pretty-printing not implemented for this LVal.");
+      assert (false && "Pretty-printing not implemented for this Loc.");
       break;
   }
 }

Modified: cfe/trunk/lib/Analysis/RegionStore.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/RegionStore.cpp?rev=57671&r1=57670&r2=57671&view=diff

==============================================================================
--- cfe/trunk/lib/Analysis/RegionStore.cpp (original)
+++ cfe/trunk/lib/Analysis/RegionStore.cpp Fri Oct 17 00:57:07 2008
@@ -23,7 +23,7 @@
 
 using namespace clang;
 
-typedef llvm::ImmutableMap<const MemRegion*, RVal> RegionBindingsTy;
+typedef llvm::ImmutableMap<const MemRegion*, SVal> RegionBindingsTy;
 
 namespace {
 
@@ -38,7 +38,7 @@
 
   virtual ~RegionStoreManager() {}
 
-  Store SetRVal(Store St, LVal LV, RVal V);
+  Store SetSVal(Store St, Loc LV, SVal V);
 
   Store getInitialStore();
 
@@ -49,10 +49,10 @@
 
 } // 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<lval::MemRegionVal>(LV).getRegion();
+  MemRegion* R = cast<loc::MemRegionVal>(LV).getRegion();
   
   if (!R)
     return store;
@@ -79,16 +79,16 @@
 
       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<ParmVarDecl>(VD) ||
+        SVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
                   isa<ImplicitParamDecl>(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);
       }
     }
   }





More information about the cfe-commits mailing list