Index: llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
===================================================================
--- llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
+++ llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
@@ -36,33 +36,42 @@
 #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());
@@ -85,6 +94,7 @@
 
 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: ");
 
Index: llvm/tools/llvm-cxxdump/llvm-cxxdump.cpp
===================================================================
--- llvm/tools/llvm-cxxdump/llvm-cxxdump.cpp
+++ llvm/tools/llvm-cxxdump/llvm-cxxdump.cpp
@@ -33,9 +33,10 @@
 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 {
@@ -549,6 +550,7 @@
   // 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.
Index: llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp
===================================================================
--- llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp
+++ llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp
@@ -29,34 +29,37 @@
   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);
@@ -160,6 +163,7 @@
 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())
Index: llvm/tools/llvm-cxxmap/llvm-cxxmap.cpp
===================================================================
--- llvm/tools/llvm-cxxmap/llvm-cxxmap.cpp
+++ llvm/tools/llvm-cxxmap/llvm-cxxmap.cpp
@@ -25,23 +25,32 @@
 
 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 = "") {
@@ -131,6 +140,7 @@
 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);
Index: llvm/tools/llvm-diff/llvm-diff.cpp
===================================================================
--- llvm/tools/llvm-diff/llvm-diff.cpp
+++ llvm/tools/llvm-diff/llvm-diff.cpp
@@ -55,16 +55,19 @@
     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;
Index: llvm/tools/llvm-dis/llvm-dis.cpp
===================================================================
--- llvm/tools/llvm-dis/llvm-dis.cpp
+++ llvm/tools/llvm-dis/llvm-dis.cpp
@@ -35,37 +35,44 @@
 #include <system_error>
 using namespace llvm;
 
+static cl::OptionCategory ToolOptions("Tool Options");
+
 static cl::list<std::string> InputFilenames(cl::Positional, cl::ZeroOrMore,
-                                            cl::desc("[input bitcode]..."));
+                                            cl::desc("[input bitcode]..."),
+                                            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 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>
-DontPrint("disable-output", cl::desc("Don't output the .ll file"), cl::Hidden);
+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 {
 
@@ -154,6 +161,7 @@
   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) {
Index: llvm/tools/llvm-dwp/llvm-dwp.cpp
===================================================================
--- llvm/tools/llvm-dwp/llvm-dwp.cpp
+++ llvm/tools/llvm-dwp/llvm-dwp.cpp
@@ -942,6 +942,7 @@
 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();
Index: llvm/tools/llvm-elfabi/llvm-elfabi.cpp
===================================================================
--- llvm/tools/llvm-elfabi/llvm-elfabi.cpp
+++ llvm/tools/llvm-elfabi/llvm-elfabi.cpp
@@ -30,22 +30,24 @@
 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",
@@ -55,11 +57,14 @@
                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.
@@ -144,6 +149,7 @@
 
 int main(int argc, char *argv[]) {
   // Parse arguments.
+  cl::HideUnrelatedOptions({&ToolOptions});
   cl::ParseCommandLineOptions(argc, argv);
 
   Expected<std::unique_ptr<ELFStub>> StubOrErr = readInputFile(InputFilePath);
Index: llvm/tools/llvm-exegesis/lib/X86/Target.cpp
===================================================================
--- llvm/tools/llvm-exegesis/lib/X86/Target.cpp
+++ llvm/tools/llvm-exegesis/lib/X86/Target.cpp
@@ -35,8 +35,7 @@
 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.
@@ -49,7 +48,7 @@
 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.
 
Index: llvm/tools/llvm-exegesis/llvm-exegesis.cpp
===================================================================
--- llvm/tools/llvm-exegesis/llvm-exegesis.cpp
+++ llvm/tools/llvm-exegesis/llvm-exegesis.cpp
@@ -47,6 +47,7 @@
 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",
@@ -458,6 +459,9 @@
 
 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) {
Index: llvm/tools/llvm-ifs/llvm-ifs.cpp
===================================================================
--- llvm/tools/llvm-ifs/llvm-ifs.cpp
+++ llvm/tools/llvm-ifs/llvm-ifs.cpp
@@ -39,26 +39,29 @@
 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,
@@ -448,6 +451,7 @@
 
 int main(int argc, char *argv[]) {
   // Parse arguments.
+  cl::HideUnrelatedOptions({&ToolOptions});
   cl::ParseCommandLineOptions(argc, argv);
 
   if (InputFilenames.empty())
Index: llvm/tools/llvm-jitlink/llvm-jitlink.cpp
===================================================================
--- llvm/tools/llvm-jitlink/llvm-jitlink.cpp
+++ llvm/tools/llvm-jitlink/llvm-jitlink.cpp
@@ -60,104 +60,109 @@
 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;
 
@@ -1335,6 +1340,7 @@
   InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm jitlink tool");
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 
Index: llvm/tools/llvm-link/llvm-link.cpp
===================================================================
--- llvm/tools/llvm-link/llvm-link.cpp
+++ llvm/tools/llvm-link/llvm-link.cpp
@@ -41,20 +41,24 @@
 #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
@@ -63,53 +67,61 @@
 // 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;
 
@@ -434,6 +446,7 @@
   LLVMContext Context;
   Context.setDiagnosticHandler(std::make_unique<LLVMLinkDiagnosticHandler>(),
                                true);
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm linker\n");
 
   if (!DisableDITypeMap)
Index: llvm/tools/llvm-lto/llvm-lto.cpp
===================================================================
--- llvm/tools/llvm-lto/llvm-lto.cpp
+++ llvm/tools/llvm-lto/llvm-lto.cpp
@@ -64,31 +64,37 @@
 
 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] "
+                      "(default = '-O2')"),
+             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,
@@ -895,6 +901,7 @@
 
 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')
Index: llvm/tools/llvm-mc/llvm-mc.cpp
===================================================================
--- llvm/tools/llvm-mc/llvm-mc.cpp
+++ llvm/tools/llvm-mc/llvm-mc.cpp
@@ -43,26 +43,33 @@
 
 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,
@@ -72,29 +79,37 @@
                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"));
+    ShowInstOperands("show-inst-operands",
+                     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"));
+    OutputAsmVariant("output-asm-variant",
+                     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"));
+    PrintImmHex("print-imm-hex", cl::init(false),
+                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,
@@ -102,86 +117,101 @@
   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",
-                  "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")));
-
-static cl::list<std::string>
-IncludeDirs("I", cl::desc("Directory of include files"),
-            cl::value_desc("directory"), cl::Prefix);
+    FileType("filetype", cl::init(OFT_AssemblyFile),
+             cl::desc("Choose an output file type:"),
+             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")),
+             cl::cat(ToolOptions));
+
+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(""));
+    MCPU("mcpu",
+         cl::desc("Target a specific cpu type (-mcpu=help for details)"),
+         cl::value_desc("cpu-name"), cl::init(""), cl::cat(ToolOptions));
 
 static cl::list<std::string>
-MAttrs("mattr",
-  cl::CommaSeparated,
-  cl::desc("Target specific attributes (-mattr=help for details)"),
-  cl::value_desc("a1,+a2,-a3,..."));
+    MAttrs("mattr", cl::CommaSeparated,
+           cl::desc("Target specific attributes (-mattr=help for details)"),
+           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"));
+    DebugCompilationDir("fdebug-compilation-dir",
+                        cl::desc("Specifies the debug info's compilation dir"),
+                        cl::cat(ToolOptions));
 
-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"));
+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"));
+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,
@@ -190,17 +220,16 @@
   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"),
+               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")),
+    cl::cat(ToolOptions));
 
 static const Target *GetTarget(const char *ProgName) {
   // Figure out the target triple.
@@ -331,6 +360,7 @@
   // 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);
Index: llvm/tools/llvm-modextract/llvm-modextract.cpp
===================================================================
--- llvm/tools/llvm-modextract/llvm-modextract.cpp
+++ llvm/tools/llvm-modextract/llvm-modextract.cpp
@@ -21,21 +21,28 @@
 
 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: ");
Index: llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp
===================================================================
--- llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp
+++ llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp
@@ -1430,6 +1430,13 @@
   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) {
Index: llvm/tools/llvm-readobj/llvm-readobj.cpp
===================================================================
--- llvm/tools/llvm-readobj/llvm-readobj.cpp
+++ llvm/tools/llvm-readobj/llvm-readobj.cpp
@@ -48,343 +48,401 @@
 using namespace llvm::object;
 
 namespace opts {
-  cl::list<std::string> InputFilenames(cl::Positional,
-    cl::desc("<input object files>"),
-    cl::ZeroOrMore);
-
-  // --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));
-
-  // --dependent-libraries
-  cl::opt<bool>
-      DependentLibraries("dependent-libraries",
-                         cl::desc("Display the dependent libraries section"));
-
-  // --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);
-
-  // --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));
-
-  // --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));
-
-  // --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);
-
-  // --section-relocations
-  // Also --sr in llvm-readobj mode.
-  cl::opt<bool> SectionRelocations("section-relocations",
-    cl::desc("Display relocations for each section shown."));
-
-  // --section-symbols
-  // Also --st in llvm-readobj mode.
-  cl::opt<bool> SectionSymbols("section-symbols",
-    cl::desc("Display symbols for each section shown."));
-
-  // --section-data
-  // Also --sd in llvm-readobj mode.
-  cl::opt<bool> SectionData("section-data",
-    cl::desc("Display section data for each section shown."));
-
-  // --section-mapping
-  cl::opt<cl::boolOrDefault>
-      SectionMapping("section-mapping",
-                     cl::desc("Display the section to segment mapping."));
-
-  // --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));
-
-  // --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);
-
-  // --dyn-relocations
-  cl::opt<bool> DynRelocs("dyn-relocations",
-    cl::desc("Display the dynamic relocation entries in the file"));
-
-  // --section-details
-  // Also -t in llvm-readelf mode.
-  cl::opt<bool> SectionDetails("section-details",
-                               cl::desc("Display the section details"));
-
-  // --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));
-
-  // --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));
-
-  // --hash-symbols
-  cl::opt<bool> HashSymbols(
-      "hash-symbols",
-      cl::desc("Display the dynamic symbols derived from the hash section"));
-
-  // --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);
-
-  // --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));
-
-  // --needed-libs
-  cl::opt<bool> NeededLibraries("needed-libs",
-    cl::desc("Display the needed libraries"));
-
-  // --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));
-
-  // --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);
-
-  // --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);
-
-  // --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);
-
-  // --hash-table
-  cl::opt<bool> HashTable("hash-table",
-    cl::desc("Display ELF hash table"));
-
-  // --gnu-hash-table
-  cl::opt<bool> GnuHashTable("gnu-hash-table",
-    cl::desc("Display ELF .gnu.hash section"));
-
-  // --expand-relocs
-  cl::opt<bool> ExpandRelocs("expand-relocs",
-    cl::desc("Expand each shown relocation to multiple lines"));
-
-  // --raw-relr
-  cl::opt<bool> RawRelr("raw-relr",
-    cl::desc("Do not decode relocations in SHT_RELR section, display raw contents"));
-
-  // --codeview
-  cl::opt<bool> CodeView("codeview",
-                         cl::desc("Display CodeView debug information"));
-
-  // --codeview-merged-types
-  cl::opt<bool>
-      CodeViewMergedTypes("codeview-merged-types",
-                          cl::desc("Display the merged CodeView type stream"));
-
-  // --codeview-ghash
-  cl::opt<bool> CodeViewEnableGHash(
-      "codeview-ghash",
-      cl::desc(
-          "Enable global hashing for CodeView type stream de-duplication"));
-
-  // --codeview-subsection-bytes
-  cl::opt<bool> CodeViewSubsectionBytes(
-      "codeview-subsection-bytes",
-      cl::desc("Dump raw contents of codeview debug sections and records"));
-
-  // --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);
-
-  // --coff-imports
-  cl::opt<bool>
-  COFFImports("coff-imports", cl::desc("Display the PE/COFF import table"));
-
-  // --coff-exports
-  cl::opt<bool>
-  COFFExports("coff-exports", cl::desc("Display the PE/COFF export table"));
-
-  // --coff-directives
-  cl::opt<bool>
-  COFFDirectives("coff-directives",
-                 cl::desc("Display the PE/COFF .drectve section"));
-
-  // --coff-basereloc
-  cl::opt<bool>
-  COFFBaseRelocs("coff-basereloc",
-                 cl::desc("Display the PE/COFF .reloc section"));
-
-  // --coff-debug-directory
-  cl::opt<bool>
-  COFFDebugDirectory("coff-debug-directory",
-                     cl::desc("Display the PE/COFF debug directory"));
-
-  // --coff-tls-directory
-  cl::opt<bool> COFFTLSDirectory("coff-tls-directory",
-                                 cl::desc("Display the PE/COFF TLS directory"));
-
-  // --coff-resources
-  cl::opt<bool> COFFResources("coff-resources",
-                              cl::desc("Display the PE/COFF .rsrc section"));
-
-  // --coff-load-config
-  cl::opt<bool>
-  COFFLoadConfig("coff-load-config",
-                 cl::desc("Display the PE/COFF load config"));
-
-  // --elf-linker-options
-  cl::opt<bool>
-  ELFLinkerOptions("elf-linker-options",
-                   cl::desc("Display the ELF .linker-options section"));
-
-  // --macho-data-in-code
-  cl::opt<bool>
-  MachODataInCode("macho-data-in-code",
-                  cl::desc("Display MachO Data in Code command"));
-
-  // --macho-indirect-symbols
-  cl::opt<bool>
-  MachOIndirectSymbols("macho-indirect-symbols",
-                  cl::desc("Display MachO indirect symbols"));
-
-  // --macho-linker-options
-  cl::opt<bool>
-  MachOLinkerOptions("macho-linker-options",
-                  cl::desc("Display MachO linker options"));
-
-  // --macho-segment
-  cl::opt<bool>
-  MachOSegment("macho-segment",
-                  cl::desc("Display MachO Segment command"));
-
-  // --macho-version-min
-  cl::opt<bool>
-  MachOVersionMin("macho-version-min",
-                  cl::desc("Display MachO version min command"));
-
-  // --macho-dysymtab
-  cl::opt<bool>
-  MachODysymtab("macho-dysymtab",
-                  cl::desc("Display MachO Dysymtab command"));
-
-  // --stackmap
-  cl::opt<bool>
-  PrintStackMap("stackmap",
-                cl::desc("Display contents of stackmap section"));
-
-  // --stack-sizes
-  cl::opt<bool>
-      PrintStackSizes("stack-sizes",
-                      cl::desc("Display contents of all stack sizes sections"));
-
-  // --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);
-
-  // --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);
-
-  // --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));
-
-  // --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));
-
-  // --bb-addr-map
-  cl::opt<bool> BBAddrMap("bb-addr-map",
-                          cl::desc("Display the BB address map section"));
-
-  // -addrsig
-  cl::opt<bool> Addrsig("addrsig",
-                        cl::desc("Display address-significance table"));
-
-  // -elf-output-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::extrahelp
-      HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
+cl::OptionCategory ToolOptions("Tool Options");
+
+cl::list<std::string> InputFilenames(cl::Positional,
+                                     cl::desc("<input object files>"),
+                                     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::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::cat(ToolOptions));
+
+// --headers, -e
+cl::opt<bool> Headers(
+    "headers",
+    cl::desc("Equivalent to setting: --file-headers, --program-headers, "
+             "--section-headers"),
+    cl::cat(ToolOptions));
+cl::alias HeadersShort("e", cl::desc("Alias for --headers"),
+                       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::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::cat(ToolOptions));
+cl::alias FileHeadersShort("h", cl::desc("Alias for --file-headers"),
+                           cl::aliasopt(FileHeaders), cl::NotHidden,
+                           cl::cat(ToolOptions));
+cl::alias FileHeadersSingular("file-header",
+                              cl::desc("Alias for --file-headers"),
+                              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::cat(ToolOptions));
+cl::alias SectionHeadersAlias("sections",
+                              cl::desc("Alias for --section-headers"),
+                              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::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::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::cat(ToolOptions));
+
+// --section-mapping
+cl::opt<cl::boolOrDefault>
+    SectionMapping("section-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::cat(ToolOptions));
+cl::alias RelocationsShort("r", cl::desc("Alias for --relocations"),
+                           cl::aliasopt(Relocations), cl::NotHidden,
+                           cl::cat(ToolOptions));
+cl::alias RelocationsGNU("relocs", cl::desc("Alias for --relocations"),
+                         cl::aliasopt(Relocations), cl::cat(ToolOptions));
+
+// --notes, -n
+cl::opt<bool> Notes("notes", cl::desc("Display the ELF notes in the file"),
+                    cl::cat(ToolOptions));
+cl::alias NotesShort("n", cl::desc("Alias for --notes"), cl::aliasopt(Notes),
+                     cl::NotHidden, cl::cat(ToolOptions));
+
+// --dyn-relocations
+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::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::cat(ToolOptions));
+cl::alias SymbolsGNU("syms", cl::desc("Alias for --symbols"),
+                     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::cat(ToolOptions));
+cl::alias DynSymsGNU("dyn-syms", cl::desc("Alias for --dyn-symbols"),
+                     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::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::cat(ToolOptions));
+
+// --dynamic-table, --dynamic, -d
+cl::opt<bool> DynamicTable("dynamic-table",
+                           cl::desc("Display the ELF .dynamic section table"),
+                           cl::cat(ToolOptions));
+cl::alias DynamicTableShort("d", cl::desc("Alias for --dynamic-table"),
+                            cl::aliasopt(DynamicTable), cl::NotHidden,
+                            cl::cat(ToolOptions));
+cl::alias DynamicTableAlias("dynamic", cl::desc("Alias for --dynamic-table"),
+                            cl::aliasopt(DynamicTable), cl::cat(ToolOptions));
+
+// --needed-libs
+cl::opt<bool> NeededLibraries("needed-libs",
+                              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::cat(ToolOptions));
+cl::alias ProgramHeadersShort("l", cl::desc("Alias for --program-headers"),
+                              cl::aliasopt(ProgramHeaders), cl::NotHidden,
+                              cl::cat(ToolOptions));
+cl::alias SegmentsAlias("segments", cl::desc("Alias for --program-headers"),
+                        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::cat(ToolOptions));
+cl::alias StringDumpShort("p", cl::desc("Alias for --string-dump"),
+                          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::cat(ToolOptions));
+cl::alias HexDumpShort("x", cl::desc("Alias for --hex-dump"),
+                       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::cat(ToolOptions));
+
+// --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::cat(ToolOptions));
+
+// --expand-relocs
+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::cat(ToolOptions));
+
+// --codeview
+cl::opt<bool> CodeView("codeview",
+                       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::cat(ToolOptions));
+
+// --codeview-ghash
+cl::opt<bool> CodeViewEnableGHash(
+    "codeview-ghash",
+    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::cat(ToolOptions));
+
+// --arch-specific
+cl::opt<bool> ArchSpecificInfo(
+    "arch-specific",
+    cl::desc("Displays architecture-specific information, if there is any."),
+    cl::cat(ToolOptions));
+cl::alias ArchSpecifcInfoShort("A", cl::desc("Alias for --arch-specific"),
+                               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::cat(ToolOptions));
+
+// --coff-exports
+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::cat(ToolOptions));
+
+// --coff-basereloc
+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::cat(ToolOptions));
+
+// --coff-tls-directory
+cl::opt<bool> COFFTLSDirectory("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::cat(ToolOptions));
+
+// --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::cat(ToolOptions));
+
+// --macho-data-in-code
+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::cat(ToolOptions));
+
+// --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::cat(ToolOptions));
+
+// --macho-version-min
+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::cat(ToolOptions));
+
+// --stackmap
+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::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::cat(ToolOptions));
+
+// --elf-section-groups, --section-groups, -g
+cl::opt<bool> SectionGroups("elf-section-groups",
+                            cl::desc("Display ELF section group contents"),
+                            cl::cat(ToolOptions));
+cl::alias SectionGroupsAlias("section-groups",
+                             cl::desc("Alias for -elf-sections-groups"),
+                             cl::aliasopt(SectionGroups), cl::cat(ToolOptions));
+cl::alias SectionGroupsShort("g", cl::desc("Alias for -elf-sections-groups"),
+                             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::cat(ToolOptions));
+cl::alias HashHistogramShort("I", cl::desc("Alias for -elf-hash-histogram"),
+                             cl::aliasopt(HashHistogram), cl::NotHidden,
+                             cl::cat(ToolOptions));
+cl::alias HistogramAlias("histogram",
+                         cl::desc("Alias for --elf-hash-histogram"),
+                         cl::aliasopt(HashHistogram), cl::cat(ToolOptions));
+
+// --cg-profile
+cl::opt<bool> CGProfile("cg-profile",
+                        cl::desc("Display callgraph profile section"),
+                        cl::cat(ToolOptions));
+cl::alias ELFCGProfile("elf-cg-profile", cl::desc("Alias for --cg-profile"),
+                       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::cat(ToolOptions));
+
+// -addrsig
+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::values(clEnumVal(LLVM, "LLVM default style"),
+                                         clEnumVal(GNU, "GNU readelf style")),
+                              cl::init(LLVM), cl::cat(ToolOptions));
+
+cl::extrahelp
+    HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 } // namespace opts
 
 static StringRef ToolName;
@@ -754,6 +812,7 @@
     registerReadobjAliases();
   }
 
+  cl::HideUnrelatedOptions(&opts::ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "LLVM Object Reader\n");
 
   // Default to print error if no filename is specified.
Index: llvm/tools/llvm-reduce/llvm-reduce.cpp
===================================================================
--- llvm/tools/llvm-reduce/llvm-reduce.cpp
+++ llvm/tools/llvm-reduce/llvm-reduce.cpp
@@ -39,7 +39,8 @@
 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>"),
@@ -105,6 +106,7 @@
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
 
+  cl::HideUnrelatedOptions(&Options);
   cl::ParseCommandLineOptions(Argc, Argv, "LLVM automatic testcase reducer.\n");
 
   if (PrintDeltaPasses) {
Index: llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp
===================================================================
--- llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp
+++ llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp
@@ -44,9 +44,11 @@
 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,
@@ -56,94 +58,92 @@
   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 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.")),
+    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(""));
+    MCPU("mcpu",
+         cl::desc("Target a specific cpu type (-mcpu=help for details)"),
+         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);
+    CheckFiles("check",
+               cl::desc("File containing RuntimeDyld verifier checks."),
+               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);
-
-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::init(0), 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::opt<bool>
-PrintAllocationRequests("print-alloc-requests",
-                        cl::desc("Print allocation requests made to the memory "
-                                 "manager by RuntimeDyld"),
-                        cl::Hidden);
+    SpecificSectionMappings("map-section",
+                            cl::desc("For -verify only: Map a section to a "
+                                     "specific address."),
+                            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, 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, 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;
 
@@ -966,6 +966,7 @@
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm MC-JIT tool\n");
 
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
Index: llvm/tools/llvm-split/llvm-split.cpp
===================================================================
--- llvm/tools/llvm-split/llvm-split.cpp
+++ llvm/tools/llvm-split/llvm-split.cpp
@@ -24,24 +24,32 @@
 
 using namespace llvm;
 
-static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
-    cl::init("-"), cl::value_desc("filename"));
+static cl::OptionCategory ToolOptions("Tool Options");
 
-static cl::opt<std::string>
-OutputFilename("o", cl::desc("Override output filename"),
-               cl::value_desc("filename"));
+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);
Index: llvm/tools/llvm-stress/llvm-stress.cpp
===================================================================
--- llvm/tools/llvm-stress/llvm-stress.cpp
+++ llvm/tools/llvm-stress/llvm-stress.cpp
@@ -52,16 +52,20 @@
 
 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",
-  cl::desc("The estimated size of the generated function (# of instrs)"),
-  cl::init(100));
+static cl::opt<unsigned> SeedCL("seed", cl::desc("Seed used for randomness"),
+                                cl::init(0), cl::cat(ToolOptions));
 
-static cl::opt<std::string>
-OutputFilename("o", cl::desc("Override output filename"),
-               cl::value_desc("filename"));
+static cl::opt<unsigned> SizeCL(
+    "size",
+    cl::desc("The estimated size of the generated function (# of instrs)"),
+    cl::init(100), cl::cat(ToolOptions));
+
+static cl::opt<std::string> OutputFilename("o",
+                                           cl::desc("Override output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::cat(ToolOptions));
 
 static LLVMContext Context;
 
@@ -95,9 +99,11 @@
 
 } // end namespace cl
 
-static cl::list<Type*> AdditionalScalarTypes("types", cl::CommaSeparated,
-  cl::desc("Additional IR scalar types "
-           "(always includes i1, i8, i16, i32, i64, float and double)"));
+static cl::list<Type *> AdditionalScalarTypes(
+    "types", cl::CommaSeparated,
+    cl::desc("Additional IR scalar types "
+             "(always includes i1, i8, i16, i32, i64, float and double)"),
+    cl::cat(ToolOptions));
 
 namespace {
 
@@ -738,6 +744,7 @@
   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);
Index: llvm/tools/llvm-strings/llvm-strings.cpp
===================================================================
--- llvm/tools/llvm-strings/llvm-strings.cpp
+++ llvm/tools/llvm-strings/llvm-strings.cpp
@@ -24,26 +24,33 @@
 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>
@@ -51,8 +58,9 @@
           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");
@@ -97,6 +105,7 @@
 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";
Index: llvm/tools/llvm-undname/llvm-undname.cpp
===================================================================
--- llvm/tools/llvm-undname/llvm-undname.cpp
+++ llvm/tools/llvm-undname/llvm-undname.cpp
@@ -28,28 +28,32 @@
 
 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;
@@ -84,6 +88,7 @@
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions(&ToolOptions);
   cl::ParseCommandLineOptions(argc, argv, "llvm-undname\n");
 
   if (!RawFile.empty()) {
Index: llvm/tools/llvm-xray/llvm-xray.cpp
===================================================================
--- llvm/tools/llvm-xray/llvm-xray.cpp
+++ llvm/tools/llvm-xray/llvm-xray.cpp
@@ -22,7 +22,10 @@
 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 "