Revert 68028.

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

3 files changed, 33 insertions, 17 deletions

diff --git a/include/clang/Analysis/PathSensitive/MemRegion.h b/include/clang/Analysis/PathSensitive/MemRegion.h
index 766c0918d1..b54efadd3a 100644
--- a/include/clang/Analysis/PathSensitive/MemRegion.h
+++ b/include/clang/Analysis/PathSensitive/MemRegion.h
@@ -39,10 +39,10 @@ class MemRegionManager;
 class MemRegion : public llvm::FoldingSetNode {
 public:
   enum Kind { MemSpaceRegionKind,
-              SymbolicRegionKind,
               AllocaRegionKind,
               // Typed regions.
               BEG_TYPED_REGIONS,
+               SymbolicRegionKind,
                CompoundLiteralRegionKind,
                StringRegionKind, ElementRegionKind,
                TypedViewRegionKind,
@@ -179,18 +179,21 @@ public:
 ///  either a real region, a NULL pointer, etc.  It essentially is used to
 ///  map the concept of symbolic values into the domain of regions.  Symbolic
 ///  regions do not need to be typed.
-class SymbolicRegion : public SubRegion {
+class SymbolicRegion : public TypedRegion {
 protected:
   const SymbolRef sym;
 
 public:
   SymbolicRegion(const SymbolRef s, const MemRegion* sreg) 
-    : SubRegion(sreg, SymbolicRegionKind), sym(s) {}
+    : TypedRegion(sreg, SymbolicRegionKind), sym(s) {}
     
   SymbolRef getSymbol() const {
     return sym;
   }
 
+  QualType getRValueType(ASTContext& C) const;
+  QualType getLValueType(ASTContext& C) const;
+
   void Profile(llvm::FoldingSetNodeID& ID) const;
 
   static void ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolRef sym);
diff --git a/lib/Analysis/MemRegion.cpp b/lib/Analysis/MemRegion.cpp
index 7c13f0701e..738e8c67d6 100644
--- a/lib/Analysis/MemRegion.cpp
+++ b/lib/Analysis/MemRegion.cpp
@@ -111,6 +111,28 @@ void ElementRegion::Profile(llvm::FoldingSetNodeID& ID) const {
 // getLValueType() and getRValueType()
 //===----------------------------------------------------------------------===//
 
+QualType SymbolicRegion::getRValueType(ASTContext& C) const {
+  // Get the type of the symbol.
+  QualType T = sym->getType(C);
+
+  if (const PointerType* PTy = T->getAsPointerType())
+    return PTy->getPointeeType();
+    
+  if (const BlockPointerType* PTy = T->getAsBlockPointerType())
+    return PTy->getPointeeType();
+
+  // There is no rvalue type of id<...>.
+  if (T->getAsObjCQualifiedIdType())
+    return QualType();
+  
+  assert(Loc::IsLocType(T) && "Non-location type.");
+  return QualType();
+}
+
+QualType SymbolicRegion::getLValueType(ASTContext& C) const {
+  return sym->getType(C);
+}
+
 QualType ElementRegion::getRValueType(ASTContext& C) const {
   // Strip off typedefs from the ArrayRegion's RvalueType.
   QualType T = getArrayRegion()->getRValueType(C)->getDesugaredType();
diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp
index 0b2d99b29b..60948062f6 100644
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -362,13 +362,9 @@ SVal RegionStoreManager::getLValueFieldOrIvar(const GRState* St, SVal Base,
     BaseR = cast<loc::MemRegionVal>(BaseL).getRegion();
     break;
 
-  case loc::SymbolValKind: {
-    SymbolRef Sym = cast<loc::SymbolVal>(&BaseL)->getSymbol();
-    const SymbolicRegion* SR = MRMgr.getSymbolicRegion(Sym);
-    // Layer the type information.
-    BaseR = MRMgr.getTypedViewRegion(Sym->getType(getContext()), SR);
+  case loc::SymbolValKind:
+    BaseR = MRMgr.getSymbolicRegion(cast<loc::SymbolVal>(&BaseL)->getSymbol());
     break;
-  }
   
   case loc::GotoLabelKind:
   case loc::FuncValKind:
@@ -411,14 +407,9 @@ SVal RegionStoreManager::getLValueElement(const GRState* St,
 
   const TypedRegion* BaseRegion = 0;
 
-  if (isa<loc::SymbolVal>(Base)) {
-    SymbolRef Sym = cast<loc::SymbolVal>(Base).getSymbol();
-    SymbolicRegion* SR = MRMgr.getSymbolicRegion(Sym);
-    // Layer the type information.
-    BaseRegion = MRMgr.getTypedViewRegion(Sym->getType(getContext()), SR);
-  } 
-  else
-    BaseRegion = cast<TypedRegion>(cast<loc::MemRegionVal>(Base).getRegion());
+  BaseRegion = isa<loc::SymbolVal>(Base)
+               ? MRMgr.getSymbolicRegion(cast<loc::SymbolVal>(Base).getSymbol())
+               : cast<TypedRegion>(cast<loc::MemRegionVal>(Base).getRegion());
 
   // Pointer of any type can be cast and used as array base.
   const ElementRegion *ElemR = dyn_cast<ElementRegion>(BaseRegion);