Add the way to extract SVals of arguments used in a call for a given StackFrameCtx

[NoQ]

Summary

This patch adds getArgsSVal method to ProgramState that allows the user to obtain SVals of argumetns used in a call that created the given StackFrameCtx. I know this isn't perfect (Alexey Sidorin pointed out that there is a problem with line 741 - argument values may be overwritten) but wanted to submit it separate from other changes that I do and find _the_ right solution.

[NoQ]

I'm ok with constructing SymbolRegionValue for ArgLoc manually and adding a comment like FIXME: leaking implementation details of RegionStoreManager.

[NoQ]

Note that the uncontrolled recursion checker will not be able to test this overwrite problem, because overwriting the argument region spoils the stack frame for it.

include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h

743

Hmm, this should work:

~ 743     StoreManager &storeMgr = stateMgr->getStoreManager();
+ 744     return storeMgr.getBinding(storeMgr.getInitialStore(SFC).getStore(),
+ 745                                ArgLoc);

[NoQ]

include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h

739

Rather in the environment. In fact, here we are relying on the store to *always* have something for us, even if wasn't directly bound earlier.

[NoQ]

Seems to become outdated with D27091.

include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h

public:
   SVal getLValue(const FieldDecl *decl, SVal Base) const;
 
   /// Get the lvalue for an indirect field reference.
   SVal getLValue(const IndirectFieldDecl *decl, SVal Base) const;
 
   /// Get the lvalue for an array index.
   SVal getLValue(QualType ElementType, SVal Idx, SVal Base) const;
 
+  /// Get the symbolic value of arguments used in a call
+  /// that created the given stack frame
+  SVal getArgSVal(const StackFrameContext *SFC, const unsigned ArgIdx) const;
+
   /// Returns the SVal bound to the statement 'S' in the state's environment.
   SVal getSVal(const Stmt *S, const LocationContext *LCtx) const;
   
   SVal getSValAsScalarOrLoc(const Stmt *Ex, const LocationContext *LCtx) const;
 
   /// \brief Return the value bound to the specified location.
   /// Returns UnknownVal() if none found.
   SVal getSVal(Loc LV, QualType T = QualType()) const;

 }
 
 inline SVal ProgramState::getLValue(QualType ElementType, SVal Idx, SVal Base) const{
   if (Optional<NonLoc> N = Idx.getAs<NonLoc>())
     return getStateManager().StoreMgr->getLValueElement(ElementType, *N, Base);
   return UnknownVal();
 }
 
+inline SVal ProgramState::getArgSVal(const StackFrameContext *SFC,
+                                     const unsigned ArgIdx) const {
+  const FunctionDecl *FunctionDecl = SFC->getDecl()->getAsFunction();
+  unsigned NumArgs = FunctionDecl->getNumParams();
+  assert(ArgIdx < NumArgs && "Arg access out of range!");
+
+  if (SFC->inTopFrame()) {
+    // if we are in the top frame we don't have any arguments bound in the store
+    // because the call wasn't modeled in the first place.
+    const VarDecl *ArgDecl = FunctionDecl->parameters()[ArgIdx];
+    const Loc ArgLoc = getLValue(ArgDecl, SFC);
+    return getSVal(ArgLoc);
+  } else {
+    // in this case we need to ask the environment as  the arguments' memory
+    // region may have been purged as no longer needed.
+    const Stmt *callSite = SFC->getCallSite();
+    const CallExpr *callSiteExpr = dyn_cast<CallExpr>(callSite);
+    const Expr *argExpr = callSiteExpr->getArg(ArgIdx);
+    return getSVal(argExpr, SFC->getParent());
+  }
+}
+
 inline SVal ProgramState::getSVal(const Stmt *Ex,
                                   const LocationContext *LCtx) const{
   return Env.getSVal(EnvironmentEntry(Ex, LCtx),
                      *getStateManager().svalBuilder);
 }
 
 inline SVal
 ProgramState::getSValAsScalarOrLoc(const Stmt *S,