[RFC] Instrumenting Clang/LLVM with Perfetto

[Nathan-Huckleberry]

Summary

Instrumenting Clang/LLVM with Perfetto

Overview

Perfetto is an event based tracer designed to replace chrome://tracing. It
allows for fine-grained control over trace data and is currently in use by
Chrome and Android.

Instrumentation of Clang with Perfetto would give nicely formatted traces
that are easily shareable by link. Compile time regression bugs could be
filed with Perfetto links that clearly show the regression.

Perfetto exposes a C++ library that allows arbitrary applications to record
app-specific events. Trace events can be added to Clang by calling macros
exposed by Perfetto.

The trace events are sent to an in-process tracing service and are kept in
memory until the trace is written to disk. The trace is written as a protobuf
and can be opened by the Perfetto trace processor (https://ui.perfetto.dev/).

The Perfetto trace processor allows you to vizualize traces as flamegraphs.
The view can be scrolled with "WASD" keys. There is also a query engine
built into the processor that can run queries by pressing CTRL+ENTER.

The benefits of Perfetto:

• Shareable Perfetto links
  • Traces can be easily shared without sending the trace file
• Traces can be easily aggregated with UNIX cat
• Fine-grained Tracing Control
  • Trace events can span across function boundaries (Start a trace in one function, end it in another)
  • Finer granularity than function level that you would see with Linux perf
• Less tracing overhead
  • Trace events are buffered in memory, not sent directly to disk
  • Perfetto macros are optimized to prevent overhead
• Smaller trace sizes
  • Strings and other reused data is interned
  • Traces are stored as protobufs instead of JSON
  • 3x smaller than -ftrace-time traces
• SQL queries for traces
  • The Perfetto UI has a query language built in for data aggregation
• Works on Linux/MacOS/Windows

Example Trace

This is an example trace on a Linux kernel source file.
https://ui.perfetto.dev/#!/?s=c7942d5118f3ccfe16f46d166b05a66d077eb61ef8e22184a7d7dfe87ba8ea

This is an example trace on the entire Linux kernel.
https://ui.perfetto.dev/#!/?s=10556b46b46aba46188a51478102a6ce21a9c767c218afa5b8429eac4cb9d4
Recorded with:

make CC="clang-9" KCFLAGS="-perfetto" -j72
find /tmp -name "*pftrace" -exec cat {} \; > trace.pftrace

Current Implementation

These changes are behind a CMake flag (-DPERFETTO). When building Clang with
the CMake flag enabled, the Perfetto GitHub is cloned into the build folder and
linked against any code that uses Perfetto macros.

The -ftime-trace and Perfetto trace events have been combined into one
macro that expands to trace events for both. The behavior of -ftime-trace
is unchanged.

To run a Perfetto trace, pass the flag -perfetto to Clang (built with
-DPERFETTO). The trace output file follows the convention set by
-ftime-trace and uses the filename passed to -o to determine the trace
filename.

For example:
clang -perfetto -c foo.c -o foo.o
would generate foo.pftrace.

Tracing documentation

LLVM_TRACE_BEGIN(name, detail)
Begins a tracing slice if Perfetto or -ftime-trace is enabled.
name : constexpr String
This is what will be displayed on the tracing UI.
detail : StringRef
Additional detail to add to the trace slice. This expands to a lambda
and will be evaluated lazily only if Perfetto or -ftime-trace are
enabled.

LLVM_TRACE_END()
Ends the most recently started slice.

LLVM_TRACE_SCOPE(name, detail)
Begins a tracing slice and initializes an anonymous struct if Perfetto or
-ftime-trace is enabled. When the struct goes out of scope, the tracing
slice will end.
name : constexpr String
This is what will be displayed on the tracing UI.
detail : StringRef
Additional detail to add to the trace slice. This expands to a lambda
and will be evaluated lazily only if Perfetto or -ftime-trace are
enabled.

Perfetto Documentation: https://perfetto.dev/

FAQs

Why not use Linux Perf?
Perfetto's event based model allows for much finer grained control over
the trace.

• Linux Perf is only available on Linux.
• Visualization requires post processing with separate tools.
• Requires kernel version specific dependencies.

Why not use -ftime-trace?
Perfetto has almost the same functionality as -ftime-trace, but with a
few added benefits.

• Shareable links.
• Traces can be aggregated easily with UNIX cat.
• The query engine for trace analysis.
• The Perfetto UI is browser agnostic and could be used the same way as godbolt.
• The resulting trace files are ~3x smaller.
  • A trace of the Linux kernel is 50MB with Perfetto and 139MB with -ftime-trace.

Extra Notes

Perfetto also has a system-mode that interacts with Linux ftrace. It can
record things like process scheduling, syscalls, memory usage and CPU
usage.

Known Issues

When no-integrated-as is enabled, traces are outputted to /tmp/. This is a
bug with the current implementation of -ftime-trace. When the Perfetto
change is applied, the bug also applies to Perfetto.

[lebedev.ri]

New files are missing standard license header blurb.
Also probably missing some tests.

clang/lib/Driver/Driver.cpp

3754

This appears unrelated to the patch.

clang/tools/clang-shlib/CMakeLists.txt

40

Could use more words. What issues?

llvm/cmake/modules/AddPerfetto.cmake

9

I have concerns about this.
It really should use system-provided version via find_package()
At worst, the sources should be bundled into the tree like it's already done in some rare cases.

[nickdesaulniers]

clang/lib/Driver/Driver.cpp

3754

This might be related to the requirement that perfetto trace everything in process; though I think this is also a pre-existing bug IMO that can be precommitted.

llvm/cmake/modules/AddPerfetto.cmake

9

Not that I'm very good with CMake, but this seems to suggest that ExternalProject_Add may not compose well with find_package: https://stackoverflow.com/questions/6351609/cmake-linking-to-library-downloaded-from-externalproject-add

[lebedev.ri]

llvm/cmake/modules/AddPerfetto.cmake

9

What i am saying is that any code that fetches anything from internet during cmake/build time is just plain broken.
perfetto should be provided by system package and we should link to it just like we link to zlib/etc.

[nickdesaulniers]

llvm/cmake/modules/AddPerfetto.cmake

9

That's how GTest is fetched. See: llvm/utils/benchmark/cmake/HandleGTest.cmake.

[lebedev.ri]

llvm/cmake/modules/AddPerfetto.cmake

9

That's how GTest is fetched.

No, it's not. That cmake file is never ever executed by LLVM's cmake.
LLVM's gtest is bundled in llvm/utils/unittest/googletest,
much like googlebenchmark is bundled in llvm/utils/benchmark,
etc.

[Nathan-Huckleberry]

• Attach translation unit names to trace processes

[Mordante]

clang/include/clang/Basic/CodeGenOptions.def

244

Seems this line should be one lower to keep the comment above together.

clang/include/clang/Frontend/FrontendOptions.h

251

Is it intended to have the same comment as TimeTrace?

clang/include/clang/Basic/CodeGenOptions.def

 CODEGENOPT(SoftFloat         , 1, 0) ///< -soft-float.
 CODEGENOPT(SpeculativeLoadHardening, 1, 0) ///< Enable speculative load hardening.
 CODEGENOPT(FineGrainedBitfieldAccesses, 1, 0) ///< Enable fine-grained bitfield accesses.
 CODEGENOPT(StrictEnums       , 1, 0) ///< Optimize based on strict enum definition.
 CODEGENOPT(StrictVTablePointers, 1, 0) ///< Optimize based on the strict vtable pointers
 CODEGENOPT(TimePasses        , 1, 0) ///< Set when -ftime-report is enabled.
 CODEGENOPT(TimeTrace         , 1, 0) ///< Set when -ftime-trace is enabled.
 VALUE_CODEGENOPT(TimeTraceGranularity, 32, 500) ///< Minimum time granularity (in microseconds),
+CODEGENOPT(Perfetto          , 1, 0) ///< Set when -perfetto is enabled.
                                                ///< traced by time profiler
 CODEGENOPT(UnrollLoops       , 1, 0) ///< Control whether loops are unrolled.
 CODEGENOPT(RerollLoops       , 1, 0) ///< Control whether loops are rerolled.
 CODEGENOPT(NoUseJumpTables   , 1, 0) ///< Set when -fno-jump-tables is enabled.
 CODEGENOPT(UnwindTables      , 1, 0) ///< Emit unwind tables.
 CODEGENOPT(VectorizeLoop     , 1, 0) ///< Run loop vectorizer.
 CODEGENOPT(VectorizeSLP      , 1, 0) ///< Run SLP vectorizer.
 CODEGENOPT(ProfileSampleAccurate, 1, 0) ///< Sample profile is accurate.

clang/include/clang/Driver/Options.td

 def nostdlibxx : Flag<["-"], "nostdlib++">;
 def object : Flag<["-"], "object">;
 def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption]>,
   HelpText<"Write output to <file>">, MetaVarName<"<file>">;
 def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">;
 def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>;
 def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>;
 def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option]>;
+def perfetto : Flag<["-"], "perfetto">, Flags<[HelpHidden, CoreOption, CC1Option]>, Group<f_Group>,
+  HelpText<"Enable Perfetto tracing and output trace data to the provided file">;
 def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
 def pipe : Flag<["-", "--"], "pipe">,
   HelpText<"Use pipes between commands, when possible">;
 def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
 def prebind : Flag<["-"], "prebind">;
 def preload : Flag<["-"], "preload">;
 def print_file_name_EQ : Joined<["-", "--"], "print-file-name=">,
   HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">;

clang/include/clang/Frontend/FrontendOptions.h

public:
   unsigned ShowTimers : 1;
 
   /// print the supported cpus for the current target
   unsigned PrintSupportedCPUs : 1;
 
   /// Output time trace profile.
   unsigned TimeTrace : 1;
 
+  /// Output time trace profile.
+  unsigned Perfetto : 1;
+
   /// Show the -version text.
   unsigned ShowVersion : 1;
 
   /// Apply fixes even if there are unfixable errors.
   unsigned FixWhatYouCan : 1;
 
   /// Apply fixes only for warnings.
   unsigned FixOnlyWarnings : 1;
public:
   std::string StatsFile;
 
   /// Minimum time granularity (in microseconds) traced by time profiler.
   unsigned TimeTraceGranularity;
 
 public:
   FrontendOptions()
       : DisableFree(false), RelocatablePCH(false), ShowHelp(false),
-        ShowStats(false), ShowTimers(false), TimeTrace(false),
+        ShowStats(false), ShowTimers(false), TimeTrace(false), Perfetto(false),
         ShowVersion(false), FixWhatYouCan(false), FixOnlyWarnings(false),
         FixAndRecompile(false), FixToTemporaries(false),
         ARCMTMigrateEmitARCErrors(false), SkipFunctionBodies(false),
         UseGlobalModuleIndex(true), GenerateGlobalModuleIndex(true),
         ASTDumpDecls(false), ASTDumpLookups(false),
         BuildingImplicitModule(false), ModulesEmbedAllFiles(false),
-        IncludeTimestamps(true), UseTemporary(true), TimeTraceGranularity(500) {}
+        IncludeTimestamps(true), UseTemporary(true), TimeTraceGranularity(500) {
+  }
 
   /// getInputKindForExtension - Return the appropriate input kind for a file
   /// extension. For example, "c" would return Language::C.
   ///
   /// \return The input kind for the extension, or Language::Unknown if the
   /// extension is not recognized.
   static InputKind getInputKindForExtension(StringRef Extension);
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H

clang/lib/CodeGen/BackendUtil.cpp

 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Passes/PassPlugin.h"
 #include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/TargetRegistry.h"
-#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/Tracing.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/Coroutines.h"
 #include "llvm/Transforms/Coroutines/CoroCleanup.h"
 #include "llvm/Transforms/Coroutines/CoroEarly.h"
 #include "llvm/Transforms/Coroutines/CoroElide.h"
 #include "llvm/Transforms/Coroutines/CoroSplit.h"
void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
   // Before executing passes, print the final values of the LLVM options.
   cl::PrintOptionValues();
 
   // Run passes. For now we do all passes at once, but eventually we
   // would like to have the option of streaming code generation.
 
   {
     PrettyStackTraceString CrashInfo("Per-function optimization");
-    llvm::TimeTraceScope TimeScope("PerFunctionPasses");
+    LLVM_TRACE_SCOPE("PerFunctionPasses", StringRef(""));
 
     PerFunctionPasses.doInitialization();
     for (Function &F : *TheModule)
       if (!F.isDeclaration())
         PerFunctionPasses.run(F);
     PerFunctionPasses.doFinalization();
   }
 
   {
     PrettyStackTraceString CrashInfo("Per-module optimization passes");
-    llvm::TimeTraceScope TimeScope("PerModulePasses");
+    LLVM_TRACE_SCOPE("PerModulePasses", StringRef(""));
     PerModulePasses.run(*TheModule);
   }
 
   {
     PrettyStackTraceString CrashInfo("Code generation");
-    llvm::TimeTraceScope TimeScope("CodeGenPasses");
+    LLVM_TRACE_SCOPE("CodeGenPasses", StringRef(""));
     CodeGenPasses.run(*TheModule);
   }
 
   if (ThinLinkOS)
     ThinLinkOS->keep();
   if (DwoOS)
     DwoOS->keep();
 }
void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
                               const HeaderSearchOptions &HeaderOpts,
                               const CodeGenOptions &CGOpts,
                               const clang::TargetOptions &TOpts,
                               const LangOptions &LOpts,
                               const llvm::DataLayout &TDesc, Module *M,
                               BackendAction Action,
                               std::unique_ptr<raw_pwrite_stream> OS) {
 
-  llvm::TimeTraceScope TimeScope("Backend");
+  LLVM_TRACE_SCOPE("Backend", StringRef(""));
 
   std::unique_ptr<llvm::Module> EmptyModule;
   if (!CGOpts.ThinLTOIndexFile.empty()) {
     // If we are performing a ThinLTO importing compile, load the function index
     // into memory and pass it into runThinLTOBackend, which will run the
     // function importer and invoke LTO passes.
     Expected<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
         llvm::getModuleSummaryIndexForFile(CGOpts.ThinLTOIndexFile,

clang/lib/CodeGen/CGDebugInfo.cpp

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/Tracing.h"
 using namespace clang;
 using namespace clang::CodeGen;
 
 static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) {
   auto TI = Ctx.getTypeInfo(Ty);
   return TI.AlignIsRequired ? TI.Align : 0;
 }
 
void CGDebugInfo::completeUnusedClass(const CXXRecordDecl &D) {
   // it is retained
   RetainedTypes.push_back(CGM.getContext().getRecordType(&D).getAsOpaquePtr());
 }
 
 llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) {
   if (Ty.isNull())
     return nullptr;
 
-  llvm::TimeTraceScope TimeScope("DebugType", [&]() {
-    std::string Name;
-    llvm::raw_string_ostream OS(Name);
-    Ty.print(OS, getPrintingPolicy());
-    return Name;
-  });
+  LLVM_TRACE_SCOPE("DebugType", StringRef(Ty.getAsString(getPrintingPolicy())));
 
   // Unwrap the type as needed for debug information.
   Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
 
   if (auto *T = getTypeOrNull(Ty))
     return T;
 
   llvm::DIType *Res = CreateTypeNode(Ty, Unit);
void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc,
                                    QualType FnType, llvm::Function *Fn) {
   StringRef Name;
   StringRef LinkageName;
 
   const Decl *D = GD.getDecl();
   if (!D)
     return;
 
-  llvm::TimeTraceScope TimeScope("DebugFunction", [&]() {
-    std::string Name;
-    llvm::raw_string_ostream OS(Name);
-    if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
-      ND->getNameForDiagnostic(OS, getPrintingPolicy(),
-                               /*Qualified=*/true);
-    return Name;
-  });
+  LLVM_TRACE_SCOPE(
+      "DebugFunction",
+      dyn_cast_or_null<NamedDecl>(D)
+          ? StringRef(
+                dyn_cast_or_null<NamedDecl>(D)->getQualifiedNameAsString())
+          : StringRef(""));
 
   llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
   llvm::DIFile *Unit = getOrCreateFile(Loc);
   bool IsDeclForCallSite = Fn ? true : false;
   llvm::DIScope *FDContext =
       IsDeclForCallSite ? Unit : getDeclContextDescriptor(D);
   llvm::DINodeArray TParamsArray;
   if (isa<FunctionDecl>(D)) {
void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
   }
   DeclCache[D->getCanonicalDecl()].reset(GVE);
 }
 
 void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
   assert(CGM.getCodeGenOpts().hasReducedDebugInfo());
   if (VD->hasAttr<NoDebugAttr>())
     return;
-  llvm::TimeTraceScope TimeScope("DebugConstGlobalVariable", [&]() {
-    std::string Name;
-    llvm::raw_string_ostream OS(Name);
-    VD->getNameForDiagnostic(OS, getPrintingPolicy(),
-                             /*Qualified=*/true);
-    return Name;
-  });
+  LLVM_TRACE_SCOPE("DebugConstGlobalVariable",
+                   StringRef(VD->getQualifiedNameAsString()));
 
   auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
   // Create the descriptor for the variable.
   llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
   StringRef Name = VD->getName();
   llvm::DIType *Ty = getOrCreateType(VD->getType(), Unit);
 
   if (const auto *ECD = dyn_cast<EnumConstantDecl>(VD)) {

clang/lib/CodeGen/CMakeLists.txt

add_clang_library(clangCodeGen
   clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangLex
   clangSerialization
   )
+
+if(PERFETTO)
+  target_link_libraries(clangCodeGen
+    PRIVATE perfetto
+    )
+endif()

clang/lib/CodeGen/CodeGenAction.cpp

 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LLVMRemarkStreamer.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/Tracing.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Transforms/IPO/Internalize.h"
 
 #include <memory>
 using namespace clang;
 using namespace llvm;
 
 namespace clang {
bool LinkInModules() {
         if (Err)
           return true;
       }
       return false; // success
     }
 
     void HandleTranslationUnit(ASTContext &C) override {
       {
-        llvm::TimeTraceScope TimeScope("Frontend");
+        LLVM_TRACE_SCOPE("Frontend", StringRef(""));
         PrettyStackTraceString CrashInfo("Per-file LLVM IR generation");
         if (FrontendTimesIsEnabled) {
           LLVMIRGenerationRefCount += 1;
           if (LLVMIRGenerationRefCount == 1)
             LLVMIRGeneration.startTimer();
         }
 
         Gen->HandleTranslationUnit(C);

clang/lib/CodeGen/CodeGenModule.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MD5.h"
-#include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/Tracing.h"
 
 using namespace clang;
 using namespace CodeGen;
 
 static llvm::cl::opt<bool> LimitedCoverage(
     "limited-coverage-experimental", llvm::cl::ZeroOrMore, llvm::cl::Hidden,
     llvm::cl::desc("Emit limited coverage mapping information (experimental)"),
     llvm::cl::init(false));
PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
                                  "Generating code for declaration");
 
   if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
     // At -O0, don't generate IR for functions with available_externally
     // linkage.
     if (!shouldEmitFunction(GD))
       return;
 
-    llvm::TimeTraceScope TimeScope("CodeGen Function", [&]() {
-      std::string Name;
-      llvm::raw_string_ostream OS(Name);
-      FD->getNameForDiagnostic(OS, getContext().getPrintingPolicy(),
-                               /*Qualified=*/true);
-      return Name;
-    });
+    LLVM_TRACE_SCOPE("CodeGen Function",
+                     StringRef(FD->getQualifiedNameAsString()));
 
     if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
       // Make sure to emit the definition(s) before we emit the thunks.
       // This is necessary for the generation of certain thunks.
       if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
         ABI->emitCXXStructor(GD);
       else if (FD->isMultiVersion())
         EmitMultiVersionFunctionDefinition(GD, GV);

clang/lib/Driver/Driver.cpp

for (Action *A : C.getActions()) {
     BuildJobsForAction(C, A, &C.getDefaultToolChain(),
                        /*BoundArch*/ StringRef(),
                        /*AtTopLevel*/ true,
                        /*MultipleArchs*/ ArchNames.size() > 1,
                        /*LinkingOutput*/ LinkingOutput, CachedResults,
                        /*TargetDeviceOffloadKind*/ Action::OFK_None);
   }
 
+  // We don't need to count the assembler as a job since it doesn't
+  // cause the memory issue that requires disabling integrated-cc1.
+  size_t NumJobs = C.getJobs().size();
+  if (NumJobs && !C.getDefaultToolChain().useIntegratedAs())
+    --NumJobs;
+
   // If we have more than one job, then disable integrated-cc1 for now.
-  if (C.getJobs().size() > 1)
+  if (NumJobs > 1)
     for (auto &J : C.getJobs())
       J.InProcess = false;
 
   // If the user passed -Qunused-arguments or there were errors, don't warn
   // about any unused arguments.
   if (Diags.hasErrorOccurred() ||
       C.getArgs().hasArg(options::OPT_Qunused_arguments))
     return;

clang/lib/Driver/ToolChains/Clang.cpp

#endif
   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
   Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
   Args.AddLastArg(CmdArgs, options::OPT_ftime_trace);
   Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
   Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
   Args.AddLastArg(CmdArgs, options::OPT_malign_double);
   Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
+  Args.AddLastArg(CmdArgs, options::OPT_perfetto);
 
   if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
     CmdArgs.push_back("-ftrapv-handler");
     CmdArgs.push_back(A->getValue());
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
 

clang/lib/Frontend/CompilerInstance.cpp

 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/LockFileManager.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
-#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
+#include "llvm/Support/Tracing.h"
 #include "llvm/Support/raw_ostream.h"
 #include <time.h>
 #include <utility>
 
 using namespace clang;
 
 CompilerInstance::CompilerInstance(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,

 static bool
 compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
                   StringRef ModuleName, FrontendInputFile Input,
                   StringRef OriginalModuleMapFile, StringRef ModuleFileName,
                   llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
                       [](CompilerInstance &) {},
                   llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
                       [](CompilerInstance &) {}) {
-  llvm::TimeTraceScope TimeScope("Module Compile", ModuleName);
+  LLVM_TRACE_SCOPE("Module Compile", ModuleName);
 
   // Construct a compiler invocation for creating this module.
   auto Invocation =
       std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
 
   PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
 
   // For any options that aren't intended to affect how a module is built,
if (!getASTReader())
     createASTReader();
 
   // Time how long it takes to load the module.
   llvm::Timer Timer;
   if (FrontendTimerGroup)
     Timer.init("loading." + ModuleFilename, "Loading " + ModuleFilename,
                *FrontendTimerGroup);
   llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
-  llvm::TimeTraceScope TimeScope("Module Load", ModuleName);
+  LLVM_TRACE_SCOPE("Module Load", ModuleName);
 
   // Try to load the module file. If we are not trying to load from the
   // module cache, we don't know how to rebuild modules.
   unsigned ARRFlags = Source == MS_ModuleCache
                           ? ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing
                           : Source == MS_PrebuiltModulePath
                                 ? 0
                                 : ASTReader::ARR_ConfigurationMismatch;

clang/lib/Frontend/CompilerInvocation.cpp

static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
   Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
   Opts.ShowHelp = Args.hasArg(OPT_help);
   Opts.ShowStats = Args.hasArg(OPT_print_stats);
   Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
   Opts.PrintSupportedCPUs = Args.hasArg(OPT_print_supported_cpus);
   Opts.TimeTrace = Args.hasArg(OPT_ftime_trace);
   Opts.TimeTraceGranularity = getLastArgIntValue(
       Args, OPT_ftime_trace_granularity_EQ, Opts.TimeTraceGranularity, Diags);
+  Opts.Perfetto = Args.hasArg(OPT_perfetto);
   Opts.ShowVersion = Args.hasArg(OPT_version);
   Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
   Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
   Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
   Opts.FixOnlyWarnings = Args.hasArg(OPT_fix_only_warnings);
   Opts.FixAndRecompile = Args.hasArg(OPT_fixit_recompile);
   Opts.FixToTemporaries = Args.hasArg(OPT_fixit_to_temp);
   Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);

clang/lib/Lex/CMakeLists.txt

add_clang_library(clangLex
   PreprocessorLexer.cpp
   ScratchBuffer.cpp
   TokenConcatenation.cpp
   TokenLexer.cpp
 
   LINK_LIBS
   clangBasic
   )
+
+if(PERFETTO)
+  target_link_libraries(clangLex
+    PRIVATE perfetto
+    )
+endif()

clang/lib/Parse/CMakeLists.txt

add_clang_library(clangParse
   Parser.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangLex
   clangSema
   )
+
+if(PERFETTO)
+  target_link_libraries(clangParse
+    PRIVATE perfetto
+    )
+endif()

clang/lib/Parse/ParseAST.cpp

 #include "clang/AST/Stmt.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaConsumer.h"
 #include "clang/Sema/TemplateInstCallback.h"
 #include "llvm/Support/CrashRecoveryContext.h"
-#include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/Tracing.h"
 #include <cstdio>
 #include <memory>
 
 using namespace clang;
 
 namespace {
 
 /// Resets LLVM's pretty stack state so that stack traces are printed correctly
if (External)
     External->StartTranslationUnit(Consumer);
 
   // If a PCH through header is specified that does not have an include in
   // the source, or a PCH is being created with #pragma hdrstop with nothing
   // after the pragma, there won't be any tokens or a Lexer.
   bool HaveLexer = S.getPreprocessor().getCurrentLexer();
 
   if (HaveLexer) {
-    llvm::TimeTraceScope TimeScope("Frontend");
+    LLVM_TRACE_SCOPE("Frontend", StringRef(""));
     P.Initialize();
     Parser::DeclGroupPtrTy ADecl;
     for (bool AtEOF = P.ParseFirstTopLevelDecl(ADecl); !AtEOF;
          AtEOF = P.ParseTopLevelDecl(ADecl)) {
       // If we got a null return and something *was* parsed, ignore it.  This
       // is due to a top-level semicolon, an action override, or a parse error
       // skipping something.
       if (ADecl && !Consumer->HandleTopLevelDecl(ADecl.get()))

clang/lib/Parse/ParseDeclCXX.cpp

 //===--- ParseDeclCXX.cpp - C++ Declaration Parsing -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements the C++ Declaration portions of the Parser interfaces.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Parse/Parser.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/PrettyDeclStackTrace.h"
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/TargetInfo.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/ADT/SmallString.h"
-#include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/Tracing.h"
 
 using namespace clang;
 
 /// ParseNamespace - We know that the current token is a namespace keyword. This
 /// may either be a top level namespace or a block-level namespace alias. If
 /// there was an inline keyword, it has already been parsed.
 ///
 ///       namespace-definition: [C++: namespace.def]
void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc,
                                          SourceLocation AttrFixitLoc,
                                          ParsedAttributesWithRange &Attrs,
                                          unsigned TagType, Decl *TagDecl) {
   assert((TagType == DeclSpec::TST_struct ||
          TagType == DeclSpec::TST_interface ||
          TagType == DeclSpec::TST_union  ||
          TagType == DeclSpec::TST_class) && "Invalid TagType!");
 
-  llvm::TimeTraceScope TimeScope("ParseClass", [&]() {
-    if (auto *TD = dyn_cast_or_null<NamedDecl>(TagDecl))
-      return TD->getQualifiedNameAsString();
-    return std::string("<anonymous>");
-  });
+  LLVM_TRACE_SCOPE(
+      "ParseClass",
+      dyn_cast_or_null<NamedDecl>(TagDecl)
+          ? dyn_cast_or_null<NamedDecl>(TagDecl)->getQualifiedNameAsString()
+          : StringRef("<anonymous>"));
 
   PrettyDeclStackTraceEntry CrashInfo(Actions.Context, TagDecl, RecordLoc,
                                       "parsing struct/union/class body");
 
   // Determine whether this is a non-nested class. Note that local
   // classes are *not* considered to be nested classes.
   bool NonNestedClass = true;
   if (!ClassStack.empty()) {

clang/lib/Parse/ParseTemplate.cpp

 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.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/TimeProfiler.h"
+#include "llvm/Support/Tracing.h"
 using namespace clang;
 
 /// Parse a template declaration, explicit instantiation, or
 /// explicit specialization.
 Decl *Parser::ParseDeclarationStartingWithTemplate(
     DeclaratorContext Context, SourceLocation &DeclEnd,
     ParsedAttributes &AccessAttrs, AccessSpecifier AS) {
   ObjCDeclContextSwitch ObjCDC(*this);
Decl *Parser::ParseSingleDeclarationAfterTemplate(
   if (!DeclaratorInfo.hasName()) {
     // If so, skip until the semi-colon or a }.
     SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
     if (Tok.is(tok::semi))
       ConsumeToken();
     return nullptr;
   }
 
-  llvm::TimeTraceScope TimeScope("ParseTemplate", [&]() {
-    return std::string(DeclaratorInfo.getIdentifier() != nullptr
-                           ? DeclaratorInfo.getIdentifier()->getName()
-                           : "<unknown>");
-  });
+  LLVM_TRACE_SCOPE("ParseTemplate",
+                   DeclaratorInfo.getIdentifier() != nullptr
+                       : StringRef("<unknown>"));
 
   LateParsedAttrList LateParsedAttrs(true);
   if (DeclaratorInfo.isFunctionDeclarator()) {
     if (Tok.is(tok::kw_requires))
       ParseTrailingRequiresClause(DeclaratorInfo);
 
     MaybeParseGNUAttributes(DeclaratorInfo, &LateParsedAttrs);
   }

clang/lib/Sema/Sema.cpp

 #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 "clang/Sema/TypoCorrection.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallSet.h"
-#include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/Tracing.h"
 
 using namespace clang;
 using namespace sema;
 
 SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {
   return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
 }
 
virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                            FileID PrevFID) override {
     if (!S)
       return;
     switch (Reason) {
     case EnterFile: {
       SourceManager &SM = S->getSourceManager();
       SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
       if (IncludeLoc.isValid()) {
-        if (llvm::timeTraceProfilerEnabled()) {
-          const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
-          llvm::timeTraceProfilerBegin(
-              "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>"));
-        }
+        // FIXME: These events are mismatched which will cause problems if
+        // additional trace events are added.
+        LLVM_TRACE_BEGIN(
+            "Source", SM.getFileEntryForID(SM.getFileID(Loc)) != nullptr
+                          ? SM.getFileEntryForID(SM.getFileID(Loc))->getName()
+                          : StringRef("<unknown>"));
 
         IncludeStack.push_back(IncludeLoc);
         S->DiagnoseNonDefaultPragmaPack(
             Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc);
       }
       break;
     }
     case ExitFile:
       if (!IncludeStack.empty()) {
-        if (llvm::timeTraceProfilerEnabled())
-          llvm::timeTraceProfilerEnd();
+        LLVM_TRACE_END();
 
         S->DiagnoseNonDefaultPragmaPack(
             Sema::PragmaPackDiagnoseKind::ChangedStateAtExit,
             IncludeStack.pop_back_val());
       }
       break;
     default:
       break;
if (ExternalSource) {
     for (auto PII : Pending)
       if (auto Func = dyn_cast<FunctionDecl>(PII.first))
         Func->setInstantiationIsPending(true);
     PendingInstantiations.insert(PendingInstantiations.begin(),
                                  Pending.begin(), Pending.end());
   }
 
   {
-    llvm::TimeTraceScope TimeScope("PerformPendingInstantiations");
+    LLVM_TRACE_SCOPE("PerformPendingInstantiations", StringRef(""));
     PerformPendingInstantiations();
   }
 
   emitDeferredDiags();
 
   assert(LateParsedInstantiations.empty() &&
          "end of TU template instantiation should not create more "
          "late-parsed templates");

clang/lib/Sema/SemaTemplateInstantiate.cpp

 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/SemaConcept.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "clang/Sema/TemplateInstCallback.h"
-#include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/Tracing.h"
 
 using namespace clang;
 using namespace sema;
 
 //===----------------------------------------------------------------------===/
 // Template Instantiation Support
 //===----------------------------------------------------------------------===/
 
Sema::InstantiateClass(SourceLocation PointOfInstantiation,
                        bool Complain) {
   CXXRecordDecl *PatternDef
     = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
   if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
                                 Instantiation->getInstantiatedFromMemberClass(),
                                      Pattern, PatternDef, TSK, Complain))
     return true;
 
-  llvm::TimeTraceScope TimeScope("InstantiateClass", [&]() {
-    std::string Name;
-    llvm::raw_string_ostream OS(Name);
-    Instantiation->getNameForDiagnostic(OS, getPrintingPolicy(),
-                                        /*Qualified=*/true);
-    return Name;
-  });
+  LLVM_TRACE_SCOPE("InstantiateClass",
+                   StringRef(Instantiation->getQualifiedNameAsString()));
 
   Pattern = PatternDef;
 
   // Record the point of instantiation.
   if (MemberSpecializationInfo *MSInfo
         = Instantiation->getMemberSpecializationInfo()) {
     MSInfo->setTemplateSpecializationKind(TSK);
     MSInfo->setPointOfInstantiation(PointOfInstantiation);

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateInstCallback.h"
-#include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/Tracing.h"
 
 using namespace clang;
 
 static bool isDeclWithinFunction(const Decl *D) {
   const DeclContext *DC = D->getDeclContext();
   if (DC->isFunctionOrMethod())
     return true;
 
void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
   if (PatternDecl->isLateTemplateParsed() &&
       !LateTemplateParser) {
     Function->setInstantiationIsPending(true);
     LateParsedInstantiations.push_back(
         std::make_pair(Function, PointOfInstantiation));
     return;
   }
 
-  llvm::TimeTraceScope TimeScope("InstantiateFunction", [&]() {
-    std::string Name;
-    llvm::raw_string_ostream OS(Name);
-    Function->getNameForDiagnostic(OS, getPrintingPolicy(),
-                                   /*Qualified=*/true);
-    return Name;
-  });
+  LLVM_TRACE_SCOPE("InstantiateFunction",
+                   StringRef(Function->getQualifiedNameAsString()));
 
   // If we're performing recursive template instantiation, create our own
   // queue of pending implicit instantiations that we will instantiate later,
   // while we're still within our own instantiation context.
   // This has to happen before LateTemplateParser below is called, so that
   // it marks vtables used in late parsed templates as used.
   GlobalEagerInstantiationScope GlobalInstantiations(*this,
                                                      /*Enabled=*/Recursive);

clang/lib/Serialization/GlobalModuleIndex.cpp

 #include "llvm/Bitstream/BitstreamWriter.h"
 #include "llvm/Support/DJB.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/LockFileManager.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/OnDiskHashTable.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/Tracing.h"
 #include <cstdio>
 using namespace clang;
 using namespace serialization;
 
 //----------------------------------------------------------------------------//
 // Shared constants
 //----------------------------------------------------------------------------//
 namespace {
GlobalModuleIndex::GlobalModuleIndex(
     llvm::BitstreamCursor Cursor)
     : Buffer(std::move(IndexBuffer)), IdentifierIndex(), NumIdentifierLookups(),
       NumIdentifierLookupHits() {
   auto Fail = [&](llvm::Error &&Err) {
     report_fatal_error("Module index '" + Buffer->getBufferIdentifier() +
                        "' failed: " + toString(std::move(Err)));
   };
 
-  llvm::TimeTraceScope TimeScope("Module LoadIndex");
+  LLVM_TRACE_SCOPE("Module LoadIndex", StringRef(""));
   // Read the global index.
   bool InGlobalIndexBlock = false;
   bool Done = false;
   while (!Done) {
     llvm::BitstreamEntry Entry;
     if (Expected<llvm::BitstreamEntry> Res = Cursor.advance())
       Entry = Res.get();
     else
if (getModuleFileInfo(File).Signature) {
         return true;
     } else if (Info.StoredSize != File->getSize() ||
                Info.StoredModTime != File->getModificationTime())
       // Verify Size and ModTime.
       return true;
   }
 
   using namespace llvm;
-  llvm::TimeTraceScope TimeScope("Module WriteIndex");
+  LLVM_TRACE_SCOPE("Module WriteIndex", StringRef(""));
 
   // Emit the file header.
   Stream.Emit((unsigned)'B', 8);
   Stream.Emit((unsigned)'C', 8);
   Stream.Emit((unsigned)'G', 8);
   Stream.Emit((unsigned)'I', 8);
 
   // Write the block-info block, which describes the records in this bitcode

clang/tools/clang-shlib/CMakeLists.txt

if (interface)
     endforeach()
   endif()
 endforeach ()
 
 if (CLANG_LINK_CLANG_DYLIB)
   set(INSTALL_WITH_TOOLCHAIN INSTALL_WITH_TOOLCHAIN)
 endif()
 
+if (PERFETTO)
+# Avoid issues with PRIVATE library
+# There's probably a better fix for this
+add_clang_library(clang-cpp
+                  SHARED
+                  ${INSTALL_WITH_TOOLCHAIN}
+                  clang-shlib.cpp
+                  ${_OBJECTS}
+                  LINK_LIBS
+                  ${clang_libs})
+else()
 add_clang_library(clang-cpp
                   SHARED
                   ${INSTALL_WITH_TOOLCHAIN}
                   clang-shlib.cpp
                   ${_OBJECTS}
                   LINK_LIBS
                   ${_DEPS})
+endif()

clang/tools/driver/cc1_main.cpp

 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
-#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
+#include "llvm/Support/Tracing.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include <cstdio>
 
 #ifdef CLANG_HAVE_RLIMITS
 #include <sys/resource.h>
 #endif
 
int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
   bool Success =
       CompilerInvocation::CreateFromArgs(Clang->getInvocation(), Argv, Diags);
 
   if (Clang->getFrontendOpts().TimeTrace) {
     llvm::timeTraceProfilerInitialize(
         Clang->getFrontendOpts().TimeTraceGranularity, Argv0);
   }
+#ifdef PERFETTO
+  std::unique_ptr<PerfettoProfiler> PerfettoSession = nullptr;
+  if (Clang->getFrontendOpts().Perfetto) {
+    SmallString<128> Path(Clang->getFrontendOpts().OutputFile);
+    llvm::sys::path::replace_extension(Path, "pftrace");
+    if (auto profilerOutput =
+            Clang->createOutputFile(Path.str(),
+                                    /*Binary=*/false,
+                                    /*RemoveFileOnSignal=*/false, "",
+                                    /*Extension=*/"json",
+                                    /*useTemporary=*/false)) {
+
+      PerfettoSession.reset(new PerfettoProfiler(std::move(profilerOutput)));
+    }
+  }
+#endif
   // --print-supported-cpus takes priority over the actual compilation.
   if (Clang->getFrontendOpts().PrintSupportedCPUs)
     return PrintSupportedCPUs(Clang->getTargetOpts().Triple);
 
   // Infer the builtin include path if unspecified.
   if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
       Clang->getHeaderSearchOpts().ResourceDir.empty())
     Clang->getHeaderSearchOpts().ResourceDir =
llvm::install_fatal_error_handler(LLVMErrorHandler,
                                   static_cast<void*>(&Clang->getDiagnostics()));
 
   DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
   if (!Success)
     return 1;
 
   // Execute the frontend actions.
   {
-    llvm::TimeTraceScope TimeScope("ExecuteCompiler");
+    LLVM_TRACE_SCOPE("ExecuteCompiler", StringRef(""));
     Success = ExecuteCompilerInvocation(Clang.get());
   }
 
   // If any timers were active but haven't been destroyed yet, print their
   // results now.  This happens in -disable-free mode.
   llvm::TimerGroup::printAll(llvm::errs());
   llvm::TimerGroup::clearAll();
 

llvm/cmake/config-ix.cmake

else()
             "Install directory for LLVM OCaml packages")
       else()
         message(STATUS "OCaml bindings disabled, need ctypes >=0.4.")
       endif()
     endif()
   endif()
 endif()
 
+include(AddPerfetto)
+
 string(REPLACE " " ";" LLVM_BINDINGS_LIST "${LLVM_BINDINGS}")
 
 function(find_python_module module)
   string(REPLACE "." "_" module_name ${module})
   string(TOUPPER ${module_name} module_upper)
   set(FOUND_VAR PY_${module_upper}_FOUND)
   if (DEFINED ${FOUND_VAR})
     return()

llvm/cmake/modules/AddPerfetto.cmake

+if(PERFETTO)
+  cmake_minimum_required(VERSION 2.8.2)
+  message(STATUS "Perfetto enabled.")
+
+  find_package(Threads)
+
+  include(ExternalProject)
+  ExternalProject_Add(perfetto_git
+      GIT_REPOSITORY https://github.com/google/perfetto.git
+      GIT_TAG releases/v4.x
+      PREFIX "${CMAKE_BINARY_DIR}/perfetto"
+      CONFIGURE_COMMAND ""
+      BUILD_COMMAND ""
+      INSTALL_COMMAND ""
+      LOG_DOWNLOAD ON
+      LOG_INSTALL ON
+      BUILD_BYPRODUCTS "perfetto/src/perfetto_git/sdk/perfetto.cc"
+      BUILD_BYPRODUCTS "perfetto/src/perfetto_git/sdk/perfetto.h"
+  )
+  ExternalProject_Get_Property(perfetto_git source_dir)
+  include_directories(${source_dir}/sdk)
+  add_library(perfetto STATIC IMPORTED)
+      set_target_properties(perfetto PROPERTIES
+      IMPORTED_LOCATION ${source_dir}/sdk/perfetto.cc
+  )
+  add_dependencies(perfetto perfetto_git)
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPERFETTO=1")
+endif()

llvm/include/llvm/Support/PerfettoTracer.h

+#ifndef PERFETTO_TRACE_CATEGORIES_H
+#define PERFETTO_TRACE_CATEGORIES_H
+
+#ifdef PERFETTO
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+#include <perfetto.h>
+
+// The set of track event categories that the example is using.
+PERFETTO_DEFINE_CATEGORIES(
+    perfetto::Category("frontend").SetDescription("Frontend events"),
+    perfetto::Category("backend").SetDescription("Backend events"),
+    perfetto::Category("clang").SetDescription("Trace for main()"));
+
+class PerfettoProfiler {
+  std::unique_ptr<perfetto::TracingSession> TracingSession;
+  std::unique_ptr<llvm::raw_pwrite_stream> OS;
+
+public:
+  PerfettoProfiler(std::unique_ptr<llvm::raw_pwrite_stream> os);
+  ~PerfettoProfiler();
+};
+
+struct Entry {
+  uint64_t BeginTime;
+  std::string Name;
+  std::string Detail;
+  Entry(uint64_t begin, std::string name, std::string detail)
+      : BeginTime(begin), Name(name), Detail(detail){};
+};
+
+bool PerfettoTracingEnabled();
+uint64_t PerfettoGetGranularity();
+extern llvm::SmallVector<Entry, 16> PerfettoStack;
+
+#define PERFETTO_TRACE_EVENT_BEGIN(name, detail)                               \
+  if (PerfettoTracingEnabled()) {                                              \
+    PerfettoStack.push_back(                                                   \
+        Entry(perfetto::internal::TrackEventInternal::GetTimeNs(),             \
+              std::string(name), (detail).str()));                             \
+  }
+
+#define PERFETTO_TRACE_EVENT_END()                                             \
+  if (PerfettoTracingEnabled()) {                                              \
+    uint64_t EndTime = perfetto::internal::TrackEventInternal::GetTimeNs();    \
+    Entry e = PerfettoStack.back();                                            \
+    PerfettoStack.pop_back();                                                  \
+    if (EndTime - e.BeginTime > PerfettoGetGranularity()) {                    \
+      TRACE_EVENT_BEGIN("clang", "", e.BeginTime,                              \
+                        [&](perfetto::EventContext ctx) {                      \
+                          auto event = ctx.event();                            \
+                          event->set_name_iid(0);                              \
+                          event->set_name(e.Name);                             \
+                          auto debug = event->add_debug_annotations();         \
+                          debug->set_name("detail");                           \
+                          debug->set_string_value(e.Detail);                   \
+                        });                                                    \
+      TRACE_EVENT_END("clang", EndTime, [&](perfetto::EventContext ctx) {});   \
+    }                                                                          \
+  }
+
+#define PERFETTO_TRACE_EVENT_SCOPE(name, detail)                               \
+  FREQUENT_TRACE_EVENT_LAMBDA("clang", name, [&](perfetto::EventContext ctx) { \
+    auto event = ctx.event();                                                  \
+    auto debug = event->add_debug_annotations();                               \
+    debug->set_name("detail");                                                 \
+    debug->set_string_value((detail).str());                                   \
+  })
+
+// Custom TRACE_EVENT macro for events that are usually high frequency
+// and very short. Only records the trace events if the slice is above
+// the minimum required theshold.
+//
+// Can take a constexpr string and an optional non-constexpr string to
+// be appended.
+#define FREQUENT_TRACE_EVENT_LAMBDA(category, name, lambda)                    \
+  struct PERFETTO_UID(ScopedEvent) {                                           \
+    struct EventFinalizer {                                                    \
+      std::function<void(perfetto::EventContext)> lambda__;                    \
+      uint64_t BeginTimestamp = 0;                                             \
+      uint64_t EndTimestamp = 0;                                               \
+      EventFinalizer(std::function<void(perfetto::EventContext)> l) {          \
+        if (PerfettoTracingEnabled()) {                                        \
+          BeginTimestamp =                                                     \
+              perfetto::internal::TrackEventInternal::GetTimeNs();             \
+          lambda__ = l;                                                        \
+        }                                                                      \
+      }                                                                        \
+      ~EventFinalizer() {                                                      \
+        if (PerfettoTracingEnabled()) {                                        \
+          EndTimestamp = perfetto::internal::TrackEventInternal::GetTimeNs();  \
+          if (EndTimestamp - BeginTimestamp > PerfettoGetGranularity()) {      \
+            TRACE_EVENT_BEGIN(category, name, BeginTimestamp, lambda__);       \
+            TRACE_EVENT_END(category, EndTimestamp,                            \
+                            [&](perfetto::EventContext ctx) {});               \
+          }                                                                    \
+        }                                                                      \
+      }                                                                        \
+    } finalizer;                                                               \
+  } PERFETTO_UID(scoped_event){{lambda}};
+
+#else
+#define PERFETTO_TRACE_EVENT_BEGIN(name, detail)
+#define PERFETTO_TRACE_EVENT_END()
+#define PERFETTO_TRACE_EVENT_SCOPE(name, detail)
+#endif
+
+#endif // PERFETTO_TRACE_CATEGORIES_H

llvm/include/llvm/Support/Tracing.h

+#ifndef TRACING_H
+#define TRACING_H
+
+#include "llvm/Support/PerfettoTracer.h"
+#include "llvm/Support/TimeProfiler.h"
+
+// Generate a unique variable name with a given prefix.
+#define INTERNAL_CONCAT2(a, b) a##b
+#define INTERNAL_CONCAT(a, b) INTERNAL_CONCAT2(a, b)
+#define UID(prefix) INTERNAL_CONCAT(prefix, __LINE__)
+
+#define LLVM_TRACE_BEGIN(name, detail)                                         \
+  if (llvm::timeTraceProfilerEnabled())                                        \
+    llvm::timeTraceProfilerBegin(name, detail);                                \
+  PERFETTO_TRACE_EVENT_BEGIN(name, detail)
+
+#define LLVM_TRACE_END()                                                       \
+  if (llvm::timeTraceProfilerEnabled())                                        \
+    llvm::timeTraceProfilerEnd();                                              \
+  PERFETTO_TRACE_EVENT_END()
+
+#define LLVM_TRACE_SCOPE(name, detail)                                         \
+  llvm::TimeTraceScope UID(TimeScope)(name, detail);                           \
+  PERFETTO_TRACE_EVENT_SCOPE(name, detail)
+
+#endif // TRACING_H

llvm/lib/Analysis/LoopPass.cpp

 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/OptBisect.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/PassTimingInfo.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
+#include "llvm/Support/Tracing.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "loop-pass-manager"
 
 namespace {
 
 /// PrintLoopPass - Print a Function corresponding to a Loop.
#endif
   while (!LQ.empty()) {
     CurrentLoopDeleted = false;
     CurrentLoop = LQ.back();
 
     // Run all passes on the current Loop.
     for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
       LoopPass *P = getContainedPass(Index);
 
-      llvm::TimeTraceScope LoopPassScope("RunLoopPass", P->getPassName());
+      LLVM_TRACE_SCOPE("RunLoopPass", P->getPassName());
 
       dumpPassInfo(P, EXECUTION_MSG, ON_LOOP_MSG,
                    CurrentLoop->getHeader()->getName());
       dumpRequiredSet(P);
 
       initializeAnalysisImpl(P);
 
       bool LocalChanged = false;

llvm/lib/IR/CMakeLists.txt

add_llvm_component_library(LLVMCore
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/IR
 
   LINK_LIBS ${LLVM_PTHREAD_LIB}
 
   DEPENDS
   intrinsics_gen
   )
+
+if(PERFETTO)
+  target_link_libraries(LLVMCore
+    PRIVATE perfetto
+    )
+endif()

llvm/lib/IR/LegacyPassManager.cpp

 #include "llvm/IR/PassTimingInfo.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
-#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
+#include "llvm/Support/Tracing.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <unordered_set>
 using namespace llvm;
 using namespace llvm::legacy;
 
 // See PassManagers.h for Pass Manager infrastructure overview.
 
bool FPPassManager::runOnFunction(Function &F) {
   StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount;
   bool EmitICRemark = M.shouldEmitInstrCountChangedRemark();
   // Collect the initial size of the module.
   if (EmitICRemark) {
     InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount);
     FunctionSize = F.getInstructionCount();
   }
 
-  llvm::TimeTraceScope FunctionScope("OptFunction", F.getName());
+  LLVM_TRACE_SCOPE("OptFunction", F.getName());
 
   for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
     FunctionPass *FP = getContainedPass(Index);
     bool LocalChanged = false;
 
-    llvm::TimeTraceScope PassScope("RunPass", FP->getPassName());
+    LLVM_TRACE_SCOPE("RunPass", FP->getPassName());
 
     dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getName());
     dumpRequiredSet(FP);
 
     initializeAnalysisImpl(FP);
 
     {
       PassManagerPrettyStackEntry X(FP, F);

 //===----------------------------------------------------------------------===//
 // MPPassManager implementation
 
 /// Execute all of the passes scheduled for execution by invoking
 /// runOnModule method.  Keep track of whether any of the passes modifies
 /// the module, and if so, return true.
 bool
 MPPassManager::runOnModule(Module &M) {
-  llvm::TimeTraceScope TimeScope("OptModule", M.getName());
+  LLVM_TRACE_SCOPE("OptModule", M.getName());
 
   bool Changed = false;
 
   // Initialize on-the-fly passes
   for (auto &OnTheFlyManager : OnTheFlyManagers) {
     FunctionPassManagerImpl *FPP = OnTheFlyManager.second;
     Changed |= FPP->doInitialization(M);
   }

llvm/lib/Support/CMakeLists.txt

add_llvm_component_library(LLVMSupport
   MathExtras.cpp
   MemAlloc.cpp
   MemoryBuffer.cpp
   MD5.cpp
   NativeFormatting.cpp
   OptimizedStructLayout.cpp
   Optional.cpp
   Parallel.cpp
+  PerfettoTracer.cpp
   PluginLoader.cpp
   PrettyStackTrace.cpp
   RandomNumberGenerator.cpp
   Regex.cpp
   RISCVAttributes.cpp
   RISCVAttributeParser.cpp
   ScaledNumber.cpp
   ScopedPrinter.cpp

llvm/lib/Support/PerfettoTracer.cpp

+#ifdef PERFETTO
+#include "llvm/Support/Tracing.h"
+
+using namespace llvm;
+
+bool PerfettoEnabled = false;
+uint64_t PerfettoGranularityNS = 2 * 1000 * 1000;
+SmallVector<Entry, 16> PerfettoStack;
+
+PerfettoProfiler::PerfettoProfiler(std::unique_ptr<raw_pwrite_stream> os)
+    : OS(std::move(os)) {
+  perfetto::TracingInitArgs args;
+  // The backends determine where trace events are recorded. For this example we
+  // are going to use the in-process tracing service, which only includes in-app
+  // events.
+  args.backends = perfetto::kInProcessBackend;
+
+  perfetto::Tracing::Initialize(args);
+  perfetto::TrackEvent::Register();
+
+  // The trace config defines which types of data sources are enabled for
+  // recording. In this example we just need the "track_event" data source,
+  // which corresponds to the TRACE_EVENT trace points.
+  perfetto::TraceConfig cfg;
+  cfg.add_buffers()->set_size_kb(32384);
+  auto *ds_cfg = cfg.add_data_sources()->mutable_config();
+  ds_cfg->set_name("track_event");
+
+  TracingSession = perfetto::Tracing::NewTrace();
+  TracingSession->Setup(cfg);
+  TracingSession->StartBlocking();
+  PerfettoEnabled = true;
+}
+
+PerfettoProfiler::~PerfettoProfiler() {
+  // Make sure the last event is closed for this example.
+  perfetto::TrackEvent::Flush();
+  // Stop tracing and read the trace data.
+  TracingSession->StopBlocking();
+  std::vector<char> trace_data(TracingSession->ReadTraceBlocking());
+  // Write the result into a file.
+  // Note: To save memory with longer traces, you can tell Perfetto to write
+  // directly into a file by passing a file descriptor into Setup() above.
+  OS->write(&trace_data[0], trace_data.size());
+  OS->flush();
+}
+
+bool PerfettoTracingEnabled() { return PerfettoEnabled; }
+
+uint64_t PerfettoGetGranularity() { return PerfettoGranularityNS; }
+
+// Reserves internal static storage for our tracing categories.
+PERFETTO_TRACK_EVENT_STATIC_STORAGE();
+#endif