Rename:

  SymbolRegionRValue => SymbolRegionValue
  SymExpr::RegionRValue => SymExpr::RegionValueKind


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@71322 91177308-0d34-0410-b5e6-96231b3b80d8

6 files changed, 27 insertions, 27 deletions

diff --git a/include/clang/Analysis/PathSensitive/SymbolManager.h b/include/clang/Analysis/PathSensitive/SymbolManager.h
index 9bdbd88cae..d424526d4e 100644
--- a/include/clang/Analysis/PathSensitive/SymbolManager.h
+++ b/include/clang/Analysis/PathSensitive/SymbolManager.h
@@ -38,7 +38,7 @@ namespace clang {
   
 class SymExpr : public llvm::FoldingSetNode {
 public:
-  enum Kind { BEGIN_SYMBOLS, RegionRValue, ConjuredKind, END_SYMBOLS,
+  enum Kind { BEGIN_SYMBOLS, RegionValueKind, ConjuredKind, END_SYMBOLS,
               SymIntKind, SymSymKind };
 private:
   Kind K;
@@ -81,16 +81,16 @@ public:
 
 typedef const SymbolData* SymbolRef;
   
-class SymbolRegionRValue : public SymbolData {
+class SymbolRegionValue : public SymbolData {
   const MemRegion *R;
 public:
-  SymbolRegionRValue(SymbolID sym, const MemRegion *r)
-    : SymbolData(RegionRValue, sym), R(r) {}
+  SymbolRegionValue(SymbolID sym, const MemRegion *r)
+    : SymbolData(RegionValueKind, sym), R(r) {}
   
   const MemRegion* getRegion() const { return R; }
 
   static void Profile(llvm::FoldingSetNodeID& profile, const MemRegion* R) {
-    profile.AddInteger((unsigned) RegionRValue);
+    profile.AddInteger((unsigned) RegionValueKind);
     profile.AddPointer(R);
   }
   
@@ -102,7 +102,7 @@ public:
 
   // Implement isa<T> support.
   static inline bool classof(const SymExpr* SE) {
-    return SE->getKind() == RegionRValue;
+    return SE->getKind() == RegionValueKind;
   }
 };
 
@@ -204,7 +204,7 @@ public:
   QualType getType(ASTContext& C) const { return T; }
 
   static void Profile(llvm::FoldingSetNodeID& ID, const SymExpr *lhs,
-                      BinaryOperator::Opcode op, const SymExpr *rhs, QualType t) {
+                    BinaryOperator::Opcode op, const SymExpr *rhs, QualType t) {
     ID.AddInteger((unsigned) SymSymKind);
     ID.AddPointer(lhs);
     ID.AddInteger(op);
@@ -240,7 +240,7 @@ public:
   static bool canSymbolicate(QualType T);
 
   /// Make a unique symbol for MemRegion R according to its kind.
-  const SymbolRegionRValue* getRegionRValueSymbol(const MemRegion* R);
+  const SymbolRegionValue* getRegionValueSymbol(const MemRegion* R);
   const SymbolConjured* getConjuredSymbol(const Stmt* E, QualType T,
                                           unsigned VisitCount,
                                           const void* SymbolTag = 0);
@@ -250,7 +250,7 @@ public:
     return getConjuredSymbol(E, E->getType(), VisitCount, SymbolTag);
   }
 
-  const SymIntExpr *getSymIntExpr(const SymExpr *lhs, BinaryOperator::Opcode op, 
+  const SymIntExpr *getSymIntExpr(const SymExpr *lhs, BinaryOperator::Opcode op,
                                   const llvm::APSInt& rhs, QualType t);
   
   const SymIntExpr *getSymIntExpr(const SymExpr &lhs, BinaryOperator::Opcode op,
diff --git a/include/clang/Analysis/PathSensitive/ValueManager.h b/include/clang/Analysis/PathSensitive/ValueManager.h
index 271d9862e4..89af975de7 100644
--- a/include/clang/Analysis/PathSensitive/ValueManager.h
+++ b/include/clang/Analysis/PathSensitive/ValueManager.h
@@ -80,8 +80,8 @@ public:
   /// elements.
   SVal makeZeroArrayIndex();
 
-  /// GetRValueSymbolVal - make a unique symbol for value of R.
-  SVal getRValueSymbolVal(const MemRegion* R);
+  /// GetRegionValueSymbolVal - make a unique symbol for value of R.
+  SVal getRegionValueSymbolVal(const MemRegion* R);
   
   SVal getConjuredSymbolVal(const Expr *E, unsigned Count);  
   SVal getConjuredSymbolVal(const Expr* E, QualType T, unsigned Count);
diff --git a/lib/Analysis/BasicStore.cpp b/lib/Analysis/BasicStore.cpp
index b9eeb9f8bc..2dd46c3853 100644
--- a/lib/Analysis/BasicStore.cpp
+++ b/lib/Analysis/BasicStore.cpp
@@ -487,7 +487,7 @@ Store BasicStoreManager::scanForIvars(Stmt *B, const Decl* SelfDecl, Store St) {
         if (DR->getDecl() == SelfDecl) {
           const MemRegion *IVR = MRMgr.getObjCIvarRegion(IV->getDecl(),
                                                          SelfRegion);          
-          SVal X = ValMgr.getRValueSymbolVal(IVR);          
+          SVal X = ValMgr.getRegionValueSymbolVal(IVR);          
           St = BindInternal(St, Loc::MakeVal(IVR), X);
         }
       }
@@ -543,7 +543,7 @@ Store BasicStoreManager::getInitialStore() {
       const MemRegion *R = StateMgr.getRegion(VD);
       SVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
                 isa<ImplicitParamDecl>(VD))
-            ? ValMgr.getRValueSymbolVal(R)
+            ? ValMgr.getRegionValueSymbolVal(R)
             : UndefinedVal();
 
       St = BindInternal(St, Loc::MakeVal(R), X);
diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp
index 6e9a1a684d..a23a47ecc8 100644
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -824,7 +824,7 @@ SVal RegionStoreManager::Retrieve(const GRState* St, Loc L, QualType T) {
     if (SR == SelfRegion) {
       // FIXME: Do we need to handle the case where the super region
       // has a view?  We want to canonicalize the bindings.
-      return ValMgr.getRValueSymbolVal(R);
+      return ValMgr.getRegionValueSymbolVal(R);
     }
     
     // Otherwise, we need a new symbol.  For now return Unknown.
@@ -846,7 +846,7 @@ SVal RegionStoreManager::Retrieve(const GRState* St, Loc L, QualType T) {
         VD->hasGlobalStorage()) {
       QualType VTy = VD->getType();
       if (Loc::IsLocType(VTy) || VTy->isIntegerType())
-        return ValMgr.getRValueSymbolVal(VR);
+        return ValMgr.getRegionValueSymbolVal(VR);
       else
         return UnknownVal();
     }
@@ -862,7 +862,7 @@ SVal RegionStoreManager::Retrieve(const GRState* St, Loc L, QualType T) {
 
   // All other integer values are symbolic.
   if (Loc::IsLocType(RTy) || RTy->isIntegerType())
-    return ValMgr.getRValueSymbolVal(R);
+    return ValMgr.getRegionValueSymbolVal(R);
   else
     return UnknownVal();
 }
diff --git a/lib/Analysis/SVals.cpp b/lib/Analysis/SVals.cpp
index 58a0b80aa6..e10ea8952a 100644
--- a/lib/Analysis/SVals.cpp
+++ b/lib/Analysis/SVals.cpp
@@ -297,8 +297,8 @@ NonLoc NonLoc::MakeCompoundVal(QualType T, llvm::ImmutableList<SVal> Vals,
   return nonloc::CompoundVal(BasicVals.getCompoundValData(T, Vals));
 }
 
-SVal ValueManager::getRValueSymbolVal(const MemRegion* R) {
-  SymbolRef sym = SymMgr.getRegionRValueSymbol(R);
+SVal ValueManager::getRegionValueSymbolVal(const MemRegion* R) {
+  SymbolRef sym = SymMgr.getRegionValueSymbol(R);
                                 
   if (const TypedRegion* TR = dyn_cast<TypedRegion>(R)) {
     QualType T = TR->getValueType(SymMgr.getContext());
diff --git a/lib/Analysis/SymbolManager.cpp b/lib/Analysis/SymbolManager.cpp
index 84019fd8d5..5c885cd6e1 100644
--- a/lib/Analysis/SymbolManager.cpp
+++ b/lib/Analysis/SymbolManager.cpp
@@ -65,7 +65,7 @@ static void print(llvm::raw_ostream& os, const SymSymExpr *SE) {
 static void print(llvm::raw_ostream& os, const SymExpr *SE) {
   switch (SE->getKind()) {
     case SymExpr::BEGIN_SYMBOLS:
-    case SymExpr::RegionRValue:
+    case SymExpr::RegionValueKind:
     case SymExpr::ConjuredKind:
     case SymExpr::END_SYMBOLS:
       os << '$' << cast<SymbolData>(SE)->getSymbolID();
@@ -91,20 +91,20 @@ std::ostream& std::operator<<(std::ostream& os, const SymExpr *SE) {
   return os;
 }
 
-const SymbolRegionRValue* 
-SymbolManager::getRegionRValueSymbol(const MemRegion* R) {
+const SymbolRegionValue* 
+SymbolManager::getRegionValueSymbol(const MemRegion* R) {
   llvm::FoldingSetNodeID profile;
-  SymbolRegionRValue::Profile(profile, R);
+  SymbolRegionValue::Profile(profile, R);
   void* InsertPos;  
   SymExpr *SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);    
   if (!SD) {  
-    SD = (SymExpr*) BPAlloc.Allocate<SymbolRegionRValue>();
-    new (SD) SymbolRegionRValue(SymbolCounter, R);  
+    SD = (SymExpr*) BPAlloc.Allocate<SymbolRegionValue>();
+    new (SD) SymbolRegionValue(SymbolCounter, R);  
     DataSet.InsertNode(SD, InsertPos);
     ++SymbolCounter;
   }
   
-  return cast<SymbolRegionRValue>(SD);
+  return cast<SymbolRegionValue>(SD);
 }
 
 const SymbolConjured*
@@ -165,7 +165,7 @@ QualType SymbolConjured::getType(ASTContext&) const {
   return T;
 }
 
-QualType SymbolRegionRValue::getType(ASTContext& C) const {
+QualType SymbolRegionValue::getType(ASTContext& C) const {
   if (const TypedRegion* TR = dyn_cast<TypedRegion>(R))
     return TR->getValueType(C);
   
@@ -197,7 +197,7 @@ bool SymbolReaper::isLive(SymbolRef sym) {
   
   // Interogate the symbol.  It may derive from an input value to
   // the analyzed function/method.
-  return isa<SymbolRegionRValue>(sym);
+  return isa<SymbolRegionValue>(sym);
 }
 
 SymbolVisitor::~SymbolVisitor() {}