Address non-test review comments.

Author: bd1976bris

clang/include/clang/Driver/Options.td

@@ -4092,7 +4092,7 @@ def fno_finite_loops: Flag<["-"], "fno-finite-loops">, Group<f_Group>,
   HelpText<"Do not assume that any loop is finite.">,
   Visibility<[ClangOption, CC1Option]>;
 def fthinlto_distributor_EQ : Joined<["-"], "fthinlto-distributor=">, Group<f_Group>,
-  HelpText<"Specifies the <path> to the distributor process executable.">, MetaVarName<"<path>">,
+  HelpText<"Specifies the <path> to the distributor process executable">, MetaVarName<"<path>">,
   Visibility<[ClangOption, CLOption]>;
 def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>,
   HelpText<"Process trigraph sequences">, Visibility<[ClangOption, CC1Option]>;

clang/lib/Driver/ToolChains/Gnu.cpp

@@ -540,7 +540,6 @@ void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   // do LTO or not dependent upon whether there are any bitcode input files in
   // the link.
   if (Arg *A = Args.getLastArg(options::OPT_fthinlto_distributor_EQ)) {
-    A->claim();
     CmdArgs.push_back(
         Args.MakeArgString("--thinlto-distributor=" + Twine(A->getValue())));
     CmdArgs.push_back(

lld/COFF/Config.h

@@ -193,9 +193,9 @@ struct Configuration {
   llvm::CachePruningPolicy ltoCachePolicy;
 
   // Used for --thinlto-distributor=
-  StringRef DTLTODistributor;
+  StringRef dtltoDistributor;
   // Used for --thinlto-remote-opt-tool=
-  StringRef DTLTORemoteOptTool;
+  StringRef dtltoRemoteOptTool;
 
   // Used for /opt:[no]ltodebugpassmanager
   bool ltoDebugPassManager = false;

lld/COFF/Driver.cpp

@@ -1519,7 +1519,7 @@ void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
     config->mllvmOpts.emplace_back(arg->getValue());
   }
 
-  if (!ctx.config.DTLTODistributor.empty())
+  if (!ctx.config.dtltoDistributor.empty())
     for (auto o : {"-thinlto-remote-opt-tool-arg=-fdiagnostics-format",
                    "-thinlto-remote-opt-tool-arg=msvc"}) {
       v.push_back(o);
@@ -2090,8 +2090,8 @@ void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   }
 
   // Handle DTLTO options.
-  config->DTLTODistributor = args.getLastArgValue(OPT_thinlto_distributor_eq);
-  config->DTLTORemoteOptTool =
+  config->dtltoDistributor = args.getLastArgValue(OPT_thinlto_distributor_eq);
+  config->dtltoRemoteOptTool =
       args.getLastArgValue(OPT_thinlto_remote_opt_tool_eq);
 
   // Handle /dwodir

lld/COFF/LTO.cpp

@@ -117,7 +117,7 @@ BitcodeCompiler::BitcodeCompiler(COFFLinkerContext &c) : ctx(c) {
 
   // Initialize ltoObj.
   lto::ThinBackend backend;
-  if (!ctx.config.DTLTODistributor.empty()) {
+  if (!ctx.config.dtltoDistributor.empty()) {
     StringRef version = getenv("LLD_VERSION"); // For testing only.
     if (version.empty())
       version = ctx.saver.save(getLLDVersion());
@@ -126,7 +126,7 @@ BitcodeCompiler::BitcodeCompiler(COFFLinkerContext &c) : ctx(c) {
         /*OnWrite=*/nullptr,
         /*ShouldEmitIndexFiles=*/false,
         /*ShouldEmitImportFiles=*/false, ctx.config.outputFile, version,
-        ctx.config.DTLTORemoteOptTool, ctx.config.DTLTODistributor,
+        ctx.config.dtltoRemoteOptTool, ctx.config.dtltoDistributor,
         !ctx.config.saveTempsArgs.empty());
   } else if (ctx.config.thinLTOIndexOnly) {
     auto OnIndexWrite = [&](StringRef S) { thinIndices.erase(S); };

lld/ELF/Config.h

@@ -243,8 +243,8 @@ struct Config {
   llvm::SmallVector<llvm::StringRef, 0> searchPaths;
   llvm::SmallVector<llvm::StringRef, 0> symbolOrderingFile;
   llvm::SmallVector<llvm::StringRef, 0> thinLTOModulesToCompile;
-  llvm::StringRef DTLTODistributor;
-  llvm::StringRef DTLTORemoteOptTool;
+  llvm::StringRef dtltoDistributor;
+  llvm::StringRef dtltoRemoteOptTool;
   llvm::SmallVector<llvm::StringRef, 0> undefined;
   llvm::SmallVector<SymbolVersion, 0> dynamicList;
   llvm::SmallVector<uint8_t, 0> buildIdVector;

lld/ELF/Driver.cpp

@@ -1341,8 +1341,8 @@ static void readConfigs(Ctx &ctx, opt::InputArgList &args) {
       args.hasFlag(OPT_dependent_libraries, OPT_no_dependent_libraries, true);
   ctx.arg.disableVerify = args.hasArg(OPT_disable_verify);
   ctx.arg.discard = getDiscard(args);
-  ctx.arg.DTLTODistributor = args.getLastArgValue(OPT_thinlto_distributor_eq);
-  ctx.arg.DTLTORemoteOptTool =
+  ctx.arg.dtltoDistributor = args.getLastArgValue(OPT_thinlto_distributor_eq);
+  ctx.arg.dtltoRemoteOptTool =
       args.getLastArgValue(OPT_thinlto_remote_opt_tool_eq);
   ctx.arg.dwoDir = args.getLastArgValue(OPT_plugin_opt_dwo_dir_eq);
   ctx.arg.dynamicLinker = getDynamicLinker(ctx, args);

lld/ELF/InputFiles.cpp

@@ -1703,9 +1703,8 @@ static uint8_t getOsAbi(const Triple &t) {
   }
 }
 
-namespace dtlto {
 // Check if an archive file is a thin archive.
-bool isThinArchive(Ctx &ctx, StringRef archiveFilePath) {
+static bool isThinArchive(Ctx &ctx, StringRef archiveFilePath) {
   const size_t thinArchiveMagicLen = sizeof(ThinArchiveMagic) - 1;
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> memBufferOrError =
@@ -1720,8 +1719,9 @@ bool isThinArchive(Ctx &ctx, StringRef archiveFilePath) {
 }
 
 // Compute a thin archive member full file path.
-std::string computeFullThinArchiveMemberPath(const StringRef modulePath,
-                                             const StringRef archiveName) {
+static std::string
+computeThinArchiveMemberFullPath(const StringRef modulePath,
+                                 const StringRef archiveName) {
   assert(!archiveName.empty());
   SmallString<64> archiveMemberPath;
   if (path::is_relative(modulePath)) {
@@ -1733,7 +1733,6 @@ std::string computeFullThinArchiveMemberPath(const StringRef modulePath,
   path::remove_dots(archiveMemberPath, /*remove_dot_dot=*/true);
   return archiveMemberPath.c_str();
 }
-} // namespace dtlto
 
 BitcodeFile::BitcodeFile(Ctx &ctx, MemoryBufferRef mb, StringRef archiveName,
                          uint64_t offsetInArchive, bool lazy)
@@ -1746,11 +1745,11 @@ BitcodeFile::BitcodeFile(Ctx &ctx, MemoryBufferRef mb, StringRef archiveName,
     path = replaceThinLTOSuffix(ctx, mb.getBufferIdentifier());
 
   // For DTLTO the name needs to be a valid path to a bitcode file.
-  bool dtltoThinArchiveHandling = !ctx.arg.DTLTODistributor.empty() &&
+  bool dtltoThinArchiveHandling = !ctx.arg.dtltoDistributor.empty() &&
                                   !archiveName.empty() &&
-                                  dtlto::isThinArchive(ctx, archiveName);
+                                  isThinArchive(ctx, archiveName);
   if (dtltoThinArchiveHandling)
-    path = dtlto::computeFullThinArchiveMemberPath(path, archiveName);
+    path = computeThinArchiveMemberFullPath(path, archiveName);
 
   // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
   // name. If two archives define two members with the same name, this

lld/ELF/LTO.cpp

@@ -187,15 +187,15 @@ BitcodeCompiler::BitcodeCompiler(Ctx &ctx) : ctx(ctx) {
         std::string(ctx.arg.thinLTOPrefixReplaceNew),
         std::string(ctx.arg.thinLTOPrefixReplaceNativeObject),
         ctx.arg.thinLTOEmitImportsFiles, indexFile.get(), onIndexWrite);
-  } else if (!ctx.arg.DTLTODistributor.empty() && !ctx.bitcodeFiles.empty()) {
+  } else if (!ctx.arg.dtltoDistributor.empty() && !ctx.bitcodeFiles.empty()) {
     StringRef version = getenv("LLD_VERSION"); // For testing only.
     if (version.empty())
       version = ctx.saver.save(getLLDVersion());
     backend = lto::createOutOfProcessThinBackend(
         llvm::heavyweight_hardware_concurrency(ctx.arg.thinLTOJobs),
         onIndexWrite, ctx.arg.thinLTOEmitIndexFiles,
         ctx.arg.thinLTOEmitImportsFiles, ctx.arg.outputFile, version,
-        ctx.arg.DTLTORemoteOptTool, ctx.arg.DTLTODistributor,
+        ctx.arg.dtltoRemoteOptTool, ctx.arg.dtltoDistributor,
         !ctx.arg.saveTempsArgs.empty());
   } else {
     backend = lto::createInProcessThinBackend(

lld/docs/DTLTO.rst

@@ -15,11 +15,11 @@ ELF LLD
 
 The command line interface for DTLTO is:
 
-- `--thinlto-distributor=<path>`
+- ``--thinlto-distributor=<path>``
   Specifies the file to execute as a distributor process.
   If specified, ThinLTO backend compilations will be distributed.
 
-- `--thinlto-remote-opt-tool=<path>`
+- ``--thinlto-remote-opt-tool=<path>``
   Specifies the path to the tool that the distributor process will use for
   backend compilations.
 
@@ -30,10 +30,10 @@ The command line interface for DTLTO is:
   This may occur in the future, at which point a different set of constraints
   will apply.
 
-- `-mllvm -thinlto-distributor-arg=<arg>`  
+- ``-mllvm -thinlto-distributor-arg=<arg>``
   Specifies `<arg>` on the command line when invoking the distributor.  
 
-- `-mllvm -thinlto-remote-opt-tool-arg=<arg>`  
+- ``-mllvm -thinlto-remote-opt-tool-arg=<arg>``
   Specifies `<arg>` on the command line to the remote optimisation tool. These
   arguments are appended to the end of the command line for the remote 
   optimisation tool.
@@ -44,10 +44,10 @@ properties of the distribution system (as such additional input/output files may
 not be pushed to or fetched from distribution system nodes correctly). If such 
 options are required, then the distributor can be modified to accept switches 
 that specify additional input/output dependencies, and 
-`-Xdist`/`-thinlto-distributor-arg=` can be used to pass such options through 
+``-Xdist``/``-thinlto-distributor-arg=`` can be used to pass such options through 
 to the distributor.
 
-Some LLD LTO options (e.g., `--lto-sample-profile=<file>`) are supported. 
+Some LLD LTO options (e.g., ``--lto-sample-profile=<file>``) are supported. 
 Currently, other options are silently accepted but do not have the desired 
 effect. Support for such options will be expanded in the future.
 
@@ -56,5 +56,5 @@ COFF LLD
 
 The command line interface for COFF LLD is generally the same as for ELF LLD.
 
-Currently, there is no DTLTO command line interface supplied for `Clang-cl`, as
+Currently, there is no DTLTO command line interface supplied for ``Clang-cl``, as
 users are expected to invoke LLD directly.