Index: include/clang/Frontend/FrontendAction.h =================================================================== --- include/clang/Frontend/FrontendAction.h +++ include/clang/Frontend/FrontendAction.h @@ -45,6 +45,9 @@ StringRef InFile); protected: + static constexpr const char *GroupName = "factions"; + static constexpr const char *GroupDescription = + "===== Frontend Actions ====="; /// @name Implementation Action Interface /// @{ Index: include/clang/Frontend/Utils.h =================================================================== --- include/clang/Frontend/Utils.h +++ include/clang/Frontend/Utils.h @@ -17,12 +17,13 @@ #include "clang/Basic/Diagnostic.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/VirtualFileSystem.h" -#include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSet.h" #include "llvm/Option/OptSpecifier.h" +#include "llvm/Support/Timer.h" #include #include #include @@ -234,6 +235,34 @@ BuryPointer(Ptr.release()); } +// Frontend timing utils + +/// If the user specifies the -ftime-report argument on an Clang command line +/// then the value of this boolean will be true, otherwise false. +extern bool FrontendTimesIsEnabled; +void startFrontendTimer(llvm::Timer *T, int *TimerLevel, const char *TimerName, + const char *TimerDsc, llvm::TimerGroup *TG); +void stopFrontendTimer(llvm::Timer *T, int *TimerLevel); + +static llvm::TimerGroup *TG = nullptr; + +class FrontendTimeRAII { + llvm::Timer *T; + int *Level; + +public: + FrontendTimeRAII(llvm::Timer *Timer, int *L, const char *TName, + const char *TDsc) + : T(Timer), Level(L) { + if (FrontendTimesIsEnabled) { + if (!TG) + TG = new llvm::TimerGroup("fetimers", "Frontend Recursive Timers"); + startFrontendTimer(T, Level, TName, TDsc, TG); + } + } + ~FrontendTimeRAII() { stopFrontendTimer(T, Level); } +}; + } // namespace clang #endif // LLVM_CLANG_FRONTEND_UTILS_H Index: include/clang/Lex/HeaderSearch.h =================================================================== --- include/clang/Lex/HeaderSearch.h +++ 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 #include #include @@ -31,6 +32,9 @@ #include #include +static const char *const IncGroupName = "includefiles"; +static const char *const IncGroupDescription = "===== Include Files ====="; + namespace clang { class DiagnosticsEngine; Index: include/clang/Parse/Parser.h =================================================================== --- include/clang/Parse/Parser.h +++ include/clang/Parse/Parser.h @@ -2851,4 +2851,6 @@ } // end namespace clang +static const char *const GroupName = "clangparser"; +static const char *const GroupDescription = "===== Clang Parser ====="; #endif Index: include/clang/Sema/Sema.h =================================================================== --- include/clang/Sema/Sema.h +++ include/clang/Sema/Sema.h @@ -304,6 +304,9 @@ bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New); public: + static constexpr const char *GroupName = "sema"; + static constexpr const char *GroupDescription = "===== Sema ====="; + typedef OpaquePtr DeclGroupPtrTy; typedef OpaquePtr TemplateTy; typedef OpaquePtr TypeTy; Index: lib/Basic/CMakeLists.txt =================================================================== --- lib/Basic/CMakeLists.txt +++ lib/Basic/CMakeLists.txt @@ -54,6 +54,7 @@ DiagnosticOptions.cpp FileManager.cpp FileSystemStatCache.cpp + FrontendTiming.cpp IdentifierTable.cpp LangOptions.cpp MemoryBufferCache.cpp Index: lib/CodeGen/BackendUtil.cpp =================================================================== --- lib/CodeGen/BackendUtil.cpp +++ lib/CodeGen/BackendUtil.cpp @@ -718,7 +718,7 @@ void EmitAssemblyHelper::EmitAssembly(BackendAction Action, std::unique_ptr OS) { - TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr); + TimeRegion Region(FrontendTimesIsEnabled ? &CodeGenerationTime : nullptr); setCommandLineOpts(CodeGenOpts); @@ -848,7 +848,7 @@ /// `EmitAssembly` at some point in the future when the default switches. void EmitAssemblyHelper::EmitAssemblyWithNewPassManager( BackendAction Action, std::unique_ptr OS) { - TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr); + TimeRegion Region(FrontendTimesIsEnabled ? &CodeGenerationTime : nullptr); setCommandLineOpts(CodeGenOpts); // The new pass manager always makes a target machine available to passes Index: lib/CodeGen/CodeGenAction.cpp =================================================================== --- lib/CodeGen/CodeGenAction.cpp +++ lib/CodeGen/CodeGenAction.cpp @@ -51,7 +51,7 @@ 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 +90,8 @@ const LangOptions &LangOpts; std::unique_ptr 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,12 +120,10 @@ : 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)) { - llvm::TimePassesIsEnabled = TimePasses; + clang::FrontendTimesIsEnabled = TimePasses; } llvm::Module *getModule() const { return Gen->GetModule(); } std::unique_ptr takeModule() { @@ -141,38 +138,22 @@ 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, + clang::FrontendTimesIsEnabled); 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, + clang::FrontendTimesIsEnabled); Gen->HandleTopLevelDecl(D); - - if (llvm::TimePassesIsEnabled) { - LLVMIRGenerationRefCount -= 1; - if (LLVMIRGenerationRefCount == 0) - LLVMIRGeneration.stopTimer(); - } - return true; } @@ -180,13 +161,11 @@ 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, clang::FrontendTimesIsEnabled); Gen->HandleInlineFunctionDefinition(D); - - if (llvm::TimePassesIsEnabled) - LLVMIRGeneration.stopTimer(); } void HandleInterestingDecl(DeclGroupRef D) override { @@ -197,6 +176,8 @@ // Links each entry in LinkModules into our module. Returns true on error. bool LinkInModules() { + NamedRegionTimer T("linkinmodules", "Link In Modules", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); for (auto &LM : LinkModules) { if (LM.PropagateAttrs) for (Function &F : *LM.Module) @@ -227,21 +208,12 @@ 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, + clang::FrontendTimesIsEnabled); 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 +281,37 @@ } void HandleTagDeclRequiredDefinition(const TagDecl *D) override { + NamedRegionTimer T("handletagdecl", "Handle Tag Decl Required Definition", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); Gen->HandleTagDeclRequiredDefinition(D); } void CompleteTentativeDefinition(VarDecl *D) override { + NamedRegionTimer T("completetentative", "Complete Tentative Definition", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); Gen->CompleteTentativeDefinition(D); } void AssignInheritanceModel(CXXRecordDecl *RD) override { + NamedRegionTimer T("assigninheritance", "Assign Inheritance Model", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); Gen->AssignInheritanceModel(RD); } void HandleVTable(CXXRecordDecl *RD) override { + NamedRegionTimer T("handlevtable", "Handle VTable", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); Gen->HandleVTable(RD); } static void InlineAsmDiagHandler(const llvm::SMDiagnostic &SM,void *Context, unsigned LocCookie) { + NamedRegionTimer T("inlineasmhandler", "Inline Asm Diag Handler", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); SourceLocation Loc = SourceLocation::getFromRawEncoding(LocCookie); ((BackendConsumer*)Context)->InlineAsmDiagHandler2(SM, Loc); } @@ -932,6 +918,8 @@ } std::unique_ptr CodeGenAction::loadModule(MemoryBufferRef MBRef) { + NamedRegionTimer T("loadmodule", "Load Module", GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); CompilerInstance &CI = getCompilerInstance(); SourceManager &SM = CI.getSourceManager(); @@ -999,6 +987,8 @@ 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, clang::FrontendTimesIsEnabled); BackendAction BA = static_cast(Act); CompilerInstance &CI = getCompilerInstance(); std::unique_ptr OS = Index: lib/Frontend/ASTMerge.cpp =================================================================== --- lib/Frontend/ASTMerge.cpp +++ lib/Frontend/ASTMerge.cpp @@ -31,6 +31,8 @@ } void ASTMergeAction::ExecuteAction() { + llvm::NamedRegionTimer T("astmerge", "AST Merge actions", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); CompilerInstance &CI = getCompilerInstance(); CI.getDiagnostics().getClient()->BeginSourceFile( CI.getASTContext().getLangOpts()); Index: lib/Frontend/CompilerInstance.cpp =================================================================== --- lib/Frontend/CompilerInstance.cpp +++ lib/Frontend/CompilerInstance.cpp @@ -54,6 +54,8 @@ #include using namespace clang; +static const char *const GroupName = "frontend"; +static const char *const GroupDescription = "===== Frontend ====="; CompilerInstance::CompilerInstance( std::shared_ptr PCHContainerOps, @@ -935,6 +937,10 @@ assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); + llvm::NamedRegionTimer T("compilerinstance", "Compiler Instance actions", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); + // 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(); Index: lib/Frontend/FrontendActions.cpp =================================================================== --- lib/Frontend/FrontendActions.cpp +++ lib/Frontend/FrontendActions.cpp @@ -262,6 +262,8 @@ } void VerifyPCHAction::ExecuteAction() { + llvm::NamedRegionTimer T("verifypch", "Verify PCH actions", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); CompilerInstance &CI = getCompilerInstance(); bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0; const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot; @@ -659,6 +661,8 @@ } void PrintPreprocessedAction::ExecuteAction() { + llvm::NamedRegionTimer T("printpp", "Print PP actions", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); CompilerInstance &CI = getCompilerInstance(); // Output file may need to be set to 'Binary', to avoid converting Unix style // line feeds () to Microsoft style line feeds (). Index: lib/Lex/HeaderSearch.cpp =================================================================== --- lib/Lex/HeaderSearch.cpp +++ lib/Lex/HeaderSearch.cpp @@ -18,6 +18,7 @@ #include "clang/Basic/Module.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/VirtualFileSystem.h" +#include "clang/Frontend/Utils.h" #include "clang/Lex/DirectoryLookup.h" #include "clang/Lex/ExternalPreprocessorSource.h" #include "clang/Lex/HeaderMap.h" @@ -199,6 +200,9 @@ } Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) { + llvm::NamedRegionTimer T("lookupmodule", "Lookup Module", IncGroupName, + IncGroupDescription, clang::FrontendTimesIsEnabled); + // 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 +227,8 @@ } Module *HeaderSearch::lookupModule(StringRef ModuleName, StringRef SearchName) { + llvm::NamedRegionTimer T("lookupmodule", "Lookup Module", IncGroupName, + IncGroupDescription, clang::FrontendTimesIsEnabled); Module *Module = nullptr; // Look through the various header search paths to load any available module @@ -340,6 +346,8 @@ bool &InUserSpecifiedSystemFramework, bool &HasBeenMapped, SmallVectorImpl &MappedName) const { + llvm::NamedRegionTimer T("lookupfile", "Lookup File", IncGroupName, + IncGroupDescription, clang::FrontendTimesIsEnabled); InUserSpecifiedSystemFramework = false; HasBeenMapped = false; @@ -467,6 +475,8 @@ SmallVectorImpl *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule, bool &InUserSpecifiedSystemFramework) const { + llvm::NamedRegionTimer T("lookupfw", "Lookup Framework", IncGroupName, + IncGroupDescription, clang::FrontendTimesIsEnabled); FileManager &FileMgr = HS.getFileMgr(); // Framework names must have a '/' in the filename. @@ -633,6 +643,8 @@ SmallVectorImpl *SearchPath, SmallVectorImpl *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool SkipCache, bool BuildSystemModule) { + llvm::NamedRegionTimer T("lookupfile2", "Lookup File2", IncGroupName, + IncGroupDescription, clang::FrontendTimesIsEnabled); if (IsMapped) *IsMapped = false; @@ -894,6 +906,8 @@ Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule) { assert(ContextFileEnt && "No context file?"); + llvm::NamedRegionTimer T("lookupsubfm", "Lookup SubFramework", IncGroupName, + IncGroupDescription, clang::FrontendTimesIsEnabled); // Framework names must have a '/' in the filename. Find it. // FIXME: Should we permit '\' on Windows? @@ -1111,6 +1125,9 @@ bool HeaderSearch::ShouldEnterIncludeFile(Preprocessor &PP, const FileEntry *File, bool isImport, bool ModulesEnabled, Module *M) { + llvm::NamedRegionTimer T("shouldenterinc", "Should Enter Include File", + IncGroupName, IncGroupDescription, + clang::FrontendTimesIsEnabled); ++NumIncluded; // Count # of attempted #includes. // Get information about this file. @@ -1287,6 +1304,9 @@ 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, + clang::FrontendTimesIsEnabled); if (File && needModuleLookup(RequestingModule, SuggestedModule)) { // If there is a module that corresponds to this header, suggest it. hasModuleMap(File->getName(), Root, IsSystemHeaderDir); @@ -1299,6 +1319,9 @@ 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, clang::FrontendTimesIsEnabled); if (needModuleLookup(RequestingModule, SuggestedModule)) { // Find the top-level framework based on this framework. SmallVector SubmodulePath; @@ -1483,6 +1506,8 @@ } void HeaderSearch::collectAllModules(SmallVectorImpl &Modules) { + llvm::NamedRegionTimer T("allmodules", "Collect All Modules", IncGroupName, + IncGroupDescription, clang::FrontendTimesIsEnabled); Modules.clear(); if (HSOpts->ImplicitModuleMaps) { Index: lib/Lex/PPMacroExpansion.cpp =================================================================== --- lib/Lex/PPMacroExpansion.cpp +++ lib/Lex/PPMacroExpansion.cpp @@ -20,25 +20,27 @@ #include "clang/Basic/ObjCRuntime.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/TargetInfo.h" +#include "clang/Frontend/Utils.h" #include "clang/Lex/CodeCompletionHandler.h" #include "clang/Lex/DirectoryLookup.h" #include "clang/Lex/ExternalPreprocessorSource.h" #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 "clang/Parse/Parser.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseSet.h" #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" @@ -69,6 +71,8 @@ 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, clang::FrontendTimesIsEnabled); MacroState &StoredMD = CurSubmoduleState->Macros[II]; auto *OldMD = StoredMD.getLatest(); @@ -131,6 +135,8 @@ MacroInfo *Macro, ArrayRef Overrides, bool &New) { + llvm::NamedRegionTimer NRT("addmodulemacro", "PP Add Module Macro", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); llvm::FoldingSetNodeID ID; ModuleMacro::Profile(ID, Mod, II); @@ -182,6 +188,9 @@ 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, + clang::FrontendTimesIsEnabled); Info.ActiveModuleMacrosGeneration = CurSubmoduleState->VisibleModules.getGeneration(); @@ -754,6 +763,8 @@ MacroArgs *Preprocessor::ReadMacroCallArgumentList(Token &MacroName, MacroInfo *MI, SourceLocation &MacroEnd) { + llvm::NamedRegionTimer NRT("ppmacrocall", "PP Macro Call Args", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); // The number of fixed arguments to parse. unsigned NumFixedArgsLeft = MI->getNumParams(); bool isVariadic = MI->isVariadic(); Index: lib/Lex/Pragma.cpp =================================================================== --- lib/Lex/Pragma.cpp +++ lib/Lex/Pragma.cpp @@ -22,6 +22,7 @@ #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TokenKinds.h" +#include "clang/Frontend/Utils.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/Lexer.h" @@ -29,20 +30,21 @@ #include "clang/Lex/MacroInfo.h" #include "clang/Lex/ModuleLoader.h" #include "clang/Lex/PPCallbacks.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 "clang/Lex/TokenLexer.h" +#include "clang/Parse/Parser.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #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/Support/Compiler.h" +#include "llvm/Support/CrashRecoveryContext.h" #include "llvm/Support/ErrorHandling.h" #include #include @@ -82,6 +84,8 @@ /// 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, clang::FrontendTimesIsEnabled); if (PragmaHandler *Handler = Handlers.lookup(Name)) return Handler; return IgnoreNull ? nullptr : Handlers.lookup(StringRef()); @@ -128,6 +132,8 @@ /// 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, clang::FrontendTimesIsEnabled); if (Callbacks) Callbacks->PragmaDirective(IntroducerLoc, Introducer); Index: lib/Parse/ParseTemplate.cpp =================================================================== --- lib/Parse/ParseTemplate.cpp +++ lib/Parse/ParseTemplate.cpp @@ -13,6 +13,7 @@ #include "clang/AST/ASTContext.h" #include "clang/AST/DeclTemplate.h" +#include "clang/Frontend/Utils.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Parse/Parser.h" #include "clang/Parse/RAIIObjectsForParser.h" @@ -28,6 +29,8 @@ SourceLocation &DeclEnd, AccessSpecifier AS, AttributeList *AccessAttrs) { + llvm::NamedRegionTimer NRT("parsetemplate", "Parse Template", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); ObjCDeclContextSwitch ObjCDC(*this); if (Tok.is(tok::kw_template) && NextToken().isNot(tok::less)) { Index: lib/Parse/Parser.cpp =================================================================== --- lib/Parse/Parser.cpp +++ lib/Parse/Parser.cpp @@ -15,6 +15,7 @@ #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclTemplate.h" +#include "clang/Frontend/Utils.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Parse/RAIIObjectsForParser.h" #include "clang/Sema/DeclSpec.h" @@ -368,6 +369,8 @@ /// ExitScope - Pop a scope off the scope stack. void Parser::ExitScope() { assert(getCurScope() && "Scope imbalance!"); + llvm::NamedRegionTimer NRT("clangscope", "Scope manipulation", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); // Inform the actions module that this scope is going away if there are any // decls in it. @@ -543,6 +546,9 @@ /// 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, + clang::FrontendTimesIsEnabled); DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); // Skip over the EOF token, flagging end of previous input for incremental @@ -1046,6 +1052,9 @@ Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, LateParsedAttrList *LateParsedAttrs) { + llvm::NamedRegionTimer NRT("parsefdef", "Parse Function Definition", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); // 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 @@ SourceLocation Parser::handleUnexpectedCodeCompletionToken() { assert(Tok.is(tok::code_completion)); + llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); PrevTokLocation = Tok.getLocation(); for (Scope *S = getCurScope(); S; S = S->getParent()) { @@ -1947,29 +1959,47 @@ // Code-completion pass-through functions void Parser::CodeCompleteDirective(bool InConditional) { + llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); Actions.CodeCompletePreprocessorDirective(InConditional); } void Parser::CodeCompleteInConditionalExclusion() { + llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); Actions.CodeCompleteInPreprocessorConditionalExclusion(getCurScope()); } void Parser::CodeCompleteMacroName(bool IsDefinition) { + llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); Actions.CodeCompletePreprocessorMacroName(IsDefinition); } -void Parser::CodeCompletePreprocessorExpression() { +void Parser::CodeCompletePreprocessorExpression() { + llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); Actions.CodeCompletePreprocessorExpression(); } void Parser::CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned ArgumentIndex) { + llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); Actions.CodeCompletePreprocessorMacroArgument(getCurScope(), Macro, MacroInfo, ArgumentIndex); } void Parser::CodeCompleteNaturalLanguage() { + llvm::NamedRegionTimer NRT("codecompletion", "Code completion operations", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); Actions.CodeCompleteNaturalLanguage(); } @@ -2078,6 +2108,9 @@ /// /// Note that 'partition' is a context-sensitive keyword. Parser::DeclGroupPtrTy Parser::ParseModuleDecl() { + llvm::NamedRegionTimer NRT("moduleoperations", "Module related operations", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); SourceLocation StartLoc = Tok.getLocation(); Sema::ModuleDeclKind MDK = TryConsumeToken(tok::kw_export) @@ -2123,6 +2156,9 @@ 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, + clang::FrontendTimesIsEnabled); SourceLocation ImportLoc = ConsumeToken(); SourceLocation StartLoc = AtLoc.isInvalid() ? ImportLoc : AtLoc; @@ -2160,6 +2196,9 @@ SourceLocation UseLoc, SmallVectorImpl> &Path, bool IsImport) { + llvm::NamedRegionTimer NRT("moduleoperations", "Module related operations", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); // Parse the module path. while (true) { if (!Tok.is(tok::identifier)) { @@ -2190,6 +2229,9 @@ /// \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, + clang::FrontendTimesIsEnabled); while (true) { switch (Tok.getKind()) { case tok::annot_module_end: Index: lib/Sema/Sema.cpp =================================================================== --- lib/Sema/Sema.cpp +++ lib/Sema/Sema.cpp @@ -24,6 +24,7 @@ #include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/TargetInfo.h" +#include "clang/Frontend/Utils.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/CXXFieldCollector.h" @@ -842,6 +843,9 @@ /// 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, clang::FrontendTimesIsEnabled); assert(DelayedDiagnostics.getCurrentPool() == nullptr && "reached end of translation unit with a pool attached?"); @@ -867,6 +871,9 @@ // 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, clang::FrontendTimesIsEnabled); DiagnoseUseOfUnimplementedSelectors(); // If DefinedUsedVTables ends up marking any virtual member functions it @@ -929,6 +936,9 @@ UnusedFileScopedDecls.end()); if (TUKind == TU_Prefix) { + llvm::NamedRegionTimer T( + "actoneou3", "Act On End Of Translation Unit: TUKind == TU_Prefix", + GroupName, GroupDescription, clang::FrontendTimesIsEnabled); // Translation unit prefixes don't need any of the checking below. if (!PP.isIncrementalProcessingEnabled()) TUScope = nullptr; @@ -963,6 +973,9 @@ } if (TUKind == TU_Module) { + llvm::NamedRegionTimer T( + "actoneou4", "Act On End Of Translation Unit: TUKind == TU_Module", + GroupName, GroupDescription, clang::FrontendTimesIsEnabled); // If we are building a module interface unit, we need to have seen the // module declaration by now. if (getLangOpts().getCompilingModule() == @@ -1557,6 +1570,9 @@ /// 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, clang::FrontendTimesIsEnabled); + ZeroArgCallReturnTy = QualType(); OverloadSet.clear(); @@ -1719,6 +1735,9 @@ bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain, bool (*IsPlausibleResult)(QualType)) { + llvm::NamedRegionTimer T("trytorecover", "Try To Recover With Call", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); SourceLocation Loc = E.get()->getExprLoc(); SourceRange Range = E.get()->getSourceRange(); Index: lib/Sema/SemaChecking.cpp =================================================================== --- lib/Sema/SemaChecking.cpp +++ lib/Sema/SemaChecking.cpp @@ -52,6 +52,7 @@ #include "clang/Basic/TargetCXXABI.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TypeTraits.h" +#include "clang/Frontend/Utils.h" #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering. #include "clang/Sema/Initialization.h" #include "clang/Sema/Lookup.h" @@ -491,6 +492,9 @@ /// 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, clang::FrontendTimesIsEnabled); unsigned NumArgs = TheCall->getNumArgs(); if (NumArgs < 4) { @@ -853,6 +857,9 @@ ExprResult Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID, CallExpr *TheCall) { + llvm::NamedRegionTimer T("checkbuiltinfunction", + "Check Builtin Function Call", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); ExprResult TheCallResult(TheCall); // Find out if any arguments are required to be integer constant expressions. @@ -2309,6 +2316,9 @@ } bool Sema::CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { + llvm::NamedRegionTimer T("checkx86builtin", "Check X86 Builtin Function Call", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); if (BuiltinID == X86::BI__builtin_cpu_supports) return SemaBuiltinCpuSupports(*this, TheCall); @@ -2750,6 +2760,8 @@ const Expr *ThisArg, ArrayRef Args, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType) { + llvm::NamedRegionTimer T("checkcall", "Check Call", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); // FIXME: We should check as much as we can in the template definition. if (CurContext->isDependentContext()) return; @@ -3388,6 +3400,10 @@ /// builtins, ExprResult Sema::SemaBuiltinAtomicOverloaded(ExprResult TheCallResult) { + llvm::NamedRegionTimer T("semabuiltinatomic", + "Sema Builtin Atomic Overloaded", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); + CallExpr *TheCall = (CallExpr *)TheCallResult.get(); DeclRefExpr *DRE =cast(TheCall->getCallee()->IgnoreParenCasts()); FunctionDecl *FDecl = cast(DRE->getDecl()); @@ -9575,6 +9591,9 @@ 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, + clang::FrontendTimesIsEnabled); if (E->isTypeDependent() || E->isValueDependent()) return; const Type *Source = S.Context.getCanonicalType(E->getType()).getTypePtr(); Index: lib/Sema/SemaDecl.cpp =================================================================== --- lib/Sema/SemaDecl.cpp +++ lib/Sema/SemaDecl.cpp @@ -28,6 +28,7 @@ #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" +#include "clang/Frontend/Utils.h" #include "clang/Lex/HeaderSearch.h" // TODO: Sema shouldn't depend on Lex #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering. #include "clang/Lex/ModuleLoader.h" // TODO: Sema shouldn't depend on Lex @@ -849,6 +850,8 @@ SourceLocation NameLoc, const Token &NextToken, bool IsAddressOfOperand, std::unique_ptr CCC) { + llvm::NamedRegionTimer T("classifyname", "Classify Name", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); DeclarationNameInfo NameInfo(Name, NameLoc); ObjCMethodDecl *CurMethod = getCurMethodDecl(); @@ -5321,6 +5324,8 @@ NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists) { + llvm::NamedRegionTimer T("handledeclarator", "Handle Declarator", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); // TODO: consider using NameInfo for diagnostic. DeclarationNameInfo NameInfo = GetNameForDeclarator(D); DeclarationName Name = NameInfo.getName(); Index: lib/Sema/SemaExpr.cpp =================================================================== --- lib/Sema/SemaExpr.cpp +++ lib/Sema/SemaExpr.cpp @@ -29,6 +29,7 @@ #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" +#include "clang/Frontend/Utils.h" #include "clang/Lex/LiteralSupport.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/AnalysisBasedWarnings.h" @@ -1308,6 +1309,10 @@ Expr *ControllingExpr, ArrayRef ArgTypes, ArrayRef ArgExprs) { + llvm::NamedRegionTimer T("actongenericselection", + "Act On Generic Selection Expr", GroupName, + GroupDescription, clang::FrontendTimesIsEnabled); + unsigned NumAssocs = ArgTypes.size(); assert(NumAssocs == ArgExprs.size()); @@ -1520,6 +1525,9 @@ ExprResult Sema::ActOnStringLiteral(ArrayRef StringToks, Scope *UDLScope) { assert(!StringToks.empty() && "Must have at least one string!"); + llvm::NamedRegionTimer T("actonstringliteral", "Act On String Literal", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); StringLiteralParser Literal(StringToks, PP); if (Literal.hadError) @@ -2027,6 +2035,8 @@ 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, clang::FrontendTimesIsEnabled); if (SS.isInvalid()) return ExprError(); @@ -3063,6 +3073,10 @@ } ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) { + llvm::NamedRegionTimer T("actonpredefined", "Act On Predefined Expr", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); + PredefinedExpr::IdentType IT; switch (Kind) { Index: lib/Sema/SemaTemplate.cpp =================================================================== --- lib/Sema/SemaTemplate.cpp +++ lib/Sema/SemaTemplate.cpp @@ -22,6 +22,7 @@ #include "clang/Basic/LangOptions.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/TargetInfo.h" +#include "clang/Frontend/Utils.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/ParsedTemplate.h" @@ -32,6 +33,7 @@ #include "llvm/ADT/SmallBitVector.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" +#include "llvm/Support/ManagedStatic.h" #include using namespace clang; @@ -187,7 +189,6 @@ } QualType ObjectType = ObjectTypePtr.get(); - LookupResult R(*this, TName, Name.getLocStart(), LookupOrdinaryName); LookupTemplateName(R, S, SS, ObjectType, EnteringContext, MemberOfUnknownSpecialization); @@ -298,11 +299,16 @@ return true; } +static llvm::ManagedStatic LTNTimer; +static int LTNTimerLevel = 0; + void Sema::LookupTemplateName(LookupResult &Found, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization) { + FrontendTimeRAII T(&*LTNTimer, <NTimerLevel, "ltntimer", + "Lookup Template Name Time"); // Determine where to perform name lookup MemberOfUnknownSpecialization = false; DeclContext *LookupCtx = nullptr; @@ -543,6 +549,9 @@ const DeclarationNameInfo &NameInfo, bool isAddressOfOperand, const TemplateArgumentListInfo *TemplateArgs) { + llvm::NamedRegionTimer T("actondependent", "Act On Dependent Id Expression", + GroupName, GroupDescription, + clang::FrontendTimesIsEnabled); DeclContext *DC = getFunctionLevelDeclContext(); // C++11 [expr.prim.general]p12: @@ -4049,7 +4058,6 @@ LookupResult R(*this, NameInfo, LookupOrdinaryName); LookupTemplateName(R, (Scope*)nullptr, SS, QualType(), /*Entering*/ false, MemberOfUnknownSpecialization); - if (R.isAmbiguous()) return ExprError(); Index: test/Frontend/ftime-report-template-decl.cpp =================================================================== --- test/Frontend/ftime-report-template-decl.cpp +++ test/Frontend/ftime-report-template-decl.cpp @@ -0,0 +1,161 @@ +// 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 +void foo(); +template +void foo(); + +// Template function definitions. +template +void foo() {} + +// Template class (forward) declarations +template +struct A; +template +struct b; +template +struct C; +template +struct D; + +// Forward declarations with default parameters? +template +class X1; +template +class X2; + +// Forward declarations w/template template parameters +template