[llvm-readobj] - Refine the LLVM-style output to be consistent.

[grimar]

Summary

Our LLVM-style output was inconsistent.
This patch changes the output in the following way:

1. SHT_GNU_verdef { -> VersionDefinitions [
2. SHT_GNU_verneed { -> VersionRequirements [
3. Version symbols [ -> VersionSymbols [
4. EH_FRAME Header [ -> EHFrameHeader {

[jhenderson]

Did you remember to run LLD tests? I'd expect to see changes there...

tools/llvm-readobj/DwarfCFIEHPrinter.h

102

The data printed isn't a list, because it prints some metadata. I think this should be a dictionary too.

tools/llvm-readobj/ELFDumper.cpp

5128

I don't think the ElfHeader should be a ListScope: it's not a list, but a dictionary (unlike, say, symbols).

5598

Ditto, though I'm wondering here why the VersionSymbols data includes stuff to do with its section header? If it didn't have that stuff, it would be a list.

[grimar]

In D68636#1699479, @jhenderson wrote:

Did you remember to run LLD tests? I'd expect to see changes there...

Sure. That will be a separate change, once we agree with LLVM side.

[grimar]

tools/llvm-readobj/ELFDumper.cpp

5598

though I'm wondering here why the VersionSymbols data includes stuff to do with its section header?

I do not know. The same information is printed under "Sections [" tag anyways, so it is not useful probably:

Section {
  Index: 3
  Name: .gnu.version (30)
  Type: SHT_GNU_versym (0x6FFFFFFF)
  Flags [ (0x0)
  ]
  Address: 0x0
  Offset: 0xB4
  Size: 2
  Link: 0
  Info: 0
  AddressAlignment: 0
  EntrySize: 2
}

Should we remove "Section Name"/"Address"/"Offset"/"Link" and make it to be a list?

[jhenderson]

tools/llvm-readobj/ELFDumper.cpp

5598

I'd be inclined to do that personally, but it should be a separate change.

[MaskRay]

tools/llvm-readobj/ELFDumper.cpp

5598

The Linux Standard Base calls this "Symbol Version Table" but this is named "VersionSymbols" here... What do you think if we just use the regular section type name "SHT_GNU_versym"? It may improve discoverability as well.

[grimar]

• Addressed review comments.

[grimar]

tools/llvm-readobj/ELFDumper.cpp

5598

What do you think if we just use the regular section type name "SHT_GNU_versym"? It may improve discoverability as well.

I.e. this is an opposite direction to what this patch does:

SHT_GNU_verdef { -> VersionDefinitions [
SHT_GNU_verneed { -> VersionRequirements [

It will be only sections for which we use type names. Should we?

[jhenderson]

In D68636#1699484, @grimar wrote:

In D68636#1699479, @jhenderson wrote:

Did you remember to run LLD tests? I'd expect to see changes there...

Sure. That will be a separate change, once we agree with LLVM side.

Just to clarify, are you still using the SVN layout rather than the monorepo? Using the monorepo would allow having all the changes in the same patch.

Aside from the discussion on the titles of Version data, this looks good to me. I don't have a strong preference whichever way is used.

[grimar]

In D68636#1699712, @jhenderson wrote:

In D68636#1699484, @grimar wrote:

In D68636#1699479, @jhenderson wrote:

Did you remember to run LLD tests? I'd expect to see changes there...

Sure. That will be a separate change, once we agree with LLVM side.

Just to clarify, are you still using the SVN layout rather than the monorepo? Using the monorepo would allow having all the changes in the same patch.

Yes, I do not use monorepo yet. Going to switch soon as later this month svn will become readonly.

[MaskRay]

tools/llvm-readobj/ELFDumper.cpp

5598

I.e. this is an opposite direction to what this patch does:

Yes. .gnu.version is currently not consistent with .gnu.version_r and .gnu.version_d, and I know this patch tries to make them consistent.

I am not clear which direction we should go. I have a very weak preference for SHT_GNU_versym.

The naming does not seem very consistent here. While LSB names .gnu.version_r "version requirements", binutils-gdb elf.h names it "version needs section".

[rupprecht]

tools/llvm-readobj/ELFDumper.cpp

5598

Count me in the camp that (slightly) prefers seeing keys like "VersionDefinitions" rather than "SHT_GNU_verdef", though mostly on style grounds (not having a mix of CamelCase and SNAKE_CASE). However, I admit this is a bikeshed -- I think this patch (not D68704) will make things look nicer, but I have zero technical objections to it.

[grimar]

tools/llvm-readobj/ELFDumper.cpp

5598

OK. Actually D68704 contains 2 independent improvements/changes. Renaming "Version symbols {" -> "SHT_GNU_versym [" is one of them.
Another is removing of the fields and making the top tag to be a list scope instead of beeing a dictionary. It looks useful to me by itself.
I'll update it to remove the renaming and keep this one on hold to collect other possible opinions too.

[grimar]

Fangrui, so do you mean you are agree with the following renaming?

SHT_GNU_verdef { -> VersionDefinitions [
SHT_GNU_verneed { -> VersionRequirements

(this patch was in "planned changes" status and needs a rebasing, then some changes will go away I think,
but this renaming disagreement was the reason I've not update it. If it is OK for you,
I'll probably need to do one more update for it).

[MaskRay]

In D68636#1710892, @grimar wrote:

Fangrui, so do you mean you are agree with the following renaming?

SHT_GNU_verdef { -> VersionDefinitions [
SHT_GNU_verneed { -> VersionRequirements

(this patch was in "planned changes" status and needs a rebasing, then some changes will go away I think,
but this renaming disagreement was the reason I've not update it. If it is OK for you,
I'll probably need to do one more update for it).

Yes, I think the renaming is right (I was on a subway, so it was inconvenient for me to make more comments). I think I proposed a scheme that I don't like myself ;-) glibc names SHT_GNU_versym #define SHT_GNU_versym 0x6fffffff /* Version symbol table. */. It is totally fine to name it VersionSymbols here.

[grimar]

• Rebased.

test/MC/AArch64/elf-globaladdress.ll

 @globaddr = global i64* null
 
 define void @address() {
     store i64* @var64, i64** @globaddr
     ret void
 }
 
 ; Check we're using EM_AARCH64
-; OBJ: ElfHeader {
+; OBJ: ElfHeader [
 ; OBJ:   Machine: EM_AARCH64
-; OBJ: }
+; OBJ: ]
 
 ; OBJ: Relocations [
 ; OBJ:   Section {{.*}} .rela.text {
 ; OBJ:     0x{{[0-9,A-F]+}} R_AARCH64_ADR_PREL_PG_HI21   var8
 ; OBJ:     0x{{[0-9,A-F]+}} R_AARCH64_LDST8_ABS_LO12_NC  var8
 ; OBJ:     0x{{[0-9,A-F]+}} R_AARCH64_ADR_PREL_PG_HI21   var16
 ; OBJ:     0x{{[0-9,A-F]+}} R_AARCH64_LDST16_ABS_LO12_NC var16
 ; OBJ:     0x{{[0-9,A-F]+}} R_AARCH64_ADR_PREL_PG_HI21   var32

test/MC/ARM/elf-eflags-eabi.s

 @ RUN: llvm-mc %s -triple=armv7-linux-gnueabi -filetype=obj -o - | \
 @ RUN:    llvm-readobj -h | FileCheck -check-prefix=OBJ %s
   .syntax unified
   .text
   .globl  barf
   .align  2
   .type barf,%function
 barf:                                   @ @barf
 @ %bb.0:                                @ %entry
         b foo
 
 @@@ make sure the EF_ARM_EABIMASK comes out OK
-@OBJ: ElfHeader {
+@OBJ: ElfHeader [
 @OBJ:   Flags [ (0x5000000)

test/MC/ELF/basic-elf-32.s

.L.str1:
 
   .type .L.str2,@object         # @.str2
 .L.str2:
   .asciz   "World!"
   .size .L.str2, 7
 
   .section  .note.GNU-stack,"",@progbits
 
-// CHECK: ElfHeader {
+// CHECK: ElfHeader [
 // CHECK:   Class: 32-bit
 // CHECK:   DataEncoding: LittleEndian
 // CHECK:   FileVersion: 1
-// CHECK: }
+// CHECK: ]
 // CHECK: Sections [
 // CHECK:   Section {
 // CHECK:     Index: 0
 // CHECK:     Name: (0)
 
 // CHECK:     Name: .text
 
 // CHECK:     Name: .rel.text

test/MC/ELF/basic-elf-64.s

.L.str1:
 
   .type .L.str2,@object         # @.str2
 .L.str2:
   .asciz   "World!"
   .size .L.str2, 7
 
   .section  .note.GNU-stack,"",@progbits
 
-// CHECK: ElfHeader {
+// CHECK: ElfHeader [
 // CHECK:   Class: 64-bit
 // CHECK:   DataEncoding: LittleEndian
 // CHECK:   FileVersion: 1
-// CHECK: }
+// CHECK: ]
 // CHECK: Sections [
 // CHECK:   Section {
 // CHECK:     Index: 0
 // CHECK:     Name: (0)
 
 // CHECK:     Name: .text
 
 // CHECK:     Name: .rela.text

test/MC/Mips/elf_basic.s

 // 32 bit big endian
 // RUN: llvm-mc -filetype=obj -triple mips-unknown-linux %s -o - | llvm-readobj -h | FileCheck -check-prefix=CHECK-BE32 %s
 // 32 bit little endian
 // RUN: llvm-mc -filetype=obj -triple mipsel-unknown-linux %s -o - | llvm-readobj -h | FileCheck -check-prefix=CHECK-LE32 %s
 // 64 bit big endian
 // RUN: llvm-mc -filetype=obj -arch=mips64 -triple mips64-unknown-linux %s -o - | llvm-readobj -h | FileCheck -check-prefix=CHECK-BE64 %s
 // 64 bit little endian
 // RUN: llvm-mc -filetype=obj -arch=mips64el -triple mips64el-unknown-linux %s -o - | llvm-readobj -h | FileCheck -check-prefix=CHECK-LE64 %s
 
 // Check that we produce 32 bit with each endian.
 
-// CHECK-BE32: ElfHeader {
+// CHECK-BE32: ElfHeader [
 // CHECK-BE32:   Ident {
 // CHECK-BE32:     Class: 32-bit
 // CHECK-BE32:     DataEncoding: BigEndian
 // CHECK-BE32:   }
-// CHECK-BE32: }
+// CHECK-BE32: ]
 
-// CHECK-LE32: ElfHeader {
+// CHECK-LE32: ElfHeader [
 // CHECK-LE32:   Ident {
 // CHECK-LE32:     Class: 32-bit
 // CHECK-LE32:     DataEncoding: LittleEndian
 // CHECK-LE32:   }
-// CHECK-LE32: }
+// CHECK-LE32: ]
 
 // Check that we produce 64 bit with each endian.
 
-// CHECK-BE64: ElfHeader {
+// CHECK-BE64: ElfHeader [
 // CHECK-BE64:   Ident {
 // CHECK-BE64:     Class: 64-bit
 // CHECK-BE64:     DataEncoding: BigEndian
 // CHECK-BE64:   }
-// CHECK-BE64: }
+// CHECK-BE64: ]
 
-// CHECK-LE64: ElfHeader {
+// CHECK-LE64: ElfHeader [
 // CHECK-LE64:   Ident {
 // CHECK-LE64:     Class: 64-bit
 // CHECK-LE64:     DataEncoding: LittleEndian
 // CHECK-LE64:     OS/ABI: SystemV
 // CHECK-LE64:   }
-// CHECK-LE64: }
+// CHECK-LE64: ]

test/MC/Mips/elf_header.s

 # RUN: llvm-mc -filetype=obj -triple mips64el-unknown-linux -mcpu=mips64r5                                 %s -o - | llvm-readobj -h | FileCheck --check-prefixes=ALL,ELF64,LE,N64,NAN1985,MIPS64R5 %s
 # RUN: llvm-mc -filetype=obj -triple mips64el-unknown-linux -mcpu=mips64r2                 -mattr=+nan2008 %s -o - | llvm-readobj -h | FileCheck --check-prefixes=ALL,ELF64,LE,N64,NAN2008,MIPS64R2 %s
 # RUN: llvm-mc -filetype=obj -triple mips64el-unknown-linux -mcpu=mips64r3                 -mattr=+nan2008 %s -o - | llvm-readobj -h | FileCheck --check-prefixes=ALL,ELF64,LE,N64,NAN2008,MIPS64R3 %s
 # RUN: llvm-mc -filetype=obj -triple mips64el-unknown-linux -mcpu=mips64r5                 -mattr=+nan2008 %s -o - | llvm-readobj -h | FileCheck --check-prefixes=ALL,ELF64,LE,N64,NAN2008,MIPS64R5 %s
 # RUN: llvm-mc -filetype=obj -triple mips64el-unknown-linux -mcpu=mips64r6                                 %s -o - | llvm-readobj -h | FileCheck --check-prefixes=ALL,ELF64,LE,N64,NAN2008,MIPS64R6 %s
 
 # RUN: llvm-mc -filetype=obj -triple mips64el-unknown-linux -mcpu=octeon   -target-abi=n64                 %s -o - | llvm-readobj -h | FileCheck --check-prefixes=ALL,ELF64,LE,N64,NAN1985,OCTEON   %s
 
-# ALL:        ElfHeader {
+# ALL:        ElfHeader [
 # ALL-NEXT:     Ident {
 # ALL-NEXT:       Magic: (7F 45 4C 46)
 # ELF32-NEXT:     Class: 32-bit
 # ELF64-NEXT:     Class: 64-bit
 # LE-NEXT:        DataEncoding: LittleEndian
 # BE-NEXT:        DataEncoding: BigEndian
 # ALL-NEXT:       FileVersion: 1
 # ALL-NEXT:       OS/ABI: SystemV

test/MC/PowerPC/ppc64-localentry.s

caller_other:
   bl callee2
   nop
   .size caller_other, .-caller_other
 
 copy1 = callee1
 copy2 = callee2
 
 # Verify that use of .localentry implies ABI version 2
-# CHECK: ElfHeader {
+# CHECK: ElfHeader [
 # CHECK: Flags [ (0x2)
 
 # Verify that fixups to local function symbols are performed only
 # if the target symbol does not use .localentry
 # CHECK: Relocations [
 # CHECK: Section ({{[0-9]*}}) .rela.text {
 # CHECK-NEXT: R_PPC64_REL24 callee1
 # CHECK-NEXT: }

test/MC/RISCV/elf-header.s

 # RUN: llvm-mc %s -filetype=obj -triple=riscv32 | llvm-readobj -h \
 # RUN:     | FileCheck -check-prefix=RV32 %s
 # RUN: llvm-mc %s -filetype=obj -triple=riscv64 | llvm-readobj -h \
 # RUN:     | FileCheck -check-prefix=RV64 %s
 
 # RV32: Format: ELF32-riscv
 # RV32: Arch: riscv32
 # RV32: AddressSize: 32bit
-# RV32: ElfHeader {
+# RV32: ElfHeader [
 # RV32:   Ident {
 # RV32:     Magic: (7F 45 4C 46)
 # RV32:     Class: 32-bit (0x1)
 # RV32:     DataEncoding: LittleEndian (0x1)
 # RV32:     FileVersion: 1
 # RV32:     OS/ABI: SystemV (0x0)
 # RV32:     ABIVersion: 0
 # RV32:   }
 # RV32:   Type: Relocatable (0x1)
 # RV32:   Machine: EM_RISCV (0xF3)
 # RV32:   Version: 1
 # RV32:   Flags [ (0x0)
 # RV32:   ]
-# RV32: }
+# RV32: ]
 
 # RV64: Format: ELF64-riscv
 # RV64: Arch: riscv64
 # RV64: AddressSize: 64bit
-# RV64: ElfHeader {
+# RV64: ElfHeader [
 # RV64:   Ident {
 # RV64:     Magic: (7F 45 4C 46)
 # RV64:     Class: 64-bit (0x2)
 # RV64:     DataEncoding: LittleEndian (0x1)
 # RV64:     FileVersion: 1
 # RV64:     OS/ABI: SystemV (0x0)
 # RV64:     ABIVersion: 0
 # RV64:   }
 # RV64:   Type: Relocatable (0x1)
 # RV64:   Machine: EM_RISCV (0xF3)
 # RV64:   Version: 1
 # RV64:   Flags [ (0x0)
 # RV64:   ]
-# RV64: }
+# RV64: ]

test/Object/multiple-sections.yaml

 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -a --elf-cg-profile --addrsig %t.o | FileCheck %s
 
 # Test that multiple sections with the same type does not trigger an error.
 
-# CHECK: ElfHeader {
-# CHECK: SHT_GNU_verdef {
-# CHECK: SHT_GNU_verneed {
+# CHECK: ElfHeader [
+# CHECK: VersionDefinitions [
+# CHECK: VersionRequirements [
 # CHECK: CGProfile [
 # CHECK: Addrsig [
 
 --- !ELF
 FileHeader:      
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL

test/tools/llvm-objcopy/ELF/binary-output-target.test

 # RISCV64-NEXT: Arch: riscv64
 # SPARC-NEXT:   Arch: sparc{{$}}
 # SPARCEL-NEXT: Arch: sparcel
 # X86-64-NEXT:  Arch: x86_64
 
 # 32-NEXT:      AddressSize: 32bit
 # 64-NEXT:      AddressSize: 64bit
 
-# CHECK:        ElfHeader {
+# CHECK:        ElfHeader [
 # CHECK-NEXT:     Ident {
 # CHECK-NEXT:       Magic: (7F 45 4C 46)
 # 32-NEXT:          Class: 32-bit (0x1)
 # 64-NEXT:          Class: 64-bit (0x2)
 # LE-NEXT:          DataEncoding: LittleEndian (0x1)
 # BE-NEXT:          DataEncoding: BigEndian (0x2)
 # CHECK-NEXT:       FileVersion: 1
 # CHECK-NEXT:       OS/ABI: SystemV (0x0)

 # 64-NEXT:        HeaderSize: 64
 # 32-NEXT:        ProgramHeaderEntrySize: 0
 # 64-NEXT:        ProgramHeaderEntrySize: 0
 # CHECK-NEXT:     ProgramHeaderCount: 0
 # 32-NEXT:        SectionHeaderEntrySize: 40
 # 64-NEXT:        SectionHeaderEntrySize: 64
 # CHECK-NEXT:     SectionHeaderCount: 4
 # CHECK-NEXT:     StringTableSectionIndex:
-# CHECK-NEXT:   }
+# CHECK-NEXT:   ]
 
 ## ELFOSABI_NONE = ELFOSABI_SYSV = 0 is the default.
 ## "-freebsd" suffixed target name can change the field to ELFOSABI_FREEBSD.
 
 ## Many uses of objcopy use no spaces in the flags, make sure that also works.
 # RUN: llvm-objcopy -Ibinary -O elf64-x86-64-freebsd %t.txt %t.freebsd.o
 # RUN: llvm-readobj --file-headers %t.freebsd.o | FileCheck %s --check-prefixes=FREEBSD
 
 # FREEBSD: OS/ABI: FreeBSD

test/tools/llvm-objcopy/ELF/many-sections.test

 RUN: %python %p/../Inputs/ungzip.py %p/Inputs/many-sections.o.gz > %t
 RUN: llvm-objcopy %t %t2
 RUN: llvm-readobj --file-headers %t2 | FileCheck --check-prefix=EHDR %s
 RUN: llvm-readobj --sections %t2 | FileCheck --check-prefix=SECS %s
 RUN: llvm-readobj --symbols %t2 | grep "Symbol {" | wc -l | FileCheck --check-prefix=SYMS %s
 RUN: llvm-readobj --symbols %t2 | FileCheck %s --check-prefix=SYM_SEC_IDS
 
 EHDR:      Format: ELF64-x86-64
 EHDR-NEXT: Arch: x86_64
 EHDR-NEXT: AddressSize: 64bit
 EHDR-NEXT: LoadName:
-EHDR-NEXT: ElfHeader {
+EHDR-NEXT: ElfHeader [
 EHDR-NEXT:   Ident {
 EHDR-NEXT:     Magic: (7F 45 4C 46)
 EHDR-NEXT:     Class: 64-bit (0x2)
 EHDR-NEXT:     DataEncoding: LittleEndian (0x1)
 EHDR-NEXT:     FileVersion: 1
 EHDR-NEXT:     OS/ABI: SystemV (0x0)
 EHDR-NEXT:     ABIVersion: 0
 EHDR-NEXT:     Unused: (00 00 00 00 00 00 00)
 EHDR-NEXT:   }
 EHDR-NEXT:   Type: Relocatable (0x1)
 EHDR-NEXT:   Machine: EM_X86_64 (0x3E)
 EHDR-NEXT:   Version: 1
 EHDR-NEXT:   Entry: 0x0
 EHDR-NEXT:   ProgramHeaderOffset: 0x0
 EHDR-NEXT:   SectionHeaderOffset:
 EHDR-NEXT:   Flags [ (0x0)
 EHDR-NEXT:   ]
 EHDR-NEXT:   HeaderSize: 64
 EHDR-NEXT:   ProgramHeaderEntrySize: 0
 EHDR-NEXT:   ProgramHeaderCount: 0
 EHDR-NEXT:   SectionHeaderEntrySize: 64
 EHDR-NEXT:   SectionHeaderCount: 0
 EHDR-NEXT:   StringTableSectionIndex: 65535
-EHDR-NEXT: }
+EHDR-NEXT: ]
 
 SECS: Index: 65285
 SECS-NEXT: Name: .symtab
 SECS-NEXT: Type: SHT_SYMTAB
 SECS: Name: .symtab_shndx
 SECS-NEXT: Type: SHT_SYMTAB_SHNDX
 SECS-NEXT: Flags [ (0x0)
 SECS-NEXT: ]

test/tools/llvm-objcopy/ELF/strip-sections.test

Sections:
     - Section: .text
     - Section: .non_alloc_in_segment
 
 # DATA: {{^[^[:blank:]]+}} de ad be ef ca fe ba be
 # DATA-NOT: fe ed fa ce
 
 # VALIDATE: {{^[^[:blank:]]+}} de ad be ef ca fe ba be fe ed fa ce
 
-# CHECK:      ElfHeader {
+# CHECK:      ElfHeader [
 # CHECK-NEXT:   Ident {
 # CHECK-NEXT:     Magic: (7F 45 4C 46)
 # CHECK-NEXT:     Class: 64-bit (0x2)
 # CHECK-NEXT:     DataEncoding: LittleEndian (0x1)
 # CHECK-NEXT:     FileVersion: 1
 # CHECK-NEXT:     OS/ABI: SystemV (0x0)
 # CHECK-NEXT:     ABIVersion: 0
 # CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Type: Executable (0x2)
 # CHECK-NEXT:   Machine: EM_X86_64 (0x3E)
 # CHECK-NEXT:   Version: 1
 # CHECK-NEXT:   Entry: 0x0
 # CHECK-NEXT:   ProgramHeaderOffset: 0x40
 # CHECK-NEXT:   SectionHeaderOffset: 0x0
 # CHECK-NEXT:   Flags [ (0x0)
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   HeaderSize: 64
 # CHECK-NEXT:   ProgramHeaderEntrySize: 56
 # CHECK-NEXT:   ProgramHeaderCount: 1
 # CHECK-NEXT:   SectionHeaderEntrySize: 0
 # CHECK-NEXT:   SectionHeaderCount: 0
 # CHECK-NEXT:   StringTableSectionIndex: 0
-# CHECK-NEXT: }
+# CHECK-NEXT: ]
 
 # CHECK:      ProgramHeaders [
 # CHECK-NEXT:   ProgramHeader {
 # CHECK-NEXT:     Type: PT_LOAD (0x1)
 # CHECK-NEXT:     Offset: 0x1000
 # CHECK-NEXT:     VirtualAddress: 0x0
 # CHECK-NEXT:     PhysicalAddress: 0x0
 # CHECK-NEXT:     FileSize: 8
 # CHECK-NEXT:     MemSize: 8
 # CHECK-NEXT:     Flags [ (0x5)
 # CHECK-NEXT:       PF_R (0x4)
 # CHECK-NEXT:       PF_X (0x1)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Alignment: 4096
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]

test/tools/llvm-readobj/all.test

 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj -a %t.o | FileCheck %s --check-prefix LLVM-ALL
 # RUN: llvm-readobj --all %t.o | FileCheck %s --check-prefix LLVM-ALL
 
 # LLVM-ALL: Format: ELF32-i386
 # LLVM-ALL: Arch: i386
 # LLVM-ALL: AddressSize: 32bit
 # LLVM-ALL: LoadName:
-# LLVM-ALL: ElfHeader {
+# LLVM-ALL: ElfHeader [
 # LLVM-ALL: Sections [
 # LLVM-ALL: Relocations [
 # LLVM-ALL: Symbols [
+# LLVM-ALL: EHFrameHeader [
+# LLVM-ALL: .eh_frame section at offset 0x1128 address 0x0:
 # LLVM-ALL: ProgramHeaders [
-# LLVM-ALL: Version symbols {
-# LLVM-ALL: SHT_GNU_verdef {
-# LLVM-ALL: SHT_GNU_verneed {
+# LLVM-ALL: VersionSymbols [
+# LLVM-ALL: VersionDefinitions [
+# LLVM-ALL: VersionRequirements [
 # LLVM-ALL: Addrsig [
 # LLVM-ALL: Notes [
 # LLVM-ALL: StackSizes [
 
 # RUN: llvm-readelf -a %t.o | FileCheck %s --check-prefix GNU-ALL
 # RUN: llvm-readelf --all %t.o | FileCheck %s --check-prefix GNU-ALL
 
 # GNU-ALL: ELF Header:
 # GNU-ALL: There are {{.*}} section headers, starting at offset {{.*}}:
 # GNU-ALL: Relocation section '.rela.data' at offset {{.*}} contains {{.*}} entries:
 # GNU-ALL: Symbol table '.symtab' contains {{.*}} entries:
-# GNU-ALL: EH_FRAME Header [
+# GNU-ALL: EHFrameHeader [
 # GNU-ALL: .eh_frame section at offset {{.*}} address 0x0:
 # GNU-ALL: Dynamic section at offset {{.*}} contains {{.*}} entries:
 # GNU-ALL: Program Headers:
 # GNU-ALL: Version symbols section '.gnu.version' contains {{.*}} entries:
 # GNU-ALL: Version definition section '.gnu.version_d' contains {{.*}} entries:
 # GNU-ALL: Version needs section '.gnu.version_r' contains {{.*}} entries:
 # GNU-ALL: There are no section groups in this file.
 # GNU-ALL: Histogram for bucket list length (total of 1 buckets)

test/tools/llvm-readobj/amdgpu-elf-definitions.test

 RUN: llvm-readobj --file-headers -l -S --symbols %p/Inputs/trivial.obj.elf-amdhsa-gfx803 | FileCheck %s
 
 CHECK: Format: ELF64-amdgpu
 CHECK: Arch: unknown
-CHECK: ElfHeader {
+CHECK: ElfHeader [
 CHECK:   Ident {
 CHECK:     OS/ABI: AMDGPU_HSA (0x40)
 CHECK:     ABIVersion: 0
 CHECK:   }
 CHECK:   Machine: EM_AMDGPU (0xE0)
-CHECK: }
+CHECK: ]

test/tools/llvm-readobj/archive.test

 # Show that dumping operations apply to all members in an archive.
 
 # RUN: rm -f %t.a
 # RUN: llvm-ar rc %t.a %p/Inputs/trivial.obj.elf-x86-64 %p/Inputs/trivial.obj.elf-i386 %p/Inputs/trivial.obj.coff-arm
 # RUN: llvm-readobj --all %t.a | FileCheck %s -DARFILE="%t.a" --check-prefixes=HEADER,LLVM,COFF
 # RUN: llvm-readelf --all %t.a | FileCheck %s -DARFILE="%t.a" --check-prefixes=HEADER,GNU,COFF
 
 # LLVM: {{^$}}
 # LLVM-NEXT: File: [[ARFILE]](trivial.obj.elf-x86-64)
 # LLVM: Format: ELF64-x86-64
-# LLVM: ElfHeader {
+# LLVM: ElfHeader [
 # LLVM:   Machine: EM_X86_64
 # LLVM: Sections [
 # LLVM: Relocations [
 # LLVM: Symbols [
 # LLVM: Notes [
 # LLVM: ]
 # LLVM: StackSizes [
 # LLVM: ]
 
 # GNU: {{^$}}
 # GNU-NEXT: File: [[ARFILE]](trivial.obj.elf-x86-64)
 # GNU: ELF Header:
 # GNU:   Machine: Advanced Micro Devices X86-64
 # GNU: Section Headers:
 # GNU: Relocation section '.rela.text'
 # GNU: Symbol table '.symtab'
 # GNU: There are no section groups in this file.
 
 # LLVM-EMPTY:
 # LLVM-NEXT: File: [[ARFILE]](trivial.obj.elf-i386)
 # LLVM: Format: ELF32-i386
-# LLVM: ElfHeader {
+# LLVM: ElfHeader [
 # LLVM:   Machine: EM_386
 # LLVM: Sections [
 # LLVM: Relocations [
 # LLVM: Symbols [
 # LLVM: Notes [
 # LLVM: ]
 # LLVM: StackSizes [
 # LLVM: ]

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

 # RUN: yaml2obj %s --docnum=1 -o %t.i386
 # RUN: llvm-readobj -h %t.i386 | FileCheck %s --strict-whitespace --match-full-lines -DFILE=%t.i386 --check-prefix I386
 
 #      I386:File: [[FILE]]
 # I386-NEXT:Format: ELF32-i386
 # I386-NEXT:Arch: i386
 # I386-NEXT:AddressSize: 32bit
 # I386-NEXT:LoadName: <Not found>
-# I386-NEXT:ElfHeader {
+# I386-NEXT:ElfHeader [
 # I386-NEXT:  Ident {
 # I386-NEXT:    Magic: (7F 45 4C 46)
 # I386-NEXT:    Class: 32-bit (0x1)
 # I386-NEXT:    DataEncoding: LittleEndian (0x1)
 # I386-NEXT:    FileVersion: 1
 # I386-NEXT:    OS/ABI: GNU/Linux (0x3)
 # I386-NEXT:    ABIVersion: 0
 # I386-NEXT:    Unused: (00 00 00 00 00 00 00)
 # I386-NEXT:  }
 # I386-NEXT:  Type: Relocatable (0x1)
 # I386-NEXT:  Machine: EM_386 (0x3)
 # I386-NEXT:  Version: 1
 # I386-NEXT:  Entry: 0x0
 # I386-NEXT:  ProgramHeaderOffset: 0x0
 # I386-NEXT:  SectionHeaderOffset: 0x64
 # I386-NEXT:  Flags [ (0x0)
 # I386-NEXT:  ]
 # I386-NEXT:  HeaderSize: 52
 # I386-NEXT:  ProgramHeaderEntrySize: 0
 # I386-NEXT:  ProgramHeaderCount: 0
 # I386-NEXT:  SectionHeaderEntrySize: 40
 # I386-NEXT:  SectionHeaderCount: 4
 # I386-NEXT:  StringTableSectionIndex: 3
-# I386-NEXT:}
+# I386-NEXT:]
 # I386-NOT:{{.}}
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   OSABI:   ELFOSABI_GNU
   Type:    ET_REL
   Machine: EM_386
 
 # RUN: yaml2obj %s --docnum=2 -o %t.x86-64
 # RUN: llvm-readobj -h %t.x86-64 \
 # RUN:  | FileCheck %s --strict-whitespace --match-full-lines -DFILE=%t.x86-64 --check-prefix X86-64
 
 #      X86-64:File: [[FILE]]
 # X86-64-NEXT:Format: ELF64-x86-64
 # X86-64-NEXT:Arch: x86_64
 # X86-64-NEXT:AddressSize: 64bit
 # X86-64-NEXT:LoadName: <Not found>
-# X86-64-NEXT:ElfHeader {
+# X86-64-NEXT:ElfHeader [
 # X86-64-NEXT:  Ident {
 # X86-64-NEXT:    Magic: (7F 45 4C 46)
 # X86-64-NEXT:    Class: 64-bit (0x2)
 # X86-64-NEXT:    DataEncoding: LittleEndian (0x1)
 # X86-64-NEXT:    FileVersion: 1
 # X86-64-NEXT:    OS/ABI: GNU/Linux (0x3)
 # X86-64-NEXT:    ABIVersion: 0
 # X86-64-NEXT:    Unused: (00 00 00 00 00 00 00)
 # X86-64-NEXT:  }
 # X86-64-NEXT:  Type: Relocatable (0x1)
 # X86-64-NEXT:  Machine: EM_X86_64 (0x3E)
 # X86-64-NEXT:  Version: 1
 # X86-64-NEXT:  Entry: 0x0
 # X86-64-NEXT:  ProgramHeaderOffset: 0x0
 # X86-64-NEXT:  SectionHeaderOffset: 0x78
 # X86-64-NEXT:  Flags [ (0x0)
 # X86-64-NEXT:  ]
 # X86-64-NEXT:  HeaderSize: 64
 # X86-64-NEXT:  ProgramHeaderEntrySize: 0
 # X86-64-NEXT:  ProgramHeaderCount: 0
 # X86-64-NEXT:  SectionHeaderEntrySize: 64
 # X86-64-NEXT:  SectionHeaderCount: 4
 # X86-64-NEXT:  StringTableSectionIndex: 3
-# X86-64-NEXT:}
+# X86-64-NEXT:]
 # X86-64-NOT:{{.}}
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   OSABI:   ELFOSABI_GNU
   Type:    ET_REL
FileHeader:
   Type:    ET_REL
   Machine: EM_LANAI
 
 #      LANAI:File: [[FILE]]
 # LANAI-NEXT:Format: ELF32-lanai
 # LANAI-NEXT:Arch: lanai
 # LANAI-NEXT:AddressSize: 32bit
 # LANAI-NEXT:LoadName: <Not found>
-# LANAI-NEXT:ElfHeader {
+# LANAI-NEXT:ElfHeader [
 # LANAI-NEXT:  Ident {
 # LANAI-NEXT:    Magic: (7F 45 4C 46)
 # LANAI-NEXT:    Class: 32-bit (0x1)
 # LANAI-NEXT:    DataEncoding: BigEndian (0x2)
 # LANAI-NEXT:    FileVersion: 1
 # LANAI-NEXT:    OS/ABI: SystemV (0x0)
 # LANAI-NEXT:    ABIVersion: 0
 # LANAI-NEXT:    Unused: (00 00 00 00 00 00 00)
 # LANAI-NEXT:  }
 # LANAI-NEXT:  Type: Relocatable (0x1)
 # LANAI-NEXT:  Machine: EM_LANAI (0xF4)
 # LANAI-NEXT:  Version: 1
 # LANAI-NEXT:  Entry: 0x0
 # LANAI-NEXT:  ProgramHeaderOffset: 0x0
 # LANAI-NEXT:  SectionHeaderOffset: 0x64
 # LANAI-NEXT:  Flags [ (0x0)
 # LANAI-NEXT:  ]
 # LANAI-NEXT:  HeaderSize: 52
 # LANAI-NEXT:  ProgramHeaderEntrySize: 0
 # LANAI-NEXT:  ProgramHeaderCount: 0
 # LANAI-NEXT:  SectionHeaderEntrySize: 40
 # LANAI-NEXT:  SectionHeaderCount: 4
 # LANAI-NEXT:  StringTableSectionIndex: 3
-# LANAI-NEXT:}
+# LANAI-NEXT:]
 # LANAI-NOT:{{.}}

test/tools/llvm-readobj/elf-file-types.test

 ## Check llvm-readobj and llvm-readelf can dump files of the different ELF types.
 
 # RUN: yaml2obj %s --docnum=1 -o %t1
 # RUN: llvm-readobj -h %t1 | FileCheck %s --match-full-lines --check-prefix LLVM-NONE
 # RUN: llvm-readelf -h %t1 | FileCheck %s --match-full-lines --check-prefix GNU-NONE
 
-# LLVM-NONE: ElfHeader {
+# LLVM-NONE: ElfHeader [
 # LLVM-NONE:   Type: None (0x0)
 
 # GNU-NONE: ELF Header:
 # GNU-NONE:   Type: NONE (none)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_NONE
   Machine: EM_X86_64
 
 # RUN: yaml2obj %s --docnum=2 -o %t2
 # RUN: llvm-readobj -h %t2 | FileCheck %s --match-full-lines --check-prefix LLVM-REL
 # RUN: llvm-readelf -h %t2 | FileCheck %s --match-full-lines --check-prefix GNU-REL
 
-# LLVM-REL: ElfHeader {
+# LLVM-REL: ElfHeader [
 # LLVM-REL:   Type: Relocatable (0x1)
 
 # GNU-REL: ELF Header:
 # GNU-REL:   Type: REL (Relocatable file)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 
 # RUN: yaml2obj %s --docnum=3 -o %t3
 # RUN: llvm-readobj -h %t3 | FileCheck %s --match-full-lines --check-prefix LLVM-EXEC
 # RUN: llvm-readelf -h %t3 | FileCheck %s --match-full-lines --check-prefix GNU-EXEC
 
-# LLVM-EXEC: ElfHeader {
+# LLVM-EXEC: ElfHeader [
 # LLVM-EXEC:   Type: Executable (0x2)
 
 # GNU-EXEC: ELF Header:
 # GNU-EXEC:   Type: EXEC (Executable file)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 
 # RUN: yaml2obj %s --docnum=4 -o %t4
 # RUN: llvm-readobj -h %t4 | FileCheck %s --match-full-lines --check-prefix LLVM-DYN
 # RUN: llvm-readelf -h %t4 | FileCheck %s --match-full-lines --check-prefix GNU-DYN
 
-# LLVM-DYN: ElfHeader {
+# LLVM-DYN: ElfHeader [
 # LLVM-DYN:   Type: SharedObject (0x3)
 
 # GNU-DYN: ELF Header:
 # GNU-DYN:   Type: DYN (Shared object file)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 
 # RUN: yaml2obj %s --docnum=5 -o %t5
 # RUN: llvm-readobj -h %t5 | FileCheck %s --match-full-lines --check-prefix LLVM-CORE
 # RUN: llvm-readelf -h %t5 | FileCheck %s --match-full-lines --check-prefix GNU-CORE
 
-# LLVM-CORE: ElfHeader {
+# LLVM-CORE: ElfHeader [
 # LLVM-CORE:   Type: Core (0x4)
 
 # GNU-CORE: ELF Header:
 # GNU-CORE:   Type: CORE (Core file)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_CORE
   Machine: EM_X86_64
 
 # RUN: yaml2obj %s --docnum=6 -o %t6
 # RUN: llvm-readobj -h %t6 | FileCheck %s --match-full-lines --check-prefix LLVM-LOOS
 # RUN: llvm-readelf -h %t6 | FileCheck %s --match-full-lines --check-prefix GNU-LOOS
 
-# LLVM-LOOS: ElfHeader {
+# LLVM-LOOS: ElfHeader [
 # LLVM-LOOS:   Type: 0xFE00
 
 # GNU-LOOS: ELF Header:
 # GNU-LOOS:   Type: fe00
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    0xfe00
   Machine: EM_X86_64
 
 # RUN: yaml2obj %s --docnum=7 -o %t7
 # RUN: llvm-readobj -h %t7 | FileCheck %s --match-full-lines --check-prefix LLVM-HIOS
 # RUN: llvm-readelf -h %t7 | FileCheck %s --match-full-lines --check-prefix GNU-HIOS
 
-# LLVM-HIOS: ElfHeader {
+# LLVM-HIOS: ElfHeader [
 # LLVM-HIOS:   Type: 0xFEFF
 
 # GNU-HIOS: ELF Header:
 # GNU-HIOS:   Type: feff
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    0xfeff
   Machine: EM_X86_64
 
 # RUN: yaml2obj %s --docnum=8 -o %t8
 # RUN: llvm-readobj -h %t8 | FileCheck %s --match-full-lines --check-prefix LLVM-LOPROC
 # RUN: llvm-readelf -h %t8 | FileCheck %s --match-full-lines --check-prefix GNU-LOPROC
 
-# LLVM-LOPROC: ElfHeader {
+# LLVM-LOPROC: ElfHeader [
 # LLVM-LOPROC:   Type: 0xFF00
 
 # GNU-LOPROC: ELF Header:
 # GNU-LOPROC:   Type: ff00
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    0xff00
   Machine: EM_X86_64
 
 # RUN: yaml2obj %s --docnum=9 -o %t9
 # RUN: llvm-readobj -h %t9 | FileCheck %s --match-full-lines --check-prefix LLVM-HIPROC
 # RUN: llvm-readelf -h %t9 | FileCheck %s --match-full-lines --check-prefix GNU-HIPROC
 
-# LLVM-HIPROC: ElfHeader {
+# LLVM-HIPROC: ElfHeader [
 # LLVM-HIPROC:   Type: 0xFFFF
 
 # GNU-HIPROC: ELF Header:
 # GNU-HIPROC:   Type: ffff
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    0xffff
   Machine: EM_X86_64

test/tools/llvm-readobj/elf-invalid-shstrndx.test

 # RUN: yaml2obj %s -o %t
 # RUN: not llvm-readelf --headers -S 2>&1 %t | FileCheck %s -DFILE=%t --check-prefix=GNU
 # RUN: not llvm-readobj --headers -S 2>&1 %t | FileCheck %s -DFILE=%t --check-prefix=LLVM
 
 # GNU:      ELF Header:
 # GNU:        Section header string table index: 255
 # GNU-NEXT:   There are 4 section headers, starting at offset 0x78:
 # GNU:      Section Headers:
 # GNU-NEXT:  [Nr] Name
 # GNU-EMPTY:
 # GNU-NEXT:  error: '[[FILE]]': section header string table index 255 does not exist
 
-# LLVM:      ElfHeader {
+# LLVM:      ElfHeader [
 # LLVM:        StringTableSectionIndex: 255
-# LLVM-NEXT: }
+# LLVM-NEXT: ]
 # LLVM-NEXT: Sections [
 # LLVM-EMPTY:
 # LLVM-NEXT: error: '[[FILE]]': section header string table index 255 does not exist
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
   SHStrNdx:  0xFF

test/tools/llvm-readobj/elf-versioninfo.test

DynamicSymbols:
   - Name:            sym3
     Binding:         STB_GLOBAL
   - Name:            sym4
     Binding:         STB_GLOBAL
   - Name:            sym5
     Binding:         STB_GLOBAL
 ...
 
-# LLVM:      Version symbols {
+# LLVM:      VersionSymbols [
 # LLVM-NEXT:   Section Name: .gnu.version
 # LLVM-NEXT:   Address: 0x0
 # LLVM-NEXT:   Offset: 0x40
 # LLVM-NEXT:   Link: 7
 # LLVM-NEXT:   Symbols [
 # LLVM-NEXT:     Symbol {
 # LLVM-NEXT:       Version: 0
 # LLVM-NEXT:       Name:

 # LLVM-NEXT:       Version: 5
 # LLVM-NEXT:       Name: sym4@v2
 # LLVM-NEXT:     }
 # LLVM-NEXT:     Symbol {
 # LLVM-NEXT:       Version: 6
 # LLVM-NEXT:       Name: sym5@v3
 # LLVM-NEXT:     }
 # LLVM-NEXT:   ]
-# LLVM-NEXT: }
-# LLVM-NEXT: SHT_GNU_verdef {
+# LLVM-NEXT: ]
+# LLVM-NEXT: VersionDefinitions [
 # LLVM-NEXT:   Definition {
 # LLVM-NEXT:     Version: 1
 # LLVM-NEXT:     Flags: 0x0
 # LLVM-NEXT:     Index: 2
 # LLVM-NEXT:     Hash: 175630257
 # LLVM-NEXT:     Name: VERSION1
 # LLVM-NEXT:   }
 # LLVM-NEXT:   Definition {
 # LLVM-NEXT:     Version: 1
 # LLVM-NEXT:     Flags: 0x0
 # LLVM-NEXT:     Index: 3
 # LLVM-NEXT:     Hash: 175630258
 # LLVM-NEXT:     Name: VERSION2
 # LLVM-NEXT:     Predecessor: VERSION1
 # LLVM-NEXT:   }
 # LLVM-NEXT:   Definition {
 # LLVM-NEXT:     Version: 1
 # LLVM-NEXT:     Flags: 0x0
 # LLVM-NEXT:     Index: 3
 # LLVM-NEXT:     Hash: 175630258
 # LLVM-NEXT:     Name: VERSION2
 # LLVM-NEXT:     Predecessor: VERSION1
 # LLVM-NEXT:   }
-# LLVM-NEXT: }
-# LLVM-NEXT: SHT_GNU_verneed {
+# LLVM-NEXT: ]
+# LLVM-NEXT: VersionRequirements [
 # LLVM-NEXT:   Dependency {
 # LLVM-NEXT:     Version: 1
 # LLVM-NEXT:     Count: 2
 # LLVM-NEXT:     FileName: verneed1.so.0
 # LLVM-NEXT:     Entries [
 # LLVM-NEXT:       Entry {
 # LLVM-NEXT:         Hash: 1938
 # LLVM-NEXT:         Flags: 0x0

 # LLVM-NEXT:       Entry {
 # LLVM-NEXT:         Hash: 1937
 # LLVM-NEXT:         Flags: 0x0
 # LLVM-NEXT:         Index: 6
 # LLVM-NEXT:         Name: v3
 # LLVM-NEXT:       }
 # LLVM-NEXT:     ]
 # LLVM-NEXT:   }
-# LLVM-NEXT: }
+# LLVM-NEXT: ]
 
 # GNU:      Version symbols section '.gnu.version' contains 6 entries:
 # GNU-NEXT:  Addr: 0000000000000000  Offset: 0x000040  Link: 7 (.dynsym)
 # GNU-NEXT:   000:   0 (*local*) 2 (VERSION1) 3 (VERSION2) 4 (v1)
 # GNU-NEXT:   004:   5 (v2)      6 (v3)
 # GNU-EMPTY:
 # GNU-NEXT: Version definition section '.gnu.version_d' contains 3 entries:
 # GNU-NEXT:  Addr: 0000000000000000  Offset: 0x00004c  Link: 8 (.dynstr)

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

 # RUN:   | FileCheck %s --check-prefixes=NAME1,LLVM,NAME2 -DFILE1=%t1 -DFILE2=%t2
 
 ## The very first line should be blank. CHECK-EMPTY isn't allowed on the first line.
 # NAME1:      {{^$}}
 # NAME1-NEXT: {{^}}File: [[FILE1]]{{$}}
 
 # GNU:          Section header string table index:
 # LLVM:         StringTableSectionIndex:
-# LLVM-NEXT:  }
+# LLVM-NEXT:  ]
 # NAME2-EMPTY:
 # NAME2-NEXT: {{^}}File: [[FILE2]]{{$}}
 
 --- !ELF
 FileHeader:
   Class:    ELFCLASS64
   Data:     ELFDATA2LSB
   Type:     ET_REL
   Machine:  EM_X86_64

test/tools/llvm-readobj/thin-archive.test

 # RUN: llvm-ar rcT %t.a %t/1.o %t/2.o %t/3.o
 
 # Test that basic dumping works for all members.
 # RUN: llvm-readobj --all %t.a | FileCheck %s --check-prefixes=LLVM,COFF
 # RUN: llvm-readelf --all %t.a | FileCheck %s --check-prefixes=GNU,COFF
 
 # LLVM: File: {{.*}}1.o
 # LLVM: Format: ELF64-x86-64
-# LLVM: ElfHeader {
+# LLVM: ElfHeader [
 # LLVM:   SectionHeaderCount: 10
 # LLVM: Sections [
 # LLVM: Relocations [
 # LLVM: Symbols [
 
 # GNU: ELF Header:
 # GNU:   Number of section headers: 10
 # GNU: Section Headers:
 # GNU: Relocation section '.rela.text'
 # GNU: Symbol table '.symtab'
 
 # LLVM: File: {{.*}}2.o
 # LLVM: Format: ELF64-x86-64
-# LLVM: ElfHeader {
+# LLVM: ElfHeader [
 # LLVM:   SectionHeaderCount: 8
 # LLVM: Sections [
 # LLVM: Relocations [
 # LLVM: Symbols [
 
 # GNU: ELF Header:
 # GNU:   Number of section headers: 8
 # GNU: Section Headers:

test/tools/yaml2obj/verdef-section.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj -V %t | FileCheck %s
 
 # Check we are able to handle the SHT_GNU_verdef sections.
 
-# CHECK:      SHT_GNU_verdef {
+# CHECK:      VersionDefinitions [
 # CHECK-NEXT:   Definition {
 # CHECK-NEXT:     Version: 1
 # CHECK-NEXT:     Flags: Base
 # CHECK-NEXT:     Index: 1
 # CHECK-NEXT:     Hash: 170240160
 # CHECK-NEXT:     Name: dso.so.0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Definition {
 # CHECK-NEXT:     Version: 1
 # CHECK-NEXT:     Flags: Weak
 # CHECK-NEXT:     Index: 2
 # CHECK-NEXT:     Hash: 108387921
 # CHECK-NEXT:     Name: VERSION_1
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Definition {
 # CHECK-NEXT:     Version: 1
 # CHECK-NEXT:     Flags: 0x3
 # CHECK-NEXT:     Index: 3
 # CHECK-NEXT:     Hash: 108387922
 # CHECK-NEXT:     Name: VERSION_2
 # CHECK-NEXT:     Predecessor: VERSION_3
 # CHECK-NEXT:   }
-# CHECK-NEXT: }
+# CHECK-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
   Entry:           0x0000000000001000

test/tools/yaml2obj/verneed-section.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readobj -V %t | FileCheck %s
 
 # Check we are able to handle the SHT_GNU_verneed sections.
 
-# CHECK:      SHT_GNU_verneed {
+# CHECK:      VersionRequirements [
 # CHECK-NEXT:   Dependency {
 # CHECK-NEXT:     Version: 1
 # CHECK-NEXT:     Count: 2
 # CHECK-NEXT:     FileName: dso.so.0
 # CHECK-NEXT:     Entries [
 # CHECK-NEXT:       Entry {
 # CHECK-NEXT:         Hash: 1937
 # CHECK-NEXT:         Flags: 0xA

 # CHECK-NEXT:       Entry {
 # CHECK-NEXT:         Hash: 1939
 # CHECK-NEXT:         Flags: 0xC
 # CHECK-NEXT:         Index: 2
 # CHECK-NEXT:         Name: v3
 # CHECK-NEXT:       }
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
-# CHECK-NEXT: }
+# CHECK-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
   Entry:           0x0000000000201000

test/tools/yaml2obj/versym-section.yaml

 ## Check we are able to produce a valid SHT_GNU_versym
 ## section from its description.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj -V %t1 | FileCheck %s
 
-# CHECK:      Version symbols {
+# CHECK:      VersionSymbols [
 # CHECK-NEXT:   Section Name: .gnu.version
 # CHECK-NEXT:   Address: 0x200210
 # CHECK-NEXT:   Offset: 0x40
 # CHECK-NEXT:   Link: 6
 # CHECK-NEXT:   Symbols [
 # CHECK-NEXT:     Symbol {
 # CHECK-NEXT:       Version: 0
 # CHECK-NEXT:       Name:
 # CHECK-NEXT:     }
 # CHECK-NEXT:     Symbol {
 # CHECK-NEXT:       Version: 3
 # CHECK-NEXT:       Name: f1@v1
 # CHECK-NEXT:     }
 # CHECK-NEXT:     Symbol {
 # CHECK-NEXT:       Version: 4
 # CHECK-NEXT:       Name: f2@v2
 # CHECK-NEXT:     }
 # CHECK-NEXT:   ]
-# CHECK-NEXT: }
-# CHECK-NEXT: SHT_GNU_verdef {
-# CHECK-NEXT: }
-# CHECK-NEXT: SHT_GNU_verneed {
+# CHECK-NEXT: ]
+# CHECK-NEXT: VersionDefinitions [
+# CHECK-NEXT: ]
+# CHECK-NEXT: VersionRequirements [
 # CHECK-NEXT:   Dependency {
 # CHECK-NEXT:     Version: 1
 # CHECK-NEXT:     Count: 2
 # CHECK-NEXT:     FileName: dso.so.0
 # CHECK-NEXT:     Entries [
 # CHECK-NEXT:       Entry {
 # CHECK-NEXT:         Hash: 1937
 # CHECK-NEXT:         Flags: 0x0
 # CHECK-NEXT:         Index: 3
 # CHECK-NEXT:         Name: v1
 # CHECK-NEXT:       }
 # CHECK-NEXT:       Entry {
 # CHECK-NEXT:         Hash: 1938
 # CHECK-NEXT:         Flags: 0x0
 # CHECK-NEXT:         Index: 4
 # CHECK-NEXT:         Name: v2
 # CHECK-NEXT:       }
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
-# CHECK-NEXT: }
+# CHECK-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
   Entry:           0x0000000000201000

tools/llvm-readobj/DwarfCFIEHPrinter.h

if (*SectionName == ".eh_frame")
       printEHFrame(&Shdr);
   }
 }
 
 template <typename ELFT>
 void PrinterContext<ELFT>::printEHFrameHdr(uint64_t EHFrameHdrOffset,
                                            uint64_t EHFrameHdrAddress,
                                            uint64_t EHFrameHdrSize) const {
-  ListScope L(W, "EH_FRAME Header");
+  ListScope L(W, "EHFrameHeader");
   W.startLine() << format("Address: 0x%" PRIx64 "\n", EHFrameHdrAddress);
   W.startLine() << format("Offset: 0x%" PRIx64 "\n", EHFrameHdrOffset);
   W.startLine() << format("Size: 0x%" PRIx64 "\n", EHFrameHdrSize);
 
   const object::ELFFile<ELFT> *Obj = ObjF->getELFFile();
   const auto *EHFrameHdrShdr = findSectionByAddress(ObjF, EHFrameHdrAddress);
   if (EHFrameHdrShdr) {
     auto SectionName = Obj->getSectionName(EHFrameHdrShdr);

tools/llvm-readobj/ELFDumper.cpp

void GNUStyle<ELFT>::printMipsABIFlags(const ELFObjectFile<ELFT> *ObjF) {
   OS << "FLAGS 1: " << format_hex_no_prefix(Flags->flags1, 8, false) << "\n";
   OS << "FLAGS 2: " << format_hex_no_prefix(Flags->flags2, 8, false) << "\n";
   OS << "\n";
 }
 
 template <class ELFT> void LLVMStyle<ELFT>::printFileHeaders(const ELFO *Obj) {
   const Elf_Ehdr *E = Obj->getHeader();
   {
-    DictScope D(W, "ElfHeader");
+    ListScope D(W, "ElfHeader");
     {
       DictScope D(W, "Ident");
       W.printBinary("Magic", makeArrayRef(E->e_ident).slice(ELF::EI_MAG0, 4));
       W.printEnum("Class", E->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
       W.printEnum("DataEncoding", E->e_ident[ELF::EI_DATA],
                   makeArrayRef(ElfDataEncoding));
       W.printNumber("FileVersion", E->e_ident[ELF::EI_VERSION]);
 
for (const Elf_Phdr &Phdr :
     W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags));
     W.printNumber("Alignment", Phdr.p_align);
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printVersionSymbolSection(const ELFFile<ELFT> *Obj,
                                                 const Elf_Shdr *Sec) {
-  DictScope SS(W, "Version symbols");
+  ListScope SS(W, "VersionSymbols");
   if (!Sec)
     return;
 
   StringRef SecName = unwrapOrError(this->FileName, Obj->getSectionName(Sec));
   W.printNumber("Section Name", SecName, Sec->sh_name);
   W.printHex("Address", Sec->sh_addr);
   W.printHex("Offset", Sec->sh_offset);
   W.printNumber("Link", Sec->sh_link);
for (const Elf_Sym &Sym : Dumper->dynamic_symbols()) {
     W.printString("Name", FullSymbolName);
     VersymBuf += sizeof(Elf_Versym);
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
                                                     const Elf_Shdr *Sec) {
-  DictScope SD(W, "SHT_GNU_verdef");
+  ListScope SD(W, "VersionDefinitions");
   if (!Sec)
     return;
 
   const uint8_t *SecStartAddress =
       reinterpret_cast<const uint8_t *>(Obj->base() + Sec->sh_offset);
   const uint8_t *SecEndAddress = SecStartAddress + Sec->sh_size;
   const uint8_t *VerdefBuf = SecStartAddress;
   const Elf_Shdr *StrTab =
while (VerDefsNum--) {
     }
     VerdefBuf += Verdef->vd_next;
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printVersionDependencySection(const ELFFile<ELFT> *Obj,
                                                     const Elf_Shdr *Sec) {
-  DictScope SD(W, "SHT_GNU_verneed");
+  ListScope SD(W, "VersionRequirements");
   if (!Sec)
     return;
 
   const uint8_t *SecData =
       reinterpret_cast<const uint8_t *>(Obj->base() + Sec->sh_offset);
   const Elf_Shdr *StrTab =
       unwrapOrError(this->FileName, Obj->getSection(Sec->sh_link));