[obj2yaml] - Teach tool to emit the "SectionHeaderTable" key and sort sections by file offset.

[grimar]

Summary

Currently when we dump sections, we dump them in the order,
which is specified in the sections header table.

With that the order in the output might not match the order in the file.
This patch starts sorting them by by file offsets when dumping.

When the order in the section header table doesn't match the order
in the file, we should emit the "SectionHeaderTable" key. This patch does it.

[MaskRay]

"actual order" -> "file offset header.

What is the motivation behind this change?

[grimar]

In D91249#2389752, @MaskRay wrote:

"actual order" -> "file offset header.

What is the motivation behind this change?

There was a mini discussion about behavior of "LastSec"/"FirstSec" here:
https://reviews.llvm.org/D90458#inline-846536

In short - it is easier to assign sections to segments when they are sorted by file offsets.

Also, sorting will help to reduce the noise from D91152 patch, which starts producing the "Offset" key
and misordered sections confuses the algorithm that calculates the expected offset basing on previous section.

I.e. having a rule that sections are sorted helps a bit for the following logic and helps to keep it simpler.

[jhenderson]

I'm a little confused here. If we have an ELF with sections .foo, .bar and .zed in that order in the section header table, but with offsets 0x300, 0x200, and 0x100 respectively, I'd expect the obj2yaml output to mantain at least the offset property (the section header table order is arguably less important, although if that order can be maintained too, great). This change appears to be changing the offsets of the sections. At least in section-headers.yaml the input offsets are 0x100, 0x200, 0x300, for .foo, .bar, .zed in that order, whereas the output offsets are 0x300, 0x100, 0x200. This isn't a faithful representation of the input. The thing that could be reordered is the Sections: array. I think either it could be ordered to match the section header table order (in which case there is no need for the SectionHeaderTable key probably), or it should be ordered according to Offset (in which case a SectionHeaderTable key could be added to maintain the table order).

[grimar]

In D91249#2390861, @jhenderson wrote:

I'm a little confused here. If we have an ELF with sections .foo, .bar and .zed in that order in the section header table, but with offsets 0x300, 0x200, and 0x100 respectively, I'd expect the obj2yaml output to mantain at least the offset property (the section header table order is arguably less important, although if that order can be maintained too, great). This change appears to be changing the offsets of the sections.

Actually I am confused too. It definetely was not my intention to change the offsets and I had such bug when developed this patch and was sure that fixed it.
Something is wrong here. I'll recheck after finish with D91152.

[grimar]

• Updated implementation. Now this patch also emits the "SectionHeaderTable" key in according to the description.

[jhenderson]

I think you might need some test coverage for fills too? At least the code you're working on works with Chunk instances, so it implies that both Sections and Fills can reach this bit.

llvm/test/tools/obj2yaml/ELF/section-headers.yaml

1 ↗

(On Diff #308307)

I'm not sure you really need this test. offset.yaml provides the same level of coverage and actually provides better coverage (it also shows that the section header table isn't printed when the sections are already in order).

[grimar]

In D91249#2424864, @jhenderson wrote:

I think you might need some test coverage for fills too? At least the code you're working on works with Chunk instances, so it implies that both Sections and Fills can reach this bit.

obj2yaml doesn't emit fills. It only dumps Sections from an object .

[grimar]

• Addressed review comment (removed test case).

[jhenderson]

LGTM.

llvm/lib/ObjectYAML/ELFYAML.cpp

else
     IO.mapRequired("Value", E.Value);
 }
 
 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   assert(!IO.getContext() && "The IO context is initialized already");
   IO.setContext(&Object);
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
-  IO.mapOptional("SectionHeaderTable", Object.SectionHeaders);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Chunks);
   IO.mapOptional("Symbols", Object.Symbols);
   IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
   IO.mapOptional("DWARF", Object.DWARF);
+  IO.mapOptional("SectionHeaderTable", Object.SectionHeaders);
   if (Object.DWARF) {
     Object.DWARF->IsLittleEndian =
         Object.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
     Object.DWARF->Is64BitAddrSize =
         Object.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
   }
   IO.setContext(nullptr);
 }

llvm/test/Object/X86/obj2yaml-dup-section-name.s

 # RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 # RUN: obj2yaml %t.o | FileCheck %s
 
 # CHECK: Sections:
+# CHECK: - Name:            .text.foo{{$}}
+# CHECK: - Name:            '.text.foo (1)'
 # CHECK: - Name:            .group{{$}}
 # CHECK:   Members:
 # CHECK:     - SectionOrType:   .text.foo{{$}}
 # CHECK:     - SectionOrType:   .rela.text.foo{{$}}
-# CHECK: - Name:            .text.foo{{$}}
-# CHECK: - Name:            .rela.text.foo{{$}}
-# CHECK:   Info:            .text.foo{{$}}
 # CHECK: - Name:            '.group (1)'
 # CHECK:   Members:
 # CHECK:     - SectionOrType:   '.text.foo (1)'
 # CHECK:     - SectionOrType:   '.rela.text.foo (1)'
-# CHECK: - Name:            '.text.foo (1)'
+# CHECK: - Name:            .rela.text.foo{{$}}
+# CHECK:   Info:            .text.foo{{$}}
 # CHECK: - Name:            '.rela.text.foo (1)'
 # CHECK:   Info:            '.text.foo (1)'
 # CHECK: Symbols:
 # CHECK:   Section:         .group{{$}}
 # CHECK:   Section:         '.group (1)'
 
 
         .section        .text.foo,"axG",@progbits,sym1,comdat
         .quad undef
 
         .section        .text.foo,"axG",@progbits,sym2,comdat
         .quad undef

llvm/test/Object/obj2yaml.test

 # ELF-MIPSEL-NEXT:   Machine:         EM_MIPS
 # ELF-MIPSEL-NEXT:   Flags:           [ EF_MIPS_NOREORDER, EF_MIPS_PIC, EF_MIPS_CPIC, EF_MIPS_ABI_O32, EF_MIPS_ARCH_32 ]
 # ELF-MIPSEL-NEXT: Sections:
 # ELF-MIPSEL-NEXT:   - Name:            .text
 # ELF-MIPSEL-NEXT:     Type:            SHT_PROGBITS
 # ELF-MIPSEL-NEXT:     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x4
 # ELF-MIPSEL-NEXT:     Content:         0000023C00004224E8FFBD271400BFAF1000B0AF218059000000018E000024240000198E09F8200321E000020000198E09F8200321E00002000002241000B08F1400BF8F0800E0031800BD27
-# ELF-MIPSEL-NEXT:   - Name:            .rel.text
-# ELF-MIPSEL-NEXT:     Type:            SHT_REL
-# ELF-MIPSEL-NEXT:     Link:            .symtab
-# ELF-MIPSEL-NEXT:     AddressAlign:    0x4
-# ELF-MIPSEL-NEXT:     Offset:          0x434
-# ELF-MIPSEL-NEXT:     Info:            .text
-# ELF-MIPSEL-NEXT:     Relocations:
-# ELF-MIPSEL-NEXT:       - Symbol:          _gp_disp
-# ELF-MIPSEL-NEXT:         Type:            R_MIPS_HI16
-# ELF-MIPSEL-NEXT:       - Offset:          0x4
-# ELF-MIPSEL-NEXT:         Symbol:          _gp_disp
-# ELF-MIPSEL-NEXT:         Type:            R_MIPS_LO16
-# ELF-MIPSEL-NEXT:       - Offset:          0x18
-# ELF-MIPSEL-NEXT:         Symbol:          '$.str'
-# ELF-MIPSEL-NEXT:         Type:            R_MIPS_GOT16
-# ELF-MIPSEL-NEXT:       - Offset:          0x1C
-# ELF-MIPSEL-NEXT:         Symbol:          '$.str'
-# ELF-MIPSEL-NEXT:         Type:            R_MIPS_LO16
-# ELF-MIPSEL-NEXT:       - Offset:          0x20
-# ELF-MIPSEL-NEXT:         Symbol:          puts
-# ELF-MIPSEL-NEXT:         Type:            R_MIPS_CALL16
-# ELF-MIPSEL-NEXT:       - Offset:          0x2C
-# ELF-MIPSEL-NEXT:         Symbol:          SomeOtherFunction
-# ELF-MIPSEL-NEXT:         Type:            R_MIPS_CALL16
 # ELF-MIPSEL-NEXT:   - Name:            .data
 # ELF-MIPSEL-NEXT:     Type:            SHT_PROGBITS
 # ELF-MIPSEL-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x4
-# ELF-MIPSEL-NEXT:     Offset:          0x80
 # ELF-MIPSEL-NEXT:   - Name:            .bss
 # ELF-MIPSEL-NEXT:     Type:            SHT_NOBITS
 # ELF-MIPSEL-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x4
 # ELF-MIPSEL-NEXT:     Size:            0x4
 # ELF-MIPSEL-NEXT:   - Name:            .mdebug.abi32
 # ELF-MIPSEL-NEXT:     Type:            SHT_PROGBITS
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x1

 # ELF-MIPSEL-NEXT:     Flags:           [ SHF_ALLOC ]
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x8
 # ELF-MIPSEL-NEXT:     ISA:             MIPS32
 # ELF-MIPSEL-NEXT:     ISARevision:     0x1
 # ELF-MIPSEL-NEXT:     FpABI:           FP_DOUBLE
 # ELF-MIPSEL-NEXT:     GPRSize:         REG_32
 # ELF-MIPSEL-NEXT:     CPR1Size:        REG_32
 # ELF-MIPSEL-NEXT:     Flags1:          [ ODDSPREG ]
+# ELF-MIPSEL-NEXT:   - Name:            .rel.text
+# ELF-MIPSEL-NEXT:     Type:            SHT_REL
+# ELF-MIPSEL-NEXT:     Link:            .symtab
+# ELF-MIPSEL-NEXT:     AddressAlign:    0x4
+# ELF-MIPSEL-NEXT:     Info:            .text
+# ELF-MIPSEL-NEXT:     Relocations:
+# ELF-MIPSEL-NEXT:       - Symbol:          _gp_disp
+# ELF-MIPSEL-NEXT:         Type:            R_MIPS_HI16
+# ELF-MIPSEL-NEXT:       - Offset:          0x4
+# ELF-MIPSEL-NEXT:         Symbol:          _gp_disp
+# ELF-MIPSEL-NEXT:         Type:            R_MIPS_LO16
+# ELF-MIPSEL-NEXT:       - Offset:          0x18
+# ELF-MIPSEL-NEXT:         Symbol:          '$.str'
+# ELF-MIPSEL-NEXT:         Type:            R_MIPS_GOT16
+# ELF-MIPSEL-NEXT:       - Offset:          0x1C
+# ELF-MIPSEL-NEXT:         Symbol:          '$.str'
+# ELF-MIPSEL-NEXT:         Type:            R_MIPS_LO16
+# ELF-MIPSEL-NEXT:       - Offset:          0x20
+# ELF-MIPSEL-NEXT:         Symbol:          puts
+# ELF-MIPSEL-NEXT:         Type:            R_MIPS_CALL16
+# ELF-MIPSEL-NEXT:       - Offset:          0x2C
+# ELF-MIPSEL-NEXT:         Symbol:          SomeOtherFunction
+# ELF-MIPSEL-NEXT:         Type:            R_MIPS_CALL16
 # ELF-MIPSEL-NEXT: Symbols:
 # ELF-MIPSEL-NEXT:     - Name:            trivial.ll
 # ELF-MIPSEL-NEXT:       Type:            STT_FILE
 # ELF-MIPSEL-NEXT:       Index:           SHN_ABS
 # ELF-MIPSEL-NEXT:     - Name:            '$.str'
 # ELF-MIPSEL-NEXT:       Type:            STT_OBJECT
 # ELF-MIPSEL-NEXT:       Section:         .rodata.str1.1
 # ELF-MIPSEL-NEXT:       Size:            0xD

 # ELF-MIPSEL-NEXT:       Binding:         STB_GLOBAL
 # ELF-MIPSEL-NEXT:       Size:            0x4
 # ELF-MIPSEL-NEXT:     - Name:            SomeOtherFunction
 # ELF-MIPSEL-NEXT:       Binding:         STB_GLOBAL
 # ELF-MIPSEL-NEXT:     - Name:            _gp_disp
 # ELF-MIPSEL-NEXT:       Binding:         STB_GLOBAL
 # ELF-MIPSEL-NEXT:     - Name:            puts
 # ELF-MIPSEL-NEXT:       Binding:         STB_GLOBAL
+# ELF-MIPSEL-NEXT: SectionHeaderTable:
+# ELF-MIPSEL-NEXT:   Sections:
+# ELF-MIPSEL-NEXT:     - Name: .text
+# ELF-MIPSEL-NEXT:     - Name: .rel.text
+# ELF-MIPSEL-NEXT:     - Name: .data
+# ELF-MIPSEL-NEXT:     - Name: .bss
+# ELF-MIPSEL-NEXT:     - Name: .mdebug.abi32
+# ELF-MIPSEL-NEXT:     - Name: .rodata.str1.1
+# ELF-MIPSEL-NEXT:     - Name: .reginfo
+# ELF-MIPSEL-NEXT:     - Name: .MIPS.abiflags
+# ELF-MIPSEL-NEXT:     - Name: .shstrtab
+# ELF-MIPSEL-NEXT:     - Name: .symtab
+# ELF-MIPSEL-NEXT:     - Name: .strtab
+# ELF-MIPSEL-NEXT: ...
 
 # RUN: obj2yaml %p/Inputs/trivial-object-test.elf-mips64el | FileCheck %s --check-prefix ELF-MIPS64EL
 
 # ELF-MIPS64EL:      FileHeader:
 # ELF-MIPS64EL-NEXT:   Class:           ELFCLASS64
 # ELF-MIPS64EL-NEXT:   Data:            ELFDATA2LSB
 # ELF-MIPS64EL-NEXT:   Type:            ET_REL
 # ELF-MIPS64EL-NEXT:   Machine:         EM_MIPS
 # ELF-MIPS64EL-NEXT:   Flags:           [ EF_MIPS_ARCH_3 ]
 # ELF-MIPS64EL-NEXT: Sections:
 # ELF-MIPS64EL-NEXT:   - Name:            .text
 # ELF-MIPS64EL-NEXT:     Type:            SHT_PROGBITS
 # ELF-MIPS64EL-NEXT:     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
 # ELF-MIPS64EL-NEXT:     AddressAlign:    0x10
 # ELF-MIPS64EL-NEXT:   - Name:            .data
 # ELF-MIPS64EL-NEXT:     Type:            SHT_PROGBITS
 # ELF-MIPS64EL-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 # ELF-MIPS64EL-NEXT:     AddressAlign:    0x10
 # ELF-MIPS64EL-NEXT:     Content:         '00000000000000000000000000000000'
-# ELF-MIPS64EL-NEXT:   - Name:            .rela.data
-# ELF-MIPS64EL-NEXT:     Type:            SHT_RELA
-# ELF-MIPS64EL-NEXT:     Link:            .symtab
-# ELF-MIPS64EL-NEXT:     AddressAlign:    0x8
-# ELF-MIPS64EL-NEXT:     Offset:          0x410
-# ELF-MIPS64EL-NEXT:     Info:            .data
-# ELF-MIPS64EL-NEXT:     Relocations:
-# ELF-MIPS64EL-NEXT:       - Symbol:          zed
-# ELF-MIPS64EL-NEXT:         Type:            R_MIPS_64
 # ELF-MIPS64EL-NEXT:   - Name:            .bss
 # ELF-MIPS64EL-NEXT:     Type:            SHT_NOBITS
 # ELF-MIPS64EL-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 # ELF-MIPS64EL-NEXT:     AddressAlign:    0x10
-# ELF-MIPS64EL-NEXT:     Offset:          0x50
 # ELF-MIPS64EL-NEXT:   - Name:            .MIPS.options
 # ELF-MIPS64EL-NEXT:     Type:            SHT_MIPS_OPTIONS
 # ELF-MIPS64EL-NEXT:     Flags:           [ SHF_ALLOC, SHF_MIPS_NOSTRIP ]
 # ELF-MIPS64EL-NEXT:     AddressAlign:    0x8
 # ELF-MIPS64EL-NEXT:     EntSize:         0x1
 # ELF-MIPS64EL-NEXT:     Content:         '01280000000000000000000000000000000000000000000000000000000000000000000000000000'
 # ELF-MIPS64EL-NEXT:   - Name:            .pdr
 # ELF-MIPS64EL-NEXT:     Type:            SHT_PROGBITS
 # ELF-MIPS64EL-NEXT:     AddressAlign:    0x4
+# ELF-MIPS64EL-NEXT:   - Name:            .rela.data
+# ELF-MIPS64EL-NEXT:     Type:            SHT_RELA
+# ELF-MIPS64EL-NEXT:     Link:            .symtab
+# ELF-MIPS64EL-NEXT:     AddressAlign:    0x8
+# ELF-MIPS64EL-NEXT:     Info:            .data
+# ELF-MIPS64EL-NEXT:     Relocations:
+# ELF-MIPS64EL-NEXT:       - Symbol:          zed
+# ELF-MIPS64EL-NEXT:         Type:            R_MIPS_64
 # ELF-MIPS64EL-NEXT: Symbols:
 # ELF-MIPS64EL-NEXT:     - Name:            .text
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .text
 # ELF-MIPS64EL-NEXT:     - Name:            .data
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .data
 # ELF-MIPS64EL-NEXT:     - Name:            .bss
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .bss
 # ELF-MIPS64EL-NEXT:     - Name:            bar
 # ELF-MIPS64EL-NEXT:       Section:         .data
 # ELF-MIPS64EL-NEXT:     - Name:            .MIPS.options
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .MIPS.options
 # ELF-MIPS64EL-NEXT:     - Name:            .pdr
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .pdr
 # ELF-MIPS64EL-NEXT:     - Name:            zed
 # ELF-MIPS64EL-NEXT:       Binding:         STB_GLOBAL
+# ELF-MIPS64EL-NEXT: SectionHeaderTable:
+# ELF-MIPS64EL-NEXT:   Sections:
+# ELF-MIPS64EL-NEXT:     - Name: .text
+# ELF-MIPS64EL-NEXT:     - Name: .data
+# ELF-MIPS64EL-NEXT:     - Name: .rela.data
+# ELF-MIPS64EL-NEXT:     - Name: .bss
+# ELF-MIPS64EL-NEXT:     - Name: .MIPS.options
+# ELF-MIPS64EL-NEXT:     - Name: .pdr
+# ELF-MIPS64EL-NEXT:     - Name: .shstrtab
+# ELF-MIPS64EL-NEXT:     - Name: .symtab
+# ELF-MIPS64EL-NEXT:     - Name: .strtab
+# ELF-MIPS64EL-NEXT: ...
 
 # RUN: yaml2obj %s -o %t-x86-64
 # RUN: obj2yaml %t-x86-64 | FileCheck %s --check-prefix ELF-X86-64
 
 # ELF-X86-64:      FileHeader:
 # ELF-X86-64-NEXT:   Class:           ELFCLASS64
 # ELF-X86-64-NEXT:   Data:            ELFDATA2LSB
 # ELF-X86-64-NEXT:   OSABI:           ELFOSABI_GNU

llvm/test/tools/obj2yaml/ELF/offset.yaml

 ## Check how the "Offset" field is dumped by obj2yaml.
 ## For each section we calulate the expected offset.
 ## When it does not match the actual offset, we emit the "Offset" key.
 
 # RUN: yaml2obj %s -o %t1.o
 # RUN: obj2yaml %t1.o | FileCheck %s --check-prefix=BASIC
 
-# BASIC:      --- !ELF
-# BASIC-NEXT: FileHeader:
-# BASIC-NEXT:   Class: ELFCLASS64
-# BASIC-NEXT:   Data:  ELFDATA2LSB
-# BASIC-NEXT:   Type:  ET_REL
-# BASIC-NEXT: Sections:
-# BASIC-NEXT:   - Name:         .foo1
-# BASIC-NEXT:     Type:         SHT_PROGBITS
-# BASIC-NEXT:     Content:      '00'
-# BASIC-NEXT:   - Name:         .foo2
-# BASIC-NEXT:     Type:         SHT_PROGBITS
-# BASIC-NEXT:     Content:      '00'
-# BASIC-NEXT:   - Name:         .foo3
-# BASIC-NEXT:     Type:         SHT_PROGBITS
-# BASIC-NEXT:     Content:      '00'
-# BASIC-NEXT:   - Name:         .bar1
-# BASIC-NEXT:     Type:         SHT_PROGBITS
-# BASIC-NEXT:     Offset:       0x100
-# BASIC-NEXT:     Content:      '00'
-# BASIC-NEXT:   - Name:         .bar2
-# BASIC-NEXT:     Type:         SHT_PROGBITS
-# BASIC-NEXT:     AddressAlign: 0x10
-# BASIC-NEXT:     Content:      '00'
-# BASIC-NEXT:   - Name:         .bar3
-# BASIC-NEXT:     Type:         SHT_PROGBITS
-# BASIC-NEXT:     AddressAlign: 0x10
-# BASIC-NEXT:     Offset:       0x200
-# BASIC-NEXT:   - Name:         .bar4
-# BASIC-NEXT:     Type:         SHT_PROGBITS
-# BASIC-NEXT:     AddressAlign: 0x100000000
-# BASIC-NEXT:     Offset:       0x210
+#   BASIC:      --- !ELF
+#   BASIC-NEXT: FileHeader:
+#   BASIC-NEXT:   Class: ELFCLASS64
+#   BASIC-NEXT:   Data:  ELFDATA2LSB
+#   BASIC-NEXT:   Type:  ET_REL
+#   BASIC-NEXT: Sections:
+#   BASIC-NEXT:   - Name:         .foo1
+#   BASIC-NEXT:     Type:         SHT_PROGBITS
+#   BASIC-NEXT:     Content:      '00'
+#   BASIC-NEXT:   - Name:         .foo2
+#   BASIC-NEXT:     Type:         SHT_PROGBITS
+#   BASIC-NEXT:     Content:      '00'
+#   BASIC-NEXT:   - Name:         .foo3
+#   BASIC-NEXT:     Type:         SHT_PROGBITS
+#   BASIC-NEXT:     Content:      '00'
+#   BASIC-NEXT:   - Name:         .bar1
+#   BASIC-NEXT:     Type:         SHT_PROGBITS
+#   BASIC-NEXT:     Offset:       0x100
+#   BASIC-NEXT:     Content:      '00'
+#   BASIC-NEXT:   - Name:         .bar2
+#   BASIC-NEXT:     Type:         SHT_PROGBITS
+#   BASIC-NEXT:     AddressAlign: 0x10
+#   BASIC-NEXT:     Content:      '00'
+#   BASIC-NEXT:   - Name:         .bar3
+#   BASIC-NEXT:     Type:         SHT_PROGBITS
+#   BASIC-NEXT:     AddressAlign: 0x10
+#   BASIC-NEXT:     Offset:       0x200
+#   BASIC-NEXT:   - Name:         .bar4
+#   BASIC-NEXT:     Type:         SHT_PROGBITS
+#   BASIC-NEXT:     AddressAlign: 0x100000000
+#   BASIC-NEXT:     Offset:       0x210
+# HEADERS-NEXT: SectionHeaderTable:
+# HEADERS-NEXT:   Sections:
+# HEADERS-NEXT:     - Name:            .bar4
+# HEADERS-NEXT:     - Name:            .bar3
+# HEADERS-NEXT:     - Name:            .bar2
+# HEADERS-NEXT:     - Name:            .bar1
+# HEADERS-NEXT:     - Name:            .foo3
+# HEADERS-NEXT:     - Name:            .foo2
+# HEADERS-NEXT:     - Name:            .foo1
+# HEADERS-NEXT:     - Name:            .strtab
+# HEADERS-NEXT:     - Name:            .shstrtab
+# BASIC-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
 ## The offset of .foo1 by default is 0x40, because it is placed right
- Name:         .bar3
     AddressAlign: 0x10
     Offset:       0x200
 ## A case where AddressAlign > MAX_UINT32 and (uint32_t)AddressAlign == 0.
 ## Check we dump an offset in this case properly.
   - Name:         .bar4
     Type:         SHT_PROGBITS
     AddressAlign: 0x100000000
     Offset:       0x210
+SectionHeaderTable:
+  Sections:
+## By default we have the same order of sections as defined by the "Sections" key.
+    - Name: [[SEC1=.foo1]]
+    - Name: [[SEC2=.foo2]]
+    - Name: [[SEC3=.foo3]]
+    - Name: [[SEC4=.bar1]]
+    - Name: [[SEC5=.bar2]]
+    - Name: [[SEC6=.bar3]]
+    - Name: [[SEC7=.bar4]]
+    - Name: .strtab
+    - Name: .shstrtab
+
+## In this case we change the order of sections in the section header table.
+## Check that we still dump offsets correctly.
+
+# RUN: yaml2obj %s -DSEC1=.bar4 -DSEC2=.bar3 -DSEC3=.bar2 \
+# RUN:   -DSEC4=.bar1 -DSEC5=.foo3 -DSEC6=.foo2 -DSEC7=.foo1 -o %t1-sechdr.o
+# RUN: obj2yaml %t1-sechdr.o | FileCheck --check-prefixes=BASIC,HEADERS %s
 
 ## Show we dump the "Offset" key for the first section when
 ## it has an unexpected file offset.
 
 # RUN: yaml2obj %s -DFIRSTOFF=0x40 -o %t2a.o
 # RUN: obj2yaml %t2a.o | FileCheck %s --check-prefix=BASIC
 # RUN: yaml2obj %s -DFIRSTOFF=0x41 -o %t2b.o
 # RUN: obj2yaml %t2b.o | FileCheck %s --check-prefix=FIRSTSEC

llvm/tools/obj2yaml/elf2yaml.cpp

template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
   // keep all of them in the final output (see comments for
   // 'shouldPrintSection()'). Undesired chunks will be removed later.
   Expected<std::vector<std::unique_ptr<ELFYAML::Chunk>>> ChunksOrErr =
       dumpSections();
   if (!ChunksOrErr)
     return ChunksOrErr.takeError();
   std::vector<std::unique_ptr<ELFYAML::Chunk>> Chunks = std::move(*ChunksOrErr);
 
+  std::vector<ELFYAML::Section *> OriginalOrder;
+  if (!Chunks.empty())
+    for (const std::unique_ptr<ELFYAML::Chunk> &C :
+         makeArrayRef(Chunks).drop_front())
+      OriginalOrder.push_back(cast<ELFYAML::Section>(C.get()));
+
+  // Sometimes the order of sections in the section header table does not match
+  // their actual order. Here we sort sections by the file offset.
+  llvm::stable_sort(Chunks, [&](const std::unique_ptr<ELFYAML::Chunk> &A,
+                                const std::unique_ptr<ELFYAML::Chunk> &B) {
+    return Sections[cast<ELFYAML::Section>(A.get())->OriginalSecNdx].sh_offset <
+           Sections[cast<ELFYAML::Section>(B.get())->OriginalSecNdx].sh_offset;
+  });
+
   // Dump program headers.
   Expected<std::vector<ELFYAML::ProgramHeader>> PhdrsOrErr =
       dumpProgramHeaders(Chunks);
   if (!PhdrsOrErr)
     return PhdrsOrErr.takeError();
   Y->ProgramHeaders = std::move(*PhdrsOrErr);
 
   dumpSectionOffsets<ELFT>(Obj.getHeader(), Y->ProgramHeaders, Chunks,
                            Sections);
 
   // Dump DWARF sections.
   Y->DWARF = dumpDWARFSections(Chunks);
 
+  // We emit the "SectionHeaderTable" key when the order of sections in the
+  // sections header table doesn't match the file order.
+  const bool SectionsSorted =
+      llvm::is_sorted(Chunks, [&](const std::unique_ptr<ELFYAML::Chunk> &A,
+                                  const std::unique_ptr<ELFYAML::Chunk> &B) {
+        return cast<ELFYAML::Section>(A.get())->OriginalSecNdx <
+               cast<ELFYAML::Section>(B.get())->OriginalSecNdx;
+      });
+  if (!SectionsSorted) {
+    Y->SectionHeaders.emplace();
+    Y->SectionHeaders->Sections.emplace();
+    for (ELFYAML::Section *S : OriginalOrder)
+      Y->SectionHeaders->Sections->push_back({S->Name});
+  }
+
   llvm::erase_if(Chunks, [this, &Y](const std::unique_ptr<ELFYAML::Chunk> &C) {
     const ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get());
     return !shouldPrintSection(S, Sections[S.OriginalSecNdx], Y->DWARF);
   });
 
   Y->Chunks = std::move(Chunks);
   return Y.release();
 }