Refactor 'BasicStoreManager::CastRegion' and 'RegionStoreManager::CastRegion'

into StoreManager::CastRegion. Both methods were practically identical, and this
is core logic that is common to all StoreManagers since it defines the basic
invariants of the abstract memory model.

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

diff --git a/include/clang/Analysis/PathSensitive/Store.h b/include/clang/Analysis/PathSensitive/Store.h
index 9d41de7bd5b6fa9ab2d7d86a8fdb5b2095fc5af1..f6ad582cb801bb6f486138576b9c43b8c7e262f2 100644 (file)
--- a/include/clang/Analysis/PathSensitive/Store.h
+++ b/include/clang/Analysis/PathSensitive/Store.h
@@ -37,13 +37,20 @@ class SubRegionMap;
 class StoreManager {
 protected:
   ValueManager &ValMgr;
+  GRStateManager &StateMgr;
 
   /// MRMgr - Manages region objects associated with this StoreManager.
   MemRegionManager &MRMgr;
 
-  StoreManager(ValueManager &valMgr)
-    : ValMgr(valMgr), MRMgr(ValMgr.getRegionManager()) {}
+  StoreManager(GRStateManager &stateMgr);
 
+protected:
+  virtual const GRState* AddRegionView(const GRState* St,
+                                       const MemRegion* View,
+                                       const MemRegion* Base) {
+    return St;
+  }
+  
 public:  
   virtual ~StoreManager() {}
   
@@ -125,8 +132,8 @@ public:
   /// CastRegion - Used by GRExprEngine::VisitCast to handle casts from
   ///  a MemRegion* to a specific location type.  'R' is the region being
   ///  casted and 'CastToTy' the result type of the cast.
-  virtual CastResult CastRegion(const GRState* state, const MemRegion* R,
-                                QualType CastToTy) = 0;
+  CastResult CastRegion(const GRState* state, const MemRegion* R,
+                        QualType CastToTy);
 
   /// EvalBinOp - Perform pointer arithmetic.
   virtual SVal EvalBinOp(BinaryOperator::Opcode Op, Loc L, NonLoc R) {

diff --git a/lib/Analysis/BasicStore.cpp b/lib/Analysis/BasicStore.cpp
index cf8d3176c45b59593865f5e77b57b8ab9c8fe99a..616c4b51350ab9ce7e8dcacc09b68fa7610ed5cb 100644 (file)
--- a/lib/Analysis/BasicStore.cpp
+++ b/lib/Analysis/BasicStore.cpp
@@ -35,14 +35,12 @@ public:
   
 class VISIBILITY_HIDDEN BasicStoreManager : public StoreManager {
   BindingsTy::Factory VBFactory;
-  GRStateManager& StateMgr;
   const MemRegion* SelfRegion;
   
 public:
   BasicStoreManager(GRStateManager& mgr)
-    : StoreManager(mgr.getValueManager()),
+    : StoreManager(mgr),
       VBFactory(mgr.getAllocator()), 
-      StateMgr(mgr), 
       SelfRegion(0) {}
   
   ~BasicStoreManager() {}
@@ -87,12 +85,6 @@ public:
   ///  conversions between arrays and pointers.
   SVal ArrayToPointer(Loc Array) { return Array; }
 
-  /// CastRegion - Used by GRExprEngine::VisitCast to handle casts from
-  ///  a MemRegion* to a specific location type.  'R' is the region being
-  ///  casted and 'CastToTy' the result type of the cast.
-  CastResult CastRegion(const GRState* state, const MemRegion* R,
-                        QualType CastToTy);
-  
   /// getSelfRegion - Returns the region for the 'self' (Objective-C) or
   ///  'this' object (C++).  When used when analyzing a normal function this
   ///  method returns NULL.
@@ -168,27 +160,7 @@ SVal BasicStoreManager::getLValueIvar(const GRState* St, const ObjCIvarDecl* D,
   
   return UnknownVal();
 }
-  
-/// CastRegion - Used by GRExprEngine::VisitCast to handle casts from
-///  a MemRegion* to a specific location type.  'R' is the region being
-///  casted and 'CastToTy' the result type of the cast.
-StoreManager::CastResult
-BasicStoreManager::CastRegion(const GRState* state, const MemRegion* R,
-                              QualType CastToTy) {
-
-  // Return the same region if the region types are compatible.
-  if (const TypedRegion* TR = dyn_cast<TypedRegion>(R)) {
-    ASTContext& Ctx = StateMgr.getContext();
-    QualType Ta = Ctx.getCanonicalType(TR->getLValueType(Ctx));
-    QualType Tb = Ctx.getCanonicalType(CastToTy);
-    
-    if (Ta == Tb)
-      return CastResult(state, R);
-  }
 
-  return CastResult(state, MRMgr.getTypedViewRegion(CastToTy, R));
-}
-  
 SVal BasicStoreManager::getLValueField(const GRState* St, SVal Base,
                                        const FieldDecl* D) {
 

diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp
index 40f7c481317a40e28bdbec146c137869779cd000..7a78036ec06fa68e1346699b62994afd6cdf9140 100644 (file)
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -142,16 +142,15 @@ class VISIBILITY_HIDDEN RegionStoreManager : public StoreManager {
   RegionBindingsTy::Factory RBFactory;
   RegionViews::Factory RVFactory;
 
-  GRStateManager& StateMgr;
   const MemRegion* SelfRegion;
   const ImplicitParamDecl *SelfDecl;
 
 public:
   RegionStoreManager(GRStateManager& mgr) 
-    : StoreManager(mgr.getValueManager()),
+    : StoreManager(mgr),
       RBFactory(mgr.getAllocator()),
       RVFactory(mgr.getAllocator()),
-      StateMgr(mgr), SelfRegion(0), SelfDecl(0) {
+      SelfRegion(0), SelfDecl(0) {
     if (const ObjCMethodDecl* MD =
           dyn_cast<ObjCMethodDecl>(&StateMgr.getCodeDecl()))
       SelfDecl = MD->getSelfDecl();
@@ -199,12 +198,6 @@ public:
   ///  casts from arrays to pointers.
   SVal ArrayToPointer(Loc Array);
 
-  /// CastRegion - Used by GRExprEngine::VisitCast to handle casts from
-  ///  a MemRegion* to a specific location type.  'R' is the region being
-  ///  casted and 'CastToTy' the result type of the cast.  
-  CastResult CastRegion(const GRState* state, const MemRegion* R,
-                        QualType CastToTy);
-
   SVal EvalBinOp(BinaryOperator::Opcode Op, Loc L, NonLoc R);
 
   /// The high level logic for this method is this:
@@ -579,31 +572,6 @@ SVal RegionStoreManager::ArrayToPointer(Loc Array) {
   return loc::MemRegionVal(ER);                    
 }
 
-StoreManager::CastResult
-RegionStoreManager::CastRegion(const GRState* state, const MemRegion* R,
-                               QualType CastToTy) {
-  
-  // Return the same region if the region types are compatible.
-  if (const TypedRegion* TR = dyn_cast<TypedRegion>(R)) {
-    ASTContext& Ctx = StateMgr.getContext();
-    QualType Ta = Ctx.getCanonicalType(TR->getLValueType(Ctx));
-    QualType Tb = Ctx.getCanonicalType(CastToTy);
-    
-    if (Ta == Tb)
-      return CastResult(state, R);
-  }
-
-  // FIXME: We should handle the case when we are casting *back* to a
-  // previous type. For example:
-  //
-  //      void* x = ...;
-  //      char* y = (char*) x;
-  //      void* z = (void*) y; // <-- we should get the same region that is 
-  //                                  bound to 'x'
-  const MemRegion* ViewR = MRMgr.getTypedViewRegion(CastToTy, R);  
-  return CastResult(AddRegionView(state, ViewR, R), ViewR);
-}
-
 SVal RegionStoreManager::EvalBinOp(BinaryOperator::Opcode Op, Loc L, NonLoc R) {
   // Assume the base location is MemRegionVal(ElementRegion).
   if (!isa<loc::MemRegionVal>(L))

diff --git a/lib/Analysis/Store.cpp b/lib/Analysis/Store.cpp
new file mode 100644 (file)
index 0000000..edd353d
--- /dev/null
+++ b/lib/Analysis/Store.cpp
@@ -0,0 +1,47 @@
+//== Store.cpp - Interface for maps from Locations to Values ----*- C++ -*--==//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defined the types Store and StoreManager.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Analysis/PathSensitive/Store.h"
+#include "clang/Analysis/PathSensitive/GRState.h"
+
+using namespace clang;
+
+StoreManager::StoreManager(GRStateManager &stateMgr)
+  : ValMgr(stateMgr.getValueManager()),
+    StateMgr(stateMgr),
+    MRMgr(ValMgr.getRegionManager()) {}
+
+StoreManager::CastResult
+StoreManager::CastRegion(const GRState* state, const MemRegion* R,
+                               QualType CastToTy) {
+  
+  // Return the same region if the region types are compatible.
+  if (const TypedRegion* TR = dyn_cast<TypedRegion>(R)) {
+    ASTContext& Ctx = StateMgr.getContext();
+    QualType Ta = Ctx.getCanonicalType(TR->getLValueType(Ctx));
+    QualType Tb = Ctx.getCanonicalType(CastToTy);
+    
+    if (Ta == Tb)
+      return CastResult(state, R);
+  }
+  
+  // FIXME: We should handle the case when we are casting *back* to a
+  // previous type. For example:
+  //
+  //      void* x = ...;
+  //      char* y = (char*) x;
+  //      void* z = (void*) y; // <-- we should get the same region that is 
+  //                                  bound to 'x'
+  const MemRegion* ViewR = MRMgr.getTypedViewRegion(CastToTy, R);  
+  return CastResult(AddRegionView(state, ViewR, R), ViewR);
+}