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

- Move ownership of MemRegionManager into ValueManager. 

- Pull SVal::GetConjuredSymbol() and friends into ValueManager. This greatly
simplifies the calling interface to clients.

llvm-svn: 68731
This commit is contained in:
Ted Kremenek 2009-04-09 22:22:44 +00:00
parent 5eb8d26f19
commit f2489ea043
10 changed files with 49 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
clang/include/clang/Analysis/PathSensitive/GRState.h
View File

@ -310,9 +310,6 @@ public:
Liveness(L) {
StoreMgr.reset((*CreateStoreManager)(*this));
ConstraintMgr.reset((*CreateConstraintManager)(*this));
// FIXME: Have ValueMgr own the MemRegionManager, not StoreManager.
ValueMgr.setRegionManager(StoreMgr->getRegionManager());
}
~GRStateManager();

9
clang/include/clang/Analysis/PathSensitive/SVals.h
View File

@ -72,15 +72,6 @@ public:
return !(*this == R);
}
/// GetRValueSymbolVal - make a unique symbol for value of R.
static SVal GetRValueSymbolVal(SymbolManager& SymMgr, MemRegionManager& MRMgr,
const MemRegion* R);
static SVal GetConjuredSymbolVal(SymbolManager& SymMgr, MemRegionManager&,
const Expr *E, unsigned Count);
static SVal GetConjuredSymbolVal(SymbolManager &SymMgr, MemRegionManager&,
const Expr* E, QualType T, unsigned Count);
inline bool isUnknown() const {
return getRawKind() == UnknownKind;
}

10
clang/include/clang/Analysis/PathSensitive/Store.h
View File

@ -16,6 +16,7 @@
#include "clang/Analysis/PathSensitive/SVals.h"
#include "clang/Analysis/PathSensitive/MemRegion.h"
#include "clang/Analysis/PathSensitive/ValueManager.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/DenseSet.h"
@ -35,10 +36,13 @@ class SubRegionMap;
class StoreManager {
protected:
/// MRMgr - Manages region objects associated with this StoreManager.
MemRegionManager MRMgr;
ValueManager &ValMgr;
StoreManager(llvm::BumpPtrAllocator& Alloc) : MRMgr(Alloc) {}
/// MRMgr - Manages region objects associated with this StoreManager.
MemRegionManager &MRMgr;
StoreManager(ValueManager &valMgr)
: ValMgr(valMgr), MRMgr(ValMgr.getRegionManager()) {}
public:
virtual ~StoreManager() {}

20
clang/include/clang/Analysis/PathSensitive/ValueManager.h
View File

@ -22,11 +22,9 @@
#include "clang/Analysis/PathSensitive/SymbolManager.h"
namespace llvm { class BumpPtrAllocator; }
namespace clang { class GRStateManager; }
namespace clang {
class ValueManager {
friend class GRStateManager;
ASTContext &Context;
BasicValueFactory BasicVals;
@ -34,16 +32,14 @@ class ValueManager {
/// SymMgr - Object that manages the symbol information.
SymbolManager SymMgr;
// FIXME: Eventually ValueManager will own this object.
MemRegionManager *MemMgr;
void setRegionManager(MemRegionManager& mm) { MemMgr = &mm; }
MemRegionManager MemMgr;
public:
ValueManager(llvm::BumpPtrAllocator &alloc, ASTContext &context)
: Context(context), BasicVals(Context, alloc),
SymMgr(Context, BasicVals, alloc),
MemMgr(0) {}
MemMgr(alloc) {}
// Accessors to submanagers.
@ -56,8 +52,8 @@ public:
SymbolManager &getSymbolManager() { return SymMgr; }
const SymbolManager &getSymbolManager() const { return SymMgr; }
MemRegionManager &getRegionManager() { return *MemMgr; }
const MemRegionManager &getRegionManager() const { return *MemMgr; }
MemRegionManager &getRegionManager() { return MemMgr; }
const MemRegionManager &getRegionManager() const { return MemMgr; }
// Forwarding methods to SymbolManager.
@ -75,11 +71,17 @@ public:
// Aggregation methods that use multiple submanagers.
Loc makeRegionVal(SymbolRef Sym) {
return Loc::MakeVal(MemMgr->getSymbolicRegion(Sym));
return Loc::MakeVal(MemMgr.getSymbolicRegion(Sym));
}
/// makeZeroVal - Construct an SVal representing '0' for the specified type.
SVal makeZeroVal(QualType T);
/// GetRValueSymbolVal - make a unique symbol for value of R.
SVal getRValueSymbolVal(const MemRegion* R);
SVal getConjuredSymbolVal(const Expr *E, unsigned Count);
SVal getConjuredSymbolVal(const Expr* E, QualType T, unsigned Count);
};
} // end clang namespace
#endif

11
clang/lib/Analysis/BasicStore.cpp
View File

@ -40,7 +40,7 @@ class VISIBILITY_HIDDEN BasicStoreManager : public StoreManager {
public:
BasicStoreManager(GRStateManager& mgr)
: StoreManager(mgr.getAllocator()),
: StoreManager(mgr.getValueManager()),
VBFactory(mgr.getAllocator()),
StateMgr(mgr),
SelfRegion(0) {}
@ -478,11 +478,8 @@ Store BasicStoreManager::scanForIvars(Stmt *B, const Decl* SelfDecl, Store St) {
if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Base)) {
if (DR->getDecl() == SelfDecl) {
const MemRegion *IVR = MRMgr.getObjCIvarRegion(IV->getDecl(),
SelfRegion);
SVal X = SVal::GetRValueSymbolVal(StateMgr.getSymbolManager(),
MRMgr, IVR);
SelfRegion);
SVal X = ValMgr.getRValueSymbolVal(IVR);
St = BindInternal(St, Loc::MakeVal(IVR), X);
}
}
@ -538,7 +535,7 @@ Store BasicStoreManager::getInitialStore() {
const MemRegion *R = StateMgr.getRegion(VD);
SVal X = (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD) ||
isa<ImplicitParamDecl>(VD))
? SVal::GetRValueSymbolVal(StateMgr.getSymbolManager(), MRMgr,R)
? ValMgr.getRValueSymbolVal(R)
: UndefinedVal();
St = BindInternal(St, Loc::MakeVal(R), X);

17
clang/lib/Analysis/CFRefCount.cpp
View File

@ -1760,8 +1760,8 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
QualType T = R->getRValueType(Ctx);
if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())){
SVal V = SVal::GetConjuredSymbolVal(Eng.getSymbolManager(),
Eng.getStoreManager().getRegionManager(), *I, T, Count);
ValueManager &ValMgr = Eng.getValueManager();
SVal V = ValMgr.getConjuredSymbolVal(*I, T, Count);
state = state.BindLoc(Loc::MakeVal(R), V);
}
else if (const RecordType *RT = T->getAsStructureType()) {
@ -1787,13 +1787,10 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
QualType FT = FD->getType();
if (Loc::IsLocType(FT) ||
(FT->isIntegerType() && FT->isScalarType())) {
(FT->isIntegerType() && FT->isScalarType())) {
const FieldRegion* FR = MRMgr.getFieldRegion(FD, R);
SVal V = SVal::GetConjuredSymbolVal(Eng.getSymbolManager(),
Eng.getStoreManager().getRegionManager(), *I, FT, Count);
ValueManager &ValMgr = Eng.getValueManager();
SVal V = ValMgr.getConjuredSymbolVal(*I, FT, Count);
state = state.BindLoc(Loc::MakeVal(FR), V);
}
}
@ -1857,8 +1854,8 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<GRState>& Dst,
if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {
unsigned Count = Builder.getCurrentBlockCount();
SVal X = SVal::GetConjuredSymbolVal(Eng.getSymbolManager(),
Eng.getStoreManager().getRegionManager(), Ex, T, Count);
ValueManager &ValMgr = Eng.getValueManager();
SVal X = ValMgr.getConjuredSymbolVal(Ex, T, Count);
state = state.BindExpr(Ex, X, false);
}

17
clang/lib/Analysis/GRExprEngine.cpp
View File

@ -2139,8 +2139,7 @@ void GRExprEngine::VisitDeclStmt(DeclStmt* DS, NodeTy* Pred, NodeSet& Dst) {
// UnknownVal.
if (InitVal.isUnknown() ||
!getConstraintManager().canReasonAbout(InitVal)) {
InitVal = SVal::GetConjuredSymbolVal(SymMgr,
getStoreManager().getRegionManager(), InitEx, Count);
InitVal = ValMgr.getConjuredSymbolVal(InitEx, Count);
}
state = StateMgr.BindDecl(state, VD, InitVal);
@ -2531,9 +2530,8 @@ void GRExprEngine::VisitUnaryOperator(UnaryOperator* U, NodeTy* Pred,
// Conjure a new symbol if necessary to recover precision.
if (Result.isUnknown() || !getConstraintManager().canReasonAbout(Result))
Result = SVal::GetConjuredSymbolVal(SymMgr,
getStoreManager().getRegionManager(),Ex,
Builder->getCurrentBlockCount());
Result = ValMgr.getConjuredSymbolVal(Ex,
Builder->getCurrentBlockCount());
state = BindExpr(state, U, U->isPostfix() ? V2 : Result);
@ -2758,10 +2756,8 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
!getConstraintManager().canReasonAbout(RightV))
&& (Loc::IsLocType(T) ||
(T->isScalarType() && T->isIntegerType()))) {
unsigned Count = Builder->getCurrentBlockCount();
RightV = SVal::GetConjuredSymbolVal(SymMgr,
getStoreManager().getRegionManager(), B->getRHS(), Count);
unsigned Count = Builder->getCurrentBlockCount();
RightV = ValMgr.getConjuredSymbolVal(B->getRHS(), Count);
}
// Simulate the effects of a "store": bind the value of the RHS
@ -2932,8 +2928,7 @@ void GRExprEngine::VisitBinaryOperator(BinaryOperator* B,
// The symbolic value is actually for the type of the left-hand side
// expression, not the computation type, as this is the value the
// LValue on the LHS will bind to.
LHSVal = SVal::GetConjuredSymbolVal(SymMgr,
getStoreManager().getRegionManager(), B->getRHS(), LTy, Count);
LHSVal = ValMgr.getConjuredSymbolVal(B->getRHS(), LTy, Count);
// However, we need to convert the symbol to the computation type.
Result = (LTy == CTy) ? LHSVal : EvalCast(LHSVal,CTy);

5
clang/lib/Analysis/GRSimpleVals.cpp
View File

@ -449,10 +449,7 @@ void GRSimpleVals::EvalCall(ExplodedNodeSet<GRState>& Dst,
QualType T = CE->getType();
if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {
unsigned Count = Builder.getCurrentBlockCount();
SVal X = SVal::GetConjuredSymbolVal(Eng.getSymbolManager(),
Eng.getStoreManager().getRegionManager(), CE, Count);
SVal X = Eng.getValueManager().getConjuredSymbolVal(CE, Count);
St = StateMgr.BindExpr(St, CE, X, Eng.getCFG().isBlkExpr(CE), false);
}

12
clang/lib/Analysis/RegionStore.cpp
View File

@ -148,7 +148,7 @@ class VISIBILITY_HIDDEN RegionStoreManager : public StoreManager {
public:
RegionStoreManager(GRStateManager& mgr)
: StoreManager(mgr.getAllocator()),
: StoreManager(mgr.getValueManager()),
RBFactory(mgr.getAllocator()),
RVFactory(mgr.getAllocator()),
StateMgr(mgr), SelfRegion(0), SelfDecl(0) {
@ -159,8 +159,6 @@ public:
virtual ~RegionStoreManager() {}
MemRegionManager& getRegionManager() { return MRMgr; }
SubRegionMap* getSubRegionMap(const GRState *state);
const GRState* BindCompoundLiteral(const GRState* St,
@ -756,7 +754,7 @@ SVal RegionStoreManager::Retrieve(const GRState* St, Loc L, QualType T) {
if (SR == SelfRegion) {
// FIXME: Do we need to handle the case where the super region
// has a view? We want to canonicalize the bindings.
return SVal::GetRValueSymbolVal(getSymbolManager(), MRMgr, R);
return ValMgr.getRValueSymbolVal(R);
}
// Otherwise, we need a new symbol. For now return Unknown.
@ -778,7 +776,7 @@ SVal RegionStoreManager::Retrieve(const GRState* St, Loc L, QualType T) {
VD->hasGlobalStorage()) {
QualType VTy = VD->getType();
if (Loc::IsLocType(VTy) || VTy->isIntegerType())
return SVal::GetRValueSymbolVal(getSymbolManager(), MRMgr, VR);
return ValMgr.getRValueSymbolVal(VR);
else
return UnknownVal();
}
@ -794,7 +792,7 @@ SVal RegionStoreManager::Retrieve(const GRState* St, Loc L, QualType T) {
// All other integer values are symbolic.
if (Loc::IsLocType(RTy) || RTy->isIntegerType())
return SVal::GetRValueSymbolVal(getSymbolManager(), MRMgr, R);
return ValMgr.getRValueSymbolVal(R);
else
return UnknownVal();
}
@ -833,7 +831,7 @@ SVal RegionStoreManager::RetrieveStruct(const GRState* St,const TypedRegion* R){
if (MRMgr.onStack(FR) || MRMgr.onHeap(FR))
FieldValue = UndefinedVal();
else
FieldValue = SVal::GetRValueSymbolVal(getSymbolManager(), MRMgr, FR);
FieldValue = ValMgr.getRValueSymbolVal(FR);
}
StructVal = getBasicVals().consVals(FieldValue, StructVal);

17
clang/lib/Analysis/SVals.cpp
View File

@ -280,15 +280,14 @@ NonLoc NonLoc::MakeCompoundVal(QualType T, llvm::ImmutableList<SVal> Vals,
return nonloc::CompoundVal(BasicVals.getCompoundValData(T, Vals));
}
SVal SVal::GetRValueSymbolVal(SymbolManager& SymMgr, MemRegionManager& MRMgr,
const MemRegion* R) {
SVal ValueManager::getRValueSymbolVal(const MemRegion* R) {
SymbolRef sym = SymMgr.getRegionRValueSymbol(R);
if (const TypedRegion* TR = dyn_cast<TypedRegion>(R)) {
QualType T = TR->getRValueType(SymMgr.getContext());
if (Loc::IsLocType(T))
return Loc::MakeVal(MRMgr.getSymbolicRegion(sym));
return Loc::MakeVal(MemMgr.getSymbolicRegion(sym));
// Only handle integers for now.
if (T->isIntegerType() && T->isScalarType())
@ -298,13 +297,12 @@ SVal SVal::GetRValueSymbolVal(SymbolManager& SymMgr, MemRegionManager& MRMgr,
return UnknownVal();
}
SVal SVal::GetConjuredSymbolVal(SymbolManager &SymMgr, MemRegionManager& MRMgr,
const Expr* E, unsigned Count) {
SVal ValueManager::getConjuredSymbolVal(const Expr* E, unsigned Count) {
QualType T = E->getType();
SymbolRef sym = SymMgr.getConjuredSymbol(E, Count);
if (Loc::IsLocType(T))
return Loc::MakeVal(MRMgr.getSymbolicRegion(sym));
return Loc::MakeVal(MemMgr.getSymbolicRegion(sym));
if (T->isIntegerType() && T->isScalarType())
return NonLoc::MakeVal(sym);
@ -312,12 +310,13 @@ SVal SVal::GetConjuredSymbolVal(SymbolManager &SymMgr, MemRegionManager& MRMgr,
return UnknownVal();
}
SVal SVal::GetConjuredSymbolVal(SymbolManager &SymMgr, MemRegionManager& MRMgr,
const Expr* E, QualType T, unsigned Count) {
SVal ValueManager::getConjuredSymbolVal(const Expr* E, QualType T,
unsigned Count) {
SymbolRef sym = SymMgr.getConjuredSymbol(E, T, Count);
if (Loc::IsLocType(T))
return Loc::MakeVal(MRMgr.getSymbolicRegion(sym));
return Loc::MakeVal(MemMgr.getSymbolicRegion(sym));
if (T->isIntegerType() && T->isScalarType())
return NonLoc::MakeVal(sym);