[llvm] [tools] Hide unrelated options from all tools

[tbaeder]

Summary

They otherwise show up in the --help output of some llvm tools, e.g. llvm-bcanalyzer. This seems to only happen when the tools are linked against the shared llvm dylib.

[lebedev.ri]

I don't believe this is correct.
This is either not a bug, r should be dealt with by adding grouping, and hiding non-tool cl::opts.

[tbaeder]

What do you mean by "hiding non-tool cl::opts"? That is what I'm trying to do of course.

[lebedev.ri]

https://github.com/llvm/llvm-project/blob/main/llvm/tools/llvm-mca/llvm-mca.cpp#L310

[tbaeder]

New version with the proposed way of using cl::HideUnrelatedOptions() instead.

Unfortunately this makes the changes difficult in some of the tools since they declare cl::opts in files other than their main file.

[jhenderson]

This isn't an issue for the static linking approach, so why does it happen for the dynamic library approach? It seems like fixing this aspect should be the way forward, as it will be more robust generally.

[tbaeder]

The options are all declared as global variables and called from __cxx_global_var_init. I was assuming that the linker removes the unused command line options when linking against llvm statically but leaves all of them in when linking against the libLLVM.so.

IMO this is simply a clash between "user-facing command line options" and "internally used command line options, for tests and benchmarking". I was trying to mark the internally used ones as auch by making them cl::Hidden.

[tbaeder]

@lebedev.ri Is this more like what you imagined?

[lebedev.ri]

Something like this yes.
I think someone attempted this previously, and i don't recall why that didn't proceed.
It may be better to do this per-tool.

[tbaeder]

The email thread about the llvm busybox implementation contains this paragraph:

One implementation detail we think will be an issue is merging arguments in individual tools that use cl::opt. cl::opt works by maintaining a global state of flags, but we aren’t confident of what the resulting behavior will be when merging them together in the dispatching main. What we would like to avoid is having flags used by one specific tool available on other tools. To address this issue, we would like to migrate all tools to use OptTable which doesn't have this issue and has been the general direction most tools have been already moving into.

So, should all tools use OptTable instead?

[MaskRay]

This seems to only happen when the tools are linked against the shared llvm dylib.

In D104363#2823895, @jhenderson wrote:

This isn't an issue for the static linking approach, so why does it happen for the dynamic library approach? It seems like fixing this aspect should be the way forward, as it will be more robust generally.

How many options are displayed depends on linker garbage collection.

With the default -DLLVM_LINK_LLVM_DYLIB=off, --gc-sections can garbage collection almost all code generation/middle-end optimization options, so --help looks clean.

With -DLLVM_LINK_LLVM_DYLIB=on, cl::opt (and its friends) options are all retained in libLLVM-13git.so, so a tool linking against libLLVM-13git.so may see many unrelated options.

Adding cl::cat(ToolOptions) annotations does solve the problem, so LGTM. For some tools like llvm-mc, they can use arbitrary MC layer cl::opt options.
Some tests may use some obscure options.
IIUC cl::HideUnrelatedOptions(&ToolOptions); will make the options cl::ReallyHidden which will disappear from --help-all-hidden. If any tool turns out to want the obscure options, we can think of other options or just dropping HideUnrelatedOptions for the particular tool.

[MaskRay]

In D104363#2835868, @tbaeder wrote:

The email thread about the llvm busybox implementation contains this paragraph:

One implementation detail we think will be an issue is merging arguments in individual tools that use cl::opt. cl::opt works by maintaining a global state of flags, but we aren’t confident of what the resulting behavior will be when merging them together in the dispatching main. What we would like to avoid is having flags used by one specific tool available on other tools. To address this issue, we would like to migrate all tools to use OptTable which doesn't have this issue and has been the general direction most tools have been already moving into.

So, should all tools use OptTable instead?

Many llvm/tools/* tools are really internal testing tools. Some are user-facing tools (llvm-objdump, llvm-readelf, llvm-objcopy, llvm-nm, ...).
For user-facing tools, I think it makes sense to convert them to OptTable. cl::opt can emulate GNU style getopt_long which we may be familiar with but there are some rough corners (see the description of D83530).

[jhenderson]

Some test changes aren't correct, so requesting changes.

llvm/test/tools/llvm-strings/help.test

11–14 ↗

(On Diff #352941)

This isn't a correct change.

Before, the intent was that the LIST-NOT checks showed that each of the checked-for categories appeared in --help output, but not --help-hidden.

The checks should be:

CATEG:     Generic Options:
LIST-NOT: Generic Options:
CATEG:     Tool Options:
LIST-NOT: Tool Options:

Additionally, you can add --implicit-check-not="General options:" to the --help FileCheck, to show that the "unrelated" options are not present in the output.

Finally, I don't know if it's still present, but in the llvm-strings copy I have installed on my machine, there's a "Color Options:" category that is also listed in the help text. It should probably be tested here too.

llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

39–43

In other tools, we either do, or used to at least, call the tool-specific option category after the tool name. Here, that would mean something like BCAnalyzerOptions("BC Analyzer Options").

It may also be a good idea to add testing similar to the llvm-strings test to show that only the expected options categories are present.

The same comments apply to each of the other tools.

llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp

65

In other cases, you've added the option category to positionals as well. I don't know if you need to, but we should be consistent either way, and either remove it from all the others, or add it here.

llvm/tools/llvm-lto/llvm-lto.cpp

111

There are a load more options here that seem like they syhould have a category?

llvm/tools/llvm-xray/llvm-xray.cpp

25

Seems like you don't need the option category here at all?

[jhenderson]

Oh, one other thing: does HideUnrelatedOptions hide the --color option (which is in its own category)? This option should be in the help text usually, because error/warning messages at least are printed with colours usually.

[tbaeder]

Yes, it also hides the --color option. I guess I need to include &llvm::ColorCategory everywhere.

But this all seems like a lot of work in all the tools (not to mention external ones linking against libLLVM.so I guess?) for something that should just work. Why not mark all the llvm internal options as cl::Hidden instead? That way thy would also still be available via --help-hidden.

[jhenderson]

In D104363#2838012, @tbaeder wrote:

Yes, it also hides the --color option. I guess I need to include &llvm::ColorCategory everywhere.

But this all seems like a lot of work in all the tools (not to mention external ones linking against libLLVM.so I guess?) for something that should just work. Why not mark all the llvm internal options as cl::Hidden instead? That way thy would also still be available via --help-hidden.

I don't think that's particularly useful, and at the very least needs discussing on the mailing lists. LLVM developers may well want to know about some of these options when using tools like opt and llc, and hiding them means newer LLVM develpers may never find them.

[andreadb]

llvm/tools/llvm-mca/llvm-mca.cpp

71–76 ↗

(On Diff #356137)

Is this change (and the other changes to this file) really needed?

If not, then I'd like those to be removed from this patch.

Thanks
-Andrea

[jhenderson]

Where you've added the ColorCategory, how sure are you that it actually has an impact on the tool you've modified. My suspicion is that in many cases it actually has no effect whatsoever, as the tool in question never uses the WithColor code. Please make sure you add it only where the option has some visible effect.

llvm/test/tools/llvm-strings/help.test

11–14 ↗

(On Diff #352941)

This still isn't correct for the code this patch is based on.

That being said, @MaskRay has just landed a patch to completely redo llvm-strings command-line handling, so it's moot - please rebase.

llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

39–43

It may also be a good idea to add testing similar to the llvm-strings test to show that only the expected options categories are present.

It seems like this part of my comment has been missed?

llvm/tools/llvm-extract/llvm-extract.cpp

143 ↗

(On Diff #356162)

Seems like this is only tangentially related to this patch. Please move it to another patch. Also check to see if --color actually should appear in the otuput - if it has no impact, it shouldn't.

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

472 ↗

(On Diff #356162)

Same as above. Don't add this in this patch.

llvm/tools/llvm-ifs/llvm-ifs.cpp

454

Here and in many other cases, we're already using namespace llvm, so you shouldn't need the llvm prefix before ColorCategory.

llvm/tools/llvm-lto/llvm-lto.cpp

67

LTO is an abbreviation, so should be capitalized in the variable name too (i.e. LTOOptions).

[tbaeder]

I'm just gonna abandon this. The move seems to be to use OptTable instead, and rebasing this every day doesn't make much sense.

[jhenderson]

In D104363#2863801, @tbaeder wrote:

I'm just gonna abandon this. The move seems to be to use OptTable instead, and rebasing this every day doesn't make much sense.

@MaskRay - could you state which tools you plan on moving over?

(My suspicion is that it's only a subset of the tools touched by this patch)

[MaskRay]

In D104363#2863828, @jhenderson wrote:

In D104363#2863801, @tbaeder wrote:

I'm just gonna abandon this. The move seems to be to use OptTable instead, and rebasing this every day doesn't make much sense.

@MaskRay - could you state which tools you plan on moving over?

(My suspicion is that it's only a subset of the tools touched by this patch)

The user-facing binary utilities llvm-{cov,cxxfilt,nm,readobj,size,strings} Most are done now.

The patch has a small intersection with the tools.

llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 using namespace llvm;
 
-static cl::opt<std::string>
-    InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
+static cl::OptionCategory ToolOptions("Tool Options");
+
+static cl::opt<std::string> InputFilename(cl::Positional,
+                                          cl::desc("<input bitcode>"),
+                                          cl::init("-"), cl::cat(ToolOptions));
 
-static cl::opt<bool> Dump("dump", cl::desc("Dump low level bitcode trace"));
+static cl::opt<bool> Dump("dump", cl::desc("Dump low level bitcode trace"),
+                          cl::cat(ToolOptions));
 
 //===----------------------------------------------------------------------===//
 // Bitcode specific analysis.
 //===----------------------------------------------------------------------===//
 
 static cl::opt<bool> NoHistogram("disable-histogram",
-                                 cl::desc("Do not print per-code histogram"));
+                                 cl::desc("Do not print per-code histogram"),
+                                 cl::cat(ToolOptions));
 
 static cl::opt<bool> NonSymbolic("non-symbolic",
                                  cl::desc("Emit numeric info in dump even if"
-                                          " symbolic info is available"));
+                                          " symbolic info is available"),
+                                 cl::cat(ToolOptions));
 
 static cl::opt<std::string>
     BlockInfoFilename("block-info",
-                      cl::desc("Use the BLOCK_INFO from the given file"));
+                      cl::desc("Use the BLOCK_INFO from the given file"),
+                      cl::cat(ToolOptions));
 
 static cl::opt<bool>
     ShowBinaryBlobs("show-binary-blobs",
-                    cl::desc("Print binary blobs using hex escapes"));
+                    cl::desc("Print binary blobs using hex escapes"),
+                    cl::cat(ToolOptions));
 
 static cl::opt<std::string> CheckHash(
     "check-hash",
-    cl::desc("Check module hash using the argument as a string table"));
+    cl::desc("Check module hash using the argument as a string table"),
+    cl::cat(ToolOptions));
 
 static Error reportError(StringRef Message) {
   return createStringError(std::errc::illegal_byte_sequence, Message.data());
 }
 
 static Expected<std::unique_ptr<MemoryBuffer>> openBitcodeFile(StringRef Path) {
   // Read the input file.
   Expected<std::unique_ptr<MemoryBuffer>> MemBufOrErr =
       errorOrToExpected(MemoryBuffer::getFileOrSTDIN(Path));
   if (Error E = MemBufOrErr.takeError())
     return std::move(E);
 
   std::unique_ptr<MemoryBuffer> MemBuf = std::move(*MemBufOrErr);
 
   if (MemBuf->getBufferSize() & 3)
     return reportError(
         "Bitcode stream should be a multiple of 4 bytes in length");
   return std::move(MemBuf);
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm-bcanalyzer file analyzer\n");
   ExitOnError ExitOnErr("llvm-bcanalyzer: ");
 
   std::unique_ptr<MemoryBuffer> MB = ExitOnErr(openBitcodeFile(InputFilename));
   std::unique_ptr<MemoryBuffer> BlockInfoMB = nullptr;
   if (!BlockInfoFilename.empty())
     BlockInfoMB = ExitOnErr(openBitcodeFile(BlockInfoFilename));
 

llvm/tools/llvm-cxxdump/llvm-cxxdump.cpp

 #include <string>
 #include <system_error>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support;
 
 namespace opts {
+cl::OptionCategory ToolOptions("Tool Options");
 cl::list<std::string> InputFilenames(cl::Positional,
                                      cl::desc("<input object files>"),
-                                     cl::ZeroOrMore);
+                                     cl::cat(ToolOptions), cl::ZeroOrMore);
 } // namespace opts
 
 namespace llvm {
 
 static void error(std::error_code EC) {
   if (!EC)
     return;
   WithColor::error(outs(), "") << "reading file: " << EC.message() << ".\n";
int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
   // Initialize targets.
   llvm::InitializeAllTargetInfos();
 
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
+  cl::HideUnrelatedOptions({&opts::ToolOptions});
   cl::ParseCommandLineOptions(argc, argv, "LLVM C++ ABI Data Dumper\n");
 
   // Default to stdin if no filename is specified.
   if (opts::InputFilenames.size() == 0)
     opts::InputFilenames.push_back("-");
 
   llvm::for_each(opts::InputFilenames, dumpInput);
 
   return EXIT_SUCCESS;
 }

llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp

enum Style {
   Lucid, ///< Lucid compiler (lcc)
   ARM,
   HP,    ///< HP compiler (xCC)
   EDG,   ///< EDG compiler
   GNUv3, ///< GNU C++ v3 ABI
   Java,  ///< Java (gcj)
   GNAT   ///< ADA compiler (gnat)
 };
+static cl::OptionCategory ToolOptions("Tool Options");
 static cl::opt<Style>
     Format("format", cl::desc("decoration style"),
            cl::values(clEnumValN(Auto, "auto", "auto-detect style"),
                       clEnumValN(GNU, "gnu", "GNU (itanium) style")),
-           cl::init(Auto));
+           cl::init(Auto), cl::cat(ToolOptions));
 static cl::alias FormatShort("s", cl::desc("alias for --format"),
-                             cl::aliasopt(Format));
+                             cl::aliasopt(Format), cl::cat(ToolOptions));
 
 static cl::opt<bool> StripUnderscore("strip-underscore",
                                      cl::desc("strip the leading underscore"),
-                                     cl::init(false));
+                                     cl::init(false), cl::cat(ToolOptions));
 static cl::alias StripUnderscoreShort("_",
                                       cl::desc("alias for --strip-underscore"),
-                                      cl::aliasopt(StripUnderscore));
+                                      cl::aliasopt(StripUnderscore),
+                                      cl::cat(ToolOptions));
 static cl::opt<bool>
     NoStripUnderscore("no-strip-underscore",
                       cl::desc("do not strip the leading underscore"),
-                      cl::init(false));
+                      cl::init(false), cl::cat(ToolOptions));
 static cl::alias
     NoStripUnderscoreShort("n", cl::desc("alias for --no-strip-underscore"),
-                           cl::aliasopt(NoStripUnderscore));
+                           cl::aliasopt(NoStripUnderscore),
+                           cl::cat(ToolOptions));
 
 static cl::opt<bool>
     Types("types",
           cl::desc("attempt to demangle types as well as function names"),
-          cl::init(false));
+          cl::init(false), cl::cat(ToolOptions));
 static cl::alias TypesShort("t", cl::desc("alias for --types"),
-                            cl::aliasopt(Types));
+                            cl::aliasopt(Types), cl::cat(ToolOptions));
 
 static cl::list<std::string>
 Decorated(cl::Positional, cl::desc("<mangled>"), cl::ZeroOrMore);
 
 static cl::extrahelp
     HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 
 static bool shouldStripUnderscore() {
   if (StripUnderscore)
     return true;
   if (NoStripUnderscore)
if (Split) {
     Result = ::demangle(std::string(Mangled));
   OS << Result << '\n';
   OS.flush();
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions({&ToolOptions});
   cl::ParseCommandLineOptions(argc, argv, "llvm symbol undecoration tool\n");
 
   if (Decorated.empty())
     for (std::string Mangled; std::getline(std::cin, Mangled);)
       demangleLine(llvm::outs(), Mangled, true);
   else
     for (const auto &Symbol : Decorated)
       demangleLine(llvm::outs(), Symbol, false);
 
   return EXIT_SUCCESS;
 }

llvm/tools/llvm-cxxmap/llvm-cxxmap.cpp

 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SymbolRemappingReader.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
+cl::OptionCategory ToolOptions("Tool Options");
 cl::opt<std::string> OldSymbolFile(cl::Positional, cl::Required,
-                                   cl::desc("<symbol-file>"));
+                                   cl::desc("<symbol-file>"),
+                                   cl::cat(ToolOptions));
 cl::opt<std::string> NewSymbolFile(cl::Positional, cl::Required,
-                                   cl::desc("<symbol-file>"));
+                                   cl::desc("<symbol-file>"),
+                                   cl::cat(ToolOptions));
 cl::opt<std::string> RemappingFile("remapping-file", cl::Required,
-                                   cl::desc("Remapping file"));
-cl::alias RemappingFileA("r", cl::aliasopt(RemappingFile));
+                                   cl::desc("Remapping file"),
+                                   cl::cat(ToolOptions));
+cl::alias RemappingFileA("r", cl::aliasopt(RemappingFile),
+                         cl::cat(ToolOptions));
 cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
-                                    cl::init("-"), cl::desc("Output file"));
-cl::alias OutputFilenameA("o", cl::aliasopt(OutputFilename));
+                                    cl::init("-"), cl::desc("Output file"),
+                                    cl::cat(ToolOptions));
+cl::alias OutputFilenameA("o", cl::aliasopt(OutputFilename),
+                          cl::cat(ToolOptions));
 
 cl::opt<bool> WarnAmbiguous(
     "Wambiguous",
-    cl::desc("Warn on equivalent symbols in the output symbol list"));
+    cl::desc("Warn on equivalent symbols in the output symbol list"),
+    cl::cat(ToolOptions));
 cl::opt<bool> WarnIncomplete(
     "Wincomplete",
-    cl::desc("Warn on input symbols missing from output symbol list"));
+    cl::desc("Warn on input symbols missing from output symbol list"),
+    cl::cat(ToolOptions));
 
 static void warn(Twine Message, Twine Whence = "",
                  std::string Hint = "") {
   WithColor::warning();
   std::string WhenceStr = Whence.str();
   if (!WhenceStr.empty())
     errs() << WhenceStr << ": ";
   errs() << Message << "\n";
for (line_iterator LineIt(OldSymbolFile, /*SkipBlanks=*/true, '#');
 
     Out << Symbol << " " << NewSymbol << "\n";
   }
 }
 
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions({&ToolOptions});
   cl::ParseCommandLineOptions(argc, argv, "LLVM C++ mangled name remapper\n");
 
   auto OldSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(OldSymbolFile);
   if (!OldSymbolBufOrError)
     exitWithErrorCode(OldSymbolBufOrError.getError(), OldSymbolFile);
 
   auto NewSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(NewSymbolFile);
   if (!NewSymbolBufOrError)

llvm/tools/llvm-diff/llvm-diff.cpp

static void diffGlobal(DifferenceEngine &Engine, Module &L, Module &R,
   else if (!LFn && !RFn)
     errs() << "No function named @" << Name << " in either module\n";
   else if (!LFn)
     errs() << "No function named @" << Name << " in left module\n";
   else
     errs() << "No function named @" << Name << " in right module\n";
 }
 
+static cl::OptionCategory ToolOptions("Tool Options");
 static cl::opt<std::string> LeftFilename(cl::Positional,
-                                         cl::desc("<first file>"),
-                                         cl::Required);
+                                         cl::desc("<first file>"), cl::Required,
+                                         cl::cat(ToolOptions));
 static cl::opt<std::string> RightFilename(cl::Positional,
                                           cl::desc("<second file>"),
-                                          cl::Required);
+                                          cl::Required, cl::cat(ToolOptions));
 static cl::list<std::string> GlobalsToCompare(cl::Positional,
-                                              cl::desc("<globals to compare>"));
+                                              cl::desc("<globals to compare>"),
+                                              cl::cat(ToolOptions));
 
 int main(int argc, char **argv) {
+  cl::HideUnrelatedOptions({&ToolOptions});
   cl::ParseCommandLineOptions(argc, argv);
 
   LLVMContext Context;
 
   // Load both modules.  Die if that fails.
   std::unique_ptr<Module> LModule = readModule(Context, LeftFilename);
   std::unique_ptr<Module> RModule = readModule(Context, RightFilename);
   if (!LModule || !RModule) return 1;

llvm/tools/llvm-dis/llvm-dis.cpp

 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 #include <system_error>
 using namespace llvm;
 
-static cl::list<std::string> InputFilenames(cl::Positional, cl::ZeroOrMore,
-                                            cl::desc("[input bitcode]..."));
-
-static cl::opt<std::string>
-OutputFilename("o", cl::desc("Override output filename"),
-               cl::value_desc("filename"));
+static cl::OptionCategory ToolOptions("Tool Options");
 
-static cl::opt<bool>
-Force("f", cl::desc("Enable binary output on terminals"));
+static cl::list<std::string> InputFilenames(cl::Positional, cl::ZeroOrMore,
+                                            cl::desc("[input bitcode]..."),
+                                            cl::cat(ToolOptions));
 
-static cl::opt<bool>
-DontPrint("disable-output", cl::desc("Don't output the .ll file"), cl::Hidden);
+static cl::opt<std::string> OutputFilename("o",
+                                           cl::desc("Override output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::cat(ToolOptions));
+
+static cl::opt<bool> Force("f", cl::desc("Enable binary output on terminals"),
+                           cl::cat(ToolOptions));
+
+static cl::opt<bool> DontPrint("disable-output",
+                               cl::desc("Don't output the .ll file"),
+                               cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<bool>
     SetImporting("set-importing",
                  cl::desc("Set lazy loading to pretend to import a module"),
-                 cl::Hidden);
+                 cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<bool>
     ShowAnnotations("show-annotations",
-                    cl::desc("Add informational comments to the .ll file"));
+                    cl::desc("Add informational comments to the .ll file"),
+                    cl::cat(ToolOptions));
 
 static cl::opt<bool> PreserveAssemblyUseListOrder(
     "preserve-ll-uselistorder",
     cl::desc("Preserve use-list order when writing LLVM assembly."),
-    cl::init(false), cl::Hidden);
+    cl::init(false), cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<bool>
     MaterializeMetadata("materialize-metadata",
                         cl::desc("Load module without materializing metadata, "
-                                 "then materialize only the metadata"));
+                                 "then materialize only the metadata"),
+                        cl::cat(ToolOptions));
 
 namespace {
 
 static void printDebugLoc(const DebugLoc &DL, formatted_raw_ostream &OS) {
   OS << DL.getLine() << ":" << DL.getCol();
   if (DILocation *IDL = DL.getInlinedAt()) {
     OS << "@";
     printDebugLoc(IDL, OS);

 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
   ExitOnErr.setBanner(std::string(argv[0]) + ": error: ");
 
   LLVMContext Context;
   Context.setDiagnosticHandler(
       std::make_unique<LLVMDisDiagnosticHandler>(argv[0]));
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm .bc -> .ll disassembler\n");
 
   if (InputFilenames.size() < 1) {
     InputFilenames.push_back("-");
   } else if (InputFilenames.size() > 1 && !OutputFilename.empty()) {
     errs()
         << "error: output file name cannot be set for multiple input files\n";
     return 1;

llvm/tools/llvm-dwp/llvm-dwp.cpp

if (!ErrOrObj)
     return ErrOrObj.takeError();
 
   return ErrOrObj->getBinary()->makeTriple();
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions(&DwpCategory);
   cl::ParseCommandLineOptions(argc, argv, "merge split dwarf (.dwo) files\n");
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
 
   std::vector<std::string> DWOFilenames = InputFiles;

llvm/tools/llvm-elfabi/llvm-elfabi.cpp

 
 } // end namespace elfabi
 } // end namespace llvm
 
 using namespace llvm;
 using namespace llvm::elfabi;
 
 // Command line flags:
+cl::OptionCategory ToolOptions("Tool Options");
 cl::opt<FileFormat> InputFileFormat(
     cl::desc("Force input file format:"),
     cl::values(clEnumValN(FileFormat::TBE, "tbe",
                           "Read `input` as text-based ELF stub"),
                clEnumValN(FileFormat::ELF, "elf",
-                          "Read `input` as ELF binary")));
+                          "Read `input` as ELF binary")),
+    cl::cat(ToolOptions));
 cl::opt<std::string> InputFilePath(cl::Positional, cl::desc("input"),
-                                   cl::Required);
+                                   cl::Required, cl::cat(ToolOptions));
 cl::opt<std::string>
     EmitTBE("emit-tbe",
             cl::desc("Emit a text-based ELF stub (.tbe) from the input file"),
-            cl::value_desc("path"));
+            cl::value_desc("path"), cl::cat(ToolOptions));
 cl::opt<std::string>
     SOName("soname",
            cl::desc("Manually set the DT_SONAME entry of any emitted files"),
-           cl::value_desc("name"));
+           cl::value_desc("name"), cl::cat(ToolOptions));
 cl::opt<ELFTarget> BinaryOutputTarget(
     "output-target", cl::desc("Create a binary stub for the specified target"),
     cl::values(clEnumValN(ELFTarget::ELF32LE, "elf32-little",
                           "32-bit little-endian ELF stub"),
                clEnumValN(ELFTarget::ELF32BE, "elf32-big",
                           "32-bit big-endian ELF stub"),
                clEnumValN(ELFTarget::ELF64LE, "elf64-little",
                           "64-bit little-endian ELF stub"),
                clEnumValN(ELFTarget::ELF64BE, "elf64-big",
-                          "64-bit big-endian ELF stub")));
-cl::opt<std::string> BinaryOutputFilePath(cl::Positional, cl::desc("output"));
+                          "64-bit big-endian ELF stub")),
+    cl::cat(ToolOptions));
+cl::opt<std::string> BinaryOutputFilePath(cl::Positional, cl::desc("output"),
+                                          cl::cat(ToolOptions));
 cl::opt<bool> WriteIfChanged(
     "write-if-changed",
-    cl::desc("Write the output file only if it is new or has changed."));
+    cl::desc("Write the output file only if it is new or has changed."),
+    cl::cat(ToolOptions));
 
 /// writeTBE() writes a Text-Based ELF stub to a file using the latest version
 /// of the YAML parser.
 static Error writeTBE(StringRef FilePath, ELFStub &Stub) {
   // Write TBE to memory first.
   std::string TBEStr;
   raw_string_ostream OutStr(TBEStr);
   Error YAMLErr = writeTBEToOutputStream(OutStr, Stub);

 
 static void fatalError(Error Err) {
   WithColor::defaultErrorHandler(std::move(Err));
   exit(1);
 }
 
 int main(int argc, char *argv[]) {
   // Parse arguments.
+  cl::HideUnrelatedOptions({&ToolOptions});
   cl::ParseCommandLineOptions(argc, argv);
 
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readInputFile(InputFilePath);
   if (!StubOrErr)
     fatalError(StubOrErr.takeError());
 
   std::unique_ptr<ELFStub> TargetStub = std::move(StubOrErr.get());
 

llvm/tools/llvm-exegesis/lib/X86/Target.cpp

 #if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
 #include <immintrin.h>
 #include <intrin.h>
 #endif
 
 namespace llvm {
 namespace exegesis {
 
-static cl::OptionCategory
-    BenchmarkOptions("llvm-exegesis benchmark x86-options");
+cl::OptionCategory X86BenchmarkOptions("llvm-exegesis benchmark x86-options");
 
 // If a positive value is specified, we are going to use the LBR in
 // latency-mode.
 //
 // Note:
 //  -  A small value is preferred, but too low a value could result in
 //     throttling.
 //  -  A prime number is preferred to avoid always skipping certain blocks.
 //
 static cl::opt<unsigned> LbrSamplingPeriod(
     "x86-lbr-sample-period",
     cl::desc("The sample period (nbranches/sample), used for LBR sampling"),
-    cl::cat(BenchmarkOptions), cl::init(0));
+    cl::cat(X86BenchmarkOptions), cl::init(0));
 
 // FIXME: Validates that repetition-mode is loop if LBR is requested.
 
 // Returns a non-null reason if we cannot handle the memory references in this
 // instruction.
 static const char *isInvalidMemoryInstr(const Instruction &Instr) {
   switch (Instr.Description.TSFlags & X86II::FormMask) {
   default:

llvm/tools/llvm-exegesis/llvm-exegesis.cpp

 #include <string>
 
 namespace llvm {
 namespace exegesis {
 
 static cl::OptionCategory Options("llvm-exegesis options");
 static cl::OptionCategory BenchmarkOptions("llvm-exegesis benchmark options");
 static cl::OptionCategory AnalysisOptions("llvm-exegesis analysis options");
+extern cl::OptionCategory X86BenchmarkOptions;
 
 static cl::opt<int> OpcodeIndex(
     "opcode-index",
     cl::desc("opcode to measure, by index, or -1 to measure all opcodes"),
     cl::cat(BenchmarkOptions), cl::init(0));
 
 static cl::opt<std::string>
     OpcodeNames("opcode-name",
maybeRunAnalysis<Analysis::PrintSchedClassInconsistencies>(
       AnalysisInconsistenciesOutputFile);
 }
 
 } // namespace exegesis
 } // namespace llvm
 
 int main(int Argc, char **Argv) {
   using namespace llvm;
+  cl::HideUnrelatedOptions({&exegesis::Options, &exegesis::BenchmarkOptions,
+                            &exegesis::AnalysisOptions,
+                            &exegesis::X86BenchmarkOptions});
   cl::ParseCommandLineOptions(Argc, Argv, "");
 
   exegesis::ExitOnErr.setExitCodeMapper([](const Error &Err) {
     if (Err.isA<exegesis::ClusteringError>())
       return EXIT_SUCCESS;
     return EXIT_FAILURE;
   });
 
   if (exegesis::BenchmarkMode == exegesis::InstructionBenchmark::Unknown) {
     exegesis::analysisMain();
   } else {
     exegesis::benchmarkMain();
   }
   return EXIT_SUCCESS;
 }

llvm/tools/llvm-ifs/llvm-ifs.cpp

 using namespace llvm::MachO;
 
 #define DEBUG_TYPE "llvm-ifs"
 
 namespace {
 const VersionTuple IFSVersionCurrent(2, 0);
 } // end anonymous namespace
 
+static cl::OptionCategory ToolOptions("Tool Options");
 static cl::opt<std::string> Action("action", cl::desc("<llvm-ifs action>"),
                                    cl::value_desc("write-ifs | write-bin"),
-                                   cl::init("write-ifs"));
+                                   cl::init("write-ifs"), cl::cat(ToolOptions));
 
 static cl::opt<std::string> ForceFormat("force-format",
                                         cl::desc("<force object format>"),
                                         cl::value_desc("ELF | TBD"),
-                                        cl::init(""));
+                                        cl::init(""), cl::cat(ToolOptions));
 
 static cl::list<std::string> InputFilenames(cl::Positional,
                                             cl::desc("<input ifs files>"),
-                                            cl::ZeroOrMore);
+                                            cl::ZeroOrMore,
+                                            cl::cat(ToolOptions));
 
 static cl::opt<std::string> OutputFilename("o", cl::desc("<output file>"),
-                                           cl::value_desc("path"));
+                                           cl::value_desc("path"),
+                                           cl::cat(ToolOptions));
 
 static cl::opt<bool> UseInterfaceStub(
     "use-interfacestub",
     cl::desc("Write output ELF file using latest InterfaceStub backend"),
-    cl::init(false));
+    cl::init(false), cl::cat(ToolOptions));
 
 enum class IFSSymbolType {
   NoType = 0,
   Object,
   Func,
   // Type information is 4 bits, so 16 is safely out of range.
   Unknown = 16,
 };

 // Triple:          <llvm triple>
 // ObjectFileFormat: <ELF | others not yet supported>
 // Symbols:
 //   _ZSymbolName: { Type: <type> }
 // ...
 
 int main(int argc, char *argv[]) {
   // Parse arguments.
+  cl::HideUnrelatedOptions({&ToolOptions});
   cl::ParseCommandLineOptions(argc, argv);
 
   if (InputFilenames.empty())
     InputFilenames.push_back("-");
 
   IFSStub Stub;
   std::map<std::string, IFSSymbol> SymbolMap;
 

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

 #endif // LLVM_ON_UNIX
 
 #define DEBUG_TYPE "llvm_jitlink"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 using namespace llvm::orc;
 
+static cl::OptionCategory ToolOptions("Tool Options");
 static cl::list<std::string> InputFiles(cl::Positional, cl::OneOrMore,
-                                        cl::desc("input files"));
+                                        cl::desc("input files"),
+                                        cl::cat(ToolOptions));
 
 static cl::opt<bool> NoExec("noexec", cl::desc("Do not execute loaded code"),
-                            cl::init(false));
+                            cl::init(false), cl::cat(ToolOptions));
 
 static cl::list<std::string>
     CheckFiles("check", cl::desc("File containing verifier checks"),
-               cl::ZeroOrMore);
+               cl::ZeroOrMore, cl::cat(ToolOptions));
 
 static cl::opt<std::string>
     CheckName("check-name", cl::desc("Name of checks to match against"),
-              cl::init("jitlink-check"));
+              cl::init("jitlink-check"), cl::cat(ToolOptions));
 
 static cl::opt<std::string>
     EntryPointName("entry", cl::desc("Symbol to call as main entry point"),
-                   cl::init(""));
+                   cl::init(""), cl::cat(ToolOptions));
 
 static cl::list<std::string> JITLinkDylibs(
-    "jld", cl::desc("Specifies the JITDylib to be used for any subsequent "
-                    "input file arguments"));
+    "jld",
+    cl::desc("Specifies the JITDylib to be used for any subsequent "
+             "input file arguments"),
+    cl::cat(ToolOptions));
 
 static cl::list<std::string>
     Dylibs("dlopen", cl::desc("Dynamic libraries to load before linking"),
-           cl::ZeroOrMore);
+           cl::ZeroOrMore, cl::cat(ToolOptions));
 
 static cl::list<std::string> InputArgv("args", cl::Positional,
                                        cl::desc("<program arguments>..."),
-                                       cl::ZeroOrMore, cl::PositionalEatsArgs);
+                                       cl::ZeroOrMore, cl::PositionalEatsArgs,
+                                       cl::cat(ToolOptions));
 
 static cl::opt<bool>
     NoProcessSymbols("no-process-syms",
                      cl::desc("Do not resolve to llvm-jitlink process symbols"),
-                     cl::init(false));
+                     cl::init(false), cl::cat(ToolOptions));
 
 static cl::list<std::string> AbsoluteDefs(
     "define-abs",
     cl::desc("Inject absolute symbol definitions (syntax: <name>=<addr>)"),
-    cl::ZeroOrMore);
+    cl::ZeroOrMore, cl::cat(ToolOptions));
 
-static cl::list<std::string> TestHarnesses("harness", cl::Positional,
-                                           cl::desc("Test harness files"),
-                                           cl::ZeroOrMore,
-                                           cl::PositionalEatsArgs);
+static cl::list<std::string>
+    TestHarnesses("harness", cl::Positional, cl::desc("Test harness files"),
+                  cl::ZeroOrMore, cl::PositionalEatsArgs, cl::cat(ToolOptions));
 
 static cl::opt<bool> ShowInitialExecutionSessionState(
     "show-init-es",
     cl::desc("Print ExecutionSession state before resolving entry point"),
-    cl::init(false));
+    cl::init(false), cl::cat(ToolOptions));
 
 static cl::opt<bool> ShowAddrs(
     "show-addrs",
     cl::desc("Print registered symbol, section, got and stub addresses"),
-    cl::init(false));
+    cl::init(false), cl::cat(ToolOptions));
 
 static cl::opt<bool> ShowLinkGraph(
     "show-graph",
     cl::desc("Print the link graph after fixups have been applied"),
-    cl::init(false));
+    cl::init(false), cl::cat(ToolOptions));
 
 static cl::opt<bool> ShowSizes(
     "show-sizes",
     cl::desc("Show sizes pre- and post-dead stripping, and allocations"),
-    cl::init(false));
+    cl::init(false), cl::cat(ToolOptions));
 
 static cl::opt<bool> ShowTimes("show-times",
                                cl::desc("Show times for llvm-jitlink phases"),
-                               cl::init(false));
+                               cl::init(false), cl::cat(ToolOptions));
 
 static cl::opt<std::string> SlabAllocateSizeString(
     "slab-allocate",
     cl::desc("Allocate from a slab of the given size "
              "(allowable suffixes: Kb, Mb, Gb. default = "
              "Kb)"),
-    cl::init(""));
+    cl::init(""), cl::cat(ToolOptions));
 
 static cl::opt<uint64_t> SlabAddress(
     "slab-address",
     cl::desc("Set slab target address (requires -slab-allocate and -noexec)"),
-    cl::init(~0ULL));
+    cl::init(~0ULL), cl::cat(ToolOptions));
 
 static cl::opt<bool> ShowRelocatedSectionContents(
     "show-relocated-section-contents",
     cl::desc("show section contents after fixups have been applied"),
-    cl::init(false));
+    cl::init(false), cl::cat(ToolOptions));
 
 static cl::opt<bool> PhonyExternals(
     "phony-externals",
     cl::desc("resolve all otherwise unresolved externals to null"),
-    cl::init(false));
+    cl::init(false), cl::cat(ToolOptions));
 
 static cl::opt<std::string> OutOfProcessExecutor(
     "oop-executor", cl::desc("Launch an out-of-process executor to run code"),
-    cl::ValueOptional);
+    cl::ValueOptional, cl::cat(ToolOptions));
 
 static cl::opt<std::string> OutOfProcessExecutorConnect(
     "oop-executor-connect",
-    cl::desc("Connect to an out-of-process executor via TCP"));
+    cl::desc("Connect to an out-of-process executor via TCP"),
+    cl::cat(ToolOptions));
 
 ExitOnError ExitOnErr;
 
 LLVM_ATTRIBUTE_USED void linkComponents() {
   errs() << (void *)&llvm_orc_registerEHFrameSectionWrapper
          << (void *)&llvm_orc_deregisterEHFrameSectionWrapper
          << (void *)&llvm_orc_registerJITLoaderGDBWrapper;
 }

 
 int main(int argc, char *argv[]) {
   InitLLVM X(argc, argv);
 
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm jitlink tool");
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 
   /// If timers are enabled, create a JITLinkTimers instance.
   std::unique_ptr<JITLinkTimers> Timers =
       ShowTimes ? std::make_unique<JITLinkTimers>() : nullptr;
 
   ExitOnErr(sanitizeArguments(getFirstFileTriple(), argv[0]));

llvm/tools/llvm-link/llvm-link.cpp

 #include "llvm/Transforms/IPO/FunctionImport.h"
 #include "llvm/Transforms/IPO/Internalize.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 
 #include <memory>
 #include <utility>
 using namespace llvm;
 
+static cl::OptionCategory ToolOptions("Tool Options");
 static cl::list<std::string> InputFilenames(cl::Positional, cl::OneOrMore,
-                                            cl::desc("<input bitcode files>"));
+                                            cl::desc("<input bitcode files>"),
+                                            cl::cat(ToolOptions));
 
 static cl::list<std::string> OverridingInputs(
     "override", cl::ZeroOrMore, cl::value_desc("filename"),
     cl::desc(
-        "input bitcode file which can override previously defined symbol(s)"));
+        "input bitcode file which can override previously defined symbol(s)"),
+    cl::cat(ToolOptions));
 
 // Option to simulate function importing for testing. This enables using
 // llvm-link to simulate ThinLTO backend processes.
 static cl::list<std::string> Imports(
     "import", cl::ZeroOrMore, cl::value_desc("function:filename"),
     cl::desc("Pair of function name and filename, where function should be "
-             "imported from bitcode in filename"));
+             "imported from bitcode in filename"),
+    cl::cat(ToolOptions));
 
 // Option to support testing of function importing. The module summary
 // must be specified in the case were we request imports via the -import
 // option, as well as when compiling any module with functions that may be
 // exported (imported by a different llvm-link -import invocation), to ensure
 // consistent promotion and renaming of locals.
 static cl::opt<std::string>
     SummaryIndex("summary-index", cl::desc("Module summary index filename"),
-                 cl::init(""), cl::value_desc("filename"));
+                 cl::init(""), cl::value_desc("filename"),
+                 cl::cat(ToolOptions));
 
-static cl::opt<std::string> OutputFilename("o",
-                                           cl::desc("Override output filename"),
-                                           cl::init("-"),
-                                           cl::value_desc("filename"));
+static cl::opt<std::string>
+    OutputFilename("o", cl::desc("Override output filename"), cl::init("-"),
+                   cl::value_desc("filename"), cl::cat(ToolOptions));
 
 static cl::opt<bool> Internalize("internalize",
-                                 cl::desc("Internalize linked symbols"));
+                                 cl::desc("Internalize linked symbols"),
+                                 cl::cat(ToolOptions));
 
 static cl::opt<bool>
     DisableDITypeMap("disable-debug-info-type-map",
-                     cl::desc("Don't use a uniquing type map for debug info"));
+                     cl::desc("Don't use a uniquing type map for debug info"),
+                     cl::cat(ToolOptions));
 
 static cl::opt<bool> OnlyNeeded("only-needed",
-                                cl::desc("Link only needed symbols"));
+                                cl::desc("Link only needed symbols"),
+                                cl::cat(ToolOptions));
 
-static cl::opt<bool> Force("f", cl::desc("Enable binary output on terminals"));
+static cl::opt<bool> Force("f", cl::desc("Enable binary output on terminals"),
+                           cl::cat(ToolOptions));
 
 static cl::opt<bool> DisableLazyLoad("disable-lazy-loading",
-                                     cl::desc("Disable lazy module loading"));
+                                     cl::desc("Disable lazy module loading"),
+                                     cl::cat(ToolOptions));
 
-static cl::opt<bool>
-    OutputAssembly("S", cl::desc("Write output as LLVM assembly"), cl::Hidden);
+static cl::opt<bool> OutputAssembly("S",
+                                    cl::desc("Write output as LLVM assembly"),
+                                    cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<bool> Verbose("v",
-                             cl::desc("Print information about actions taken"));
+                             cl::desc("Print information about actions taken"),
+                             cl::cat(ToolOptions));
 
 static cl::opt<bool> DumpAsm("d", cl::desc("Print assembly as linked"),
-                             cl::Hidden);
+                             cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<bool> SuppressWarnings("suppress-warnings",
                                       cl::desc("Suppress all linking warnings"),
-                                      cl::init(false));
+                                      cl::init(false), cl::cat(ToolOptions));
 
 static cl::opt<bool> PreserveBitcodeUseListOrder(
     "preserve-bc-uselistorder",
     cl::desc("Preserve use-list order when writing LLVM bitcode."),
-    cl::init(true), cl::Hidden);
+    cl::init(true), cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<bool> PreserveAssemblyUseListOrder(
     "preserve-ll-uselistorder",
     cl::desc("Preserve use-list order when writing LLVM assembly."),
-    cl::init(false), cl::Hidden);
+    cl::init(false), cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<bool> NoVerify("disable-verify",
-                              cl::desc("Do not run the verifier"), cl::Hidden);
+                              cl::desc("Do not run the verifier"), cl::Hidden,
+                              cl::cat(ToolOptions));
 
 static ExitOnError ExitOnErr;
 
 // Read the specified bitcode file in and return it. This routine searches the
 // link path for the specified file to try to find it...
 //
 static std::unique_ptr<Module> loadFile(const char *argv0,
                                         std::unique_ptr<MemoryBuffer> Buffer,

 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 
   LLVMContext Context;
   Context.setDiagnosticHandler(std::make_unique<LLVMLinkDiagnosticHandler>(),
                                true);
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm linker\n");
 
   if (!DisableDITypeMap)
     Context.enableDebugTypeODRUniquing();
 
   auto Composite = std::make_unique<Module>("llvm-link", Context);
   Linker L(*Composite);
 

llvm/tools/llvm-lto/llvm-lto.cpp

 #include <tuple>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 static codegen::RegisterCodeGenFlags CGF;
 
+static cl::OptionCategory ToolOptions("Tool Options");
 static cl::opt<char>
-    OptLevel("O", cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
-                           "(default = '-O2')"),
-             cl::Prefix, cl::ZeroOrMore, cl::init('2'));
+    OptLevel("O",
+             cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
+             cl::Prefix, cl::ZeroOrMore, cl::init('2'), cl::cat(ToolOptions));
 
 static cl::opt<bool>
     IndexStats("thinlto-index-stats",
                cl::desc("Print statistic for the index in every input files"),
-               cl::init(false));
+               cl::init(false), cl::cat(ToolOptions));
 
 static cl::opt<bool> DisableVerify(
     "disable-verify", cl::init(false),
-    cl::desc("Do not run the verifier during the optimization pipeline"));
+    cl::desc("Do not run the verifier during the optimization pipeline"),
+    cl::cat(ToolOptions));
 
 static cl::opt<bool> EnableFreestanding(
     "lto-freestanding", cl::init(false),
-    cl::desc("Enable Freestanding (disable builtins / TLI) during LTO"));
+    cl::desc("Enable Freestanding (disable builtins / TLI) during LTO"),
+    cl::cat(ToolOptions));
 
 static cl::opt<bool> UseDiagnosticHandler(
     "use-diagnostic-handler", cl::init(false),
-    cl::desc("Use a diagnostic handler to test the handler interface"));
+    cl::desc("Use a diagnostic handler to test the handler interface"),
+    cl::cat(ToolOptions));
 
 static cl::opt<bool>
     ThinLTO("thinlto", cl::init(false),
-            cl::desc("Only write combined global index for ThinLTO backends"));
+            cl::desc("Only write combined global index for ThinLTO backends"),
+            cl::cat(ToolOptions));
 
 enum ThinLTOModes {
   THINLINK,
   THINDISTRIBUTE,
   THINEMITIMPORTS,
   THINPROMOTE,
   THINIMPORT,
   THININTERNALIZE,
   THINOPT,
   THINCODEGEN,
   THINALL
 };
 
 cl::opt<ThinLTOModes> ThinLTOMode(
     "thinlto-action", cl::desc("Perform a single ThinLTO stage:"),
     cl::values(
         clEnumValN(
             THINLINK, "thinlink",
             "ThinLink: produces the index by linking only the summaries."),
         clEnumValN(THINDISTRIBUTE, "distributedindexes",
                    "Produces individual indexes for distributed backends."),
         clEnumValN(THINEMITIMPORTS, "emitimports",
private:
 
   /// Load the combined index from disk, then load every file referenced by
 };
 
 } // end namespace thinlto
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm LTO linker\n");
 
   if (OptLevel < '0' || OptLevel > '3')
     error("optimization level must be between 0 and 3");
 
   // Initialize the configured targets.
   InitializeAllTargets();
   InitializeAllTargetMCs();

llvm/tools/llvm-mc/llvm-mc.cpp

 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 
 using namespace llvm;
 
 static mc::RegisterMCTargetOptionsFlags MOF;
 
-static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
+static cl::OptionCategory ToolOptions("Tool Options");
+
+static cl::opt<std::string> InputFilename(cl::Positional,
+                                          cl::desc("<input file>"),
+                                          cl::init("-"), cl::cat(ToolOptions));
 
 static cl::list<std::string>
-    DisassemblerOptions("M", cl::desc("Disassembler options"));
+    DisassemblerOptions("M", cl::desc("Disassembler options"),
+                        cl::cat(ToolOptions));
 
 static cl::opt<std::string> OutputFilename("o", cl::desc("Output filename"),
                                            cl::value_desc("filename"),
-                                           cl::init("-"));
+                                           cl::init("-"), cl::cat(ToolOptions));
 
 static cl::opt<std::string> SplitDwarfFile("split-dwarf-file",
                                            cl::desc("DWO output filename"),
-                                           cl::value_desc("filename"));
+                                           cl::value_desc("filename"),
+                                           cl::cat(ToolOptions));
 
-static cl::opt<bool>
-ShowEncoding("show-encoding", cl::desc("Show instruction encodings"));
+static cl::opt<bool> ShowEncoding("show-encoding",
+                                  cl::desc("Show instruction encodings"),
+                                  cl::cat(ToolOptions));
 
 static cl::opt<bool> RelaxELFRel(
     "relax-relocations", cl::init(true),
-    cl::desc("Emit R_X86_64_GOTPCRELX instead of R_X86_64_GOTPCREL"));
+    cl::desc("Emit R_X86_64_GOTPCRELX instead of R_X86_64_GOTPCREL"),
+    cl::cat(ToolOptions));
 
 static cl::opt<DebugCompressionType> CompressDebugSections(
     "compress-debug-sections", cl::ValueOptional,
     cl::init(DebugCompressionType::None),
     cl::desc("Choose DWARF debug sections compression:"),
     cl::values(clEnumValN(DebugCompressionType::None, "none", "No compression"),
                clEnumValN(DebugCompressionType::Z, "zlib",
                           "Use zlib compression"),
                clEnumValN(DebugCompressionType::GNU, "zlib-gnu",
-                          "Use zlib-gnu compression (deprecated)")));
+                          "Use zlib-gnu compression (deprecated)")),
+    cl::cat(ToolOptions));
 
 static cl::opt<bool>
-ShowInst("show-inst", cl::desc("Show internal instruction representation"));
+    ShowInst("show-inst", cl::desc("Show internal instruction representation"),
+             cl::cat(ToolOptions));
 
 static cl::opt<bool>
     ShowInstOperands("show-inst-operands",
-                 cl::desc("Show instructions operands as parsed"));
+                     cl::desc("Show instructions operands as parsed"),
+                     cl::cat(ToolOptions));
 
 static cl::opt<unsigned>
     OutputAsmVariant("output-asm-variant",
-                 cl::desc("Syntax variant to use for output printing"));
+                     cl::desc("Syntax variant to use for output printing"),
+                     cl::cat(ToolOptions));
 
 static cl::opt<bool>
     PrintImmHex("print-imm-hex", cl::init(false),
-            cl::desc("Prefer hex format for immediate values"));
+                cl::desc("Prefer hex format for immediate values"),
+                cl::cat(ToolOptions));
 
 static cl::list<std::string>
-DefineSymbol("defsym", cl::desc("Defines a symbol to be an integer constant"));
+    DefineSymbol("defsym",
+                 cl::desc("Defines a symbol to be an integer constant"),
+                 cl::cat(ToolOptions));
 
 static cl::opt<bool>
     PreserveComments("preserve-comments",
-                     cl::desc("Preserve Comments in outputted assembly"));
+                     cl::desc("Preserve Comments in outputted assembly"),
+                     cl::cat(ToolOptions));
 
 enum OutputFileType {
   OFT_Null,
   OFT_AssemblyFile,
   OFT_ObjectFile
 };
 static cl::opt<OutputFileType>
     FileType("filetype", cl::init(OFT_AssemblyFile),
              cl::desc("Choose an output file type:"),
-  cl::values(
-       clEnumValN(OFT_AssemblyFile, "asm",
+             cl::values(clEnumValN(OFT_AssemblyFile, "asm",
                                    "Emit an assembly ('.s') file"),
                         clEnumValN(OFT_Null, "null",
                                    "Don't emit anything (for timing purposes)"),
                         clEnumValN(OFT_ObjectFile, "obj",
-                  "Emit a native object ('.o') file")));
+                                   "Emit a native object ('.o') file")),
+             cl::cat(ToolOptions));
 
-static cl::list<std::string>
-IncludeDirs("I", cl::desc("Directory of include files"),
-            cl::value_desc("directory"), cl::Prefix);
+static cl::list<std::string> IncludeDirs("I",
+                                         cl::desc("Directory of include files"),
+                                         cl::value_desc("directory"),
+                                         cl::Prefix, cl::cat(ToolOptions));
 
 static cl::opt<std::string>
-ArchName("arch", cl::desc("Target arch to assemble for, "
-                          "see -version for available targets"));
+    ArchName("arch",
+             cl::desc("Target arch to assemble for, "
+                      "see -version for available targets"),
+             cl::cat(ToolOptions));
 
 static cl::opt<std::string>
-TripleName("triple", cl::desc("Target triple to assemble for, "
-                              "see -version for available targets"));
+    TripleName("triple",
+               cl::desc("Target triple to assemble for, "
+                        "see -version for available targets"),
+               cl::cat(ToolOptions));
 
 static cl::opt<std::string>
     MCPU("mcpu",
          cl::desc("Target a specific cpu type (-mcpu=help for details)"),
-     cl::value_desc("cpu-name"),
-     cl::init(""));
+         cl::value_desc("cpu-name"), cl::init(""), cl::cat(ToolOptions));
 
 static cl::list<std::string>
-MAttrs("mattr",
-  cl::CommaSeparated,
+    MAttrs("mattr", cl::CommaSeparated,
            cl::desc("Target specific attributes (-mattr=help for details)"),
-  cl::value_desc("a1,+a2,-a3,..."));
+           cl::value_desc("a1,+a2,-a3,..."), cl::cat(ToolOptions));
 
 static cl::opt<bool> PIC("position-independent",
-                         cl::desc("Position independent"), cl::init(false));
+                         cl::desc("Position independent"), cl::init(false),
+                         cl::cat(ToolOptions));
 
 static cl::opt<bool>
     LargeCodeModel("large-code-model",
                    cl::desc("Create cfi directives that assume the code might "
-                            "be more than 2gb away"));
+                            "be more than 2gb away"),
+                   cl::cat(ToolOptions));
 
 static cl::opt<bool>
-NoInitialTextSection("n", cl::desc("Don't assume assembly file starts "
-                                   "in the text section"));
+    NoInitialTextSection("n",
+                         cl::desc("Don't assume assembly file starts "
+                                  "in the text section"),
+                         cl::cat(ToolOptions));
 
 static cl::opt<bool>
-GenDwarfForAssembly("g", cl::desc("Generate dwarf debugging info for assembly "
-                                  "source files"));
+    GenDwarfForAssembly("g",
+                        cl::desc("Generate dwarf debugging info for assembly "
+                                 "source files"),
+                        cl::cat(ToolOptions));
 
 static cl::opt<std::string>
     DebugCompilationDir("fdebug-compilation-dir",
-                    cl::desc("Specifies the debug info's compilation dir"));
-
-static cl::list<std::string>
-DebugPrefixMap("fdebug-prefix-map",
-               cl::desc("Map file source paths in debug info"),
-               cl::value_desc("= separated key-value pairs"));
+                        cl::desc("Specifies the debug info's compilation dir"),
+                        cl::cat(ToolOptions));
 
-static cl::opt<std::string>
-MainFileName("main-file-name",
-             cl::desc("Specifies the name we should consider the input file"));
+static cl::list<std::string> DebugPrefixMap(
+    "fdebug-prefix-map", cl::desc("Map file source paths in debug info"),
+    cl::value_desc("= separated key-value pairs"), cl::cat(ToolOptions));
+
+static cl::opt<std::string> MainFileName(
+    "main-file-name",
+    cl::desc("Specifies the name we should consider the input file"),
+    cl::cat(ToolOptions));
 
 static cl::opt<bool> SaveTempLabels("save-temp-labels",
-                                    cl::desc("Don't discard temporary labels"));
+                                    cl::desc("Don't discard temporary labels"),
+                                    cl::cat(ToolOptions));
 
 static cl::opt<bool> LexMasmIntegers(
     "masm-integers",
-    cl::desc("Enable binary and hex masm integers (0b110 and 0ABCh)"));
+    cl::desc("Enable binary and hex masm integers (0b110 and 0ABCh)"),
+    cl::cat(ToolOptions));
 
 static cl::opt<bool> LexMasmHexFloats(
     "masm-hexfloats",
-    cl::desc("Enable MASM-style hex float initializers (3F800000r)"));
+    cl::desc("Enable MASM-style hex float initializers (3F800000r)"),
+    cl::cat(ToolOptions));
 
 static cl::opt<bool> LexMotorolaIntegers(
     "motorola-integers",
-    cl::desc("Enable binary and hex Motorola integers (%110 and $ABC)"));
+    cl::desc("Enable binary and hex Motorola integers (%110 and $ABC)"),
+    cl::cat(ToolOptions));
 
 static cl::opt<bool> NoExecStack("no-exec-stack",
-                                 cl::desc("File doesn't need an exec stack"));
+                                 cl::desc("File doesn't need an exec stack"),
+                                 cl::cat(ToolOptions));
 
 enum ActionType {
   AC_AsLex,
   AC_Assemble,
   AC_Disassemble,
   AC_MDisassemble,
 };
 
-static cl::opt<ActionType>
-Action(cl::desc("Action to perform:"),
-       cl::init(AC_Assemble),
-       cl::values(clEnumValN(AC_AsLex, "as-lex",
-                             "Lex tokens from a .s file"),
-                  clEnumValN(AC_Assemble, "assemble",
-                             "Assemble a .s file (default)"),
-                  clEnumValN(AC_Disassemble, "disassemble",
-                             "Disassemble strings of hex bytes"),
-                  clEnumValN(AC_MDisassemble, "mdis",
-                             "Marked up disassembly of strings of hex bytes")));
+static cl::opt<ActionType> Action(
+    cl::desc("Action to perform:"), cl::init(AC_Assemble),
+    cl::values(clEnumValN(AC_AsLex, "as-lex", "Lex tokens from a .s file"),
+                          "Marked up disassembly of strings of hex bytes")),
+    cl::cat(ToolOptions));
 
 static const Target *GetTarget(const char *ProgName) {
   // Figure out the target triple.
   if (TripleName.empty())
     TripleName = sys::getDefaultTargetTriple();
   Triple TheTriple(Triple::normalize(TripleName));
 
   // Get the target specific parser.
int main(int argc, char **argv) {
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
   llvm::InitializeAllDisassemblers();
 
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm machine code playground\n");
   const MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
   setDwarfDebugFlags(argc, argv);
 
   setDwarfDebugProducer();
 
   const char *ProgName = argv[0];
   const Target *TheTarget = GetTarget(ProgName);

llvm/tools/llvm-modextract/llvm-modextract.cpp

 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace llvm;
 
+static cl::OptionCategory ToolOptions("Tool Options");
+
 static cl::opt<bool>
-    BinaryExtract("b", cl::desc("Whether to perform binary extraction"));
+    BinaryExtract("b", cl::desc("Whether to perform binary extraction"),
+                  cl::cat(ToolOptions));
 
 static cl::opt<std::string> OutputFilename("o", cl::Required,
                                            cl::desc("Output filename"),
-                                           cl::value_desc("filename"));
+                                           cl::value_desc("filename"),
+                                           cl::cat(ToolOptions));
 
-static cl::opt<std::string>
-    InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
+static cl::opt<std::string> InputFilename(cl::Positional,
+                                          cl::desc("<input bitcode>"),
+                                          cl::init("-"), cl::cat(ToolOptions));
 
 static cl::opt<unsigned> ModuleIndex("n", cl::Required,
                                      cl::desc("Index of module to extract"),
-                                     cl::value_desc("index"));
+                                     cl::value_desc("index"),
+                                     cl::cat(ToolOptions));
 
 int main(int argc, char **argv) {
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "Module extractor");
 
   ExitOnError ExitOnErr("llvm-modextract: error: ");
 
   std::unique_ptr<MemoryBuffer> MB =
       ExitOnErr(errorOrToExpected(MemoryBuffer::getFileOrSTDIN(InputFilename)));
   std::vector<BitcodeModule> Ms = ExitOnErr(getBitcodeModuleList(*MB));
 

llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp

static void simplifyChunkList(llvm::cl::list<opts::ModuleSubsection> &Chunks) {
   Chunks.reset();
   Chunks.push_back(opts::ModuleSubsection::All);
 }
 
 int main(int Argc, const char **Argv) {
   InitLLVM X(Argc, Argv);
   ExitOnErr.setBanner("llvm-pdbutil: ");
 
+  cl::HideUnrelatedOptions(
+      {&opts::TypeCategory, &opts::FilterCategory, &opts::OtherOptions,
+       &opts::FileOptions, &opts::bytes::MsfBytes, &opts::bytes::DbiBytes,
+       &opts::bytes::PdbBytes, &opts::bytes::Types,
+       &opts::bytes::ModuleCategory, &opts::dump::MsfOptions,
+       &opts::dump::TypeOptions, &opts::dump::SymbolOptions,
+       &opts::dump::MiscOptions});
   cl::ParseCommandLineOptions(Argc, Argv, "LLVM PDB Dumper\n");
 
   if (opts::BytesSubcommand) {
     if (!parseRange(opts::bytes::DumpBlockRangeOpt,
                     opts::bytes::DumpBlockRange)) {
       errs() << "Argument '" << opts::bytes::DumpBlockRangeOpt
              << "' invalid format.\n";
       errs().flush();

llvm/tools/llvm-readobj/llvm-readobj.cpp

 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/WithColor.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 namespace opts {
-  cl::list<std::string> InputFilenames(cl::Positional,
+cl::OptionCategory ToolOptions("Tool Options");
+
                                      cl::desc("<input object files>"),
-    cl::ZeroOrMore);
+                                     cl::ZeroOrMore, cl::cat(ToolOptions));
 
-  // --all, -a
-  cl::opt<bool>
-      All("all",
-          cl::desc("Equivalent to setting: --file-headers, --program-headers, "
-                   "--section-headers, --symbols, --relocations, "
-                   "--dynamic-table, --notes, --version-info, --unwind, "
-                   "--section-groups and --elf-hash-histogram."));
-  cl::alias AllShort("a", cl::desc("Alias for --all"), cl::aliasopt(All));
+                 "--section-groups and --elf-hash-histogram."),
+        cl::cat(ToolOptions));
+cl::alias AllShort("a", cl::desc("Alias for --all"), cl::aliasopt(All),
+                   cl::cat(ToolOptions));
 
-  // --dependent-libraries
-  cl::opt<bool>
-      DependentLibraries("dependent-libraries",
-                         cl::desc("Display the dependent libraries section"));
+                       cl::desc("Display the dependent libraries section"),
+                       cl::cat(ToolOptions));
 
-  // --headers, -e
-  cl::opt<bool>
-      Headers("headers",
-          cl::desc("Equivalent to setting: --file-headers, --program-headers, "
-                   "--section-headers"));
-  cl::alias HeadersShort("e", cl::desc("Alias for --headers"),
-                         cl::aliasopt(Headers), cl::NotHidden);
+cl::opt<bool> Headers(
+    "headers",
+             "--section-headers"),
+    cl::cat(ToolOptions));
+                       cl::aliasopt(Headers), cl::NotHidden,
+                       cl::cat(ToolOptions));
 
-  // --wide, -W
-  cl::opt<bool>
-      WideOutput("wide", cl::desc("Ignored for compatibility with GNU readelf"),
-                 cl::Hidden);
-  cl::alias WideOutputShort("W",
-    cl::desc("Alias for --wide"),
-    cl::aliasopt(WideOutput));
+cl::opt<bool> WideOutput("wide",
+                         cl::desc("Ignored for compatibility with GNU readelf"),
+                         cl::Hidden, cl::cat(ToolOptions));
+cl::alias WideOutputShort("W", cl::desc("Alias for --wide"),
+                          cl::aliasopt(WideOutput), cl::cat(ToolOptions));
 
-  // --file-headers, --file-header, -h
-  cl::opt<bool> FileHeaders("file-headers",
-    cl::desc("Display file headers "));
-  cl::alias FileHeadersShort("h", cl::desc("Alias for --file-headers"),
-                             cl::aliasopt(FileHeaders), cl::NotHidden);
-  cl::alias FileHeadersSingular("file-header",
-                                cl::desc("Alias for --file-headers"),
-                                cl::aliasopt(FileHeaders));
+cl::opt<bool> FileHeaders("file-headers", cl::desc("Display file headers "),
+                          cl::cat(ToolOptions));
+                           cl::aliasopt(FileHeaders), cl::NotHidden,
+                           cl::cat(ToolOptions));
+                              cl::aliasopt(FileHeaders), cl::cat(ToolOptions));
 
-  // --section-headers, --sections, -S
-  // Also -s in llvm-readobj mode.
-  cl::opt<bool> SectionHeaders("section-headers",
-                               cl::desc("Display all section headers."));
-  cl::alias SectionsShortUpper("S", cl::desc("Alias for --section-headers"),
-                               cl::aliasopt(SectionHeaders), cl::NotHidden);
-  cl::alias SectionHeadersAlias("sections",
-                                cl::desc("Alias for --section-headers"),
-                                cl::aliasopt(SectionHeaders), cl::NotHidden);
+                             cl::aliasopt(SectionHeaders), cl::NotHidden,
+                             cl::cat(ToolOptions));
+                              cl::aliasopt(SectionHeaders), cl::NotHidden,
+                              cl::cat(ToolOptions));
 
-  // --section-relocations
-  // Also --sr in llvm-readobj mode.
-  cl::opt<bool> SectionRelocations("section-relocations",
-    cl::desc("Display relocations for each section shown."));
+cl::opt<bool>
+    SectionRelocations("section-relocations",
+                       cl::desc("Display relocations for each section shown."),
+                       cl::cat(ToolOptions));
 
-  // --section-symbols
-  // Also --st in llvm-readobj mode.
-  cl::opt<bool> SectionSymbols("section-symbols",
-    cl::desc("Display symbols for each section shown."));
+cl::opt<bool>
+    SectionSymbols("section-symbols",
+                   cl::desc("Display symbols for each section shown."),
+                   cl::cat(ToolOptions));
 
-  // --section-data
-  // Also --sd in llvm-readobj mode.
-  cl::opt<bool> SectionData("section-data",
-    cl::desc("Display section data for each section shown."));
+cl::opt<bool>
+    SectionData("section-data",
+                cl::desc("Display section data for each section shown."),
+                cl::cat(ToolOptions));
 
-  // --section-mapping
-  cl::opt<cl::boolOrDefault>
-      SectionMapping("section-mapping",
-                     cl::desc("Display the section to segment mapping."));
+                   cl::desc("Display the section to segment mapping."),
+                   cl::cat(ToolOptions));
 
-  // --relocations, --relocs, -r
-  cl::opt<bool> Relocations("relocations",
-    cl::desc("Display the relocation entries in the file"));
-  cl::alias RelocationsShort("r", cl::desc("Alias for --relocations"),
-                             cl::aliasopt(Relocations), cl::NotHidden);
-  cl::alias RelocationsGNU("relocs", cl::desc("Alias for --relocations"),
-                           cl::aliasopt(Relocations));
+cl::opt<bool>
+    Relocations("relocations",
+                cl::desc("Display the relocation entries in the file"),
+                cl::cat(ToolOptions));
+                           cl::aliasopt(Relocations), cl::NotHidden,
+                           cl::cat(ToolOptions));
+                         cl::aliasopt(Relocations), cl::cat(ToolOptions));
 
-  // --notes, -n
-  cl::opt<bool> Notes("notes", cl::desc("Display the ELF notes in the file"));
-  cl::alias NotesShort("n", cl::desc("Alias for --notes"), cl::aliasopt(Notes),
-                       cl::NotHidden);
+cl::opt<bool> Notes("notes", cl::desc("Display the ELF notes in the file"),
+                    cl::cat(ToolOptions));
+                     cl::NotHidden, cl::cat(ToolOptions));
 
-  // --dyn-relocations
-  cl::opt<bool> DynRelocs("dyn-relocations",
-    cl::desc("Display the dynamic relocation entries in the file"));
+cl::opt<bool>
+    DynRelocs("dyn-relocations",
+              cl::desc("Display the dynamic relocation entries in the file"),
+              cl::cat(ToolOptions));
 
-  // --section-details
-  // Also -t in llvm-readelf mode.
-  cl::opt<bool> SectionDetails("section-details",
-                               cl::desc("Display the section details"));
+                             cl::desc("Display the section details"),
+                             cl::cat(ToolOptions));
 
-  // --symbols
-  // Also -s in llvm-readelf mode, or -t in llvm-readobj mode.
-  cl::opt<bool>
-      Symbols("symbols",
-              cl::desc("Display the symbol table. Also display the dynamic "
-                       "symbol table when using GNU output style for ELF"));
-  cl::alias SymbolsGNU("syms", cl::desc("Alias for --symbols"),
-                       cl::aliasopt(Symbols));
+                     "symbol table when using GNU output style for ELF"),
+            cl::cat(ToolOptions));
+                     cl::aliasopt(Symbols), cl::cat(ToolOptions));
 
-  // --dyn-symbols, --dyn-syms
-  // Also --dt in llvm-readobj mode.
-  cl::opt<bool> DynamicSymbols("dyn-symbols",
-    cl::desc("Display the dynamic symbol table"));
-  cl::alias DynSymsGNU("dyn-syms", cl::desc("Alias for --dyn-symbols"),
-                       cl::aliasopt(DynamicSymbols));
+                             cl::desc("Display the dynamic symbol table"),
+                             cl::cat(ToolOptions));
+                     cl::aliasopt(DynamicSymbols), cl::cat(ToolOptions));
 
-  // --hash-symbols
-  cl::opt<bool> HashSymbols(
-      "hash-symbols",
-      cl::desc("Display the dynamic symbols derived from the hash section"));
+    cl::desc("Display the dynamic symbols derived from the hash section"),
+    cl::cat(ToolOptions));
 
-  // --unwind, -u
-  cl::opt<bool> UnwindInfo("unwind",
-    cl::desc("Display unwind information"));
-  cl::alias UnwindInfoShort("u", cl::desc("Alias for --unwind"),
-                            cl::aliasopt(UnwindInfo), cl::NotHidden);
+cl::opt<bool> UnwindInfo("unwind", cl::desc("Display unwind information"));
+                          cl::aliasopt(UnwindInfo), cl::NotHidden,
+                          cl::cat(ToolOptions));
 
-  // --dynamic-table, --dynamic, -d
-  cl::opt<bool> DynamicTable("dynamic-table",
-    cl::desc("Display the ELF .dynamic section table"));
-  cl::alias DynamicTableShort("d", cl::desc("Alias for --dynamic-table"),
-                              cl::aliasopt(DynamicTable), cl::NotHidden);
-  cl::alias DynamicTableAlias("dynamic", cl::desc("Alias for --dynamic-table"),
-                              cl::aliasopt(DynamicTable));
+                           cl::desc("Display the ELF .dynamic section table"),
+                           cl::cat(ToolOptions));
+                            cl::aliasopt(DynamicTable), cl::NotHidden,
+                            cl::cat(ToolOptions));
+                            cl::aliasopt(DynamicTable), cl::cat(ToolOptions));
 
-  // --needed-libs
-  cl::opt<bool> NeededLibraries("needed-libs",
-    cl::desc("Display the needed libraries"));
+                              cl::desc("Display the needed libraries"),
+                              cl::cat(ToolOptions));
 
-  // --program-headers, --segments, -l
-  cl::opt<bool> ProgramHeaders("program-headers",
-    cl::desc("Display ELF program headers"));
-  cl::alias ProgramHeadersShort("l", cl::desc("Alias for --program-headers"),
-                                cl::aliasopt(ProgramHeaders), cl::NotHidden);
-  cl::alias SegmentsAlias("segments", cl::desc("Alias for --program-headers"),
-                          cl::aliasopt(ProgramHeaders));
+                             cl::desc("Display ELF program headers"),
+                             cl::cat(ToolOptions));
+                              cl::aliasopt(ProgramHeaders), cl::NotHidden,
+                              cl::cat(ToolOptions));
+                        cl::aliasopt(ProgramHeaders), cl::cat(ToolOptions));
 
-  // --string-dump, -p
-  cl::list<std::string> StringDump(
-      "string-dump", cl::value_desc("number|name"),
-      cl::desc("Display the specified section(s) as a list of strings"),
-      cl::ZeroOrMore);
-  cl::alias StringDumpShort("p", cl::desc("Alias for --string-dump"),
-                            cl::aliasopt(StringDump), cl::Prefix,
-                            cl::NotHidden);
+    cl::ZeroOrMore, cl::cat(ToolOptions));
+                          cl::aliasopt(StringDump), cl::Prefix, cl::NotHidden,
+                          cl::cat(ToolOptions));
 
-  // --hex-dump, -x
-  cl::list<std::string>
-      HexDump("hex-dump", cl::value_desc("number|name"),
-              cl::desc("Display the specified section(s) as hexadecimal bytes"),
-              cl::ZeroOrMore);
-  cl::alias HexDumpShort("x", cl::desc("Alias for --hex-dump"),
-                         cl::aliasopt(HexDump), cl::Prefix, cl::NotHidden);
+            cl::ZeroOrMore, cl::cat(ToolOptions));
+                       cl::aliasopt(HexDump), cl::Prefix, cl::NotHidden,
+                       cl::cat(ToolOptions));
 
-  // --demangle, -C
-  cl::opt<bool> Demangle("demangle",
-                         cl::desc("Demangle symbol names in output"));
-  cl::alias DemangleShort("C", cl::desc("Alias for --demangle"),
-                          cl::aliasopt(Demangle), cl::NotHidden);
+cl::opt<bool> Demangle("demangle", cl::desc("Demangle symbol names in output"));
+                        cl::aliasopt(Demangle), cl::NotHidden,
+                        cl::cat(ToolOptions));
 
-  // --hash-table
-  cl::opt<bool> HashTable("hash-table",
-    cl::desc("Display ELF hash table"));
+cl::opt<bool> HashTable("hash-table", cl::desc("Display ELF hash table"),
+                        cl::cat(ToolOptions));
 
-  // --gnu-hash-table
-  cl::opt<bool> GnuHashTable("gnu-hash-table",
-    cl::desc("Display ELF .gnu.hash section"));
+                           cl::desc("Display ELF .gnu.hash section"),
+                           cl::cat(ToolOptions));
 
-  // --expand-relocs
-  cl::opt<bool> ExpandRelocs("expand-relocs",
-    cl::desc("Expand each shown relocation to multiple lines"));
+cl::opt<bool>
+    ExpandRelocs("expand-relocs",
+                 cl::desc("Expand each shown relocation to multiple lines"),
+                 cl::cat(ToolOptions));
 
-  // --raw-relr
-  cl::opt<bool> RawRelr("raw-relr",
-    cl::desc("Do not decode relocations in SHT_RELR section, display raw contents"));
+cl::opt<bool> RawRelr(
+    "raw-relr",
+    cl::desc(
+        "Do not decode relocations in SHT_RELR section, display raw contents"),
+    cl::cat(ToolOptions));
 
-  // --codeview
-  cl::opt<bool> CodeView("codeview",
-                         cl::desc("Display CodeView debug information"));
+                       cl::desc("Display CodeView debug information"),
+                       cl::cat(ToolOptions));
 
-  // --codeview-merged-types
-  cl::opt<bool>
-      CodeViewMergedTypes("codeview-merged-types",
-                          cl::desc("Display the merged CodeView type stream"));
+                        cl::desc("Display the merged CodeView type stream"),
+                        cl::cat(ToolOptions));
 
-  // --codeview-ghash
-  cl::opt<bool> CodeViewEnableGHash(
-      "codeview-ghash",
-      cl::desc(
-          "Enable global hashing for CodeView type stream de-duplication"));
+    cl::desc("Enable global hashing for CodeView type stream de-duplication"),
+    cl::cat(ToolOptions));
 
-  // --codeview-subsection-bytes
-  cl::opt<bool> CodeViewSubsectionBytes(
-      "codeview-subsection-bytes",
-      cl::desc("Dump raw contents of codeview debug sections and records"));
+    cl::desc("Dump raw contents of codeview debug sections and records"),
+    cl::cat(ToolOptions));
 
-  // --arch-specific
-  cl::opt<bool> ArchSpecificInfo("arch-specific",
-                              cl::desc("Displays architecture-specific information, if there is any."));
-  cl::alias ArchSpecifcInfoShort("A", cl::desc("Alias for --arch-specific"),
-                                 cl::aliasopt(ArchSpecificInfo), cl::NotHidden);
+cl::opt<bool> ArchSpecificInfo(
+    "arch-specific",
+    cl::desc("Displays architecture-specific information, if there is any."),
+    cl::cat(ToolOptions));
+                               cl::aliasopt(ArchSpecificInfo), cl::NotHidden,
+                               cl::cat(ToolOptions));
 
-  // --coff-imports
-  cl::opt<bool>
-  COFFImports("coff-imports", cl::desc("Display the PE/COFF import table"));
+cl::opt<bool> COFFImports("coff-imports",
+                          cl::desc("Display the PE/COFF import table"),
+                          cl::cat(ToolOptions));
 
-  // --coff-exports
-  cl::opt<bool>
-  COFFExports("coff-exports", cl::desc("Display the PE/COFF export table"));
+cl::opt<bool> COFFExports("coff-exports",
+                          cl::desc("Display the PE/COFF export table"),
+                          cl::cat(ToolOptions));
 
-  // --coff-directives
-  cl::opt<bool>
-  COFFDirectives("coff-directives",
-                 cl::desc("Display the PE/COFF .drectve section"));
+cl::opt<bool> COFFDirectives("coff-directives",
+                             cl::desc("Display the PE/COFF .drectve section"),
+                             cl::cat(ToolOptions));
 
-  // --coff-basereloc
-  cl::opt<bool>
-  COFFBaseRelocs("coff-basereloc",
-                 cl::desc("Display the PE/COFF .reloc section"));
+cl::opt<bool> COFFBaseRelocs("coff-basereloc",
+                             cl::desc("Display the PE/COFF .reloc section"),
+                             cl::cat(ToolOptions));
 
-  // --coff-debug-directory
-  cl::opt<bool>
     COFFDebugDirectory("coff-debug-directory",
-                     cl::desc("Display the PE/COFF debug directory"));
+                       cl::desc("Display the PE/COFF debug directory"),
+                       cl::cat(ToolOptions));
 
-  // --coff-tls-directory
-  cl::opt<bool> COFFTLSDirectory("coff-tls-directory",
-                                 cl::desc("Display the PE/COFF TLS directory"));
+                               cl::desc("Display the PE/COFF TLS directory"),
+                               cl::cat(ToolOptions));
 
-  // --coff-resources
-  cl::opt<bool> COFFResources("coff-resources",
-                              cl::desc("Display the PE/COFF .rsrc section"));
+                            cl::desc("Display the PE/COFF .rsrc section"),
+                            cl::cat(ToolOptions));
 
-  // --coff-load-config
-  cl::opt<bool>
-  COFFLoadConfig("coff-load-config",
-                 cl::desc("Display the PE/COFF load config"));
+cl::opt<bool> COFFLoadConfig("coff-load-config",
+                             cl::desc("Display the PE/COFF load config"),
+                             cl::cat(ToolOptions));
 
-  // --elf-linker-options
-  cl::opt<bool>
     ELFLinkerOptions("elf-linker-options",
-                   cl::desc("Display the ELF .linker-options section"));
+                     cl::desc("Display the ELF .linker-options section"),
+                     cl::cat(ToolOptions));
 
-  // --macho-data-in-code
-  cl::opt<bool>
-  MachODataInCode("macho-data-in-code",
-                  cl::desc("Display MachO Data in Code command"));
+cl::opt<bool> MachODataInCode("macho-data-in-code",
+                              cl::desc("Display MachO Data in Code command"),
+                              cl::cat(ToolOptions));
 
-  // --macho-indirect-symbols
-  cl::opt<bool>
-  MachOIndirectSymbols("macho-indirect-symbols",
-                  cl::desc("Display MachO indirect symbols"));
+cl::opt<bool> MachOIndirectSymbols("macho-indirect-symbols",
+                                   cl::desc("Display MachO indirect symbols"),
+                                   cl::cat(ToolOptions));
 
-  // --macho-linker-options
-  cl::opt<bool>
-  MachOLinkerOptions("macho-linker-options",
-                  cl::desc("Display MachO linker options"));
+cl::opt<bool> MachOLinkerOptions("macho-linker-options",
+                                 cl::desc("Display MachO linker options"),
+                                 cl::cat(ToolOptions));
 
-  // --macho-segment
-  cl::opt<bool>
-  MachOSegment("macho-segment",
-                  cl::desc("Display MachO Segment command"));
+cl::opt<bool> MachOSegment("macho-segment",
+                           cl::desc("Display MachO Segment command"),
+                           cl::cat(ToolOptions));
 
-  // --macho-version-min
-  cl::opt<bool>
-  MachOVersionMin("macho-version-min",
-                  cl::desc("Display MachO version min command"));
+cl::opt<bool> MachOVersionMin("macho-version-min",
+                              cl::desc("Display MachO version min command"),
+                              cl::cat(ToolOptions));
 
-  // --macho-dysymtab
-  cl::opt<bool>
-  MachODysymtab("macho-dysymtab",
-                  cl::desc("Display MachO Dysymtab command"));
+cl::opt<bool> MachODysymtab("macho-dysymtab",
+                            cl::desc("Display MachO Dysymtab command"),
+                            cl::cat(ToolOptions));
 
-  // --stackmap
-  cl::opt<bool>
-  PrintStackMap("stackmap",
-                cl::desc("Display contents of stackmap section"));
+cl::opt<bool> PrintStackMap("stackmap",
+                            cl::desc("Display contents of stackmap section"),
+                            cl::cat(ToolOptions));
 
-  // --stack-sizes
-  cl::opt<bool>
-      PrintStackSizes("stack-sizes",
-                      cl::desc("Display contents of all stack sizes sections"));
+                    cl::desc("Display contents of all stack sizes sections"),
+                    cl::cat(ToolOptions));
 
-  // --version-info, -V
-  cl::opt<bool>
-      VersionInfo("version-info",
-                  cl::desc("Display ELF version sections (if present)"));
-  cl::alias VersionInfoShort("V", cl::desc("Alias for -version-info"),
-                             cl::aliasopt(VersionInfo), cl::NotHidden);
+                           cl::aliasopt(VersionInfo), cl::NotHidden,
+                           cl::cat(ToolOptions));
 
-  // --elf-section-groups, --section-groups, -g
-  cl::opt<bool> SectionGroups("elf-section-groups",
-                              cl::desc("Display ELF section group contents"));
-  cl::alias SectionGroupsAlias("section-groups",
-                               cl::desc("Alias for -elf-sections-groups"),
-                               cl::aliasopt(SectionGroups));
-  cl::alias SectionGroupsShort("g", cl::desc("Alias for -elf-sections-groups"),
-                               cl::aliasopt(SectionGroups), cl::NotHidden);
+                            cl::desc("Display ELF section group contents"),
+                            cl::cat(ToolOptions));
+                             cl::aliasopt(SectionGroups), cl::cat(ToolOptions));
+                             cl::aliasopt(SectionGroups), cl::NotHidden,
+                             cl::cat(ToolOptions));
 
-  // --elf-hash-histogram, --histogram, -I
-  cl::opt<bool> HashHistogram(
-      "elf-hash-histogram",
-      cl::desc("Display bucket list histogram for hash sections"));
-  cl::alias HashHistogramShort("I", cl::desc("Alias for -elf-hash-histogram"),
-                               cl::aliasopt(HashHistogram), cl::NotHidden);
-  cl::alias HistogramAlias("histogram",
-                           cl::desc("Alias for --elf-hash-histogram"),
-                           cl::aliasopt(HashHistogram));
+cl::opt<bool>
+    HashHistogram("elf-hash-histogram",
+                  cl::desc("Display bucket list histogram for hash sections"),
+                  cl::cat(ToolOptions));
+                             cl::aliasopt(HashHistogram), cl::NotHidden,
+                             cl::cat(ToolOptions));
+                         cl::aliasopt(HashHistogram), cl::cat(ToolOptions));
 
-  // --cg-profile
-  cl::opt<bool> CGProfile("cg-profile",
-                          cl::desc("Display callgraph profile section"));
-  cl::alias ELFCGProfile("elf-cg-profile", cl::desc("Alias for --cg-profile"),
-                         cl::aliasopt(CGProfile));
+                        cl::desc("Display callgraph profile section"),
+                        cl::cat(ToolOptions));
+                       cl::aliasopt(CGProfile), cl::cat(ToolOptions));
 
-  // --bb-addr-map
-  cl::opt<bool> BBAddrMap("bb-addr-map",
-                          cl::desc("Display the BB address map section"));
+                        cl::desc("Display the BB address map section"),
+                        cl::cat(ToolOptions));
 
-  // -addrsig
-  cl::opt<bool> Addrsig("addrsig",
-                        cl::desc("Display address-significance table"));
+cl::opt<bool> Addrsig("addrsig", cl::desc("Display address-significance table"),
+                      cl::cat(ToolOptions));
 
-  // -elf-output-style
-  cl::opt<OutputStyleTy>
-      Output("elf-output-style", cl::desc("Specify ELF dump style"),
+cl::opt<OutputStyleTy> Output("elf-output-style",
+                              cl::desc("Specify ELF dump style"),
                               cl::values(clEnumVal(LLVM, "LLVM default style"),
                                          clEnumVal(GNU, "GNU readelf style")),
-             cl::init(LLVM));
+                              cl::init(LLVM), cl::cat(ToolOptions));
 
-  cl::extrahelp
-      HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 } // namespace opts
 
 static StringRef ToolName;
 
 namespace llvm {
 
 LLVM_ATTRIBUTE_NORETURN static void error(Twine Msg) {
   // Flush the standard output to print the error at a
int main(int argc, const char *argv[]) {
 
   if (sys::path::stem(argv[0]).contains("readelf")) {
     opts::Output = opts::GNU;
     registerReadelfAliases();
   } else {
     registerReadobjAliases();
   }
 
+  cl::HideUnrelatedOptions(&opts::ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "LLVM Object Reader\n");
 
   // Default to print error if no filename is specified.
   if (opts::InputFilenames.empty()) {
     error("no input files specified");
   }
 
   if (opts::All) {

llvm/tools/llvm-reduce/llvm-reduce.cpp

 static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden,
                           cl::cat(Options));
 static cl::opt<bool> Version("v", cl::desc("Alias for -version"), cl::Hidden,
                              cl::cat(Options));
 
 static cl::opt<bool>
     PrintDeltaPasses("print-delta-passes",
                      cl::desc("Print list of delta passes, passable to "
-                              "--delta-passes as a comma separated list"));
+                              "--delta-passes as a comma separated list"),
+                     cl::cat(Options));
 
 static cl::opt<std::string> InputFilename(cl::Positional, cl::Required,
                                           cl::desc("<input llvm ll/bc file>"),
                                           cl::cat(Options));
 
 static cl::opt<std::string>
     TestFilename("test", cl::Required,
                  cl::desc("Name of the interesting-ness test to be run"),
void writeOutput(Module *M, StringRef Message) {
   }
   M->print(Out, /*AnnotationWriter=*/nullptr);
   errs() << Message << OutputFilename << "\n";
 }
 
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
 
+  cl::HideUnrelatedOptions(&Options);
   cl::ParseCommandLineOptions(Argc, Argv, "LLVM automatic testcase reducer.\n");
 
   if (PrintDeltaPasses) {
     printDeltaPasses(errs());
     return 0;
   }
 
   LLVMContext Context;

llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp

 #include "llvm/Support/raw_ostream.h"
 
 #include <future>
 #include <list>
 
 using namespace llvm;
 using namespace llvm::object;
 
-static cl::list<std::string>
-InputFileList(cl::Positional, cl::ZeroOrMore,
-              cl::desc("<input files>"));
+static cl::OptionCategory ToolOptions("Tool Options");
+
+static cl::list<std::string> InputFileList(cl::Positional, cl::ZeroOrMore,
+                                           cl::desc("<input files>"),
+                                           cl::cat(ToolOptions));
 
 enum ActionType {
   AC_Execute,
   AC_PrintObjectLineInfo,
   AC_PrintLineInfo,
   AC_PrintDebugLineInfo,
   AC_Verify
 };
 
-static cl::opt<ActionType>
-Action(cl::desc("Action to perform:"),
-       cl::init(AC_Execute),
-       cl::values(clEnumValN(AC_Execute, "execute",
-                             "Load, link, and execute the inputs."),
-                  clEnumValN(AC_PrintLineInfo, "printline",
-                             "Load, link, and print line information for each function."),
-                  clEnumValN(AC_PrintDebugLineInfo, "printdebugline",
-                             "Load, link, and print line information for each function using the debug object"),
-                  clEnumValN(AC_PrintObjectLineInfo, "printobjline",
-                             "Like -printlineinfo but does not load the object first"),
-                  clEnumValN(AC_Verify, "verify",
-                             "Load, link and verify the resulting memory image.")));
+static cl::opt<ActionType> Action(
+    cl::desc("Action to perform:"), cl::init(AC_Execute),
+    cl::values(
+        clEnumValN(AC_Execute, "execute",
+                   "Load, link, and print line information for each function "
+                   "using the debug object"),
+                   "Load, link and verify the resulting memory image.")),
+    cl::cat(ToolOptions));
 
 static cl::opt<std::string>
-EntryPoint("entry",
-           cl::desc("Function to call as entry point."),
-           cl::init("_main"));
+    EntryPoint("entry", cl::desc("Function to call as entry point."),
+               cl::init("_main"), cl::cat(ToolOptions));
 
-static cl::list<std::string>
-Dylibs("dylib",
-       cl::desc("Add library."),
-       cl::ZeroOrMore);
+static cl::list<std::string> Dylibs("dylib", cl::desc("Add library."),
+                                    cl::ZeroOrMore, cl::cat(ToolOptions));
 
 static cl::list<std::string> InputArgv("args", cl::Positional,
                                        cl::desc("<program arguments>..."),
-                                       cl::ZeroOrMore, cl::PositionalEatsArgs);
+                                       cl::ZeroOrMore, cl::PositionalEatsArgs,
+                                       cl::cat(ToolOptions));
 
 static cl::opt<std::string>
-TripleName("triple", cl::desc("Target triple for disassembler"));
+    TripleName("triple", cl::desc("Target triple for disassembler"),
+               cl::cat(ToolOptions));
 
 static cl::opt<std::string>
     MCPU("mcpu",
          cl::desc("Target a specific cpu type (-mcpu=help for details)"),
-     cl::value_desc("cpu-name"),
-     cl::init(""));
+         cl::value_desc("cpu-name"), cl::init(""), cl::cat(ToolOptions));
 
 static cl::list<std::string>
     CheckFiles("check",
                cl::desc("File containing RuntimeDyld verifier checks."),
-           cl::ZeroOrMore);
+               cl::ZeroOrMore, cl::cat(ToolOptions));
 
 static cl::opt<uint64_t>
     PreallocMemory("preallocate",
                    cl::desc("Allocate memory upfront rather than on-demand"),
-                   cl::init(0));
+                   cl::init(0), cl::cat(ToolOptions));
 
 static cl::opt<uint64_t> TargetAddrStart(
     "target-addr-start",
     cl::desc("For -verify only: start of phony target address "
              "range."),
     cl::init(4096), // Start at "page 1" - no allocating at "null".
-    cl::Hidden);
+    cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<uint64_t> TargetAddrEnd(
     "target-addr-end",
     cl::desc("For -verify only: end of phony target address range."),
-    cl::init(~0ULL), cl::Hidden);
+    cl::init(~0ULL), cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<uint64_t> TargetSectionSep(
     "target-section-sep",
     cl::desc("For -verify only: Separation between sections in "
              "phony target address space."),
-    cl::init(0), cl::Hidden);
+    cl::init(0), cl::Hidden, cl::cat(ToolOptions));
 
 static cl::list<std::string>
     SpecificSectionMappings("map-section",
                             cl::desc("For -verify only: Map a section to a "
                                      "specific address."),
-                        cl::ZeroOrMore,
-                        cl::Hidden);
+                            cl::ZeroOrMore, cl::Hidden, cl::cat(ToolOptions));
 
-static cl::list<std::string>
-DummySymbolMappings("dummy-extern",
-                    cl::desc("For -verify only: Inject a symbol into the extern "
-                             "symbol table."),
-                    cl::ZeroOrMore,
-                    cl::Hidden);
+static cl::list<std::string> DummySymbolMappings(
+    "dummy-extern",
+    cl::ZeroOrMore, cl::Hidden, cl::cat(ToolOptions));
 
-static cl::opt<bool>
-PrintAllocationRequests("print-alloc-requests",
-                        cl::desc("Print allocation requests made to the memory "
-                                 "manager by RuntimeDyld"),
-                        cl::Hidden);
+static cl::opt<bool> PrintAllocationRequests(
+    "print-alloc-requests",
+    cl::Hidden, cl::cat(ToolOptions));
 
 static cl::opt<bool> ShowTimes("show-times",
                                cl::desc("Show times for llvm-rtdyld phases"),
-                               cl::init(false));
+                               cl::init(false), cl::cat(ToolOptions));
 
 ExitOnError ExitOnErr;
 
 struct RTDyldTimers {
   TimerGroup RTDyldTG{"llvm-rtdyld timers", "timers for llvm-rtdyld phases"};
   Timer LoadObjectsTimer{"load", "time to load/add object files", RTDyldTG};
   Timer LinkTimer{"link", "time to link object files", RTDyldTG};
   Timer RunTimer{"run", "time to execute jitlink'd code", RTDyldTG};

 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   ProgramName = argv[0];
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm MC-JIT tool\n");
 
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 
   Timers = ShowTimes ? std::make_unique<RTDyldTimers>() : nullptr;
 
   int Result;
   switch (Action) {

llvm/tools/llvm-split/llvm-split.cpp

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Utils/SplitModule.h"
 
 using namespace llvm;
 
-static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
-    cl::init("-"), cl::value_desc("filename"));
-
-static cl::opt<std::string>
-OutputFilename("o", cl::desc("Override output filename"),
-               cl::value_desc("filename"));
+static cl::OptionCategory ToolOptions("Tool Options");
+
+static cl::opt<std::string> InputFilename(cl::Positional,
+                                          cl::desc("<input bitcode file>"),
+                                          cl::init("-"),
+                                          cl::value_desc("filename"),
+                                          cl::cat(ToolOptions));
+
+static cl::opt<std::string> OutputFilename("o",
+                                           cl::desc("Override output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::cat(ToolOptions));
 
 static cl::opt<unsigned> NumOutputs("j", cl::Prefix, cl::init(2),
-                                    cl::desc("Number of output files"));
+                                    cl::desc("Number of output files"),
+                                    cl::cat(ToolOptions));
 
 static cl::opt<bool>
     PreserveLocals("preserve-locals", cl::Prefix, cl::init(false),
-                   cl::desc("Split without externalizing locals"));
+                   cl::desc("Split without externalizing locals"),
+                   cl::cat(ToolOptions));
 
 int main(int argc, char **argv) {
   LLVMContext Context;
   SMDiagnostic Err;
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "LLVM module splitter\n");
 
   std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
 
   if (!M) {
     Err.print(argv[0], errs());
     return 1;
   }

llvm/tools/llvm-stress/llvm-stress.cpp

 #include <cstdint>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <vector>
 
 namespace llvm {
 
-static cl::opt<unsigned> SeedCL("seed",
-  cl::desc("Seed used for randomness"), cl::init(0));
+static cl::OptionCategory ToolOptions("Tool Options");
 
-static cl::opt<unsigned> SizeCL("size",
+static cl::opt<unsigned> SeedCL("seed", cl::desc("Seed used for randomness"),
+                                cl::init(0), cl::cat(ToolOptions));
+
+static cl::opt<unsigned> SizeCL(
+    "size",
     cl::desc("The estimated size of the generated function (# of instrs)"),
-  cl::init(100));
+    cl::init(100), cl::cat(ToolOptions));
 
-static cl::opt<std::string>
-OutputFilename("o", cl::desc("Override output filename"),
-               cl::value_desc("filename"));
+static cl::opt<std::string> OutputFilename("o",
+                                           cl::desc("Override output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::cat(ToolOptions));
 
 static LLVMContext Context;
 
 namespace cl {
 
 template <> class parser<Type*> final : public basic_parser<Type*> {
 public:
   parser(Option &O) : basic_parser(O) {}
bool parse(Option &O, StringRef, StringRef Arg, Type *&Value) {
     return false;
   }
 
   StringRef getValueName() const override { return "IR scalar type"; }
 };
 
 } // end namespace cl
 
-static cl::list<Type*> AdditionalScalarTypes("types", cl::CommaSeparated,
+static cl::list<Type *> AdditionalScalarTypes(
+    "types", cl::CommaSeparated,
     cl::desc("Additional IR scalar types "
-           "(always includes i1, i8, i16, i32, i64, float and double)"));
+             "(always includes i1, i8, i16, i32, i64, float and double)"),
+    cl::cat(ToolOptions));
 
 namespace {
 
 /// A utility class to provide a pseudo-random number generator which is
 /// the same across all platforms. This is somewhat close to the libc
 /// implementation. Note: This is not a cryptographically secure pseudorandom
 /// number generator.
 class Random {

 }
 
 } // end namespace llvm
 
 int main(int argc, char **argv) {
   using namespace llvm;
 
   InitLLVM X(argc, argv);
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm codegen stress-tester\n");
 
   auto M = std::make_unique<Module>("/tmp/autogen.bc", Context);
   Function *F = GenEmptyFunction(M.get());
 
   // Pick an initial seed value
   Random R(SeedCL);
   // Generate lots of random instructions inside a single basic block.

llvm/tools/llvm-strings/llvm-strings.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 #include <cctype>
 #include <string>
 
 using namespace llvm;
 using namespace llvm::object;
 
+static cl::OptionCategory ToolOptions("Tool Options");
+
 static cl::list<std::string> InputFileNames(cl::Positional,
                                             cl::desc("<input object files>"),
-                                            cl::ZeroOrMore);
+                                            cl::ZeroOrMore,
+                                            cl::cat(ToolOptions));
 
 static cl::opt<bool>
     PrintFileName("print-file-name",
-                  cl::desc("Print the name of the file before each string"));
+                  cl::desc("Print the name of the file before each string"),
+                  cl::cat(ToolOptions));
 static cl::alias PrintFileNameShort("f", cl::desc(""),
-                                    cl::aliasopt(PrintFileName));
+                                    cl::aliasopt(PrintFileName),
+                                    cl::cat(ToolOptions));
 
 static cl::opt<int>
     MinLength("bytes", cl::desc("Print sequences of the specified length"),
-              cl::init(4));
-static cl::alias MinLengthShort("n", cl::desc(""), cl::aliasopt(MinLength));
+              cl::init(4), cl::cat(ToolOptions));
+static cl::alias MinLengthShort("n", cl::desc(""), cl::aliasopt(MinLength),
+                                cl::cat(ToolOptions));
 
 static cl::opt<bool>
     AllSections("all",
-                  cl::desc("Check all sections, not just the data section"));
-static cl::alias AllSectionsShort("a", cl::desc(""),
-                                    cl::aliasopt(AllSections));
+                cl::desc("Check all sections, not just the data section"),
+                cl::cat(ToolOptions));
+static cl::alias AllSectionsShort("a", cl::desc(""), cl::aliasopt(AllSections),
+                                  cl::cat(ToolOptions));
 
 enum radix { none, octal, hexadecimal, decimal };
 static cl::opt<radix>
     Radix("radix", cl::desc("print the offset within the file"),
           cl::values(clEnumValN(octal, "o", "octal"),
                      clEnumValN(hexadecimal, "x", "hexadecimal"),
                      clEnumValN(decimal, "d", "decimal")),
-          cl::init(none));
-static cl::alias RadixShort("t", cl::desc(""), cl::aliasopt(Radix));
+          cl::init(none), cl::cat(ToolOptions));
+static cl::alias RadixShort("t", cl::desc(""), cl::aliasopt(Radix),
+                            cl::cat(ToolOptions));
 
 static cl::extrahelp
     HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 
 static void strings(raw_ostream &OS, StringRef FileName, StringRef Contents) {
   auto print = [&OS, FileName](unsigned Offset, StringRef L) {
     if (L.size() < static_cast<size_t>(MinLength))
       return;
static void strings(raw_ostream &OS, StringRef FileName, StringRef Contents) {
   }
   if (S)
     print(S - B, StringRef(S, E - S));
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm string dumper\n");
   if (MinLength == 0) {
     errs() << "invalid minimum string length 0\n";
     return EXIT_FAILURE;
   }
 
   if (InputFileNames.empty())
     InputFileNames.push_back("-");

llvm/tools/llvm-undname/llvm-undname.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <string>
 
 using namespace llvm;
 
+static cl::OptionCategory ToolOptions("Tool Options");
+
 cl::opt<bool> DumpBackReferences("backrefs", cl::Optional,
                                  cl::desc("dump backreferences"), cl::Hidden,
-                                 cl::init(false));
+                                 cl::init(false), cl::cat(ToolOptions));
 cl::opt<bool> NoAccessSpecifier("no-access-specifier", cl::Optional,
                                 cl::desc("skip access specifiers"), cl::Hidden,
-                                cl::init(false));
+                                cl::init(false), cl::cat(ToolOptions));
 cl::opt<bool> NoCallingConvention("no-calling-convention", cl::Optional,
                                   cl::desc("skip calling convention"),
-                                  cl::Hidden, cl::init(false));
+                                  cl::Hidden, cl::init(false),
+                                  cl::cat(ToolOptions));
 cl::opt<bool> NoReturnType("no-return-type", cl::Optional,
                            cl::desc("skip return types"), cl::Hidden,
-                           cl::init(false));
+                           cl::init(false), cl::cat(ToolOptions));
 cl::opt<bool> NoMemberType("no-member-type", cl::Optional,
                            cl::desc("skip member types"), cl::Hidden,
-                           cl::init(false));
+                           cl::init(false), cl::cat(ToolOptions));
 cl::opt<std::string> RawFile("raw-file", cl::Optional,
-                             cl::desc("for fuzzer data"), cl::Hidden);
+                             cl::desc("for fuzzer data"), cl::Hidden,
+                             cl::cat(ToolOptions));
 cl::opt<bool> WarnTrailing("warn-trailing", cl::Optional,
                            cl::desc("warn on trailing characters"), cl::Hidden,
-                           cl::init(false));
+                           cl::init(false), cl::cat(ToolOptions));
 cl::list<std::string> Symbols(cl::Positional, cl::desc("<input symbols>"),
-                              cl::ZeroOrMore);
+                              cl::ZeroOrMore, cl::cat(ToolOptions));
 
 static bool msDemangle(const std::string &S) {
   int Status;
   MSDemangleFlags Flags = MSDF_None;
   if (DumpBackReferences)
     Flags = MSDemangleFlags(Flags | MSDF_DumpBackrefs);
   if (NoAccessSpecifier)
     Flags = MSDemangleFlags(Flags | MSDF_NoAccessSpecifier);
static bool msDemangle(const std::string &S) {
   }
   std::free(ResultBuf);
   return Status == llvm::demangle_success;
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm-undname\n");
 
   if (!RawFile.empty()) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
         MemoryBuffer::getFileOrSTDIN(RawFile);
     if (std::error_code EC = FileOrErr.getError()) {
       WithColor::error() << "Could not open input file \'" << RawFile
                          << "\': " << EC.message() << '\n';

llvm/tools/llvm-xray/llvm-xray.cpp

 //
 #include "xray-registry.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::xray;
 
+static cl::OptionCategory ToolOptions("Tool Options");
+
 int main(int argc, char *argv[]) {
+  cl::HideUnrelatedOptions({});
   cl::ParseCommandLineOptions(argc, argv,
                               "XRay Tools\n\n"
                               "  This program consolidates multiple XRay trace "
                               "processing tools for convenient access.\n");
   for (auto *SC : cl::getRegisteredSubcommands()) {
     if (*SC) {
       // If no subcommand was provided, we need to explicitly check if this is
       // the top-level subcommand.