StoreManager::Retrieve and StoreManager::RemoveDeadBindings now take a GRState* argument instead of a Store. This allows them to use the GDM for storing other data.

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

5 files changed, 53 insertions, 47 deletions

diff --git a/include/clang/Analysis/PathSensitive/GRState.h b/include/clang/Analysis/PathSensitive/GRState.h
index 0e72742e63..6efafd6f0c 100644
--- a/include/clang/Analysis/PathSensitive/GRState.h
+++ b/include/clang/Analysis/PathSensitive/GRState.h
@@ -346,8 +346,8 @@ public:
                                      const CompoundLiteralExpr* CL, SVal V);
 
   const GRState* RemoveDeadBindings(const GRState* St, Stmt* Loc, 
-                                       const LiveVariables& Liveness,
-                                       DeadSymbolsTy& DeadSyms);
+                                    const LiveVariables& Liveness,
+                                    DeadSymbolsTy& DeadSyms);
 
   const GRState* RemoveSubExprBindings(const GRState* St) {
     GRState NewSt = *St;
@@ -459,12 +459,12 @@ public:
   }
     
   
-  SVal GetSVal(const GRState* St, Loc LV, QualType T = QualType()) {
-    return StoreMgr->Retrieve(St->getStore(), LV, T);
+  SVal GetSVal(const GRState* state, Loc LV, QualType T = QualType()) {
+    return StoreMgr->Retrieve(state, LV, T);
   }
   
-  SVal GetSVal(const GRState* St, const MemRegion* R) {
-    return StoreMgr->GetRegionSVal(St->getStore(), R);
+  SVal GetSVal(const GRState* state, const MemRegion* R) {
+    return StoreMgr->GetRegionSVal(state, R);
   }  
   
   void BindLoc(GRState& St, Loc LV, SVal V) {
diff --git a/include/clang/Analysis/PathSensitive/Store.h b/include/clang/Analysis/PathSensitive/Store.h
index b067fba812..a272f05867 100644
--- a/include/clang/Analysis/PathSensitive/Store.h
+++ b/include/clang/Analysis/PathSensitive/Store.h
@@ -39,10 +39,15 @@ public:
   typedef llvm::DenseSet<SymbolID>          DeadSymbolsTy;
   
   virtual ~StoreManager() {}
-  virtual SVal Retrieve(Store St, Loc LV, QualType T = QualType()) = 0;  
-
-  virtual SVal GetRegionSVal(Store St, const MemRegion* R) {
-    return Retrieve(St, loc::MemRegionVal(R));
+  
+  /// Retrieve - Retrieves the value bound to specified location.  The optional
+  ///  QualType information provides a hint to the store indicating the expected
+  ///  type of the returned value.
+  virtual SVal Retrieve(const GRState* state, Loc LV, QualType T=QualType()) =0;  
+
+  /// GetRegionSVal - Retrieves  the value bound to the specified region.
+  SVal GetRegionSVal(const GRState* state, const MemRegion* R) {
+    return Retrieve(state, loc::MemRegionVal(R));
   }
   
   virtual Store Bind(Store St, Loc LV, SVal V) = 0;
@@ -90,7 +95,7 @@ public:
   virtual const MemRegion* getSelfRegion(Store store) = 0;
 
   virtual Store
-  RemoveDeadBindings(Store store, Stmt* Loc, const LiveVariables& Live,
+  RemoveDeadBindings(const GRState* state, Stmt* Loc, const LiveVariables& Live,
                      llvm::SmallVectorImpl<const MemRegion*>& RegionRoots,
                      LiveSymbolsTy& LSymbols, DeadSymbolsTy& DSymbols) = 0;
 
diff --git a/lib/Analysis/BasicStore.cpp b/lib/Analysis/BasicStore.cpp
index 963254ed5c..c3146cba40 100644
--- a/lib/Analysis/BasicStore.cpp
+++ b/lib/Analysis/BasicStore.cpp
@@ -38,7 +38,7 @@ public:
   
   ~BasicStoreManager() {}
 
-  SVal Retrieve(Store St, Loc LV, QualType T);  
+  SVal Retrieve(const GRState *state, Loc LV, QualType T);  
   Store Bind(Store St, Loc LV, SVal V);  
   Store Remove(Store St, Loc LV);
   Store getInitialStore();
@@ -79,10 +79,11 @@ public:
     return SelfRegion;  
   }
     
-  /// RemoveDeadBindings - Scans a BasicStore for dead values.  It returns
-  ///  a new Store with these values removed, and populates LSymbols and
-  ///  DSymbols with the known set of live and dead symbols respectively.
-  Store RemoveDeadBindings(Store store, Stmt* Loc, const LiveVariables& Live,
+  /// RemoveDeadBindings - Scans a BasicStore of 'state' for dead values.
+  ///  It returns a new Store with these values removed, and populates LSymbols
+  ///  and DSymbols with the known set of live and dead symbols respectively.
+  Store RemoveDeadBindings(const GRState* state, Stmt* Loc,
+                           const LiveVariables& Live,
                            llvm::SmallVectorImpl<const MemRegion*>& RegionRoots,
                            LiveSymbolsTy& LSymbols, DeadSymbolsTy& DSymbols);
 
@@ -168,7 +169,7 @@ SVal BasicStoreManager::getLValueElement(const GRState* St, SVal Base,
   return Base;
 }
 
-SVal BasicStoreManager::Retrieve(Store St, Loc LV, QualType T) {
+SVal BasicStoreManager::Retrieve(const GRState* state, Loc LV, QualType T) {
   
   if (isa<UnknownVal>(LV))
     return UnknownVal();
@@ -183,8 +184,9 @@ SVal BasicStoreManager::Retrieve(Store St, Loc LV, QualType T) {
       
       if (!R)
         return UnknownVal();
-        
-      VarBindingsTy B(static_cast<const VarBindingsTy::TreeTy*>(St));      
+      
+      Store store = state->getStore();
+      VarBindingsTy B(static_cast<const VarBindingsTy::TreeTy*>(store));
       VarBindingsTy::data_type* T = B.lookup(R->getDecl());      
       return T ? *T : UnknownVal();
     }
@@ -247,11 +249,12 @@ Store BasicStoreManager::Remove(Store store, Loc LV) {
 }
 
 Store
-BasicStoreManager::RemoveDeadBindings(Store store, Stmt* Loc,
+BasicStoreManager::RemoveDeadBindings(const GRState* state, Stmt* Loc,
                           const LiveVariables& Liveness,
                           llvm::SmallVectorImpl<const MemRegion*>& RegionRoots,
                           LiveSymbolsTy& LSymbols, DeadSymbolsTy& DSymbols) {
   
+  Store store = state->getStore();
   VarBindingsTy B = GetVarBindings(store);
   typedef SVal::symbol_iterator symbol_iterator;
   
@@ -282,7 +285,7 @@ BasicStoreManager::RemoveDeadBindings(Store store, Stmt* Loc,
           break;
         
         Marked.insert(R);
-        SVal X = GetRegionSVal(store, R);      
+        SVal X = GetRegionSVal(state, R);      
     
         // FIXME: We need to handle symbols nested in region definitions.
         for (symbol_iterator SI=X.symbol_begin(), SE=X.symbol_end(); SI!=SE; ++SI)
diff --git a/lib/Analysis/GRState.cpp b/lib/Analysis/GRState.cpp
index dd296e0676..83ab508117 100644
--- a/lib/Analysis/GRState.cpp
+++ b/lib/Analysis/GRState.cpp
@@ -33,7 +33,7 @@ GRStateManager::~GRStateManager() {
 }
 
 const GRState*
-GRStateManager::RemoveDeadBindings(const GRState* St, Stmt* Loc,
+GRStateManager::RemoveDeadBindings(const GRState* state, Stmt* Loc,
                                    const LiveVariables& Liveness,
                                    DeadSymbolsTy& DSymbols) {  
   
@@ -45,17 +45,17 @@ GRStateManager::RemoveDeadBindings(const GRState* St, Stmt* Loc,
   // for optimum performance.
   llvm::SmallVector<const MemRegion*, 10> RegionRoots;
   StoreManager::LiveSymbolsTy LSymbols;
-  GRState NewSt = *St;
+  GRState NewState = *state;
 
-  NewSt.Env =
-    EnvMgr.RemoveDeadBindings(NewSt.Env, Loc, Liveness, RegionRoots, LSymbols);
+  NewState.Env = EnvMgr.RemoveDeadBindings(NewState.Env, Loc, Liveness,
+                                           RegionRoots, LSymbols);
 
   // Clean up the store.
   DSymbols.clear();
-  NewSt.St = StoreMgr->RemoveDeadBindings(St->getStore(), Loc, Liveness,
-                                       RegionRoots, LSymbols, DSymbols);
+  NewState.St = StoreMgr->RemoveDeadBindings(&NewState, Loc, Liveness,
+                                             RegionRoots, LSymbols, DSymbols);
 
-  return ConstraintMgr->RemoveDeadBindings(getPersistentState(NewSt), 
+  return ConstraintMgr->RemoveDeadBindings(getPersistentState(NewState),
                                            LSymbols, DSymbols);
 }
 
diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp
index f2410643fd..07399f41ef 100644
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -53,12 +53,12 @@ template<> struct GRStateTrait<RegionExtentsTy>
 }
 
 // KillSet GDM stuff.
-typedef llvm::ImmutableSet<const MemRegion*> RegionKillSetTy;
-static int RegionKillSetTyIndex = 0;
+typedef llvm::ImmutableSet<const MemRegion*> RegionKills;
+static int RegionKillsIndex = 0;
 namespace clang {
-  template<> struct GRStateTrait<RegionKillSetTy>
-  : public GRStatePartialTrait<RegionKillSetTy> {
-    static void* GDMIndex() { return &RegionKillSetTyIndex; }
+  template<> struct GRStateTrait<RegionKills>
+  : public GRStatePartialTrait<RegionKills> {
+    static void* GDMIndex() { return &RegionKillsIndex; }
   };
 }
 
@@ -82,11 +82,6 @@ public:
   virtual ~RegionStoreManager() {}
 
   MemRegionManager& getRegionManager() { return MRMgr; }
-
-  // FIXME: Is this function necessary?
-  SVal GetRegionSVal(Store St, const MemRegion* R) {
-    return Retrieve(St, loc::MemRegionVal(R));
-  }
   
   Store BindCompoundLiteral(Store store, const CompoundLiteralExpr* CL, SVal V);
 
@@ -109,7 +104,7 @@ public:
   std::pair<const GRState*, SVal>
   CastRegion(const GRState* St, SVal VoidPtr, QualType CastToTy, Stmt* CastE);
 
-  SVal Retrieve(Store S, Loc L, QualType T = QualType());
+  SVal Retrieve(const GRState* state, Loc L, QualType T = QualType());
 
   Store Bind(Store St, Loc LV, SVal V);
 
@@ -128,13 +123,14 @@ public:
     return 0;
   }
   
-  /// RemoveDeadBindings - Scans a RegionStore for dead values.  It returns
-  ///  a new Store with these values removed, and populates LSymbols and
-  ///  DSymbols with the known set of live and dead symbols respectively.
-  Store RemoveDeadBindings(Store store, Stmt* Loc, const LiveVariables& Live,
+  /// RemoveDeadBindings - Scans the RegionStore of 'state' for dead values.
+  ///  It returns a new Store with these values removed, and populates LSymbols
+  //   and DSymbols with the known set of live and dead symbols respectively.
+  Store RemoveDeadBindings(const GRState* state, Stmt* Loc,
+                           const LiveVariables& Live,
                            llvm::SmallVectorImpl<const MemRegion*>& RegionRoots,
                            LiveSymbolsTy& LSymbols, DeadSymbolsTy& DSymbols);
-  
+
   void UpdateLiveSymbols(SVal X, LiveSymbolsTy& LSymbols);
 
   Store BindDecl(Store store, const VarDecl* VD, SVal* InitVal, unsigned Count);
@@ -142,7 +138,7 @@ public:
   const GRState* setExtent(const GRState* St, const MemRegion* R, SVal Extent);
 
   static inline RegionBindingsTy GetRegionBindings(Store store) {
-   return RegionBindingsTy(static_cast<const RegionBindingsTy::TreeTy*>(store));
+    return RegionBindingsTy(static_cast<const RegionBindingsTy::TreeTy*>(store));
   }
 
   void print(Store store, std::ostream& Out, const char* nl, const char *sep);
@@ -393,9 +389,10 @@ RegionStoreManager::CastRegion(const GRState* St, SVal VoidPtr,
   return std::make_pair(St, UnknownVal());
 }
 
-SVal RegionStoreManager::Retrieve(Store S, Loc L, QualType T) {
+SVal RegionStoreManager::Retrieve(const GRState* state, Loc L, QualType T) {
   assert(!isa<UnknownVal>(L) && "location unknown");
   assert(!isa<UndefinedVal>(L) && "location undefined");
+  Store S = state->getStore();
 
   switch (L.getSubKind()) {
   case loc::MemRegionKind: {
@@ -626,11 +623,12 @@ void RegionStoreManager::UpdateLiveSymbols(SVal X, LiveSymbolsTy& LSymbols) {
     LSymbols.insert(*SI);
 }
 
-Store RegionStoreManager::RemoveDeadBindings(Store store, Stmt* Loc, 
+Store RegionStoreManager::RemoveDeadBindings(const GRState* state, Stmt* Loc, 
                                              const LiveVariables& Live,
                            llvm::SmallVectorImpl<const MemRegion*>& RegionRoots,
                            LiveSymbolsTy& LSymbols, DeadSymbolsTy& DSymbols) {
 
+  Store store = state->getStore();
   RegionBindingsTy B = GetRegionBindings(store);
   
   // Lazily constructed backmap from MemRegions to SubRegions.