Add a separate MemSpaceRegion for function/method arguments passed on the stack.

This will simplify the logic of StoreManagers that want to specially reason
about the values of parameters.

llvm-svn: 74715

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

@@ -585,13 +585,15 @@ class MemRegionManager {
   
   MemSpaceRegion *globals;
   MemSpaceRegion *stack;
+  MemSpaceRegion *stackArguments;
   MemSpaceRegion *heap;
   MemSpaceRegion *unknown;
   MemSpaceRegion *code;
 
 public:
   MemRegionManager(ASTContext &c, llvm::BumpPtrAllocator& a)
-    : C(c), A(a), globals(0), stack(0), heap(0), unknown(0), code(0) {}
+    : C(c), A(a), globals(0), stack(0), stackArguments(0), heap(0),
+      unknown(0), code(0) {}
   
   ~MemRegionManager() {}
   
@@ -601,6 +603,10 @@ public:
   ///  current stack frame.
   MemSpaceRegion *getStackRegion();
 
+  /// getStackArgumentsRegion - Retrieve the memory region associated with
+  ///  function/method arguments of the current stack frame.
+  MemSpaceRegion *getStackArgumentsRegion();
+  
   /// getGlobalsRegion - Retrieve the memory region associated with
   ///  all global variables.
   MemSpaceRegion *getGlobalsRegion();
@@ -784,8 +790,12 @@ template <> struct MemRegionManagerTrait<VarRegion> {
   typedef MemRegion SuperRegionTy;
   static const SuperRegionTy* getSuperRegion(MemRegionManager& MRMgr,
                                              const VarDecl *d) {
-    return d->hasLocalStorage() ? MRMgr.getStackRegion() 
-                                : MRMgr.getGlobalsRegion();
+    if (d->hasLocalStorage()) {
+      return isa<ParmVarDecl>(d) || isa<ImplicitParamDecl>(d)
+             ? MRMgr.getStackArgumentsRegion() : MRMgr.getStackRegion();
+    }
+    
+    return MRMgr.getGlobalsRegion();
   }
 };
   

clang/lib/Analysis/MemRegion.cpp

@@ -223,6 +223,10 @@ MemSpaceRegion* MemRegionManager::getStackRegion() {
   return LazyAllocate(stack);
 }
 
+MemSpaceRegion* MemRegionManager::getStackArgumentsRegion() {
+  return LazyAllocate(stackArguments);
+}
+
 MemSpaceRegion* MemRegionManager::getGlobalsRegion() {
   return LazyAllocate(globals);
 }
@@ -332,8 +336,10 @@ const MemSpaceRegion *MemRegion::getMemorySpace() const {
 }
 
 bool MemRegion::hasStackStorage() const {
-  if (const MemSpaceRegion *MS = getMemorySpace())
-    return MS == getMemRegionManager()->getStackRegion();
+  if (const MemSpaceRegion *MS = getMemorySpace()) {
+    MemRegionManager *Mgr = getMemRegionManager();
+    return MS == Mgr->getStackRegion() || MS == Mgr->getStackArgumentsRegion();
+  }
 
   return false;
 }
@@ -348,7 +354,9 @@ bool MemRegion::hasHeapStorage() const {
 bool MemRegion::hasHeapOrStackStorage() const {
   if (const MemSpaceRegion *MS = getMemorySpace()) {
     MemRegionManager *Mgr = getMemRegionManager();
-    return MS == Mgr->getHeapRegion() || MS == Mgr->getStackRegion();
+    return MS == Mgr->getHeapRegion()
+      || MS == Mgr->getStackRegion()
+      || MS == Mgr->getStackArgumentsRegion();
   }
   return false;
 }