1 files changed, 80 insertions, 21 deletions

diff --git a/include/clang/Analysis/PathSensitive/Checker.h b/include/clang/Analysis/PathSensitive/Checker.h
index b7ed20f..91a4b6d 100644
--- a/include/clang/Analysis/PathSensitive/Checker.h
+++ b/include/clang/Analysis/PathSensitive/Checker.h
@@ -40,24 +40,35 @@ class CheckerContext {
   SaveAndRestore<ProgramPoint::Kind> OldPointKind;
   SaveOr OldHasGen;
   const GRState *state;
-
+  const Stmt *statement;
+  const unsigned size;
+  bool DoneEvaluating; // FIXME: This is not a permanent API change.
 public:
   CheckerContext(ExplodedNodeSet &dst, GRStmtNodeBuilder &builder,
                  GRExprEngine &eng, ExplodedNode *pred,
                  const void *tag, ProgramPoint::Kind K,
-                 const GRState *st = 0)
+                 const Stmt *stmt = 0, const GRState *st = 0)
     : Dst(dst), B(builder), Eng(eng), Pred(pred),
       OldSink(B.BuildSinks),
       OldTag(B.Tag, tag),
       OldPointKind(B.PointKind, K),
       OldHasGen(B.HasGeneratedNode),
-      state(st) {}
+      state(st), statement(stmt), size(Dst.size()),
+      DoneEvaluating(false) {}
 
-  ~CheckerContext() {
-    if (!B.BuildSinks && !B.HasGeneratedNode)
-      Dst.Add(Pred);
+  ~CheckerContext();
+  
+  // FIXME: This were added to support CallAndMessageChecker to indicating
+  // to GRExprEngine to "stop evaluating" a message expression under certain
+  // cases.  This is *not* meant to be a permanent API change, and was added
+  // to aid in the transition of removing logic for checks from GRExprEngine.  
+  void setDoneEvaluating() {
+    DoneEvaluating = true;
   }
-
+  bool isDoneEvaluating() const {
+    return DoneEvaluating;
+  }
+  
   ConstraintManager &getConstraintManager() {
       return Eng.getConstraintManager();
   }
@@ -83,27 +94,70 @@ public:
     return getBugReporter().getSourceManager();
   }
 
-  ExplodedNode *GenerateNode(const Stmt *S, bool markAsSink = false) {
-    return GenerateNode(S, getState(), markAsSink);
+  ValueManager &getValueManager() {
+    return Eng.getValueManager();
   }
 
-  ExplodedNode *GenerateNode(const Stmt* S, const GRState *state,
-                             bool markAsSink = false) {
-    ExplodedNode *node = B.generateNode(S, state, Pred);
+  ExplodedNode *GenerateNode(bool autoTransition = true) {
+    assert(statement && "Only transitions with statements currently supported");
+    ExplodedNode *N = GenerateNodeImpl(statement, getState(), false);
+    if (N && autoTransition)
+      Dst.Add(N);
+    return N;
+  }
+  
+  ExplodedNode *GenerateNode(const Stmt *stmt, const GRState *state,
+                             bool autoTransition = true) {
+    assert(state);
+    ExplodedNode *N = GenerateNodeImpl(stmt, state, false);
+    if (N && autoTransition)
+      addTransition(N);
+    return N;
+  }
 
-    if (markAsSink && node)
-      node->markAsSink();
+  ExplodedNode *GenerateNode(const GRState *state, bool autoTransition = true) {
+    assert(statement && "Only transitions with statements currently supported");
+    ExplodedNode *N = GenerateNodeImpl(statement, state, false);
+    if (N && autoTransition)
+      addTransition(N);
+    return N;
+  }
 
-    return node;
+  ExplodedNode *GenerateSink(const Stmt *stmt, const GRState *state = 0) {
+    return GenerateNodeImpl(stmt, state ? state : getState(), true);
+  }
+  
+  ExplodedNode *GenerateSink(const GRState *state = 0) {
+    assert(statement && "Only transitions with statements currently supported");
+    return GenerateNodeImpl(statement, state ? state : getState(), true);
   }
 
   void addTransition(ExplodedNode *node) {
     Dst.Add(node);
   }
+  
+  void addTransition(const GRState *state) {
+    assert(state);
+    if (state != getState() || 
+        (state && state != B.GetState(Pred)))
+      GenerateNode(state, true);
+    else
+      Dst.Add(Pred);
+  }
 
   void EmitReport(BugReport *R) {
     Eng.getBugReporter().EmitReport(R);
   }
+
+private:
+  ExplodedNode *GenerateNodeImpl(const Stmt* stmt, const GRState *state,
+                             bool markAsSink) {
+    ExplodedNode *node = B.generateNode(stmt, state, Pred);
+    if (markAsSink && node)
+      node->markAsSink();
+    return node;
+  }
+  
 };
 
 class Checker {
@@ -111,18 +165,19 @@ private:
   friend class GRExprEngine;
 
   // FIXME: Remove the 'tag' option.
-  void GR_Visit(ExplodedNodeSet &Dst,
+  bool GR_Visit(ExplodedNodeSet &Dst,
                 GRStmtNodeBuilder &Builder,
                 GRExprEngine &Eng,
                 const Stmt *S,
                 ExplodedNode *Pred, void *tag, bool isPrevisit) {
     CheckerContext C(Dst, Builder, Eng, Pred, tag,
                      isPrevisit ? ProgramPoint::PreStmtKind :
-                     ProgramPoint::PostStmtKind);
+                     ProgramPoint::PostStmtKind, S);
     if (isPrevisit)
       _PreVisit(C, S);
     else
       _PostVisit(C, S);
+    return C.isDoneEvaluating();
   }
 
   // FIXME: Remove the 'tag' option.
@@ -134,7 +189,7 @@ private:
                     bool isPrevisit) {
     CheckerContext C(Dst, Builder, Eng, Pred, tag,
                      isPrevisit ? ProgramPoint::PreStmtKind :
-                     ProgramPoint::PostStmtKind);
+                     ProgramPoint::PostStmtKind, StoreE);
     assert(isPrevisit && "Only previsit supported for now.");
     PreVisitBind(C, AssignE, StoreE, location, val);
   }
@@ -149,7 +204,7 @@ private:
                         void *tag, bool isLoad) {
     CheckerContext C(Dst, Builder, Eng, Pred, tag,
                      isLoad ? ProgramPoint::PreLoadKind :
-                     ProgramPoint::PreStoreKind, state);
+                     ProgramPoint::PreStoreKind, S, state);
     VisitLocation(C, S, location);
   }
 
@@ -157,12 +212,12 @@ private:
                           GRExprEngine &Eng, const Stmt *S, ExplodedNode *Pred,
                           SymbolReaper &SymReaper, void *tag) {
     CheckerContext C(Dst, Builder, Eng, Pred, tag, 
-                     ProgramPoint::PostPurgeDeadSymbolsKind, Pred->getState());
+                     ProgramPoint::PostPurgeDeadSymbolsKind, S);
     EvalDeadSymbols(C, S, SymReaper);
   }
 
 public:
-  virtual ~Checker() {}
+  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) {}
@@ -172,6 +227,10 @@ public:
                                SymbolReaper &SymReaper) {}
   virtual void EvalEndPath(GREndPathNodeBuilder &B, void *tag,
                            GRExprEngine &Eng) {}
+
+  virtual void VisitBranchCondition(GRBranchNodeBuilder &Builder,
+                                    GRExprEngine &Eng,
+                                    Stmt *Condition, void *tag) {}
 };
 } // end clang namespace