[llvm-objdump] - Show aliases in -help.

[grimar]

Summary

Currently llvm-objdump is inconsistent.

When -help is specified it shows no aliases except two.
Aliases are shown with -help-hidden though.
GNU objdump also prints them by default.

This patch does a change to always show all aliases when -help is given.

I included no test case because seems there is no good way to test it:

• Does not seem we want to test the whole -help output. It seems an overkill.
• Does not seem we want to test only lines with the aliases, because it is brittle

and would be easy to forget to update such test case.

• In LLD we test a single option:

https://github.com/llvm-mirror/lld/blob/master/test/ELF/help.s
IMO it is not very useful actually. It effectively tests that we print at least one alias.
It does not save from any mistakes.

[ruiu]

LGTM

I think this is a good change, and I agree with you that we don't need to test each alias.

Speaking of the --help message, I found there are other weird stuff there. The options in the --help message are categorized as "Color Options", "General options" and "Generic Options". There is only one option under the "Color Options" category, which is --color. Most options are under "General Options". --help and --version are under "Generic Options". Frankly, these categories doesn't make sense at all to me. (what's the difference between "Generic" and "General"?)

Maybe we should remove the categories and display all options just asciibetically.

[grimar]

In D56853#1361899, @ruiu wrote:

LGTM

I think this is a good change, and I agree with you that we don't need to test each alias.

Speaking of the --help message, I found there are other weird stuff there. The options in the --help message are categorized as "Color Options", "General options" and "Generic Options". There is only one option under the "Color Options" category, which is --color. Most options are under "General Options". --help and --version are under "Generic Options". Frankly, these categories doesn't make sense at all to me. (what's the difference between "Generic" and "General"?)

Maybe we should remove the categories and display all options just asciibetically.

Yeah, I also noticed that. I *guess* it somehow can be related with GNU objdump which seems to divide options into two groups (required and optional):

At least one of the following switches must be given:

-a, --archive-headers    Display archive header information
-f, --file-headers       Display the contents of the overall file header
-p, --private-headers    Display object format specific file header contents

....

The following switches are optional:

-b, --target=BFDNAME           Specify the target object format as BFDNAME
-m, --architecture=MACHINE     Specify the target architecture as MACHINE
-j, --section=NAME             Only display information for section NAME
-M, --disassembler-options=OPT Pass text OPT on to the disassembler

....

Perhaps the intention was to do something like that, but something went wrong. I agree that just listing them asciibetically would be better than what is done now.
I'll try to suggest a patch on the next week if nobody do that earlier.

[jhenderson]

Thanks for working on this! I agree that testing for this is somewhat tricky, and I don't have any suggestions for how to improve it.

I have a feeling that the option categorisation is more general to LLVM, rather than specifically llvm-objdump, from memory, but I haven't dug into this recently. IIRC, the "Generic" options category is not provided by llvm-objdump at all, and is instead somewhere in the CommandLine library.

[grimar]

In D56853#1362809, @jhenderson wrote:

I have a feeling that the option categorisation is more general to LLVM, rather than specifically llvm-objdump, from memory, but I haven't dug into this recently. IIRC, the "Generic" options category is not provided by llvm-objdump at all, and is instead somewhere in the CommandLine library.

Yes. And the current behavior seems intentional (it is documented): to print command line options as an uncategorized list, -help-list can be used (https://llvm.org/docs/CommandLine.html#grouping-options-into-categories).
FTR, LLD, llvm-objcopy and few other tools use a different approach based on llvm::opt::OptTable for parsing options and we have no strange categories there.

Seems if we want to change this for llvm-objdump we probably might want to reimplement it in the same way I guess.

tools/llvm-objdump/llvm-objdump.cpp

 
 using namespace llvm;
 using namespace object;
 
 cl::opt<bool>
     llvm::AllHeaders("all-headers",
                      cl::desc("Display all available header information"));
 static cl::alias AllHeadersShort("x", cl::desc("Alias for --all-headers"),
-                                 cl::aliasopt(AllHeaders));
+                                 cl::NotHidden, cl::aliasopt(AllHeaders));
 
 static cl::list<std::string>
 InputFilenames(cl::Positional, cl::desc("<input object files>"),cl::ZeroOrMore);
 
 cl::opt<bool>
 llvm::Disassemble("disassemble",
   cl::desc("Display assembler mnemonics for the machine instructions"));
-static cl::alias
-Disassembled("d", cl::desc("Alias for --disassemble"),
-             cl::aliasopt(Disassemble));
+static cl::alias Disassembled("d", cl::desc("Alias for --disassemble"),
+                              cl::NotHidden, cl::aliasopt(Disassemble));
 
 cl::opt<bool>
 llvm::DisassembleAll("disassemble-all",
   cl::desc("Display assembler mnemonics for the machine instructions"));
-static cl::alias
-DisassembleAlld("D", cl::desc("Alias for --disassemble-all"),
-             cl::aliasopt(DisassembleAll));
+static cl::alias DisassembleAlld("D", cl::desc("Alias for --disassemble-all"),
+                                 cl::NotHidden, cl::aliasopt(DisassembleAll));
 
 cl::opt<bool> llvm::Demangle("demangle", cl::desc("Demangle symbols names"),
                              cl::init(false));
 
 static cl::alias DemangleShort("C", cl::desc("Alias for --demangle"),
-                               cl::aliasopt(llvm::Demangle));
+                               cl::NotHidden, cl::aliasopt(llvm::Demangle));
 
 static cl::list<std::string>
 DisassembleFunctions("df",
                      cl::CommaSeparated,
                      cl::desc("List of functions to disassemble"));
 static StringSet<> DisasmFuncsSet;
 
 cl::opt<bool>
 llvm::Relocations("reloc",
                   cl::desc("Display the relocation entries in the file"));
 static cl::alias RelocationsShort("r", cl::desc("Alias for --reloc"),
                                   cl::NotHidden,
                                   cl::aliasopt(llvm::Relocations));
 
 cl::opt<bool>
 llvm::DynamicRelocations("dynamic-reloc",
   cl::desc("Display the dynamic relocation entries in the file"));
-static cl::alias
-DynamicRelocationsd("R", cl::desc("Alias for --dynamic-reloc"),
+static cl::alias DynamicRelocationsd("R", cl::desc("Alias for --dynamic-reloc"),
+                                     cl::NotHidden,
                                      cl::aliasopt(DynamicRelocations));
 
 cl::opt<bool>
     llvm::SectionContents("full-contents",
                           cl::desc("Display the content of each section"));
 static cl::alias SectionContentsShort("s",
                                       cl::desc("Alias for --full-contents"),
+                                      cl::NotHidden,
                                       cl::aliasopt(SectionContents));
 
 cl::opt<bool> llvm::SymbolTable("syms", cl::desc("Display the symbol table"));
 static cl::alias SymbolTableShort("t", cl::desc("Alias for --syms"),
                                   cl::NotHidden,
                                   cl::aliasopt(llvm::SymbolTable));
 
 cl::opt<bool>

 llvm::WeakBind("weak-bind", cl::desc("Display mach-o weak binding info"));
 
 cl::opt<bool>
 llvm::RawClangAST("raw-clang-ast",
     cl::desc("Dump the raw binary contents of the clang AST section"));
 
 static cl::opt<bool>
 MachOOpt("macho", cl::desc("Use MachO specific object file parser"));
-static cl::alias
-MachOm("m", cl::desc("Alias for --macho"), cl::aliasopt(MachOOpt));
+static cl::alias MachOm("m", cl::desc("Alias for --macho"), cl::NotHidden,
+                        cl::aliasopt(MachOOpt));
 
 cl::opt<std::string>
 llvm::TripleName("triple", cl::desc("Target triple to disassemble for, "
                                     "see -version for available targets"));
 
 cl::opt<std::string>
 llvm::MCPU("mcpu",
      cl::desc("Target a specific cpu type (-mcpu=help for details)"),
      cl::value_desc("cpu-name"),
      cl::init(""));
 
 cl::opt<std::string>
 llvm::ArchName("arch-name", cl::desc("Target arch to disassemble for, "
                                 "see -version for available targets"));
 
 cl::opt<bool>
 llvm::SectionHeaders("section-headers", cl::desc("Display summaries of the "
                                                  "headers for each section."));
-static cl::alias
-SectionHeadersShort("headers", cl::desc("Alias for --section-headers"),
+static cl::alias SectionHeadersShort("headers",
+                                     cl::desc("Alias for --section-headers"),
+                                     cl::NotHidden,
                                      cl::aliasopt(SectionHeaders));
-static cl::alias
-SectionHeadersShorter("h", cl::desc("Alias for --section-headers"),
+static cl::alias SectionHeadersShorter("h",
+                                       cl::desc("Alias for --section-headers"),
+                                       cl::NotHidden,
                                        cl::aliasopt(SectionHeaders));
 
 cl::list<std::string>
 llvm::FilterSections("section", cl::desc("Operate on the specified sections only. "
                                          "With -macho dump segment,section"));
-cl::alias
-static FilterSectionsj("j", cl::desc("Alias for --section"),
+cl::alias static FilterSectionsj("j", cl::desc("Alias for --section"),
+                                 cl::NotHidden,
                                  cl::aliasopt(llvm::FilterSections));
 
 cl::list<std::string>
 llvm::MAttrs("mattr",
   cl::CommaSeparated,
   cl::desc("Target specific attributes"),
   cl::value_desc("a1,+a2,-a3,..."));
 
 cl::opt<bool>
 llvm::NoShowRawInsn("no-show-raw-insn", cl::desc("When disassembling "
                                                  "instructions, do not print "
                                                  "the instruction bytes."));
 cl::opt<bool>
 llvm::NoLeadingAddr("no-leading-addr", cl::desc("Print no leading address"));
 
 cl::opt<bool>
 llvm::UnwindInfo("unwind-info", cl::desc("Display unwind information"));
 
-static cl::alias
-UnwindInfoShort("u", cl::desc("Alias for --unwind-info"),
-                cl::aliasopt(UnwindInfo));
+static cl::alias UnwindInfoShort("u", cl::desc("Alias for --unwind-info"),
+                                 cl::NotHidden, cl::aliasopt(UnwindInfo));
 
 cl::opt<bool>
 llvm::PrivateHeaders("private-headers",
                      cl::desc("Display format specific file headers"));
 
 cl::opt<bool>
 llvm::FirstPrivateHeader("private-header",
                          cl::desc("Display only the first format specific file "
                                   "header"));
 
-static cl::alias
-PrivateHeadersShort("p", cl::desc("Alias for --private-headers"),
+static cl::alias PrivateHeadersShort("p",
+                                     cl::desc("Alias for --private-headers"),
+                                     cl::NotHidden,
                                      cl::aliasopt(PrivateHeaders));
 
 cl::opt<bool> llvm::FileHeaders(
     "file-headers",
     cl::desc("Display the contents of the overall file header"));
 
 static cl::alias FileHeadersShort("f", cl::desc("Alias for --file-headers"),
-                                  cl::aliasopt(FileHeaders));
+                                  cl::NotHidden, cl::aliasopt(FileHeaders));
 
 cl::opt<bool>
     llvm::ArchiveHeaders("archive-headers",
                          cl::desc("Display archive header information"));
 
-cl::alias
-ArchiveHeadersShort("a", cl::desc("Alias for --archive-headers"),
-                    cl::aliasopt(ArchiveHeaders));
+cl::alias ArchiveHeadersShort("a", cl::desc("Alias for --archive-headers"),
+                              cl::NotHidden, cl::aliasopt(ArchiveHeaders));
 
 cl::opt<bool>
     llvm::PrintImmHex("print-imm-hex",
                       cl::desc("Use hex format for immediate values"));
 
 cl::opt<bool> PrintFaultMaps("fault-map-section",
                              cl::desc("Display contents of faultmap section"));
 
 cl::opt<DIDumpType> llvm::DwarfDumpType(
     "dwarf", cl::init(DIDT_Null), cl::desc("Dump of dwarf debug sections:"),
     cl::values(clEnumValN(DIDT_DebugFrame, "frames", ".debug_frame")));
 
 cl::opt<bool> PrintSource(
     "source",
     cl::desc(
         "Display source inlined with disassembly. Implies disassemble object"));
 
-cl::alias PrintSourceShort("S", cl::desc("Alias for -source"),
+cl::alias PrintSourceShort("S", cl::desc("Alias for -source"), cl::NotHidden,
                            cl::aliasopt(PrintSource));
 
 cl::opt<bool> PrintLines("line-numbers",
                          cl::desc("Display source line numbers with "
                                   "disassembly. Implies disassemble object"));
 
 cl::alias PrintLinesShort("l", cl::desc("Alias for -line-numbers"),
-                          cl::aliasopt(PrintLines));
+                          cl::NotHidden, cl::aliasopt(PrintLines));
 
 cl::opt<unsigned long long>
     StartAddress("start-address", cl::desc("Disassemble beginning at address"),
                  cl::value_desc("address"), cl::init(0));
 cl::opt<unsigned long long>
     StopAddress("stop-address",
                 cl::desc("Stop disassembly at address"),
                 cl::value_desc("address"), cl::init(UINT64_MAX));
 
 cl::opt<bool> DisassembleZeroes(
                 "disassemble-zeroes",
                 cl::desc("Do not skip blocks of zeroes when disassembling"));
 cl::alias DisassembleZeroesShort("z",
                                  cl::desc("Alias for --disassemble-zeroes"),
+                                 cl::NotHidden,
                                  cl::aliasopt(DisassembleZeroes));
 
 static StringRef ToolName;
 
 typedef std::vector<std::tuple<uint64_t, StringRef, uint8_t>> SectionSymbolsTy;
 
 namespace {
 typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;