[yaml2obj] Write the section header table after section contents

[MaskRay]

Summary

Linkers (ld.bfd/gold/lld) place the section header table at the very
end. The section header table is optional in executable/shared objects,
so this allows tools to strip it. In addition, if we add or remove a
section, the size of the section header table will change. Placing the
section header table in the end keeps section offsets unchanged.

yaml2obj currently places the section header table immediately after the
program header. Follow what linkers do to make offset updating easier.

[MaskRay]

There are 20+ other tests (llvm-readobj,llvm-objcopy,etc) that are affected. I am still updating them.

[grimar]

Generally the idea is OK I think.

lib/ObjectYAML/ELFEmitter.cpp

233

Seems you can just call initELFHeader later instead?
I think placing it right before OS.write((const char *)&Header, sizeof(Header)); in ELFState<ELFT>::writeELF should work.

It needs rewriting the assignment:

const size_t SectionContentBeginOffset = Header.e_ehsize +
                                         Header.e_phentsize * Header.e_phnum +
                                         Header.e_shentsize * Header.e_shnum;

to something like

const size_t SectionContentBeginOffset = sizeof(Elf_Ehdr) +
                                         sizeof(Elf_Phdr) * Doc.ProgramHeaders.size() + ... ;

but seems there are no more problems?

1030

typedef typename ELFT::uint uintX_t; ?

1063

You don't need (void) I think. We already have one more place where the result isn't used.

[MaskRay]

Update remaining tests
Address review comments

[MaskRay]

lib/ObjectYAML/ELFEmitter.cpp

233

Reordered.

Elf_Ehdr Header;
uint64_t SHOff;
(void)CBA.getOSAndAlignedOffset(SHOff, sizeof(typename ELFT::uint));
State.initELFHeader(Header, SHOff);
OS.write((const char *)&Header, sizeof(Header));

is still needed.

1030

Moved one use of typename ELFT::uint into initELFHeader, so this function just uses typename ELFT::uint once. The typedef will be reundant, then.

[grimar]

lib/ObjectYAML/ELFEmitter.cpp

1063

Side note: we are not consistent in naming... we have ShOffset vs SHOffset and what is worse IO.mapOptional("SHOffset", FileHdr.SHOffset); vs IO.mapOptional("ShOffset", Section.ShOffset)

1066–1067

What do you think about moving this code to a new method which can replace the
initELFHeader? Something like:

void ELFState<ELFT>::writeElfHeader() {
  uint64_t SHOff;
  CBA.getOSAndAlignedOffset(SHOff, sizeof(typename ELFT::uint));

  Elf_Ehdr Header;

  /* Place the code from initELFHeader() method here */

  OS.write((const char *)&Header, sizeof(Header));
}

That way you do not need to declare and pass Elf_Ehdr and SHOff from here.

[MaskRay]

Replace initELFHeader with writeELFHeader

[MaskRay]

lib/ObjectYAML/ELFEmitter.cpp

1063

Changed to ShOffset

[MaskRay]

SHOff -> ShOffset

[grimar]

LGTM

test/tools/llvm-objcopy/ELF/overlapping-sections-in-segments.test

13 ↗

(On Diff #218902)

Seems we should be able to rewrite this and "overlapping-sections.test" tests to use just YAML, since we have override the sh_offset now. I'll try to do this.

[grimar]

test/tools/llvm-objcopy/ELF/overlapping-sections-in-segments.test

13 ↗

(On Diff #218902)

since we have -> since we can

[jhenderson]

Thanks for doing this. I have vague concerns that there might be some tests out there that assume the section header table's position, and somehow rely on it, but are now passing for unrelated reasons to their original intent, but I don't have a good way to check for them short of auditing every yaml2obj user, which seems silly, so I guess we just have to take that risk.

[grimar]

It broke ASan BB:
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/13820/steps/check-llvm%20asan/logs/stdio

It is not a problem of this patch and hopefully is fixed now by rL371318. I am waiting for BB build result.

[grimar]

BB is happy: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/13822

[MaskRay]

In D67221#1660429, @jhenderson wrote:

Thanks for doing this. I have vague concerns that there might be some tests out there that assume the section header table's position, and somehow rely on it, but are now passing for unrelated reasons to their original intent, but I don't have a good way to check for them short of auditing every yaml2obj user, which seems silly, so I guess we just have to take that risk.

I have considered this use case. An unconventional placement of the section header table may detect problems that reply on its exact position. Making it follow the convention will no longer detect such problems. Just like we have SHOff, SHNum, ShOffset, etc, we can probably add an option to place the section header table immediately after the program header, if we consider this check useful. A more general option is to add a gap between the program header table and the first section.

In D67221#1662264, @grimar wrote:

BB is happy: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/13822

Thanks!

[jhenderson]

In D67221#1662273, @MaskRay wrote:

I have considered this use case. An unconventional placement of the section header table may detect problems that reply on its exact position. Making it follow the convention will no longer detect such problems. Just like we have SHOff, SHNum, ShOffset, etc, we can probably add an option to place the section header table immediately after the program header, if we consider this check useful. A more general option is to add a gap between the program header table and the first section.

I might even go one step further and allow an option to force the exact offset of the section header table (and the program header table for that matter), as opposed to just the value written in the ELF header. That would allow for maximum flexibility. Having a default of after the sections though makes a lot of sense to me.

lib/ObjectYAML/ELFEmitter.cpp

template <class ELFT> void ELFState<ELFT>::initELFHeader(Elf_Ehdr &Header) {
   Header.e_flags = Doc.Header.Flags;
   Header.e_ehsize = sizeof(Elf_Ehdr);
   Header.e_phentsize = sizeof(Elf_Phdr);
   Header.e_phnum = Doc.ProgramHeaders.size();
 
   Header.e_shentsize =
       Doc.Header.SHEntSize ? (uint16_t)*Doc.Header.SHEntSize : sizeof(Elf_Shdr);
   // Immediately following the ELF header and program headers.
-  Header.e_shoff =
-      Doc.Header.SHOffset
-          ? (typename ELFT::uint)(*Doc.Header.SHOffset)
-          : sizeof(Header) + sizeof(Elf_Phdr) * Doc.ProgramHeaders.size();
+  // e_shoff will be filled in in writeELF.
   Header.e_shnum =
       Doc.Header.SHNum ? (uint16_t)*Doc.Header.SHNum : Doc.Sections.size();
   Header.e_shstrndx = Doc.Header.SHStrNdx ? (uint16_t)*Doc.Header.SHStrNdx
                                           : SN2I.get(".shstrtab");
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
for (const std::unique_ptr<ELFYAML::Section> &Sec : Doc.Sections) {
     }
   }
 
   DotDynstr.finalize();
 }
 
 template <class ELFT>
 int ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc) {
   ELFState<ELFT> State(Doc);
 
   // Finalize .strtab and .dynstr sections. We do that early because want to
   // finalize the string table builders before writing the content of the
   // sections that might want to use them.
   State.finalizeStrings();
 
   if (!State.buildSectionIndex() || !State.buildSymbolIndexes())
     return 1;
 
   Elf_Ehdr Header;
   State.initELFHeader(Header);
 
   // TODO: Flesh out section header support.
 
   std::vector<Elf_Phdr> PHeaders;
   State.initProgramHeaders(PHeaders);
 
   // XXX: This offset is tightly coupled with the order that we write
   // things to `OS`.
-  const size_t SectionContentBeginOffset = Header.e_ehsize +
-                                           Header.e_phentsize * Header.e_phnum +
-                                           Header.e_shentsize * Header.e_shnum;
+  const size_t SectionContentBeginOffset =
+      Header.e_ehsize + Header.e_phentsize * Header.e_phnum;
   ContiguousBlobAccumulator CBA(SectionContentBeginOffset);
 
   std::vector<Elf_Shdr> SHeaders;
   if (!State.initSectionHeaders(SHeaders, CBA))
     return 1;
 
   // Now we can decide segment offsets
   State.setProgramHeaderLayout(PHeaders, SHeaders);
 
+  // Align the start of the section header and write the ELF header.
+  uint64_t Offset;
+  (void)CBA.getOSAndAlignedOffset(Offset, sizeof(typename ELFT::uint));
+  Header.e_shoff =
+      Doc.Header.SHOffset ? typename ELFT::uint(*Doc.Header.SHOffset) : Offset;
   OS.write((const char *)&Header, sizeof(Header));
+
   writeArrayData(OS, makeArrayRef(PHeaders));
-  writeArrayData(OS, makeArrayRef(SHeaders));
   CBA.writeBlobToStream(OS);
+  writeArrayData(OS, makeArrayRef(SHeaders));
   return 0;
 }
 
 namespace llvm {
 namespace yaml {
 
 int yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out) {
   bool IsLE = Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);

test/Object/invalid.test

FileHeader:
   SHNum:   0xFF
 
 ## Check that llvm-readobj reports an error if a relocation contains an
 ## incorrect (too large) symbol index.
 
 # RUN: yaml2obj %s --docnum=16 -o %t16
 # RUN: not llvm-readobj -r %t16 2>&1 | FileCheck -DFILE=%t16 --check-prefix=INVALID-REL-SYM %s
 
-# INVALID-REL-SYM: error: '[[FILE]]': unable to access section [index 2] data at 0x18000180: offset goes past the end of file
+# INVALID-REL-SYM: error: '[[FILE]]': unable to access section [index 2] data at 0x18000040: offset goes past the end of file
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

 
 ## We report an error if the number of sections stored in sh_size
 ## is greater than UINT64_MAX / sizeof(Elf_Shdr) == 288230376151711743.
 ## Here we check that do not crash on a border value.
 
 # RUN: yaml2obj --docnum=26 %s -o %t26
 # RUN: not llvm-readobj -h %t26 2>&1 | FileCheck -DFILE=%t26 --check-prefix=INVALID-SEC-NUM1 %s
 
-# INVALID-SEC-NUM1: error: '[[FILE]]': invalid section header table offset (e_shoff = 0x40) or invalid number of sections specified in the first section header's sh_size field (0x3ffffffffffffff)
+# INVALID-SEC-NUM1: error: '[[FILE]]': invalid section header table offset (e_shoff = 0x78) or invalid number of sections specified in the first section header's sh_size field (0x3ffffffffffffff)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
   SHNum:   0x0

test/tools/llvm-readobj/elf-wrong-shstrtab-type.test

 # LLVM: warning: '[[FILE]]': invalid sh_type for string table section [index 1]: expected SHT_STRTAB, but got SHT_PROGBITS
 # LLVM:  Section {
 # LLVM:    Name: .shstrtab
 # LLVM:    Type: SHT_PROGBITS
 
 # GNU: Section Headers:
 # GNU:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
 # GNU: warning: '[[FILE]]': invalid sh_type for string table section [index 1]: expected SHT_STRTAB, but got SHT_PROGBITS
-# GNU:   [ 1] .shstrtab         PROGBITS        0000000000000000 000140 00001b 00 0   0  0
+# GNU:   [ 1] .shstrtab         PROGBITS        0000000000000000 000040 00001b 00 0   0  0
 
 ## Test we report multiple identical warnings (one for each object) when dumping an archive.
 
 # RUN: rm -f %t.a
 # RUN: cp %t1 %t2
 # RUN: llvm-ar rc %t.a %t1 %t2 %t1
 # RUN: llvm-readobj -S %t.a 2>&1 | FileCheck %s --implicit-check-not warning --check-prefix WARNINGS
 # RUN: llvm-readelf -S %t.a 2>&1 | FileCheck %s --implicit-check-not warning --check-prefix WARNINGS

test/tools/llvm-readobj/gnu-sections.test

 # RUN: yaml2obj --docnum=1 %s -o %t-i386.o
 # RUN: llvm-readelf -S %t-i386.o | FileCheck %s -check-prefix ELF32
 
-# ELF32:      There are 8 section headers, starting at offset 0x34:
+# ELF32:      There are 8 section headers, starting at offset 0x90:
 # ELF32-EMPTY:
 # ELF32-NEXT: Section Headers:
 # ELF32-NEXT:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
 # ELF32-NEXT:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
-# ELF32-NEXT:   [ 1] .text             PROGBITS        00000000 000174 000001 00  AX  0   0  4
-# ELF32-NEXT:   [ 2] .rel.text         REL             00000000 000178 000000 08      5   1  4
-# ELF32-NEXT:   [ 3] .data             PROGBITS        00000000 000178 000000 00  WA  0   0  4
-# ELF32-NEXT:   [ 4] .bss              NOBITS          00000000 000178 000000 00  WA  0   0  4
-# ELF32-NEXT:   [ 5] .symtab           SYMTAB          00000000 000178 000020 10      6   2  8
-# ELF32-NEXT:   [ 6] .strtab           STRTAB          00000000 000198 000007 00      0   0  1
-# ELF32-NEXT:   [ 7] .shstrtab         STRTAB          00000000 00019f 000030 00      0   0  1
+# ELF32-NEXT:   [ 1] .text             PROGBITS        00000000 000034 000001 00  AX  0   0  4
+# ELF32-NEXT:   [ 2] .rel.text         REL             00000000 000038 000000 08      5   1  4
+# ELF32-NEXT:   [ 3] .data             PROGBITS        00000000 000038 000000 00  WA  0   0  4
+# ELF32-NEXT:   [ 4] .bss              NOBITS          00000000 000038 000000 00  WA  0   0  4
+# ELF32-NEXT:   [ 5] .symtab           SYMTAB          00000000 000038 000020 10      6   2  8
+# ELF32-NEXT:   [ 6] .strtab           STRTAB          00000000 000058 000007 00      0   0  1
+# ELF32-NEXT:   [ 7] .shstrtab         STRTAB          00000000 00005f 000030 00      0   0  1
 # ELF32-NEXT: Key to Flags:
 # ELF32-NEXT:   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)
 # ELF32-NEXT:   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
 # ELF32-NEXT:   O (extra OS processing required) o (OS specific), p (processor specific)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32

 ## Check that --wide is the same as -W and ignored and also
 ## that --section is the same as -S.
 # RUN: llvm-readobj --wide --sections %t-x64.o --elf-output-style=GNU \
 # RUN:   | FileCheck %s -check-prefix ELF64
 # RUN: llvm-readobj -W --sections %t-x64.o --elf-output-style=GNU \
 # RUN:   | FileCheck %s -check-prefix ELF64
 # RUN: llvm-readelf -W -S %t-x64.o | FileCheck %s -check-prefix ELF64
 
-# ELF64:      There are 8 section headers, starting at offset 0x40:
+# ELF64:      There are 8 section headers, starting at offset 0xb0:
 # ELF64-EMPTY: 
 # ELF64-NEXT: Section Headers:
 # ELF64-NEXT:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
 # ELF64-NEXT:   [ 0]                   NULL            0000000000000000 000000 000000 00  0  0  0
-# ELF64-NEXT:   [ 1] .text             PROGBITS        0000000000000000 000240 000001 00  AX 0   0  4
-# ELF64-NEXT:   [ 2] .rela.text        RELA            0000000000000000 000248 000000 18  5  1  8
-# ELF64-NEXT:   [ 3] .data             PROGBITS        0000000000000000 000248 000000 00  WA 0   0  4
-# ELF64-NEXT:   [ 4] .bss              NOBITS          0000000000000000 000248 000000 00  WA 0   0  4
-# ELF64-NEXT:   [ 5] .symtab           SYMTAB          0000000000000000 000248 000030 18  6  2  8
-# ELF64-NEXT:   [ 6] .strtab           STRTAB          0000000000000000 000278 000007 00  0  0  1
-# ELF64-NEXT:   [ 7] .shstrtab         STRTAB          0000000000000000 00027f 000031 00  0  0  1
+# ELF64-NEXT:   [ 1] .text             PROGBITS        0000000000000000 000040 000001 00  AX 0   0  4
+# ELF64-NEXT:   [ 2] .rela.text        RELA            0000000000000000 000048 000000 18  5  1  8
+# ELF64-NEXT:   [ 3] .data             PROGBITS        0000000000000000 000048 000000 00  WA 0   0  4
+# ELF64-NEXT:   [ 4] .bss              NOBITS          0000000000000000 000048 000000 00  WA 0   0  4
+# ELF64-NEXT:   [ 5] .symtab           SYMTAB          0000000000000000 000048 000030 18  6  2  8
+# ELF64-NEXT:   [ 6] .strtab           STRTAB          0000000000000000 000078 000007 00  0  0  1
+# ELF64-NEXT:   [ 7] .shstrtab         STRTAB          0000000000000000 00007f 000031 00  0  0  1
 # ELF64-NEXT: Key to Flags:
 # ELF64-NEXT:   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)
 # ELF64-NEXT:   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
 # ELF64-NEXT:   O (extra OS processing required) o (OS specific), p (processor specific)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64

test/tools/llvm-readobj/reloc-types-elf-i386.test

 # LLVM: Type: R_386_TLS_DTPOFF32 (36)
 # LLVM: Type: R_386_TLS_TPOFF32 (37)
 # LLVM: Type: R_386_TLS_GOTDESC (39)
 # LLVM: Type: R_386_TLS_DESC_CALL (40)
 # LLVM: Type: R_386_TLS_DESC (41)
 # LLVM: Type: R_386_IRELATIVE (42)
 # LLVM: Type: R_386_GOT32X (43)
 
-# GNU:      Relocation section '.rel.text' at offset 0x128 contains 41 entries:
+# GNU:      Relocation section '.rel.text' at offset 0x38 contains 41 entries:
 # GNU-NEXT:  Offset     Info    Type                Sym. Value  Symbol's Name
 # GNU-NEXT: 00000002  00000100 R_386_NONE             00000000   foo
 # GNU-NEXT: 00000008  00000101 R_386_32               00000000   foo
 # GNU-NEXT: 0000000e  00000102 R_386_PC32             00000000   foo
 # GNU-NEXT: 00000014  00000103 R_386_GOT32            00000000   foo
 # GNU-NEXT: 0000001a  00000104 R_386_PLT32            00000000   foo
 # GNU-NEXT: 00000020  00000105 R_386_COPY             00000000   foo
 # GNU-NEXT: 00000026  00000106 R_386_GLOB_DAT         00000000   foo

test/tools/llvm-readobj/reloc-types-elf-x64.test

 # LLVM: Type: R_X86_64_SIZE64 (33)
 # LLVM: Type: R_X86_64_GOTPC32_TLSDESC (34)
 # LLVM: Type: R_X86_64_TLSDESC_CALL (35)
 # LLVM: Type: R_X86_64_TLSDESC (36)
 # LLVM: Type: R_X86_64_IRELATIVE (37)
 # LLVM: Type: R_X86_64_GOTPCRELX (41)
 # LLVM: Type: R_X86_64_REX_GOTPCRELX (42)
 
-# GNU:      Relocation section '.rela.text' at offset 0x1c8 contains 40 entries:
+# GNU:      Relocation section '.rela.text' at offset 0x48 contains 40 entries:
 # GNU-NEXT:     Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
 # GNU-NEXT: 0000000000000003  0000000100000000 R_X86_64_NONE          0000000000000000 foo + 0
 # GNU-NEXT: 000000000000000a  0000000100000001 R_X86_64_64            0000000000000000 foo + 0
 # GNU-NEXT: 0000000000000011  0000000100000002 R_X86_64_PC32          0000000000000000 foo + 0
 # GNU-NEXT: 0000000000000018  0000000100000003 R_X86_64_GOT32         0000000000000000 foo + 0
 # GNU-NEXT: 000000000000001f  0000000100000004 R_X86_64_PLT32         0000000000000000 foo + 0
 # GNU-NEXT: 0000000000000026  0000000100000005 R_X86_64_COPY          0000000000000000 foo + 0
 # GNU-NEXT: 000000000000002d  0000000100000006 R_X86_64_GLOB_DAT      0000000000000000 foo + 0

test/tools/llvm-readobj/unwind.test

 # RUN: yaml2obj %s > %t.exe
 # RUN: llvm-readobj --unwind %t.exe | FileCheck %s
 
 # CHECK:      EH_FRAME Header [
 # CHECK-NEXT:  Address: 0x4013c0
-# CHECK-NEXT:  Offset: 0x27c
+# CHECK-NEXT:  Offset: 0xbc
 # CHECK-NEXT:  Size: 0x3c
 # CHECK-NEXT:  Corresponding Section: .eh_frame_hdr
 # CHECK-NEXT:  Header {
 # CHECK-NEXT:    version: 1
 # CHECK-NEXT:    eh_frame_ptr_enc: 0x1b
 # CHECK-NEXT:    fde_count_enc: 0x3
 # CHECK-NEXT:    table_enc: 0x3b
 # CHECK-NEXT:    eh_frame_ptr: 0x401400

 # CHECK-NEXT:    }
 # CHECK-NEXT:    entry 5 {
 # CHECK-NEXT:      initial_location: 0x4012c0
 # CHECK-NEXT:      address: 0x4014f0
 # CHECK-NEXT:    }
 # CHECK-NEXT:  }
 # CHECK-NEXT:]
 
-# CHECK:      .eh_frame section at offset 0x2b8 address 0x401400:
+# CHECK:      .eh_frame section at offset 0xf8 address 0x401400:
 # CHECK-NEXT:  [0x401400] CIE length=20
 # CHECK-NEXT:    version: 1
 # CHECK-NEXT:    augmentation: zR
 # CHECK-NEXT:    code_alignment_factor: 1
 # CHECK-NEXT:    data_alignment_factor: -8
 # CHECK-NEXT:    return_address_register: 16
 
 # CHECK:         Program:

test/tools/yaml2obj/dynsymtab-implicit-sections-size-content.yaml

 # RUN: llvm-readobj --section-data -S %t4 | FileCheck %s --check-prefix=CASE4
 
 # CASE4:      Name: .dynsym
 # CASE4-NEXT: Type: SHT_DYNSYM
 # CASE4-NEXT: Flags [
 # CASE4-NEXT:   SHF_ALLOC
 # CASE4-NEXT: ]
 # CASE4-NEXT: Address: 0x0
-# CASE4-NEXT: Offset: 0x180
+# CASE4-NEXT: Offset: 0x40
 # CASE4-NEXT: Size: 2
 # CASE4-NEXT: Link: 0
 # CASE4-NEXT: Info: 1
 # CASE4-NEXT: AddressAlignment: 0
 # CASE4-NEXT: EntrySize: 24
 # CASE4-NEXT: SectionData (
 # CASE4-NEXT:   0000: 0123
 # CASE4-NEXT: )

 # RUN: llvm-readobj --section-data -S %t5 | FileCheck %s --check-prefix=CASE5
 
 # CASE5:      Name: .dynsym
 # CASE5-NEXT: Type: SHT_DYNSYM
 # CASE5-NEXT: Flags [
 # CASE5-NEXT:   SHF_ALLOC
 # CASE5-NEXT: ]
 # CASE5-NEXT: Address: 0x0
-# CASE5-NEXT: Offset: 0x180
+# CASE5-NEXT: Offset: 0x40
 # CASE5-NEXT: Size: 5
 # CASE5-NEXT: Link: 0
 # CASE5-NEXT: Info: 1
 # CASE5-NEXT: AddressAlignment: 0
 # CASE5-NEXT: EntrySize: 24
 # CASE5-NEXT: SectionData (
 # CASE5-NEXT:   0000: 00000000 00
 # CASE5-NEXT: )

 # RUN: llvm-readobj %t6 --section-data -S | FileCheck %s --check-prefix=CASE6
 
 # CASE6:      Name: .dynsym
 # CASE6-NEXT: Type: SHT_DYNSYM
 # CASE6-NEXT: Flags [
 # CASE6-NEXT:   SHF_ALLOC
 # CASE6-NEXT: ]
 # CASE6-NEXT: Address: 0x0
-# CASE6-NEXT: Offset: 0x180
+# CASE6-NEXT: Offset: 0x40
 # CASE6-NEXT: Size: 4
 # CASE6-NEXT: Link: 0
 # CASE6-NEXT: Info: 1
 # CASE6-NEXT: AddressAlignment: 0
 # CASE6-NEXT: EntrySize: 24
 # CASE6-NEXT: SectionData (
 # CASE6-NEXT:   0000: 01230000
 # CASE6-NEXT: )

 # RUN: llvm-readobj --section-data -S %t7 | FileCheck %s --check-prefix=CASE7
 
 # CASE7:       Name: .dynsym
 # CASE7-NEXT:  Type: SHT_DYNSYM
 # CASE7-NEXT:  Flags [
 # CASE7-NEXT:    SHF_ALLOC
 # CASE7-NEXT:  ]
 # CASE7-NEXT:  Address: 0x0
-# CASE7-NEXT:  Offset: 0x180
+# CASE7-NEXT:  Offset: 0x40
 # CASE7-NEXT:  Size: 2
 # CASE7-NEXT:  Link: 0
 # CASE7-NEXT:  Info: 1
 # CASE7-NEXT:  AddressAlignment: 0
 # CASE7-NEXT:  EntrySize: 24
 # CASE7-NEXT:  SectionData (
 # CASE7-NEXT:    0000: 0123
 # CASE7-NEXT:  )

test/tools/yaml2obj/elf-custom-null-section.yaml

 ## In this test we check that can redefine the null section in the YAML.
 
 ## Test the default output first.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf --sections %t1 | FileCheck %s --check-prefix=DEFAULT
 
 # DEFAULT:      Section Headers:
 # DEFAULT-NEXT:  [Nr] Name      Type   Address          Off    Size   ES Flg Lk Inf Al
 # DEFAULT-NEXT:  [ 0]           NULL   0000000000000000 000000 000000 00 0   0  0
-# DEFAULT-NEXT:  [ 1] .symtab   SYMTAB 0000000000000000 000140 000018 18 2   1  8
-# DEFAULT-NEXT:  [ 2] .strtab   STRTAB 0000000000000000 000158 000001 00 0   0  1
-# DEFAULT-NEXT:  [ 3] .shstrtab STRTAB 0000000000000000 000159 00001b 00 0   0  1
+# DEFAULT-NEXT:  [ 1] .symtab   SYMTAB 0000000000000000 000040 000018 18 2   1  8
+# DEFAULT-NEXT:  [ 2] .strtab   STRTAB 0000000000000000 000058 000001 00 0   0  1
+# DEFAULT-NEXT:  [ 3] .shstrtab STRTAB 0000000000000000 000059 00001b 00 0   0  1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 

 ## Check we are still able to describe other sections too.
 
 # RUN: yaml2obj --docnum=5 %s -o %t5
 # RUN: llvm-readelf --sections %t5 | FileCheck %s --check-prefix=OTHER-SECTION
 
 # OTHER-SECTION:      Section Headers:
 # OTHER-SECTION-NEXT:   [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf Al
 # OTHER-SECTION-NEXT:   [ 0]           NULL     0000000000000000 000000 000000 00 0   0  0
-# OTHER-SECTION-NEXT:   [ 1] foo       PROGBITS 0000000000000000 000180 000000 00 0   0  0
-# OTHER-SECTION-NEXT:   [ 2] .symtab   SYMTAB   0000000000000000 000180 000018 18 3   1  8
-# OTHER-SECTION-NEXT:   [ 3] .strtab   STRTAB   0000000000000000 000198 000001 00 0   0  1
-# OTHER-SECTION-NEXT:   [ 4] .shstrtab STRTAB   0000000000000000 000199 00001f 00 0   0  1
+# OTHER-SECTION-NEXT:   [ 1] foo       PROGBITS 0000000000000000 000040 000000 00 0   0  0
+# OTHER-SECTION-NEXT:   [ 2] .symtab   SYMTAB   0000000000000000 000040 000018 18 3   1  8
+# OTHER-SECTION-NEXT:   [ 3] .strtab   STRTAB   0000000000000000 000058 000001 00 0   0  1
+# OTHER-SECTION-NEXT:   [ 4] .shstrtab STRTAB   0000000000000000 000059 00001f 00 0   0  1
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

 ## Check we do not crash if we have more than one SHT_NULL section.
 
 # RUN: yaml2obj --docnum=8 %s -o %t8
 # RUN: llvm-readelf --sections %t8 | FileCheck %s --check-prefix=MULTIPLE
 
 # MULTIPLE:      Section Headers:
 # MULTIPLE-NEXT:  [Nr] Name Type Address          Off    Size   ES Flg Lk Inf Al
 # MULTIPLE-NEXT:  [ 0]      NULL 0000000000000000 000000 000000 00 0   0  0
-# MULTIPLE-NEXT:  [ 1] .foo NULL 0000000000000123 000180 000020 10 A   1  2   0
+# MULTIPLE-NEXT:  [ 1] .foo NULL 0000000000000123 000040 000020 10 A   1  2   0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

test/tools/yaml2obj/elf-header-sh-fields.yaml

 ## In this test case we check that we can override the default values for
 ## e_shentsize, e_shoff, e_shnum and e_shstrndx fields in the YAML.
 
 ## First we check the default values.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf --file-headers %t1 | FileCheck %s --check-prefix=DEFAULT
 
-# DEFAULT:   Start of section headers:          64 (bytes into file)
+# DEFAULT:   Start of section headers:          120 (bytes into file)
 # DEFAULT:   Size of section headers:           64 (bytes)
 # DEFAULT:   Number of section headers:         4
 # DEFAULT:   Section header string table index: 3
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB

test/tools/yaml2obj/elf-override-shsize.yaml

 ## Check we are able to set custom sh_size field
 ## for different sections.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf --sections %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      Section Headers:
 # CASE1-NEXT:  [Nr] Name           Type     Address          Off    Size  
 # CASE1-NEXT:  [ 0]                NULL     0000000000000000 000000 000000
-# CASE1-NEXT:  [ 1] .dynsym        DYNSYM   0000000000000000 000380 000001
-# CASE1-NEXT:  [ 2] .symtab        SYMTAB   0000000000000000 000398 000002
-# CASE1-NEXT:  [ 3] .dynamic       DYNAMIC  0000000000000000 0003b0 000003
-# CASE1-NEXT:  [ 4] .rela          RELA     0000000000000000 0003b0 000004
-# CASE1-NEXT:  [ 5] .nobits        NOBITS   0000000000000000 0003b0 000005
-# CASE1-NEXT:  [ 6] .group         GROUP    0000000000000000 0003b0 000006
-# CASE1-NEXT:  [ 7] .gnu.version   VERSYM   0000000000000000 0003b0 000007
-# CASE1-NEXT:  [ 8] .gnu.version_r VERNEED  0000000000000000 0003b0 000008
-# CASE1-NEXT:  [ 9] .gnu.version_d VERDEF   0000000000000000 0003b0 000009
-# CASE1-NEXT:  [10] .regular       PROGBITS 0000000000000000 0003b0 00000a
-# CASE1-NEXT:  [11] .strtab        STRTAB   0000000000000000 0003b0 00000b
+# CASE1-NEXT:  [ 1] .dynsym        DYNSYM   0000000000000000 000040 000001
+# CASE1-NEXT:  [ 2] .symtab        SYMTAB   0000000000000000 000058 000002
+# CASE1-NEXT:  [ 3] .dynamic       DYNAMIC  0000000000000000 000070 000003
+# CASE1-NEXT:  [ 4] .rela          RELA     0000000000000000 000070 000004
+# CASE1-NEXT:  [ 5] .nobits        NOBITS   0000000000000000 000070 000005
+# CASE1-NEXT:  [ 6] .group         GROUP    0000000000000000 000070 000006
+# CASE1-NEXT:  [ 7] .gnu.version   VERSYM   0000000000000000 000070 000007
+# CASE1-NEXT:  [ 8] .gnu.version_r VERNEED  0000000000000000 000070 000008
+# CASE1-NEXT:  [ 9] .gnu.version_d VERDEF   0000000000000000 000070 000009
+# CASE1-NEXT:  [10] .regular       PROGBITS 0000000000000000 000070 00000a
+# CASE1-NEXT:  [11] .strtab        STRTAB   0000000000000000 000070 00000b
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

test/tools/yaml2obj/explicit-dynsym-no-dynstr.yaml

 ## Check we do not crash/assert when .dynsym is specified
 ## explicitly, but .dynstr is not present.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readelf --section-headers %t | FileCheck %s
 
 ## Check that .dynsym has Link field set to 0.
 
 # CHECK:      Section Headers:
 # CHECK-NEXT:  [Nr] Name    Type   Address          Off    Size   ES Flg Lk
 # CHECK-NEXT:  [ 0]         NULL   0000000000000000 000000 000000 00 0   0
-# CHECK-NEXT:  [ 1] .dynsym DYNSYM 0000000000000000 000180 000018 18 A   0
+# CHECK-NEXT:  [ 1] .dynsym DYNSYM 0000000000000000 000040 000018 18 A   0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name: .dynsym
     Type: SHT_DYNSYM

test/tools/yaml2obj/implicit-sections.test

 ## Check the section header properties of ".dynsym",
 ## ".dynstr", ".symtab", ".strtab", ".shstrtab".
 ## These sections sections are usually added implicitly,
 ## but here we add them explicitly in YAML and verify.
 ## We check their order matches YAML and that file offset is
 ## ascending. This is a natural default behavior.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readelf -S %t1 | FileCheck %s
 
 # CHECK:      Section Headers:
 # CHECK-NEXT:  [Nr] Name      Type     Address          Off    Size
 # CHECK-NEXT:  [ 0]           NULL     0000000000000000 000000 000000
-# CHECK-NEXT:  [ 1] .dynstr   STRTAB   0000000000000100 000200 000009
-# CHECK-NEXT:  [ 2] .dynsym   DYNSYM   0000000000000150 000209 000030
-# CHECK-NEXT:  [ 3] .symtab   SYMTAB   0000000000000000 000239 000018
-# CHECK-NEXT:  [ 4] .strtab   STRTAB   0000000000000000 000251 000001
-# CHECK-NEXT:  [ 5] .shstrtab STRTAB   0000000000000000 000252 000035
-# CHECK-NEXT:  [ 6] .text.foo PROGBITS 0000000000000200 000287 000000
+# CHECK-NEXT:  [ 1] .dynstr   STRTAB   0000000000000100 000040 000009
+# CHECK-NEXT:  [ 2] .dynsym   DYNSYM   0000000000000150 000049 000030
+# CHECK-NEXT:  [ 3] .symtab   SYMTAB   0000000000000000 000079 000018
+# CHECK-NEXT:  [ 4] .strtab   STRTAB   0000000000000000 000091 000001
+# CHECK-NEXT:  [ 5] .shstrtab STRTAB   0000000000000000 000092 000035
+# CHECK-NEXT:  [ 6] .text.foo PROGBITS 0000000000000200 0000c7 000000
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:

 ## but the sections were explicitly listed. Check their VAs are correct.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readelf -S %t2 | FileCheck %s --check-prefix=NODYNSYM
 
 # NODYNSYM:      Section Headers:
 # NODYNSYM-NEXT: [Nr] Name      Type      Address          Off    Size
 # NODYNSYM-NEXT: [ 0]           NULL      0000000000000000 000000 000000
-# NODYNSYM-NEXT: [ 1] .dynstr   STRTAB    0000000000000100 000200 000001
-# NODYNSYM-NEXT: [ 2] .dynsym   DYNSYM    0000000000000150 000201 000018
-# NODYNSYM-NEXT: [ 3] .symtab   SYMTAB    0000000000000000 000219 000018
-# NODYNSYM-NEXT: [ 4] .strtab   STRTAB    0000000000000000 000231 000001
-# NODYNSYM-NEXT: [ 5] .shstrtab STRTAB    0000000000000000 000232 000035
-# NODYNSYM-NEXT: [ 6] .text.foo PROGBITS  0000000000000200 000267 000000
+# NODYNSYM-NEXT: [ 1] .dynstr   STRTAB    0000000000000100 000040 000001
+# NODYNSYM-NEXT: [ 2] .dynsym   DYNSYM    0000000000000150 000041 000018
+# NODYNSYM-NEXT: [ 3] .symtab   SYMTAB    0000000000000000 000059 000018
+# NODYNSYM-NEXT: [ 4] .strtab   STRTAB    0000000000000000 000071 000001
+# NODYNSYM-NEXT: [ 5] .shstrtab STRTAB    0000000000000000 000072 000035
+# NODYNSYM-NEXT: [ 6] .text.foo PROGBITS  0000000000000200 0000a7 000000
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:

test/tools/yaml2obj/program-header-align.yaml

- Type: PT_LOAD
     PAddr: 0xFFFF2040
     Align: 0x1000
     Sections:
       - Section: .data
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:   ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD
-#CHECK-NEXT:    Offset: 0x230
+#CHECK-NEXT:    Offset: 0xB0
 #CHECK-NEXT:    VirtualAddress: 0xAAAA1030
 #CHECK-NEXT:    PhysicalAddress: 0xFFFF1030
 #CHECK-NEXT:    FileSize: 4
 #CHECK-NEXT:    MemSize: 4
 #CHECK-NEXT:    Flags [
 #CHECK-NEXT:      PF_R
 #CHECK-NEXT:      PF_X
 #CHECK-NEXT:    ]
 #CHECK-NEXT:    Alignment: 4096
 #CHECK-NEXT:  }
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD
-#CHECK-NEXT:    Offset: 0x240
+#CHECK-NEXT:    Offset: 0xC0
 #CHECK-NEXT:    VirtualAddress: 0xAAAA2040
 #CHECK-NEXT:    PhysicalAddress: 0xFFFF2040
 #CHECK-NEXT:    FileSize: 4
 #CHECK-NEXT:    MemSize: 4
 #CHECK-NEXT:    Flags [
 #CHECK-NEXT:      PF_R
 #CHECK-NEXT:    ]
 #CHECK-NEXT:    Alignment: 4096
 #CHECK-NEXT:  }
 #CHECK-NEXT:]

test/tools/yaml2obj/section-size-content.yaml

 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj --section-data -S %t2 | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      Name: .foo
 # CASE2-NEXT: Type: SHT_PROGBITS
 # CASE2-NEXT: Flags [
 # CASE2-NEXT: ]
 # CASE2-NEXT: Address: 0x0
-# CASE2-NEXT: Offset: 0x180
+# CASE2-NEXT: Offset: 0x40
 # CASE2-NEXT: Size: 1
 # CASE2-NEXT: Link: 0
 # CASE2-NEXT: Info: 0
 # CASE2-NEXT: AddressAlignment: 0
 # CASE2-NEXT: EntrySize: 0
 # CASE2-NEXT: SectionData (
 # CASE2-NEXT:   0000: FF
 # CASE2-NEXT: )

 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-readobj --section-data -S %t4 | FileCheck %s --check-prefix=CASE3
 
 # CASE3:      Name: .foo
 # CASE3-NEXT: Type: SHT_PROGBITS
 # CASE3-NEXT: Flags [
 # CASE3-NEXT: ]
 # CASE3-NEXT: Address: 0x0
-# CASE3-NEXT: Offset: 0x180
+# CASE3-NEXT: Offset: 0x40
 # CASE3-NEXT: Size: 1
 # CASE3-NEXT: Link: 0
 # CASE3-NEXT: Info: 0
 # CASE3-NEXT: AddressAlignment: 0
 # CASE3-NEXT: EntrySize: 0
 # CASE3-NEXT: SectionData (
 # CASE3-NEXT:   0000: 00
 # CASE3-NEXT: )

 # RUN: yaml2obj --docnum=5 %s -o %t5
 # RUN: llvm-readobj --section-data -S %t5 | FileCheck %s --check-prefix=CASE4
 
 # CASE4:      Name: .foo
 # CASE4-NEXT: Type: SHT_PROGBITS
 # CASE4-NEXT: Flags [
 # CASE4-NEXT: ]
 # CASE4-NEXT: Address: 0x0
-# CASE4-NEXT: Offset: 0x180
+# CASE4-NEXT: Offset: 0x40
 # CASE4-NEXT: Size: 3
 # CASE4-NEXT: Link: 0
 # CASE4-NEXT: Info: 0
 # CASE4-NEXT: AddressAlignment: 0
 # CASE4-NEXT: EntrySize: 0
 # CASE4-NEXT: SectionData (
 # CASE4-NEXT:   0000: FF0000
 # CASE4-NEXT: )

 # RUN: yaml2obj --docnum=6 %s -o %t6
 # RUN: llvm-readobj %t6 --sections | FileCheck %s --check-prefix=CASE5
 
 # CASE5:      Name: .foo
 # CASE5-NEXT: Type: SHT_PROGBITS
 # CASE5-NEXT: Flags [
 # CASE5-NEXT: ]
 # CASE5-NEXT: Address: 0x0
-# CASE5-NEXT: Offset: 0x180
+# CASE5-NEXT: Offset: 0x40
 # CASE5-NEXT: Size: 0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64

test/tools/yaml2obj/strtab-implicit-sections-size-content.yaml

 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readobj --section-data -S %t2 | FileCheck %s --check-prefix=CASE2
 
 # CASE2:      Name: .strtab
 # CASE2-NEXT: Type: SHT_STRTAB
 # CASE2-NEXT: Flags [
 # CASE2-NEXT: ]
 # CASE2-NEXT: Address: 0x0
-# CASE2-NEXT: Offset: 0x140
+# CASE2-NEXT: Offset: 0x40
 # CASE2-NEXT: Size: 2
 # CASE2-NEXT: Link: 0
 # CASE2-NEXT: Info: 0
 # CASE2-NEXT: AddressAlignment: 0
 # CASE2-NEXT: EntrySize: 0
 # CASE2-NEXT: SectionData (
 # CASE2-NEXT:   0000: 0000
 # CASE2-NEXT: )

 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-readobj --section-data -S %t3 | FileCheck %s --check-prefix=CASE3
 
 # CASE3:      Name: .strtab
 # CASE3-NEXT: Type: SHT_STRTAB
 # CASE3-NEXT: Flags [
 # CASE3-NEXT: ]
 # CASE3-NEXT: Address: 0x0
-# CASE3-NEXT: Offset: 0x140
+# CASE3-NEXT: Offset: 0x40
 # CASE3-NEXT: Size: 2
 # CASE3-NEXT: Link: 0
 # CASE3-NEXT: Info: 0
 # CASE3-NEXT: AddressAlignment: 0
 # CASE3-NEXT: EntrySize: 0
 # CASE3-NEXT: SectionData (
 # CASE3-NEXT:   0000: 0102
 # CASE3-NEXT: )

 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-readobj --section-data -S %t4 | FileCheck %s --check-prefix=CASE4
 
 # CASE4:      Name: .strtab
 # CASE4-NEXT: Type: SHT_STRTAB
 # CASE4-NEXT: Flags [
 # CASE4-NEXT: ]
 # CASE4-NEXT: Address: 0x0
-# CASE4-NEXT: Offset: 0x140
+# CASE4-NEXT: Offset: 0x40
 # CASE4-NEXT: Size: 3
 # CASE4-NEXT: Link: 0
 # CASE4-NEXT: Info: 0
 # CASE4-NEXT: AddressAlignment: 0
 # CASE4-NEXT: EntrySize: 0
 # CASE4-NEXT: SectionData (
 # CASE4-NEXT:   0000: 010200
 # CASE4-NEXT: )

 # RUN: yaml2obj --docnum=5 %s -o %t5
 # RUN: llvm-readobj --section-data -S %t5 | FileCheck %s --check-prefix=CASE5
 
 # CASE5:      Name: .strtab
 # CASE5-NEXT: Type: SHT_STRTAB
 # CASE5-NEXT: Flags [ (0x0)
 # CASE5-NEXT: ]
 # CASE5-NEXT: Address: 0x0
-# CASE5-NEXT: Offset: 0x140
+# CASE5-NEXT: Offset: 0x40
 # CASE5-NEXT: Size: 2
 # CASE5-NEXT: Link: 0
 # CASE5-NEXT: Info: 0
 # CASE5-NEXT: AddressAlignment: 0
 # CASE5-NEXT: EntrySize: 0
 # CASE5-NEXT: SectionData (
 # CASE5-NEXT:   0000: 0102
 # CASE5-NEXT: )

test/tools/yaml2obj/symtab-implicit-sections-size-content.yaml

 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-readobj --section-data -S %t4 | FileCheck %s --check-prefix=CASE4
 
 # CASE4:      Name: .symtab
 # CASE4-NEXT: Type: SHT_SYMTAB
 # CASE4-NEXT: Flags [ (0x0)
 # CASE4-NEXT: ]
 # CASE4-NEXT: Address: 0x0
-# CASE4-NEXT: Offset: 0x140
+# CASE4-NEXT: Offset: 0x40
 # CASE4-NEXT: Size: 2
 # CASE4-NEXT: Link: 2
 # CASE4-NEXT: Info: 1
 # CASE4-NEXT: AddressAlignment: 0
 # CASE4-NEXT: EntrySize: 24
 # CASE4-NEXT: SectionData (
 # CASE4-NEXT:   0000: 0123
 # CASE4-NEXT: )

 # RUN: yaml2obj --docnum=5 %s -o %t5
 # RUN: llvm-readobj --section-data -S %t5 | FileCheck %s --check-prefix=CASE5
 
 # CASE5:      Name: .symtab (19)
 # CASE5-NEXT: Type: SHT_SYMTAB (0x2)
 # CASE5-NEXT: Flags [ (0x0)
 # CASE5-NEXT: ]
 # CASE5-NEXT: Address: 0x0
-# CASE5-NEXT: Offset: 0x140
+# CASE5-NEXT: Offset: 0x40
 # CASE5-NEXT: Size: 5
 # CASE5-NEXT: Link: 2
 # CASE5-NEXT: Info: 1
 # CASE5-NEXT: AddressAlignment: 0
 # CASE5-NEXT: EntrySize: 24
 # CASE5-NEXT: SectionData (
 # CASE5-NEXT:   0000: 00000000 00
 # CASE5-NEXT: )

 # RUN: yaml2obj --docnum=6 %s -o %t6
 # RUN: llvm-readobj %t6 --section-data -S | FileCheck %s --check-prefix=CASE6
 
 # CASE6:      Name: .symtab
 # CASE6-NEXT: Type: SHT_SYMTAB
 # CASE6-NEXT: Flags [
 # CASE6-NEXT: ]
 # CASE6-NEXT: Address: 0x0
-# CASE6-NEXT: Offset: 0x140
+# CASE6-NEXT: Offset: 0x40
 # CASE6-NEXT: Size: 4
 # CASE6-NEXT: Link: 2
 # CASE6-NEXT: Info: 1
 # CASE6-NEXT: AddressAlignment: 0
 # CASE6-NEXT: EntrySize: 24
 # CASE6-NEXT: SectionData (
 # CASE6-NEXT:   0000: 01230000
 # CASE6-NEXT: )

 # RUN: yaml2obj --docnum=7 %s -o %t7
 # RUN: llvm-readobj --section-data -S %t7 | FileCheck %s --check-prefix=CASE7
 
 # CASE7:       Name: .symtab
 # CASE7-NEXT:  Type: SHT_SYMTAB
 # CASE7-NEXT:  Flags [
 # CASE7-NEXT:  ]
 # CASE7-NEXT:  Address: 0x0
-# CASE7-NEXT:  Offset: 0x140
+# CASE7-NEXT:  Offset: 0x40
 # CASE7-NEXT:  Size: 2
 # CASE7-NEXT:  Link: 2
 # CASE7-NEXT:  Info: 1
 # CASE7-NEXT:  AddressAlignment: 0
 # CASE7-NEXT:  EntrySize: 24
 # CASE7-NEXT:  SectionData (
 # CASE7-NEXT:    0000: 0123
 # CASE7-NEXT:  )

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-NEXT:   Section Name: .gnu.version
 # CHECK-NEXT:   Address: 0x200210
-# CHECK-NEXT:   Offset: 0x240
+# 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 we are able to set custom sh_entsize field for SHT_GNU_versym section.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readelf -S %t2 | FileCheck %s --check-prefix=ENTSIZE
 
 # ENTSIZE: Section Headers:
 # ENTSIZE:   [Nr] Name         Type   Address          Off    Size   ES
-# ENTSIZE:   [ 1] .gnu.version VERSYM 0000000000000000 000180 000000 03
+# ENTSIZE:   [ 1] .gnu.version VERSYM 0000000000000000 000040 000000 03
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   OSABI:   ELFOSABI_FREEBSD
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
   - Name:    .gnu.version
     Type:    SHT_GNU_versym
     EntSize: 0x0000000000000003
     Entries: [ ]