-ftime-report switch support in Clang.

The current support of the feature produces only 2 lines in report:
 -Some general Code Generation Time;
 -Total time of Backend Consumer actions.
This patch extends Clang time report with new lines related to Preprocessor, Include Filea Search, Parsing, etc.
Differential Revision: https://reviews.llvm.org/D43578

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

diff --git a/include/clang/Frontend/FrontendAction.h b/include/clang/Frontend/FrontendAction.h
index 7ae6173512a6802e6c03ad3b045d201b708602cf..0151d7e303a5766424e73984767483fae0fa9011 100644 (file)
--- a/include/clang/Frontend/FrontendAction.h
+++ b/include/clang/Frontend/FrontendAction.h
@@ -45,6 +45,9 @@ private:
                                                         StringRef InFile);
 
 protected:
+  static constexpr const char *GroupName = "factions";
+  static constexpr const char *GroupDescription =
+      "===== Frontend Actions =====";
   /// @name Implementation Action Interface
   /// @{
 

diff --git a/include/clang/Lex/HeaderSearch.h b/include/clang/Lex/HeaderSearch.h
index 6ba9c66fc36439c19b6a155edbc6e1a0d9328a41..aac8758afd7fd83268f0e4926a4c211e971e7e5d 100644 (file)
--- a/include/clang/Lex/HeaderSearch.h
+++ b/include/clang/Lex/HeaderSearch.h
@@ -21,9 +21,10 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/Timer.h"
 #include <cassert>
 #include <cstddef>
 #include <memory>
@@ -31,6 +32,9 @@
 #include <utility>
 #include <vector>
 
+static const char *const IncGroupName = "includefiles";
+static const char *const IncGroupDescription = "===== Include Files =====";
+
 namespace clang {
 
 class DiagnosticsEngine;

diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h
index 619b56363f43763acdcaa3622435f4cb79e8dbd9..943ceaed8855937147eb4f3b0944d2a7d4f0e0ae 100644 (file)
--- a/include/clang/Parse/Parser.h
+++ b/include/clang/Parse/Parser.h
@@ -2851,4 +2851,6 @@ private:
 
 }  // end namespace clang
 
+static const char *const GroupName = "clangparser";
+static const char *const GroupDescription = "===== Clang Parser =====";
 #endif

diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index 0305094d9fb408f935a828ebd9f031350127a25e..1942eb11debc8d1d2f1a3759742b00f79ac18549 100644 (file)
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -304,6 +304,9 @@ class Sema {
   bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
 
 public:
+  static constexpr const char *GroupName = "sema";
+  static constexpr const char *GroupDescription = "===== Sema =====";
+
   typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
   typedef OpaquePtr<TemplateName> TemplateTy;
   typedef OpaquePtr<QualType> TypeTy;

diff --git a/lib/CodeGen/CodeGenAction.cpp b/lib/CodeGen/CodeGenAction.cpp
index ac2548e6a52804230305389bb2254b846d670ea4..168113065778f489eb1a5423d1813dc6628f2c26 100644 (file)
--- a/lib/CodeGen/CodeGenAction.cpp
+++ b/lib/CodeGen/CodeGenAction.cpp
@@ -23,6 +23,7 @@
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Rewrite/Frontend/FrontendActions.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
 #include "llvm/IR/DebugInfo.h"
@@ -51,7 +52,7 @@ namespace clang {
   public:
     ClangDiagnosticHandler(const CodeGenOptions &CGOpts, BackendConsumer *BCon)
         : CodeGenOpts(CGOpts), BackendCon(BCon) {}
-  
+
     bool handleDiagnostics(const DiagnosticInfo &DI) override;
 
     bool isAnalysisRemarkEnabled(StringRef PassName) const override {
@@ -90,9 +91,8 @@ namespace clang {
     const LangOptions &LangOpts;
     std::unique_ptr<raw_pwrite_stream> AsmOutStream;
     ASTContext *Context;
-
-    Timer LLVMIRGeneration;
-    unsigned LLVMIRGenerationRefCount;
+    static constexpr const char *GroupName = "frontend";
+    static constexpr const char *GroupDescription = "===== Frontend =====";
 
     /// True if we've finished generating IR. This prevents us from generating
     /// additional LLVM IR after emitting output in HandleTranslationUnit. This
@@ -121,8 +121,6 @@ namespace clang {
         : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
           CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts),
           AsmOutStream(std::move(OS)), Context(nullptr),
-          LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
-          LLVMIRGenerationRefCount(0),
           Gen(CreateLLVMCodeGen(Diags, InFile, HeaderSearchOpts, PPOpts,
                                 CodeGenOpts, C, CoverageInfo)),
           LinkModules(std::move(LinkModules)) {
@@ -141,38 +139,22 @@ namespace clang {
 
     void Initialize(ASTContext &Ctx) override {
       assert(!Context && "initialized multiple times");
-
       Context = &Ctx;
-
-      if (llvm::TimePassesIsEnabled)
-        LLVMIRGeneration.startTimer();
-
+      NamedRegionTimer T("initbackendconsumer", "Init Backend Consumer",
+                         GroupName, GroupDescription,
+                         llvm::TimePassesIsEnabled);
       Gen->Initialize(Ctx);
-
-      if (llvm::TimePassesIsEnabled)
-        LLVMIRGeneration.stopTimer();
     }
 
     bool HandleTopLevelDecl(DeclGroupRef D) override {
       PrettyStackTraceDecl CrashInfo(*D.begin(), SourceLocation(),
                                      Context->getSourceManager(),
                                      "LLVM IR generation of declaration");
-
-      // Recurse.
-      if (llvm::TimePassesIsEnabled) {
-        LLVMIRGenerationRefCount += 1;
-        if (LLVMIRGenerationRefCount == 1)
-          LLVMIRGeneration.startTimer();
-      }
+      NamedRegionTimer T("handlehophevelhecl", "Handle Top Level Decl",
+                         GroupName, GroupDescription,
+                         llvm::TimePassesIsEnabled);
 
       Gen->HandleTopLevelDecl(D);
-
-      if (llvm::TimePassesIsEnabled) {
-        LLVMIRGenerationRefCount -= 1;
-        if (LLVMIRGenerationRefCount == 0)
-          LLVMIRGeneration.stopTimer();
-      }
-
       return true;
     }
 
@@ -180,13 +162,11 @@ namespace clang {
       PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
                                      Context->getSourceManager(),
                                      "LLVM IR generation of inline function");
-      if (llvm::TimePassesIsEnabled)
-        LLVMIRGeneration.startTimer();
+      NamedRegionTimer T("handleinlinefunction",
+                         "Handle Inline Function Definition", GroupName,
+                         GroupDescription, llvm::TimePassesIsEnabled);
 
       Gen->HandleInlineFunctionDefinition(D);
-
-      if (llvm::TimePassesIsEnabled)
-        LLVMIRGeneration.stopTimer();
     }
 
     void HandleInterestingDecl(DeclGroupRef D) override {
@@ -197,6 +177,8 @@ namespace clang {
 
     // Links each entry in LinkModules into our module.  Returns true on error.
     bool LinkInModules() {
+      NamedRegionTimer T("linkinmodules", "Link In Modules", GroupName,
+                         GroupDescription, llvm::TimePassesIsEnabled);
       for (auto &LM : LinkModules) {
         if (LM.PropagateAttrs)
           for (Function &F : *LM.Module)
@@ -227,21 +209,12 @@ namespace clang {
     void HandleTranslationUnit(ASTContext &C) override {
       {
         PrettyStackTraceString CrashInfo("Per-file LLVM IR generation");
-        if (llvm::TimePassesIsEnabled) {
-          LLVMIRGenerationRefCount += 1;
-          if (LLVMIRGenerationRefCount == 1)
-            LLVMIRGeneration.startTimer();
-        }
+        NamedRegionTimer T("handletranslationunit", "Handle Translation Unit",
+                           GroupName, GroupDescription,
+                           llvm::TimePassesIsEnabled);
 
         Gen->HandleTranslationUnit(C);
-
-        if (llvm::TimePassesIsEnabled) {
-          LLVMIRGenerationRefCount -= 1;
-          if (LLVMIRGenerationRefCount == 0)
-            LLVMIRGeneration.stopTimer();
-        }
-
-       IRGenFinished = true;
+        IRGenFinished = true;
       }
 
       // Silently ignore if we weren't initialized for some reason.
@@ -309,23 +282,37 @@ namespace clang {
     }
 
     void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
+      NamedRegionTimer T("handletagdecl",
+                         "Handle Tag Decl Required Definition", GroupName,
+                         GroupDescription, llvm::TimePassesIsEnabled);
       Gen->HandleTagDeclRequiredDefinition(D);
     }
 
     void CompleteTentativeDefinition(VarDecl *D) override {
+      NamedRegionTimer T("completetentative",
+                         "Complete Tentative Definition", GroupName,
+                         GroupDescription, llvm::TimePassesIsEnabled);
       Gen->CompleteTentativeDefinition(D);
     }
 
     void AssignInheritanceModel(CXXRecordDecl *RD) override {
+      NamedRegionTimer T("assigninheritance", "Assign Inheritance Model",
+                         GroupName, GroupDescription,
+                         llvm::TimePassesIsEnabled);
       Gen->AssignInheritanceModel(RD);
     }
 
     void HandleVTable(CXXRecordDecl *RD) override {
+      NamedRegionTimer T("handlevtable", "Handle VTable", GroupName,
+                         GroupDescription, llvm::TimePassesIsEnabled);
       Gen->HandleVTable(RD);
     }
 
     static void InlineAsmDiagHandler(const llvm::SMDiagnostic &SM,void *Context,
                                      unsigned LocCookie) {
+      NamedRegionTimer T("inlineasmhandler", "Inline Asm Diag Handler",
+                         GroupName, GroupDescription,
+                         llvm::TimePassesIsEnabled);
       SourceLocation Loc = SourceLocation::getFromRawEncoding(LocCookie);
       ((BackendConsumer*)Context)->InlineAsmDiagHandler2(SM, Loc);
     }
@@ -932,6 +919,8 @@ static void BitcodeInlineAsmDiagHandler(const llvm::SMDiagnostic &SM,
 }
 
 std::unique_ptr<llvm::Module> CodeGenAction::loadModule(MemoryBufferRef MBRef) {
+  NamedRegionTimer T("loadmodule", "Load Module", GroupName, GroupDescription,
+                     llvm::TimePassesIsEnabled);
   CompilerInstance &CI = getCompilerInstance();
   SourceManager &SM = CI.getSourceManager();
 
@@ -999,6 +988,8 @@ std::unique_ptr<llvm::Module> CodeGenAction::loadModule(MemoryBufferRef MBRef) {
 void CodeGenAction::ExecuteAction() {
   // If this is an IR file, we have to treat it specially.
   if (getCurrentFileKind().getLanguage() == InputKind::LLVM_IR) {
+    NamedRegionTimer T("executeaction", "LLVM_IR ExecuteAction", GroupName,
+                       GroupDescription, llvm::TimePassesIsEnabled);
     BackendAction BA = static_cast<BackendAction>(Act);
     CompilerInstance &CI = getCompilerInstance();
     std::unique_ptr<raw_pwrite_stream> OS =

diff --git a/lib/Frontend/ASTMerge.cpp b/lib/Frontend/ASTMerge.cpp
index 6ec0e2a98c1b1589381782651e97a0d426c86bce..b1a3407a423205335cbe608f4f3421f3bc24442f 100644 (file)
--- a/lib/Frontend/ASTMerge.cpp
+++ b/lib/Frontend/ASTMerge.cpp
@@ -6,13 +6,14 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "clang/Frontend/ASTUnit.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTImporter.h"
 #include "clang/Basic/Diagnostic.h"
+#include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
+#include "llvm/Support/Timer.h"
 
 using namespace clang;
 
@@ -31,6 +32,8 @@ bool ASTMergeAction::BeginSourceFileAction(CompilerInstance &CI) {
 }
 
 void ASTMergeAction::ExecuteAction() {
+  llvm::NamedRegionTimer T("astmerge", "AST Merge actions", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
   CompilerInstance &CI = getCompilerInstance();
   CI.getDiagnostics().getClient()->BeginSourceFile(
                                              CI.getASTContext().getLangOpts());

diff --git a/lib/Frontend/CompilerInstance.cpp b/lib/Frontend/CompilerInstance.cpp
index b8f55b614271efd2766b879b71cab9f96e01bd0e..904e5876814f38672dc6adc1ff33d5757705612f 100644 (file)
--- a/lib/Frontend/CompilerInstance.cpp
+++ b/lib/Frontend/CompilerInstance.cpp
@@ -54,6 +54,8 @@
 #include <utility>
 
 using namespace clang;
+static const char *const GroupName = "frontend";
+static const char *const GroupDescription = "===== Frontend =====";
 
 CompilerInstance::CompilerInstance(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
@@ -935,6 +937,10 @@ bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
   assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
   assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
 
+  llvm::NamedRegionTimer T("compilerinstance", "Compiler Instance actions",
+                           GroupName, GroupDescription,
+                           llvm::TimePassesIsEnabled);
+
   // FIXME: Take this as an argument, once all the APIs we used have moved to
   // taking it as an input instead of hard-coding llvm::errs.
   raw_ostream &OS = llvm::errs();

diff --git a/lib/Frontend/FrontendAction.cpp b/lib/Frontend/FrontendAction.cpp
index 1b4d789b4d978eed01845067d8f01e83d627d718..b41d581ba30b9fb2f6dd853560663539093c425f 100644 (file)
--- a/lib/Frontend/FrontendAction.cpp
+++ b/lib/Frontend/FrontendAction.cpp
@@ -23,6 +23,7 @@
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Parse/ParseAST.h"
+#include "clang/Rewrite/Frontend/FrontendActions.h"
 #include "clang/Serialization/ASTDeserializationListener.h"
 #include "clang/Serialization/ASTReader.h"
 #include "clang/Serialization/GlobalModuleIndex.h"

diff --git a/lib/Frontend/FrontendActions.cpp b/lib/Frontend/FrontendActions.cpp
index 8cb6a04224da3e4420e4f3f48c10cb995e264621..74563ad04dd2ab6d6aa398850a480e59bfecd0ef 100644 (file)
--- a/lib/Frontend/FrontendActions.cpp
+++ b/lib/Frontend/FrontendActions.cpp
@@ -262,6 +262,8 @@ VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
 }
 
 void VerifyPCHAction::ExecuteAction() {
+  llvm::NamedRegionTimer T("verifypch", "Verify PCH actions", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
   CompilerInstance &CI = getCompilerInstance();
   bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
   const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
@@ -659,6 +661,8 @@ void PreprocessOnlyAction::ExecuteAction() {
 }
 
 void PrintPreprocessedAction::ExecuteAction() {
+  llvm::NamedRegionTimer T("printpp", "Print PP actions", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
   CompilerInstance &CI = getCompilerInstance();
   // Output file may need to be set to 'Binary', to avoid converting Unix style
   // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>).

diff --git a/lib/Lex/HeaderSearch.cpp b/lib/Lex/HeaderSearch.cpp
index 93a5ad4c9218d0a5b86e1dd2860d9f02351cc7a0..3d9084661280df970ea64fdeba3bb0c90abc88a2 100644 (file)
--- a/lib/Lex/HeaderSearch.cpp
+++ b/lib/Lex/HeaderSearch.cpp
@@ -30,11 +30,13 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Pass.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Capacity.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Timer.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -199,6 +201,9 @@ std::string HeaderSearch::getCachedModuleFileName(StringRef ModuleName,
 }
 
 Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) {
+  llvm::NamedRegionTimer T("lookupmodule", "Lookup Module", IncGroupName,
+                           IncGroupDescription, llvm::TimePassesIsEnabled);
+
   // Look in the module map to determine if there is a module by this name.
   Module *Module = ModMap.findModule(ModuleName);
   if (Module || !AllowSearch || !HSOpts->ImplicitModuleMaps)
@@ -223,6 +228,8 @@ Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) {
 }
 
 Module *HeaderSearch::lookupModule(StringRef ModuleName, StringRef SearchName) {
+  llvm::NamedRegionTimer T("lookupmodule", "Lookup Module", IncGroupName,
+                           IncGroupDescription, llvm::TimePassesIsEnabled);
   Module *Module = nullptr;
 
   // Look through the various header search paths to load any available module
@@ -340,6 +347,8 @@ const FileEntry *DirectoryLookup::LookupFile(
     bool &InUserSpecifiedSystemFramework,
     bool &HasBeenMapped,
     SmallVectorImpl<char> &MappedName) const {
+  llvm::NamedRegionTimer T("lookupfile", "Lookup File", IncGroupName,
+                           IncGroupDescription, llvm::TimePassesIsEnabled);
   InUserSpecifiedSystemFramework = false;
   HasBeenMapped = false;
 
@@ -467,6 +476,8 @@ const FileEntry *DirectoryLookup::DoFrameworkLookup(
     SmallVectorImpl<char> *RelativePath, Module *RequestingModule,
     ModuleMap::KnownHeader *SuggestedModule,
     bool &InUserSpecifiedSystemFramework) const {
+  llvm::NamedRegionTimer T("lookupfw", "Lookup Framework", IncGroupName,
+                           IncGroupDescription, llvm::TimePassesIsEnabled);
   FileManager &FileMgr = HS.getFileMgr();
 
   // Framework names must have a '/' in the filename.
@@ -633,6 +644,8 @@ const FileEntry *HeaderSearch::LookupFile(
     SmallVectorImpl<char> *SearchPath, SmallVectorImpl<char> *RelativePath,
     Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule,
     bool *IsMapped, bool SkipCache, bool BuildSystemModule) {
+  llvm::NamedRegionTimer T("lookupfile2", "Lookup File2", IncGroupName,
+                           IncGroupDescription, llvm::TimePassesIsEnabled);
   if (IsMapped)
     *IsMapped = false;
 
@@ -894,6 +907,8 @@ LookupSubframeworkHeader(StringRef Filename,
                          Module *RequestingModule,
                          ModuleMap::KnownHeader *SuggestedModule) {
   assert(ContextFileEnt && "No context file?");
+  llvm::NamedRegionTimer T("lookupsubfm", "Lookup SubFramework", IncGroupName,
+                           IncGroupDescription, llvm::TimePassesIsEnabled);
 
   // Framework names must have a '/' in the filename.  Find it.
   // FIXME: Should we permit '\' on Windows?
@@ -1111,6 +1126,9 @@ void HeaderSearch::MarkFileModuleHeader(const FileEntry *FE,
 bool HeaderSearch::ShouldEnterIncludeFile(Preprocessor &PP,
                                           const FileEntry *File, bool isImport,
                                           bool ModulesEnabled, Module *M) {
+  llvm::NamedRegionTimer T("shouldenterinc", "Should Enter Include File",
+                           IncGroupName, IncGroupDescription,
+                           llvm::TimePassesIsEnabled);
   ++NumIncluded; // Count # of attempted #includes.
 
   // Get information about this file.
@@ -1287,6 +1305,9 @@ static bool suggestModule(HeaderSearch &HS, const FileEntry *File,
 bool HeaderSearch::findUsableModuleForHeader(
     const FileEntry *File, const DirectoryEntry *Root, Module *RequestingModule,
     ModuleMap::KnownHeader *SuggestedModule, bool IsSystemHeaderDir) {
+  llvm::NamedRegionTimer T("findmodule4header", "Find Usable Module For Header",
+                           IncGroupName, IncGroupDescription,
+                           llvm::TimePassesIsEnabled);
   if (File && needModuleLookup(RequestingModule, SuggestedModule)) {
     // If there is a module that corresponds to this header, suggest it.
     hasModuleMap(File->getName(), Root, IsSystemHeaderDir);
@@ -1299,6 +1320,9 @@ bool HeaderSearch::findUsableModuleForFrameworkHeader(
     const FileEntry *File, StringRef FrameworkName, Module *RequestingModule,
     ModuleMap::KnownHeader *SuggestedModule, bool IsSystemFramework) {
   // If we're supposed to suggest a module, look for one now.
+  llvm::NamedRegionTimer T(
+      "findmodule4fwheader", "Find Usable Module For Framework Header",
+      IncGroupName, IncGroupDescription, llvm::TimePassesIsEnabled);
   if (needModuleLookup(RequestingModule, SuggestedModule)) {
     // Find the top-level framework based on this framework.
     SmallVector<std::string, 4> SubmodulePath;
@@ -1483,6 +1507,8 @@ HeaderSearch::loadModuleMapFile(const DirectoryEntry *Dir, bool IsSystem,
 }
 
 void HeaderSearch::collectAllModules(SmallVectorImpl<Module *> &Modules) {
+  llvm::NamedRegionTimer T("allmodules", "Collect All Modules", IncGroupName,
+                           IncGroupDescription, llvm::TimePassesIsEnabled);
   Modules.clear();
 
   if (HSOpts->ImplicitModuleMaps) {

diff --git a/lib/Lex/PPMacroExpansion.cpp b/lib/Lex/PPMacroExpansion.cpp
index 5af8ba57241e381c7003141daeab2bb140359706..7c44cc8430059f7871d0ed8c336b65dd60f460a8 100644 (file)
--- a/lib/Lex/PPMacroExpansion.cpp
+++ b/lib/Lex/PPMacroExpansion.cpp
@@ -26,9 +26,9 @@
 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/MacroArgs.h"
 #include "clang/Lex/MacroInfo.h"
+#include "clang/Lex/PTHLexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorLexer.h"
-#include "clang/Lex/PTHLexer.h"
 #include "clang/Lex/Token.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
@@ -36,15 +36,16 @@
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
@@ -57,6 +58,9 @@
 
 using namespace clang;
 
+static const char *const GroupName = "clangparser";
+static const char *const GroupDescription = "===== Clang Parser =====";
+
 MacroDirective *
 Preprocessor::getLocalMacroDirectiveHistory(const IdentifierInfo *II) const {
   if (!II->hadMacroDefinition())
@@ -69,6 +73,8 @@ Preprocessor::getLocalMacroDirectiveHistory(const IdentifierInfo *II) const {
 void Preprocessor::appendMacroDirective(IdentifierInfo *II, MacroDirective *MD){
   assert(MD && "MacroDirective should be non-zero!");
   assert(!MD->getPrevious() && "Already attached to a MacroDirective history.");
+  llvm::NamedRegionTimer NRT("appendmacro", "PP Append Macro", GroupName,
+                             GroupDescription, llvm::TimePassesIsEnabled);
 
   MacroState &StoredMD = CurSubmoduleState->Macros[II];
   auto *OldMD = StoredMD.getLatest();
@@ -131,6 +137,8 @@ ModuleMacro *Preprocessor::addModuleMacro(Module *Mod, IdentifierInfo *II,
                                           MacroInfo *Macro,
                                           ArrayRef<ModuleMacro *> Overrides,
                                           bool &New) {
+  llvm::NamedRegionTimer NRT("addmodulemacro", "PP Add Module Macro", GroupName,
+                             GroupDescription, llvm::TimePassesIsEnabled);
   llvm::FoldingSetNodeID ID;
   ModuleMacro::Profile(ID, Mod, II);
 
@@ -182,6 +190,9 @@ void Preprocessor::updateModuleMacroInfo(const IdentifierInfo *II,
   assert(Info.ActiveModuleMacrosGeneration !=
              CurSubmoduleState->VisibleModules.getGeneration() &&
          "don't need to update this macro name info");
+  llvm::NamedRegionTimer NRT("updatemodulemacro", "PP Update Module Macro",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   Info.ActiveModuleMacrosGeneration =
       CurSubmoduleState->VisibleModules.getGeneration();
 
@@ -754,6 +765,8 @@ static bool GenerateNewArgTokens(Preprocessor &PP,
 MacroArgs *Preprocessor::ReadMacroCallArgumentList(Token &MacroName,
                                                    MacroInfo *MI,
                                                    SourceLocation &MacroEnd) {
+  llvm::NamedRegionTimer NRT("ppmacrocall", "PP Macro Call Args", GroupName,
+                             GroupDescription, llvm::TimePassesIsEnabled);
   // The number of fixed arguments to parse.
   unsigned NumFixedArgsLeft = MI->getNumParams();
   bool isVariadic = MI->isVariadic();

diff --git a/lib/Lex/Pragma.cpp b/lib/Lex/Pragma.cpp
index db32e452d0795bfe43ecae38143da9c8ab12dc82..a1944e30ffb0f20e13d04acaa3710014c712dd99 100644 (file)
--- a/lib/Lex/Pragma.cpp
+++ b/lib/Lex/Pragma.cpp
@@ -39,11 +39,13 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/CrashRecoveryContext.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Pass.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Timer.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -54,6 +56,8 @@
 #include <vector>
 
 using namespace clang;
+static const char *const GroupName = "clangparser";
+static const char *const GroupDescription = "===== Clang Parser =====";
 
 // Out-of-line destructor to provide a home for the class.
 PragmaHandler::~PragmaHandler() = default;
@@ -82,6 +86,8 @@ PragmaNamespace::~PragmaNamespace() {
 /// the null handler isn't returned on failure to match.
 PragmaHandler *PragmaNamespace::FindHandler(StringRef Name,
                                             bool IgnoreNull) const {
+  llvm::NamedRegionTimer NRT("ppfindhandler", "PP Find Handler", GroupName,
+                             GroupDescription, llvm::TimePassesIsEnabled);
   if (PragmaHandler *Handler = Handlers.lookup(Name))
     return Handler;
   return IgnoreNull ? nullptr : Handlers.lookup(StringRef());
@@ -128,6 +134,8 @@ void PragmaNamespace::HandlePragma(Preprocessor &PP,
 /// rest of the pragma, passing it to the registered pragma handlers.
 void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc,
                                          PragmaIntroducerKind Introducer) {
+  llvm::NamedRegionTimer NRT("pppragma", "Handle Pragma Directive", GroupName,
+                             GroupDescription, llvm::TimePassesIsEnabled);
   if (Callbacks)
     Callbacks->PragmaDirective(IntroducerLoc, Introducer);
 

diff --git a/lib/Parse/ParseTemplate.cpp b/lib/Parse/ParseTemplate.cpp
index 88a5745350d6d45da1b7ea0e4f2989309af926e7..0792e135cd58e755e4afea73b4b9e02b294e949f 100644 (file)
--- a/lib/Parse/ParseTemplate.cpp
+++ b/lib/Parse/ParseTemplate.cpp
@@ -19,6 +19,7 @@
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
+#include "llvm/Support/Timer.h"
 using namespace clang;
 
 /// \brief Parse a template declaration, explicit instantiation, or
@@ -28,6 +29,8 @@ Parser::ParseDeclarationStartingWithTemplate(DeclaratorContext Context,
                                              SourceLocation &DeclEnd,
                                              AccessSpecifier AS,
                                              AttributeList *AccessAttrs) {
+  llvm::NamedRegionTimer NRT("parsetemplate", "Parse Template", GroupName,
+                             GroupDescription, llvm::TimePassesIsEnabled);
   ObjCDeclContextSwitch ObjCDC(*this);
   
   if (Tok.is(tok::kw_template) && NextToken().isNot(tok::less)) {

diff --git a/lib/Parse/Parser.cpp b/lib/Parse/Parser.cpp
index d8f9f7a390257dfec42a95f7190bb8c1e3525585..1d0511e0ef4d5e80ba7df26d034a22ef2252f4b7 100644 (file)
--- a/lib/Parse/Parser.cpp
+++ b/lib/Parse/Parser.cpp
@@ -20,6 +20,7 @@
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
+#include "llvm/Support/Timer.h"
 using namespace clang;
 
 
@@ -368,6 +369,8 @@ void Parser::EnterScope(unsigned ScopeFlags) {
 /// ExitScope - Pop a scope off the scope stack.
 void Parser::ExitScope() {
   assert(getCurScope() && "Scope imbalance!");
+  llvm::NamedRegionTimer NRT("clangscope", "Scope manipulation", GroupName,
+                             GroupDescription, llvm::TimePassesIsEnabled);
 
   // Inform the actions module that this scope is going away if there are any
   // decls in it.
@@ -543,6 +546,9 @@ bool Parser::ParseFirstTopLevelDecl(DeclGroupPtrTy &Result) {
 /// ParseTopLevelDecl - Parse one top-level declaration, return whatever the
 /// action tells us to.  This returns true if the EOF was encountered.
 bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result) {
+  llvm::NamedRegionTimer NRT("parsetopleveldecl", "Parse Top Level Decl",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds);
 
   // Skip over the EOF token, flagging end of previous input for incremental
@@ -1046,6 +1052,9 @@ Parser::ParseDeclarationOrFunctionDefinition(ParsedAttributesWithRange &attrs,
 Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D,
                                       const ParsedTemplateInfo &TemplateInfo,
                                       LateParsedAttrList *LateParsedAttrs) {
+  llvm::NamedRegionTimer NRT("parsefdef", "Parse Function Definition",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   // Poison SEH identifiers so they are flagged as illegal in function bodies.
   PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true);
   const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
@@ -1922,6 +1931,9 @@ bool Parser::isTokenEqualOrEqualTypo() {
 
 SourceLocation Parser::handleUnexpectedCodeCompletionToken() {
   assert(Tok.is(tok::code_completion));
+  llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   PrevTokLocation = Tok.getLocation();
 
   for (Scope *S = getCurScope(); S; S = S->getParent()) {
@@ -1947,29 +1959,47 @@ SourceLocation Parser::handleUnexpectedCodeCompletionToken() {
 // Code-completion pass-through functions
 
 void Parser::CodeCompleteDirective(bool InConditional) {
+  llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   Actions.CodeCompletePreprocessorDirective(InConditional);
 }
 
 void Parser::CodeCompleteInConditionalExclusion() {
+  llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   Actions.CodeCompleteInPreprocessorConditionalExclusion(getCurScope());
 }
 
 void Parser::CodeCompleteMacroName(bool IsDefinition) {
+  llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   Actions.CodeCompletePreprocessorMacroName(IsDefinition);
 }
 
-void Parser::CodeCompletePreprocessorExpression() { 
+void Parser::CodeCompletePreprocessorExpression() {
+  llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   Actions.CodeCompletePreprocessorExpression();
 }
 
 void Parser::CodeCompleteMacroArgument(IdentifierInfo *Macro,
                                        MacroInfo *MacroInfo,
                                        unsigned ArgumentIndex) {
+  llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   Actions.CodeCompletePreprocessorMacroArgument(getCurScope(), Macro, MacroInfo,
                                                 ArgumentIndex);
 }
 
 void Parser::CodeCompleteNaturalLanguage() {
+  llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   Actions.CodeCompleteNaturalLanguage();
 }
 
@@ -2078,6 +2108,9 @@ void Parser::ParseMicrosoftIfExistsExternalDeclaration() {
 ///
 /// Note that 'partition' is a context-sensitive keyword.
 Parser::DeclGroupPtrTy Parser::ParseModuleDecl() {
+  llvm::NamedRegionTimer NRT("moduleoperations", "Module related operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   SourceLocation StartLoc = Tok.getLocation();
 
   Sema::ModuleDeclKind MDK = TryConsumeToken(tok::kw_export)
@@ -2123,6 +2156,9 @@ Decl *Parser::ParseModuleImport(SourceLocation AtLoc) {
   assert((AtLoc.isInvalid() ? Tok.is(tok::kw_import)
                             : Tok.isObjCAtKeyword(tok::objc_import)) &&
          "Improper start to module import");
+  llvm::NamedRegionTimer NRT("moduleoperations", "Module related operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   SourceLocation ImportLoc = ConsumeToken();
   SourceLocation StartLoc = AtLoc.isInvalid() ? ImportLoc : AtLoc;
   
@@ -2160,6 +2196,9 @@ bool Parser::ParseModuleName(
     SourceLocation UseLoc,
     SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>> &Path,
     bool IsImport) {
+  llvm::NamedRegionTimer NRT("moduleoperations", "Module related operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   // Parse the module path.
   while (true) {
     if (!Tok.is(tok::identifier)) {
@@ -2190,6 +2229,9 @@ bool Parser::ParseModuleName(
 /// \returns false if the recover was successful and parsing may be continued, or
 /// true if parser must bail out to top level and handle the token there.
 bool Parser::parseMisplacedModuleImport() {
+  llvm::NamedRegionTimer NRT("moduleoperations", "Module related operations",
+                             GroupName, GroupDescription,
+                             llvm::TimePassesIsEnabled);
   while (true) {
     switch (Tok.getKind()) {
     case tok::annot_module_end:

diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp
index 5c0026cd3747d7aa131a89fb4b96db1579d94d07..928d87322111a6acea6ec725d60bb64e465a70d2 100644 (file)
--- a/lib/Sema/Sema.cpp
+++ b/lib/Sema/Sema.cpp
@@ -40,6 +40,7 @@
 #include "clang/Sema/TemplateInstCallback.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallSet.h"
+#include "llvm/Support/Timer.h"
 using namespace clang;
 using namespace sema;
 
@@ -842,6 +843,9 @@ void Sema::ActOnStartOfTranslationUnit() {
 /// translation unit when EOF is reached and all but the top-level scope is
 /// popped.
 void Sema::ActOnEndOfTranslationUnit() {
+  llvm::NamedRegionTimer T(
+      "actoneou1", "Act On End Of Translation Unit: Common case",
+      GroupName, GroupDescription, llvm::TimePassesIsEnabled);
   assert(DelayedDiagnostics.getCurrentPool() == nullptr
          && "reached end of translation unit with a pool attached?");
 
@@ -867,6 +871,10 @@ void Sema::ActOnEndOfTranslationUnit() {
   // Complete translation units and modules define vtables and perform implicit
   // instantiations. PCH files do not.
   if (TUKind != TU_Prefix) {
+    llvm::NamedRegionTimer T(
+        "actoneou2",
+        "Act On End Of Translation Unit: TUKind != TU_Prefix", GroupName,
+        GroupDescription, llvm::TimePassesIsEnabled);
     DiagnoseUseOfUnimplementedSelectors();
 
     // If DefinedUsedVTables ends up marking any virtual member functions it
@@ -929,6 +937,10 @@ void Sema::ActOnEndOfTranslationUnit() {
       UnusedFileScopedDecls.end());
 
   if (TUKind == TU_Prefix) {
+    llvm::NamedRegionTimer T(
+        "actoneou3",
+        "Act On End Of Translation Unit: TUKind == TU_Prefix", GroupName,
+        GroupDescription, llvm::TimePassesIsEnabled);
     // Translation unit prefixes don't need any of the checking below.
     if (!PP.isIncrementalProcessingEnabled())
       TUScope = nullptr;
@@ -963,6 +975,10 @@ void Sema::ActOnEndOfTranslationUnit() {
   }
 
   if (TUKind == TU_Module) {
+    llvm::NamedRegionTimer T(
+        "actoneou4",
+        "Act On End Of Translation Unit: TUKind == TU_Module", GroupName,
+        GroupDescription, llvm::TimePassesIsEnabled);
     // If we are building a module interface unit, we need to have seen the
     // module declaration by now.
     if (getLangOpts().getCompilingModule() ==
@@ -1557,6 +1573,9 @@ void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
 ///  name, this parameter is populated with the decls of the various overloads.
 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
                          UnresolvedSetImpl &OverloadSet) {
+  llvm::NamedRegionTimer T("tryascall", "Try Expr As Call", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
+
   ZeroArgCallReturnTy = QualType();
   OverloadSet.clear();
 
@@ -1719,6 +1738,9 @@ static bool IsCallableWithAppend(Expr *E) {
 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
                                 bool ForceComplain,
                                 bool (*IsPlausibleResult)(QualType)) {
+  llvm::NamedRegionTimer T("trytorecover", "Try To Recover With Call",
+                           GroupName, GroupDescription,
+                           llvm::TimePassesIsEnabled);
   SourceLocation Loc = E.get()->getExprLoc();
   SourceRange Range = E.get()->getSourceRange();
 

diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp
index fdf7e2b70f39cfaec0213b97f8a82756fcf7493f..74f0de61abecd022e153d4867874a1cf89e3b404 100644 (file)
--- a/lib/Sema/SemaChecking.cpp
+++ b/lib/Sema/SemaChecking.cpp
@@ -84,6 +84,7 @@
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Locale.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
@@ -118,7 +119,7 @@ static bool checkArgCount(Sema &S, CallExpr *call, unsigned desiredArgCount) {
   // Highlight all the excess arguments.
   SourceRange range(call->getArg(desiredArgCount)->getLocStart(),
                     call->getArg(argCount - 1)->getLocEnd());
-    
+
   return S.Diag(range.getBegin(), diag::err_typecheck_call_too_many_args)
     << 0 /*function call*/ << desiredArgCount << argCount
     << call->getArg(1)->getSourceRange();
@@ -224,7 +225,7 @@ static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall) {
 }
 
 static void SemaBuiltinMemChkCall(Sema &S, FunctionDecl *FDecl,
-                                 CallExpr *TheCall, unsigned SizeIdx,
+                                  CallExpr *TheCall, unsigned SizeIdx,
                                   unsigned DstSizeIdx) {
   if (TheCall->getNumArgs() <= SizeIdx ||
       TheCall->getNumArgs() <= DstSizeIdx)
@@ -491,6 +492,9 @@ static bool checkOpenCLEnqueueVariadicArgs(Sema &S, CallExpr *TheCall,
 ///                    void (^block)(local void*, ...),
 ///                    uint size0, ...)
 static bool SemaOpenCLBuiltinEnqueueKernel(Sema &S, CallExpr *TheCall) {
+  llvm::NamedRegionTimer T(
+      "semaopenclbuiltin", "Sema OpenCL Builtin Enqueue Kernel",
+      Sema::GroupName, Sema::GroupDescription, llvm::TimePassesIsEnabled);
   unsigned NumArgs = TheCall->getNumArgs();
 
   if (NumArgs < 4) {
@@ -853,6 +857,10 @@ static bool SemaOpenCLBuiltinToAddr(Sema &S, unsigned BuiltinID,
 ExprResult
 Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
                                CallExpr *TheCall) {
+  llvm::NamedRegionTimer T("checkbuiltinfunction",
+                           "Check Builtin Function Call", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
+
   ExprResult TheCallResult(TheCall);
 
   // Find out if any arguments are required to be integer constant expressions.
@@ -2252,6 +2260,9 @@ bool Sema::CheckX86BuiltinGatherScatterScale(unsigned BuiltinID,
 }
 
 bool Sema::CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
+  llvm::NamedRegionTimer T("checkx86builtin",
+                           "Check X86 Builtin Function Call", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
   if (BuiltinID == X86::BI__builtin_cpu_supports)
     return SemaBuiltinCpuSupports(*this, TheCall);
 
@@ -2693,6 +2704,8 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
                      const Expr *ThisArg, ArrayRef<const Expr *> Args,
                      bool IsMemberFunction, SourceLocation Loc,
                      SourceRange Range, VariadicCallType CallType) {
+  llvm::NamedRegionTimer T("checkcall", "Check Call", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
   // FIXME: We should check as much as we can in the template definition.
   if (CurContext->isDependentContext())
     return;
@@ -3331,6 +3344,10 @@ static bool checkBuiltinArgument(Sema &S, CallExpr *E, unsigned ArgIndex) {
 /// builtins,
 ExprResult
 Sema::SemaBuiltinAtomicOverloaded(ExprResult TheCallResult) {
+  llvm::NamedRegionTimer T("semabuiltinatomic",
+                           "Sema Builtin Atomic Overloaded", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
+
   CallExpr *TheCall = (CallExpr *)TheCallResult.get();
   DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
   FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
@@ -9518,6 +9535,10 @@ static bool isSameWidthConstantConversion(Sema &S, Expr *E, QualType T,
 static void
 CheckImplicitConversion(Sema &S, Expr *E, QualType T, SourceLocation CC,
                         bool *ICContext = nullptr) {
+  llvm::NamedRegionTimer NRT("checkimplicit",
+                             "Check Implicit Conversion", Sema::GroupName,
+                             Sema::GroupDescription, llvm::TimePassesIsEnabled);
+
   if (E->isTypeDependent() || E->isValueDependent()) return;
 
   const Type *Source = S.Context.getCanonicalType(E->getType()).getTypePtr();

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 9228d65250cd56d01169e6af2394fa9db6d98d17..6ed2c9ee80523f973f72bc6849b015bd4fa0b3bf 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -44,6 +44,7 @@
 #include "clang/Sema/Template.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Support/Timer.h"
 #include <algorithm>
 #include <cstring>
 #include <functional>
@@ -849,6 +850,8 @@ Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
                    SourceLocation NameLoc, const Token &NextToken,
                    bool IsAddressOfOperand,
                    std::unique_ptr<CorrectionCandidateCallback> CCC) {
+  llvm::NamedRegionTimer T("classifyname", "Classify Name", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
   DeclarationNameInfo NameInfo(Name, NameLoc);
   ObjCMethodDecl *CurMethod = getCurMethodDecl();
 
@@ -5321,6 +5324,8 @@ bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
 
 NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D,
                                   MultiTemplateParamsArg TemplateParamLists) {
+  llvm::NamedRegionTimer T("handledeclarator", "Handle Declarator", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
   // TODO: consider using NameInfo for diagnostic.
   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
   DeclarationName Name = NameInfo.getName();

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index b8cadaf7abbaf40d8f34aa3456ddc6fa2a3f3ee7..0b86480385916d10d68abd7d0fd13c8185fcb49f 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -44,6 +44,7 @@
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/Timer.h"
 using namespace clang;
 using namespace sema;
 
@@ -1308,6 +1309,10 @@ Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc,
                                 Expr *ControllingExpr,
                                 ArrayRef<ParsedType> ArgTypes,
                                 ArrayRef<Expr *> ArgExprs) {
+  llvm::NamedRegionTimer T("actongenericselection",
+                           "Act On Generic Selection Expr", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
+
   unsigned NumAssocs = ArgTypes.size();
   assert(NumAssocs == ArgExprs.size());
 
@@ -1520,6 +1525,9 @@ static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope,
 ExprResult
 Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
   assert(!StringToks.empty() && "Must have at least one string!");
+  llvm::NamedRegionTimer T("actonstringliteral", "Act On String Literal",
+                           GroupName, GroupDescription,
+                           llvm::TimePassesIsEnabled);
 
   StringLiteralParser Literal(StringToks, PP);
   if (Literal.hadError)
@@ -2027,6 +2035,9 @@ Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
                         bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
   assert(!(IsAddressOfOperand && HasTrailingLParen) &&
          "cannot be direct & operand and have a trailing lparen");
+  llvm::NamedRegionTimer T("actonid", "Act On Id Expression",
+                           GroupName, GroupDescription,
+                           llvm::TimePassesIsEnabled);
   if (SS.isInvalid())
     return ExprError();
 
@@ -3063,6 +3074,10 @@ ExprResult Sema::BuildPredefinedExpr(SourceLocation Loc,
 }
 
 ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) {
+  llvm::NamedRegionTimer T("actonpredefined", "Act On Predefined Expr",
+                           GroupName, GroupDescription,
+                           llvm::TimePassesIsEnabled);
+
   PredefinedExpr::IdentType IT;
 
   switch (Kind) {

diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 9cc1bd529ff3d5a673b48d25ff25dfe8b1f1c78d..9df697eebef44c57f10c48f6f786c21a8ac36a5b 100644 (file)
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -32,6 +32,7 @@
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Timer.h"
 
 #include <iterator>
 using namespace clang;
@@ -303,6 +304,9 @@ void Sema::LookupTemplateName(LookupResult &Found,
                               QualType ObjectType,
                               bool EnteringContext,
                               bool &MemberOfUnknownSpecialization) {
+  llvm::NamedRegionTimer T("lookuptemplate", "Lookup Template Name",
+                           GroupName, GroupDescription,
+                           llvm::TimePassesIsEnabled);
   // Determine where to perform name lookup
   MemberOfUnknownSpecialization = false;
   DeclContext *LookupCtx = nullptr;
@@ -543,6 +547,9 @@ Sema::ActOnDependentIdExpression(const CXXScopeSpec &SS,
                                  const DeclarationNameInfo &NameInfo,
                                  bool isAddressOfOperand,
                            const TemplateArgumentListInfo *TemplateArgs) {
+  llvm::NamedRegionTimer T("actondependent",
+                           "Act On Dependent Id Expression", GroupName,
+                           GroupDescription, llvm::TimePassesIsEnabled);
   DeclContext *DC = getFunctionLevelDeclContext();
 
   // C++11 [expr.prim.general]p12:

diff --git a/test/Frontend/ftime-report-template-decl.cpp b/test/Frontend/ftime-report-template-decl.cpp
new file mode 100644 (file)
index 0000000..311358a
--- /dev/null
+++ b/test/Frontend/ftime-report-template-decl.cpp
@@ -0,0 +1,147 @@
+// RUN: %clang %s -S -o - -ftime-report  2>&1 | FileCheck %s
+// RUN: %clang %s -S -o - -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING -ftime-report  2>&1 | FileCheck %s
+
+// Template function declarations
+template <typename T>
+void foo();
+template <typename T, typename U>
+void foo();
+
+// Template function definitions.
+template <typename T>
+void foo() {}
+
+// Template class (forward) declarations
+template <typename T>
+struct A;
+template <typename T, typename U>
+struct b;
+template <typename>
+struct C;
+template <typename, typename>
+struct D;
+
+// Forward declarations with default parameters?
+template <typename T = int>
+class X1;
+template <typename = int>
+class X2;
+
+// Forward declarations w/template template parameters
+template <template <typename> class T>
+class TTP1;
+template <template <typename> class>
+class TTP2;
+template <template <typename X, typename Y> class T>
+class TTP5;
+
+// Forward declarations with non-type params
+template <int>
+class NTP0;
+template <int N>
+class NTP1;
+template <int N = 5>
+class NTP2;
+template <int = 10>
+class NTP3;
+template <unsigned int N = 12u>
+class NTP4;
+template <unsigned int = 12u>
+class NTP5;
+template <unsigned = 15u>
+class NTP6;
+template <typename T, T Obj>
+class NTP7;
+
+// Template class declarations
+template <typename T>
+struct A {};
+template <typename T, typename U>
+struct B {};
+
+namespace PR6184 {
+namespace N {
+template <typename T>
+void bar(typename T::x);
+}
+
+template <typename T>
+void N::bar(typename T::x) {}
+}
+
+// This PR occurred only in template parsing mode.
+namespace PR17637 {
+template <int>
+struct L {
+  template <typename T>
+  struct O {
+    template <typename U>
+    static void Fun(U);
+  };
+};
+
+template <int k>
+template <typename T>
+template <typename U>
+void L<k>::O<T>::Fun(U) {}
+
+void Instantiate() { L<0>::O<int>::Fun(0); }
+}
+
+namespace explicit_partial_specializations {
+typedef char (&oneT)[1];
+typedef char (&twoT)[2];
+typedef char (&threeT)[3];
+typedef char (&fourT)[4];
+typedef char (&fiveT)[5];
+typedef char (&sixT)[6];
+
+char one[1];
+char two[2];
+char three[3];
+char four[4];
+char five[5];
+char six[6];
+
+template <bool b>
+struct bool_ { typedef int type; };
+template <>
+struct bool_<false> {};
+
+#define XCAT(x, y) x##y
+#define CAT(x, y) XCAT(x, y)
+#define sassert(_b_) bool_<(_b_)>::type CAT(var, __LINE__);
+
+template <int>
+struct L {
+  template <typename T>
+  struct O {
+    template <typename U>
+    static oneT Fun(U);
+  };
+};
+template <int k>
+template <typename T>
+template <typename U>
+oneT L<k>::O<T>::Fun(U) { return one; }
+
+template <>
+template <>
+template <typename U>
+oneT L<0>::O<char>::Fun(U) { return one; }
+
+void Instantiate() {
+  sassert(sizeof(L<0>::O<int>::Fun(0)) == sizeof(one));
+  sassert(sizeof(L<0>::O<char>::Fun(0)) == sizeof(one));
+}
+}
+
+// CHECK:   ===== Clang Parser =====
+// CHECK:   ---User Time---   --User+System--   ---Wall Time---  --- Name ---
+// CHECK:   Parse Top Level Decl
+// CHECK:   Parse Template
+// CHECK:   Parse Function Definition
+// CHECK:   PP Append Macro
+// CHECK:   Scope manipulation
+// CHECK:   PP Find Handler
+// CHECK:   Total