[analyzer] WIP: Move `TimerGroup` to Analyzer's options

[mikhail.ramalho]

Summary

This patch moves the TimerGroup object to the AnalyzerOptions object, so it can be easily accessed from other parts of the analyzer.

This might be conceptually wrong (an AnalyzerOptions holding timers), but I created this review so we can discuss possible implementations.

Also, this patch adds the crosscheck timer as an example. I can move this part to another revision if requested.

[george.karpenkov]

Requesting changes as previously discussed.
If we really need to pass statistics around, maybe they should be stored in a special "statistics" class created just for this purpose.

include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

 #ifndef LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H
 #define LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H
 
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Timer.h"
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace clang {
 
 namespace ento {
 
public:
 
   /// The inlining stack depth limit.
   // Cap the stack depth at 4 calls (5 stack frames, base + 4 calls).
   unsigned InlineMaxStackDepth = 5;
 
   /// The mode of function selection used during inlining.
   AnalysisInliningMode InliningMode = NoRedundancy;
 
+  /// Returns the timer group used accross the analyzer
+  std::shared_ptr<llvm::TimerGroup> AnalyzerTimers =
+      std::make_shared<llvm::TimerGroup>("analyzer", "Analyzer timers");
+
   enum class ExplorationStrategyKind {
     DFS,
     BFS,
     UnexploredFirst,
     UnexploredFirstQueue,
     BFSBlockDFSContents,
     NotSet
   };

lib/StaticAnalyzer/Core/BugReporter.cpp

 static
 std::pair<BugReport*, std::unique_ptr<VisitorsDiagnosticsTy>> findValidReport(
   TrimmedGraph &TrimG,
   ReportGraph &ErrorGraph,
   ArrayRef<BugReport *> &bugReports,
   AnalyzerOptions &Opts,
   GRBugReporter &Reporter) {
 
+  bool enableStatistics = Opts.PrintStats || Opts.shouldSerializeStats();
+
+  llvm::Timer CrosscheckTimer;
+  if (Opts.shouldCrosscheckWithZ3() && enableStatistics) {
+    CrosscheckTimer.init("crosscheck", "Crosscheck total time",
+                         *Opts.AnalyzerTimers);
+  }
+
   while (TrimG.popNextReportGraph(ErrorGraph)) {
     // Find the BugReport with the original location.
     assert(ErrorGraph.Index < bugReports.size());
     BugReport *R = bugReports[ErrorGraph.Index];
     assert(R && "No original report found for sliced graph.");
     assert(R->isValid() && "Report selected by trimmed graph marked invalid.");
     const ExplodedNode *ErrorNode = ErrorGraph.ErrorNode;
 
while (TrimG.popNextReportGraph(ErrorGraph)) {
 
     if (R->isValid()) {
       if (Opts.shouldCrosscheckWithZ3()) {
         // If crosscheck is enabled, remove all visitors, add the refutation
         // visitor and check again
         R->clearVisitors();
         R->addVisitor(llvm::make_unique<FalsePositiveRefutationBRVisitor>());
 
+        if (enableStatistics) CrosscheckTimer.startTimer();
+
         // We don't overrite the notes inserted by other visitors because the
         // refutation manager does not add any new note to the path
         generateVisitorsDiagnostics(R, ErrorGraph.ErrorNode, BRC);
+
+        if(enableStatistics) CrosscheckTimer.stopTimer();
       }
 
       // Check if the bug is still valid
       if (R->isValid())
         return std::make_pair(R, std::move(visitorNotes));
     }
   }
 

lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp

public:
 
   StoreManagerCreator CreateStoreMgr;
   ConstraintManagerCreator CreateConstraintMgr;
 
   std::unique_ptr<CheckerManager> checkerMgr;
   std::unique_ptr<AnalysisManager> Mgr;
 
   /// Time the analyzes time of each translation unit.
-  std::unique_ptr<llvm::TimerGroup> AnalyzerTimers;
   std::unique_ptr<llvm::Timer> TUTotalTimer;
 
   /// The information about analyzed functions shared throughout the
   /// translation unit.
   FunctionSummariesTy FunctionSummaries;
 
   AnalysisConsumer(CompilerInstance &CI, const std::string &outdir,
                    AnalyzerOptionsRef opts, ArrayRef<std::string> plugins,
                    CodeInjector *injector)
       : RecVisitorMode(0), RecVisitorBR(nullptr), Ctx(nullptr),
         PP(CI.getPreprocessor()), OutDir(outdir), Opts(std::move(opts)),
         Plugins(plugins), Injector(injector), CTU(CI) {
     DigestAnalyzerOptions();
     if (Opts->PrintStats || Opts->shouldSerializeStats()) {
-      AnalyzerTimers = llvm::make_unique<llvm::TimerGroup>(
-          "analyzer", "Analyzer timers");
       TUTotalTimer = llvm::make_unique<llvm::Timer>(
-          "time", "Analyzer total time", *AnalyzerTimers);
+          "time", "Analyzer total time", *Opts->AnalyzerTimers);
       llvm::EnableStatistics(/* PrintOnExit= */ false);
     }
   }
 
   ~AnalysisConsumer() override {
     if (Opts->PrintStats) {
       llvm::PrintStatistics();
     }