1 files changed, 62 insertions, 37 deletions

diff --git a/include/clang/Analysis/PathSensitive/Checker.h b/include/clang/Analysis/PathSensitive/Checker.h
index 4fc0a617ecf0..b7ed20fab250 100644
--- a/include/clang/Analysis/PathSensitive/Checker.h
+++ b/include/clang/Analysis/PathSensitive/Checker.h
@@ -39,22 +39,19 @@ class CheckerContext {
   SaveAndRestore<const void*> OldTag;
   SaveAndRestore<ProgramPoint::Kind> OldPointKind;
   SaveOr OldHasGen;
+  const GRState *state;
 
 public:
-  CheckerContext(ExplodedNodeSet &dst,
-                 GRStmtNodeBuilder &builder,
-                 GRExprEngine &eng,
-                 ExplodedNode *pred,
-                 const void *tag, bool preVisit)
+  CheckerContext(ExplodedNodeSet &dst, GRStmtNodeBuilder &builder,
+                 GRExprEngine &eng, ExplodedNode *pred,
+                 const void *tag, ProgramPoint::Kind K,
+                 const GRState *st = 0)
     : Dst(dst), B(builder), Eng(eng), Pred(pred),
-      OldSink(B.BuildSinks), OldTag(B.Tag),
-      OldPointKind(B.PointKind), OldHasGen(B.HasGeneratedNode) {
-        //assert(Dst.empty()); // This is a fake assertion.
-              // See GRExprEngine::CheckerVisit(), CurrSet is repeatedly used.
-        B.Tag = tag;
-        if (preVisit)
-          B.PointKind = ProgramPoint::PreStmtKind;
-      }
+      OldSink(B.BuildSinks),
+      OldTag(B.Tag, tag),
+      OldPointKind(B.PointKind, K),
+      OldHasGen(B.HasGeneratedNode),
+      state(st) {}
 
   ~CheckerContext() {
     if (!B.BuildSinks && !B.HasGeneratedNode)
@@ -64,10 +61,15 @@ public:
   ConstraintManager &getConstraintManager() {
       return Eng.getConstraintManager();
   }
+
+  StoreManager &getStoreManager() {
+    return Eng.getStoreManager();
+  }
+
   ExplodedNodeSet &getNodeSet() { return Dst; }
   GRStmtNodeBuilder &getNodeBuilder() { return B; }
   ExplodedNode *&getPredecessor() { return Pred; }
-  const GRState *getState() { return B.GetState(Pred); }
+  const GRState *getState() { return state ? state : B.GetState(Pred); }
 
   ASTContext &getASTContext() {
     return Eng.getContext();
@@ -76,6 +78,10 @@ public:
   BugReporter &getBugReporter() {
     return Eng.getBugReporter();
   }
+  
+  SourceManager &getSourceManager() {
+    return getBugReporter().getSourceManager();
+  }
 
   ExplodedNode *GenerateNode(const Stmt *S, bool markAsSink = false) {
     return GenerateNode(S, getState(), markAsSink);
@@ -104,50 +110,69 @@ class Checker {
 private:
   friend class GRExprEngine;
 
+  // FIXME: Remove the 'tag' option.
   void GR_Visit(ExplodedNodeSet &Dst,
                 GRStmtNodeBuilder &Builder,
                 GRExprEngine &Eng,
-                const Stmt *stmt,
+                const Stmt *S,
                 ExplodedNode *Pred, void *tag, bool isPrevisit) {
-    CheckerContext C(Dst, Builder, Eng, Pred, tag, isPrevisit);
-    assert(isPrevisit && "Only previsit supported for now.");
-    _PreVisit(C, stmt);
+    CheckerContext C(Dst, Builder, Eng, Pred, tag,
+                     isPrevisit ? ProgramPoint::PreStmtKind :
+                     ProgramPoint::PostStmtKind);
+    if (isPrevisit)
+      _PreVisit(C, S);
+    else
+      _PostVisit(C, S);
   }
 
+  // FIXME: Remove the 'tag' option.
   void GR_VisitBind(ExplodedNodeSet &Dst,
                     GRStmtNodeBuilder &Builder, GRExprEngine &Eng,
                     const Stmt *AssignE,
                     const Stmt *StoreE, ExplodedNode *Pred, void *tag, 
                     SVal location, SVal val,
                     bool isPrevisit) {
-    CheckerContext C(Dst, Builder, Eng, Pred, tag, isPrevisit);
+    CheckerContext C(Dst, Builder, Eng, Pred, tag,
+                     isPrevisit ? ProgramPoint::PreStmtKind :
+                     ProgramPoint::PostStmtKind);
     assert(isPrevisit && "Only previsit supported for now.");
     PreVisitBind(C, AssignE, StoreE, location, val);
   }
-
-public:
-  virtual ~Checker() {}
-  virtual void _PreVisit(CheckerContext &C, const Stmt *ST) {}
   
-  // This is a previsit which takes a node returns a node.
-  virtual ExplodedNode *CheckLocation(const Stmt *S, ExplodedNode *Pred,
-                                      const GRState *state, SVal V,
-                                      GRExprEngine &Eng) {
-    return Pred;
+  // FIXME: Remove the 'tag' option.
+  void GR_VisitLocation(ExplodedNodeSet &Dst,
+                        GRStmtNodeBuilder &Builder,
+                        GRExprEngine &Eng,
+                        const Stmt *S,
+                        ExplodedNode *Pred, const GRState *state,
+                        SVal location,
+                        void *tag, bool isLoad) {
+    CheckerContext C(Dst, Builder, Eng, Pred, tag,
+                     isLoad ? ProgramPoint::PreLoadKind :
+                     ProgramPoint::PreStoreKind, state);
+    VisitLocation(C, S, location);
   }
-  
-  virtual void PreVisitBind(CheckerContext &C,
-                            const Stmt *AssignE, const Stmt *StoreE, 
-                            SVal location, SVal val) {}
 
-  virtual ExplodedNode *CheckType(QualType T, ExplodedNode *Pred, 
-                                  const GRState *state, Stmt *S, 
-                                  GRExprEngine &Eng) {
-    return Pred;
+  void GR_EvalDeadSymbols(ExplodedNodeSet &Dst, GRStmtNodeBuilder &Builder,
+                          GRExprEngine &Eng, const Stmt *S, ExplodedNode *Pred,
+                          SymbolReaper &SymReaper, void *tag) {
+    CheckerContext C(Dst, Builder, Eng, Pred, tag, 
+                     ProgramPoint::PostPurgeDeadSymbolsKind, Pred->getState());
+    EvalDeadSymbols(C, S, SymReaper);
   }
 
+public:
+  virtual ~Checker() {}
+  virtual void _PreVisit(CheckerContext &C, const Stmt *S) {}
+  virtual void _PostVisit(CheckerContext &C, const Stmt *S) {}
+  virtual void VisitLocation(CheckerContext &C, const Stmt *S, SVal location) {}
+  virtual void PreVisitBind(CheckerContext &C, const Stmt *AssignE,
+                            const Stmt *StoreE, SVal location, SVal val) {}
+  virtual void EvalDeadSymbols(CheckerContext &C, const Stmt *S,
+                               SymbolReaper &SymReaper) {}
+  virtual void EvalEndPath(GREndPathNodeBuilder &B, void *tag,
+                           GRExprEngine &Eng) {}
 };
-
 } // end clang namespace
 
 #endif