[analyzer] Remove StmtNodeBuilder from CheckerContext

It now only depends on a generic NodeBuilder instead. As part of this change, make the generic node builder results finalized by default.

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

diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
index 1d0d716944e4e94358a9cc55ee925917427345fb..c2188454c91e3278198ae39fb27fd31e725a424e 100644 (file)
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
@@ -24,7 +24,6 @@ namespace ento {
 
 class CheckerContext {
   ExplodedNodeSet &Dst;
-  StmtNodeBuilder &B;
   ExprEngine &Eng;
   ExplodedNode *Pred;
   const ProgramPoint Location;
@@ -32,26 +31,25 @@ class CheckerContext {
   const unsigned size;
   // TODO: Use global context.
   NodeBuilderContext Ctx;
-  NodeBuilder NB;
+  NodeBuilder &NB;
 public:
   bool *respondsToCallback;
 public:
   CheckerContext(ExplodedNodeSet &dst,
-                 StmtNodeBuilder &builder,
+                 NodeBuilder &builder,
                  ExprEngine &eng,
                  ExplodedNode *pred,
                  const ProgramPoint &loc,
                  bool *respondsToCB = 0,
                  const ProgramState *st = 0)
     : Dst(dst),
-      B(builder),
       Eng(eng),
       Pred(pred),
       Location(loc),
       ST(st),
       size(Dst.size()),
       Ctx(builder.C.Eng, builder.getBlock()),
-      NB(pred, Ctx),
+      NB(builder),
       respondsToCallback(respondsToCB) {
     assert(!(ST && ST != Pred->getState()));
   }

diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h b/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
index 6e9f54fca7687bb2c97225483bb690df00424fb5..7d7aa1417beba4d0a25cdc1b33f17b02494434e0 100644 (file)
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
@@ -187,6 +187,8 @@ public:
   const NodeBuilderContext &C;
 protected:
 
+  /// Specifies if the builder results have been finalized. For example, if it
+  /// is set to false, autotransitions are yet to be generated.
   bool Finalized;
 
   /// \brief The frontier set - a set of nodes which need to be propagated after
@@ -196,7 +198,8 @@ protected:
 
   BlockCounter getBlockCounter() const { return C.Eng.WList->getBlockCounter();}
 
-  bool checkResults() {
+  /// Checkes if the results are ready.
+  virtual bool checkResults() {
     if (!Finalized)
       return false;
     for (DeferredTy::iterator I=Deferred.begin(), E=Deferred.end(); I!=E; ++I)
@@ -205,11 +208,8 @@ protected:
     return true;
   }
 
-  virtual void finalizeResults() {
-    if (!Finalized) {
-      Finalized = true;
-    }
-  }
+  /// Allow subclasses to finalize results before result_begin() is executed.
+  virtual void finalizeResults() {}
   
   ExplodedNode *generateNodeImpl(const ProgramPoint &PP,
                                  const ProgramState *State,
@@ -217,15 +217,15 @@ protected:
                                  bool MarkAsSink = false);
 
 public:
-  NodeBuilder(ExplodedNode *N, NodeBuilderContext &Ctx)
-    : BuilderPred(N), C(Ctx), Finalized(false) {
+  NodeBuilder(ExplodedNode *N, NodeBuilderContext &Ctx, bool F = true)
+    : BuilderPred(N), C(Ctx), Finalized(F) {
     assert(!N->isSink());
     Deferred.insert(N);
   }
 
   /// Create a new builder using the parent builder's context.
-  NodeBuilder(ExplodedNode *N, const NodeBuilder &ParentBldr)
-    : BuilderPred(N), C(ParentBldr.C), Finalized(false) {
+  NodeBuilder(ExplodedNode *N, const NodeBuilder &ParentBldr, bool F = true)
+    : BuilderPred(N), C(ParentBldr.C), Finalized(F) {
     assert(!N->isSink());
     Deferred.insert(N);
   }
@@ -383,6 +383,8 @@ class BranchNodeBuilder: public NodeBuilder {
   bool InFeasibleTrue;
   bool InFeasibleFalse;
 
+  /// Generate default branching transitions of none were generated or
+  /// suppressed.
   void finalizeResults() {
     if (Finalized)
       return;
@@ -394,15 +396,15 @@ class BranchNodeBuilder: public NodeBuilder {
 public:
   BranchNodeBuilder(ExplodedNode *Pred, NodeBuilderContext &C,
                     const CFGBlock *dstT, const CFGBlock *dstF)
-  : NodeBuilder(Pred, C), DstT(dstT), DstF(dstF),
+  : NodeBuilder(Pred, C, false), DstT(dstT), DstF(dstF),
     GeneratedTrue(false), GeneratedFalse(false),
     InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
   }
 
   /// Create a new builder using the parent builder's context.
   BranchNodeBuilder(ExplodedNode *Pred, BranchNodeBuilder &ParentBldr)
-  : NodeBuilder(Pred, ParentBldr), DstT(ParentBldr.DstT), DstF(ParentBldr.DstF),
-    GeneratedTrue(false), GeneratedFalse(false),
+  : NodeBuilder(Pred, ParentBldr, false), DstT(ParentBldr.DstT),
+    DstF(ParentBldr.DstF), GeneratedTrue(false), GeneratedFalse(false),
     InFeasibleTrue(!DstT), InFeasibleFalse(!DstF) {
   }
 

diff --git a/lib/StaticAnalyzer/Core/CheckerContext.cpp b/lib/StaticAnalyzer/Core/CheckerContext.cpp
index e380165c2e86ffbeb204b9b08ece5e17cac413e3..26479d055218ebe20695fcdac5b1bd777e3ecbcd 100644 (file)
--- a/lib/StaticAnalyzer/Core/CheckerContext.cpp
+++ b/lib/StaticAnalyzer/Core/CheckerContext.cpp
@@ -22,8 +22,4 @@ CheckerContext::~CheckerContext() {
                              E = NB.results_end(); I != E; ++I) {
     Dst.Add(*I);
   }
-
-  // Copy the results  into the StmtNodeBuilder.
-  //TODO: This will be removed after we completely migrate NodeBuilder.
-  B.importNodesFromBuilder(NB);
 }

diff --git a/lib/StaticAnalyzer/Core/CoreEngine.cpp b/lib/StaticAnalyzer/Core/CoreEngine.cpp
index fda7bbdf4c6aca3190e9fa01bc922f6d3533fdf3..0a308670c0c4bf32d4cbf59751b60327bc16f1ff 100644 (file)
--- a/lib/StaticAnalyzer/Core/CoreEngine.cpp
+++ b/lib/StaticAnalyzer/Core/CoreEngine.cpp
@@ -489,9 +489,6 @@ ExplodedNode* NodeBuilder::generateNodeImpl(const ProgramPoint &Loc,
                                             const ProgramState *State,
                                             ExplodedNode *FromN,
                                             bool MarkAsSink) {
-  assert(Finalized == false &&
-         "We cannot create new nodes after the results have been finalized.");
-
   bool IsNew;
   ExplodedNode *N = C.Eng.G->getNode(Loc, State, &IsNew);
   N->addPredecessor(FromN, *C.Eng.G);
@@ -570,6 +567,8 @@ ExplodedNode *StmtNodeBuilder::MakeNode(ExplodedNodeSet &Dst,
 ExplodedNode *BranchNodeBuilder::generateNode(const ProgramState *State,
                                               bool branch,
                                               ExplodedNode *NodePred) {
+  assert(Finalized == false &&
+         "We cannot create new nodes after the results have been finalized.");
 
   // If the branch has been marked infeasible we should not generate a node.
   if (!isFeasible(branch))