llvmorg-github-actions[bot] wrote:

<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-lld

Author: Fangrui Song (MaskRay)

<details>
<summary>Changes</summary>

`RegisterMCToolOptions` adds `MCToolOptions` to the process-wide
registry. Once lld registers them, every later parse in the process
accepts `-crel`, including clang's `-mllvm`, which then ignores it.

Add a `parseCommandLineOptions` overload that takes the libraries a tool
opts in to. Replace `RegisterMCToolOptions` with `mc::getToolOptions`
and `codegen::getToolOptions`, which tools pass where they parse,
including lld's `-mllvm`, gold's `-plugin-opt`, and libLTO's debug
options. `RegisterCodeGenFlags` no longer registers the MC options.

`LibraryOptionsContext` records the library that parsed each argument,
so `assign` replays without looking up the registry, which does not
contain tool options.

LLM-aided

---

&lt;sub&gt;Stack created with &lt;a 
href="https://github.com/github/gh-stack"&gt;GitHub Stacks CLI&lt;/a&gt; • 
&lt;a href="https://gh.io/stacks-feedback"&gt;Give Feedback 
💬&lt;/a&gt;&lt;/sub&gt;

---

Patch is 34.92 KiB, truncated to 20.00 KiB below, full version: 
https://github.com/llvm/llvm-project/pull/240009.diff


32 Files Affected:

- (modified) clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp (+2-1) 
- (modified) clang/tools/clang-nvlink-wrapper/ClangNVLinkWrapper.cpp (+2-1) 
- (modified) lld/COFF/Driver.cpp (+2-1) 
- (modified) lld/Common/TargetOptionsCommandFlags.cpp (+4) 
- (modified) lld/ELF/Driver.cpp (+3-1) 
- (modified) lld/MachO/Driver.cpp (+3-1) 
- (modified) lld/include/lld/Common/TargetOptionsCommandFlags.h (+6) 
- (modified) lld/wasm/Driver.cpp (+2-1) 
- (modified) llvm/docs/CommandLine.md (+1) 
- (modified) llvm/include/llvm/CodeGen/CommandFlags.h (+9) 
- (modified) llvm/include/llvm/FuzzMutate/FuzzerCLI.h (+4-1) 
- (modified) llvm/include/llvm/MC/MCTargetOptionsCommandFlags.h (+5-5) 
- (modified) llvm/include/llvm/Support/CommandLine.h (+12) 
- (modified) llvm/include/llvm/Support/LibraryOptionsContext.h (+4-1) 
- (modified) llvm/lib/CodeGen/CommandFlags.cpp (+3-1) 
- (modified) llvm/lib/FuzzMutate/FuzzerCLI.cpp (+3-2) 
- (modified) llvm/lib/LTO/LTOCodeGenerator.cpp (+2-1) 
- (modified) llvm/lib/MC/MCTargetOptionsCommandFlags.cpp (+4-2) 
- (modified) llvm/lib/Support/CommandLine.cpp (+64-26) 
- (modified) llvm/tools/gold/gold-plugin.cpp (+2-1) 
- (modified) llvm/tools/llc/lib/llcdriver.cpp (+2-1) 
- (modified) llvm/tools/lli/lli.cpp (+2-1) 
- (modified) llvm/tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp (+1-1) 
- (modified) llvm/tools/llvm-lto/llvm-lto.cpp (+2-2) 
- (modified) llvm/tools/llvm-lto2/llvm-lto2.cpp (+2-1) 
- (modified) llvm/tools/llvm-mc/llvm-mc.cpp (+2-3) 
- (modified) llvm/tools/llvm-mca/llvm-mca.cpp (+2-3) 
- (modified) llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp (+1-1) 
- (modified) llvm/tools/llvm-reduce/llvm-reduce.cpp (+2-1) 
- (modified) llvm/tools/lto/lto.cpp (+2-1) 
- (modified) llvm/tools/opt/optdriver.cpp (+2-1) 
- (modified) llvm/unittests/Option/LibraryOptionsTest.cpp (+25) 


``````````diff
diff --git a/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp 
b/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
index 1024d5e6e1a6c8..5c75f88831bbef 100644
--- a/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
+++ b/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
@@ -1558,7 +1558,8 @@ int main(int Argc, char **Argv) {
   for (const opt::Arg *Arg : Args.filtered(OPT_offload_opt_eq_minus))
     NewArgv.push_back(Arg->getValue());
   cl::LibraryOptionsContext LibraryOptions;
-  cl::parseCommandLineOptions(LibraryOptions, NewArgv);
+  cl::parseCommandLineOptions(LibraryOptions, codegen::getToolOptions(),
+                              NewArgv);
 
   Verbose = Args.hasArg(OPT_verbose);
   DryRun = Args.hasArg(OPT_dry_run);
diff --git a/clang/tools/clang-nvlink-wrapper/ClangNVLinkWrapper.cpp 
b/clang/tools/clang-nvlink-wrapper/ClangNVLinkWrapper.cpp
index 9b134b004953ca..b047a76907d661 100644
--- a/clang/tools/clang-nvlink-wrapper/ClangNVLinkWrapper.cpp
+++ b/clang/tools/clang-nvlink-wrapper/ClangNVLinkWrapper.cpp
@@ -823,7 +823,8 @@ int main(int argc, char **argv) {
   for (const opt::Arg *Arg : Args.filtered(OPT_plugin_opt))
     NewArgv.push_back(Arg->getValue());
   cl::LibraryOptionsContext LibraryOptions;
-  cl::parseCommandLineOptions(LibraryOptions, NewArgv);
+  cl::parseCommandLineOptions(LibraryOptions, codegen::getToolOptions(),
+                              NewArgv);
 
   // Get the input files to pass to 'nvlink'.
   auto FilesOrErr = getInput(LibraryOptions, Args);
diff --git a/lld/COFF/Driver.cpp b/lld/COFF/Driver.cpp
index 8580526c0ab4c1..06a938aebdebba 100644
--- a/lld/COFF/Driver.cpp
+++ b/lld/COFF/Driver.cpp
@@ -20,6 +20,7 @@
 #include "lld/Common/Args.h"
 #include "lld/Common/CommonLinkerContext.h"
 #include "lld/Common/Filesystem.h"
+#include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Timer.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
@@ -1656,7 +1657,7 @@ void LinkerDriver::linkerMain(ArrayRef<const char *> 
argsArr) {
   {
     llvm::TimeTraceScope timeScope2("Parse cl::opt");
     cl::ResetAllOptionOccurrences();
-    cl::parseCommandLineOptions(config->libraryOptions, v);
+    cl::parseCommandLineOptions(config->libraryOptions, getToolOptions(), v);
   }
 
   // Handle /errorlimit early, because error() depends on it.
diff --git a/lld/Common/TargetOptionsCommandFlags.cpp 
b/lld/Common/TargetOptionsCommandFlags.cpp
index 180e8c98e1037b..d0baeb47fa32f8 100644
--- a/lld/Common/TargetOptionsCommandFlags.cpp
+++ b/lld/Common/TargetOptionsCommandFlags.cpp
@@ -17,6 +17,10 @@ lld::getTargetOptions(const llvm::cl::LibraryOptionsContext 
&libraryOptions) {
   return llvm::codegen::getTargetOptions(libraryOptions, llvm::Triple());
 }
 
+llvm::ArrayRef<llvm::cl::LibraryOptions *> lld::getToolOptions() {
+  return llvm::codegen::getToolOptions();
+}
+
 std::optional<llvm::Reloc::Model> lld::getRelocModelFromCMModel() {
   return llvm::codegen::getExplicitRelocModel();
 }
diff --git a/lld/ELF/Driver.cpp b/lld/ELF/Driver.cpp
index 08c2fb3b4985fb..10c67fdd8e9f51 100644
--- a/lld/ELF/Driver.cpp
+++ b/lld/ELF/Driver.cpp
@@ -42,6 +42,7 @@
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
+#include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
@@ -1360,7 +1361,8 @@ static void parseClangOption(Ctx &ctx, StringRef opt, 
const Twine &msg) {
   const char *argv[] = {ctx.arg.progName.data(), opt.data()};
   // Called after initLLVM() to ensure target-specific RegisterLibraryOptions
   // have been called.
-  if (cl::parseCommandLineOptions(ctx.arg.libraryOptions, argv, "", &os))
+  if (cl::parseCommandLineOptions(ctx.arg.libraryOptions, getToolOptions(),
+                                  argv, "", &os))
     return;
   ErrAlways(ctx) << msg << ": " << StringRef(err).trim();
 }
diff --git a/lld/MachO/Driver.cpp b/lld/MachO/Driver.cpp
index 525c86d4fc141a..7b88d549fb691a 100644
--- a/lld/MachO/Driver.cpp
+++ b/lld/MachO/Driver.cpp
@@ -30,6 +30,7 @@
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
+#include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
@@ -1126,7 +1127,8 @@ static void parseClangOption(StringRef opt, const Twine 
&msg) {
   raw_string_ostream os(err);
 
   const char *argv[] = {"lld", opt.data()};
-  if (cl::parseCommandLineOptions(config->libraryOptions, argv, "", &os))
+  if (cl::parseCommandLineOptions(config->libraryOptions, getToolOptions(),
+                                  argv, "", &os))
     return;
   error(msg + ": " + StringRef(err).trim());
 }
diff --git a/lld/include/lld/Common/TargetOptionsCommandFlags.h 
b/lld/include/lld/Common/TargetOptionsCommandFlags.h
index 92334bb3ba4ff3..fbbc702542d8a4 100644
--- a/lld/include/lld/Common/TargetOptionsCommandFlags.h
+++ b/lld/include/lld/Common/TargetOptionsCommandFlags.h
@@ -13,13 +13,19 @@
 #ifndef LLD_COMMON_TARGETOPTIONSCOMMANDFLAGS_H
 #define LLD_COMMON_TARGETOPTIONSCOMMANDFLAGS_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Target/TargetOptions.h"
 #include <optional>
 
+namespace llvm::cl {
+class LibraryOptions;
+}
+
 namespace lld {
 llvm::TargetOptions
 getTargetOptions(const llvm::cl::LibraryOptionsContext &libraryOptions);
+llvm::ArrayRef<llvm::cl::LibraryOptions *> getToolOptions();
 std::optional<llvm::Reloc::Model> getRelocModelFromCMModel();
 std::optional<llvm::CodeModel::Model> getCodeModelFromCMModel();
 std::string getCPUStr();
diff --git a/lld/wasm/Driver.cpp b/lld/wasm/Driver.cpp
index e5e6a414519b0d..dedbc9dbd99cb8 100644
--- a/lld/wasm/Driver.cpp
+++ b/lld/wasm/Driver.cpp
@@ -20,6 +20,7 @@
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "lld/Common/Strings.h"
+#include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/llvm-config.h"
@@ -1321,7 +1322,7 @@ void LinkerDriver::linkerMain(ArrayRef<const char *> 
argsArr) {
   for (auto *arg : args.filtered(OPT_mllvm))
     v.push_back(arg->getValue());
   cl::ResetAllOptionOccurrences();
-  cl::parseCommandLineOptions(ctx.arg.libraryOptions, v);
+  cl::parseCommandLineOptions(ctx.arg.libraryOptions, getToolOptions(), v);
 
   readConfigs(args);
   setConfigs();
diff --git a/llvm/docs/CommandLine.md b/llvm/docs/CommandLine.md
index 00e293a12be1d0..8c7a601e6d7a29 100644
--- a/llvm/docs/CommandLine.md
+++ b/llvm/docs/CommandLine.md
@@ -1599,6 +1599,7 @@ Only `-help-hidden` lists the options, like `cl::Hidden`.
 A default is the member's C++ initializer, so `"\"-\""` initializes `foo_path` 
to `"-"`.
 An `OptionalValueField` or `OptionalEnumField` takes no default; its 
`std::optional` member stays `std::nullopt` unless the option is given, 
replacing `getNumOccurrences()`.
 The header declares the struct after including what the member defaults need, 
and one source file defines it and registers it with `cl::`.
+Options that only some tools accept, such as those that 
`mc::getMCTargetOptions` reads, are not registered: a function returns a 
function-local `opt::LibraryOptionsParser`, and each such tool passes it to the 
`cl::parseCommandLineOptions` overload that takes tool options.
 
 The library then lists `FooOptionsTableGen` under `DEPENDS` and `Option` under 
`LINK_COMPONENTS`.
 A library that otherwise needs only `llvm-min-tblgen` sets 
`LLVM_TABLEGEN_PROJECT` to `LLVM_HEADERS` before its `llvm_tablegen()` call, so 
that its sources need not wait for `llvm-tblgen`.
diff --git a/llvm/include/llvm/CodeGen/CommandFlags.h 
b/llvm/include/llvm/CodeGen/CommandFlags.h
index 2c343fe95226d0..4509c95e17b425 100644
--- a/llvm/include/llvm/CodeGen/CommandFlags.h
+++ b/llvm/include/llvm/CodeGen/CommandFlags.h
@@ -15,6 +15,7 @@
 #ifndef LLVM_CODEGEN_COMMANDFLAGS_H
 #define LLVM_CODEGEN_COMMANDFLAGS_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
@@ -31,6 +32,10 @@ class Function;
 class Triple;
 class TargetMachine;
 
+namespace cl {
+class LibraryOptions;
+}
+
 namespace codegen {
 
 LLVM_ABI std::string getMArch();
@@ -143,6 +148,10 @@ struct RegisterCodeGenFlags {
   LLVM_ABI RegisterCodeGenFlags();
 };
 
+/// The options that a tool reading getTargetOptions passes to
+/// cl::parseCommandLineOptions.
+LLVM_ABI ArrayRef<cl::LibraryOptions *> getToolOptions();
+
 /// Tools that support subtarget tuning should create this object with static
 /// storage to register the -mtune command line option.
 struct RegisterMTuneFlag {
diff --git a/llvm/include/llvm/FuzzMutate/FuzzerCLI.h 
b/llvm/include/llvm/FuzzMutate/FuzzerCLI.h
index 865542a7efe564..4558242851b5b3 100644
--- a/llvm/include/llvm/FuzzMutate/FuzzerCLI.h
+++ b/llvm/include/llvm/FuzzMutate/FuzzerCLI.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_FUZZMUTATE_FUZZERCLI_H
 #define LLVM_FUZZMUTATE_FUZZERCLI_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 #include <stddef.h>
@@ -22,6 +23,7 @@ namespace llvm {
 
 class StringRef;
 namespace cl {
+class LibraryOptions;
 class LibraryOptionsContext;
 }
 
@@ -29,7 +31,8 @@ class LibraryOptionsContext;
 ///
 /// This handles all arguments after -ignore_remaining_args=1 as cl::opts.
 LLVM_ABI void parseFuzzerCLOpts(cl::LibraryOptionsContext &LibraryOptions,
-                                int ArgC, char *ArgV[]);
+                                int ArgC, char *ArgV[],
+                                ArrayRef<cl::LibraryOptions *> ToolOptions);
 
 /// Handle backend options that are encoded in the executable name.
 ///
diff --git a/llvm/include/llvm/MC/MCTargetOptionsCommandFlags.h 
b/llvm/include/llvm/MC/MCTargetOptionsCommandFlags.h
index 87eb39817bff37..b9cb73cb10b19b 100644
--- a/llvm/include/llvm/MC/MCTargetOptionsCommandFlags.h
+++ b/llvm/include/llvm/MC/MCTargetOptionsCommandFlags.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
 #define LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
@@ -22,6 +23,7 @@ class MCTargetOptions;
 class StringRef;
 
 namespace cl {
+class LibraryOptions;
 class LibraryOptionsContext;
 }
 
@@ -29,11 +31,9 @@ namespace mc {
 
 LLVM_ABI StringRef getABIName(const cl::LibraryOptionsContext &C);
 
-/// Create this object with static storage to register mc-related command
-/// line options.
-struct RegisterMCToolOptions {
-  LLVM_ABI RegisterMCToolOptions();
-};
+/// The options that a tool reading getMCTargetOptions passes to
+/// cl::parseCommandLineOptions.
+LLVM_ABI ArrayRef<cl::LibraryOptions *> getToolOptions();
 
 LLVM_ABI MCTargetOptions getMCTargetOptions(const cl::LibraryOptionsContext 
&C);
 
diff --git a/llvm/include/llvm/Support/CommandLine.h 
b/llvm/include/llvm/Support/CommandLine.h
index f4cf54884846b7..396f8281cfc8e6 100644
--- a/llvm/include/llvm/Support/CommandLine.h
+++ b/llvm/include/llvm/Support/CommandLine.h
@@ -50,6 +50,7 @@ class Error;
 /// It is intentionally a short name to make qualified usage concise.
 namespace cl {
 
+class LibraryOptions;
 class LibraryOptionsContext;
 
 
//===----------------------------------------------------------------------===//
@@ -81,6 +82,17 @@ LLVM_ABI bool parseCommandLineOptions(LibraryOptionsContext 
&Context,
                                       vfs::FileSystem *VFS = nullptr,
                                       const char *EnvVar = nullptr);
 
+// Like the above, but also recognizes the options of ToolOptions, which are
+// not registered with addLibraryOptions, such as the options that a tool opts
+// in to. The ToolOptions objects must outlive the contexts that parse them.
+LLVM_ABI bool parseCommandLineOptions(LibraryOptionsContext &Context,
+                                      ArrayRef<LibraryOptions *> ToolOptions,
+                                      ArrayRef<const char *> Args,
+                                      StringRef Overview = "",
+                                      raw_ostream *Errs = nullptr,
+                                      vfs::FileSystem *VFS = nullptr,
+                                      const char *EnvVar = nullptr);
+
 // The library options that LLVMParseCommandLineOptions sets, which contexts
 // created through the C API start with.
 LLVM_ABI LibraryOptionsContext &getCAPILibraryOptions();
diff --git a/llvm/include/llvm/Support/LibraryOptionsContext.h 
b/llvm/include/llvm/Support/LibraryOptionsContext.h
index ab6507ebdae5c0..f83ebd97ab95f6 100644
--- a/llvm/include/llvm/Support/LibraryOptionsContext.h
+++ b/llvm/include/llvm/Support/LibraryOptionsContext.h
@@ -28,7 +28,6 @@ class LibraryOptions;
 class LLVM_ABI LibraryOptionsContext {
 public:
   // Replaces the library options with Other's by replaying its arguments.
-  // Indexing libraries registered since the last parse is not thread-safe.
   void assign(const LibraryOptionsContext &Other);
 
   // Parses the option of L that Args[0] spells, keeping the other values.
@@ -38,6 +37,9 @@ class LLVM_ABI LibraryOptionsContext {
   // The arguments assigned so far.
   ArrayRef<const char *> args() const { return SavedArgs; }
 
+  // The library that parsed each argument in args().
+  ArrayRef<LibraryOptions *> argLibraries() const { return SavedLibraries; }
+
   // T's values, or T::Default if none of its options is parsed.
   template <typename T> const T &get() const {
     auto It = Values.find(&T::Default);
@@ -53,6 +55,7 @@ class LLVM_ABI LibraryOptionsContext {
 private:
   DenseMap<const void *, void *> Values;
   SmallVector<const char *, 0> SavedArgs;
+  SmallVector<LibraryOptions *, 0> SavedLibraries;
   BumpPtrAllocator Alloc;
 };
 
diff --git a/llvm/lib/CodeGen/CommandFlags.cpp 
b/llvm/lib/CodeGen/CommandFlags.cpp
index e6d059acda0455..5537e3f539020b 100644
--- a/llvm/lib/CodeGen/CommandFlags.cpp
+++ b/llvm/lib/CodeGen/CommandFlags.cpp
@@ -467,8 +467,10 @@ codegen::RegisterCodeGenFlags::RegisterCodeGenFlags() {
                "values are put into the RO data section."),
       cl::init(false));
   CGBINDOPT(XCOFFReadOnlyPointers);
+}
 
-  mc::RegisterMCToolOptions();
+ArrayRef<cl::LibraryOptions *> codegen::getToolOptions() {
+  return mc::getToolOptions();
 }
 
 codegen::RegisterMTuneFlag::RegisterMTuneFlag() {
diff --git a/llvm/lib/FuzzMutate/FuzzerCLI.cpp 
b/llvm/lib/FuzzMutate/FuzzerCLI.cpp
index d183209c34720d..7914514d2c8361 100644
--- a/llvm/lib/FuzzMutate/FuzzerCLI.cpp
+++ b/llvm/lib/FuzzMutate/FuzzerCLI.cpp
@@ -16,7 +16,8 @@
 using namespace llvm;
 
 void llvm::parseFuzzerCLOpts(cl::LibraryOptionsContext &LibraryOptions,
-                             int ArgC, char *ArgV[]) {
+                             int ArgC, char *ArgV[],
+                             ArrayRef<cl::LibraryOptions *> ToolOptions) {
   std::vector<const char *> CLArgs;
   CLArgs.push_back(ArgV[0]);
 
@@ -27,7 +28,7 @@ void llvm::parseFuzzerCLOpts(cl::LibraryOptionsContext 
&LibraryOptions,
   while (I < ArgC)
     CLArgs.push_back(ArgV[I++]);
 
-  cl::parseCommandLineOptions(LibraryOptions, CLArgs);
+  cl::parseCommandLineOptions(LibraryOptions, ToolOptions, CLArgs);
 }
 
 void llvm::handleExecNameEncodedBEOpts(
diff --git a/llvm/lib/LTO/LTOCodeGenerator.cpp 
b/llvm/lib/LTO/LTOCodeGenerator.cpp
index 82a089a454dd21..b5bb4fbe22d659 100644
--- a/llvm/lib/LTO/LTOCodeGenerator.cpp
+++ b/llvm/lib/LTO/LTOCodeGenerator.cpp
@@ -683,7 +683,8 @@ void LTOCodeGenerator::parseCodeGenDebugOptions() {
     std::vector<const char *> CodegenArgv(1, "libLLVMLTO");
     for (std::string &Arg : CodegenOptions)
       CodegenArgv.push_back(Arg.c_str());
-    cl::parseCommandLineOptions(Context.getLibraryOptions(), CodegenArgv);
+    cl::parseCommandLineOptions(Context.getLibraryOptions(),
+                                codegen::getToolOptions(), CodegenArgv);
   }
 }
 
diff --git a/llvm/lib/MC/MCTargetOptionsCommandFlags.cpp 
b/llvm/lib/MC/MCTargetOptionsCommandFlags.cpp
index e8c4a7ef8e7442..39fc4980047cb4 100644
--- a/llvm/lib/MC/MCTargetOptionsCommandFlags.cpp
+++ b/llvm/lib/MC/MCTargetOptionsCommandFlags.cpp
@@ -23,8 +23,10 @@ using namespace llvm;
 #define OPTIONS_STRUCT_DEFS
 #include "MCToolOptions.inc"
 
-llvm::mc::RegisterMCToolOptions::RegisterMCToolOptions() {
-  static opt::RegisterLibraryOptions<MCToolOptions> Registration;
+ArrayRef<cl::LibraryOptions *> llvm::mc::getToolOptions() {
+  static opt::LibraryOptionsParser Parser(std::in_place_type<MCToolOptions>);
+  static cl::LibraryOptions *const Libraries[] = {&Parser};
+  return Libraries;
 }
 
 StringRef llvm::mc::getABIName(const cl::LibraryOptionsContext &C) {
diff --git a/llvm/lib/Support/CommandLine.cpp b/llvm/lib/Support/CommandLine.cpp
index 3ada0587b9407f..ded6054e8799e1 100644
--- a/llvm/lib/Support/CommandLine.cpp
+++ b/llvm/lib/Support/CommandLine.cpp
@@ -179,6 +179,9 @@ class CommandLineParser {
   SmallVector<LibraryOptions *, 0> Libraries;
   DenseMap<StringRef, LibraryOptions *> LibraryIndex;
   size_t NumIndexedLibraries = 0;
+  // The libraries that the last parse recognized in addition to Libraries,
+  // also in LibraryIndex.
+  SmallVector<LibraryOptions *, 0> ToolOptions;
   // Storage that library options refer to: copies of the arguments passed to
   // LibraryOptions::parse and what it allocates. Response file expansions do
   // not outlive parsing.
@@ -191,7 +194,8 @@ class CommandLineParser {
   bool ParseCommandLineOptions(int argc, const char *const *argv,
                                StringRef Overview, raw_ostream *Errs = nullptr,
                                vfs::FileSystem *VFS = nullptr,
-                               LibraryOptionsContext *Context = nullptr);
+                               LibraryOptionsContext *Context = nullptr,
+                               ArrayRef<LibraryOptions *> ToolOptions = {});
 
   void forEachSubCommand(Option &Opt, function_ref<void(SubCommand &)> Action) 
{
     if (Opt.Subs.empty()) {
@@ -334,10 +338,9 @@ class CommandLineParser {
 
   void printOptionValues();
 
-  void indexLibraryOptions() {
+  void indexLibraries(ArrayRef<LibraryOptions *> Libs) {
     bool HadErrors = false;
-    for (; NumIndexedLibraries != Libraries.size(); ++NumIndexedLibraries) {
-      LibraryOptions *L = Libraries[NumIndexedLibraries];
+    for (LibraryOptions *L : Libs) {
       L->forEachOption([&](StringRef Spelling, StringRef, StringRef) {
         StringRef Name = Spelling.rtrim('=');
         auto [It, Inserted] = LibraryIndex.try_emplace(Name, L);
@@ -356,6 +359,23 @@ class CommandLineParser {
       report_fatal_error("inconsistency in registered CommandLine options");
   }
 
+  void indexLibraryOptions() {
+    indexLibraries(ArrayRef(Libraries).drop_front(NumIndexedLibraries));
+    NumIndexedLibraries = Libraries.size();
+  }
+
+  void setToolOptions(ArrayRef<LibraryOptions *> Libs) {
+    if (ArrayRef(ToolOptions) == Libs)
+      return;
+    for (LibraryOptions *L : ToolOptions)
+      if (!is_contained(Libraries, L))
+        L->forEachOption([&](StringRef Spelling, StringRef, StringRef) {
+          LibraryIndex.erase(Spelling.rtrim('='));
+        });
+    ToolOptions.assign(Libs.begin(), Libs.end());
+    indexLibraries(ToolOptions);
+  }
+
   // A library loaded while parsing (e.g. a pass plugin) may define the name.
   LibraryOptions *lookupLibraryOption(StringRef Name) {
     indexLibraryOptions();
@@ -417,6 +437,7 @@ class CommandLineParser {
     Libraries.clear();
     LibraryIndex.clear();
     NumIndexedLibraries = 0;
+    ToolOptions.clear();
 
     SubCommand::getTopLevel().reset();
     SubCommand::getAll().reset();
@@ -1446,11 +1467,10 @@ Error ExpansionContext::readConfigFile(StringRef 
CfgFile,
 }
 
 static void initCommonOptions();
-static bool parseCommandLineOptionsImpl(LibraryOptionsContext *Context,
-                                        ArrayRef<const char *> Args,
-                                        StringRef Overview, raw_ostream *Errs,
-                                        vfs::FileSystem *VFS,
-                                        const char *EnvVar) {
+static bool parseCommandLineOptionsImpl(
+    LibraryOptionsContext *Context, ArrayRef<const char *> Args,
+    StringRef Overview, raw_ostream *Errs, vfs::FileS...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/240009
_______________________________________________
llvm-branch-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits

Reply via email to