maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

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

llvm-svn: 95279
This commit is contained in:
Zhongxing Xu 2010-02-04 02:39:47 +00:00
parent 11ef09f8b5
commit 4f8b9899bb
5 changed files with 31 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
clang/include/clang/Checker/PathSensitive/GRState.h
View File

@ -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 {

4
clang/include/clang/Checker/PathSensitive/Store.h
View File

@ -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.

20
clang/lib/Checker/BasicStore.cpp
View File

@ -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)

7
clang/lib/Checker/FlatStore.cpp
View File

@ -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) {

45
clang/lib/Checker/RegionStore.cpp
View File

@ -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*>