[llvm-nm] Help option output should be consistent with the command guide

[gbreynoo]

Summary

The nm command guide shows the short options used as aliases but these are not found in the help text unless --show-hidden is used, other tools show aliases with --help. This change fixes the help output to be consistent with the command guide.

[keith]

It's too bad this format doesn't look like python's where it shows it inline:

-q, --quiet           Suppress no error output

For reference for other reviewers here's the diff in -help with this change:

--- /tmp/before.log	2021-05-07 13:46:23.154086836 -0700
+++ /tmp/after.log	2021-05-07 13:47:01.999269513 -0700
@@ -12,8 +12,16 @@
 
 llvm-nm Options:
 
+  -A                 - Alias for --print-file-name
   -B                 - Alias for --format=bsd
+  -C                 - Alias for --demangle
+  -D                 - Alias for --dynamic
+  -M                 - Alias for --print-armap
   -P                 - Alias for --format=posix
+  -S                 - Alias for --print-size
+  -U                 - Alias for --defined-only
+  -W                 - Alias for --no-weak
+  -a                 - Alias for --debug-syms
   --add-dyldinfo     - Add symbols from the dyldinfo not already in the symbol table, Mach-O only
   --add-inlinedinfo  - Add symbols from the inlined libraries, TBD(Mach-O) only
   --arch=<string>    - architecture(s) from a Mach-O file to dump
@@ -23,25 +31,32 @@
   --dyldinfo-only    - Show only symbols from the dyldinfo, Mach-O only
   --dynamic          - Display the dynamic symbols instead of normal symbols.
   --extern-only      - Show only external symbols
+  -f                 - Alias for --format
   --format=<value>   - Specify output format
     =bsd             -   BSD format
     =sysv            -   System V format
     =posix           -   POSIX.2 format
     =darwin          -   Darwin -m format
     =just-symbols    -   just symbol names
+  -g                 - Alias for --extern-only
+  -j                 - Alias for --format-just-symbols
   --just-symbol-name - Alias for --format=just-symbols
   -m                 - Alias for --format=darwin
+  -n                 - Alias for --numeric-sort
   --no-demangle      - Don't demangle symbol names
   --no-dyldinfo      - Don't add any symbols from the dyldinfo, Mach-O only
   --no-llvm-bc       - Disable LLVM bitcode reader
   --no-sort          - Show symbols in order encountered
   --no-weak          - Show only non-weak symbols
   --numeric-sort     - Sort symbols by address
+  -o                 - Alias for --print-file-name
+  -p                 - Alias for --no-sort
   --portability      - Alias for --format=posix
   --print-armap      - Print the archive map
   --print-file-name  - Precede each symbol with the object file it came from
   --print-size       - Show symbol size as well as address
   --quiet            - Suppress 'no symbols' diagnostic
+  -r                 - Alias for --reverse-sort
   --radix=<value>    - Radix (o/d/x) for printing symbol Values
     =d               -   decimal
     =o               -   octal
@@ -49,7 +64,11 @@
   --reverse-sort     - Sort in reverse order
   --size-sort        - Sort symbols by size
   --special-syms     - Do not filter special symbols from the output
+  -t                 - Alias for --radix
+  -u                 - Alias for --undefined-only
   --undefined-only   - Show only undefined symbols
+  -v                 - Alias for --numeric-sort
+  --without-aliases  - Exclude aliases from output
   -x                 - Print symbol entry in hex, Mach-O only
 
 Pass @FILE as argument to read options from FILE.

[MaskRay]

Looks great!

llvm/tools/llvm-nm/llvm-nm.cpp

cl::opt<OutputFormatTy> OutputFormat(
     "format", cl::desc("Specify output format"),
     cl::values(clEnumVal(bsd, "BSD format"), clEnumVal(sysv, "System V format"),
                clEnumVal(posix, "POSIX.2 format"),
                clEnumVal(darwin, "Darwin -m format"),
                cl::OptionEnumValue{"just-symbols", int(just_symbols),
                                    "just symbol names"}),
     cl::init(bsd), cl::cat(NMCat));
 cl::alias OutputFormat2("f", cl::desc("Alias for --format"),
-                        cl::aliasopt(OutputFormat));
+                        cl::aliasopt(OutputFormat), cl::NotHidden);
 
 cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<input files>"),
                                      cl::ZeroOrMore);
 
 cl::opt<bool> UndefinedOnly("undefined-only",
                             cl::desc("Show only undefined symbols"),
                             cl::cat(NMCat));
 cl::alias UndefinedOnly2("u", cl::desc("Alias for --undefined-only"),
-                         cl::aliasopt(UndefinedOnly), cl::Grouping);
+                         cl::aliasopt(UndefinedOnly), cl::Grouping,
+                         cl::NotHidden);
 
 cl::opt<bool> DynamicSyms("dynamic",
                           cl::desc("Display the dynamic symbols instead "
                                    "of normal symbols."),
                           cl::cat(NMCat));
 cl::alias DynamicSyms2("D", cl::desc("Alias for --dynamic"),
-                       cl::aliasopt(DynamicSyms), cl::Grouping);
+                       cl::aliasopt(DynamicSyms), cl::Grouping, cl::NotHidden);
 
 cl::opt<bool> DefinedOnly("defined-only", cl::desc("Show only defined symbols"),
                           cl::cat(NMCat));
 cl::alias DefinedOnly2("U", cl::desc("Alias for --defined-only"),
-                       cl::aliasopt(DefinedOnly), cl::Grouping);
+                       cl::aliasopt(DefinedOnly), cl::Grouping, cl::NotHidden);
 
 cl::opt<bool> ExternalOnly("extern-only",
                            cl::desc("Show only external symbols"),
                            cl::ZeroOrMore, cl::cat(NMCat));
 cl::alias ExternalOnly2("g", cl::desc("Alias for --extern-only"),
                         cl::aliasopt(ExternalOnly), cl::Grouping,
-                        cl::ZeroOrMore);
+                        cl::ZeroOrMore, cl::NotHidden);
 
 cl::opt<bool> NoWeakSymbols("no-weak", cl::desc("Show only non-weak symbols"),
                             cl::cat(NMCat));
 cl::alias NoWeakSymbols2("W", cl::desc("Alias for --no-weak"),
-                         cl::aliasopt(NoWeakSymbols), cl::Grouping);
+                         cl::aliasopt(NoWeakSymbols), cl::Grouping,
+                         cl::NotHidden);
 
 cl::opt<bool> BSDFormat("B", cl::desc("Alias for --format=bsd"), cl::Grouping,
                         cl::cat(NMCat));
 cl::opt<bool> POSIXFormat("P", cl::desc("Alias for --format=posix"),
                           cl::Grouping, cl::cat(NMCat));
 cl::alias Portability("portability", cl::desc("Alias for --format=posix"),
                       cl::aliasopt(POSIXFormat), cl::NotHidden);
 cl::opt<bool> DarwinFormat("m", cl::desc("Alias for --format=darwin"),
-                           cl::Grouping, cl::cat(NMCat));
+                           cl::Grouping, cl::cat(NMCat), cl::NotHidden);
 
 static cl::list<std::string>
     ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"),
               cl::ZeroOrMore, cl::cat(NMCat));
 bool ArchAll = false;
 
 cl::opt<bool> PrintFileName(
     "print-file-name",
     cl::desc("Precede each symbol with the object file it came from"),
     cl::cat(NMCat));
 
 cl::alias PrintFileNameA("A", cl::desc("Alias for --print-file-name"),
-                         cl::aliasopt(PrintFileName), cl::Grouping);
+                         cl::aliasopt(PrintFileName), cl::Grouping,
+                         cl::NotHidden);
 cl::alias PrintFileNameo("o", cl::desc("Alias for --print-file-name"),
-                         cl::aliasopt(PrintFileName), cl::Grouping);
+                         cl::aliasopt(PrintFileName), cl::Grouping,
+                         cl::NotHidden);
 
 cl::opt<bool> Quiet("quiet", cl::desc("Suppress 'no symbols' diagnostic"),
                     cl::cat(NMCat));
 
 cl::opt<bool> DebugSyms("debug-syms",
                         cl::desc("Show all symbols, even debugger only"),
                         cl::cat(NMCat));
 cl::alias DebugSymsa("a", cl::desc("Alias for --debug-syms"),
-                     cl::aliasopt(DebugSyms), cl::Grouping);
+                     cl::aliasopt(DebugSyms), cl::Grouping, cl::NotHidden);
 
 cl::opt<bool> NumericSort("numeric-sort", cl::desc("Sort symbols by address"),
                           cl::cat(NMCat));
 cl::alias NumericSortn("n", cl::desc("Alias for --numeric-sort"),
-                       cl::aliasopt(NumericSort), cl::Grouping);
+                       cl::aliasopt(NumericSort), cl::Grouping, cl::NotHidden);
 cl::alias NumericSortv("v", cl::desc("Alias for --numeric-sort"),
-                       cl::aliasopt(NumericSort), cl::Grouping);
+                       cl::aliasopt(NumericSort), cl::Grouping, cl::NotHidden);
 
 cl::opt<bool> NoSort("no-sort", cl::desc("Show symbols in order encountered"),
                      cl::cat(NMCat));
 cl::alias NoSortp("p", cl::desc("Alias for --no-sort"), cl::aliasopt(NoSort),
-                  cl::Grouping);
+                  cl::Grouping, cl::NotHidden);
 
 cl::opt<bool> Demangle("demangle", cl::ZeroOrMore,
                        cl::desc("Demangle C++ symbol names"), cl::cat(NMCat));
 cl::alias DemangleC("C", cl::desc("Alias for --demangle"),
-                    cl::aliasopt(Demangle), cl::Grouping);
+                    cl::aliasopt(Demangle), cl::Grouping, cl::NotHidden);
 cl::opt<bool> NoDemangle("no-demangle", cl::init(false), cl::ZeroOrMore,
                          cl::desc("Don't demangle symbol names"),
                          cl::cat(NMCat));
 
 cl::opt<bool> ReverseSort("reverse-sort", cl::desc("Sort in reverse order"),
                           cl::cat(NMCat));
 cl::alias ReverseSortr("r", cl::desc("Alias for --reverse-sort"),
-                       cl::aliasopt(ReverseSort), cl::Grouping);
+                       cl::aliasopt(ReverseSort), cl::Grouping, cl::NotHidden);
 
 cl::opt<bool> PrintSize("print-size",
                         cl::desc("Show symbol size as well as address"),
                         cl::cat(NMCat));
 cl::alias PrintSizeS("S", cl::desc("Alias for --print-size"),
-                     cl::aliasopt(PrintSize), cl::Grouping);
+                     cl::aliasopt(PrintSize), cl::Grouping, cl::NotHidden);
 bool MachOPrintSizeWarning = false;
 
 cl::opt<bool> SizeSort("size-sort", cl::desc("Sort symbols by size"),
                        cl::cat(NMCat));
 
 cl::opt<bool> WithoutAliases("without-aliases", cl::Hidden,
                              cl::desc("Exclude aliases from output"),
-                             cl::cat(NMCat));
+                             cl::cat(NMCat), cl::NotHidden);
 
 cl::opt<bool> ArchiveMap("print-armap", cl::desc("Print the archive map"),
                          cl::cat(NMCat));
 cl::alias ArchiveMaps("M", cl::desc("Alias for --print-armap"),
-                      cl::aliasopt(ArchiveMap), cl::Grouping);
+                      cl::aliasopt(ArchiveMap), cl::Grouping, cl::NotHidden);
 
 enum Radix { d, o, x };
 cl::opt<Radix>
     AddressRadix("radix", cl::desc("Radix (o/d/x) for printing symbol Values"),
                  cl::values(clEnumVal(d, "decimal"), clEnumVal(o, "octal"),
                             clEnumVal(x, "hexadecimal")),
                  cl::init(x), cl::cat(NMCat));
 cl::alias RadixAlias("t", cl::desc("Alias for --radix"),
-                     cl::aliasopt(AddressRadix));
+                     cl::aliasopt(AddressRadix), cl::NotHidden);
 
 cl::opt<bool> JustSymbolName("just-symbol-name",
                              cl::desc("Alias for --format=just-symbols"),
-                             cl::cat(NMCat));
+                             cl::cat(NMCat), cl::NotHidden);
 cl::alias JustSymbolNames("j", cl::desc("Alias for --format-just-symbols"),
-                          cl::aliasopt(JustSymbolName), cl::Grouping);
+                          cl::aliasopt(JustSymbolName), cl::Grouping,
+                          cl::NotHidden);
 
 cl::opt<bool>
     SpecialSyms("special-syms",
                 cl::desc("Do not filter special symbols from the output"),
                 cl::cat(NMCat));
 
 cl::list<std::string> SegSect("s", cl::multi_val(2), cl::ZeroOrMore,
                               cl::value_desc("segment section"), cl::Hidden,