* Remove unused GRState* parameter

* Make all Base value the last argument.


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@84071 91177308-0d34-0410-b5e6-96231b3b80d8

5 files changed, 50 insertions, 72 deletions

diff --git a/include/clang/Analysis/PathSensitive/GRState.h b/include/clang/Analysis/PathSensitive/GRState.h
index f4224e4b09..d8b9d560cc 100644
--- a/include/clang/Analysis/PathSensitive/GRState.h
+++ b/include/clang/Analysis/PathSensitive/GRState.h
@@ -243,10 +243,10 @@ public:
   SVal getLValue(const ObjCIvarDecl *decl, SVal base) const;
 
   /// Get the lvalue for a field reference.
-  SVal getLValue(SVal Base, const FieldDecl *decl) const;
+  SVal getLValue(const FieldDecl *decl, SVal Base) const;
 
   /// Get the lvalue for an array index.
-  SVal getLValue(QualType ElementType, SVal Base, SVal Idx) const;
+  SVal getLValue(QualType ElementType, SVal Idx, SVal Base) const;
 
   const llvm::APSInt *getSymVal(SymbolRef sym) const;
 
@@ -623,27 +623,27 @@ inline const GRState *GRState::bindLoc(SVal LV, SVal V) const {
 
 inline SVal GRState::getLValue(const VarDecl* VD,
                                const LocationContext *LC) const {
-  return getStateManager().StoreMgr->getLValueVar(this, VD, LC);
+  return getStateManager().StoreMgr->getLValueVar(VD, LC);
 }
 
 inline SVal GRState::getLValue(const StringLiteral *literal) const {
-  return getStateManager().StoreMgr->getLValueString(this, literal);
+  return getStateManager().StoreMgr->getLValueString(literal);
 }
 
 inline SVal GRState::getLValue(const CompoundLiteralExpr *literal) const {
-  return getStateManager().StoreMgr->getLValueCompoundLiteral(this, literal);
+  return getStateManager().StoreMgr->getLValueCompoundLiteral(literal);
 }
 
 inline SVal GRState::getLValue(const ObjCIvarDecl *D, SVal Base) const {
-  return getStateManager().StoreMgr->getLValueIvar(this, D, Base);
+  return getStateManager().StoreMgr->getLValueIvar(D, Base);
 }
 
-inline SVal GRState::getLValue(SVal Base, const FieldDecl* D) const {
-  return getStateManager().StoreMgr->getLValueField(this, Base, D);
+inline SVal GRState::getLValue(const FieldDecl* D, SVal Base) const {
+  return getStateManager().StoreMgr->getLValueField(D, Base);
 }
 
-inline SVal GRState::getLValue(QualType ElementType, SVal Base, SVal Idx) const{
-  return getStateManager().StoreMgr->getLValueElement(this, ElementType, Base, Idx);
+inline SVal GRState::getLValue(QualType ElementType, SVal Idx, SVal Base) const{
+  return getStateManager().StoreMgr->getLValueElement(ElementType, Idx, Base);
 }
 
 inline const llvm::APSInt *GRState::getSymVal(SymbolRef sym) const {
diff --git a/include/clang/Analysis/PathSensitive/Store.h b/include/clang/Analysis/PathSensitive/Store.h
index c9713c0b36..ed2da1a59a 100644
--- a/include/clang/Analysis/PathSensitive/Store.h
+++ b/include/clang/Analysis/PathSensitive/Store.h
@@ -89,23 +89,17 @@ public:
   //   caller's responsibility to 'delete' the returned map.
   virtual SubRegionMap *getSubRegionMap(const GRState *state) = 0;
 
-  virtual SVal getLValueVar(const GRState *ST, const VarDecl *VD,
-                            const LocationContext *LC) = 0;
+  virtual SVal getLValueVar(const VarDecl *VD, const LocationContext *LC) = 0;
 
-  virtual SVal getLValueString(const GRState *state,
-                               const StringLiteral* sl) = 0;
+  virtual SVal getLValueString(const StringLiteral* sl) = 0;
 
-  virtual SVal getLValueCompoundLiteral(const GRState *state,
-                                        const CompoundLiteralExpr* cl) = 0;
+  virtual SVal getLValueCompoundLiteral(const CompoundLiteralExpr* cl) = 0;
 
-  virtual SVal getLValueIvar(const GRState *state, const ObjCIvarDecl* decl,
-                             SVal base) = 0;
+  virtual SVal getLValueIvar(const ObjCIvarDecl* decl, SVal base) = 0;
 
-  virtual SVal getLValueField(const GRState *state, SVal base,
-                              const FieldDecl* D) = 0;
+  virtual SVal getLValueField(const FieldDecl* D, SVal Base) = 0;
 
-  virtual SVal getLValueElement(const GRState *state, QualType elementType,
-                                SVal base, SVal offset) = 0;
+  virtual SVal getLValueElement(QualType elementType, SVal offset, SVal Base)=0;
 
   // FIXME: Make out-of-line.
   virtual SVal getSizeInElements(const GRState *state, const MemRegion *region){
diff --git a/lib/Analysis/BasicStore.cpp b/lib/Analysis/BasicStore.cpp
index e2a19cf834..a4f451f364 100644
--- a/lib/Analysis/BasicStore.cpp
+++ b/lib/Analysis/BasicStore.cpp
@@ -73,15 +73,12 @@ public:
     return state;
   }
 
-  SVal getLValueVar(const GRState *state, const VarDecl *VD,
-                    const LocationContext *LC);
-  SVal getLValueString(const GRState *state, const StringLiteral *S);
-  SVal getLValueCompoundLiteral(const GRState *state,
-                                const CompoundLiteralExpr *CL);
-  SVal getLValueIvar(const GRState *state, const ObjCIvarDecl* D, SVal Base);
-  SVal getLValueField(const GRState *state, SVal Base, const FieldDecl *D);
-  SVal getLValueElement(const GRState *state, QualType elementType,
-                        SVal Base, SVal Offset);
+  SVal getLValueVar(const VarDecl *VD, const LocationContext *LC);
+  SVal getLValueString(const StringLiteral *S);
+  SVal getLValueCompoundLiteral(const CompoundLiteralExpr *CL);
+  SVal getLValueIvar(const ObjCIvarDecl* D, SVal Base);
+  SVal getLValueField(const FieldDecl *D, SVal Base);
+  SVal getLValueElement(QualType elementType, SVal Offset, SVal Base);
 
   /// ArrayToPointer - Used by GRExprEngine::VistCast to handle implicit
   ///  conversions between arrays and pointers.
@@ -126,24 +123,20 @@ StoreManager* clang::CreateBasicStoreManager(GRStateManager& StMgr) {
   return new BasicStoreManager(StMgr);
 }
 
-SVal BasicStoreManager::getLValueVar(const GRState *state, const VarDecl* VD,
+SVal BasicStoreManager::getLValueVar(const VarDecl* VD, 
                                      const LocationContext *LC) {
   return ValMgr.makeLoc(MRMgr.getVarRegion(VD, LC));
 }
 
-SVal BasicStoreManager::getLValueString(const GRState *state,
-                                        const StringLiteral* S) {
+SVal BasicStoreManager::getLValueString(const StringLiteral* S) {
   return ValMgr.makeLoc(MRMgr.getStringRegion(S));
 }
 
-SVal BasicStoreManager::getLValueCompoundLiteral(const GRState *state,
-                                                 const CompoundLiteralExpr* CL){
+SVal BasicStoreManager::getLValueCompoundLiteral(const CompoundLiteralExpr* CL){
   return ValMgr.makeLoc(MRMgr.getCompoundLiteralRegion(CL));
 }
 
-SVal BasicStoreManager::getLValueIvar(const GRState *state,
-                                      const ObjCIvarDecl* D,
-                                      SVal Base) {
+SVal BasicStoreManager::getLValueIvar(const ObjCIvarDecl* D, SVal Base) {
 
   if (Base.isUnknownOrUndef())
     return Base;
@@ -158,8 +151,7 @@ SVal BasicStoreManager::getLValueIvar(const GRState *state,
   return UnknownVal();
 }
 
-SVal BasicStoreManager::getLValueField(const GRState *state, SVal Base,
-                                       const FieldDecl* D) {
+SVal BasicStoreManager::getLValueField(const FieldDecl* D, SVal Base) {
 
   if (Base.isUnknownOrUndef())
     return Base;
@@ -190,9 +182,8 @@ SVal BasicStoreManager::getLValueField(const GRState *state, SVal Base,
   return ValMgr.makeLoc(MRMgr.getFieldRegion(D, BaseR));
 }
 
-SVal BasicStoreManager::getLValueElement(const GRState *state,
-                                         QualType elementType,
-                                         SVal Base, SVal Offset) {
+SVal BasicStoreManager::getLValueElement(QualType elementType,
+                                         SVal Offset, SVal Base) {
 
   if (Base.isUnknownOrUndef())
     return Base;
diff --git a/lib/Analysis/GRExprEngine.cpp b/lib/Analysis/GRExprEngine.cpp
index 8de200cb1e..35a1bf2d72 100644
--- a/lib/Analysis/GRExprEngine.cpp
+++ b/lib/Analysis/GRExprEngine.cpp
@@ -1042,8 +1042,8 @@ void GRExprEngine::VisitArraySubscriptExpr(ArraySubscriptExpr* A,
 
     for (ExplodedNodeSet::iterator I2=Tmp2.begin(),E2=Tmp2.end();I2!=E2; ++I2) {
       const GRState* state = GetState(*I2);
-      SVal V = state->getLValue(A->getType(), state->getSVal(Base),
-                                state->getSVal(Idx));
+      SVal V = state->getLValue(A->getType(), state->getSVal(Idx),
+                                state->getSVal(Base));
 
       if (asLValue)
         MakeNode(Dst, A, *I2, state->BindExpr(A, V),
@@ -1075,7 +1075,7 @@ void GRExprEngine::VisitMemberExpr(MemberExpr* M, ExplodedNode* Pred,
     // FIXME: Should we insert some assumption logic in here to determine
     // if "Base" is a valid piece of memory?  Before we put this assumption
     // later when using FieldOffset lvals (which we no longer have).
-    SVal L = state->getLValue(state->getSVal(Base), Field);
+    SVal L = state->getLValue(Field, state->getSVal(Base));
 
     if (asLValue)
       MakeNode(Dst, M, *I, state->BindExpr(M, L),
diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp
index 63bfa97c4d..3844d6a614 100644
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -220,28 +220,26 @@ public:
   ///  StringLiteral.  Within RegionStore a StringLiteral has an
   ///  associated StringRegion, and the lvalue of a StringLiteral is
   ///  the lvalue of that region.
-  SVal getLValueString(const GRState *state, const StringLiteral* S);
+  SVal getLValueString(const StringLiteral* S);
 
   /// getLValueCompoundLiteral - Returns an SVal representing the
   ///   lvalue of a compound literal.  Within RegionStore a compound
   ///   literal has an associated region, and the lvalue of the
   ///   compound literal is the lvalue of that region.
-  SVal getLValueCompoundLiteral(const GRState *state, const CompoundLiteralExpr*);
+  SVal getLValueCompoundLiteral(const CompoundLiteralExpr*);
 
   /// getLValueVar - Returns an SVal that represents the lvalue of a
   ///  variable.  Within RegionStore a variable has an associated
   ///  VarRegion, and the lvalue of the variable is the lvalue of that region.
-  SVal getLValueVar(const GRState *ST, const VarDecl *VD,
-                    const LocationContext *LC);
+  SVal getLValueVar(const VarDecl *VD, const LocationContext *LC);
 
-  SVal getLValueIvar(const GRState *state, const ObjCIvarDecl* D, SVal Base);
+  SVal getLValueIvar(const ObjCIvarDecl* D, SVal Base);
 
-  SVal getLValueField(const GRState *state, SVal Base, const FieldDecl* D);
+  SVal getLValueField(const FieldDecl* D, SVal Base);
 
-  SVal getLValueFieldOrIvar(const GRState *state, SVal Base, const Decl* D);
+  SVal getLValueFieldOrIvar(const Decl* D, SVal Base);
 
-  SVal getLValueElement(const GRState *state, QualType elementType,
-                        SVal Base, SVal Offset);
+  SVal getLValueElement(QualType elementType, SVal Offset, SVal Base);
 
 
   /// ArrayToPointer - Emulates the "decay" of an array to a pointer
@@ -561,15 +559,14 @@ const GRState *RegionStoreManager::InvalidateRegion(const GRState *state,
 ///  StringLiteral.  Within RegionStore a StringLiteral has an
 ///  associated StringRegion, and the lvalue of a StringLiteral is the
 ///  lvalue of that region.
-SVal RegionStoreManager::getLValueString(const GRState *St,
-                                         const StringLiteral* S) {
+SVal RegionStoreManager::getLValueString(const StringLiteral* S) {
   return loc::MemRegionVal(MRMgr.getStringRegion(S));
 }
 
 /// getLValueVar - Returns an SVal that represents the lvalue of a
 ///  variable.  Within RegionStore a variable has an associated
 ///  VarRegion, and the lvalue of the variable is the lvalue of that region.
-SVal RegionStoreManager::getLValueVar(const GRState *ST, const VarDecl *VD,
+SVal RegionStoreManager::getLValueVar(const VarDecl *VD, 
                                       const LocationContext *LC) {
   return loc::MemRegionVal(MRMgr.getVarRegion(VD, LC));
 }
@@ -578,23 +575,20 @@ SVal RegionStoreManager::getLValueVar(const GRState *ST, const VarDecl *VD,
 ///   of a compound literal.  Within RegionStore a compound literal
 ///   has an associated region, and the lvalue of the compound literal
 ///   is the lvalue of that region.
-SVal RegionStoreManager::getLValueCompoundLiteral(const GRState *St,
-                                                const CompoundLiteralExpr* CL) {
+SVal 
+RegionStoreManager::getLValueCompoundLiteral(const CompoundLiteralExpr* CL) {
   return loc::MemRegionVal(MRMgr.getCompoundLiteralRegion(CL));
 }
 
-SVal RegionStoreManager::getLValueIvar(const GRState *St, const ObjCIvarDecl* D,
-                                       SVal Base) {
-  return getLValueFieldOrIvar(St, Base, D);
+SVal RegionStoreManager::getLValueIvar(const ObjCIvarDecl* D, SVal Base) {
+  return getLValueFieldOrIvar(D, Base);
 }
 
-SVal RegionStoreManager::getLValueField(const GRState *St, SVal Base,
-                                        const FieldDecl* D) {
-  return getLValueFieldOrIvar(St, Base, D);
+SVal RegionStoreManager::getLValueField(const FieldDecl* D, SVal Base) {
+  return getLValueFieldOrIvar(D, Base);
 }
 
-SVal RegionStoreManager::getLValueFieldOrIvar(const GRState *St, SVal Base,
-                                              const Decl* D) {
+SVal RegionStoreManager::getLValueFieldOrIvar(const Decl* D, SVal Base) {
   if (Base.isUnknownOrUndef())
     return Base;
 
@@ -630,9 +624,8 @@ SVal RegionStoreManager::getLValueFieldOrIvar(const GRState *St, SVal Base,
   return loc::MemRegionVal(MRMgr.getFieldRegion(cast<FieldDecl>(D), BaseR));
 }
 
-SVal RegionStoreManager::getLValueElement(const GRState *St,
-                                          QualType elementType,
-                                          SVal Base, SVal Offset) {
+SVal RegionStoreManager::getLValueElement(QualType elementType, SVal Offset, 
+                                          SVal Base) {
 
   // If the base is an unknown or undefined value, just return it back.
   // FIXME: For absolute pointer addresses, we just return that value back as