[bugpoint] Add option categories.

[hintonda]

Summary

Add option categories to cleanup help output.

[MatzeB]

LGTM with declarations moved into a header.

tools/bugpoint/ExtractFunction.cpp

44

Can you put this declaration into a header?

tools/bugpoint/ToolRunner.cpp

29

Can you put this declaration into a header?

[hintonda]

While this is a marginal improvement, replacing bugpoint is a better option.

tools/bugpoint/BugDriver.cpp

if (SaveTemps) {
     if (Error E = File.keep())
       errs() << "Failed to keep temp file " << toString(std::move(E)) << '\n';
     return;
   }
   if (Error E = File.discard())
     errs() << "Failed to delete temp file " << toString(std::move(E)) << '\n';
 }
 
+extern cl::OptionCategory ExecutionOptions;
+
 // Anonymous namespace to define command line options for debugging.
 //
 namespace {
 // Output - The user can specify a file containing the expected output of the
 // program.  If this filename is set, it is used as the reference diff source,
 // otherwise the raw input run through an interpreter is used as the reference
 // source.
 //
 cl::opt<std::string> OutputFile("output",
+                                cl::cat(ExecutionOptions),
                                 cl::desc("Specify a reference program output "
                                          "(for miscompilation detection)"));
 }
 
 /// If we reduce or update the program somehow, call this method to update
 /// bugdriver with it.  This deletes the old module and sets the specified one
 /// as the current program.
 void BugDriver::setNewProgram(std::unique_ptr<Module> M) {

tools/bugpoint/CrashDebugger.cpp

 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include <set>
 using namespace llvm;
 
 namespace {
+cl::OptionCategory CrashDebuggerOptions("CrashDebugger Options", "");
 cl::opt<bool> KeepMain("keep-main",
+                       cl::cat(CrashDebuggerOptions),
                        cl::desc("Force function reduction to keep main"),
                        cl::init(false));
 cl::opt<bool> NoGlobalRM("disable-global-remove",
+                         cl::cat(CrashDebuggerOptions),
                          cl::desc("Do not remove global variables"),
                          cl::init(false));
 
 cl::opt<bool> ReplaceFuncsWithNull(
     "replace-funcs-with-null",
+    cl::cat(CrashDebuggerOptions),
     cl::desc("When stubbing functions, replace all uses will null"),
     cl::init(false));
 cl::opt<bool> DontReducePassList("disable-pass-list-reduction",
+                                 cl::cat(CrashDebuggerOptions),
                                  cl::desc("Skip pass list reduction steps"),
                                  cl::init(false));
 
 cl::opt<bool> NoNamedMDRM("disable-namedmd-remove",
+                          cl::cat(CrashDebuggerOptions),
                           cl::desc("Do not remove global named metadata"),
                           cl::init(false));
 cl::opt<bool> NoStripDebugInfo("disable-strip-debuginfo",
+                               cl::cat(CrashDebuggerOptions),
                                cl::desc("Do not strip debug info metadata"),
                                cl::init(false));
-cl::opt<bool> NoStripDebugTypeInfo("disable-strip-debug-types",
-                               cl::desc("Do not strip debug type info metadata"),
-                               cl::init(false));
+cl::opt<bool> NoStripDebugTypeInfo(
+    "disable-strip-debug-types",
+    cl::cat(CrashDebuggerOptions),
 cl::opt<bool> VerboseErrors("verbose-errors",
+                            cl::cat(CrashDebuggerOptions),
                             cl::desc("Print the output of crashing program"),
                             cl::init(false));
 }
 
 namespace llvm {
 class ReducePassList : public ListReducer<std::string> {
   BugDriver &BD;
 

tools/bugpoint/ExecutionDriver.cpp

 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/SystemUtils.h"
 #include "llvm/Support/raw_ostream.h"
 #include <fstream>
 
 using namespace llvm;
 
+cl::OptionCategory ExecutionOptions("Execution Options", "");
+
 namespace {
 // OutputType - Allow the user to specify the way code should be run, to test
 // for miscompilation.
 //
 enum OutputType {
   AutoPick,
   RunLLI,
   RunJIT,
   RunLLC,
   RunLLCIA,
   LLC_Safe,
   CompileCustom,
   Custom
 };
 
 cl::opt<double> AbsTolerance("abs-tolerance",
+                             cl::cat(ExecutionOptions),
                              cl::desc("Absolute error tolerated"),
                              cl::init(0.0));
 cl::opt<double> RelTolerance("rel-tolerance",
+                             cl::cat(ExecutionOptions),
                              cl::desc("Relative error tolerated"),
                              cl::init(0.0));
 
 cl::opt<OutputType> InterpreterSel(
+    cl::cat(ExecutionOptions),
     cl::desc("Specify the \"test\" i.e. suspect back-end:"),
     cl::values(clEnumValN(AutoPick, "auto", "Use best guess"),
                clEnumValN(RunLLI, "run-int", "Execute with the interpreter"),
                clEnumValN(RunJIT, "run-jit", "Execute with JIT"),
                clEnumValN(RunLLC, "run-llc", "Compile with LLC"),
                clEnumValN(RunLLCIA, "run-llc-ia",
                           "Compile with LLC with integrated assembler"),
                clEnumValN(LLC_Safe, "llc-safe", "Use LLC for all"),
                clEnumValN(CompileCustom, "compile-custom",
                           "Use -compile-command to define a command to "
                           "compile the bitcode. Useful to avoid linking."),
                clEnumValN(Custom, "run-custom",
                           "Use -exec-command to define a command to execute "
                           "the bitcode. Useful for cross-compilation.")),
     cl::init(AutoPick));
 
 cl::opt<OutputType> SafeInterpreterSel(
+    cl::cat(ExecutionOptions),
     cl::desc("Specify \"safe\" i.e. known-good backend:"),
     cl::values(clEnumValN(AutoPick, "safe-auto", "Use best guess"),
                clEnumValN(RunLLC, "safe-run-llc", "Compile with LLC"),
                clEnumValN(Custom, "safe-run-custom",
                           "Use -exec-command to define a command to execute "
                           "the bitcode. Useful for cross-compilation.")),
     cl::init(AutoPick));
 
 cl::opt<std::string> SafeInterpreterPath(
-    "safe-path", cl::desc("Specify the path to the \"safe\" backend program"),
+    "safe-path", cl::cat(ExecutionOptions),
+    cl::desc("Specify the path to the \"safe\" backend program"),
     cl::init(""));
 
 cl::opt<bool> AppendProgramExitCode(
-    "append-exit-code",
+    "append-exit-code", cl::cat(ExecutionOptions),
     cl::desc("Append the exit code to the output so it gets diff'd too"),
     cl::init(false));
 
 cl::opt<std::string>
     InputFile("input", cl::init("/dev/null"),
+              cl::cat(ExecutionOptions),
               cl::desc("Filename to pipe in as stdin (default: /dev/null)"));
 
 cl::list<std::string>
-    AdditionalSOs("additional-so", cl::desc("Additional shared objects to load "
-                                            "into executing programs"));
+    AdditionalSOs("additional-so", cl::cat(ExecutionOptions),
+                  cl::desc("Additional shared objects to load "
 
 cl::list<std::string> AdditionalLinkerArgs(
-    "Xlinker", cl::desc("Additional arguments to pass to the linker"));
+    "Xlinker", cl::cat(ExecutionOptions),
+    cl::desc("Additional arguments to pass to the linker"));
 
 cl::opt<std::string> CustomCompileCommand(
     "compile-command", cl::init("llc"),
+    cl::cat(ExecutionOptions),
     cl::desc("Command to compile the bitcode (use with -compile-custom) "
              "(default: llc)"));
 
 cl::opt<std::string> CustomExecCommand(
     "exec-command", cl::init("simulate"),
+    cl::cat(ExecutionOptions),
     cl::desc("Command to execute the bitcode (use with -run-custom) "
              "(default: simulate)"));
 }
 
 namespace llvm {
 // Anything specified after the --args option are taken as arguments to the
 // program being debugged.
 cl::list<std::string> InputArgv("args", cl::Positional,
+                                cl::cat(ExecutionOptions),
                                 cl::desc("<program arguments>..."),
                                 cl::ZeroOrMore, cl::PositionalEatsArgs);
 
 cl::opt<std::string>
     OutputPrefix("output-prefix", cl::init("bugpoint"),
+                 cl::cat(ExecutionOptions),
                  cl::desc("Prefix to use for outputs (default: 'bugpoint')"));
 }
 
 namespace {
 cl::list<std::string> ToolArgv("tool-args", cl::Positional,
+                               cl::cat(ExecutionOptions),
                                cl::desc("<tool arguments>..."), cl::ZeroOrMore,
                                cl::PositionalEatsArgs);
 
 cl::list<std::string> SafeToolArgv("safe-tool-args", cl::Positional,
+                                   cl::cat(ExecutionOptions),
                                    cl::desc("<safe-tool arguments>..."),
                                    cl::ZeroOrMore, cl::PositionalEatsArgs);
 
 cl::opt<std::string> CCBinary("gcc", cl::init(""),
+                              cl::cat(ExecutionOptions),
                               cl::desc("The gcc binary to use."));
 
 cl::list<std::string> CCToolArgv("gcc-tool-args", cl::Positional,
+                                 cl::cat(ExecutionOptions),
                                  cl::desc("<gcc-tool arguments>..."),
                                  cl::ZeroOrMore, cl::PositionalEatsArgs);
 }
 
 //===----------------------------------------------------------------------===//
 // BugDriver method implementation
 //
 

tools/bugpoint/ExtractFunction.cpp

 
 #define DEBUG_TYPE "bugpoint"
 
 namespace llvm {
 bool DisableSimplifyCFG = false;
 extern cl::opt<std::string> OutputPrefix;
 } // End llvm namespace
 
+extern cl::OptionCategory MiscDebuggerOptions;
+
 namespace {
-cl::opt<bool> NoDCE("disable-dce",
+cl::opt<bool> NoDCE("disable-dce", cl::cat(MiscDebuggerOptions),
                     cl::desc("Do not use the -dce pass to reduce testcases"));
 cl::opt<bool, true>
     NoSCFG("disable-simplifycfg", cl::location(DisableSimplifyCFG),
+           cl::cat(MiscDebuggerOptions),
            cl::desc("Do not use the -simplifycfg pass to reduce testcases"));
 
 Function *globalInitUsesExternalBA(GlobalVariable *GV) {
   if (!GV->hasInitializer())
     return nullptr;
 
   Constant *I = GV->getInitializer();
 

tools/bugpoint/Miscompilation.cpp

 
 using namespace llvm;
 
 namespace llvm {
 extern cl::opt<std::string> OutputPrefix;
 extern cl::list<std::string> InputArgv;
 } // end namespace llvm
 
+cl::OptionCategory MiscDebuggerOptions("MiscompilationDebugger Options", "");
+
 namespace {
 static llvm::cl::opt<bool> DisableLoopExtraction(
     "disable-loop-extraction",
+    cl::cat(MiscDebuggerOptions),
     cl::desc("Don't extract loops when searching for miscompilations"),
     cl::init(false));
 static llvm::cl::opt<bool> DisableBlockExtraction(
     "disable-block-extraction",
+    cl::cat(MiscDebuggerOptions),
     cl::desc("Don't extract blocks when searching for miscompilations"),
     cl::init(false));
 
 class ReduceMiscompilingPasses : public ListReducer<std::string> {
   BugDriver &BD;
 
 public:
   ReduceMiscompilingPasses(BugDriver &bd) : BD(bd) {}

tools/bugpoint/OptimizerDriver.cpp

 using namespace llvm;
 
 #define DEBUG_TYPE "bugpoint"
 
 namespace llvm {
 extern cl::opt<std::string> OutputPrefix;
 }
 
+extern cl::OptionCategory ExecutionOptions;
+
 static cl::opt<bool> PreserveBitcodeUseListOrder(
     "preserve-bc-uselistorder",
+    cl::cat(ExecutionOptions),
     cl::desc("Preserve use-list order when writing LLVM bitcode."),
     cl::init(true), cl::Hidden);
 
 static cl::opt<std::string>
     OptCmd("opt-command", cl::init(""),
+           cl::cat(ExecutionOptions),
            cl::desc("Path to opt. (default: search path "
                     "for 'opt'.)"));
 
 /// This writes the current "Program" to the named bitcode file.  If an error
 /// occurs, true is returned.
 static bool writeProgramToFileAux(ToolOutputFile &Out, const Module &M) {
   WriteBitcodeToFile(M, Out.os(), PreserveBitcodeUseListOrder);
   Out.os().close();
void BugDriver::EmitProgressBitcode(const Module &M, const std::string &ID,
   for (unsigned i = 0, e = PluginLoader::getNumPlugins(); i != e; ++i) {
     outs() << " -load " << PluginLoader::getPlugin(i);
   }
   outs() << " " << getPassesString(PassesToRun) << "\n";
 }
 
 cl::opt<bool> SilencePasses(
     "silence-passes",
+    cl::cat(ExecutionOptions),
     cl::desc("Suppress output of running passes (both stdout and stderr)"));
 
 static cl::list<std::string> OptArgs("opt-args", cl::Positional,
+                                     cl::cat(ExecutionOptions),
                                      cl::desc("<opt arguments>..."),
                                      cl::ZeroOrMore, cl::PositionalEatsArgs);
 
 /// runPasses - Run the specified passes on Program, outputting a bitcode file
 /// and writing the filename into OutputFile if successful.  If the
 /// optimizations fail for some reason (optimizer crashes), return true,
 /// otherwise return false.  If DeleteOutput is set to true, the bitcode is
 /// deleted on success, and the filename string is undefined.  This prints to

tools/bugpoint/ToolRunner.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <fstream>
 #include <sstream>
 #include <utility>
 using namespace llvm;
 
 #define DEBUG_TYPE "toolrunner"
 
+extern cl::OptionCategory ExecutionOptions;
+
 namespace llvm {
 cl::opt<bool> SaveTemps("save-temps", cl::init(false),
+                        cl::cat(ExecutionOptions),
                         cl::desc("Save temporary files"));
 }
 
 namespace {
 cl::opt<std::string>
     RemoteClient("remote-client",
+                 cl::cat(ExecutionOptions),
                  cl::desc("Remote execution client (rsh/ssh)"));
 
 cl::opt<std::string> RemoteHost("remote-host",
+                                cl::cat(ExecutionOptions),
                                 cl::desc("Remote execution (rsh/ssh) host"));
 
 cl::opt<std::string> RemotePort("remote-port",
+                                cl::cat(ExecutionOptions),
                                 cl::desc("Remote execution (rsh/ssh) port"));
 
 cl::opt<std::string> RemoteUser("remote-user",
+                                cl::cat(ExecutionOptions),
                                 cl::desc("Remote execution (rsh/ssh) user id"));
 
 cl::opt<std::string>
     RemoteExtra("remote-extra-options",
+                cl::cat(ExecutionOptions),
                 cl::desc("Remote execution (rsh/ssh) extra options"));
 }
 
 /// RunProgramWithTimeout - This function provides an alternate interface
 /// to the sys::Program::ExecuteAndWait interface.
 /// @see sys::Program::ExecuteAndWait
 static int RunProgramWithTimeout(StringRef ProgramPath, const char **Args,
                                  StringRef StdInFile, StringRef StdOutFile,

tools/bugpoint/bugpoint.cpp

 #include "llvm/Transforms/IPO/AlwaysInliner.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 
 // Enable this macro to debug bugpoint itself.
 //#define DEBUG_BUGPOINT 1
 
 using namespace llvm;
 
+cl::OptionCategory BugpointOptions("Bugpoint Options", "");
 static cl::opt<bool>
-    FindBugs("find-bugs", cl::desc("Run many different optimization sequences "
-                                   "on program to find bugs"),
+    FindBugs("find-bugs", cl::cat(BugpointOptions),
+             cl::desc("Run many different optimization sequences "
              cl::init(false));
 
 static cl::list<std::string>
     InputFilenames(cl::Positional, cl::OneOrMore,
+                   cl::cat(BugpointOptions),
                    cl::desc("<input llvm ll/bc files>"));
 
 static cl::opt<unsigned> TimeoutValue(
-    "timeout", cl::init(300), cl::value_desc("seconds"),
+    "timeout", cl::cat(BugpointOptions),
+    cl::init(300), cl::value_desc("seconds"),
     cl::desc("Number of seconds program is allowed to run before it "
              "is killed (default is 300s), 0 disables timeout"));
 
 static cl::opt<int> MemoryLimit(
-    "mlimit", cl::init(-1), cl::value_desc("MBytes"),
+    "mlimit", cl::cat(BugpointOptions),
+    cl::init(-1), cl::value_desc("MBytes"),
     cl::desc("Maximum amount of memory to use. 0 disables check. Defaults to "
              "400MB (800MB under valgrind, 0 with sanitizers)."));
 
 static cl::opt<bool>
     UseValgrind("enable-valgrind",
+                cl::cat(BugpointOptions),
                 cl::desc("Run optimizations through valgrind"));
 
 // The AnalysesList is automatically populated with registered Passes by the
 // PassNameParser.
 //
 static cl::list<const PassInfo *, bool, PassNameParser>
     PassList(cl::desc("Passes available:"), cl::ZeroOrMore);
 
 static cl::opt<bool>
-    StandardLinkOpts("std-link-opts",
+    StandardLinkOpts("std-link-opts", cl::cat(BugpointOptions),
                      cl::desc("Include the standard link time optimizations"));
 
 static cl::opt<bool>
-    OptLevelO1("O1", cl::desc("Optimization level 1. Identical to 'opt -O1'"));
+    OptLevelO1("O1", cl::cat(BugpointOptions),
+               cl::desc("Optimization level 1. Identical to 'opt -O1'"));
 
 static cl::opt<bool>
-    OptLevelO2("O2", cl::desc("Optimization level 2. Identical to 'opt -O2'"));
+    OptLevelO2("O2", cl::cat(BugpointOptions),
+               cl::desc("Optimization level 2. Identical to 'opt -O2'"));
 
 static cl::opt<bool> OptLevelOs(
-    "Os",
+    "Os", cl::cat(BugpointOptions),
     cl::desc(
         "Like -O2 with extra optimizations for size. Similar to clang -Os"));
 
 static cl::opt<bool>
-    OptLevelO3("O3", cl::desc("Optimization level 3. Identical to 'opt -O3'"));
+    OptLevelO3("O3", cl::cat(BugpointOptions),
+               cl::desc("Optimization level 3. Identical to 'opt -O3'"));
 
 static cl::opt<std::string>
-    OverrideTriple("mtriple", cl::desc("Override target triple for module"));
+    OverrideTriple("mtriple", cl::cat(BugpointOptions),
+                   cl::desc("Override target triple for module"));
 
 /// BugpointIsInterrupted - Set to true when the user presses ctrl-c.
 bool llvm::BugpointIsInterrupted = false;
 
 #ifndef DEBUG_BUGPOINT
 static void BugpointInterruptFunction() { BugpointIsInterrupted = true; }
 #endif