Now that CastRetrievedVal returns SVal, there is no need to use CastResult.

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

diff --git a/include/clang/Checker/PathSensitive/GRState.h b/include/clang/Checker/PathSensitive/GRState.h
index 947db6e46c50f3409f464340c388f50fd361efb1..06123fa843ae36560c5ca832d24471cfa67db562 100644 (file)
--- a/include/clang/Checker/PathSensitive/GRState.h
+++ b/include/clang/Checker/PathSensitive/GRState.h
@@ -671,11 +671,11 @@ inline SVal GRState::getSValAsScalarOrLoc(const Stmt *S) const {
 }
 
 inline SVal GRState::getSVal(Loc LV, QualType T) const {
-  return getStateManager().StoreMgr->Retrieve(this, LV, T).getSVal();
+  return getStateManager().StoreMgr->Retrieve(this, LV, T);
 }
 
 inline SVal GRState::getSVal(const MemRegion* R) const {
-  return getStateManager().StoreMgr->Retrieve(this, loc::MemRegionVal(R)).getSVal();
+  return getStateManager().StoreMgr->Retrieve(this, loc::MemRegionVal(R));
 }
 
 inline BasicValueFactory &GRState::getBasicVals() const {

diff --git a/include/clang/Checker/PathSensitive/Store.h b/include/clang/Checker/PathSensitive/Store.h
index 08d974b72cc78c32061a7649de81f0e65fc62429..abfa4eea7fd8bcfce56d3d722f35aea496931ea3 100644 (file)
--- a/include/clang/Checker/PathSensitive/Store.h
+++ b/include/clang/Checker/PathSensitive/Store.h
@@ -54,8 +54,8 @@ public:
   ///   expected type of the returned value.  This is used if the value is
   ///   lazily computed.
   /// \return The value bound to the location \c loc.
-  virtual SValuator::CastResult Retrieve(const GRState *state, Loc loc,
-                                         QualType T = QualType()) = 0;
+  virtual SVal Retrieve(const GRState *state, Loc loc, QualType T = QualType())
+                                                                            = 0;
 
   /// Return a state with the specified value bound to the given location.
   /// \param[in] state The analysis state.

diff --git a/lib/Checker/BasicStore.cpp b/lib/Checker/BasicStore.cpp
index 0c95940e0319c6ee1eb2185787c58910ac2d1283..5de9573805ded24f84693e77bee979accfea5cf3 100644 (file)
--- a/lib/Checker/BasicStore.cpp
+++ b/lib/Checker/BasicStore.cpp
@@ -44,8 +44,7 @@ public:
     return new BasicStoreSubRegionMap();
   }
 
-  SValuator::CastResult Retrieve(const GRState *state, Loc loc,
-                                 QualType T = QualType());
+  SVal Retrieve(const GRState *state, Loc loc, QualType T = QualType());
 
   const GRState *InvalidateRegion(const GRState *state, const MemRegion *R,
                                   const Expr *E, unsigned Count,
@@ -250,11 +249,9 @@ static bool isHigherOrderRawPtr(QualType T, ASTContext &C) {
   }
 }
 
-SValuator::CastResult BasicStoreManager::Retrieve(const GRState *state,
-                                                  Loc loc, QualType T) {
-
+SVal BasicStoreManager::Retrieve(const GRState *state, Loc loc, QualType T) {
   if (isa<UnknownVal>(loc))
-    return SValuator::CastResult(state, UnknownVal());
+    return UnknownVal();
 
   assert(!isa<UndefinedVal>(loc));
 
@@ -264,7 +261,7 @@ SValuator::CastResult BasicStoreManager::Retrieve(const GRState *state,
       const MemRegion* R = cast<loc::MemRegionVal>(loc).getRegion();
 
       if (!(isa<VarRegion>(R) || isa<ObjCIvarRegion>(R)))
-        return SValuator::CastResult(state, UnknownVal());
+        return UnknownVal();
 
       BindingsTy B = GetBindings(state->getStore());
       BindingsTy::data_type *Val = B.lookup(R);
@@ -272,22 +269,21 @@ SValuator::CastResult BasicStoreManager::Retrieve(const GRState *state,
       if (!Val)
         break;
 
-      return SValuator::CastResult(state,
-                              CastRetrievedVal(*Val, cast<TypedRegion>(R), T));
+      return CastRetrievedVal(*Val, cast<TypedRegion>(R), T);
     }
 
     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 SValuator::CastResult(state, UndefinedVal());
+      return UndefinedVal();
 
     default:
       assert (false && "Invalid Loc.");
       break;
   }
 
-  return SValuator::CastResult(state, UnknownVal());
+  return UnknownVal();
 }
 
 Store BasicStoreManager::BindInternal(Store store, Loc loc, SVal V) {
@@ -398,7 +394,7 @@ BasicStoreManager::RemoveDeadBindings(GRState &state, Stmt* Loc,
           break;
 
         Marked.insert(MR);
-        SVal X = Retrieve(&state, loc::MemRegionVal(MR)).getSVal();
+        SVal X = Retrieve(&state, loc::MemRegionVal(MR));
 
         // 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/Checker/FlatStore.cpp b/lib/Checker/FlatStore.cpp
index ceb9870107154d205d51e9772b4208db5e790211..99afbb8931b4cd20dbd0aa57fc8b7f974919131d 100644 (file)
--- a/lib/Checker/FlatStore.cpp
+++ b/lib/Checker/FlatStore.cpp
@@ -27,7 +27,7 @@ public:
       RBFactory(mgr.getAllocator()), 
       BVFactory(mgr.getAllocator()) {}
 
-  SValuator::CastResult Retrieve(const GRState *state, Loc loc, QualType T);
+  SVal Retrieve(const GRState *state, Loc loc, QualType T);
   const GRState *Bind(const GRState *state, Loc loc, SVal val);
   Store Remove(Store St, Loc L);
   const GRState *BindCompoundLiteral(const GRState *state,
@@ -73,9 +73,8 @@ StoreManager *clang::CreateFlatStoreManager(GRStateManager &StMgr) {
   return new FlatStoreManager(StMgr);
 }
 
-SValuator::CastResult FlatStoreManager::Retrieve(const GRState *state, Loc loc,
-                                                 QualType T) {
-  return SValuator::CastResult(state, UnknownVal());
+SVal FlatStoreManager::Retrieve(const GRState *state, Loc loc, QualType T) {
+  return UnknownVal();
 }
 
 const GRState *FlatStoreManager::Bind(const GRState *state, Loc loc, SVal val) {

diff --git a/lib/Checker/RegionStore.cpp b/lib/Checker/RegionStore.cpp
index d829199d3523ad376913c3a9772776a14c53b8f9..c882904aae9b674ab7d92b48cf0b6d916c52fefb 100644 (file)
--- a/lib/Checker/RegionStore.cpp
+++ b/lib/Checker/RegionStore.cpp
@@ -355,8 +355,7 @@ public: // Part of public interface to class.
   ///       return undefined
   ///     else
   ///       return symbolic
-  SValuator::CastResult Retrieve(const GRState *state, Loc L,
-                                 QualType T = QualType());
+  SVal Retrieve(const GRState *state, Loc L, QualType T = QualType());
 
   SVal RetrieveElement(const GRState *state, const ElementRegion *R);
 
@@ -1095,19 +1094,15 @@ RegionStoreManager::GetElementZeroRegion(const SymbolicRegion *SR, QualType T) {
   assert(!T.isNull());
   return MRMgr.getElementRegion(T, idx, SR, Ctx);
 }
-  
-  
-
-SValuator::CastResult
-RegionStoreManager::Retrieve(const GRState *state, 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");
   
   // FIXME: Is this even possible?  Shouldn't this be treated as a null
   //  dereference at a higher level?
   if (isa<loc::ConcreteInt>(L))
-    return SValuator::CastResult(state, UndefinedVal());
+    return UndefinedVal();
   
   const MemRegion *MR = cast<loc::MemRegionVal>(L).getRegion();
 
@@ -1118,13 +1113,13 @@ RegionStoreManager::Retrieve(const GRState *state, Loc L, QualType T) {
   // read(p);
   // c = *p;
   if (isa<AllocaRegion>(MR))
-    return SValuator::CastResult(state, UnknownVal());
+    return UnknownVal();
 
   if (const SymbolicRegion *SR = dyn_cast<SymbolicRegion>(MR))
     MR = GetElementZeroRegion(SR, T);
 
   if (isa<CodeTextRegion>(MR))
-    return SValuator::CastResult(state, UnknownVal());
+    return UnknownVal();
 
   // FIXME: Perhaps this method should just take a 'const MemRegion*' argument
   //  instead of 'Loc', and have the other Loc cases handled at a higher level.
@@ -1152,23 +1147,21 @@ RegionStoreManager::Retrieve(const GRState *state, Loc L, QualType T) {
 #endif
 
   if (RTy->isStructureType())
-    return SValuator::CastResult(state, RetrieveStruct(state, R));
+    return RetrieveStruct(state, R);
 
   // FIXME: Handle unions.
   if (RTy->isUnionType())
-    return SValuator::CastResult(state, UnknownVal());
+    return UnknownVal();
 
   if (RTy->isArrayType())
-    return SValuator::CastResult(state, RetrieveArray(state, R));
+    return RetrieveArray(state, R);
 
   // FIXME: handle Vector types.
   if (RTy->isVectorType())
-    return SValuator::CastResult(state, UnknownVal());
+    return UnknownVal();
 
   if (const FieldRegion* FR = dyn_cast<FieldRegion>(R))
-    return SValuator::CastResult(state, 
-                                 CastRetrievedVal(RetrieveField(state, FR), FR,
-                                                  T, false));
+    return CastRetrievedVal(RetrieveField(state, FR), FR, T, false);
 
   if (const ElementRegion* ER = dyn_cast<ElementRegion>(R)) {
     // FIXME: Here we actually perform an implicit conversion from the loaded
@@ -1176,9 +1169,7 @@ RegionStoreManager::Retrieve(const GRState *state, Loc L, QualType T) {
     // more intelligently.  For example, an 'element' can encompass multiple
     // bound regions (e.g., several bound bytes), or could be a subset of
     // a larger value.
-    return SValuator::CastResult(state,
-                                 CastRetrievedVal(RetrieveElement(state, ER),
-                                                  ER, T, false));
+    return CastRetrievedVal(RetrieveElement(state, ER), ER, T, false);
   }    
 
   if (const ObjCIvarRegion *IVR = dyn_cast<ObjCIvarRegion>(R)) {
@@ -1188,9 +1179,7 @@ RegionStoreManager::Retrieve(const GRState *state, Loc L, QualType T) {
     // reinterpretted, it is possible we stored a different value that could
     // fit within the ivar.  Either we need to cast these when storing them
     // or reinterpret them lazily (as we do here).
-    return SValuator::CastResult(state,
-                                 CastRetrievedVal(RetrieveObjCIvar(state, IVR),
-                                                  IVR, T, false));
+    return CastRetrievedVal(RetrieveObjCIvar(state, IVR), IVR, T, false);
   }
 
   if (const VarRegion *VR = dyn_cast<VarRegion>(R)) {
@@ -1200,9 +1189,7 @@ RegionStoreManager::Retrieve(const GRState *state, Loc L, QualType T) {
     // variable is reinterpretted, it is possible we stored a different value
     // that could fit within the variable.  Either we need to cast these when
     // storing them or reinterpret them lazily (as we do here).    
-    return SValuator::CastResult(state,
-                                 CastRetrievedVal(RetrieveVar(state, VR), VR, T,
-                                                  false));
+    return CastRetrievedVal(RetrieveVar(state, VR), VR, T, false);
   }
 
   RegionBindings B = GetRegionBindings(state->getStore());
@@ -1210,7 +1197,7 @@ RegionStoreManager::Retrieve(const GRState *state, Loc L, QualType T) {
 
   // Check if the region has a binding.
   if (V)
-      return SValuator::CastResult(state, *V);
+    return *V;
 
   // The location does not have a bound value.  This means that it has
   // the value it had upon its creation and/or entry to the analyzed
@@ -1220,11 +1207,11 @@ RegionStoreManager::Retrieve(const GRState *state, Loc L, QualType T) {
     // upon creation.  All heap allocated blocks are considered to
     // have undefined values as well unless they are explicitly bound
     // to specific values.
-    return SValuator::CastResult(state, UndefinedVal());
+    return UndefinedVal();
   }
 
   // All other values are symbolic.
-  return SValuator::CastResult(state, ValMgr.getRegionValueSymbolVal(R, RTy));
+  return ValMgr.getRegionValueSymbolVal(R, RTy);
 }
 
 std::pair<const GRState*, const MemRegion*>