Migrate the call inliner to the Checker interface.

llvm-svn: 91991

clang/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

clang/include/clang/Analysis/PathSensitive/Checker.h

@@ -61,6 +61,10 @@ public:
     return Eng;
   }
 
+  AnalysisManager &getAnalysisManager() {
+    return Eng.getAnalysisManager();
+  }
+
   ConstraintManager &getConstraintManager() {
     return Eng.getConstraintManager();
   }

clang/include/clang/Analysis/PathSensitive/GRTransferFuncs.h

@@ -80,9 +80,6 @@ public:
     return state;
   }  
 };
-
-GRTransferFuncs *CreateCallInliner(ASTContext &ctx);
-
 } // end clang namespace
 
 #endif

clang/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) {}
-
-  void EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Engine,
-                GRStmtNodeBuilder& Builder, CallExpr* CE, SVal L,
-                ExplodedNode* Pred);
-  
-};
-
+  static void *getTag() {
+    static int x;
+    return &x;
   }
 
-void CallInliner::EvalCall(ExplodedNodeSet& Dst, GRExprEngine& Engine,
-                           GRStmtNodeBuilder& Builder, CallExpr* CE, SVal L,
-                           ExplodedNode* Pred) {
-  FunctionDecl const *FD = L.getAsFunctionDecl();
+  virtual bool EvalCallExpr(CheckerContext &C, const CallExpr *CE);
+};
+}
+
+void clang::RegisterCallInliner(GRExprEngine &Eng) {
+  Eng.registerCheck(new CallInliner());
+}
+
+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);
-
-  bool isNew;
-  ExplodedNode *SuccN = Engine.getGraph().getNode(Loc, state, &isNew);
-  SuccN->addPredecessor(Pred, Engine.getGraph());
-
-  Builder.Deferred.erase(Pred);
-
+  state = C.getStoreManager().EnterStackFrame(state, LocCtx);
   // This is a hack. We really should not use the GRStmtNodeBuilder.
+  bool isNew;
+  GRExprEngine &Eng = C.getEngine();
+  ExplodedNode *Pred = C.getPredecessor();
+  GRStmtNodeBuilder &Builder = C.getNodeBuilder();
+
+  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);
-}

clang/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,10 +267,12 @@ void AnalysisConsumer::HandleTranslationUnit(ASTContext &C) {
       }
     }
 
+    if (FD) {
       for (Actions::iterator I = TranslationUnitActions.begin(), 
              E = TranslationUnitActions.end(); I != E; ++I)
         (*I)(*this, *Mgr, FD);  
     }
+  }
 
   if (!ObjCImplementationActions.empty()) {
     for (DeclContext::decl_iterator I = TU->decls_begin(),
@@ -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);
 
-  ActionGRExprEngine(C, mgr, D, CreateCallInliner(mgr.getASTContext()));
+  GRExprEngine Eng(mgr);
+
+  RegisterCallInliner(Eng);
+
+  if (C.Opts.EnableExperimentalInternalChecks)
+    RegisterExperimentalInternalChecks(Eng);
+  
+  RegisterAppleChecks(Eng, *D);
+  
+  if (C.Opts.EnableExperimentalChecks)
+    RegisterExperimentalChecks(Eng);
+  
+  // 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();
 }
 
 //===----------------------------------------------------------------------===//