Migrate the call inliner to the Checker interface.

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

5 files changed, 77 insertions, 38 deletions

diff --git a/include/clang/Analysis/LocalCheckers.h b/include/clang/Analysis/LocalCheckers.h
index 8c70e4fc7b..9c343e0786 100644
--- a/include/clang/Analysis/LocalCheckers.h
+++ b/include/clang/Analysis/LocalCheckers.h
@@ -56,6 +56,8 @@ void RegisterExperimentalInternalChecks(GRExprEngine &Eng);
 void CheckSecuritySyntaxOnly(const Decl *D, BugReporter &BR);
 
 void CheckSizeofPointer(const Decl *D, BugReporter &BR);
+
+void RegisterCallInliner(GRExprEngine &Eng);
 } // end namespace clang
 
 #endif
diff --git a/include/clang/Analysis/PathSensitive/Checker.h b/include/clang/Analysis/PathSensitive/Checker.h
index a625a7a256..c87889a267 100644
--- a/include/clang/Analysis/PathSensitive/Checker.h
+++ b/include/clang/Analysis/PathSensitive/Checker.h
@@ -61,8 +61,12 @@ public:
     return Eng;
   }
 
+  AnalysisManager &getAnalysisManager() {
+    return Eng.getAnalysisManager();
+  }
+
   ConstraintManager &getConstraintManager() {
-      return Eng.getConstraintManager();
+    return Eng.getConstraintManager();
   }
 
   StoreManager &getStoreManager() {
diff --git a/include/clang/Analysis/PathSensitive/GRTransferFuncs.h b/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
index 2594618c16..b058460a49 100644
--- a/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
+++ b/include/clang/Analysis/PathSensitive/GRTransferFuncs.h
@@ -80,9 +80,6 @@ public:
     return state;
   }  
 };
-
-GRTransferFuncs *CreateCallInliner(ASTContext &ctx);
-
 } // end clang namespace
 
 #endif
diff --git a/lib/Analysis/CallInliner.cpp b/lib/Analysis/CallInliner.cpp
index 43523c293d..2f748bd8bd 100644
--- a/lib/Analysis/CallInliner.cpp
+++ b/lib/Analysis/CallInliner.cpp
@@ -11,36 +11,43 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Analysis/PathSensitive/GRExprEngine.h"
-#include "clang/Analysis/PathSensitive/GRTransferFuncs.h"
+#include "clang/Analysis/PathSensitive/CheckerVisitor.h"
+#include "clang/Analysis/PathSensitive/GRState.h"
+#include "clang/Analysis/LocalCheckers.h"
 
 using namespace clang;
 
 namespace {
-  
-class CallInliner : public GRTransferFuncs {
-  ASTContext &Ctx;
+class CallInliner : public Checker {
 public:
-  CallInliner(ASTContext &ctx) : Ctx(ctx) {}
+  static void *getTag() {
+    static int x;
+    return &x;
+  }
 
-  void EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Engine,
-                GRStmtNodeBuilder& Builder, CallExpr* CE, SVal L,
-                ExplodedNode* Pred);
-  
+  virtual bool EvalCallExpr(CheckerContext &C, const CallExpr *CE);
 };
+}
 
+void clang::RegisterCallInliner(GRExprEngine &Eng) {
+  Eng.registerCheck(new CallInliner());
 }
 
-void CallInliner::EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Engine,
-                           GRStmtNodeBuilder& Builder, CallExpr* CE, SVal L,
-                           ExplodedNode* Pred) {
-  FunctionDecl const *FD = L.getAsFunctionDecl();
+bool CallInliner::EvalCallExpr(CheckerContext &C, const CallExpr *CE) {
+  const GRState *state = C.getState();
+  const Expr *Callee = CE->getCallee();
+  SVal L = state->getSVal(Callee);
+
+  const FunctionDecl *FD = L.getAsFunctionDecl();
   if (!FD)
-    return; // GRExprEngine is responsible for the autotransition.
+    return false;
+
+  if (!FD->isThisDeclarationADefinition())
+    return false;
 
   // Make a new LocationContext.
-  StackFrameContext const *LocCtx =
-  Engine.getAnalysisManager().getStackFrame(FD, Pred->getLocationContext(), CE);
+  const StackFrameContext *LocCtx = C.getAnalysisManager().getStackFrame(FD, 
+                                  C.getPredecessor()->getLocationContext(), CE);
 
   CFGBlock const *Entry = &(LocCtx->getCFG()->getEntry());
 
@@ -54,22 +61,22 @@ void CallInliner::EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Engine,
   // Construct an edge representing the starting location in the function.
   BlockEdge Loc(Entry, SuccB, LocCtx);
 
-  GRState const *state = Builder.GetState(Pred);  
-  state = Engine.getStoreManager().EnterStackFrame(state, LocCtx);
-
+  state = C.getStoreManager().EnterStackFrame(state, LocCtx);
+  // This is a hack. We really should not use the GRStmtNodeBuilder.
   bool isNew;
-  ExplodedNode *SuccN = Engine.getGraph().getNode(Loc, state, &isNew);
-  SuccN->addPredecessor(Pred, Engine.getGraph());
+  GRExprEngine &Eng = C.getEngine();
+  ExplodedNode *Pred = C.getPredecessor();
+  GRStmtNodeBuilder &Builder = C.getNodeBuilder();
 
-  Builder.Deferred.erase(Pred);
-
-  // This is a hack. We really should not use the GRStmtNodeBuilder.
+  ExplodedNode *SuccN = Eng.getGraph().getNode(Loc, state, &isNew);
+  SuccN->addPredecessor(Pred, Eng.getGraph());
+  C.getNodeBuilder().Deferred.erase(Pred);
+  
   if (isNew)
     Builder.getWorkList()->Enqueue(SuccN);
 
   Builder.HasGeneratedNode = true;
+
+  return true;
 }
-  
-GRTransferFuncs *clang::CreateCallInliner(ASTContext &ctx) {
-  return new CallInliner(ctx);
-}
+
diff --git a/lib/Frontend/AnalysisConsumer.cpp b/lib/Frontend/AnalysisConsumer.cpp
index 9fade9488b..ec55c4ca0e 100644
--- a/lib/Frontend/AnalysisConsumer.cpp
+++ b/lib/Frontend/AnalysisConsumer.cpp
@@ -254,7 +254,7 @@ void AnalysisConsumer::HandleTranslationUnit(ASTContext &C) {
   if (!TranslationUnitActions.empty()) {  
     // Find the entry function definition (if any).
     FunctionDecl *FD = 0;
-    
+    // Must specify an entry function.
     if (!Opts.AnalyzeSpecificFunction.empty()) {
       for (DeclContext::decl_iterator I=TU->decls_begin(), E=TU->decls_end();
            I != E; ++I) {
@@ -267,9 +267,11 @@ void AnalysisConsumer::HandleTranslationUnit(ASTContext &C) {
       }
     }
 
-    for (Actions::iterator I = TranslationUnitActions.begin(), 
-         E = TranslationUnitActions.end(); I != E; ++I)
-      (*I)(*this, *Mgr, FD);  
+    if (FD) {
+      for (Actions::iterator I = TranslationUnitActions.begin(), 
+             E = TranslationUnitActions.end(); I != E; ++I)
+        (*I)(*this, *Mgr, FD);  
+    }
   }
 
   if (!ObjCImplementationActions.empty()) {
@@ -489,8 +491,35 @@ static void ActionWarnSizeofPointer(AnalysisConsumer &C, AnalysisManager &mgr,
 
 static void ActionInlineCall(AnalysisConsumer &C, AnalysisManager &mgr,
                              Decl *D) {
+  // FIXME: This is largely copy of ActionGRExprEngine. Needs cleanup.  
+  // Display progress.
+  C.DisplayFunction(D);
+
+  GRExprEngine Eng(mgr);
+
+  RegisterCallInliner(Eng);
+
+  if (C.Opts.EnableExperimentalInternalChecks)
+    RegisterExperimentalInternalChecks(Eng);
+  
+  RegisterAppleChecks(Eng, *D);
+  
+  if (C.Opts.EnableExperimentalChecks)
+    RegisterExperimentalChecks(Eng);
   
-  ActionGRExprEngine(C, mgr, D, CreateCallInliner(mgr.getASTContext()));
+  // Make a fake transfer function. The GRTransferFunc interface will be 
+  // removed.
+  Eng.setTransferFunctions(new GRTransferFuncs());  
+
+  // Execute the worklist algorithm.
+  Eng.ExecuteWorkList(mgr.getStackFrame(D));
+
+  // Visualize the exploded graph.
+  if (mgr.shouldVisualizeGraphviz())
+    Eng.ViewGraph(mgr.shouldTrimGraph());
+
+  // Display warnings.
+  Eng.getBugReporter().FlushReports();
 }
 
 //===----------------------------------------------------------------------===//