[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 ↗

(On Diff #218895)

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 ↗

(On Diff #218895)

typedef typename ELFT::uint uintX_t; ?

1063 ↗

(On Diff #218895)

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 ↗

(On Diff #218895)

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 ↗

(On Diff #218895)

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

1060 ↗

(On Diff #218899)

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)

1063 ↗

(On Diff #218899)

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

1060 ↗

(On Diff #218899)

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.

llvm/trunk/lib/ObjectYAML/ELFEmitter.cpp

template <class ELFT> class ELFState {
 
   NameToIdxMap SN2I;
   NameToIdxMap SymN2I;
   NameToIdxMap DynSymN2I;
   ELFYAML::Object &Doc;
 
   bool buildSectionIndex();
   bool buildSymbolIndexes();
-  void initELFHeader(Elf_Ehdr &Header);
   void initProgramHeaders(std::vector<Elf_Phdr> &PHeaders);
   bool initImplicitHeader(ContiguousBlobAccumulator &CBA, Elf_Shdr &Header,
                           StringRef SecName, ELFYAML::Section *YAMLSec);
   bool initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                           ContiguousBlobAccumulator &CBA);
   void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                               std::vector<Elf_Shdr> &SHeaders);
   void finalizeStrings();
+  void writeELFHeader(ContiguousBlobAccumulator &CBA, raw_ostream &OS);
   bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RawContentSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RelocationSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader, const ELFYAML::Group &Group,
                            ContiguousBlobAccumulator &CBA);
for (StringRef SecName : ImplicitSections) {
 
     std::unique_ptr<ELFYAML::Section> Sec = std::make_unique<ELFYAML::Section>(
         ELFYAML::Section::SectionKind::RawContent, true /*IsImplicit*/);
     Sec->Name = SecName;
     Doc.Sections.push_back(std::move(Sec));
   }
 }
 
-template <class ELFT> void ELFState<ELFT>::initELFHeader(Elf_Ehdr &Header) {
+template <class ELFT>
+void ELFState<ELFT>::writeELFHeader(ContiguousBlobAccumulator &CBA, raw_ostream &OS) {
   using namespace llvm::ELF;
+
+  Elf_Ehdr Header;
   zero(Header);
   Header.e_ident[EI_MAG0] = 0x7f;
   Header.e_ident[EI_MAG1] = 'E';
   Header.e_ident[EI_MAG2] = 'L';
   Header.e_ident[EI_MAG3] = 'F';
   Header.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
   Header.e_ident[EI_DATA] = Doc.Header.Data;
   Header.e_ident[EI_VERSION] = EV_CURRENT;
   Header.e_ident[EI_OSABI] = Doc.Header.OSABI;
   Header.e_ident[EI_ABIVERSION] = Doc.Header.ABIVersion;
   Header.e_type = Doc.Header.Type;
   Header.e_machine = Doc.Header.Machine;
   Header.e_version = EV_CURRENT;
   Header.e_entry = Doc.Header.Entry;
   Header.e_phoff = sizeof(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();
+  // Align the start of the section header and write the ELF header.
+  uint64_t ShOffset;
+  CBA.getOSAndAlignedOffset(ShOffset, sizeof(typename ELFT::uint));
+  Header.e_shoff = Doc.Header.SHOffset
+                       ? typename ELFT::uint(*Doc.Header.SHOffset)
+                       : ShOffset;
   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");
+
+  OS.write((const char *)&Header, sizeof(Header));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
   for (const auto &YamlPhdr : Doc.ProgramHeaders) {
     Elf_Phdr Phdr;
     Phdr.p_type = YamlPhdr.Type;
     Phdr.p_flags = YamlPhdr.Flags;
int ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &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 =
+      sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * Doc.ProgramHeaders.size();
   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);
 
-  OS.write((const char *)&Header, sizeof(Header));
+  State.writeELFHeader(CBA, OS);
   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);

llvm/trunk/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

llvm/trunk/test/tools/llvm-objcopy/ELF/group-reorder.test

 # RUN: yaml2obj %s > %t.o
 # RUN: llvm-objcopy %t.o %t.2.o
 # RUN: llvm-readelf --elf-section-groups --sections %t.o | FileCheck %s --check-prefix=IN
 # RUN: llvm-readelf --elf-section-groups --sections %t.2.o | FileCheck %s --check-prefix=OUT
 
 # In this test, .group gets moved to the beginning. Run readelf -gS on input as
 # well as output to make sure it really moved, as well as to verify that we
 # aren't purely sorting based on offsets (it gets moved to the beginning
 # despite having a larger offset).
 
-# IN:      There are 7 section headers, starting at offset 0x40:
+# IN:      There are 7 section headers, starting at offset 0x160:
 # IN:        [Nr] Name              Type            Address          Off    Size
 # IN-NEXT:   [ 0]                   NULL            0000000000000000 000000 000000
-# IN-NEXT:   [ 1] .foo              PROGBITS        0000000000000000 000200 000040
-# IN-NEXT:   [ 2] .group            GROUP           0000000000000000 000240 000008
-# IN-NEXT:   [ 3] .bar              PROGBITS        0000000000000000 000248 000040
+# IN-NEXT:   [ 1] .foo              PROGBITS        0000000000000000 000040 000040
+# IN-NEXT:   [ 2] .group            GROUP           0000000000000000 000080 000008
+# IN-NEXT:   [ 3] .bar              PROGBITS        0000000000000000 000088 000040
 
 # IN:      COMDAT group section [    2] `.group' [bar] contains 1 sections:
 # IN-NEXT:    [Index]    Name
 # IN-NEXT:    [    3]   .bar
 
 # OUT:      There are 7 section headers, starting at offset 0x160:
 # OUT:        [Nr] Name              Type            Address          Off    Size
 # OUT-NEXT:   [ 0]                   NULL            0000000000000000 000000 000000

llvm/trunk/test/tools/llvm-objcopy/ELF/invalid-e_shoff.test

 ## If the e_shoff field is set to a value either past the end of the file, or
 ## such that e_shoff + e_shnum * sizeof(Elf_Shdr) is past the end of the file,
 ## we should emit an error. This test checks that the emitted error is sensible.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: cp %t.o %t2.o
 
 ## Sanity check that the section header table is at offset 64:
 # RUN: llvm-readobj --file-headers %t.o | FileCheck %s --check-prefix=VALIDATE
-# VALIDATE: SectionHeaderOffset: 0x40{{$}}
+# VALIDATE: SectionHeaderOffset: 0x80{{$}}
 
 ## Truncate the file to end before the section header table ends.
-# RUN: %python -c "with open('%/t.o', 'r+b') as input: input.truncate(65)"
+# RUN: %python -c "with open('%/t.o', 'r+b') as input: input.truncate(0x7f)"
 # RUN: not llvm-objcopy %t.o 2>&1 | FileCheck %s -DINPUT=%t.o --check-prefix=CASE1
 
-# CASE1: error: '[[INPUT]]': section header table goes past the end of the file: e_shoff = 0x40
+# CASE1: error: '[[INPUT]]': section header table goes past the end of the file: e_shoff = 0x80
 
 ## Set the e_shoff field to a value much larger than the object file size.
 # RUN: %python -c "with open('%/t2.o', 'r+b') as input: import struct; bytes = struct.pack('<Q', 0x40000000); input.seek(40); input.write(bytes)"
 # RUN: not llvm-objcopy %t2.o 2>&1 | FileCheck %s -DINPUT=%t2.o --check-prefix=CASE2
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
 
 # CASE2: error: '[[INPUT]]': section header table goes past the end of the file: e_shoff = 0x40000000

llvm/trunk/test/tools/llvm-objcopy/ELF/invalid-p_filesz-p_offset.test

 ## In this case, we have a program header with a file size that
 ## overflows the binary size. Check llvm-objcopy doesn't crash
 ## and report this error properly.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1.o
 # RUN: not llvm-objcopy %t1.o 2>&1 | FileCheck %s --check-prefix=ERR1
-# ERR1: error: program header with offset 0x1b8 and file size 0x100000 goes past the end of the file
+# ERR1: error: program header with offset 0x78 and file size 0x100000 goes past the end of the file
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

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

 ## This test shows that llvm-objcopy does not baulk at overlapping sections
 ## where such sections are within segments.
 ## These don't really make sense, but the tool should still handle invalid
 ## inputs somehow.
 # RUN: yaml2obj %s -o %t.o
 
-## First, check that the section header table appears immediately after the program
-## header table.
+## First, check the address of the section header table.
 # RUN: llvm-readobj --file-headers %t.o | FileCheck %s --check-prefix=SHDRS-OFFSET
-# SHDRS-OFFSET: SectionHeaderOffset: 0x78{{$}}
+# SHDRS-OFFSET: SectionHeaderOffset: 0x1050{{$}}
 
 ## Binary edit the section header sh_offset field of the second section to
-## overlap the first one.
-# RUN: %python -c "with open('%/t.o', 'r+b') as input: import struct; bytes = struct.pack('<Q', 0x1001); input.seek(272); input.write(bytes)"
+## (e_shoff+64*2+24 = 0x10e8) overlap the first one.
+# RUN: %python -c "with open('%/t.o', 'r+b') as input: import struct; bytes = struct.pack('<Q', 0x1001); input.seek(0x10e8); input.write(bytes)"
 
 ## Sanity check that the binary editing modified the correct field.
 # RUN: llvm-readobj --section-headers %t.o | FileCheck %s
 
 ## Check that the contents are as expected before the copy.
 # RUN: llvm-readobj -x .first -x .second %t.o | FileCheck %s --check-prefix=CONTENTS
 
 ## Now check that the section contents are still correct after the copy and show that

llvm/trunk/test/tools/llvm-objcopy/ELF/overlapping-sections.test

 ## This test shows that llvm-objcopy does not baulk at overlapping sections.
 ## These don't really make sense, but the tool should still handle invalid
 ## inputs somehow.
 # RUN: yaml2obj %s -o %t.o
 
-## First, check that the section header table appears immediately after the ELF
-## header.
+## First, check the address of the section header table.
 # RUN: llvm-readobj --file-headers %t.o | FileCheck %s --check-prefix=SHDRS-OFFSET
-# SHDRS-OFFSET: SectionHeaderOffset: 0x40{{$}}
+# SHDRS-OFFSET: SectionHeaderOffset: 0x1050{{$}}
 
 ## Binary edit the section header sh_offset field of the second section to
-## overlap the first one.
-# RUN: %python -c "with open('%/t.o', 'r+b') as input: import struct; bytes = struct.pack('<Q', 0x1001); input.seek(216); input.write(bytes)"
+## (e_shoff+64*2+24 = 0x10e8) overlap the first one.
+# RUN: %python -c "with open('%/t.o', 'r+b') as input: import struct; bytes = struct.pack('<Q', 0x1001); input.seek(0x10e8); input.write(bytes)"
 
 ## Sanity check that the binary editing modified the correct field.
 # RUN: llvm-readobj --section-headers %t.o | FileCheck %s --check-prefix=VALIDATE
 
 # VALIDATE: Name: .first
 # VALIDATE: Offset: 0x1000
 # VALIDATE: Name: .second
 # VALIDATE: Offset: 0x1001

llvm/trunk/test/tools/llvm-objcopy/ELF/preserve-segment-contents-ehdr-phdrs.test

 ## Show that llvm-objcopy correctly updates the elf header and program header
 ## table when they are within a segment.
 
 # RUN: yaml2obj %s -o %t.in
 ## Validate that the properties are different before the removal.
 # RUN: llvm-readobj --file-headers --program-headers %t.in | FileCheck %s --check-prefix=BEFORE
 # RUN: llvm-objcopy %t.in %t.out -R .remove_me
 # RUN: llvm-readobj --file-headers --program-headers %t.out | FileCheck %s --check-prefix=AFTER
 
 # BEFORE: SectionHeaderCount: 6
 # BEFORE:      Type: PT_LOAD
 # BEFORE-NEXT: Offset: 0x0
 # BEFORE:      Type: PT_LOAD
-# BEFORE-NEXT: Offset: 0x240
+# BEFORE-NEXT: Offset: 0xC0
 
 # AFTER:      SectionHeaderCount: 3
 # AFTER:      Type: PT_LOAD
 # AFTER-NEXT: Offset: 0x0
 # AFTER:      Type: PT_LOAD
 # AFTER-NEXT: Offset: 0xB0
 
 --- !ELF

llvm/trunk/test/tools/llvm-readobj/elf-broken-dynsym-link.test

 ## Test that we are able to dump section headers even if the
 ## .dynsym section's sh_link field is broken.
 
 ## Case 1: sh_link is set to 0.
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: llvm-readobj -S %t1 2>&1 | FileCheck %s -DFILE=%t1 --check-prefixes=LLVM,ERR
 # RUN: llvm-readelf -S %t1 2>&1 | FileCheck %s -DFILE=%t1 --check-prefixes=GNU,ERR
 
 # ERR: warning: '[[FILE]]': invalid sh_type for string table section [index 0]: expected SHT_STRTAB, but got SHT_NULL
 
 # LLVM:      Name: .dynsym
 # LLVM-NEXT:  Type: SHT_DYNSYM
 # LLVM-NEXT:  Flags [
 # LLVM-NEXT:    SHF_ALLOC
 # LLVM-NEXT:  ]
 # LLVM-NEXT:  Address: 0x0
-# LLVM-NEXT:  Offset: 0x180
+# LLVM-NEXT:  Offset: 0x40
 # LLVM-NEXT:  Size: 24
 # LLVM-NEXT:  Link: 0
 
 # GNU:      Section Headers:
 # GNU-NEXT:  [Nr] Name    Type   Address          Off    Size   ES Flg Lk
 # GNU-NEXT:  [ 0]         NULL   0000000000000000 000000 000000 00 0   0
-# GNU-NEXT:  [ 1] .dynsym DYNSYM 0000000000000000 000180 000018 18 A   0
+# GNU-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
     Link: 255
 
 # LLVM2:      Name: .dynsym
 # LLVM2-NEXT:  Type: SHT_DYNSYM
 # LLVM2-NEXT:  Flags [
 # LLVM2-NEXT:    SHF_ALLOC
 # LLVM2-NEXT:  ]
 # LLVM2-NEXT:  Address: 0x0
-# LLVM2-NEXT:  Offset: 0x180
+# LLVM2-NEXT:  Offset: 0x40
 # LLVM2-NEXT:  Size: 24
 # LLVM2-NEXT:  Link: 255
 
 # GNU2:      Section Headers:
 # GNU2-NEXT:  [Nr] Name    Type   Address          Off    Size   ES Flg Lk
 # GNU2-NEXT:  [ 0]         NULL   0000000000000000 000000 000000 00 0   0
-# GNU2-NEXT:  [ 1] .dynsym DYNSYM 0000000000000000 000180 000018 18 A   255
+# GNU2-NEXT:  [ 1] .dynsym DYNSYM 0000000000000000 000040 000018 18 A   255

llvm/trunk/test/tools/llvm-readobj/elf-dynamic-malformed.test

 
 # CHECK: warning: '[[FILE]]': Unable to parse DT_RELA: virtual address is not in any segment: 0x1000000
 
 # BAD-RELA:      DynamicSection [ (2 entries)
 # BAD-RELA-NEXT:   Tag                Type Name/Value
 # BAD-RELA-NEXT:   0x0000000000000007 RELA 0x1000000
 # BAD-RELA-NEXT:   0x0000000000000000 NULL 0x0
 # BAD-RELA-NEXT: ]
-# BAD-RELA-GNU:      Dynamic section at offset 0x1f0 contains 2 entries:
+# BAD-RELA-GNU:      Dynamic section at offset 0xb0 contains 2 entries:
 # BAD-RELA-GNU-NEXT: Tag                Type   Name/Value
 # BAD-RELA-GNU-NEXT: 0x0000000000000007 (RELA) 0x1000000
 # BAD-RELA-GNU-NEXT: 0x0000000000000000 (NULL) 0x0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB

llvm/trunk/test/tools/llvm-readobj/elf-dynamic-no-pt-dynamic.test

 ## Show that dumping occurs even if there is no PT_DYNAMIC header.
 ## This is inconsistent with the GNU behavior, but seems to be more reasonable.
 # RUN: yaml2obj %s -o %t.no-phdr
 # RUN: llvm-readobj --dynamic-table %t.no-phdr | FileCheck %s --check-prefix=LLVM
 # RUN: llvm-readelf --dynamic-table %t.no-phdr | FileCheck %s --check-prefix=GNU
 
 # LLVM:      File: {{.*}}.no-phdr
 # LLVM-NEXT: Format: ELF64-x86-64
 # LLVM-NEXT: Arch: x86_64
 # LLVM-NEXT: AddressSize: 64bit
 # LLVM-NEXT: LoadName:{{ *}}
 # LLVM-NEXT: DynamicSection [ (1 entries)
 # LLVM-NEXT:   Tag                Type Name/Value
 # LLVM-NEXT:   0x0000000000000000 NULL 0x0
 # LLVM-NEXT: ]
 
-# GNU:      Dynamic section at offset 0x1b8 contains 1 entries:
+# GNU:      Dynamic section at offset 0x78 contains 1 entries:
 # GNU-NEXT: Tag                Type   Name/Value
 # GNU-NEXT: 0x0000000000000000 (NULL) 0x0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC

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

 # I386-NEXT:    ABIVersion: 0
 # I386-NEXT:    Unused: (00 00 00 00 00 00 00)
 # I386-NEXT:  }
 # I386-NEXT:  Type: Relocatable (0x1)
 # I386-NEXT:  Machine: EM_386 (0x3)
 # I386-NEXT:  Version: 1
 # I386-NEXT:  Entry: 0x0
 # I386-NEXT:  ProgramHeaderOffset: 0x34
-# I386-NEXT:  SectionHeaderOffset: 0x34
+# I386-NEXT:  SectionHeaderOffset: 0x64
 # I386-NEXT:  Flags [ (0x0)
 # I386-NEXT:  ]
 # I386-NEXT:  HeaderSize: 52
 # I386-NEXT:  ProgramHeaderEntrySize: 32
 # I386-NEXT:  ProgramHeaderCount: 0
 # I386-NEXT:  SectionHeaderEntrySize: 40
 # I386-NEXT:  SectionHeaderCount: 4
 # I386-NEXT:  StringTableSectionIndex: 3

 # X86-64-NEXT:    ABIVersion: 0
 # X86-64-NEXT:    Unused: (00 00 00 00 00 00 00)
 # X86-64-NEXT:  }
 # X86-64-NEXT:  Type: Relocatable (0x1)
 # X86-64-NEXT:  Machine: EM_X86_64 (0x3E)
 # X86-64-NEXT:  Version: 1
 # X86-64-NEXT:  Entry: 0x0
 # X86-64-NEXT:  ProgramHeaderOffset: 0x40
-# X86-64-NEXT:  SectionHeaderOffset: 0x40
+# X86-64-NEXT:  SectionHeaderOffset: 0x78
 # X86-64-NEXT:  Flags [ (0x0)
 # X86-64-NEXT:  ]
 # X86-64-NEXT:  HeaderSize: 64
 # X86-64-NEXT:  ProgramHeaderEntrySize: 56
 # X86-64-NEXT:  ProgramHeaderCount: 0
 # X86-64-NEXT:  SectionHeaderEntrySize: 64
 # X86-64-NEXT:  SectionHeaderCount: 4
 # X86-64-NEXT:  StringTableSectionIndex: 3

 # LANAI-NEXT:    ABIVersion: 0
 # LANAI-NEXT:    Unused: (00 00 00 00 00 00 00)
 # LANAI-NEXT:  }
 # LANAI-NEXT:  Type: Relocatable (0x1)
 # LANAI-NEXT:  Machine: EM_LANAI (0xF4)
 # LANAI-NEXT:  Version: 1
 # LANAI-NEXT:  Entry: 0x0
 # LANAI-NEXT:  ProgramHeaderOffset: 0x34
-# LANAI-NEXT:  SectionHeaderOffset: 0x34
+# LANAI-NEXT:  SectionHeaderOffset: 0x64
 # LANAI-NEXT:  Flags [ (0x0)
 # LANAI-NEXT:  ]
 # LANAI-NEXT:  HeaderSize: 52
 # LANAI-NEXT:  ProgramHeaderEntrySize: 32
 # LANAI-NEXT:  ProgramHeaderCount: 0
 # LANAI-NEXT:  SectionHeaderEntrySize: 40
 # LANAI-NEXT:  SectionHeaderCount: 4
 # LANAI-NEXT:  StringTableSectionIndex: 3
 # LANAI-NEXT:}
 # LANAI-NOT:{{.}}

llvm/trunk/test/tools/llvm-readobj/elf-hidden-versym.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readelf -V %t | FileCheck %s --check-prefix=HIDDEN
 
 # HIDDEN:      Version symbols section '.gnu.version' contains 2 entries:
-# HIDDEN-NEXT:  Addr: 0000000000200210  Offset: 0x000240  Link: 6 (.dynsym)
+# HIDDEN-NEXT:  Addr: 0000000000200210  Offset: 0x000040  Link: 6 (.dynsym)
 # HIDDEN-NEXT:   000:   0 (*local*)       3h(hiddensym)
 
 --- !ELF
 FileHeader:
   Class:             ELFCLASS64
   Data:              ELFDATA2LSB
   Type:              ET_EXEC
   Machine:           EM_X86_64

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

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

llvm/trunk/test/tools/llvm-readobj/elf-invalid-versioning.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readelf -V %t | FileCheck %s --check-prefix=INVALID
 
 # INVALID:      Version symbols section '.gnu.version' contains 2 entries:
-# INVALID-NEXT:  Addr: 0000000000200210  Offset: 0x000240  Link: 6 (.dynsym)
+# INVALID-NEXT:  Addr: 0000000000200210  Offset: 0x000040  Link: 6 (.dynsym)
 # INVALID-NEXT:   000:   0 (*local*)       3 (*invalid*)
 
 --- !ELF
 FileHeader:
   Class:             ELFCLASS64
   Data:              ELFDATA2LSB
   Type:              ET_EXEC
   Machine:           EM_X86_64

llvm/trunk/test/tools/llvm-readobj/elf-loadname.test

 ## Check we are able to dump library soname properly.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj %t.o | FileCheck %s --check-prefix LLVM
 # RUN: llvm-readelf --dynamic-table %t.o | FileCheck %s --check-prefix GNU
 
 # LLVM:      Format: ELF64-x86-64
 # LLVM-NEXT: Arch: x86_64
 # LLVM-NEXT: AddressSize: 64bit
 # LLVM-NEXT: LoadName: test.so
 
-# GNU:       Dynamic section at offset 0x200 contains 4 entries:
+# GNU:       Dynamic section at offset 0x80 contains 4 entries:
 # GNU-NEXT:   Tag                Type     Name/Value
 # GNU-NEXT:   0x0000000000000005 (STRTAB) 0x0
 # GNU-NEXT:   0x000000000000000a (STRSZ)  7 (bytes)
 # GNU-NEXT:   0x000000000000000e (SONAME) Library soname: [test.so]
 # GNU-NEXT:   0x0000000000000000 (NULL)   0x0
 
 !ELF
 FileHeader:

llvm/trunk/test/tools/llvm-readobj/elf-packed-relocs.test

 # The binary blobs in this file were created like this:
 # llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu Inputs/elf-packed-relocs1.s -o - | obj2yaml | grep Content:
 
 # RUN: yaml2obj -docnum 1 %s | llvm-readobj --relocations - | FileCheck --check-prefix=LLVM1 %s
 # LLVM1:      Section (1) .rela.dyn {
 # LLVM1-NEXT:   0x1100 R_X86_64_RELATIVE - 0x0
 # LLVM1-NEXT:   0x1180 R_X86_64_RELATIVE - 0x0
 # LLVM1-NEXT:   0x1188 R_X86_64_64 sym1 0x0
 # LLVM1-NEXT:   0x1190 R_X86_64_64 sym2 0x0
 # LLVM1-NEXT:   0x1191 R_X86_64_64 sym1 0x8
 # LLVM1-NEXT:   0x1193 R_X86_64_64 sym2 0xC
 # LLVM1-NEXT:   0x1197 R_X86_64_64 sym1 0xA
 # LLVM1-NEXT:   0x119F R_X86_64_64 sym2 0xA
 # LLVM1-NEXT: }
 
 # RUN: yaml2obj -docnum 1 %s | llvm-readelf -relocations - | FileCheck --check-prefix=GNU1 %s
-# GNU1:      Relocation section '.rela.dyn' at offset 0x180 contains 8 entries:
+# GNU1:      Relocation section '.rela.dyn' at offset 0x40 contains 8 entries:
 # GNU1:      0000000000001100  0000000000000008 R_X86_64_RELATIVE                 0
 # GNU1-NEXT: 0000000000001180  0000000000000008 R_X86_64_RELATIVE                 0
 # GNU1-NEXT: 0000000000001188  0000000100000001 R_X86_64_64            0000000000000000 sym1 + 0
 # GNU1-NEXT: 0000000000001190  0000000200000001 R_X86_64_64            0000000000000000 sym2 + 0
 # GNU1-NEXT: 0000000000001191  0000000100000001 R_X86_64_64            0000000000000000 sym1 + 8
 # GNU1-NEXT: 0000000000001193  0000000200000001 R_X86_64_64            0000000000000000 sym2 + c
 # GNU1-NEXT: 0000000000001197  0000000100000001 R_X86_64_64            0000000000000000 sym1 + a
 # GNU1-NEXT: 000000000000119f  0000000200000001 R_X86_64_64            0000000000000000 sym2 + a

 # LLVM2-NEXT:   0x1000 R_386_RELATIVE - 0x0
 # LLVM2-NEXT:   0xFFC R_386_RELATIVE - 0x0
 # LLVM2-NEXT:   0xFF8 R_386_RELATIVE - 0x0
 # LLVM2-NEXT:   0xFF4 R_386_RELATIVE - 0x0
 # LLVM2-NEXT:   0xFF0 R_386_RELATIVE - 0x0
 # LLVM2-NEXT: }
 
 # RUN: yaml2obj -docnum 2 %s | llvm-readelf -relocations - | FileCheck --check-prefix=GNU2 %s
-# GNU2:      Relocation section '.rel.dyn' at offset 0xfc contains 10 entries:
+# GNU2:      Relocation section '.rel.dyn' at offset 0x34 contains 10 entries:
 # GNU2:      00001008  00000101 R_386_32               00000000   sym1
 # GNU2-NEXT: 00001010  00000203 R_386_GOT32            00000000   sym2
 # GNU2-NEXT: 0000100c  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00001008  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00001004  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00001000  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00000ffc  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00000ff8  00000008 R_386_RELATIVE

 # LLVM3-NEXT:   0x1180 R_X86_64_RELATIVE - 0x8
 # LLVM3-NEXT:   0x1200 R_X86_64_64 sym1 0x0
 # LLVM3-NEXT:   0x1208 R_X86_64_64 sym2 0x0
 # LLVM3-NEXT:   0x1210 R_X86_64_64 sym1 0x0
 # LLVM3-NEXT:   0x1218 R_X86_64_64 sym2 0x8
 # LLVM3-NEXT: }
 
 # RUN: yaml2obj -docnum 3 %s | llvm-readelf -relocations - | FileCheck --check-prefix=GNU3 %s
-# GNU3:      Relocation section '.rela.dyn' at offset 0x180 contains 6 entries:
+# GNU3:      Relocation section '.rela.dyn' at offset 0x40 contains 6 entries:
 # GNU3: 0000000000001100  0000000000000008 R_X86_64_RELATIVE                 0
 # GNU3-NEXT: 0000000000001180  0000000000000008 R_X86_64_RELATIVE                 8
 # GNU3-NEXT: 0000000000001200  0000000100000001 R_X86_64_64            0000000000000000 sym1 + 0
 # GNU3-NEXT: 0000000000001208  0000000200000001 R_X86_64_64            0000000000000000 sym2 + 0
 # GNU3-NEXT: 0000000000001210  0000000100000001 R_X86_64_64            0000000000000000 sym1 + 0
 # GNU3-NEXT: 0000000000001218  0000000200000001 R_X86_64_64            0000000000000000 sym2 + 8
 
 # elf-packed-relocs3.s

llvm/trunk/test/tools/llvm-readobj/elf-relr-relocs.test

 # LLVM1-NEXT:   0x20368 R_X86_64_RELATIVE - 0x0
 # LLVM1-NEXT:   0x20380 R_X86_64_RELATIVE - 0x0
 # LLVM1-NEXT:   0x20390 R_X86_64_RELATIVE - 0x0
 # LLVM1-NEXT: }
 
 # RUN: yaml2obj -docnum 1 %s \
 # RUN:   | llvm-readelf -relocations -raw-relr - \
 # RUN:   | FileCheck --check-prefix=RAW-GNU1 %s
-# RAW-GNU1:      Relocation section '.relr.dyn' at offset 0x180 contains 5 entries:
+# RAW-GNU1:      Relocation section '.relr.dyn' at offset 0x40 contains 5 entries:
 # RAW-GNU1:      0000000000010d60
 # RAW-GNU1-NEXT: 0000000000000103
 # RAW-GNU1-NEXT: 0000000000020000
 # RAW-GNU1-NEXT: 00000000000f0501
 # RAW-GNU1-NEXT: 000a700550400009
 
 # RUN: yaml2obj -docnum 1 %s \
 # RUN:   | llvm-readelf -relocations - \
 # RUN:   | FileCheck --check-prefix=GNU1 %s
-# GNU1:      Relocation section '.relr.dyn' at offset 0x180 contains 21 entries:
+# GNU1:      Relocation section '.relr.dyn' at offset 0x40 contains 21 entries:
 # GNU1:      0000000000010d60  0000000000000008 R_X86_64_RELATIVE
 # GNU1-NEXT: 0000000000010d68  0000000000000008 R_X86_64_RELATIVE
 # GNU1-NEXT: 0000000000010da0  0000000000000008 R_X86_64_RELATIVE
 # GNU1-NEXT: 0000000000020000  0000000000000008 R_X86_64_RELATIVE
 # GNU1-NEXT: 0000000000020040  0000000000000008 R_X86_64_RELATIVE
 # GNU1-NEXT: 0000000000020050  0000000000000008 R_X86_64_RELATIVE
 # GNU1-NEXT: 0000000000020080  0000000000000008 R_X86_64_RELATIVE
 # GNU1-NEXT: 0000000000020088  0000000000000008 R_X86_64_RELATIVE

 # LLVM2-NEXT:   0x200D4 R_386_RELATIVE - 0x0
 # LLVM2-NEXT:   0x200EC R_386_RELATIVE - 0x0
 # LLVM2-NEXT:   0x200F4 R_386_RELATIVE - 0x0
 # LLVM2-NEXT: }
 
 # RUN: yaml2obj -docnum 2 %s \
 # RUN:   | llvm-readelf -relocations -raw-relr - \
 # RUN:   | FileCheck --check-prefix=RAW-GNU2 %s
-# RAW-GNU2:      Relocation section '.relr.dyn' at offset 0xfc contains 5 entries:
+# RAW-GNU2:      Relocation section '.relr.dyn' at offset 0x34 contains 5 entries:
 # RAW-GNU2:      00010d60
 # RAW-GNU2-NEXT: 00000103
 # RAW-GNU2-NEXT: 00020000
 # RAW-GNU2-NEXT: 000f0501
 # RAW-GNU2-NEXT: 50400009
 
 # RUN: yaml2obj -docnum 2 %s \
 # RUN:   | llvm-readelf -relocations - \
 # RUN:   | FileCheck --check-prefix=GNU2 %s
-# GNU2:      Relocation section '.relr.dyn' at offset 0xfc contains 14 entries:
+# GNU2:      Relocation section '.relr.dyn' at offset 0x34 contains 14 entries:
 # GNU2:      00010d60  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00010d64  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00010d80  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00020000  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00020020  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00020028  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00020040  00000008 R_386_RELATIVE
 # GNU2-NEXT: 00020044  00000008 R_386_RELATIVE

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

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

 # LLVM-NEXT:         Index: 6
 # LLVM-NEXT:         Name: v3
 # LLVM-NEXT:       }
 # LLVM-NEXT:     ]
 # LLVM-NEXT:   }
 # LLVM-NEXT: }
 
 # GNU:      Version symbols section '.gnu.version' contains 6 entries:
-# GNU-NEXT:  Addr: 0000000000000000  Offset: 0x000280  Link: 7 (.dynsym)
+# GNU-NEXT:  Addr: 0000000000000000  Offset: 0x000040  Link: 7 (.dynsym)
 # GNU-NEXT:   000:   0 (*local*) 2 (VERSION1) 3 (VERSION2) 4 (v1)
 # GNU-NEXT:   004:   5 (v2)      6 (v3)
 # GNU-EMPTY:
 # GNU-NEXT: Version definition section '.gnu.version_d' contains 3 entries:
-# GNU-NEXT:  Addr: 0000000000000000  Offset: 0x00028c  Link: 8 (.dynstr)
+# GNU-NEXT:  Addr: 0000000000000000  Offset: 0x00004c  Link: 8 (.dynstr)
 # GNU-NEXT:   0x0000: Rev: 1  Flags: none  Index: 2  Cnt: 1  Name: VERSION1
 # GNU-NEXT:   0x001c: Rev: 1  Flags: none  Index: 3  Cnt: 2  Name: VERSION2
 # GNU-NEXT:   0x0038: Parent 1: VERSION1
 # GNU-NEXT:   0x001c: Rev: 1  Flags: none  Index: 3  Cnt: 2  Name: VERSION2
 # GNU-NEXT:   0x0038: Parent 1: VERSION1
 # GNU-EMPTY:
 # GNU-NEXT: Version needs section '.gnu.version_r' contains 2 entries:
-# GNU-NEXT:  Addr: 0000000000000000  Offset: 0x0002cc  Link: 8 (.dynstr)
+# GNU-NEXT:  Addr: 0000000000000000  Offset: 0x00008c  Link: 8 (.dynstr)
 # GNU-NEXT:   0x0000: Version: 1  File: verneed1.so.0  Cnt: 2
 # GNU-NEXT:   0x0010:   Name: v1  Flags: none  Version: 4
 # GNU-NEXT:   0x0020:   Name: v2  Flags: none  Version: 5
 # GNU-NEXT:   0x0030: Version: 1  File: verneed2.so.0  Cnt: 1
 # GNU-NEXT:   0x0040:   Name: v3  Flags: none  Version: 6

llvm/trunk/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

llvm/trunk/test/tools/llvm-readobj/gnu-notes.test

 ## Test tools are able to dump different types of notes.
 
 # RUN: yaml2obj --docnum=1 %s > %t1.so
 # RUN: llvm-readelf --notes %t1.so | FileCheck %s --check-prefix=GNU --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --notes %t1.so | FileCheck %s --check-prefix=LLVM
 # RUN: llvm-objcopy --strip-sections %t1.so %t1.stripped.so
 # RUN: llvm-readelf --notes %t1.stripped.so | FileCheck %s --check-prefix=GNU-STRIPPED --strict-whitespace --match-full-lines
 # RUN: llvm-readobj --notes %t1.stripped.so | FileCheck %s --check-prefix=LLVM-STRIPPED
 
-#      GNU:Displaying notes found at file offset 0x00000238 with length 0x00000020:
+#      GNU:Displaying notes found at file offset 0x00000078 with length 0x00000020:
 # GNU-NEXT:  Owner                Data size   Description
 # GNU-NEXT:  GNU                  0x00000010  NT_GNU_ABI_TAG (ABI version tag)
 # GNU-NEXT:    OS: Linux, ABI: 2.6.32
 
-#      GNU:Displaying notes found at file offset 0x00000258 with length 0x00000020:
+#      GNU:Displaying notes found at file offset 0x00000098 with length 0x00000020:
 # GNU-NEXT:  Owner                Data size   Description
 # GNU-NEXT:  GNU                  0x00000010  NT_GNU_BUILD_ID (unique build ID bitstring)
 # GNU-NEXT:    Build ID: 4fcb712aa6387724a9f465a32cd8c14b
 
-#      GNU:Displaying notes found at file offset 0x00000278 with length 0x0000001c:
+#      GNU:Displaying notes found at file offset 0x000000b8 with length 0x0000001c:
 # GNU-NEXT:  Owner                Data size   Description
 # GNU-NEXT:  GNU                  0x00000009  NT_GNU_GOLD_VERSION (gold version)
 # GNU-NEXT:    Version: gold 1.11
 
 # LLVM:      Notes [
 # LLVM-NEXT:   NoteSection {
-# LLVM-NEXT:     Offset: 0x238
+# LLVM-NEXT:     Offset: 0x78
 # LLVM-NEXT:     Size: 0x20
 # LLVM-NEXT:     Note {
 # LLVM-NEXT:       Owner: GNU
 # LLVM-NEXT:       Data size: 0x10
 # LLVM-NEXT:       Type: NT_GNU_ABI_TAG (ABI version tag)
 # LLVM-NEXT:       OS: Linux
 # LLVM-NEXT:       ABI: 2.6.32
 # LLVM-NEXT:     }
 # LLVM-NEXT:   }
 # LLVM-NEXT:   NoteSection {
-# LLVM-NEXT:     Offset: 0x258
+# LLVM-NEXT:     Offset: 0x98
 # LLVM-NEXT:     Size: 0x20
 # LLVM-NEXT:     Note {
 # LLVM-NEXT:       Owner: GNU
 # LLVM-NEXT:       Data size: 0x10
 # LLVM-NEXT:       Type: NT_GNU_BUILD_ID (unique build ID bitstring)
 # LLVM-NEXT:       Build ID: 4fcb712aa6387724a9f465a32cd8c14b
 # LLVM-NEXT:     }
 # LLVM-NEXT:   }
 # LLVM-NEXT:   NoteSection {
-# LLVM-NEXT:     Offset: 0x278
+# LLVM-NEXT:     Offset: 0xB8
 # LLVM-NEXT:     Size: 0x1C
 # LLVM-NEXT:     Note {
 # LLVM-NEXT:       Owner: GNU
 # LLVM-NEXT:       Data size: 0x9
 # LLVM-NEXT:       Type: NT_GNU_GOLD_VERSION (gold version)
 # LLVM-NEXT:       Version: gold 1.11
 # LLVM-NEXT:     }
 # LLVM-NEXT:   }

 
 ## Test tools report an error if a note section has invalid size
 ## that goes past the end of file.
 
 # RUN: yaml2obj --docnum=3 %s > %t3.so
 # RUN: not llvm-readelf --notes %t3.so 2>&1 | FileCheck -DFILE=%t3.so %s --check-prefix=ERR2
 # RUN: not llvm-readobj --notes %t3.so 2>&1 | FileCheck -DFILE=%t3.so %s --check-prefix=ERR2
 
-# ERR2: error: '[[FILE]]': SHT_NOTE section [index 1] has invalid offset (0x180) or size (0xffff0000)
+# ERR2: error: '[[FILE]]': SHT_NOTE section [index 1] has invalid offset (0x40) or size (0xffff0000)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:

 
 ## Test tools report an error if a note program header has an invalid size that
 ## goes past the end of file.
 
 # RUN: yaml2obj --docnum=5 %s > %t5.so
 # RUN: not llvm-readelf --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so  %s --check-prefix=ERR4
 # RUN: not llvm-readobj --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefix=ERR4
 
-# ERR4: error: '[[FILE]]': PT_NOTE header has invalid offset (0x1b8) or size (0xffff0000)
+# ERR4: error: '[[FILE]]': PT_NOTE header has invalid offset (0x78) or size (0xffff0000)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_CORE
   Machine: EM_X86_64
 Sections:
   - Name: .note
     Type: SHT_NOTE
 ProgramHeaders:
   - Type: PT_NOTE
     FileSize: 0xffff0000
     Sections:
       - Section: .note

llvm/trunk/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

llvm/trunk/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

llvm/trunk/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

llvm/trunk/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:

llvm/trunk/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:  )

llvm/trunk/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:

llvm/trunk/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

llvm/trunk/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:

llvm/trunk/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

llvm/trunk/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:

llvm/trunk/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:]

llvm/trunk/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

llvm/trunk/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: )

llvm/trunk/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:  )

llvm/trunk/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: [ ]