[llvm][tools] Hide unrelated cli options of more tools

[tbaeder]

Summary

Hide unrelated cli options of a few more CLI tools in llvm/tools/ and add a test for each of them.

[MaskRay]

Looks great!

[jhenderson]

Please remember to include full diff context when posting patches.

[tbaeder]

Rebased after the llvm-elfabi removal.

[jhenderson]

LGTM.

llvm/test/tools/llvm-cxxdump/help.test

+# RUN: llvm-cxxdump --help | FileCheck %s --check-prefix HELP --implicit-check-not='{{[Oo]}}ptions:'
+
+# HELP: OVERVIEW: LLVM C++ ABI Data Dumper
+# HELP: USAGE
+# HELP: Color Options
+# HELP: Generic Options

llvm/test/tools/llvm-cxxmap/help.test

+# RUN: llvm-cxxmap --help | FileCheck %s --check-prefix HELP --implicit-check-not='{{[Oo]}}ptions:'
+
+# HELP: OVERVIEW: LLVM C++ mangled name remapper
+# HELP: USAGE
+# HELP: CXX Map Options
+# HELP: Color Options
+# HELP: Generic Options

llvm/test/tools/llvm-diff/help.test

+# RUN: llvm-diff --help | FileCheck %s --check-prefix HELP --implicit-check-not='{{[Oo]}}ptions:'
+
+# HELP: USAGE
+# HELP: Color Options
+# HELP: Generic Options

llvm/test/tools/llvm-dis/help.test

+# RUN: llvm-dis --help | FileCheck %s --check-prefix HELP --implicit-check-not='{{[Oo]}}ptions:'
+
+# HELP: OVERVIEW
+# HELP: USAGE
+# HELP: Color Options
+# HELP: Disassembler Options
+# HELP: Generic Options

llvm/test/tools/llvm-dwp/help.test

+# RUN: llvm-dwp --help | FileCheck %s --check-prefix HELP --implicit-check-not='{{[Oo]}}ptions:'
+
+# HELP: OVERVIEW
+# HELP: USAGE
+# HELP: Color Options
+# HELP: Generic Options
+# HELP: Specific Options

llvm/test/tools/llvm-ifs/help.test

+# RUN: llvm-ifs --help | FileCheck %s --check-prefix HELP --implicit-check-not='{{[Oo]}}ptions:'
+
+# HELP: USAGE
+# HELP: Color Options
+# HELP: Generic Options
+# HELP: Ifs Options

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

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

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

 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SymbolRemappingReader.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
+cl::OptionCategory CXXMapCategory("CXX Map Options");
+
 cl::opt<std::string> OldSymbolFile(cl::Positional, cl::Required,
-                                   cl::desc("<symbol-file>"));
+                                   cl::desc("<symbol-file>"),
+                                   cl::cat(CXXMapCategory));
 cl::opt<std::string> NewSymbolFile(cl::Positional, cl::Required,
-                                   cl::desc("<symbol-file>"));
+                                   cl::desc("<symbol-file>"),
+                                   cl::cat(CXXMapCategory));
 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(CXXMapCategory));
+cl::alias RemappingFileA("r", cl::aliasopt(RemappingFile),
+                         cl::cat(CXXMapCategory));
 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(CXXMapCategory));
+cl::alias OutputFilenameA("o", cl::aliasopt(OutputFilename),
+                          cl::cat(CXXMapCategory));
 
 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(CXXMapCategory));
 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(CXXMapCategory));
 
 static void warn(Twine Message, Twine Whence = "",
                  std::string Hint = "") {
   WithColor::warning();
   std::string WhenceStr = Whence.str();
   if (!WhenceStr.empty())
     errs() << WhenceStr << ": ";
   errs() << Message << "\n";
for (line_iterator LineIt(OldSymbolFile, /*SkipBlanks=*/true, '#');
 
     Out << Symbol << " " << NewSymbol << "\n";
   }
 }
 
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
+  cl::HideUnrelatedOptions({&CXXMapCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "LLVM C++ mangled name remapper\n");
 
   auto OldSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(OldSymbolFile);
   if (!OldSymbolBufOrError)
     exitWithErrorCode(OldSymbolBufOrError.getError(), OldSymbolFile);
 
   auto NewSymbolBufOrError = MemoryBuffer::getFileOrSTDIN(NewSymbolFile);
   if (!NewSymbolBufOrError)

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

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

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

 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 #include <system_error>
 using namespace llvm;
 
-static cl::list<std::string> InputFilenames(cl::Positional, cl::ZeroOrMore,
-                                            cl::desc("[input bitcode]..."));
-
-static cl::opt<std::string>
-OutputFilename("o", cl::desc("Override output filename"),
-               cl::value_desc("filename"));
+static cl::OptionCategory DisCategory("Disassembler Options");
 
-static cl::opt<bool>
-Force("f", cl::desc("Enable binary output on terminals"));
+static cl::list<std::string> InputFilenames(cl::Positional, cl::ZeroOrMore,
+                                            cl::desc("[input bitcode]..."),
+                                            cl::cat(DisCategory));
 
-static cl::opt<bool>
-DontPrint("disable-output", cl::desc("Don't output the .ll file"), cl::Hidden);
+static cl::opt<std::string> OutputFilename("o",
+                                           cl::desc("Override output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::cat(DisCategory));
+
+static cl::opt<bool> Force("f", cl::desc("Enable binary output on terminals"),
+                           cl::cat(DisCategory));
+
+static cl::opt<bool> DontPrint("disable-output",
+                               cl::desc("Don't output the .ll file"),
+                               cl::Hidden, cl::cat(DisCategory));
 
 static cl::opt<bool>
     SetImporting("set-importing",
                  cl::desc("Set lazy loading to pretend to import a module"),
-                 cl::Hidden);
+                 cl::Hidden, cl::cat(DisCategory));
 
 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(DisCategory));
 
 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(DisCategory));
 
 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(DisCategory));
 
 namespace {
 
 static void printDebugLoc(const DebugLoc &DL, formatted_raw_ostream &OS) {
   OS << DL.getLine() << ":" << DL.getCol();
   if (DILocation *IDL = DL.getInlinedAt()) {
     OS << "@";
     printDebugLoc(IDL, OS);

 
 static ExitOnError ExitOnErr;
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
   ExitOnErr.setBanner(std::string(argv[0]) + ": error: ");
 
+  cl::HideUnrelatedOptions({&DisCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv, "llvm .bc -> .ll disassembler\n");
 
   LLVMContext Context;
   Context.setDiagnosticHandler(
       std::make_unique<LLVMDisDiagnosticHandler>(argv[0]));
 
   if (InputFilenames.size() < 1) {
     InputFilenames.push_back("-");

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

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

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

 #define DEBUG_TYPE "llvm-ifs"
 
 namespace {
 const VersionTuple IfsVersionCurrent(3, 0);
 
 enum class FileFormat { IFS, ELF, TBD };
 } // end anonymous namespace
 
+cl::OptionCategory IfsCategory("Ifs Options");
+
 // TODO: Use OptTable for option parsing in the future.
 // Command line flags:
 cl::list<std::string> InputFilePaths(cl::Positional, cl::desc("input"),
-                                     cl::ZeroOrMore);
+                                     cl::ZeroOrMore, cl::cat(IfsCategory));
 cl::opt<FileFormat> InputFormat(
     "input-format", cl::desc("Specify the input file format"),
     cl::values(clEnumValN(FileFormat::IFS, "IFS", "Text based ELF stub file"),
-               clEnumValN(FileFormat::ELF, "ELF", "ELF object file")));
+               clEnumValN(FileFormat::ELF, "ELF", "ELF object file")),
+    cl::cat(IfsCategory));
 cl::opt<FileFormat> OutputFormat(
     "output-format", cl::desc("Specify the output file format"),
     cl::values(clEnumValN(FileFormat::IFS, "IFS", "Text based ELF stub file"),
                clEnumValN(FileFormat::ELF, "ELF", "ELF stub file"),
                clEnumValN(FileFormat::TBD, "TBD", "Apple TBD text stub file")),
-    cl::Required);
+    cl::Required, cl::cat(IfsCategory));
 cl::opt<std::string> OptArch("arch",
-                             cl::desc("Specify the architecture, e.g. x86_64"));
-cl::opt<IFSBitWidthType> OptBitWidth(
-    "bitwidth", cl::desc("Specify the bit width"),
+                             cl::desc("Specify the architecture, e.g. x86_64"),
+                             cl::cat(IfsCategory));
+cl::opt<IFSBitWidthType>
+    OptBitWidth("bitwidth", cl::desc("Specify the bit width"),
                 cl::values(clEnumValN(IFSBitWidthType::IFS32, "32", "32 bits"),
-               clEnumValN(IFSBitWidthType::IFS64, "64", "64 bits")));
+                           clEnumValN(IFSBitWidthType::IFS64, "64", "64 bits")),
+                cl::cat(IfsCategory));
 cl::opt<IFSEndiannessType> OptEndianness(
     "endianness", cl::desc("Specify the endianness"),
     cl::values(clEnumValN(IFSEndiannessType::Little, "little", "Little Endian"),
-               clEnumValN(IFSEndiannessType::Big, "big", "Big Endian")));
+               clEnumValN(IFSEndiannessType::Big, "big", "Big Endian")),
+    cl::cat(IfsCategory));
 cl::opt<std::string> OptTargetTriple(
-    "target", cl::desc("Specify the target triple, e.g. x86_64-linux-gnu"));
+    "target", cl::desc("Specify the target triple, e.g. x86_64-linux-gnu"),
+    cl::cat(IfsCategory));
 cl::opt<std::string> OptTargetTripleHint(
     "hint-ifs-target",
     cl::desc("When --output-format is 'IFS', this flag will hint the expected "
-             "target triple for IFS output"));
+             "target triple for IFS output"),
+    cl::cat(IfsCategory));
 cl::opt<bool> StripIFSArch(
     "strip-ifs-arch",
-    cl::desc("Strip target architecture information away from IFS output"));
+    cl::desc("Strip target architecture information away from IFS output"),
+    cl::cat(IfsCategory));
 cl::opt<bool> StripIFSBitWidth(
     "strip-ifs-bitwidth",
-    cl::desc("Strip target bit width information away from IFS output"));
+    cl::desc("Strip target bit width information away from IFS output"),
+    cl::cat(IfsCategory));
 cl::opt<bool> StripIFSEndiannessWidth(
     "strip-ifs-endianness",
-    cl::desc("Strip target endianness information away from IFS output"));
+    cl::desc("Strip target endianness information away from IFS output"),
+    cl::cat(IfsCategory));
 cl::opt<bool> StripIFSTarget(
     "strip-ifs-target",
-    cl::desc("Strip all target information away from IFS output"));
+    cl::desc("Strip all target information away from IFS output"),
+    cl::cat(IfsCategory));
 cl::opt<std::string>
     SoName("soname",
            cl::desc("Manually set the DT_SONAME entry of any emitted files"),
-           cl::value_desc("name"));
-cl::opt<std::string> OutputFilePath("output", cl::desc("Output file"));
+           cl::value_desc("name"), cl::cat(IfsCategory));
+cl::opt<std::string> OutputFilePath("output", cl::desc("Output file"),
+                                    cl::cat(IfsCategory));
 cl::alias OutputFilePathA("o", cl::desc("Alias for --output"),
-                          cl::aliasopt(OutputFilePath));
+                          cl::aliasopt(OutputFilePath), cl::cat(IfsCategory));
 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(IfsCategory));
 
 static std::string getTypeName(IFSSymbolType Type) {
   switch (Type) {
   case IFSSymbolType::NoType:
     return "NoType";
   case IFSSymbolType::Func:
     return "Func";
   case IFSSymbolType::Object:
if (SysErr)
     return createStringError(SysErr, "Couldn't open `%s` for writing",
                              FilePath.data());
   Out << IFSStr;
   return Error::success();
 }
 
 int main(int argc, char *argv[]) {
   // Parse arguments.
+  cl::HideUnrelatedOptions({&IfsCategory, &getColorCategory()});
   cl::ParseCommandLineOptions(argc, argv);
 
   if (InputFilePaths.empty())
     InputFilePaths.push_back("-");
 
   // If input files are more than one, they can only be IFS files.
   if (InputFilePaths.size() > 1)
     InputFormat.setValue(FileFormat::IFS);