-ftime-report switch support in Clang

[avt77]

Summary

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 the following lines:

-------------------------------------------------------------------------

===== Clang Parser =====

-------------------------------------------------------------------------

Total Execution Time: 0.0160 seconds (0.0189 wall clock)

 ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
 0.0080 ( 66.7%)   0.0040 (100.0%)   0.0120 ( 75.0%)   0.0114 ( 60.3%)  Parse Template
 0.0040 ( 33.3%)   0.0000 (  0.0%)   0.0040 ( 25.0%)   0.0057 ( 30.2%)  Parse Function Body
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0011 (  5.8%)  PP Macro Expansion
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0005 (  2.4%)  Scope manipulation
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0001 (  0.5%)  Annotation operations
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0001 (  0.5%)  PP Macro Call Args
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0001 (  0.3%)  PP Find Handler
 0.0120 (100.0%)   0.0040 (100.0%)   0.0160 (100.0%)   0.0189 (100.0%)  Total

We could add more lines in the report but it'd be nice to understand what we'd like to see.

[MatzeB]

• Just a warning: I'm a bit skeptical timers will work reliable for things that happen in well under a millisecond (did you do some sanity checking? i.e. do all the timer roughly add up to the time spent in the frontend?)
• In the same vain I wonder if you add overhead by adding timers to functions that are likely called hundreds of times for a typical source file. Have you measured a release build with and without your patch.

[avt77]

In D43578#1016751, @MatzeB wrote:

• Just a warning: I'm a bit skeptical timers will work reliable for things that happen in well under a millisecond (did you do some sanity checking? i.e. do all the timer roughly add up to the time spent in the frontend?)
• In the same vain I wonder if you add overhead by adding timers to functions that are likely called hundreds of times for a typical source file. Have you measured a release build with and without your patch.

1. You can see in the report very small numbers - it seems eveything works properly. But maybe you have some concrect examples to check?
2. I'm going to build bootsraps with and w/o timers - I'll be back with results when it's done.

But the main idea of this version of the patch was to get understanding about interesting timers: what exactly do we want to see in report? Parser only? Sema? Some special parts of Clang Code Gen?...

[erik.pilkington]

Hi, thanks for working on this! Having better timers in clang would be really great.

But the main idea of this version of the patch was to get understanding about interesting timers: what exactly do we want to see in report? Parser only? Sema? Some special parts of Clang Code Gen?...

I think it would be a good idea to include timers on specific parts of the compiler that can often lead to big compile times, off the top of my head: constant evaluation, template instantiation, analysis based warnings, macro expansion (looks like you've already done this), and name lookup would all be really nice to have. Having these general timers like "Parse Template" that track the time spent in a parsing function don't really seem that valuable to me because they don't really give any indication as to how that time was actually spent. If the parser calls into sema then sema could start doing any number of things that would be included in the parser's timer, and nobody would have any insight into what actually needs to be optimized. What do you think about that?

include/clang/Lex/Preprocessor.h

145–146 ↗

(On Diff #135260)

Making these non-static members is a waste of memory. Please make them static constexpr or just inline them into where they're used.

lib/Parse/ParseStmt.cpp

102 ↗

(On Diff #135260)

Please don't include these unrelated whitespace changes in the diff!

[avt77]

I changed the timers. Now we could get something like here:

-------------------------------------------------------------------------

===== Frontend =====

-------------------------------------------------------------------------

Total Execution Time: 0.3760 seconds (0.3659 wall clock)

 ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
 0.2080 ( 59.1%)   0.0160 ( 66.7%)   0.2240 ( 59.6%)   0.2157 ( 58.9%)  Handle Top Level Decl
 0.1120 ( 31.8%)   0.0000 (  0.0%)   0.1120 ( 29.8%)   0.1152 ( 31.5%)  Handle Translation Unit
 0.0200 (  5.7%)   0.0080 ( 33.3%)   0.0280 (  7.4%)   0.0253 (  6.9%)  Handle Tag Decl Required Definition
 0.0080 (  2.3%)   0.0000 (  0.0%)   0.0080 (  2.1%)   0.0097 (  2.6%)  Handle Inline Function Definition
 0.0040 (  1.1%)   0.0000 (  0.0%)   0.0040 (  1.1%)   0.0000 (  0.0%)  Init Backend Consumer
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)  Link In Modules
 0.3520 (100.0%)   0.0240 (100.0%)   0.3760 (100.0%)   0.3659 (100.0%)  Total

-------------------------------------------------------------------------

===== Clang Parser =====

-------------------------------------------------------------------------

Total Execution Time: 6.7240 seconds (6.7310 wall clock)

 ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
 4.5520 ( 76.9%)   0.5560 ( 68.8%)   5.1080 ( 76.0%)   5.1109 ( 75.9%)  Parse Top Level Decl
 0.6680 ( 11.3%)   0.1200 ( 14.9%)   0.7880 ( 11.7%)   0.7732 ( 11.5%)  Parse Template
 0.6440 ( 10.9%)   0.1240 ( 15.3%)   0.7680 ( 11.4%)   0.7459 ( 11.1%)  Parse Function Definition
 0.0360 (  0.6%)   0.0040 (  0.5%)   0.0400 (  0.6%)   0.0654 (  1.0%)  Scope manipulation
 0.0120 (  0.2%)   0.0040 (  0.5%)   0.0160 (  0.2%)   0.0267 (  0.4%)  PP Macro Call Args
 0.0040 (  0.1%)   0.0000 (  0.0%)   0.0040 (  0.1%)   0.0059 (  0.1%)  PP Append Macro
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0029 (  0.0%)  Handle Pragma Directive
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0003 (  0.0%)  PP Find Handler
 5.9160 (100.0%)   0.8080 (100.0%)   6.7240 (100.0%)   6.7310 (100.0%)  Total

-------------------------------------------------------------------------

===== Sema =====

-------------------------------------------------------------------------

Total Execution Time: 3.0480 seconds (3.0127 wall clock)

 ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
 1.0760 ( 38.9%)   0.0960 ( 33.8%)   1.1720 ( 38.5%)   1.1687 ( 38.8%)  Act On End Of Translation Unit: Common case
 1.0760 ( 38.9%)   0.0960 ( 33.8%)   1.1720 ( 38.5%)   1.1681 ( 38.8%)  Act On End Of Translation Unit: TUKind != TU_Prefix
 0.2520 (  9.1%)   0.0440 ( 15.5%)   0.2960 (  9.7%)   0.2534 (  8.4%)  Handle Declarator
 0.1160 (  4.2%)   0.0120 (  4.2%)   0.1280 (  4.2%)   0.1453 (  4.8%)  Act On Id Expression
 0.0520 (  1.9%)   0.0120 (  4.2%)   0.0640 (  2.1%)   0.0827 (  2.7%)  Classify Name
 0.0520 (  1.9%)   0.0120 (  4.2%)   0.0640 (  2.1%)   0.0612 (  2.0%)  Check Implicit Conversion
 0.0480 (  1.7%)   0.0040 (  1.4%)   0.0520 (  1.7%)   0.0485 (  1.6%)  Check Call
 0.0560 (  2.0%)   0.0040 (  1.4%)   0.0600 (  2.0%)   0.0465 (  1.5%)  Lookup Template Name
 0.0280 (  1.0%)   0.0000 (  0.0%)   0.0280 (  0.9%)   0.0160 (  0.5%)  Act On String Literal
 0.0040 (  0.1%)   0.0040 (  1.4%)   0.0080 (  0.3%)   0.0137 (  0.5%)  Check Builtin Function Call
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0049 (  0.2%)  Act On Predefined Expr
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0022 (  0.1%)  Check X86 Builtin Function Call
 0.0040 (  0.1%)   0.0000 (  0.0%)   0.0040 (  0.1%)   0.0014 (  0.0%)  Act On Dependent Id Expression
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)  Try To Recover With Call
 0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)   0.0000 (  0.0%)  Try Expr As Call
 2.7640 (100.0%)   0.2840 (100.0%)   3.0480 (100.0%)   3.0127 (100.0%)  Total

-------------------------------------------------------------------------

===== Include Files =====

-------------------------------------------------------------------------

Total Execution Time: 0.0600 seconds (0.0540 wall clock)

 ---User Time---   --User+System--   ---Wall Time---  --- Name ---
 0.0320 ( 53.3%)   0.0320 ( 53.3%)   0.0292 ( 54.0%)  Lookup File2
 0.0200 ( 33.3%)   0.0200 ( 33.3%)   0.0218 ( 40.3%)  Lookup File
 0.0040 (  6.7%)   0.0040 (  6.7%)   0.0016 (  3.0%)  Find Usable Module For Header
 0.0040 (  6.7%)   0.0040 (  6.7%)   0.0014 (  2.7%)  Should Enter Include File
 0.0600 (100.0%)   0.0600 (100.0%)   0.0540 (100.0%)  Total

The exact picture very depends on content of the compiling file but in general it's clear what we have.
About the performance question: I compared boostrap times produced by pure trunk compiler and my compiler with timers. I got the following results (obviously I used the patched compiler w/o option -ftime-report):

Trunk compiler (4 bootstraps were created):
real 43m19.845s
user 161m22.448s
sys 6m57.480s

real 42m54.171s
user 160m45.444s
sys 6m50.236s

real 43m43.098s
user 161m8.112s
sys 6m46.944s

real 42m59.542s
user 160m48.304s
sys 6m48.616s

The patched compiler (3 bootstraps):

real 44m13.653s
user 162m15.588s
sys 6m55.864s

real 44m7.108s
user 162m7.740s
sys 6m47.848s

real 43m18.520s
user 162m14.008s
sys 6m44.828s

As we see in the worst case we have degradation less than 1.2%. From my point of view it's absolutely acceptable.
Any comments, suggestions, objections?

[mzolotukhin]

Hi,

I think it would be really instrumental to have a finer timing report, so thanks for your work! I tested the patch on CTMark with O0-g and didn't see detectable change either, so I think from compile-time impact this change is good. The patch needs some clean-up, but otherwise looks good to me.

Thanks,
Michael

lib/CodeGen/CodeGenModule.cpp

59 ↗

(On Diff #138021)

No timers are added to this file, thus the header is redundant.

64–65 ↗

(On Diff #138021)

These are unused.

lib/Frontend/FrontendAction.cpp

898–899 ↗

(On Diff #138021)

Unused variable.

lib/Lex/Pragma.cpp

32 ↗

(On Diff #138021)

Please don't reorder header files in the patch (you can commit such changes separately before the patch).

44 ↗

(On Diff #138021)

Why do we need "Pass.h" here?

89 ↗

(On Diff #138021)

What does the number 22 mean (and other similar numbers in the names)?

137 ↗

(On Diff #138021)

Typo in "pppragma"?

lib/Parse/Parser.cpp

1468–1470 ↗

(On Diff #138021)

Not-cleaned leftover of some sort?

1662 ↗

(On Diff #138021)

Please don't include unnecessary whitespace changes (it applies to some other changes too).

[avt77]

lib/Lex/Pragma.cpp

44 ↗

(On Diff #138021)

Because we need llvm::TimePassesIsEnabled.

89 ↗

(On Diff #138021)

I renamed all such names but in fact it's only a simple timer ID that's why we could use any name here.

137 ↗

(On Diff #138021)

No, stays for PreProcessor Pragma

[avt77]

I fixed all issues raised by mzolotukhin and answered on his questions. I'm waiting for LGTM now.

[mzolotukhin]

LGTM. Please don't forget to commit headers sorting (and other NFC if any) in a separate patch.

Thanks,
Michael

[thakis]

@davezarzycki remarks in https://reviews.llvm.org/D45485 that this breaks the shared build. The proposed fix there is to make several of clang's modules depend on LLVM's IR library ("Core"). This seems weird to me for two reasons, one architectural, one form a build point of view:

1. The modules growing the dep don't really depend on IR, they just need that one bool that happens to be defined there. That bool is called TimePassesIsEnabled which is a reasonable bool to live in IR, but this patch starts using that bool for meanings other than "should we time passes?". It instead uses the same bool to decide if clang should print a bunch of timing info. We probably should have a separate bool in clang and key this off that and make -ftime-report set both.

2. From a build PoV, depending on Core means explicitly depending on TableGen processing the Attributes.td and Intrinsics.td files in include/llvm/IR, which needlessly (explicitly) serializes the build.

[thakis]

Also, please add cfe-commits to clang changes. Since this wasn't here and the patch wasn't seen by clang folks, since ftime-report-template-decl.cppwarnings is still failing on the bots (e.g. http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/16388) and since it breaks the shared bot, maybe we should revert for now and reland when the issues are addressed?

[rsmith]

In D43578#1062984, @thakis wrote:

Also, please add cfe-commits to clang changes. Since this wasn't here and the patch wasn't seen by clang folks, since ftime-report-template-decl.cppwarnings is still failing on the bots (e.g. http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/16388) and since it breaks the shared bot, maybe we should revert for now and reland when the issues are addressed?

Yes, please. This was not appropriately reviewed, breaks bots, and appears to be wrong/inappropriate in multiple ways.

[avt77]

Could you help me with revert of the committed patch?
I'll do all necessary changes but I don't know how I can revert the patch.

[avt77]

Obviously, this patch was not ready for commit that's why I reopen the revison.
But I don't know how to revert the patch from trunk: please, help me.

[davezarzycki]

A revert in practice just means undoing the changes. For example, while both git and svn have revert subcommands, you can also just take the original diff/patch, pipe it into patch -R, and if there are no conflicts, commit the result.

[avt77]

In D43578#1063365, @davezarzycki wrote:

A revert in practice just means undoing the changes. For example, while both git and svn have revert subcommands, you can also just take the original diff/patch, pipe it into patch -R, and if there are no conflicts, commit the result.

Unfortunately, revert does not work with committed changes:

revert: Restore pristine working copy state (undo local changes).
usage: revert PATH...

Revert changes in the working copy at or within PATH, and remove
conflict markers as well, if any.

• This subcommand does not revert already committed changes.**

But I'll try with patch -R. Tnx.

[efriedma]

while both git and svn have revert subcommands

This is kind of misleading; yes, both git and svn have subcommands named "revert", but "svn revert" doesn't have the right meaning. You have to use "svn merge" to revert a committed change.

[thakis]

Reverted:

$ svn merge -c -329714 .

• Reverse-merging r329714 into '.':

A test/Frontend/ftime-report-template-decl.cpp

• Recording mergeinfo for reverse merge of r329714 into '.': U .

$ svn merge -c -329693 .

• Reverse-merging r329693 into '.':

U test/Frontend/ftime-report-template-decl.cpp

• Recording mergeinfo for reverse merge of r329693 into '.': U .

$ svn merge -c -329684 .

• Reverse-merging r329684 into '.':

D test/Frontend/ftime-report-template-decl.cpp
U include/clang/Frontend/FrontendAction.h
U lib/Parse/ParseTemplate.cpp
U lib/Frontend/FrontendAction.cpp
U lib/Lex/Pragma.cpp
U lib/CodeGen/CodeGenAction.cpp
U include/clang/Parse/Parser.h
U include/clang/Sema/Sema.h
U include/clang/Lex/HeaderSearch.h
U lib/Parse/Parser.cpp
U lib/Frontend/ASTMerge.cpp
U lib/Frontend/FrontendActions.cpp
U lib/Frontend/CompilerInstance.cpp
U lib/Sema/SemaChecking.cpp
U lib/Sema/SemaExpr.cpp
U lib/Sema/Sema.cpp
U lib/Sema/SemaDecl.cpp
U lib/Sema/SemaTemplate.cpp
U lib/Lex/PPMacroExpansion.cpp
U lib/Lex/HeaderSearch.cpp

• Recording mergeinfo for reverse merge of r329684 into '.': U .

$ svn commit -m 'Revert r329684 (and follow-ups 329693, 329714). See discussion on https://reviews.llvm.org/D43578.'
Sending include/clang/Frontend/FrontendAction.h
Sending include/clang/Lex/HeaderSearch.h
Sending include/clang/Parse/Parser.h
Sending include/clang/Sema/Sema.h
Sending lib/CodeGen/CodeGenAction.cpp
Sending lib/Frontend/ASTMerge.cpp
Sending lib/Frontend/CompilerInstance.cpp
Sending lib/Frontend/FrontendAction.cpp
Sending lib/Frontend/FrontendActions.cpp
Sending lib/Lex/HeaderSearch.cpp
Sending lib/Lex/PPMacroExpansion.cpp
Sending lib/Lex/Pragma.cpp
Sending lib/Parse/ParseTemplate.cpp
Sending lib/Parse/Parser.cpp
Sending lib/Sema/Sema.cpp
Sending lib/Sema/SemaChecking.cpp
Sending lib/Sema/SemaDecl.cpp
Sending lib/Sema/SemaExpr.cpp
Sending lib/Sema/SemaTemplate.cpp
Transmitting file data ...................done
Committing transaction...
Committed revision 329739.

[avt77]

In D43578#1063462, @thakis wrote:

Reverted:

Many thanks for your help!

[davezarzycki]

Hi @efriedma – Sorry about that. I haven't directly used svn in years thanks to the git svn bridge.

[avt77]

In D43578#1062950, @thakis wrote:

@davezarzycki remarks in https://reviews.llvm.org/D45485 that this breaks the shared build. The proposed fix there is to make several of clang's modules depend on LLVM's IR library ("Core"). This seems weird to me for two reasons, one architectural, one form a build point of view:

1. The modules growing the dep don't really depend on IR, they just need that one bool that happens to be defined there. That bool is called TimePassesIsEnabled which is a reasonable bool to live in IR, but this patch starts using that bool for meanings other than "should we time passes?". It instead uses the same bool to decide if clang should print a bunch of timing info. We probably should have a separate bool in clang and key this off that and make -ftime-report set both.

2. From a build PoV, depending on Core means explicitly depending on TableGen processing the Attributes.td and Intrinsics.td files in include/llvm/IR, which needlessly (explicitly) serializes the build.

In fact the current trunk already depends on TimePassesIsEnabled (w/o this patch applied):

$ find clang -name \*.cpp | xargs grep TimePassesIsEnabled
clang/lib/CodeGen/CodeGenAction.cpp: llvm::TimePassesIsEnabled = TimePasses;
clang/lib/CodeGen/CodeGenAction.cpp: if (llvm::TimePassesIsEnabled)
clang/lib/CodeGen/CodeGenAction.cpp: if (llvm::TimePassesIsEnabled)
clang/lib/CodeGen/CodeGenAction.cpp: if (llvm::TimePassesIsEnabled) {
clang/lib/CodeGen/CodeGenAction.cpp: if (llvm::TimePassesIsEnabled) {
clang/lib/CodeGen/CodeGenAction.cpp: if (llvm::TimePassesIsEnabled)
clang/lib/CodeGen/CodeGenAction.cpp: if (llvm::TimePassesIsEnabled)
clang/lib/CodeGen/CodeGenAction.cpp: if (llvm::TimePassesIsEnabled) {
clang/lib/CodeGen/CodeGenAction.cpp: if (llvm::TimePassesIsEnabled) {
clang/lib/CodeGen/BackendUtil.cpp: TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr);
clang/lib/CodeGen/BackendUtil.cpp: TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr);

But I agree that such dependence is not OK. I'll create a separate bool instead of TimePassesIsEnabled but the question is should I remove the above usage of TimePassesIsEnabled as well? Or maybe it should be a separate pre-patch? Or it could be left as it is?
And one more question: should we introduce a new command line switch say 'ffrontend-time-report' or we should use the current 'ftime-report'?

[russell.gallop]

We also see an assertion failure prior to the revert. At r329738:

$ cat test.cpp
template <class> struct A {
  template <class _Other> using rebind_alloc = _Other;
};
template <class _Alloc> struct _Wrap_alloc {
  template <class _Other>
  using rebind_alloc = typename A<_Alloc>::template rebind_alloc<_Other>;
  template <class> using rebind = _Wrap_alloc;
};
_Wrap_alloc<int>::rebind<int> w;

$ clang++ -c test.cpp

$ clang++ -c test.cpp -ftime-report
clang-7: llvm/lib/Support/Timer.cpp:133: void llvm::Timer::startTimer(): Assertion `!Running && "Cannot start a running timer"' failed.

[avt77]

In D43578#1064113, @russell.gallop wrote:

We also see an assertion failure prior to the revert. At r329738:

Yes, you're right - thaks again for this test case.

[avt77]

I removed the dependence on TimePassesIsEnabled (as @davezarzycki sugested) and fixed the issue with failed test (tnx to @russell.gallop). As result the patch was redesigned.

[davezarzycki]

It wasn't my suggestion. @thakis wrote: "We probably should have a separate bool in clang and key this off that and make -ftime-report set both."

[avt77]

In D43578#1065827, @davezarzycki wrote:

It wasn't my suggestion. @thakis wrote: "We probably should have a separate bool in clang and key this off that and make -ftime-report set both."

Sorry, but it's done now. Any comments, suggestions, requirements?

[rsmith]

Last time I looked at doing this, I found that LLVM's timer infrastructure was fundamentally unsuitable for adding timers like these to Clang. The big problems are that Clang switches between "layers" and pieces that should be independently accounted at a very large number of call sites (eg, there are hundreds of functions on Sema that the Parser calls), and that Clang makes heavy use of recursion and delegation between functions that we might want to time (and generally has a very complex call graph, matching the complexity of the grammars that it parses). Unless there have been major changes, none of that actually works in LLVM's timer infrastructure: the time allocated to recursive and mutually-recursive functions is misaccounted (double-counted or worse), and there's no real way to extract the amount of time spent parsing a particular kind of declaration without including all the time spent in nested subactions (such as instantiating unrelated templates, generating code, and so on) -- and even enumerating all the barriers between "time spent in parsing" and "time spent in semantic analysis" does not seem reasonable. Generating user-friendly but misleading and likely wrong timing data seems like it would be a big problem here.

So I don't think this patch is reasonable for that reason. I'm also not sure whether this, as is, is addressing a pressing use case -- for Clang developers, existing non-invasive profiling tools (such as linux-perftools) are likely to work a lot better for identifying where in the Clang source code we're spending time. And Clang users typically don't care which function we're in (unless they're filing a bug, where again a profiler is probably a better tool).

However, I do think we could make -ftime-report vastly more useful to Clang users. Specifically, I think the useful, actionable feedback we can give to users would be to tell them which parts of their source code are taking a long time to compile. Profiling information that can describe -- for instance -- the time spent instantiating the N slowest templates, or handling the N slowest functions, or evaluating the N slowest constant expressions, or parsing the N slowest #included files, seems like it would be incredibly valuable. To make that work, I think we'll need to teach LLVM's timer infrastructure to properly separate out "self" time from "children" time for timers in the same group, and may need other infrastructure improvements.

[avt77]

In D43578#1067768, @rsmith wrote:

Last time I looked at doing this, I found that LLVM's timer infrastructure was fundamentally unsuitable for adding timers like these to Clang.

Thank you for this answer. As I understand we should close both this review and D45619 but you'd like to see something like MS has here, right?

[kimgr]

Hi Richard,

[kimgr]

Heh, my e-mail response was eaten along the way. Continued here:

On Sat, Apr 14, 2018 at 1:53 AM, Richard Smith - zygoloid via
Phabricator via cfe-commits <[e-mail]> wrote:

rsmith added a comment.

So I don't think this patch is reasonable for that reason. I'm also not sure whether this, as is, is addressing a pressing use case -- for Clang developers, existing non-invasive profiling tools (such as linux-perftools) are likely to work a lot better for identifying where in the Clang source code we're spending time. And Clang users typically don't care which function we're in (unless they're filing a bug, where again a profiler is probably a better tool).

However, I do think we could make -ftime-report vastly more useful to Clang users. Specifically, I think the useful, actionable feedback we can give to users would be to tell them which parts of their source code are taking a long time to compile. Profiling information that can describe -- for instance -- the time spent instantiating the N slowest templates, or handling the N slowest functions, or evaluating the N slowest constant expressions, or parsing the N slowest #included files, seems like it would be incredibly valuable. To make that work, I think we'll need to teach LLVM's timer infrastructure to properly separate out "self" time from "children" time for timers in the same group, and may need other infrastructure improvements.

I disagreed up until the last paragraph :)

That's exactly the crux of what most users need to know -- which parts
of my source code are causing the biggest build slow-down? The summary
information from -ftime-report can give a hint, but a detailed
breakdown would of course be great!

[rsmith]

In D43578#1067891, @kimgr wrote:

I disagreed up until the last paragraph :)

Can you say which things you disagree with? There seem to be two important facts here:

1. LLVM's timing infrastructure cannot correctly report timings when one function containing a timing region calls another. That will happen all the time with this patch applied.
2. Clang's architecture means that if you time the amount of time spent in, say, the "ParseTemplate" function, you have not computed the amount of time spent parsing templates, because the parser calls into Sema, which might perform tasks that are only somewhat related to parsing the template (such as performing other instantiations), and likewise Sema calls into other layers (such as AST file deserialization and code generation).

The first might have been fixed in LLVM at this point, but I can't see any evidence of that in LLVM's Timer implementation. And the second seems even more fundamental. But if there's some way around that, which would allow us to produce (correct!) numbers for times spent parsing / whatever else, without, for instance, adding a correctness requirement that we annotate every Parser -> Sema entry point with a timer, then that's definitely something we should discuss.

[rsmith]

In D43578#1067879, @avt77 wrote:

In D43578#1067768, @rsmith wrote:

Last time I looked at doing this, I found that LLVM's timer infrastructure was fundamentally unsuitable for adding timers like these to Clang.

Thank you for this answer. As I understand we should close both this review and D45619

I think D45619 is a good change, and I'd like to see that get committed.

If LLVM's timer infrastructure can be improved to correctly track time in recursive and mutually-recursive timing regions (and I believe it can be), we could continue with this patch; if you want to pursue that, my first questions would be:

Who is the audience for this information?
What information do they want from a time report?
How do we present that information in a way that's not misleading (given Clang's architecture)?
Can we deliver useful value compared to a modern, dedicated profiling tool?

but you'd like to see something like MS has here, right?

Yes, that's the kind of information I think we should be looking at adding here -- I think that's exactly what Clang users would be looking for when they reach out to a compilation time report to try to figure out why their compile is slow.

[kimgr]

In D43578#1067974, @rsmith wrote:

In D43578#1067891, @kimgr wrote:

I disagreed up until the last paragraph :)

Can you say which things you disagree with? There seem to be two important facts here:

1. LLVM's timing infrastructure cannot correctly report timings when one function containing a timing region calls another. That will happen all the time with this patch applied.
2. Clang's architecture means that if you time the amount of time spent in, say, the "ParseTemplate" function, you have not computed the amount of time spent parsing templates, because the parser calls into Sema, which might perform tasks that are only somewhat related to parsing the template (such as performing other instantiations), and likewise Sema calls into other layers (such as AST file deserialization and code generation).

The first might have been fixed in LLVM at this point, but I can't see any evidence of that in LLVM's Timer implementation. And the second seems even more fundamental. But if there's some way around that, which would allow us to produce (correct!) numbers for times spent parsing / whatever else, without, for instance, adding a correctness requirement that we annotate every Parser -> Sema entry point with a timer, then that's definitely something we should discuss.

Ah, I see. I read your original message as dismissive as in users don't need to know where time is spent.

I tried to make the case that users do care where time is spent, because it can give a hint as to what part of their physical/logical design they can work on to get better compile times.

But I think you were really saying that LLVM and Clang as designed can't provide anything perfect, only slightly misleading information?

Sorry for the misunderstanding.

• Kim

[mzolotukhin]

Hi,

I've been monitoring compile-time for quite a while, so let my put my 2 cents here too.

Who is the audience for this information?
What information do they want from a time report?
How do we present that information in a way that's not misleading (given Clang's architecture)?

I would find the timers extremely useful. Even if they overlap, they still would 1) be a good indicator of a newly introduced problem and 2) give a rough idea where frontend time is spent. I agree that it wouldn't be super-accurate, but the numbers we usually operate are quite high (e.g. <some part> started to take 1.5x time). When we decide to investigate it deeper, we can use more accurate tools, such as profilers. All that said, if we can make timers more accurate/not-overlapping, that surely would be helpful as well.

Can we deliver useful value compared to a modern, dedicated profiling tool?

Having timers, especially producing results in the same format, as existing LLVM timers, would be much more convenient than using profilers. With timers I can simply add a compile-time flag to my test-suite run and get all the numbers in the end of my usual run. With profilers it's a bit more complicated.

Speaking of timers overlapping and mutual calling: LLVM timers also have this problem, and e.g. if there is problem is in some analysis (say, ScalarEvolution), we see indications in several other passes using this analysis (say, IndVarSimplify and LoopStrengthReduction). While it does not immediately show the problematic spot, it gives you pretty strong hints to where to look at first. So, having even not-perfect timers is still useful.

Also, I apologize for LGTMing the patch earlier while it was not properly reviewed - I didn't notice it didn't have cfe-commits in subscribers, and it had been waiting for a review for quite some time (so I assumed that all interested parties had their chance to look at it).

Thanks,
Michael

[rsmith]

In D43578#1068127, @mzolotukhin wrote:

Who is the audience for this information?
What information do they want from a time report?
How do we present that information in a way that's not misleading (given Clang's architecture)?

I would find the timers extremely useful. Even if they overlap, they still would 1) be a good indicator of a newly introduced problem and 2) give a rough idea where frontend time is spent. I agree that it wouldn't be super-accurate, but the numbers we usually operate are quite high (e.g. <some part> started to take 1.5x time). When we decide to investigate it deeper, we can use more accurate tools, such as profilers.

What kinds of <some part> would be useful to you? (How do you want the runtime of Clang broken down?) Are vertical slices (through all Clang's various layers and potentially parts of LLVM) -- as this patch will produce -- useful, or would you really want horizontal slices (as in, what part of Clang is actually spending the time)? Or just anything that's basically expected to be consistent from run to run, so you can identify that something has slowed down, even if you don't have enough information to really know what?

All that said, if we can make timers more accurate/not-overlapping, that surely would be helpful as well.

I think we need to fix the overlap issue as a prerequisite to adding timers with large amounts of overlap, especially self-overlap. Otherwise the numbers will likely do more harm than good, as they will significantly misattribute runtime. Fortunately, I think that should only require some relatively small changes to the LLVM timer infrastructure.

Can we deliver useful value compared to a modern, dedicated profiling tool?

Having timers, especially producing results in the same format, as existing LLVM timers, would be much more convenient than using profilers. With timers I can simply add a compile-time flag to my test-suite run and get all the numbers in the end of my usual run. With profilers it's a bit more complicated.

Well, that depends on the profiler. With some profilers, you can just attach a profiler to your entire compilation and then ask it what the hottest functions were. But sure, if you have existing infrastructure built around -ftime-report, I can see that it makes sense to reuse that infrastructure.

Speaking of timers overlapping and mutual calling: LLVM timers also have this problem, and e.g. if there is problem is in some analysis (say, ScalarEvolution), we see indications in several other passes using this analysis (say, IndVarSimplify and LoopStrengthReduction). While it does not immediately show the problematic spot, it gives you pretty strong hints to where to look at first. So, having even not-perfect timers is still useful.

While LLVM may have some overlap between regions, the vertical timing slices are still pretty well aligned with the horizontal functionality slices. I expect the problems in Clang to be a lot worse. Suppose you enter N levels of parsing templates, and then trigger a whole bunch of template instantiation, AST deserialization, and code generation. Let's say that takes 1s in total. With this patch, I think we'd end up attributing Ns of compile time to "parsing templates", which is clearly very far from the truth, but will likely be listed as (by far) the slowest thing in the compilation. This does not even rise to the level of "not-perfect", it's going to be actively misleading in a lot of cases, and won't even necessarily point anywhere near the problematic spot.

I think with this patch and no fix to the overlap problem, we will find ourselves frequently fielding bugs where people say "X is slow" when it actually isn't. Plus I think we have the opportunity to deliver something that's hugely useful and not much harder to achieve (providing timing information that relates back to the source code), and I'd prefer we spend our complexity budget for this feature there.

Also, I apologize for LGTMing the patch earlier while it was not properly reviewed - I didn't notice it didn't have cfe-commits in subscribers, and it had been waiting for a review for quite some time (so I assumed that all interested parties had their chance to look at it).

No problem, these things happen :) And thank you for your feedback, it's very useful.

[mzolotukhin]

What kinds of <some part> would be useful to you? (How do you want the runtime of Clang broken down?) Are vertical slices (through all Clang's various layers and potentially parts of LLVM) -- as this patch will produce -- useful, or would you really want horizontal slices (as in, what part of Clang is actually spending the time)? Or just anything that's basically expected to be consistent from run to run, so you can identify that something has slowed down, even if you don't have enough information to really know what?

For me "something has slowed down" would be enough. I.e. even if "parse templates" would be erroneously attributed to 90% time spent in front-end, I would be able to see a jump from 90% to 95%. While these numbers are not reflecting the actual ratio, they still will indicate changes.

I would find horizontal slicing more interesting, as we can get vertical slices from profilers. I.e. if in LLVM profile I see that time spent in APInt::add has grown a lot, I'd like to know which pass started to use it more extensively - it's rarely the case that APInt::add slowed down itself.

I think we need to fix the overlap issue as a prerequisite to adding timers with large amounts of overlap, especially self-overlap. Otherwise the numbers will likely do more harm than good, as they will significantly misattribute runtime. Fortunately, I think that should only require some relatively small changes to the LLVM timer infrastructure.

I definitely would support that :)

Well, that depends on the profiler. With some profilers, you can just attach a profiler to your entire compilation and then ask it what the hottest functions were. But sure, if you have existing infrastructure built around -ftime-report, I can see that it makes sense to reuse that infrastructure.

Yeah, that was exactly my point.

While LLVM may have some overlap between regions, the vertical timing slices are still pretty well aligned with the horizontal functionality slices. I expect the problems in Clang to be a lot worse. Suppose you enter N levels of parsing templates, and then trigger a whole bunch of template instantiation, AST deserialization, and code generation. Let's say that takes 1s in total. With this patch, I think we'd end up attributing Ns of compile time to "parsing templates", which is clearly very far from the truth, but will likely be listed as (by far) the slowest thing in the compilation. This does not even rise to the level of "not-perfect", it's going to be actively misleading in a lot of cases, and won't even necessarily point anywhere near the problematic spot.
I think with this patch and no fix to the overlap problem, we will find ourselves frequently fielding bugs where people say "X is slow" when it actually isn't. Plus I think we have the opportunity to deliver something that's hugely useful and not much harder to achieve (providing timing information that relates back to the source code), and I'd prefer we spend our complexity budget for this feature there.

I see your point, and I agree it would be really misleading if e.g the sum of timers won't match the total time due to self-overlaps. I think adding these timers still might be worthwhile as my guess is that no one usually uses them anyway unless they know what to expect from the reported timers, but I might be mistaken here. And anyway, if you think it's possible to fix the issue first, it's totally fine with me.

Thanks,
Michael

[avt77]

In D43578#1067995, @rsmith wrote:

I think D45619 is a good change, and I'd like to see that get committed.

Could you give me LGTM in this case? I'm going to publish "recursive"(ovelaped) timers but I'd like to base it on D45619.

[avt77]

In D43578#1068417, @rsmith wrote:

I think we need to fix the overlap issue as a prerequisite to adding timers with large amounts of overlap, especially self-overlap. Otherwise the numbers will likely do more harm than good, as they will significantly misattribute runtime. Fortunately, I think that should only require some relatively small changes to the LLVM timer infrastructure.

JFYI: the given patch introduces non-recursive (self-overlaps) timers only. I'm going to introduce self-overlaps timers when D45619 is committed.

cfe/trunk/include/clang/Frontend/FrontendAction.h

class FrontendAction {
   friend class ASTMergeAction;
   friend class WrapperFrontendAction;
 
 private:
   std::unique_ptr<ASTConsumer> CreateWrappedASTConsumer(CompilerInstance &CI,
                                                         StringRef InFile);
 
 protected:
+  static constexpr const char *GroupName = "factions";
+  static constexpr const char *GroupDescription =
+      "===== Frontend Actions =====";
   /// @name Implementation Action Interface
   /// @{
 
   /// \brief Create the AST consumer object for this action, if supported.
   ///
   /// This routine is called as part of BeginSourceFile(), which will
   /// fail if the AST consumer cannot be created. This will not be called if the
   /// action has indicated that it only uses the preprocessor.

cfe/trunk/include/clang/Lex/HeaderSearch.h

 
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/DirectoryLookup.h"
 #include "clang/Lex/ModuleMap.h"
 #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>
 #include <string>
 #include <utility>
 #include <vector>
 
+static const char *const IncGroupName = "includefiles";
+static const char *const IncGroupDescription = "===== Include Files =====";
+
 namespace clang {
 
 class DiagnosticsEngine;
 class DirectoryEntry;
 class ExternalPreprocessorSource;
 class FileEntry;
 class FileManager;
 class HeaderMap;

cfe/trunk/include/clang/Parse/Parser.h

private:
   void CodeCompletePreprocessorExpression() override;
   void CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo,
                                  unsigned ArgumentIndex) override;
   void CodeCompleteNaturalLanguage() override;
 };
 
 }  // end namespace clang
 
+static const char *const GroupName = "clangparser";
+static const char *const GroupDescription = "===== Clang Parser =====";
 #endif

cfe/trunk/include/clang/Sema/Sema.h

if (New->isExternallyDeclarable()) {
              "should not have found a non-externally-declarable previous decl");
       return true;
     }
     return false;
   }
   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;
 
   OpenCLOptions OpenCLFeatures;
   FPOptions FPFeatures;
 
   const LangOptions &LangOpts;

cfe/trunk/lib/CodeGen/CodeGenAction.cpp

 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/BackendUtil.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #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"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"

 using namespace llvm;
 
 namespace clang {
   class BackendConsumer;
   class ClangDiagnosticHandler final : public DiagnosticHandler {
   public:
     ClangDiagnosticHandler(const CodeGenOptions &CGOpts, BackendConsumer *BCon)
         : CodeGenOpts(CGOpts), BackendCon(BCon) {}
-  
     bool handleDiagnostics(const DiagnosticInfo &DI) override;
 
     bool isAnalysisRemarkEnabled(StringRef PassName) const override {
       return (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
               CodeGenOpts.OptimizationRemarkAnalysisPattern->match(PassName));
     }
     bool isMissedOptRemarkEnabled(StringRef PassName) const override {
       return (CodeGenOpts.OptimizationRemarkMissedPattern &&
class BackendConsumer : public ASTConsumer {
     DiagnosticsEngine &Diags;
     BackendAction Action;
     const HeaderSearchOptions &HeaderSearchOpts;
     const CodeGenOptions &CodeGenOpts;
     const TargetOptions &TargetOpts;
     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
     /// can happen when Clang plugins trigger additional AST deserialization.
     bool IRGenFinished = false;
 
     std::unique_ptr<CodeGenerator> Gen;
 
BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags,
                     const LangOptions &LangOpts, bool TimePasses,
                     const std::string &InFile,
                     SmallVector<LinkModule, 4> LinkModules,
                     std::unique_ptr<raw_pwrite_stream> OS, LLVMContext &C,
                     CoverageSourceInfo *CoverageInfo = nullptr)
         : 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;
     }
     llvm::Module *getModule() const { return Gen->GetModule(); }
     std::unique_ptr<llvm::Module> takeModule() {
       return std::unique_ptr<llvm::Module>(Gen->ReleaseModule());
     }
 
     CodeGenerator *getCodeGenerator() { return Gen.get(); }
 
     void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
       Gen->HandleCXXStaticMemberVarInstantiation(VD);
     }
 
     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;
     }
 
     void HandleInlineFunctionDefinition(FunctionDecl *D) override {
       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 {
       // Ignore interesting decls from the AST reader after IRGen is finished.
       if (!IRGenFinished)
         HandleTopLevelDecl(D);
     }
 
     // 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)
             Gen->CGM().AddDefaultFnAttrs(F);
 
         CurLinkModule = LM.Module.get();
 
         bool Err;
bool LinkInModules() {
           return true;
       }
       return false; // success
     }
 
     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.
       if (!getModule())
         return;
 
       // Install an inline asm handler so that diagnostics get printed through
       // our diagnostics hooks.
public:
     void HandleTagDeclDefinition(TagDecl *D) override {
       PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
                                      Context->getSourceManager(),
                                      "LLVM IR generation of declaration");
       Gen->HandleTagDeclDefinition(D);
     }
 
     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);
     }
 
     /// Get the best possible source location to represent a diagnostic that
     /// may have associated debug info.
     const FullSourceLoc
     getBestLocationFromDebugLoc(const llvm::DiagnosticInfoWithLocationBase &D,
static void BitcodeInlineAsmDiagHandler(const llvm::SMDiagnostic &SM,
   case llvm::SourceMgr::DK_Remark:
     llvm_unreachable("remarks unexpected");
   }
 
   Diags->Report(DiagID).AddString("cannot compile inline asm");
 }
 
 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();
 
   // For ThinLTO backend invocations, ensure that the context
   // merges types based on ODR identifiers. We also need to read
   // the correct module out of a multi-module bitcode file.
   if (!CI.getCodeGenOpts().ThinLTOIndexFile.empty()) {
     VMContext->enableDebugTypeODRUniquing();
std::unique_ptr<llvm::Module> CodeGenAction::loadModule(MemoryBufferRef MBRef) {
 
   CI.getDiagnostics().Report(Loc, DiagID) << Msg;
   return {};
 }
 
 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 =
         GetOutputStream(CI, getCurrentFile(), BA);
     if (BA != Backend_EmitNothing && !OS)
       return;
 
     bool Invalid;

cfe/trunk/lib/Frontend/ASTMerge.cpp

 //===-- ASTMerge.cpp - AST Merging Frontend Action --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // 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;
 
 std::unique_ptr<ASTConsumer>
 ASTMergeAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   return AdaptedAction->CreateASTConsumer(CI, InFile);
 }
 
 bool ASTMergeAction::BeginSourceFileAction(CompilerInstance &CI) {
   // FIXME: This is a hack. We need a better way to communicate the
   // AST file, compiler instance, and file name than member variables
   // of FrontendAction.
   AdaptedAction->setCurrentInput(getCurrentInput(), takeCurrentASTUnit());
   AdaptedAction->setCompilerInstance(&CI);
   return AdaptedAction->BeginSourceFileAction(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());
   CI.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
                                        &CI.getASTContext());
   IntrusiveRefCntPtr<DiagnosticIDs>
       DiagIDs(CI.getDiagnostics().getDiagnosticIDs());
   for (unsigned I = 0, N = ASTFiles.size(); I != N; ++I) {

cfe/trunk/lib/Frontend/CompilerInstance.cpp

 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <sys/stat.h>
 #include <system_error>
 #include <time.h>
 #include <utility>
 
 using namespace clang;
+static const char *const GroupName = "frontend";
+static const char *const GroupDescription = "===== Frontend =====";
 
 CompilerInstance::CompilerInstance(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     MemoryBufferCache *SharedPCMCache)
     : ModuleLoader(/* BuildingModule = */ SharedPCMCache),
       Invocation(new CompilerInvocation()),
       PCMCache(SharedPCMCache ? SharedPCMCache : new MemoryBufferCache),
       ThePCHContainerOperations(std::move(PCHContainerOps)) {

 
 // High-Level Operations
 
 bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
   assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
   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();
 
   // Create the target instance.
   setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
                                          getInvocation().TargetOpts));
   if (!hasTarget())

cfe/trunk/lib/Frontend/FrontendAction.cpp

 #include "clang/Frontend/LayoutOverrideSource.h"
 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/LiteralSupport.h"
 #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"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"

cfe/trunk/lib/Frontend/FrontendActions.cpp

 }
 
 std::unique_ptr<ASTConsumer>
 VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   return llvm::make_unique<ASTConsumer>();
 }
 
 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;
   std::unique_ptr<ASTReader> Reader(new ASTReader(
       CI.getPreprocessor(), &CI.getASTContext(), CI.getPCHContainerReader(),
       CI.getFrontendOpts().ModuleFileExtensions,
       Sysroot.empty() ? "" : Sysroot.c_str(),
       /*DisableValidation*/ false,
void PreprocessOnlyAction::ExecuteAction() {
   // Start parsing the specified input file.
   PP.EnterMainSourceFile();
   do {
     PP.Lex(Tok);
   } while (Tok.isNot(tok::eof));
 }
 
 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>).
   //
   // Look to see what type of line endings the file uses. If there's a
   // CRLF, then we won't open the file up in binary mode. If there is
   // just an LF or CR, then we will open the file up in binary mode.
   // In this fashion, the output format should match the input format, unless

cfe/trunk/lib/Lex/HeaderSearch.cpp

 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/ModuleMap.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/Hashing.h"
 #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>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <system_error>
 #include <utility>
if (HSOpts->DisableModuleHash) {
     SmallString<128> HashStr;
     llvm::APInt(64, size_t(Hash)).toStringUnsigned(HashStr, /*Radix*/36);
     llvm::sys::path::append(Result, ModuleName + "-" + HashStr + ".pcm");
   }
   return Result.str().str();
 }
 
 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)
     return Module;
 
   StringRef SearchName = ModuleName;
   Module = lookupModule(ModuleName, SearchName);
 
   // The facility for "private modules" -- adjacent, optional module maps named
   // module.private.modulemap that are supposed to define private submodules --
   // may have different flavors of names: FooPrivate, Foo_Private and Foo.Private.
   //
   // Foo.Private is now deprecated in favor of Foo_Private. Users of FooPrivate
   // should also rename to Foo_Private. Representing private as submodules
   // could force building unwanted dependencies into the parent module and cause
   // dependency cycles.
   if (!Module && SearchName.consume_back("_Private"))
     Module = lookupModule(ModuleName, SearchName);
   if (!Module && SearchName.consume_back("Private"))
     Module = lookupModule(ModuleName, SearchName);
   return Module;
 }
 
 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
   // maps, searching for a module map that describes this module.
   for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
     if (SearchDirs[Idx].isFramework()) {
       // Search for or infer a module map for a framework. Here we use
       // SearchName rather than ModuleName, to permit finding private modules
const FileEntry *DirectoryLookup::LookupFile(
     SourceLocation IncludeLoc,
     SmallVectorImpl<char> *SearchPath,
     SmallVectorImpl<char> *RelativePath,
     Module *RequestingModule,
     ModuleMap::KnownHeader *SuggestedModule,
     bool &InUserSpecifiedSystemFramework,
     bool &HasBeenMapped,
     SmallVectorImpl<char> &MappedName) const {
+  llvm::NamedRegionTimer T("lookupfile", "Lookup File", IncGroupName,
+                           IncGroupDescription, llvm::TimePassesIsEnabled);
   InUserSpecifiedSystemFramework = false;
   HasBeenMapped = false;
 
   SmallString<1024> TmpDir;
   if (isNormalDir()) {
     // Concatenate the requested file onto the directory.
     TmpDir = getDir()->getName();
     llvm::sys::path::append(TmpDir, Filename);

 
 /// DoFrameworkLookup - Do a lookup of the specified file in the current
 /// DirectoryLookup, which is a framework directory.
 const FileEntry *DirectoryLookup::DoFrameworkLookup(
     StringRef Filename, HeaderSearch &HS, SmallVectorImpl<char> *SearchPath,
     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.
   size_t SlashPos = Filename.find('/');
   if (SlashPos == StringRef::npos) return nullptr;
 
   // Find out if this is the home for the specified framework, by checking
   // HeaderSearch.  Possible answers are yes/no and unknown.

 /// search is needed. Microsoft mode will pass all \#including files.
 const FileEntry *HeaderSearch::LookupFile(
     StringRef Filename, SourceLocation IncludeLoc, bool isAngled,
     const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir,
     ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>> Includers,
     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;
 
   if (SuggestedModule)
     *SuggestedModule = ModuleMap::KnownHeader();
     
   // If 'Filename' is absolute, check to see if it exists and no searching.
   if (llvm::sys::path::is_absolute(Filename)) {

 const FileEntry *HeaderSearch::
 LookupSubframeworkHeader(StringRef Filename,
                          const FileEntry *ContextFileEnt,
                          SmallVectorImpl<char> *SearchPath,
                          SmallVectorImpl<char> *RelativePath,
                          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?
   size_t SlashPos = Filename.find('/');
   if (SlashPos == StringRef::npos) return nullptr;
 
   // Look up the base framework name of the ContextFileEnt.
   StringRef ContextName = ContextFileEnt->getName();
void HeaderSearch::MarkFileModuleHeader(const FileEntry *FE,
   auto &HFI = getFileInfo(FE);
   HFI.isModuleHeader |= isModularHeader;
   HFI.isCompilingModuleHeader |= isCompilingModuleHeader;
 }
 
 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.
   HeaderFileInfo &FileInfo = getFileInfo(File);
 
   // FIXME: this is a workaround for the lack of proper modules-aware support
   // for #import / #pragma once
   auto TryEnterImported = [&]() -> bool {
static bool suggestModule(HeaderSearch &HS, const FileEntry *File,
   }
 
   return true;
 }
 
 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);
     return suggestModule(*this, File, RequestingModule, SuggestedModule);
   }
   return true;
 }
 
 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;
     const DirectoryEntry *TopFrameworkDir
       = ::getTopFrameworkDir(FileMgr, FrameworkName, SubmodulePath);
     
     // Determine the name of the top-level framework.
     StringRef ModuleName = llvm::sys::path::stem(TopFrameworkDir->getName());
if (const FileEntry *ModuleMapFile = lookupModuleMapFile(Dir, IsFramework)) {
     else if (Result == LMM_InvalidModuleMap)
       DirectoryHasModuleMap[Dir] = false;
     return Result;
   }
   return LMM_InvalidModuleMap;
 }
 
 void HeaderSearch::collectAllModules(SmallVectorImpl<Module *> &Modules) {
+  llvm::NamedRegionTimer T("allmodules", "Collect All Modules", IncGroupName,
+                           IncGroupDescription, llvm::TimePassesIsEnabled);
   Modules.clear();
 
   if (HSOpts->ImplicitModuleMaps) {
     // Load module maps for each of the header search directories.
     for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
       bool IsSystem = SearchDirs[Idx].isSystemHeaderDirectory();
       if (SearchDirs[Idx].isFramework()) {
         std::error_code EC;

cfe/trunk/lib/Lex/PPMacroExpansion.cpp

 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.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 "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"
 #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>
 #include <cstddef>
 #include <cstring>
 #include <ctime>
 #include <string>
 #include <tuple>
 #include <utility>
 
 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())
     return nullptr;
   auto Pos = CurSubmoduleState->Macros.find(II);
   return Pos == CurSubmoduleState->Macros.end() ? nullptr
                                                 : Pos->second.getLatest();
 }
 
 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();
   MD->setPrevious(OldMD);
   StoredMD.setLatest(MD);
   StoredMD.overrideActiveModuleMacros(*this, II);
 
   if (needModuleMacros()) {
void Preprocessor::setLoadedMacroDirective(IdentifierInfo *II,
   if (!MD->isDefined() && LeafModuleMacros.find(II) == LeafModuleMacros.end())
     II->setHasMacroDefinition(false);
 }
 
 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);
 
   void *InsertPos;
   if (auto *MM = ModuleMacros.FindNodeOrInsertPos(ID, InsertPos)) {
     New = false;
     return MM;
   }
ModuleMacro *Preprocessor::getModuleMacro(Module *Mod, IdentifierInfo *II) {
   return ModuleMacros.FindNodeOrInsertPos(ID, InsertPos);
 }
 
 void Preprocessor::updateModuleMacroInfo(const IdentifierInfo *II,
                                          ModuleMacroInfo &Info) {
   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();
 
   auto Leaf = LeafModuleMacros.find(II);
   if (Leaf == LeafModuleMacros.end()) {
     // No imported macros at all: nothing to do.
     return;
   }

 
 /// ReadFunctionLikeMacroArgs - After reading "MACRO" and knowing that the next
 /// token is the '(' of the macro, this method is invoked to read all of the
 /// actual arguments specified for the macro invocation.  This returns null on
 /// error.
 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();
 
   // Outer loop, while there are more arguments, keep reading them.
   Token Tok;
 
   // Read arguments as unexpanded tokens.  This avoids issues, e.g., where

cfe/trunk/lib/Lex/Pragma.cpp

 #include "clang/Lex/PTHLexer.h"
 #include "clang/Lex/Token.h"
 #include "clang/Lex/TokenLexer.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/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>
 #include <cstdint>
 #include <limits>
 #include <string>
 #include <utility>
 #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;
 
 //===----------------------------------------------------------------------===//
 // EmptyPragmaHandler Implementation.
 //===----------------------------------------------------------------------===//
 

 }
 
 /// FindHandler - Check to see if there is already a handler for the
 /// specified name.  If not, return the handler for the null identifier if it
 /// exists, otherwise return null.  If IgnoreNull is true (the default) then
 /// 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());
 }
 
 void PragmaNamespace::AddPragma(PragmaHandler *Handler) {
   assert(!Handlers.lookup(Handler->getName()) &&
          "A handler with this name is already registered in this namespace");

 //===----------------------------------------------------------------------===//
 // Preprocessor Pragma Directive Handling.
 //===----------------------------------------------------------------------===//
 
 /// HandlePragmaDirective - The "\#pragma" directive has been parsed.  Lex the
 /// 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);
 
   if (!PragmasEnabled)
     return;
 
   ++NumPragma;
 

cfe/trunk/lib/Parse/ParseTemplate.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #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
 /// explicit specialization.
 Decl *
 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)) {
     return ParseExplicitInstantiation(Context,
                                       SourceLocation(), ConsumeToken(),
                                       DeclEnd, AS);
   }
   return ParseTemplateDeclarationOrSpecialization(Context, DeclEnd, AS,

cfe/trunk/lib/Parse/Parser.cpp

 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
+#include "llvm/Support/Timer.h"
 using namespace clang;
 
 
 namespace {
 /// \brief A comment handler that passes comments found by the preprocessor
 /// to the parser action.
 class ActionCommentHandler : public CommentHandler {
   Sema &S;
void Parser::EnterScope(unsigned ScopeFlags) {
   } else {
     Actions.CurScope = new Scope(getCurScope(), ScopeFlags, Diags);
   }
 }
 
 /// 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.
   Actions.ActOnPopScope(Tok.getLocation(), getCurScope());
 
   Scope *OldScope = getCurScope();
   Actions.CurScope = OldScope->getParent();
 
if (NoTopLevelDecls && !Actions.getASTContext().getExternalSource() &&
     Diag(diag::ext_empty_translation_unit);
 
   return NoTopLevelDecls;
 }
 
 /// 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
   // processing
   if (PP.isIncrementalProcessingEnabled() && Tok.is(tok::eof))
     ConsumeToken();
 
   Result = nullptr;

 ///         decl-specifier-seq[opt] declarator ctor-initializer[opt]
 ///         function-body
 /// [C++] function-definition: [C++ 8.4]
 ///         decl-specifier-seq[opt] declarator function-try-block
 ///
 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();
 
   // If this is C90 and the declspecs were completely missing, fudge in an
   // implicit int.  We do this here because this is the only place where
   // declaration-specifiers are completely optional in the grammar.
   if (getLangOpts().ImplicitInt && D.getDeclSpec().isEmpty()) {
case tok::equalequal:          // ==
     LLVM_FALLTHROUGH;
   case tok::equal:
     return true;
   }
 }
 
 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()) {
     if (S->getFlags() & Scope::FnScope) {
       Actions.CodeCompleteOrdinaryName(getCurScope(),
                                        Sema::PCC_RecoveryInFunction);
       cutOffParsing();
       return PrevTokLocation;
SourceLocation Parser::handleUnexpectedCodeCompletionToken() {
   Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Namespace);
   cutOffParsing();
   return PrevTokLocation;
 }
 
 // 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();
 }
 
 bool Parser::ParseMicrosoftIfExistsCondition(IfExistsCondition& Result) {
   assert((Tok.is(tok::kw___if_exists) || Tok.is(tok::kw___if_not_exists)) &&
          "Expected '__if_exists' or '__if_not_exists'");
   Result.IsIfExists = Tok.is(tok::kw___if_exists);
   Result.KeywordLoc = ConsumeToken();

 /// of a module interface, module partition, or module implementation file.
 ///
 ///   module-declaration:   [Modules TS + P0273R0 + P0629R0]
 ///     'export'[opt] 'module' 'partition'[opt]
 ///            module-name attribute-specifier-seq[opt] ';'
 ///
 /// 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)
                                  ? Sema::ModuleDeclKind::Interface
                                  : Sema::ModuleDeclKind::Implementation;
 
   assert(Tok.is(tok::kw_module) && "not a module declaration");
   SourceLocation ModuleLoc = ConsumeToken();

 /// [ObjC]  @import declaration:
 ///           '@' 'import' module-name ';'
 /// [ModTS] module-import-declaration:
 ///           'import' module-name attribute-specifier-seq[opt] ';'
 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;
   
   SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
   if (ParseModuleName(ImportLoc, Path, /*IsImport*/true))
     return nullptr;
 
   ParsedAttributesWithRange Attrs(AttrFactory);

 ///         module-name:
 ///           module-name-qualifier[opt] identifier
 ///         module-name-qualifier:
 ///           module-name-qualifier[opt] identifier '.'
 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)) {
       if (Tok.is(tok::code_completion)) {
         Actions.CodeCompleteModuleImport(UseLoc, Path);
         cutOffParsing();
         return true;
       }
bool Parser::ParseModuleName(
   }
 }
 
 /// \brief Try recover parser when module annotation appears where it must not
 /// be found.
 /// \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:
       // If we recovered from a misplaced module begin, we expect to hit a
       // misplaced module end too. Stay in the current context when this
       // happens.
       if (MisplacedModuleBeginCount) {
         --MisplacedModuleBeginCount;

cfe/trunk/lib/Sema/Sema.cpp

 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaConsumer.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/TemplateDeduction.h"
 #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;
 
 SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {
   return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
 }
 
 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
if (getLangOpts().ModulesTS) {
     TU->setLocalOwningModule(GlobalModule);
   }
 }
 
 /// ActOnEndOfTranslationUnit - This is called at the very end of the
 /// 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?");
 
   // If code completion is enabled, don't perform any end-of-translation-unit
   // work.
   if (PP.isCodeCompletionEnabled())
     return;
 
void Sema::ActOnEndOfTranslationUnit() {
   PendingInstantiations.insert(PendingInstantiations.end(),
                                LateParsedInstantiations.begin(),
                                LateParsedInstantiations.end());
   LateParsedInstantiations.clear();
 
   // 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
     // might lead to more pending template instantiations, which we then need
     // to instantiate.
     DefineUsedVTables();
 
     // C++: Perform implicit template instantiations.
UnusedFileScopedDecls.erase(
       std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
                      UnusedFileScopedDecls.end(),
                      [this](const DeclaratorDecl *DD) {
                        return ShouldRemoveFromUnused(this, DD);
                      }),
       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;
     return;
   }
 
   // Check for #pragma weak identifiers that were never declared
   LoadExternalWeakUndeclaredIdentifiers();
void Sema::ActOnEndOfTranslationUnit() {
 
   if (!Diags.hasErrorOccurred()) {
     if (ExternalSource)
       ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
     checkUndefinedButUsed(*this);
   }
 
   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() ==
             LangOptions::CMK_ModuleInterface &&
         ModuleScopes.back().Module->Kind != Module::ModuleInterfaceUnit) {
       // FIXME: Make a better guess as to where to put the module declaration.
       Diag(getSourceManager().getLocForStartOfFile(
                getSourceManager().getMainFileID()),

 /// \param E - The expression to examine.
 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
 ///  with no arguments, this parameter is set to the type returned by such a
 ///  call; otherwise, it is set to an empty QualType.
 /// \param OverloadSet - If the expression is an overloaded function
 ///  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();
 
   const OverloadExpr *Overloads = nullptr;
   bool IsMemExpr = false;
   if (E.getType() == Context.OverloadTy) {
     OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
 
return (!isa<CStyleCastExpr>(E) &&
           !isa<UnaryOperator>(E) &&
           !isa<BinaryOperator>(E) &&
           !isa<CXXOperatorCallExpr>(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();
 
   QualType ZeroArgCallTy;
   UnresolvedSet<4> Overloads;
   if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
       !ZeroArgCallTy.isNull() &&
       (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {

cfe/trunk/lib/Sema/SemaChecking.cpp

 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ErrorHandling.h"
 #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>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <limits>
 #include <string>
static bool checkArgCount(Sema &S, CallExpr *call, unsigned desiredArgCount) {
   if (argCount < desiredArgCount)
     return S.Diag(call->getLocEnd(), diag::err_typecheck_call_too_few_args)
         << 0 /*function call*/ << desiredArgCount << argCount
         << call->getSourceRange();
 
   // 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();
 }
 
 /// Check that the first argument to __builtin_annotation is an integer
 /// and the second argument is a non-wide string literal.
 static bool SemaBuiltinAnnotation(Sema &S, CallExpr *TheCall) {
if (!(PtrTy && PtrTy->getPointeeType()->isIntegerType() &&
       return true;
     }
   }
 
   return false;
 }
 
 static void SemaBuiltinMemChkCall(Sema &S, FunctionDecl *FDecl,
-                      CallExpr *TheCall, unsigned SizeIdx,
+                                  CallExpr *TheCall, unsigned SizeIdx,
                                   unsigned DstSizeIdx) {
   if (TheCall->getNumArgs() <= SizeIdx ||
       TheCall->getNumArgs() <= DstSizeIdx)
     return;
 
   const Expr *SizeArg = TheCall->getArg(SizeIdx);
   const Expr *DstSizeArg = TheCall->getArg(DstSizeIdx);
 

 ///                    kernel_enqueue_flags_t flags,
 ///                    const ndrange_t ndrange,
 ///                    uint num_events_in_wait_list,
 ///                    clk_event_t *event_wait_list,
 ///                    clk_event_t *event_ret,
 ///                    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) {
     S.Diag(TheCall->getLocStart(), diag::err_typecheck_call_too_few_args);
     return true;
   }
 
   Expr *Arg0 = TheCall->getArg(0);
Call->setType(S.Context.getPointerType(S.Context.getQualifiedType(
       RT.getUnqualifiedType(), Qual)));
 
   return false;
 }
 
 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.
   unsigned ICEArguments = 0;
   ASTContext::GetBuiltinTypeError Error;
   Context.GetBuiltinType(BuiltinID, Error, &ICEArguments);
   if (Error != ASTContext::GE_None)
     ICEArguments = 0;  // Don't diagnose previously diagnosed errors.
bool Sema::CheckX86BuiltinGatherScatterScale(unsigned BuiltinID,
   if (Result == 1 || Result == 2 || Result == 4 || Result == 8)
     return false;
 
   return Diag(TheCall->getLocStart(), diag::err_x86_builtin_invalid_scale)
     << Arg->getSourceRange();
 }
 
 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);
 
   if (BuiltinID == X86::BI__builtin_cpu_is)
     return SemaBuiltinCpuIs(*this, TheCall);
 
   // If the intrinsic has rounding or SAE make sure its valid.
   if (CheckX86BuiltinRoundingOrSAE(BuiltinID, TheCall))

 
 /// Handles the checks for format strings, non-POD arguments to vararg
 /// functions, NULL arguments passed to non-NULL parameters, and diagnose_if
 /// attributes.
 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;
 
   // Printf and scanf checking.
   llvm::SmallBitVector CheckedVarArgs;
   if (FDecl) {
     for (const auto *I : FDecl->specific_attrs<FormatAttr>()) {

 /// type of its first argument.  The main ActOnCallExpr routines have already
 /// promoted the types of arguments because all of these calls are prototyped as
 /// void(...).
 ///
 /// This function goes through and does final semantic checking for these
 /// 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());
 
   // Ensure that we have at least one argument to do type inference from.
   if (TheCall->getNumArgs() < 1) {
     Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args_at_least)
       << 0 << 1 << TheCall->getNumArgs()
static bool isSameWidthConstantConversion(Sema &S, Expr *E, QualType T,
   }
 
   return true;
 }
 
 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();
   const Type *Target = S.Context.getCanonicalType(T).getTypePtr();
   if (Source == Target) return;
   if (Target->isDependentType()) return;
 
   // If the conversion context location is invalid don't complain. We also

cfe/trunk/lib/Sema/SemaDecl.cpp

 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #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>
 
 using namespace clang;
 using namespace sema;
 
 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) {
static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS,
   return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
 }
 
 Sema::NameClassification
 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();
 
   if (NextToken.is(tok::coloncolon)) {
     NestedNameSpecInfo IdInfo(Name, NameLoc, NextToken.getLocation());
     BuildCXXNestedNameSpecifier(S, IdInfo, false, SS, nullptr, false);
   } else if (getLangOpts().CPlusPlus && SS.isSet() &&
              isCurrentClassName(*Name, S, &SS)) {
if (dyn_cast_or_null<DecltypeType>(
     Diag(Loc, diag::err_decltype_in_declarator)
       << SpecLoc.getTypeLoc().getSourceRange();
 
   return false;
 }
 
 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();
 
   // All of these full declarators require an identifier.  If it doesn't have
   // one, the ParsedFreeStandingDeclSpec action should be used.
   if (D.isDecompositionDeclarator()) {
     return ActOnDecompositionDeclarator(S, D, TemplateParamLists);

cfe/trunk/lib/Sema/SemaExpr.cpp

 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaFixItUtils.h"
 #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;
 
 /// \brief Determine whether the use of this declaration is valid, without
 /// emitting diagnostics.
 bool Sema::CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid) {
   // See if this is an auto-typed variable whose initializer we are parsing.
   if (ParsingInitForAutoVars.count(D))

 
 ExprResult
 Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc,
                                 SourceLocation DefaultLoc,
                                 SourceLocation RParenLoc,
                                 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());
 
   TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs];
   for (unsigned i = 0; i < NumAssocs; ++i) {
     if (ArgTypes[i])
       (void) GetTypeFromParser(ArgTypes[i], &Types[i]);
     else

 /// fragments (e.g. "foo" "bar" L"baz").  The result string has to handle string
 /// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
 /// multiple tokens.  However, the common case is that StringToks points to one
 /// string.
 ///
 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)
     return ExprError();
 
   SmallVector<SourceLocation, 4> StringTokLocs;
   for (const Token &Tok : StringToks)
     StringTokLocs.push_back(Tok.getLocation());

 ExprResult
 Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
                         SourceLocation TemplateKWLoc, UnqualifiedId &Id,
                         bool HasTrailingLParen, bool IsAddressOfOperand,
                         std::unique_ptr<CorrectionCandidateCallback> CCC,
                         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();
 
   TemplateArgumentListInfo TemplateArgsBuffer;
 
   // Decompose the UnqualifiedId into the following data.
   DeclarationNameInfo NameInfo;
   const TemplateArgumentListInfo *TemplateArgs;
if (IT == PredefinedExpr::LFunction) {
                                  /*Pascal*/ false, ResTy, Loc);
     }
   }
 
   return new (Context) PredefinedExpr(Loc, ResTy, IT, SL);
 }
 
 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) {
   default: llvm_unreachable("Unknown simple primary expr!");
   case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
   case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
   case tok::kw___FUNCDNAME__: IT = PredefinedExpr::FuncDName; break; // [MS]
   case tok::kw___FUNCSIG__: IT = PredefinedExpr::FuncSig; break; // [MS]

cfe/trunk/lib/Sema/SemaTemplate.cpp

 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #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;
 using namespace sema;
 
 // Exported for use by Parser.
 SourceRange
 clang::getTemplateParamsRange(TemplateParameterList const * const *Ps,
bool Sema::DiagnoseUnknownTemplateName(const IdentifierInfo &II,
   return true;
 }
 
 void Sema::LookupTemplateName(LookupResult &Found,
                               Scope *S, CXXScopeSpec &SS,
                               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;
   bool isDependent = false;
   if (!ObjectType.isNull()) {
     // This nested-name-specifier occurs in a member access expression, e.g.,
     // x->B::f, and we are looking into the type of the object.
     assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");

 /// was just parsed.  This is only possible with an explicit scope
 /// specifier naming a dependent type.
 ExprResult
 Sema::ActOnDependentIdExpression(const CXXScopeSpec &SS,
                                  SourceLocation TemplateKWLoc,
                                  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:
   //   An id-expression that denotes a non-static data member or non-static
   //   member function of a class can only be used:
   //   (...)
   //   - if that id-expression denotes a non-static data member and it
   //     appears in an unevaluated operand.

cfe/trunk/test/Frontend/ftime-report-template-decl.cpp

+// 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