[llvm-readelf] Make llvm-readelf more compatible with GNU readelf.

[rupprecht]

Summary

This change adds a bunch of options that GNU readelf supports. There is one breaking change when invoked as llvm-readobj, and three breaking changes when invoked as llvm-readelf:

• Add --all (implies --file-header, --program-headers, etc.)
• [Breaking] -a is --all instead of --arm-attributes
• Add --file-header as an alias for --file-headers
• Replace --sections with --sections-headers, keeping --sections as an alias for it
• Add --relocs as an alias for --relocations
• Add --dynamic as an alias for --dynamic-table
• Add --segments as an alias for --program-headers
• Add --section-groups as an alias for --elf-section-groups
• Add --dyn-syms as an alias for --dyn-symbols
• Add --syms as an alias for --symbols
• Add --histogram as an alias for --elf-hash-histogram
• [Breaking] When invoked as llvm-readelf, -s is --symbols instead of --sections
• [Breaking] When invoked as llvm-readelf, -t is no longer an alias for --symbols

[MaskRay]

Add two subscribers:

@compnerd who added the -a alias to ARMAttributesShort in rL200450
@echristo who added --relocations in rL178679 and could share some background of the two tools llvm-readobj llvm-readelf and the naming of these options...

I guess there was once only llvm-readobj and it had better option names (but incompatible with GNU readelf, e.g. --dynamic-table instead of GNU --dynamic) and later llvm-readelf was born. Now for compatibility reasons we have to add these GNU aliases and the option parsing looks very messy now.

[phosek]

In the "Migrating llvm-objdump and a few other common binutils replacements away from llvm::c" thread, @silvas said:

The way I think about libOption vs cl:::opt is:

• cl::opt: use it for convenience and simplicity
• libOption: use it for when you need to be compatible with a particular command line flag format.

My understanding is that cl::opt just doesn't have the fine-grained control needed for a truly production-quality command line interface compatible with some existing tool. I think this is a matter of correctness: is it a requirement to parse the command line options in the same way as some existing program? If so, then cl::opt probably isn't flexible enough. It may get you 90% of the way there, maybe 95%, but it will probably never truly feel native to users of the tool that it is intended to be compatible with.

I agree with him and after looking at this change, I'm convinced that llvm-readobj/llvm-readelf fits firmly into the latter category. We should consider migrating them to libOption in the future, although that's independent from this change.

[jhenderson]

Wow, that's some spooky timing. I didn't realise somebody else was thinking the exact same thing as me at the time! I brought this up on the mailing list earlier today, not realising that this review existed!

Some thoughts:

1. Why not break -s for both llvm-readobj and llvm-readelf? Yes, it will cause some test churn, but I think we should seriously consider avoiding weird lingering issues like this if we can.
2. What do you think about removing -t as an alias for --symbols in llvm-readelf (and possibly llvm-readobj)? -t means --section-details in GNU readelf, so has nothing to do with symbols. Of course, llvm-readelf doesn't (currently?) support --section-details, but maybe if we're breaking the meaning of switches we should get it completely right?
3. Are we comfortable breaking the behaviour for end-users with no prior warning? In my email, I proposed a few options, including "deprecating" old switch behaviour for a release, or simply providing a new switch that can be enabled by default in downstream ports to change the meaning of incompatible switches like -s.

I agree that changing to libOption seems sensible, but out of scope for this change. I also think we need to give careful consideration to the behaviour of single-dash options, since that's a difference in behaviour between GNU and LLVM tools (see for example . It's a common issue beyond llvm-readobj though (see also https://bugs.llvm.org/show_bug.cgi?id=31679).

I haven't looked at the actual change yet, but I'll try to do that tomorrow.

[rupprecht]

In D54124#1288822, @jhenderson wrote:

Wow, that's some spooky timing.

Happy belated Halloween! :)

I didn't realise somebody else was thinking the exact same thing as me at the time! I brought this up on the mailing list earlier today, not realising that this review existed!

I'd like to keep that thread going, as there are more people reading llvm-dev than reading this patch.

Some thoughts:

1. Why not break -s for both llvm-readobj and llvm-readelf? Yes, it will cause some test churn, but I think we should seriously consider avoiding weird lingering issues like this if we can.

I'm unsure if that's allowed given how long the tool has existed. But I'm happy to do that if others agree it's a good idea.
As a measurement, I ran ninja check-all with -s removed, and ~450 tests broke. (Keep in mind I can't run arm/windows/etc. tests on my machine, so the real number is higher).

1. What do you think about removing -t as an alias for --symbols in llvm-readelf (and possibly llvm-readobj)? -t means --section-details in GNU readelf, so has nothing to do with symbols. Of course, llvm-readelf doesn't (currently?) support --section-details, but maybe if we're breaking the meaning of switches we should get it completely right?

Done -- looks like lld tests were the only user of this; changed those in rL346260.

1. Are we comfortable breaking the behaviour for end-users with no prior warning? In my email, I proposed a few options, including "deprecating" old switch behaviour for a release, or simply providing a new switch that can be enabled by default in downstream ports to change the meaning of incompatible switches like -s.

For llvm-readelf, I am comfortable, since it seems like this is the right behavior. Maybe it would be worth putting in release notes though.
I'm also fine doing it for llvm-readobj with some support.

[rupprecht]

• Hide -t as an alias for --symbols in readelf mode

[rupprecht]

• Only expose compatibility args (e.g. --relocs for --relocations) in readelf mode

[MaskRay]

tools/llvm-readobj/llvm-readobj.cpp

597 ↗

(On Diff #172848)

How about just meaning --symbols in readelf.

len(--symbols) < len(something else) :)

649 ↗

(On Diff #172848)

if (sys::path::stem(argv[0]).contains("readelf")) {

[MaskRay]

tools/llvm-readobj/llvm-readobj.cpp

614 ↗

(On Diff #172848)

It seems NotHidden can be made inline:

static cl::alias SymbolsShort("s", cl::desc("Alias for --symbols"), cl::aliasopt(opts::Symbols), cl::NotHidden);

[jhenderson]

test/tools/llvm-readobj/readelf-s-alias.test

4–5 ↗

(On Diff #172848)

Since -s should be an alias for --sections, maybe it's worth piping the -s output to a file and then comparing the output against --sections output.

Similar comment below for --symbols.

I assume we have sufficient separate testing for --symbols and --sections, so we can rely on those to show that we dump sections and symbols output correctly with the long-form switches. If we don't, we should add them.

tools/llvm-readobj/llvm-readobj.cpp

616 ↗

(On Diff #172848)

I don't see any harm in these aliases being applicable for both llvm-readobj and llvm-readelf, if they're hidden.

[jhenderson]

Please also add the following aliases:

• --syms is also a GNU readelf option as an alias for --symbols.
• --dyn-syms is the GNU readelf version of --dyn-symbols.
• --histogram is the GNU readelf long-form of -I/--elf-hash-histogram.

I think those are the various missing aliases for supported features, on top of the ones you're proposing adding.

tools/llvm-readobj/llvm-readobj.cpp

57 ↗

(On Diff #172848)

Missing comma between --version-info and --unwind. Also --histogram isn't a thing in llvm-readelf, as far as I can tell (but you should probably add it in this patch).

617–619 ↗

(On Diff #172848)

I actually think --section-headers is clearer than --sections...

[rupprecht]

• Clean up aliases/tests

[rupprecht]

test/tools/llvm-readobj/readelf-s-alias.test

4–5 ↗

(On Diff #172848)

Since -s should be an alias for --sections, maybe it's worth piping the -s output to a file and then comparing the output against --sections output.

Similar comment below for --symbols.

Sorry, I don't understand this comment. This test is already running through FileCheck to make sure that -s and --sections both look like section output (for readobj) and similar for --symbols. Piping to a file and then comparing both files seems like it should pass, but is not really a targeted test -- the error would be "files differ" instead of "'Sections [' not found".

I assume we have sufficient separate testing for --symbols and --sections, so we can rely on those to show that we dump sections and symbols output correctly with the long-form switches. If we don't, we should add them.

The tests use short symbols by default. I flipped it so by default we use --symbols and --sections, with just a quick test that the aliases work.

[jhenderson]

test/tools/llvm-readobj/readelf-s-alias.test

4–5 ↗

(On Diff #172848)

I would say that we want -s and --sections/--symbols to be identical output. Technically, all this test does is show that -s/--sections/--symbols produces sections/symbols output. The test would actually pass if -s did both, which clearly isn't the intent of the test.

We don't need to show that --sections/--symbols produces sections/symbols output in this test. There's already a dedicated test for that. If you want to show that -s is truly an alias, then the whole output needs to be identical, and therefore "files differ" is actually the appropriate failure.

The main --sections/--symbols tests can test that -s prints sections/symbols output as well, if desired.

test/tools/llvm-readobj/symbols.test

13 ↗

(On Diff #173024)

Maybe worth doing "llvm-readelf -s" here too

tools/llvm-readobj/llvm-readobj.cpp

68 ↗

(On Diff #173024)

These comments should probably mention all of the public aliases, not just one long and one short.

82 ↗

(On Diff #173024)

This should be the "main" option, in my opinion, with the other two as aliases. Also, the help text for it should be "Display all section headers." since it doesn't display section contents.

126 ↗

(On Diff #173024)

Maybe SymbolsGNU would be clearer as to why this exists? Ditto dyn-syms below.

618–619 ↗

(On Diff #173024)

and -> as
Missing trailing full stop.

57 ↗

(On Diff #172848)

--sections -> --section-headers
--histogram -> --elf-hash-histogram

--sections to me implies section headers and section contents, which isn't the case.

[rupprecht]

• Renaming/removing unnecessary externs/more test cases/other comments

[jhenderson]

Okay, from my point of view, LGTM (with a nit). However, we should probably get some more buy-in on the RFC before breaking people's builds etc, so you might want to hold off on the commit for now.

Any thoughts on how to drum up some more interest?

test/tools/llvm-readobj/symbols.test

14–15 ↗

(On Diff #173206)

Nit: for consistency with the other filenames in this set of cases, maybe use %t.s, if you don't think it's too confusing with assembly?

[MaskRay]

In the description.

Add --sections-headers as an alias for --sections: --section-headers is now the canonical option name (I still have trouble understanding the plural form though, see my comment above) but --sections is an alias.

tools/llvm-readobj/llvm-readobj.cpp

82 ↗

(On Diff #173024)

What's your opinion on the plural form -file-headers? I think I'm lost why in readelf, -file-header is singular while others are plural. Usually there are not more than one program headers, section headers, etc.

[rupprecht]

Updated the description, thanks for pointing that out.

tools/llvm-readobj/llvm-readobj.cpp

82 ↗

(On Diff #173024)

My guess: most file formats only have one file header (e.g. ELF just has the ELF header), so singular makes sense, e.g. vs section headers where there is one section header per section.

Looking at COFFDumper::printFileHeaders() though, there can be multiple file headers (ImageFileHeader, ImageOptionalHeader, DOSHeader), so actually I'm inclined to leave the plural version as the main flag: the tool will print any number of file headers, even if you only work in ELF and so it only ever prints one.

[rupprecht]

In D54124#1292583, @jhenderson wrote:

Okay, from my point of view, LGTM (with a nit). However, we should probably get some more buy-in on the RFC before breaking people's builds etc, so you might want to hold off on the commit for now.

Any thoughts on how to drum up some more interest?

I'll ping the thread you started, and I'd like to commit on Monday if there are no objections. I'm hoping this change is not so controversial.

After this I'd like to switch to tablegen/liboption and support some merged args (e.g. "readelf -SW" seems to be a common usage)... that will be slightly more dangerous :)

test/tools/llvm-readobj/symbols.test

14–15 ↗

(On Diff #173206)

I'd prefer .lowers (consistent with the sections test) instead of .s just to highlight that it's a lowercase s given the general confusion of -s and -S for both (sometimes) meaning --sections, even though the same doesn't apply to --symbols.

Also just to note -- I chose "lowers" and "uppers" instead of "s" and "S" just to make sure this didn't mess with any build bots that are case insensitive with filenames.

[echristo]

In D54124#1293752, @rupprecht wrote:

In D54124#1292583, @jhenderson wrote:

Okay, from my point of view, LGTM (with a nit). However, we should probably get some more buy-in on the RFC before breaking people's builds etc, so you might want to hold off on the commit for now.

Any thoughts on how to drum up some more interest?

I'll ping the thread you started, and I'd like to commit on Monday if there are no objections. I'm hoping this change is not so controversial.

As a not entirely unbiased person, but who has worked on this, I'm in favor of this at the moment. Long term plans at the bottom...

After this I'd like to switch to tablegen/liboption and support some merged args (e.g. "readelf -SW" seems to be a common usage)... that will be slightly more dangerous :)

Awesome.

I'd really like to see a better "multiple tools calling into the same library with different options and output decorators allowing compatibility with random tools/output" set of support in an ideal world here.

-eric

[kristina]

I'm in favor of breaking changes for preserving GNU binutils compatibility. I think if downstream projects require "nonstandard" aliases, it is easy enough to tweak while in upstream I think compatibility is more important and brings LLVM's replacements for binutils one step closer to being drop-ins, which in turn encourages wider adoption of said tools.

llvm/trunk/test/MC/ARM/elf-execute-only-section.ll

 ; RUN: llc < %s -mtriple=thumbv8m.base-eabi -mattr=+execute-only -filetype=obj %s -o - | \
-; RUN: llvm-readelf -s | FileCheck %s
+; RUN: llvm-readelf -S | FileCheck %s
 ; RUN: llc < %s -mtriple=thumbv8m.main-eabi -mattr=+execute-only -filetype=obj %s -o - | \
-; RUN: llvm-readelf -s | FileCheck %s
+; RUN: llvm-readelf -S | FileCheck %s
 ; RUN: llc < %s -mtriple=thumbv7m-eabi -mattr=+execute-only -filetype=obj %s -o - | \
-; RUN: llvm-readelf -s | FileCheck %s
+; RUN: llvm-readelf -S | FileCheck %s
 
 ; CHECK-NOT: {{.text[ ]+PROGBITS[ ]+[0-9]+ [0-9]+ [0-9]+ [0-9]+ AX[^p]}}
 ; CHECK: {{.text[ ]+PROGBITS[ ]+[0-9]+ [0-9]+ [0-9]+ [0-9]+ AXp}}
 define void @test_func() {
 entry:
   ret void
 }

llvm/trunk/test/tools/llvm-readobj/all.test

+RUN: llvm-readobj -a %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix ALL
+RUN: llvm-readobj --all %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix ALL
+
+ALL: Format: ELF32-i386
+ALL: Arch: i386
+ALL: AddressSize: 32bit
+ALL: LoadName:
+ALL: ElfHeader {
+ALL: Sections [
+ALL: Relocations [
+ALL: Symbols [
+ALL: ProgramHeaders [
+ALL: Notes [

llvm/trunk/test/tools/llvm-readobj/readelf-s-alias.test

+# In llvm-readobj, -s is an alias for --sections.
+RUN: llvm-readobj -s %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix SEC
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix SEC
+
+# In llvm-readelf, -s is an alias for --symbols.
+RUN: llvm-readelf -s %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix SYM
+RUN: llvm-readelf --symbols %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix SYM
+
+SEC:      Sections [
+SEC-NEXT:   Section {
+SEC-NEXT:     Index: 0
+SEC-NEXT:     Name:  (0)
+SEC-NEXT:     Type: SHT_NULL (0x0)
+SEC-NEXT:     Flags [ (0x0)
+SEC-NEXT:     ]
+SEC-NEXT:     Address: 0x0
+SEC-NEXT:     Offset: 0x0
+SEC-NEXT:     Size: 0
+SEC-NEXT:     Link: 0
+SEC-NEXT:     Info: 0
+SEC-NEXT:     AddressAlignment: 0
+SEC-NEXT:     EntrySize: 0
+SEC-NEXT:   }
+SEC-NEXT:   Section {
+SEC-NEXT:     Index: 1
+SEC-NEXT:     Name: .text (5)
+SEC-NEXT:     Type: SHT_PROGBITS (0x1)
+SEC-NEXT:     Flags [ (0x6)
+SEC-NEXT:       SHF_ALLOC (0x2)
+SEC-NEXT:       SHF_EXECINSTR (0x4)
+SEC-NEXT:     ]
+SEC-NEXT:     Address: 0x0
+SEC-NEXT:     Offset: 0x40
+SEC-NEXT:     Size: 42
+SEC-NEXT:     Link: 0
+SEC-NEXT:     Info: 0
+SEC-NEXT:     AddressAlignment: 16
+SEC-NEXT:     EntrySize: 0
+SEC-NEXT:   }
+
+SYM:      Symbol table '.symtab' contains {{.*}} entries:
+SYM-NEXT:    Num:    Value  Size Type    Bind   Vis      Ndx Name
+SYM-NEXT:      0: {{.*}} NOTYPE  {{.*}} UND
+SYM-NEXT:      1: {{.*}} FILE    {{.*}} trivial.ll
+SYM-NEXT:      2: {{.*}} OBJECT  {{.*}} .L.str

llvm/trunk/test/tools/llvm-readobj/sections.test

-RUN: llvm-readobj -s %p/Inputs/trivial.obj.coff-i386 \
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.coff-i386 \
 RUN:   | FileCheck %s -check-prefix COFF
-RUN: llvm-readobj -s %p/Inputs/trivial.obj.elf-i386 \
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.elf-i386 \
 RUN:   | FileCheck %s -check-prefix ELF
-RUN: llvm-readobj -s %p/Inputs/trivial.obj.elf-mipsel \
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.elf-mipsel \
 RUN:   | FileCheck %s -check-prefix ELF-MIPSEL
-RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-i386 \
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.macho-i386 \
 RUN:   | FileCheck %s -check-prefix MACHO-I386
-RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-x86-64 \
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.macho-x86-64 \
 RUN:   | FileCheck %s -check-prefix MACHO-X86-64
-RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-ppc \
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.macho-ppc \
 RUN:   | FileCheck %s -check-prefix MACHO-PPC
-RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-ppc64 \
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.macho-ppc64 \
 RUN:   | FileCheck %s -check-prefix MACHO-PPC64
-RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-arm \
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.macho-arm \
 RUN:   | FileCheck %s -check-prefix MACHO-ARM
-RUN: llvm-readobj -s %p/Inputs/trivial.obj.wasm \
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.wasm \
 RUN:   | FileCheck %s -check-prefix WASM
 
+# Check flag aliases produce identical output.
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.elf-i386 > %t.sections
+RUN: llvm-readobj -S %p/Inputs/trivial.obj.elf-i386 > %t.uppers
+RUN: cmp %t.sections %t.uppers
+RUN: llvm-readobj -s %p/Inputs/trivial.obj.elf-i386 > %t.lowers
+RUN: cmp %t.sections %t.lowers
+
 COFF:      Sections [
 COFF-NEXT:   Section {
 COFF-NEXT:     Number: 1
 COFF-NEXT:     Name: .text (2E 74 65 78 74 00 00 00)
 COFF-NEXT:     VirtualSize: 0x0
 COFF-NEXT:     VirtualAddress: 0x0
 COFF-NEXT:     RawDataSize: 22
 COFF-NEXT:     PointerToRawData: 0x64

llvm/trunk/test/tools/llvm-readobj/symbols.test

-RUN: llvm-readobj -t %p/Inputs/trivial.obj.coff-i386 \
+RUN: llvm-readobj --symbols %p/Inputs/trivial.obj.coff-i386 \
 RUN:   | FileCheck %s -check-prefix COFF
-RUN: llvm-readobj -t %p/Inputs/trivial.obj.elf-i386 \
+RUN: llvm-readobj --symbols %p/Inputs/trivial.obj.elf-i386 \
 RUN:   | FileCheck %s -check-prefix ELF
-RUN: llvm-readobj -t %p/Inputs/trivial.obj.wasm \
+RUN: llvm-readobj --symbols %p/Inputs/trivial.obj.wasm \
 RUN:   | FileCheck %s -check-prefix WASM
 
+# Check flag aliases produce identical output.
+RUN: llvm-readobj --symbols %p/Inputs/trivial.obj.elf-i386 > %t.symbols
+RUN: llvm-readobj --syms %p/Inputs/trivial.obj.elf-i386 > %t.syms
+RUN: cmp %t.symbols %t.syms
+RUN: llvm-readobj -t %p/Inputs/trivial.obj.elf-i386 > %t.t
+RUN: cmp %t.symbols %t.t
+RUN: llvm-readelf -s -elf-output-style LLVM %p/Inputs/trivial.obj.elf-i386 > %t.lowers
+RUN: cmp %t.symbols %t.lowers
+
 COFF:      Symbols [
 COFF-NEXT:   Symbol {
 COFF-NEXT:     Name: @comp.id
 COFF-NEXT:    Value: 14766605
 COFF-NEXT:    Section:  IMAGE_SYM_ABSOLUTE (-1)
 COFF-NEXT:     BaseType: Null (0x0)
 COFF-NEXT:     ComplexType: Null (0x0)
 COFF-NEXT:    StorageClass: Static (0x3)

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

 
 class COFFDumper : public ObjDumper {
 public:
   friend class COFFObjectDumpDelegate;
   COFFDumper(const llvm::object::COFFObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer), Obj(Obj), Writer(Writer), Types(100) {}
 
   void printFileHeaders() override;
-  void printSections() override;
+  void printSectionHeaders() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
 
   void printNeededLibraries() override;
 
   void printCOFFImports() override;
void COFFDumper::printCodeViewSymbolSection(StringRef SectionName,
   StringRef SectionContents;
   error(Section.getContents(SectionContents));
   StringRef Data = SectionContents;
 
   SmallVector<StringRef, 10> FunctionNames;
   StringMap<StringRef> FunctionLineTables;
 
   ListScope D(W, "CodeViewDebugInfo");
-  // Print the section to allow correlation with printSections.
+  // Print the section to allow correlation with printSectionHeaders.
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
 
   uint32_t Magic;
   error(consume(Data, Magic));
   W.printHex("Magic", Magic);
   if (Magic != COFF::DEBUG_SECTION_MAGIC)
     return error(object_error::parse_failed);
 
void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
 
   Types.reset(Data, 100);
 
   TypeDumpVisitor TDV(Types, &W, opts::CodeViewSubsectionBytes);
   error(codeview::visitTypeStream(Types, TDV));
   W.flush();
 }
 
-void COFFDumper::printSections() {
+void COFFDumper::printSectionHeaders() {
   ListScope SectionsD(W, "Sections");
   int SectionNumber = 0;
   for (const SectionRef &Sec : Obj->sections()) {
     ++SectionNumber;
     const coff_section *Section = Obj->getCOFFSection(Sec);
 
     StringRef Name;
     error(Sec.getName(Name));

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

 };
 
 template<typename ELFT>
 class ELFDumper : public ObjDumper {
 public:
   ELFDumper(const ELFFile<ELFT> *Obj, ScopedPrinter &Writer);
 
   void printFileHeaders() override;
-  void printSections() override;
+  void printSectionHeaders() override;
   void printRelocations() override;
   void printDynamicRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
 
   void printDynamicTable() override;
   void printNeededLibraries() override;
public:
   using Elf_Sym = typename ELFT::Sym;
 
   DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) {}
   virtual ~DumpStyle() = default;
 
   virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0;
   virtual void printRelocations(const ELFFile<ELFT> *Obj) = 0;
-  virtual void printSections(const ELFFile<ELFT> *Obj) = 0;
+  virtual void printSectionHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymbols(const ELFFile<ELFT> *Obj) = 0;
   virtual void printDynamicSymbols(const ELFFile<ELFT> *Obj) = 0;
   virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymtabMessage(const ELFFile<ELFT> *obj, StringRef Name,
                                   size_t Offset) {}
   virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol,
                            const Elf_Sym *FirstSym, StringRef StrTable,
                            bool IsDynamic) = 0;
public:
   TYPEDEF_ELF_TYPES(ELFT)
 
   GNUStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper)
       : DumpStyle<ELFT>(Dumper), OS(W.getOStream()) {}
 
   void printFileHeaders(const ELFO *Obj) override;
   void printGroupSections(const ELFFile<ELFT> *Obj) override;
   void printRelocations(const ELFO *Obj) override;
-  void printSections(const ELFO *Obj) override;
+  void printSectionHeaders(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj) override;
   void printDynamicSymbols(const ELFO *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
   void printSymtabMessage(const ELFO *Obj, StringRef Name,
                           size_t Offset) override;
   void printProgramHeaders(const ELFO *Obj) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
public:
 
   LLVMStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper)
       : DumpStyle<ELFT>(Dumper), W(W) {}
 
   void printFileHeaders(const ELFO *Obj) override;
   void printGroupSections(const ELFFile<ELFT> *Obj) override;
   void printRelocations(const ELFO *Obj) override;
   void printRelocations(const Elf_Shdr *Sec, const ELFO *Obj);
-  void printSections(const ELFO *Obj) override;
+  void printSectionHeaders(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj) override;
   void printDynamicSymbols(const ELFO *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
   void printProgramHeaders(const ELFO *Obj) override;
   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
   void printCGProfile(const ELFFile<ELFT> *Obj) override;
   void printAddrsig(const ELFFile<ELFT> *Obj) override;
   void printNotes(const ELFFile<ELFT> *Obj) override;
typename ELFDumper<ELFT>::Elf_Relr_Range ELFDumper<ELFT>::dyn_relrs() const {
   return DynRelrRegion.getAsArrayRef<Elf_Relr>();
 }
 
 template<class ELFT>
 void ELFDumper<ELFT>::printFileHeaders() {
   ELFDumperStyle->printFileHeaders(Obj);
 }
 
-template<class ELFT>
-void ELFDumper<ELFT>::printSections() {
-  ELFDumperStyle->printSections(Obj);
+template <class ELFT> void ELFDumper<ELFT>::printSectionHeaders() {
+  ELFDumperStyle->printSectionHeaders(Obj);
 }
 
 template<class ELFT>
 void ELFDumper<ELFT>::printRelocations() {
   ELFDumperStyle->printRelocations(Obj);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printProgramHeaders() {
std::string getSectionTypeString(unsigned Arch, unsigned Type) {
   case SHT_GNU_versym:
     return "VERSYM";
   default:
     return "";
   }
   return "";
 }
 
-template <class ELFT> void GNUStyle<ELFT>::printSections(const ELFO *Obj) {
+template <class ELFT>
+void GNUStyle<ELFT>::printSectionHeaders(const ELFO *Obj) {
   size_t SectionIndex = 0;
   std::string Number, Type, Size, Address, Offset, Flags, Link, Info, EntrySize,
       Alignment;
   unsigned Bias;
   unsigned Width;
 
   if (ELFT::Is64Bits) {
     Bias = 0;
void LLVMStyle<ELFT>::printRelocation(const ELFO *Obj, Elf_Rela Rel,
   } else {
     raw_ostream &OS = W.startLine();
     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
        << (!TargetName.empty() ? TargetName : "-") << " "
        << W.hex(Rel.r_addend) << "\n";
   }
 }
 
-template <class ELFT> void LLVMStyle<ELFT>::printSections(const ELFO *Obj) {
+template <class ELFT>
+void LLVMStyle<ELFT>::printSectionHeaders(const ELFO *Obj) {
   ListScope SectionsD(W, "Sections");
 
   int SectionIndex = -1;
   for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
     ++SectionIndex;
 
     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
 

llvm/trunk/tools/llvm-readobj/MachODumper.cpp

 namespace {
 
 class MachODumper : public ObjDumper {
 public:
   MachODumper(const MachOObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer), Obj(Obj) {}
 
   void printFileHeaders() override;
-  void printSections() override;
+  void printSectionHeaders() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printStackMap() const override;
 
   void printNeededLibraries() override;
 
private:
   void printFileHeaders(const MachHeader &Header);
 
   void printSymbol(const SymbolRef &Symbol);
 
   void printRelocation(const RelocationRef &Reloc);
 
   void printRelocation(const MachOObjectFile *Obj, const RelocationRef &Reloc);
 
-  void printSections(const MachOObjectFile *Obj);
+  void printSectionHeaders(const MachOObjectFile *Obj);
 
   const MachOObjectFile *Obj;
 };
 
 } // namespace
 
 
 namespace llvm {
default:
     W.printHex("CpuSubtype", subtype);
   }
   W.printEnum("FileType", Header.filetype, makeArrayRef(MachOHeaderFileTypes));
   W.printNumber("NumOfLoadCommands", Header.ncmds);
   W.printNumber("SizeOfLoadCommands", Header.sizeofcmds);
   W.printFlags("Flags", Header.flags, makeArrayRef(MachOHeaderFlags));
 }
 
-void MachODumper::printSections() {
-  return printSections(Obj);
-}
+void MachODumper::printSectionHeaders() { return printSectionHeaders(Obj); }
 
-void MachODumper::printSections(const MachOObjectFile *Obj) {
+void MachODumper::printSectionHeaders(const MachOObjectFile *Obj) {
   ListScope Group(W, "Sections");
 
   int SectionIndex = -1;
   for (const SectionRef &Section : Obj->sections()) {
     ++SectionIndex;
 
     MachOSection MOSection;
     getSection(Obj, Section.getRawDataRefImpl(), MOSection);

llvm/trunk/tools/llvm-readobj/ObjDumper.h

 class ScopedPrinter;
 
 class ObjDumper {
 public:
   ObjDumper(ScopedPrinter &Writer);
   virtual ~ObjDumper();
 
   virtual void printFileHeaders() = 0;
-  virtual void printSections() = 0;
+  virtual void printSectionHeaders() = 0;
   virtual void printRelocations() = 0;
   virtual void printSymbols() = 0;
   virtual void printDynamicSymbols() = 0;
   virtual void printUnwindInfo() = 0;
 
   // Only implemented for ELF at this time.
   virtual void printDynamicRelocations() { }
   virtual void printDynamicTable() { }

llvm/trunk/tools/llvm-readobj/WasmDumper.cpp

 };
 
 class WasmDumper : public ObjDumper {
 public:
   WasmDumper(const WasmObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer), Obj(Obj) {}
 
   void printFileHeaders() override;
-  void printSections() override;
+  void printSectionHeaders() override;
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override { llvm_unreachable("unimplemented"); }
   void printUnwindInfo() override { llvm_unreachable("unimplemented"); }
   void printStackMap() const override { llvm_unreachable("unimplemented"); }
 
 protected:
   void printSymbol(const SymbolRef &Sym);

 
 void WasmDumper::printSymbols() {
   ListScope Group(W, "Symbols");
 
   for (const SymbolRef &Symbol : Obj->symbols())
     printSymbol(Symbol);
 }
 
-void WasmDumper::printSections() {
+void WasmDumper::printSectionHeaders() {
   ListScope Group(W, "Sections");
   for (const SectionRef &Section : Obj->sections()) {
     const WasmSection &WasmSec = Obj->getWasmSection(Section);
     DictScope SectionD(W, "Section");
     W.printEnum("Type", WasmSec.Type, makeArrayRef(WasmSectionTypes));
     W.printNumber("Size", static_cast<uint64_t>(WasmSec.Content.size()));
     W.printNumber("Offset", WasmSec.Offset);
     switch (WasmSec.Type) {

llvm/trunk/tools/llvm-readobj/llvm-readobj.h

template <class T> T unwrapOrError(Expected<T> EO) {
     OS.flush();
     reportError(Buf);
   }
   bool relocAddressLess(object::RelocationRef A,
                         object::RelocationRef B);
 } // namespace llvm
 
 namespace opts {
-  extern llvm::cl::list<std::string> InputFilenames;
-  extern llvm::cl::opt<bool> FileHeaders;
-  extern llvm::cl::opt<bool> Sections;
   extern llvm::cl::opt<bool> SectionRelocations;
   extern llvm::cl::opt<bool> SectionSymbols;
   extern llvm::cl::opt<bool> SectionData;
-  extern llvm::cl::opt<bool> Relocations;
-  extern llvm::cl::opt<bool> Symbols;
   extern llvm::cl::opt<bool> DynamicSymbols;
-  extern llvm::cl::opt<bool> UnwindInfo;
   extern llvm::cl::opt<bool> ExpandRelocs;
   extern llvm::cl::opt<bool> RawRelr;
-  extern llvm::cl::opt<bool> CodeView;
   extern llvm::cl::opt<bool> CodeViewSubsectionBytes;
-  extern llvm::cl::opt<bool> ARMAttributes;
-  extern llvm::cl::opt<bool> MipsPLTGOT;
   enum OutputStyleTy { LLVM, GNU };
   extern llvm::cl::opt<OutputStyleTy> Output;
 } // namespace opts
 
 #define LLVM_READOBJ_ENUM_ENT(ns, enum) \
   { #enum, ns::enum }
 
 #define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum) \
   { #enum, std::underlying_type<enum_class>::type(enum_class::enum) }
 
 #endif

llvm/trunk/tools/llvm-readobj/llvm-readobj.cpp

 using namespace llvm;
 using namespace llvm::object;
 
 namespace opts {
   cl::list<std::string> InputFilenames(cl::Positional,
     cl::desc("<input object files>"),
     cl::ZeroOrMore);
 
+  // -all, -a
+  cl::opt<bool>
+      All("all",
+          cl::desc("Equivalent to setting: --file-headers, --program-headers, "
+                   "--section-headers, --symbols, --relocations, "
+                   "--dynamic-table, --notes, --version-info, --unwind, "
+                   "--section-groups and --elf-hash-histogram."));
+  cl::alias AllShort("a", cl::desc("Alias for --all"), cl::aliasopt(All));
+
   // -wide, -W
-  cl::opt<bool> WideOutput("wide",
-    cl::desc("Ignored for compatibility with GNU readelf"));
+  cl::opt<bool>
+      WideOutput("wide", cl::desc("Ignored for compatibility with GNU readelf"),
+                 cl::Hidden);
   cl::alias WideOutputShort("W",
     cl::desc("Alias for --wide"),
     cl::aliasopt(WideOutput));
 
-  // -file-headers, -h
+  // -file-headers, -file-header, -h
   cl::opt<bool> FileHeaders("file-headers",
     cl::desc("Display file headers "));
-  cl::alias FileHeadersShort("h",
+  cl::alias FileHeadersShort("h", cl::desc("Alias for --file-headers"),
+                             cl::aliasopt(FileHeaders), cl::NotHidden);
+  cl::alias FileHeadersSingular("file-header",
                                 cl::desc("Alias for --file-headers"),
                                 cl::aliasopt(FileHeaders));
 
-  // -sections, -s, -S
-  // Note: In GNU readelf, -s means --symbols!
-  cl::opt<bool> Sections("sections",
-    cl::desc("Display all sections."));
-  cl::alias SectionsShort("s",
-    cl::desc("Alias for --sections"),
-    cl::aliasopt(Sections));
-  cl::alias SectionsShortUpper("S",
-    cl::desc("Alias for --sections"),
-    cl::aliasopt(Sections));
+  // -section-headers, -sections, -S
+  // Also -s in llvm-readobj mode.
+  cl::opt<bool> SectionHeaders("section-headers",
+                               cl::desc("Display all section headers."));
+  cl::alias SectionsShortUpper("S", cl::desc("Alias for --section-headers"),
+                               cl::aliasopt(SectionHeaders), cl::NotHidden);
+  cl::alias SectionHeadersAlias("sections",
+                                cl::desc("Alias for --section-headers"),
+                                cl::aliasopt(SectionHeaders), cl::NotHidden);
 
   // -section-relocations, -sr
   cl::opt<bool> SectionRelocations("section-relocations",
     cl::desc("Display relocations for each section shown."));
   cl::alias SectionRelocationsShort("sr",
     cl::desc("Alias for --section-relocations"),
     cl::aliasopt(SectionRelocations));
 
   // -section-symbols, -st
   cl::opt<bool> SectionSymbols("section-symbols",
     cl::desc("Display symbols for each section shown."));
   cl::alias SectionSymbolsShort("st",
     cl::desc("Alias for --section-symbols"),
     cl::aliasopt(SectionSymbols));
 
   // -section-data, -sd
   cl::opt<bool> SectionData("section-data",
     cl::desc("Display section data for each section shown."));
   cl::alias SectionDataShort("sd",
     cl::desc("Alias for --section-data"),
     cl::aliasopt(SectionData));
 
-  // -relocations, -r
+  // -relocations, -relocs, -r
   cl::opt<bool> Relocations("relocations",
     cl::desc("Display the relocation entries in the file"));
-  cl::alias RelocationsShort("r",
-    cl::desc("Alias for --relocations"),
+  cl::alias RelocationsShort("r", cl::desc("Alias for --relocations"),
+                             cl::aliasopt(Relocations), cl::NotHidden);
+  cl::alias RelocationsGNU("relocs", cl::desc("Alias for --relocations"),
                            cl::aliasopt(Relocations));
 
   // -notes, -n
   cl::opt<bool> Notes("notes", cl::desc("Display the ELF notes in the file"));
   cl::alias NotesShort("n", cl::desc("Alias for --notes"), cl::aliasopt(Notes));
 
   // -dyn-relocations
   cl::opt<bool> DynRelocs("dyn-relocations",
     cl::desc("Display the dynamic relocation entries in the file"));
 
-  // -symbols, -t
+  // -symbols
+  // Also -s in llvm-readelf mode, or -t in llvm-readobj mode.
   cl::opt<bool> Symbols("symbols",
     cl::desc("Display the symbol table"));
-  cl::alias SymbolsShort("t",
-    cl::desc("Alias for --symbols"),
+  cl::alias SymbolsGNU("syms", cl::desc("Alias for --symbols"),
                        cl::aliasopt(Symbols));
 
-  // -dyn-symbols, -dt
+  // -dyn-symbols, -dyn-syms, -dt
   cl::opt<bool> DynamicSymbols("dyn-symbols",
     cl::desc("Display the dynamic symbol table"));
   cl::alias DynamicSymbolsShort("dt",
     cl::desc("Alias for --dyn-symbols"),
     cl::aliasopt(DynamicSymbols));
+  cl::alias DynSymsGNU("dyn-syms", cl::desc("Alias for --dyn-symbols"),
+                       cl::aliasopt(DynamicSymbols));
 
   // -unwind, -u
   cl::opt<bool> UnwindInfo("unwind",
     cl::desc("Display unwind information"));
   cl::alias UnwindInfoShort("u",
     cl::desc("Alias for --unwind"),
     cl::aliasopt(UnwindInfo));
 
-  // -dynamic-table
+  // -dynamic-table, -dynamic, -d
   cl::opt<bool> DynamicTable("dynamic-table",
     cl::desc("Display the ELF .dynamic section table"));
   cl::alias DynamicTableShort("d", cl::desc("Alias for --dynamic-table"),
+                              cl::aliasopt(DynamicTable), cl::NotHidden);
+  cl::alias DynamicTableAlias("dynamic", cl::desc("Alias for --dynamic-table"),
                               cl::aliasopt(DynamicTable));
 
   // -needed-libs
   cl::opt<bool> NeededLibraries("needed-libs",
     cl::desc("Display the needed libraries"));
 
-  // -program-headers
+  // -program-headers, -segments, -l
   cl::opt<bool> ProgramHeaders("program-headers",
     cl::desc("Display ELF program headers"));
   cl::alias ProgramHeadersShort("l", cl::desc("Alias for --program-headers"),
-                                cl::aliasopt(ProgramHeaders));
+                                cl::aliasopt(ProgramHeaders), cl::NotHidden);
+  cl::alias SegmentsAlias("segments", cl::desc("Alias for --program-headers"),
 
-  // -string-dump
+  // -string-dump, -p
   cl::list<std::string> StringDump("string-dump", cl::desc("<number|name>"),
                                    cl::ZeroOrMore);
   cl::alias StringDumpShort("p", cl::desc("Alias for --string-dump"),
                             cl::aliasopt(StringDump));
 
-  // -hex-dump
+  // -hex-dump, -x
   cl::list<std::string> HexDump("hex-dump", cl::desc("<number|name>"),
                                 cl::ZeroOrMore);
   cl::alias HexDumpShort("x", cl::desc("Alias for --hex-dump"),
                          cl::aliasopt(HexDump));
 
   // -hash-table
   cl::opt<bool> HashTable("hash-table",
     cl::desc("Display ELF hash table"));
cl::opt<bool>
       CodeViewMergedTypes("codeview-merged-types",
                           cl::desc("Display the merged CodeView type stream"));
 
   // -codeview-subsection-bytes
   cl::opt<bool> CodeViewSubsectionBytes(
       "codeview-subsection-bytes",
       cl::desc("Dump raw contents of codeview debug sections and records"));
 
-  // -arm-attributes, -a
+  // -arm-attributes
   cl::opt<bool> ARMAttributes("arm-attributes",
                               cl::desc("Display the ARM attributes section"));
-  cl::alias ARMAttributesShort("a", cl::desc("Alias for --arm-attributes"),
-                               cl::aliasopt(ARMAttributes));
 
   // -mips-plt-got
   cl::opt<bool>
   MipsPLTGOT("mips-plt-got",
              cl::desc("Display the MIPS GOT and PLT GOT sections"));
 
   // -mips-abi-flags
   cl::opt<bool> MipsABIFlags("mips-abi-flags",
namespace opts {
   MachODysymtab("macho-dysymtab",
                   cl::desc("Display MachO Dysymtab command"));
 
   // -stackmap
   cl::opt<bool>
   PrintStackMap("stackmap",
                 cl::desc("Display contents of stackmap section"));
 
-  // -version-info
+  // -version-info, -V
   cl::opt<bool>
       VersionInfo("version-info",
                   cl::desc("Display ELF version sections (if present)"));
   cl::alias VersionInfoShort("V", cl::desc("Alias for -version-info"),
                              cl::aliasopt(VersionInfo));
 
+  // -elf-section-groups, -section-groups, -g
   cl::opt<bool> SectionGroups("elf-section-groups",
                               cl::desc("Display ELF section group contents"));
+  cl::alias SectionGroupsAlias("section-groups",
+                               cl::desc("Alias for -elf-sections-groups"),
+                               cl::aliasopt(SectionGroups));
   cl::alias SectionGroupsShort("g", cl::desc("Alias for -elf-sections-groups"),
                                cl::aliasopt(SectionGroups));
+
+  // -elf-hash-histogram, -histogram, -I
   cl::opt<bool> HashHistogram(
       "elf-hash-histogram",
       cl::desc("Display bucket list histogram for hash sections"));
   cl::alias HashHistogramShort("I", cl::desc("Alias for -elf-hash-histogram"),
                                cl::aliasopt(HashHistogram));
+  cl::alias HistogramAlias("histogram",
+                           cl::desc("Alias for --elf-hash-histogram"),
+                           cl::aliasopt(HashHistogram));
 
+  // -elf-cg-profile
   cl::opt<bool> CGProfile("elf-cg-profile", cl::desc("Display callgraph profile section"));
 
+  // -addrsig
   cl::opt<bool> Addrsig("addrsig",
                         cl::desc("Display address-significance table"));
 
+  // -elf-output-style
   cl::opt<OutputStyleTy>
       Output("elf-output-style", cl::desc("Specify ELF dump style"),
              cl::values(clEnumVal(LLVM, "LLVM default style"),
                         clEnumVal(GNU, "GNU readelf style")),
              cl::init(LLVM));
 } // namespace opts
 
 namespace llvm {
Writer.printString("Arch", Triple::getArchTypeName(
                                    (llvm::Triple::ArchType)Obj->getArch()));
     Writer.printString("AddressSize",
                        formatv("{0}bit", 8 * Obj->getBytesInAddress()));
     Dumper->printLoadName();
   }
 
   if (opts::FileHeaders)
     Dumper->printFileHeaders();
-  if (opts::Sections)
-    Dumper->printSections();
+  if (opts::SectionHeaders)
+    Dumper->printSectionHeaders();
   if (opts::Relocations)
     Dumper->printRelocations();
   if (opts::DynRelocs)
     Dumper->printDynamicRelocations();
   if (opts::Symbols)
     Dumper->printSymbols();
   if (opts::DynamicSymbols)
     Dumper->printDynamicSymbols();
static void dumpInput(StringRef File) {
   else if (COFFImportFile *Import = dyn_cast<COFFImportFile>(&Binary))
     dumpCOFFImportFile(Import, Writer);
   else if (WindowsResource *WinRes = dyn_cast<WindowsResource>(&Binary))
     dumpWindowsResourceFile(WinRes);
   else
     reportError(File, readobj_error::unrecognized_file_format);
 }
 
+/// Registers aliases that should only be allowed by readobj.
+static void registerReadobjAliases() {
+  // -s has meant --sections for a very long time in llvm-readobj despite
+  // meaning --symbols in readelf.
+  static cl::alias SectionsShort("s", cl::desc("Alias for --section-headers"),
+                                 cl::aliasopt(opts::SectionHeaders),
+                                 cl::NotHidden);
+
+  // Only register -t in llvm-readobj, as readelf reserves it for
+  // --section-details (not implemented yet).
+  static cl::alias SymbolsShort("t", cl::desc("Alias for --symbols"),
+                                cl::aliasopt(opts::Symbols), cl::NotHidden);
+}
+
+/// Registers aliases that should only be allowed by readelf.
+static void registerReadelfAliases() {
+  // -s is here because for readobj it means --sections.
+  static cl::alias SymbolsShort("s", cl::desc("Alias for --symbols"),
+                                cl::aliasopt(opts::Symbols), cl::NotHidden);
+}
+
 int main(int argc, const char *argv[]) {
   InitLLVM X(argc, argv);
 
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
-  // Make some commonly used short options visibile in -help.
-  opts::DynamicTableShort.setHiddenFlag(cl::NotHidden);
-  opts::FileHeadersShort.setHiddenFlag(cl::NotHidden);
-  opts::ProgramHeadersShort.setHiddenFlag(cl::NotHidden);
-  opts::RelocationsShort.setHiddenFlag(cl::NotHidden);
-  opts::SectionsShort.setHiddenFlag(cl::NotHidden);
-  opts::SectionsShortUpper.setHiddenFlag(cl::NotHidden);
-  opts::SymbolsShort.setHiddenFlag(cl::NotHidden);
-
-  opts::WideOutput.setHiddenFlag(cl::Hidden);
-
-  if (sys::path::stem(argv[0]).find("readelf") != StringRef::npos)
+  if (sys::path::stem(argv[0]).contains("readelf")) {
     opts::Output = opts::GNU;
+    registerReadelfAliases();
+  } else {
+    registerReadobjAliases();
+  }
 
   cl::ParseCommandLineOptions(argc, argv, "LLVM Object Reader\n");
 
+  if (opts::All) {
+    opts::FileHeaders = true;
+    opts::ProgramHeaders = true;
+    opts::SectionHeaders = true;
+    opts::Symbols = true;
+    opts::Relocations = true;
+    opts::DynamicTable = true;
+    opts::Notes = true;
+    opts::VersionInfo = true;
+    opts::UnwindInfo = true;
+    opts::SectionGroups = true;
+    opts::HashHistogram = true;
+  }
+
   // Default to stdin if no filename is specified.
   if (opts::InputFilenames.size() == 0)
     opts::InputFilenames.push_back("-");
 
   llvm::for_each(opts::InputFilenames, dumpInput);
 
   if (opts::CodeViewMergedTypes) {
     ScopedPrinter W(outs());
     dumpCodeViewMergedTypes(W, CVTypes.IDTable, CVTypes.TypeTable);
   }
 
   return 0;
 }