From: Zhongxing Xu Date: Wed, 14 Oct 2009 06:55:01 +0000 (+0000) Subject: Now StoreManager::CastRegion() takes a MemRegion, returns a MemRegion. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=09270cc1b9cdd4c50012cb7984df8745e05833e5;p=clang Now StoreManager::CastRegion() takes a MemRegion, returns a MemRegion. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@84081 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Analysis/PathSensitive/Store.h b/include/clang/Analysis/PathSensitive/Store.h index ed2da1a59a..3ff253d0ab 100644 --- a/include/clang/Analysis/PathSensitive/Store.h +++ b/include/clang/Analysis/PathSensitive/Store.h @@ -122,8 +122,7 @@ public: /// CastRegion - Used by GRExprEngine::VisitCast to handle casts from /// a MemRegion* to a specific location type. 'R' is the region being /// casted and 'CastToTy' the result type of the cast. - CastResult CastRegion(const GRState *state, const MemRegion *region, - QualType CastToTy); + const MemRegion *CastRegion(const MemRegion *region, QualType CastToTy); /// EvalBinOp - Perform pointer arithmetic. virtual SVal EvalBinOp(const GRState *state, BinaryOperator::Opcode Op, @@ -173,9 +172,8 @@ public: virtual void iterBindings(Store store, BindingsHandler& f) = 0; protected: - CastResult MakeElementRegion(const GRState *state, const MemRegion *region, - QualType pointeeTy, QualType castToTy, - uint64_t index = 0); + const MemRegion *MakeElementRegion(const MemRegion *Base, + QualType pointeeTy, uint64_t index = 0); /// CastRetrievedVal - Used by subclasses of StoreManager to implement /// implicit casts that arise from loads from regions that are reinterpreted diff --git a/lib/Analysis/SValuator.cpp b/lib/Analysis/SValuator.cpp index 86006c3df6..573cac315b 100644 --- a/lib/Analysis/SValuator.cpp +++ b/lib/Analysis/SValuator.cpp @@ -133,18 +133,15 @@ SValuator::CastResult SValuator::EvalCast(SVal val, const GRState *state, StoreManager &storeMgr = ValMgr.getStateManager().getStoreManager(); - // Delegate to store manager to get the result of casting a region - // to a different type. - const StoreManager::CastResult& Res = storeMgr.CastRegion(state, R, castTy); - - // Inspect the result. If the MemRegion* returned is NULL, this - // expression evaluates to UnknownVal. - R = Res.getRegion(); + // Delegate to store manager to get the result of casting a region to a + // different type. If the MemRegion* returned is NULL, this expression + // evaluates to UnknownVal. + R = storeMgr.CastRegion(R, castTy); if (R) - return CastResult(Res.getState(), loc::MemRegionVal(R)); + return CastResult(state, loc::MemRegionVal(R)); - return CastResult(Res.getState(), UnknownVal()); + return CastResult(state, UnknownVal()); } // All other cases. diff --git a/lib/Analysis/Store.cpp b/lib/Analysis/Store.cpp index d1abd57640..4b4ae65808 100644 --- a/lib/Analysis/Store.cpp +++ b/lib/Analysis/Store.cpp @@ -20,14 +20,10 @@ StoreManager::StoreManager(GRStateManager &stateMgr) : ValMgr(stateMgr.getValueManager()), StateMgr(stateMgr), MRMgr(ValMgr.getRegionManager()) {} -StoreManager::CastResult -StoreManager::MakeElementRegion(const GRState *state, const MemRegion *region, - QualType pointeeTy, QualType castToTy, - uint64_t index) { - // Create a new ElementRegion. +const MemRegion *StoreManager::MakeElementRegion(const MemRegion *Base, + QualType EleTy, uint64_t index) { SVal idx = ValMgr.makeArrayIndex(index); - return CastResult(state, MRMgr.getElementRegion(pointeeTy, idx, region, - ValMgr.getContext())); + return MRMgr.getElementRegion(EleTy, idx, Base, ValMgr.getContext()); } // FIXME: Merge with the implementation of the same method in MemRegion.cpp @@ -41,15 +37,13 @@ static bool IsCompleteType(ASTContext &Ctx, QualType Ty) { return true; } -StoreManager::CastResult -StoreManager::CastRegion(const GRState *state, const MemRegion* R, - QualType CastToTy) { +const MemRegion *StoreManager::CastRegion(const MemRegion *R, QualType CastToTy) { ASTContext& Ctx = StateMgr.getContext(); // Handle casts to Objective-C objects. if (CastToTy->isObjCObjectPointerType()) - return CastResult(state, R->getBaseRegion()); + return R->getBaseRegion(); if (CastToTy->isBlockPointerType()) { // FIXME: We may need different solutions, depending on the symbol @@ -57,11 +51,11 @@ StoreManager::CastRegion(const GRState *state, const MemRegion* R, // as Objective-C objects. This could possibly be handled by enhancing // our reasoning of downcasts of symbolic objects. if (isa(R) || isa(R)) - return CastResult(state, R); + return R; // We don't know what to make of it. Return a NULL region, which // will be interpretted as UnknownVal. - return CastResult(state, NULL); + return NULL; } // Now assume we are casting from pointer to pointer. Other cases should @@ -71,14 +65,14 @@ StoreManager::CastRegion(const GRState *state, const MemRegion* R, // Handle casts to void*. We just pass the region through. if (CanonPointeeTy.getUnqualifiedType() == Ctx.VoidTy) - return CastResult(state, R); + return R; // Handle casts from compatible types. if (R->isBoundable()) if (const TypedRegion *TR = dyn_cast(R)) { QualType ObjTy = Ctx.getCanonicalType(TR->getValueType(Ctx)); if (CanonPointeeTy == ObjTy) - return CastResult(state, R); + return R; } // Process region cast according to the kind of the region being cast. @@ -93,10 +87,10 @@ StoreManager::CastRegion(const GRState *state, const MemRegion* R, } case MemRegion::CodeTextRegionKind: { // CodeTextRegion should be cast to only a function or block pointer type, - // although they can in practice be casted to anything, e.g, void*, - // char*, etc. - // Just pass the region through. - break; + // although they can in practice be casted to anything, e.g, void*, char*, + // etc. + // Just return the region. + return R; } case MemRegion::StringRegionKind: @@ -108,7 +102,7 @@ StoreManager::CastRegion(const GRState *state, const MemRegion* R, case MemRegion::FieldRegionKind: case MemRegion::ObjCIvarRegionKind: case MemRegion::VarRegionKind: - return MakeElementRegion(state, R, PointeeTy, CastToTy); + return MakeElementRegion(R, PointeeTy); case MemRegion::ElementRegionKind: { // If we are casting from an ElementRegion to another type, the @@ -137,7 +131,7 @@ StoreManager::CastRegion(const GRState *state, const MemRegion* R, // If we cannot compute a raw offset, throw up our hands and return // a NULL MemRegion*. if (!baseR) - return CastResult(state, NULL); + return NULL; int64_t off = rawOff.getByteOffset(); @@ -149,11 +143,11 @@ StoreManager::CastRegion(const GRState *state, const MemRegion* R, QualType ObjTy = Ctx.getCanonicalType(TR->getValueType(Ctx)); QualType CanonPointeeTy = Ctx.getCanonicalType(PointeeTy); if (CanonPointeeTy == ObjTy) - return CastResult(state, baseR); + return baseR; } // Otherwise, create a new ElementRegion at offset 0. - return MakeElementRegion(state, baseR, PointeeTy, CastToTy, 0); + return MakeElementRegion(baseR, PointeeTy); } // We have a non-zero offset from the base region. We want to determine @@ -183,15 +177,15 @@ StoreManager::CastRegion(const GRState *state, const MemRegion* R, if (!newSuperR) { // Create an intermediate ElementRegion to represent the raw byte. // This will be the super region of the final ElementRegion. - SVal idx = ValMgr.makeArrayIndex(off); - newSuperR = MRMgr.getElementRegion(Ctx.CharTy, idx, baseR, Ctx); + newSuperR = MakeElementRegion(baseR, Ctx.CharTy, off); } - return MakeElementRegion(state, newSuperR, PointeeTy, CastToTy, newIndex); + return MakeElementRegion(newSuperR, PointeeTy, newIndex); } } - return CastResult(state, R); + assert(0 && "unreachable"); + return 0; }