[time-report] Add Template Instantiation Timer

[eduardo-elizondo]

Summary

This adds the "Template Instantiation Time" timer when running -ftime-report. Gcc already provides this.

i.e:

===-------------------------------------------------------------------------===
                         Miscellaneous Ungrouped Timers
===-------------------------------------------------------------------------===

   ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
   0.0170 ( 63.0%)   0.0000 (  0.0%)   0.0170 ( 60.7%)   0.0168 ( 60.7%)  Template Instantiation Time
   0.0090 ( 33.3%)   0.0010 (100.0%)   0.0100 ( 35.7%)   0.0099 ( 35.5%)  Code Generation Time
   0.0010 (  3.7%)   0.0000 (  0.0%)   0.0010 (  3.6%)   0.0010 (  3.8%)  LLVM IR Generation Time
   0.0270 (100.0%)   0.0010 (100.0%)   0.0280 (100.0%)   0.0278 (100.0%)  Total

This diffs depends on the reference-counted timer: D36847

[eric_niebler]

This appears to be only measuring the time spent instantiating class templates. What about other template entities, like functions?

[eduardo-elizondo]

@eric_niebler You are right, we should also time: Sema::InstantiateFunctionDefinition

[eduardo-elizondo]

Added timing to Function Instantiations as well

include/clang/Sema/Sema.h

 #include "clang/Sema/TypoCorrection.h"
 #include "clang/Sema/Weak.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/TinyPtrVector.h"
+#include "llvm/Support/Timer.h"
 #include <deque>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace llvm {
   class APSInt;
   template <typename ValueT> struct DenseMapInfo;
class Sema {
   ///\brief Source of additional semantic information.
   ExternalSemaSource *ExternalSource;
 
   ///\brief Whether Sema has generated a multiplexer and has to delete it.
   bool isMultiplexExternalSource;
 
   static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
 
+  llvm::RefCntTimer TemplateInstantiationTime;
+
   bool isVisibleSlow(const NamedDecl *D);
 
   bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
                                     const NamedDecl *New) {
     // We are about to link these. It is now safe to compute the linkage of
     // the new decl. If the new decl has external linkage, we will
     // link it with the hidden decl (which also has external linkage) and
     // it will keep having external linkage. If it has internal linkage, we

lib/Sema/Sema.cpp

 };
 
 } // end namespace sema
 } // end namespace clang
 
 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
            TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
     : ExternalSource(nullptr), isMultiplexExternalSource(false),
+      TemplateInstantiationTime("templateinst", "Template Instantiation Time"),
       FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
       Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
       SourceMgr(PP.getSourceManager()), CollectStats(false),
       CodeCompleter(CodeCompleter), CurContext(nullptr),
       OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
       MSPointerToMemberRepresentationMethod(
           LangOpts.getMSPointerToMemberRepresentationMethod()),
       VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0),

lib/Sema/SemaTemplateInstantiate.cpp

 ///
 /// \returns true if an error occurred, false otherwise.
 bool
 Sema::InstantiateClass(SourceLocation PointOfInstantiation,
                        CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
                        const MultiLevelTemplateArgumentList &TemplateArgs,
                        TemplateSpecializationKind TSK,
                        bool Complain) {
+  llvm::TimeRegion Region(
+      llvm::TimePassesIsEnabled ? &TemplateInstantiationTime : nullptr);
+
   CXXRecordDecl *PatternDef
     = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
   if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
                                 Instantiation->getInstantiatedFromMemberClass(),
                                      Pattern, PatternDef, TSK, Complain))
     return true;
   Pattern = PatternDef;
 

lib/Sema/SemaTemplateInstantiateDecl.cpp

 /// \param DefinitionRequired if true, then we are performing an explicit
 /// instantiation where the body of the function is required. Complain if
 /// there is no such body.
 void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
                                          FunctionDecl *Function,
                                          bool Recursive,
                                          bool DefinitionRequired,
                                          bool AtEndOfTU) {
+  llvm::TimeRegion Region(
+            llvm::TimePassesIsEnabled ? &TemplateInstantiationTime : nullptr);
+
   if (Function->isInvalidDecl() || Function->isDefined())
     return;
 
   // Never instantiate an explicit specialization except if it is a class scope
   // explicit specialization.
   TemplateSpecializationKind TSK = Function->getTemplateSpecializationKind();
   if (TSK == TSK_ExplicitSpecialization &&
       !Function->getClassScopeSpecializationPattern())