Cleaned up typedefs involving StateTy so that we always use "StateTy*" instead of...

This is conceptually much cleaner, as it shows that the state is always a pointer.
It also makes it easier to marshall these values around across the internal APIs
of the path-sensitive engine.

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

diff --git a/include/clang/Analysis/PathSensitive/ExplodedGraph.h b/include/clang/Analysis/PathSensitive/ExplodedGraph.h
index a3d1bfe82e58a1bcfeb6e117cb9bdc44336cb5b7..423f4f065c1c30cdb705ec910f6e53c6aa3b78b5 100644 (file)
--- a/include/clang/Analysis/PathSensitive/ExplodedGraph.h
+++ b/include/clang/Analysis/PathSensitive/ExplodedGraph.h
@@ -114,15 +114,6 @@ protected:
   }
   
 public:
-  // This method is only defined so that we can cast a
-  // void* to FoldingSet<ExplodedNodeImpl> so that we can iterate
-  // over the vertices of EdgeNodeSetMap in ExplodeGraphImpl.
-  // The actual profiling of vertices will be done in the derived
-  // class, ExplodedNode<>.  Nodes will NEVER be INSERTED into the
-  // FoldingSet using this Profile method (since it doesn't do anything).
-  inline void Profile(llvm::FoldingSetNodeID& ID) const {
-    assert (false && "Needs to be implemented in derived class.");
-  }
   
   /// getLocation - Returns the edge associated with the given node.
   const ProgramPoint& getLocation() const { return Location; }
@@ -139,11 +130,8 @@ public:
 
 template <typename StateTy>
 struct GRTrait {
-  static inline void* toPtr(StateTy S) {
-    return reinterpret_cast<void*>(S);
-  }  
-  static inline StateTy toState(void* P) {
-    return reinterpret_cast<StateTy>(P);
+  static inline void Profile(llvm::FoldingSetNodeID& ID, const StateTy* St) {
+    St->Profile(ID);
   }
 };
 
@@ -153,19 +141,19 @@ class ExplodedNode : public ExplodedNodeImpl {
 public:
   /// Construct a ExplodedNodeImpl with the given node ID, program edge,
   ///  and state.
-  explicit ExplodedNode(const ProgramPoint& loc, StateTy state)
-  : ExplodedNodeImpl(loc, GRTrait<StateTy>::toPtr(state)) {}
+  explicit ExplodedNode(const ProgramPoint& loc, StateTy* St)
+    : ExplodedNodeImpl(loc, St) {}
   
   /// getState - Returns the state associated with the node.  
-  inline StateTy getState() const {
-    return GRTrait<StateTy>::toState(State);
+  inline StateTy* getState() const {
+    return static_cast<StateTy*>(State);
   }
   
   // Profiling (for FoldingSet).
   
   static inline void Profile(llvm::FoldingSetNodeID& ID,
                              const ProgramPoint& Loc,
-                             StateTy state) {
+                             StateTy* state) {
     ID.Add(Loc);
     GRTrait<StateTy>::Profile(ID, state);
   }
@@ -293,7 +281,7 @@ protected:
 protected:
   virtual ExplodedNodeImpl*
   getNodeImpl(const ProgramPoint& L, void* State, bool* IsNew) {
-    return getNode(L, GRTrait<StateTy>::toState(State), IsNew);
+    return getNode(L, static_cast<StateTy*>(State), IsNew);
   }
     
 public:
@@ -309,7 +297,7 @@ public:
   ///  where the 'Location' is a ProgramPoint in the CFG.  If no node for
   ///  this pair exists, it is created.  IsNew is set to true if
   ///  the node was freshly created.
-  NodeTy* getNode(const ProgramPoint& L, StateTy State, bool* IsNew = NULL) {
+  NodeTy* getNode(const ProgramPoint& L, StateTy* State, bool* IsNew = NULL) {
     
     // Profile 'State' to determine if we already have an existing node.
     llvm::FoldingSetNodeID profile;    

diff --git a/include/clang/Analysis/PathSensitive/GRCoreEngine.h b/include/clang/Analysis/PathSensitive/GRCoreEngine.h
index 2051850c920428be3d16da67dc410f994fb97a98..53986a326ff405f063be843f3139ec73df0f1197 100644 (file)
--- a/include/clang/Analysis/PathSensitive/GRCoreEngine.h
+++ b/include/clang/Analysis/PathSensitive/GRCoreEngine.h
@@ -168,18 +168,16 @@ public:
     return static_cast<NodeTy*>(NB.getLastNode());
   }
   
-  NodeTy* generateNode(Stmt* S, StateTy State, NodeTy* Pred) {
-    void *state = GRTrait<StateTy>::toPtr(State);        
-    return static_cast<NodeTy*>(NB.generateNodeImpl(S, state, Pred));
+  NodeTy* generateNode(Stmt* S, StateTy* St, NodeTy* Pred) {
+    return static_cast<NodeTy*>(NB.generateNodeImpl(S, St, Pred));
   }
   
-  NodeTy* generateNode(Stmt* S, StateTy State) {
-    void *state = GRTrait<StateTy>::toPtr(State);
-    return static_cast<NodeTy*>(NB.generateNodeImpl(S, state));    
+  NodeTy* generateNode(Stmt* S, StateTy* St) {
+    return static_cast<NodeTy*>(NB.generateNodeImpl(S, St));    
   }
   
-  NodeTy* Nodify(ExplodedNodeSet<NodeTy> Dst, Stmt* S,
-                 NodeTy* Pred, StateTy St) {
+  NodeTy* Nodify(ExplodedNodeSet<NodeTy>& Dst, Stmt* S,
+                 NodeTy* Pred, StateTy* St) {
     
     // If the state hasn't changed, don't generate a new node.
     if (St == Pred->getState()) {
@@ -251,13 +249,12 @@ public:
     return static_cast<NodeTy*>(NB.getPredecessor());
   }
   
-  StateTy getState() const {
+  StateTy* getState() const {
     return getPredecessor()->getState();
   }
 
-  inline NodeTy* generateNode(StateTy State, bool branch) {
-    void *state = GRTrait<StateTy>::toPtr(State);        
-    return static_cast<NodeTy*>(NB.generateNodeImpl(state, branch));
+  inline NodeTy* generateNode(StateTy* St, bool branch) {
+    return static_cast<NodeTy*>(NB.generateNodeImpl(St, branch));
   }
   
   GRBlockCounter getBlockCounter() const {
@@ -334,13 +331,12 @@ public:
   
   inline Expr* getTarget() const { return NB.getTarget(); }
   
-  inline NodeTy* generateNode(const iterator& I, StateTy St, bool isSink=false){    
-    void *state = GRTrait<StateTy>::toPtr(St);        
-    return static_cast<NodeTy*>(NB.generateNodeImpl(I, state, isSink));
+  inline NodeTy* generateNode(const iterator& I, StateTy* St, bool isSink=false){    
+    return static_cast<NodeTy*>(NB.generateNodeImpl(I, St, isSink));
   }
   
-  inline StateTy getState() const {
-    return GRTrait<StateTy>::toState(NB.getState());
+  inline StateTy* getState() const {
+    return static_cast<StateTy*>(NB.getState());
   }    
 };
   
@@ -402,18 +398,16 @@ public:
   
   inline Expr* getCondition() const { return NB.getCondition(); }
   
-  inline NodeTy* generateCaseStmtNode(const iterator& I, StateTy St) {
-    void *state = GRTrait<StateTy>::toPtr(St);        
-    return static_cast<NodeTy*>(NB.generateCaseStmtNodeImpl(I, state));
+  inline NodeTy* generateCaseStmtNode(const iterator& I, StateTy* St) {
+    return static_cast<NodeTy*>(NB.generateCaseStmtNodeImpl(I, St));
   }
   
-  inline NodeTy* generateDefaultCaseNode(StateTy St, bool isSink = false) {    
-    void *state = GRTrait<StateTy>::toPtr(St);        
-    return static_cast<NodeTy*>(NB.generateDefaultCaseNodeImpl(state, isSink));
+  inline NodeTy* generateDefaultCaseNode(StateTy* St, bool isSink = false) {    
+    return static_cast<NodeTy*>(NB.generateDefaultCaseNodeImpl(St, isSink));
   }
   
-  inline StateTy getState() const {
-    return GRTrait<StateTy>::toState(NB.getState());
+  inline StateTy* getState() const {
+    return static_cast<StateTy*>(NB.getState());
   }    
 };
 
@@ -432,7 +426,7 @@ protected:
   CheckerTy* Checker;  
   
   virtual void* getInitialState() {
-    return GRTrait<StateTy>::toPtr(getCheckerState().getInitialState());
+    return getCheckerState().getInitialState();
   }
   
   virtual void* ProcessEOP(CFGBlock* Blk, void* State) {
@@ -448,7 +442,7 @@ protected:
   virtual bool ProcessBlockEntrance(CFGBlock* Blk, void* State,
                                     GRBlockCounter BC) {    
     return Checker->ProcessBlockEntrance(Blk,
-                                         GRTrait<StateTy>::toState(State), BC);
+                                         static_cast<StateTy*>(State), BC);
   }
 
   virtual void ProcessBranch(Expr* Condition, Stmt* Terminator,

diff --git a/include/clang/Analysis/PathSensitive/GRExprEngine.h b/include/clang/Analysis/PathSensitive/GRExprEngine.h
index a6d502f2a306206972d5718522583b5d130632f6..ffbd064c30b56b6053b90d1a2ccd0f7d92e25863 100644 (file)
--- a/include/clang/Analysis/PathSensitive/GRExprEngine.h
+++ b/include/clang/Analysis/PathSensitive/GRExprEngine.h
@@ -22,7 +22,7 @@ namespace clang {
 class GRExprEngine {
   
 public:
-  typedef ValueState*                 StateTy;
+  typedef ValueState                  StateTy;
   typedef ExplodedGraph<GRExprEngine> GraphTy;
   typedef GraphTy::NodeTy             NodeTy;
   

diff --git a/include/clang/Analysis/PathSensitive/ValueState.h b/include/clang/Analysis/PathSensitive/ValueState.h
index ba323b5a865f8fc86afd6aeb4da705c3528243b2..2d538f544c0327515bbb46010d8fa4484d47facc 100644 (file)
--- a/include/clang/Analysis/PathSensitive/ValueState.h
+++ b/include/clang/Analysis/PathSensitive/ValueState.h
@@ -93,7 +93,7 @@ public:
   
   /// Profile - Profile the contents of a ValueState object for use
   ///  in a FoldingSet.
-  static void Profile(llvm::FoldingSetNodeID& ID, ValueState* V) {
+  static void Profile(llvm::FoldingSetNodeID& ID, const ValueState* V) {
     V->SubExprBindings.Profile(ID);
     V->BlockExprBindings.Profile(ID);
     V->VarBindings.Profile(ID);
@@ -103,7 +103,7 @@ public:
 
   /// Profile - Used to profile the contents of this object for inclusion
   ///  in a FoldingSet.
-  void Profile(llvm::FoldingSetNodeID& ID) {
+  void Profile(llvm::FoldingSetNodeID& ID) const {
     Profile(ID, this);
   }