constify MemRegion* returned by MemRegionManager::getXXXRegion() methods.

llvm-svn: 90503

clang/include/clang/Analysis/PathSensitive/MemRegion.h

@@ -691,50 +691,50 @@ public:
 
   /// getStackRegion - Retrieve the memory region associated with the
   ///  current stack frame.
-  MemSpaceRegion *getStackRegion();
+  const MemSpaceRegion *getStackRegion();
 
   /// getStackArgumentsRegion - Retrieve the memory region associated with
   ///  function/method arguments of the current stack frame.
-  MemSpaceRegion *getStackArgumentsRegion();
+  const MemSpaceRegion *getStackArgumentsRegion();
 
   /// getGlobalsRegion - Retrieve the memory region associated with
   ///  all global variables.
-  MemSpaceRegion *getGlobalsRegion();
+  const MemSpaceRegion *getGlobalsRegion();
 
   /// getHeapRegion - Retrieve the memory region associated with the
   ///  generic "heap".
-  MemSpaceRegion *getHeapRegion();
+  const MemSpaceRegion *getHeapRegion();
 
   /// getUnknownRegion - Retrieve the memory region associated with unknown
   /// memory space.
-  MemSpaceRegion *getUnknownRegion();
+  const MemSpaceRegion *getUnknownRegion();
 
-  MemSpaceRegion *getCodeRegion();
+  const MemSpaceRegion *getCodeRegion();
 
   /// getAllocaRegion - Retrieve a region associated with a call to alloca().
-  AllocaRegion *getAllocaRegion(const Expr* Ex, unsigned Cnt);
+  const AllocaRegion *getAllocaRegion(const Expr* Ex, unsigned Cnt);
 
   /// getCompoundLiteralRegion - Retrieve the region associated with a
   ///  given CompoundLiteral.
-  CompoundLiteralRegion*
+  const CompoundLiteralRegion*
   getCompoundLiteralRegion(const CompoundLiteralExpr* CL);
 
   /// getSymbolicRegion - Retrieve or create a "symbolic" memory region.
-  SymbolicRegion* getSymbolicRegion(SymbolRef sym);
+  const SymbolicRegion* getSymbolicRegion(SymbolRef sym);
 
-  StringRegion* getStringRegion(const StringLiteral* Str);
+  const StringRegion* getStringRegion(const StringLiteral* Str);
 
   /// getVarRegion - Retrieve or create the memory region associated with
   ///  a specified VarDecl and LocationContext.
-  VarRegion* getVarRegion(const VarDecl *D, const LocationContext *LC);
+  const VarRegion* getVarRegion(const VarDecl *D, const LocationContext *LC);
 
   /// getElementRegion - Retrieve the memory region associated with the
   ///  associated element type, index, and super region.
-  ElementRegion *getElementRegion(QualType elementType, SVal Idx,
+  const ElementRegion *getElementRegion(QualType elementType, SVal Idx,
                                   const MemRegion *superRegion,
                                   ASTContext &Ctx);
 
-  ElementRegion *getElementRegionWithSuper(const ElementRegion *ER,
+  const ElementRegion *getElementRegionWithSuper(const ElementRegion *ER,
                                            const MemRegion *superRegion) {
     return getElementRegion(ER->getElementType(), ER->getIndex(),
                             superRegion, ER->getContext());
@@ -744,29 +744,30 @@ public:
   ///  a specified FieldDecl.  'superRegion' corresponds to the containing
   ///  memory region (which typically represents the memory representing
   ///  a structure or class).
-  FieldRegion *getFieldRegion(const FieldDecl* fd,
+  const FieldRegion *getFieldRegion(const FieldDecl* fd,
                                     const MemRegion* superRegion);
 
-  FieldRegion *getFieldRegionWithSuper(const FieldRegion *FR,
+  const FieldRegion *getFieldRegionWithSuper(const FieldRegion *FR,
                                              const MemRegion *superRegion) {
     return getFieldRegion(FR->getDecl(), superRegion);
   }
 
   /// getObjCObjectRegion - Retrieve or create the memory region associated with
   ///  the instance of a specified Objective-C class.
-  ObjCObjectRegion* getObjCObjectRegion(const ObjCInterfaceDecl* ID,
+  const ObjCObjectRegion* getObjCObjectRegion(const ObjCInterfaceDecl* ID,
                                               const MemRegion* superRegion);
 
   /// getObjCIvarRegion - Retrieve or create the memory region associated with
   ///   a specified Objective-c instance variable.  'superRegion' corresponds
   ///   to the containing region (which typically represents the Objective-C
   ///   object).
-  ObjCIvarRegion *getObjCIvarRegion(const ObjCIvarDecl* ivd,
+  const ObjCIvarRegion *getObjCIvarRegion(const ObjCIvarDecl* ivd,
                                           const MemRegion* superRegion);
 
-  FunctionTextRegion *getFunctionTextRegion(const FunctionDecl *FD);
+  const FunctionTextRegion *getFunctionTextRegion(const FunctionDecl *FD);
-  BlockTextRegion *getBlockTextRegion(const BlockDecl *BD, CanQualType locTy);
+  const BlockTextRegion *getBlockTextRegion(const BlockDecl *BD,
-  BlockDataRegion *getBlockDataRegion(const BlockTextRegion *bc,
+                                            CanQualType locTy);
+  const BlockDataRegion *getBlockDataRegion(const BlockTextRegion *bc,
                                       const LocationContext *lc);
 
   bool isGlobalsRegion(const MemRegion* R) {
@@ -788,7 +789,7 @@ private:
   RegionTy* getSubRegion(const A1 a1, const A2 a2,
                          const MemRegion* superRegion);
 
-  MemSpaceRegion* LazyAllocate(MemSpaceRegion*& region);
+  const MemSpaceRegion* LazyAllocate(MemSpaceRegion*& region);
 };
 
 //===----------------------------------------------------------------------===//

clang/lib/Analysis/MemRegion.cpp

@@ -404,7 +404,7 @@ void RegionRawOffset::dumpToStream(llvm::raw_ostream& os) const {
 // MemRegionManager methods.
 //===----------------------------------------------------------------------===//
 
-MemSpaceRegion* MemRegionManager::LazyAllocate(MemSpaceRegion*& region) {
+const MemSpaceRegion *MemRegionManager::LazyAllocate(MemSpaceRegion*& region) {
   if (!region) {
     region = (MemSpaceRegion*) A.Allocate<MemSpaceRegion>();
     new (region) MemSpaceRegion(this);
@@ -413,27 +413,27 @@ MemSpaceRegion* MemRegionManager::LazyAllocate(MemSpaceRegion*& region) {
   return region;
 }
 
-MemSpaceRegion* MemRegionManager::getStackRegion() {
+const MemSpaceRegion *MemRegionManager::getStackRegion() {
   return LazyAllocate(stack);
 }
 
-MemSpaceRegion* MemRegionManager::getStackArgumentsRegion() {
+const MemSpaceRegion *MemRegionManager::getStackArgumentsRegion() {
   return LazyAllocate(stackArguments);
 }
 
-MemSpaceRegion* MemRegionManager::getGlobalsRegion() {
+const MemSpaceRegion *MemRegionManager::getGlobalsRegion() {
   return LazyAllocate(globals);
 }
 
-MemSpaceRegion* MemRegionManager::getHeapRegion() {
+const MemSpaceRegion *MemRegionManager::getHeapRegion() {
   return LazyAllocate(heap);
 }
 
-MemSpaceRegion* MemRegionManager::getUnknownRegion() {
+const MemSpaceRegion *MemRegionManager::getUnknownRegion() {
   return LazyAllocate(unknown);
 }
 
-MemSpaceRegion* MemRegionManager::getCodeRegion() {
+const MemSpaceRegion *MemRegionManager::getCodeRegion() {
   return LazyAllocate(code);
 }
 
@@ -441,11 +441,11 @@ MemSpaceRegion* MemRegionManager::getCodeRegion() {
 // Constructing regions.
 //===----------------------------------------------------------------------===//
 
-StringRegion* MemRegionManager::getStringRegion(const StringLiteral* Str) {
+const StringRegion* MemRegionManager::getStringRegion(const StringLiteral* Str) {
   return getRegion<StringRegion>(Str);
 }
 
-VarRegion* MemRegionManager::getVarRegion(const VarDecl *D,
+const VarRegion* MemRegionManager::getVarRegion(const VarDecl *D,
                                                 const LocationContext *LC) {
 
   // FIXME: Once we implement scope handling, we will need to properly lookup
@@ -457,9 +457,9 @@ VarRegion* MemRegionManager::getVarRegion(const VarDecl *D,
   return getRegion<VarRegion>(D, LC);
 }
 
-BlockDataRegion *MemRegionManager::getBlockDataRegion(const BlockTextRegion *BC,
+const BlockDataRegion *
-                                                      const LocationContext *LC)
+MemRegionManager::getBlockDataRegion(const BlockTextRegion *BC,
-{
+                                     const LocationContext *LC) {
   // FIXME: Once we implement scope handling, we will need to properly lookup
   // 'D' to the proper LocationContext.  For now, just strip down to the
   // StackFrame.
@@ -469,12 +469,12 @@ BlockDataRegion *MemRegionManager::getBlockDataRegion(const BlockTextRegion *BC,
   return getSubRegion<BlockDataRegion>(BC, LC, getStackRegion());
 }
 
-CompoundLiteralRegion*
+const CompoundLiteralRegion*
 MemRegionManager::getCompoundLiteralRegion(const CompoundLiteralExpr* CL) {
   return getRegion<CompoundLiteralRegion>(CL);
 }
 
-ElementRegion*
+const ElementRegion*
 MemRegionManager::getElementRegion(QualType elementType, SVal Idx,
                                    const MemRegion* superRegion,
                                    ASTContext& Ctx){
@@ -497,40 +497,42 @@ MemRegionManager::getElementRegion(QualType elementType, SVal Idx,
   return R;
 }
 
-FunctionTextRegion *
+const FunctionTextRegion *
 MemRegionManager::getFunctionTextRegion(const FunctionDecl *FD) {
   return getRegion<FunctionTextRegion>(FD);
 }
 
-BlockTextRegion *MemRegionManager::getBlockTextRegion(const BlockDecl *BD,
+const BlockTextRegion *
-                                                      CanQualType locTy) {
+MemRegionManager::getBlockTextRegion(const BlockDecl *BD, CanQualType locTy) {
   return getRegion<BlockTextRegion>(BD, locTy);
 }
 
 
 /// getSymbolicRegion - Retrieve or create a "symbolic" memory region.
-SymbolicRegion* MemRegionManager::getSymbolicRegion(SymbolRef sym) {
+const SymbolicRegion *MemRegionManager::getSymbolicRegion(SymbolRef sym) {
   return getRegion<SymbolicRegion>(sym);
 }
 
-FieldRegion* MemRegionManager::getFieldRegion(const FieldDecl* d,
+const FieldRegion *
+MemRegionManager::getFieldRegion(const FieldDecl* d,
                                  const MemRegion* superRegion){
   return getSubRegion<FieldRegion>(d, superRegion);
 }
 
-ObjCIvarRegion*
+const ObjCIvarRegion*
 MemRegionManager::getObjCIvarRegion(const ObjCIvarDecl* d,
                                     const MemRegion* superRegion) {
   return getSubRegion<ObjCIvarRegion>(d, superRegion);
 }
 
-ObjCObjectRegion*
+const ObjCObjectRegion*
 MemRegionManager::getObjCObjectRegion(const ObjCInterfaceDecl* d,
                                       const MemRegion* superRegion) {
   return getSubRegion<ObjCObjectRegion>(d, superRegion);
 }
 
-AllocaRegion* MemRegionManager::getAllocaRegion(const Expr* E, unsigned cnt) {
+const AllocaRegion*
+MemRegionManager::getAllocaRegion(const Expr* E, unsigned cnt) {
   return getRegion<AllocaRegion>(E, cnt);
 }
 

clang/lib/Analysis/RegionStore.cpp

@@ -820,9 +820,8 @@ SVal RegionStoreManager::ArrayToPointer(Loc Array) {
   T = AT->getElementType();
 
   SVal ZeroIdx = ValMgr.makeZeroArrayIndex();
-  ElementRegion* ER = MRMgr.getElementRegion(T, ZeroIdx, ArrayR, getContext());
+  return loc::MemRegionVal(MRMgr.getElementRegion(T, ZeroIdx, ArrayR,
-
+                                                  getContext()));
-  return loc::MemRegionVal(ER);
 }
 
 //===----------------------------------------------------------------------===//
@@ -1465,9 +1464,7 @@ const GRState *
 RegionStoreManager::BindCompoundLiteral(const GRState *state,
                                         const CompoundLiteralExpr* CL,
                                         SVal V) {
-
+  return Bind(state, loc::MemRegionVal(MRMgr.getCompoundLiteralRegion(CL)), V);
-  CompoundLiteralRegion* R = MRMgr.getCompoundLiteralRegion(CL);
-  return Bind(state, loc::MemRegionVal(R), V);
 }
 
 const GRState *RegionStoreManager::setImplicitDefaultValue(const GRState *state,
@@ -1520,7 +1517,7 @@ const GRState *RegionStoreManager::BindArray(const GRState *state,
         break;
 
       SVal Idx = ValMgr.makeArrayIndex(i);
-      ElementRegion* ER = MRMgr.getElementRegion(ElementTy, Idx, R,
+      const ElementRegion* ER = MRMgr.getElementRegion(ElementTy, Idx, R,
                                                        getContext());
 
       SVal V = ValMgr.makeIntVal(str[j], sizeof(char)*8, true);
@@ -1549,7 +1546,7 @@ const GRState *RegionStoreManager::BindArray(const GRState *state,
       break;
 
     SVal Idx = ValMgr.makeArrayIndex(i);
-    ElementRegion* ER = MRMgr.getElementRegion(ElementTy, Idx, R, getContext());
+    const ElementRegion *ER = MRMgr.getElementRegion(ElementTy, Idx, R, getContext());
 
     if (CAT->getElementType()->isStructureType())
       state = BindStruct(state, ER, *VI);
@@ -1871,8 +1868,7 @@ GRState const *RegionStoreManager::EnterStackFrame(GRState const *state,
   // Copy the arg expression value to the arg variables.
   for (; AI != AE; ++AI, ++PI) {
     SVal ArgVal = state->getSVal(*AI);
-    MemRegion *R = MRMgr.getVarRegion(*PI, frame);
+    state = Bind(state, ValMgr.makeLoc(MRMgr.getVarRegion(*PI, frame)), ArgVal);
-    state = Bind(state, ValMgr.makeLoc(R), ArgVal);
   }
 
   return state;

clang/lib/Analysis/ValueManager.cpp

@@ -138,15 +138,14 @@ ValueManager::getDerivedRegionValueSymbolVal(SymbolRef parentSymbol,
 }
 
 DefinedSVal ValueManager::getFunctionPointer(const FunctionDecl* FD) {
-  CodeTextRegion *R  = MemMgr.getFunctionTextRegion(FD);
+  return loc::MemRegionVal(MemMgr.getFunctionTextRegion(FD));
-  return loc::MemRegionVal(R);
 }
 
 DefinedSVal ValueManager::getBlockPointer(const BlockDecl *D,
                                           CanQualType locTy,
                                           const LocationContext *LC) {
-  BlockTextRegion *BC = MemMgr.getBlockTextRegion(D, locTy);
+  const BlockTextRegion *BC = MemMgr.getBlockTextRegion(D, locTy);
-  BlockDataRegion *BD = MemMgr.getBlockDataRegion(BC, LC);
+  const BlockDataRegion *BD = MemMgr.getBlockDataRegion(BC, LC);
   return loc::MemRegionVal(BD);
 }