Sanitize llvm-extract -help output

[serge-sans-paille]

Summary

Filter out irrelevant options

New output:

OVERVIEW: llvm extractor

USAGE: llvm-extract [options] <input bitcode file>

OPTIONS:

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-extract Options:

  --alias=<alias>     - Specify alias to extract
  --bb=<function:bb>  - Specify <function, basic block> pairs to extract
  --delete            - Delete specified Globals from Module
  -f                  - Enable binary output on terminals
  --func=<function>   - Specify function to extract
  --glob=<global>     - Specify global to extract
  -o=<filename>       - Specify output filename
  --ralias=<ralias>   - Specify alias(es) to extract using a regular expression
  --recursive         - Recursively extract all called functions
  --rfunc=<rfunction> - Specify function(s) to extract using a regular expression
  --rglob=<rglobal>   - Specify global(s) to extract using a regular expression

[serge-sans-paille]

For reference, the output before filtering (but after categorization)

OVERVIEW: llvm extractor

USAGE: llvm-extract [options] <input bitcode file>

OPTIONS:

Color Options:

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

General options:

  --atomic-counter-update-promoted                   - Do counter update using atomic fetch add  for promoted counters only
  --bounds-checking-single-trap                      - Use one trap block per function
  --cost-kind=<value>                                - Target cost kind
    =throughput                                      -   Reciprocal throughput
    =latency                                         -   Instruction latency
    =code-size                                       -   Code size
  --cvp-dont-add-nowrap-flags                        - 
  --do-counter-promotion                             - Do counter register promotion
  --enable-gvn-memdep                                - 
  --enable-load-pre                                  - 
  --enable-loop-simplifycfg-term-folding             - 
  --enable-name-compression                          - Enable name string compression
  --expensive-combines                               - Enable expensive instruction combines
  --hash-based-counter-split                         - Rename counter variable of a comdat function based on cfg hash
  --import-all-index                                 - Import all external functions in index.
  --instcombine-code-sinking                         - Enable code sinking
  --instcombine-guard-widening-window=<uint>         - How wide an instruction window to bypass looking for another guard
  --instcombine-max-num-phis=<uint>                  - Maximum number phis to handle in intptr/ptrint folding
  --instcombine-maxarray-size=<uint>                 - Maximum array size considered when doing a combine
  --instrprof-atomic-counter-update-all              - Make all profile counter updates atomic (for testing only)
  --internalize-public-api-file=<filename>           - A file containing list of symbol names to preserve
  --internalize-public-api-list=<list>               - A list of symbol names to preserve
  --iterative-counter-promotion                      - Allow counter promotion across the whole loop nest.
  --max-counter-promotions=<int>                     - Max number of allowed counter promotions
  --max-counter-promotions-per-loop=<uint>           - Max number counter promotions per loop to avoid increasing register pressure too much
  --memop-size-large=<uint>                          - Set large value thresthold in memory intrinsic size profiling. Value of 0 disables the large value profiling.
  --memop-size-range=<string>                        - Set the range of size in memory intrinsic calls to be profiled precisely, in a format of <start_val>:<end_val>
  --no-discriminators                                - Disable generation of discriminator information.
  --remarks-yaml-string-table                        - 
  --safepoint-ir-verifier-print-only                 - 
  --sample-profile-check-record-coverage=<N>         - Emit a warning if less than N% of records in the input profile are matched to the IR.
  --sample-profile-check-sample-coverage=<N>         - Emit a warning if less than N% of samples in the input profile are matched to the IR.
  --sample-profile-max-propagate-iterations=<uint>   - Maximum number of iterations to go through when propagating sample block/edge weights through the CFG.
  --speculative-counter-promotion-max-exiting=<uint> - The max number of exiting blocks of a loop to allow  speculative counter promotion
  --speculative-counter-promotion-to-loop            - When the option is false, if the target block is in a loop, the promotion will be disallowed unless the promoted counter  update can be further/iteratively promoted into an acyclic  region.
  --summary-file=<string>                            - The summary file to use for function importing.
  --time-trace-granularity=<uint>                    - Minimum time granularity (in microseconds) traced by time profiler
  --verify-region-info                               - Verify region info (time consuming)
  --vp-counters-per-site=<number>                    - The average number of profile counters allocated per value profiling site.
  --vp-static-alloc                                  - Do static counter allocation for value profiler

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-extract Options:

  --alias=<alias>                                    - Specify alias to extract
  --bb=<function:bb>                                 - Specify <function, basic block> pairs to extract
  --delete                                           - Delete specified Globals from Module
  -f                                                 - Enable binary output on terminals
  --func=<function>                                  - Specify function to extract
  --glob=<global>                                    - Specify global to extract
  -o=<filename>                                      - Specify output filename
  --ralias=<ralias>                                  - Specify alias(es) to extract using a regular expression
  --recursive                                        - Recursively extract all called functions
  --rfunc=<rfunction>                                - Specify function(s) to extract using a regular expression
  --rglob=<rglobal>                                  - Specify global(s) to extract using a regular expression

According to the callgraph, the only options reachable from main and filtered out are hidden ones related to pass debugging.

[jhenderson]

I'm not familiar at all with llvm-extract, but what you've done looks reasonable, barring one comment. Maybe worth seeing if there are others who have used/developed this tool to get a bit more confirmation.

llvm/tools/llvm-extract/llvm-extract.cpp

43

Do you need the category here on a positional argument?

[serge-sans-paille]

llvm/tools/llvm-extract/llvm-extract.cpp

43

Definitively not!

[serge-sans-paille]

remove category of positional argument

[jhenderson]

Okay, LGTM. Might be worth waiting a couple of days in case somebody with more familiarity with the tool wants to chime in.

llvm/tools/llvm-extract/llvm-extract.cpp

 #include "llvm/Support/Regex.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/SystemUtils.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Transforms/IPO.h"
 #include <memory>
 using namespace llvm;
 
-// InputFilename - The filename to read from.
-static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
-              cl::init("-"), cl::value_desc("filename"));
-
-static cl::opt<std::string>
-OutputFilename("o", cl::desc("Specify output filename"),
-               cl::value_desc("filename"), cl::init("-"));
-
-static cl::opt<bool>
-Force("f", cl::desc("Enable binary output on terminals"));
+cl::OptionCategory ExtractCat("llvm-extract Options");
 
-static cl::opt<bool>
-DeleteFn("delete", cl::desc("Delete specified Globals from Module"));
+// InputFilename - The filename to read from.
+static cl::opt<std::string> InputFilename(cl::Positional,
+                                          cl::desc("<input bitcode file>"),
+                                          cl::init("-"),
+                                          cl::value_desc("filename"),
+                                          cl::cat(ExtractCat));
+
+static cl::opt<std::string> OutputFilename("o",
+                                           cl::desc("Specify output filename"),
+                                           cl::value_desc("filename"),
+                                           cl::init("-"), cl::cat(ExtractCat));
+
+static cl::opt<bool> Force("f", cl::desc("Enable binary output on terminals"),
+                           cl::cat(ExtractCat));
+
+static cl::opt<bool> DeleteFn("delete",
+                              cl::desc("Delete specified Globals from Module"),
+                              cl::cat(ExtractCat));
 
 static cl::opt<bool>
-    Recursive("recursive",
-              cl::desc("Recursively extract all called functions"));
+    Recursive("recursive", cl::desc("Recursively extract all called functions"),
+              cl::cat(ExtractCat));
 
 // ExtractFuncs - The functions to extract from the module.
 static cl::list<std::string>
     ExtractFuncs("func", cl::desc("Specify function to extract"),
-             cl::ZeroOrMore, cl::value_desc("function"));
+                 cl::ZeroOrMore, cl::value_desc("function"),
+                 cl::cat(ExtractCat));
 
 // ExtractRegExpFuncs - The functions, matched via regular expression, to
 // extract from the module.
 static cl::list<std::string>
-ExtractRegExpFuncs("rfunc", cl::desc("Specify function(s) to extract using a "
-                                     "regular expression"),
-                   cl::ZeroOrMore, cl::value_desc("rfunction"));
+    ExtractRegExpFuncs("rfunc",
+                       cl::desc("Specify function(s) to extract using a "
+                       cl::ZeroOrMore, cl::value_desc("rfunction"),
+                       cl::cat(ExtractCat));
 
 // ExtractBlocks - The blocks to extract from the module.
-static cl::list<std::string>
-    ExtractBlocks("bb",
-                  cl::desc("Specify <function, basic block> pairs to extract"),
-                  cl::ZeroOrMore, cl::value_desc("function:bb"));
+static cl::list<std::string> ExtractBlocks(
+    "bb", cl::desc("Specify <function, basic block> pairs to extract"),
+    cl::ZeroOrMore, cl::value_desc("function:bb"), cl::cat(ExtractCat));
 
 // ExtractAlias - The alias to extract from the module.
 static cl::list<std::string>
     ExtractAliases("alias", cl::desc("Specify alias to extract"),
-               cl::ZeroOrMore, cl::value_desc("alias"));
-
+                   cl::ZeroOrMore, cl::value_desc("alias"),
+                   cl::cat(ExtractCat));
 
 // ExtractRegExpAliases - The aliases, matched via regular expression, to
 // extract from the module.
 static cl::list<std::string>
-ExtractRegExpAliases("ralias", cl::desc("Specify alias(es) to extract using a "
-                                        "regular expression"),
-                     cl::ZeroOrMore, cl::value_desc("ralias"));
+    ExtractRegExpAliases("ralias",
+                         cl::desc("Specify alias(es) to extract using a "
+                         cl::ZeroOrMore, cl::value_desc("ralias"),
+                         cl::cat(ExtractCat));
 
 // ExtractGlobals - The globals to extract from the module.
 static cl::list<std::string>
     ExtractGlobals("glob", cl::desc("Specify global to extract"),
-               cl::ZeroOrMore, cl::value_desc("global"));
+                   cl::ZeroOrMore, cl::value_desc("global"),
+                   cl::cat(ExtractCat));
 
 // ExtractRegExpGlobals - The globals, matched via regular expression, to
 // extract from the module...
 static cl::list<std::string>
-ExtractRegExpGlobals("rglob", cl::desc("Specify global(s) to extract using a "
-                                       "regular expression"),
-                     cl::ZeroOrMore, cl::value_desc("rglobal"));
+    ExtractRegExpGlobals("rglob",
+                         cl::desc("Specify global(s) to extract using a "
+                         cl::ZeroOrMore, cl::value_desc("rglobal"),
+                         cl::cat(ExtractCat));
 
-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(ExtractCat));
 
 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(ExtractCat));
 
 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(ExtractCat));
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
 
   LLVMContext Context;
+  cl::HideUnrelatedOptions(ExtractCat);
   cl::ParseCommandLineOptions(argc, argv, "llvm extractor\n");
 
   // Use lazy loading, since we only care about selected global values.
   SMDiagnostic Err;
   std::unique_ptr<Module> M = getLazyIRFileModule(InputFilename, Err, Context);
 
   if (!M.get()) {
     Err.print(argv[0], errs());