[LinkerWrapper] Support remarks files for device LTO

[jhuber6]

Summary

This patch adds the necessary changes to parse the -plugin-opt
arguments that provide the paths for things like
-fsave-optmization-record, allowing these options to be used for
device LTO as well. We still require some form of PGO to fully utilize
these however.

Depends on D129581

clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp

 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/OffloadBinary.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"

 std::unique_ptr<lto::LTO> createLTO(
     const ArgList &Args, const std::vector<std::string> &Features,
     ModuleHook Hook = [](size_t, const Module &) { return true; }) {
   const llvm::Triple Triple(Args.getLastArgValue(OPT_triple_EQ));
   StringRef Arch = Args.getLastArgValue(OPT_arch_EQ);
   lto::Config Conf;
   lto::ThinBackend Backend;
   // TODO: Handle index-only thin-LTO
-  Backend =
-      lto::createInProcessThinBackend(llvm::heavyweight_hardware_concurrency());
+  StringRef Jobs = Args.getLastArgValue(OPT_jobs, "0");
+  Backend = lto::createInProcessThinBackend(
+      llvm::heavyweight_hardware_concurrency(Jobs));
 
   Conf.CPU = Arch.str();
   Conf.Options = codegen::InitTargetOptionsFromCodeGenFlags(Triple);
 
   StringRef OptLevel = Args.getLastArgValue(OPT_opt_level, "2");
   Conf.MAttrs = Features;
   Conf.CGOptLevel = getCGOptLevel(OptLevel[0] - '0');
   Conf.OptLevel = OptLevel[0] - '0';
Conf.PostInternalizeModuleHook = [=](size_t Task, const Module &M) {
         reportError(errorCodeToError(EC));
       WriteBitcodeToFile(M, LinkedBitcode);
       return true;
     };
   }
   Conf.PostOptModuleHook = Hook;
   Conf.CGFileType = Triple.isNVPTX() ? CGFT_AssemblyFile : CGFT_ObjectFile;
 
-  // TODO: Handle remark files
+  Conf.RemarksFilename = (Args.getLastArgValue(OPT_remarks_filename) + "-" +
+                          Triple.getTriple() + "-" + Arch)
+                             .str();
+  Conf.RemarksPasses = Args.getLastArgValue(OPT_remarks_passes).str();
+  Conf.RemarksWithHotness = Args.hasArg(OPT_remarks_with_hotness);
+  Conf.RemarksFormat = Args.getLastArgValue(OPT_remarks_format).str();
+  auto Threshold = remarks::parseHotnessThresholdOption(
+      Args.getLastArgValue(OPT_remarks_hotness_threshold, "-1"));
+  if (!Threshold)
+    reportError(Threshold.takeError());
+  Conf.RemarksHotnessThreshold = *Threshold;
+
   Conf.HasWholeProgramVisibility = Args.hasArg(OPT_whole_program);
 
   return std::make_unique<lto::LTO>(std::move(Conf), Backend);
 }
 
 // Returns true if \p S is valid as a C language identifier and will be given
 // `__start_` and `__stop_` symbols.
 bool isValidCIdentifier(StringRef S) {

clang/tools/clang-linker-wrapper/LinkerWrapperOpts.td

 
 def v : Flag<["--", "-"], "v">, HelpText<"Display the version number and exit">;
 def version : Flag<["--", "-"], "version">, Flags<[HelpHidden]>, Alias<v>;
 
 // Standard flags passed to the plugin for host-LTO.
 def opt_level : Joined<["--", "-"], "plugin-opt=O">, Flags<[HelpHidden, PluginOnlyOption]>,
   HelpText<"Optimization level for LTO">;
 
+def jobs : Joined<["--", "-"], "plugin-opt=jobs=">, Flags<[HelpHidden, PluginOnlyOption]>,
+  HelpText<"Number of jobs for ThinLTO">;
+
+def remarks_filename : Joined<["--", "-"], "plugin-opt=opt-remarks-filename=">,
+  Flags<[HelpHidden, PluginOnlyOption]>, HelpText<"YAML output file for optimization remarks">;
+def remarks_passes : Joined<["--", "-"], "plugin-opt=opt-remarks-passes=">,
+  Flags<[HelpHidden, PluginOnlyOption]>,
+  HelpText<"Regex for the passes that need to be serialized to the output file">;
+def remarks_with_hotness : Flag<["--", "-"], "plugin-opt=opt-remarks-with-hotness">,
+  Flags<[HelpHidden, PluginOnlyOption]>,
+  HelpText<"Regex for the passes that need to be serialized to the output file">;
+def remarks_hotness_threshold : Joined<["--", "-"], "plugin-opt=opt-remarks-hotness-threshold">,
+  Flags<[HelpHidden, PluginOnlyOption]>,
+  HelpText<"Minimum profile count to trigger an optimization">;
+def remarks_format : Joined<["--", "-"], "plugin-opt=opt-remarks-format=">,
+  Flags<[HelpHidden, PluginOnlyOption]>,
+  HelpText<"The format used for serializing remarks (default: YAML)">;
+
 // Sink all the other options here so we can ignore them if needed.
 def plugin_opt : Separate<["--", "-"], "plugin-opt">, Flags<[HelpHidden, PluginOnlyOption]>,
   HelpText<"Options passed to the linker plugin">;
 def plugin_opt_eq : Joined<["--", "-"], "plugin-opt=">, Alias<plugin_opt>;
 def plugin_opt_eq_minus : Joined<["--", "-"], "plugin-opt=-">, Flags<[HelpHidden, PluginOnlyOption]>,
   HelpText<"Options passed to LLVM">;
 
 // The precense of the plugin indicates if the host requires LTO as well.
 def plugin : Separate<["--", "-"], "plugin">, Flags<[HelpHidden]>,
   HelpText<"The plugin passed to the linker">;