Index: llvm/test/tools/llvm-strings/help.test
===================================================================
--- llvm/test/tools/llvm-strings/help.test
+++ llvm/test/tools/llvm-strings/help.test
@@ -8,8 +8,9 @@
 CHECK: OVERVIEW: llvm string dumper
 CHECK: USAGE: llvm-strings{{(.exe)?}} [options] <input object files>{{$}}
 CHECK: OPTIONS:
-CATEG:    General options:
-LIST-NOT: General options:
+CATEG:    Color Options:
 CATEG:    Generic Options:
-LIST-NOT: Generic Options:
+LIST-NOT: General options:
+CATEG:    Strings Options:
+LIST-NOT: Strings Options:
 CHECK: @FILE
Index: llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
===================================================================
--- llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
+++ llvm/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
@@ -32,37 +32,48 @@
 #include "llvm/Support/Error.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 using namespace llvm;
 
-static cl::opt<std::string>
-    InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
+static cl::OptionCategory BCAnalyzerOptions("BC Analyzer Options");
+
+static cl::opt<std::string> InputFilename(cl::Positional,
+                                          cl::desc("<input bitcode>"),
+                                          cl::init("-"),
+                                          cl::cat(BCAnalyzerOptions));
 
-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(BCAnalyzerOptions));
 
 //===----------------------------------------------------------------------===//
 // 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(BCAnalyzerOptions));
 
 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(BCAnalyzerOptions));
 
 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(BCAnalyzerOptions));
 
 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(BCAnalyzerOptions));
 
 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(BCAnalyzerOptions));
 
 static Error reportError(StringRef Message) {
   return createStringError(std::errc::illegal_byte_sequence, Message.data());
@@ -85,6 +96,7 @@
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
+  cl::HideUnrelatedOptions({&BCAnalyzerOptions, &llvm::ColorCategory});
   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 CXXDumpOptions("CXX Dump Options");
 cl::list<std::string> InputFilenames(cl::Positional,
                                      cl::desc("<input object files>"),
-                                     cl::ZeroOrMore);
+                                     cl::cat(CXXDumpOptions), cl::ZeroOrMore);
 } // namespace opts
 
 namespace llvm {
@@ -549,6 +550,7 @@
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
+  cl::HideUnrelatedOptions({&opts::CXXDumpOptions, &llvm::ColorCategory});
   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
@@ -12,6 +12,7 @@
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <iostream>
@@ -29,37 +30,40 @@
   Java,  ///< Java (gcj)
   GNAT   ///< ADA compiler (gnat)
 };
+static cl::OptionCategory CXXFiltOptions("CXX Filt 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(CXXFiltOptions));
 static cl::alias FormatShort("s", cl::desc("alias for --format"),
-                             cl::aliasopt(Format));
+                             cl::aliasopt(Format), cl::cat(CXXFiltOptions));
 
 static cl::opt<bool> StripUnderscore("strip-underscore",
                                      cl::desc("strip the leading underscore"),
-                                     cl::init(false));
+                                     cl::init(false), cl::cat(CXXFiltOptions));
 static cl::alias StripUnderscoreShort("_",
                                       cl::desc("alias for --strip-underscore"),
-                                      cl::aliasopt(StripUnderscore));
+                                      cl::aliasopt(StripUnderscore),
+                                      cl::cat(CXXFiltOptions));
 static cl::opt<bool>
     NoStripUnderscore("no-strip-underscore",
                       cl::desc("do not strip the leading underscore"),
-                      cl::init(false));
+                      cl::init(false), cl::cat(CXXFiltOptions));
 static cl::alias
     NoStripUnderscoreShort("n", cl::desc("alias for --no-strip-underscore"),
-                           cl::aliasopt(NoStripUnderscore));
+                           cl::aliasopt(NoStripUnderscore),
+                           cl::cat(CXXFiltOptions));
 
 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(CXXFiltOptions));
 static cl::alias TypesShort("t", cl::desc("alias for --types"),
-                            cl::aliasopt(Types));
+                            cl::aliasopt(Types), cl::cat(CXXFiltOptions));
 
-static cl::list<std::string>
-Decorated(cl::Positional, cl::desc("<mangled>"), cl::ZeroOrMore);
+static cl::list<std::string> Decorated(cl::Positional, cl::desc("<mangled>"),
+                                       cl::ZeroOrMore, cl::cat(CXXFiltOptions));
 
 static cl::extrahelp
     HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
@@ -160,6 +164,7 @@
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions({&CXXFiltOptions, &llvm::ColorCategory});
   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 CXXMapOptions("CXX Map Options");
 cl::opt<std::string> OldSymbolFile(cl::Positional, cl::Required,
-                                   cl::desc("<symbol-file>"));
+                                   cl::desc("<symbol-file>"),
+                                   cl::cat(CXXMapOptions));
 cl::opt<std::string> NewSymbolFile(cl::Positional, cl::Required,
-                                   cl::desc("<symbol-file>"));
+                                   cl::desc("<symbol-file>"),
+                                   cl::cat(CXXMapOptions));
 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(CXXMapOptions));
+cl::alias RemappingFileA("r", cl::aliasopt(RemappingFile),
+                         cl::cat(CXXMapOptions));
 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(CXXMapOptions));
+cl::alias OutputFilenameA("o", cl::aliasopt(OutputFilename),
+                          cl::cat(CXXMapOptions));
 
 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(CXXMapOptions));
 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(CXXMapOptions));
 
 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({&CXXMapOptions, &llvm::ColorCategory});
   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 DiffOptions("Diff Options");
 static cl::opt<std::string> LeftFilename(cl::Positional,
-                                         cl::desc("<first file>"),
-                                         cl::Required);
+                                         cl::desc("<first file>"), cl::Required,
+                                         cl::cat(DiffOptions));
 static cl::opt<std::string> RightFilename(cl::Positional,
                                           cl::desc("<second file>"),
-                                          cl::Required);
+                                          cl::Required, cl::cat(DiffOptions));
 static cl::list<std::string> GlobalsToCompare(cl::Positional,
-                                              cl::desc("<globals to compare>"));
+                                              cl::desc("<globals to compare>"),
+                                              cl::cat(DiffOptions));
 
 int main(int argc, char **argv) {
+  cl::HideUnrelatedOptions({&DiffOptions, &llvm::ColorCategory});
   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 DisOptions("Dis Options");
+
 static cl::list<std::string> InputFilenames(cl::Positional, cl::ZeroOrMore,
-                                            cl::desc("[input bitcode]..."));
+                                            cl::desc("[input bitcode]..."),
+                                            cl::cat(DisOptions));
 
-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(DisOptions));
 
-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(DisOptions));
 
-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(DisOptions));
 
 static cl::opt<bool>
     SetImporting("set-importing",
                  cl::desc("Set lazy loading to pretend to import a module"),
-                 cl::Hidden);
+                 cl::Hidden, cl::cat(DisOptions));
 
 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(DisOptions));
 
 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(DisOptions));
 
 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(DisOptions));
 
 namespace {
 
@@ -154,6 +161,7 @@
   LLVMContext Context;
   Context.setDiagnosticHandler(
       std::make_unique<LLVMDisDiagnosticHandler>(argv[0]));
+  cl::HideUnrelatedOptions({&DisOptions, &llvm::ColorCategory});
   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 ElfAbiOptions("ElfAbi 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(ElfAbiOptions));
 cl::opt<std::string> InputFilePath(cl::Positional, cl::desc("input"),
-                                   cl::Required);
+                                   cl::Required, cl::cat(ElfAbiOptions));
 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(ElfAbiOptions));
 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(ElfAbiOptions));
 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(ElfAbiOptions));
+cl::opt<std::string> BinaryOutputFilePath(cl::Positional, cl::desc("output"),
+                                          cl::cat(ElfAbiOptions));
 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(ElfAbiOptions));
 
 /// 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({&ElfAbiOptions, &llvm::ColorCategory});
   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,10 @@
 
 int main(int Argc, char **Argv) {
   using namespace llvm;
+  cl::HideUnrelatedOptions({&exegesis::Options, &exegesis::BenchmarkOptions,
+                            &exegesis::AnalysisOptions,
+                            &exegesis::X86BenchmarkOptions,
+                            &llvm::ColorCategory});
   cl::ParseCommandLineOptions(Argc, Argv, "");
 
   exegesis::ExitOnErr.setExitCodeMapper([](const Error &Err) {
Index: llvm/tools/llvm-extract/llvm-extract.cpp
===================================================================
--- llvm/tools/llvm-extract/llvm-extract.cpp
+++ llvm/tools/llvm-extract/llvm-extract.cpp
@@ -140,7 +140,7 @@
   InitLLVM X(argc, argv);
 
   LLVMContext Context;
-  cl::HideUnrelatedOptions(ExtractCat);
+  cl::HideUnrelatedOptions({&ExtractCat, &llvm::ColorCategory});
   cl::ParseCommandLineOptions(argc, argv, "llvm extractor\n");
 
   // Use lazy loading, since we only care about selected global values.
Index: llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp
===================================================================
--- llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp
+++ llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp
@@ -468,7 +468,8 @@
       "lookup addresses within that GSYM file.\n"
       "Use the --convert option to specify a file with option --out-file "
       "option to convert to GSYM format.\n";
-  HideUnrelatedOptions({&GeneralOptions, &ConversionOptions, &LookupOptions});
+  HideUnrelatedOptions({&GeneralOptions, &ConversionOptions, &LookupOptions,
+                        &llvm::ColorCategory});
   cl::ParseCommandLineOptions(argc, argv, Overview);
 
   if (Help) {
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 IfsOptions("Ifs 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(IfsOptions));
 
 static cl::opt<std::string> ForceFormat("force-format",
                                         cl::desc("<force object format>"),
                                         cl::value_desc("ELF | TBD"),
-                                        cl::init(""));
+                                        cl::init(""), cl::cat(IfsOptions));
 
 static cl::list<std::string> InputFilenames(cl::Positional,
                                             cl::desc("<input ifs files>"),
-                                            cl::ZeroOrMore);
+                                            cl::ZeroOrMore,
+                                            cl::cat(IfsOptions));
 
 static cl::opt<std::string> OutputFilename("o", cl::desc("<output file>"),
-                                           cl::value_desc("path"));
+                                           cl::value_desc("path"),
+                                           cl::cat(IfsOptions));
 
 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(IfsOptions));
 
 enum class IFSSymbolType {
   NoType = 0,
@@ -448,6 +451,7 @@
 
 int main(int argc, char *argv[]) {
   // Parse arguments.
+  cl::HideUnrelatedOptions({&IfsOptions, &llvm::ColorCategory});
   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,111 @@
 using namespace llvm::jitlink;
 using namespace llvm::orc;
 
+static cl::OptionCategory JitLinkOptions("JitLink Options");
 static cl::list<std::string> InputFiles(cl::Positional, cl::OneOrMore,
-                                        cl::desc("input files"));
+                                        cl::desc("input files"),
+                                        cl::cat(JitLinkOptions));
 
 static cl::opt<bool> NoExec("noexec", cl::desc("Do not execute loaded code"),
-                            cl::init(false));
+                            cl::init(false), cl::cat(JitLinkOptions));
 
 static cl::list<std::string>
     CheckFiles("check", cl::desc("File containing verifier checks"),
-               cl::ZeroOrMore);
+               cl::ZeroOrMore, cl::cat(JitLinkOptions));
 
 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(JitLinkOptions));
 
 static cl::opt<std::string>
     EntryPointName("entry", cl::desc("Symbol to call as main entry point"),
-                   cl::init(""));
+                   cl::init(""), cl::cat(JitLinkOptions));
 
 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(JitLinkOptions));
 
 static cl::list<std::string>
     Dylibs("dlopen", cl::desc("Dynamic libraries to load before linking"),
-           cl::ZeroOrMore);
+           cl::ZeroOrMore, cl::cat(JitLinkOptions));
 
 static cl::list<std::string> InputArgv("args", cl::Positional,
                                        cl::desc("<program arguments>..."),
-                                       cl::ZeroOrMore, cl::PositionalEatsArgs);
+                                       cl::ZeroOrMore, cl::PositionalEatsArgs,
+                                       cl::cat(JitLinkOptions));
 
 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(JitLinkOptions));
 
 static cl::list<std::string> AbsoluteDefs(
     "define-abs",
     cl::desc("Inject absolute symbol definitions (syntax: <name>=<addr>)"),
-    cl::ZeroOrMore);
+    cl::ZeroOrMore, cl::cat(JitLinkOptions));
 
 static cl::list<std::string> TestHarnesses("harness", cl::Positional,
                                            cl::desc("Test harness files"),
                                            cl::ZeroOrMore,
-                                           cl::PositionalEatsArgs);
+                                           cl::PositionalEatsArgs,
+                                           cl::cat(JitLinkOptions));
 
 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(JitLinkOptions));
 
 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(JitLinkOptions));
 
 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(JitLinkOptions));
 
 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(JitLinkOptions));
 
 static cl::opt<bool> ShowTimes("show-times",
                                cl::desc("Show times for llvm-jitlink phases"),
-                               cl::init(false));
+                               cl::init(false), cl::cat(JitLinkOptions));
 
 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(JitLinkOptions));
 
 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(JitLinkOptions));
 
 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(JitLinkOptions));
 
 static cl::opt<bool> PhonyExternals(
     "phony-externals",
     cl::desc("resolve all otherwise unresolved externals to null"),
-    cl::init(false));
+    cl::init(false), cl::cat(JitLinkOptions));
 
 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(JitLinkOptions));
 
 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(JitLinkOptions));
 
 ExitOnError ExitOnErr;
 
@@ -1335,6 +1342,7 @@
   InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 
+  cl::HideUnrelatedOptions({&JitLinkOptions, &llvm::ColorCategory});
   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 LinkOptions("Link Options");
 static cl::list<std::string> InputFilenames(cl::Positional, cl::OneOrMore,
-                                            cl::desc("<input bitcode files>"));
+                                            cl::desc("<input bitcode files>"),
+                                            cl::cat(LinkOptions));
 
 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(LinkOptions));
 
 // 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(LinkOptions));
 
 // 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(LinkOptions));
 
-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(LinkOptions));
 
 static cl::opt<bool> Internalize("internalize",
-                                 cl::desc("Internalize linked symbols"));
+                                 cl::desc("Internalize linked symbols"),
+                                 cl::cat(LinkOptions));
 
 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(LinkOptions));
 
 static cl::opt<bool> OnlyNeeded("only-needed",
-                                cl::desc("Link only needed symbols"));
+                                cl::desc("Link only needed symbols"),
+                                cl::cat(LinkOptions));
 
-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(LinkOptions));
 
 static cl::opt<bool> DisableLazyLoad("disable-lazy-loading",
-                                     cl::desc("Disable lazy module loading"));
+                                     cl::desc("Disable lazy module loading"),
+                                     cl::cat(LinkOptions));
 
-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(LinkOptions));
 
 static cl::opt<bool> Verbose("v",
-                             cl::desc("Print information about actions taken"));
+                             cl::desc("Print information about actions taken"),
+                             cl::cat(LinkOptions));
 
 static cl::opt<bool> DumpAsm("d", cl::desc("Print assembly as linked"),
-                             cl::Hidden);
+                             cl::Hidden, cl::cat(LinkOptions));
 
 static cl::opt<bool> SuppressWarnings("suppress-warnings",
                                       cl::desc("Suppress all linking warnings"),
-                                      cl::init(false));
+                                      cl::init(false), cl::cat(LinkOptions));
 
 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(LinkOptions));
 
 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(LinkOptions));
 
 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(LinkOptions));
 
 static ExitOnError ExitOnErr;
 
@@ -434,6 +446,7 @@
   LLVMContext Context;
   Context.setDiagnosticHandler(std::make_unique<LLVMLinkDiagnosticHandler>(),
                                true);
+  cl::HideUnrelatedOptions({&LinkOptions, &llvm::ColorCategory});
   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 LtoOptions("LTO 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(LtoOptions));
 
 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(LtoOptions));
 
 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(LtoOptions));
 
 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(LtoOptions));
 
 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(LtoOptions));
 
 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(LtoOptions));
 
 enum ThinLTOModes {
   THINLINK,
@@ -104,6 +110,7 @@
 
 cl::opt<ThinLTOModes> ThinLTOMode(
     "thinlto-action", cl::desc("Perform a single ThinLTO stage:"),
+    cl::cat(LtoOptions),
     cl::values(
         clEnumValN(
             THINLINK, "thinlink",
@@ -114,9 +121,10 @@
                    "Emit imports files for distributed backends."),
         clEnumValN(THINPROMOTE, "promote",
                    "Perform pre-import promotion (requires -thinlto-index)."),
-        clEnumValN(THINIMPORT, "import", "Perform both promotion and "
-                                         "cross-module importing (requires "
-                                         "-thinlto-index)."),
+        clEnumValN(THINIMPORT, "import",
+                   "Perform both promotion and "
+                   "cross-module importing (requires "
+                   "-thinlto-index)."),
         clEnumValN(THININTERNALIZE, "internalize",
                    "Perform internalization driven by -exported-symbol "
                    "(requires -thinlto-index)."),
@@ -127,109 +135,129 @@
 static cl::opt<std::string>
     ThinLTOIndex("thinlto-index",
                  cl::desc("Provide the index produced by a ThinLink, required "
-                          "to perform the promotion and/or importing."));
+                          "to perform the promotion and/or importing."),
+                 cl::cat(LtoOptions));
 
 static cl::opt<std::string> ThinLTOPrefixReplace(
     "thinlto-prefix-replace",
     cl::desc("Control where files for distributed backends are "
              "created. Expects 'oldprefix;newprefix' and if path "
              "prefix of output file is oldprefix it will be "
-             "replaced with newprefix."));
+             "replaced with newprefix."),
+    cl::cat(LtoOptions));
 
 static cl::opt<std::string> ThinLTOModuleId(
     "thinlto-module-id",
     cl::desc("For the module ID for the file to process, useful to "
-             "match what is in the index."));
+             "match what is in the index."),
+    cl::cat(LtoOptions));
 
-static cl::opt<std::string>
-    ThinLTOCacheDir("thinlto-cache-dir", cl::desc("Enable ThinLTO caching."));
+static cl::opt<std::string> ThinLTOCacheDir("thinlto-cache-dir",
+                                            cl::desc("Enable ThinLTO caching."),
+                                            cl::cat(LtoOptions));
 
-static cl::opt<int>
-    ThinLTOCachePruningInterval("thinlto-cache-pruning-interval",
-    cl::init(1200), cl::desc("Set ThinLTO cache pruning interval."));
+static cl::opt<int> ThinLTOCachePruningInterval(
+    "thinlto-cache-pruning-interval", cl::init(1200),
+    cl::desc("Set ThinLTO cache pruning interval."), cl::cat(LtoOptions));
 
 static cl::opt<uint64_t> ThinLTOCacheMaxSizeBytes(
     "thinlto-cache-max-size-bytes",
-    cl::desc("Set ThinLTO cache pruning directory maximum size in bytes."));
+    cl::desc("Set ThinLTO cache pruning directory maximum size in bytes."),
+    cl::cat(LtoOptions));
 
-static cl::opt<int>
-    ThinLTOCacheMaxSizeFiles("thinlto-cache-max-size-files", cl::init(1000000),
-    cl::desc("Set ThinLTO cache pruning directory maximum number of files."));
+static cl::opt<int> ThinLTOCacheMaxSizeFiles(
+    "thinlto-cache-max-size-files", cl::init(1000000),
+    cl::desc("Set ThinLTO cache pruning directory maximum number of files."),
+    cl::cat(LtoOptions));
 
-static cl::opt<unsigned>
-    ThinLTOCacheEntryExpiration("thinlto-cache-entry-expiration", cl::init(604800) /* 1w */,
-    cl::desc("Set ThinLTO cache entry expiration time."));
+static cl::opt<unsigned> ThinLTOCacheEntryExpiration(
+    "thinlto-cache-entry-expiration", cl::init(604800) /* 1w */,
+    cl::desc("Set ThinLTO cache entry expiration time."), cl::cat(LtoOptions));
 
 static cl::opt<std::string> ThinLTOSaveTempsPrefix(
     "thinlto-save-temps",
     cl::desc("Save ThinLTO temp files using filenames created by adding "
-             "suffixes to the given file path prefix."));
+             "suffixes to the given file path prefix."),
+    cl::cat(LtoOptions));
 
 static cl::opt<std::string> ThinLTOGeneratedObjectsDir(
     "thinlto-save-objects",
     cl::desc("Save ThinLTO generated object files using filenames created in "
-             "the given directory."));
+             "the given directory."),
+    cl::cat(LtoOptions));
 
 static cl::opt<bool> SaveLinkedModuleFile(
     "save-linked-module", cl::init(false),
-    cl::desc("Write linked LTO module to file before optimize"));
+    cl::desc("Write linked LTO module to file before optimize"),
+    cl::cat(LtoOptions));
 
 static cl::opt<bool>
     SaveModuleFile("save-merged-module", cl::init(false),
-                   cl::desc("Write merged LTO module to file before CodeGen"));
+                   cl::desc("Write merged LTO module to file before CodeGen"),
+                   cl::cat(LtoOptions));
 
 static cl::list<std::string> InputFilenames(cl::Positional, cl::OneOrMore,
-                                            cl::desc("<input bitcode files>"));
+                                            cl::desc("<input bitcode files>"),
+                                            cl::cat(LtoOptions));
 
 static cl::opt<std::string> OutputFilename("o", cl::init(""),
                                            cl::desc("Override output filename"),
-                                           cl::value_desc("filename"));
+                                           cl::value_desc("filename"),
+                                           cl::cat(LtoOptions));
 
 static cl::list<std::string> ExportedSymbols(
     "exported-symbol",
     cl::desc("List of symbols to export from the resulting object file"),
-    cl::ZeroOrMore);
+    cl::ZeroOrMore, cl::cat(LtoOptions));
 
 static cl::list<std::string>
     DSOSymbols("dso-symbol",
                cl::desc("Symbol to put in the symtab in the resulting dso"),
-               cl::ZeroOrMore);
+               cl::ZeroOrMore, cl::cat(LtoOptions));
 
 static cl::opt<bool> ListSymbolsOnly(
     "list-symbols-only", cl::init(false),
-    cl::desc("Instead of running LTO, list the symbols in each IR file"));
+    cl::desc("Instead of running LTO, list the symbols in each IR file"),
+    cl::cat(LtoOptions));
 
 static cl::opt<bool> ListDependentLibrariesOnly(
     "list-dependent-libraries-only", cl::init(false),
-    cl::desc("Instead of running LTO, list the dependent libraries in each IR file"));
+    cl::desc(
+        "Instead of running LTO, list the dependent libraries in each IR file"),
+    cl::cat(LtoOptions));
 
-static cl::opt<bool> SetMergedModule(
-    "set-merged-module", cl::init(false),
-    cl::desc("Use the first input module as the merged module"));
+static cl::opt<bool>
+    SetMergedModule("set-merged-module", cl::init(false),
+                    cl::desc("Use the first input module as the merged module"),
+                    cl::cat(LtoOptions));
 
 static cl::opt<unsigned> Parallelism("j", cl::Prefix, cl::init(1),
-                                     cl::desc("Number of backend threads"));
+                                     cl::desc("Number of backend threads"),
+                                     cl::cat(LtoOptions));
 
 static cl::opt<bool> RestoreGlobalsLinkage(
     "restore-linkage", cl::init(false),
-    cl::desc("Restore original linkage of globals prior to CodeGen"));
+    cl::desc("Restore original linkage of globals prior to CodeGen"),
+    cl::cat(LtoOptions));
 
 static cl::opt<bool> CheckHasObjC(
     "check-for-objc", cl::init(false),
-    cl::desc("Only check if the module has objective-C defined in it"));
+    cl::desc("Only check if the module has objective-C defined in it"),
+    cl::cat(LtoOptions));
 
 static cl::opt<bool> PrintMachOCPUOnly(
     "print-macho-cpu-only", cl::init(false),
-    cl::desc("Instead of running LTO, print the mach-o cpu in each IR file"));
+    cl::desc("Instead of running LTO, print the mach-o cpu in each IR file"),
+    cl::cat(LtoOptions));
 
-static cl::opt<bool>
-    UseNewPM("use-new-pm",
-             cl::desc("Run LTO passes using the new pass manager"),
-             cl::init(LLVM_ENABLE_NEW_PASS_MANAGER), cl::Hidden);
+static cl::opt<bool> UseNewPM(
+    "use-new-pm", cl::desc("Run LTO passes using the new pass manager"),
+    cl::init(LLVM_ENABLE_NEW_PASS_MANAGER), cl::Hidden, cl::cat(LtoOptions));
 
 static cl::opt<bool>
     DebugPassManager("debug-pass-manager", cl::init(false), cl::Hidden,
-                     cl::desc("Print pass management debugging information"));
+                     cl::desc("Print pass management debugging information"),
+                     cl::cat(LtoOptions));
 
 namespace {
 
@@ -895,6 +923,7 @@
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
+  cl::HideUnrelatedOptions({&LtoOptions, &llvm::ColorCategory});
   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 MCOptions("MC Options");
+
+static cl::opt<std::string> InputFilename(cl::Positional,
+                                          cl::desc("<input file>"),
+                                          cl::init("-"), cl::cat(MCOptions));
 
 static cl::list<std::string>
-    DisassemblerOptions("M", cl::desc("Disassembler options"));
+    DisassemblerOptions("M", cl::desc("Disassembler options"),
+                        cl::cat(MCOptions));
 
 static cl::opt<std::string> OutputFilename("o", cl::desc("Output filename"),
                                            cl::value_desc("filename"),
-                                           cl::init("-"));
+                                           cl::init("-"), cl::cat(MCOptions));
 
 static cl::opt<std::string> SplitDwarfFile("split-dwarf-file",
                                            cl::desc("DWO output filename"),
-                                           cl::value_desc("filename"));
+                                           cl::value_desc("filename"),
+                                           cl::cat(MCOptions));
 
-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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 static cl::opt<bool>
-ShowInst("show-inst", cl::desc("Show internal instruction representation"));
+    ShowInst("show-inst", cl::desc("Show internal instruction representation"),
+             cl::cat(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 static cl::opt<bool>
     PreserveComments("preserve-comments",
-                     cl::desc("Preserve Comments in outputted assembly"));
+                     cl::desc("Preserve Comments in outputted assembly"),
+                     cl::cat(MCOptions));
 
 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(MCOptions));
+
+static cl::list<std::string> IncludeDirs("I",
+                                         cl::desc("Directory of include files"),
+                                         cl::value_desc("directory"),
+                                         cl::Prefix, cl::cat(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 static cl::opt<bool> PIC("position-independent",
-                         cl::desc("Position independent"), cl::init(false));
+                         cl::desc("Position independent"), cl::init(false),
+                         cl::cat(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
-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(MCOptions));
 
-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(MCOptions));
 
 static cl::opt<bool> SaveTempLabels("save-temp-labels",
-                                    cl::desc("Don't discard temporary labels"));
+                                    cl::desc("Don't discard temporary labels"),
+                                    cl::cat(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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(MCOptions));
 
 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({&MCOptions, &llvm::ColorCategory});
   cl::ParseCommandLineOptions(argc, argv, "llvm machine code playground\n");
   const MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
   setDwarfDebugFlags(argc, argv);
Index: llvm/tools/llvm-mca/llvm-mca.cpp
===================================================================
--- llvm/tools/llvm-mca/llvm-mca.cpp
+++ llvm/tools/llvm-mca/llvm-mca.cpp
@@ -68,76 +68,74 @@
 
 static mc::RegisterMCTargetOptionsFlags MOF;
 
-static cl::OptionCategory ToolOptions("Tool Options");
+static cl::OptionCategory MCAOptions("MCA Options");
 static cl::OptionCategory ViewOptions("View Options");
 
 static cl::opt<std::string> InputFilename(cl::Positional,
                                           cl::desc("<input file>"),
-                                          cl::cat(ToolOptions), cl::init("-"));
+                                          cl::cat(MCAOptions), cl::init("-"));
 
 static cl::opt<std::string> OutputFilename("o", cl::desc("Output filename"),
-                                           cl::init("-"), cl::cat(ToolOptions),
+                                           cl::init("-"), cl::cat(MCAOptions),
                                            cl::value_desc("filename"));
 
 static cl::opt<std::string>
     ArchName("march",
              cl::desc("Target architecture. "
                       "See -version for available targets"),
-             cl::cat(ToolOptions));
+             cl::cat(MCAOptions));
 
 static cl::opt<std::string>
     TripleName("mtriple",
                cl::desc("Target triple. See -version for available targets"),
-               cl::cat(ToolOptions));
+               cl::cat(MCAOptions));
 
 static cl::opt<std::string>
     MCPU("mcpu",
          cl::desc("Target a specific cpu type (-mcpu=help for details)"),
-         cl::value_desc("cpu-name"), cl::cat(ToolOptions), cl::init("native"));
+         cl::value_desc("cpu-name"), cl::cat(MCAOptions), cl::init("native"));
 
-static cl::opt<std::string>
-    MATTR("mattr",
-          cl::desc("Additional target features."),
-          cl::cat(ToolOptions));
+static cl::opt<std::string> MATTR("mattr",
+                                  cl::desc("Additional target features."),
+                                  cl::cat(MCAOptions));
 
-static cl::opt<bool>
-    PrintJson("json",
-          cl::desc("Print the output in json format"),
-          cl::cat(ToolOptions), cl::init(false));
+static cl::opt<bool> PrintJson("json",
+                               cl::desc("Print the output in json format"),
+                               cl::cat(MCAOptions), cl::init(false));
 
 static cl::opt<int>
     OutputAsmVariant("output-asm-variant",
                      cl::desc("Syntax variant to use for output printing"),
-                     cl::cat(ToolOptions), cl::init(-1));
+                     cl::cat(MCAOptions), cl::init(-1));
 
 static cl::opt<bool>
-    PrintImmHex("print-imm-hex", cl::cat(ToolOptions), cl::init(false),
+    PrintImmHex("print-imm-hex", cl::cat(MCAOptions), cl::init(false),
                 cl::desc("Prefer hex format when printing immediate values"));
 
 static cl::opt<unsigned> Iterations("iterations",
                                     cl::desc("Number of iterations to run"),
-                                    cl::cat(ToolOptions), cl::init(0));
+                                    cl::cat(MCAOptions), cl::init(0));
 
 static cl::opt<unsigned>
     DispatchWidth("dispatch", cl::desc("Override the processor dispatch width"),
-                  cl::cat(ToolOptions), cl::init(0));
+                  cl::cat(MCAOptions), cl::init(0));
 
 static cl::opt<unsigned>
     RegisterFileSize("register-file-size",
                      cl::desc("Maximum number of physical registers which can "
                               "be used for register mappings"),
-                     cl::cat(ToolOptions), cl::init(0));
+                     cl::cat(MCAOptions), cl::init(0));
 
 static cl::opt<unsigned>
     MicroOpQueue("micro-op-queue-size", cl::Hidden,
                  cl::desc("Number of entries in the micro-op queue"),
-                 cl::cat(ToolOptions), cl::init(0));
+                 cl::cat(MCAOptions), cl::init(0));
 
 static cl::opt<unsigned>
     DecoderThroughput("decoder-throughput", cl::Hidden,
                       cl::desc("Maximum throughput from the decoders "
                                "(instructions per cycle)"),
-                      cl::cat(ToolOptions), cl::init(0));
+                      cl::cat(MCAOptions), cl::init(0));
 
 static cl::opt<bool>
     PrintRegisterFileStats("register-file-stats",
@@ -185,20 +183,20 @@
 static cl::opt<bool>
     AssumeNoAlias("noalias",
                   cl::desc("If set, assume that loads and stores do not alias"),
-                  cl::cat(ToolOptions), cl::init(true));
+                  cl::cat(MCAOptions), cl::init(true));
 
 static cl::opt<unsigned> LoadQueueSize("lqueue",
                                        cl::desc("Size of the load queue"),
-                                       cl::cat(ToolOptions), cl::init(0));
+                                       cl::cat(MCAOptions), cl::init(0));
 
 static cl::opt<unsigned> StoreQueueSize("squeue",
                                         cl::desc("Size of the store queue"),
-                                        cl::cat(ToolOptions), cl::init(0));
+                                        cl::cat(MCAOptions), cl::init(0));
 
 static cl::opt<bool>
     PrintInstructionTables("instruction-tables",
                            cl::desc("Print instruction tables"),
-                           cl::cat(ToolOptions), cl::init(false));
+                           cl::cat(MCAOptions), cl::init(false));
 
 static cl::opt<bool> PrintInstructionInfoView(
     "instruction-info",
@@ -350,7 +348,7 @@
   // Enable printing of available targets when flag --version is specified.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
-  cl::HideUnrelatedOptions({&ToolOptions, &ViewOptions});
+  cl::HideUnrelatedOptions({&MCAOptions, &ViewOptions, &llvm::ColorCategory});
 
   // Parse flags and initialize target options.
   cl::ParseCommandLineOptions(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,29 @@
 
 using namespace llvm;
 
+static cl::OptionCategory ModExtractOptions("ModExtract 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(ModExtractOptions));
 
 static cl::opt<std::string> OutputFilename("o", cl::Required,
                                            cl::desc("Output filename"),
-                                           cl::value_desc("filename"));
+                                           cl::value_desc("filename"),
+                                           cl::cat(ModExtractOptions));
 
-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(ModExtractOptions));
 
 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(ModExtractOptions));
 
 int main(int argc, char **argv) {
+  cl::HideUnrelatedOptions({&ModExtractOptions, &llvm::ColorCategory});
   cl::ParseCommandLineOptions(argc, argv, "Module extractor");
 
   ExitOnError ExitOnErr("llvm-modextract: error: ");
Index: llvm/tools/llvm-nm/llvm-nm.cpp
===================================================================
--- llvm/tools/llvm-nm/llvm-nm.cpp
+++ llvm/tools/llvm-nm/llvm-nm.cpp
@@ -2244,7 +2244,7 @@
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
-  cl::HideUnrelatedOptions(NMCat);
+  cl::HideUnrelatedOptions({&NMCat, &llvm::ColorCategory});
   cl::AddExtraVersionPrinter(printExtraVersionInfo);
   cl::ParseCommandLineOptions(argc, argv, "llvm symbol table dumper\n");
 
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-profgen/llvm-profgen.cpp
===================================================================
--- llvm/tools/llvm-profgen/llvm-profgen.cpp
+++ llvm/tools/llvm-profgen/llvm-profgen.cpp
@@ -18,16 +18,20 @@
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/TargetSelect.h"
 
+static cl::OptionCategory ProfGenOptions("ProfGen Options");
+
 static cl::list<std::string> PerfTraceFilenames(
     "perfscript", cl::value_desc("perfscript"), cl::OneOrMore,
     llvm::cl::MiscFlags::CommaSeparated,
     cl::desc("Path of perf-script trace created by Linux perf tool with "
-             "`script` command(the raw perf.data should be profiled with -b)"));
+             "`script` command(the raw perf.data should be profiled with -b)"),
+    cl::cat(ProfGenOptions));
 
 static cl::list<std::string>
     BinaryFilenames("binary", cl::value_desc("binary"), cl::OneOrMore,
                     llvm::cl::MiscFlags::CommaSeparated,
-                    cl::desc("Path of profiled binary files"));
+                    cl::desc("Path of profiled binary files"),
+                    cl::cat(ProfGenOptions));
 
 extern cl::opt<bool> ShowDisassemblyOnly;
 
@@ -42,6 +46,7 @@
   InitializeAllTargetMCs();
   InitializeAllDisassemblers();
 
+  cl::HideUnrelatedOptions({&ProfGenOptions, &llvm::ColorCategory});
   cl::ParseCommandLineOptions(argc, argv, "llvm SPGO profile generator\n");
 
   // Load binaries and parse perf events and samples
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,405 @@
 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 ReadObjOptions("ReadObj Options");
+
+cl::list<std::string> InputFilenames(cl::Positional,
+                                     cl::desc("<input object files>"),
+                                     cl::ZeroOrMore, cl::cat(ReadObjOptions));
+
+// --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(ReadObjOptions));
+cl::alias AllShort("a", cl::desc("Alias for --all"), cl::aliasopt(All),
+                   cl::cat(ReadObjOptions));
+
+// --dependent-libraries
+cl::opt<bool>
+    DependentLibraries("dependent-libraries",
+                       cl::desc("Display the dependent libraries section"),
+                       cl::cat(ReadObjOptions));
+
+// --headers, -e
+cl::opt<bool> Headers(
+    "headers",
+    cl::desc("Equivalent to setting: --file-headers, --program-headers, "
+             "--section-headers"),
+    cl::cat(ReadObjOptions));
+cl::alias HeadersShort("e", cl::desc("Alias for --headers"),
+                       cl::aliasopt(Headers), cl::NotHidden,
+                       cl::cat(ReadObjOptions));
+
+// --wide, -W
+cl::opt<bool> WideOutput("wide",
+                         cl::desc("Ignored for compatibility with GNU readelf"),
+                         cl::Hidden, cl::cat(ReadObjOptions));
+cl::alias WideOutputShort("W", cl::desc("Alias for --wide"),
+                          cl::aliasopt(WideOutput), cl::cat(ReadObjOptions));
+
+// --file-headers, --file-header, -h
+cl::opt<bool> FileHeaders("file-headers", cl::desc("Display file headers "),
+                          cl::cat(ReadObjOptions));
+cl::alias FileHeadersShort("h", cl::desc("Alias for --file-headers"),
+                           cl::aliasopt(FileHeaders), cl::NotHidden,
+                           cl::cat(ReadObjOptions));
+cl::alias FileHeadersSingular("file-header",
+                              cl::desc("Alias for --file-headers"),
+                              cl::aliasopt(FileHeaders),
+                              cl::cat(ReadObjOptions));
+
+// --section-headers, --sections, -S
+// Also -s in llvm-readobj mode.
+cl::opt<bool> SectionHeaders("section-headers",
+                             cl::desc("Display all section headers."),
+                             cl::cat(ReadObjOptions));
+cl::alias SectionsShortUpper("S", cl::desc("Alias for --section-headers"),
+                             cl::aliasopt(SectionHeaders), cl::NotHidden,
+                             cl::cat(ReadObjOptions));
+cl::alias SectionHeadersAlias("sections",
+                              cl::desc("Alias for --section-headers"),
+                              cl::aliasopt(SectionHeaders), cl::NotHidden,
+                              cl::cat(ReadObjOptions));
+
+// --section-relocations
+// Also --sr in llvm-readobj mode.
+cl::opt<bool>
+    SectionRelocations("section-relocations",
+                       cl::desc("Display relocations for each section shown."),
+                       cl::cat(ReadObjOptions));
+
+// --section-symbols
+// Also --st in llvm-readobj mode.
+cl::opt<bool>
+    SectionSymbols("section-symbols",
+                   cl::desc("Display symbols for each section shown."),
+                   cl::cat(ReadObjOptions));
+
+// --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(ReadObjOptions));
+
+// --section-mapping
+cl::opt<cl::boolOrDefault>
+    SectionMapping("section-mapping",
+                   cl::desc("Display the section to segment mapping."),
+                   cl::cat(ReadObjOptions));
+
+// --relocations, --relocs, -r
+cl::opt<bool>
+    Relocations("relocations",
+                cl::desc("Display the relocation entries in the file"),
+                cl::cat(ReadObjOptions));
+cl::alias RelocationsShort("r", cl::desc("Alias for --relocations"),
+                           cl::aliasopt(Relocations), cl::NotHidden,
+                           cl::cat(ReadObjOptions));
+cl::alias RelocationsGNU("relocs", cl::desc("Alias for --relocations"),
+                         cl::aliasopt(Relocations), cl::cat(ReadObjOptions));
+
+// --notes, -n
+cl::opt<bool> Notes("notes", cl::desc("Display the ELF notes in the file"),
+                    cl::cat(ReadObjOptions));
+cl::alias NotesShort("n", cl::desc("Alias for --notes"), cl::aliasopt(Notes),
+                     cl::NotHidden, cl::cat(ReadObjOptions));
+
+// --dyn-relocations
+cl::opt<bool>
+    DynRelocs("dyn-relocations",
+              cl::desc("Display the dynamic relocation entries in the file"),
+              cl::cat(ReadObjOptions));
+
+// --section-details
+// Also -t in llvm-readelf mode.
+cl::opt<bool> SectionDetails("section-details",
+                             cl::desc("Display the section details"),
+                             cl::cat(ReadObjOptions));
+
+// --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(ReadObjOptions));
+cl::alias SymbolsGNU("syms", cl::desc("Alias for --symbols"),
+                     cl::aliasopt(Symbols), cl::cat(ReadObjOptions));
+
+// --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(ReadObjOptions));
+cl::alias DynSymsGNU("dyn-syms", cl::desc("Alias for --dyn-symbols"),
+                     cl::aliasopt(DynamicSymbols), cl::cat(ReadObjOptions));
+
+// --hash-symbols
+cl::opt<bool> HashSymbols(
+    "hash-symbols",
+    cl::desc("Display the dynamic symbols derived from the hash section"),
+    cl::cat(ReadObjOptions));
+
+// --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(ReadObjOptions));
+
+// --dynamic-table, --dynamic, -d
+cl::opt<bool> DynamicTable("dynamic-table",
+                           cl::desc("Display the ELF .dynamic section table"),
+                           cl::cat(ReadObjOptions));
+cl::alias DynamicTableShort("d", cl::desc("Alias for --dynamic-table"),
+                            cl::aliasopt(DynamicTable), cl::NotHidden,
+                            cl::cat(ReadObjOptions));
+cl::alias DynamicTableAlias("dynamic", cl::desc("Alias for --dynamic-table"),
+                            cl::aliasopt(DynamicTable),
+                            cl::cat(ReadObjOptions));
+
+// --needed-libs
+cl::opt<bool> NeededLibraries("needed-libs",
+                              cl::desc("Display the needed libraries"),
+                              cl::cat(ReadObjOptions));
+
+// --program-headers, --segments, -l
+cl::opt<bool> ProgramHeaders("program-headers",
+                             cl::desc("Display ELF program headers"),
+                             cl::cat(ReadObjOptions));
+cl::alias ProgramHeadersShort("l", cl::desc("Alias for --program-headers"),
+                              cl::aliasopt(ProgramHeaders), cl::NotHidden,
+                              cl::cat(ReadObjOptions));
+cl::alias SegmentsAlias("segments", cl::desc("Alias for --program-headers"),
+                        cl::aliasopt(ProgramHeaders), cl::cat(ReadObjOptions));
+
+// --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(ReadObjOptions));
+cl::alias StringDumpShort("p", cl::desc("Alias for --string-dump"),
+                          cl::aliasopt(StringDump), cl::Prefix, cl::NotHidden,
+                          cl::cat(ReadObjOptions));
+
+// --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(ReadObjOptions));
+cl::alias HexDumpShort("x", cl::desc("Alias for --hex-dump"),
+                       cl::aliasopt(HexDump), cl::Prefix, cl::NotHidden,
+                       cl::cat(ReadObjOptions));
+
+// --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(ReadObjOptions));
+
+// --hash-table
+cl::opt<bool> HashTable("hash-table", cl::desc("Display ELF hash table"),
+                        cl::cat(ReadObjOptions));
+
+// --gnu-hash-table
+cl::opt<bool> GnuHashTable("gnu-hash-table",
+                           cl::desc("Display ELF .gnu.hash section"),
+                           cl::cat(ReadObjOptions));
+
+// --expand-relocs
+cl::opt<bool>
+    ExpandRelocs("expand-relocs",
+                 cl::desc("Expand each shown relocation to multiple lines"),
+                 cl::cat(ReadObjOptions));
+
+// --raw-relr
+cl::opt<bool> RawRelr(
+    "raw-relr",
+    cl::desc(
+        "Do not decode relocations in SHT_RELR section, display raw contents"),
+    cl::cat(ReadObjOptions));
+
+// --codeview
+cl::opt<bool> CodeView("codeview",
+                       cl::desc("Display CodeView debug information"),
+                       cl::cat(ReadObjOptions));
+
+// --codeview-merged-types
+cl::opt<bool>
+    CodeViewMergedTypes("codeview-merged-types",
+                        cl::desc("Display the merged CodeView type stream"),
+                        cl::cat(ReadObjOptions));
+
+// --codeview-ghash
+cl::opt<bool> CodeViewEnableGHash(
+    "codeview-ghash",
+    cl::desc("Enable global hashing for CodeView type stream de-duplication"),
+    cl::cat(ReadObjOptions));
+
+// --codeview-subsection-bytes
+cl::opt<bool> CodeViewSubsectionBytes(
+    "codeview-subsection-bytes",
+    cl::desc("Dump raw contents of codeview debug sections and records"),
+    cl::cat(ReadObjOptions));
+
+// --arch-specific
+cl::opt<bool> ArchSpecificInfo(
+    "arch-specific",
+    cl::desc("Displays architecture-specific information, if there is any."),
+    cl::cat(ReadObjOptions));
+cl::alias ArchSpecifcInfoShort("A", cl::desc("Alias for --arch-specific"),
+                               cl::aliasopt(ArchSpecificInfo), cl::NotHidden,
+                               cl::cat(ReadObjOptions));
+
+// --coff-imports
+cl::opt<bool> COFFImports("coff-imports",
+                          cl::desc("Display the PE/COFF import table"),
+                          cl::cat(ReadObjOptions));
+
+// --coff-exports
+cl::opt<bool> COFFExports("coff-exports",
+                          cl::desc("Display the PE/COFF export table"),
+                          cl::cat(ReadObjOptions));
+
+// --coff-directives
+cl::opt<bool> COFFDirectives("coff-directives",
+                             cl::desc("Display the PE/COFF .drectve section"),
+                             cl::cat(ReadObjOptions));
+
+// --coff-basereloc
+cl::opt<bool> COFFBaseRelocs("coff-basereloc",
+                             cl::desc("Display the PE/COFF .reloc section"),
+                             cl::cat(ReadObjOptions));
+
+// --coff-debug-directory
+cl::opt<bool>
+    COFFDebugDirectory("coff-debug-directory",
+                       cl::desc("Display the PE/COFF debug directory"),
+                       cl::cat(ReadObjOptions));
+
+// --coff-tls-directory
+cl::opt<bool> COFFTLSDirectory("coff-tls-directory",
+                               cl::desc("Display the PE/COFF TLS directory"),
+                               cl::cat(ReadObjOptions));
+
+// --coff-resources
+cl::opt<bool> COFFResources("coff-resources",
+                            cl::desc("Display the PE/COFF .rsrc section"),
+                            cl::cat(ReadObjOptions));
+
+// --coff-load-config
+cl::opt<bool> COFFLoadConfig("coff-load-config",
+                             cl::desc("Display the PE/COFF load config"),
+                             cl::cat(ReadObjOptions));
+
+// --elf-linker-options
+cl::opt<bool>
+    ELFLinkerOptions("elf-linker-options",
+                     cl::desc("Display the ELF .linker-options section"),
+                     cl::cat(ReadObjOptions));
+
+// --macho-data-in-code
+cl::opt<bool> MachODataInCode("macho-data-in-code",
+                              cl::desc("Display MachO Data in Code command"),
+                              cl::cat(ReadObjOptions));
+
+// --macho-indirect-symbols
+cl::opt<bool> MachOIndirectSymbols("macho-indirect-symbols",
+                                   cl::desc("Display MachO indirect symbols"),
+                                   cl::cat(ReadObjOptions));
+
+// --macho-linker-options
+cl::opt<bool> MachOLinkerOptions("macho-linker-options",
+                                 cl::desc("Display MachO linker options"),
+                                 cl::cat(ReadObjOptions));
+
+// --macho-segment
+cl::opt<bool> MachOSegment("macho-segment",
+                           cl::desc("Display MachO Segment command"),
+                           cl::cat(ReadObjOptions));
+
+// --macho-version-min
+cl::opt<bool> MachOVersionMin("macho-version-min",
+                              cl::desc("Display MachO version min command"),
+                              cl::cat(ReadObjOptions));
+
+// --macho-dysymtab
+cl::opt<bool> MachODysymtab("macho-dysymtab",
+                            cl::desc("Display MachO Dysymtab command"),
+                            cl::cat(ReadObjOptions));
+
+// --stackmap
+cl::opt<bool> PrintStackMap("stackmap",
+                            cl::desc("Display contents of stackmap section"),
+                            cl::cat(ReadObjOptions));
+
+// --stack-sizes
+cl::opt<bool>
+    PrintStackSizes("stack-sizes",
+                    cl::desc("Display contents of all stack sizes sections"),
+                    cl::cat(ReadObjOptions));
+
+// --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(ReadObjOptions));
+
+// --elf-section-groups, --section-groups, -g
+cl::opt<bool> SectionGroups("elf-section-groups",
+                            cl::desc("Display ELF section group contents"),
+                            cl::cat(ReadObjOptions));
+cl::alias SectionGroupsAlias("section-groups",
+                             cl::desc("Alias for -elf-sections-groups"),
+                             cl::aliasopt(SectionGroups),
+                             cl::cat(ReadObjOptions));
+cl::alias SectionGroupsShort("g", cl::desc("Alias for -elf-sections-groups"),
+                             cl::aliasopt(SectionGroups), cl::NotHidden,
+                             cl::cat(ReadObjOptions));
+
+// --elf-hash-histogram, --histogram, -I
+cl::opt<bool>
+    HashHistogram("elf-hash-histogram",
+                  cl::desc("Display bucket list histogram for hash sections"),
+                  cl::cat(ReadObjOptions));
+cl::alias HashHistogramShort("I", cl::desc("Alias for -elf-hash-histogram"),
+                             cl::aliasopt(HashHistogram), cl::NotHidden,
+                             cl::cat(ReadObjOptions));
+cl::alias HistogramAlias("histogram",
+                         cl::desc("Alias for --elf-hash-histogram"),
+                         cl::aliasopt(HashHistogram), cl::cat(ReadObjOptions));
+
+// --cg-profile
+cl::opt<bool> CGProfile("cg-profile",
+                        cl::desc("Display callgraph profile section"),
+                        cl::cat(ReadObjOptions));
+cl::alias ELFCGProfile("elf-cg-profile", cl::desc("Alias for --cg-profile"),
+                       cl::aliasopt(CGProfile), cl::cat(ReadObjOptions));
+
+// --bb-addr-map
+cl::opt<bool> BBAddrMap("bb-addr-map",
+                        cl::desc("Display the BB address map section"),
+                        cl::cat(ReadObjOptions));
+
+// -addrsig
+cl::opt<bool> Addrsig("addrsig", cl::desc("Display address-significance table"),
+                      cl::cat(ReadObjOptions));
+
+// -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(ReadObjOptions));
+
+cl::extrahelp
+    HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 } // namespace opts
 
 static StringRef ToolName;
@@ -698,25 +760,27 @@
   // meaning --symbols in readelf.
   static cl::alias SectionsShort("s", cl::desc("Alias for --section-headers"),
                                  cl::aliasopt(opts::SectionHeaders),
-                                 cl::NotHidden);
+                                 cl::cat(opts::ReadObjOptions), cl::NotHidden);
 
   // llvm-readelf reserves it for --section-details.
   static cl::alias SymbolsShort("t", cl::desc("Alias for --symbols"),
-                                cl::aliasopt(opts::Symbols), cl::NotHidden);
+                                cl::aliasopt(opts::Symbols), cl::NotHidden,
+                                cl::cat(opts::ReadObjOptions));
 
   // The following two-letter aliases are only provided for readobj, as readelf
   // allows single-letter args to be grouped together.
   static cl::alias SectionRelocationsShort(
       "sr", cl::desc("Alias for --section-relocations"),
-      cl::aliasopt(opts::SectionRelocations));
+      cl::aliasopt(opts::SectionRelocations), cl::cat(opts::ReadObjOptions));
   static cl::alias SectionDataShort("sd", cl::desc("Alias for --section-data"),
-                                    cl::aliasopt(opts::SectionData));
-  static cl::alias SectionSymbolsShort("st",
-                                       cl::desc("Alias for --section-symbols"),
-                                       cl::aliasopt(opts::SectionSymbols));
-  static cl::alias DynamicSymbolsShort("dt",
-                                       cl::desc("Alias for --dyn-symbols"),
-                                       cl::aliasopt(opts::DynamicSymbols));
+                                    cl::aliasopt(opts::SectionData),
+                                    cl::cat(opts::ReadObjOptions));
+  static cl::alias SectionSymbolsShort(
+      "st", cl::desc("Alias for --section-symbols"),
+      cl::aliasopt(opts::SectionSymbols), cl::cat(opts::ReadObjOptions));
+  static cl::alias DynamicSymbolsShort(
+      "dt", cl::desc("Alias for --dyn-symbols"),
+      cl::aliasopt(opts::DynamicSymbols), cl::cat(opts::ReadObjOptions));
 }
 
 /// Registers aliases that should only be allowed by readelf.
@@ -724,12 +788,13 @@
   // -s is here because for readobj it means --sections.
   static cl::alias SymbolsShort("s", cl::desc("Alias for --symbols"),
                                 cl::aliasopt(opts::Symbols), cl::NotHidden,
-                                cl::Grouping);
+                                cl::Grouping, cl::cat(opts::ReadObjOptions));
 
   // -t is here because for readobj it is an alias for --symbols.
   static cl::alias SectionDetailsShort(
       "t", cl::desc("Alias for --section-details"),
-      cl::aliasopt(opts::SectionDetails), cl::NotHidden);
+      cl::aliasopt(opts::SectionDetails), cl::NotHidden,
+      cl::cat(opts::ReadObjOptions));
 
   // Allow all single letter flags to be grouped together.
   for (auto &OptEntry : cl::getRegisteredOptions()) {
@@ -754,6 +819,7 @@
     registerReadobjAliases();
   }
 
+  cl::HideUnrelatedOptions({&opts::ReadObjOptions, &llvm::ColorCategory});
   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 RtdyldOptions("Rtdyld Options");
+
+static cl::list<std::string> InputFileList(cl::Positional, cl::ZeroOrMore,
+                                           cl::desc("<input files>"),
+                                           cl::cat(RtdyldOptions));
 
 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(RtdyldOptions));
 
 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(RtdyldOptions));
 
-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(RtdyldOptions));
 
 static cl::list<std::string> InputArgv("args", cl::Positional,
                                        cl::desc("<program arguments>..."),
-                                       cl::ZeroOrMore, cl::PositionalEatsArgs);
+                                       cl::ZeroOrMore, cl::PositionalEatsArgs,
+                                       cl::cat(RtdyldOptions));
 
 static cl::opt<std::string>
-TripleName("triple", cl::desc("Target triple for disassembler"));
+    TripleName("triple", cl::desc("Target triple for disassembler"),
+               cl::cat(RtdyldOptions));
 
 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(RtdyldOptions));
 
 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(RtdyldOptions));
 
 static cl::opt<uint64_t>
     PreallocMemory("preallocate",
                    cl::desc("Allocate memory upfront rather than on-demand"),
-                   cl::init(0));
+                   cl::init(0), cl::cat(RtdyldOptions));
 
 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(RtdyldOptions));
 
 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(RtdyldOptions));
 
 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(RtdyldOptions));
 
 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(RtdyldOptions));
+
+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(RtdyldOptions));
+
+static cl::opt<bool> PrintAllocationRequests(
+    "print-alloc-requests",
+    cl::desc("Print allocation requests made to the memory "
+             "manager by RuntimeDyld"),
+    cl::Hidden, cl::cat(RtdyldOptions));
 
 static cl::opt<bool> ShowTimes("show-times",
                                cl::desc("Show times for llvm-rtdyld phases"),
-                               cl::init(false));
+                               cl::init(false), cl::cat(RtdyldOptions));
 
 ExitOnError ExitOnErr;
 
@@ -966,6 +966,7 @@
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
+  cl::HideUnrelatedOptions({&RtdyldOptions, &llvm::ColorCategory});
   cl::ParseCommandLineOptions(argc, argv, "llvm MC-JIT tool\n");
 
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
Index: llvm/tools/llvm-sim/llvm-sim.cpp
===================================================================
--- llvm/tools/llvm-sim/llvm-sim.cpp
+++ llvm/tools/llvm-sim/llvm-sim.cpp
@@ -26,14 +26,16 @@
 using namespace llvm;
 using namespace IRSimilarity;
 
+static cl::OptionCategory SimOptions("Sim Options");
+
 static cl::opt<std::string> OutputFilename("o", cl::desc("Output Filename"),
                                            cl::init("-"),
-                                           cl::value_desc("filename"));
+                                           cl::value_desc("filename"),
+                                           cl::cat(SimOptions));
 
-static cl::opt<std::string> InputSourceFile(cl::Positional,
-                                            cl::desc("<Source file>"),
-                                            cl::init("-"),
-                                            cl::value_desc("filename"));
+static cl::opt<std::string>
+    InputSourceFile(cl::Positional, cl::desc("<Source file>"), cl::init("-"),
+                    cl::value_desc("filename"), cl::cat(SimOptions));
 
 /// Retrieve the unique number \p I was mapped to in parseBitcodeFile.
 ///
@@ -109,6 +111,7 @@
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions({&SimOptions, &llvm::ColorCategory});
   cl::ParseCommandLineOptions(argc, argv, "LLVM IR Similarity Visualizer\n");
 
   LLVMContext CurrContext;
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 SplitOptions("Split 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(SplitOptions));
+
+static cl::opt<std::string> OutputFilename("o",
+                                           cl::desc("Override output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::cat(SplitOptions));
 
 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(SplitOptions));
 
 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(SplitOptions));
 
 int main(int argc, char **argv) {
   LLVMContext Context;
   SMDiagnostic Err;
+  cl::HideUnrelatedOptions({&SplitOptions, &llvm::ColorCategory});
   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 StressOptions("Stress 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(StressOptions));
 
-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(StressOptions));
+
+static cl::opt<std::string> OutputFilename("o",
+                                           cl::desc("Override output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::cat(StressOptions));
 
 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(StressOptions));
 
 namespace {
 
@@ -738,6 +744,7 @@
   using namespace llvm;
 
   InitLLVM X(argc, argv);
+  cl::HideUnrelatedOptions({&StressOptions, &llvm::ColorCategory});
   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
@@ -18,32 +18,40 @@
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
+#include "llvm/Support/WithColor.h"
 #include <cctype>
 #include <string>
 
 using namespace llvm;
 using namespace llvm::object;
 
+static cl::OptionCategory StringsOptions("Strings Options");
+
 static cl::list<std::string> InputFileNames(cl::Positional,
                                             cl::desc("<input object files>"),
-                                            cl::ZeroOrMore);
+                                            cl::ZeroOrMore,
+                                            cl::cat(StringsOptions));
 
 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(StringsOptions));
 static cl::alias PrintFileNameShort("f", cl::desc(""),
-                                    cl::aliasopt(PrintFileName));
+                                    cl::aliasopt(PrintFileName),
+                                    cl::cat(StringsOptions));
 
 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(StringsOptions));
+static cl::alias MinLengthShort("n", cl::desc(""), cl::aliasopt(MinLength),
+                                cl::cat(StringsOptions));
 
 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(StringsOptions));
+static cl::alias AllSectionsShort("a", cl::desc(""), cl::aliasopt(AllSections),
+                                  cl::cat(StringsOptions));
 
 enum radix { none, octal, hexadecimal, decimal };
 static cl::opt<radix>
@@ -51,8 +59,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(StringsOptions));
+static cl::alias RadixShort("t", cl::desc(""), cl::aliasopt(Radix),
+                            cl::cat(StringsOptions));
 
 static cl::extrahelp
     HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
@@ -97,6 +106,7 @@
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions({&StringsOptions, &llvm::ColorCategory});
   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 UndNameOptions("UndName Options");
+
 cl::opt<bool> DumpBackReferences("backrefs", cl::Optional,
                                  cl::desc("dump backreferences"), cl::Hidden,
-                                 cl::init(false));
+                                 cl::init(false), cl::cat(UndNameOptions));
 cl::opt<bool> NoAccessSpecifier("no-access-specifier", cl::Optional,
                                 cl::desc("skip access specifiers"), cl::Hidden,
-                                cl::init(false));
+                                cl::init(false), cl::cat(UndNameOptions));
 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(UndNameOptions));
 cl::opt<bool> NoReturnType("no-return-type", cl::Optional,
                            cl::desc("skip return types"), cl::Hidden,
-                           cl::init(false));
+                           cl::init(false), cl::cat(UndNameOptions));
 cl::opt<bool> NoMemberType("no-member-type", cl::Optional,
                            cl::desc("skip member types"), cl::Hidden,
-                           cl::init(false));
+                           cl::init(false), cl::cat(UndNameOptions));
 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(UndNameOptions));
 cl::opt<bool> WarnTrailing("warn-trailing", cl::Optional,
                            cl::desc("warn on trailing characters"), cl::Hidden,
-                           cl::init(false));
+                           cl::init(false), cl::cat(UndNameOptions));
 cl::list<std::string> Symbols(cl::Positional, cl::desc("<input symbols>"),
-                              cl::ZeroOrMore);
+                              cl::ZeroOrMore, cl::cat(UndNameOptions));
 
 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({&UndNameOptions, &llvm::ColorCategory});
   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
@@ -17,12 +17,14 @@
 //
 #include "xray-registry.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::xray;
 
 int main(int argc, char *argv[]) {
+  cl::HideUnrelatedOptions(&llvm::ColorCategory);
   cl::ParseCommandLineOptions(argc, argv,
                               "XRay Tools\n\n"
                               "  This program consolidates multiple XRay trace "