[yaml2obj] - ProgramHeaders: introduce FirstSec/LastSec instead of Sections list.

[grimar]

Summary

Imagine we have a YAML declaration of few sections: foo1, <unnamed 2>, foo3, foo4.

To put them into segment we can do (1*):

Sections:
 - Section: foo1
 - Section: foo4

or we can use (2*):

Sections:
 - Section: foo1
 - Section: foo3
 - Section: foo4

or (3*) :

Sections:
 - Section: foo1
## "(index 2)" here is a name that we automatically created for a unnamed section.
 - Section: (index 2)
 - Section: foo3
 - Section: foo4

It looks really confusing that we don't have to list all of sections.

At first I've tried to make this rule stricter and report an error when there is a gap
(i.e. when a section is included into segment, but not listed explicitly).
This did not work perfect, because such approach conflicts with unnamed sections/fills (see (3*)).

This patch drops "Sections" key and introduces 2 keys instead: FirstSec and LastSec.
Both are optional.

[MaskRay]

The idea looks good. It is used by LLD to compute p_filesz/p_memsz:)

I can understand that if a segment contains many sections, it can be inconvenient to enumerate every one.

[jhenderson]

As long as this approach still allows creating program headers with the exact same contents as before (i.e. it's as flexible as possible), then it makes sense to me too. Happy for you to proceed.

[grimar]

In D90458#2367707, @jhenderson wrote:

As long as this approach still allows creating program headers with the exact same contents as before (i.e. it's as flexible as possible), then it makes sense to me too. Happy for you to proceed.

It indeed will be at least on the same level of flexibility.

FTR, partially I was inspired by the following possible situation. Currently we allocate a space for nobits sections in a segment when there are
fills or non-nobits sections after them:

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

If we have a segment with sections:
<regular1>, <nobits1>, <regular2>, <nobits2>

Then we might have a segment description that specifies only <regular1> and <nobits2>:

Sections:
  - Section: <regular1>
  - Section: <nobits2>

and it will be different from the case where we explicitly specify all of sections,
because in the case above I believe we will not allocate a space for the <nobits1> section with the current code.

That is why I tried to implement a requirement about that all sections must explicitly present in the segment description at first.

With the solution that this patch suggests it should be impossible to trigger the possible bug/misbehavior I've described.

[grimar]

• Updated other tests. Added a few new ones.

Ready for review.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

505–506

The behaviour here is a little subtle (relying on the zero-value insertion of a size_t when a member doesn't exist). I wonder if it would be worth adding some comments to make it clearer?

510

This behaviour isn't immediately clear to me as being the behaviour when just FirstSec is specified. It could easily be thought that just FirstSec implies that section and all later sections. What do you think about requiring both keys if either is specified?

515

Maybe worth bailing out at this point if either First or Last are invalid, rahter than needing the if (First && Last) bits here.

llvm/lib/ObjectYAML/ELFYAML.cpp

917

llvm/test/tools/llvm-objdump/X86/elf-dynamic-relocs.test

99 ↗

(On Diff #302485)

Side-note: this one was previously missing .got.plt!

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

331–332

This comment probably needs updating.

llvm/test/tools/yaml2obj/ELF/custom-fill.yaml

265–269

We probably need the same test case but for the LastSec key.

llvm/test/tools/yaml2obj/ELF/program-header.yaml

98

99

113

131

Should we have a test case showing that Fills are included as well?

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

510

It could easily be thought that just FirstSec implies that section and all later sections.

I had such concern too. Was not sure what is better. I've made both keys to be required if either is specified.

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

331–332

I've updated the test itself instead.

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

488–503

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

192 ↗

(On Diff #303063)

llvm/test/tools/llvm-readobj/ELF/hash-histogram.test

412 ↗

(On Diff #303063)

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

365–367

We probably need a case where .non-alloc.2 would be the LastSec too.

llvm/tools/obj2yaml/elf2yaml.cpp

393–401

Does this loop work if section headers are not in section offset order? Or are they guaranteed to be by some sorting earlier on?

[grimar]

llvm/tools/obj2yaml/elf2yaml.cpp

393–401

I have no short answer, we have a specific behavior for cases where sections are not in the
section offset order currently, let me describe it.

Imagine we have 3 sections:
.foo at offset 0x100, .bar at offset 0x200 and .zed at offset 0x300.
And lets have a section header table where they are in a different order:
.zed (0x300), .foo (0x100) and .bar (0x200).

And lets have a segment [.foo, .zed]. The YAML for this case is shown below:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_EXEC
Sections:
  - Name:    .foo
    Type:    SHT_PROGBITS
    Flags:   [ SHF_ALLOC ]
    Size:    0x1
    Offset:  0x100
  - Name:    .bar
    Type:    SHT_PROGBITS
    Flags:   [ SHF_ALLOC ]
    Size:    0x2
    Offset:  0x200
  - Name:    .zed
    Type:    SHT_PROGBITS
    Flags:   [ SHF_ALLOC ]
    Size:    0x3
    Offset:  0x300
SectionHeaderTable:
  Sections:
    - Name: .zed
    - Name: .foo
    - Name: .bar
    - Name: .strtab
    - Name: .shstrtab
ProgramHeaders:
  - Type:     PT_LOAD
    Flags:    [ PF_W, PF_R ]
    VAddr:    0x1000
    FirstSec: .foo
    LastSec:  .zed

after applying obj2yaml we have:

--- !ELF
FileHeader:
  Class:           ELFCLASS64
  Data:            ELFDATA2LSB
  Type:            ET_EXEC
ProgramHeaders:
  - Type:            PT_LOAD
    Flags:           [ PF_W, PF_R ]
    FirstSec:        .zed
    LastSec:         .bar
    VAddr:           0x0000000000001000
Sections:
  - Name:            .zed
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC ]
    Address:         0x0000000000000003
    Content:         '000000'
  - Name:            .foo
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC ]
    Content:         '00'
  - Name:            .bar
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC ]
    Address:         0x0000000000000001
    Content:         '0000'
...

What is noticable:

1. We lost the information about the section header order. I.e. now the order is not .foo .bar. zed, but .zed .foo .bar. Because we dump sections by section header table order only and don't try to preserve section offsets.
2. FirstSec/LastSec were changed, but they match the YAML produced.

[jhenderson]

llvm/tools/obj2yaml/elf2yaml.cpp

393–401

My opinion is that we don't need to preserve in the YAML the section header table order, as long as the semantic meaning is identical. Section offset order likely needs maintaining if the sections are inside segments, or any hard-coded addresses will end up breaking, right? It sounds like that might be an issue already though?

[grimar]

• Addressed review comments.

llvm/tools/obj2yaml/elf2yaml.cpp

393–401

Yeah, I think so.

I guess we want do dump sections as we do now, but then sort them by file offsets (i.e. sort Chunks) and also emit the Offset field (perhaps not always, but when the aligned [previous offset + size of previous section] value doesn't match the offset of a section dumped).

Though I'd like to experiment with this are probably at first to see if there is something not obvious that I may be missing.

[jhenderson]

I think this patch looks good. The section offset ordering thing is probably an independent change.

llvm/include/llvm/ObjectYAML/ELFYAML.h

 };
 
 struct SectionHeaderTable {
   Optional<std::vector<SectionHeader>> Sections;
   Optional<std::vector<SectionHeader>> Excluded;
   Optional<bool> NoHeaders;
 };
 
-struct SectionName {
-  StringRef Section;
-};
-
 struct Symbol {
   StringRef Name;
   ELF_STT Type;
   StringRef Section;
   Optional<ELF_SHN> Index;
   ELF_STB Binding;
   llvm::yaml::Hex64 Value;
   llvm::yaml::Hex64 Size;
struct ProgramHeader {
   ELF_PT Type;
   ELF_PF Flags;
   llvm::yaml::Hex64 VAddr;
   llvm::yaml::Hex64 PAddr;
   Optional<llvm::yaml::Hex64> Align;
   Optional<llvm::yaml::Hex64> FileSize;
   Optional<llvm::yaml::Hex64> MemSize;
   Optional<llvm::yaml::Hex64> Offset;
+  Optional<StringRef> FirstSec;
+  Optional<StringRef> LastSec;
 
-  std::vector<SectionName> Sections;
-  // This vector is parallel to Sections and contains corresponding chunks.
+  // This vector contains all chunks from [FirstSec, LastSec].
   std::vector<Chunk *> Chunks;
 };
 
 struct Object {
   FileHeader Header;
   Optional<SectionHeaderTable> SectionHeaders;
   std::vector<ProgramHeader> ProgramHeaders;
 

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ARMIndexTableEntry)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct ScalarTraits<ELFYAML::YAMLIntUInt> {
   static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx,
                      raw_ostream &Out);

 };
 
 template <> struct MappingTraits<ELFYAML::SectionHeader> {
   static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr);
 };
 
 template <> struct MappingTraits<ELFYAML::ProgramHeader> {
   static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
+  static std::string validate(IO &IO, ELFYAML::ProgramHeader &FileHdr);
 };
 
 template <>
 struct MappingTraits<ELFYAML::Symbol> {
   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
   static std::string validate(IO &IO, ELFYAML::Symbol &Symbol);
 };
 

 struct MappingTraits<ELFYAML::Object> {
   static void mapping(IO &IO, ELFYAML::Object &Object);
 };
 
 template <> struct MappingTraits<ELFYAML::SectionOrType> {
   static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
 };
 
-template <> struct MappingTraits<ELFYAML::SectionName> {
-  static void mapping(IO &IO, ELFYAML::SectionName &sectionName);
-};
-
 } // end namespace yaml
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_ELFYAML_H

llvm/lib/ObjectYAML/ELFEmitter.cpp

else
     Header.e_shstrndx = 0;
 
   OS.write((const char *)&Header, sizeof(Header));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
   DenseMap<StringRef, ELFYAML::Fill *> NameToFill;
-  for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks)
-    if (auto S = dyn_cast<ELFYAML::Fill>(D.get()))
+  DenseMap<StringRef, size_t> NameToIndex;
+  for (size_t I = 0, E = Doc.Chunks.size(); I != E; ++I) {
+    if (auto S = dyn_cast<ELFYAML::Fill>(Doc.Chunks[I].get()))
       NameToFill[S->Name] = S;
+    NameToIndex[Doc.Chunks[I]->Name] = I + 1;
+  }
 
   std::vector<ELFYAML::Section *> Sections = Doc.getSections();
-  for (ELFYAML::ProgramHeader &YamlPhdr : Doc.ProgramHeaders) {
+  for (size_t I = 0, E = Doc.ProgramHeaders.size(); I != E; ++I) {
+    ELFYAML::ProgramHeader &YamlPhdr = Doc.ProgramHeaders[I];
     Elf_Phdr Phdr;
     zero(Phdr);
     Phdr.p_type = YamlPhdr.Type;
     Phdr.p_flags = YamlPhdr.Flags;
     Phdr.p_vaddr = YamlPhdr.VAddr;
     Phdr.p_paddr = YamlPhdr.PAddr;
     PHeaders.push_back(Phdr);
 
-    // Map Sections list to corresponding chunks.
-    for (const ELFYAML::SectionName &SecName : YamlPhdr.Sections) {
-      if (ELFYAML::Fill *Fill = NameToFill.lookup(SecName.Section)) {
-        YamlPhdr.Chunks.push_back(Fill);
-        continue;
-      }
+    if (!YamlPhdr.FirstSec)
 
-      unsigned Index;
-      if (SN2I.lookup(SecName.Section, Index)) {
-        YamlPhdr.Chunks.push_back(Sections[Index]);
-        continue;
-      }
+    size_t First = NameToIndex[*YamlPhdr.FirstSec];
+    if (!First)
+      reportError("unknown section or fill referenced: '" + *YamlPhdr.FirstSec +
+                  "' by the 'FirstSec' key of the program header with index " +
+                  Twine(I));
+    size_t Last = YamlPhdr.LastSec ? NameToIndex[*YamlPhdr.LastSec] : First;
+    if (!Last && YamlPhdr.LastSec)
+      reportError("unknown section or fill referenced: '" + *YamlPhdr.LastSec +
+                  "' by the 'LastSec' key of the program header with index " +
+                  Twine(I));
+    if (First && Last && First > Last)
+      reportError("program header with index " + Twine(I) +
+                  ": the section index of " + *YamlPhdr.FirstSec +
+                  " is greater than the index of " + *YamlPhdr.LastSec);
+    if (HasError)
 
-      reportError("unknown section or fill referenced: '" + SecName.Section +
-                  "' by program header");
-    }
+    for (size_t I = First; I <= Last; ++I)
+      YamlPhdr.Chunks.push_back(Doc.Chunks[I - 1].get());
   }
 }
 
 template <class ELFT>
 unsigned ELFState<ELFT>::toSectionIndex(StringRef S, StringRef LocSec,
                                         StringRef LocSym) {
   assert(LocSec.empty() || LocSym.empty());
 
   unsigned Index;
   if (!SN2I.lookup(S, Index) && !to_integer(S, Index)) {
     if (!LocSym.empty())
       reportError("unknown section referenced: '" + S + "' by YAML symbol '" +
                   LocSym + "'");
     else
       reportError("unknown section referenced: '" + S + "' by YAML section '" +
                   LocSec + "'");
     return 0;

llvm/lib/ObjectYAML/ELFYAML.cpp

void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
   IO.mapOptional("EShNum", FileHdr.EShNum);
   IO.mapOptional("EShStrNdx", FileHdr.EShStrNdx);
 }
 
 void MappingTraits<ELFYAML::ProgramHeader>::mapping(
     IO &IO, ELFYAML::ProgramHeader &Phdr) {
   IO.mapRequired("Type", Phdr.Type);
   IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
-  IO.mapOptional("Sections", Phdr.Sections);
+  IO.mapOptional("FirstSec", Phdr.FirstSec);
+  IO.mapOptional("LastSec", Phdr.LastSec);
   IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
   IO.mapOptional("PAddr", Phdr.PAddr, Phdr.VAddr);
   IO.mapOptional("Align", Phdr.Align);
   IO.mapOptional("FileSize", Phdr.FileSize);
   IO.mapOptional("MemSize", Phdr.MemSize);
   IO.mapOptional("Offset", Phdr.Offset);
 }
 
+std::string MappingTraits<ELFYAML::ProgramHeader>::validate(
+    IO &IO, ELFYAML::ProgramHeader &FileHdr) {
+  if (!FileHdr.FirstSec && FileHdr.LastSec)
+    return "the \"LastSec\" can't be used without the \"LastSec\" key";
+  return "";
+}
+
 LLVM_YAML_STRONG_TYPEDEF(StringRef, StOtherPiece)
 
 template <> struct ScalarTraits<StOtherPiece> {
   static void output(const StOtherPiece &Val, void *, raw_ostream &Out) {
     Out << Val;
   }
   static StringRef input(StringRef Scalar, void *, StOtherPiece &Val) {
     Val = Scalar;
static void sectionMapping(IO &IO, ELFYAML::CallGraphProfileSection &Section) {
   IO.mapOptional("Entries", Section.Entries);
 }
 
 void MappingTraits<ELFYAML::SectionOrType>::mapping(
     IO &IO, ELFYAML::SectionOrType &sectionOrType) {
   IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
 }
 
-void MappingTraits<ELFYAML::SectionName>::mapping(
-    IO &IO, ELFYAML::SectionName &sectionName) {
-  IO.mapRequired("Section", sectionName.Section);
-}
-
 static void sectionMapping(IO &IO, ELFYAML::ARMIndexTableSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Entries", Section.Entries);
 }
 
 static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Version", Section.Version, Hex16(0));

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

 # SEGMENT-MAPPING-NEXT:   08     .gnu.hash {{$}}
 # SEGMENT-MAPPING-NEXT:   None   .symtab .strtab .shstrtab {{$}}
 
 ## Check that obj2yaml produced a correct program headers description.
 
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=YAML
 
 # YAML:      ProgramHeaders:
-# YAML-NEXT:  - Type:  PT_LOAD
-# YAML-NEXT:    Flags: [ PF_R ]
-# YAML-NEXT:    Sections:
-# YAML-NEXT:      - Section: .hash
-# YAML-NEXT:      - Section: .gnu.hash
-# YAML-NEXT:      - Section: .dynsym
-# YAML-NEXT:      - Section: .dynstr
-# YAML-NEXT:    Align: 0x0000000000001000
-# YAML-NEXT:  - Type:  PT_LOAD
-# YAML-NEXT:    Flags: [ PF_X, PF_R ]
-# YAML-NEXT:    Sections:
-# YAML-NEXT:      - Section: .foo
-# YAML-NEXT:      - Section: .zed
-# YAML-NEXT:    VAddr: 0x0000000000001000
-# YAML-NEXT:    Align: 0x0000000000001000
-# YAML-NEXT:  - Type:  PT_LOAD
-# YAML-NEXT:    Flags: [ PF_R ]
-# YAML-NEXT:    Sections:
-# YAML-NEXT:      - Section: '.foo (1)'
-# YAML-NEXT:      - Section: .baz
-# YAML-NEXT:    VAddr: 0x0000000000002000
-# YAML-NEXT:    Align: 0x0000000000001000
-# YAML-NEXT:  - Type:  PT_LOAD
-# YAML-NEXT:    Flags: [ PF_W, PF_R ]
-# YAML-NEXT:    Sections:
-# YAML-NEXT:      - Section: .dynamic
-# YAML-NEXT:      - Section: .dynamic.tail
-# YAML-NEXT:    VAddr: 0x0000000000003EF0
-# YAML-NEXT:    Align: 0x0000000000001000
-# YAML-NEXT:  - Type:  PT_DYNAMIC
-# YAML-NEXT:    Flags: [ PF_W, PF_R ]
-# YAML-NEXT:    Sections:
-# YAML-NEXT:      - Section: .dynamic
-# YAML-NEXT:    VAddr: 0x0000000000003EF0
-# YAML-NEXT:    Align: 0x0000000000000008
-# YAML-NEXT:  - Type:  PT_GNU_RELRO
-# YAML-NEXT:    Flags: [ PF_R ]
-# YAML-NEXT:    Sections:
-# YAML-NEXT:      - Section: .dynamic
-# YAML-NEXT:    VAddr: 0x0000000000003EF0
+# YAML-NEXT:  - Type:     PT_LOAD
+# YAML-NEXT:    Flags:    [ PF_R ]
+# YAML-NEXT:    FirstSec: .hash
+# YAML-NEXT:    LastSec:  .dynstr
+# YAML-NEXT:    Align:    0x0000000000001000
+# YAML-NEXT:  - Type:     PT_LOAD
+# YAML-NEXT:    Flags:    [ PF_X, PF_R ]
+# YAML-NEXT:    FirstSec: .foo
+# YAML-NEXT:    LastSec:  .zed
+# YAML-NEXT:    VAddr:    0x0000000000001000
+# YAML-NEXT:    Align:    0x0000000000001000
+# YAML-NEXT:  - Type:     PT_LOAD
+# YAML-NEXT:    Flags:    [ PF_R ]
+# YAML-NEXT:    FirstSec: '.foo (1)'
+# YAML-NEXT:    LastSec:  .baz
+# YAML-NEXT:    VAddr:    0x0000000000002000
+# YAML-NEXT:    Align:    0x0000000000001000
+# YAML-NEXT:  - Type:     PT_LOAD
+# YAML-NEXT:    Flags:    [ PF_W, PF_R ]
+# YAML-NEXT:    FirstSec: .dynamic
+# YAML-NEXT:    LastSec:  .dynamic.tail
+# YAML-NEXT:    VAddr:    0x0000000000003EF0
+# YAML-NEXT:    Align:    0x0000000000001000
+# YAML-NEXT:  - Type:     PT_DYNAMIC
+# YAML-NEXT:    Flags:    [ PF_W, PF_R ]
+# YAML-NEXT:    FirstSec: .dynamic
+# YAML-NEXT:    VAddr:    0x0000000000003EF0
+# YAML-NEXT:    Align:    0x0000000000000008
+# YAML-NEXT:  - Type:     PT_GNU_RELRO
+# YAML-NEXT:    Flags:    [ PF_R ]
+# YAML-NEXT:    FirstSec: .dynamic
+# YAML-NEXT:    VAddr:    0x0000000000003EF0
 # YAML-NEXT:  - Type:  PT_LOAD
 # YAML-NEXT:    Flags: [ PF_R ]
 # YAML-NEXT:    VAddr: 0x0000000000004000
-# YAML-NEXT:  - Type:  PT_LOAD
-# YAML-NEXT:    Flags: [ PF_R ]
-# YAML-NEXT:    Sections:
-# YAML-NEXT:      - Section: .gnu.hash
-# YAML-NEXT:    VAddr: 0x00000000000001A0
-# YAML-NEXT:  - Type:  PT_LOAD
-# YAML-NEXT:    Flags: [ PF_R ]
-# YAML-NEXT:    Sections:
-# YAML-NEXT:      - Section: .gnu.hash
-# YAML-NEXT:    VAddr: 0x00000000000001A0
+# YAML-NEXT:  - Type:     PT_LOAD
+# YAML-NEXT:    Flags:    [ PF_R ]
+# YAML-NEXT:    FirstSec: .gnu.hash
+# YAML-NEXT:    VAddr:    0x00000000000001A0
+# YAML-NEXT:  - Type:     PT_LOAD
+# YAML-NEXT:    Flags:    [ PF_R ]
+# YAML-NEXT:    FirstSec: .gnu.hash
+# YAML-NEXT:    VAddr:    0x00000000000001A0
 # YAML-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 ProgramHeaders:
 ## Check we can create a PT_LOAD with arbitrary (we used .hash, .gnu.hash)
 ## and implicit sections (we use .dynsym, .dynstr). It also checks that the
 ## SHT_NULL section at index 0 is not included in the segment.
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .hash
-      - Section: .gnu.hash
-      - Section: .dynsym
-      - Section: .dynstr
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .hash
+    LastSec:  .dynstr
     Align:  0x1000
     Offset: 0x0
 ## Check we can create a PT_LOAD with a different set of properties and sections.
-  - Type:  PT_LOAD
-    Flags: [ PF_X, PF_R ]
-    Sections:
-      - Section: .foo
-      - Section: .zed
-    VAddr: 0x1000
-    Align: 0x1000
+  - Type:     PT_LOAD
+    Flags:    [ PF_X, PF_R ]
+    FirstSec: .foo
+    LastSec:  .zed
+    VAddr:    0x1000
+    Align:    0x1000
 ## Create a PT_LOAD to demonstate we are able to refer to output sections with the same name.
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: '.foo (1)'
-      - Section: .baz
-    VAddr: 0x2000
-    Align: 0x1000
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: '.foo (1)'
+    LastSec:  .baz
+    VAddr:    0x2000
+    Align:    0x1000
 ## Show we can create a writeable PT_LOAD segment and put an arbitrary section into it.
 ## Here we test both regular (SHT_PROGBITS) and a special section (SHT_DYNAMIC).
-  - Type:  PT_LOAD
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .dynamic
-      - Section: .dynamic.tail
-    VAddr: 0x3EF0
-    Align: 0x1000
+  - Type:     PT_LOAD
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .dynamic
+    LastSec:  .dynamic.tail
+    VAddr:    0x3EF0
+    Align:    0x1000
 ## Show we can create a nested dynamic segment and put a section into it.
-  - Type:  PT_DYNAMIC
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .dynamic
-    VAddr: 0x3EF0
-    Align: 0x8
+  - Type:     PT_DYNAMIC
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .dynamic
+    VAddr:    0x3EF0
+    Align:    0x8
 ## Show we can create a relro segment and put a section into it.
 ## We used .dynamic here and in tests above to demonstrate that
 ## we can place a section in any number of segments.
 ## Also, we explicitly set the "Align" property to 1 to demonstate
 ## that we do not dump it, because it is the default alignment
 ## value set by yaml2obj.
-  - Type:  PT_GNU_RELRO
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .dynamic
-    VAddr: 0x3EF0
-    Align: 0x1
+  - Type:     PT_GNU_RELRO
+    Flags:    [ PF_R ]
+    FirstSec: .dynamic
+    VAddr:    0x3EF0
+    Align:    0x1
 ## Show we can dump a standalone empty segment.
   - Type:  PT_LOAD
     Flags: [ PF_R ]
-    Sections: [ ]
     VAddr: 0x4000
     Align: 0x1
 ## ELF specification says that loadable segment entries in the
 ## program header are sorted by virtual address.
 ## Show we can dump an out of order segment.
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .gnu.hash
-    VAddr: 0x1A0
-    Align: 0x1
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .gnu.hash
+    VAddr:    0x1A0
+    Align:    0x1
 ## Test we are able to dump duplicated segments.
 ## We use a segment that is the same as the previous one for this.
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .gnu.hash
-    VAddr: 0x1A0
-    Align: 0x1
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .gnu.hash
+    VAddr:    0x1A0
+    Align:    0x1
 Sections:
   - Name:    .hash
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Address: 0x190
     Size:    0x10
   - Name:    .gnu.hash
     Type:    SHT_PROGBITS

 
 ## Part II. More specific tests.
 
 ## Check we are able to dump segments that are empty or
 ## contain empty sections.
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: obj2yaml %t2 | FileCheck %s --check-prefix=EMPTY
 
-# EMPTY:      - Type:  PT_LOAD
-# EMPTY-NEXT:   Flags: [ PF_W, PF_R ]
-# EMPTY-NEXT:   Sections:
-# EMPTY-NEXT:     - Section: .empty.tls.start
-# EMPTY-NEXT:     - Section: .section.1
-# EMPTY-NEXT:     - Section: .empty.tls.middle
-# EMPTY-NEXT:     - Section: .section.2
-# EMPTY-NEXT:     - Section: .empty.tls.end
+# 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: 0x0000000000001000
 # EMPTY-NEXT:   Align: 0x0000000000001000
-# EMPTY-NEXT: - Type:            PT_TLS
-# EMPTY-NEXT:   Flags:           [ PF_W, PF_R ]
-# EMPTY-NEXT:   Sections:
-# EMPTY-NEXT:     - Section:         .empty.tls.start
-# EMPTY-NEXT:   VAddr:           0x0000000000001000
-# EMPTY-NEXT: - Type:            PT_TLS
-# EMPTY-NEXT:   Flags:           [ PF_W, PF_R ]
-# EMPTY-NEXT:   Sections:
-# EMPTY-NEXT:     - Section:         .empty.tls.middle
-# EMPTY-NEXT:   VAddr:           0x0000000000001100
-# EMPTY-NEXT: - Type:            PT_TLS
-# EMPTY-NEXT:   Flags:           [ PF_W, PF_R ]
-# EMPTY-NEXT:   Sections:
-# EMPTY-NEXT:     - Section:         .empty.tls.end
-# EMPTY-NEXT:   VAddr:           0x0000000000001200
+# EMPTY-NEXT: - Type:     PT_TLS
+# EMPTY-NEXT:   Flags:    [ PF_W, PF_R ]
+# EMPTY-NEXT:   FirstSec: .empty.tls.start
+# EMPTY-NEXT:   VAddr:    0x0000000000001000
+# EMPTY-NEXT: - Type:     PT_TLS
+# EMPTY-NEXT:   Flags:    [ PF_W, PF_R ]
+# EMPTY-NEXT:   FirstSec: .empty.tls.middle
+# EMPTY-NEXT:   VAddr:    0x0000000000001100
+# EMPTY-NEXT: - Type:     PT_TLS
+# EMPTY-NEXT:   Flags:    [ PF_W, PF_R ]
+# EMPTY-NEXT:   FirstSec: .empty.tls.end
+# EMPTY-NEXT:   VAddr:    0x0000000000001200
 # EMPTY-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 ProgramHeaders:
-  - Type:  PT_LOAD
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .empty.tls.start
-      - Section: .section.1
-      - Section: .empty.tls.middle
-      - Section: .section.2
-      - Section: .empty.tls.end
-    VAddr: 0x1000
-    Align: 0x1000
-  - Type:  PT_TLS
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .empty.tls.start
-    VAddr: 0x1000
-    Align: 0x1
-  - Type:  PT_TLS
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .empty.tls.middle
-    VAddr: 0x1100
-    Align: 0x1
-  - Type:  PT_TLS
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .empty.tls.end
-    VAddr: 0x1200
-    Align: 0x1
+  - Type:     PT_LOAD
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .empty.tls.start
+    LastSec:  .empty.tls.end
+    VAddr:    0x1000
+    Align:    0x1000
+  - Type:     PT_TLS
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .empty.tls.start
+    VAddr:    0x1000
+    Align:    0x1
+  - Type:     PT_TLS
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .empty.tls.middle
+    VAddr:    0x1100
+    Align:    0x1
+  - Type:     PT_TLS
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .empty.tls.end
+    VAddr:    0x1200
+    Align:    0x1
 Sections:
   - Name:    .empty.tls.start
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_TLS ]
     Size:    0x0
     Address: 0x1000
   - Name:  .section.1
     Type:  SHT_PROGBITS

 
 ## As a misaligned p_offset value we use (`.foo` section offset - 1).
 # MISALIGNED-READELF:      [Nr] Name Type     Address          Off
 # MISALIGNED-READELF:      [ 1] .foo PROGBITS 0000000000001000 000078
 # MISALIGNED-READELF:      Type Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
 # MISALIGNED-READELF-NEXT: LOAD 0x000077 0x0000000000001000 0x0000000000001000 0x000078 0x000078 R   0x1000
 
 # MISALIGNED-YAML:      ProgramHeaders:
-# MISALIGNED-YAML-NEXT:  - Type:  PT_LOAD
-# MISALIGNED-YAML-NEXT:    Flags: [ PF_R ]
-# MISALIGNED-YAML-NEXT:    Sections:
-# MISALIGNED-YAML-NEXT:     - Section: .foo
-# MISALIGNED-YAML-NEXT:    VAddr: 0x0000000000001000
-# MISALIGNED-YAML-NEXT:    Align: 0x0000000000001000
+# MISALIGNED-YAML-NEXT:  - Type:     PT_LOAD
+# MISALIGNED-YAML-NEXT:    Flags:    [ PF_R ]
+# MISALIGNED-YAML-NEXT:    FirstSec: .foo
+# MISALIGNED-YAML-NEXT:    VAddr:    0x0000000000001000
+# MISALIGNED-YAML-NEXT:    Align:    0x0000000000001000
 # MISALIGNED-YAML-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 ProgramHeaders:
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .foo
-    VAddr:  0x1000
-    Align:  0x1000
-    Offset: 0x000077
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .foo
+    VAddr:    0x1000
+    Align:    0x1000
+    Offset:   0x000077
 Sections:
   - Name:    .foo
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x77
     Address: 0x1000
 
 ## Test we include non-allocatable sections in segments.
 ## We also document that SHT_NULL sections are not considered to be inside a segment.
 # 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:     Sections:
-# NON-ALLOC-NEXT:      - Section: .alloc.1
-# NON-ALLOC-NEXT:      - Section: .non-alloc.1
-# NON-ALLOC-NEXT:      - Section: .alloc.2
-# NON-ALLOC-NEXT:     VAddr: 0x0000000000001000
+# 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:     VAddr:    0x0000000000001000
 # NON-ALLOC-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 ProgramHeaders:
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .alloc.1
-      - Section: .alloc.2
-    VAddr:  0x1000
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .alloc.1
+    LastSec:  .alloc.2
+    VAddr:    0x1000
 Sections:
   - Name:    .alloc.1
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x100
     Address: 0x1000
   - Name:    .non-alloc.1
     Type:    SHT_PROGBITS
     Flags:   [ ]
     Size:    0x10
   - Name:    .non-alloc.2
     Type:    SHT_NULL
     Flags:   [ ]
     Size:    0x10
   - Name:    .alloc.2
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x1
 
 ## Check how we dump segments which contain SHT_NOBITS sections.
 # 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:     Sections:
-# NOBITS-NEXT:       - Section: .bss
-# NOBITS-NEXT:   - Type:  PT_LOAD
-# NOBITS-NEXT:     Flags: [ PF_W, PF_R ]
-# NOBITS-NEXT:     Sections:
-# NOBITS-NEXT:       - Section: .data.1
-# NOBITS-NEXT:       - Section: .bss
-# NOBITS-NEXT:   - Type:  PT_LOAD
-# NOBITS-NEXT:     Flags: [ PF_W, PF_R ]
-# NOBITS-NEXT:     Sections:
-# NOBITS-NEXT:       - Section: .data.1
-# NOBITS-NEXT:       - Section: .bss
-# NOBITS-NEXT:       - Section: .data.2
-# NOBITS-NEXT:   - Type:  PT_LOAD
-# NOBITS-NEXT:     Flags: [ PF_W, PF_R ]
-# NOBITS-NEXT:     Sections:
-# NOBITS-NEXT:       - Section: .bss
-# NOBITS-NEXT:       - Section: .data.2
-# NOBITS-NEXT:   - Type:  PT_LOAD
-# NOBITS-NEXT:     Flags: [ PF_W, PF_R ]
-# NOBITS-NEXT:     Sections:
-# NOBITS-NEXT:       - Section: .foo.bss
-# NOBITS-NEXT:       - Section: .bar.bss
+# NOBITS-NEXT:   - Type:     PT_LOAD
+# NOBITS-NEXT:     Flags:    [ PF_W, PF_R ]
+# NOBITS-NEXT:     FirstSec: .bss
+# NOBITS-NEXT:   - Type:     PT_LOAD
+# NOBITS-NEXT:     Flags:    [ PF_W, PF_R ]
+# NOBITS-NEXT:     FirstSec: .data.1
+# NOBITS-NEXT:     LastSec:  .bss
+# NOBITS-NEXT:   - Type:     PT_LOAD
+# NOBITS-NEXT:     Flags:    [ PF_W, PF_R ]
+# NOBITS-NEXT:     FirstSec: .data.1
+# NOBITS-NEXT:     LastSec:  .data.2
+# NOBITS-NEXT:   - Type:     PT_LOAD
+# NOBITS-NEXT:     Flags:    [ PF_W, PF_R ]
+# NOBITS-NEXT:     FirstSec: .bss
+# NOBITS-NEXT:     LastSec:  .data.2
+# 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: 0x0000000200000000
 # NOBITS-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 ProgramHeaders:
 ## Case 1: the segment contains a single SHT_NOBITS section.
-  - Type:  PT_LOAD
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .bss
+  - Type:     PT_LOAD
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .bss
 ## Case 2: the SHT_NOBITS section is the last section in the segment.
-  - Type:  PT_LOAD
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .data.1
-      - Section: .bss
+  - Type:     PT_LOAD
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .data.1
+    LastSec:  .bss
 ## Case 3: the SHT_NOBITS section is in the middle of the segment.
-  - Type:  PT_LOAD
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .data.1
-      - Section: .bss
-      - Section: .data.2
+  - Type:     PT_LOAD
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .data.1
+    LastSec:  .data.2
 ## Case 4: the SHT_NOBITS section is the first section in the segment.
-  - Type:  PT_LOAD
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .bss
-      - Section: .data.2
+  - Type:     PT_LOAD
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .bss
+    LastSec:  .data.2
 ## Case 5: another two SHT_NOBITS sections in a different segment.
-  - Type:  PT_LOAD
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .foo.bss
-      - Section: .bar.bss
-    VAddr: 0x200000000
+  - Type:     PT_LOAD
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .foo.bss
+    LastSec:  .bar.bss
+    VAddr:    0x200000000
 Sections:
   - Name:    .data.1
     Type:    SHT_PROGBITS
     Flags:   [ SHF_WRITE, SHF_ALLOC ]
 ## Use an arbitrary address and size.
     Address: 0x1000
     Size:    0x1
   - Name:   .bss

 ## the previous section.
     Size:    0x20
 
 ## Check that we require sections in a program header
 ## declaration to be sorted by their offsets.
 # RUN: not yaml2obj --docnum=6 %s -o %t6 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=UNSORTED --implicit-check-not="error:"
 
-# UNSORTED:      error: sections in the program header with index 1 are not sorted by their file offset
+# UNSORTED:      error: program header with index 0: the section index of .bar is greater than the index of .foo
 # UNSORTED-NEXT: error: sections in the program header with index 3 are not sorted by their file offset
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 ProgramHeaders:
 ## Case 1: the .bar section is placed after the .foo section in the file.
 ##         Check we report an error about the violation of the order.
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .bar
-      - Section: .foo
-    VAddr:  0x1000
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .bar
+    LastSec:  .foo
+    VAddr:    0x1000
 ## There is nothing wrong with this segment. We have it to show that
 ## we report correct program header indices in error messages.
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .foo
-      - Section: .bar
-    VAddr:  0x1000
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .foo
+    LastSec:  .bar
+    VAddr:    0x1000
 ## Case 2: the .bar section is placed before the .zed section in the file,
 ##         but the sh_offset of .zed is less than the sh_offset of
 ##         the .bar section because of the "ShOffset" property.
 ##         Document we report an error for such a case.
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .bar
-      - Section: .zed
-    VAddr:  0x1001
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .bar
+    LastSec:  .zed
+    VAddr:    0x1001
 Sections:
   - Name:    .foo
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x1
     Address: 0x1000
   - Name:    .bar
     Type:    SHT_PROGBITS

 # ZERO-SIZE-MAPPING-NEXT:   [ 2] .empty.bar1 PROGBITS 0000000000002000 000078 000000
 # ZERO-SIZE-MAPPING-NEXT:   [ 3] .bar        PROGBITS 0000000000002000 000078 000001
 # ZERO-SIZE-MAPPING-NEXT:   [ 4] .empty.bar2 PROGBITS 0000000000002001 000079 000000
 # ZERO-SIZE-MAPPING-NEXT:   [ 5] .empty.zed  PROGBITS 0000000000003000 000079 000000
 
 # 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:     Sections:
-# ZERO-SIZE-NEXT:       - Section: .empty.bar1
-# ZERO-SIZE-NEXT:       - Section: .bar
-# ZERO-SIZE-NEXT:       - Section: .empty.bar2
-# ZERO-SIZE-NEXT:     VAddr: 0x0000000000002000
+# 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:    0x0000000000002000
 # ZERO-SIZE-NEXT: Sections:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 ProgramHeaders:
-  - Type:  PT_LOAD
-    Flags: [ PF_W, PF_R ]
-    Sections:
-      - Section: .bar
-    VAddr: 0x2000
+  - Type:     PT_LOAD
+    Flags:    [ PF_W, PF_R ]
+    FirstSec: .bar
+    VAddr:    0x2000
 Sections:
   - Name:    .empty.foo
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
     Address: 0x1000
   - Name:    .empty.bar1
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]

 ## Check how we dump a segment when we have sections that are outside of the virtual
 ## address space of a segment, but inside its file space. We do not include such sections
 ## in a segment when they are at the edges of a segment, because this is a normal case and
 ## it may mean they belong to a different segment.
 # RUN: yaml2obj --docnum=8 %s -o %t8
 # RUN: obj2yaml %t8 | FileCheck %s --check-prefix=BROKEN-VA
 
 # BROKEN-VA:      ProgramHeaders:
-# BROKEN-VA-NEXT:  - Type:  PT_LOAD
-# BROKEN-VA-NEXT:    Flags: [ PF_W, PF_R ]
-# BROKEN-VA-NEXT:    Sections:
-# BROKEN-VA-NEXT:      - Section: .empty_middle
-# BROKEN-VA-NEXT:    VAddr: 0x0000000000001000
+# BROKEN-VA-NEXT:  - Type:     PT_LOAD
+# BROKEN-VA-NEXT:    Flags:    [ PF_W, PF_R ]
+# BROKEN-VA-NEXT:    FirstSec: .empty_middle
+# BROKEN-VA-NEXT:    VAddr:    0x0000000000001000
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 ProgramHeaders:
-  - Type:  PT_LOAD
-    Flags: [ PF_W, PF_R ]
-    VAddr: 0x1000
-    Sections:
-      - Section: .empty_begin
-      - Section: .empty_middle
-      - Section: .empty_end
+  - Type:     PT_LOAD
+    Flags:    [ PF_W, PF_R ]
+    VAddr:    0x1000
+    FirstSec: .empty_begin
+    LastSec:  .empty_end
 Sections:
   - Name:    .empty_begin
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
     Address: 0xFEFEFEFE
   - Type:    Fill
     Pattern: "00"
     Size:    1

llvm/test/tools/yaml2obj/ELF/custom-fill.yaml

- Name:         .bar
     Size:         0x5
     Address:      0x100
     AddressAlign: 2
   - Type:    Fill
     Name:    fill2
     Pattern: ""
     Size:    0x45
 ProgramHeaders:
-  - Type:  PT_LOAD
-    VAddr: 0x100
-    Sections:
-      - Section: fill1
-      - Section: .bar
-      - Section: fill2
-  - Type:  PT_GNU_RELRO
-    VAddr: 0x105
-    Sections:
-      - Section: fill2
+  - Type:     PT_LOAD
+    VAddr:    0x100
+    FirstSec: fill1
+    LastSec:  fill2
+  - Type:     PT_GNU_RELRO
+    VAddr:    0x105
+    FirstSec: fill2
 
 ## Check that the "Pattern" field is not mandatory.
 # RUN: yaml2obj --docnum=4 2>&1 -o %t4 %s
 # RUN: llvm-readelf --sections %t4 | FileCheck %s --check-prefix=NOPATTERN
 
 ## The fill we dump starts at (offset of .strtab - 1 - 3 - 1), which is (0x45 - 5) = 0x40.
 # RUN: od -t x1 -v -j 0x40 -N 5 %t4 | FileCheck %s --ignore-case --check-prefix=NOPATTERN-DATA
 
FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Type:    Fill
     Pattern: "00"
     Size:    0
 
 ## Check we report an error when a program header references
 ## an unknown section or fill and have at least one Fill defined.
 
 # RUN: not yaml2obj --docnum=10 2>&1 %s | FileCheck %s --check-prefix=UNKNOWN-ERR
-# UNKNOWN-ERR: error: unknown section or fill referenced: 'fill' by program header
+# UNKNOWN-ERR: error: unknown section or fill referenced: 'fill' by the 'FirstSec' key of the program header with index 0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Type:    Fill
     Pattern: ""
     Size:    0
 ProgramHeaders:
-  - Type: PT_LOAD
-    Sections:
-      - Section: fill
+  - Type:     PT_LOAD
+    FirstSec: fill
 
 ## Show that we can use the "Offset" key to set an arbitrary offset for a Fill.
 
 ## 0x41 is the minimal possible valid offset for Fill,
 ## because the .foo section of size 0x1 is placed at 0x40.
 # RUN: yaml2obj --docnum=11 -DOFFSET=0x41 -o %t11 %s
 # RUN: llvm-readelf --section-headers %t11 | FileCheck %s --check-prefix=OFFSET-MIN
 

llvm/test/tools/yaml2obj/ELF/dynamic-section-i386.yaml

- Name:            .dynamic
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_STRSZ
         Value:           0x0000000000000001
       - Tag:             DT_NULL
         Value:           0x0000000000000000
 ProgramHeaders:
-  - Type: PT_LOAD
-    Flags: [ PF_R ]
-    VAddr: 0x0000
-    Align: 8
-    Sections:
-      - Section: .dynamic
-  - Type: PT_DYNAMIC
-    Flags: [ PF_X, PF_R ]
-    VAddr: 0x0008
-    Sections:
-      - Section: .dynamic
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    VAddr:    0x0000
+    Align:    8
+    FirstSec: .dynamic
+  - Type:     PT_DYNAMIC
+    Flags:    [ PF_X, PF_R ]
+    VAddr:    0x0008
+    FirstSec: .dynamic

llvm/test/tools/yaml2obj/ELF/header-sh-fields.yaml

 # DEFAULT: Section header string table index: 2
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 ProgramHeaders:
-  - Type:     PT_LOAD
-    Sections: []
-  - Type:     PT_LOAD
-    Sections: []
+  - Type: PT_LOAD
+  - Type: PT_LOAD
 
 ## Check we can override all default values using the same values
 ## and that this does not change the output.
 # RUN: yaml2obj --docnum=2 %s -o %t-default-override
 # RUN: cmp %t-default %t-default-override
 
 --- !ELF
 FileHeader:
   Class:      ELFCLASS64
   Data:       ELFDATA2LSB
   Type:       ET_REL
   EShEntSize: [[SHENTSIZE=64]]
   EShOff:     [[SHOFF=200]]
   EShNum:     [[SHNUM=3]]
   EShStrNdx:  [[SHSTRNDX=2]]
   EPhOff:     [[PHOFF=64]]
   EPhEntSize: [[PHENTSIZE=56]]
   EPhNum:     [[PHNUM=2]]
 ProgramHeaders:
-  - Type:     PT_LOAD
-    Sections: []
-  - Type:     PT_LOAD
-    Sections: []
+  - Type: PT_LOAD
+  - Type: PT_LOAD
 
 ## Override different fields to check the output produced.
 
 ## Override the e_shoff field.
 # RUN: yaml2obj --docnum=2 %s -DSHOFF=3 -o %t2
 # RUN: llvm-readelf --file-headers %t2 | FileCheck %s --check-prefix=SHOFF
 
 # SHOFF: Start of section headers: 3 (bytes into file)

llvm/test/tools/yaml2obj/ELF/program-header-address.yaml

Sections:
   - Name:    .foo
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x1
     Address: 0x1234
 ProgramHeaders:
 ## Show what virtual and physical address we set by default for the case where
 ## a program header has no sections.
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    Sections: []
+  - Type:  PT_LOAD
+    Flags: [ PF_X, PF_R ]
 ## Show what virtual and physical address we set by default for the case
 ## where a program header includes a section with a virtual address that
 ## is explicitly set.
   - Type:     PT_LOAD
     Flags:    [ PF_X, PF_R ]
-    Sections:
-      - Section: .foo
+    FirstSec: .foo
 ## Now we have a program header that has a virtual address different to
 ## the address of the section included. Show that the default physical address
 ## is equal to the program header's virtual address.
-  - Type:  PT_LOAD
-    Flags: [ PF_X, PF_R ]
-    VAddr: 0xAAAA1000
-    Sections:
-      - Section: .foo
+  - Type:     PT_LOAD
+    Flags:    [ PF_X, PF_R ]
+    VAddr:    0xAAAA1000
+    FirstSec: .foo
 ## Show that we are able to set different virtual and physical addresses.
-  - Type:  PT_LOAD
-    Flags: [ PF_X, PF_R ]
-    VAddr: 0xAAAA1000
-    PAddr: 0xBBBB2000
-    Sections:
-      - Section: .foo
+  - Type:     PT_LOAD
+    Flags:    [ PF_X, PF_R ]
+    VAddr:    0xAAAA1000
+    PAddr:    0xBBBB2000
+    FirstSec: .foo

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

- Name:         .tdata
     Type:         SHT_PROGBITS
     AddressAlign: 4
   - Name:         .tbss
     Type:         SHT_NOBITS
     AddressAlign: 64
 ProgramHeaders:
   - Type:  PT_TLS
     Align: 16
-    Sections:
-      - Section: .tdata
-      - Section: .tbss
+    FirstSec: .tdata
+    LastSec:  .tbss
 
 ## If Align is not specified, p_align is inferred from the maximum alignment
 ## of contained sections.
 
 # RUN: yaml2obj --docnum=2 %s -o %t
 # RUN: llvm-readobj -l %t | FileCheck %s
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:         .text
     Type:         SHT_PROGBITS
     AddressAlign: 4
   - Name:         .text.hot
     Type:         SHT_PROGBITS
     AddressAlign: 16
 ProgramHeaders:
-  - Type: PT_LOAD
-    Sections:
-      - Section: .text
-      - Section: .text.hot
+  - Type:     PT_LOAD
+    FirstSec: .text
+    LastSec:  .text.hot

llvm/test/tools/yaml2obj/ELF/program-header-nobits.yaml

Sections:
   - Name:  .data.last
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x6
 ProgramHeaders:
 ## We have 2 segments, the first is predefined and the second can be customized.
 ## We want to have more than one segment to show we check all of them when
 ## trying to find a non-nobits section after a nobits one.
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .data.before
-      - Section: .nobits.1
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: [[SEC1]]
-      - Section: [[SEC2]]
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .data.before
+    LastSec:  .nobits.1
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: [[SEC1]]
+    LastSec:  [[SEC2]]
 
 ## Case D. We have a segment with SHT_NOBITS sections on its borders and one
 ##         non-nobits in the middle. Check we allocate the file space only for
 ##         the first nobits section.
 
 # RUN: yaml2obj --docnum=2 %s -o %t4
 # RUN: llvm-readelf --sections --segments %t4 | FileCheck %s --check-prefix=MIDDLE
 
- Name:  .data
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x10
   - Name:  .nobits.2
     Type:  SHT_NOBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x100
 ProgramHeaders:
-  - Type:  PT_LOAD
-    Flags: [ PF_R ]
-    Sections:
-      - Section: .nobits.1
-      - Section: .data
-      - Section: .nobits.2
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    FirstSec: .nobits.1
+    LastSec:  .nobits.2

llvm/test/tools/yaml2obj/ELF/program-header-size-offset.yaml

ProgramHeaders:
   # Program header with no sections.
   - Type:     0x6abcdef0 # arbitrary type
     Offset:   0x1234
     FileSize: 1111
     MemSize:  9999
   # Program header with only file size set.
   - Type:     0x6abcdef0
     FileSize: 6
-    Sections:
-      - Section: .rodata
+    FirstSec: .rodata
   # Program header with only mem size set.
   - Type:     0x6abcdef0
-    MemSize: 6
-    Sections:
-      - Section: .rodata
+    MemSize:  6
+    FirstSec: .rodata
   # Program header with only offset set.
   - Type:     0x6abcdef0
     Offset:   0x1fff
-    Sections:
-      - Section: .rodata
+    FirstSec: .rodata
   # Program header with sections, valid properties.
   - Type:     0x6abcdef0
     Offset:   0xffe
     FileSize: 7
     MemSize:  9
-    Sections:
-      - Section: .text
+    FirstSec: .text
   # Program header with invalid properties.
   - Type:     0x6abcdef0
     Offset:   0x3000
     FileSize: 3
     MemSize:  2
   # Program header with 2 SHT_NOBITS sections.
   - Type:     0x6abcdef0
     Offset:   0x2004
-    Sections:
-      - Section: .data
-      - Section: .nobits1
-      - Section: .nobits2
+    FirstSec: .data
+    LastSec:  .nobits2
 
 ## Test the "Offset" property.
 
 ## Check that by default the p_offset field of a segment is set to the
 ## offset of the section with the minimum offset.
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-readelf %t2 --sections --program-headers | \
 # RUN:   FileCheck %s --check-prefixes=DEFAULT-OFFSET
- Name:    .foo
     Flags:   [ SHF_ALLOC ]
     Size:    0x1
     Address: 0x1000
   - Name:  .bar
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x1
 ProgramHeaders:
-  - Type: PT_LOAD
-    Sections:
-      - Section: .foo
-      - Section: .bar
-  - Type: PT_LOAD
-    Sections:
-      - Section: .bar
+  - Type:     PT_LOAD
+    FirstSec: .foo
+    LastSec:  .bar
+  - Type:     PT_LOAD
+    FirstSec: .bar
 
 ## Check we can set the "Offset" value explicitly to be less than or equal to
 ## the offset of a section in the segment.
 # RUN: yaml2obj --docnum=3 -DOFFSET=0x77 %s -o %t3
 # RUN: llvm-readelf %t3 --sections --program-headers | \
 # RUN:   FileCheck %s --check-prefixes=VALID-OFFSET,VALID-OFFSET-LESS
 # RUN: yaml2obj --docnum=3 -DOFFSET=0x78 %s -o %t4
 # RUN: llvm-readelf %t4 --sections --program-headers | \
FileHeader:
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:  .foo
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x1
 ProgramHeaders:
-  - Type: PT_LOAD
-    Offset: [[OFFSET]]
-    Sections:
-      - Section: .foo
+  - Type:    PT_LOAD
+    Offset:  [[OFFSET]]
+    FirstSec: .foo
 
 ## Check we report an error when the "Offset" value is larger than the offset of a section in the segment.
 # RUN: not yaml2obj --docnum=3 -DOFFSET=0x79 %s -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=INVALID-OFFSET
 
 # INVALID-OFFSET: yaml2obj: error: 'Offset' for segment with index 1 must be less than or equal to the minimum file offset of all included sections (0x78)
 
 ## Document that the "Offset" value is checked after the section offset is overriden using "ShOffset".
Sections:
   - Name:     .foo
     Type:     SHT_PROGBITS
     Flags:    [ SHF_ALLOC ]
     Size:     0x1
 ## Note: the real .foo offset is much less than 0xFFFFFFFF or
 ##       0xFFFFFF00, but no error is reported.
     ShOffset: 0xFFFFFFFF
 ProgramHeaders:
-  - Type:   PT_LOAD
-    Offset: 0xFFFFFF00
-    Sections:
-      - Section: .foo
+  - Type:     PT_LOAD
+    Offset:   0xFFFFFF00
+    FirstSec: .foo

llvm/test/tools/yaml2obj/ELF/program-header.yaml

- Name:            .init
     Content:         "00000000"
     AddressAlign:    0x0000000000000010
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Content:         "00000000"
     AddressAlign:    0x0000000000001000
 ProgramHeaders:
-  - Type: PT_LOAD
-    Flags: [ PF_X, PF_R ]
-    VAddr: 0xAAAA1000
-    PAddr: 0xFFFF1000
-    Sections:
-      - Section: .text
-      - Section: .init
-  - Type: PT_LOAD
-    Flags: [ PF_R ]
-    VAddr: 0xAAAA2000
-    PAddr: 0xFFFF2000
-    Sections:
-      - Section: .data
+  - Type:     PT_LOAD
+    Flags:    [ PF_X, PF_R ]
+    VAddr:    0xAAAA1000
+    PAddr:    0xFFFF1000
+    FirstSec: .text
+    LastSec:  .init
+  - Type:     PT_LOAD
+    Flags:    [ PF_R ]
+    VAddr:    0xAAAA2000
+    PAddr:    0xFFFF2000
+    FirstSec: .data
   - Type: PT_GNU_EH_FRAME
   - Type: PT_GNU_STACK
   - Type: PT_GNU_RELRO
   - Type: PT_GNU_PROPERTY
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:   ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD

 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_GNU_PROPERTY (0x6474E553)
 #CHECK:       }
 #CHECK-NEXT:]
 
 ## Check we do not allow referencing sections that do not exist.
 # RUN: not yaml2obj --docnum=2 %s -o %t 2>&1 | FileCheck %s --check-prefix=ERR
 
-# ERR: error: unknown section or fill referenced: '.foo' by program header
-# ERR: error: unknown section or fill referenced: '.bar' by program header
+# ERR: error: unknown section or fill referenced: '.foo' by the 'FirstSec' key of the program header with index 0
+# ERR: error: unknown section or fill referenced: '.bar' by the 'LastSec' key of the program header with index 0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 ProgramHeaders:
-  - Type: PT_LOAD
-    Sections:
-      - Section: .foo
-      - Section: .bar
+  - Type:     PT_LOAD
+    FirstSec: .foo
+    LastSec:  .bar

llvm/tools/obj2yaml/elf2yaml.cpp

for (const typename ELFT::Phdr &Phdr : *PhdrsOrErr) {
     // 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
     // obj2yaml does not create Fill chunks.
     for (const std::unique_ptr<ELFYAML::Chunk> &C : Chunks) {
       ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get());
-      if (isInSegment<ELFT>(S, Sections[S.OriginalSecNdx], Phdr))
-        PH.Sections.push_back({S.Name});
+      if (isInSegment<ELFT>(S, Sections[S.OriginalSecNdx], Phdr)) {
+        if (!PH.FirstSec)
+          PH.FirstSec = S.Name;
+        if (S.Name != *PH.FirstSec)
+          PH.LastSec = S.Name;
+      }
     }
 
     Ret.push_back(PH);
   }
 
   return Ret;
 }
 
 template <class ELFT>