From: Andrew V. Tischenko Date: Tue, 10 Apr 2018 10:34:13 +0000 (+0000) Subject: -ftime-report switch support in Clang. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=d3f7881f4d6b0c3c9aa0dba7d379954386c92d40;p=clang -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 7ae6173512..0151d7e303 100644 --- 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 6ba9c66fc3..aac8758afd 100644 --- 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 #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; diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h index 619b56363f..943ceaed88 100644 --- 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 0305094d9f..1942eb11de 100644 --- 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 DeclGroupPtrTy; typedef OpaquePtr TemplateTy; typedef OpaquePtr TypeTy; diff --git a/lib/CodeGen/CodeGenAction.cpp b/lib/CodeGen/CodeGenAction.cpp index ac2548e6a5..1681130657 100644 --- 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 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 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 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(Act); CompilerInstance &CI = getCompilerInstance(); std::unique_ptr OS = diff --git a/lib/Frontend/ASTMerge.cpp b/lib/Frontend/ASTMerge.cpp index 6ec0e2a98c..b1a3407a42 100644 --- 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 b8f55b6142..904e587681 100644 --- a/lib/Frontend/CompilerInstance.cpp +++ b/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 @@ 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 1b4d789b4d..b41d581ba3 100644 --- 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 8cb6a04224..74563ad04d 100644 --- 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 () to Microsoft style line feeds (). diff --git a/lib/Lex/HeaderSearch.cpp b/lib/Lex/HeaderSearch.cpp index 93a5ad4c92..3d90846612 100644 --- 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 #include #include @@ -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 &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 *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 *SearchPath, SmallVectorImpl *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 SubmodulePath; @@ -1483,6 +1507,8 @@ HeaderSearch::loadModuleMapFile(const DirectoryEntry *Dir, bool IsSystem, } void HeaderSearch::collectAllModules(SmallVectorImpl &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 5af8ba5724..7c44cc8430 100644 --- 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 #include @@ -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 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 db32e452d0..a1944e30ff 100644 --- 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 #include #include @@ -54,6 +56,8 @@ #include 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 88a5745350..0792e135cd 100644 --- 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 d8f9f7a390..1d0511e0ef 100644 --- 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> &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 5c0026cd37..928d873221 100644 --- 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 fdf7e2b70f..74f0de61ab 100644 --- 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 #include @@ -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 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(TheCall->getCallee()->IgnoreParenCasts()); FunctionDecl *FDecl = cast(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 9228d65250..6ed2c9ee80 100644 --- 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 #include #include @@ -849,6 +850,8 @@ Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, bool IsAddressOfOperand, std::unique_ptr 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 b8cadaf7ab..0b86480385 100644 --- 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 ArgTypes, ArrayRef 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 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 9cc1bd529f..9df697eebe 100644 --- 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 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 index 0000000000..311358af18 --- /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 +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