[time-report] Add timers to codegen actions

[weiwang]

Summary

Time report does not show time spent in frontend, optimizer and codegen passes clearly:

1. The total time of pass timer group usually over-estimates due to the inclusion of wrapper passes.
2. "Code Generation Time" includes both optimizer and codegen passes.
3. "LLVM IR Generation Time" only counts IR codegen, but missing out the parsing time.
4. "Clang front-end timer" measures the total frontend action execution, but it has the problem of resetting itself prematurely in the case of multiple actions being dispatched because the timer is attached to the global CompilerInstance.

This change adds timers for frontend parsing, IR codegen, optimizer and codegen passes and put them into a new timer group. The timer points are aligned with time trace points for better consistency.

Sample output

===-------------------------------------------------------------------------===
                               Clang Compilation
===-------------------------------------------------------------------------===
  Total Execution Time: 1.1988 seconds (1.1988 wall clock)

   ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
   0.9365 ( 83.9%)   0.0506 ( 61.3%)   0.9871 ( 82.3%)   0.9871 ( 82.3%)  Parse AST
   0.1275 ( 11.4%)   0.0180 ( 21.8%)   0.1455 ( 12.1%)   0.1455 ( 12.1%)  Optimizer
   0.0397 (  3.6%)   0.0139 ( 16.8%)   0.0536 (  4.5%)   0.0536 (  4.5%)  CodeGenPasses
   0.0127 (  1.1%)   0.0000 (  0.0%)   0.0127 (  1.1%)   0.0127 (  1.1%)  IR Generation
   1.1163 (100.0%)   0.0825 (100.0%)   1.1988 (100.0%)   1.1988 (100.0%)  Total

[weiwang]

fix typo

clang/include/clang/Frontend/FrontendAction.h

 class ASTMergeAction;
 class CompilerInstance;
 
 /// Abstract base class for actions which can be performed by the frontend.
 class FrontendAction {
   FrontendInputFile CurrentInput;
   std::unique_ptr<ASTUnit> CurrentASTUnit;
   CompilerInstance *Instance;
+  bool TimePassesIsEnabled = false;
   friend class ASTMergeAction;
   friend class WrapperFrontendAction;
 
 private:
   std::unique_ptr<ASTConsumer> CreateWrappedASTConsumer(CompilerInstance &CI,
                                                         StringRef InFile);
 
 protected:
public:
 
   std::unique_ptr<ASTUnit> takeCurrentASTUnit() {
     return std::move(CurrentASTUnit);
   }
 
   void setCurrentInput(const FrontendInputFile &CurrentInput,
                        std::unique_ptr<ASTUnit> AST = nullptr);
 
+  bool isTimePassesEnabled() { return TimePassesIsEnabled; }
+  void enableTimePasses() { TimePassesIsEnabled = true; }
+
   /// @}
   /// @name Supported Modes
   /// @{
 
   /// Is this action invoked on a model file?
   ///
   /// Model files are incomplete translation units that relies on type
   /// information from another translation unit. Check ParseModelFileAction for

clang/include/clang/Parse/ParseAST.h

void ParseAST(Preprocessor &pp, ASTConsumer *C,
                 ASTContext &Ctx, bool PrintStats = false,
                 TranslationUnitKind TUKind = TU_Complete,
                 CodeCompleteConsumer *CompletionConsumer = nullptr,
                 bool SkipFunctionBodies = false);
 
   /// Parse the main file known to the preprocessor, producing an
   /// abstract syntax tree.
   void ParseAST(Sema &S, bool PrintStats = false,
-                bool SkipFunctionBodies = false);
+                bool SkipFunctionBodies = false,
+                bool TimePassesIsEnabled = false);
 
 }  // end namespace clang
 
 #endif

clang/lib/CodeGen/BackendUtil.cpp

#include "llvm/Support/Extension.def"
   default:
     break;
   }
 
   // Now that we have all of the passes ready, run them.
   {
     PrettyStackTraceString CrashInfo("Optimizer");
     llvm::TimeTraceScope TimeScope("Optimizer");
+    llvm::NamedRegionTimer T("Optimizer", "Optimizer", "Clang Compilation",
+                             "Clang Compilation", CodeGenOpts.TimePasses);
     MPM.run(*TheModule, MAM);
   }
 }
 
 void EmitAssemblyHelper::RunCodegenPipeline(
     BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
     std::unique_ptr<llvm::ToolOutputFile> &DwoOS) {
   // We still use the legacy PM to run the codegen pipeline since the new PM
case Backend_EmitObj:
     break;
   default:
     return;
   }
 
   {
     PrettyStackTraceString CrashInfo("Code generation");
     llvm::TimeTraceScope TimeScope("CodeGenPasses");
+    llvm::NamedRegionTimer T("CodeGenPasses", "CodeGenPasses",
+                             "Clang Compilation", "Clang Compilation",
+                             CodeGenOpts.TimePasses);
     CodeGenPasses.run(*TheModule);
   }
 }
 
 /// A clean version of `EmitAssembly` that uses the new pass manager.
 ///
 /// Not all features are currently supported in this system, but where
 /// necessary it falls back to the legacy pass manager to at least provide

clang/lib/CodeGen/CodeGenAction.cpp

bool LinkInModules() {
           return true;
       }
       return false; // success
     }
 
     void HandleTranslationUnit(ASTContext &C) override {
       {
         llvm::TimeTraceScope TimeScope("Frontend");
+        llvm::NamedRegionTimer T("IR Generation", "IR Generation",
+                                 "Clang Compilation", "Clang Compilation",
+                                 CodeGenOpts.TimePasses);
         PrettyStackTraceString CrashInfo("Per-file LLVM IR generation");
         if (TimerIsEnabled) {
           LLVMIRGenerationRefCount += 1;
           if (LLVMIRGenerationRefCount == 1)
             LLVMIRGeneration.startTimer();
         }
 
         Gen->HandleTranslationUnit(C);

clang/lib/Frontend/FrontendAction.cpp

void ASTFrontendAction::ExecuteAction() {
   CodeCompleteConsumer *CompletionConsumer = nullptr;
   if (CI.hasCodeCompletionConsumer())
     CompletionConsumer = &CI.getCodeCompletionConsumer();
 
   if (!CI.hasSema())
     CI.createSema(getTranslationUnitKind(), CompletionConsumer);
 
   ParseAST(CI.getSema(), CI.getFrontendOpts().ShowStats,
-           CI.getFrontendOpts().SkipFunctionBodies);
+           CI.getFrontendOpts().SkipFunctionBodies, isTimePassesEnabled());
 }
 
 void PluginASTAction::anchor() { }
 
 std::unique_ptr<ASTConsumer>
 PreprocessorFrontendAction::CreateASTConsumer(CompilerInstance &CI,
                                               StringRef InFile) {
   llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");

clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

 #endif
 
   // If there are any AST files to merge, create a frontend action
   // adaptor to perform the merge.
   if (!FEOpts.ASTMergeFiles.empty())
     Act = std::make_unique<ASTMergeAction>(std::move(Act),
                                             FEOpts.ASTMergeFiles);
 
+  if (CI.getCodeGenOpts().TimePasses)
+    Act->enableTimePasses();
+
   return Act;
 }
 
 bool ExecuteCompilerInvocation(CompilerInstance *Clang) {
   // Honor -help.
   if (Clang->getFrontendOpts().ShowHelp) {
     driver::getDriverOptTable().printHelp(
         llvm::outs(), "clang -cc1 [options] file...",

clang/lib/Parse/ParseAST.cpp

 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaConsumer.h"
 #include "clang/Sema/TemplateInstCallback.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/Timer.h"
 #include <cstdio>
 #include <memory>
 
 using namespace clang;
 
 namespace {
 
 /// Resets LLVM's pretty stack state so that stack traces are printed correctly
std::unique_ptr<Sema> S(
       new Sema(PP, Ctx, *Consumer, TUKind, CompletionConsumer));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleanupSema(S.get());
 
   ParseAST(*S.get(), PrintStats, SkipFunctionBodies);
 }
 
-void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies) {
+void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies,
+                     bool TimePassesIsEnabled) {
   // Collect global stats on Decls/Stmts (until we have a module streamer).
   if (PrintStats) {
     Decl::EnableStatistics();
     Stmt::EnableStatistics();
   }
 
   // Also turn on collection of stats inside of the Sema object.
   bool OldCollectStats = PrintStats;
void clang::ParseAST(Sema &S, bool PrintStats, bool SkipFunctionBodies,
 
   // If a PCH through header is specified that does not have an include in
   // the source, or a PCH is being created with #pragma hdrstop with nothing
   // after the pragma, there won't be any tokens or a Lexer.
   bool HaveLexer = S.getPreprocessor().getCurrentLexer();
 
   if (HaveLexer) {
     llvm::TimeTraceScope TimeScope("Frontend");
+    llvm::NamedRegionTimer T("Parse AST", "Parse AST", "Clang Compilation",
+                             "Clang Compilation", TimePassesIsEnabled);
     P.Initialize();
     Parser::DeclGroupPtrTy ADecl;
     Sema::ModuleImportState ImportState;
     EnterExpressionEvaluationContext PotentiallyEvaluated(
         S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
 
     for (bool AtEOF = P.ParseFirstTopLevelDecl(ADecl, ImportState); !AtEOF;
          AtEOF = P.ParseTopLevelDecl(ADecl, ImportState)) {