[llvm-reduce] Make all llvm-reduce specifict options use the same options category

[markus]

Summary

Previously the options category given to cl::HideUnrelatedOptions was local to llvm-reduce.cpp and as a result only options declared in that file were visible in the -help options listing. This was a bit unfortunate since there were several useful options declared in other files. This patch addresses that. The full options listing is now:

OVERVIEW: LLVM automatic testcase reducer.

USAGE: llvm-reduce [options] <input llvm ll/bc file>

OPTIONS:

Color Options:

  --color                             - Use colors in output (default=autodetect)

Generic Options:

  --help                              - Display available options (--help-hidden for more)
  --help-list                         - Display list of available options (--help-list-hidden for more)
  --version                           - Display the version of this program

llvm-reduce options:

  --abort-on-invalid-reduction        - Abort if any reduction results in invalid IR
  --delta-passes=<string>             - Delta passes to run, separated by commas. By default, run all delta passes.
  --in-place                          - WARNING: This option will replace your input file with the reduced version!
  -j=<uint>                           - Maximum number of threads to use to process chunks. Set to 1 to disables parallelism.
  --max-pass-iterations=<int>         - Maximum number of times to run the full set of delta passes (default=1)
  --mtriple=<string>                  - Set the target triple
  --print-delta-passes                - Print list of delta passes, passable to --delta-passes as a comma separated list
  --starting-granularity-level=<uint> - Number of times to divide chunks prior to first test
  --test=<string>                     - Name of the interesting-ness test to be run
  --test-arg=<string>                 - Arguments passed onto the interesting-ness test
  --write-tmp-files-as-bitcode        - Write temporary files as bitcode, instead of textual IR
  -x=<value>                          - Input language ('ir' or 'mir')
    =ir
    =mir

llvm/tools/llvm-reduce/DeltaManager.cpp

 #include "deltas/ReduceOperands.h"
 #include "deltas/ReduceOperandsSkip.h"
 #include "deltas/ReduceOperandsToArgs.h"
 #include "deltas/ReduceSpecialGlobals.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
+extern cl::OptionCategory LLVMReduceOptions;
 static cl::opt<std::string>
     DeltaPasses("delta-passes",
                 cl::desc("Delta passes to run, separated by commas. By "
-                         "default, run all delta passes."));
+                         "default, run all delta passes."),
+                cl::cat(LLVMReduceOptions));
 
 #define DELTA_PASSES                                                           \
   DELTA_PASS("special-globals", reduceSpecialGlobalsDeltaPass)                 \
   DELTA_PASS("aliases", reduceAliasesDeltaPass)                                \
   DELTA_PASS("function-bodies", reduceFunctionBodiesDeltaPass)                 \
   DELTA_PASS("functions", reduceFunctionsDeltaPass)                            \
   DELTA_PASS("basic-blocks", reduceBasicBlocksDeltaPass)                       \
   DELTA_PASS("global-values", reduceGlobalValuesDeltaPass)                     \

llvm/tools/llvm-reduce/deltas/Delta.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include <fstream>
 #include <set>
 
 using namespace llvm;
 
+extern cl::OptionCategory LLVMReduceOptions;
+
 static cl::opt<bool> AbortOnInvalidReduction(
     "abort-on-invalid-reduction",
-    cl::desc("Abort if any reduction results in invalid IR"));
+    cl::desc("Abort if any reduction results in invalid IR"),
+    cl::cat(LLVMReduceOptions));
 
 static cl::opt<unsigned int> StartingGranularityLevel(
     "starting-granularity-level",
-    cl::desc("Number of times to divide chunks prior to first test"));
+    cl::desc("Number of times to divide chunks prior to first test"),
+    cl::cat(LLVMReduceOptions));
 
 static cl::opt<bool> TmpFilesAsBitcode(
     "write-tmp-files-as-bitcode",
     cl::desc("Write temporary files as bitcode, instead of textual IR"),
-    cl::init(false));
+    cl::init(false), cl::cat(LLVMReduceOptions));
 
 #ifdef LLVM_ENABLE_THREADS
 static cl::opt<unsigned> NumJobs(
     "j",
     cl::desc("Maximum number of threads to use to process chunks. Set to 1 to "
              "disables parallelism."),
-    cl::init(1));
+    cl::init(1), cl::cat(LLVMReduceOptions));
 #else
 unsigned NumJobs = 1;
 #endif
 
 void writeOutput(ReducerWorkItem &M, llvm::StringRef Message);
 
 bool isReduced(ReducerWorkItem &M, TestRunner &Test,
                SmallString<128> &CurrentFilepath) {

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

 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Target/TargetMachine.h"
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 
-static cl::OptionCategory Options("llvm-reduce options");
+cl::OptionCategory LLVMReduceOptions("llvm-reduce options");
 
 static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden,
-                          cl::cat(Options));
+                          cl::cat(LLVMReduceOptions));
 static cl::opt<bool> Version("v", cl::desc("Alias for -version"), cl::Hidden,
-                             cl::cat(Options));
+                             cl::cat(LLVMReduceOptions));
 
 static cl::opt<bool>
     PrintDeltaPasses("print-delta-passes",
                      cl::desc("Print list of delta passes, passable to "
                               "--delta-passes as a comma separated list"),
-                     cl::cat(Options));
+                     cl::cat(LLVMReduceOptions));
 
 static cl::opt<std::string> InputFilename(cl::Positional, cl::Required,
                                           cl::desc("<input llvm ll/bc file>"),
-                                          cl::cat(Options));
+                                          cl::cat(LLVMReduceOptions));
 
 static cl::opt<std::string>
     TestFilename("test", cl::Required,
                  cl::desc("Name of the interesting-ness test to be run"),
-                 cl::cat(Options));
+                 cl::cat(LLVMReduceOptions));
 
 static cl::list<std::string>
     TestArguments("test-arg", cl::ZeroOrMore,
                   cl::desc("Arguments passed onto the interesting-ness test"),
-                  cl::cat(Options));
+                  cl::cat(LLVMReduceOptions));
 
 static cl::opt<std::string> OutputFilename(
     "output", cl::desc("Specify the output file. default: reduced.ll|mir"));
 static cl::alias OutputFileAlias("o", cl::desc("Alias for -output"),
                                  cl::aliasopt(OutputFilename),
-                                 cl::cat(Options));
+                                 cl::cat(LLVMReduceOptions));
 
 static cl::opt<bool>
     ReplaceInput("in-place",
                  cl::desc("WARNING: This option will replace your input file "
                           "with the reduced version!"),
-                 cl::cat(Options));
+                 cl::cat(LLVMReduceOptions));
 
 enum class InputLanguages { None, IR, MIR };
 
 static cl::opt<InputLanguages>
     InputLanguage("x", cl::ValueOptional,
                   cl::desc("Input language ('ir' or 'mir')"),
                   cl::init(InputLanguages::None),
                   cl::values(clEnumValN(InputLanguages::IR, "ir", ""),
                              clEnumValN(InputLanguages::MIR, "mir", "")),
-                  cl::cat(Options));
+                  cl::cat(LLVMReduceOptions));
 
 static cl::opt<std::string> TargetTriple("mtriple",
                                          cl::desc("Set the target triple"),
-                                         cl::cat(Options));
+                                         cl::cat(LLVMReduceOptions));
 
 static cl::opt<int>
     MaxPassIterations("max-pass-iterations",
                       cl::desc("Maximum number of times to run the full set "
                                "of delta passes (default=1)"),
-                      cl::init(1), cl::cat(Options));
+                      cl::init(1), cl::cat(LLVMReduceOptions));
 
 static codegen::RegisterCodeGenFlags CGF;
 
 void writeOutput(ReducerWorkItem &M, StringRef Message) {
   if (ReplaceInput) // In-place
     OutputFilename = InputFilename.c_str();
   else if (OutputFilename.empty() || OutputFilename == "-")
     OutputFilename = M.isMIR() ? "reduced.mir" : "reduced.ll";
static std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
   return std::unique_ptr<LLVMTargetMachine>(
       static_cast<LLVMTargetMachine *>(TheTarget->createTargetMachine(
           TT, CPU, FS, TargetOptions(), None, None, CodeGenOpt::Default)));
 }
 
 int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
 
-  cl::HideUnrelatedOptions({&Options, &getColorCategory()});
+  cl::HideUnrelatedOptions({&LLVMReduceOptions, &getColorCategory()});
   cl::ParseCommandLineOptions(Argc, Argv, "LLVM automatic testcase reducer.\n");
 
   bool ReduceModeMIR = false;
   if (InputLanguage != InputLanguages::None) {
     if (InputLanguage == InputLanguages::MIR)
       ReduceModeMIR = true;
   } else if (StringRef(InputFilename).endswith(".mir")) {
     ReduceModeMIR = true;