[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

3

19

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

21

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

75

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

158

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

167

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

21

Done.

75

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

75

(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

75

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 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 0xe8:
+# GNU64-EMPTY:
+#  GNU64-NEXT:Section Headers:
+#  GNU64-NEXT:  [Nr] Name
+#  GNU64-NEXT:       Type              Address          Offset            Link
+#  GNU64-NEXT:       Size              EntSize          Info              Align
+#  GNU64-NEXT:       Flags
+#  GNU64-NEXT:  [ 0] {{$}}
+#  GNU64-NEXT:       NULL              0000000000000000 0000000000000000  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000000]: {{$}}
+#  GNU64-NEXT:  [ 1] allflags
+#  GNU64-NEXT:       PROGBITS          1111111111111111 2222222222222222  3
+#  GNU64-NEXT:       4444444444444444  0000000000000005 6                 7
+#  GNU64-NEXT:       [0000000080000ff7]: WRITE, ALLOC, EXEC, MERGE, STRINGS, INFO LINK, LINK ORDER, OS NONCONF, GROUP, TLS, COMPRESSED, EXCLUDE
+#  GNU64-NEXT:  [ 2] noflags
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000000]: {{$}}
+#  GNU64-NEXT:  [ 3] write
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000001]: WRITE
+#  GNU64-NEXT:  [ 4] alloc
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000002]: ALLOC
+#  GNU64-NEXT:  [ 5] exec
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000004]: EXEC
+#  GNU64-NEXT:  [ 6] merge
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000010]: MERGE
+#  GNU64-NEXT:  [ 7] strings
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000020]: STRINGS
+#  GNU64-NEXT:  [ 8] infolink
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000040]: INFO LINK
+#  GNU64-NEXT:  [ 9] linkorder
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000080]: LINK ORDER
+#  GNU64-NEXT:  [10] nonconforming
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000100]: OS NONCONF
+#  GNU64-NEXT:  [11] group
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000200]: GROUP
+#  GNU64-NEXT:  [12] tls
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000400]: TLS
+#  GNU64-NEXT:  [13] compressed
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000000000800]: COMPRESSED
+#  GNU64-NEXT:  [14] exclude
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [0000000080000000]: EXCLUDE
+#  GNU64-NEXT:  [15] known_and_unknown
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [00000000000f0003]: WRITE, ALLOC, UNKNOWN (00000000000f0000)
+#  GNU64-NEXT:  [16] only_unknown
+#  GNU64-NEXT:       PROGBITS          0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000000  0000000000000000 0                 0
+#  GNU64-NEXT:       [00000000000f0000]: UNKNOWN (00000000000f0000)
+#  GNU64-NEXT:  [17] .strtab
+#  GNU64-NEXT:       STRTAB            0000000000000000 0000000000000046  0
+#  GNU64-NEXT:       0000000000000001  0000000000000000 0                 1
+#  GNU64-NEXT:       [0000000000000000]: {{$}}
+#  GNU64-NEXT:  [18] .shstrtab
+#  GNU64-NEXT:       STRTAB            0000000000000000 0000000000000047  0
+#  GNU64-NEXT:       00000000000000a0  0000000000000000 0                 1
+#  GNU64-NEXT:       [0000000000000000]: {{$}}
+#  GNU64-NOT:{{.}}
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS[[BITS]]
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+  Flags: []
+Sections:
+  - Name:  allflags
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_WRITE, SHF_ALLOC, SHF_EXECINSTR, SHF_MERGE,
+            SHF_STRINGS, SHF_INFO_LINK, SHF_LINK_ORDER, SHF_OS_NONCONFORMING,
+            SHF_GROUP, SHF_TLS, SHF_COMPRESSED, SHF_EXCLUDE ]
+    Address:      0x1111111111111111
+    ShOffset:     0x2222222222222222
+    Link:         0x3
+    ShSize:       0x4444444444444444
+    EntSize:      0x5
+    Info:         0x6
+    AddressAlign: 0x7
+  - 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
+
+## When --section-details and --sections are both specified, the latter one 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 the output for 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 0xdc:
+# GNU32-EMPTY:
+#  GNU32-NEXT:Section Headers:
+#  GNU32-NEXT:  [Nr] Name
+#  GNU32-NEXT:       Type            Addr     Off      Size     ES   Lk Inf Al
+#  GNU32-NEXT:  [ 0] {{$}}
+#  GNU32-NEXT:       NULL            00000000 00000000 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000000]: {{$}}
+#  GNU32-NEXT:  [ 1] allflags
+#  GNU32-NEXT:       PROGBITS        11111111 22222222 44444444 05   3   6  7
+#  GNU32-NEXT:       [80000ff7]: WRITE, ALLOC, EXEC, MERGE, STRINGS, INFO LINK, LINK ORDER, OS NONCONF, GROUP, TLS, COMPRESSED, EXCLUDE
+#  GNU32-NEXT:  [ 2] noflags
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000000]: {{$}}
+#  GNU32-NEXT:  [ 3] write
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000001]: WRITE
+#  GNU32-NEXT:  [ 4] alloc
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000002]: ALLOC
+#  GNU32-NEXT:  [ 5] exec
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000004]: EXEC
+#  GNU32-NEXT:  [ 6] merge
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000010]: MERGE
+#  GNU32-NEXT:  [ 7] strings
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000020]: STRINGS
+#  GNU32-NEXT:  [ 8] infolink
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000040]: INFO LINK
+#  GNU32-NEXT:  [ 9] linkorder
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000080]: LINK ORDER
+#  GNU32-NEXT:  [10] nonconforming
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000100]: OS NONCONF
+#  GNU32-NEXT:  [11] group
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000200]: GROUP
+#  GNU32-NEXT:  [12] tls
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000400]: TLS
+#  GNU32-NEXT:  [13] compressed
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [00000800]: COMPRESSED
+#  GNU32-NEXT:  [14] exclude
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [80000000]: EXCLUDE
+#  GNU32-NEXT:  [15] known_and_unknown
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [000f0003]: WRITE, ALLOC, UNKNOWN (000f0000)
+#  GNU32-NEXT:  [16] only_unknown
+#  GNU32-NEXT:       PROGBITS        00000000 00000038 00000000 00   0   0  0
+#  GNU32-NEXT:       [000f0000]: UNKNOWN (000f0000)
+#  GNU32-NEXT:  [17] .strtab
+#  GNU32-NEXT:       STRTAB          00000000 00000038 00000001 00   0   0  1
+#  GNU32-NEXT:       [00000000]: {{$}}
+#  GNU32-NEXT:  [18] .shstrtab
+#  GNU32-NEXT:       STRTAB          00000000 00000039 000000a0 00   0   0  1
+#  GNU32-NEXT:       [00000000]: {{$}}
+#  GNU32-NOT:{{.}}

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}});
+
+  if (ELFT::Is64Bits) {
+    PrintFields({{"Type", 7}, {"Address", 25}, {"Offset", 42}, {"Link", 60}});
+    PrintFields({{"Size", 7}, {"EntSize", 25}, {"Info", 42}, {"Align", 60}});
+    PrintFields({{"Flags", 7}});
+  } else {
+    PrintFields({{"Type", 7},
+                 {"Addr", 23},
+                 {"Off", 32},
+                 {"Size", 41},
+                 {"ES", 50},
+                 {"Lk", 55},
+                 {"Inf", 58},
+                 {"Al", 61}});
+  }
+
+  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 = ELFT::Is64Bits ? 16 : 8;
+  for (const Elf_Shdr &S : Sections) {
+    OS.PadToColumn(2);
+    OS << "[" << right_justify(to_string(SectionIndex), 2) << "]";
+
+    StringRef Name = unwrapOrError<StringRef>(
+        this->FileName, this->Obj.getSectionName(S, SecStrTable));
+    PrintFields({{Name, 7}});
+
+    if (ELFT::Is64Bits) {
+      PrintFields(
+          {{getSectionTypeString(this->Obj.getHeader().e_machine, S.sh_type),
+            7},
+           {to_string(format_hex_no_prefix(S.sh_addr, AddrSize)), 25},
+           {to_string(format_hex_no_prefix(S.sh_offset, AddrSize)), 42},
+           {to_string(format_hex_no_prefix(S.sh_link, 1)), 60}});
+
+      PrintFields(
+          {{to_string(format_hex_no_prefix(S.sh_size, AddrSize)), 7},
+           {to_string(format_hex_no_prefix(S.sh_entsize, AddrSize)), 25},
+           {to_string(format_hex_no_prefix(S.sh_info, 1)), 42},
+           {to_string(format_hex_no_prefix(S.sh_addralign, 1)), 60}});
+    } else {
+      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, AddrSize)), 32},
+           {to_string(format_hex_no_prefix(S.sh_size, AddrSize)), 39},
+           {to_string(format_hex_no_prefix(S.sh_entsize, 2)), 50},
+           {to_string(format_hex_no_prefix(S.sh_link, 1)), 55},
+           {to_string(format_hex_no_prefix(S.sh_info, 1)), 59},
+           {to_string(format_hex_no_prefix(S.sh_addralign, 1)), 62}});
+    }
+
+    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 First = true;
+    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 (!First)
+          OS << ", ";
+        First = false;
+        OS << (*It).second;
+      } else {
+        UnknownFlags |= Flag;
+      }
+    }
+
+    if (UnknownFlags != 0) {
+      if (!First)
+        OS << ", ";
+      OS << "UNKNOWN ("
+         << to_string(format_hex_no_prefix(UnknownFlags, AddrSize)) << ")";
+    }
+
+    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);
   }
 }