[Clang] Change -ftime-trace storing path and support multiple compilation jobs

[Maetveis]

Summary

This is an alternative approach for D131469.

The difference in behavior compared to D131469 is that instead of looking for linking jobs, here if a "main" output is available ('-o <output>' is given) the directory of it is used for '-ftime-trace'.
Another is that time traces in offloading tool-chain (e.g. CUDA or HIP) compilation steps are also supported by saving them to the same directory as the host trace, with naming similar to '-save-temps'.
If '-save temps' is on the file type suffix is also included to keep the trace from e.g the front-end compilation overwriting the back-end trace.

The final behavior is this:

• if '-ftime-trace=path/to/trace.json' is given, then use it for the final compilation, and use the directory where it is for the rest (offloading or '-save-temps')
• if '-ftime-trace=path/to/trace/folder' is given:
  • for the main output use 'path/to/trace/folder/<output-name>,json' if '-o <output-name>.o' is given
  • if no output path is specified or for the rest of the files use 'path/to/trace/folder/<input-name>.json' similar to '-save-temps'
• if '-ftime-trace' is given and there is a main output ('-o output') use the directory of it to store the traces
• if '-ftime-trace' but no '-o <output>' use the current working directory

The patch also drops '-ftime-trace' from cc1 options as the driver now always passes the full path in '-ftime-trace=<path>'

[jamieschmeiser]

I'm a little confused as to what is being proposed here. Is this building on D131469 or is it an alternative? It seems that there are portions of the code from D131469 included in these changes, which implies that you are building on it. I think this patch is premature in that the other patch has not yet landed (@MaskRay has asked for revisions that @dongjunduo has made but is waiting for review). When that patch has landed, this could be reposted based on those changes.

[Maetveis]

In D133662#3787250, @jamieschmeiser wrote:

I'm a little confused as to what is being proposed here. Is this building on D131469 or is it an alternative? It seems that there are portions of the code from D131469 included in these changes, which implies that you are building on it. I think this patch is premature in that the other patch has not yet landed (@MaskRay has asked for revisions that @dongjunduo has made but is waiting for review). When that patch has landed, this could be reposted based on those changes.

Yes, there is some code taken from D131469, mainly removing the -ftime-trace file logic from cc1.
The way the paths on where to store the traces are different both in implementation and in behaviour.
D131469 is rewriting the arguements for already created jobs and infers the path based on a link job.
This patch sets up the time trace path for each job that supports it, so it can be read during assembling of the commands. The location is based on the final output (-o <out>) and the file names are based on the inputs instead of the output names (similar to -save-temps).

I felt that this is a different approach, that might not be taken once D131469 is accepted. If it's better to leave these points as suggestions on D131469, than I can summarize them over there.
Waiting for it to land is also fine for me.

[MaskRay]

At a glance the approach looks more elegant to me, but I haven't studied this carefully yet. Also thanks for checking how to handle offloading.

[MaskRay]

clang/include/clang/Driver/Compilation.h

134

I don't think we should use a non-zero inline element for these members.
They are, in 99.9% cases, empty. We should optimize for the member size by making the number of inline element to 0.

[Maetveis]

Remove inline elements from the map. Add tests. With the tests I now consider this complete, so removed the draft from the title.

[jamieschmeiser]

I had an email exchange with @dongjunduo about this situation. He was a GSoC student that @Whitney and I were mentoring for the past summer. He agrees that your approach is cleaner. There appears to be two parts to your work. First, you implemented the determining and passing of the options differently, and secondly, you improved the handling of off-loading and system specific file handling. Based on your earlier response, we proposed to him the following and he agrees that it seems appropriate. Could you please add comments to https://reviews.llvm.org/D131469 and he will work with you to change his code to reflect searching for -o and using the virtual functions. Then, if @MaskRay agrees, he can land his code and finish up his GSoC work. You can then add your extensions of off-loading and file-handling. Is this acceptable to you?

[Maetveis]

In D133662#3798276, @jamieschmeiser wrote:

I had an email exchange with @dongjunduo about this situation. He was a GSoC student that @Whitney and I were mentoring for the past summer. He agrees that your approach is cleaner. There appears to be two parts to your work. First, you implemented the determining and passing of the options differently, and secondly, you improved the handling of off-loading and system specific file handling. Based on your earlier response, we proposed to him the following and he agrees that it seems appropriate. Could you please add comments to https://reviews.llvm.org/D131469 and he will work with you to change his code to reflect searching for -o and using the virtual functions. Then, if @MaskRay agrees, he can land his code and finish up his GSoC work. You can then add your extensions of off-loading and file-handling. Is this acceptable to you?

Yes, I can gladly do that.

I'm sorry for the confusion this must have caused for you and @dongjunduo, my intention was not judgment on the code he posted, rather seeing his code motivated me to post my own changes, that I've been working on beforehand., Some of his code gave me the right ideas, so I'm happy to share the credit for it. Let's make his contribution better together!

[jamieschmeiser]

Great. Also, something you may want to consider, either as part of or after you land this code. This really is a specific instance of a more generic problem: setting up option handling for something that saves results in a file for each compilation. This is equally useful for other things such as listings and could also be used by something like print-changed (which currently just outputs to the stream), opt stats reporting, etc. This code could be organized as a function (or possibly an object, depends...) that takes a string for the extension, a lambda/template for the virtual call on whether to add the option to a tool so that off-handling, platform-isms, and where files are saved would all be captured neatly and would be re-usable. InferTimeTrace and getPath, off-loading, platform-isms would be captured in a generic call that would look something like (in this instance)

PerFileTraceGenerator(".json",
     [](Tool &T, Args &Args)->bool{ return T->supportsTimeTrace() && Args.hasArg(options::OPT_ftime_trace, options::OPT_ftime_trace_EQ; },
     "-ftime-trace=");

Each option that needs per file output would just call this function appropriately.

clang/include/clang/Driver/Compilation.h

class Compilation {
   bool ForDiagnostics = false;
 
   /// Whether an error during the parsing of the input args.
   bool ContainsError;
 
   /// Whether to keep temporary files regardless of -save-temps.
   bool ForceKeepTempFiles = false;
 
+  StringRef TimeTracePath;
+
+  llvm::DenseMap<const JobAction *, const char *> TimeTraceFiles;
+
 public:
   Compilation(const Driver &D, const ToolChain &DefaultToolChain,
               llvm::opt::InputArgList *Args,
               llvm::opt::DerivedArgList *TranslatedArgs, bool ContainsError);
   ~Compilation();
 
   const Driver &getDriver() const { return TheDriver; }
 
public:
 
   /// addFailureResultFile - Add a file to remove if we crash, and returns its
   /// argument.
   const char *addFailureResultFile(const char *Name, const JobAction *JA) {
     FailureResultFiles[JA] = Name;
     return Name;
   }
 
+  void setTimeTraceFileForJob(const JobAction *JA,
+                              const char *TimeTraceFileName) {
+    TimeTraceFiles[JA] = TimeTraceFileName;
+  }
+
+  const char *getTimeTraceFileForJob(const JobAction *JA) const {
+    return TimeTraceFiles.lookup(JA);
+  }
+
+  void setTimeTracePath(llvm::StringRef _TimeTracePath) {
+    TimeTracePath = _TimeTracePath;
+  }
+
+  llvm::StringRef getTimeTracePath() const { return TimeTracePath; }
+
   /// CleanupFile - Delete a given file.
   ///
   /// \param IssueErrors - Report failures as errors.
   /// \return Whether the file was removed successfully.
   bool CleanupFile(const char *File, bool IssueErrors = false) const;
 
   /// CleanupFileList - Remove the files in the given list.
   ///

clang/include/clang/Driver/Driver.h

private:
   /// building jobs for the Action's inputs.
   InputInfoList BuildJobsForActionNoCache(
       Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch,
       bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput,
       std::map<std::pair<const Action *, std::string>, InputInfoList>
           &CachedResults,
       Action::OffloadKind TargetDeviceOffloadKind) const;
 
+  const char *getTimeTraceOutputPath(Compilation &C, const JobAction &JA,
+                                     StringRef OrigFileName,
+                                     StringRef OrigBoundArch, bool AtTopLevel,
+                                     bool MultipleArchs,
+                                     StringRef OffloadingPrefix) const;
+
 public:
   /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and
   /// return the grouped values as integers. Numbers which are not
   /// provided are set to 0.
   ///
   /// \return True if the entire string was parsed (9.2), or all
   /// groups were parsed (10.3.5extrastuff). HadExtra is true if all
   /// groups were parsed but extra characters remain at the end.

clang/include/clang/Driver/Options.td

def ftime_report_EQ: Joined<["-"], "ftime-report=">, Group<f_Group>,
   HelpText<"(For new pass manager) 'per-pass': one report for each pass; "
            "'per-pass-run': one report for each pass invocation">;
 def ftime_trace : Flag<["-"], "ftime-trace">, Group<f_Group>,
   HelpText<"Turn on time profiler. Generates JSON file based on output filename.">,
   DocBrief<[{
 Turn on time profiler. Generates JSON file based on output filename. Results
 can be analyzed with chrome://tracing or `Speedscope App
 <https://www.speedscope.app>`_ for flamegraph visualization.}]>,
-  Flags<[CC1Option, CoreOption]>,
-  MarshallingInfoFlag<FrontendOpts<"TimeTrace">>;
+  Flags<[CoreOption]>;
 def ftime_trace_granularity_EQ : Joined<["-"], "ftime-trace-granularity=">, Group<f_Group>,
   HelpText<"Minimum time granularity (in microseconds) traced by time profiler">,
   Flags<[CC1Option, CoreOption]>,
   MarshallingInfoInt<FrontendOpts<"TimeTraceGranularity">, "500u">;
 def ftime_trace_EQ : Joined<["-"], "ftime-trace=">, Group<f_Group>,
   HelpText<"Similar to -ftime-trace. Specify the JSON file or a directory which will contain the JSON file">,
   Flags<[CC1Option, CoreOption]>,
   MarshallingInfoString<FrontendOpts<"TimeTracePath">>;

clang/include/clang/Driver/Tool.h

public:
   virtual bool hasIntegratedCPP() const = 0;
   virtual bool isLinkJob() const { return false; }
   virtual bool isDsymutilJob() const { return false; }
 
   /// Does this tool have "good" standardized diagnostics, or should the
   /// driver add an additional "command failed" diagnostic on failures.
   virtual bool hasGoodDiagnostics() const { return false; }
 
+  virtual bool supportsTimeTrace() const { return false; }
+
   /// ConstructJob - Construct jobs to perform the action \p JA,
   /// writing to \p Output and with \p Inputs, and add the jobs to
   /// \p C.
   ///
   /// \param TCArgs - The argument list for this toolchain, with any
   /// tool chain specific translations applied.
   /// \param LinkingOutput - If this output will eventually feed the
   /// linker, then this is the final output name of the linked image.

clang/include/clang/Frontend/FrontendOptions.h

public:
   unsigned ShowHelp : 1;
 
   /// Show frontend performance metrics and statistics.
   unsigned ShowStats : 1;
 
   /// print the supported cpus for the current target
   unsigned PrintSupportedCPUs : 1;
 
-  /// Output time trace profile.
-  unsigned TimeTrace : 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:
   unsigned TimeTraceGranularity;
 
   /// Path which stores the output files for -ftime-trace
   std::string TimeTracePath;
 
 public:
   FrontendOptions()
       : DisableFree(false), RelocatablePCH(false), ShowHelp(false),
-        ShowStats(false), TimeTrace(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),
-        BuildingImplicitModuleUsesLock(true), ModulesEmbedAllFiles(false),
-        IncludeTimestamps(true), UseTemporary(true),
-        AllowPCMWithCompilerErrors(false), ModulesShareFileManager(true),
-        TimeTraceGranularity(500) {}
+        ShowStats(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), BuildingImplicitModuleUsesLock(true),
+        ModulesEmbedAllFiles(false), IncludeTimestamps(true),
+        UseTemporary(true), AllowPCMWithCompilerErrors(false),
+        ModulesShareFileManager(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/Driver/Driver.cpp

Action *Driver::ConstructPhaseAction(
   }
   case phases::Assemble:
     return C.MakeAction<AssembleJobAction>(std::move(Input), types::TY_Object);
   }
 
   llvm_unreachable("invalid phase in ConstructPhaseAction");
 }
 
+// Infer data storing path of the options `-ftime-trace`, `-ftime-trace=<path>`
+static void inferTimeTracePath(Compilation &C, const Arg *FinalOutput) {
+  const ArgList &Args = C.getArgs();
+  const bool HasTimeTrace = Args.hasArgNoClaim(options::OPT_ftime_trace);
+  const bool HasTimeTraceFile = Args.hasArgNoClaim(options::OPT_ftime_trace_EQ);
+
+  // Whether `-ftime-trace` or `-ftime-trace=<path>` are specified
+  if (!HasTimeTrace && !HasTimeTraceFile)
+    return;
+
+  if (HasTimeTraceFile) {
+    StringRef TracePath =
+        Args.getLastArgNoClaim(options::OPT_ftime_trace_EQ)->getValue();
+    if (!llvm::sys::fs::is_directory(TracePath))
+      TracePath = llvm::sys::path::parent_path(TracePath);
+    C.setTimeTracePath(TracePath);
+    return;
+  }
+
+  if (FinalOutput != nullptr) {
+    C.setTimeTracePath(llvm::sys::path::parent_path(FinalOutput->getValue()));
+    return;
+  }
+
+  // Empty trace path prefix, use the current working directory
+  C.setTimeTracePath(StringRef());
+}
+
+const char *Driver::getTimeTraceOutputPath(Compilation &C, const JobAction &JA,
+                                           StringRef OrigFileName,
+                                           StringRef OrigBoundArch,
+                                           bool AtTopLevel, bool MultipleArchs,
+                                           StringRef OffloadingPrefix) const {
+  StringRef FileName = OrigFileName;
+  if (AtTopLevel) {
+    // Output to a user requested destination?
+    if (const Arg *TimeTraceFile =
+            C.getArgs().getLastArg(options::OPT_ftime_trace_EQ)) {
+      if (!llvm::sys::fs::is_directory(TimeTraceFile->getValue()))
+        return TimeTraceFile->getValue();
+      assert(TimeTraceFile->getValue() == C.getTimeTracePath() &&
+             "C.getTimeTracePath() should match the value of -ftime-trace=");
+    }
+
+    // "-o output.o" -> "output.json"
+    if (const Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
+      FileName = FinalOutput->getValue();
+  }
+  const StringRef Stem = llvm::sys::path::stem(FileName);
+
+  llvm::SmallString<64> BoundArch(OrigBoundArch);
+  if (is_style_windows(llvm::sys::path::Style::native)) {
+    // BoundArch may contains ':', which is invalid in file names on Windows,
+    // therefore replace it with '%'.
+    std::replace(BoundArch.begin(), BoundArch.end(), ':', '@');
+  }
+
+  SmallString<128> TraceFileName(C.getTimeTracePath());
+  llvm::sys::path::append(TraceFileName, Stem);
+  TraceFileName += OffloadingPrefix;
+  if (MultipleArchs && !BoundArch.empty()) {
+    TraceFileName += "-";
+    TraceFileName.append(BoundArch);
+  }
+  if (isSaveTempsEnabled()) {
+    const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode());
+    assert(Suffix && "All types used for output should have a suffix.");
+    TraceFileName += ".";
+    TraceFileName += Suffix;
+  }
+
+  TraceFileName += ".json";
+
+  return C.addResultFile(C.getArgs().MakeArgString(TraceFileName.c_str()), &JA);
+}
+
 void Driver::BuildJobs(Compilation &C) const {
   llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
 
   Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
 
   // It is an error to provide a -o option if we are making multiple output
   // files. There are exceptions:
   //
void Driver::BuildJobs(Compilation &C) const {
 
   // Collect the list of architectures.
   llvm::StringSet<> ArchNames;
   if (RawTriple.isOSBinFormatMachO())
     for (const Arg *A : C.getArgs())
       if (A->getOption().matches(options::OPT_arch))
         ArchNames.insert(A->getValue());
 
+  inferTimeTracePath(C, FinalOutput);
+
   // Set of (Action, canonical ToolChain triple) pairs we've built jobs for.
   std::map<std::pair<const Action *, std::string>, InputInfoList> CachedResults;
   for (Action *A : C.getActions()) {
     // If we are linking an image for multiple archs then the linker wants
     // -arch_multiple and -final_output <final image name>. Unfortunately, this
     // doesn't fit in cleanly because we have to pass this information down.
     //
     // FIXME: This is a hack; find a cleaner way to integrate this into the
std::string OffloadingPrefix = Action::GetOffloadingFileNamePrefix(
             !(A->getOffloadingHostActiveKinds() == Action::OFK_None ||
               AtTopLevel));
     Result = InputInfo(A, GetNamedOutputPath(C, *JA, BaseInput, BoundArch,
                                              AtTopLevel, MultipleArchs,
                                              OffloadingPrefix),
                        BaseInput);
   }
 
+  // Only claim the options if the tool supports '-ftime-trace'
+  if (T->supportsTimeTrace() &&
+      Args.hasArg(options::OPT_ftime_trace, options::OPT_ftime_trace_EQ)) {
+    // We only have to generate a prefix for the host if this is not a top-level
+    // action.
+    std::string OffloadingPrefix = Action::GetOffloadingFileNamePrefix(
+        A->getOffloadingDeviceKind(), TC->getTriple().normalize(),
+        /*CreatePrefixForHost=*/
+        !(A->getOffloadingHostActiveKinds() == Action::OFK_None || AtTopLevel));
+
+    const char *TimeTraceOutputPath =
+        getTimeTraceOutputPath(C, *JA, BaseInput, BoundArch, AtTopLevel,
+                               MultipleArchs, OffloadingPrefix);
+    C.setTimeTraceFileForJob(JA, TimeTraceOutputPath);
+  }
+
   if (CCCPrintBindings && !CCGenDiagnostics) {
     llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"'
                  << " - \"" << T->getName() << "\", inputs: [";
     for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
       llvm::errs() << InputInfos[i].getAsString();
       if (i + 1 != e)
         llvm::errs() << ", ";
     }

clang/lib/Driver/ToolChains/Clang.h

public:
   Clang(const ToolChain &TC, bool HasIntegratedBackend = true);
   ~Clang() override;
 
   bool hasGoodDiagnostics() const override { return true; }
   bool hasIntegratedAssembler() const override { return true; }
   bool hasIntegratedBackend() const override { return HasBackend; }
   bool hasIntegratedCPP() const override { return true; }
   bool canEmitIR() const override { return true; }
+  bool supportsTimeTrace() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 
 /// Clang integrated assembler tool.

clang/lib/Driver/ToolChains/Clang.cpp

 
   Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat);
   Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ);
   Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
   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_report_EQ);
-  Args.AddLastArg(CmdArgs, options::OPT_ftime_trace);
   Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ);
-  Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_EQ);
+
+  if (const char *Name = C.getTimeTraceFileForJob(&JA))
+    CmdArgs.push_back(Args.MakeArgString("-ftime-trace=" + Twine(Name)));
+
   Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
   Args.AddLastArg(CmdArgs, options::OPT_malign_double);
   Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file);
 
   if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
     CmdArgs.push_back("-ftrapv-handler");
     CmdArgs.push_back(A->getValue());
   }

clang/test/Driver/check-time-trace.cpp

 // CHECK-NEXT: "ph":
 // CHECK-NEXT: "pid":
 // CHECK-NEXT: "tid":
 // CHECK-NEXT: "ts":
 // CHECK:      "name": "clang{{.*}}"
 // CHECK:      "name": "process_name"
 // CHECK:      "name": "thread_name"
 
+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: %clangxx -ftime-trace=path/to/trace.json -c -x hip -nogpulib -nogpuinc --offload-arch=gfx803 --offload-arch=gfx900 -### -- %s 2>&1 \
+// RUN:   | FileCheck --check-prefixes=COMMON,FILE %s
+// RUN: %clangxx -ftime-trace=%t -c -x hip -nogpulib -nogpuinc --offload-arch=gfx803 --offload-arch=gfx900 -### -- %s 2>&1 \
+// RUN:   | FileCheck --check-prefixes=COMMON,FOLDER %s
+// RUN: %clangxx -ftime-trace -c -o path/to/output.o -x hip -nogpulib -nogpuinc --offload-arch=gfx803 --offload-arch=gfx900 -### -- %s 2>&1 \
+// RUN:   | FileCheck --check-prefixes=COMMON,OUTPUT %s
+// RUN: %clangxx -ftime-trace -x hip -nogpulib -nogpuinc --offload-arch=gfx803 --offload-arch=gfx900 -### -- %s 2>&1 \
+// RUN:   | FileCheck --check-prefixes=COMMON,NO_OUTPUT %s
+
+// COMMON: "-target-cpu" "gfx803"
+// FILE: "-ftime-trace=path/to/check-time-trace-{{.*}}-gfx803.json"
+// FOLDER: "-ftime-trace=[[BASE:.*]]/check-time-trace-{{.*}}-gfx803.json"
+// OUTPUT: "-ftime-trace=path/to/check-time-trace-{{.*}}-gfx803.json"
+// NO_OUTPUT: "-ftime-trace=check-time-trace-{{.*}}-gfx803.json"
+
+// COMMON: "-target-cpu" "gfx900"
+// FILE: "-ftime-trace=path/to/check-time-trace-{{.*}}-gfx900.json"
+// FOLDER: "-ftime-trace=[[BASE]]/check-time-trace-{{.*}}-gfx900.json"
+// OUTPUT: "-ftime-trace=path/to/check-time-trace-{{.*}}-gfx900.json"
+// NO_OUTPUT: "-ftime-trace=check-time-trace-{{.*}}-gfx900.json"
+
+// COMMON: "-cc1"
+// COMMON-NOT: "-target-cpu" "gfx
+// FILE: "-ftime-trace=path/to/trace.json"
+// FOLDER: "-ftime-trace=[[BASE]]/check-time-trace.json"
+// OUTPUT: "-ftime-trace=path/to/output.json"
+// NO_OUTPUT: "-ftime-trace=check-time-trace-host-{{.*}}.json"
+
+// RUN %clangxx -ftime-trace -save-temps -S -### -- %s 2>&1 | FileCheck --check-prefix=SAVE_TEMPS
+// SAVE_TEMPS: "-E"
+// SAVE_TEMPS: "-ftime-trace=check-time-trace.ii.json"
+// SAVE_TEMPS: "-S"
+// SAVE_TEMPS: "-ftime-trace=check-time-trace.s.json"
+
 template <typename T>
 struct Struct {
   T Num;
 };
 
 int main() {
   Struct<int> S;
 
   return 0;
 }

clang/tools/driver/cc1_main.cpp

int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   // Setup round-trip remarks for the DiagnosticsEngine used in CreateFromArgs.
   if (find(Argv, StringRef("-Rround-trip-cc1-args")) != Argv.end())
     Diags.setSeverity(diag::remark_cc1_round_trip_generated,
                       diag::Severity::Remark, {});
 
   bool Success = CompilerInvocation::CreateFromArgs(Clang->getInvocation(),
                                                     Argv, Diags, Argv0);
 
-  if (Clang->getFrontendOpts().TimeTrace ||
-      !Clang->getFrontendOpts().TimeTracePath.empty()) {
-    Clang->getFrontendOpts().TimeTrace = 1;
+  if (!Clang->getFrontendOpts().TimeTracePath.empty()) {
     llvm::timeTraceProfilerInitialize(
         Clang->getFrontendOpts().TimeTraceGranularity, Argv0);
   }
   // --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.
int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   }
 
   // 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();
 
   if (llvm::timeTraceProfilerEnabled()) {
-    SmallString<128> Path(Clang->getFrontendOpts().OutputFile);
-    llvm::sys::path::replace_extension(Path, "json");
-    if (!Clang->getFrontendOpts().TimeTracePath.empty()) {
-      // replace the suffix to '.json' directly
-      SmallString<128> TracePath(Clang->getFrontendOpts().TimeTracePath);
-      if (llvm::sys::fs::is_directory(TracePath))
-        llvm::sys::path::append(TracePath, llvm::sys::path::filename(Path));
-      Path.assign(TracePath);
-    }
+    const StringRef TracePath = Clang->getFrontendOpts().TimeTracePath;
+    assert(!TracePath.empty() && "`-ftime-trace=<path>` is empty");
     if (auto profilerOutput = Clang->createOutputFile(
-            Path.str(), /*Binary=*/false, /*RemoveFileOnSignal=*/false,
+            TracePath, /*Binary=*/false, /*RemoveFileOnSignal=*/false,
             /*useTemporary=*/false)) {
       llvm::timeTraceProfilerWrite(*profilerOutput);
       profilerOutput.reset();
       llvm::timeTraceProfilerCleanup();
       Clang->clearOutputFiles(false);
     }
   }