From: Zhongxing Xu Date: Thu, 4 Feb 2010 02:39:47 +0000 (+0000) Subject: Now that CastRetrievedVal returns SVal, there is no need to use CastResult. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=c999ed792900026c462027e546d63c3f39310755;p=clang 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 947db6e46c..06123fa843 100644 --- 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 08d974b72c..abfa4eea7f 100644 --- 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 0c95940e03..5de9573805 100644 --- 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(loc)) - return SValuator::CastResult(state, UnknownVal()); + return UnknownVal(); assert(!isa(loc)); @@ -264,7 +261,7 @@ SValuator::CastResult BasicStoreManager::Retrieve(const GRState *state, const MemRegion* R = cast(loc).getRegion(); if (!(isa(R) || isa(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(R), T)); + return CastRetrievedVal(*Val, cast(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 ceb9870107..99afbb8931 100644 --- 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 d829199d35..c882904aae 100644 --- 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(L) && "location unknown"); assert(!isa(L) && "location undefined"); // FIXME: Is this even possible? Shouldn't this be treated as a null // dereference at a higher level? if (isa(L)) - return SValuator::CastResult(state, UndefinedVal()); + return UndefinedVal(); const MemRegion *MR = cast(L).getRegion(); @@ -1118,13 +1113,13 @@ RegionStoreManager::Retrieve(const GRState *state, Loc L, QualType T) { // read(p); // c = *p; if (isa(MR)) - return SValuator::CastResult(state, UnknownVal()); + return UnknownVal(); if (const SymbolicRegion *SR = dyn_cast(MR)) MR = GetElementZeroRegion(SR, T); if (isa(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(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(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(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(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