[llvm-readelf] - Implement --section-details option.

[grimar]

Summary

--section-details/-t is a GNU readelf option that produce
an output that is an alternative to --sections.

[jhenderson]

I'm not going to have time to look at this today, and am off for the rest of the week. I'll try to look early next week. Don't forget to update the llvm-readelf documentation.

[grimar]

• Updated documentation to mention the new option.

[jhenderson]

llvm-readelf -S is actually an equivalent to readelf -S --wide in terms of formatting. It probably makes sense for us to do the same with -t (i.e. match the wide formatting), with all the content except the flags on one line.

llvm/test/tools/llvm-readobj/ELF/section-details.test

4

20

We should have at least one section with a long name that goes beyond the first column width, I think.

22

Any reason not to have all 5s for the entsize? What about a high alignment (since the addralign field is much wider than one byte)?

76

Is UNKNOWN printed for "known" OS/Processor specific flags with GNU readelf?

159

When reading this comment, I was expecting to see --sections win when specified first (latter could mean the latter as specified on the command-line).

168

I'd move this case to be immediately after the "standard" 64-bit case.

llvm/tools/llvm-readobj/ELFDumper.cpp

4205

Test case?

4213–4214

Shouldn't this use reportUniqueWarning? Also, test case?

4267

[grimar]

• Addressed review comments.

Now depends on D90019

[grimar]

llvm/test/tools/llvm-readobj/ELF/section-details.test

22

Done.

76

GNU readelf prints the following for sh_flags = 0xffffffffffffffff:

[ffffffffffffffff]: WRITE, ALLOC, EXEC, MERGE, STRINGS, INFO LINK, LINK ORDER, OS NONCONF, GROUP, TLS, COMPRESSED, GNU_MBIND, EXCLUDE, OS (000000000ef00000), PROC (0000000070000000), UNKNOWN (ffffffff000ff008)

I.e. it prints "OS", "PROC" and "UNKNOWN" separatelly. I've updated implementation to follow.

llvm/tools/llvm-readobj/ELFDumper.cpp

4213–4214

I've added a single test case that covers both warnings.
(Sorry, I think I just forgot about these places initially).

[jhenderson]

LGTM, thanks.

llvm/test/tools/llvm-readobj/ELF/section-details.test

76

(grumbles quietly about SHF_EXCLUDE usurping a bit from the processor-specific range making the PROC value not match SHF_MASK_PROC...)

[MaskRay]

llvm/test/tools/llvm-readobj/ELF/section-details.test

76

This is unfortunate but many architectures using this bit for other purposes are not supported by LLVM at all:)

llvm/docs/CommandGuide/llvm-readelf.rst

 
  Display all sections.
 
 .. option:: --section-data
 
  When used with :option:`--sections`, display section data for each section
  shown. This option has no effect for GNU style output.
 
+.. option:: --section-details, -t
+
+ Display all section details. Used as an alternative to :option:`--sections`.
+
 .. option:: --section-mapping
 
  Display the section to segment mapping.
 
 .. option:: --section-relocations
 
  When used with :option:`--sections`, display relocations for each section
  shown. This option has no effect for GNU style output.

llvm/test/tools/llvm-readobj/ELF/section-details.test

+## Check how llvm-readelf prints section details with --section-details.
+
+## Check the output for the 64-bit case.
+# RUN: yaml2obj %s -DBITS=64 -o %t64.o
+# RUN: llvm-readelf %t64.o --section-details | \
+# RUN:   FileCheck %s --strict-whitespace --match-full-lines --check-prefix=GNU64
+
+#       GNU64:There are 19 section headers, starting at offset 0xf8:
+# GNU64-EMPTY:
+#  GNU64-NEXT:Section Headers:
+#  GNU64-NEXT:  [Nr] Name
+#  GNU64-NEXT:       Type            Address          Off    Size   ES   Lk Inf Al
+#  GNU64-NEXT:       Flags
+#  GNU64-NEXT:  [ 0] {{$}}
+#  GNU64-NEXT:       NULL            0000000000000000 000000 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000000]: {{$}}
+#  GNU64-NEXT:  [ 1] allflags_and_long_fields
+#  GNU64-NEXT:       PROGBITS        1111111111111111 2222222222222222 4444444444444444 5555555555555555 858993459 1717986918 8608480567731124087
+#  GNU64-NEXT:       [ffffffffffffffff]: WRITE, ALLOC, EXEC, MERGE, STRINGS, INFO LINK, LINK ORDER, OS NONCONF, GROUP, TLS, COMPRESSED, EXCLUDE, OS (000000000ff00000), PROC (0000000070000000), UNKNOWN (ffffffff000ff008)
+#  GNU64-NEXT:  [ 2] noflags
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000000]: {{$}}
+#  GNU64-NEXT:  [ 3] write
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000001]: WRITE
+#  GNU64-NEXT:  [ 4] alloc
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000002]: ALLOC
+#  GNU64-NEXT:  [ 5] exec
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000004]: EXEC
+#  GNU64-NEXT:  [ 6] merge
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000010]: MERGE
+#  GNU64-NEXT:  [ 7] strings
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000020]: STRINGS
+#  GNU64-NEXT:  [ 8] infolink
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000040]: INFO LINK
+#  GNU64-NEXT:  [ 9] linkorder
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000080]: LINK ORDER
+#  GNU64-NEXT:  [10] nonconforming
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000100]: OS NONCONF
+#  GNU64-NEXT:  [11] group
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000200]: GROUP
+#  GNU64-NEXT:  [12] tls
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000400]: TLS
+#  GNU64-NEXT:  [13] compressed
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000000000800]: COMPRESSED
+#  GNU64-NEXT:  [14] exclude
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [0000000080000000]: EXCLUDE
+#  GNU64-NEXT:  [15] known_and_unknown
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [00000000000f0003]: WRITE, ALLOC, UNKNOWN (00000000000f0000)
+#  GNU64-NEXT:  [16] only_unknown
+#  GNU64-NEXT:       PROGBITS        0000000000000000 000040 000000 00   0   0  0
+#  GNU64-NEXT:       [00000000000f0000]: UNKNOWN (00000000000f0000)
+#  GNU64-NEXT:  [17] .strtab
+#  GNU64-NEXT:       STRTAB          0000000000000000 000040 000001 00   0   0  1
+#  GNU64-NEXT:       [0000000000000000]: {{$}}
+#  GNU64-NEXT:  [18] .shstrtab
+#  GNU64-NEXT:       STRTAB          0000000000000000 000041 0000b0 00   0   0  1
+#  GNU64-NEXT:       [0000000000000000]: {{$}}
+#  GNU64-NOT:{{.}}
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS[[BITS]]
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+  Flags: []
+Sections:
+  - Name:        allflags_and_long_fields
+    Type:        SHT_PROGBITS
+    ShFlags:     0xffffffffffffffff
+    Address:     0x1111111111111111
+    ShOffset:    0x2222222222222222
+    Link:        0x33333333
+    ShSize:      0x4444444444444444
+    EntSize:     0x5555555555555555
+    Info:        0x66666666
+    ShAddrAlign: 0x7777777777777777
+  - Name:  noflags
+    Type:  SHT_PROGBITS
+    Flags: [ ]
+  - Name:  write
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_WRITE ]
+  - Name:  alloc
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC ]
+  - Name:  exec
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_EXECINSTR ]
+  - Name:  merge
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_MERGE ]
+  - Name:  strings
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_STRINGS ]
+  - Name:  infolink
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_INFO_LINK ]
+  - Name:  linkorder
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_LINK_ORDER ]
+  - Name:  nonconforming
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_OS_NONCONFORMING ]
+  - Name:  group
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_GROUP ]
+  - Name:  tls
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_TLS ]
+  - Name:  compressed
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_COMPRESSED ]
+  - Name:  exclude
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_EXCLUDE ]
+  - Name:  known_and_unknown
+    Type:  SHT_PROGBITS
+    ShFlags: 0x000f0003
+  - Name:  only_unknown
+    Type:  SHT_PROGBITS
+    ShFlags: 0x000f0000
+
+## Check the output for the 32-bit case.
+# RUN: yaml2obj %s -DBITS=32 -o %t32.o
+# RUN: llvm-readelf %t32.o --section-details | \
+# RUN:   FileCheck %s --strict-whitespace --match-full-lines --check-prefix=GNU32
+
+#       GNU32:There are 19 section headers, starting at offset 0xe8:
+# GNU32-EMPTY:
+#  GNU32-NEXT:Section Headers:
+#  GNU32-NEXT:  [Nr] Name
+#  GNU32-NEXT:       Type            Addr     Off    Size   ES   Lk Inf Al
+#  GNU32-NEXT:       Flags
+#  GNU32-NEXT:  [ 0] {{$}}
+#  GNU32-NEXT:       NULL            00000000 000000 000000 00   0   0  0
+#  GNU32-NEXT:       [00000000]: {{$}}
+#  GNU32-NEXT:  [ 1] allflags_and_long_fields
+#  GNU32-NEXT:       PROGBITS        11111111 22222222 44444444 55555555 858993459 1717986918 2004318071
+#  GNU32-NEXT:       [ffffffff]: WRITE, ALLOC, EXEC, MERGE, STRINGS, INFO LINK, LINK ORDER, OS NONCONF, GROUP, TLS, COMPRESSED, EXCLUDE, OS (0ff00000), PROC (70000000), UNKNOWN (000ff008)
+#  GNU32-NEXT:  [ 2] noflags
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000000]: {{$}}
+#  GNU32-NEXT:  [ 3] write
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000001]: WRITE
+#  GNU32-NEXT:  [ 4] alloc
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000002]: ALLOC
+#  GNU32-NEXT:  [ 5] exec
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000004]: EXEC
+#  GNU32-NEXT:  [ 6] merge
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000010]: MERGE
+#  GNU32-NEXT:  [ 7] strings
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000020]: STRINGS
+#  GNU32-NEXT:  [ 8] infolink
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000040]: INFO LINK
+#  GNU32-NEXT:  [ 9] linkorder
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000080]: LINK ORDER
+#  GNU32-NEXT:  [10] nonconforming
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000100]: OS NONCONF
+#  GNU32-NEXT:  [11] group
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000200]: GROUP
+#  GNU32-NEXT:  [12] tls
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000400]: TLS
+#  GNU32-NEXT:  [13] compressed
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [00000800]: COMPRESSED
+#  GNU32-NEXT:  [14] exclude
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [80000000]: EXCLUDE
+#  GNU32-NEXT:  [15] known_and_unknown
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [000f0003]: WRITE, ALLOC, UNKNOWN (000f0000)
+#  GNU32-NEXT:  [16] only_unknown
+#  GNU32-NEXT:       PROGBITS        00000000 000034 000000 00   0   0  0
+#  GNU32-NEXT:       [000f0000]: UNKNOWN (000f0000)
+#  GNU32-NEXT:  [17] .strtab
+#  GNU32-NEXT:       STRTAB          00000000 000034 000001 00   0   0  1
+#  GNU32-NEXT:       [00000000]: {{$}}
+#  GNU32-NEXT:  [18] .shstrtab
+#  GNU32-NEXT:       STRTAB          00000000 000035 0000b0 00   0   0  1
+#  GNU32-NEXT:       [00000000]: {{$}}
+#  GNU32-NOT:{{.}}
+
+## When --section-details and --sections are both specified, --sections is ignored.
+# RUN: llvm-readelf %t64.o --section-details --sections | FileCheck %s --check-prefix=GNU64
+# RUN: llvm-readelf %t64.o --sections --section-details | FileCheck %s --check-prefix=GNU64
+
+## Check that we produce the same output with -t (alias).
+# RUN: llvm-readelf --section-details %t64.o > %t.readelf.full
+# RUN: llvm-readelf -t %t64.o > %t.readelf.alias
+# RUN: cmp %t.readelf.full %t.readelf.alias
+
+## Check how we dump sections when the section header string table can't be read.
+
+# RUN: yaml2obj --docnum=2 %s -o %tshstrndx.o
+# RUN: llvm-readelf %tshstrndx.o --section-details 2>&1 | \
+# RUN:   FileCheck %s -DFILE=%tshstrndx.o --check-prefix=SHSTRNDX
+
+# SHSTRNDX:      Section Headers:
+# SHSTRNDX-NEXT:   [Nr] Name
+# SHSTRNDX-NEXT:        Type            Address          Off    Size   ES   Lk Inf Al
+# SHSTRNDX-NEXT:        Flags
+# SHSTRNDX-NEXT: warning: '[[FILE]]': section header string table index 65279 does not exist
+# SHSTRNDX-NEXT:   [ 0]
+# SHSTRNDX-NEXT:        NULL            0000000000000000 000000 000000 00   0   0  0
+# SHSTRNDX-NEXT:        [0000000000000000]:
+# SHSTRNDX-NEXT: warning: '[[FILE]]': a section [index 1] has an invalid sh_name (0x5) offset which goes past the end of the section name string table
+# SHSTRNDX-NEXT:   [ 1] <?>
+# SHSTRNDX-NEXT:        PROGBITS        0000000000000000 000040 000000 00   0   0  0
+# SHSTRNDX-NEXT:        [0000000000000000]:
+# SHSTRNDX-NEXT: warning: '[[FILE]]': a section [index 2] has an invalid sh_name (0x1) offset which goes past the end of the section name string table
+# SHSTRNDX-NEXT:   [ 2] <?>
+# SHSTRNDX-NEXT:        PROGBITS        0000000000000000 000040 000000 00   0   0  0
+# SHSTRNDX-NEXT:        [0000000000000000]:
+# SHSTRNDX-NEXT: warning: '[[FILE]]': a section [index 3] has an invalid sh_name (0x13) offset which goes past the end of the section name string table
+# SHSTRNDX-NEXT:   [ 3] <?>
+# SHSTRNDX-NEXT:        STRTAB          0000000000000000 000040 000001 00   0   0  1
+# SHSTRNDX-NEXT:        [0000000000000000]:
+# SHSTRNDX-NEXT: warning: '[[FILE]]': a section [index 4] has an invalid sh_name (0x9) offset which goes past the end of the section name string table
+# SHSTRNDX-NEXT:   [ 4] <?>
+# SHSTRNDX-NEXT:        STRTAB          0000000000000000 000041 00001b 00   0   0  1
+# SHSTRNDX-NEXT:        [0000000000000000]:
+
+--- !ELF
+FileHeader:
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_REL
+  EShStrNdx: 0xfeff
+Sections:
+  - Name: foo
+    Type: SHT_PROGBITS
+  - Name: bar
+    Type: SHT_PROGBITS

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

 # RUN: llvm-readobj -t %t64 > %t.t
 # RUN: cmp %t.symbols %t.t
 # RUN: llvm-readelf -s --elf-output-style=LLVM %t64 > %t.lowers
 # RUN: cmp %t.symbols %t.lowers
 
 # RUN: llvm-readelf --symbols %t64 > %t.symbols.gnu
 # RUN: llvm-readelf --syms %t64 > %t.syms.gnu
 # RUN: cmp %t.symbols.gnu %t.syms.gnu
-## There is no -t option in llvm-readelf.
-# RUN: not llvm-readelf -t %t64 2>&1 | FileCheck %s --check-prefix=NO-T-ERR
-# NO-T-ERR: Unknown command line argument '-t'
+
 ## -s is an llvm-readobj option to dump sections.
 # RUN: llvm-readobj -s --elf-output-style=GNU %t64 | FileCheck %s --implicit-check-not="Symbol table"
 
 ## Case 3: Test that both regular and dynamic symbols are dumped when `--symbols` and `--dyn-symbols`
 ##         are specified together. Note that the order is different for different styles.
 # RUN: llvm-readobj --symbols --dyn-symbols %t64 | FileCheck %s --check-prefix=BOTH-LLVM
 # RUN: llvm-readelf --symbols --dyn-symbols %t64 | FileCheck %s --check-prefix=BOTH-GNU
 

llvm/test/tools/llvm-readobj/basic.test

 RUN: llvm-readelf --help | FileCheck %s --check-prefixes=HELP,ELF
 HELP: OVERVIEW: LLVM Object Reader
 OBJ: llvm-readobj{{.*}} [options] <input object files>
 ELF: llvm-readelf{{.*}} [options] <input object files>
 HELP: OPTIONS:
 OBJ: -s - Alias for --section-headers
 OBJ: -t - Alias for --symbols
 ELF: -s - Alias for --symbols
-ELF-NOT: {{ }}-t{{ }}
+ELF: -t - Alias for --section-details
 HELP: @FILE

llvm/tools/llvm-readobj/ELFDumper.cpp

public:
 
   void printFileHeaders() override;
   void printSectionHeaders() override;
   void printRelocations() override;
   void printDependentLibs() override;
   void printDynamicRelocations() override;
   void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
   void printHashSymbols() override;
+  void printSectionDetails() override;
   void printUnwindInfo() override;
 
   void printDynamicTable() override;
   void printNeededLibraries() override;
   void printProgramHeaders(bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printHashTable() override;
   void printGnuHashTable() override;
public:
   virtual ~DumpStyle() = default;
 
   virtual void printFileHeaders() = 0;
   virtual void printGroupSections() = 0;
   virtual void printRelocations() = 0;
   virtual void printSectionHeaders() = 0;
   virtual void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) = 0;
   virtual void printHashSymbols() {}
+  virtual void printSectionDetails() {}
   virtual void printDependentLibs() = 0;
   virtual void printDynamic() {}
   virtual void printDynamicRelocations() = 0;
   virtual void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset,
                                   bool NonVisibilityBitsUsed) {}
   virtual void printSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
                            Optional<StringRef> StrTable, bool IsDynamic,
                            bool NonVisibilityBitsUsed) = 0;
public:
   }
 
   void printFileHeaders() override;
   void printGroupSections() override;
   void printRelocations() override;
   void printSectionHeaders() override;
   void printSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
   void printHashSymbols() override;
+  void printSectionDetails() override;
   void printDependentLibs() override;
   void printDynamic() override;
   void printDynamicRelocations() override;
   void printSymtabMessage(const Elf_Shdr *Symtab, size_t Offset,
                           bool NonVisibilityBitsUsed) override;
   void printProgramHeaders(bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printVersionSymbolSection(const Elf_Shdr *Sec) override;
void ELFDumper<ELFT>::printSymbols(bool PrintSymbols,
                                    bool PrintDynamicSymbols) {
   ELFDumperStyle->printSymbols(PrintSymbols, PrintDynamicSymbols);
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printHashSymbols() {
   ELFDumperStyle->printHashSymbols();
 }
 
+template <class ELFT> void ELFDumper<ELFT>::printSectionDetails() {
+  ELFDumperStyle->printSectionDetails();
+}
+
 template <class ELFT> void ELFDumper<ELFT>::printHashHistograms() {
   ELFDumperStyle->printHashHistograms();
 }
 
 template <class ELFT> void ELFDumper<ELFT>::printCGProfile() {
   ELFDumperStyle->printCGProfile();
 }
 
if (const Elf_GnuHash *GnuHash = this->dumper().getGnuHashTable()) {
 
     if (Error E = checkGNUHashTable<ELFT>(this->Obj, GnuHash))
       this->reportUniqueWarning(std::move(E));
     else
       printGnuHashTableSymbols(*GnuHash);
   }
 }
 
+template <class ELFT> void GNUStyle<ELFT>::printSectionDetails() {
+  ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections());
+  OS << "There are " << to_string(Sections.size())
+     << " section headers, starting at offset "
+     << "0x" << to_hexString(this->Obj.getHeader().e_shoff, false) << ":\n\n";
+
+  OS << "Section Headers:\n";
+
+  auto PrintFields = [&](ArrayRef<Field> V) {
+    for (const Field &F : V)
+      printField(F);
+    OS << "\n";
+  };
+
+  PrintFields({{"[Nr]", 2}, {"Name", 7}});
+
+  constexpr bool Is64 = ELFT::Is64Bits;
+  PrintFields({{"Type", 7},
+               {Is64 ? "Address" : "Addr", 23},
+               {"Off", Is64 ? 40 : 32},
+               {"Size", Is64 ? 47 : 39},
+               {"ES", Is64 ? 54 : 46},
+               {"Lk", Is64 ? 59 : 51},
+               {"Inf", Is64 ? 62 : 54},
+               {"Al", Is64 ? 66 : 57}});
+  PrintFields({{"Flags", 7}});
+
+  StringRef SecStrTable;
+  if (Expected<StringRef> SecStrTableOrErr = this->Obj.getSectionStringTable(
+          Sections, this->dumper().WarningHandler))
+    SecStrTable = *SecStrTableOrErr;
+  else
+    this->reportUniqueWarning(SecStrTableOrErr.takeError());
+
+  size_t SectionIndex = 0;
+  const unsigned AddrSize = Is64 ? 16 : 8;
+  for (const Elf_Shdr &S : Sections) {
+    StringRef Name = "<?>";
+    if (Expected<StringRef> NameOrErr =
+            this->Obj.getSectionName(S, SecStrTable))
+      Name = *NameOrErr;
+    else
+      this->reportUniqueWarning(NameOrErr.takeError());
+
+    OS.PadToColumn(2);
+    OS << "[" << right_justify(to_string(SectionIndex), 2) << "]";
+    PrintFields({{Name, 7}});
+    PrintFields(
+        {{getSectionTypeString(this->Obj.getHeader().e_machine, S.sh_type), 7},
+         {to_string(format_hex_no_prefix(S.sh_addr, AddrSize)), 23},
+         {to_string(format_hex_no_prefix(S.sh_offset, 6)), Is64 ? 39 : 32},
+         {to_string(format_hex_no_prefix(S.sh_size, 6)), Is64 ? 47 : 39},
+         {to_string(format_hex_no_prefix(S.sh_entsize, 2)), Is64 ? 54 : 46},
+         {to_string(S.sh_link), Is64 ? 59 : 51},
+         {to_string(S.sh_info), Is64 ? 63 : 55},
+         {to_string(S.sh_addralign), Is64 ? 66 : 58}});
+
+    OS.PadToColumn(7);
+    OS << "[" << to_string(format_hex_no_prefix(S.sh_flags, AddrSize)) << "]: ";
+
+    DenseMap<unsigned, StringRef> FlagToName = {
+        {SHF_WRITE, "WRITE"},           {SHF_ALLOC, "ALLOC"},
+        {SHF_EXECINSTR, "EXEC"},        {SHF_MERGE, "MERGE"},
+        {SHF_STRINGS, "STRINGS"},       {SHF_INFO_LINK, "INFO LINK"},
+        {SHF_LINK_ORDER, "LINK ORDER"}, {SHF_OS_NONCONFORMING, "OS NONCONF"},
+        {SHF_GROUP, "GROUP"},           {SHF_TLS, "TLS"},
+        {SHF_COMPRESSED, "COMPRESSED"}, {SHF_EXCLUDE, "EXCLUDE"}};
+
+    uint64_t Flags = S.sh_flags;
+    uint64_t UnknownFlags = 0;
+    bool NeedsComma = false;
+    while (Flags) {
+      // Take the least significant bit as a flag.
+      uint64_t Flag = Flags & -Flags;
+      Flags -= Flag;
+
+      auto It = FlagToName.find(Flag);
+      if (It != FlagToName.end()) {
+        if (NeedsComma)
+          OS << ", ";
+        NeedsComma = true;
+        OS << It->second;
+      } else {
+        UnknownFlags |= Flag;
+      }
+    }
+
+    auto PrintUnknownFlags = [&](uint64_t Mask, StringRef Name) {
+      uint64_t FlagsToPrint = UnknownFlags & Mask;
+      if (!FlagsToPrint)
+        return;
+
+      if (NeedsComma)
+        OS << ", ";
+      OS << Name << " ("
+         << to_string(format_hex_no_prefix(FlagsToPrint, AddrSize)) << ")";
+      UnknownFlags &= ~Mask;
+      NeedsComma = true;
+    };
+
+    PrintUnknownFlags(SHF_MASKOS, "OS");
+    PrintUnknownFlags(SHF_MASKPROC, "PROC");
+    PrintUnknownFlags(uint64_t(-1), "UNKNOWN");
+
+    OS << "\n";
+    ++SectionIndex;
+  }
+}
+
 static inline std::string printPhdrFlags(unsigned Flag) {
   std::string Str;
   Str = (Flag & PF_R) ? "R" : " ";
   Str += (Flag & PF_W) ? "W" : " ";
   Str += (Flag & PF_X) ? "E" : " ";
   return Str;
 }
 

llvm/tools/llvm-readobj/ObjDumper.h

public:
   virtual void printVersionInfo() {}
   virtual void printGroupSections() {}
   virtual void printHashHistograms() {}
   virtual void printCGProfile() {}
   virtual void printAddrsig() {}
   virtual void printNotes() {}
   virtual void printELFLinkerOptions() {}
   virtual void printStackSizes() {}
-  virtual void printArchSpecificInfo() { }
+  virtual void printSectionDetails() {}
+  virtual void printArchSpecificInfo() {}
 
   // Only implemented for PE/COFF.
   virtual void printCOFFImports() { }
   virtual void printCOFFExports() { }
   virtual void printCOFFDirectives() { }
   virtual void printCOFFBaseReloc() { }
   virtual void printCOFFDebugDirectory() { }
   virtual void printCOFFTLSDirectory() {}

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

namespace opts {
   // --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"));
 
+  // --section-details
+  // Also -t in llvm-readelf mode.
+  cl::opt<bool> SectionDetails("section-details",
+                               cl::desc("Display the section details"));
+
   // --symbols
   // Also -s in llvm-readelf mode, or -t in llvm-readobj mode.
   cl::opt<bool>
       Symbols("symbols",
               cl::desc("Display the symbol table. Also display the dynamic "
                        "symbol table when using GNU output style for ELF"));
   cl::alias SymbolsGNU("syms", cl::desc("Alias for --symbols"),
                        cl::aliasopt(Symbols));
if (opts::Output == opts::LLVM) {
     Writer.printString(
         "AddressSize",
         std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress())));
     Dumper->printLoadName();
   }
 
   if (opts::FileHeaders)
     Dumper->printFileHeaders();
-  if (opts::SectionHeaders)
+
+  if (opts::SectionDetails || opts::SectionHeaders) {
+    if (opts::Output == opts::GNU && opts::SectionDetails)
+      Dumper->printSectionDetails();
+    else
       Dumper->printSectionHeaders();
+  }
+
   if (opts::HashSymbols)
     Dumper->printHashSymbols();
   if (opts::ProgramHeaders || opts::SectionMapping == cl::BOU_TRUE)
     Dumper->printProgramHeaders(opts::ProgramHeaders, opts::SectionMapping);
   if (opts::DynamicTable)
     Dumper->printDynamicTable();
   if (opts::NeededLibraries)
     Dumper->printNeededLibraries();

 /// 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).
+  // llvm-readelf reserves it for --section-details.
   static cl::alias SymbolsShort("t", cl::desc("Alias for --symbols"),
                                 cl::aliasopt(opts::Symbols), cl::NotHidden);
 
   // The following two-letter aliases are only provided for readobj, as readelf
   // allows single-letter args to be grouped together.
   static cl::alias SectionRelocationsShort(
       "sr", cl::desc("Alias for --section-relocations"),
       cl::aliasopt(opts::SectionRelocations));

 
 /// 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,
                                 cl::Grouping);
 
+  // -t is here because for readobj it is an alias for --symbols.
+  static cl::alias SectionDetailsShort(
+      "t", cl::desc("Alias for --section-details"),
+      cl::aliasopt(opts::SectionDetails), cl::NotHidden);
+
   // Allow all single letter flags to be grouped together.
   for (auto &OptEntry : cl::getRegisteredOptions()) {
     StringRef ArgName = OptEntry.getKey();
     cl::Option *Option = OptEntry.getValue();
     if (ArgName.size() == 1)
       apply(Option, cl::Grouping);
   }
 }