[obj2yaml] - Dump section offsets in some cases.

[grimar]

Summary

Currently we never dump the sh_offset key.
Though it sometimes an important information.

To reduce the noise this patch implements the following logic:

1. The "Offset" key for the first section is always emitted.
2. If we can derive the offset for a next section naturally, then the "Offset" key is omitted.

By "naturally" I mean that section[X] offset is expected to be:

offsetOf(section[X]) == alignTo(section[X - 1].sh_offset + section[X - 1].sh_size, section[X].sh_addralign)

So, when it has the expected value, we omit it from the output.

[grimar]

• Cosmetic fix.

[jhenderson]

I don't think you want to set the offset unconditionally for the first section either. Much of the time the first section's position will be automatically derivable, namely immediately after the ELF header and potential program headers (after alignment has been taken into account). If we explicitly print the offset, people are going to start including it unnecessarily.

[grimar]

• Addressed review comment (don't dump the offset of the first section).

[grimar]

• Fixed test case.

[jhenderson]

Mostly looks fine. Do NOBITS sections come into play here at all? In particular, their size wouldn't normally impact the offset of subsequent sections.

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

87

100

[grimar]

• Addressed review comments.

[grimar]

In D91152#2388303, @jhenderson wrote:

Mostly looks fine. Do NOBITS sections come into play here at all? In particular, their size wouldn't normally impact the offset of subsequent sections.

I've updated the patch and added the test case for SHT_NOBITS sections. Thanks!

[jhenderson]

Doesn't the behaviour of a SHT_NOBITS section depend on whether it is a non-last member of a segment? IIRC, SHT_NOBITS sections in a segment which are last do not need file space, but to ensure correct addresses for sections appearing after them in a segment, they are allocated filespace by a linker if non-NOBITS appear after them in the same segment. (The behaviour you're doing here looks fine for when such sections are not inside segments, e.g. for ET_REL objects).

[grimar]

In D91152#2388491, @jhenderson wrote:

Doesn't the behaviour of a SHT_NOBITS section depend on whether it is a non-last member of a segment? IIRC, SHT_NOBITS sections in a segment which are last do not need file space, but to ensure correct addresses for sections appearing after them in a segment, they are allocated filespace by a linker if non-NOBITS appear after them in the same segment. (The behaviour you're doing here looks fine for when such sections are not inside segments, e.g. for ET_REL objects).

True. But how much necessary to support this case now? The problem is that we at first dump sections and then dump program headers.
To implement the precise behavior, I think we need to delay assigning offsets to be able to call shouldAllocateFileSpace, which does the job:

static bool shouldAllocateFileSpace(ArrayRef<ELFYAML::ProgramHeader> Phdrs,
                                    const ELFYAML::NoBitsSection &S) {
  for (const ELFYAML::ProgramHeader &PH : Phdrs) {
    auto It = llvm::find_if(
        PH.Chunks, [&](ELFYAML::Chunk *C) { return C->Name == S.Name; });
    if (std::any_of(It, PH.Chunks.end(), [](ELFYAML::Chunk *C) {
          return (isa<ELFYAML::Fill>(C) ||
                  cast<ELFYAML::Section>(C)->Type != ELF::SHT_NOBITS);
        }))
      return true;
  }
  return false;
}

I wonder - do we want adding this complexity? I thought that nobits sections are usually placed after progbits anyways.

[MaskRay]

In D91152#2388533, @grimar wrote:

In D91152#2388491, @jhenderson wrote:

Doesn't the behaviour of a SHT_NOBITS section depend on whether it is a non-last member of a segment? IIRC, SHT_NOBITS sections in a segment which are last do not need file space, but to ensure correct addresses for sections appearing after them in a segment, they are allocated filespace by a linker if non-NOBITS appear after them in the same segment. (The behaviour you're doing here looks fine for when such sections are not inside segments, e.g. for ET_REL objects).

True. But how much necessary to support this case now? The problem is that we at first dump sections and then dump program headers.
To implement the precise behavior, I think we need to delay assigning offsets to be able to call shouldAllocateFileSpace, which does the job:

In dumpProgramHeaders we call isInSegment to know the parent segment of a section. If we move the logic earlier before setOffsets, we can refine the computation of the expected sh_offset.
With a containing PT_LOAD, sh_offset should equal its address modulo p_align.

static bool shouldAllocateFileSpace(ArrayRef<ELFYAML::ProgramHeader> Phdrs,
                                    const ELFYAML::NoBitsSection &S) {
  for (const ELFYAML::ProgramHeader &PH : Phdrs) {
    auto It = llvm::find_if(
        PH.Chunks, [&](ELFYAML::Chunk *C) { return C->Name == S.Name; });
    if (std::any_of(It, PH.Chunks.end(), [](ELFYAML::Chunk *C) {
          return (isa<ELFYAML::Fill>(C) ||
                  cast<ELFYAML::Section>(C)->Type != ELF::SHT_NOBITS);
        }))
      return true;
  }
  return false;
}

I wonder - do we want adding this complexity? I thought that nobits sections are usually placed after progbits anyways.

[jhenderson]

I mostly want to make sure we don't result in invalid output caused by missing the corner case. If all that happens is that Offset is produced unnecessarily, it's probably fine either way, but what I don't want is Offset to be omitted due to an incorrect calculation, when it shouldn't be, as this will lead to an invalid output, which might mask a problem a user is trying to locate. As things stand, I think we can run into that situation.

llvm/tools/obj2yaml/elf2yaml.cpp

480–483

By the way, I think it feels more natural to do the special case first (i.e. Sec.Type == ELF::SHT_NOBITS), before the default case, as it is easier to add further cases in the future, but it's not a big deal either way.

[grimar]

In D91152#2390116, @MaskRay wrote:

In D91152#2388533, @grimar wrote:

In D91152#2388491, @jhenderson wrote:

Doesn't the behaviour of a SHT_NOBITS section depend on whether it is a non-last member of a segment? IIRC, SHT_NOBITS sections in a segment which are last do not need file space, but to ensure correct addresses for sections appearing after them in a segment, they are allocated filespace by a linker if non-NOBITS appear after them in the same segment. (The behaviour you're doing here looks fine for when such sections are not inside segments, e.g. for ET_REL objects).

True. But how much necessary to support this case now? The problem is that we at first dump sections and then dump program headers.
To implement the precise behavior, I think we need to delay assigning offsets to be able to call shouldAllocateFileSpace, which does the job:

In dumpProgramHeaders we call isInSegment to know the parent segment of a section. If we move the logic earlier before setOffsets, we can refine the computation of the expected sh_offset.
With a containing PT_LOAD, sh_offset should equal its address modulo p_align.

This should work, but it introduces the depencency on the VA. Perhaps I'd try to avoid adding more dependencies. I don't have a strong opinion though,
but I have a feeling that just delaying of the offsets assigning might look a bit simpler (or at least not that bad as it sounds). Going to try to see how it will look like.

[grimar]

• Updated implementation to delay dumping of offsets to fix the logic for SHT_NOBITS sections.

[jhenderson]

llvm/test/Object/obj2yaml.test

366

Just trying to understand why this and the .data Offsets are needed explicitly here, when they weren't prior to this patch?

[grimar]

llvm/test/Object/obj2yaml.test

366

1. Before this patch we never dumped the "Offset" field.
2. This is the case when we unable to properly derive the offset of the .rel.text and .data because they

are not sorted by the file offset in the section header table:

Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .text             PROGBITS        00000000 000034 00004c 00  AX  0   0  4
  [ 2] .rel.text         REL             00000000 000434 000030 08     10   1  4
  [ 3] .data             PROGBITS        00000000 000080 000000 00  WA  0   0  4
  [ 4] .bss              NOBITS          00000000 000080 000004 00  WA  0   0  4
  [ 5] .mdebug.abi32     PROGBITS        00000000 000080 000000 00      0   0  1

[jhenderson]

LGTM, thanks. Might want to wait for @MaskRay too.

[grimar]

Ping @MaskRay?

llvm/test/Object/obj2yaml.test

 # ELF-MIPSEL-NEXT:   Type:            ET_REL
 # 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:    0x0000000000000004
+# ELF-MIPSEL-NEXT:     Offset:          0x0000000000000034
 # 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:    0x0000000000000004
+# ELF-MIPSEL-NEXT:     Offset:          0x0000000000000434
 # 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:          0x0000000000000004
 # ELF-MIPSEL-NEXT:         Symbol:          _gp_disp
 # ELF-MIPSEL-NEXT:         Type:            R_MIPS_LO16
 # ELF-MIPSEL-NEXT:       - Offset:          0x0000000000000018
 # ELF-MIPSEL-NEXT:         Symbol:          '$.str'
 # ELF-MIPSEL-NEXT:         Type:            R_MIPS_GOT16
 # ELF-MIPSEL-NEXT:       - Offset:          0x000000000000001C
 # ELF-MIPSEL-NEXT:         Symbol:          '$.str'
 # ELF-MIPSEL-NEXT:         Type:            R_MIPS_LO16
 # ELF-MIPSEL-NEXT:       - Offset:          0x0000000000000020
 # ELF-MIPSEL-NEXT:         Symbol:          puts
 # ELF-MIPSEL-NEXT:         Type:            R_MIPS_CALL16
 # ELF-MIPSEL-NEXT:       - Offset:          0x000000000000002C
 # 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:    0x0000000000000004
+# ELF-MIPSEL-NEXT:     Offset:          0x0000000000000080
 # ELF-MIPSEL-NEXT:   - Name:            .bss
 # ELF-MIPSEL-NEXT:     Type:            SHT_NOBITS
 # ELF-MIPSEL-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x0000000000000004
 # ELF-MIPSEL-NEXT:     Size:            0x0000000000000004
 # ELF-MIPSEL-NEXT:   - Name:            .mdebug.abi32
 # ELF-MIPSEL-NEXT:     Type:            SHT_PROGBITS
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x0000000000000001
+# ELF-MIPSEL-NEXT:     Offset:          0x0000000000000080
 # ELF-MIPSEL-NEXT:   - Name:            .rodata.str1.1
 # ELF-MIPSEL-NEXT:     Type:            SHT_PROGBITS
 # ELF-MIPSEL-NEXT:     Flags:           [ SHF_ALLOC, SHF_MERGE, SHF_STRINGS ]
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x0000000000000001
 # ELF-MIPSEL-NEXT:     EntSize:         0x0000000000000001
 # ELF-MIPSEL-NEXT:     Content:         48656C6C6F20576F726C640A00
 # ELF-MIPSEL-NEXT:   - Name:            .reginfo
 # ELF-MIPSEL-NEXT:     Type:            SHT_MIPS_REGINFO

 # 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:    0x0000000000000010
+# ELF-MIPS64EL-NEXT:     Offset:          0x0000000000000040
 # ELF-MIPS64EL-NEXT:   - Name:            .data
 # ELF-MIPS64EL-NEXT:     Type:            SHT_PROGBITS
 # ELF-MIPS64EL-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 # ELF-MIPS64EL-NEXT:     AddressAlign:    0x0000000000000010
 # 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:    0x0000000000000008
+# ELF-MIPS64EL-NEXT:     Offset:          0x0000000000000410
 # 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:    0x0000000000000010
+# ELF-MIPS64EL-NEXT:     Offset:          0x0000000000000050
 # 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:    0x0000000000000008
 # ELF-MIPS64EL-NEXT:     EntSize:         0x0000000000000001
 # ELF-MIPS64EL-NEXT:     Content:         '01280000000000000000000000000000000000000000000000000000000000000000000000000000'
 # ELF-MIPS64EL-NEXT:   - Name:            .pdr
 # ELF-MIPS64EL-NEXT:     Type:            SHT_PROGBITS

 # ELF-X86-64-NEXT:   OSABI:           ELFOSABI_GNU
 # ELF-X86-64-NEXT:   Type:            ET_REL
 # ELF-X86-64-NEXT:   Machine:         EM_X86_64
 # ELF-X86-64-NEXT: Sections:
 # ELF-X86-64-NEXT:   - Name:            .text
 # ELF-X86-64-NEXT:     Type:            SHT_PROGBITS
 # ELF-X86-64-NEXT:     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
 # ELF-X86-64-NEXT:     AddressAlign:    0x0000000000000010
+# ELF-X86-64-NEXT:     Offset:          0x0000000000000040
 # ELF-X86-64-NEXT:     Content:         4883EC08C744240400000000BF00000000E80000000030C0E8000000008B4424044883C408C3
 # ELF-X86-64-NEXT:   - Name:            .rodata.str1.1
 # ELF-X86-64-NEXT:     Type:            SHT_PROGBITS
 # ELF-X86-64-NEXT:     Flags:           [ SHF_ALLOC, SHF_MERGE, SHF_STRINGS ]
 # ELF-X86-64-NEXT:     Address:         0x0000000000000026
 # ELF-X86-64-NEXT:     AddressAlign:    0x0000000000000001
 # ELF-X86-64-NEXT:     Content:         48656C6C6F20576F726C642100
 # ELF-X86-64-NEXT:   - Name:            .note.GNU-stack

 # ELF-AVR-NEXT:    LastSec:  .data
 # ELF-AVR-NEXT:    VAddr:    0x0000000000800060
 # ELF-AVR-NEXT:    PAddr:    0x0000000000000004
 # ELF-AVR-NEXT: Sections:
 # ELF-AVR-NEXT:   - Name:            .text
 # ELF-AVR-NEXT:     Type:            SHT_PROGBITS
 # ELF-AVR-NEXT:     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
 # ELF-AVR-NEXT:     AddressAlign:    0x0000000000000002
+# ELF-AVR-NEXT:     Offset:          0x0000000000000074
 # ELF-AVR-NEXT:     Content:         C20E0895
 # ELF-AVR-NEXT:   - Name:            .data
 # ELF-AVR-NEXT:     Type:            SHT_PROGBITS
 # ELF-AVR-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]
 # ELF-AVR-NEXT:     Address:         0x0000000000800060
 # ELF-AVR-NEXT:     AddressAlign:    0x0000000000000001
 # ELF-AVR-NEXT: Symbols:
 # ELF-AVR-NEXT:     - Name:           .text

llvm/test/tools/obj2yaml/ELF/DWARF/debug-addr.yaml

 #         COMMON: Sections:
 #    COMMON-NEXT:   - Name:         .debug_addr
 #    COMMON-NEXT:     Type:         [[TYPE]]
 #     FLAGS-NEXT:     Flags:        [ SHF_ALLOC ]
 #      LINK-NEXT:     Link:         .sec
 #      ADDR-NEXT:     Address:      0x0000000000002020
 # ADDRALIGN-NEXT:     AddressAlign: 0x0000000000000003
 #   ENTSIZE-NEXT:     EntSize:      0x0000000000000003
+#    COMMON-NEXT:     Offset:       0x{{.*}}
 #      INFO-NEXT:     Info:         0x0000000000000003
 #    COMMON-NEXT:   - Name:         .sec
 #    COMMON-NEXT:     Type:         SHT_PROGBITS
 #    COMMON-NEXT: DWARF:
 #    COMMON-NEXT:   debug_addr:
 #    COMMON-NEXT:     - Length:      0x0000000000000014
 #    COMMON-NEXT:       Version:     0x0005
 #    COMMON-NEXT:       AddressSize: 0x08

 
 # RUN: yaml2obj --docnum=3 %s -DCONTENT="AABBCC" | obj2yaml | \
 # RUN:   FileCheck %s --check-prefix=RAW --implicit-check-not=DWARF:
 
 #      RAW: Sections:
 # RAW-NEXT:   - Name:         .debug_addr
 # RAW-NEXT:     Type:         SHT_PROGBITS
 # RAW-NEXT:     AddressAlign: 0x0000000000000001
+# RAW-NEXT:     Offset:       0x0000000000000040
 # RAW-NEXT:     Content:      AABBCC
 # RAW-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC

llvm/test/tools/obj2yaml/ELF/DWARF/debug-aranges.yaml

 # RUN: yaml2obj --docnum=2 -DINFO=3 %s | obj2yaml | FileCheck %s -DTYPE=PROGBITS --check-prefixes=ARANGE,SHDR,INFO
 # RUN: yaml2obj --docnum=2 -DADDRALIGN=3 %s | obj2yaml | FileCheck %s -DTYPE=PROGBITS --check-prefixes=ARANGE,SHDR,ADDRALIGN
 # RUN: yaml2obj --docnum=2 -DADDRESS=0x2020 %s | obj2yaml | FileCheck %s -DTYPE=PROGBITS --check-prefixes=ARANGE,SHDR,ADDRESS
 
 #           SHDR: - Name:         .debug_aranges
 #      SHDR-NEXT:   Type:         SHT_[[TYPE]]
 #     FLAGS-NEXT:   Flags:        [ SHF_ALLOC ]
 #      LINK-NEXT:   Link:         .sec
+#   ADDRESS-NEXT:   Address:      0x0000000000002020
+# ADDRALIGN-NEXT:   AddressAlign: 0x0000000000000003
 #   ENTSIZE-NEXT:   EntSize:      0x0000000000000003
+#           SHDR:   Offset:       0x{{.*}}
 #      INFO-NEXT:   Info:         0x0000000000000003
-# ADDRALIGN-NEXT:   AddressAlign: 0x0000000000000003
-#   ADDRESS-NEXT:   Address:      0x0000000000002020
 
 #      ARANGE: DWARF:
 # ARANGE-NEXT:   debug_aranges:
 # ARANGE-NEXT:     - Length:      0x000000000000001C
 # ARANGE-NEXT:       Version:     2
 # ARANGE-NEXT:       CuOffset:    0x0000000000001234
 # ARANGE-NEXT:       AddressSize: 0x08
 # ARANGE-NEXT: ...

 ## This makes the DWARF parser fail to parse it and we will dump it as a raw content section.
 
 # RUN: yaml2obj --docnum=4 %s | obj2yaml | FileCheck %s --check-prefix=RAW-CONTENT
 
 #      RAW-CONTENT: Sections:
 # RAW-CONTENT-NEXT:   - Name:            .debug_aranges
 # RAW-CONTENT-NEXT:     Type:            SHT_PROGBITS
 # RAW-CONTENT-NEXT:     AddressAlign:    0x0000000000000001
+# RAW-CONTENT-NEXT:     Offset:          0x0000000000000040
 # RAW-CONTENT-NEXT:     Content:         '3412000002003412000008000000000000000000000000000000000000000000'
 # RAW-CONTENT-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC

llvm/test/tools/obj2yaml/ELF/DWARF/debug-ranges.yaml

 ## doesn't match.
 
 # RUN: yaml2obj --docnum=1 -DADDRSIZE1=4 -DADDRSIZE2=8 %s | obj2yaml | \
 # RUN:   FileCheck %s --check-prefix=RAW --implicit-check-not=debug_ranges
 
 #      RAW: - Name:         .debug_ranges
 # RAW-NEXT:   Type:         SHT_PROGBITS
 # RAW-NEXT:   AddressAlign: 0x0000000000000001
+# RAW-NEXT:   Offset:       0x0000000000000040
 # RAW-NEXT:   Content:      '1000000000000000
 ##                           ^--------------- LowOffset
 # RAW-SAME:             {{^}}2000000000000000
 ##                           ^--------------- HighOffset
 # RAW-SAME:             {{^}}3000000000000000
 ##                           ^--------------- LowOffset
 # RAW-SAME:             {{^}}4000000000000000
 ##                           ^--------------- HighOffset

 ## Override the sh_address field.
 # RUN: yaml2obj --docnum=3 -DADDRESS=0x2020 %s | obj2yaml | \
 # RUN:   FileCheck %s -DTYPE=PROGBITS --check-prefixes=COMMON,ADDRESS
 
 #         COMMON: - Name:         .debug_ranges
 #    COMMON-NEXT:   Type:         SHT_[[TYPE]]
 #     FLAGS-NEXT:   Flags:        [ SHF_ALLOC ]
 #      LINK-NEXT:   Link:         .sec
+#   ADDRESS-NEXT:   Address:      0x0000000000002020
+# ADDRALIGN-NEXT:   AddressAlign: 0x0000000000000003
 #   ENTSIZE-NEXT:   EntSize:      0x0000000000000003
+#         COMMON:   Offset:       0x{{.*}}
 #      INFO-NEXT:   Info:         0x0000000000000003
-# ADDRALIGN-NEXT:   AddressAlign: 0x0000000000000003
-#   ADDRESS-NEXT:   Address:      0x0000000000002020
+
 
 #         COMMON: debug_ranges:
 #    COMMON-NEXT:   - Offset:   0x0000000000000000
 #    COMMON-NEXT:     AddrSize: 0x08
 #    COMMON-NEXT:     Entries:
 #    COMMON-NEXT:       - LowOffset:  0x0000000000000010
 #    COMMON-NEXT:         HighOffset: 0x0000000000000020
 

llvm/test/tools/obj2yaml/ELF/DWARF/debug-str.yaml

 
 #       COMMON: - Name:         .debug_str
 #  COMMON-NEXT:   Type:         SHT_[[TYPE]]
 #  COMMON-NEXT:   Flags:        [[FLAGS]]
 #    LINK-NEXT:   Link:         .sec
 # ADDRESS-NEXT:   Address:      0x[[#%.16x,ADDRESS]]
 #  COMMON-NEXT:   AddressAlign: 0x[[#%.16x,ADDRALIGN]]
 # ENTSIZE-NEXT:   EntSize:      0x[[#%.16x,ENTSIZE]]
+#       COMMON:   Offset:       0x{{.*}}
 #    INFO-NEXT:   Info:         0x[[#%.16x,INFO]]
+
 #        BASIC: DWARF:
 #   BASIC-NEXT:   debug_str:
 #   BASIC-NEXT:     - a
 #   BASIC-NEXT:     - b
 #   BASIC-NEXT:     - abc
 #   BASIC-NEXT: ...
 
 ## c) Test dumping an empty .debug_str section.

 
 # RUN: yaml2obj --docnum=3 %s | obj2yaml | FileCheck %s --check-prefix=NO-TERMINATOR
 
 #  NO-TERMINATOR-NOT: DWARF:
 #      NO-TERMINATOR: Sections:
 # NO-TERMINATOR-NEXT:   - Name:    .debug_str
 # NO-TERMINATOR-NEXT:     Type:    SHT_PROGBITS
 # NO-TERMINATOR-NEXT:     Flags:   [ SHF_MERGE, SHF_STRINGS ]
+# NO-TERMINATOR-NEXT:     Offset:  0x0000000000000040
 # NO-TERMINATOR-NEXT:     Content: '61626300616263'
 # NO-TERMINATOR-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:    .debug_str
     Type:    SHT_PROGBITS
     Content: "61626300616263" ## "abc\0abc"

llvm/test/tools/obj2yaml/ELF/DWARF/unrecognized-debug-section.yaml

 ## Test dumping a debug section when its name is not recognized by obj2yaml.
 
 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 
 #      CHECK: Sections:
 # CHECK-NEXT:   - Name:    .debug_foo
 # CHECK-NEXT:     Type:    SHT_PROGBITS
+# CHECK-NEXT:     Offset:  0x0000000000000040
 # CHECK-NEXT:     Content: '01020304'
 # CHECK-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:    .debug_foo
     Type:    SHT_PROGBITS
     Content: '01020304'

llvm/test/tools/obj2yaml/ELF/arm-exidx-section.yaml

 ## Check how obj2yaml dumps the SHT_ARM_EXIDX section.
 
 ## For a valid section, obj2yaml emits the "Entries" key.
 ## This checks that we respect data endianness and recognize the
 ## EXIDX_CANTUNWIND (0x1) special value properly.
 
 # RUN: yaml2obj --docnum=1 -DENCODE=LSB %s -o %t.le.so
 # RUN: obj2yaml %t.le.so | FileCheck %s --check-prefix=LE
 # RUN: yaml2obj --docnum=1 -DENCODE=MSB %s -o %t.be.so
 # RUN: obj2yaml %t.be.so | FileCheck %s --check-prefix=BE
 
-# LE:      - Name: .ARM.exidx
-# LE-NEXT:   Type: SHT_ARM_EXIDX
+# LE:      - Name:   .ARM.exidx
+# LE-NEXT:   Type:   SHT_ARM_EXIDX
+# LE-NEXT:   Offset: 0x0000000000000040
 # LE-NEXT:   Entries:
 # LE-NEXT:     - Offset: 0xDDCCBBAA
 # LE-NEXT:       Value:  0x01000000
 # LE-NEXT:     - Offset: 0x9988FFEE
 # LE-NEXT:       Value:  EXIDX_CANTUNWIND
 # LE-NEXT: ...
 
-# BE:      - Name: .ARM.exidx
-# BE-NEXT:   Type: SHT_ARM_EXIDX
+# BE:      - Name:   .ARM.exidx
+# BE-NEXT:   Type:   SHT_ARM_EXIDX
+# BE-NEXT:   Offset: 0x0000000000000040
 # BE-NEXT:   Entries:
 # BE-NEXT:     - Offset: 0xAABBCCDD
 # BE-NEXT:       Value:  EXIDX_CANTUNWIND
 # BE-NEXT:     - Offset: 0xEEFF8899
 # BE-NEXT:       Value:  0x01000000
 # BE-NEXT: ...
 
 --- !ELF

 
 ## Check that we dump the content of a truncated SHT_ARM_EXIDX section
 ## using the "Content" key.
 # RUN: yaml2obj --docnum=1 -DSIZE=17 %s -o %t.invalid-size.so
 # RUN: obj2yaml %t.invalid-size.so | FileCheck %s --check-prefix=INVALID-SIZE
 
 # INVALID-SIZE:      - Name:    .ARM.exidx
 # INVALID-SIZE-NEXT:   Type:    SHT_ARM_EXIDX
+# INVALID-SIZE-NEXT:   Offset:  0x0000000000000040
 # INVALID-SIZE-NEXT:   Content: AABBCCDD00000001EEFF88990100000000
 # INVALID-SIZE-NEXT: ...
 
 ## Check how we dump an empty SHT_ARM_EXIDX section.
 # RUN: yaml2obj --docnum=2 %s -o %t.empty.so
 # RUN: obj2yaml %t.empty.so | FileCheck %s --check-prefix=EMPTY
 
 # EMPTY:      - Name: .ARM.exidx
 # EMPTY-NEXT:     Type:    SHT_ARM_EXIDX
+# EMPTY-NEXT:     Offset:  0x0000000000000040
 # EMPTY-NEXT:     Entries: []
 # EMPTY-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN

 # RUN: obj2yaml %t.not-arm.so | FileCheck %s --check-prefix=NOT-ARM
 
 # RUN: yaml2obj --docnum=3 -DMACHINE=EM_ARM %s -o %t.arm.so
 # RUN: obj2yaml %t.arm.so | FileCheck %s --check-prefix=ARM
 
 # NOT-ARM:      Sections:
 # NOT-ARM-NEXT:   - Name:    .ARM.exidx
 # NOT-ARM-NEXT:     Type:    0x70000001
+# NOT-ARM-NEXT:     Offset:  0x0000000000000040
 # NOT-ARM-NEXT:     Content: AABBCCDD11223344
 # NOT-ARM-NEXT: ...
 
-# ARM:      - Name: .ARM.exidx
-# ARM-NEXT:   Type: SHT_ARM_EXIDX
+# ARM:      - Name:    .ARM.exidx
+# ARM-NEXT:   Type:    SHT_ARM_EXIDX
+# ARM-NEXT:   Offset:  0x0000000000000040
 # ARM-NEXT:   Entries:
 # ARM-NEXT:     - Offset: 0xDDCCBBAA
 # ARM-NEXT:       Value:  0x44332211
 # ARM-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64

llvm/test/tools/obj2yaml/ELF/bb-addr-map.yaml

 ## Check how obj2yaml produces YAML .llvm_bb_addr_map descriptions.
 
 ## Check that obj2yaml uses the "Entries" tag to describe an .llvm_bb_addr_map section.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=VALID
 
 # VALID:      --- !ELF
 # VALID-NEXT: FileHeader:
 # VALID-NEXT:   Class:   ELFCLASS64
 # VALID-NEXT:   Data:    ELFDATA2LSB
 # VALID-NEXT:   Type:    ET_EXEC
 # VALID-NEXT: Sections:
-# VALID-NEXT:   - Name: .llvm_bb_addr_map
-# VALID-NEXT:     Type: SHT_LLVM_BB_ADDR_MAP
+# VALID-NEXT:   - Name:   .llvm_bb_addr_map
+# VALID-NEXT:     Type:   SHT_LLVM_BB_ADDR_MAP
+# VALID-NEXT:     Offset: 0x0000000000000040
 # VALID-NEXT:     Entries:
 ## The 'Address' field is omitted when it's zero.
 # VALID-NEXT:         BBEntries:
 # VALID-NEXT:           - AddressOffset:    0x00000001
 # VALID-NEXT:             Size:             0x00000002
 # VALID-NEXT:             Metadata:         0x00000003
 # VALID-NEXT:           - AddressOffset:    0x00000004
 # VALID-NEXT:             Size:             0x00000005

 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=INVALID
 
 # INVALID:      --- !ELF
 # INVALID-NEXT: FileHeader:
 # INVALID-NEXT:   Class:   ELFCLASS64
 # INVALID-NEXT:   Data:    ELFDATA2LSB
 # INVALID-NEXT:   Type:    ET_EXEC
 # INVALID-NEXT: Sections:
-# INVALID-NEXT:   - Name: .llvm_bb_addr_map
-# INVALID-NEXT:     Type: SHT_LLVM_BB_ADDR_MAP
+# INVALID-NEXT:   - Name:    .llvm_bb_addr_map
+# INVALID-NEXT:     Type:    SHT_LLVM_BB_ADDR_MAP
+# INVALID-NEXT:     Offset:  0x0000000000000040
 # INVALID-NEXT:     Content: '10000000000000'
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:

 # RUN: obj2yaml %t4 | FileCheck %s --check-prefix=MULTI
 
 # MULTI:      --- !ELF
 # MULTI-NEXT: FileHeader:
 # MULTI-NEXT:   Class: ELFCLASS64
 # MULTI-NEXT:   Data:  ELFDATA2LSB
 # MULTI-NEXT:   Type:  ET_EXEC
 # MULTI-NEXT: Sections:
-# MULTI-NEXT:   - Name:    .llvm_bb_addr_map
-# MULTI-NEXT:     Type:    SHT_LLVM_BB_ADDR_MAP
+# MULTI-NEXT:   - Name:   .llvm_bb_addr_map
+# MULTI-NEXT:     Type:   SHT_LLVM_BB_ADDR_MAP
+# MULTI-NEXT:     Offset: 0x0000000000000040
 # MULTI-NEXT:     Entries:
 ## The 'Address' field is omitted when it's zero.
 # MULTI-NEXT:       - BBEntries:
 # MULTI-NEXT:           - AddressOffset:    0x00000001
 # MULTI-NEXT:             Size:             0x00000002
 # MULTI-NEXT:             Metadata:         0x00000003
 # MULTI-NEXT:   - Name:    '.llvm_bb_addr_map (1)'
 # MULTI-NEXT:     Type:    SHT_LLVM_BB_ADDR_MAP

llvm/test/tools/obj2yaml/ELF/call-graph-profile-section.yaml

 # RUN: yaml2obj -D BITS=32 -D ENCODE=MSB %s -o %t.be32
 # RUN: obj2yaml %t.be32 | FileCheck %s --check-prefix=BASIC
 
 # BASIC:      Sections:
 # BASIC-NEXT:   - Name:    .llvm.call-graph-profile
 # BASIC-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
 # BASIC-NEXT:     Link:    .symtab
 # BASIC-NEXT:     EntSize: 0x0000000000000010
+# BASIC-NEXT:     Offset:  0x{{.*}}
 # BASIC-NEXT:     Entries:
 # BASIC-NEXT:       - From:   foo
 # BASIC-NEXT:         To:     bar
 # BASIC-NEXT:         Weight: 89
 # BASIC-NEXT:       - From:   bar
 # BASIC-NEXT:         To:     foo
 # BASIC-NEXT:         Weight: 98
 # BASIC-NEXT: Symbols:

 # INVALID-NEXT:   Class: ELFCLASS32
 # INVALID-NEXT:   Data:  ELFDATA2MSB
 # INVALID-NEXT:   Type:  ET_DYN
 # INVALID-NEXT: Sections:
 # INVALID-NEXT:   - Name:    .empty
 # INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link:    .symtab
 # INVALID-NEXT:     EntSize: 0x0000000000000010
+# INVALID-NEXT:     Offset:  0x0000000000000034
 # INVALID-NEXT:   - Name:    .multiple.16.valid
 # INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link:    .symtab
 # INVALID-NEXT:     EntSize: 0x0000000000000010
 # INVALID-NEXT:     Entries:
 # INVALID-NEXT:       - From:   foo
 # INVALID-NEXT:         To:     bar
 # INVALID-NEXT:         Weight: 3

llvm/test/tools/obj2yaml/ELF/duplicate-symbol-and-section-names.yaml

 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      --- !ELF
 # CASE1-NEXT: FileHeader:
 # CASE1-NEXT:   Class: ELFCLASS64
 # CASE1-NEXT:   Data:  ELFDATA2LSB
 # CASE1-NEXT:   Type:  ET_REL
 # CASE1-NEXT: Sections:
-# CASE1-NEXT:   - Name: .foo
-# CASE1-NEXT:     Type: SHT_PROGBITS
+# CASE1-NEXT:   - Name:   .foo
+# CASE1-NEXT:     Type:   SHT_PROGBITS
+# CASE1-NEXT:     Offset: 0x0000000000000040
 # CASE1-NEXT:   - Name: '.foo (1)'
 # CASE1-NEXT:     Type: SHT_PROGBITS
 # CASE1-NEXT:   - Name: '.foo (2)'
 # CASE1-NEXT:     Type: SHT_PROGBITS
 # CASE1-NEXT:   - Name: .bar
 # CASE1-NEXT:     Type: SHT_PROGBITS
 # CASE1-NEXT:   - Name: '.bar (1)'
 # CASE1-NEXT:     Type: SHT_PROGBITS

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

 ## Check we can use obj2yaml to yamalize the object containing .dynamic
 ## section. Check that resulting section has the proper attributes and
 ## dynamic tags and that we do not dump the default sh_entsize.
 
 # RUN: yaml2obj -DENTSIZE=0x10 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s
 
 # CHECK:       Sections:
 # CHECK-NEXT:  - Name:            .dynamic
 # CHECK-NEXT:    Type:            SHT_DYNAMIC
 # CHECK-NEXT:    Address:         0x0000000000001000
 # CHECK-NEXT:    AddressAlign:    0x0000000000002000
+# CHECK-NEXT:    Offset:          0x0000000000002000
 # CHECK-NEXT:    Entries:
 # CHECK-NEXT:      - Tag:             DT_NULL
 # CHECK-NEXT:        Value:           0x0000000000000000
 # CHECK-NEXT:      - Tag:             DT_NEEDED
 # CHECK-NEXT:        Value:           0x0000000000000001
 # CHECK-NEXT:      - Tag:             DT_PLTRELSZ
 # CHECK-NEXT:        Value:           0x0000000000000002
 # CHECK-NEXT:      - Tag:             DT_PLTGOT

llvm/test/tools/obj2yaml/ELF/gnu-hash-section.yaml

 ## Check how obj2yaml produces SHT_GNU_HASH section descriptions.
 
 ## Check that obj2yaml uses "Header", "BloomFilter", "HashBuckets" and "HashValues"
 ## tags to describe a SHT_GNU_HASH section when it has content of a correct size.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=FIELDS
 
 # FIELDS:      - Name:   .gnu.hash
 # FIELDS-NEXT:     Type:   SHT_GNU_HASH
 # FIELDS-NEXT:     Flags:  [ SHF_ALLOC ]
+# FIELDS-NEXT:     Offset: 0x0000000000000034
 # FIELDS-NEXT:     Header:
 # FIELDS-NEXT:       SymNdx: 0x00000001
 # FIELDS-NEXT:       Shift2: 0x00000002
 # FIELDS-NEXT:     BloomFilter: [ 0x0000000000000003, 0x0000000000000004 ]
 # FIELDS-NEXT:     HashBuckets: [ 0x00000005, 0x00000006, 0x00000007 ]
 # FIELDS-NEXT:     HashValues:  [ 0x00000008, 0x00000009, 0x0000000A, 0x0000000B ]
 
 --- !ELF

 ## Check how we handle broken cases.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=INVALID
 
 # INVALID:      - Name:        .gnu.hash.tooshort
 # INVALID-NEXT:   Type:        SHT_GNU_HASH
 # INVALID-NEXT:   Flags:       [ SHF_ALLOC ]
+# INVALID-NEXT:   Offset:      0x0000000000000034
 # INVALID-NEXT:   Content:     112233445566778899AABBCCDDEEFF
 # INVALID-NEXT: - Name:        .gnu.hash.empty
 # INVALID-NEXT:   Type:        SHT_GNU_HASH
 # INVALID-NEXT:   Flags:       [ SHF_ALLOC ]
 # INVALID-NEXT:   Address:     0x000000000000000F
 # INVALID-NEXT:   Header:
 # INVALID-NEXT:     SymNdx:      0x00000000
 # INVALID-NEXT:     Shift2:      0x00000000

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

 ## Check how obj2yaml produces SHT_HASH section descriptions.
 
 ## Check that obj2yaml uses "Bucket" and "Chain" tags to describe
 ## a SHT_HASH section when it has content of a correct size.
 ## I.e. data size == 4 * (2 + nbucket + nchain).
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=CHAIN-BUCKET
 
 # CHAIN-BUCKET:      - Name:  .hash1
 # CHAIN-BUCKET-NEXT:  Type:   SHT_HASH
+# CHAIN-BUCKET-NEXT:  Offset: 0x0000000000000034
 # CHAIN-BUCKET-NEXT:  Bucket: [ 3 ]
 # CHAIN-BUCKET-NEXT:  Chain:  [ 4, 5 ]
 # CHAIN-BUCKET:      - Name:  .hash2
 # CHAIN-BUCKET-NEXT:  Type:   SHT_HASH
 # CHAIN-BUCKET-NEXT:  Bucket: [  ]
 # CHAIN-BUCKET-NEXT:  Chain:  [  ]
 
 --- !ELF

 ## Check that obj2yaml falls back to using the "Content" tag when
 ## hash sections are broken.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      - Name:    .empty_hash
 # CONTENT-NEXT:   Type:    SHT_HASH
+# CONTENT-NEXT:   Offset:  0x0000000000000034
 # CONTENT-NEXT:   Content: ''
 # CONTENT-NEXT: - Name:    .invalid_header
 # CONTENT-NEXT:   Type:    SHT_HASH
 # CONTENT-NEXT:   Content: '00'
 # CONTENT-NEXT: - Name:    .truncated
 # CONTENT-NEXT:   Type:    SHT_HASH
 # CONTENT-NEXT:   Content: '01000000020000000300000004000000'
 # CONTENT-NEXT: - Name:    .oversized

 ## we don't print it, because it is the default value for the SHT_HASH section.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=ENT-SIZE
 
 # ENT-SIZE:      - Name:    .hash.entsize.0
 # ENT-SIZE-NEXT:   Type:    SHT_HASH
 # ENT-SIZE-NEXT:   EntSize: 0x0000000000000000
+# ENT-SIZE-NEXT:   Offset:  0x0000000000000034
 # ENT-SIZE-NEXT:   Content: ''
 # ENT-SIZE-NEXT: - Name:    .hash.entsize.4.default
 # ENT-SIZE-NEXT:   Type:    SHT_HASH
 # ENT-SIZE-NEXT:   Content: ''
 # ENT-SIZE-NEXT: - Name:    .hash.entsize.255
 # ENT-SIZE-NEXT:   Type:    SHT_HASH
 # ENT-SIZE-NEXT:   EntSize: 0x00000000000000FF
 # ENT-SIZE-NEXT:   Content: ''

llvm/test/tools/obj2yaml/ELF/implicit-sections-order.yaml

 # RE-NEXT:   [11] .foo.6    PROGBITS 0000000000000000 0000ff 000000 00     0   0  0
 
 # OUTPUT:      --- !ELF
 # OUTPUT-NEXT: FileHeader:
 # OUTPUT-NEXT:   Class: ELFCLASS64
 # OUTPUT-NEXT:   Data:  ELFDATA2LSB
 # OUTPUT-NEXT:   Type:  ET_DYN
 # OUTPUT-NEXT: Sections:
-# OUTPUT-NEXT:   - Name: .foo.1
-# OUTPUT-NEXT:     Type: SHT_PROGBITS
+# OUTPUT-NEXT:   - Name:   .foo.1
+# OUTPUT-NEXT:     Type:   SHT_PROGBITS
+# OUTPUT-NEXT:     Offset: 0x0000000000000040
 # OUTPUT-NEXT:   - Name:    .dynsym
 # OUTPUT-NEXT:     Type:    SHT_DYNSYM
 # OUTPUT-NEXT:     Flags:   [ SHF_ALLOC ]
 # OUTPUT-NEXT:     Address: 0x0000000000001000
 # OUTPUT-NEXT:     Link:    .dynstr
 # OUTPUT-NEXT:     EntSize: 0x0000000000000018
 # OUTPUT-NEXT:   - Name: .foo.2
 # OUTPUT-NEXT:     Type: SHT_PROGBITS

 ## Check we explicitly declare only allocatable
 ## SHT_STRTAB/SHT_SYMTAB/SHT_DYNSYM sections.
 # OUTPUT2:      --- !ELF
 # OUTPUT2-NEXT: FileHeader:
 # OUTPUT2-NEXT:   Class: ELFCLASS64
 # OUTPUT2-NEXT:   Data:  ELFDATA2LSB
 # OUTPUT2-NEXT:   Type:  ET_DYN
 # OUTPUT2-NEXT: Sections:
-# OUTPUT2-NEXT:   - Name: .foo.1
-# OUTPUT2-NEXT:     Type: SHT_PROGBITS
+# OUTPUT2-NEXT:   - Name:   .foo.1
+# OUTPUT2-NEXT:     Type:   SHT_PROGBITS
+# OUTPUT2-NEXT:     Offset: 0x0000000000000040
 # OUTPUT2-NEXT:   - Name: .foo.2
 # OUTPUT2-NEXT:     Type: SHT_PROGBITS
 # OUTPUT2-NEXT:   - Name: .foo.3
 # OUTPUT2-NEXT:     Type: SHT_PROGBITS
 # OUTPUT2-NEXT:   - Name:    .symtab
 # OUTPUT2-NEXT:     Type:    SHT_SYMTAB
 # OUTPUT2-NEXT:     Flags:   [ SHF_ALLOC ]
 # OUTPUT2-NEXT:     Address: 0x0000000000003000

llvm/test/tools/obj2yaml/ELF/invalid-section-name.yaml

 ## Check we do not crash/assert when dumping a broken section name.
 ## Here we replace the section name with a sequence of characters that
 ## are not representable as unsigned char.
 ## We used to assert for this case before. 
 
 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 # CHECK:      --- !ELF
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Class: ELFCLASS64
 # CHECK-NEXT:   Data:  ELFDATA2LSB
 # CHECK-NEXT:   Type:  ET_REL
 # CHECK-NEXT: Sections:
-# CHECK-NEXT:   - Name: "{{.*}}"
-# CHECK-NEXT:     Type: SHT_PROGBITS
+# CHECK-NEXT:   - Name:   "{{.*}}"
+# CHECK-NEXT:     Type:   SHT_PROGBITS
+# CHECK-NEXT:     Offset: 0x0000000000000040
 # CHECK-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: foo
     Type: SHT_PROGBITS
   - Name: .shstrtab
     Type: SHT_STRTAB
     Content: "00FEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFEFE00"

llvm/test/tools/obj2yaml/ELF/linker-options.yaml

 ## Check how obj2yaml produces SHT_LLVM_LINKER_OPTIONS section descriptions.
 
 ## Check we dump valid sections using pairs of "Name" and "Value" strings.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=VALID
 
-# VALID:      - Name: .linker-options-valid1
-# VALID-NEXT:   Type: SHT_LLVM_LINKER_OPTIONS
+# VALID:      - Name:   .linker-options-valid1
+# VALID-NEXT:   Type:   SHT_LLVM_LINKER_OPTIONS
+# VALID-NEXT:   Offset: 0x0000000000000040
 # VALID-NEXT:   Options:
 # VALID-NEXT:     - Name:  a
 # VALID-NEXT:       Value: b
 # VALID-NEXT: - Name: .linker-options-valid2
 # VALID-NEXT:   Type: SHT_LLVM_LINKER_OPTIONS
 # VALID-NEXT:   Options:
 # VALID-NEXT:     - Name:  a
 # VALID-NEXT:       Value: b

 
 ## Check we dump corrupt sections using the "Content" key.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=CORRUPT
 
 # CORRUPT:      - Name:    .linker-options-empty
 # CORRUPT-NEXT:   Type:    SHT_LLVM_LINKER_OPTIONS
+# CORRUPT-NEXT:   Offset:  0x0000000000000040
 # CORRUPT-NEXT:   Content: ''
 # CORRUPT-NEXT: - Name:    .linker-options-no-null
 # CORRUPT-NEXT:   Type:    SHT_LLVM_LINKER_OPTIONS
 # CORRUPT-NEXT:   Content: '610062'
 # CORRUPT-NEXT: - Name:    .linker-options-incomplete
 # CORRUPT-NEXT:   Type:    SHT_LLVM_LINKER_OPTIONS
 # CORRUPT-NEXT:   Content: '6100'
 

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

 ## Check how obj2yaml dumps the SHT_LLVM_ADDRSIG section.
 
 ## Check that when possible obj2yaml tries to produce the "Name" tag when
 ## dumping entries of the SHT_LLVM_ADDRSIG section. It falls back to producing
 ## the "Index" tag when it can't match a symbol index with a symbol table entry.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=NAME
 
 # NAME:      - Name:    .llvm_addrsig
 # NAME-NEXT:   Type:    SHT_LLVM_ADDRSIG
 # NAME-NEXT:   Link:    .symtab
+# NAME-NEXT:   Offset:  0x0000000000000040
 # NAME-NEXT:   Symbols: [ foo, bar, '3', '4294967295' ]
 # NAME:      - Name: .llvm_addrsig_unlinked
 # NAME-NEXT:   Type: SHT_LLVM_ADDRSIG
 # NAME-NEXT:   Symbols: [ '1', '2', '3', '4294967295' ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64

 ## data using the "Content" tag when at least one of the entries is broken,
 ## e.g. because the entry contains a malformed uleb128 value.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=INVALID-ENTRY
 
 # INVALID-ENTRY:      - Name:    .llvm_addrsig
 # INVALID-ENTRY-NEXT:   Type:    SHT_LLVM_ADDRSIG
+# INVALID-ENTRY-NEXT:   Offset:  0x0000000000000040
 # INVALID-ENTRY-NEXT:   Content: FFFFFFFFFF
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Content: "FFFFFFFFFF"
 
 ## obj2yaml produces a "Symbols" tag when describing an empty SHT_LLVM_ADDRSIG section.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=EMPTY
 
 # EMPTY:      - Name:    .llvm_addrsig
 # EMPTY-NEXT:   Type:    SHT_LLVM_ADDRSIG
+# EMPTY-NEXT:   Offset:  0x0000000000000040
 # EMPTY-NEXT:   Symbols: [ ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .llvm_addrsig
     Type: SHT_LLVM_ADDRSIG
     Content: ""

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

 ## Check how obj2yaml produces SHT_LLVM_DEPENDENT_LIBRARIES section descriptions.
 
 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 # CHECK:      Sections:
 # CHECK-NEXT:  - Name:      .deplibs.single
 # CHECK-NEXT:    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+# CHECK-NEXT:    Offset:    0x0000000000000040
 # CHECK-NEXT:    Libraries: [ foo ]
 # CHECK-NEXT:  - Name:      .deplibs.multiple
 # CHECK-NEXT:    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
 # CHECK-NEXT:    Libraries: [ foo, bar, foo ]
 # CHECK-NEXT:  - Name:      .deplibs.empty
 # CHECK-NEXT:    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
 # CHECK-NEXT:    Libraries: [  ]
 # CHECK-NEXT:  - Name:      .deplibs.nonul

llvm/test/tools/obj2yaml/ELF/mips-abi-flags.yaml

 ## Check how obj2yaml dumps SHT_MIPS_ABIFLAGS sections.
 
 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 # CHECK:      Sections:
 # CHECK-NEXT:   - Name:         .MIPS.abiflags
 # CHECK-NEXT:     Type:         SHT_MIPS_ABIFLAGS
 # CHECK-NEXT:     AddressAlign: 0x0000000000000008
 # CHECK-NEXT:     EntSize:      0x0000000000000018
+# CHECK-NEXT:     Offset:       0x0000000000000040
 # CHECK-NEXT:     ISA:          MIPS64
 # CHECK-NEXT:     ISARevision:  0x05
 # CHECK-NEXT:     ISAExtension: EXT_OCTEON3
 # CHECK-NEXT:     ASEs:         [ DSP, DSPR2, VIRT ]
 # CHECK-NEXT:     FpABI:        FP_DOUBLE
 # CHECK-NEXT:     GPRSize:      REG_64
 # CHECK-NEXT:     CPR1Size:     REG_64
 # CHECK-NEXT:     Flags1:       [ ODDSPREG ]

 ## section of an unknown type.
 
 # RUN: yaml2obj %s --docnum=2 -DMACHINE=EM_NONE -o %t2.notmips
 # RUN: obj2yaml %t2.notmips | FileCheck %s --check-prefix=NOT-MIPS
 
 # RUN: yaml2obj %s --docnum=2 -DMACHINE=EM_MIPS -o %t2.mips
 # RUN: obj2yaml %t2.mips | FileCheck %s --check-prefix=MIPS
 
-# MIPS:      - Name: .MIPS.abiflags
-# MIPS-NEXT:   Type: SHT_MIPS_ABIFLAGS
-# MIPS-NEXT:   ISA:  0x00000000
+# MIPS:      - Name:   .MIPS.abiflags
+# MIPS-NEXT:   Type:   SHT_MIPS_ABIFLAGS
+# MIPS-NEXT:   Offset: 0x0000000000000040
+# MIPS-NEXT:   ISA:    0x00000000
 # MIPS-NEXT: ...
 
 # NOT-MIPS:      - Name:    .MIPS.abiflags
 # NOT-MIPS-NEXT:   Type:    0x7000002A
+# NOT-MIPS-NEXT:   Offset:  0x0000000000000040
 # NOT-MIPS-NEXT:   Content: '000000000000000000000000000000000000000000000000'
 # NOT-MIPS-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2MSB
   Type:    ET_REL
   Machine: [[MACHINE]]
 Sections:
   - Name:   .MIPS.abiflags
     Type:   SHT_PROGBITS
     ShType: 0x7000002a ## SHT_MIPS_ABIFLAGS.
     Size:   0x18

llvm/test/tools/obj2yaml/ELF/no-symbol-reloc.yaml

 ## Check yaml2obj is able to dump relocations
 ## that have no or a zero symbol associated.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: obj2yaml %t.o | FileCheck %s
 
 # CHECK:      --- !ELF
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Class:   ELFCLASS64
 # CHECK-NEXT:   Data:    ELFDATA2LSB
 # CHECK-NEXT:   Type:    ET_REL
 # CHECK-NEXT:   Machine: EM_X86_64
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Name:    .text
 # CHECK-NEXT:     Type:    SHT_PROGBITS
 # CHECK-NEXT:     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
+# CHECK-NEXT:     Offset: 0x0000000000000040
 # CHECK-NEXT:   - Name:    .rela.text
 # CHECK-NEXT:     Type:    SHT_RELA
 # CHECK-NEXT:     Info:    .text
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Type:   R_X86_64_NONE
 # CHECK-NEXT:       - Offset: 0x0000000000000004
 # CHECK-NEXT:         Type:   R_X86_64_NONE
 # CHECK-NEXT: ...

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

 ## Check how obj2yaml dumps SHT_NOTE sections.
 
 ## We can dump the Name, Desc and Type fields when the note section is valid.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=VALID
 
-# VALID:      - Name: .note.foo
-# VALID-NEXT:   Type: SHT_NOTE
+# VALID:      - Name:   .note.foo
+# VALID-NEXT:   Type:   SHT_NOTE
+# VALID-NEXT:   Offset: 0x0000000000000040
 # VALID-NEXT:   Notes:
 # VALID-NEXT:    - Name: ''
 # VALID-NEXT:      Desc: ''
 # VALID-NEXT:      Type: 0x00
 # VALID-NEXT: - Name: .note.bar
 # VALID-NEXT:   Type: SHT_NOTE
 # VALID-NEXT:   Notes:
 # VALID-NEXT:     - Name: ABC

 
 ## Check we dump hex digit pairs if the note section is invalid.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=INVALID
 
 # INVALID:      - Name:    .note.tooShortNote
 # INVALID-NEXT:   Type:    SHT_NOTE
+# INVALID-NEXT:   Offset:  0x0000000000000040
 # INVALID-NEXT:   Content: '0000000000000000000000'
 # INVALID-NEXT: - Name:    .note.tooLongNameSize
 # INVALID-NEXT:   Type:    SHT_NOTE
 # INVALID-NEXT:   Content: 0100000000000000FF00000000
 # INVALID-NEXT: - Name:    .note.tooLongDescSize
 # INVALID-NEXT:   Type:    SHT_NOTE
 # INVALID-NEXT:   Content: 0000000001000000FF00000000
 

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

 # FIRST-SEC-NEXT:     Address:      0x0000000000000006
 # FIRST-SEC-NEXT:     Link:         .foo
 # FIRST-SEC-NEXT:     AddressAlign: 0x0000000000000003
 # FIRST-SEC-NEXT:     EntSize:      0x0000000000000005
 # FIRST-SEC-NEXT:     Size:         0x0000000000000004
 # FIRST-SEC-NEXT:     Info:         0x0000000000000002
 # FIRST-SEC-NEXT:   - Name:         .foo
 # FIRST-SEC-NEXT:     Type:         SHT_PROGBITS
+# FIRST-SEC-NEXT:     Offset:       0x0000000000000040
 # FIRST-SEC-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:

 # SECOND-SEC:      --- !ELF
 # SECOND-SEC-NEXT: FileHeader:
 # SECOND-SEC-NEXT:   Class: ELFCLASS64
 # SECOND-SEC-NEXT:   Data:  ELFDATA2LSB
 # SECOND-SEC-NEXT:   Type:  ET_REL
 # SECOND-SEC-NEXT: Sections:
 # SECOND-SEC-NEXT:   - Name:         .foo
 # SECOND-SEC-NEXT:     Type:         SHT_PROGBITS
+# SECOND-SEC-NEXT:     Offset:       0x0000000000000040
 # SECOND-SEC-NEXT:   - Type:         SHT_NULL
 # SECOND-SEC-NEXT:     Flags:        [ SHF_ALLOC ]
 # SECOND-SEC-NEXT:     Address:      0x0000000000000006
 # SECOND-SEC-NEXT:     Link:         .foo
 # SECOND-SEC-NEXT:     AddressAlign: 0x0000000000000003
 # SECOND-SEC-NEXT:     EntSize:      0x0000000000000005
 # SECOND-SEC-NEXT:     Content:      '00000000'
 # SECOND-SEC-NEXT:     Info:         0x0000000000000002

 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=NULL-SEC
 
 # NULL-SEC:      --- !ELF
 # NULL-SEC-NEXT: FileHeader:
 # NULL-SEC-NEXT:   Class: ELFCLASS64
 # NULL-SEC-NEXT:   Data:  ELFDATA2LSB
 # NULL-SEC-NEXT:   Type:  ET_REL
 # NULL-SEC-NEXT: Sections:
-# NULL-SEC-NEXT:   - Name: .foo
-# NULL-SEC-NEXT:     Type: SHT_PROGBITS
+# NULL-SEC-NEXT:   - Name:   .foo
+# NULL-SEC-NEXT:     Type:   SHT_PROGBITS
+# NULL-SEC-NEXT:     Offset: 0x0000000000000040
 # NULL-SEC-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Type: SHT_NULL
   - Type: SHT_PROGBITS
     Name: .foo
 
 ## Check we dump SHT_NULL sections which are not at the beginning
 ## of the section list even if they don't have any non-null fields.
 
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: obj2yaml %t4 | FileCheck %s --check-prefix=NULL-SEC-MIDDLE
 
 # NULL-SEC-MIDDLE:      --- !ELF
 # NULL-SEC-MIDDLE-NEXT: FileHeader:
 # NULL-SEC-MIDDLE-NEXT:   Class: ELFCLASS64
 # NULL-SEC-MIDDLE-NEXT:   Data:  ELFDATA2LSB
 # NULL-SEC-MIDDLE-NEXT:   Type:  ET_REL
 # NULL-SEC-MIDDLE-NEXT: Sections:
-# NULL-SEC-MIDDLE-NEXT:   - Name: .foo
-# NULL-SEC-MIDDLE-NEXT:     Type: SHT_PROGBITS
+# NULL-SEC-MIDDLE-NEXT:   - Name:   .foo
+# NULL-SEC-MIDDLE-NEXT:     Type:   SHT_PROGBITS
+# NULL-SEC-MIDDLE-NEXT:     Offset: 0x0000000000000040
 # NULL-SEC-MIDDLE-NEXT:   - Type: SHT_NULL
 # NULL-SEC-MIDDLE-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Type: SHT_PROGBITS
     Name: .foo
   - Type: SHT_NULL

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

+## Check how the "Offset" field is dumped by obj2yaml.
+
+# RUN: yaml2obj %s -o %t.o
+# RUN: obj2yaml %t.o | FileCheck %s
+
+# CHECK:      --- !ELF
+# CHECK-NEXT: FileHeader:
+# CHECK-NEXT:   Class: ELFCLASS64
+# CHECK-NEXT:   Data:  ELFDATA2LSB
+# CHECK-NEXT:   Type:  ET_REL
+# CHECK-NEXT: Sections:
+# CHECK-NEXT:   - Name:         .foo1
+# CHECK-NEXT:     Type:         SHT_PROGBITS
+# CHECK-NEXT:     Offset:       0x0000000000000040
+# CHECK-NEXT:     Content:      '00'
+# CHECK-NEXT:   - Name:         .foo2
+# CHECK-NEXT:     Type:         SHT_PROGBITS
+# CHECK-NEXT:     Content:      '00'
+# CHECK-NEXT:   - Name:         .foo3
+# CHECK-NEXT:     Type:         SHT_PROGBITS
+# CHECK-NEXT:     Content:      '00'
+# CHECK-NEXT:   - Name:         .bar1
+# CHECK-NEXT:     Type:         SHT_PROGBITS
+# CHECK-NEXT:     Offset:       0x0000000000000100
+# CHECK-NEXT:     Content:      '00'
+# CHECK-NEXT:   - Name:         .bar2
+# CHECK-NEXT:     Type:         SHT_PROGBITS
+# CHECK-NEXT:     AddressAlign: 0x0000000000000010
+# CHECK-NEXT:     Content:      '00'
+# CHECK-NEXT:   - Name:         .bar3
+# CHECK-NEXT:     Type:         SHT_PROGBITS
+# CHECK-NEXT:     AddressAlign: 0x0000000000000010
+# CHECK-NEXT:     Offset:       0x0000000000000200
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+Sections:
+## Used to show that we always dump the "Offset" of the first section.
+## sh_offset of .foo1 is 0x40.
+  - Name: .foo1
+    Type: SHT_PROGBITS
+    Size: 1
+## Offset of .foo2 == offset of .foo1 + size of .foo1.
+## We don't dump the "Offset" key in this case.
+## sh_offset of .foo2 is 0x41.
+  - Name: .foo2
+    Type: SHT_PROGBITS
+    Size: 1
+## Offset of .foo3 == offset of .foo2 + size of .foo2,
+## We don't dump the "Offset" key in this case.
+## sh_offset of .foo3 is 0x42.
+  - Name: .foo3
+    Type: SHT_PROGBITS
+    Size: 1
+## Offset of .bar1 != offset of .foo3 + size of .foo3.
+## We dump the "Offset" key in this case.
+## sh_offset of .bar1 is 0x100.
+  - Name:   .bar1
+    Type:   SHT_PROGBITS
+    Offset: 0x100
+    Size: 1
+## [Offset of .bar1 + size of .bar1] aligned by 0x10 is equal to the offset
+## of .bar2. We don't dump the "Offset" key in this case.
+## sh_offset of .bar2 is 0x110.
+  - Name:         .bar2
+    Type:         SHT_PROGBITS
+    AddressAlign: 0x10
+    Offset:       0x110
+    Size:         1
+## [Offset of .bar2 + size of .bar2] aligned by 0x10 is not equal to the offset
+## of .bar3. We dump the "Offset" key in this case.
+## sh_offset of .bar3 is 0x200.
+  - Name:         .bar3
+    Type:         SHT_PROGBITS
+    AddressAlign: 0x10
+    Offset:       0x200

llvm/test/tools/obj2yaml/ELF/ppc64-relocations.yaml

 ## Check obj2yaml is able to decode all PPC64 relocations.
 
 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 # CHECK:      --- !ELF
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Class:   ELFCLASS64
 # CHECK-NEXT:   Data:    ELFDATA2MSB
 # CHECK-NEXT:   Type:    ET_REL
 # CHECK-NEXT:   Machine: EM_PPC64
 # CHECK-NEXT: Sections:
-# CHECK-NEXT:   - Name: .rela.text
-# CHECK-NEXT:     Type: SHT_RELA
+# CHECK-NEXT:   - Name:   .rela.text
+# CHECK-NEXT:     Type:   SHT_RELA
+# CHECK-NEXT:     Offset: 0x0000000000000040
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Type: R_PPC64_NONE
 # CHECK-NEXT:       - Type: R_PPC64_ADDR32
 # CHECK-NEXT:       - Type: R_PPC64_ADDR24
 # CHECK-NEXT:       - Type: R_PPC64_ADDR16
 # CHECK-NEXT:       - Type: R_PPC64_ADDR16_LO
 # CHECK-NEXT:       - Type: R_PPC64_ADDR16_HI
 # CHECK-NEXT:       - Type: R_PPC64_ADDR16_HA

llvm/test/tools/obj2yaml/ELF/rel-rela-section.yaml

 ## This is a generic test for SHT_REL/SHT_RELA sections.
 
 ## Check that we do not print excessive default
 ## fields for SHT_REL[A] sections.
 # RUN: yaml2obj %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=YAML
 
 ## Note: it is important to have at least two sections with sh_info == 0.
 ##       Previously we printed a broken Info field in this case.
 # YAML:      - Name:    .rela.dyn
 # YAML-NEXT:   Type:    SHT_RELA
+# YAML-NEXT:   Offset:  0x0000000000000040
 # YAML-NEXT: - Name:    .rel.dyn
 # YAML-NEXT:   Type:    SHT_REL
 # YAML-NEXT: - Name
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB

llvm/test/tools/obj2yaml/ELF/reladyn-section-shinfo.yaml

 # CHECK-NEXT: Address:
 # CHECK-NEXT: Offset:
 # CHECK-NEXT: Size:
 # CHECK-NEXT: Link:
 # CHECK-NEXT: Info: 0
 # CHECK-NEXT: AddressAlignment:
 # CHECK-NEXT: EntrySize:
 
-# YAML:      - Name:  .rela.dyn
-# YAML-NEXT:   Type:  SHT_RELA
-# YAML-NEXT:   Flags: [ SHF_ALLOC ]
-# YAML-NEXT:   Link:  .dynsym
+# YAML:      - Name:   .rela.dyn
+# YAML-NEXT:   Type:   SHT_RELA
+# YAML-NEXT:   Flags:  [ SHF_ALLOC ]
+# YAML-NEXT:   Link:   .dynsym
+# YAML-NEXT:   Offset: 0x0000000000000040
 # YAML-NEXT: - Name:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
   Entry: 0x0000000000001000

llvm/test/tools/obj2yaml/ELF/relocation-type.yaml

 ## Show how obj2yaml dumps relocation types.
 
 ## Show that obj2yaml is able to dump relocation types when `e_machine` kind is unknown.
 # RUN: yaml2obj %s -o %t1 -DMACHINE=0x1234
 # RUN: obj2yaml %t1 | FileCheck %s -DMACHINE=0x1234 -DFIRST=0x00000000 -DSECOND=0x00000001
 
 # CHECK:      --- !ELF
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Class:   ELFCLASS64
 # CHECK-NEXT:   Data:    ELFDATA2MSB
 # CHECK-NEXT:   Type:    ET_REL
 # CHECK-NEXT:   Machine: [[MACHINE]]
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Name:    .rela.text
 # CHECK-NEXT:     Type:    SHT_RELA
+# CHECK-NEXT:     Offset:  0x0000000000000040
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Offset: 0x0000000000000009
 # CHECK-NEXT:         Type:   [[FIRST]]
 # CHECK-NEXT:       - Offset: 0x0000000000000008
 # CHECK-NEXT:         Type:   [[SECOND]]
 # CHECK-NEXT:       - Offset: 0x0000000000000007
 # CHECK-NEXT:         Type:   0x0000007F
 # CHECK-NEXT:       - Offset: 0x0000000000000006

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

 # RUN: yaml2obj --docnum=1 -D BITS=64 -D ENCODE=LSB %s -o %t.64le
 # RUN: obj2yaml %t.64le | FileCheck %s --check-prefix=ELF64LE
 # RUN: yaml2obj --docnum=1 -D BITS=64 -D ENCODE=MSB %s -o %t.64be
 # RUN: obj2yaml %t.64be | FileCheck %s --check-prefix=ELF64BE
 
 # ELF64LE:      Sections:
 # ELF64LE-NEXT:   - Name:    .relr.dyn
 # ELF64LE-NEXT:     Type:    SHT_RELR
+# ELF64LE-NEXT:     Offset:  0x0000000000000040
 # ELF64LE-NEXT:     Entries: [ 0x8877665544332211 ]
 
 # ELF32LE:      Sections:
 # ELF32LE-NEXT:   - Name:    .relr.dyn
 # ELF32LE-NEXT:     Type:    SHT_RELR
+# ELF32LE-NEXT:     Offset:  0x0000000000000034
 # ELF32LE-NEXT:     Entries: [ 0x0000000044332211, 0x0000000088776655 ]
 
 # ELF64BE:      Sections:
 # ELF64BE-NEXT:   - Name:    .relr.dyn
 # ELF64BE-NEXT:     Type:    SHT_RELR
+# ELF64BE-NEXT:     Offset:  0x0000000000000040
 # ELF64BE-NEXT:     Entries: [ 0x1122334455667788 ]
 
 # ELF32BE:      Sections:
 # ELF32BE-NEXT:  - Name:    .relr.dyn
 # ELF32BE-NEXT:    Type:    SHT_RELR
+# ELF32BE-NEXT:    Offset:  0x0000000000000034
 # ELF32BE-NEXT:    Entries: [ 0x0000000011223344, 0x0000000055667788 ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2[[ENCODE]]
   Type:  ET_DYN
 Sections:
   - Name: .relr.dyn
     Type: SHT_RELR
     Content: "1122334455667788"
 
 ## Test we use the "Content" property when a SHT_RELR section is truncated.
 
 # RUN: yaml2obj --docnum=2 %s -o %t.content
 # RUN: obj2yaml %t.content | FileCheck %s --check-prefix=CONTENT
 
 # CONTENT:      - Name:    .relr.dyn
 # CONTENT-NEXT:   Type:    SHT_RELR
+# CONTENT-NEXT:   Offset:  0x0000000000000040
 # CONTENT-NEXT:   Content: '11223344556677'
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2MSB
   Type:  ET_DYN
 Sections:
   - Name: .relr.dyn
     Type: SHT_RELR
     Content: "11223344556677"
 
 ## Test we are able to dump a SHT_RELR section when sh_entsize is invalid.
 ## Here we use 0xFE as a value instead of expected 0x8.
 
 # RUN: yaml2obj --docnum=3 %s -o %t.entsize
 # RUN: obj2yaml %t.entsize | FileCheck %s --check-prefix=ENTSIZE
 
 # ENTSIZE:        - Name:    .relr.dyn
 # ENTSIZE-NEXT:     Type:    SHT_RELR
-# ENTSIZE-NEXT:     EntSize: 0x00000000000000FE
+# ENTSIZE-NEXT:     EntSize: 0x00000000000000FE
+# ENTSIZE-NEXT:     Offset:  0x0000000000000040
 # ENTSIZE-NEXT:     Content: '1122334455667788'
 # ENTSIZE-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2MSB
   Type:  ET_DYN
 Sections:
   - Name:    .relr.dyn
     Type:    SHT_RELR
     EntSize: 0xFE
     Content: "1122334455667788"

llvm/test/tools/obj2yaml/ELF/sections-info.yaml

 ## Check that obj2yaml does not write a section Info
 ## field in the case when it has a value of zero.
 
 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 # CHECK:      Sections:
-# CHECK-NEXT:  - Name: .foo
-# CHECK-NEXT:    Type: SHT_PROGBITS
+# CHECK-NEXT:  - Name:   .foo
+# CHECK-NEXT:    Type:   SHT_PROGBITS
+# CHECK-NEXT:    Offset: 0x0000000000000040
 # CHECK-NEXT:  - Name: .bar
 # CHECK-NEXT:    Type: SHT_PROGBITS
 # CHECK-NEXT:    Info: 0x0000000000000001
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
   - Name: .bar
     Type: SHT_PROGBITS
     Info: 1

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

 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 ## Check obj2yaml is able to dump sh_info field of a section.
 
-# CHECK:      - Name:            .test
-# CHECK-NEXT:   Type:            SHT_PROGBITS
-# CHECK-NEXT:   Info:            0x000000000000002A
+# CHECK:      - Name:   .test
+# CHECK-NEXT:   Type:   SHT_PROGBITS
+# CHECK-NEXT:   Offset: 0x0000000000000040
+# CHECK-NEXT:   Info:   0x000000000000002A
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name:            .test
     Type:            SHT_PROGBITS
     Info:            42

llvm/test/tools/obj2yaml/ELF/sht-symtab-shndx.yaml

 ## Check that obj2yaml is able to dump a normal object which
 ## contains the SHT_SYMTAB_SHNDX section and symbols with
 ## section index == SHN_XINDEX.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      --- !ELF
 # CASE1-NEXT: FileHeader:
 # CASE1-NEXT:   Class: ELFCLASS64
 # CASE1-NEXT:   Data:  ELFDATA2LSB
 # CASE1-NEXT:   Type:  ET_REL
 # CASE1-NEXT: Sections:
 # CASE1-NEXT:   - Name:    bar
 # CASE1-NEXT:     Type:    SHT_PROGBITS
+# CASE1-NEXT:     Offset:  0x0000000000000040
 # CASE1-NEXT:   - Name:    .symtab_shndx
 # CASE1-NEXT:     Type:    SHT_SYMTAB_SHNDX
 # CASE1-NEXT:     Link:    .symtab
 # CASE1-NEXT:     EntSize: 0x0000000000000004
 # CASE1-NEXT:     Entries: [ 0, 1, 2 ]
 # CASE1-NEXT: Symbols:
 # CASE1-NEXT:   - Name:  bar
 # CASE1-NEXT:     Type:  STT_SECTION

llvm/test/tools/obj2yaml/ELF/stack-sizes.yaml

 ## Check how obj2yaml produces YAML .stack_sizes descriptions.
 
 ## Check that obj2yaml uses the "Entries" tag to describe a .stack_sizes section
 ## when it can extract <address, size> pairs.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=VALID
 
 # VALID:      --- !ELF
 # VALID-NEXT: FileHeader:
 # VALID-NEXT:   Class: ELFCLASS64
 # VALID-NEXT:   Data:  ELFDATA2LSB
 # VALID-NEXT:   Type:  ET_EXEC
 # VALID-NEXT: Sections:
-# VALID-NEXT:   - Name: .stack_sizes
-# VALID-NEXT:     Type: SHT_PROGBITS
+# VALID-NEXT:   - Name:   .stack_sizes
+# VALID-NEXT:     Type:   SHT_PROGBITS
+# VALID-NEXT:     Offset: 0x0000000000000040
 # VALID-NEXT:     Entries:
 # VALID-NEXT:       - Address: 0x0000000000000010
 # VALID-NEXT:         Size:    0x0000000000000020
 # VALID-NEXT:       - Address: 0x0000000000000030
 # VALID-NEXT:         Size:    0x0000000000000040
 
 --- !ELF
 FileHeader:

 # INVALID:      --- !ELF
 # INVALID-NEXT: FileHeader:
 # INVALID-NEXT:   Class: ELFCLASS64
 # INVALID-NEXT:   Data:  ELFDATA2LSB
 # INVALID-NEXT:   Type:  ET_EXEC
 # INVALID-NEXT: Sections:
 # INVALID-NEXT:   - Name:    .stack_sizes
 # INVALID-NEXT:     Type:    SHT_PROGBITS
+# INVALID-NEXT:     Offset:  0x0000000000000040
 # INVALID-NEXT:     Content: '1000000000000000203000000000000000'
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:

 # EMPTY:      --- !ELF
 # EMPTY-NEXT: FileHeader:
 # EMPTY-NEXT:   Class: ELFCLASS64
 # EMPTY-NEXT:   Data:  ELFDATA2LSB
 # EMPTY-NEXT:   Type:  ET_EXEC
 # EMPTY-NEXT: Sections:
 # EMPTY-NEXT:   - Name:    .stack_sizes
 # EMPTY-NEXT:     Type:    SHT_PROGBITS
+# EMPTY-NEXT:     Offset:  0x0000000000000040
 # EMPTY-NEXT:     Content: ''
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:

 # MULTI:      --- !ELF
 # MULTI-NEXT: FileHeader:
 # MULTI-NEXT:   Class: ELFCLASS64
 # MULTI-NEXT:   Data:  ELFDATA2LSB
 # MULTI-NEXT:   Type:  ET_EXEC
 # MULTI-NEXT: Sections:
 # MULTI-NEXT:   - Name:    .stack_sizes
 # MULTI-NEXT:     Type:    SHT_PROGBITS
+# MULTI-NEXT:     Offset:  0x0000000000000040
 # MULTI-NEXT:     Entries:
 # MULTI-NEXT:       - Address: 0x0000000000000010
 # MULTI-NEXT:         Size:    0x0000000000000020
 # MULTI-NEXT:       - Address: 0x0000000000000030
 # MULTI-NEXT:         Size:    0x0000000000000040
 # MULTI-NEXT:   - Name:    '.stack_sizes (1)'
 # MULTI-NEXT:     Type:    SHT_PROGBITS
 # MULTI-NEXT:     Entries:

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

 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 ## Check we are able to yamalize SHT_GNU_verdef section.
 
 # CHECK:       - Name:            .gnu.version_d
 # CHECK-NEXT:     Type:            SHT_GNU_verdef
 # CHECK-NEXT:     Flags:           [ SHF_ALLOC ]
 # CHECK-NEXT:     Address:         0x0000000000000230
 # CHECK-NEXT:     Link:            .dynstr
 # CHECK-NEXT:     AddressAlign:    0x0000000000000004
+# CHECK-NEXT:     Offset:          0x0000000000000040
 # CHECK-NEXT:     Info:            0x0000000000000004
 # CHECK-NEXT:     Entries:
 # CHECK-NEXT:       - Version:         1
 # CHECK-NEXT:         Flags:           1
 # CHECK-NEXT:         VersionNdx:      1
 # CHECK-NEXT:         Hash:            170240160
 # CHECK-NEXT:         Names:
 # CHECK-NEXT:           - dso.so.0

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

 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 ## Check we are able to yamalize SHT_GNU_verneed section.
 
 # CHECK:      - Name:            .gnu.version_r
 # CHECK-NEXT:   Type:            SHT_GNU_verneed
 # CHECK-NEXT:   Flags:           [ SHF_ALLOC ]
 # CHECK-NEXT:   Address:         0x0000000000200250
 # CHECK-NEXT:   Link:            .dynstr
 # CHECK-NEXT:   AddressAlign:    0x0000000000000004
+# CHECK-NEXT:   Offset:          0x0000000000000040
 # CHECK-NEXT:   Info:            0x0000000000000002
 # CHECK-NEXT:   Dependencies:
 # CHECK-NEXT:     - Version:         1
 # CHECK-NEXT:       File:            dso.so.0
 # CHECK-NEXT:       Entries:
 # CHECK-NEXT:         - Name:            v1
 # CHECK-NEXT:           Hash:            1937
 # CHECK-NEXT:           Flags:           10

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

 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Name:            .gnu.version
 # CHECK-NEXT:     Type:            SHT_GNU_versym
 # CHECK-NEXT:     Flags:           [ SHF_ALLOC ]
 # CHECK-NEXT:     Address:         0x0000000000200210
 # CHECK-NEXT:     Link:            .dynsym
 # CHECK-NEXT:     AddressAlign:    0x0000000000000002
 # CHECK-NEXT:     EntSize:         0x0000000000000002
+# CHECK-NEXT:     Offset:          0x0000000000000040
 # CHECK-NEXT:     Entries:         [ 0, 3, 4 ]
 # CHECK-NEXT:   - Name:
 # CHECK:      DynamicSymbols:
 # CHECK-NEXT:   - Name:    f1
 # CHECK-NEXT:     Binding: STB_GLOBAL
 # CHECK-NEXT:   - Name:    f2
 # CHECK-NEXT:     Binding: STB_GLOBAL
 

llvm/tools/obj2yaml/elf2yaml.cpp

 ELFDumper<ELFT>::dumpPlaceholderSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::RawContentSection>();
   if (Error E = dumpCommonSection(Shdr, *S.get()))
     return std::move(E);
   return S.release();
 }
 
 template <class ELFT>
+static void setOffsets(std::vector<std::unique_ptr<ELFYAML::Chunk>> &V,
+                       ArrayRef<typename ELFT::Shdr> S) {
+  for (size_t I = 0, E = V.size(); I < E; ++I) {
+    if (I == 0)
+      continue;
+
+    const typename ELFT::Shdr &PrevSec = S[I - 1];
+    const typename ELFT::Shdr &Sec = S[I];
+
+    // We only set the "Offset" field when it can't be naturally derived
+    // from the offset and size of the previous section. This reduces
+    // the noise in the YAML output.
+    uint64_t ExpectedOffset = alignTo(PrevSec.sh_offset + PrevSec.sh_size,
+                                      Sec.sh_addralign ? Sec.sh_addralign : 1);
+    if (Sec.sh_offset != ExpectedOffset)
+      cast<ELFYAML::Section>(V[I].get())->Offset = (yaml::Hex64)Sec.sh_offset;
+  }
+}
+
+template <class ELFT>
 Expected<std::vector<std::unique_ptr<ELFYAML::Chunk>>>
 ELFDumper<ELFT>::dumpSections() {
   std::vector<std::unique_ptr<ELFYAML::Chunk>> Ret;
   auto Add = [&](Expected<ELFYAML::Chunk *> SecOrErr) -> Error {
     if (!SecOrErr)
       return SecOrErr.takeError();
     Ret.emplace_back(*SecOrErr);
     return Error::success();
   };
 
   auto GetDumper = [this](unsigned Type)
       -> std::function<Expected<ELFYAML::Chunk *>(const Elf_Shdr *)> {
     if (Obj.getHeader().e_machine == ELF::EM_ARM && Type == ELF::SHT_ARM_EXIDX)
       return [this](const Elf_Shdr *S) { return dumpARMIndexTableSection(S); };
 
if (Sec.sh_type == ELF::SHT_PROGBITS) {
         continue;
       }
     }
 
     if (Error E = Add(dumpContentSection(&Sec)))
       return std::move(E);
   }
 
+  setOffsets<ELFT>(Ret, Sections);
   return std::move(Ret);
 }
 
 template <class ELFT>
 Error ELFDumper<ELFT>::dumpSymbols(const Elf_Shdr *Symtab,
                              std::vector<ELFYAML::Symbol> &Symbols) {
   if (!Symtab)
     return Error::success();