[obj2yaml] Support dumping program headers.

[rupprecht]

Summary

This change dumps all program headers for ELF files. This will be useful for checking in yaml files instead of binaries/cores for programs (e.g. lldb) that needs to run tests on files with program headers.

[labath]

Unfortunately, I don't think this will be enough to make obj2yaml really useful for handling program headers. The interesting thing about program headers is their interconnection with the data described by section headers, and by storing that values verbatim, you're completely ignoring that aspect. This may be enough to capture a file, if the elf file was already produced by yaml2obj, and the yaml hasn't been modified in any way, as then obj2yaml will likely lay things out the same way and the program headers will come out "right". However, if the elf file was produced by some other tool (including an older version of yaml2obj), then the reconstituted program headers will likely point to garbage.

So, I believe a more sophisticated solution is needed here. I think we will need to somehow capture the segment-to-section relationship symbolically, much like yaml2obj allows you to state the sections which are to be contained in a segment, and then adjusts the program headers offset and size fields accordingly. However, that is not going to be that trivial, because there is a bunch of edge cases to consider:

• the segments can contain data not covered by any section, due to alignment or other considerations. The most extreme case of this are elf core files, which contain no sections, and all data is accessible only through program headers. So we'll probably need a way to specify (parts of) segment content directly.
• this means that yaml2obj will need to be able to generate and allocate space for this kind of data in its output. That may mean changing the algorithm it uses to allocate space for the section data, but I don't really have that part thought out.
• the PT_PHDR header is particularly amusing, because it is self-referencing. However, I don't think we use this header for anything right now, so it's probably not too important what we do with it..

[jhenderson]

I agree with @labath, I don't think this approach is quite right. We should avoid using the strict Offset field if we can, in the obj2yaml output, and we should definitely link them with their sections (i.e. via the Sections: member of a program header). Perhaps we need to update the whole paradigm, to allow for arbitrary data in the list of "Sections"? Something like:

Sections:
  - Data: '12345678'
  - Section: .text
  - Data: 'abcdef90'
  - Section: .another.text

And I'd probably rename "Sections" to "Members" or similar.

I've been using the FileSize and Offset fields up to now because there isn't a sensible alternative for arbitrary data in program headers not covered by a section, and something like this would make the tests I've written more robust. It would also allow a cleaner obj2yaml output, I think.

[rupprecht]

Ack -- those suggestions sound good, I'll revive this patch when I have a proposal for smarter program headers.

llvm/test/Object/obj2yaml.test

 ELF-X86-64-NEXT:       Binding:         STB_GLOBAL
 
 ELF-AVR:      FileHeader:
 ELF-AVR-NEXT:   Class:           ELFCLASS32
 ELF-AVR-NEXT:   Data:            ELFDATA2LSB
 ELF-AVR-NEXT:   Type:            ET_EXEC
 ELF-AVR-NEXT:   Machine:         EM_AVR
 ELF-AVR-NEXT:   Flags:           [ EF_AVR_ARCH_AVR2 ]
+ELF-AVR-NEXT: ProgramHeaders:
+ELF-AVR-NEXT:   - Type:            PT_LOAD
+ELF-AVR-NEXT:     Flags:           [ PF_X, PF_R ]
+ELF-AVR-NEXT:     Align:           0x0000000000000002
+ELF-AVR-NEXT:     FileSize:        0x0000000000000004
+ELF-AVR-NEXT:     MemSize:         0x0000000000000004
+ELF-AVR-NEXT:     Offset:          0x0000000000000074
+ELF-AVR-NEXT:   - Type:            PT_LOAD
+ELF-AVR-NEXT:     Flags:           [ PF_W, PF_R ]
+ELF-AVR-NEXT:     VAddr:           0x0000000000800060
+ELF-AVR-NEXT:     PAddr:           0x0000000000000004
+ELF-AVR-NEXT:     Align:           0x0000000000000001
+ELF-AVR-NEXT:     FileSize:        0x0000000000000000
+ELF-AVR-NEXT:     MemSize:         0x0000000000000000
+ELF-AVR-NEXT:     Offset:          0x0000000000000078
 ELF-AVR-NEXT: Sections:
 ELF-AVR-NEXT:   - Name:            .text
 ELF-AVR-NEXT:     Type:            SHT_PROGBITS
 ELF-AVR-NEXT:     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
 ELF-AVR-NEXT:     AddressAlign:    0x0000000000000002
 ELF-AVR-NEXT:     Content:         C20E0895
 ELF-AVR-NEXT:   - Name:            .data
 ELF-AVR-NEXT:     Type:            SHT_PROGBITS

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

+# RUN: yaml2obj %s -o %t
+# RUN: obj2yaml %t | FileCheck %s
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0xAAAA4000
+    PAddr: 0xFFFF4000
+    Align: 0x4000
+    Sections:
+      - Section: .foo
+  - Type: PT_NOTE
+    Flags: [ PF_R ]
+    VAddr: 0xAAAA7000
+    PAddr: 0xFFFF7000
+    Sections:
+      - Section: .bar
+  - Type: 0x1234
+    Flags: [ PF_R ]
+    VAddr: 0xAAAA9000
+    PAddr: 0xFFFF9000
+    Sections:
+      - Section: .bar
+Sections:
+  - Name:            .foo
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000001000
+    Content:         "0000000000000000"
+  - Name:            .bar
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Content:         "00000000"
+    AddressAlign:    0x0000000000001000
+
+# CHECK:      ProgramHeaders:
+# CHECK-NEXT:   - Type:            PT_LOAD
+# CHECK-NEXT:     Flags:           [ PF_X, PF_R ]
+# CHECK-NEXT:     VAddr:           0x00000000AAAA4000
+# CHECK-NEXT:     PAddr:           0x00000000FFFF4000
+# CHECK-NEXT:     Align:           0x0000000000004000
+# CHECK-NEXT:     FileSize:        0x0000000000000008
+# CHECK-NEXT:     MemSize:         0x0000000000000008
+# CHECK-NEXT:     Offset:          0x0000000000001000
+# CHECK-NEXT:   - Type:            PT_NOTE
+# CHECK-NEXT:     Flags:           [ PF_R ]
+# CHECK-NEXT:     VAddr:           0x00000000AAAA7000
+# CHECK-NEXT:     PAddr:           0x00000000FFFF7000
+# CHECK-NEXT:     Align:           0x0000000000001000
+# CHECK-NEXT:     FileSize:        0x0000000000000004
+# CHECK-NEXT:     MemSize:         0x0000000000000004
+# CHECK-NEXT:     Offset:          0x0000000000002000
+# CHECK-NEXT:   - Type:            0x00001234
+# CHECK-NEXT:     Flags:           [ PF_R ]
+# CHECK-NEXT:     VAddr:           0x00000000AAAA9000
+# CHECK-NEXT:     PAddr:           0x00000000FFFF9000
+# CHECK-NEXT:     Align:           0x0000000000001000
+# CHECK-NEXT:     FileSize:        0x0000000000000004
+# CHECK-NEXT:     MemSize:         0x0000000000000004
+# CHECK-NEXT:     Offset:          0x0000000000002000

llvm/tools/obj2yaml/elf2yaml.cpp

 using namespace llvm;
 
 namespace {
 
 template <class ELFT>
 class ELFDumper {
   typedef object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef typename ELFT::Dyn Elf_Dyn;
+  typedef typename ELFT::Phdr Elf_Phdr;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Word Elf_Word;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
 
   ArrayRef<Elf_Shdr> Sections;
 
   // If the file has multiple sections with the same name, we add a
template <class ELFT> ErrorOr<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
   Y->Header.Data = ELFYAML::ELF_ELFDATA(Obj.getHeader()->getDataEncoding());
   Y->Header.OSABI = Obj.getHeader()->e_ident[ELF::EI_OSABI];
   Y->Header.ABIVersion = Obj.getHeader()->e_ident[ELF::EI_ABIVERSION];
   Y->Header.Type = Obj.getHeader()->e_type;
   Y->Header.Machine = Obj.getHeader()->e_machine;
   Y->Header.Flags = Obj.getHeader()->e_flags;
   Y->Header.Entry = Obj.getHeader()->e_entry;
 
+  auto PhdrRangeOrErr = Obj.program_headers();
+  if (!PhdrRangeOrErr)
+    return errorToErrorCode(PhdrRangeOrErr.takeError());
+
+  for (const Elf_Phdr &Phdr : *PhdrRangeOrErr) {
+    ELFYAML::ProgramHeader PH;
+    PH.Type = Phdr.p_type;
+    PH.Flags = Phdr.p_flags;
+    PH.VAddr = Phdr.p_vaddr;
+    PH.PAddr = Phdr.p_paddr;
+    // Optional fields
+    PH.Align = {Phdr.p_align};
+    PH.Offset = {Phdr.p_offset};
+    PH.FileSize = {Phdr.p_filesz};
+    PH.MemSize = {Phdr.p_memsz};
+    Y->ProgramHeaders.push_back(PH);
+  }
+
   const Elf_Shdr *Symtab = nullptr;
   const Elf_Shdr *DynSymtab = nullptr;
 
   // Dump sections
   auto SectionsOrErr = Obj.sections();
   if (!SectionsOrErr)
     return errorToErrorCode(SectionsOrErr.takeError());
   Sections = *SectionsOrErr;