[LLD][ELF] Add time-trace to ELF LLD (2/2)

[russell.gallop]

Summary

Following on from RFC here: https://reviews.llvm.org/D69043

This requires the previous patch: https://reviews.llvm.org/D71059

This adds some LLD specific scopes and picks up optimisation scopes via LTO/ThinLTO. This makes use of the TimeProfiler multi-thread support added in first in this series.

[russell.gallop]

Add tests to patch.

[ruiu]

lld/ELF/Driver.cpp

552

I think it is better to make -time-trace to just print the result to stdout, as it is convenient.

983

Is u prefix supported?

edit: Oh, this is not for nanosecond but just an unsigned. I'd just remove u.

1627

I'm curious what is supposed to pass as a second argument.

[russell.gallop]

lld/ELF/Driver.cpp

552

Hmm, I went for this as it was more consistent with the comparable compiler option.

I do find this behaviour useful if you are tracing a build such as llvm which has a lot of links. While this probably isn't typical, it does make it easy to send all of the link traces to separate files just by adding a single link option to all links.

What about an option like "-ftime-trace -" to send to stdout?

983

Thanks. Will fix.

1627

This is used for "Detail". E.g. optimisation passes specify which pass they are running on "OptModule" specifies which module it is running on. This helps to distinguish multiples of the same kind of scope in traces. I don't think there is anything useful to detail at this level.

I could add an overloaded constructor to TimeTraceScope with a default to not add "detail". That would cut down on the StringRef("") argument which come up quite a bit. It could also cut down on file size by not writing that block out.

[russell.gallop]

Here are some examples of the output from LLD. One for a llvm-tblgen ThinLTO link (-time-trace-granularity=50000) and a clang Release build (-time-trace-granularity=500). The clang link has some significant gaps in it. I'll see if I can identify where they're from and trace them.

llvm-tblgen.json52 KBDownload

clang-10.json1 KBDownload

[russell.gallop]

lld/ELF/Driver.cpp

1627

Created new review for TimeTraceScope constructor to avoid the need for StringRef("") in places like this: https://reviews.llvm.org/D71347

[russell.gallop]

Removed StringRef("") in several places after D71347.
Added some more time scopes to account for gaps in time trace.
Updated tests for args/detail not always being present.

[ruiu]

lld/ELF/Driver.cpp

552

Yeah that makes sense, but I think that ".json" extension is the problem. We may want to add a different feature that outputs some data in the JSON format, and if we choose the same design, the option will conflict with the feature that you are adding. How about adding ".time-trace" to an output file then? Also, I don't think we should replace an extension -- usually Unix commands don't have extensions. I'd just append ".time-trace"

lld/ELF/Options.td

361–362

I think that giving two options the same name isn't very conventional as a Unix command, as --foo bar and --foo=bar are usually considered the same option. Could you rename the latter --time-trace-file?

[ruiu]

In D71060#1779463, @russell.gallop wrote:

Here are some examples of the output from LLD. One for a llvm-tblgen ThinLTO link (-time-trace-granularity=50000) and a clang Release build (-time-trace-granularity=500). The clang link has some significant gaps in it. I'll see if I can identify where they're from and trace them.

llvm-tblgen.json52 KBDownload

clang-10.json1 KBDownload

These JSON outputs look nice! One feature request -- is there any way to add a key-value to an output JSON file? I mean if we can add something like "argv": ["ld.lld", "-o", ...] to the JSON output it would be great. (You don't need to do that in this patch though.)

[russell.gallop]

Change to appending .time-trace as default name.
Make -time-trace-file a separate option
Use temp names in tests

[russell.gallop]

Add test for writing trace to stdout

[russell.gallop]

Thanks for the comments. I believe I've fixed them all now.

[ruiu]

lld/ELF/Driver.cpp

501

s/time trace/time trace profiler/

501–505

I'd move this above initLLVM() so that we can measure time consumed by createFiles and other functions.

Please remove llvm::.

550

Let's use the same condition if (config->timeTraceEnabled) as before for consistency.

550

Add a single line comment -- // Write the result of the time trace profiler.

553–554

You could simplify this a little bit as shown below:

std::string path = args.getLastArgValue(OPT_time_trace_file_eq);
if (path.empty())
  path = (config->outputFile + ".time-trace").str();

555–556

Let's use shorter conventional names: ec and os

562

What does this cleanup function do? If some cleanup is needed, can we run it on timeTraceProfilerWrite?

lld/ELF/ICF.cpp

529–532

This is the entry point function of ICF, so please move the TimeTraceScope here.

[MaskRay]

lld/ELF/Driver.cpp

556

OF_Text. F_Text is for compatibility only.

lld/test/ELF/check-time-trace.s

1 ↗

(On Diff #233635)

Just time-trace.s?

2 ↗

(On Diff #233635)

Delete -unknown-linux

23 ↗

(On Diff #233635)

Align keys. See other files (with a llvm-readobj RUN line) for examples

llvm/include/llvm/LTO/Config.h

120

Full stop

[russell.gallop]

Fix recent review comments.

[russell.gallop]

lld/ELF/Driver.cpp

562

Cleanup disables the profiler and deletes the data.

This is the design as from the original addition of the time profiler (https://reviews.llvm.org/D58675). I think it allows more flexibility (e.g. we may want to write a text report of the same data) though I don't think we use that flexibility at the moment. I'm not sure what the original reason for this was. @anton-afanasyev please can you comment on why this is and whether timeTraceProfilerCleanup could be combined with timeTraceProfilerWrite? Thanks.

[anton-afanasyev]

lld/ELF/Driver.cpp

562

Yes, that is for the flexibility in a future. We may want in follow-ups to support different Writers (for instance, to terminal). But you are right it could be combined with current Writer for now.

[anton-afanasyev]

lld/ELF/Driver.cpp

562

*I mean any kind of another output format, short summary for terminal, for instance.

[russell.gallop]

Fix to work with LLVM_ENABLE_THREADS=OFF. In this mode ThinLTO still uses tasks but need to avoid re-initialising the time profiler.

Requires https://reviews.llvm.org/D71548 to avoid thread_local in this mode.

[ruiu]

LGTM

lld/ELF/Driver.cpp

562

OK, I prefer merging the cleanup function with write function because (1) it's less error-prone, and (2) if you need to write a result to two different stream, you can easily do that by writing to a string buffer and then write the buffer contents to two streams. Do you mind if I ask you do that as a follow-up patch?

[MaskRay]

I have a general question about the llvm::TimeTraceScope timeScope("LTO"); trace sites. Shall we just use the container function name if applicable?

lld/ELF/Driver.cpp

2021

This comment may be misleading.

It creates MergeSyntheticSection's and does other tasks that cannot be summaries by "Merge input sections".

Probably delete the trace here. It shouldn't take a lot of time anyway.

lld/ELF/MarkLive.cpp

327

Probably just reuse the function name: markLive

[russell.gallop]

In D71060#1787251, @MaskRay wrote:

I have a general question about the llvm::TimeTraceScope timeScope("LTO"); trace sites. Shall we just use the container function name if applicable?

The clang --time-trace feature (https://aras-p.info/blog/2019/01/16/time-trace-timeline-flame-chart-profiler-for-Clang/) is intended to be helpful for users understanding what the tools are doing with their code, not (just) LLVM developers, and I think that this should have the same aim in LLD.

As such, I tried to add scopes that correspond to user visible features (e.g. LTO, GC, ICF), rather than the functions which implement them. In some places this can be tricky as scopes don't always correspond to notional blocks (e.g. clang Frontend). I would prefer to stick with the current names if possible, though there may be better places for them.

lld/ELF/Driver.cpp

2021

Okay, I'll remove this.

[russell.gallop]

Removed "Merge input sections" scope.
Also moved "ExecuteLinker" to cover longer time period, including initLLVM() etc..

[russell.gallop]

lld/ELF/Driver.cpp

562

Okay. I'll do that. Seems best as a follow up change as it will affect the time profiler usage in clang as well.

lld/ELF/MarkLive.cpp

327

As I mentioned above, I would like these to make sense to linker users. Is that okay?

Is there a better place to measure for GC?

[MaskRay]

For code blocks, using a descriptive name seems fine. For a trace added for a whole function, I still prefer using the function name as the trace point name. I think for users who are so familiar with the linker that they know the existence of --time-trace and will like to investigate the bottleneck, the function names should not impair their understanding of the pass names.

lld/ELF/Driver.cpp

1754

I'd prefer "LinkerDriver::link".

lld/ELF/MarkLive.cpp

327

This is the best place, though I still feel "GC" as the name is less ideal than the function name "markLive".

[russell.gallop]

Rename scopes as requested.

@MaskRay, thanks for the comments. Are you happy this is okay to commit now?

[anton-afanasyev]

lld/ELF/Driver.cpp

1754

Unified scope name like "Link" is good for grouping blocks by chrome://tracing app. Isn't it better to put "LinkerDriver::link" to Details field of timeScope? (though this field is usually used for _user_ source code names, but here it is unused).

[russell.gallop]

lld/ELF/Driver.cpp

1754

I'll put "LinkerDriver::link" in the Details field.

Longer term it might be better to add another "args" field for function name to distinguish compiler source code names and user source code names.

[dmajor]

Should this go into the docs / man page / release notes / etc.?

[russell.gallop]

In D71060#1867085, @dmajor wrote:

Should this go into the docs / man page / release notes / etc.?

Probably. I'll take a look.

[russell.gallop]

In D71060#1871814, @russell.gallop wrote:

In D71060#1867085, @dmajor wrote:

Should this go into the docs / man page / release notes / etc.?

Probably. I'll take a look.

Opened review here: https://reviews.llvm.org/D79780

lld/ELF/Config.h

struct Configuration {
   bool singleRoRx;
   bool shared;
   bool isStatic = false;
   bool sysvHash = false;
   bool target1Rel;
   bool trace;
   bool thinLTOEmitImportsFiles;
   bool thinLTOIndexOnly;
+  bool timeTraceEnabled;
   bool tocOptimize;
   bool undefinedVersion;
   bool useAndroidRelrTags = false;
   bool warnBackrefs;
   bool warnCommon;
   bool warnIfuncTextrel;
   bool warnMissingEntry;
   bool warnSymbolOrdering;
struct Configuration {
   uint64_t commonPageSize;
   uint64_t maxPageSize;
   uint64_t mipsGotSize;
   uint64_t zStackSize;
   unsigned ltoPartitions;
   unsigned ltoo;
   unsigned optimize;
   unsigned thinLTOJobs;
+  unsigned timeTraceGranularity;
   int32_t splitStackAdjustSize;
 
   // The following config options do not directly correspond to any
   // particular command line options.
 
   // True if we need to pass through relocations in input files to the
   // output file. Usually false because we consume relocations.
   bool copyRelocs;

lld/ELF/Driver.cpp

 #include "llvm/LTO/LTO.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys;
void LinkerDriver::main(ArrayRef<const char *> argsArr) {
 
   // The behavior of -v or --version is a bit strange, but this is
   // needed for compatibility with GNU linkers.
   if (args.hasArg(OPT_v) && !args.hasArg(OPT_INPUT))
     return;
   if (args.hasArg(OPT_version))
     return;
 
+  // Initialize time trace profiler.
+  if (config->timeTraceEnabled)
+    timeTraceProfilerInitialize(config->timeTraceGranularity, config->progName);
+
+  {
+    llvm::TimeTraceScope timeScope("ExecuteLinker");
+
     initLLVM();
     createFiles(args);
     if (errorCount())
       return;
 
     inferMachineType();
     setConfigs(args);
     checkOptions();
     if (errorCount())
       return;
 
     // The Target instance handles target-specific stuff, such as applying
     // relocations or writing a PLT section. It also contains target-dependent
     // values such as a default image base address.
     target = getTarget();
 
     switch (config->ekind) {
     case ELF32LEKind:
       link<ELF32LE>(args);
-    return;
+      break;
     case ELF32BEKind:
       link<ELF32BE>(args);
-    return;
+      break;
     case ELF64LEKind:
       link<ELF64LE>(args);
-    return;
+      break;
     case ELF64BEKind:
       link<ELF64BE>(args);
-    return;
+      break;
     default:
       llvm_unreachable("unknown Config->EKind");
     }
   }
 
+  if (config->timeTraceEnabled) {
+    // Write the result of the time trace profiler.
+    std::string path = args.getLastArgValue(OPT_time_trace_file_eq);
+    if (path.empty())
+      path = (config->outputFile + ".time-trace").str();
+    std::error_code ec;
+    raw_fd_ostream os(path, ec, sys::fs::OF_Text);
+    if (ec) {
+      error("cannot open " + path + ": " + ec.message());
+      return;
+    }
+    timeTraceProfilerWrite(os);
+    timeTraceProfilerCleanup();
+  }
+}
+
 static std::string getRpath(opt::InputArgList &args) {
   std::vector<StringRef> v = args::getStrings(args, OPT_rpath);
   return llvm::join(v.begin(), v.end(), ":");
 }
 
 // Determines what we should do if there are remaining unresolved
 // symbols after the name resolution.
 static UnresolvedPolicy getUnresolvedSymbolPolicy(opt::InputArgList &args) {
   UnresolvedPolicy errorOrWarn = args.hasFlag(OPT_error_unresolved_symbols,
                                               OPT_warn_unresolved_symbols, true)
                                      ? UnresolvedPolicy::ReportError
                                      : UnresolvedPolicy::Warn;
 
   // Process the last of -unresolved-symbols, -no-undefined or -z defs.
   for (auto *arg : llvm::reverse(args)) {
     switch (arg->getOption().getID()) {
     case OPT_unresolved_symbols: {
       StringRef s = arg->getValue();
       if (s == "ignore-all" || s == "ignore-in-object-files")
         return UnresolvedPolicy::Ignore;
static void readConfigs(opt::InputArgList &args) {
   config->thinLTOIndexOnly = args.hasArg(OPT_thinlto_index_only) ||
                              args.hasArg(OPT_thinlto_index_only_eq);
   config->thinLTOIndexOnlyArg = args.getLastArgValue(OPT_thinlto_index_only_eq);
   config->thinLTOJobs = args::getInteger(args, OPT_thinlto_jobs, -1u);
   config->thinLTOObjectSuffixReplace =
       getOldNewOptions(args, OPT_thinlto_object_suffix_replace_eq);
   config->thinLTOPrefixReplace =
       getOldNewOptions(args, OPT_thinlto_prefix_replace_eq);
+  config->timeTraceEnabled = args.hasArg(OPT_time_trace);
+  config->timeTraceGranularity =
+      args::getInteger(args, OPT_time_trace_granularity, 500);
   config->trace = args.hasArg(OPT_trace);
   config->undefined = args::getStrings(args, OPT_undefined);
   config->undefinedVersion =
       args.hasFlag(OPT_undefined_version, OPT_no_undefined_version, true);
   config->useAndroidRelrTags = args.hasFlag(
       OPT_use_android_relr_tags, OPT_no_use_android_relr_tags, false);
   config->unresolvedSymbols = getUnresolvedSymbolPolicy(args);
   config->warnBackrefs =
       args.hasFlag(OPT_warn_backrefs, OPT_no_warn_backrefs, false);

 // This function is where all the optimizations of link-time
 // optimization takes place. When LTO is in use, some input files are
 // not in native object file format but in the LLVM bitcode format.
 // This function compiles bitcode files into a few big native files
 // using LLVM functions and replaces bitcode symbols with the results.
 // Because all bitcode files that the program consists of are passed to
 // the compiler at once, it can do a whole-program optimization.
 template <class ELFT> void LinkerDriver::compileBitcodeFiles() {
+  llvm::TimeTraceScope timeScope("LTO");
   // Compile bitcode files and replace bitcode symbols.
   lto.reset(new BitcodeCompiler);
   for (BitcodeFile *file : bitcodeFiles)
     lto->add(*file);
 
   for (InputFile *file : lto->compile()) {
     auto *obj = cast<ObjFile<ELFT>>(file);
     obj->parse(/*ignoreComdats=*/true);
if (config->pacPlt)
     ret |= GNU_PROPERTY_AARCH64_FEATURE_1_PAC;
 
   return ret;
 }
 
 // Do actual linking. Note that when this function is called,
 // all linker scripts have already been parsed.
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
+  llvm::TimeTraceScope timeScope("LinkerDriver::Link");
   // If a -hash-style option was not given, set to a default value,
   // which varies depending on the target.
   if (!args.hasArg(OPT_hash_style)) {
     if (config->emachine == EM_MIPS)
       config->sysvHash = true;
     else
       config->sysvHash = config->gnuHash = true;
   }
template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
   // Handle --trace-symbol.
   for (auto *arg : args.filtered(OPT_trace_symbol))
     symtab->insert(arg->getValue())->traced = true;
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table. This process might
   // add files to the link, via autolinking, these files are always
   // appended to the Files vector.
+  {
+    llvm::TimeTraceScope timeScope("Parse input files");
     for (size_t i = 0; i < files.size(); ++i)
       parseFile(files[i]);
+  }
 
   // Now that we have every file, we can decide if we will need a
   // dynamic symbol table.
   // We need one if we were asked to export dynamic symbols or if we are
   // producing a shared library.
   // We also need one if any shared libraries are used and for pie executables
   // (probably because the dynamic linker needs it).
   config->hasDynSymTab =
template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
   // merging MergeInputSections into a single MergeSyntheticSection. From this
   // point onwards InputSectionDescription::sections should be used instead of
   // sectionBases.
   for (BaseCommand *base : script->sectionCommands)
     if (auto *sec = dyn_cast<OutputSection>(base))
       sec->finalizeInputSections();
   llvm::erase_if(inputSections,
                  [](InputSectionBase *s) { return isa<MergeInputSection>(s); });
 
   // Two input sections with different output sections should not be folded.
   // ICF runs after processSectionCommands() so that we know the output sections.
   if (config->icf != ICFLevel::None) {
     findKeepUniqueSections<ELFT>(args);
     doIcf<ELFT>();
   }
 
   // Read the callgraph now that we know what was gced or icfed

lld/ELF/ICF.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Writer.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Object/ELF.h"
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/xxhash.h"
 #include <algorithm>
 #include <atomic>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
for (BaseCommand *base : script->sectionCommands)
     if (auto *sec = dyn_cast<OutputSection>(base))
       for (BaseCommand *sub_base : sec->sectionCommands)
         if (auto *isd = dyn_cast<InputSectionDescription>(sub_base))
           llvm::erase_if(isd->sections,
                          [](InputSection *isec) { return !isec->isLive(); });
 }
 
 // ICF entry point function.
-template <class ELFT> void doIcf() { ICF<ELFT>().run(); }
+template <class ELFT> void doIcf() {
+  llvm::TimeTraceScope timeScope("ICF");
+  ICF<ELFT>().run();
+}
 
 template void doIcf<ELF32LE>();
 template void doIcf<ELF32BE>();
 template void doIcf<ELF64LE>();
 template void doIcf<ELF64BE>();
 
 } // namespace elf
 } // namespace lld

lld/ELF/LTO.cpp

static lto::Config createConfig() {
   c.RemarksWithHotness = config->optRemarksWithHotness;
   c.RemarksFormat = config->optRemarksFormat;
 
   c.SampleProfile = config->ltoSampleProfile;
   c.UseNewPM = config->ltoNewPassManager;
   c.DebugPassManager = config->ltoDebugPassManager;
   c.DwoDir = config->dwoDir;
 
+  c.TimeTraceEnabled = config->timeTraceEnabled;
+  c.TimeTraceGranularity = config->timeTraceGranularity;
+
   c.CSIRProfile = config->ltoCSProfileFile;
   c.RunCSIRInstr = config->ltoCSProfileGenerate;
 
   if (config->emitLLVM) {
     c.PostInternalizeModuleHook = [](size_t task, const Module &m) {
       if (std::unique_ptr<raw_fd_ostream> os = openFile(config->outputFile))
         WriteBitcodeToFile(m, *os, false);
       return false;

lld/ELF/MarkLive.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/ELF.h"
+#include "llvm/Support/TimeProfiler.h"
 #include <functional>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 namespace endian = llvm::support::endian;
template <class ELFT> void MarkLive<ELFT>::moveToMain() {
 
   mark();
 }
 
 // Before calling this function, Live bits are off for all
 // input sections. This function make some or all of them on
 // so that they are emitted to the output file.
 template <class ELFT> void markLive() {
+  llvm::TimeTraceScope timeScope("markLive");
   // If -gc-sections is not given, no sections are removed.
   if (!config->gcSections) {
     for (InputSectionBase *sec : inputSections)
       sec->markLive();
 
     // If a DSO defines a symbol referenced in a regular object, it is needed.
     for (Symbol *sym : symtab->symbols())
       if (auto *s = dyn_cast<SharedSymbol>(sym))

lld/ELF/Options.td

 defm target2:
   Eq<"target2", "Interpret R_ARM_TARGET2 as <type>, where <type> is one of rel, abs, or got-rel">,
   MetaVarName<"<type>">;
 
 defm threads: B<"threads",
     "Run the linker multi-threaded (default)",
     "Do not run the linker multi-threaded">;
 
+def time_trace: F<"time-trace">, HelpText<"Record time trace">;
+def time_trace_file_eq: J<"time-trace-file=">, HelpText<"Specify time trace output file">;
+
+defm time_trace_granularity: Eq<"time-trace-granularity",
+  "Minimum time granularity (in microseconds) traced by time profiler">;
+
 defm toc_optimize : B<"toc-optimize",
     "(PowerPC64) Enable TOC related optimizations (default)",
     "(PowerPC64) Disable TOC related optimizations">;
 
 def trace: F<"trace">, HelpText<"Print the names of the input files">;
 
 defm trace_symbol: Eq<"trace-symbol", "Trace references to symbols">;
 

lld/ELF/SyntheticSections.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MD5.h"
+#include "llvm/Support/TimeProfiler.h"
 #include <cstdlib>
 #include <thread>
 
 using namespace llvm;
 using namespace llvm::dwarf;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
MergeSyntheticSection *createMergeSynthetic(StringRef name, uint32_t type,
                                             uint32_t alignment) {
   bool shouldTailMerge = (flags & SHF_STRINGS) && config->optimize >= 2;
   if (shouldTailMerge)
     return make<MergeTailSection>(name, type, flags, alignment);
   return make<MergeNoTailSection>(name, type, flags, alignment);
 }
 
 template <class ELFT> void splitSections() {
+  llvm::TimeTraceScope timeScope("Split sections");
   // splitIntoPieces needs to be called on each MergeInputSection
   // before calling finalizeContents().
   parallelForEach(inputSections, [](InputSectionBase *sec) {
     if (auto *s = dyn_cast<MergeInputSection>(sec))
       s->splitIntoPieces();
     else if (auto *eh = dyn_cast<EhInputSection>(sec))
       eh->split<ELFT>();
   });

lld/ELF/Writer.cpp

 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/xxhash.h"
 #include <climits>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
StringRef getOutputSectionName(const InputSectionBase *s) {
   return s->name;
 }
 
 static bool needsInterpSection() {
   return !sharedFiles.empty() && !config->dynamicLinker.empty() &&
          script->needsInterpSection();
 }
 
-template <class ELFT> void writeResult() { Writer<ELFT>().run(); }
+template <class ELFT> void writeResult() {
+  llvm::TimeTraceScope timeScope("Write output file");
+  Writer<ELFT>().run();
+}
 
 static void removeEmptyPTLoad(std::vector<PhdrEntry *> &phdrs) {
   llvm::erase_if(phdrs, [&](const PhdrEntry *p) {
     if (p->p_type != PT_LOAD)
       return false;
     if (!p->firstSec)
       return true;
     uint64_t size = p->lastSec->addr + p->lastSec->size - p->firstSec->addr;

lld/test/ELF/lto/thinlto-time-trace.ll

+; REQUIRES: x86
+
+; Test ThinLTO with time trace
+; RUN: opt -module-summary %s -o %t1.o
+; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
+
+; Test single-threaded
+; RUN: ld.lld --thinlto-jobs=1 -time-trace -time-trace-granularity=0 -shared %t1.o %t2.o -o %t3.so
+; RUN: cat %t3.so.time-trace \
+; RUN:   | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \
+; RUN:   | FileCheck %s
+
+; Test multi-threaded
+; RUN: ld.lld -time-trace -time-trace-granularity=0 -shared %t1.o %t2.o -o %t4.so
+; RUN: cat %t4.so.time-trace \
+; RUN:   | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \
+; RUN:   | FileCheck %s
+
+; CHECK: "traceEvents": [
+; Check fields for an event are present
+; CHECK: "args":
+; CHECK-NEXT: "detail":
+; CHECK: "dur":
+; CHECK-NEXT: "name":
+; CHECK-NEXT: "ph":
+; CHECK-NEXT: "pid":
+; CHECK-NEXT: "tid":
+; CHECK-NEXT: "ts":
+
+; Check that an optimisation event is present
+; CHECK: "name": "OptModule"
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+declare void @g(...)
+
+define void @f() {
+entry:
+  call void (...) @g()
+  ret void
+}
+

lld/test/ELF/time-trace.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+
+# Test implicit trace file name
+# RUN: ld.lld -time-trace -time-trace-granularity=0 -o %t1.elf %t.o
+# RUN: cat %t1.elf.time-trace \
+# RUN:   | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \
+# RUN:   | FileCheck %s
+
+# Test specified trace file name
+# RUN: ld.lld -time-trace -time-trace-file=%t2.json -time-trace-granularity=0 -o %t2.elf %t.o
+# RUN: cat %t2.json \
+# RUN:   | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \
+# RUN:   | FileCheck %s
+
+# Test trace requested to stdout
+# RUN: ld.lld -time-trace -time-trace-file=- -time-trace-granularity=0 -o %t3.elf %t.o \
+# RUN:   | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \
+# RUN:   | FileCheck %s
+
+# CHECK: "traceEvents": [
+
+# Check one event has correct fields
+# CHECK:      "dur":
+# CHECK-NEXT: "name":
+# CHECK-NEXT: "ph":
+# CHECK-NEXT: "pid":
+# CHECK-NEXT: "tid":
+# CHECK-NEXT: "ts":
+
+# Check there is an ExecuteLinker event
+# CHECK: "name": "ExecuteLinker"
+
+# Check process_name entry field
+# CHECK: "name": "ld.lld{{(.exe)?}}"
+# CHECK: "name": "process_name"
+
+.globl _start
+_start:
+  ret

llvm/include/llvm/LTO/Config.h

struct Config {
   std::string RemarksFormat = "";
 
   /// Whether to emit the pass manager debuggging informations.
   bool DebugPassManager = false;
 
   /// Statistics output file path.
   std::string StatsFile;
 
+  /// Time trace enabled.
+  bool TimeTraceEnabled = false;
+
+  /// Time trace granularity.
+  unsigned TimeTraceGranularity = 500;
+
   bool ShouldDiscardValueNames = true;
   DiagnosticHandlerFunction DiagHandler;
 
   /// If this field is set, LTO will write input file paths and symbol
   /// resolutions here in llvm-lto2 command line flag format. This can be
   /// used for testing and for running the LTO pipeline outside of the linker
   /// with llvm-lto2.
   std::unique_ptr<raw_ostream> ResolutionFile;

llvm/lib/LTO/LTO.cpp

 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/Threading.h"
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/VCSRevision.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/IPO/WholeProgramDevirt.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
Error start(
     BackendThreadPool.async(
         [=](BitcodeModule BM, ModuleSummaryIndex &CombinedIndex,
             const FunctionImporter::ImportMapTy &ImportList,
             const FunctionImporter::ExportSetTy &ExportList,
             const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>
                 &ResolvedODR,
             const GVSummaryMapTy &DefinedGlobals,
             MapVector<StringRef, BitcodeModule> &ModuleMap) {
+          if (LLVM_ENABLE_THREADS && Conf.TimeTraceEnabled)
+            timeTraceProfilerInitialize(Conf.TimeTraceGranularity,
+                                        "thin backend");
           Error E = runThinLTOBackendThread(
               AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
               ResolvedODR, DefinedGlobals, ModuleMap);
           if (E) {
             std::unique_lock<std::mutex> L(ErrMu);
             if (Err)
               Err = joinErrors(std::move(*Err), std::move(E));
             else
               Err = std::move(E);
           }
+          if (LLVM_ENABLE_THREADS && Conf.TimeTraceEnabled)
+            timeTraceProfilerFinishThread();
         },
         BM, std::ref(CombinedIndex), std::ref(ImportList), std::ref(ExportList),
         std::ref(ResolvedODR), std::ref(DefinedGlobals), std::ref(ModuleMap));
     return Error::success();
   }
 
   Error wait() override {
     BackendThreadPool.wait();