[llvm][tools] Hide unrelated llvm-bcanalyzer options

[tbaeder]

Summary

Dynamically linking against libLLVM.so otherwise shows all cl::opts scattered around the code base.

Per-tool follow-up of https://reviews.llvm.org/D104363

[MaskRay]

This patch needs test/tools/llvm-bcanalyzer/help.test. See @jhenderson's comment on the other thread: "It may also be a good idea to add testing similar to the llvm-strings test to show that only the expected options categories are present."

Consider a NOT pattern (https://llvm.org/docs/CommandGuide/FileCheck.html#the-check-not-directive) --implicit-check-not='{{[Oo]}}ptions:' to avoid undesired options categories>

[tbaeder]

It doesn't seem very useful to me to add tests for the help output. Since all categories are listed in the HideUnrelatedOptions() call anyway, new categories are not just gonna show up without changing that call. And this one test doesn't cover new tools that are going to be added either.

Added the suggested test case anyway, with some modifications to make it work.

[MaskRay]

llvm/test/tools/llvm-bcanalyzer/help.test

1

Use --implicit-check-not='{{[Oo]}}ptions:'

3

Make the OVERVIEW line complete.

[jhenderson]

LGTM too.

llvm/test/tools/llvm-bcanalyzer/help.test

+# RUN: llvm-bcanalyzer --help | FileCheck %s --check-prefix HELP --implicit-check-not="General options:"
+
+# HELP: OVERVIEW
+# HELP: USAGE
+# HELP: BC Analyzer Options
+# HELP: Color Options
+# HELP: Generic Options

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

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Bitcode/BitcodeAnalyzer.h"
 #include "llvm/Support/CommandLine.h"
 #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 BCAnalyzerCategory("BC Analyzer Options");
+
+static cl::opt<std::string> InputFilename(cl::Positional,
+                                          cl::desc("<input bitcode>"),
+                                          cl::init("-"),
+                                          cl::cat(BCAnalyzerCategory));
 
-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(BCAnalyzerCategory));
 
 //===----------------------------------------------------------------------===//
 // 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(BCAnalyzerCategory));
 
 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(BCAnalyzerCategory));
 
 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(BCAnalyzerCategory));
 
 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(BCAnalyzerCategory));
 
 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(BCAnalyzerCategory));
 
 static Error reportError(StringRef Message) {
   return createStringError(std::errc::illegal_byte_sequence, Message.data());
 }
 
 static Expected<std::unique_ptr<MemoryBuffer>> openBitcodeFile(StringRef Path) {
   // Read the input file.
   Expected<std::unique_ptr<MemoryBuffer>> MemBufOrErr =
       errorOrToExpected(MemoryBuffer::getFileOrSTDIN(Path));
   if (Error E = MemBufOrErr.takeError())
     return std::move(E);
 
   std::unique_ptr<MemoryBuffer> MemBuf = std::move(*MemBufOrErr);
 
   if (MemBuf->getBufferSize() & 3)
     return reportError(
         "Bitcode stream should be a multiple of 4 bytes in length");
   return std::move(MemBuf);
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
+
+  cl::HideUnrelatedOptions({&BCAnalyzerCategory, &ColorCategory});
   cl::ParseCommandLineOptions(argc, argv, "llvm-bcanalyzer file analyzer\n");
   ExitOnError ExitOnErr("llvm-bcanalyzer: ");
 
   std::unique_ptr<MemoryBuffer> MB = ExitOnErr(openBitcodeFile(InputFilename));
   std::unique_ptr<MemoryBuffer> BlockInfoMB = nullptr;
   if (!BlockInfoFilename.empty())
     BlockInfoMB = ExitOnErr(openBitcodeFile(BlockInfoFilename));