From: Ted Kremenek Date: Thu, 9 Apr 2009 22:22:44 +0000 (+0000) Subject: - Move ownership of MemRegionManager into ValueManager. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=8d7f5481a0eeb4c0508202a4bd2b754cfa93c4fe;p=clang - Move ownership of MemRegionManager into ValueManager. - Pull SVal::GetConjuredSymbol() and friends into ValueManager. This greatly simplifies the calling interface to clients. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@68731 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Analysis/PathSensitive/GRState.h b/include/clang/Analysis/PathSensitive/GRState.h index aa794175b1..4c75c86c9f 100644 --- a/include/clang/Analysis/PathSensitive/GRState.h +++ b/include/clang/Analysis/PathSensitive/GRState.h @@ -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(); diff --git a/include/clang/Analysis/PathSensitive/SVals.h b/include/clang/Analysis/PathSensitive/SVals.h index df40780181..73c5509d2e 100644 --- a/include/clang/Analysis/PathSensitive/SVals.h +++ b/include/clang/Analysis/PathSensitive/SVals.h @@ -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; } diff --git a/include/clang/Analysis/PathSensitive/Store.h b/include/clang/Analysis/PathSensitive/Store.h index ea7c496ff9..9d41de7bd5 100644 --- a/include/clang/Analysis/PathSensitive/Store.h +++ b/include/clang/Analysis/PathSensitive/Store.h @@ -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: + ValueManager &ValMgr; + /// MRMgr - Manages region objects associated with this StoreManager. - MemRegionManager MRMgr; + MemRegionManager &MRMgr; - StoreManager(llvm::BumpPtrAllocator& Alloc) : MRMgr(Alloc) {} + StoreManager(ValueManager &valMgr) + : ValMgr(valMgr), MRMgr(ValMgr.getRegionManager()) {} public: virtual ~StoreManager() {} diff --git a/include/clang/Analysis/PathSensitive/ValueManager.h b/include/clang/Analysis/PathSensitive/ValueManager.h index 28aa791c02..f83b02c227 100644 --- a/include/clang/Analysis/PathSensitive/ValueManager.h +++ b/include/clang/Analysis/PathSensitive/ValueManager.h @@ -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 diff --git a/lib/Analysis/BasicStore.cpp b/lib/Analysis/BasicStore.cpp index c1efb983c0..5c234549a4 100644 --- a/lib/Analysis/BasicStore.cpp +++ b/lib/Analysis/BasicStore.cpp @@ -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(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(VD) || isa(VD)) - ? SVal::GetRValueSymbolVal(StateMgr.getSymbolManager(), MRMgr,R) + ? ValMgr.getRValueSymbolVal(R) : UndefinedVal(); St = BindInternal(St, Loc::MakeVal(R), X); diff --git a/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp index 0a68ee49de..cfeabd0cb1 100644 --- a/lib/Analysis/CFRefCount.cpp +++ b/lib/Analysis/CFRefCount.cpp @@ -1760,8 +1760,8 @@ void CFRefCount::EvalSummary(ExplodedNodeSet& 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& 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& 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); } diff --git a/lib/Analysis/GRExprEngine.cpp b/lib/Analysis/GRExprEngine.cpp index 2a43b9a89e..c7ff0aec27 100644 --- a/lib/Analysis/GRExprEngine.cpp +++ b/lib/Analysis/GRExprEngine.cpp @@ -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); diff --git a/lib/Analysis/GRSimpleVals.cpp b/lib/Analysis/GRSimpleVals.cpp index 44e76555f9..8d596955be 100644 --- a/lib/Analysis/GRSimpleVals.cpp +++ b/lib/Analysis/GRSimpleVals.cpp @@ -449,10 +449,7 @@ void GRSimpleVals::EvalCall(ExplodedNodeSet& 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); } diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp index 5e60363573..4088158627 100644 --- a/lib/Analysis/RegionStore.cpp +++ b/lib/Analysis/RegionStore.cpp @@ -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); diff --git a/lib/Analysis/SVals.cpp b/lib/Analysis/SVals.cpp index 8fdc37fe73..acc4111b70 100644 --- a/lib/Analysis/SVals.cpp +++ b/lib/Analysis/SVals.cpp @@ -280,15 +280,14 @@ NonLoc NonLoc::MakeCompoundVal(QualType T, llvm::ImmutableList 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(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);