[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

608

How about just meaning --symbols in readelf.

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

642

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

[MaskRay]

tools/llvm-readobj/llvm-readobj.cpp

625

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

5–6

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

627

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

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).

628–630

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

[rupprecht]

• Clean up aliases/tests

[rupprecht]

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

5–6

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

5–6

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

57

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

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

66

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

86

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–127

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

612–613

and -> as
Missing trailing full stop.

[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

86

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

86

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.

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
 }

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 [

test/tools/llvm-readobj/dynamic.test

 ELF-MIPS-EXE:   0x6FFFFFFE VERNEED              0x4003E8
 ELF-MIPS-EXE:   0x6FFFFFFF VERNEEDNUM           1
 ELF-MIPS-EXE:   0x6FFFFFF0 VERSYM               0x4003D8
 ELF-MIPS-EXE:   0x00000000 NULL                 0x0
 ELF-MIPS-EXE: ]
 
 RUN: llvm-readobj -dynamic-table %p/Inputs/dynamic-table-exe.x86 \
 RUN:     | FileCheck %s -check-prefix ELF-X86-EXE
+RUN: llvm-readobj --dynamic %p/Inputs/dynamic-table-exe.x86 \
+RUN:     | FileCheck %s -check-prefix ELF-X86-EXE
+RUN: llvm-readobj -d %p/Inputs/dynamic-table-exe.x86 \
+RUN:     | FileCheck %s -check-prefix ELF-X86-EXE
 
 ELF-X86-EXE: Format: ELF32-i386
 ELF-X86-EXE: Arch: i386
 ELF-X86-EXE: AddressSize: 32bit
 ELF-X86-EXE: LoadName:
 ELF-X86-EXE: DynamicSection [ (30 entries)
 ELF-X86-EXE:   Tag        Type                 Name/Value
 ELF-X86-EXE:   0x00000001 NEEDED               Shared library: [libstdc++.so.6]

test/tools/llvm-readobj/file-headers.test

 RUN:   | FileCheck %s -check-prefix COFF-UNKNOWN
 RUN: llvm-readobj -h %p/Inputs/magic.coff-importlib \
 RUN:   | FileCheck %s -check-prefix COFF-IMPORTLIB
 RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-lanai \
 RUN:   | FileCheck %s -check-prefix ELF-LANAI
 RUN: llvm-readobj -h %p/Inputs/trivial.obj.wasm \
 RUN:   | FileCheck %s -check-prefix WASM
 
+# Check flag aliases.
+RUN: llvm-readobj --file-header %p/Inputs/trivial.obj.elf-x86-64 \
+RUN:   | FileCheck %s -check-prefix ELF64
+RUN: llvm-readobj --file-headers %p/Inputs/trivial.obj.elf-x86-64 \
+RUN:   | FileCheck %s -check-prefix ELF64
+
 COFF-ARM:      File: {{(.*[/\\])?}}trivial.obj.coff-arm
 COFF-ARM-NEXT: Format: COFF-ARM
 COFF-ARM-NEXT: Arch: thumb
 COFF-ARM-NEXT: AddressSize: 32bit
 COFF-ARM-NEXT: ImageFileHeader {
 COFF-ARM-NEXT:   Machine: IMAGE_FILE_MACHINE_ARMNT (0x1C4)
 COFF-ARM-NEXT:   SectionCount: 2
 COFF-ARM-NEXT:   TimeDateStamp: 2014-03-13 02:48:34 (0x53211C82)

test/tools/llvm-readobj/program-headers.test

 ## PHDRS { text PT_LOAD FILEHDR PHDRS; foo 0x65a3dbe6; bar 0x65a3dbe7; zed 0x65a41be6; }
 ##   Where 0x65a3dbe6 is the value of PT_OPENBSD_RANDOMIZE,
 ##         0x65a3dbe7 is the value of PT_OPENBSD_WXNEEDED,
 ##         0x65a41be6 is the value of PT_OPENBSD_BOOTDATA
 ## SECTIONS { . = SIZEOF_HEADERS; .all : { *(.*) } : text }
 RUN: llvm-readobj -program-headers %p/../../Object/Inputs/openbsd-phdrs.elf-x86-64 \
 RUN:     | FileCheck %s -check-prefix OPENBSD-X86-64
 
+# Check flag aliases.
+RUN: llvm-readobj --segments %p/../../Object/Inputs/program-headers.elf-x86-64 \
+RUN:     | FileCheck %s -check-prefix ELF-X86-64
+RUN: llvm-readobj -l %p/../../Object/Inputs/program-headers.elf-x86-64 \
+RUN:     | FileCheck %s -check-prefix ELF-X86-64
+
 ELF-I386:      ProgramHeaders [
 ELF-I386-NEXT:   ProgramHeader {
 ELF-I386-NEXT:     Type: PT_LOAD (0x1)
 ELF-I386-NEXT:     Offset: 0x0
 ELF-I386-NEXT:     VirtualAddress: 0x8048000
 ELF-I386-NEXT:     PhysicalAddress: 0x8048000
 ELF-I386-NEXT:     FileSize: 308
 ELF-I386-NEXT:     MemSize: 308

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

test/tools/llvm-readobj/relocations.test

 RUN:   | FileCheck %s -check-prefix MACHO-PPC
 RUN: llvm-readobj -r --expand-relocs %p/Inputs/trivial.obj.macho-ppc64 \
 RUN:   | FileCheck %s -check-prefix MACHO-PPC64
 RUN: llvm-readobj -r -expand-relocs %p/Inputs/trivial.obj.macho-arm \
 RUN:   | FileCheck %s -check-prefix MACHO-ARM
 RUN: llvm-readobj -r --expand-relocs %p/Inputs/trivial.obj.wasm \
 RUN:   | FileCheck %s -check-prefix WASM
 
+# Check flag aliases.
+RUN: llvm-readobj --relocs %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix ELF
+RUN: llvm-readobj --relocations %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix ELF
+
 COFF:      Relocations [
 COFF-NEXT:   Section (1) .text {
 COFF-NEXT:     0x4 IMAGE_REL_I386_DIR32 .data
 COFF-NEXT:     0x9 IMAGE_REL_I386_REL32 _puts
 COFF-NEXT:     0xE IMAGE_REL_I386_REL32 _SomeOtherFunction
 COFF-NEXT:   }
 COFF-NEXT: ]
 

test/tools/llvm-readobj/sections.test

 RUN:   | FileCheck %s -check-prefix MACHO-PPC
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-ppc64 \
 RUN:   | FileCheck %s -check-prefix MACHO-PPC64
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.macho-arm \
 RUN:   | FileCheck %s -check-prefix MACHO-ARM
 RUN: llvm-readobj -s %p/Inputs/trivial.obj.wasm \
 RUN:   | FileCheck %s -check-prefix WASM
 
+# Check flag aliases.
+RUN: llvm-readobj -S %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix ELF
+RUN: llvm-readobj --sections %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix ELF
+RUN: llvm-readobj --section-headers %p/Inputs/trivial.obj.elf-i386 \
+RUN:   | FileCheck %s -check-prefix ELF
+
 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

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-header, --program-headers, "
+               "--sections, --symbols, --relocs, --dynamic, --notes, "
+               "--version-info --unwind, --section-groups and --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::alias WideOutputShort("W",
     cl::desc("Alias for --wide"),
     cl::aliasopt(WideOutput));
 
   // -file-headers, -h
   cl::opt<bool> FileHeaders("file-headers",
     cl::desc("Display file headers "));
+  cl::alias FileHeadersSingular("file-header",
+                                cl::desc("Alias for --file-headers"),
+                                cl::aliasopt(FileHeaders));
   cl::alias FileHeadersShort("h",
     cl::desc("Alias for --file-headers"),
     cl::aliasopt(FileHeaders));
 
-  // -sections, -s, -S
-  // Note: In GNU readelf, -s means --symbols!
+  // -sections, -section-headers, -S
   cl::opt<bool> Sections("sections",
     cl::desc("Display all sections."));
-  cl::alias SectionsShort("s",
+  cl::alias SectionHeadersAlias("section-headers",
                                 cl::desc("Alias for --sections"),
                                 cl::aliasopt(Sections));
   cl::alias SectionsShortUpper("S",
     cl::desc("Alias for --sections"),
     cl::aliasopt(Sections));
 
   // -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
   cl::opt<bool> Relocations("relocations",
     cl::desc("Display the relocation entries in the file"));
+  cl::alias RelocationsMedium("relocs", cl::desc("Alias for --relocations"),
+                              cl::aliasopt(Relocations));
   cl::alias RelocationsShort("r",
     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
   cl::opt<bool> Symbols("symbols",
     cl::desc("Display the symbol table"));
-  cl::alias SymbolsShort("t",
-    cl::desc("Alias for --symbols"),
-    cl::aliasopt(Symbols));
 
   // -dyn-symbols, -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));
 
   // -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
   cl::opt<bool> DynamicTable("dynamic-table",
     cl::desc("Display the ELF .dynamic section table"));
+  cl::alias DynamicTableAlias("dynamic", cl::desc("Alias for --dynamic-table"),
+                              cl::aliasopt(DynamicTable));
   cl::alias DynamicTableShort("d", 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
   cl::opt<bool> ProgramHeaders("program-headers",
     cl::desc("Display ELF program headers"));
+  cl::alias SegmentsAlias("segments", cl::desc("Alias for --program-headers"),
+                          cl::aliasopt(ProgramHeaders));
   cl::alias ProgramHeadersShort("l", cl::desc("Alias for --program-headers"),
                                 cl::aliasopt(ProgramHeaders));
 
   // -string-dump
   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));
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 {
   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));
 
   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));
   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));
 
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 something else in readelf.
+  static cl::alias SectionsShort("s", cl::desc("Alias for --sections"),
+                                 cl::aliasopt(opts::Sections));
+  SectionsShort.setHiddenFlag(cl::NotHidden);
+
+  // Only register -t in llvm-readobj, and readelf reserves it for
+  // --section-details (not implemented yet)
+  static cl::alias SymbolsShort("t", cl::desc("Alias for --symbols"),
+                                cl::aliasopt(opts::Symbols));
+  SymbolsShort.setHiddenFlag(cl::NotHidden);
+}
+
+/// Registers aliases that should only be allowed by readelf.
+static void registerReadelfAliases() {
+  static cl::alias SymbolsShort("s", cl::desc("Alias for --symbols"),
+                                cl::aliasopt(opts::Symbols));
+  SymbolsShort.setHiddenFlag(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]).find("readelf") != StringRef::npos) {
     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::Sections = 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;
 }