[lldCOFF] Print detailed timing information with /VERBOSE

[zturner]

Summary

When passing /VERBOSE, lld will now print detailed timing information about the various linking phases. For example, when linking clang with /verbose, I get this output:

Timing:
  Code Layout Time:          (  1.38%)   229 ms
  Commit Output File:        (  0.09%)    15 ms
  PDB Emission (Cumulative): ( 96.03%) 15969 ms
    Globals Stream Layout:   (  1.18%)   197 ms
    Symbol Merging:          ( 26.26%)  4367 ms
    Type Merging:            ( 36.94%)  6142 ms
    TPI Stream Layout:       (  6.95%)  1155 ms
    Commit to Disk:          ( 18.65%)  3101 ms
-----------------------------------------------
  Total Link Time:           (100.00%) 16629 ms

[ruiu]

lld/COFF/Config.h

113

Why do you have to store them to Config? Config is for configuration variables and not a generic place to store miscellaneous data.

lld/COFF/PDB.cpp

1017–1018

These things should be done in the RAII style.

lld/COFF/Writer.cpp

286

I'd print out the timing information as we measure, instead of printing out all the information at end.

306–325

Please avoid using formatv in lld because we do not use it in other places in lld. We don't remember the format string format.

[zturner]

lld/COFF/PDB.cpp

1017–1018

I didn't do RAII style here because we want to start and stop in the middle of functions sometimes. It seemed inconvenient to have to make a nested scope just for that.

lld/COFF/Writer.cpp

286

If we do it this way it might not all appear together. This will make it harder to parse the output, as you might have to scroll the terminal around to find the different pieces of information you're interested in.

306–325

It's pretty ugly to do any kind of nice alignment without it. I try to avoid it if there's a better way, but in this case I think it would add a lot of additional code for no real benefit.

[ruiu]

lld/COFF/PDB.cpp

1017–1018

I guess it's because the timing information is printed out along with other debug info. How about adding a new command line just for this feature?

[ruiu]

lld/COFF/PDB.cpp

1017–1018

It's worth noting that /verbose makes the linker slower because generating and emitting debug messages is sometimes not cheap. For that reason it makes sense to separate the flag.

[zturner]

• Moved the printing and collection of this information out of /VERBOSE and into a new option, /SHOWTIMING.

• Removed a few explicit calls to Timer.end() where RAII-style end would work (the class already calls end() in its destructor anyway). A few calls to end() are still explicit, where we need to do it in the middle of a function.

• Moved the statistics out of the Config class and into a separate class called TimingInfo, which is created in Writer and passed through to the PDB linker.

[pcc]

Could this also include some of the earlier linking phases in Driver.cpp (I'm thinking input file reading, GC, ICF)?

[zturner]

In D41915#972686, @pcc wrote:

Could this also include some of the earlier linking phases in Driver.cpp (I'm thinking input file reading, GC, ICF)?

Yea, I can do that. Stay tuned.

[ruiu]

lld/COFF/Driver.cpp

845–847

For consistency:

// Handle /showtiming
if (Args.hasArg(OPT_show_timing))
  Config->ShowTiming = true;

lld/include/lld/Common/LinkTimer.h

18 ↗

(On Diff #129342)

Since everything in lld namespace is related to linking, I'd name this Timer.

21 ↗

(On Diff #129342)

Why don't you use nanosecond?

30 ↗

(On Diff #129342)

Please write the actual type instead of auto.

31 ↗

(On Diff #129342)

It is better to use chrono::high_resolution_clock, or at least chrono::steady_clock. system_clock is not guaranteed to be monotonic (so it can rewind.)

[zturner]

I went to start implementing peter's suggestion, and things started getting a little interesting. A lot of the things you might want to time are behind command line options, and it would be nice if we didn't show anything when the lines weren't relevant.

At the same time, I don't like writing code and then having someone re-invent the same thing later that is slightly different. So although nobody's using this now, I wanted to do this in a way that could benefit, for example, the ELF linker or the MachO linker at some point in the future.

So I tried to generalize this a little bit. Everything is moved into Common now, and the only thing defined in COFF is a set of enums that represent the various statistics that you might want to time. You can add phases dynamically (for example, only if an option is set on the command line), and all the printing logic is raised up into common too, and it does all the work of figuring out the right set of statistics you're timing, calculating percentages, etc, so nobody else has to deal with the formatting and alignment again.

just to illustrate what I mean, currently when I link with /OPT:REF + /OPT:ICF + /DEBUG I get this:

  Input File Reading:        (  3.54%)   576 ms
  ICF:                       (  0.66%)   107 ms
  GC:                        (  1.34%)   218 ms
  Code Layout:               (  0.79%)   128 ms
  Commit Output File:        (  0.07%)    11 ms
  PDB Emission (Cumulative): ( 93.46%) 15214 ms
    Globals Stream Layout:   (  1.09%)   177 ms
    TPI Stream Layout:       (  6.71%)  1093 ms
    Type Merging:            ( 35.43%)  5767 ms
    Symbol Merging:          ( 24.43%)  3977 ms
    Commit to Disk:          ( 17.90%)  2913 ms
------------------------------------------------
Total Link Time:             (100.00%) 16278 ms

whereas if I link with only /OPT:ICF and /OPT:REF but remove /DEBUG I get this:

  Input File Reading: ( 54.80%) 542 ms
  ICF:                ( 11.93%) 118 ms
  GC:                 ( 16.38%) 162 ms
  Code Layout:        ( 13.14%) 130 ms
  Commit Output File: (  1.31%)  13 ms
---------------------------------------
Total Link Time:      (100.00%) 989 ms

I think this is a more friendly output and more useful from a usability perspective. But if I went a little overboard let me know :)

[pcc]

lld/COFF/Driver.cpp

951

I gather that the intent is to add a "ThinLTO" phase to the timing output only if we end up doing LTO, but a user is not required to pass this flag in order to use LTO. Instead, we always perform LTO if the user passes at least one bitcode input file. You can find the check for that condition as well as the code that actually does LTO in the function SymbolTable::addCombinedLTOObject().

Also, I'd call this "LTO" and not "ThinLTO" because the linker supports both full and thin LTO.

[zturner]

• Renamed LinkTimer to Timer, as suggested by Rui.
• Moved the LTO setup into the proper place.
• Changed from system_clock to high_resolution_clock.

I didn't change ms to nanoseconds because I find nanoseconds hard to read. It prints more than 10 digits of numbers, and it takes some mental strain to translate that back into something I can understand. If anyone feels strongly that ms is not a fine enough granularity though, let me know. Making the milliseconds a floating point might be another alternative.

[zturner]

Storing the accumulated time in nanoseconds. Turns out when you store in milliseconds you can accumulate a large amount of truncation error. So I'm now accumulating nanoseconds but still printing milliseconds.

[ruiu]

lld/COFF/Driver.cpp

715

Timer::TimerPhaseRAII is too long. I'd name this ScopedTimer and name the local variable T. As long as you use T as a name for the timer, there should be no confusion. I imagine that you could use it like this:

ScopedTimer T(TotalTimer);

lld/COFF/Timing.h

17

Instead of defining one timer which contains multiple timers in it, can you define a timer for each measurement like this?

namespace lld {
namespace coff {
Timer TotalTimer("Total");
Timer FileReadTimer("Input File Reading");
...
}
}

Then you can remove this enum.

lld/Common/Timer.cpp

14

Please do not use auto.

18

Use double unless there's a reason to use float.

34

Instead of formatv, please use llvm::format which takes printf-style format string. It is more familiar (and thus easy to read) to most people who work on lld.

103

This is a bit too overdesigned at the moment. Just use some fixed width (e.g. 20 chars) as the width of the name field. I'd reduce the amount of code as much as possible.

lld/include/lld/Common/Timer.h

56

I don't think there's a valid use case for this constructor.

[zturner]

lld/COFF/Timing.h

17

The whole idea is that a single class aggregates all of the timers so that at the end, there is one print function that handles all the formatting and alignment. Also, how would nested timers work? For example, I want to have a timer for "PDB Link Time" but then subtimers for the various phases of PDB linking, and those should be indented under the main timer to make it easier to understand the results. See some of the sample outputs I posted earlier, for example.

You could make it all work by having Timer contain a TimerManager&, and then writing something like:

namespace lld {
namespace coff {
TimerManager Timers;
Timer TotalTimer("Total", Timers);
Timer FileReadTimer("Input File Reading", Timers);
...
}
}

but this looks like a worse API to me. Finally, there is the issue of dynamic timers. If someone doesn't pass /DEBUG on the command line, there is no reason to have a bunch of output related to PDB linking phases. So this is why there is the addPhase function, which will add a timer dynamically.

I think this gives the best output.

lld/Common/Timer.cpp

34

Can you show me a printf line that prints N spaces, followed by a string, followed by M spaces, followed by a some right aligned text? I honestly don't know how to do this with printf.

That said, I don't know why we should be scared of or avoid using standard LLVM support types and classes. It's about the same as a python format string, and once you do understand it, it's much easier (not to mention safer) than printf format string. printf format strings are also the source of countless portability bugs.

The code here doesn't really use anything fancy, and it's mostly self explanatory since instead of embedding all the formatting in the format string, I used the adapters like fmt_align which spell out exactly what they're doing, so familiarity shouldn't be an issue.

103

I have a separate patch offline which adds some more timers and which goes past 20. So this would cause it to not be aligned. We can make it 40, or 60, but then it will look ugly in most cases. This is all code hidden behind an option that you have to explicitly specify, so is there any disadvantage to just doing it "correctly"?

[ruiu]

lld/COFF/Timing.h

17

We can organize timer "trees" by passing "parent" timer to child timers like this:

Timer TotalTimer("Total");
Timer FileReadTimer("Input File Reading", &TotalTimer);

And then make timer's "print" function print out its timing information as well as its children's timing information. Then all you have to do at end is to call the "print" function on TotalTimer which recursively prints out all timer info.

lld/Common/Timer.cpp

34

You may be more familiar with this format string than printf-style format string, but that's not true for many other people. And honestly I don't think people would want to spend time on understanding the new format string that occur only a few times in lld (even for making sure that that's the same as Python's format string.) lld is part of the LLVM project, but at the same time, this is a project that people who are not working on LLVM/Clang are interested in, and I don't want to use an LLVM-specific utility if the more language-standard-ish one works sufficiently.

As to how to write it in printf, how about this?

$ printf '% 20s: (% .2f%%) % 5d ms\n' 'Code layout time' 1.379 229
Code layout time: ( 1.38%)   229 ms

103

The disadvantage is the amount of code and time to understand how it works. Please keep it simple even if it looks a bit stupid. In addition to that, calculating the width doesn't create a desired output. If some timer is 80 columns long, you'll get something like

Timing:
  Code Layout Time:                                                                            (  1.38%)   229 ms
  Commit Output File:                                                                          (  0.09%)    15 ms
  Very loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong name: (  0.00%)     0 ms
  PDB Emission (Cumulative):                                                                   ( 96.03%) 15969 ms
    Globals Stream Layout:                                                                     (  1.18%)   197 ms
    Symbol Merging:                                                                            ( 26.26%)  4367 ms
    Type Merging:                                                                              ( 36.94%)  6142 ms
    TPI Stream Layout:                                                                         (  6.95%)  1155 ms
    Commit to Disk:                                                   ( 18.65%)  3101 ms
-----------------------------------------------
  Total Link Time:           (100.00%) 16629 ms

I think what we want to do is to insert a reasonable number of space between ':' and '(' so it doesn't wrap around for most lines. We should format this assuming that the terminal size is 80 columns, so variable width is not really desirable.

Timing:
  Code Layout Time:             (  1.38%)   229 ms
  Commit Output File:           (  0.09%)    15 ms
Very loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong name: (  0.00%)     0 ms
  PDB Emission (Cumulative):    ( 96.03%) 15969 ms
    Globals Stream Layout:      (  1.18%)   197 ms
    Symbol Merging:             ( 26.26%)  4367 ms
    Type Merging:               ( 36.94%)  6142 ms
    TPI Stream Layout:          (  6.95%)  1155 ms
    Commit to Disk:             ( 18.65%)  3101 ms
-----------------------------------------------
  Total Link Time:           (100.00%) 16629 ms

[zturner]

Fixes suggested by rui.

[ruiu]

lld/COFF/Driver.cpp

51

Can you remove addChildTimer if you pass a parent timer to the constructor?

lld/COFF/PDB.cpp

891

I found T1, T2, ... (which you did in Writer.cpp) is better than T, U, V.

lld/Common/Timer.cpp

9

High resolution timer is very cheap on modern processors (I believe it is compiled to RSTSC instruction on x86, for example), so I think we should always enable this and just don't print out the final result if Config->ShowTiming is false.

63

I believe this can be written without repeat:

Stream << std::string('-', 49);

81–88

std::string S = (std::string(' ', Depth * 2) + Name).str();
format("% 30s (%6.2f%%) %5d ms", S, 100 * millis() / TotalDuration, (int)millis());

is perhaps a bit easier to read?

lld/include/lld/Common/Timer.h

36–42

We usually write private members after public members.

[zturner]

lld/COFF/Driver.cpp

51

No because we don't want every timer to be enabled always. Only if a certain branch of code is run (for example we only want to add PDB timers if /DEBUG is specified)

[rnk]

I'd suggest putting this under MSVC's /TIME flag: https://cs.chromium.org/chromium/src/build/config/win/BUILD.gn?type=cs&q=win_linker_timing&sq=package:chromium&l=281

It would then naturally work in Chrome builds that set the win_linker_timing=true gn args.

[zturner]

More fixes as suggested by rui

[zturner]

lld/Common/Timer.cpp

81–88

This isn't quite the same. printf right justifies %30s, I want it left justified. I also don't want it left justified to 30, because the indentation would have changed that. I think it's easier to just explicitly pad on the left and pad on the right.

[ruiu]

lld/COFF/Driver.cpp

51

But I don't think we need a separate flag. It seems you can show timing information only when a timer has non-zero time duration (which means the timer has activated and deactivated).

lld/COFF/PDB.cpp

994

T1 and T2?

lld/Common/Timer.cpp

81–88

std::string S = (std::string(' ', Depth * 2) + Name).str();

indents the string, no?

[zturner]

lld/COFF/Driver.cpp

51

That's an option, but would there be issues if we use a "Parent" that is defined in another translation unit. The child will call parent->Children.add(*this). Can we guarantee that the Parent has been constructed at that point? I always forget when it's safe for one global variable to use another. If we have to introduce ManagedStatic or something then I think it just makes the code more complicated.

lld/Common/Timer.cpp

81–88

Yes, but then the %30s is no longer correct, because some of the 30 has been consumed by the Depth*2 characters on the left. The point is that after indenting, the field width is no longer a constant. That said, I think this code is pretty simple already no?

[ruiu]

lld/COFF/Driver.cpp

51

Good point, but you could add a timer to its parent not when the constructor is executed but when it's start()'ed.

lld/Common/Timer.cpp

81–88

Aah, sorry I misunderstood the issue. Can't you use '% -30s'? It left-justifies the string.

[zturner]

lld/COFF/Driver.cpp

51

We might start and stop it many times though (we already do this in PDB.cpp with TypeMergingTimer, for example). So if we do it that way we'd need to make sure it hasn't already been added, at which point we have to use a map of some kind instead of a simple vector.

lld/Common/Timer.cpp

81–88

If we append the spaces first to construct a temporary string then that should work, but that results in some extra copies. I don't think it would result in shorter or fewer lines of code either.

[ruiu]

lld/COFF/Driver.cpp

51

I don't think we need a map. A timer can add itself to a parent timer first time start() is called -- which is when the timer duration is zero.

lld/Common/Timer.cpp

81–88

Creating extra copies is fine -- it's very small amount of data, and

std::string S = (std::string(' ', Depth * 2) + Name + ":").str();
Stream << format("% -30s (%6.2f%%) %5d ms", S, 100 * millis() / TotalDuration, (int)millis());

is apparently shorter than 8 lines of code.

[zturner]

lld/COFF/Driver.cpp

51

Currently a timer does not store a pointer to its parent. In order to do this it would have to store that. Should I make that change?

[ruiu]

lld/COFF/Driver.cpp

51

Good point, and I'm almost convinced, but I'd think we still want it. The current API is easy to misuse. I think you forgot to call addChildTimer for LTOTimer.

[zturner]

Fix remaining issues.

[ruiu]

Overall looking pretty good.

lld/COFF/Driver.cpp

51

Ah, this is a very nice way to force some initialization order. Thank you for doing this.

lld/include/lld/Common/Timer.h

36–42

Please move private members after public members.

38

I'd use std::vector when we do not have to optimize for speed.

42

This constructor is used only by root(), so I'd make this private to prevent misuse of this constructor.

45

It looks like ScopedTimer accesses only public functions of this class.

[ruiu]

I tried to run this patch and found that printing out the timer tree as a tree like this

Total Link Time:              (100.00%)  6470 ms
  Input File Reading:         (  0.00%)     0 ms
  ICF:                        (  0.00%)     0 ms
  GC:                         (  0.00%)     0 ms
  LTO:                        (  0.00%)     0 ms
  Code Layout:                (  0.00%)     0 ms
  Commit Output File:         (  0.00%)     0 ms
  PDB Emission (Cumulative):  (  0.00%)     0 ms
    Add Objects:              (  0.00%)     0 ms
      Type Merging:           (  0.00%)     0 ms
      Symbol Merging:         (  0.00%)     0 ms
  ...

is more natural than the current format

  Input File Reading:         (  0.00%)     0 ms
  ICF:                        (  0.00%)     0 ms
  GC:                         (  0.00%)     0 ms
  LTO:                        (  0.00%)     0 ms
  Code Layout:                (  0.00%)     0 ms
  Commit Output File:         (  0.00%)     0 ms
  PDB Emission (Cumulative):  (  0.00%)     0 ms
    Add Objects:              (  0.00%)     0 ms
      Type Merging:           (  0.00%)     0 ms
      Symbol Merging:         (  0.00%)     0 ms
  ...
-------------------------------------------------
Total Link Time:              (100.00%)  6470 ms

which handles only the root timer in a special way because the former represents a tree as-is. Do you mind if I ask you to change the format?

[ruiu]

I didn't notice until I actually tried to use this, but showing only the total in the reverse order actually confused me about how to interpret the "Total" after the separator "-------------". Turned out that the the last line after the hyphen line is a continuation of the previous lines, but that wasn't very intuitive to me.

Also, this order looks a bit odd to me

PDB Emission (Cumulative): ( 96.03%) 15969 ms

because parenthesized number describes not the following but the preceding number. I feel

PDB Emission (Cumulative): 15969 ms ( 96.03%)

is more natural.

The other point I noticed is that we probably need only one digit after the decimal point for the percentage number. We truncate duration to milliseconds, and compared to that, showing two digits after the decimal point is disproportionally precise for the percentage.

[zturner]

Reversed the order of the time and the percentage, and formatted the percentage with only 1 decimal.

[ruiu]

LGTM with these changes.

Please update the commit message as it no longer depends on /VERBOSE.

lld/include/lld/Common/Timer.h

36

Move private members after public members.

38

Please use std::vector.

42

Make this private.

45

Please remove friend. I believe this file compiles without it.

[ruiu]

It seems it is still showing the total timer at the end. Can you fix it?

[takuto.ikuta]

Common/Timer.cpp

1 ↗

(On Diff #130227)

Do you forget adding LICENSE statement in this file?

lld/COFF/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_CONFIG_H
 #define LLD_COFF_CONFIG_H
 
+#include "lld/Common/Timer.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/CachePruning.h"
 #include <cstdint>
 #include <map>
 #include <set>
 #include <string>
 
struct Configuration {
   std::string ImportName;
   bool DoGC = true;
   bool DoICF = true;
   bool Relocatable = true;
   bool Force = false;
   bool Debug = false;
   bool DebugDwarf = false;
   bool DebugGHashes = false;
+  bool ShowTiming = false;
   unsigned DebugTypes = static_cast<unsigned>(DebugType::None);
   llvm::SmallString<128> PDBPath;
+
   std::vector<llvm::StringRef> Argv;
 
   // Symbols in this set are considered as live by the garbage collector.
   std::vector<Symbol *> GCRoot;
 
   std::set<StringRef> NoDefaultLibs;
   bool NoDefaultLibAll = false;
 
   // True if we are creating a DLL.
   bool DLL = false;
   StringRef Implib;
   std::vector<Export> Exports;
   std::set<std::string> DelayLoads;
   std::map<std::string, int> DLLOrder;
   Symbol *DelayLoadHelper = nullptr;
 
   bool SaveTemps = false;
 
   // Used for SafeSEH.
   Symbol *SEHTable = nullptr;
   Symbol *SEHCount = nullptr;
 
   // Used for /opt:lldlto=N
   unsigned LTOOptLevel = 2;
struct Configuration {
   std::map<StringRef, StringRef> MustMatch;
 
   // Used for /alternatename.
   std::map<StringRef, StringRef> AlternateNames;
 
   // Used for /lldmap.
   std::string MapFile;
 
+  // Used for /showtiming
+  Timer Metrics;
+
   uint64_t ImageBase = -1;
   uint64_t StackReserve = 1024 * 1024;
   uint64_t StackCommit = 4096;
   uint64_t HeapReserve = 1024 * 1024;
   uint64_t HeapCommit = 4096;
   uint32_t MajorImageVersion = 0;
   uint32_t MinorImageVersion = 0;
   uint32_t MajorOSVersion = 6;

lld/COFF/Driver.cpp

 //===- Driver.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Config.h"
 #include "InputFiles.h"
 #include "MinGW.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
+#include "Timing.h"
 #include "Writer.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/Magic.h"

 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::COFF;
 using llvm::sys::Process;
 
 namespace lld {
 namespace coff {
 
 Configuration *Config;
 LinkerDriver *Driver;
 
 bool link(ArrayRef<const char *> Args, bool CanExitEarly, raw_ostream &Diag) {
   errorHandler().LogName = Args[0];
   errorHandler().ErrorOS = &Diag;
   errorHandler().ColorDiagnostics = Diag.has_colors();
   errorHandler().ErrorLimitExceededMsg =
       "too many errors emitted, stopping now"
for (StringRef Path : Temps)
     sys::fs::remove(Path);
 }
 
 void LinkerDriver::enqueueTask(std::function<void()> Task) {
   TaskQueue.push_back(std::move(Task));
 }
 
 bool LinkerDriver::run() {
+  Timer::TimerPhaseRAII Timer =
+      Config->Metrics.startPhaseRAII(TP_InputFileReading);
+
   bool DidWork = !TaskQueue.empty();
   while (!TaskQueue.empty()) {
     TaskQueue.front()();
     TaskQueue.pop_front();
   }
   return DidWork;
 }
 
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   }
 
   // Handle /help
   if (Args.hasArg(OPT_help)) {
     printHelp(ArgsArr[0]);
     return;
   }
 
+  if (Args.hasArg(OPT_show_timing)) {
+    Config->ShowTiming = true;
+    Config->Metrics.addPhase("Input File Reading", TP_InputFileReading);
+  }
+  Config->Metrics.enable(Config->ShowTiming);
+  Config->Metrics.startPhase(TP_Total);
+
   // Handle --version, which is an lld extension. This option is a bit odd
   // because it doesn't start with "/", but we deliberately chose "--" to
   // avoid conflict with /version and for compatibility with clang-cl.
   if (Args.hasArg(OPT_dash_dash_version)) {
     outs() << getLLDVersion() << "\n";
     return;
   }
 
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   if (Args.hasArg(OPT_debug, OPT_debug_dwarf, OPT_debug_ghash)) {
     Config->Debug = true;
     if (auto *Arg = Args.getLastArg(OPT_debugtype))
       Config->DebugTypes = parseDebugType(Arg->getValue());
     else
       Config->DebugTypes = getDefaultDebugType(Args);
   }
 
   // Handle /pdb
   bool ShouldCreatePDB = Args.hasArg(OPT_debug, OPT_debug_ghash);
   if (ShouldCreatePDB)
     if (auto *Arg = Args.getLastArg(OPT_pdb))
       Config->PDBPath = Arg->getValue();
 
   // Handle /noentry
   if (Args.hasArg(OPT_noentry)) {
     if (Args.hasArg(OPT_dll))
       Config->NoEntry = true;
     else
for (StringRef S : Vec) {
         DoGC = true;
       } else if (S == "noref") {
         DoGC = false;
       } else if (S == "icf" || S.startswith("icf=")) {
         ICFLevel = 2;
       } else if (S == "noicf") {
         ICFLevel = 0;
       } else if (S.startswith("lldlto=")) {
         StringRef OptLevel = S.substr(7);
         if (OptLevel.getAsInteger(10, Config->LTOOptLevel) ||
             Config->LTOOptLevel > 3)
           error("/opt:lldlto: invalid optimization level: " + OptLevel);
       } else if (S.startswith("lldltojobs=")) {
         StringRef Jobs = S.substr(11);
         if (Jobs.getAsInteger(10, Config->LTOJobs) || Config->LTOJobs == 0)
           error("/opt:lldltojobs: invalid job count: " + Jobs);
       } else if (S.startswith("lldltopartitions=")) {
for (auto Pair : Config->AlignComm) {
     C->Alignment = std::max(C->Alignment, Alignment);
   }
 
   // Windows specific -- Create a side-by-side manifest file.
   if (Config->Manifest == Configuration::SideBySide)
     createSideBySideManifest();
 
   // Identify unreferenced COMDAT sections.
-  if (Config->DoGC)
+  if (Config->DoGC) {
+    Config->Metrics.addPhase("GC", TP_GC);
     markLive(Symtab->getChunks());
+  }
 
   // Identify identical COMDAT sections to merge them.
-  if (Config->DoICF)
+  if (Config->DoICF) {
+    Config->Metrics.addPhase("ICF", TP_ICF);
     doICF(Symtab->getChunks());
+  }
 
   // Write the result.
   writeResult();
+
+  Config->Metrics.stopPhase(TP_Total);
+  Config->Metrics.print();
 }
 
 } // namespace coff
 } // namespace lld

lld/COFF/ICF.cpp

 // On Windows, ICF is enabled by default.
 //
 // See ELF/ICF.cpp for the details about the algortihm.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Chunks.h"
 #include "Symbols.h"
+#include "Timing.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <atomic>
 #include <vector>
void ICF::forEachClass(std::function<void(size_t, size_t)> Fn) {
   });
   ++Cnt;
 }
 
 // Merge identical COMDAT sections.
 // Two sections are considered the same if their section headers,
 // contents and relocations are all the same.
 void ICF::run(ArrayRef<Chunk *> Vec) {
+  Timer::TimerPhaseRAII Timer = Config->Metrics.startPhaseRAII(TP_ICF);
+
   // Collect only mergeable sections and group by hash value.
   uint32_t NextId = 1;
   for (Chunk *C : Vec) {
     if (auto *SC = dyn_cast<SectionChunk>(C)) {
       if (isEligible(SC))
         Chunks.push_back(SC);
       else
         SC->Class[0] = NextId++;

lld/COFF/MarkLive.cpp

 //===- MarkLive.cpp -------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Chunks.h"
 #include "Symbols.h"
+#include "Timing.h"
 #include "llvm/ADT/STLExtras.h"
 #include <vector>
 
 namespace lld {
 namespace coff {
 
 // Set live bit on for each reachable chunk. Unmarked (unreachable)
 // COMDAT chunks will be ignored by Writer, so they will be excluded
 // from the final output.
 void markLive(ArrayRef<Chunk *> Chunks) {
+  Timer::TimerPhaseRAII Timer = Config->Metrics.startPhaseRAII(TP_GC);
+
   // We build up a worklist of sections which have been marked as live. We only
   // push into the worklist when we discover an unmarked section, and we mark
   // as we push, so sections never appear twice in the list.
   SmallVector<SectionChunk *, 256> Worklist;
 
   // COMDAT section chunks are dead by default. Add non-COMDAT chunks.
   for (Chunk *C : Chunks)
     if (auto *SC = dyn_cast<SectionChunk>(C))

lld/COFF/Options.td

 def rsp_quoting : Joined<["--"], "rsp-quoting=">,
   HelpText<"Quoting style for response files, 'windows' (default) or 'posix'">;
 def dash_dash_version : Flag<["--"], "version">,
   HelpText<"Print version information">;
 
 // Flags for debugging
 def lldmap : F<"lldmap">;
 def lldmap_file : Joined<["/", "-"], "lldmap:">;
+def show_timing : F<"showtiming">;
 
 //==============================================================================
 // The flags below do nothing. They are defined only for link.exe compatibility.
 //==============================================================================
 
 class QF<string name> : Joined<["/", "-", "-?"], name#":">;
 
 multiclass QB<string name> {

lld/COFF/PDB.cpp

 //===- PDB.cpp ------------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PDB.h"
 #include "Chunks.h"
 #include "Config.h"
 #include "Driver.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
+#include "Timing.h"
 #include "Writer.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Timer.h"
 #include "llvm/DebugInfo/CodeView/CVDebugRecord.h"
 #include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/RecordName.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
maybeReadTypeServerRecord(CVTypeArray &Types) {
   TypeServer2Record TS;
   if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(Type), TS))
     fatal("error reading type server record: " + toString(std::move(EC)));
   return std::move(TS);
 }
 
 const CVIndexMap &PDBLinker::mergeDebugT(ObjFile *File,
                                          CVIndexMap &ObjectIndexMap) {
+  Timer::TimerPhaseRAII TypeMergingTimer =
+      Config->Metrics.startPhaseRAII(TP_PdbTypeMerging);
+
   ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
   if (Data.empty())
     return ObjectIndexMap;
 
   BinaryByteStream Stream(Data, support::little);
   CVTypeArray Types;
   BinaryStreamReader Reader(Stream);
   if (auto EC = Reader.readArray(Types, Reader.getLength()))
void PDBLinker::addObjFile(ObjFile *File) {
 
   // Before we can process symbol substreams from .debug$S, we need to process
   // type information, file checksums, and the string table.  Add type info to
   // the PDB first, so that we can get the map from object file type and item
   // indices to PDB type and item indices.
   CVIndexMap ObjectIndexMap;
   const CVIndexMap &IndexMap = mergeDebugT(File, ObjectIndexMap);
 
+  Timer::TimerPhaseRAII SymbolTimer =
+      Config->Metrics.startPhaseRAII(TP_PdbSymbolMerging);
+
   // Now do all live .debug$S sections.
   DebugStringTableSubsectionRef CVStrTab;
   DebugChecksumsSubsectionRef Checksums;
   std::vector<ulittle32_t *> StringTableReferences;
   for (SectionChunk *DebugChunk : File->getDebugChunks()) {
     if (!DebugChunk->isLive() || DebugChunk->getSectionName() != ".debug$S")
       continue;
 
static PublicSym32 createPublic(Defined *Def) {
   Pub.Offset = Def->getRVA() - OS->getRVA();
   Pub.Segment = OS->SectionIndex;
   return Pub;
 }
 
 // Add all object files to the PDB. Merge .debug$T sections into IpiData and
 // TpiData.
 void PDBLinker::addObjectsToPDB() {
+  Config->Metrics.startPhase(TP_PdbAddObjects);
   for (ObjFile *File : ObjFile::Instances)
     addObjFile(File);
 
   Builder.getStringTableBuilder().setStrings(PDBStrTab);
+  Config->Metrics.stopPhase(TP_PdbAddObjects);
 
   // Construct TPI and IPI stream contents.
+  Config->Metrics.startPhase(TP_PdbTpiConstruction);
   if (Config->DebugGHashes) {
     addTypeInfo(Builder.getTpiBuilder(), GlobalTypeTable);
     addTypeInfo(Builder.getIpiBuilder(), GlobalIDTable);
   } else {
     addTypeInfo(Builder.getTpiBuilder(), TypeTable);
     addTypeInfo(Builder.getIpiBuilder(), IDTable);
   }
+  Config->Metrics.stopPhase(TP_PdbTpiConstruction);
+
+  Timer::TimerPhaseRAII PublicsTimer =
+      Config->Metrics.startPhaseRAII(TP_PdbPublicsConstruction);
 
   // Compute the public and global symbols.
   auto &GsiBuilder = Builder.getGsiBuilder();
   std::vector<PublicSym32> Publics;
   Symtab->forEachSymbol([&Publics](Symbol *S) {
     // Only emit defined, live symbols that have a chunk.
     auto *Def = dyn_cast<Defined>(S);
     if (Def && Def->isLive() && Def->getChunk())
Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       Sym, Allocator, CodeViewContainer::Pdb));
 }
 
 // Creates a PDB file.
 void coff::createPDB(SymbolTable *Symtab,
                      ArrayRef<OutputSection *> OutputSections,
                      ArrayRef<uint8_t> SectionTable,
                      const llvm::codeview::DebugInfo &BuildId) {
+  Config->Metrics.addPhase("PDB Emission (Cumulative)", TP_PdbLinkTotal);
+  Config->Metrics.addPhase("Add Objects", TP_PdbAddObjects, TP_PdbLinkTotal);
+
+  Config->Metrics.addPhase("Globals Stream Layout", TP_PdbPublicsConstruction,
+                           TP_PdbLinkTotal);
+  Config->Metrics.addPhase("TPI Stream Layout", TP_PdbTpiConstruction,
+                           TP_PdbLinkTotal);
+  Config->Metrics.addPhase("Type Merging", TP_PdbTypeMerging, TP_PdbAddObjects);
+  Config->Metrics.addPhase("Symbol Merging", TP_PdbSymbolMerging,
+                           TP_PdbAddObjects);
+  Config->Metrics.addPhase("Commit to Disk", TP_PdbDiskCommit, TP_PdbLinkTotal);
+
+  Timer::TimerPhaseRAII TotalTimer =
+      Config->Metrics.startPhaseRAII(TP_PdbLinkTotal);
+
   PDBLinker PDB(Symtab);
   PDB.initialize(BuildId);
   PDB.addObjectsToPDB();
   PDB.addSections(OutputSections, SectionTable);
+
+  Timer::TimerPhaseRAII CommitTimer =
+      Config->Metrics.startPhaseRAII(TP_PdbDiskCommit);
+
   PDB.commit();
 }
 
 void PDBLinker::initialize(const llvm::codeview::DebugInfo &BuildId) {
   ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
 
   // Create streams in MSF for predefined streams, namely
   // PDB, TPI, DBI and IPI.
   for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I)
     ExitOnErr(Builder.getMsfBuilder().addStream(0));
 
   // Add an Info stream.

lld/COFF/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "Driver.h"
 #include "LTO.h"
 #include "Symbols.h"
+#include "Timing.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>
 
 using namespace llvm;
std::vector<StringRef> SymbolTable::compileBitcodeFiles() {
   for (BitcodeFile *F : BitcodeFile::Instances)
     LTO->add(*F);
   return LTO->compile();
 }
 
 void SymbolTable::addCombinedLTOObjects() {
   if (BitcodeFile::Instances.empty())
     return;
+
+  Config->Metrics.addPhase("LTO", TP_LTO);
+
+  Timer::TimerPhaseRAII Timer = Config->Metrics.startPhaseRAII(TP_LTO);
   for (StringRef Object : compileBitcodeFiles()) {
     auto *Obj = make<ObjFile>(MemoryBufferRef(Object, "lto.tmp"));
     Obj->parse();
     ObjFile::Instances.push_back(Obj);
   }
 }
 
 } // namespace coff
 } // namespace lld

lld/COFF/Timing.h

+//===- Timing.h -------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_TIMING_H
+#define LLD_COFF_TIMING_H
+
+#include "lld/Common/Timer.h"
+
+namespace lld {
+namespace coff {
+enum TimingPhases {
+  TP_Total,
+
+  TP_InputFileReading,
+  TP_ImportLibrary,
+  TP_ICF,
+  TP_GC,
+  TP_LTO,
+  TP_CodeLayout,
+  TP_CodeDiskCommit,
+
+  TP_PdbLinkTotal,
+  TP_PdbPublicsConstruction,
+  TP_PdbTpiConstruction,
+  TP_PdbAddObjects,
+  TP_PdbTypeMerging,
+  TP_PdbSymbolMerging,
+  TP_PdbDiskCommit,
+
+  TP_Max,
+};
+}
+} // namespace lld
+
+#endif

lld/COFF/Writer.h

 //===- Writer.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_WRITER_H
 #define LLD_COFF_WRITER_H
 
 #include "Chunks.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/COFF.h"
+#include <chrono>
 #include <cstdint>
 #include <vector>
 
 namespace lld {
 namespace coff {
 static const int PageSize = 4096;
 
 void writeResult();

lld/COFF/Writer.cpp

 #include "Writer.h"
 #include "Config.h"
 #include "DLL.h"
 #include "InputFiles.h"
 #include "MapFile.h"
 #include "PDB.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
+#include "Timing.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
for (const auto &DebugDir : File.debug_directories()) {
     // id that we recognize / support, ignore it.
     if (ExistingDI->Signature.CVSignature != OMF::Signature::PDB70)
       return None;
     return *ExistingDI;
   }
   return None;
 }
 
 // The main function of the writer.
 void Writer::run() {
+  Config->Metrics.addPhase("Code Layout", TP_CodeLayout);
+  Config->Metrics.addPhase("Commit Output File", TP_CodeDiskCommit);
+
+  Config->Metrics.startPhase(TP_CodeLayout);
+
   createSections();
   createMiscChunks();
   createImportTables();
   createExportTable();
   if (Config->Relocatable)
     createSection(".reloc");
   assignAddresses();
   removeEmptySections();
   setSectionPermissions();
   createSymbolAndStringTable();
 
   // We must do this before opening the output file, as it depends on being able
   // to read the contents of the existing output file.
   PreviousBuildId = loadExistingBuildId(Config->OutputFile);
   openFile(Config->OutputFile);
   if (Config->is64()) {
     writeHeader<pe32plus_header>();
   } else {
     writeHeader<pe32_header>();
   }
   writeSections();
   sortExceptionTable();
   writeBuildId();
 
-  if (!Config->PDBPath.empty() && Config->Debug) {
+  Config->Metrics.stopPhase(TP_CodeLayout);
 
+  if (!Config->PDBPath.empty() && Config->Debug) {
     assert(BuildId);
     createPDB(Symtab, OutputSections, SectionTable, *BuildId->BuildId);
   }
 
   writeMapFile(OutputSections);
 
+  Config->Metrics.startPhase(TP_CodeDiskCommit);
   if (auto E = Buffer->commit())
     fatal("failed to write the output file: " + toString(std::move(E)));
+  Config->Metrics.stopPhase(TP_CodeDiskCommit);
 }
 
 static StringRef getOutputSection(StringRef Name) {
   StringRef S = Name.split('$').first;
 
   // Treat a later period as a separator for MinGW, for sections like
   // ".ctors.01234".
   S = S.substr(0, S.find('.', 1));

lld/Common/CMakeLists.txt

 if(NOT LLD_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lld_library(lldCommon
   Args.cpp
   ErrorHandler.cpp
   Memory.cpp
   Reproduce.cpp
   Strings.cpp
   TargetOptionsCommandFlags.cpp
   Threads.cpp
+  Timer.cpp
   Version.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLD_INCLUDE_DIR}/lld/Common
 
   LINK_COMPONENTS
   Codegen
   Core

lld/Common/Timer.cpp

+#include "lld/Common/Timer.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/Support/FormatAdapters.h"
+#include "llvm/Support/FormatVariadic.h"
+
+using namespace lld;
+using namespace llvm;
+
+void Timer::TimerPhase::start() {
+  StartTime = std::chrono::high_resolution_clock::now();
+}
+
+void Timer::TimerPhase::stop() {
+  auto EndTime = std::chrono::high_resolution_clock::now();
+  Total += (EndTime - StartTime);
+}
+
+float Timer::TimerPhase::millis() const {
+  return std::chrono::duration_cast<std::chrono::duration<float, std::milli>>(
+             Total)
+      .count();
+}
+
+void Timer::TimerPhase::print(int Depth, int NameWidth, int Digits,
+                              float TotalDuration, bool Recurse) const {
+
+  float P = 100.0f * millis() / TotalDuration;
+
+  int LI = Depth * 2;                        // left indent
+  int RI = NameWidth - Name.size() - 1 - LI; // right indent
+
+  // Output line format is:
+  // <indent>name:<padding for alignment>
+  message(formatv("{0}({1,+6}%) {2:ms}",
+                  fmt_pad(Name + ":", LI, RI), // <indent>name:<padding>
+                  P,                           // (AAA.BB%)
+                  fmt_align(Total, AlignStyle::Right, Digits + 3))); // ABCD ns
+
+  if (Recurse) {
+    for (const auto &Child : ChildrenPhases)
+      Child.second->print(Depth + 1, NameWidth, Digits, TotalDuration);
+  }
+}
+
+Timer::Timer() {
+  RootPhase.Name = "Total Link Time";
+  AllPhases.insert(std::make_pair(0, &RootPhase));
+}
+
+Timer::~Timer() {}
+
+void Timer::addPhase(StringRef Name, int Code, TimerPhase &Parent) {
+  assert(Parent.ChildrenPhases.count(Code) == 0 && "Phase already exists!");
+  auto NewPhase = make_unique<TimerPhase>();
+  NewPhase->Name = Name;
+
+  AllPhases.insert(std::make_pair(Code, NewPhase.get()));
+  Parent.ChildrenPhases.insert(std::make_pair(Code, std::move(NewPhase)));
+}
+
+/// Add a link phase using the specified unique code.  You can start and stop
+/// time counting for this phase by calling startPhase(Code) or
+/// stopPhase(Code).
+void Timer::addPhase(StringRef Name, int Code) {
+  assert(AllPhases.count(Code) == 0 && "Phase already exists!");
+  addPhase(Name, Code, RootPhase);
+}
+
+/// Add a link phase using the specified code, indicating that this phase is
+/// a child of another phase.  Child phases will be printed under their
+/// parent phases, and indented to visually indicate that it is a child.
+void Timer::addPhase(StringRef Name, int Code, int Parent) {
+  assert(AllPhases.count(Parent) == 1 && "Parent phase doesn't exist!");
+
+  TimerPhase *ParentPtr = AllPhases[Parent];
+  addPhase(Name, Code, *ParentPtr);
+}
+
+void Timer::startPhase(int Code) {
+  if (!EnableTiming)
+    return;
+
+  assert(AllPhases.count(Code) == 1 && "Can't start phase that doesn't exist!");
+  AllPhases[Code]->start();
+}
+
+void Timer::stopPhase(int Code) {
+  if (!EnableTiming)
+    return;
+
+  assert(AllPhases.count(Code) == 1 && "Can't stop phase that doesn't exist!");
+  AllPhases[Code]->stop();
+}
+
+Timer::TimerPhaseRAII Timer::startPhaseRAII(int Code) {
+  if (!EnableTiming)
+    return {};
+
+  assert(AllPhases.count(Code) == 1 && "Can't start phase that doesn't exist!");
+  return TimerPhaseRAII(*AllPhases[Code]);
+}
+
+int Timer::calculateNameFieldWidth(int Depth, const TimerPhase &Phase) const {
+  // indentation, then name, then a colon and a space.
+  int MaxLen = 2 * Depth + Phase.Name.size() + 2;
+  for (const auto &Child : Phase.ChildrenPhases)
+    MaxLen =
+        std::max(MaxLen, calculateNameFieldWidth(Depth + 1, *Child.second));
+  return MaxLen;
+}
+
+void Timer::print() const {
+  if (!EnableTiming)
+    return;
+
+  float TotalDuration = static_cast<float>(RootPhase.millis());
+  int Digits = std::ceil(std::log10f(TotalDuration));
+
+  // We want to print the grand total under all the intermediate phases, so we
+  // special case this by printing all children first, rather than just
+  // immediately calling RootPhase.print()
+  int NameWidth = calculateNameFieldWidth(0, RootPhase);
+  for (const auto &Child : RootPhase.ChildrenPhases) {
+    Child.second->print(1, NameWidth, Digits, TotalDuration);
+  }
+
+  int RowLength = NameWidth + 11 + Digits + 3; // <Name> ( AB.CD%) <Digits> ms
+  message(formatv("{0}", fmt_repeat("-", RowLength)));
+
+  RootPhase.print(0, NameWidth, Digits, RootPhase.millis(), false);
+}

lld/include/lld/Common/Timer.h

+//===- Timer.h ----------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COMMON_TIMER_H
+#define LLD_COMMON_TIMER_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringRef.h"
+#include <assert.h>
+#include <chrono>
+#include <map>
+#include <memory>
+
+namespace lld {
+
+/// Provides a way to time various phases of the linker.  The set of phases to
+/// be timed is dynamic, so that for example you can add phases as necessary
+/// based on the command line options given.  Phases can have sub-phases, so
+/// that a large operation (for example linking of a PDB file) can show total
+/// time but still be broken down into the individual steps of PDB linking.
+/// Note that the timer does *not* automatically accumulate the duration of
+/// child phases to compute the duration of a parent phase.  All accounting is
+/// manual.  The separation of child / parent phases is purely for aesthetic
+/// reasons in the formatted output.
+/// All phases must be added at runtime using a unique code, with the exception
+/// of the root phase, which always has Code 0.
+class Timer {
+  struct TimerPhase {
+    void start();
+    void stop();
+    void print(int Depth, int NameWidth, int Digits, float TotalDuration,
+               bool Recurse = true) const;
+
+    float millis() const;
+    std::chrono::time_point<std::chrono::high_resolution_clock> StartTime;
+    std::chrono::nanoseconds Total;
+    std::map<int, std::unique_ptr<TimerPhase>> ChildrenPhases;
+    std::string Name;
+  };
+
+  bool EnableTiming = false;
+  llvm::DenseMap<int, TimerPhase *> AllPhases;
+  TimerPhase RootPhase;
+
+  int calculateNameFieldWidth(int Depth, const TimerPhase &Parent) const;
+  void addPhase(llvm::StringRef Name, int Code, TimerPhase &Parent);
+
+public:
+  struct TimerPhaseRAII {
+    TimerPhaseRAII() = default;
+
+    explicit TimerPhaseRAII(TimerPhase &T) : T(&T) { T.start(); }
+
+    ~TimerPhaseRAII() {
+      if (T)
+        T->stop();
+    }
+
+    TimerPhase *T = nullptr;
+  };
+
+  Timer();
+  ~Timer();
+
+  void enable(bool Enable) { EnableTiming = Enable; }
+
+  /// Add a link phase using the specified unique code.  You can start and stop
+  /// time counting for this phase by calling startPhase(Code) or
+  /// stopPhase(Code).
+  void addPhase(llvm::StringRef Name, int Code);
+
+  /// Add a link phase using the specified code, indicating that this phase is
+  /// a child of another phase.  Child phases will be printed under their
+  /// parent phases, and indented to visually indicate that it is a child.
+  void addPhase(llvm::StringRef Name, int Code, int Parent);
+
+  void startPhase(int Code);
+  void stopPhase(int Code);
+  TimerPhaseRAII startPhaseRAII(int Code);
+
+  /// Print all timing information.  Phases will be printed in numerical order
+  /// by their code, with child phases always appearing directly under (and
+  /// indented from) parent phases.
+  void print() const;
+};
+
+} // namespace lld
+
+#endif