[obj2yaml] Emit ProgramHeader.Offset

[jobnoorman]

Summary

Currently, obj2yaml doesn't emit the offset of program headers, leaving it to yaml2obj to calculate offsets based on FirstSec and LastSec. This causes an obj2yaml->yaml2obj round trip to often produce an ELF file that is not equivalent to the original, especially since it seems common to have program headers at offset 0 whose first section starts at a higher address. Besides being non-equivalent, the produced ELF files also do not seem to work propery and readelf complains about them.

Taking a simple hello world program in C, compiled using either GCC or Clang, the original ELF file has the following program headers (only showing some relevant ones):

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  PHDR           0x0000000000000040 0x0000000000000040 0x0000000000000040
                 0x00000000000002d8 0x00000000000002d8  R      0x8
  INTERP         0x0000000000000318 0x0000000000000318 0x0000000000000318
                 0x000000000000001c 0x000000000000001c  R      0x1
      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
  LOAD           0x0000000000000000 0x0000000000000000 0x0000000000000000
                 0x0000000000000630 0x0000000000000630  R      0x1000
  LOAD           0x0000000000001000 0x0000000000001000 0x0000000000001000
                 0x0000000000000161 0x0000000000000161  R E    0x1000
...

 Section to Segment mapping:
  Segment Sections...
   00
   01     .interp
   02     .interp .note.gnu.property .note.gnu.build-id .note.ABI-tag .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt
   03     .init .plt .text .fini
...

While this is the result of an obj2yaml->yaml2obj round trip:

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  PHDR           0x0000000000000000 0x0000000000000040 0x0000000000000040
                 0x0000000000000000 0x0000000000000000  R      0x8
readelf: Error: the PHDR segment is not covered by a LOAD segment
  INTERP         0x0000000000000318 0x0000000000000318 0x0000000000000318
                 0x000000000000001c 0x000000000000001c  R      0x1
      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
  LOAD           0x0000000000000318 0x0000000000000000 0x0000000000000000
                 0x0000000000000318 0x0000000000000318  R      0x1000
  LOAD           0x0000000000001000 0x0000000000001000 0x0000000000001000
                 0x0000000000000161 0x0000000000000161  R E    0x1000
...

 Section to Segment mapping:
  Segment Sections...
   00
   01     .interp
   02
   03     .init .plt .text .fini
...

Note that the offset of segment 2 changed from 0x0 to 0x318. This has two effects:

• readelf complains "Error: the PHDR segment is not covered by a LOAD segment" since PHDR was originally covered by segment 2 but not anymore;
• Segment 2 effectively became empty according to the section to segment mapping.

I addition to these, the output doesn't correctly execute anymore, crashing with a "SIGSEGV (Address boundary error)".

This patch fixes the difference in program header layout after a round trip by explicitly emitting offsets.

[jobnoorman]

Ping (I was just bitten by this issue again).

llvm/test/Object/obj2yaml.test

 # ELF-AVR-NEXT:   Machine:         EM_AVR
 # ELF-AVR-NEXT:   Flags:           [ EF_AVR_ARCH_AVR2, EF_AVR_LINKRELAX_PREPARED ]
 # ELF-AVR-NEXT: ProgramHeaders:
 # ELF-AVR-NEXT:  - Type:     PT_LOAD
 # ELF-AVR-NEXT:    Flags:    [ PF_X, PF_R ]
 # ELF-AVR-NEXT:    FirstSec: .text
 # ELF-AVR-NEXT:    LastSec:  .text
 # ELF-AVR-NEXT:    Align:    0x2
+# ELF-AVR-NEXT:    Offset:   0x74
 # ELF-AVR-NEXT:  - Type:     PT_LOAD
 # ELF-AVR-NEXT:    Flags:    [ PF_W, PF_R ]
 # ELF-AVR-NEXT:    FirstSec: .data
 # ELF-AVR-NEXT:    LastSec:  .data
 # ELF-AVR-NEXT:    VAddr:    0x800060
 # ELF-AVR-NEXT:    PAddr:    0x4
+# ELF-AVR-NEXT:    Offset:   0x78
 # ELF-AVR-NEXT: Sections:
 # ELF-AVR-NEXT:   - Name:            .text
 # ELF-AVR-NEXT:     Type:            SHT_PROGBITS
 # ELF-AVR-NEXT:     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
 # ELF-AVR-NEXT:     AddressAlign:    0x2
 # ELF-AVR-NEXT:     Content:         C20E0895
 # ELF-AVR-NEXT:   - Name:            .data
 # ELF-AVR-NEXT:     Type:            SHT_PROGBITS

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

 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=YAML
 
 # YAML:      ProgramHeaders:
 # YAML-NEXT:  - Type:     PT_LOAD
 # YAML-NEXT:    Flags:    [ PF_R ]
 # YAML-NEXT:    FirstSec: .hash
 # YAML-NEXT:    LastSec:  .dynstr
 # YAML-NEXT:    Align:    0x1000
+# YAML-NEXT:    Offset:   0x0
 # YAML-NEXT:  - Type:     PT_LOAD
 # YAML-NEXT:    Flags:    [ PF_X, PF_R ]
 # YAML-NEXT:    FirstSec: .foo
 # YAML-NEXT:    LastSec:  .zed
 # YAML-NEXT:    VAddr:    0x1000
 # YAML-NEXT:    Align:    0x1000
+# YAML-NEXT:    Offset:   0x281
 # YAML-NEXT:  - Type:     PT_LOAD
 # YAML-NEXT:    Flags:    [ PF_R ]
 # YAML-NEXT:    FirstSec: '.foo (1)'
 # YAML-NEXT:    LastSec:  .baz
 # YAML-NEXT:    VAddr:    0x2000
 # YAML-NEXT:    Align:    0x1000
+# YAML-NEXT:    Offset:   0x291
 # YAML-NEXT:  - Type:     PT_LOAD
 # YAML-NEXT:    Flags:    [ PF_W, PF_R ]
 # YAML-NEXT:    FirstSec: .dynamic
 # YAML-NEXT:    LastSec:  .dynamic.tail
 # YAML-NEXT:    VAddr:    0x3EF0
 # YAML-NEXT:    Align:    0x1000
+# YAML-NEXT:    Offset:   0x29A
 # YAML-NEXT:  - Type:     PT_DYNAMIC
 # YAML-NEXT:    Flags:    [ PF_W, PF_R ]
 # YAML-NEXT:    FirstSec: .dynamic
 # YAML-NEXT:    LastSec:  .dynamic
 # YAML-NEXT:    VAddr:    0x3EF0
 # YAML-NEXT:    Align:    0x8
+# YAML-NEXT:    Offset:   0x29A
 # YAML-NEXT:  - Type:     PT_GNU_RELRO
 # YAML-NEXT:    Flags:    [ PF_R ]
 # YAML-NEXT:    FirstSec: .dynamic
 # YAML-NEXT:    LastSec:  .dynamic
 # YAML-NEXT:    VAddr:    0x3EF0
+# YAML-NEXT:    Offset:   0x29A
 # YAML-NEXT:  - Type:  PT_LOAD
 # YAML-NEXT:    Flags: [ PF_R ]
 # YAML-NEXT:    VAddr: 0x4000
+# YAML-NEXT:    Offset:   0x0
 # YAML-NEXT:  - Type:     PT_LOAD
 # YAML-NEXT:    Flags:    [ PF_R ]
 # YAML-NEXT:    FirstSec: .gnu.hash
 # YAML-NEXT:    LastSec:  .gnu.hash
 # YAML-NEXT:    VAddr:    0x1A0
+# YAML-NEXT:    Offset:   0x248
 # YAML-NEXT:  - Type:     PT_LOAD
 # YAML-NEXT:    Flags:    [ PF_R ]
 # YAML-NEXT:    FirstSec: .gnu.hash
 # YAML-NEXT:    LastSec:  .gnu.hash
 # YAML-NEXT:    VAddr:    0x1A0
+# YAML-NEXT:    Offset:   0x248
 # YAML-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 ProgramHeaders:

 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=EMPTY
 
 # EMPTY:      - Type:     PT_LOAD
 # EMPTY-NEXT:   Flags:    [ PF_W, PF_R ]
 # EMPTY-NEXT:   FirstSec: .empty.tls.start
 # EMPTY-NEXT:   LastSec:  .empty.tls.end
 # EMPTY-NEXT:   VAddr:    0x1000
 # EMPTY-NEXT:   Align:    0x1000
+# EMPTY-NEXT:   Offset:   0x120
 # EMPTY-NEXT: - Type:     PT_TLS
 # EMPTY-NEXT:   Flags:    [ PF_W, PF_R ]
 # EMPTY-NEXT:   FirstSec: .empty.tls.start
 # EMPTY-NEXT:   LastSec:  .empty.tls.start
 # EMPTY-NEXT:   VAddr:    0x1000
+# EMPTY-NEXT:   Offset:   0x120
 # EMPTY-NEXT: - Type:     PT_TLS
 # EMPTY-NEXT:   Flags:    [ PF_W, PF_R ]
 # EMPTY-NEXT:   FirstSec: .empty.tls.middle
 # EMPTY-NEXT:   LastSec:  .empty.tls.middle
 # EMPTY-NEXT:   VAddr:    0x1100
+# EMPTY-NEXT:   Offset:   0x220
 # EMPTY-NEXT: - Type:     PT_TLS
 # EMPTY-NEXT:   Flags:    [ PF_W, PF_R ]
 # EMPTY-NEXT:   FirstSec: .empty.tls.end
 # EMPTY-NEXT:   LastSec:  .empty.tls.end
 # EMPTY-NEXT:   VAddr:    0x1200
+# EMPTY-NEXT:   Offset:   0x320
 # EMPTY-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 ProgramHeaders:

 
 # MISALIGNED-YAML:      ProgramHeaders:
 # MISALIGNED-YAML-NEXT:  - Type:     PT_LOAD
 # MISALIGNED-YAML-NEXT:    Flags:    [ PF_R ]
 # MISALIGNED-YAML-NEXT:    FirstSec: .foo
 # MISALIGNED-YAML-NEXT:    LastSec:  .foo
 # MISALIGNED-YAML-NEXT:    VAddr:    0x1000
 # MISALIGNED-YAML-NEXT:    Align:    0x1000
+# MISALIGNED-YAML-NEXT:    Offset:   0x77
 # MISALIGNED-YAML-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 ProgramHeaders:

 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: obj2yaml %t4 | FileCheck %s --check-prefix=NON-ALLOC
 
 # NON-ALLOC:      ProgramHeaders:
 # NON-ALLOC-NEXT: - Type:     PT_LOAD
 # NON-ALLOC-NEXT:   Flags:    [ PF_R ]
 # NON-ALLOC-NEXT:   FirstSec: .alloc.1
 # NON-ALLOC-NEXT:   LastSec:  .non-alloc.1
+# NON-ALLOC-NEXT:   Offset:   0x120
 # NON-ALLOC-NEXT: - Type:     PT_LOAD
 # NON-ALLOC-NEXT:   Flags:    [ PF_R ]
 # NON-ALLOC-NEXT:   FirstSec: .alloc.1
 # NON-ALLOC-NEXT:   LastSec:  .non-alloc.1
+# NON-ALLOC-NEXT:   Offset:   0x120
 # NON-ALLOC-NEXT: - Type:     PT_LOAD
 # NON-ALLOC-NEXT:   Flags:    [ PF_R ]
 # NON-ALLOC-NEXT:   FirstSec: .alloc.2
 # NON-ALLOC-NEXT:   LastSec:  .alloc.2
+# NON-ALLOC-NEXT:   Offset:   0x230
 # NON-ALLOC-NEXT: - Type:     PT_LOAD
 # NON-ALLOC-NEXT:   Flags:    [ PF_R ]
 # NON-ALLOC-NEXT:   FirstSec: .alloc.1
 # NON-ALLOC-NEXT:   LastSec:  .alloc.2
+# NON-ALLOC-NEXT:   Offset:   0x120
 # NON-ALLOC-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 ProgramHeaders:

 # RUN: yaml2obj --docnum=5 %s -o %t5
 # RUN: obj2yaml %t5 | FileCheck %s --check-prefix=NOBITS
 
 # NOBITS:      ProgramHeaders:
 # NOBITS-NEXT:   - Type:     PT_LOAD
 # NOBITS-NEXT:     Flags:    [ PF_W, PF_R ]
 # NOBITS-NEXT:     FirstSec: .bss
 # NOBITS-NEXT:     LastSec:  .bss
+# NOBITS-NEXT:     Offset:   0x159
 # NOBITS-NEXT:   - Type:     PT_LOAD
 # NOBITS-NEXT:     Flags:    [ PF_W, PF_R ]
 # NOBITS-NEXT:     FirstSec: .data.1
 # NOBITS-NEXT:     LastSec:  .bss
+# NOBITS-NEXT:     Offset:   0x158
 # NOBITS-NEXT:   - Type:     PT_LOAD
 # NOBITS-NEXT:     Flags:    [ PF_W, PF_R ]
 # NOBITS-NEXT:     FirstSec: .data.1
 # NOBITS-NEXT:     LastSec:  .data.2
+# NOBITS-NEXT:     Offset:   0x158
 # NOBITS-NEXT:   - Type:     PT_LOAD
 # NOBITS-NEXT:     Flags:    [ PF_W, PF_R ]
 # NOBITS-NEXT:     FirstSec: .bss
 # NOBITS-NEXT:     LastSec:  .data.2
+# NOBITS-NEXT:     Offset:   0x159
 # NOBITS-NEXT:   - Type:     PT_LOAD
 # NOBITS-NEXT:     Flags:    [ PF_W, PF_R ]
 # NOBITS-NEXT:     FirstSec: .foo.bss
 # NOBITS-NEXT:     LastSec:  .bar.bss
 # NOBITS-NEXT:     VAddr:    0x200000000
+# NOBITS-NEXT:     Offset:   0x15A
 # NOBITS-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 ProgramHeaders:

 # RUN: obj2yaml %t7 | FileCheck %s --check-prefix=ZERO-SIZE
 
 # ZERO-SIZE:      ProgramHeaders:
 # ZERO-SIZE-NEXT:   - Type:     PT_LOAD
 # ZERO-SIZE-NEXT:     Flags:    [ PF_W, PF_R ]
 # ZERO-SIZE-NEXT:     FirstSec: .empty.bar1
 # ZERO-SIZE-NEXT:     LastSec:  .empty.bar2
 # ZERO-SIZE-NEXT:     VAddr:    0x2000
+# ZERO-SIZE-NEXT:     Offset:   0x78
 # ZERO-SIZE-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 ProgramHeaders:

llvm/tools/obj2yaml/elf2yaml.cpp

if (!PhdrsOrErr)
     return PhdrsOrErr.takeError();
 
   for (const typename ELFT::Phdr &Phdr : *PhdrsOrErr) {
     ELFYAML::ProgramHeader PH;
     PH.Type = Phdr.p_type;
     PH.Flags = Phdr.p_flags;
     PH.VAddr = Phdr.p_vaddr;
     PH.PAddr = Phdr.p_paddr;
+    PH.Offset = Phdr.p_offset;
 
     // yaml2obj sets the alignment of a segment to 1 by default.
     // We do not print the default alignment to reduce noise in the output.
     if (Phdr.p_align != 1)
       PH.Align = static_cast<llvm::yaml::Hex64>(Phdr.p_align);
 
     // Here we match sections with segments.
     // It is not possible to have a non-Section chunk, because