[analyzer] Move enqueueEndOfFunction into CoreEngine.

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

diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h b/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
index ca98e637e0553fef3361f5c305cefcf3f097fdc2..87751d28a3e2f5dc5a004e4d2e1f55f055d61ca3 100644 (file)
--- a/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
+++ b/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h
@@ -47,7 +47,6 @@ class CoreEngine {
   friend class EndOfFunctionNodeBuilder;
   friend class CallEnterNodeBuilder;
   friend class CallExitNodeBuilder;
-  friend class ExprEngine;
 
 public:
   typedef std::vector<std::pair<BlockEdge, const ExplodedNode*> >
@@ -103,6 +102,8 @@ private:
   void enqueueStmtNode(ExplodedNode *N,
                        const CFGBlock *Block, unsigned Idx);
 
+  ExplodedNode *generateCallExitNode(ExplodedNode *N);
+
 public:
   /// Construct a CoreEngine object to analyze the provided CFG using
   ///  a DFS exploration of the exploded graph.
@@ -167,11 +168,15 @@ public:
   }
 
   /// \brief Enqueue the given set of nodes onto the work list.
-  void enqueue(ExplodedNodeSet &NB);
+  void enqueue(ExplodedNodeSet &Set);
 
   /// \brief Enqueue nodes that were created as a result of processing
   /// a statement onto the work list.
   void enqueue(ExplodedNodeSet &Set, const CFGBlock *Block, unsigned Idx);
+
+  /// \brief enqueue the nodes corresponding to the end of function onto the
+  /// end of path / work list.
+  void enqueueEndOfFunction(ExplodedNodeSet &Set);
 };
 
 // TODO: Turn into a calss.

diff --git a/lib/StaticAnalyzer/Core/CoreEngine.cpp b/lib/StaticAnalyzer/Core/CoreEngine.cpp
index e88a8f1963db5ee7e503300f3fa746a5606dc12a..5ab55b5ee396045f7a55f18d4d0dcc452fa610a7 100644 (file)
--- a/lib/StaticAnalyzer/Core/CoreEngine.cpp
+++ b/lib/StaticAnalyzer/Core/CoreEngine.cpp
@@ -491,6 +491,22 @@ void CoreEngine::enqueueStmtNode(ExplodedNode *N,
     WList->enqueue(Succ, Block, Idx+1);
 }
 
+ExplodedNode *CoreEngine::generateCallExitNode(ExplodedNode *N) {
+  // Create a CallExit node and enqueue it.
+  const StackFrameContext *LocCtx
+                         = cast<StackFrameContext>(N->getLocationContext());
+  const Stmt *CE = LocCtx->getCallSite();
+
+  // Use the the callee location context.
+  CallExit Loc(CE, LocCtx);
+
+  bool isNew;
+  ExplodedNode *Node = G->getNode(Loc, N->getState(), &isNew);
+  Node->addPredecessor(N, *G);
+  return isNew ? Node : 0;
+}
+
+
 void CoreEngine::enqueue(ExplodedNodeSet &Set) {
   for (ExplodedNodeSet::iterator I = Set.begin(),
                                  E = Set.end(); I != E; ++I) {
@@ -506,6 +522,19 @@ void CoreEngine::enqueue(ExplodedNodeSet &Set,
   }
 }
 
+void CoreEngine::enqueueEndOfFunction(ExplodedNodeSet &Set) {
+  for (ExplodedNodeSet::iterator I = Set.begin(), E = Set.end(); I != E; ++I) {
+    ExplodedNode *N = *I;
+    // If we are in an inlined call, generate CallExit node.
+    if (N->getLocationContext()->getParent()) {
+      N = generateCallExitNode(N);
+      if (N)
+        WList->enqueue(N);
+    } else
+      G->addEndOfPath(N);
+  }
+}
+
 
 ExplodedNode* NodeBuilder::generateNodeImpl(const ProgramPoint &Loc,
                                             const ProgramState *State,

diff --git a/lib/StaticAnalyzer/Core/ExprEngine.cpp b/lib/StaticAnalyzer/Core/ExprEngine.cpp
index 2c5379f66a7266e7d3e44d9d8f01bf9569c73af4..3924154f6f43b313cccd7670735a4871557e02db 100644 (file)
--- a/lib/StaticAnalyzer/Core/ExprEngine.cpp
+++ b/lib/StaticAnalyzer/Core/ExprEngine.cpp
@@ -1100,42 +1100,13 @@ void ExprEngine::processIndirectGoto(IndirectGotoNodeBuilder &builder) {
     builder.generateNode(I, state);
 }
 
-// TODO: The next two functions should be moved into CoreEngine.
-void ExprEngine::GenerateCallExitNode(ExplodedNode *N) {
-  // Create a CallExit node and enqueue it.
-  const StackFrameContext *LocCtx
-                         = cast<StackFrameContext>(N->getLocationContext());
-  const Stmt *CE = LocCtx->getCallSite();
-
-  // Use the the callee location context.
-  CallExit Loc(CE, LocCtx);
-
-  bool isNew;
-  ExplodedNode *Node = Engine.G->getNode(Loc, N->getState(), &isNew);
-  Node->addPredecessor(N, *Engine.G);
-
-  if (isNew)
-    Engine.WList->enqueue(Node);
-}
-
-void ExprEngine::enqueueEndOfPath(ExplodedNodeSet &S) {
-  for (ExplodedNodeSet::iterator I = S.begin(), E = S.end(); I != E; ++I) {
-    ExplodedNode *N = *I;
-    // If we are in an inlined call, generate CallExit node.
-    if (N->getLocationContext()->getParent())
-      GenerateCallExitNode(N);
-    else
-      Engine.G->addEndOfPath(N);
-  }
-}
-
 /// ProcessEndPath - Called by CoreEngine.  Used to generate end-of-path
 ///  nodes when the control reaches the end of a function.
 void ExprEngine::processEndOfFunction(NodeBuilderContext& BC) {
   StateMgr.EndPath(BC.Pred->getState());
   ExplodedNodeSet Dst;
   getCheckerManager().runCheckersForEndPath(BC, Dst, *this);
-  enqueueEndOfPath(Dst);
+  Engine.enqueueEndOfFunction(Dst);
 }
 
 /// ProcessSwitch - Called by CoreEngine.  Used to generate successor