[llvm-branch-commits] [clang] [lld] [llvm] [Support] Pass tool options to parseCommandLineOptions (PR #240009)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Sat Nov 7 10:04:58 PST 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-lto
@llvm/pr-subscribers-platform-windows
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
---
<sub>Stack created with <a href="https://github.com/github/gh-stack">GitHub Stacks CLI</a> • <a href="https://gh.io/stacks-feedback">Give Feedback 💬</a></sub>
---
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
More information about the llvm-branch-commits
mailing list