[yaml2obj/obj2yaml] - Implement program header table as a special Chunk.

[grimar]

Summary

This implements the program header table as a chunk of type "ProgramHeaderTable".
It allows to place the program header table at an arbitrary location.

[jhenderson]

I might well have missed it, but I don't recall seeing any dedicated obj2yaml tests?

llvm/lib/ObjectYAML/ELFEmitter.cpp

758

My reading of the ELF gABI is that this will need to be aligned on a 4-byte/8-byte boundary dependent on ELF32/ELF64. We should do that for an implicit offset (but allow it if the offset is explicit):

All data structures that the object file format defines follow the ``natural'' size and alignment guidelines for the relevant class. If necessary, data structures contain explicit padding to ensure 8-byte alignment for 8-byte objects, 4-byte alignment for 4-byte objects, to force structure sizes to a multiple of 4 or 8, and so forth. Data also have suitable alignment from the beginning of the file. Thus, for example, a structure containing an Elf32_Addr member will be aligned on a 4-byte boundary within the file.

Speaking of which, this code looks quite different to the section header table code, which has two separate calls to alignToOffset dependent on whether the Offset has been specified, if I read it correctly. Why is that?

760

(sorry - missed this same issue in the section header table case)

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

176

203–204

What about an offset that isn't already aligned to 4/8?

218–219

Should we have one for after all other chunks so that the total file size is based on the end of the last chunk? I don't know if that's really needed or not.

[grimar]

In D95591#2527530, @jhenderson wrote:

I might well have missed it, but I don't recall seeing any dedicated obj2yaml tests?

There is a obj2yaml/ELF/program-headers.yaml test which checks how the
program header table is emitted. But there is no much else we have to test currently I think,
because at this moment obj2yaml just emits the description in the begining of sections list.
It can't dump the table on a proper position or dump the "Offset" key.
I.e. this is already covered by the test. I am going to improve it slightly though (e.g. will add a comment).

[grimar]

• Addressed review comments.
• Improved testing.

llvm/lib/ObjectYAML/ELFEmitter.cpp

758

Why is that?

Just because the code did not do the auto alignment. I wasn't sure if we want it as usually the program header
table is placed at the begining, where it is naturally aligned, though your reference to gABI makes sense to me. Also, the code is indeed better to be
consistent with the code for the section header table. So, I've fixed it.

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

203–204

Done.

218–219

I've improved testing and added such a test case.

[jhenderson]

LGTM, with one nit.

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

357–358

Copy paste error? The file size is 336 in this case.

[grimar]

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

357–358

Oh, right, thanks!

[MaskRay]

This change will make obj2yaml crash on a binary processed by llvm-strip --remove-sections (which is currently untested).

Program headers are not subsidiary of the section header table. ProgramHeaderType is fine, but it probably should not have Segments:. The program headers can still be described the current ProgramHeaders:.

[grimar]

In D95591#2529833, @MaskRay wrote:

Program headers are not subsidiary of the section header table. ProgramHeaderType is fine, but it probably should not have Segments:. The program headers can still be described the current ProgramHeaders:.

This was already discussed.
We can rename the "Sections:" to "Layout:". Or allow both. See https://reviews.llvm.org/D93678#2492777.
Having Segments: in ProgramHeader Type is consistent with SectionHeaderTable type.

[grimar]

• Fix the obj2yaml crash on a binary processed by llvm-strip --remove-sections. The issue happened when there was no section header table. I've fixed it and added a test case to program-headers.yaml. Note that currently obj2yaml doesn't emit a SectionHeaderTable chunk with NoHeaders = true for such a case. But this issue is unrelated to this patch, we already have the following FIXME in the eshnum.yaml test:

## In the test case below we have an object without a section header table and e_shnum == 0.
## Document how we dump it.
## FIXME: we should emit the `SectionHeaderTable` key with `NoHeaders=true` for this case.

[jhenderson]

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

357–358

Looks like this still hasn't been addressed?

[grimar]

• Addressed review comment.

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

357–358

My apoligies. Seems I've pushed "Done" by mistake yesterday.

[jhenderson]

LGTM again, but this probably needs @MaskRay's approval too, since he was concerned about the user-facing design.

[MaskRay]

If the idea is that we will have ability to create two program header tables, this seems fine. Such an ability has no use though because only the one referenced by e_phoff matters.
So I am still on the fence whether there is a good syntax.

+ @labath who added some ProgramHeaders: yaml2obj tests to lldb/test/Shell.

[labath]

In D95591#2531495, @MaskRay wrote:

If the idea is that we will have ability to create two program header tables, this seems fine. Such an ability has no use though because only the one referenced by e_phoff matters.
So I am still on the fence whether there is a good syntax.

+ @labath who added some ProgramHeaders: yaml2obj tests to lldb/test/Shell.

Overall, I like the ability to explicitly control the location of program headers.

As for @MaskRay's question, I don't have any real answers, but I am going to make an observation. :)

The way I see it, the root cause of the problem here is that the top item item is called "Sections". The name kind of stopped being correct back when we allowed non-section filler chunks. Now it will be even less correct. If you follow this up with (I don't know if its in the works, but it would totally make sense to me) a change to control the placement/contents of section headers, it will become amusingly (confusingly?) self-referential.

If, instead, the top level item was called "Chunks", or "Layout", or "Contents", then it would not be weird to see program (or section) headers described inside. OTOH, it would make the (common) case of describing a section longer (by one line) as they would no longer automatically get the "section" kind.

Whether that's worth it... I don't know...

[jhenderson]

@grimar is on vacation for an extended period, so I'll take over the design discussion from him, since I worked with him on coming up with the design. Below, I summarise the key design ideas, to make sure we're all on the same page.

At some point, I think we want to change Sections: to Layout:, to avoid confusion. Due to the invasiveness of this change, I think we wanted to get the member design done first, and possibly even keep Sections: as an alias.

This block is now used to control (with this patch) placement of 4 different kinds of things (called "chunks" in the code): sections, fills, the section header table, and the program header table. These would be distinguished by their Type field. Fill, SectionHeaderTable and ProgramHeaderTable have special meanings. All others represent some kind of section. The Type field then drives the meaning of the rest of the chunk. All four types share the same Offset behaviour (it is automatically calculated unless explicitly specified). This means we can control placement of all components of an ELF object, except for the file header itself, which needs to be at a fixed location anyway.

As we all know, fills are for creating gaps in the output, and sections are for defining the section header properties and contents of a section. The ProgramHeaderTable chunk simply describes the program headers in the ELF, in the same way as the old ProgramHeaders key functioned before. Finally, the SectionHeaderTable chunk type is for describing that table. In particular, it provides the ability to control the order of the section headers, as well as whether some or all headers should be omitted from the table. The latter feature is useful for writing arbitrary contents in section form, without needing the data visible to tools via the section header. Note that the section header order is independent of the section data order. The Sections: ordering provides the data ordering. Thus a section header could appear last in the table, but the data might be first in the ELF (after the file header).

In D95591#2531495, @MaskRay wrote:

If the idea is that we will have ability to create two program header tables, this seems fine. Such an ability has no use though because only the one referenced by e_phoff matters.
So I am still on the fence whether there is a good syntax.

The idea is to allow control over where the program header table is in the ELF object. I don't think the goal is to allow multiple tables. However, should a need arise to do this or something similar ever, the design is easily extensible, which is the reason we actually switched to this design from the older design.

In D95591#2532708, @labath wrote:

The way I see it, the root cause of the problem here is that the top item item is called "Sections". The name kind of stopped being correct back when we allowed non-section filler chunks. Now it will be even less correct. If you follow this up with (I don't know if its in the works, but it would totally make sense to me) a change to control the placement/contents of section headers, it will become amusingly (confusingly?) self-referential.

You may have missed this - the SectionHeaderTable key (which used to be independent, but now is another of the chunk kinds as described above, due to a recent change) was relatively recently added and allows us to describe the section header table. If the key is omitted, the section header table will be implicitly added at the end.

If, instead, the top level item was called "Chunks", or "Layout", or "Contents", then it would not be weird to see program (or section) headers described inside. OTOH, it would make the (common) case of describing a section longer (by one line) as they would no longer automatically get the "section" kind.

As noted above, by using the existing Type field to recognise special chunk kinds, and then with the default behaviour being to interpret the value as some section type, I don't think we need an extra line.

I did consider whether it would be worthwhile to keep the ProgramHeaders tag as an option, to avoid the need to explicitly place it somewhere in the output/update all the tests, but I don't think there is much benefit for this and it causes an increase in code complexity.

[MaskRay]

Thanks for the explanation. Type: ProgramHeaderTable looks good. Layout: instead of Sections: can indeed make things less confusing but that would be a large refactoring on its own. I think making them aliases may not be straightforward to implement to ObjectYAML... The few check-lldb-shell tests still need to be fixed first.

[labath]

In D95591#2533380, @jhenderson wrote:

@grimar is on vacation for an extended period, so I'll take over the design discussion from him, since I worked with him on coming up with the design. Below, I summarise the key design ideas, to make sure we're all on the same page.

At some point, I think we want to change Sections: to Layout:, to avoid confusion. Due to the invasiveness of this change, I think we wanted to get the member design done first, and possibly even keep Sections: as an alias.

This block is now used to control (with this patch) placement of 4 different kinds of things (called "chunks" in the code): sections, fills, the section header table, and the program header table. These would be distinguished by their Type field. Fill, SectionHeaderTable and ProgramHeaderTable have special meanings. All others represent some kind of section. The Type field then drives the meaning of the rest of the chunk. All four types share the same Offset behaviour (it is automatically calculated unless explicitly specified). This means we can control placement of all components of an ELF object, except for the file header itself, which needs to be at a fixed location anyway.

As we all know, fills are for creating gaps in the output, and sections are for defining the section header properties and contents of a section. The ProgramHeaderTable chunk simply describes the program headers in the ELF, in the same way as the old ProgramHeaders key functioned before. Finally, the SectionHeaderTable chunk type is for describing that table. In particular, it provides the ability to control the order of the section headers, as well as whether some or all headers should be omitted from the table. The latter feature is useful for writing arbitrary contents in section form, without needing the data visible to tools via the section header. Note that the section header order is independent of the section data order. The Sections: ordering provides the data ordering. Thus a section header could appear last in the table, but the data might be first in the ELF (after the file header).

Thanks for summarizing this. I haven't been keeping track of recent yaml2obj changes, but all of this looks extremely nice and useful to me. The main functionality I am missing is the ability to (de)serialize core files (no sections, all info is given through program headers and notes), and it sounds like this comes really close to making that possible.

As noted above, by using the existing Type field to recognise special chunk kinds, and then with the default behaviour being to interpret the value as some section type, I don't think we need an extra line.

Interesting. It slightly overloads the meaning of the "Type" field, but I guess it does make the common case simpler.

[jhenderson]

In D95591#2541825, @labath wrote:

Thanks for summarizing this. I haven't been keeping track of recent yaml2obj changes, but all of this looks extremely nice and useful to me. The main functionality I am missing is the ability to (de)serialize core files (no sections, all info is given through program headers and notes), and it sounds like this comes really close to making that possible.

Not a problem! To achieve what I think you're suggesting, I think we'd need to have obj2yaml be able to generate Fills itself. I might be wrong, but I don't think it currently does (Fills are supported in the other direction). I guess the way to do this would be to identify gaps between the other blocks and convert them to Fills with the relevant contents (with no fills required if the size and contents would be the default without the fill). Sounds viable.

As noted above, by using the existing Type field to recognise special chunk kinds, and then with the default behaviour being to interpret the value as some section type, I don't think we need an extra line.

Interesting. It slightly overloads the meaning of the "Type" field, but I guess it does make the common case simpler.

One way of looking at it is not to consider sections directly as a kind of chunk, but rather consider each individual type of section as a different chunk kind (e.g. a relocation section, a dynamic section etc). It just so happens that to generate these different chunk kinds, you use SHT_* instead of "RelocationSection" etc.

llvm/include/llvm/ObjectYAML/ELFYAML.h

enum class ChunkKind {
     DependentLibraries,
     CallGraphProfile,
     BBAddrMap,
 
     // Special chunks.
     SpecialChunksStart,
     Fill = SpecialChunksStart,
     SectionHeaderTable,
+    ProgramHeaderTable
   };
 
   ChunkKind Kind;
   StringRef Name;
   Optional<llvm::yaml::Hex64> Offset;
 
   // Usually chunks are not created implicitly, but rather loaded from YAML.
   // This flag is used to signal whether this is the case or not.
size_t getNumHeaders(size_t SectionsNum) const {
     return (Sections ? Sections->size() : 0) + /*Null section*/ 1;
   }
 
   bool isDefault() const { return !Sections && !Excluded && !NoHeaders; }
 
   static constexpr StringRef TypeStr = "SectionHeaderTable";
 };
 
+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;
+
+  // This vector contains all chunks from [FirstSec, LastSec].
+  std::vector<Chunk *> Chunks;
+};
+
+struct ProgramHeaderTable : Chunk {
+  ProgramHeaderTable(bool IsImplicit)
+      : Chunk(ChunkKind::ProgramHeaderTable, IsImplicit) {}
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::ProgramHeaderTable;
+  }
+
+  std::vector<ProgramHeader> Segments;
+
+  static constexpr StringRef TypeStr = "ProgramHeaderTable";
+};
+
 struct BBAddrMapSection : Section {
   Optional<std::vector<BBAddrMapEntry>> Entries;
 
   BBAddrMapSection() : Section(ChunkKind::BBAddrMap) {}
 
   std::vector<std::pair<StringRef, bool>> getEntries() const override {
     return {{"Entries", Entries.hasValue()}};
   };
struct MipsABIFlags : Section {
 
   MipsABIFlags() : Section(ChunkKind::MipsABIFlags) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::MipsABIFlags;
   }
 };
 
-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;
-
-  // This vector contains all chunks from [FirstSec, LastSec].
-  std::vector<Chunk *> Chunks;
-};
-
 struct Object {
   FileHeader Header;
-  std::vector<ProgramHeader> ProgramHeaders;
 
   // An object might contain output section descriptions as well as
   // custom data that does not belong to any section.
   std::vector<std::unique_ptr<Chunk>> Chunks;
 
   // Although in reality the symbols reside in a section, it is a lot
   // cleaner and nicer if we read them from the YAML as a separate
   // top-level key, which automatically ensures that invariants like there
struct Object {
 
   const SectionHeaderTable &getSectionHeaderTable() const {
     for (const std::unique_ptr<Chunk> &C : Chunks)
       if (auto *S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get()))
         return *S;
     llvm_unreachable("the section header table chunk must always be present");
   }
 
+  ProgramHeaderTable *getProgramHeaderTable() {
+    for (std::unique_ptr<Chunk> &C : Chunks)
+      if (auto *S = dyn_cast<ELFYAML::ProgramHeaderTable>(C.get()))
+        return S;
+    return nullptr;
+  }
+
   unsigned getMachine() const;
 };
 
-bool shouldAllocateFileSpace(ArrayRef<ProgramHeader> Phdrs,
+bool shouldAllocateFileSpace(const ELFYAML::ProgramHeaderTable *PHT,
                              const NoBitsSection &S);
 
 } // end namespace ELFYAML
 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry::BBEntry)

llvm/lib/ObjectYAML/ELFEmitter.cpp

template <class ELFT> class ELFState {
   uint64_t getSectionNameOffset(StringRef Name);
 
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH, uint64_t MaxSize);
 };
 } // end anonymous namespace
 
-template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
-  return A.size() * sizeof(T);
-}
-
-template <class T> static void writeArrayData(raw_ostream &OS, ArrayRef<T> A) {
-  OS.write((const char *)A.data(), arrayDataSize(A));
-}
-
 template <class T> static void zero(T &Obj) { memset(&Obj, 0, sizeof(Obj)); }
 
 template <class ELFT>
 ELFState<ELFT>::ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH)
     : Doc(D), ErrHandler(EH) {
   std::vector<ELFYAML::Section *> Sections = Doc.getSections();
   // Insert SHT_NULL section implicitly when it is not defined in YAML.
   if (Sections.empty() || Sections.front()->Type != ELF::SHT_NULL)
     Doc.Chunks.insert(
         Doc.Chunks.begin(),
         std::make_unique<ELFYAML::Section>(
             ELFYAML::Chunk::ChunkKind::RawContent, /*IsImplicit=*/true));
 
   StringSet<> DocSections;
   ELFYAML::SectionHeaderTable *SecHdrTable = nullptr;
+  bool HasProgramHeaderTable = false;
   for (size_t I = 0; I < Doc.Chunks.size(); ++I) {
     const std::unique_ptr<ELFYAML::Chunk> &C = Doc.Chunks[I];
 
     // We might have an explicit section header table declaration.
     if (auto S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {
       if (SecHdrTable)
         reportError("multiple section header tables are not allowed");
       SecHdrTable = S;
       continue;
     }
 
+    if (isa<ELFYAML::ProgramHeaderTable>(C.get())) {
+      if (HasProgramHeaderTable)
+        reportError("multiple program header tables are not allowed");
+      HasProgramHeaderTable = true;
+      continue;
+    }
+
     // We add a technical suffix for each unnamed section/fill. It does not
     // affect the output, but allows us to map them by name in the code and
     // report better error messages.
     if (C->Name.empty()) {
       std::string NewName = ELFYAML::appendUniqueSuffix(
           /*Name=*/"", "index " + Twine(I));
       C->Name = StringRef(NewName).copy(StringAlloc);
       assert(ELFYAML::dropUniqueSuffix(C->Name).empty());
void ELFState<ELFT>::writeELFHeader(raw_ostream &OS) {
   else
     Header.e_machine = EM_NONE;
 
   Header.e_version = EV_CURRENT;
   Header.e_entry = Doc.Header.Entry;
   Header.e_flags = Doc.Header.Flags;
   Header.e_ehsize = sizeof(Elf_Ehdr);
 
+  const ELFYAML::ProgramHeaderTable *ProgramHeaders =
+      Doc.getProgramHeaderTable();
+
   if (Doc.Header.EPhOff)
     Header.e_phoff = *Doc.Header.EPhOff;
-  else if (!Doc.ProgramHeaders.empty())
-    Header.e_phoff = sizeof(Header);
+  else if (ProgramHeaders)
+    Header.e_phoff = *ProgramHeaders->Offset;
   else
     Header.e_phoff = 0;
 
   if (Doc.Header.EPhEntSize)
     Header.e_phentsize = *Doc.Header.EPhEntSize;
-  else if (!Doc.ProgramHeaders.empty())
+  else if (ProgramHeaders)
     Header.e_phentsize = sizeof(Elf_Phdr);
   else
     Header.e_phentsize = 0;
 
   if (Doc.Header.EPhNum)
     Header.e_phnum = *Doc.Header.EPhNum;
-  else if (!Doc.ProgramHeaders.empty())
-    Header.e_phnum = Doc.ProgramHeaders.size();
+  else if (ProgramHeaders)
+    Header.e_phnum = ProgramHeaders->Segments.size();
   else
     Header.e_phnum = 0;
 
   Header.e_shentsize = Doc.Header.EShEntSize ? (uint16_t)*Doc.Header.EShEntSize
                                              : sizeof(Elf_Shdr);
 
   const ELFYAML::SectionHeaderTable &SectionHeaders =
       Doc.getSectionHeaderTable();
void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
   DenseMap<StringRef, ELFYAML::Fill *> NameToFill;
   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 (size_t I = 0, E = Doc.ProgramHeaders.size(); I != E; ++I) {
-    ELFYAML::ProgramHeader &YamlPhdr = Doc.ProgramHeaders[I];
+  ELFYAML::ProgramHeaderTable *ProgramHeaders = Doc.getProgramHeaderTable();
+  if (!ProgramHeaders)
+    return;
+
+  for (size_t I = 0, E = ProgramHeaders->Segments.size(); I != E; ++I) {
+    ELFYAML::ProgramHeader &YamlPhdr = ProgramHeaders->Segments[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);
 
if (ELFYAML::SectionHeaderTable *S =
       uint64_t Size = S->getNumHeaders(SHeaders.size()) * sizeof(Elf_Shdr);
       // The full section header information might be not available here, so
       // fill the space with zeroes as a placeholder.
       CBA.writeZeros(Size);
       LocationCounter += Size;
       continue;
     }
 
+    if (ELFYAML::ProgramHeaderTable *PHT =
+            dyn_cast<ELFYAML::ProgramHeaderTable>(D.get())) {
+      if (!PHT->Offset)
+        PHT->Offset = alignToOffset(CBA, sizeof(typename ELFT::uint),
+                                    /*Offset=*/None);
+      else
+        PHT->Offset = alignToOffset(CBA, /*Align=*/1, PHT->Offset);
+
+      uint64_t Size = sizeof(Elf_Phdr) * PHT->Segments.size();
+      // The full program header information might not be available here, so
+      // fill the space with zeroes as a placeholder.
+      CBA.writeZeros(Size);
+      LocationCounter += Size;
+      continue;
+    }
+
     ELFYAML::Section *Sec = cast<ELFYAML::Section>(D.get());
     bool IsFirstUndefSection = Sec == Doc.getSections().front();
     if (IsFirstUndefSection && Sec->IsImplicit)
       continue;
 
     Elf_Shdr &SHeader = SHeaders[SN2I.get(Sec->Name)];
     if (Sec->Link) {
       SHeader.sh_link = toSectionIndex(*Sec->Link, Sec->Name);
for (const ELFYAML::Chunk *C : Phdr.Chunks) {
     Ret.push_back({H.sh_offset, H.sh_size, H.sh_type, H.sh_addralign});
   }
   return Ret;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                                             std::vector<Elf_Shdr> &SHeaders) {
+  ELFYAML::ProgramHeaderTable *ProgramHeaders = Doc.getProgramHeaderTable();
+  if (!ProgramHeaders)
+    return;
+
   uint32_t PhdrIdx = 0;
-  for (auto &YamlPhdr : Doc.ProgramHeaders) {
+  for (ELFYAML::ProgramHeader &YamlPhdr : ProgramHeaders->Segments) {
     Elf_Phdr &PHeader = PHeaders[PhdrIdx++];
     std::vector<Fragment> Fragments = getPhdrFragments(YamlPhdr, SHeaders);
     if (!llvm::is_sorted(Fragments, [](const Fragment &A, const Fragment &B) {
           return A.Offset < B.Offset;
         }))
       reportError("sections in the program header with index " +
                   Twine(PhdrIdx) + " are not sorted by their file offset");
 
if (YamlPhdr.Align) {
       PHeader.p_align = 1;
       for (const Fragment &F : Fragments)
         PHeader.p_align = std::max((uint64_t)PHeader.p_align, F.AddrAlign);
     }
   }
 }
 
 bool llvm::ELFYAML::shouldAllocateFileSpace(
-    ArrayRef<ELFYAML::ProgramHeader> Phdrs, const ELFYAML::NoBitsSection &S) {
-  for (const ELFYAML::ProgramHeader &PH : Phdrs) {
+    const ELFYAML::ProgramHeaderTable *PHT, const ELFYAML::NoBitsSection &S) {
+  if (!PHT)
+    return false;
+  for (const ELFYAML::ProgramHeader &PH : PHT->Segments) {
     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;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::NoBitsSection &S,
                                          ContiguousBlobAccumulator &CBA) {
   if (!S.Size)
     return;
 
   SHeader.sh_size = *S.Size;
 
   // When a nobits section is followed by a non-nobits section or fill
   // in the same segment, we allocate the file space for it. This behavior
   // matches linkers.
-  if (shouldAllocateFileSpace(Doc.ProgramHeaders, S))
+  const ELFYAML::ProgramHeaderTable *PHT = Doc.getProgramHeaderTable();
+  if (shouldAllocateFileSpace(PHT, S))
     CBA.writeZeros(*S.Size);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
     ContiguousBlobAccumulator &CBA) {
   if (Section.Info)
bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
   State.buildSymbolIndexes();
 
   if (State.HasError)
     return false;
 
   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 =
-      sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * Doc.ProgramHeaders.size();
   // It is quite easy to accidentally create output with yaml2obj that is larger
   // than intended, for example, due to an issue in the YAML description.
   // We limit the maximum allowed output size, but also provide a command line
   // option to change this limitation.
-  ContiguousBlobAccumulator CBA(SectionContentBeginOffset, MaxSize);
+  ContiguousBlobAccumulator CBA(sizeof(Elf_Ehdr), MaxSize);
 
   std::vector<Elf_Shdr> SHeaders;
   State.initSectionHeaders(SHeaders, CBA);
 
   // Now we can decide segment offsets.
   State.setProgramHeaderLayout(PHeaders, SHeaders);
 
   bool ReachedLimit = CBA.getOffset() > MaxSize;
   if (Error E = CBA.takeLimitError()) {
     // We report a custom error message instead below.
     consumeError(std::move(E));
     ReachedLimit = true;
   }
 
   if (ReachedLimit)
     State.reportError(
         "the desired output size is greater than permitted. Use the "
         "--max-size option to change the limit");
 
   if (State.HasError)
     return false;
 
   State.writeELFHeader(OS);
-  writeArrayData(OS, makeArrayRef(PHeaders));
+
+  if (const ELFYAML::ProgramHeaderTable *PHT = Doc.getProgramHeaderTable())
+    CBA.updateDataAt(*PHT->Offset, PHeaders.data(),
+                     PHeaders.size() * sizeof(Elf_Phdr));
 
   const ELFYAML::SectionHeaderTable &SHT = Doc.getSectionHeaderTable();
   if (!SHT.NoHeaders.getValueOr(false))
     CBA.updateDataAt(*SHT.Offset, SHeaders.data(),
                      SHT.getNumHeaders(SHeaders.size()) * sizeof(Elf_Shdr));
 
   CBA.writeBlobToStream(OS);
   return true;

llvm/lib/ObjectYAML/ELFYAML.cpp

 namespace ELFYAML {
 unsigned Object::getMachine() const {
   if (Header.Machine)
     return *Header.Machine;
   return llvm::ELF::EM_NONE;
 }
 
 constexpr StringRef SectionHeaderTable::TypeStr;
+constexpr StringRef ProgramHeaderTable::TypeStr;
 } // namespace ELFYAML
 
 namespace yaml {
 
 void ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(
     IO &IO, ELFYAML::ELF_ET &Value) {
 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(ET_NONE);

 static void sectionHeaderTableMapping(IO &IO,
                                       ELFYAML::SectionHeaderTable &SHT) {
   IO.mapOptional("Offset", SHT.Offset);
   IO.mapOptional("Sections", SHT.Sections);
   IO.mapOptional("Excluded", SHT.Excluded);
   IO.mapOptional("NoHeaders", SHT.NoHeaders);
 }
 
+static void sectionHeaderTableMapping(IO &IO,
+                                      ELFYAML::ProgramHeaderTable &PHT) {
+  IO.mapOptional("Offset", PHT.Offset);
+  IO.mapOptional("Segments", PHT.Segments);
+}
+
 static void sectionMapping(IO &IO, ELFYAML::LinkerOptionsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Options", Section.Options);
 }
 
 static void sectionMapping(IO &IO,
                            ELFYAML::DependentLibrariesSection &Section) {
   commonSectionMapping(IO, Section);
void MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::mapping(
     IO &IO, std::unique_ptr<ELFYAML::Chunk> &Section) {
   ELFYAML::ELF_SHT Type;
   StringRef TypeStr;
   if (IO.outputting()) {
     if (auto *S = dyn_cast<ELFYAML::Section>(Section.get()))
       Type = S->Type;
     else if (auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(Section.get()))
       TypeStr = SHT->TypeStr;
+    else if (auto *PHT = dyn_cast<ELFYAML::ProgramHeaderTable>(Section.get()))
+      TypeStr = PHT->TypeStr;
   } else {
     // When the Type string does not have a "SHT_" prefix, we know it is not a
     // description of a regular ELF output section.
     TypeStr = getStringValue(IO, "Type");
     if (TypeStr.startswith("SHT_") || isInteger(TypeStr))
       IO.mapRequired("Type", Type);
   }
 
if (TypeStr == ELFYAML::SectionHeaderTable::TypeStr) {
     else
       Section.reset(new ELFYAML::SectionHeaderTable(/*IsImplicit=*/false));
 
     sectionHeaderTableMapping(
         IO, *cast<ELFYAML::SectionHeaderTable>(Section.get()));
     return;
   }
 
+  if (TypeStr == ELFYAML::ProgramHeaderTable::TypeStr) {
+    if (IO.outputting())
+      setStringValue(IO, "Type", TypeStr);
+    else
+      Section.reset(new ELFYAML::ProgramHeaderTable(/*IsImplicit=*/false));
+
+    sectionHeaderTableMapping(
+        IO, *cast<ELFYAML::ProgramHeaderTable>(Section.get()));
+    return;
+  }
+
   const auto &Obj = *static_cast<ELFYAML::Object *>(IO.getContext());
   if (Obj.getMachine() == ELF::EM_MIPS && Type == ELF::SHT_MIPS_ABIFLAGS) {
     if (!IO.outputting())
       Section.reset(new ELFYAML::MipsABIFlags());
     sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
     return;
   }
 
std::string MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
   }
 
   if (const auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {
     if (SHT->NoHeaders && (SHT->Sections || SHT->Excluded || SHT->Offset))
       return "NoHeaders can't be used together with Offset/Sections/Excluded";
     return "";
   }
 
+  if (isa<ELFYAML::ProgramHeaderTable>(C.get()))
+    return "";
+
   const ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get());
   if (Sec.Size && Sec.Content &&
       (uint64_t)(*Sec.Size) < Sec.Content->binary_size())
     return "Section size must be greater than or equal to the content size";
 
   auto BuildErrPrefix = [](ArrayRef<std::pair<StringRef, bool>> EntV) {
     std::string Msg;
     for (size_t I = 0, E = EntV.size(); I != E; ++I) {
else
     IO.mapRequired("Value", E.Value);
 }
 
 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   assert(!IO.getContext() && "The IO context is initialized already");
   IO.setContext(&Object);
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
-  IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Chunks);
   IO.mapOptional("Symbols", Object.Symbols);
   IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
   IO.mapOptional("DWARF", Object.DWARF);
   if (Object.DWARF) {
     Object.DWARF->IsLittleEndian =
         Object.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
     Object.DWARF->Is64BitAddrSize =

llvm/test/DebugInfo/symbolize-build-id-error.test

 # RUN: yaml2obj %s -o %t
 
 # RUN: llvm-symbolizer --debug-file-directory=%p/Inputs --obj=%t 0x20112f | FileCheck %s
 
 # CHECK:      ??
 # CHECK-NEXT: ??:0:0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
-  - Name:    .note.invalid
-    Type:    SHT_NOTE
-    Flags:   [ SHF_ALLOC ]
-    Content: 0123456789
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         Flags:    [ PF_R ]
         FirstSec: .note.invalid
         LastSec:  .note.invalid
+  - Name:    .note.invalid
+    Type:    SHT_NOTE
+    Flags:   [ SHF_ALLOC ]
+    Content: 0123456789

llvm/test/DebugInfo/symbolize-build-id.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
-  - Name:    .note.gnu.build-id
-    Type:    SHT_NOTE
-    Flags:   [ SHF_ALLOC ]
-    Content: 040000000800000003000000474e5500abb50d82b6bdc861
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         Flags:    [ PF_R ]
         FirstSec: .note.gnu.build-id
         LastSec:  .note.gnu.build-id
+  - Name:    .note.gnu.build-id
+    Type:    SHT_NOTE
+    Flags:   [ SHF_ALLOC ]
+    Content: 040000000800000003000000474e5500abb50d82b6bdc861

llvm/test/Object/invalid.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1000
     Entries:
       - Tag:   DT_STRTAB
         Value: 0xFFFF0000
       - Tag:   DT_NULL
         Value: 0x0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Check that llvm-readobj reports a warning when a dynamic relocation section
 ## has sh_entsize field with size != sizeof(Elf_Rela).
 
 # RUN: llvm-readobj --dyn-relocations \
 # RUN:   %p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 2>&1 \
 # RUN:    | FileCheck -DFILE=%p/Inputs/corrupt-invalid-relocation-size.elf.x86-64 --check-prefix=RELOC-BROKEN-ENTSIZE %s
 

 # DYN-TABLE-PHDR: warning: '[[FILE]]': PT_DYNAMIC segment offset (0xffff0000) + file size (0x0) exceeds the size of the file (0x150)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:   PT_DYNAMIC
         Offset: 0xffff0000
 
 ## PT_DYNAMIC's p_filesz field is so large that p_offset + p_filesz is larger
 ## than the object size. Check llvm-readobj reports it.
 
 # RUN: yaml2obj %s --docnum=23 -o %t23
 # RUN: llvm-readobj --dyn-relocations %t23 2>&1 \
 # RUN:  | FileCheck -DFILE=%t23 --check-prefix=DYN-TABLE-PHDR2 %s
 
 # DYN-TABLE-PHDR2: warning: '[[FILE]]': PT_DYNAMIC segment offset (0x78) + file size (0xffff0000) exceeds the size of the file (0x1a8)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_DYNAMIC
+        FileSize: 0xffff0000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_DYNAMIC
-    FileSize: 0xffff0000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # RUN: yaml2obj --docnum=24 %s -o %t24
 # RUN: not obj2yaml 2>&1 %t24 | FileCheck %s -DFILE=%t24 --check-prefix=INVALID-SHSTRNDX
 
 # INVALID-SHSTRNDX: Error reading file: [[FILE]]: section header string table index 255 does not exist
 
 --- !ELF
 FileHeader:

llvm/test/Object/obj2yaml.test

 # RUN: obj2yaml %p/Inputs/trivial-object-test.elf-avr | FileCheck %s --check-prefix ELF-AVR
 
 # 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:    FirstSec: .text
-# ELF-AVR-NEXT:    LastSec:  .text
-# ELF-AVR-NEXT:    Align:    0x2
-# 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: Sections:
+# ELF-AVR-NEXT: Sections:
+# ELF-AVR-NEXT:   - Type:            ProgramHeaderTable
+# ELF-AVR-NEXT:     Segments:
+# 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:       - 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:   - 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
 # ELF-AVR-NEXT:     Flags:           [ SHF_WRITE, SHF_ALLOC ]

llvm/test/tools/llvm-elfabi/binary-read-add-soname.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-elfabi --elf %t --emit-tbe=- --soname=best.so | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_AARCH64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x0000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x0008
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000
     Content:         "00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000000008
     Link:            .dynstr
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_STRSZ
         Value:           0x0000000000000001
       - Tag:             DT_STRTAB
         Value:           0x0000000000000000
       - Tag:             DT_SYMTAB
         Value:           0x0000000000000000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x0000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type: PT_DYNAMIC
-    Flags: [ PF_X, PF_R ]
-    VAddr: 0x0008
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # CHECK:      --- !tapi-tbe
 # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: SoName: best.so{{$}}
 # CHECK-NEXT: Arch: AArch64
 # CHECK-NEXT: Symbols: {}
 # CHECK-NEXT: ...

llvm/test/tools/llvm-elfabi/binary-read-arch.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x0000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x0008
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000
     Content:         "00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000000008
     Link:            .dynstr
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_STRSZ
         Value:           0x0000000000000001
       - Tag:             DT_STRTAB
         Value:           0x0000000000000000
       - Tag:             DT_SYMTAB
         Value:           0x0000000000000000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x0000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x0008
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # CHECK:      --- !tapi-tbe
 # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: Arch: x86_64
 # CHECK-NEXT: Symbols: {}
 # CHECK-NEXT: ...

llvm/test/tools/llvm-elfabi/binary-read-bad-soname.test

 # RUN: yaml2obj %s -o %t
 # RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x0000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x0008
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000
     Content:         "00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000000008
     Link:            .dynstr
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_SONAME
         Value:           0x000000000000000D
       - Tag:             DT_STRSZ
         Value:           0x0000000000000001
       - Tag:             DT_STRTAB
         Value:           0x0000000000000000
       - Tag:             DT_SYMTAB
         Value:           0x0000000000000000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x0000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x0008
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # CHECK: DT_SONAME string offset (0x000000000000000d) outside of dynamic string table

llvm/test/tools/llvm-elfabi/binary-read-bad-vaddr.test

 # RUN: yaml2obj %s -o %t
 # RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x1008
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x1000
     Content:         "00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000001008
     Link:            .dynstr
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_SONAME
         Value:           0x0000000000000000
       - Tag:             DT_STRSZ
         Value:           0x0000000000000001
       - Tag:             DT_STRTAB
         Value:           0x0000000000000260 # Bad vaddr (no PT_LOAD for 0x0000 to 0x0FFF)
       - Tag:             DT_SYMTAB
         Value:           0x0000000000001000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x1008
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # CHECK: virtual address is not in any segment: 0x260 when locating .dynstr section contents

llvm/test/tools/llvm-elfabi/binary-read-neededlibs-bad-offset.test

 # RUN: yaml2obj %s -o %t
 # RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:  PT_DYNAMIC
+        Flags: [ PF_X, PF_R ]
+        VAddr: 0x1024
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x1000
     #                "\0libfoo.so\0libbar.so\0somelib.so\0foo\0"
     Content:         "006c6962666f6f2e736f006c69626261722e736f00736f6d656c69622e736f00666f6f00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
Entries:
       - Tag:             DT_STRSZ
         Value:           0x0000000000000024
       - Tag:             DT_STRTAB
         Value:           0x0000000000001000
       - Tag:             DT_SYMTAB
         Value:           0x0000000000001000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:  PT_DYNAMIC
-    Flags: [ PF_X, PF_R ]
-    VAddr: 0x1024
 
 # CHECK: DT_NEEDED string offset (0x000000000000ffff) outside of dynamic string table

llvm/test/tools/llvm-elfabi/binary-read-neededlibs.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:  PT_DYNAMIC
+        Flags: [ PF_X, PF_R ]
+        VAddr: 0x1024
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x1000
     #                "\0libfoo.so\0libbar.so\0somelib.so\0foo\0"
     Content:         "006c6962666f6f2e736f006c69626261722e736f00736f6d656c69622e736f00666f6f00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
Entries:
       - Tag:             DT_STRSZ
         Value:           0x0000000000000024
       - Tag:             DT_STRTAB
         Value:           0x0000000000001000
       - Tag:             DT_SYMTAB
         Value:           0x0000000000001000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type: PT_DYNAMIC
-    Flags: [ PF_X, PF_R ]
-    VAddr: 0x1024
 
 # CHECK:      NeededLibs:
 # CHECK-NEXT:   - libfoo.so{{$}}
 # CHECK-NEXT:   - libbar.so{{$}}
 # CHECK-NEXT: Symbols: {}

llvm/test/tools/llvm-elfabi/binary-read-no-dt-strsz.test

 # RUN: yaml2obj %s -o %t
 # RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x0000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x0008
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000
 #                     \0 b a z\0
     Content:         "0062617a00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000000008
     Link:            .dynstr
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_STRTAB
         Value:           0x0000000000000000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x0000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x0008
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # CHECK: Couldn't determine dynamic string table size (no DT_STRSZ entry)

llvm/test/tools/llvm-elfabi/binary-read-no-dt-strtab.test

 # RUN: yaml2obj %s -o %t
 # RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x0000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x0008
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000
     Content:         "00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000000008
     Link:            .dynstr
     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
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x0008
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # CHECK: Couldn't locate dynamic string table (no DT_STRTAB entry)

llvm/test/tools/llvm-elfabi/binary-read-replace-soname.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s --check-prefix=ORIGINAL
 # RUN: llvm-elfabi --elf %t --emit-tbe=- --soname=libbest.so | FileCheck %s --check-prefix=REPLACED
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x1018
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x1000
 #                     \0 b a z\0 s o m e l i b . s o\0 f o o\0
     Content:         "0062617a00736f6d656c69622e736f00666f6f00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000001018
     Link:            .dynstr
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_SONAME
         Value:           0x0000000000000005
       - Tag:             DT_STRSZ
         Value:           0x0000000000000014
       - Tag:             DT_STRTAB
         Value:           0x0000000000001000
       - Tag:             DT_SYMTAB
         Value:           0x0000000000001000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x1018
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # ORIGINAL: SoName: somelib.so{{$}}
 
 # REPLACED: SoName: libbest.so{{$}}

llvm/test/tools/llvm-elfabi/binary-read-soname-no-null.test

 # RUN: yaml2obj %s -o %t
 # RUN: not llvm-elfabi --elf %t --emit-tbe=%t.tbe 2>&1 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x1018
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x1000
 #                     \0 b a z\0 s o m e l i b . s o z z z
     Content:         "0062617a00736f6d656c69622e736f7a7a7a"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000001018
     Link:            .dynstr
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_SONAME
         Value:           0x0000000000000005
       - Tag:             DT_STRSZ
         Value:           0x000000000000000F
       - Tag:             DT_STRTAB
         Value:           0x0000000000001000
       - Tag:             DT_SYMTAB
         Value:           0x0000000000001000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x1018
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # CHECK: String overran bounds of string table (no null terminator) when reading DT_SONAME

llvm/test/tools/llvm-elfabi/binary-read-soname.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-elfabi --elf %t --emit-tbe=- | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        Align:    8
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x1018
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
     Address:         0x1000
 #                     \0 b a z\0 s o m e l i b . s o\0 f o o\0
     Content:         "0062617a00736f6d656c69622e736f00666f6f00"
   - Name:            .dynamic
     Type:            SHT_DYNAMIC
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000001018
     Link:            .dynstr
     AddressAlign:    0x0000000000000008
     EntSize:         0x0000000000000010
     Entries:
       - Tag:             DT_SONAME
         Value:           0x0000000000000005
       - Tag:             DT_STRSZ
         Value:           0x0000000000000014
       - Tag:             DT_STRTAB
         Value:           0x0000000000001000
       - Tag:             DT_SYMTAB
         Value:           0x0000000000001000
       - Tag:             DT_NULL
         Value:           0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    Align:    8
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x1018
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # CHECK:      --- !tapi-tbe
 # CHECK-NEXT: TbeVersion: {{[1-9]\d*\.(0|([1-9]\d*))}}
 # CHECK-NEXT: SoName: somelib.so{{$}}
 # CHECK-NEXT: Arch: x86_64
 # CHECK-NEXT: Symbols: {}
 # CHECK-NEXT: ...

llvm/test/tools/llvm-elfabi/read-elf-dynsym.test

 
 --- !ELF
 FileHeader:
   Class:      ELFCLASS64
   Data:       ELFDATA2LSB
   Type:       ET_DYN
   Machine:    EM_AARCH64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x400
+        FirstSec: .dynsym
+        LastSec:  .gnu.hash
+      - Type:     PT_DYNAMIC
+        VAddr:    0x800
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:         .text
     Type:         SHT_PROGBITS
   - Name:         .data
     Type:         SHT_PROGBITS
   - Name:         .strtab
     Type:         SHT_STRTAB
   - Name:         .shstrtab
     Type:         SHT_STRTAB
DynamicSymbols:
   - Name:    foo
     Type:    STT_FUNC
     Value:   0x100
     Binding: 1
   - Name:    bar
     Type:    STT_OBJECT
     Value:   0x200
     Binding: 1
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x400
-    FirstSec: .dynsym
-    LastSec:  .gnu.hash
-  - Type:     PT_DYNAMIC
-    VAddr:    0x800
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-gsymutil/X86/elf-dwarf.yaml

 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
   Entry:           0x00000000004003E0
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x0000000000400000
+        Align:    1024
+        FirstSec: .interp
+        LastSec:  .dynstr
   - Name:            .interp
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000400238
     AddressAlign:    0x0000000000000001
     Content:         2F6C696236342F6C642D6C696E75782D7838362D36342E736F2E3200
   - Name:            .note.ABI-tag
     Type:            SHT_NOTE
- Name:            .debug_line
     AddressAlign:    0x0000000000000001
     Content:         3800000002001F0000000101FB0E0D000101010100000001000001006D61696E2E6370700000000000000902CD0440000000000001AD590202000101
   - Name:            .debug_str
     Type:            SHT_PROGBITS
     Flags:           [ SHF_MERGE, SHF_STRINGS ]
     AddressAlign:    0x0000000000000001
     EntSize:         0x0000000000000001
     Content:         61726776002F746D70006D61696E006D61696E2E637070006172676300474E5520432B2B20342E382E3520323031353036323320285265642048617420342E382E352D333629202D6D74756E653D67656E65726963202D6D617263683D7838362D3634202D67202D4F30006368617200
-ProgramHeaders:
-  - Type: PT_LOAD
-    Flags: [ PF_X, PF_R ]
-    VAddr: 0x0000000000400000
-    Align: 1024
-    FirstSec: .interp
-    LastSec:  .dynstr
 Symbols:
   - Name:            .interp
     Type:            STT_SECTION
     Section:         .interp
     Value:           0x0000000000400238
   - Name:            .note.ABI-tag
     Type:            STT_SECTION
     Section:         .note.ABI-tag

llvm/test/tools/llvm-objcopy/ELF/Inputs/ihex-elf-pt-null.yaml

 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address:         0x0
-    AddressAlign:    0x8
-    Content:         "0001020304"
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NULL
         Flags:    [ PF_X, PF_R ]
         VAddr:    0xF00000000
         PAddr:    0x100000
         FirstSec: .text
         LastSec:  .text
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x0
+    AddressAlign:    0x8
+    Content:         "0001020304"

llvm/test/tools/llvm-objcopy/ELF/Inputs/ihex-elf-segments.yaml

 # Here we use yaml from ihex-elf-sections.yaml, but add single load
 # segment containing all exported sections. In such case we should 
 # use physical address of a section intead of virtual address. Physical
 # addresses start from 0x100000, so we create two additional 'ExtenededAddr'
 # (03) record in the beginning of IHex file with that physical address
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
   Entry:           0x100000
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0xF00000000
+        PAddr:    0x100000
+        FirstSec: .text
+        LastSec:  .bss
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x0
     AddressAlign:    0x8
     Content:         "000102030405060708090A0B0C0D0E0F1011121314"
   - Name:            .data1
     Type:            SHT_PROGBITS
- Name:            .bss
     Size:            0x1000
     AddressAlign:    0x8
   - Name:            .dummy
     Type:            SHT_PROGBITS
     Flags:           [ ]
     Address:         0x20FFF8
     Size:            65536
     AddressAlign:    0x8
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0xF00000000
-    PAddr:    0x100000
-    FirstSec: .text
-    LastSec:  .bss

llvm/test/tools/llvm-objcopy/ELF/add-symbol.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS32
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_ARM
 Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address:         0x1000
-    AddressAlign:    0x0000000000001000
-    Size:            64
-  - Name:            .data
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC ]
-    Address:         0x2000
-    AddressAlign:    0x0000000000001000
-    Size:            64
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         VAddr:    0x1000
         Align:    0x1000
         FirstSec: .text
         LastSec:  .text
       - Type:     PT_LOAD
         Flags:    [ PF_R, PF_W ]
         VAddr:    0x2000
         Align:    0x1000
         FirstSec: .data
         LastSec:  .data
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x0000000000001000
+    Size:            64
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x2000
+    AddressAlign:    0x0000000000001000
+    Size:            64
 ## TODO (grimar): llvm-objcopy seems produce a broken output without
 ## the following line, i.e. when there is no symbol table in the input.
 Symbols: []
 
 # CHECK:      0: 00000000 0 NOTYPE LOCAL DEFAULT UND
 # CHECK-NEXT: 1: 00000001 0 NOTYPE GLOBAL DEFAULT ABS abs1
 # CHECK-NEXT: 2: 00000002 0 FUNC LOCAL HIDDEN ABS abs2
 # CHECK-NEXT: 3: 00000003 0 OBJECT GLOBAL DEFAULT ABS abs3

llvm/test/tools/llvm-objcopy/ELF/adjacent-segments.test

 # This test tests that if two non-overlapping segments are right next to each
 # other no problems arise.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy %t %t2
 # RUN: llvm-readobj --program-headers %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text
+        LastSec:  .text
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text2
+        LastSec:  .text2
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x1000
     Size:            24
   - Name:            .text2
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x10
     Size:            16
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text
-    LastSec:  .text
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text2
-    LastSec:  .text2
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD (0x1)
 #CHECK-NEXT:    Offset: 0x1000
 #CHECK-NEXT:    VirtualAddress: 0x0
 #CHECK-NEXT:    PhysicalAddress: 0x0
 #CHECK-NEXT:    FileSize: 24

llvm/test/tools/llvm-objcopy/ELF/bad-build-id.test

 # RUN: yaml2obj %s -o %t
 # RUN: not llvm-objcopy --build-id-link-dir=%t-dir --build-id-link-input=.debug %t 2>&1 >/dev/null | FileCheck %s
 
 # CHECK: build ID is smaller than two bytes
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
-  - Name:            .note.gnu.build-id
-    Type:            SHT_NOTE
-    Flags:           [ SHF_ALLOC ]
-    Content:         040000000100000003000000474E55004F000000
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         Flags:    [ PF_R ]
         FirstSec: .note.gnu.build-id
         LastSec:  .note.gnu.build-id
+  - Name:            .note.gnu.build-id
+    Type:            SHT_NOTE
+    Flags:           [ SHF_ALLOC ]
+    Content:         040000000100000003000000474E55004F000000

llvm/test/tools/llvm-objcopy/ELF/basic-binary-copy.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -O binary %t %t2
 # RUN: od -t x2 -v %t2 | FileCheck %s --ignore-case
 # RUN: wc -c < %t2 | FileCheck %s --check-prefix=SIZE
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text
+        LastSec:  .text
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x0000000000001000
     Content:         "c3c3c3c3"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text
-    LastSec:  .text
 
 # CHECK: 0000000 c3c3 c3c3
 # SIZE:  4

llvm/test/tools/llvm-objcopy/ELF/binary-first-seg-offset-zero.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -R .note -O binary %t %t2
 # RUN: od -Ax -t x1 %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .note
+        LastSec:  .rodata
   - Name:            .note
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "32323232"
     Size:            32
   - Name:            .rodata
     Flags:           [ SHF_ALLOC ]
     Type:            SHT_PROGBITS
     Address:         0x1020
     Size:            4064
     Content:         "DEADBEEF"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .note
-    LastSec:  .rodata
 
 # CHECK: 000000 de ad be ef

llvm/test/tools/llvm-objcopy/ELF/binary-no-paddr.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address:         0x1000
-    AddressAlign:    0x0000000000001000
-    Content:         "c3c3c3c3"
-  - Name:            .data
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC ]
-    Address:         0x1004
-    AddressAlign:    0x0000000000000004
-    Content:         "3232"
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         VAddr:    0x1000
         PAddr:    [[PADDR]]
         FirstSec: .text
         LastSec:  .text
       - Type:     PT_LOAD
         Flags:    [ PF_R, PF_W ]
         VAddr:    0x1004
         PAddr:    [[PADDR]]
         FirstSec: .data
         LastSec:  .data
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x0000000000001000
+    Content:         "c3c3c3c3"
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1004
+    AddressAlign:    0x0000000000000004
+    Content:         "3232"
 
 # CHECK: 0000000 3232 c3c3
 # SIZE:  4

llvm/test/tools/llvm-objcopy/ELF/binary-paddr.test

 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_W ]
+        FirstSec: .text
+        LastSec:  .data
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "c3c3c3c3"
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_WRITE ]
     Address:         0x2000
     AddressAlign:    0x1000
     Content:         "3232"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_W ]
-    FirstSec: .text
-    LastSec:  .data
 
 ## The computed LMA of a section not in a PT_LOAD equals its sh_addr.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-objcopy -O binary %t2 %t2.out
 # RUN: od -A x -t x2 %t2.out | FileCheck %s --check-prefix=CHECK2 --ignore-case
 # RUN: wc -c %t2.out | FileCheck %s --check-prefix=SIZE2
 
 ## The computed LMA of .data is 0x4000. The minimum LMA of all non-empty sections is 0x1000.
 ## The content of .data will be written at 0x4000-0x1000 = 0x3000.
 # CHECK2:      000000 c3c3 c3c3 0000 0000 0000 0000 0000 0000
 # CHECK2-NEXT: 000010 0000 0000 0000 0000 0000 0000 0000 0000
 # CHECK2-NEXT: *
 # CHECK2-NEXT: 003000 3232
 # SIZE2:       12290
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_W ]
+        VAddr:    0x2000
+        ## p_vaddr is increased from 0x2000 to 0x4000.
+        PAddr:    0x4000
+        FirstSec: .data
+        LastSec:  .data
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     ## Not in a PT_LOAD. LMA = sh_addr = 0x1000.
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "c3c3c3c3"
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_WRITE ]
     ## LMA = sh_offset-p_offset+p_paddr = 0x2000-0x2000+0x4000 = 0x4000.
     Address:         0x2000
     AddressAlign:    0x1000
     Content:         "3232"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_W ]
-    VAddr:    0x2000
-    ## p_vaddr is increased from 0x2000 to 0x4000.
-    PAddr:    0x4000
-    FirstSec: .data
-    LastSec:  .data
 
 ## Check that we use sh_offset instead of sh_addr to decide where to write section contents.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-objcopy -O binary %t3 %t3.out
 # RUN: od -A x -t x2 %t3.out | FileCheck %s --check-prefix=CHECK3 --ignore-case
 # RUN: wc -c %t3.out | FileCheck %s --check-prefix=SIZE3
 
 ## The minimum LMA of all non-empty sections is 0x1000.
 ## The content of .data will be written at 0x3000-0x1000 = 0x2000.
 # CHECK3:      000000 c3c3 c3c3 0000 0000 0000 0000 0000 0000
 # CHECK3-NEXT: 000010 0000 0000 0000 0000 0000 0000 0000 0000
 # CHECK3-NEXT: *
 # CHECK3-NEXT: 002000 3232
 # SIZE3:       8194
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_W ]
+        VAddr:    0x3000
+        FirstSec: .data
+        LastSec:  .data
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     ## Not in a PT_LOAD. LMA = sh_addr = 0x1000.
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "c3c3c3c3"
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_WRITE ]
     ## sh_addr is increased from 0x2000 to 0x3000, but it is ignored.
     ## LMA = sh_offset-p_offset+p_paddr = 0x2000-0x2000+0x3000 = 0x3000.
     Address:         0x3000
     AddressAlign:    0x1000
     Content:         "3232"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_W ]
-    VAddr:    0x3000
-    FirstSec: .data
-    LastSec:  .data
 
 ## The first section (.text) is empty. Test that we skip its LMA until the first
 ## non-empty section, otherwise we would leave a large number of leading zeroes.
 # RUN: yaml2obj --docnum=4 %s -o %t4
 # RUN: llvm-objcopy -O binary %t4 %t4.out
 # RUN: od -A x -t x2 %t4.out | FileCheck %s --check-prefix=SKIPEMPTY
 
 # SKIPEMPTY:      000000 3232

llvm/test/tools/llvm-objcopy/ELF/binary-remove-all-but-one.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -R .text -R .text3 -O binary %t %t2
 # RUN: od -Ax -t x1 %t2 | FileCheck %s
 # RUN: wc -c %t2 | FileCheck %s --check-prefix=SIZE
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text3
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "c3c3c3c3"
     Size:            0x1000
   - Name:            .text2
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x2000
     AddressAlign:    0x1000
     Content:         "DEADBEEF"
     Size:            0x1000
   - Name:            .text3
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x3000
     AddressAlign:    0x1000
     Content:         "32323232"
     Size:            0x1000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text3
 
 # CHECK: 000000 de ad be ef
 
 # SIZE: 4096

llvm/test/tools/llvm-objcopy/ELF/binary-remove-end.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -R .text3 -O binary %t %t2
 # RUN: od -Ax -v -t x1 %t2 | FileCheck %s
 # RUN: wc -c %t2 | FileCheck %s --check-prefix=SIZE
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text3
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "c3c3c3c3"
     Size:            0x1000
   - Name:            .text2
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x2000
     AddressAlign:    0x1000
     Content:         "DEADBEEF"
     Size:            0x1000
   - Name:            .text3
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x3000
     AddressAlign:    0x1000
     Content:         "32323232"
     Size:            0x1000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text3
 
 # CHECK: 000000 c3 c3 c3 c3
 # CHECK: 001000 de ad be ef
 
 # SIZE: 8192

llvm/test/tools/llvm-objcopy/ELF/binary-remove-middle.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -R .text2 -O binary %t %t2
 # RUN: od -Ax -v -t x1 %t2 | FileCheck %s
 # RUN: wc -c %t2 | FileCheck %s --check-prefix=SIZE
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text3
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "c3c3c3c3"
     Size:            0x1000
   - Name:            .text2
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x2000
     AddressAlign:    0x1000
     Content:         "DEADBEEF"
     Size:            0x1000
   - Name:            .text3
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x3000
     AddressAlign:    0x1000
     Content:         "32323232"
     Size:            0x1000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text3
 
 # CHECK: 000000 c3 c3 c3 c3
 # CHECK: 001000 00 00 00 00
 # CHECK: 002000 32 32 32 32
 
 # SIZE: 12288

llvm/test/tools/llvm-objcopy/ELF/binary-segment-layout.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -O binary %t %t2
 # RUN: od -t x2 %t2 | FileCheck %s --ignore-case
 # RUN: wc -c < %t2 | FileCheck %s --check-prefix=SIZE
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x00
+        FirstSec: .text
+        LastSec:  .text
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x08
+        FirstSec: .data
+        LastSec:  .data
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x0000000000001000
     Address:         0x00
     Content:         "c3c3c3c3"
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x0000000000000008
     Address:         0x08
     Content:         "3232"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x00
-    FirstSec: .text
-    LastSec:  .text
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x08
-    FirstSec: .data
-    LastSec:  .data
 
 # CHECK:       0000000 c3c3 c3c3 0000 0000 3232
 # SIZE:        10

llvm/test/tools/llvm-objcopy/ELF/build-id-link-dir.test

 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
-  - Name:            .note.gnu.build-id
-    Type:            SHT_NOTE
-    Flags:           [ SHF_ALLOC ]
-    Content:         040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         Flags:    [ PF_R ]
         FirstSec: .note.gnu.build-id
         LastSec:  .note.gnu.build-id
+  - Name:            .note.gnu.build-id
+    Type:            SHT_NOTE
+    Flags:           [ SHF_ALLOC ]
+    Content:         040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B

llvm/test/tools/llvm-objcopy/ELF/check-addr-offset-align-binary.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -O binary %t %t2
 # RUN: od -t x1 %t2 | FileCheck %s --ignore-case
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address:         0x1000
-    AddressAlign:    0x0000000000001000
-    Content:         "c3c3c3c3"
-  - Name:            .data
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC ]
-    Address:         0x1008
-    AddressAlign:    0x0000000000000008
-    Content:         "3232"
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         VAddr:    0x1000
         Align:    0x1000
         FirstSec: .text
         LastSec:  .text
       - Type:     PT_LOAD
         Flags:    [ PF_R, PF_W ]
         VAddr:    0x1008
         Align:    0x1000
         FirstSec: .data
         LastSec:  .data
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x0000000000001000
+    Content:         "c3c3c3c3"
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1008
+    AddressAlign:    0x0000000000000008
+    Content:         "3232"
 
 # CHECK: 0000000 c3 c3 c3 c3 00 00 00 00 32 32

llvm/test/tools/llvm-objcopy/ELF/check-addr-offset-align.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy %t %t2
 # RUN: llvm-readobj --program-headers %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address:         0x1000
-    AddressAlign:    0x0000000000001000
-    Content:         "c3c3c3c3"
-  - Name:            .data
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC ]
-    Address:         0x1008
-    AddressAlign:    0x0000000000000008
-    Content:         "3232"
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         VAddr:    0x1000
         Align:    0x1000
         FirstSec: .text
         LastSec:  .text
       - Type:     PT_LOAD
         Flags:    [ PF_R, PF_W ]
         VAddr:    0x1008
         Align:    0x1000
         FirstSec: .data
         LastSec:  .data
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x0000000000001000
+    Content:         "c3c3c3c3"
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1008
+    AddressAlign:    0x0000000000000008
+    Content:         "3232"
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:   ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD
 #CHECK-NEXT:    Offset: 0x1000
 #CHECK-NEXT:    VirtualAddress: 0x1000
 #CHECK-NEXT:    PhysicalAddress: 0x1000
 #CHECK-NEXT:    FileSize: 4

llvm/test/tools/llvm-objcopy/ELF/copy-after-strip-sections.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
-  - Name: .text
-    Type: SHT_PROGBITS
-    Content: 'facefeed'
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         FirstSec: .text
         LastSec:  .text
+  - Name: .text
+    Type: SHT_PROGBITS
+    Content: 'facefeed'

llvm/test/tools/llvm-objcopy/ELF/dump-section.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text
+        LastSec:  .text
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x0000000000001000
     Content:         "DEADBEEF"
   - Name:            .foo
     Type:            SHT_PROGBITS
     Flags:           [ SHF_WRITE ]
     Content:         "CAFE"
   - Name:            .empty
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
   - Name:            .bar
     Type:            SHT_NOBITS
     Flags:           [ SHF_WRITE ]
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text
-    LastSec:  .text
 
 # CHECK: 0000000 de ad be ef
 
 # NON-ALLOC: 0000000 ca fe
 
 # SIZE: 4
 
 # NOBITS: error: '[[INPUT]]': cannot dump section '.bar': it has no contents
 
 # EMPTY: 0

llvm/test/tools/llvm-objcopy/ELF/empty-section.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0
+        Align:    0x100
+        FirstSec: .foo
+        LastSec:  .foo
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        Align:    0x1000
+        FirstSec: .empty
+        LastSec:  .baz
   - Name:         gap
     Type:         Fill
     Size:         0xE00
   - Name:         .foo
     Type:         SHT_PROGBITS
     Flags:        [ SHF_ALLOC ]
     AddressAlign: 0x100
     Address:      0
     Size:         0x100
   - Name:         .empty
     Type:         SHT_PROGBITS
     Flags:        [ SHF_ALLOC ]
     Address:      0x1000
   - Name:         .baz
     Type:         SHT_PROGBITS
     Flags:        [ SHF_ALLOC ]
     AddressAlign: 0x1000
     Address:      0x1000
     Size:         0x100
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0
-    Align:    0x100
-    FirstSec: .foo
-    LastSec:  .foo
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    Align:    0x1000
-    FirstSec: .empty
-    LastSec:  .baz

llvm/test/tools/llvm-objcopy/ELF/identical-segments.test

 # This test tests that if two possible parent segments have the same offset that
 # they're disambiguated based on their original index. This ensures that cycles
 # do not occur.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy %t %t2
 # RUN: llvm-readobj --program-headers %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    AddressAlign:    0x1000
-    Size:            4096
-  - Name:            .text2
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    AddressAlign:    0x1000
-    Size:            4096
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         FirstSec: .text2
         LastSec:  .text2
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         FirstSec: .text
         LastSec:  .text2
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         FirstSec: .text
         LastSec:  .text2
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x1000
+    Size:            4096
+  - Name:            .text2
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x1000
+    Size:            4096
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD (0x1)
 #CHECK-NEXT:    Offset: 0x2000
 #CHECK-NEXT:    VirtualAddress: 0x0
 #CHECK-NEXT:    PhysicalAddress: 0x0
 #CHECK-NEXT:    FileSize: 4096

llvm/test/tools/llvm-objcopy/ELF/invalid-e_phoff.test

 # RUN: not llvm-objcopy %t2.o 2>&1 | FileCheck %s --check-prefix=CASE2
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type: PT_LOAD
 
 # CASE2: error: program headers are longer than binary of size 120: e_phoff = 0x40000000, e_phnum = 1, e_phentsize = 56

llvm/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 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:
-  - Name: .foo
-    Type: SHT_PROGBITS
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         FileSize: 0x100000
         FirstSec: .foo
         LastSec:  .foo
+  - Name: .foo
+    Type: SHT_PROGBITS
 
 ## A similar case, but now the p_offset property of the program header is too large.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2.o
 # RUN: not llvm-objcopy %t2.o 2>&1 | FileCheck %s --check-prefix=ERR2
 # ERR2: error: program header with offset 0x100000 and file size 0x1 goes past the end of the file
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Offset:   0x100000
         FileSize: 1

llvm/test/tools/llvm-objcopy/ELF/marker-segment.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy %t %t2
 # RUN: llvm-readobj --program-headers %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS32
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_ARM
 Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address:         0x1000
-    AddressAlign:    0x0000000000001000
-    Content:         "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
-  - Name:            .data
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC ]
-    Address:         0x2000
-    AddressAlign:    0x0000000000001000
-    Content:         "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
-  - Name:            .xdata
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC ]
-  - Name:            .after
-    Type:            SHT_NOBITS
-    Flags:           [ SHF_ALLOC ]
-    Size:            64
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         VAddr:    0x1000
         Align:    0x1000
         FirstSec: .text
         LastSec:  .text
       - Type:     PT_LOAD
         Flags:    [ PF_R, PF_W ]
         VAddr:    0x2000
         Align:    0x1000
         FirstSec: .data
         LastSec:  .data
       - Type: PT_GNU_STACK
         Flags: [ PF_R, PF_W ]
         VAddr: 0x0000
         Align: 0x0000
       - Type:     PT_LOAD
         Flags:    [ PF_R ]
         VAddr:    0x2010
         FirstSec: .xdata
         LastSec:  .after
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x0000000000001000
+    Content:         "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x2000
+    AddressAlign:    0x0000000000001000
+    Content:         "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
+  - Name:            .xdata
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+  - Name:            .after
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_ALLOC ]
+    Size:            64
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:   ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD
 #CHECK-NEXT:    Offset: 0x1000
 #CHECK-NEXT:    VirtualAddress: 0x1000
 #CHECK-NEXT:    PhysicalAddress: 0x1000
 #CHECK-NEXT:    FileSize: 16

llvm/test/tools/llvm-objcopy/ELF/no-build-id.test

 # RUN: yaml2obj %s -o %t
 # RUN: not llvm-objcopy --build-id-link-dir=%t-dir --build-id-link-input=.debug %t 2>&1 >/dev/null | FileCheck %s -DINPUT=%t
 
 # CHECK: error: '[[INPUT]]': could not find build ID
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
-  - Name:            .note.foo
-    Type:            SHT_NOTE
-    Flags:           [ SHF_ALLOC ]
-    Content:         000000000000000000000000
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         Flags:    [ PF_R ]
         FirstSec: .note.foo
         LastSec:  .note.foo
+  - Name:            .note.foo
+    Type:            SHT_NOTE
+    Flags:           [ SHF_ALLOC ]
+    Content:         000000000000000000000000

llvm/test/tools/llvm-objcopy/ELF/only-keep-debug.test

 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_DYN
   Machine:   EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        Offset:   0
+        Align:    0x1000
+        FirstSec: .note1
+        LastSec:  .text
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_W ]
+        VAddr:    0x1480    # Ensure Offset=VAddr (mod Align) if Offset changes
+        Align:    0x1000
+        FirstSec: .tdata
+        LastSec:  .bss
+      - Type:     PT_TLS
+        Flags:    [ PF_R, PF_W ]
+        VAddr:    0x1480    # Ensure Offset=VAddr (mod Align) if Offset changes
+        FirstSec: .tdata
+        LastSec:  .tbss
+      - Type:     PT_NOTE
+        VAddr:    0x400
+        FirstSec: .note1
+        LastSec:  .note2
   - Name:         .note1
     Type:         SHT_NOTE
     Flags:        [ SHF_ALLOC ]
     Address:      0x400
     AddressAlign: 0x400
     Content:      01
   - Name:         .note2
     Type:         SHT_NOTE
Sections:
   - Name:         .debug_frame
     Type:         SHT_PROGBITS
     # AddressAlign tests the file offset assignment leaves a gap.
     AddressAlign: 0x8
     Content:      04
   - Name:         .debug_info
     Type:         SHT_PROGBITS
     Content:      05
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    Offset:   0
-    Align:    0x1000
-    FirstSec: .note1
-    LastSec:  .text
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_W ]
-    VAddr:    0x1480    # Ensure Offset=VAddr (mod Align) if Offset changes
-    Align:    0x1000
-    FirstSec: .tdata
-    LastSec:  .bss
-  - Type:     PT_TLS
-    Flags:    [ PF_R, PF_W ]
-    VAddr:    0x1480    # Ensure Offset=VAddr (mod Align) if Offset changes
-    FirstSec: .tdata
-    LastSec:  .tbss
-  - Type:     PT_NOTE
-    VAddr:    0x400
-    FirstSec: .note1
-    LastSec:  .note2
 ...
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-objcopy --only-keep-debug %t2 %t2.dbg
 # RUN: llvm-readelf -S -l %t2.dbg | FileCheck --check-prefix=CHECK2 %s
 
 ## Only the tail of a segment can be trimmed. .text still occupies space because
 ## it is followed by .note which is not SHT_NOBITS.

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
-  - Name:         .text
-    Type:         SHT_PROGBITS
-    Flags:        [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address:      0x200
-    AddressAlign: 0x200
-    Content:      c3
-  - Name:         .note
-    Type:         SHT_NOTE
-    Flags:        [ SHF_ALLOC ]
-    Address:      0x201
-    Content:      01
-  - Name:         .debug_info
-    Type:         SHT_PROGBITS
-    AddressAlign: 0x20
-    Content:      02
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_PHDR
         Flags:    [ PF_R ]
         Offset:   0x40
         VAddr:    0x40
         # 3 * sizeof(Elf64_Phdr) = 0xa8
         FileSize: 0xa8
         MemSize:  0xa8
         Align:    8
       - Type:     PT_LOAD
         Flags:    [ PF_R, PF_X ]
         Offset:   0
         Align:    4096
         FirstSec: .text
         LastSec:  .note
       - Type:     PT_LOAD
         Flags:    [ PF_R, PF_W ]
         Offset:   0x202
         VAddr:    0x202
         FileSize: 14
         MemSize:  14
+  - Name:         .text
+    Type:         SHT_PROGBITS
+    Flags:        [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:      0x200
+    AddressAlign: 0x200
+    Content:      c3
+  - Name:         .note
+    Type:         SHT_NOTE
+    Flags:        [ SHF_ALLOC ]
+    Address:      0x201
+    Content:      01
+  - Name:         .debug_info
+    Type:         SHT_PROGBITS
+    AddressAlign: 0x20
+    Content:      02
 ...
 
 ## If .symtab or .strtab has the SHF_ALLOC flag, it will be changed to SHT_NOBITS.
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-objcopy --only-keep-debug %t3 %t3.dbg
 # RUN: llvm-readelf -S -l %t3.dbg | FileCheck --check-prefix=CHECK3 %s
 
 # CHECK3:      [Nr] Name          Type     Address          Off    Size   ES Flg Lk Inf Al

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
-  - Name:         .text
-    Type:         SHT_PROGBITS
-    Flags:        [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address:      0x200
-    Size:         1
-  - Name:         .tdata
-    Type:         SHT_PROGBITS
-    Flags:        [ SHF_ALLOC, SHF_WRITE, SHF_TLS ]
-    Address:      0x1240   # Ensure Address=0x1000+Offset
-    AddressAlign: 0x40
-  - Name:         .got
-    Type:         SHT_PROGBITS
-    Flags:        [ SHF_ALLOC, SHF_WRITE ]
-    Size:         8
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_R, PF_X ]
         VAddr:    0x200
         Align:    0x1000
         FirstSec: .text
         LastSec:  .text
-  ## Add .got so that the PT_LOAD does not have zero p_memsz. We don't add
-  ## sections to zero-sized segments so zero-sized segments may have strange
-  ## offsets. In practice, the Linux kernel errors when mmapping a p_memsz
-  ## PT_LOAD,so for practical so this assumption can generally be made.
       - Type:     PT_LOAD
         Flags:    [ PF_R, PF_W ]
         VAddr:    0x1240
         Align:    0x1000
         FirstSec: .tdata
         LastSec:  .got
       - Type:     PT_TLS
         Flags:    [ PF_R ]
         VAddr:    0x1240
         FirstSec: .tdata
         LastSec:  .tdata
+  - Name:         .text
+    Type:         SHT_PROGBITS
+    Flags:        [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:      0x200
+    Size:         1
+  - Name:         .tdata
+    Type:         SHT_PROGBITS
+    Flags:        [ SHF_ALLOC, SHF_WRITE, SHF_TLS ]
+    Address:      0x1240   # Ensure Address=0x1000+Offset
+    AddressAlign: 0x40
+  - Name:         .got
+    Type:         SHT_PROGBITS
+    Flags:        [ SHF_ALLOC, SHF_WRITE ]
+    Size:         8

llvm/test/tools/llvm-objcopy/ELF/overlap-chain.test

 # This test tests how ParentSegment is set for Segments. In particular this test
 # tests that if a chain of parents forms, the offsets are chosen for parents
 # first despite the order of the list. It also tests multiple branches of the
 # code that assigns parents.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy %t %t2
 # RUN: llvm-readobj --program-headers %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text
+        LastSec:  .text2
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text4
+        LastSec:  .text5
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text3
+        LastSec:  .text4
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text2
+        LastSec:  .text3
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x1000
     Size:            4096
   - Name:            .text2
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
- Name:            .text4
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x1000
     Size:            4096
   - Name:            .text5
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x1000
     Size:            4096
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text
-    LastSec:  .text2
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text4
-    LastSec:  .text5
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text3
-    LastSec:  .text4
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text2
-    LastSec:  .text3
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD (0x1)
 #CHECK-NEXT:    Offset: 0x1000
 #CHECK-NEXT:    VirtualAddress: 0x0
 #CHECK-NEXT:    PhysicalAddress: 0x0
 #CHECK-NEXT:    FileSize: 8192

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

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FileSize: 5
+        Offset:   0x1000
+        Align:    0x1000
   - Name: .first
     Type: SHT_PROGBITS
     Content: '01234567'
     AddressAlign: 0x1000
   - Name: .second
     Type: SHT_PROGBITS
     Content: '89abcdef'
     ShOffset: 0x1001
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FileSize: 5
-    Offset:   0x1000
-    Align:    0x1000

llvm/test/tools/llvm-objcopy/ELF/parent-loop-check.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .note
+        LastSec:  .rodata
+      - Type:     PT_NOTE
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .note
+        LastSec:  .note
   - Name:            .note
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "32323232"
     Size:            32
   - Name:            .rodata
     Flags:           [ SHF_ALLOC ]
     Type:            SHT_PROGBITS
     Address:         0x1020
     Size:            4064
     Content:         "DEADBEEF"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .note
-    LastSec:  .rodata
-  - Type:     PT_NOTE
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .note
-    LastSec:  .note
 
 # CHECK: 000000 de ad be ef

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

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
-  - Name: .remove_me
-    Type: SHT_PROGBITS
-    Size: 0x10
-  - Name: .keep_me
-    Type: SHT_PROGBITS
-    Size: 0x10
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Offset:   0
         FileSize: 176 # sizeof(Elf64_Ehdr) + 2 * sizeof(Elf64_Phdr)
       - Type:     PT_LOAD
         FirstSec: .keep_me
         LastSec:  .keep_me
+  - Name: .remove_me
+    Type: SHT_PROGBITS
+    Size: 0x10
+  - Name: .keep_me
+    Type: SHT_PROGBITS
+    Size: 0x10
 Symbols: []

llvm/test/tools/llvm-objcopy/ELF/preserve-segment-contents.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+## First segment has unlabelled space at start and end.
+      - Type:     0x6ABCDEF0 # Non-specific segment type.
+        VAddr:    0x2000
+        Align:    0x2000
+        FirstSec: blob1
+        LastSec:  blob4
+## Second segment has sections at start and end.
+      - Type:     0x6ABCDEF0
+        VAddr:    0x2100
+        Align:    0x100
+        FirstSec: section4
+        LastSec:  section5
+## Third segment is all covered by a section.
+      - Type:     0x6ABCDEF0
+        VAddr:    0x2200
+        Align:    0x100
+        FirstSec: section6
+        LastSec:  section6
+## Fourth segment has no sections (after removing blob headers).
+      - Type:     0x6ABCDEF0
+        VAddr:    0x2300
+        Align:    0x100
+        FirstSec: blob6
+        LastSec:  blob6
+## Fifth segment is empty.
+      - Type:   0x6ABCDEF0
+        VAddr:  0x2308
+        Offset: 0x2308
+## The next few segments test behaviour of fully nested segments.
+## Sixth segment is the "parent" segment.
+      - Type:     0x6ABCDEF0
+        VAddr:    0x3000
+        Align:    0x1000
+        FirstSec: sectionA
+        LastSec:  sectionI
+## Seventh segment is empty and nested.
+      - Type:   0x6ABCDEF0
+        VAddr:  0x3002
+        Offset: 0x3002
+## Eighth segment contains only a section and is nested.
+      - Type:     0x6ABCDEF0
+        VAddr:    0x3004
+        FirstSec: sectionB
+        LastSec:  sectionB
+## Ninth segment contains only unlabelled space and is nested.
+      - Type:     0x6ABCDEF0
+        VAddr:    0x3008
+        FirstSec: blobA
+        LastSec:  blobA
+## Tenth segment contains two sections with space between and is nested.
+      - Type:     0x6ABCDEF0
+        VAddr:    0x300C
+        FirstSec: sectionC
+        LastSec:  sectionD
+## Eleventh segment contains two sections with space between and at ends and is nested.
+      - Type:     0x6ABCDEF0
+        VAddr:    0x3018
+        FirstSec: blobC
+        LastSec:  blobE
+## Twelfth segment contains one section with space at ends adjacent to space in parent segment.
+      - Type:     0x6ABCDEF0
+        VAddr:    0x302E
+        Offset:   0x302E
+        FileSize: 8
+        FirstSec: sectionG
+        LastSec:  sectionG
+## Thirteenth segment contains overlaps sections at either end in parent segment.
+      - Type:     0x6ABCDEF0
+        VAddr:    0x303A
+        Offset:   0x303A
+        FileSize: 0x8
+        FirstSec: blobH
+        LastSec:  blobH
+
+## The next batch of segments are segments that only partially overlap other segments.
+
+## Segment14: |-unlabelled-|-Sec-|
+## Segment15:           |--|-Sec-|-unlabelled-|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x4000
+        FirstSec: blobz
+        LastSec:  sectionz
+      - Type:     0x6ABCDEF0
+        VAddr:    0x4002
+        Offset:   0x4002
+        FirstSec: sectionz
+        LastSec:  bloby
+
+## Segment16: |-Sec-|--|
+## Segment17:    |--|----unlabelled---|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x400C
+        FileSize: 6
+        FirstSec: sectiony
+        LastSec:  sectiony
+      - Type:     0x6ABCDEF0
+        VAddr:    0x400E
+        Offset:   0x400E
+        FirstSec: blobx
+        LastSec:  blobx
+
+## Segment18: |-unlabelled-|-Sec-|
+## Segment19:              |-Sec-|-unlabelled-|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x4014
+        FirstSec: blobw
+        LastSec:  sectionx
+      - Type:     0x6ABCDEF0
+        VAddr:    0x4018
+        FirstSec: sectionx
+        LastSec:  blobv
+
+## Segment20: |-Sec-|
+## Segment21:    |--|-unlabelled-|-Sec-|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x4020
+        FirstSec: sectionw
+        LastSec:  sectionw
+
+      - Type:   0x6ABCDEF0
+        VAddr:  0x4022
+        Offset: 0x4022
+        FirstSec: blobu
+        LastSec:  sectionv
+
+## Segment22: |-Sec-|
+## Segment23:    |--|-Sec-|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x402C
+        FirstSec: sectionu
+        LastSec:  sectionu
+      - Type:     0x6ABCDEF0
+        VAddr:    0x402E
+        Offset:   0x402E
+        FirstSec: sectiont
+        LastSec:  sectiont
+
+## Segment24: |-unlabelled-|--|
+## Segment25:              |--Sec--|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x4034
+        FileSize: 6
+        FirstSec: blobt
+        LastSec:  blobt
+      - Type:     0x6ABCDEF0
+        VAddr:    0x4038
+        FirstSec: sections
+        LastSec:  sections
+
+## The next batch of segments represent groups of three nested/overlapping segments,
+## with one parent segment containing two overlapping segments.
+
+## Segment26: |-unlabelled-|-Sec-|-unlabelled-|
+## Segment27: |------------|--|
+## Segment28:              |-Sec-|------------|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5000
+        Align:    0x1000
+        FirstSec: bloba
+        LastSec:  blobb
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5000
+        FileSize: 6
+        FirstSec: bloba
+        LastSec:  bloba
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5004
+        FirstSec: sectiona
+        LastSec:  blobb
+
+## Segment29: |-Sec-|-unlabelled-|-Sec-|
+## Segment30: |-Sec-|--------|
+## Segment31:          |---------|-Sec-|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x500C
+        FirstSec: sectionb
+        LastSec:  sectionc
+      - Type:     0x6ABCDEF0
+        VAddr:    0x500C
+        FileSize: 7
+        FirstSec: sectionb
+        LastSec:  sectionb
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5011
+        Offset:   0x5011
+        FirstSec: sectionc
+        LastSec:  sectionc
+
+## Segment32: |-Sec-|-unlabelled-|-Sec-|
+## Segment33: |-Sec-|------------|
+## Segment34:       |------------|-Sec-|
+      - Type:    0x6ABCDEF0
+        VAddr:   0x5018
+        FirstSec: sectiond
+        LastSec:  sectione
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5018
+        FirstSec: sectiond
+        LastSec:  blobd
+      - Type:     0x6ABCDEF0
+        VAddr:    0x501C
+        FirstSec: blobd
+        LastSec:  sectione
+
+## Segment35: |-unlabelled-|-Sec-|-unlabelled-|
+## Segment36: |------------|-Sec-|
+## Segment37:              |-Sec-|------------|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5024
+        FirstSec: blobe
+        LastSec:  blobf
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5024
+        FirstSec: blobe
+        LastSec:  sectionf
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5028
+        FirstSec: sectionf
+        LastSec:  blobf
+
+## Segment38: |-unlabelled-|-Sec-|-unlabelled-|
+## Segment39: |------------|---|
+## Segment40:                |---|------------|
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5030
+        FirstSec: blobg
+        LastSec:  blobh
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5030
+        FileSize: 7
+        FirstSec: blobg
+        LastSec:  blobg
+      - Type:     0x6ABCDEF0
+        VAddr:    0x5035
+        Offset:   0x5035
+        FirstSec: blobh
+        LastSec:  blobh
   - Name: blob1
     Type: SHT_PROGBITS
     Content: 'abbababa'
     Address: 0x2000
     AddressAlign: 0x2000
   - Name: section1
     Type: SHT_PROGBITS
     Address: 0x2004
## Segment40:                |---|------------|
   - Name: sectiong
     Type: SHT_PROGBITS
     Content: '44444444'
     Address: 0x5034
   - Name: blobh
     Type: SHT_PROGBITS
     Content: 'abbababa'
     Address: 0x5038
-ProgramHeaders:
-  # First segment has unlabelled space at start and end.
-  - Type:     0x6ABCDEF0 # Non-specific segment type.
-    VAddr:    0x2000
-    Align:    0x2000
-    FirstSec: blob1
-    LastSec:  blob4
-  # Second segment has sections at start and end.
-  - Type:     0x6ABCDEF0
-    VAddr:    0x2100
-    Align:    0x100
-    FirstSec: section4
-    LastSec:  section5
-  # Third segment is all covered by a section.
-  - Type:     0x6ABCDEF0
-    VAddr:    0x2200
-    Align:    0x100
-    FirstSec: section6
-    LastSec:  section6
-  # Fourth segment has no sections (after removing blob headers).
-  - Type:     0x6ABCDEF0
-    VAddr:    0x2300
-    Align:    0x100
-    FirstSec: blob6
-    LastSec:  blob6
-  # Fifth segment is empty.
-  - Type:   0x6ABCDEF0
-    VAddr:  0x2308
-    Offset: 0x2308
-  # The next few segments test behaviour of fully nested segments.
-  # Sixth segment is the "parent" segment.
-  - Type:     0x6ABCDEF0
-    VAddr:    0x3000
-    Align:    0x1000
-    FirstSec: sectionA
-    LastSec:  sectionI
-  # Seventh segment is empty and nested.
-  - Type:   0x6ABCDEF0
-    VAddr:  0x3002
-    Offset: 0x3002
-  # Eighth segment contains only a section and is nested.
-  - Type:     0x6ABCDEF0
-    VAddr:    0x3004
-    FirstSec: sectionB
-    LastSec:  sectionB
-  # Ninth segment contains only unlabelled space and is nested.
-  - Type:     0x6ABCDEF0
-    VAddr:    0x3008
-    FirstSec: blobA
-    LastSec:  blobA
-  # Tenth segment contains two sections with space between and is nested.
-  - Type:     0x6ABCDEF0
-    VAddr:    0x300C
-    FirstSec: sectionC
-    LastSec:  sectionD
-  # Eleventh segment contains two sections with space between and at ends and is nested.
-  - Type:     0x6ABCDEF0
-    VAddr:    0x3018
-    FirstSec: blobC
-    LastSec:  blobE
-  # Twelfth segment contains one section with space at ends adjacent to space in parent segment.
-  - Type:     0x6ABCDEF0
-    VAddr:    0x302E
-    Offset:   0x302E
-    FileSize: 8
-    FirstSec: sectionG
-    LastSec:  sectionG
-  # Thirteenth segment contains overlaps sections at either end in parent segment.
-  - Type:     0x6ABCDEF0
-    VAddr:    0x303A
-    Offset:   0x303A
-    FileSize: 0x8
-    FirstSec: blobH
-    LastSec:  blobH
-
-  # The next batch of segments are segments that only partially overlap other segments.
-
-  # Segment14: |-unlabelled-|-Sec-|
-  # Segment15:           |--|-Sec-|-unlabelled-|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x4000
-    FirstSec: blobz
-    LastSec:  sectionz
-  - Type:     0x6ABCDEF0
-    VAddr:    0x4002
-    Offset:   0x4002
-    FirstSec: sectionz
-    LastSec:  bloby
-
-  # Segment16: |-Sec-|--|
-  # Segment17:    |--|----unlabelled---|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x400C
-    FileSize: 6
-    FirstSec: sectiony
-    LastSec:  sectiony
-  - Type:     0x6ABCDEF0
-    VAddr:    0x400E
-    Offset:   0x400E
-    FirstSec: blobx
-    LastSec:  blobx
-
-  # Segment18: |-unlabelled-|-Sec-|
-  # Segment19:              |-Sec-|-unlabelled-|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x4014
-    FirstSec: blobw
-    LastSec:  sectionx
-  - Type:     0x6ABCDEF0
-    VAddr:    0x4018
-    FirstSec: sectionx
-    LastSec:  blobv
-
-  # Segment20: |-Sec-|
-  # Segment21:    |--|-unlabelled-|-Sec-|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x4020
-    FirstSec: sectionw
-    LastSec:  sectionw
-
-  - Type:   0x6ABCDEF0
-    VAddr:  0x4022
-    Offset: 0x4022
-    FirstSec: blobu
-    LastSec:  sectionv
-
-  # Segment22: |-Sec-|
-  # Segment23:    |--|-Sec-|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x402C
-    FirstSec: sectionu
-    LastSec:  sectionu
-  - Type:     0x6ABCDEF0
-    VAddr:    0x402E
-    Offset:   0x402E
-    FirstSec: sectiont
-    LastSec:  sectiont
-
-  # Segment24: |-unlabelled-|--|
-  # Segment25:              |--Sec--|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x4034
-    FileSize: 6
-    FirstSec: blobt
-    LastSec:  blobt
-  - Type:     0x6ABCDEF0
-    VAddr:    0x4038
-    FirstSec: sections
-    LastSec:  sections
-
-  # The next batch of segments represent groups of three nested/overlapping segments,
-  # with one parent segment containing two overlapping segments.
-
-  # Segment26: |-unlabelled-|-Sec-|-unlabelled-|
-  # Segment27: |------------|--|
-  # Segment28:              |-Sec-|------------|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5000
-    Align:    0x1000
-    FirstSec: bloba
-    LastSec:  blobb
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5000
-    FileSize: 6
-    FirstSec: bloba
-    LastSec:  bloba
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5004
-    FirstSec: sectiona
-    LastSec:  blobb
-
-  # Segment29: |-Sec-|-unlabelled-|-Sec-|
-  # Segment30: |-Sec-|--------|
-  # Segment31:          |---------|-Sec-|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x500C
-    FirstSec: sectionb
-    LastSec:  sectionc
-  - Type:     0x6ABCDEF0
-    VAddr:    0x500C
-    FileSize: 7
-    FirstSec: sectionb
-    LastSec:  sectionb
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5011
-    Offset:   0x5011
-    FirstSec: sectionc
-    LastSec:  sectionc
-
-  # Segment32: |-Sec-|-unlabelled-|-Sec-|
-  # Segment33: |-Sec-|------------|
-  # Segment34:       |------------|-Sec-|
-  - Type:    0x6ABCDEF0
-    VAddr:   0x5018
-    FirstSec: sectiond
-    LastSec:  sectione
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5018
-    FirstSec: sectiond
-    LastSec:  blobd
-  - Type:     0x6ABCDEF0
-    VAddr:    0x501C
-    FirstSec: blobd
-    LastSec:  sectione
-
-  # Segment35: |-unlabelled-|-Sec-|-unlabelled-|
-  # Segment36: |------------|-Sec-|
-  # Segment37:              |-Sec-|------------|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5024
-    FirstSec: blobe
-    LastSec:  blobf
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5024
-    FirstSec: blobe
-    LastSec:  sectionf
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5028
-    FirstSec: sectionf
-    LastSec:  blobf
-
-  # Segment38: |-unlabelled-|-Sec-|-unlabelled-|
-  # Segment39: |------------|---|
-  # Segment40:                |---|------------|
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5030
-    FirstSec: blobg
-    LastSec:  blobh
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5030
-    FileSize: 7
-    FirstSec: blobg
-    LastSec:  blobg
-  - Type:     0x6ABCDEF0
-    VAddr:    0x5035
-    Offset:   0x5035
-    FirstSec: blobh
-    LastSec:  blobh

llvm/test/tools/llvm-objcopy/ELF/program-headers.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy %t %t2
 # RUN: llvm-readobj --program-headers %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - 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
+        LastSec:  .data
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0xAAAA1000
     AddressAlign:    0x0000000000001000
     Content:         "00000000"
   - Name:            .init
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Content:         "00000000"
     Address:         0xAAAA1010
     AddressAlign:    0x0000000000000010
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Content:         "00000000"
     Address:         0xAAAA2000
     AddressAlign:    0x0000000000001000
-ProgramHeaders:
-  - 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
-    LastSec:  .data
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:   ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD
 #CHECK-NEXT:    Offset: 0x1000
 #CHECK-NEXT:    VirtualAddress: 0xAAAA1000
 #CHECK-NEXT:    PhysicalAddress: 0xFFFF1000
 #CHECK-NEXT:    FileSize: 20

llvm/test/tools/llvm-objcopy/ELF/remove-section-in-segment.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+## Use an arbitrary segment type to show that the segment type is unimportant.
+      - Type: 0x61234567
+        FirstSec: shf_alloc
+        LastSec:  non_alloc
   - Name:    shf_alloc
     Type:    SHT_PROGBITS
     Flags:   [SHF_ALLOC]
     Content: '11223344'
   - Name:    non_alloc
     Type:    SHT_PROGBITS
     Flags:   []
     Content: '55667788'
-ProgramHeaders:
-  # Use an arbitrary segment type to show that the segment type is unimportant.
-  - Type: 0x61234567
-    FirstSec: shf_alloc
-    LastSec:  non_alloc

llvm/test/tools/llvm-objcopy/ELF/segment-shift-section-remove.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -R .text2 %t %t2
 # RUN: llvm-readobj --file-headers --sections --program-headers %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x3000
+        FirstSec: .text3
+        LastSec:  .text3
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Size:            0x1000
   - Name:            .text2
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x2000
     AddressAlign:    0x1000
     Size:            0x1000
   - Name:            .text3
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x3000
     AddressAlign:    0x1000
     Size:            0x1000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x3000
-    FirstSec: .text3
-    LastSec:  .text3
 ## TODO (grimar): without the following line (i.e. without an empty symbol table),
 ## llvm-objcopy adds an empty .strtab section. It doesn't look correct.
 Symbols: []
 
 #CHECK: SectionHeaderCount: 4
 
 # CHECK:           Sections [
 # CHECK-NEXT:        Section {

llvm/test/tools/llvm-objcopy/ELF/segment-shift.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy %t %t2
 # RUN: llvm-readobj --program-headers %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x3000
+        FirstSec: .text3
+        LastSec:  .text3
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Size:            0x1000
   - Name:            .text2
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x2000
     AddressAlign:    0x1000
     Size:            0x1000
   - Name:            .text3
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x3000
     AddressAlign:    0x1000
     Size:            0x1000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x3000
-    FirstSec: .text3
-    LastSec:  .text3
 
 # CHECK:     ProgramHeaders [
 # CHECK-NEXT:  ProgramHeader {
 # CHECK-NEXT:    Type: PT_LOAD (0x1)
 # CHECK-NEXT:    Offset: 0x1000
 # CHECK-NEXT:    VirtualAddress: 0x1000
 # CHECK-NEXT:    PhysicalAddress: 0x1000
 # CHECK-NEXT:    FileSize: 4096

llvm/test/tools/llvm-objcopy/ELF/segment-test-remove-section.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text
+        LastSec:  .text3
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Size:            4096
   - Name:            .text2
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x2000
     AddressAlign:    0x1000
     Size:            4096
     Content:         "DEADBEEF"
   - Name:            .text3
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x3000
     AddressAlign:    0x1000
     Size:            4096
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text
-    LastSec:  .text3
 ## TODO (grimar): without the following line (i.e. without an empty symbol table),
 ## llvm-objcopy adds an empty .strtab section. It doesn't look correct.
 Symbols: []
 
 # Make sure that when we remove a section we overwrite it with zeros
 # DATA: {{^[^[:blank:]]+}} 00 00 00 00
 
 #CHECK: SectionHeaderCount: 4

llvm/test/tools/llvm-objcopy/ELF/strip-all-gnu.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+## Use an arbitrary segment type to show that the segment type is unimportant.
+      - Type:     0x61234567
+        FirstSec: .debug_in_segment
+        LastSec:  .debug_in_segment
   - Name:            .debug_in_segment
     Type:            SHT_PROGBITS
     Flags:           [ ]
     Content:         "deadbeef"
   - Name:            .dynstr
     Type:            SHT_STRTAB
     Flags:           [ SHF_ALLOC ]
   - Name:            .symtab.dyn
## Use an arbitrary segment type to show that the segment type is unimportant.
   - Name:            .debug_not_a_real_debug_section
     Type:            SHT_PROGBITS
   - Name:            .rel.text
     Type:            SHT_REL
     Info:            .text
   - Name:            .rela.text
     Type:            SHT_RELA
     Info:            .text
-ProgramHeaders:
-  # Use an arbitrary segment type to show that the segment type is unimportant.
-  - Type:     0x61234567
-    FirstSec: .debug_in_segment
-    LastSec:  .debug_in_segment
 
 # CHECK: SectionHeaderCount: 8
 
 # CHECK:      Name: .dynstr
 # CHECK:      Name: .symtab.dyn
 # CHECK:      Name: .text
 # CHECK:      Name: .debug_loc
 # CHECK:      Name: .comment
 # CHECK:      Name: .random_section_name
 # CHECK:      Name: .shstrtab
 
 # COPY-BYTES:  de ad be ef
 # STRIP-BYTES: 00 00 00 00

llvm/test/tools/llvm-objcopy/ELF/strip-all.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+## Use an arbitrary segment type to show that the segment type is unimportant.
+      - Type:     0x61234567
+        FirstSec: non_alloc_in_segment
+        LastSec:  non_alloc_in_segment
   - Name:            non_alloc_in_segment
     Type:            SHT_PROGBITS
     Flags:           [ ]
     Size:            4
   - Name:            .bss
     Type:            SHT_NOBITS
     Flags:           [ SHF_ALLOC ]
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
   - Name:            .blarg
     Type:            SHT_PROGBITS
     Flags:           [ ]
   - Name:            .gnu.warning.foo
     Type:            SHT_PROGBITS
-ProgramHeaders:
-  # Use an arbitrary segment type to show that the segment type is unimportant.
-  - Type:     0x61234567
-    FirstSec: non_alloc_in_segment
-    LastSec:  non_alloc_in_segment
 
 # CHECK: SectionHeaderCount: 6
 
 # CHECK: Name: non_alloc_in_segment
 # CHECK: Name: .bss
 # CHECK: Name: .text
 # CHECK: Name: .gnu.warning.foo
 # CHECK: Name: .shstrtab

llvm/test/tools/llvm-objcopy/ELF/strip-non-alloc.test

 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+## Use an arbitrary segment type to show that the segment type is unimportant.
+      - Type:     0x61234567
+        FirstSec: non_alloc_in_segment
+        LastSec:  non_alloc_in_segment
   - Name:            non_alloc_in_segment
     Type:            SHT_PROGBITS
     Flags:           [ ]
     Size:            4
   - Name:            .bss
     Type:            SHT_NOBITS
     Flags:           [ SHF_ALLOC ]
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-ProgramHeaders:
-  # Use an arbitrary segment type to show that the segment type is unimportant.
-  - Type:     0x61234567
-    FirstSec: non_alloc_in_segment
-    LastSec:  non_alloc_in_segment
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-objcopy --strip-non-alloc %t2 %t2.out
 # RUN: llvm-readobj --file-headers --sections %t2.out | FileCheck --check-prefix=CHECK2 %s
 
 # CHECK2: SectionHeaderCount: 3
 # CHECK2: Name: .text
 # CHECK2: Name: .shstrtab
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     0x61234567
+        FirstSec: .text
+        LastSec:  .text
   - Name:    .text
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
 ## empty_trailing_non_alloc is considered included by the segment,
 ## so it will be retained.
   - Name:    empty_trailing_non_alloc
     Type:    SHT_PROGBITS
   - Name:    trailing_non_alloc
     Type:    SHT_PROGBITS
     Content: 00
-ProgramHeaders:
-  - Type:     0x61234567
-    FirstSec: .text
-    LastSec:  .text

llvm/test/tools/llvm-objcopy/ELF/strip-sections.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text
+        LastSec:  .non_alloc_in_segment
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x0000000000001000
     Content:         "DEADBEEF"
   - Name:            .non_alloc_in_segment
     Type:            SHT_PROGBITS
     Flags:           [ ]
     Content:         "CAFEBABE"
   - Name:            .non_alloc_not_in_segment
     Type:            SHT_PROGBITS
     Flags:           [ ]
     Content:         "FEEDFACE"
-ProgramHeaders:
-- Type:     PT_LOAD
-  Flags:    [ PF_X, PF_R ]
-  FirstSec: .text
-  LastSec:  .non_alloc_in_segment
 
 # DATA: {{^[^[:blank:]]+}} de ad be ef ca fe ba be
 # DATA-NOT: fe ed fa ce
 
 # VALIDATE: {{^[^[:blank:]]+}} de ad be ef ca fe ba be fe ed fa ce
 
 # CHECK:      ElfHeader {
 # CHECK-NEXT:   Ident {

llvm/test/tools/llvm-objcopy/ELF/triple-overlap.test

 # This test tests that each segment is assigned a canonical parent segment.
 # Importantly if two segments could be the parent segment of a segment this test
 # should cover the case where a new parent replaces the old parent and the case
 # where an old parent is not replaced by a new parent.
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy %t %t2
 # RUN: llvm-readobj --program-headers %t2 | FileCheck %s
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text4
+        LastSec:  .text5
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text3
+        LastSec:  .text5
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text
+        LastSec:  .text5
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        FirstSec: .text2
+        LastSec:  .text5
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x1000
     Size:            4096
   - Name:            .text2
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
- Name:            .text4
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x1000
     Size:            4096
   - Name:            .text5
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     AddressAlign:    0x1000
     Size:            4096
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text4
-    LastSec:  .text5
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text3
-    LastSec:  .text5
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text
-    LastSec:  .text5
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    FirstSec: .text2
-    LastSec:  .text5
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:  ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD (0x1)
 #CHECK-NEXT:    Offset: 0x4000
 #CHECK-NEXT:    VirtualAddress: 0x0
 #CHECK-NEXT:    PhysicalAddress: 0x0
 #CHECK-NEXT:    FileSize: 8192

llvm/test/tools/llvm-objcopy/ELF/two-seg-remove-end.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -R .text4 -O binary %t %t2
 # RUN: od -Ax -v -t x1 %t2 | FileCheck %s
 # RUN: wc -c %t2 | FileCheck %s --check-prefix=SIZE
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text2
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x3000
+        FirstSec: .text3
+        LastSec:  .text4
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "c3c3c3c3"
     Size:            0x1000
   - Name:            .text2
- Name:            .text3
     Size:            0x1000
   - Name:            .text4
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x4000
     AddressAlign:    0x1000
     Content:         "FFFFFFFF"
     Size:            0x1000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text2
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x3000
-    FirstSec: .text3
-    LastSec:  .text4
 
 # CHECK: 000000 c3 c3 c3 c3
 # CHECK: 001000 de ad be ef
 # CHECK: 002000 32 32 32 32
 
 # SIZE: 12288

llvm/test/tools/llvm-objcopy/ELF/two-seg-remove-first.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -R .text -O binary %t %t2
 # RUN: od -Ax -v -t x1 %t2 | FileCheck %s
 # RUN: wc -c %t2 | FileCheck %s --check-prefix=SIZE
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text2
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x3000
+        FirstSec: .text3
+        LastSec:  .text4
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "c3c3c3c3"
     Size:            0x1000
   - Name:            .text2
- Name:            .text3
     Size:            0x1000
   - Name:            .text4
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x4000
     AddressAlign:    0x1000
     Content:         "FFFFFFFF"
     Size:            0x1000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text2
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x3000
-    FirstSec: .text3
-    LastSec:  .text4
 
 # CHECK: 000000 de ad be ef
 # CHECK: 001000 32 32 32 32
 # CHECK: 002000 ff ff ff ff
 
 # SIZE: 12288

llvm/test/tools/llvm-objcopy/ELF/two-seg-remove-third-sec.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objcopy -R .text3 -O binary %t %t2
 # RUN: od -Ax -v -t x1 %t2 | FileCheck %s
 # RUN: wc -c %t2 | FileCheck %s --check-prefix=SIZE
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text2
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x3000
+        FirstSec: .text3
+        LastSec:  .text4
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x1000
     Content:         "c3c3c3c3"
     Size:            0x1000
   - Name:            .text2
- Name:            .text3
     Size:            0x1000
   - Name:            .text4
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x4000
     AddressAlign:    0x1000
     Content:         "FFFFFFFF"
     Size:            0x1000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text2
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x3000
-    FirstSec: .text3
-    LastSec:  .text4
 
 # CHECK: 000000 c3 c3 c3 c3
 # CHECK: 001000 de ad be ef
 # CHECK: 002000 00 00 00 00
 # CHECK: 003000 ff ff ff ff
 
 # SIZE: 16384

llvm/test/tools/llvm-objdump/ELF/dynamic-section-machine-specific.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_HEXAGON
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_HEXAGON_SYMSZ
         Value: 0x10
       - Tag:   DT_HEXAGON_VER
         Value: 0x1000
       - Tag:   DT_HEXAGON_PLT
         Value: 0x1000
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 2: Test that MIPS machine-specific tags can be dumped.
 ##         MIPS has a few long tag names. Show that we indent columns properly.
 # RUN: yaml2obj --docnum=2 -o %t.mips %s
 # RUN: llvm-objdump -p %t.mips | FileCheck %s  --strict-whitespace --match-full-lines --check-prefix=MIPS
 
 #      MIPS:Dynamic Section:
 # MIPS-NEXT:  MIPS_RLD_VERSION           0x0000000012345678

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_MIPS
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_MIPS_RLD_VERSION
         Value: 0x12345678
       - Tag:   DT_MIPS_TIME_STAMP
         Value: 0x11223344
       - Tag:   DT_MIPS_ICHECKSUM
Entries:
       - Tag:   DT_MIPS_PLTGOT
         Value: 0x1000
       - Tag:   DT_MIPS_RWPLT
         Value: 0x1000
       - Tag:   DT_MIPS_RLD_MAP_REL
         Value: 0x1000
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 3: Test that PPC machine-specific tags can be dumped.
 # RUN: yaml2obj --docnum=3 -o %t.ppc %s
 # RUN: llvm-objdump -p %t.ppc | FileCheck %s --check-prefix=PPC
 
 # PPC:      Dynamic Section:
 # PPC-NEXT:  PPC_GOT 0x000200c0
 # PPC-NEXT:  PPC_OPT 0x00000001
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2MSB
   Type:    ET_EXEC
   Machine: EM_PPC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_PPC_GOT
         Value: 0x200c0
       - Tag:   DT_PPC_OPT
         Value: 1
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 4: Test that PPC64 machine-specific tags can be dumped.
 # RUN: yaml2obj --docnum=4 -o %t.ppc64 %s
 # RUN: llvm-objdump -p %t.ppc64 | FileCheck %s --check-prefix=PPC64
 
 # PPC64:      Dynamic Section:
 # PPC64-NEXT:  PPC64_GLINK 0x0000000000001000
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_PPC64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:      PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_PPC64_GLINK
         Value: 0x1000
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:      PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 5: Test that AARCH64 machine-specific tags can be dumped.
 # RUN: yaml2obj --docnum=5 -o %t.aarch64 %s
 # RUN: llvm-objdump -p %t.aarch64 | FileCheck %s --check-prefix=AARCH64
 
 # AARCH64:      Dynamic Section:
 # AARCH64-NEXT:  AARCH64_BTI_PLT      0x0000000000000001
 # AARCH64-NEXT:  AARCH64_PAC_PLT      0x0000000000000002
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_AARCH64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_AARCH64_BTI_PLT
         Value: 1
       - Tag:   DT_AARCH64_PAC_PLT
         Value: 2
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-objdump/ELF/dynamic-section.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1010
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynstr
     Type:    SHT_STRTAB
     Address: 0x1000
     Size:    0x10
     Content: "004400550066007700"
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1010

 ## An OS specific tag.
      - Tag:   0x6abcdef0
        Value: 0x9988776655443322
 ## A processor specific tags.
      - Tag:   0x76543210
        Value: 0x5555666677778888
      - Tag:   DT_NULL
        Value: 0x0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1010
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # RUN: yaml2obj --docnum=2 %s -o %t2
 # RUN: llvm-objdump -p %t2 | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=ELF32
 
 #      ELF32:Dynamic Section:
 # ELF32-NEXT:  NEEDED               D
 # ELF32-NEXT:  PLTRELSZ             0x00000010
 # ELF32-NEXT:  PLTGOT               0x00001000

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_386
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1010
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynstr
     Type:    SHT_STRTAB
     Address: 0x1000
     Size:    0x10
     Content: "004400550066007700"
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1010

 ## An OS specific tag.
      - Tag:   0x6abcdef0
        Value: 0x99887766
 ## A processor specific tags.
      - Tag:   0x76543210
        Value: 0x55556666
      - Tag:   DT_NULL
        Value: 0x0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1010
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## When printing the value column we want to have the minimal possible indentation.
 ## Use an arbitrary dynamic tag to demonstrate that.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3
 # RUN: llvm-objdump -p %t3 | FileCheck %s --strict-whitespace --check-prefix=INDENT
 
 # RUN: yaml2obj --docnum=4 %s -o %t4

llvm/test/tools/llvm-objdump/ELF/pt-gnu-property.test

 # RUN: yaml2obj %s -o %t
 # RUN: llvm-objdump -p %t | FileCheck %s
 
 # CHECK: Program Header:
 # CHECK-NEXT: {{ }}PROPERTY{{ }}
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_AARCH64
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type: PT_GNU_PROPERTY

llvm/test/tools/llvm-objdump/X86/elf-disassemble-dynamic-symbols.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text
   - Name:    .text
     Type:    SHT_PROGBITS
     Flags:   [SHF_ALLOC, SHF_EXECINSTR]
     Address: 0x1000
     Content: 909090909090909090909090
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text
 Symbols:
   - Name:    both_static
     Value:   0x1001
     Section: .text
     Binding: STB_GLOBAL
   - Name:    only_static
     Value:   0x1002
     Section: .text

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

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x100000
+        Align:    0x100
+        FirstSec: .foo
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x100500
+        Align:    0x100
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:         .foo
     Type:         SHT_PROGBITS
     Size:         16
     Flags:        [SHF_ALLOC]
     Address:      0x100000
     AddressAlign: 0x100
   - Name:         .got.plt
     Type:         SHT_PROGBITS
Entries:
       - Tag: DT_REL
         Value: 0x100400
       - Tag: DT_RELSZ
         Value: 16
       - Tag: DT_RELENT
         Value: 16
       - Tag: DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x100000
-    Align:    0x100
-    FirstSec: .foo
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x100500
-    Align:    0x100
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 DynamicSymbols:
   - Name:    foo
     Section: .foo
     Binding: STB_GLOBAL
   - Name:    bar
     Type:    STT_FUNC
     Binding: STB_GLOBAL

llvm/test/tools/llvm-objdump/X86/phdrs-lma.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x00001000
+        PAddr:    0x00002000
+        FirstSec: .text
+        LastSec:  .init
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x00002000
+        PAddr:    0x00003000
+        FirstSec: .data
+        LastSec:  .data
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Content:         "00000000"
     Address:         0x00001000
   - Name:            .init
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Content:         "00000000"
     Address:         0x00001010
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Content:         "00000000"
     Address:         0x00002000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x00001000
-    PAddr:    0x00002000
-    FirstSec: .text
-    LastSec:  .init
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x00002000
-    PAddr:    0x00003000
-    FirstSec: .data
-    LastSec:  .data

llvm/test/tools/llvm-objdump/X86/phdrs-lma2.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x00001000
+        FirstSec: .text
+        LastSec:  .init
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x00002000
+        FirstSec: .data
+        LastSec:  .data
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Content:         "00000000"
     Address:         0x00001000
   - Name:            .init
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Content:         "00000000"
     Address:         0x00001010
   - Name:            .data
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Content:         "00000000"
     Address:         0x00002000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x00001000
-    FirstSec: .text
-    LastSec:  .init
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x00002000
-    FirstSec: .data
-    LastSec:  .data

llvm/test/tools/llvm-objdump/openbsd-headers.test

 # CHECK-NEXT:      filesz 0x0000000000000000 memsz 0x0000000000000000 flags ---
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type: 0x65a3dbe6 ## PT_OPENBSD_RANDOMIZE
       - Type: 0x65a3dbe7 ## PT_OPENBSD_WXNEEDED
       - Type: 0x65a41be6 ## PT_OPENBSD_BOOTDATA

llvm/test/tools/llvm-objdump/section-filter.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x400
+        PAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text2
+      - Type:     PT_LOAD
+        VAddr:    0x410
+        PAddr:    0x2000
+        FirstSec: .data
+        LastSec:  .data
+      - Type:     PT_LOAD
+        VAddr:    0x420
+        PAddr:    0x3000
+        FirstSec: .bss
+        LastSec:  .bss
   - Name:         .text
     Type:         SHT_PROGBITS
     Flags:        [SHF_ALLOC, SHF_EXECINSTR]
     Address:      0x400
     AddressAlign: 0x10
     Content:      'c3'
   - Name:         .text2
     Type:         SHT_PROGBITS
     Flags:        [SHF_ALLOC, SHF_EXECINSTR]
     Address:      0x401
     Content:      '90'
   - Name:         .data
     Type:         SHT_PROGBITS
     Flags:        [SHF_ALLOC, SHF_WRITE]
     Address:      0x410
     AddressAlign: 0x10
     Content:      '42'
   - Name:         .bss
     Type:         SHT_NOBITS
     Flags:        [SHF_ALLOC, SHF_WRITE]
     Address:      0x420
     AddressAlign: 0x10
     Size:         1
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x400
-    PAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text2
-  - Type:     PT_LOAD
-    VAddr:    0x410
-    PAddr:    0x2000
-    FirstSec: .data
-    LastSec:  .data
-  - Type:     PT_LOAD
-    VAddr:    0x420
-    PAddr:    0x3000
-    FirstSec: .bss
-    LastSec:  .bss
 
 ## Test that --section works with --fault-map-section.
 # RUN: yaml2obj %s --docnum=2 -o %t.o
 # RUN: llvm-objdump %t.o --fault-map-section -j __clangast \
 # RUN:   | FileCheck %s --check-prefixes=FAULTMAP,NO-FAULTMAP
 # RUN: llvm-objdump %t.o --fault-map-section -j .llvm_faultmaps \
 # RUN:   | FileCheck %s --check-prefixes=FAULTMAP,WITH-FAULTMAP
 

llvm/test/tools/llvm-objdump/warn-on-out-of-range-start-stop-address.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x1000
+        FileSize: 0x500
+        FirstSec: .text
+        LastSec:  .text2
   - Name:    .text
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
     Address: 0x1000
     Size:    4
   - Name:    .text2
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
     Address: 0x1400
     Size:    4
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x1000
-    FileSize: 0x500
-    FirstSec: .text
-    LastSec:  .text2
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
-  - Name:    .text
-    Type:    SHT_PROGBITS
-    Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
-    Address: 0x2000
-    Size:    4
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         VAddr:    0x1000
         FileSize: 0x4
         FirstSec: .text
         LastSec:  .text
+  - Name:    .text
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address: 0x2000
+    Size:    4
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

llvm/test/tools/llvm-readobj/ELF/all.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_386
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .hash
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_GNU_EH_FRAME
+        FirstSec: .eh_frame_hdr
+        LastSec:  .eh_frame_hdr
+      - Type:     PT_NOTE
+        FirstSec: .note.gnu.build-id
+        LastSec:  .note.gnu.build-id
   - Name: .data
     Type: SHT_PROGBITS
   - Name: .rela.data
     Type: SHT_REL
     Relocations:
   - Name:    .gnu.version
     Type:    SHT_GNU_versym
     Entries: [ 0 ]

 ## An arbitrary linker-generated valid content.
     Content:      1400000000000000017a5200017810011b0c070890010000100000001c000000c8efffff0100000000000000
   - Name:    .note.gnu.build-id
     Type:    SHT_NOTE
     Flags:   [ SHF_ALLOC ]
     Address: 0x1500
 ## An arbitrary linker-generated valid content.
     Content: 040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .hash
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_GNU_EH_FRAME
-    FirstSec: .eh_frame_hdr
-    LastSec:  .eh_frame_hdr
-  - Type:     PT_NOTE
-    FirstSec: .note.gnu.build-id
-    LastSec:  .note.gnu.build-id
 Symbols: []
 DynamicSymbols:
   - Name: foo

llvm/test/tools/llvm-readobj/ELF/broken-dynamic-reloc.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .rela.dyn
+        LastSec:  .dynamic
   - Name:    .rela.dyn
     Type:    SHT_RELA
     Link:    .dynsym
     Relocations:
       - Symbol: 1 ## Index of a dynamic symbol with a broken st_name.
         Type:   R_X86_64_NONE
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_RELA
         Value: 0x0000000000000000
       - Tag:   DT_RELASZ
         Value: 0x0000000000000018
       - Tag:   DT_RELAENT
         Value: 0x0000000000000018
       - Tag:   DT_NULL
         Value: 0x0000000000000000
 DynamicSymbols:
   - StName: 0x1234
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .rela.dyn
-    LastSec:  .dynamic
 
 ## Show we print a warning for an invalid relocation table size stored in a DT_RELASZ entry.
 
 ## Case A: the size of a single relocation entry is 0x18. In this case 0xFF % 0x18 != 0 and we report a warning
 
 # RUN: yaml2obj --docnum=2 -DRELTYPE=RELA -DTAG1=DT_RELASZ -DTAG1VAL=0xFF -DTAG2=DT_RELAENT %s -o %t2a
 # RUN: llvm-readobj --dyn-relocations %t2a 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t2a --check-prefix=INVALID-DT-RELASZ1 --implicit-check-not=warning:
 # RUN: llvm-readelf --dyn-relocations %t2a 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t2a --check-prefix=INVALID-DT-RELASZ1 --implicit-check-not=warning:
 
 # INVALID-DT-RELASZ1: warning: '[[FILE]]': invalid DT_RELASZ value (0xff) or DT_RELAENT value (0x18)
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .relx.dyn
+        LastSec:  .dynamic
   - Name:  .relx.dyn
     Type:  SHT_[[RELTYPE]]
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_[[RELTYPE]]
         Value: 0x0
       - Tag:   [[TAG1]]
         Value: [[TAG1VAL=0x18]]
       - Tag:   [[TAG2]]
         Value: [[TAG2VAL=0x18]]
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .relx.dyn
-    LastSec:  .dynamic
 
 ## Case B: the DT_RELASZ has value of 0x251, what is too large, because the relocation table goes past the EOF.
 
 # RUN: yaml2obj --docnum=2 -DRELTYPE=RELA -DTAG1=DT_RELASZ -DTAG1VAL=0x251 -DTAG2=DT_RELAENT %s -o %t2b
 # RUN: llvm-readobj --dyn-relocations %t2b 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t2b --check-prefix=INVALID-DT-RELASZ2 --implicit-check-not=warning:
 # RUN: llvm-readelf --dyn-relocations %t2b 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t2b --check-prefix=INVALID-DT-RELASZ2 --implicit-check-not=warning:

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .rela.plt
+        LastSec:  .dynamic
   - Name:  .rela.plt
     Type:  SHT_RELA
     Relocations:
       - Type:   R_X86_64_NONE
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Entries:
       - Tag:   DT_JMPREL
         Value: 0x0
       - Tag:   DT_PLTRELSZ
         Value: [[VAL]] ## The valid value would be 0x18.
       - Tag:   DT_PLTREL
         Value: 0x7 ## DT_RELA
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .rela.plt
-    LastSec:  .dynamic
 
 ## Case B: the DT_PLTRELSZ (PLT size) has value of 0x269, what is too large, because PLT goes past the EOF.
 
 # RUN: yaml2obj --docnum=3 -DVAL=0x269 %s -o %t10b
 # RUN: llvm-readobj --dyn-relocations %t10b 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t10b --check-prefix=INVALID-DT-PLTRELSZ2-LLVM --implicit-check-not=warning:
 # RUN: llvm-readelf --dyn-relocations %t10b 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t10b --check-prefix=INVALID-DT-PLTRELSZ2-GNU --implicit-check-not=warning:

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .rela.dyn
+        LastSec:  .dynamic
   - Name:    .rela.dyn
     Type:    SHT_RELA
     Relocations:
       - Type:   R_X86_64_NONE
       - Type:   R_X86_64_NONE
         Symbol: 0x1
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_RELA
         Value: 0x0
       - Tag:   DT_RELASZ
         Value: 0x30
       - Tag:   DT_RELAENT
         Value: 0x18
       - Tag:   DT_NULL
         Value: 0x0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .rela.dyn
-    LastSec:  .dynamic
 
 ## Show we print a warning when the symbol index of a dynamic relocation is too
 ## large (goes past the end of the dynamic symbol table).
 # RUN: yaml2obj --docnum=5 %s -o %t12
 # RUN: llvm-readobj --dyn-relocations %t12 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t12 --implicit-check-not=warning: --check-prefix=LLVM-INVALID-DYNSYM
 # RUN: llvm-readelf --dyn-relocations %t12 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t12 --implicit-check-not=warning: --check-prefix=GNU-INVALID-DYNSYM

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .rela.dyn
+        LastSec:  .dynamic
   - Name:    .rela.dyn
     Type:    SHT_RELA
     Relocations:
       - Type:   R_X86_64_NONE
         Symbol: 0x2
       - Type:   R_X86_64_NONE
         Symbol: 0x2
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_RELA
         Value: 0x0
       - Tag:   DT_RELASZ
         Value: 0x30
       - Tag:   DT_RELAENT
         Value: 0x18
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols:
   - Name: foo
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .rela.dyn
-    LastSec:  .dynamic
 
 ## Show that when we have both REL and RELA relocations, we dump both sets.
 # RUN: yaml2obj --docnum=6 %s -o %t13
 # RUN: llvm-readobj --dyn-relocations %t13 2>&1 | FileCheck %s -DFILE=%t13 --check-prefix=BOTH-RELA-REL-LLVM
 # RUN: llvm-readelf --dyn-relocations %t13 2>&1 | FileCheck %s -DFILE=%t13 --check-prefix=BOTH-RELA-REL-GNU
 
 # BOTH-RELA-REL-LLVM:      Dynamic Relocations {
 # BOTH-RELA-REL-LLVM-NEXT:   0x1 R_X86_64_NONE - 0x0{{$}}

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .rela.dyn
+        LastSec:  .dynamic
   - Name: .rela.dyn
     Type: SHT_RELA
     Relocations:
       - Type:   R_X86_64_NONE
         Offset: 0x1
   - Name: .rel.dyn
     Type: SHT_REL
     Relocations:
## 0x18 == offset of .rel.dyn == size of .rela.dyn section.
         Value: 0x18
       - Tag:   DT_RELSZ
         Value: 0x10
       - Tag:   DT_RELENT
         Value: 0x10
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .rela.dyn
-    LastSec:  .dynamic
 
 ## Check that llvm-readobj/llvm-readelf reports a warning when dumping a relocation
 ## which refers to a symbol past the end of the file.
 
 # RUN: yaml2obj --docnum=7 %s -o %t7
 # RUN: llvm-readobj --dyn-relocations %t7 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t7 --check-prefix=PAST-EOF-LLVM
 # RUN: llvm-readelf --dyn-relocations %t7 2>&1 | \

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Offset:   0x0
+        FirstSec: .dynamic
+        LastSec:  .dynsym
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Flags:   [ SHF_ALLOC ]
     Address: 0x100
     Offset:  0x100
     Entries:
       - Tag:   DT_RELA
         Value: 0x200
- Name:    .dynsym
     Type:    SHT_DYNSYM
     Flags:   [ SHF_ALLOC ]
     Address: 0x300
     Offset:  0x300
   - Type: SectionHeaderTable
     NoHeaders: true
 DynamicSymbols:
   - Name: foo
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Offset:   0x0
-    FirstSec: .dynamic
-    LastSec:  .dynsym
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/check-output-order.test

 
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Entries:
       - Tag: DT_NULL
         Value: 0
 Symbols: []
-ProgramHeaders:
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/demangle.test

 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        VAddr:    0x0
+        FirstSec: .dynstr
+        LastSec:  .text.foo
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:         .dynstr
     Type:         SHT_STRTAB
     Flags:        [ SHF_ALLOC ]
     AddressAlign: 0x100
     EntSize:      0x1
   - Name:         .dynsym
     Type:         SHT_DYNSYM
     Flags:        [ SHF_ALLOC ]
- Name:    _Z3fooc
     Binding: STB_GLOBAL
   - Name:    _Z4blahf
     Type:    STT_FUNC
     Section: .text.foo
     Binding: STB_GLOBAL
 DynamicSymbols:
   - Name:    _Z3fooi
     Binding: STB_GLOBAL
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    VAddr:    0x0
-    FirstSec: .dynstr
-    LastSec:  .text.foo
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/dyn-symbols-size-from-hash-table.test

 # GNU1-EMPTY:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0
+        FirstSec: .text
+        LastSec:  .data
+      - Type:     PT_LOAD
+        VAddr:    0x400
+        FirstSec: .dynsym
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0xA00
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:         .text
     Type:         SHT_PROGBITS
   - Name:         .data
     Type:         SHT_PROGBITS
   - Name:         .dynsym
     Type:         SHT_DYNSYM
     Flags:        [ SHF_ALLOC ]
     Address:      0x400
DynamicSymbols:
   - Name:    foo
     Type:    STT_FUNC
     Section: .text
     Value:   0x100
   - Name:    bar
     Type:    STT_OBJECT
     Section: .data
     Value:   0x200
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0
-    FirstSec: .text
-    LastSec:  .data
-  - Type:     PT_LOAD
-    VAddr:    0x400
-    FirstSec: .dynsym
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0xA00
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 2: Table size from DT_HASH does not match size from section header.
 # RUN: yaml2obj --docnum=2 %s -o %t2-smaller -DCHAIN="[1, 2]"
 # RUN: llvm-readobj --dyn-symbols %t2-smaller 2>&1 | \
 # RUN:   FileCheck %s --check-prefixes=LLVM2,WARN \
 # RUN:              --implicit-check-not=warning: -DNCHAIN=2
 # RUN: llvm-readelf --dyn-symbols %t2-smaller 2>&1 | \
 # RUN:   FileCheck %s --check-prefixes=GNU2,WARN \

 ## when a size of 4 is derived from the hash table, we still have a valid symbol
 ## to dump.
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0
+        FirstSec: .text
+        LastSec:  .data
+      - Type:     PT_LOAD
+        VAddr:    0x400
+        FirstSec: .dynsym
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0xA00
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:         .text
     Type:         SHT_PROGBITS
   - Name:         .data
     Type:         SHT_PROGBITS
   - Name:         .dynsym
     Type:         SHT_DYNSYM
     Flags:        [ SHF_ALLOC ]
     ShSize:       0x48
DynamicSymbols:
   - Name:    bar
     Type:    STT_OBJECT
     Section: .data
     Value:   0x200
   - Name:    baz
     Type:    STT_OBJECT
     Section: .data
     Value:   0x300
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0
-    FirstSec: .text
-    LastSec:  .data
-  - Type:     PT_LOAD
-    VAddr:    0x400
-    FirstSec: .dynsym
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0xA00
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 3: DT_HASH is missing.
 ## Show that no warning occurs if there are section headers.
 # RUN: yaml2obj --docnum=1 %s -o %t3 -DTAG1=DT_SYMTAB -DVAL1=0x400 -DTAG2=DT_NULL -DVAL2=0 -DBITS=64
 # RUN: llvm-readobj --dyn-symbols %t3 2>&1 | \
 # RUN:   FileCheck %s --check-prefixes=LLVM1,NOSTRIP --implicit-check-not=warning:
 # RUN: llvm-readelf --dyn-symbols %t3 2>&1 | \
 # RUN:   FileCheck %s --check-prefixes=GNU1,GNU1-NOSTRIP --implicit-check-not=warning:

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .rela.plt
+        LastSec:  .hash
+        VAddr: 0x1000
   - Name:    .rela.plt
     Type:    SHT_RELA
     Flags:   [ SHF_ALLOC ]
     Address: 0x1000
     Relocations:
       - Type:   R_X86_64_NONE
         Symbol: 0xFFDDFFDD
   - Name:  .dynamic
## 0x68 + PT_LOAD's p_offset (0x78) == .hash section offset (0xE0).
         Value: 0x0
   - Name:   .hash
     Type:   SHT_HASH
     Flags:  [ SHF_ALLOC ]
     Bucket: [ 0 ]
     Chain:  [ 0 ]
     NChain: 0xFFFFFFFF
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .rela.plt
-    LastSec:  .hash
-    VAddr: 0x1000

llvm/test/tools/llvm-readobj/ELF/dyn-symbols.test

 # DYNSYMS-GNU-NEXT:    2: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND bar
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x100
+        FirstSec: .dynsym
+        LastSec:  .dynsym
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Entries:
       - Tag:   DT_SYMTAB
         Value: 0x100
       - Tag:   DT_NULL
         Value: 0
   - Name:    .dynsym
     Type:    SHT_DYNSYM
     Address: 0x100
 DynamicSymbols:
   - Name: foo
   - Name: bar
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x100
-    FirstSec: .dynsym
-    LastSec:  .dynsym
 
 ## Case 2: Check the output for aliases.
 ## a) Check the two-letter alias --dt is equivalent to the --dyn-symbols
 ## full flag name.
 # RUN: llvm-readobj --dt %t1.so > %t.readobj-dt-alias
 # RUN: llvm-readobj --dyn-symbols %t1.so > %t.readobj-dt-no-alias
 # RUN: cmp %t.readobj-dt-alias %t.readobj-dt-no-alias
 ## b) Check --dyn-syms equals --dyn-symbols, --dt for llvm-readobj.

 # BROKEN-DTSYMTAB-GNU:  1: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND foo
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x0000
+        FirstSec: .dynsym
+        LastSec:  .dynsym
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Entries:
       - Tag:   DT_SYMTAB
         Value: 0xffff1234
       - Tag:   DT_NULL
         Value: 0
 DynamicSymbols:
   - Name: foo
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x0000
-    FirstSec: .dynsym
-    LastSec:  .dynsym
 
 ## Case 6: Check that if we can get the location of the dynamic symbol table using both the DT_SYMTAB value
 ## and the section headers table then we prefer the former and report a warning.
 # RUN: yaml2obj --docnum=5 %s -o %t5.so
 # RUN: llvm-readobj %t5.so --dyn-symbols 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefixes=PREFER-DTSYMTAB,PREFER-DTSYMTAB-LLVM
 # RUN: llvm-readelf %t5.so --dyn-symbols 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefixes=PREFER-DTSYMTAB,PREFER-DTSYMTAB-GNU
 
 # PREFER-DTSYMTAB:      warning: '[[FILE]]': SHT_DYNSYM section header and DT_SYMTAB disagree about the location of the dynamic symbol table
 # PREFER-DTSYMTAB-LLVM: Name: o
 # PREFER-DTSYMTAB-GNU:  1: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND o
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x0000
+        FirstSec: .mydynsym
+        LastSec:  .mydynsym
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Entries:
       - Tag:   DT_SYMTAB
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0
   - Name: .dynsym
     Type: SHT_DYNSYM
   - Name: .mydynsym
     Type: SHT_DYNSYM
 ## The Content describes 2 symbols: zero symbol and symbol with st_name == 3.
     Content: "000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000"
 DynamicSymbols:
   - Name: foo
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x0000
-    FirstSec: .mydynsym
-    LastSec:  .mydynsym
 
 ## Case 7: Check how we dump versioned symbols. Use both -V and --dyn-symbols
 ## to check that printed version is consistent.
 ## A default version is one that is contained in the version table (SHT_GNU_versym)
 ## and only available for defined symbols. We use the "@@" prefix to print it.
 
 ## Check how we dump undefined symbols.
 
- Name: .dynsym
     Size: 0x1
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x100
+        FirstSec: .dynsym
+        LastSec:  .dynsym
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Entries:
       - Tag:   DT_SYMTAB
         Value: 0x100
       - Tag:   DT_NULL
         Value: 0
   - Name:    .dynsym
     Type:    SHT_DYNSYM
     Address: 0x100
     Size:    0x1
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x100
-    FirstSec: .dynsym
-    LastSec:  .dynsym
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:    .dynamic

 # DYNSTR-INVALID-GNU-NEXT:      2: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT   UND test
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        FirstSec: .dynstr
+        LastSec:  .dynamic
   - Name:    .dynstr
     Type:    SHT_STRTAB
     Flags:   [ SHF_ALLOC ]
     Content: '007465737400' ## '\0', 'test', '\0'
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Link:  .dynstr
     Entries:
       - Tag:   DT_STRTAB
         Value: 0x0
       - Tag:   DT_STRSZ
         Value: 0xffffffff
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols:
   - StName:  0xffffff00
 ## An arbitrary valid symbol to document we report an error before dumping it.
   - StName:  0x1
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    FirstSec: .dynstr
-    LastSec:  .dynamic
 
 ## Case 11: check various warnings we report when fields of the SHT_DYNSYM section are broken.
 
 ## a) check we report a warning when the entry size of the dynamic symbol table is zero.
 # RUN: yaml2obj %s --docnum=14 -DENTSIZE=0x0 -o %t15.entsize
 # RUN: llvm-readobj --dyn-symbols %t15.entsize 2>&1 | FileCheck %s -DFILE=%t15.entsize --check-prefix=DYNSYM-ZERO-ENTSIZE-LLVM
 # RUN: llvm-readelf --dyn-symbols %t15.entsize 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t15.entsize --check-prefix=DYNSYM-ZERO-ENTSIZE-GNU --implicit-check-not="Symbol table"

llvm/test/tools/llvm-readobj/ELF/dynamic-empty.test

 # Show that llvm-readobj can handle an empty .dynamic section.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: llvm-readobj --dynamic-table %t.o | FileCheck %s --check-prefix LLVM
 # RUN: llvm-readelf --dynamic-table %t.o | FileCheck %s --check-prefix GNU --allow-empty
 
 # LLVM: File: {{.*}}.o
 # LLVM-NOT: DynamicSection
 # GNU-NOT: {{.}}
 
 !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
-  - Name:         .dynamic
-    Type:         SHT_DYNAMIC
-    Address:      0x1000
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         VAddr:    0x1000
         FirstSec: .dynamic
         LastSec:  .dynamic
       - Type:     PT_DYNAMIC
         VAddr:    0x1000
         FirstSec: .dynamic
         LastSec:  .dynamic
+  - Name:         .dynamic
+    Type:         SHT_DYNAMIC
+    Address:      0x1000

llvm/test/tools/llvm-readobj/ELF/dynamic-malformed.test

 # WARN-GNU:        0:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
-  - Name:    .dynamic
-    Type:    SHT_DYNAMIC
-    Address: 0x1000
-    Content: "01234567"
-Symbols: []
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         VAddr:    0x1000
         FirstSec: .dynamic
         LastSec:  .dynamic
       - Type:     PT_DYNAMIC
         VAddr:    0x1000
         FirstSec: .dynamic
         LastSec:  .dynamic
+  - Name:    .dynamic
+    Type:    SHT_DYNAMIC
+    Address: 0x1000
+    Content: "01234567"
+Symbols: []
 
 ## Test handling of a .dynamic section with an invalid entsize (i.e. not 2 * sizeof(Elf_Dyn)).
 # RUN: yaml2obj %s --docnum=2 -o %t.bad-entsize
 # RUN: llvm-readobj --dynamic-table %t.bad-entsize | FileCheck %s --check-prefix BAD-ENTSIZE-LLVM
 # RUN: llvm-readelf --dynamic-table %t.bad-entsize | FileCheck %s --check-prefix BAD-ENTSIZE-GNU
 
 # BAD-ENTSIZE-LLVM:      DynamicSection [ (2 entries)
 # BAD-ENTSIZE-LLVM-NEXT:   Tag                Type                 Name/Value
 # BAD-ENTSIZE-LLVM-NEXT:   0x0000000000000015 DEBUG                0x0
 # BAD-ENTSIZE-LLVM-NEXT:   0x0000000000000000 NULL                 0x0
 # BAD-ENTSIZE-LLVM-NEXT: ]
 
 # BAD-ENTSIZE-GNU:      Dynamic section at offset 0x{{.*}} contains 2 entries:
 # BAD-ENTSIZE-GNU-NEXT:   Tag                Type                 Name/Value
 # BAD-ENTSIZE-GNU-NEXT:   0x0000000000000015 (DEBUG)              0x0
 # BAD-ENTSIZE-GNU-NEXT:   0x0000000000000000 (NULL)               0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1000
     EntSize: 0x2
     Entries:
       - Tag:   DT_DEBUG
         Value: 0
       - Tag:   DT_NULL
         Value: 0
 Symbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Test handling of string references pointing past the end of the dynamic string table.
 # RUN: yaml2obj %s --docnum=3 -o %t.bad-string
 # RUN: llvm-readobj --dynamic-table %t.bad-string 2>&1 | \
 # RUN:   FileCheck %s --implicit-check-not=warning: --check-prefix BAD-STRING-LLVM -DFILE=%t.bad-string
 # RUN: llvm-readelf --dynamic-table %t.bad-string 2>&1 | \
 # RUN:   FileCheck %s --implicit-check-not=warning: --check-prefix BAD-STRING-GNU -DFILE=%t.bad-string
 

 # BAD-STRING-GNU-NEXT:   0x0000000000000000 (NULL)      0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1010
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynstr
     Type:    SHT_STRTAB
     Address: 0x1000
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1010
     Entries:
       - Tag:   DT_STRTAB
Entries:
         Value: 6
       - Tag:   DT_RPATH
         Value: 7
       - Tag:   DT_RUNPATH
         Value: 8
       - Tag:   DT_NULL
         Value: 0
 Symbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1010
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Test handling of DT_STRTAB pointing outside the file's address space.
 # RUN: yaml2obj %s --docnum=4 -o %t.bad-strtab
 
 # RUN: llvm-readobj --dynamic-table %t.bad-strtab 2>&1 >/dev/null | \
 # RUN:   FileCheck -DFILE=%t.bad-strtab %s --implicit-check-not=warning: --check-prefix=BAD-STRTAB-ERR
 # RUN: llvm-readelf --dynamic-table %t.bad-strtab 2>&1 >/dev/null | \
 # RUN:   FileCheck -DFILE=%t.bad-strtab %s --implicit-check-not=warning: --check-prefix=BAD-STRTAB-ERR

 #           BAD-STRTAB: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1000
     Entries:
 ## Two DT_STRTAB entries are needed to check that we don't report it twice.
       - Tag:   DT_STRTAB
         Value: 0x2000000
       - Tag:   DT_STRTAB
         Value: 0x2000000
       - Tag:   DT_STRSZ
         Value: 10
       - Tag:   DT_NEEDED
         Value: 1
       - Tag:   DT_NULL
         Value: 0x0
 Symbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Test handling of other d_ptr tags pointing outside the file's address space.
 # RUN: yaml2obj %s --docnum=5 -o %t.bad-rela
 # RUN: llvm-readobj --dynamic-table %t.bad-rela 2>&1 | FileCheck -DFILE=%t.bad-rela %s --check-prefixes=CHECK,BAD-RELA
 # RUN: llvm-readelf --dynamic-table %t.bad-rela 2>&1 | FileCheck -DFILE=%t.bad-rela %s --check-prefixes=CHECK,BAD-RELA-GNU
 
 # 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 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
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1000
     Entries:
       - Tag:   DT_RELA
         Value: 0x1000000
       - Tag:   DT_NULL
         Value: 0x0
 Symbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Check how we handle cases when the dynamic string table is not null-terminated.
 
 ## Case A: the value of the DT_STRSZ tag is equal to the size of
 ##         the not null-terminated dynamic string table.
 # RUN: yaml2obj %s -DSTRSZ=7 --docnum=6 -o %t6
 # RUN: llvm-readobj --dynamic-table %t6 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t6 --implicit-check-not=warning: \

 # NOT-TERMINATED-NEXT: {{[(]?}}NULL{{[)]?}}      0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1100
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynstr
     Type:    SHT_STRTAB
     Address: 0x1000
     Content: '746573742e736f' ## "test.so", not null terminated.
   - Type:    Fill
     Pattern: "61626300" ## 'a', 'b', 'c', '\0'.
     Size:    "4"
   - Name:    .dynamic
Entries:
       - Tag:   DT_SONAME
         Value: 4
       - Tag:   DT_RPATH
         Value: 5
       - Tag:   DT_RUNPATH
         Value: 6
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1100
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Check that we emit an appropriate warning when the dynamic string table ends past the end of the file.
 
 ## Case A: the value of DT_STRSZ tag is set so that the string table ends
 ## right before the EOF. No warning should be emitted.
 # RUN: yaml2obj %s -DSTRSZ=0x210 --docnum=6 -o %t9.1
 # RUN: llvm-readobj --dynamic-table %t9.1 | \
 # RUN:   FileCheck %s --implicit-check-not=warning: --check-prefix=BEFORE-THE-EOF

 # OUT-OF-ORDER-GNU-NEXT:   0x0000000000000000 (NULL)   0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
-  - Name:    .dynstr
-    Type:    SHT_STRTAB
-    Address: 0x1000
-  - Name:    .dynamic
-    Type:    SHT_DYNAMIC
-    Address: 0x1010
-    Entries:
-      - Tag:   DT_STRTAB
-        Value: 0x1000
-      - Tag:   DT_NULL
-        Value: 0
-Symbols: []
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         VAddr:    0x1010
         FirstSec: .dynamic
         LastSec:  .dynamic
       - Type:     PT_LOAD
         VAddr:    0x1000
         FirstSec: .dynstr
         LastSec:  .dynstr
       - Type:     PT_DYNAMIC
         VAddr:    0x1010
         FirstSec: .dynamic
         LastSec:  .dynamic
+  - Name:    .dynstr
+    Type:    SHT_STRTAB
+    Address: 0x1000
+  - Name:    .dynamic
+    Type:    SHT_DYNAMIC
+    Address: 0x1010
+    Entries:
+      - Tag:   DT_STRTAB
+        Value: 0x1000
+      - Tag:   DT_NULL
+        Value: 0
+Symbols: []

llvm/test/tools/llvm-readobj/ELF/dynamic-no-pt-dynamic.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1000
     Entries:
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/dynamic-not-in-pt-dynamic.test

 # GNU1-NEXT:   0x0000000000000000 (NULL)     0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .text
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Flags: [SHF_ALLOC]
     Address: 0x1000
     AddressAlign: 0x1000
     Entries:
       - Tag:   DT_BIND_NOW
         Value: 0x1
       - Tag:   DT_NULL
         Value: 0x0
   - Name: .text
     Type: SHT_PROGBITS
     Flags: [SHF_ALLOC]
     Address: 0x1100
     AddressAlign: 0x100
     Content: "00"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .text
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text
 
 ## Case 2: The dynamic table found using the dynamic program header is different from the
 ##         table found using the section header table.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2.o
 # RUN: llvm-readobj --dynamic-table %t2.o 2>&1 \
 # RUN:   | FileCheck -DFILE=%t2.o --check-prefixes=WARNING2,LLVM2 %s
 # RUN: llvm-readelf --dynamic-table %t2.o 2>&1 \

 # GNU2-NEXT:   0x0000000000000000 (NULL)     0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:      PT_LOAD
+        VAddr:     0x1000
+        FirstSec:  .dynamic
+        LastSec:   .text
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Flags: [SHF_ALLOC]
     Address: 0x1000
     AddressAlign: 0x1000
     Entries:
       - Tag:   DT_BIND_NOW
         Value: 0x1
       - Tag:   DT_NULL
         Value: 0x0
   - Name: .text
     Type: SHT_PROGBITS
     Flags: [SHF_ALLOC]
     Address: 0x1100
     AddressAlign: 0x100
     Content: "00000000000000000000000000000000"
-ProgramHeaders:
-  - Type:      PT_LOAD
-    VAddr:     0x1000
-    FirstSec:  .dynamic
-    LastSec:   .text
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text
 
 ## Case 3: Both dynamic tables found using SHT_DYNAMIC/PT_DYNAMIC are corrupted.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3.o
 # RUN: llvm-readobj --dynamic-table %t3.o 2>&1 \
 # RUN:   | FileCheck -DFILE=%t3.o --check-prefix=WARNING3 --implicit-check-not="Dynamic" %s
 # RUN: llvm-readelf --dynamic-table %t3.o 2>&1 \
 # RUN:   | FileCheck -DFILE=%t3.o --check-prefix=WARNING3 --implicit-check-not="Dynamic" %s
 
 # WARNING3: warning: '[[FILE]]': invalid PT_DYNAMIC size (0x1){{$}}
 # WARNING3: warning: '[[FILE]]': SHT_DYNAMIC section header and PT_DYNAMIC program header disagree about the location of the dynamic table
 # WARNING3: warning: '[[FILE]]': no valid dynamic table was found
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .text
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .text
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Flags: [SHF_ALLOC]
     Address: 0x1000
     AddressAlign: 0x1000
     Content: "00"
   - Name: .text
     Type: SHT_PROGBITS
     Flags: [SHF_ALLOC]
     Address: 0x1100
     AddressAlign: 0x100
     Content: "00"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .text
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .text

llvm/test/tools/llvm-readobj/ELF/dynamic-reloc-no-section-headers.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .rela.dyn
+        LastSec:  .dynstr
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .rela.dyn
     Type:    SHT_RELA
     Relocations:
       - Type:   R_X86_64_NONE
         Symbol: 0x1
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
## 0x168 - 0xb0 == 0xb8
       - Tag:   DT_NULL
         Value: 0x0
   - Name:    .dynsym
     Type:    SHT_DYNSYM
   - Type: SectionHeaderTable
     NoHeaders: true
 DynamicSymbols:
   - Name: foo
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .rela.dyn
-    LastSec:  .dynstr
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/dynamic-reloc.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .rela.dyn
+        LastSec:  .dynamic
   - Name: .rela.dyn
     Type: SHT_RELA
     Relocations:
       - Type:   R_X86_64_NONE
         Offset: 0x1
         Symbol: foo
   - Name: .rel.dyn
     Type: SHT_REL
## 0x30 == offset of .plt section in the segment.
       - Tag:   DT_PLTRELSZ
         Value: [[PLTRELSZ=0x10]]
       - Tag:   DT_NULL
         Value: 0x0
 Symbols:
   - Name: foo
 DynamicSymbols:
   - Name: foo
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .rela.dyn
-    LastSec:  .dynamic
 
 ## Check we report a warning when the value of the DT_PLTREL dynamic tag is invalid.
 ## We currently accept DT_RELA(7) and DT_REL(17) values. This test case uses 0xff.
 
 # RUN: yaml2obj --docnum=2 %s -DDTPLTREL=0xFF -o %t3
 # RUN: llvm-readobj --dyn-relocations %t3 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t3 --implicit-check-not=warning: --check-prefix=PLTRELUNKNOWN-LLVM
 # RUN: llvm-readelf --dyn-relocations %t3 2>&1 | \

llvm/test/tools/llvm-readobj/ELF/dynamic-table-dtnull.s

 # NONULL-GNU-NEXT:   0x0000000000000015 (DEBUG)  0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
-  - Name: .dynamic
-    Type: SHT_DYNAMIC
-    Entries:
-      - Tag:   DT_DEBUG
-        Value: 0x0000000000000000
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         FirstSec: .dynamic
         LastSec:  .dynamic
       - Type:     PT_DYNAMIC
         FirstSec: .dynamic
         LastSec:  .dynamic
+  - Name: .dynamic
+    Type: SHT_DYNAMIC
+    Entries:
+      - Tag:   DT_DEBUG
+        Value: 0x0000000000000000
 
 # Sometimes .dynamic section content length can be greater than the
 # length of its entries. In this case, we should not try to dump anything
 # past the DT_NULL entry, which works as a terminator.
 
 # RUN: yaml2obj --docnum=2 %s -o %t.o
 # RUN: llvm-readobj --dynamic-table %t.o | FileCheck %s --check-prefix=LONG-LLVM
 # RUN: llvm-readelf --dynamic-table %t.o | FileCheck %s --check-prefix=LONG-GNU

 # LONG-GNU-NEXT:   0x0000000000000000 (NULL)               0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_DEBUG
         Value: 0x0000000000000000
       - Tag:   DT_NULL
         Value: 0x0000000000000000
       - Tag:   DT_NULL
         Value: 0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/dynamic-tags-machine-specific.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_HEXAGON
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_HEXAGON_SYMSZ
         Value: 0x10
       - Tag:   DT_HEXAGON_VER
         Value: 0x1000
       - Tag:   DT_HEXAGON_PLT
         Value: 0x1000
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 2: Test that MIPS machine-specific tags can be dumped.
 # RUN: yaml2obj --docnum=2 %s -o %t.mips
 # RUN: llvm-readobj --dynamic-table %t.mips \
 # RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=LLVM-MIPS
 # RUN: llvm-readelf --dynamic-table %t.mips \
 # RUN:  | FileCheck %s --strict-whitespace --match-full-lines --check-prefix=GNU-MIPS
 

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_MIPS
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_HASH
         Value: 0x1000
       - Tag:   DT_MIPS_RLD_VERSION
         Value: 0x12345678
       - Tag:   DT_MIPS_TIME_STAMP
Entries:
       - Tag:   DT_MIPS_PLTGOT
         Value: 0x1000
       - Tag:   DT_MIPS_RWPLT
         Value: 0x1000
       - Tag:   DT_MIPS_RLD_MAP_REL
         Value: 0x1000
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 3: Test that PPC machine-specific tags can be dumped.
 # RUN: yaml2obj --docnum=3 %s -o %t.ppc
 # RUN: llvm-readobj --dynamic-table %t.ppc | FileCheck %s --check-prefix=LLVM-PPC
 # RUN: llvm-readelf --dynamic-table %t.ppc | FileCheck %s --check-prefix=GNU-PPC
 
 # LLVM-PPC:      DynamicSection [ (3 entries)
 # LLVM-PPC-NEXT:   Tag        Type    Name/Value

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2MSB
   Type:    ET_EXEC
   Machine: EM_PPC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_PPC_GOT
         Value: 0x200c0
       - Tag:   DT_PPC_OPT
         Value: 1
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 4: Test that PPC64 machine-specific tags can be dumped.
 # RUN: yaml2obj --docnum=4 %s -o %t.ppc64
 # RUN: llvm-readobj --dynamic-table %t.ppc64 | FileCheck %s --check-prefix=LLVM-PPC64
 # RUN: llvm-readelf --dynamic-table %t.ppc64 | FileCheck %s --check-prefix=GNU-PPC64
 
 # LLVM-PPC64:      DynamicSection [ (2 entries)
 # LLVM-PPC64-NEXT:   Tag                Type        Name/Value
 # LLVM-PPC64-NEXT:   0x0000000070000000 PPC64_GLINK 0x1000
 # LLVM-PPC64-NEXT:   0x0000000000000000 NULL        0x0
 # LLVM-PPC64-NEXT: ]
 
 # GNU-PPC64:      Dynamic section at offset {{.*}} contains 2 entries:
 # GNU-PPC64-NEXT:   Tag                Type          Name/Value
 # GNU-PPC64-NEXT:   0x0000000070000000 (PPC64_GLINK) 0x1000
 # GNU-PPC64-NEXT:   0x0000000000000000 (NULL)        0x0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_PPC64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_PPC64_GLINK
         Value: 0x1000
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Case 5: Test that AARCH64 machine-specific tags can be dumped.
 # RUN: yaml2obj --docnum=5 %s -o %t.aarch64
 # RUN: llvm-readobj --dynamic-table %t.aarch64 | FileCheck %s --check-prefix=LLVM-AARCH64
 # RUN: llvm-readelf --dynamic-table %t.aarch64 | FileCheck %s --check-prefix=GNU-AARCH64
 
 # LLVM-AARCH64:     DynamicSection [ (4 entries)
 # LLVM-AARCH64-NEXT:  Tag                Type                Name/Value

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_AARCH64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .dynamic
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Entries:
       - Tag:   DT_AARCH64_BTI_PLT
         Value: 1
       - Tag:   DT_AARCH64_PAC_PLT
         Value: 2
       - Tag:   DT_AARCH64_VARIANT_PCS
         Value: 3
       - Tag:   DT_NULL
         Value: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .dynamic
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/dynamic-tags.test

 
 --- !ELF
 FileHeader:
   Class:      ELFCLASS[[BITS=64]]
   Data:       ELFDATA2LSB
   Type:       ET_EXEC
   EPhEntSize: [[PHENTSIZE=<none>]]
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynstr
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1010
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:    .dynstr
     Type:    SHT_STRTAB
     Address: 0x1000
     Size:    0x10
     Content: "004400550066007700"
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1010

 ## An OS specific tag.
       - Tag:   0x6abcdef0
         Value: [[OSSPEC=0x9988776655443322]]
 ## A processor specific tags.
       - Tag:   0x76543210
         Value: [[PROCSPEC=0x5555666677778888]]
       - Tag:   DT_NULL
         Value: 0x0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynstr
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1010
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 # RUN: yaml2obj %s --docnum=1 -DBITS=32 -DSYMBOLIC=0x12345678 -DDEBUG=0xfedcba09 \
 # RUN:   -DTEXTREL=0x11223344 -DBINDNOW=0x88776655 -DFLAGS=0xffffffff \
 # RUN:   -DUNKNOWN=0x87654321 -DOSSPEC=0x99887766 -DPROCSPEC=0x55556666 -o %t2
 # RUN: llvm-readobj --dynamic-table %t2 \
 # RUN:   | FileCheck %s --check-prefix=LLVM32 --strict-whitespace --match-full-lines
 # RUN: llvm-readobj -d %t2 | FileCheck %s --check-prefix=LLVM32 --strict-whitespace --match-full-lines
 # RUN: llvm-readelf --dynamic-table %t2 \

llvm/test/tools/llvm-readobj/ELF/gnu-file-headers.test

 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_386
   Entry:   0x11223344
 Sections:
-  - Name: .foo
-    Type: SHT_PROGBITS
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type: PT_LOAD
         Flags: [ PF_R ]
+  - Name: .foo
+    Type: SHT_PROGBITS
 
 ## Case 2: Test EM_X86_64 object.
 # RUN: yaml2obj %s --docnum=2 -o %t2
 # RUN: llvm-readelf -h %t2 | FileCheck %s --check-prefix=X86-64
 # RUN: llvm-readelf --file-header %t2 \
 # RUN:   | FileCheck %s --check-prefix=X86-64 --strict-whitespace --match-full-lines
 # RUN: llvm-readelf --file-headers %t2 \
 # RUN:   | FileCheck %s --check-prefix=X86-64 --strict-whitespace --match-full-lines

 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
   Entry:   0x1122334455667788
 Sections:
-  - Name: .foo
-    Type: SHT_PROGBITS
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type: PT_LOAD
         Flags: [ PF_R ]
+  - Name: .foo
+    Type: SHT_PROGBITS
 
 ## Case 3: Use an arbitrary machine type that allows to show how we print Flags.
 ##         Here we use an EM_MIPS object for that.
 # RUN: yaml2obj %s --docnum=3 -o %t3
 # RUN: llvm-readelf -h %t3 | FileCheck %s --check-prefix=MIPSEL
 # RUN: llvm-readelf --file-header %t3 \
 # RUN:   | FileCheck %s --check-prefix=MIPSEL --strict-whitespace --match-full-lines
 # RUN: llvm-readelf --file-headers %t3 \

 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_MIPS
   Flags:   [ EF_MIPS_ARCH_32, EF_MIPS_ABI_O32 ]
 Sections:
-  - Name: .foo
-    Type: SHT_PROGBITS
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type: PT_LOAD
         Flags: [ PF_R ]
+  - Name: .foo
+    Type: SHT_PROGBITS

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

 --- !ELF
 FileHeader:
   Class:      ELFCLASS64
   Data:       ELFDATA2LSB
   Type:       ET_EXEC
   EPhEntSize: [[PHENTSIZE=<none>]]
   EShNum:     [[SHNUM=<none>]]
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_NOTE
+        FileSize: 0x20
+        FirstSec: .note.gnu.build-id
+        LastSec:  .note.gnu.build-id
   - Name:         .note.ABI-tag
     Type:         SHT_NOTE
     AddressAlign: 0x0000000000000004
     Content:      040000001000000001000000474E550000000000020000000600000020000000
   - Name:         .note.gnu.build-id
     Type:         SHT_NOTE
     Flags:        [ SHF_ALLOC ]
     Address:      0x0000000000400120
     AddressAlign: 0x0000000000000004
     Content:      040000001000000003000000474E55004FCB712AA6387724A9F465A32CD8C14B
   - Name:         .note.gnu.gold-version
     Type:         SHT_NOTE
     AddressAlign: 0x0000000000000004
     Content:      040000000900000004000000474E5500676F6C6420312E3131000000
-ProgramHeaders:
-  - Type:     PT_NOTE
-    FileSize: 0x20
-    FirstSec: .note.gnu.build-id
-    LastSec:  .note.gnu.build-id
 
 ## Test tools report an error if a note section has an invalid offset
 ## that goes past the end of file.
 
 # RUN: yaml2obj --docnum=2 -DSHOFFSET=0xffff0000 %s -o %t2.so
 # RUN: llvm-readelf --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1-GNU
 # RUN: llvm-readobj --notes %t2.so 2>&1 | FileCheck -DFILE=%t2.so %s --check-prefix=ERR1-LLVM
 

 # ERR3-LLVM-NEXT:   }
 # ERR3-LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_CORE
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         Offset:   [[PHOFFSET=<none>]]
         FileSize: [[PHFILESIZE=<none>]]
 
 ## Test tools report an error if a note program header has an invalid size that
 ## goes past the end of file.
 
 # RUN: yaml2obj --docnum=3 -DPHFILESIZE=0xffff0000 %s -o %t5.so
 # RUN: llvm-readelf --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefix=ERR4-GNU
 # RUN: llvm-readobj --notes %t5.so 2>&1 | FileCheck -DFILE=%t5.so %s --check-prefix=ERR4-LLVM
 

llvm/test/tools/llvm-readobj/ELF/gnu-section-mapping.test

 
 --- !ELF
 FileHeader:
   Class:      ELFCLASS64
   Data:       ELFDATA2LSB
   Type:       ET_EXEC
   EPhEntSize: [[PHENTSIZE=<none>]]
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+## Case 1: an arbitrary segment with sections.
+      - Type:     PT_PHDR
+        Flags:    [ PF_W ]
+        VAddr:    0x1000
+        FirstSec: .foo.begin
+        LastSec:  .foo.end
+## Case 2: another segment with different sections.
+      - Type:     PT_PHDR
+        Flags:    [ PF_X ]
+        VAddr:    0x2000
+        FirstSec: .bar.begin
+        LastSec:  .bar.end
   - Name:    .foo.begin
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Address: 0x1000
     Size:    0x1
   - Name:    .foo.end
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x2
   - Name:    .bar.begin
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Address: 0x2000
     Size:    0x3
   - Name:    .bar.end
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x4
-ProgramHeaders:
-## Case 1: an arbitrary segment with sections.
-  - Type:     PT_PHDR
-    Flags:    [ PF_W ]
-    VAddr:    0x1000
-    FirstSec: .foo.begin
-    LastSec:  .foo.end
-## Case 2: another segment with different sections.
-  - Type:     PT_PHDR
-    Flags:    [ PF_X ]
-    VAddr:    0x2000
-    FirstSec: .bar.begin
-    LastSec:  .bar.end
 
 ## Check that --section-mapping=false --program-headers produces just program headers.
 # RUN: llvm-readelf --section-mapping=false --program-headers %t64.elf \
 # RUN:   | FileCheck %s --check-prefix=SEC-MAPPING-FALSE --implicit-check-not="Section to Segment mapping:"
 
 # SEC-MAPPING-FALSE: Program Headers:
 
 ## Check that only one copy of the section/segment mapping table is produced

llvm/test/tools/llvm-readobj/ELF/gnuhash.test

 # CHECK-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x1
       Shift2: 0x2
 ## The number of words in the Bloom filter. The value of 2 is no-op.
       MaskWords: [[MASKWORDS=2]]
DynamicSymbols:
   - Name:    aaa
     Binding: STB_GLOBAL
   - Name:    bbb
     Binding: STB_GLOBAL
   - Name:    ccc
     Binding: STB_GLOBAL
   - Name:    ddd
     Binding: STB_GLOBAL
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## Check we report a warning if there is no dynamic symbol section in the object.
 
 # RUN: yaml2obj --docnum=2 %s -o %t.nodynsym
 # RUN: llvm-readobj --gnu-hash-table %t.nodynsym 2>&1 | FileCheck %s -DFILE=%t.nodynsym --check-prefix=NODYNSYM
 # RUN: llvm-readelf --gnu-hash-table %t.nodynsym 2>&1 | FileCheck %s -DFILE=%t.nodynsym --check-prefix=NODYNSYM
 
 # NODYNSYM:      GnuHashTable {
 # NODYNSYM-NEXT:   Num Buckets: 1
 # NODYNSYM-NEXT:   First Hashed Symbol Index: 0
 # NODYNSYM-NEXT:   Num Mask Words: 1
 # NODYNSYM-NEXT:   Shift Count: 0
 # NODYNSYM-NEXT:   Bloom Filter: [0x0]
 # NODYNSYM-NEXT:   Buckets: [0]
 # NODYNSYM-NEXT: warning: '[[FILE]]': unable to dump 'Values' for the SHT_GNU_HASH section: no dynamic symbol table found
 # NODYNSYM-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x0
       Shift2: 0x0
     BloomFilter: [ 0x0 ]
     HashBuckets: [ 0x0 ]
     HashValues:  [ 0x0 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Entries:
       - Tag:   DT_GNU_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## Check what we do when the index of the first symbol in the dynamic symbol table
 ## included in the hash table is larger than the number of dynamic symbols.
 
 # RUN: yaml2obj --docnum=3 %s -o %t.brokensymndx
 # RUN: llvm-readobj --gnu-hash-table %t.brokensymndx 2>&1 \
 # RUN:   | FileCheck %s -DFILE=%t.brokensymndx --check-prefix=SYMNDX
 # RUN: llvm-readelf --gnu-hash-table %t.brokensymndx 2>&1 \

 # SYMNDX-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x2
       Shift2: 0x0
     BloomFilter: [ 0x1 ]
     HashBuckets: [ 0x2 ]
     HashValues:  [ 0x3 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Link:  0
     Entries:
       - Tag:   DT_GNU_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols:
   - Name:    aaa
     Binding: STB_GLOBAL
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## Check we emit a warning when the dynamic symbol table is empty.
 ## A valid dynamic symbol table should have at least one symbol: the symbol with index 0.
 
 # RUN: yaml2obj --docnum=4 %s -o %t.emptydynsym
 # RUN: llvm-readobj --gnu-hash-table %t.emptydynsym 2>&1 \
 # RUN:   | FileCheck %s -DFILE=%t.emptydynsym --check-prefix=EMPTY-DYNSYM
 # RUN: llvm-readelf --gnu-hash-table %t.emptydynsym 2>&1 \

 # EMPTY-DYNSYM-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x0
       Shift2: 0x0
     BloomFilter: [ 0x0 ]
     HashBuckets: [ 0x0 ]
     HashValues:  [ 0x0 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Link:  0
     Entries:
       - Tag:   DT_GNU_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
   - Name: .dynsym
     Type: SHT_DYNSYM
     Size: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## Linkers might produce an empty no-op SHT_GNU_HASH section when
 ## there are no dynamic symbols or when all dynamic symbols are undefined.
 ## Such sections normally have a single zero entry in the bloom
 ## filter, a single zero entry in the hash bucket and no values.
 ##
 ## The index of the first symbol in the dynamic symbol table
 ## included in the hash table can be set to the number of dynamic symbols,

 # EMPTY-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: [[SYMNDX]]
       Shift2: 0x0
     BloomFilter: [ 0x0 ]
     HashBuckets: [ 0x0 ]
     HashValues:  [ ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Link:  0
     Entries:
       - Tag:   DT_GNU_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## Check we report a proper warning when a hash table goes past the end of the file.
 
 ## Case A: the 'maskwords' field is set so that the table goes past the end of the file.
 # RUN: yaml2obj --docnum=1 -DBITS=64 -DMACHINE=EM_X86_64 -D MASKWORDS=4294967295 %s -o %t.err.maskwords
 # RUN: llvm-readobj --gnu-hash-table %t.err.maskwords 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.err.maskwords -DMASKWORDS=4294967295 -DNBUCKETS=3 --check-prefix=ERR
 # RUN: llvm-readelf --gnu-hash-table %t.err.maskwords 2>&1 | \

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

 # HIST-NOT:  {{.}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:   .hash
     Type:   SHT_HASH
     Flags:  [ SHF_ALLOC ]
     Bucket: [ 6, 4, 5 ]
     Chain:  [ 0, 0, 1, 0, 2 ]
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
## sizeof(.hash) == 0x28.
         Value: 0x28
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols:
   - Name: a
   - Name: b
   - Name: c
   - Name: d
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Show that we report a warning for a hash table which contains an entry of
 ## the bucket array pointing to a cycle.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2.o
 # RUN: llvm-readelf --elf-hash-histogram 2>&1 %t2.o | \
 # RUN:   FileCheck -DFILE=%t2.o %s --check-prefix=BROKEN --implicit-check-not=warning:
 
 # BROKEN:       warning: '[[FILE]]': .hash section is invalid: bucket 1: a cycle was detected in the linked chain
 # BROKEN:       Histogram for bucket list length (total of 2 buckets)
 # BROKEN-NEXT:  Length  Number     % of total  Coverage
 # BROKEN-NEXT:       0  0          (  0.0%)       0.0%
 # BROKEN-NEXT:       1  2          (100.0%)     100.0%
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:   .hash
     Type:   SHT_HASH
     Link:   .dynsym
     Bucket: [ 1, 1 ]
     Chain:  [ 0, 1 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Entries:
 ## llvm-readelf will read the hash table from the file offset
 ## p_offset + (p_vaddr - DT_HASH) = p_offset + (0 - 0) = p_offset,
 ## which is the start of PT_LOAD, i.e. the file offset of .hash.
       - Tag:   DT_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0
 DynamicSymbols:
   - Name: foo
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Each SHT_HASH section starts with two 32-bit fields: nbucket and nchain.
 ## Check we report an error when a DT_HASH value points to data that has size less than 8 bytes.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3.o
 # RUN: llvm-readelf --elf-hash-histogram %t3.o 2>&1 | FileCheck %s --check-prefix=ERR1 -DFILE=%t3.o
 
 # ERR1: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8){{$}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FileSize: 0x23a
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:   .hash
     Type:   SHT_HASH
     Flags:  [ SHF_ALLOC ]
     Bucket: [ 0 ]
     Chain:  [ 0 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_WRITE, SHF_ALLOC ]
     Entries:
       - Tag:   DT_HASH
         Value: 0x239
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FileSize: 0x23a
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Check we report a warning when the hash table goes past the end of the file.
 
 ## Case A.1: the hash table ends right before the EOF. We have a broken nbucket
 ##           field that has a value larger than the number of buckets.
 # RUN: yaml2obj --docnum=4 %s -o %t4.1.o -DNBUCKET=0x5d -DNCHAIN=0x1
 # RUN: llvm-readelf --elf-hash-histogram %t4.1.o 2>&1 | \
 # RUN:   FileCheck %s --implicit-check-not={{.}} --allow-empty

 # ERR4: warning: '[[FILE]]': the hash table at offset 0x54 goes past the end of the file (0x1d4), nbucket = 1, nchain = 94{{$}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:    .hash
     Type:    SHT_HASH
     Flags:   [ SHF_ALLOC ]
     Bucket:  [ 0 ]
     NBucket: [[NBUCKET]]
     Chain:   [ 0 ]
     NChain:  [[NCHAIN]]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_WRITE, SHF_ALLOC ]
     Entries:
       - Tag:   DT_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Check we dump a histogram for the .gnu.hash table even when the .hash table is skipped.
 
 ## Case A: the .hash table has no data to build histogram and it is skipped.
 # RUN: yaml2obj --docnum=5 %s -o %t5.o
 # RUN: llvm-readelf --elf-hash-histogram %t5.o 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=GNU-HASH --implicit-check-not="Histogram"
 
 ## Case B: the .hash table has a broken nbucket field. We report a warning
 ##         and skip dumping of the .hash table.
 # RUN: yaml2obj --docnum=5 -DNBUCKET=0xffffffff %s -o %t6.o
 # RUN: llvm-readelf --elf-hash-histogram %t6.o 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t6.o --check-prefixes=WARN,GNU-HASH
 
 # WARN:     warning: '[[FILE]]': the hash table at offset 0x78 goes past the end of the file (0x358), nbucket = 4294967295, nchain = 2
 # GNU-HASH: Histogram for `.gnu.hash' bucket list length (total of 3 buckets)
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:    .hash
     Type:    SHT_HASH
     Flags:   [ SHF_ALLOC ]
     Bucket:  [ 0 ]
 ## 0x2 is a no-op: it does not change the number of buckets described by the "Bucket" key
     NBucket: [[NBUCKET=0x2]]
     Chain:   [ 0, 0 ]
   - Name:  .gnu.hash
Entries:
         Value: 0x0
       - Tag:   DT_GNU_HASH
 ## sizeof(.hash) == 0x14.
         Value: 0x14
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols:
   - Name: foo
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Check we report a proper warning when the GNU hash table goes past the end of the file.
 
 ## Case A: the 'maskwords' field is set so that the GNU hash table goes past the end of the file.
 # RUN: yaml2obj --docnum=6 -D MASKWORDS=0x80000000 %s -o %t7
 # RUN: llvm-readelf --elf-hash-histogram %t7 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t7 --check-prefix=ERR5 --implicit-check-not="Histogram"
 
 # ERR5: warning: '[[FILE]]': unable to dump the SHT_GNU_HASH section at 0x78: it goes past the end of the file
 
 ## Case B: the 'nbuckets' field is set so that the GNU hash table goes past the end of the file.
 # RUN: yaml2obj --docnum=6 -D NBUCKETS=0x80000000 %s -o %t8
 # RUN: llvm-readelf --elf-hash-histogram %t8 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t8 --check-prefix=ERR5 --implicit-check-not="Histogram"
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x0
       Shift2: 0x0
 ## The number of words in the Bloom filter. The value of 1 is no-op.
       MaskWords: [[MASKWORDS=1]]
 ## The number of hash buckets. The value of 1 is no-op.
       NBuckets:  [[NBUCKETS=1]]
     BloomFilter: [ 0x0 ]
     HashBuckets: [ 0x0 ]
     HashValues:  [ 0x0 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Link:  .dynstr
     Entries:
       - Tag:   DT_GNU_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## Linkers might produce an empty no-op SHT_GNU_HASH section when
 ## there are no dynamic symbols or when all dynamic symbols are undefined.
 ## Such sections normally have a single zero entry in the bloom
 ## filter, a single zero entry in the hash bucket and no values.
 ##
 ## The index of the first symbol in the dynamic symbol table
 ## included in the hash table can be set to the number of dynamic symbols,

 # RUN:   FileCheck %s --allow-empty --implicit-check-not="Histogram"
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x10
       Shift2: 0x0
     BloomFilter: [ 0x0 ]
     HashBuckets: [ [[VAL]] ]
     HashValues:  [ 0x0 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Link:  .dynstr
     Entries:
       - Tag:   DT_GNU_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## Check we report warnings when the dynamic symbol table is absent or empty.
 
 ## The code locates the dynamic symbol table by the section type. Use SHT_PROGBITS to hide it.
 # RUN: yaml2obj --docnum=8 -DTYPE=SHT_PROGBITS %s -o %t12
 # RUN: llvm-readelf --elf-hash-histogram %t12 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t12 --check-prefix=ERR7
 
 # ERR7: warning: '[[FILE]]': unable to print the GNU hash table histogram: no dynamic symbol table found
 
 # RUN: yaml2obj --docnum=8 -DTYPE=SHT_DYNSYM %s -o %t13
 # RUN: llvm-readelf --elf-hash-histogram %t13 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t13 --check-prefix=ERR8
 
 # ERR8: warning: '[[FILE]]': unable to print the GNU hash table histogram: the dynamic symbol table is empty
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .gnu.hash
+        LastSec:  .gnu.hash
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x0
       Shift2: 0x0
     BloomFilter: [ 0x0 ]
     HashBuckets: [ 0x0 ]
     HashValues:  [ 0x0 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Entries:
       - Tag:   DT_GNU_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
   - Name: .dynsym
     Type: [[TYPE]]
     Size: 0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .gnu.hash
-    LastSec:  .gnu.hash

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

 # HASH-64-NOT: {{.}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:      PT_LOAD
+        Flags:     [ PF_R, PF_X ]
+        FirstSec:  .hash
+        LastSec:   .dynamic
   - Name:    .hash
     Type:    SHT_HASH
     Flags:   [ SHF_ALLOC ]
     Link:    .dynsym
     Bucket:  [ 1, 0, 0 ]
     Chain:   [ 0, 5, 4, 2, 0, 3 ]
   - Name:    .gnu.hash
     Type:    SHT_GNU_HASH
- Name:    [[NAME=eee]]
     Section: .gnu.hash
     Binding: STB_GLOBAL
     Type:    [[TYPE=STT_NOTYPE]]
   - Name:    [[NAME=bbb]]
     Section: .hash
     Binding: STB_WEAK
     Value:   0x0000000000001001
     Type:    [[TYPE=STT_NOTYPE]]
-ProgramHeaders:
-  - Type:      PT_LOAD
-    Flags:     [ PF_R, PF_X ]
-    FirstSec:  .hash
-    LastSec:   .dynamic
 
 ## Check what we print for unnamed section symbols.
 # RUN: yaml2obj --docnum=1 -DBITS=64 -DTYPE=STT_SECTION -DNAME="''" %s -o %t1-sec-syms.so
 # RUN: llvm-readelf --hash-symbols %t1-sec-syms.so 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t1-sec-syms.so --check-prefix=UNNAMED-SEC-SYMS
 
 # UNNAMED-SEC-SYMS:      Symbol table of .hash for image:
 # UNNAMED-SEC-SYMS-NEXT:  Num   {{.*}} Ndx Name

 # ONLY-HASH-32-NOT: {{.}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:    .hash
     Type:    SHT_HASH
     Flags:   [ SHF_ALLOC ]
     Link:    .dynsym
     Bucket: [ 1, 0, 0 ]
     Chain:  [ 0, 5, 4, 2, 0, 3 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
- Name:    ddd
     Value:   0x0000000000000001
   - Name:    eee
     Section: .dynamic
     Binding: STB_GLOBAL
   - Name:    bbb
     Section: .hash
     Binding: STB_WEAK
     Value:   0x0000000000001001
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Check the output when only .gnu.hash section is present.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3-32.so
 # RUN: llvm-readelf --hash-symbols %t3-32.so \
 # RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ONLY-GNUHASH-32
 
 # ONLY-GNUHASH-32: Symbol table of .gnu.hash for image:
 # ONLY-GNUHASH-32-NEXT:  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
 # ONLY-GNUHASH-32-NEXT:    2   1: 00001000     0 NOTYPE  GLOBAL DEFAULT   2 aaa
 # ONLY-GNUHASH-32-NEXT:    3   1: 00000001     0 NOTYPE  GLOBAL DEFAULT ABS ddd
 # ONLY-GNUHASH-32-NEXT:    4   2: 00000000     0 NOTYPE  GLOBAL DEFAULT   1 eee
 # ONLY-GNUHASH-32-NEXT:    5   2: 00001001     0 NOTYPE  WEAK   DEFAULT   2 bbb
 # ONLY-GNUHASH-32-NOT: {{.}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:    .gnu.hash
     Type:    SHT_GNU_HASH
     Flags:   [ SHF_ALLOC ]
     Link:    .dynsym
     Header:
       SymNdx: 0x2
       Shift2: 0x0
     BloomFilter: [ 0x0 ]
- Name:    ddd
     Value:   0x0000000000000001
   - Name:    eee
     Section: .gnu.hash
     Binding: STB_GLOBAL
   - Name:    bbb
     Section: .dynamic
     Binding: STB_WEAK
     Value:   0x0000000000001001
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## Show that if there are no hash sections, we do not print anything.
 # RUN: yaml2obj --docnum=4 %s -o %t4.so
 # RUN: llvm-readelf --hash-symbols %t4.so \
 # RUN:   | FileCheck %s --check-prefix NO-HASH --allow-empty
 
 # NO-HASH-NOT: {{.}}
 
 ## Sanity check that we can still find the dynamic symbols (i.e. the above test
 ## doesn't pass due to a mistake in the dynamic section).
 # RUN: llvm-readelf --dyn-symbols %t4.so | FileCheck %s --check-prefix DYNSYMS
 
 # DYNSYMS: Symbol table '.dynsym' contains 2 entries:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        VAddr:    0x0
+        FirstSec: .dynstr
+        LastSec:  .text.foo
+      - Type:     PT_DYNAMIC
+        Flags:    [ PF_R ]
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:         .dynstr
     Type:         SHT_STRTAB
     Flags:        [ SHF_ALLOC ]
     AddressAlign: 0x100
     EntSize:      0x1
   - Name:         .dynsym
     Type:         SHT_DYNSYM
     Flags:        [ SHF_ALLOC ]
- Name:  .text.foo
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ]
     Size:  0x40
     Address: 0x2000
     AddressAlign: 0x2000
 DynamicSymbols:
   - Name:    _Z3fooi
     Binding: STB_GLOBAL
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    VAddr:    0x0
-    FirstSec: .dynstr
-    LastSec:  .text.foo
-  - Type:     PT_DYNAMIC
-    Flags:    [ PF_R ]
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Show that we report a warning for a hash table which contains an entry of
 ## the bucket array pointing to a cycle.
 
 # RUN: yaml2obj --docnum=5 %s -o %t5.so
 # RUN: llvm-readelf --hash-symbols %t5.so 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t5.so --check-prefix=BROKEN --implicit-check-not=warning:
 
 # BROKEN:      Symbol table of .hash for image:
 # BROKEN-NEXT:  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
 # BROKEN-NEXT:    1   0: 00000000     0 NOTYPE  LOCAL  DEFAULT UND aaa
 # BROKEN: warning: '[[FILE]]': .hash section is invalid: bucket 1: a cycle was detected in the linked chain
 # BROKEN-NEXT:    1   1: 00000000     0 NOTYPE  LOCAL  DEFAULT UND aaa
 # BROKEN-NOT: {{.}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:    .hash
     Type:    SHT_HASH
     Link:    .dynsym
     Bucket:  [ 1, 1 ]
     Chain:   [ 1, 1 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Entries:
 ## llvm-readelf will read the hash table from the file offset
 ## p_offset + (p_vaddr - DT_HASH) = p_offset + (0 - 0) = p_offset,
 ## which is the start of PT_LOAD, i.e. the file offset of .hash.
       - Tag:   DT_HASH
         Value: 0x0
 DynamicSymbols:
   - Name: aaa
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Each SHT_HASH section starts with two 32-bit fields: nbucket and nchain.
 ## Check we report an error when a DT_HASH value points to data that has size less than 8 bytes.
 
 # RUN: yaml2obj --docnum=6 %s -o %t6.o
 # RUN: llvm-readelf --hash-symbols %t6.o 2>&1 | FileCheck %s --check-prefix=ERR1 -DFILE=%t6.o
 
 # ERR1: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8){{$}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FileSize: 0x23a
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:   .hash
     Type:   SHT_HASH
     Flags:  [ SHF_ALLOC ]
     Bucket: [ 0 ]
     Chain:  [ 0 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_WRITE, SHF_ALLOC ]
     Entries:
       - Tag:   DT_HASH
         Value: 0x239
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FileSize: 0x23a
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Check we report a warning when the hash table goes past the end of the file.
 
 ## Case A.1: the hash table ends right before the EOF. We have a broken nbucket
 ##           field that has a value larger than the number of buckets.
 # RUN: yaml2obj --docnum=7 %s -o %t7.1.o -DNBUCKET=0x5d
 # RUN: llvm-readelf --hash-symbols %t7.1.o 2>&1 | FileCheck %s --check-prefix=NOERR1
 # NOERR1:            Symbol table of .hash for image:

 # ERR3-NOT:  {{.}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:    .hash
     Type:    SHT_HASH
     Flags:   [ SHF_ALLOC ]
     Bucket:  [ 0 ]
     NBucket: [[NBUCKET=1]]
     Chain:   [ 0 ]
     NChain:  [[NCHAIN=1]]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_WRITE, SHF_ALLOC ]
     Entries:
       - Tag:   DT_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Check we report a proper warning when a GNU hash table goes past the end of the file.
 
 ## Case A: the 'maskwords' field is set so that the table goes past the end of the file.
 # RUN: yaml2obj --docnum=8 -D MASKWORDS=4294967295 %s -o %t.err.maskwords
 # RUN: llvm-readelf --hash-symbols %t.err.maskwords 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.err.maskwords --check-prefix=ERR4
 
 # ERR4:      Symbol table of .gnu.hash for image:
 # ERR4-NEXT:  Num Buc: Value Size Type Bind Vis Ndx Name
 # ERR4-NEXT: warning: '[[FILE]]': unable to dump the SHT_GNU_HASH section at 0x78: it goes past the end of the file
 
 ## Case B: the 'nbuckets' field is set so that the table goes past the end of the file.
 # RUN: yaml2obj --docnum=8 -D NBUCKETS=4294967295 %s -o %t.err.nbuckets
 # RUN: llvm-readelf --hash-symbols %t.err.nbuckets 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.err.nbuckets --check-prefix=ERR4
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x1
       Shift2: 0x2
 ## The number of words in the Bloom filter. The value of 2 is no-op.
       MaskWords: [[MASKWORDS=2]]
DynamicSymbols:
   - Name:    aaa
     Binding: STB_GLOBAL
   - Name:    bbb
     Binding: STB_GLOBAL
   - Name:    ccc
     Binding: STB_GLOBAL
   - Name:    ddd
     Binding: STB_GLOBAL
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## Check the behavior when the dynamic symbol table is empty or not found.
 
 ## Case A.1: Check we report a warning when the dynamic symbol table is empty and we attempt to print hash symbols
 ##         from the .hash table. The number of symbols in the dynamic symbol table can be calculated from its size
 ##         or derived from the Chain vector of the .hash table. Make both ways to return a zero to do the check.
 # RUN: yaml2obj --docnum=9 %s -o %t9.1.so
 # RUN: llvm-readelf --hash-symbols %t9.1.so 2>&1 | FileCheck %s -DFILE=%t9.1.so --check-prefix=DYNSYM-EMPTY-HASH
 
 # DYNSYM-EMPTY-HASH:      Symbol table of .hash for image:
 # DYNSYM-EMPTY-HASH-NEXT:   Num Buc:    Value  Size   Type   Bind Vis      Ndx Name
 # DYNSYM-EMPTY-HASH-NEXT: warning: '[[FILE]]': unable to print symbols for the .hash table: the dynamic symbol table is empty
 # DYNSYM-EMPTY-HASH-NOT:  {{.}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .hash
+        LastSec:  .dynstr
   - Name:   .hash
     Type:   SHT_HASH
     Flags:  [ SHF_ALLOC ]
     Bucket: [ 0 ]
     Chain:  [ ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
## 0x54 + 0x2c == 0x80 == .dynstr offset.
         Value: 0x0
   - Name:  .dynstr
     Type:  SHT_STRTAB
     Flags: [ SHF_ALLOC ]
   - Name:  .dynsym
     Type:  [[DYNSYMTYPE=SHT_DYNSYM]]
     Flags: [ SHF_ALLOC ]
     Size:  0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .hash
-    LastSec:  .dynstr
 
 ## Case A.2: similar to A.1, but now check that we report a warning when the dynamic symbol table was not found.
 ##           To do that, set the type of the .dynsym to SHT_PROGBITS to hide it.
 # RUN: yaml2obj --docnum=9 -DDYNSYMTYPE=SHT_PROGBITS %s -o %t9.2.so
 # RUN: llvm-readelf --hash-symbols %t9.2.so 2>&1 | FileCheck %s -DFILE=%t9.2.so --check-prefix=DYNSYM-NOTFOUND-HASH
 
 # DYNSYM-NOTFOUND-HASH:      Symbol table of .hash for image:
 # DYNSYM-NOTFOUND-HASH-NEXT:   Num Buc:    Value  Size   Type   Bind Vis      Ndx Name

 # DYNSYM-NOTFOUND-GNUHASH-NOT:  {{.}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .gnu.hash
+        LastSec:  .dynstr
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Header:
       SymNdx: 0x0
       Shift2: 0x0
     BloomFilter: [ 0x0 ]
     HashBuckets: [ 0x1 ]
## 0x54 + 0x3c == 0x80 == .dynstr offset.
       - Tag:   DT_NULL
         Value: 0x0
   - Name: .dynstr
     Type: SHT_STRTAB
   - Name:  .dynsym
     Type:  [[DYNSYMTYPE=SHT_DYNSYM]]
     Flags: [ SHF_ALLOC ]
     Size:  0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .gnu.hash
-    LastSec:  .dynstr
 
 ## In this case we have a broken value in the hash buckets array. Normally it contains an
 ## index into the dynamic symbol table and also is used to get a hash value from the hash values array.
 ## llvm-readelf attempts to read a symbol that is past the end of the dynamic symbol table.
 
 # RUN: yaml2obj --docnum=11 -DVALUE=0x2 %s -o %t11.past.dynsym.so
 # RUN: llvm-readelf --hash-symbols %t11.past.dynsym.so 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t11.past.dynsym.so --check-prefix=BUCKET-PAST-DYNSYM
 
 # BUCKET-PAST-DYNSYM:      Symbol table of .gnu.hash for image:
 # BUCKET-PAST-DYNSYM-NEXT:   Num Buc:    Value          Size   Type   Bind Vis      Ndx Name
 # BUCKET-PAST-DYNSYM-NEXT: warning: '[[FILE]]': unable to print hashed symbol with index 2, which is greater than or equal to the number of dynamic symbols (2)
 # BUCKET-PAST-DYNSYM-NEXT:     1   2: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT UND foo
 # BUCKET-PAST-DYNSYM-NOT:  {{.}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R, PF_X ]
+        FirstSec: .gnu.hash
+        LastSec:  .dynamic
   - Name:  .gnu.hash
     Type:  SHT_GNU_HASH
     Flags: [ SHF_ALLOC ]
     Link:  .dynsym
     Header:
       SymNdx: [[SYMNDX=0x0]]
       Shift2: 0x0
     BloomFilter: [ 0x0 ]
     HashBuckets: [ 0x0, [[VALUE]], 0x1 ]
     HashValues:  [ 0x0 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Link:  .dynstr
     Entries:
       - Tag:   DT_GNU_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols:
   - Name:    foo
     Binding: STB_GLOBAL
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R, PF_X ]
-    FirstSec: .gnu.hash
-    LastSec:  .dynamic
 
 ## In this case we are unable to read a hash value for a symbol with
 ## an index that is less than the index of the first hashed symbol.
 
 # RUN: yaml2obj --docnum=11 -DSYMNDX=0x2 -DVALUE=0x1 %s -o %t11.first.hashed.so
 # RUN: llvm-readelf --hash-symbols %t11.first.hashed.so 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t11.first.hashed.so --check-prefix=FIRST-HASHED
 

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

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS[[BITS=64]]
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: [[MACHINE]]
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:    .hash
     Type:    SHT_HASH
     Flags:   [ SHF_ALLOC ]
     Bucket:  [ 1, 2 ]
     Chain:   [ 3, 4, 5 ]
     EntSize: [[ENTSIZE=4]]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Entries:
       - Tag:   DT_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Document that we ignore the sh_entsize value when dumping the hash section.
 ## Implementation assumes that the size of entries is 4, matching the ELF specification.
 
 # RUN: yaml2obj --docnum=1 -DENTSIZE=8 -DBITS=64 -DMACHINE=EM_X86_64 %s -o %t.x64.ent8
 # RUN: yaml2obj --docnum=1 -DENTSIZE=8 -DBITS=32 -DMACHINE=EM_386 %s -o %t.x32.ent8
 
 # RUN: llvm-readobj --hash-table %t.x64.ent8 | FileCheck %s --check-prefix=HASH
- Name:  .dynamic
     Flags: [ SHF_ALLOC ]
     Entries:
       - Tag:   [[DYNTAG=DT_HASH]]
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
   - Type: SectionHeaderTable
     NoHeaders: [[NOHEADERS=false]]
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         FirstSec: .hash
         LastSec:  .dynamic
       - Type:     PT_DYNAMIC
         VAddr:    0x10
         FirstSec: .dynamic
         LastSec:  .dynamic
 
 ## Document we don't report a warning when the value of the sh_entsize field of the SHT_HASH section is not 4.
 
 # RUN: yaml2obj --docnum=2 -DENTSIZE=0xff %s -o %t.ent.size
 # RUN: llvm-readobj --hash-table %t.ent.size 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.ent.size --check-prefix=NOSHDR --implicit-check-not=warning:
 # RUN: llvm-readelf --hash-table %t.ent.size 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.ent.size --check-prefix=NOSHDR --implicit-check-not=warning:

 # ERR1-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FileSize: 0x23a
+        FirstSec: .hash
+        LastSec:  .dynamic
   - Name:   .hash
     Type:   SHT_HASH
     Flags:  [ SHF_ALLOC ]
     Bucket: [ 0 ]
     Chain:  [ 0 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_WRITE, SHF_ALLOC ]
     Entries:
       - Tag:   DT_HASH
         Value: 0x239
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FileSize: 0x23a
-    FirstSec: .hash
-    LastSec:  .dynamic
 
 ## Check we report a warning when the hash table goes past the end of the file.
 
 ## Case A.1: the hash table ends right before the EOF. We have a broken nbucket
 ##           field that has a value larger than the number of buckets.
 # RUN: yaml2obj --docnum=4 %s -o %t5.1.o -DNBUCKET=0x5d -DNCHAIN=0x1
 # RUN: llvm-readelf --hash-table %t5.1.o 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NOERR1 --implicit-check-not="warning:"

 # ERR3-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .hash
+        LastSec: .dynamic
   - Name:    .hash
     Type:    SHT_HASH
     Flags:   [ SHF_ALLOC ]
     Bucket:  [ 0 ]
     NBucket: [[NBUCKET]]
     Chain:   [ 0 ]
     NChain:  [[NCHAIN]]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_WRITE, SHF_ALLOC ]
     Entries:
       - Tag:   DT_HASH
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
 DynamicSymbols: []
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .hash
-    LastSec: .dynamic
 
 ## Show we do not duplicate warnings when printing both the hash table and the hash histogram.
 ## Note that --elf-hash-histogram is only implemented for llvm-readelf currently.
 # RUN: yaml2obj --docnum=3 %s -o %t4.o
 # RUN: llvm-readelf --hash-table --elf-hash-histogram %t4.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=SINGLE-WARN -DFILE=%t4.o --implicit-check-not="warning:"
 
 # SINGLE-WARN:      warning: '[[FILE]]': hash table nchain (0) differs from symbol count derived from SHT_DYNSYM section header (1)
 # SINGLE-WARN-NEXT: HashTable {
 # SINGLE-WARN-NEXT: warning: '[[FILE]]': the hash table at offset 0x2b1 goes past the end of the file (0x2b8)
 # SINGLE-WARN-NEXT: }

llvm/test/tools/llvm-readobj/ELF/headers.test

 # RUN: cmp %t.headers.llvm.txt %t.all.llvm.txt
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type: PT_LOAD
   - Name: .foo
     Type: SHT_PROGBITS
-ProgramHeaders:
-  - Type: PT_LOAD

llvm/test/tools/llvm-readobj/ELF/loadname.test

 
 !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        VAddr:    0x0000
+        FileSize: [[PHDRFILESIZE]]
+        FirstSec: .dynstr
+        LastSec:  .dynamic
   - Name:  .dynstr
     Type:  SHT_STRTAB
     Flags: [ SHF_ALLOC ]
     Content: '746573742e736f00' ## "test.so"
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Link:  .dynstr
     Entries:
       - Tag:   DT_STRTAB
         Value: [[DTSTRTABVAL]]
       - Tag:   DT_STRSZ
         Value: 0x0000000000000008
       - Tag:   DT_SONAME
         Value: 0x0000000000000000
       - Tag:   DT_NULL
         Value: 0x0000000000000000
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_R ]
-    VAddr:    0x0000
-    FileSize: [[PHDRFILESIZE]]
-    FirstSec: .dynstr
-    LastSec:  .dynamic
 
 ## Check we do not crash when an object contains a DT_STRTAB entry whose address
 ## is past the end of the object.
 ## Note that we have to set p_filesz for PT_LOAD larger than DT_STRTAB value
 ## to trigger this particular warning.
 
 # RUN: yaml2obj -DDTSTRTABVAL=0xFFFE -DPHDRFILESIZE=0xFFFF %s -o %t.err.1.o
 # RUN: llvm-readobj %t.err.1.o 2>&1 | FileCheck %s -DFILE=%t.err.1.o --check-prefixes=BROKEN-OFFSET,BROKEN-OFFSET-LLVM
 # RUN: llvm-readelf --dynamic-table %t.err.1.o 2>&1 | FileCheck %s -DFILE=%t.err.1.o --check-prefixes=BROKEN-OFFSET,BROKEN-OFFSET-GNU
 
 # BROKEN-OFFSET:      warning: '[[FILE]]': unable to parse DT_STRTAB: can't map virtual address 0xfffe to the segment with index 1: the segment ends at 0x10077, which is greater than the file size (0x228)
 # BROKEN-OFFSET:      warning: '[[FILE]]': string table was not found
 # BROKEN-OFFSET-LLVM: LoadName: <?>
 # BROKEN-OFFSET-GNU:  0x000000000000000e (SONAME) Library soname: [<?>]

llvm/test/tools/llvm-readobj/ELF/malformed-pt-dynamic.test

 # WARN6-NOHEADERS: warning: '[[FILE]]': PT_DYNAMIC segment offset (0x1000) + file size (0xffffffff) exceeds the size of the file (0x1009)
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS=64]]
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_DYNAMIC
+        FileSize: [[FILESIZE=<none>]]
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name:     .dynamic
     Type:     SHT_DYNAMIC
     Address:  0x1000
     Offset:   0x1000
     ShOffset: [[OFFSET=<none>]]
     Entries:
       - Tag:   DT_NULL
         Value: 0
   - Type: SectionHeaderTable
     NoHeaders: [[NOHEADERS=false]]
-ProgramHeaders:
-  - Type:     PT_DYNAMIC
-    FileSize: [[FILESIZE=<none>]]
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/needed-libs.test

 # NEEDED-LIBS-NEXT:{{^}}]{{$}}
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type: PT_LOAD
+        VAddr: 0x0
+        FirstSec: .dynstr
+        LastSec:  .dynamic
   - Name:  .dynstr
     Type:  SHT_STRTAB
     Flags: [ SHF_ALLOC ]
     Content: '00616161006262620063636300' ## 0,a,a,a,0,b,b,b,0,c,c,c,0
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Entries:
       - Tag:   DT_STRTAB
         Value: 0x0000000000000000
       - Tag:   DT_NEEDED
         Value: 0x9999999
       - Tag:   DT_NEEDED
         Value: 9
       - Tag:   DT_NEEDED
         Value: 1
       - Tag:   DT_NEEDED
         Value: 5
       - Tag:   DT_NEEDED
         Value: 0x1111111
       - Tag:   DT_STRSZ
         Value: [[SIZE=0xD]]
       - Tag:   DT_NULL
         Value: 0x0
-ProgramHeaders:
-  - Type: PT_LOAD
-    VAddr: 0x0
-    FirstSec: .dynstr
-    LastSec:  .dynamic
 
 ## Check what we print when the dynamic string table is empty.
 # RUN: yaml2obj %s --docnum=2 -o %t2
 # RUN: llvm-readobj --needed-libs %t2 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t2 --implicit-check-not=warning: --check-prefix=EMPTY-DYNSTR
 # RUN: llvm-readelf --needed-libs %t2 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t2 --implicit-check-not=warning: --check-prefix=EMPTY-DYNSTR
 
 # EMPTY-DYNSTR:      NeededLibraries [
 # EMPTY-DYNSTR-NEXT: warning: '[[FILE]]': string table at offset 0x78: unable to read the string at 0x79: it goes past the end of the table (0x78)
 # EMPTY-DYNSTR-NEXT: warning: '[[FILE]]': string table at offset 0x78: unable to read the string at 0x7a: it goes past the end of the table (0x78)
 # EMPTY-DYNSTR-NEXT:   <?>
 # EMPTY-DYNSTR-NEXT:   <?>
 # EMPTY-DYNSTR-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x0
+        FirstSec: .dynstr
+        LastSec:  .dynamic
   - Name:  .dynstr
     Type:  SHT_STRTAB
     Flags: [ SHF_ALLOC ]
     Size:  0
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Address: 0x1000
     Entries:
       - Tag:   DT_STRTAB
         Value: 0x0000000000000000
       - Tag:   DT_NEEDED
         Value: 1
       - Tag:   DT_NEEDED
         Value: 2
       - Tag:   DT_STRSZ
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x0
-    FirstSec: .dynstr
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/non-dynamic-in-pt-dynamic.test

 # GNU-NEXT:   0x0000000000000000 (NULL)     0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .dynamic
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .text
+        LastSec:  .dynamic
   - Name: .text
     Type: SHT_PROGBITS
     Flags: [SHF_ALLOC]
     Address: 0x1000
     AddressAlign: 0x100
     Content: "00"
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Flags: [SHF_ALLOC]
     Address: 0x1001
     Entries:
       - Tag:   DT_BIND_NOW
         Value: 0x1
       - Tag:   DT_NULL
         Value: 0x0
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .dynamic
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .text
-    LastSec:  .dynamic
 
 ## In this case .text goes after .dynamic and we don't display any warnings,
 ## though the content of the .text is used for dumping the dynamic table.
 
 # RUN: yaml2obj --docnum=2 %s -o %t2.o
 # RUN: llvm-readobj --dynamic-table %t2.o 2>&1 | FileCheck %s --check-prefix=LLVM2
 # RUN: llvm-readelf --dynamic-table %t2.o 2>&1 | FileCheck %s --check-prefix=GNU2
 

 # GNU2-NEXT:   0x0000000000000000 (NULL)     0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .text
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .text
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Flags: [SHF_ALLOC]
     Address: 0x1000
     AddressAlign: 0x1000
     Entries:
       - Tag:   DT_BIND_NOW
         Value: 0x1
       - Tag:   DT_BIND_NOW
         Value: 0x2
   - Name: .text
     Type: SHT_PROGBITS
     Flags: [SHF_ALLOC]
     Address: 0x1100
     AddressAlign: 0x100
     Content: "00000000000000000000000000000000"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .text
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .text
 
 ## In this case .text goes after .dynamic, but (PT_DYNAMIC segment size % dynamic entry size != 0)
 ## and we have to use the information from the section header instead.
 
 # RUN: yaml2obj --docnum=3 %s -o %t3.o
 # RUN: llvm-readobj --dynamic-table %t3.o 2>&1 | FileCheck %s --DFILE=%t3.o --check-prefixes=WARNING2,LLVM3
 # RUN: llvm-readelf --dynamic-table %t3.o 2>&1 | FileCheck %s --DFILE=%t3.o --check-prefixes=WARNING2,GNU3
 

 # GNU3-NEXT:   0x0000000000000000 (NULL)     0x0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .text
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .text
   - Name: .dynamic
     Type: SHT_DYNAMIC
     Flags: [SHF_ALLOC]
     Address: 0x1000
     AddressAlign: 0x1000
     Entries:
       - Tag:   DT_BIND_NOW
         Value: 0x1
       - Tag:   DT_NULL
         Value: 0x0
   - Name: .text
     Type: SHT_PROGBITS
     Flags: [SHF_ALLOC]
     Address: 0x1100
     AddressAlign: 0x100
     Content: "00"
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .text
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .text

llvm/test/tools/llvm-readobj/ELF/note-core-ntfile-bad.test

 # end:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_CORE
 Sections:
-  - Name:    .note.foo
-    Type:    SHT_NOTE
-    Content: 0500000008000000454C4946434F5245000000000000000000000000
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         FirstSec: .note.foo
         LastSec:  .note.foo
+  - Name:    .note.foo
+    Type:    SHT_NOTE
+    Content: 0500000008000000454C4946434F5245000000000000000000000000
 
 # RUN: yaml2obj --docnum=2 %s -o %t2.o
 # RUN: llvm-readelf -n %t2.o 2>&1 | FileCheck -DFILE=%t2.o %s --check-prefix=ERR-NULL-TERM
 # RUN: llvm-readobj -n %t2.o 2>&1 | FileCheck -DFILE=%t2.o %s --check-prefix=ERR-NULL-TERM
 
 # ERR-NULL-TERM: warning: '[[FILE]]': unable to read note with index 0 from the PT_NOTE segment with index 0: the note is not NUL terminated
 
 # .section ".note.foo", "a"

 # end:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_CORE
 Sections:
-  - Name:    .note.foo
-    Type:    SHT_NOTE
-    Content: 050000002C000000454C4946434F5245000000000100000000000000001000000000000000100000000000000020000000000000003000000000000078787878
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         FirstSec: .note.foo
         LastSec:  .note.foo
+  - Name:    .note.foo
+    Type:    SHT_NOTE
+    Content: 050000002C000000454C4946434F5245000000000100000000000000001000000000000000100000000000000020000000000000003000000000000078787878
 
 # RUN: yaml2obj --docnum=3 %s -o %t3.o
 # RUN: llvm-readelf -n %t3.o 2>&1 | FileCheck -DFILE=%t3.o %s --check-prefix=ERR-FILE-COUNT
 # RUN: llvm-readobj -n %t3.o 2>&1 | FileCheck -DFILE=%t3.o %s --check-prefix=ERR-FILE-COUNT
 
 # ERR-FILE-COUNT: warning: '[[FILE]]': unable to read note with index 0 from the PT_NOTE segment with index 0: unable to read file mappings (found 2): the note of size 0x2c is too short
 
 # .section ".note.foo", "a"

 # end:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_CORE
 Sections:
-  - Name:    .note.foo
-    Type:    SHT_NOTE
-    Content: 050000002C000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000078797A00
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         FirstSec: .note.foo
         LastSec:  .note.foo
+  - Name:    .note.foo
+    Type:    SHT_NOTE
+    Content: 050000002C000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000078797A00
 
 # RUN: yaml2obj --docnum=4 %s -o %t4.o
 # RUN: llvm-readelf -n %t4.o 2>&1 | FileCheck -DFILE=%t4.o %s --check-prefix=ERR-FILE-END-EARLY
 # RUN: llvm-readobj -n %t4.o 2>&1 | FileCheck -DFILE=%t4.o %s --check-prefix=ERR-FILE-END-EARLY
 
 # ERR-FILE-END-EARLY: warning: '[[FILE]]': unable to read note with index 0 from the PT_NOTE segment with index 0: unable to read the file name for the mapping with index 2: the note of size 0x44 is truncated
 
 # .section ".note.foo", "a"

 # end:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_CORE
 Sections:
-  - Name:    .note.foo
-    Type:    SHT_NOTE
-    Content: 0500000044000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000000400000000000000050000000000000006000000000000078797A00
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         FirstSec: .note.foo
         LastSec:  .note.foo
+  - Name:    .note.foo
+    Type:    SHT_NOTE
+    Content: 0500000044000000454C4946434F5245000000000200000000000000001000000000000000100000000000000020000000000000003000000000000000400000000000000050000000000000006000000000000078797A00

llvm/test/tools/llvm-readobj/ELF/note-core-ntfile.test

 # end:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_CORE
 Sections:
-  - Name:        .note.foo
-    Type:        SHT_NOTE
-    Content:     0500000080000000454C4946434F524500000000030000000000000000100000000000000010000000000000002000000000000000300000000000000040000000000000005000000000000000600000000000000070000000000000008000000000000000900000000000002F706174682F746F2F612E6F7574002F706174682F746F2F6C6962632E736F005B737461636B5D00
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_NOTE
         FirstSec: .note.foo
         LastSec:  .note.foo
+  - Name:        .note.foo
+    Type:        SHT_NOTE
+    Content:     0500000080000000454C4946434F524500000000030000000000000000100000000000000010000000000000002000000000000000300000000000000040000000000000005000000000000000600000000000000070000000000000008000000000000000900000000000002F706174682F746F2F612E6F7574002F706174682F746F2F6C6962632E736F005B737461636B5D00
 
 # GNU:      Displaying notes found
 # GNU-NEXT:   Owner                 Data size       Description
 # GNU-NEXT:   CORE                  0x00000080      NT_FILE (mapped files)
 # GNU-NEXT:     Page size: 4096
 # GNU-NEXT:                  Start                 End         Page Offset
 # GNU-NEXT:     0x0000000000001000  0x0000000000002000  0x0000000000003000
 # GNU-NEXT:         /path/to/a.out

llvm/test/tools/llvm-readobj/ELF/note-core.test

 # CHECK-LLVM-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_CORE
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_NOTE
+        FirstSec: .note.foo
+        LastSec:  .note.foo
   - Name: .note.foo
     Type: SHT_NOTE
     Notes:
       - Name: CORE
         Type: [[TYPE]]
-ProgramHeaders:
-  - Type:     PT_NOTE
-    FirstSec: .note.foo
-    LastSec:  .note.foo

llvm/test/tools/llvm-readobj/ELF/program-headers.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS[[BITS]]
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: [[MACHINE]]
 Sections:
-  - Name:    .foo.begin
-    Type:    SHT_PROGBITS
-    Flags:   [ SHF_ALLOC ]
-    Address: 0x1000
-    Size:    0x1
-  - Name:    .foo.end
-    Type:    SHT_PROGBITS
-    Flags:   [ SHF_ALLOC ]
-    Size:    0x2
-  - Name:    .bar.begin
-    Type:    SHT_PROGBITS
-    Flags:   [ SHF_ALLOC ]
-    Address: 0x2000
-    Size:    0x3
-  - Name:    .bar.end
-    Type:    SHT_PROGBITS
-    Flags:   [ SHF_ALLOC ]
-    Size:    0x4
-  - Name:    .interp
-    Type:    SHT_PROGBITS
-    Flags:   [ SHF_ALLOC ]
-    Address: 0x3000
-    Content: "41424300" ## "ABC"
-  - Name:    .tls
-    Type:    SHT_PROGBITS
-    Flags:   [ SHF_ALLOC, SHF_TLS ]
-    Address: 0x4000
-    Size:    0x1
-  - Name:    .unused
-    Type:    SHT_PROGBITS
-    Flags:   [ SHF_ALLOC, SHF_TLS ]
-    Address: 0x5000
-    Size:    0x1
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
 ## Case 1: an arbitrary segment with sections.
       - Type:     PT_PHDR
         Flags:    [ PF_W ]
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 2: another segment with different sections.
       - Type:     PT_PHDR
         Flags:    [ PF_X ]
         VAddr:    0x2000
         FirstSec: .bar.begin
         LastSec:  .bar.end
 ## Case 3: the PT_NULL segment.
       - Type:     PT_NULL
         Flags:    [ PF_X ]
         VAddr:    0x2000
         FirstSec: .bar.begin
         LastSec:  .bar.end
 ## Case 4: the PT_DYNAMIC segment.
       - Type:     PT_DYNAMIC
         Flags:    [ PF_R, PF_W, PF_X ]
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 5: the PT_INTERP segment.
       - Type:     PT_INTERP
         Flags:    [ PF_R, PF_W ]
         VAddr:    0x3000
         FirstSec: .interp
         LastSec:  .interp
 ## Case 6: the PT_NOTE segment.
       - Type:     PT_NOTE
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 7: the PT_SHLIB segment.
       - Type:     PT_SHLIB
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.begin
 ## Case 8: the PT_TLS segment.
       - Type:     PT_TLS
         VAddr:    0x4000
         FirstSec: .tls
         LastSec:  .tls
 ## Case 9: the PT_LOOS segment.
       - Type:     0x60000000 ## PT_LOOS
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 10: the PT_GNU_EH_FRAME segment.
       - Type:     PT_GNU_EH_FRAME
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 11: the PT_SUNW_UNWIND segment.
       - Type:     0x6464e550 ## PT_SUNW_UNWIND
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 12: the PT_GNU_STACK segment.
       - Type:     PT_GNU_STACK
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 13: the PT_GNU_RELRO segment.
       - Type:     PT_GNU_RELRO
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 14: the PT_GNU_PROPERTY segment.
       - Type:     PT_GNU_PROPERTY
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 15: the PT_OPENBSD_RANDOMIZE segment.
       - Type:     0x65a3dbe6 ## PT_OPENBSD_RANDOMIZE
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 16: the PT_OPENBSD_WXNEEDED segment.
       - Type:     0x65a3dbe7 ## PT_OPENBSD_WXNEEDED
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 17: the PT_OPENBSD_BOOTDATA segment.
       - Type:     0x65a41be6 ## PT_OPENBSD_BOOTDATA
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 18: the PT_HIOS segment.
       - Type:     0x6fffffff ## PT_HIOS
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 19: the PT_LOPROC/PT_ARM_ARCHEXT/PT_MIPS_REGINFO segment.
       - Type:     0x70000000 ## PT_LOPROC/PT_ARM_ARCHEXT/PT_MIPS_REGINFO
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 20: the PT_ARM_EXIDX/PT_MIPS_RTPROC segment.
       - Type:     0x70000001 ## PT_ARM_EXIDX, PT_MIPS_RTPROC
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 20: the PT_MIPS_OPTIONS segment.
       - Type:     0x70000002 ## PT_MIPS_OPTIONS
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 21: the PT_MIPS_ABIFLAGS segment.
       - Type:     0x70000003 ## PT_MIPS_ABIFLAGS
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec:  .foo.end
 ## Case 22: the PT_HIPROC segment.
       - Type:     0x7fffffff ## PT_HIPROC
         VAddr:    0x1000
         FirstSec: .foo.begin
         LastSec: .foo.end
+  - Name:    .foo.begin
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Address: 0x1000
+    Size:    0x1
+  - Name:    .foo.end
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Size:    0x2
+  - Name:    .bar.begin
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Address: 0x2000
+    Size:    0x3
+  - Name:    .bar.end
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Size:    0x4
+  - Name:    .interp
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Address: 0x3000
+    Content: "41424300" ## "ABC"
+  - Name:    .tls
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC, SHF_TLS ]
+    Address: 0x4000
+    Size:    0x1
+  - Name:    .unused
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC, SHF_TLS ]
+    Address: 0x5000
+    Size:    0x1
 
 ## Check how we dump ARM specific program headers.
 # RUN: yaml2obj --docnum=1 -DBITS=64 -DMACHINE=EM_ARM %s -o %tarm.elf
 # RUN: llvm-readelf --program-headers %tarm.elf | FileCheck %s --check-prefix=ARM-GNU
 # RUN: llvm-readobj --program-headers %tarm.elf | FileCheck %s --check-prefix=ARM-LLVM
 
 # ARM-GNU:      <unknown>: 0x70000000 0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1
 # ARM-GNU-NEXT:            EXIDX      0x000548 0x0000000000001000 0x0000000000001000 0x000003 0x000003 0x1

 # ERROR-INTERP-NEXT: warning: '[[FILE]]': unable to read program interpreter name at offset 0xaabbccddeeff1122: it goes past the end of the file (0x[[#OFFSET + 3]])
 # ERROR-INTERP-NEXT: INTERP         0xaabbccddeeff1122
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
 ## Case 1: the offset points to the first additional byte.
       - Type:   PT_INTERP
         Offset: 616
 ## Case 1: the offset points to the second additional byte,
 ##         which is a null byte.
       - Type:   PT_INTERP
         Offset: 617
 ## Case 3: the offset points to the third additional
 ##         byte, which is the last byte in the file.
       - Type:   PT_INTERP
         Offset: 618
 ## Case 4: the offset goes 1 byte past the end of the file.
       - Type:   PT_INTERP
         Offset: 619
 ## Case 5: an arbitrary large offset that goes past the end of the file.
       - Type:   PT_INTERP
         Offset: 0xAABBCCDDEEFF1122
 ## Case 6: the same as case 5. Used to demonstrate that we don't report
 ##         the same warning twice.
       - Type:   PT_INTERP
         Offset: 0xAABBCCDDEEFF1122
 
 ## Check we report a warning when we are unable to read program headers.
 ## Case A: the e_phentsize field is invalid.
 # RUN: yaml2obj --docnum=3 -DPHENTSIZE=1 %s -o %t.phdr.err
 # RUN: llvm-readelf --program-headers %t.phdr.err 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.phdr.err --check-prefix=WARN-PHENTSIZE-GNU
 # RUN: llvm-readobj --program-headers %t.phdr.err 2>&1 | \
 # RUN:   FileCheck %s -DFILE=%t.phdr.err --check-prefix=WARN-PHENTSIZE-LLVM

 --- !ELF
 FileHeader:
   Class:      ELFCLASS64
   Data:       ELFDATA2LSB
   Type:       ET_EXEC
   EPhEntSize: [[PHENTSIZE=<none>]]
   EPhOff:     [[PHOFF=<none>]]
 Sections:
-  - Name: .foo
-    Type: SHT_PROGBITS
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_PHDR
         FirstSec: .foo
         LastSec:  .foo
+  - Name: .foo
+    Type: SHT_PROGBITS
 
 ## Case B: the value of the e_phoff field is invalid.
 
 ## Check that we do not report a warning when the program header table ends right before the end of the file.
 ## 0x160 + size of headers (56) == file size.
 # RUN: yaml2obj --docnum=3 -DPHOFF=0x160 %s -o %t.phdr.no.err2
 # RUN: llvm-readelf %t.phdr.no.err2 --program-headers 2>&1 | FileCheck %s --implicit-check-not=warning:
 # RUN: llvm-readobj %t.phdr.no.err2 --program-headers 2>&1 | FileCheck %s --implicit-check-not=warning:

llvm/test/tools/llvm-readobj/ELF/reloc-negative-addend-no-sym.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .rela.dyn
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .text
     Type: SHT_PROGBITS
     Size: 0x10
   - Name: .rela.text
     Type: SHT_RELA
     Info: .text
     Relocations:
       - Offset: 0
- Name: .rela.dyn
     AddressAlign: 0x100
     Relocations:
       - Offset: 8
         Type: R_X86_64_NONE
         Addend: -1
 DynamicSymbols:
   - Name:    force_dynsym
     Binding: STB_GLOBAL
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .rela.dyn
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/reloc-zero-name-or-value.test

 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_EXEC
   Machine: EM_X86_64
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .rela.dyn
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .text
     Type: SHT_PROGBITS
     Size: 0x10
   - Name: .rela.text
     Type: SHT_RELA
     Link: .symtab
     Info: .text
     Relocations:
DynamicSymbols:
   - Value:   0x123
     Section: .text
     Binding: STB_GLOBAL
   - Type:  STT_SECTION
     Index: 0
   - Value:   0x0
     Section: .text
     Binding: STB_GLOBAL
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .rela.dyn
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/symtab-shndx.test

 # LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .bar
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .section1
     Type: SHT_PROGBITS
   - Name: .section2
     Type: SHT_PROGBITS
   - Name: .section3
     Type: SHT_PROGBITS
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
- Name:  sym1
     Index: SHN_XINDEX
   - Name:  sym2
     Index: SHN_XINDEX
 DynamicSymbols:
   - Name:  dynsym1
     Index: SHN_XINDEX
   - Name:  dynsym2
     Index: SHN_XINDEX
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .bar
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic
 
 ## Check that we locate the SHT_SYMTAB_SHNDX section using the DT_SYMTAB_SHNDX
 ## dynamic tag when dumping dynamic symbols. In this case we make the value of
 ## DT_SYMTAB_SHNDX point to the SHT_SYMTAB_SHNDX section that is
 ## linked with the static symbol table and check that we use it.
 
 # RUN: yaml2obj --docnum=1 -DSYMTABSHNDX=0x2000 %s -o %t2
 # RUN: llvm-readelf --dyn-syms %t2 2>&1 | FileCheck %s --check-prefix=DYNTAG-GNU

 # PASTEND-LLVM-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .symtab_shndx
+      - Type:     PT_DYNAMIC
+        VAddr:    0x1000
+        FirstSec: .dynamic
+        LastSec:  .dynamic
   - Name: .section1
     Type: SHT_PROGBITS
   - Name: .section2
     Type: SHT_PROGBITS
   - Name:    .dynamic
     Type:    SHT_DYNAMIC
     Flags:   [ SHF_ALLOC ]
     Address: 0x1000
- Name:    .symtab_shndx
     Address: 0x2000
   - Type:      SectionHeaderTable
     NoHeaders: true
 DynamicSymbols:
   - Name:  dynsym1
     Index: SHN_XINDEX
   - Name:  dynsym2
     Index: SHN_XINDEX
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .symtab_shndx
-  - Type:     PT_DYNAMIC
-    VAddr:    0x1000
-    FirstSec: .dynamic
-    LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/unwind.test

 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
   Entry:           0x0000000000400000
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x00400000
+        PAddr:    0x00400000
+        FirstSec: .text
+        LastSec:  .text
+      - Type:     PT_GNU_EH_FRAME
+        Flags:    [ PF_X, PF_R ]
+        VAddr:    0x004013C0
+        PAddr:    0x004013C0
+        MemSize:  [[MEMSIZE]]
+        FileSize: [[FILESIZE]]
+        FirstSec: .eh_frame_hdr
+        LastSec:  .eh_frame_hdr
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x0000000000400000
     AddressAlign:    16
     Content:         50C704240020400031C05AC3
   - Name:            .eh_frame_hdr
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Address:         0x00000000004013c0
     AddressAlign:    4
     Content:         011B033B3C00000006000000E0F0FFFF8800000010F1FFFF58000000F6F1FFFFB000000010F2FFFFD000000090FEFFFF0001000000FFFFFF30010000
   - Name:            .eh_frame
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000401400
     AddressAlign:    8
     Content:         1400000000000000017A5200017810011B0C070890010710140000001C000000B0F0FFFF2A00000000000000000000001400000000000000017A5200017810011B0C070890010000240000001C00000050F0FFFF20000000000E10460E184A0F0B770880003F1A3B2A332422000000001C000000440000003EF1FFFF1000000000410E108602430D064B0C07080000002C0000006400000038F1FFFF7F0C000000450C0A00491006027600450F0376780603660C0C0A00450C070800000000002C0000009400000088FDFFFF6600000000410E108602430D06428F03458E04478D058C06488307024B0C07080000000014000000C4000000C8FDFFFF01000000000000000000000000000000
 Symbols:
   - Name:            myfunc
     Type:            STT_FUNC
     Section:         .text
     Value:           0x0000000000400000
     Binding:         STB_GLOBAL
-ProgramHeaders:
-  - Type:     PT_LOAD
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x00400000
-    PAddr:    0x00400000
-    FirstSec: .text
-    LastSec:  .text
-  - Type:     PT_GNU_EH_FRAME
-    Flags:    [ PF_X, PF_R ]
-    VAddr:    0x004013C0
-    PAddr:    0x004013C0
-    MemSize:  [[MEMSIZE]]
-    FileSize: [[FILESIZE]]
-    FirstSec: .eh_frame_hdr
-    LastSec:  .eh_frame_hdr
 
 ## Document we report a error when the memory size of the PT_GNU_EH_FRAME does not match its file size.
 ## TODO: we want to report a warning and continue dumping instead.
 # RUN: yaml2obj --docnum=1 %s -DMEMSIZE=0x3b -DFILESIZE=0x3c -o %t1.size.mismatch
 # RUN: not llvm-readobj --unwind %t1.size.mismatch 2>&1 | \
 # RUN:   FileCheck -DFILE=%t1.size.mismatch %s --check-prefix=SIZE-MISMATCH
 # RUN: not llvm-readelf --unwind %t1.size.mismatch 2>&1 | \
 # RUN:   FileCheck -DFILE=%t1.size.mismatch %s --check-prefix=SIZE-MISMATCH

 # BROKEN-CONTENT-NEXT:   Corresponding Section:
 # BROKEN-CONTENT-NEXT: error: '[[FILE]]': program header  [index 0] has a p_offset ([[OFFSET]]) + p_filesz ([[SIZE]]) that is greater than the file size (0xe0)
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS[[BITS]]
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_GNU_EH_FRAME
         MemSize:  [[SIZE]]
         FileSize: [[SIZE]]
         Offset:   [[OFFSET]]
 
 ## Case B: test we report an error when the file size of the PT_GNU_EH_FRAME
 ##         is invalid (goes past the end of the file).
 # RUN: yaml2obj --docnum=4 %s -o %t6 -DOFFSET=0x100 -DSIZE=0xffff0000 -DBITS=32
 # RUN: not llvm-readobj --unwind %t6 2>&1 \
 # RUN:   | FileCheck %s -DFILE=%t6 --check-prefix=BROKEN-CONTENT -DOFFSET=0x100 -DSIZE=0xffff0000
 
 ## Case C: test we report an error when the offset + the file size of the PT_GNU_EH_FRAME is so large a

llvm/test/tools/llvm-xray/ARM/extract-instrmap.test

 --- !ELF
 FileHeader:
   Class:           ELFCLASS32
   Data:            ELFDATA2LSB
   Type:            ET_DYN
   Machine:         EM_ARM
   Flags:           [ EF_ARM_SOFT_FLOAT, EF_ARM_EABI_VER5 ]
   Entry:           0x00000000000012B0
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_R ]
         FirstSec: .rel.dyn
         LastSec:  .rel.dyn
         Align:    0x0000000000001000
       - Type:     PT_LOAD
         Flags:    [ PF_X, PF_R ]
         FirstSec: .text
         LastSec:  .text
         VAddr:    0x00000000000012B0
         Align:    0x0000000000001000
       - Type:     PT_LOAD
         Flags:    [ PF_W, PF_R ]
         FirstSec: xray_instr_map
         LastSec:  xray_fn_idx
         VAddr:    0x00000000000033CC
         Align:    0x0000000000001000
-Sections:
   - Name:            .rel.dyn
     Type:            SHT_REL
     Flags:           [ SHF_ALLOC ]
     Address:         0x0000000000000200
     Link:            .dynsym
     AddressAlign:    0x0000000000000004
     Relocations:
       - Offset:          0x00000000000033CC

llvm/test/tools/obj2yaml/ELF/eshnum.yaml

 # NO-SECTIONS-NEXT:   Data:   ELFDATA2LSB
 # NO-SECTIONS-NEXT:   Type:   ET_REL
 # NO-SECTIONS-NEXT:   EShNum: 0x0
 ## Note: yaml2obj will create the SHT_NULL section with sh_size = 0 implicitly.
 # NO-SECTIONS-NEXT: ...
 
 ## In the test case below we have an object without a section header table and e_shnum == 0.
 ## Document how we dump it.
-## FIXME: we should emit the `SectionHeaderTable` key with `NoHeaders=true` for this case.
+## FIXME: we should emit the `SectionHeaderTable` chunk with `NoHeaders=true` for this case.
 
 # RUN: yaml2obj %s -DESHOFF=0x0 -o %t3
 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=NO-HEADERS
 
 # NO-HEADERS:      --- !ELF
 # NO-HEADERS-NEXT: FileHeader:
 # NO-HEADERS-NEXT:   Class: ELFCLASS64
 # NO-HEADERS-NEXT:   Data:  ELFDATA2LSB
 # NO-HEADERS-NEXT:   Type:  ET_REL
 # NO-HEADERS-NEXT: ...

llvm/test/tools/obj2yaml/ELF/offset.yaml

 ## The expected file offset of the first section is:
 ## 0x40 (start of program headers) + 0x38 (size of program headers) * 2(number of program headers) = 0xB0
 # RUN: yaml2obj %s --docnum=2 -DFIRSTOFF=0xB0 -o %t4b.o
 # RUN: obj2yaml %t4b.o | FileCheck %s --check-prefix=FIRSTSECPHDRS
 # RUN: yaml2obj %s --docnum=2 -DFIRSTOFF=0xB1 -o %t4c.o
 # RUN: obj2yaml %t4c.o | FileCheck %s --check-prefixes=FIRSTSECPHDRS,FIRSTSECPHDRSOFFSET
 
 #       FIRSTSECPHDRS:      Sections:
+#       FIRSTSECPHDRS-NEXT:   - Type: ProgramHeaderTable
+#       FIRSTSECPHDRS-NEXT:     Segments:
+#       FIRSTSECPHDRS-NEXT:       - Type: PT_LOAD
+#       FIRSTSECPHDRS-NEXT:       - Type: PT_LOAD
 #       FIRSTSECPHDRS-NEXT:   - Name:   .foo
 #       FIRSTSECPHDRS-NEXT:     Type:   SHT_PROGBITS
 # FIRSTSECPHDRSOFFSET-NEXT:     Offset: 0xB1
 #       FIRSTSECPHDRS-NEXT:   ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type: PT_LOAD
+      - Type: PT_LOAD
   - Name:   .foo
     Type:   SHT_PROGBITS
     Offset: [[FIRSTOFF=<none>]]
-ProgramHeaders:
-  - Type: PT_LOAD
-  - Type: PT_LOAD
 
 ## Test that when there are no program headers in the file, we don't take SHT_NOBITS
 ## section sizes into account, but respect their alignment when calculating the expected
 ## section offsets.
 
 # RUN: yaml2obj %s --docnum=3 -o %t5.o
 # RUN: obj2yaml %t5.o | FileCheck %s --check-prefix=NOBITS
 

 ## the expected offsets when there are program headers in the file. The rule is the following:
 ## we assume that the file space is allocated for the SHT_NOBITS section when there are
 ## other non-nobits sections in the same segment that follows it.
 
 # RUN: yaml2obj %s --docnum=4 -o %t6.o
 # RUN: obj2yaml %t6.o | FileCheck %s --check-prefix=NOBITS-PHDRS
 
 # NOBITS-PHDRS:      Sections:
-# NOBITS-PHDRS-NEXT:   - Name:    .nobits1
+# NOBITS-PHDRS:        - Name:    .nobits1
 # NOBITS-PHDRS-NEXT:     Type:    SHT_NOBITS
 # NOBITS-PHDRS-NEXT:     Size:    0x1
 # NOBITS-PHDRS-NEXT:   - Name:    .progbits
 # NOBITS-PHDRS-NEXT:     Type:    SHT_PROGBITS
 # NOBITS-PHDRS-NEXT:     Content: '0000'
 # NOBITS-PHDRS-NEXT:   - Name:    .nobits3
 # NOBITS-PHDRS-NEXT:     Type:    SHT_NOBITS
 # NOBITS-PHDRS-NEXT:     Size:    0x100
 # NOBITS-PHDRS-NEXT:   - Name:    .nobits4
 # NOBITS-PHDRS-NEXT:     Type:    SHT_NOBITS
 # NOBITS-PHDRS-NEXT:     Size:    0x200
 # NOBITS-PHDRS-NEXT:   - Name:    .nobits5
 # NOBITS-PHDRS-NEXT:     Type:    SHT_NOBITS
 # NOBITS-PHDRS-NEXT:     Offset:  0x100
 # NOBITS-PHDRS-NEXT:     Size:    0x300
 # NOBITS-PHDRS-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .nobits1
+        LastSec:  .progbits
+      - Type:     PT_LOAD
+        FirstSec: .nobits3
+        LastSec:  .nobits4
+      - Type:     PT_LOAD
+        FirstSec: .nobits5
+        LastSec:  .nobits5
 ## sh_offset == 0xe8.
   - Name: .nobits1
     Type: SHT_NOBITS
     Size: 0x1
 ## sh_offset == 0xe9.
   - Name: .progbits
     Type: SHT_PROGBITS
     Size: 0x2
 ## sh_offset == 0xeb.
   - Name: .nobits3
     Type: SHT_NOBITS
     Size: 0x100
 ## sh_offset == 0xeb.
   - Name: .nobits4
     Type: SHT_NOBITS
     Size: 0x200
 ## sh_offset == 0x100.
   - Name:   .nobits5
     Type:   SHT_NOBITS
     Size:   0x300
     Offset: 0x100
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .nobits1
-    LastSec:  .progbits
-  - Type:     PT_LOAD
-    FirstSec: .nobits3
-    LastSec:  .nobits4
-  - Type:     PT_LOAD
-    FirstSec: .nobits5
-    LastSec:  .nobits5

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

 # SEGMENT-MAPPING-NEXT:   04     .dynamic {{$}}
 # SEGMENT-MAPPING-NEXT:   05     .dynamic {{$}}
 # SEGMENT-MAPPING-NEXT:   06{{ *$}}
 # SEGMENT-MAPPING-NEXT:   07     .gnu.hash {{$}}
 # SEGMENT-MAPPING-NEXT:   08     .gnu.hash {{$}}
 # SEGMENT-MAPPING-NEXT:   None   .symtab .strtab .shstrtab {{$}}
 
 ## Check that obj2yaml produced a correct program headers description.
+## Document that obj2yaml is unable to dump the "Offset" key properly at this moment.
 
 # 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:  - 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:  - 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:  - 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:  - 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:  - Type:     PT_GNU_RELRO
-# YAML-NEXT:    Flags:    [ PF_R ]
-# YAML-NEXT:    FirstSec: .dynamic
-# YAML-NEXT:    LastSec:  .dynamic
-# YAML-NEXT:    VAddr:    0x3EF0
-# YAML-NEXT:  - Type:  PT_LOAD
-# YAML-NEXT:    Flags: [ PF_R ]
-# YAML-NEXT:    VAddr: 0x4000
-# 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:  - Type:     PT_LOAD
-# YAML-NEXT:    Flags:    [ PF_R ]
-# YAML-NEXT:    FirstSec: .gnu.hash
-# YAML-NEXT:    LastSec:  .gnu.hash
-# YAML-NEXT:    VAddr:    0x1A0
-# YAML-NEXT: Sections:
+# RUN: yaml2obj %s -DOFFSET=0x100 -o %t1.offset
+# RUN: obj2yaml %t1.offset | FileCheck %s --check-prefix=YAML
+
+# YAML:     Sections:
+# YAML-NEXT:  - Type: ProgramHeaderTable
+# YAML-NEXT:    Segments:
+# YAML-NEXT:      - Type:     PT_LOAD
+# YAML-NEXT:        Flags:    [ PF_R ]
+# YAML-NEXT:        FirstSec: .hash
+# YAML-NEXT:        LastSec:  .dynstr
+# YAML-NEXT:        Align:    0x1000
+# 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:      - 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:      - 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:      - 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:      - Type:     PT_GNU_RELRO
+# YAML-NEXT:        Flags:    [ PF_R ]
+# YAML-NEXT:        FirstSec: .dynamic
+# YAML-NEXT:        LastSec:  .dynamic
+# YAML-NEXT:        VAddr:    0x3EF0
+# YAML-NEXT:      - Type:  PT_LOAD
+# YAML-NEXT:        Flags: [ PF_R ]
+# YAML-NEXT:        VAddr: 0x4000
+# 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:      - Type:     PT_LOAD
+# YAML-NEXT:        Flags:    [ PF_R ]
+# YAML-NEXT:        FirstSec: .gnu.hash
+# YAML-NEXT:        LastSec:  .gnu.hash
+# YAML-NEXT:        VAddr:    0x1A0
+# YAML-NEXT:  - Name:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
-ProgramHeaders:
+Sections:
+  - Type:   ProgramHeaderTable
+    Offset: [[OFFSET=<none>]]
+    Segments:
 ## 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 ]
         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 ]
         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 ]
         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 ]
         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 ]
         FirstSec: .dynamic
         LastSec:  .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 ]
         FirstSec: .dynamic
         LastSec:  .dynamic
         VAddr:    0x3EF0
         Align:    0x1
 ## Show we can dump a standalone empty segment.
       - Type:  PT_LOAD
         Flags: [ PF_R ]
         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 ]
         FirstSec: .gnu.hash
         LastSec:  .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 ]
         FirstSec: .gnu.hash
         LastSec:  .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
     Flags:   [ SHF_ALLOC ]

 
 ## 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:   FirstSec: .empty.tls.start
-# EMPTY-NEXT:   LastSec:  .empty.tls.end
-# EMPTY-NEXT:   VAddr:    0x1000
-# EMPTY-NEXT:   Align:    0x1000
-# 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: - 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: - 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: Sections:
+# EMPTY:      Sections:
+# EMPTY-NEXT:   - Type: ProgramHeaderTable
+# EMPTY-NEXT:     Segments:
+# EMPTY-NEXT:   - 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:   - 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:   - 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:   - 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: - Name:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - 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
         LastSec:  .empty.tls.start
         VAddr:    0x1000
         Align:    0x1
       - Type:     PT_TLS
         Flags:    [ PF_W, PF_R ]
         FirstSec: .empty.tls.middle
         LastSec:  .empty.tls.middle
         VAddr:    0x1100
         Align:    0x1
       - Type:     PT_TLS
         Flags:    [ PF_W, PF_R ]
         FirstSec: .empty.tls.end
         LastSec:  .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
     Flags: [ SHF_ALLOC ]

 # RUN: obj2yaml %t3 | FileCheck %s --check-prefix=MISALIGNED-YAML
 
 ## 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:    FirstSec: .foo
-# MISALIGNED-YAML-NEXT:    LastSec:  .foo
-# MISALIGNED-YAML-NEXT:    VAddr:    0x1000
-# MISALIGNED-YAML-NEXT:    Align:    0x1000
-# MISALIGNED-YAML-NEXT: Sections:
+# MISALIGNED-YAML:       - Type: ProgramHeaderTable
+# MISALIGNED-YAML-NEXT:    Segments:
+# 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:  - Name:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_R ]
         FirstSec: .foo
         LastSec:  .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:   FirstSec: .alloc.1
-# NON-ALLOC-NEXT:   LastSec:  .non-alloc.1
-# 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: - Type:     PT_LOAD
-# NON-ALLOC-NEXT:   Flags:    [ PF_R ]
-# NON-ALLOC-NEXT:   FirstSec: .alloc.2
-# NON-ALLOC-NEXT:   LastSec:  .alloc.2
-# 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: Sections:
+# NON-ALLOC:      Sections:
+# NON-ALLOC-NEXT:   - Type: ProgramHeaderTable
+# NON-ALLOC-NEXT:     Segments:
+# 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:       - 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:       - Type:     PT_LOAD
+# NON-ALLOC-NEXT:         Flags:    [ PF_R ]
+# NON-ALLOC-NEXT:         FirstSec: .alloc.2
+# NON-ALLOC-NEXT:         LastSec:  .alloc.2
+# 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:   - Name:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_R ]
         FirstSec: .alloc.1
         LastSec:  .non-alloc.1
       - Type:     PT_LOAD
         Flags:    [ PF_R ]
         FirstSec: .alloc.1
         LastSec:  .non-alloc.2
       - Type:     PT_LOAD
         Flags:    [ PF_R ]
         FirstSec: .non-alloc.2
         LastSec:  .alloc.2
       - Type:     PT_LOAD
         Flags:    [ PF_R ]
         FirstSec: .alloc.1
         LastSec:  .alloc.2
-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:     FirstSec: .bss
-# NOBITS-NEXT:     LastSec:  .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:    0x200000000
-# NOBITS-NEXT: Sections:
+# NOBITS:       - Type: ProgramHeaderTable
+# NOBITS-NEXT:    Segments:
+# NOBITS-NEXT:      - Type:     PT_LOAD
+# NOBITS-NEXT:        Flags:    [ PF_W, PF_R ]
+# NOBITS-NEXT:        FirstSec: .bss
+# NOBITS-NEXT:        LastSec:  .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:    0x200000000
+# NOBITS-NEXT: - Name:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
 ## Case 1: the segment contains a single SHT_NOBITS section.
       - Type:     PT_LOAD
         Flags:    [ PF_W, PF_R ]
         FirstSec: .bss
         LastSec:  .bss
 ## Case 2: the SHT_NOBITS section is the last section in the segment.
       - 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 ]
         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 ]
         FirstSec: .bss
         LastSec:  .data.2
  ## Case 5: another two SHT_NOBITS sections in a different segment.
       - 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
     Type:   SHT_NOBITS

 # 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:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
 ## 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 ]
         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 ]
         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 ]
         FirstSec: .bar
         LastSec:  .zed
         VAddr:    0x1001
-Sections:
   - Name:    .foo
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x1
     Address: 0x1000
   - Name:    .bar
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]

 # ZERO-SIZE-MAPPING:        [ 1] .empty.foo  PROGBITS 0000000000001000 000078 000000
 # 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:     FirstSec: .empty.bar1
-# ZERO-SIZE-NEXT:     LastSec:  .empty.bar2
-# ZERO-SIZE-NEXT:     VAddr:    0x2000
-# ZERO-SIZE-NEXT: Sections:
+# ZERO-SIZE:      - Type: ProgramHeaderTable
+# ZERO-SIZE-NEXT:    Segments:
+# 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: - Name:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_W, PF_R ]
         FirstSec: .bar
         LastSec:  .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 ]
     Address: 0x2000

 
 ## 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:    FirstSec: .empty_middle
-# BROKEN-VA-NEXT:    LastSec:  .empty_middle
-# BROKEN-VA-NEXT:    VAddr:    0x1000
+# BROKEN-VA:      Sections:
+# BROKEN-VA-NEXT:   - Type: ProgramHeaderTable
+# BROKEN-VA-NEXT:     Segments:
+# BROKEN-VA-NEXT:       - Type:     PT_LOAD
+# BROKEN-VA-NEXT:         Flags:    [ PF_W, PF_R ]
+# BROKEN-VA-NEXT:         FirstSec: .empty_middle
+# BROKEN-VA-NEXT:         LastSec:  .empty_middle
+# BROKEN-VA-NEXT:         VAddr:    0x1000
+# BROKEN-VA-NEXT:   - Name:
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - 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
     Name:    begin
   - Name:    .empty_middle
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
     Address: 0xFEFEFEFE
   - Type:    Fill
     Pattern: "00"
     Size:    1
   - Name:    .empty_end
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC, SHF_EXECINSTR ]
     Address: 0xFEFEFEFE
+
+## Document that obj2yaml currently always dumps the program header
+## table at the begining of the sections list.
+## FIXME: we should preserve the right chunks order.
+
+# RUN: yaml2obj --docnum=9 %s -o %t9
+# RUN: obj2yaml %t9 | FileCheck %s --check-prefix=ORDER
+
+# ORDER:      Sections:
+# ORDER-NEXT:   - Type: ProgramHeaderTable
+# ORDER-NEXT:     Segments:
+# ORDER-NEXT:       - Type: PT_LOAD
+# ORDER-NEXT:   - Name: .foo
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+    Size: 0x1
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type: PT_LOAD
+  - Type: SectionHeaderTable
+    NoHeaders: [[NOHEADERS=false]]
+
+## Check we are able to dump the program header table when
+## there is no section header table in an object.
+## FIXME: we should emit the `SectionHeaderTable` chunk with `NoHeaders=true` for this case.
+##        See the similar FIXME in the eshnum.yaml test case.
+
+# RUN: yaml2obj --docnum=9 -DNOHEADERS=true %s -o %t9.noheaders
+# RUN: obj2yaml %t9.noheaders | FileCheck %s --check-prefix=NOHEADERS
+
+# NOHEADERS:      --- !ELF
+# NOHEADERS-NEXT: FileHeader:
+# NOHEADERS-NEXT:   Class: ELFCLASS64
+# NOHEADERS-NEXT:   Data:  ELFDATA2LSB
+# NOHEADERS-NEXT:   Type:  ET_EXEC
+# NOHEADERS-NEXT: Sections:
+# NOHEADERS-NEXT:   - Type: ProgramHeaderTable
+# NOHEADERS-NEXT:     Segments:
+# NOHEADERS-NEXT:       - Type: PT_LOAD
+# NOHEADERS-NEXT: ...

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

 # PHDR:   GNU_RELRO 0x0000c5 0x0000000000000105 0x0000000000000105 0x000045 0x000045     0x1
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x100
+        FirstSec: fill1
+        LastSec:  fill2
+      - Type:     PT_GNU_RELRO
+        VAddr:    0x105
+        FirstSec: fill2
+        LastSec:  fill2
   - Type:    Fill
     Name:    fill1
     Pattern: ""
     Size:    0x10
   - Name:         .bar
     Type:         SHT_PROGBITS
     Size:         0x5
     Address:      0x100
     AddressAlign: 2
   - Type:    Fill
     Name:    fill2
     Pattern: ""
     Size:    0x45
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x100
-    FirstSec: fill1
-    LastSec:  fill2
-  - Type:     PT_GNU_RELRO
-    VAddr:    0x105
-    FirstSec: fill2
-    LastSec:  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
 

 # UNKNOWN-ERR: error: unknown section or fill referenced: 'fill' by the 'LastSec' 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: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         FirstSec: fill
         LastSec:  fill
+  - Type:    Fill
+    Pattern: ""
+    Size:    0
 
 ## 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

 # CHECK-NEXT: ]
 
 !ELF
 FileHeader:
   Class: ELFCLASS32
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
-  - Name:            .dynamic
-    Type:            SHT_DYNAMIC
-    Flags:           [ SHF_ALLOC ]
-    Address:         0x0000000000000008
-    AddressAlign:    0x0000000000000008
-    EntSize:         0x0000000000000010
-    Entries:
-      - Tag:             DT_STRSZ
-        Value:           0x0000000000000001
-      - Tag:             DT_NULL
-        Value:           0x0000000000000000
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:     PT_LOAD
         Flags:    [ PF_R ]
         VAddr:    0x0000
         Align:    8
         FirstSec: .dynamic
         LastSec:  .dynamic
       - Type:     PT_DYNAMIC
         Flags:    [ PF_X, PF_R ]
         VAddr:    0x0008
         FirstSec: .dynamic
         LastSec:  .dynamic
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000000008
+    AddressAlign:    0x0000000000000008
+    EntSize:         0x0000000000000010
+    Entries:
+      - Tag:             DT_STRSZ
+        Value:           0x0000000000000001
+      - Tag:             DT_NULL
+        Value:           0x0000000000000000

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

 # DEFAULT: Number of section headers:         3
 # DEFAULT: Section header string table index: 2
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
-ProgramHeaders:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - 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:
+Sections:
+  - Type: ProgramHeaderTable
+    Segments:
       - 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

 # CHECK-NEXT:  LOAD 0x000120 0x00000000aaaa1000 0x00000000bbbb2000 0x000001 0x000001 R E 0x1
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
-  - Name:    .foo
-    Type:    SHT_PROGBITS
-    Flags:   [ SHF_ALLOC ]
-    Size:    0x1
-    Address: 0x1234
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
 ## 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 ]
 ## 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 ]
         FirstSec: .foo
         LastSec:  .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
         FirstSec: .foo
         LastSec:  .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
         FirstSec: .foo
         LastSec:  .foo
+  - Name:    .foo
+    Type:    SHT_PROGBITS
+    Flags:   [ SHF_ALLOC ]
+    Size:    0x1
+    Address: 0x1234

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

 # CHECK-NEXT: }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:  PT_TLS
+        Align: 16
+        FirstSec: .tdata
+        LastSec:  .tbss
   - Name:         .tdata
     Type:         SHT_PROGBITS
     AddressAlign: 4
   - Name:         .tbss
     Type:         SHT_NOBITS
     AddressAlign: 64
-ProgramHeaders:
-  - Type:  PT_TLS
-    Align: 16
-    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:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .text
+        LastSec:  .text.hot
   - Name:         .text
     Type:         SHT_PROGBITS
     AddressAlign: 4
   - Name:         .text.hot
     Type:         SHT_PROGBITS
     AddressAlign: 16
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .text
-    LastSec:  .text.hot

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

 ## In this test we check that we allocate file space for SHT_NOBITS sections when
 ## there are non-nobits sections in the same segment after them. When an object has
 ## multiple segments, we check each and allocate the space if at least one matches the
 ## condition mentioned.
 
 ## Case A. In this case there are no non-nobits sections after SHT_NOBITS sections in segments.
 ##         Because of this the file space for SHT_NOBITS sections is not allocated.
 # RUN: yaml2obj %s -D SEC1=.data.before -D SEC2=.nobits.1 -o %t1
 # RUN: llvm-readelf --sections --segments %t1 | FileCheck %s --check-prefix=NO-ALLOC
 
 # NO-ALLOC:      [Nr] Name         Type     Address          Off    Size
-# NO-ALLOC:      [ 1] .data.before PROGBITS 0000000000000000 0000b0 000001
-# NO-ALLOC-NEXT: [ 2] .nobits.1    NOBITS   0000000000000001 0000b1 000002
-# NO-ALLOC-NEXT: [ 3] .data.after  PROGBITS 0000000000000003 0000b1 000003
-# NO-ALLOC-NEXT: [ 4] .nobits.2    NOBITS   0000000000000006 0000b4 000004
+# NO-ALLOC:      [ 1] .data.before PROGBITS 0000000000000070 0000b0 000001
+# NO-ALLOC-NEXT: [ 2] .nobits.1    NOBITS   0000000000000071 0000b1 000002
+# NO-ALLOC-NEXT: [ 3] .data.after  PROGBITS 0000000000000073 0000b1 000003
+# NO-ALLOC-NEXT: [ 4] .nobits.2    NOBITS   0000000000000076 0000b4 000004
 ## .fill of size 0x5 is placed here.
-# NO-ALLOC-NEXT: [ 5] .data.last   PROGBITS 000000000000000f 0000b9 000006
+# NO-ALLOC-NEXT: [ 5] .data.last   PROGBITS 000000000000007f 0000b9 000006
 
 # NO-ALLOC:       Type Offset   VirtAddr           PhysAddr           FileSiz  MemSiz
 # NO-ALLOC-NEXT:  LOAD 0x0000b0 0x0000000000000000 0x0000000000000000 0x000001 0x000003
 # NO-ALLOC-NEXT:  LOAD 0x0000b0 0x0000000000000000 0x0000000000000000 0x000001 0x000003
 
 ## Case B. We have a segment that has a non-nobits section after the SHT_NOBITS section ".nobits.1".
 ##         The file space is allocated for it, but not for ".nobits.2",
 ##         which does not belong to any segment.
 # RUN: yaml2obj %s -D SEC1=.nobits.1 -D SEC2=.data.after -o %t2
 # RUN: llvm-readelf --sections --segments %t2 | FileCheck %s --check-prefix=ALLOC-FIRST
 
 # ALLOC-FIRST:      [Nr] Name         Type     Address          Off    Size
-# ALLOC-FIRST:      [ 1] .data.before PROGBITS 0000000000000000 0000b0 000001
-# ALLOC-FIRST-NEXT: [ 2] .nobits.1    NOBITS   0000000000000001 0000b1 000002
-# ALLOC-FIRST-NEXT: [ 3] .data.after  PROGBITS 0000000000000003 0000b3 000003
-# ALLOC-FIRST-NEXT: [ 4] .nobits.2    NOBITS   0000000000000006 0000b6 000004
+# ALLOC-FIRST:      [ 1] .data.before PROGBITS 0000000000000070 0000b0 000001
+# ALLOC-FIRST-NEXT: [ 2] .nobits.1    NOBITS   0000000000000071 0000b1 000002
+# ALLOC-FIRST-NEXT: [ 3] .data.after  PROGBITS 0000000000000073 0000b3 000003
+# ALLOC-FIRST-NEXT: [ 4] .nobits.2    NOBITS   0000000000000076 0000b6 000004
 ## .fill of size 0x5 is placed here.
-# ALLOC-FIRST-NEXT: [ 5] .data.last   PROGBITS 000000000000000f 0000bb 000006
+# ALLOC-FIRST-NEXT: [ 5] .data.last   PROGBITS 000000000000007f 0000bb 000006
 
 # ALLOC-FIRST:       Type Offset   VirtAddr           PhysAddr           FileSiz  MemSiz
 # ALLOC-FIRST-NEXT:  LOAD 0x0000b0 0x0000000000000000 0x0000000000000000 0x000001 0x000003
 # ALLOC-FIRST-NEXT:  LOAD 0x0000b1 0x0000000000000000 0x0000000000000000 0x000005 0x000005
 
 ## Case C. We have a Fill after the ".nobits.2" section. In this case the file space is
 ##         allocated for it, because fills are handled just like any other non-nobits sections.
 # RUN: yaml2obj %s -D SEC1=.nobits.2 -D SEC2=.fill -o %t3
 # RUN: llvm-readelf --sections --segments %t3 | FileCheck %s --check-prefix=FILL-AT-END
 
 # FILL-AT-END: [Nr] Name       Type     Address          Off    Size
-# FILL-AT-END: [ 4] .nobits.2  NOBITS   0000000000000006 0000b4 000004
+# FILL-AT-END: [ 4] .nobits.2  NOBITS   0000000000000076 0000b4 000004
 ## .fill of size 0x5 is placed here.
-# FILL-AT-END: [ 5] .data.last PROGBITS 000000000000000f 0000bd 000006
+# FILL-AT-END: [ 5] .data.last PROGBITS 000000000000007f 0000bd 000006
 
 # FILL-AT-END:      Type Offset   VirtAddr           PhysAddr           FileSiz  MemSiz
 # FILL-AT-END-NEXT: LOAD 0x0000b0 0x0000000000000000 0x0000000000000000 0x000001 0x000003
 # FILL-AT-END-NEXT: LOAD 0x0000b4 0x0000000000000000 0x0000000000000000 0x000009 0x000009
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+## 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 ]
+        FirstSec: .data.before
+        LastSec:  .nobits.1
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        FirstSec: [[SEC1]]
+        LastSec:  [[SEC2]]
   - Name:  .data.before
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x1
   - Name:  .nobits.1
     Type:  SHT_NOBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x2
   - Name:  .data.after
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x3
   - Name:  .nobits.2
     Type:  SHT_NOBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x4
   - Type:    Fill
     Name:    .fill
     Pattern: "00"
     Size:    5
   - 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 ]
-    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
 
 # MIDDLE:      [Nr] Name      Type     Address          Off    Size
-# MIDDLE:      [ 1] .nobits.1 NOBITS   0000000000000000 000078 000001
-# MIDDLE-NEXT: [ 2] .data     PROGBITS 0000000000000001 000079 000010
-# MIDDLE-NEXT: [ 3] .nobits.2 NOBITS   0000000000000011 000089 000100
+# MIDDLE:      [ 1] .nobits.1 NOBITS   0000000000000038 000078 000001
+# MIDDLE-NEXT: [ 2] .data     PROGBITS 0000000000000039 000079 000010
+# MIDDLE-NEXT: [ 3] .nobits.2 NOBITS   0000000000000049 000089 000100
 # MIDDLE-NEXT: [ 4] .strtab   STRTAB   0000000000000000 000089 000001
 
 # MIDDLE:      Type Offset   VirtAddr           PhysAddr           FileSiz  MemSiz
 # MIDDLE-NEXT: LOAD 0x000078 0x0000000000000000 0x0000000000000000 0x000011 0x000111
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Flags:    [ PF_R ]
+        FirstSec: .nobits.1
+        LastSec:  .nobits.2
   - Name:  .nobits.1
     Type:  SHT_NOBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x1
   - 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 ]
-    FirstSec: .nobits.1
-    LastSec:  .nobits.2

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

 # CHECK: ]
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
-  - Name: .text
-    Type: SHT_PROGBITS
-    Size: 4
-    ShOffset: 0x1000
-    AddressAlign: 0x1000
-  - Name: .rodata
-    Type: SHT_PROGBITS
-    Size: 4
-    ShOffset: 0x2000
-    AddressAlign: 0x1000
-  - Name: .data
-    Type: SHT_PROGBITS
-    ShOffset: 0x2004
-    Size: 4
-  - Name: .nobits1
-    Type: SHT_NOBITS
-    ShOffset: 0x2008
-    Size: 1
-  - Name: .nobits2
-    Type: SHT_NOBITS
-    # Intentionally set to 0x2009 though the previous section is SHT_NOBITS.
-    ShOffset: 0x2009
-    Size: 1
-ProgramHeaders:
-  # Program header with no sections.
+  - Type: ProgramHeaderTable
+    Segments:
+## Program header with no sections.
       - Type:     0x6abcdef0 # arbitrary type
         Offset:   0x1234
         FileSize: 1111
         MemSize:  9999
-  # Program header with only file size set.
+## Program header with only file size set.
       - Type:     0x6abcdef0
         FileSize: 6
         FirstSec: .rodata
         LastSec:  .rodata
-  # Program header with only mem size set.
+## Program header with only mem size set.
       - Type:     0x6abcdef0
         MemSize:  6
         FirstSec: .rodata
         LastSec:  .rodata
-  # Program header with only offset set.
+## Program header with only offset set.
       - Type:     0x6abcdef0
         Offset:   0x1fff
         FirstSec: .rodata
         LastSec:  .rodata
-  # Program header with sections, valid properties.
+## Program header with sections, valid properties.
       - Type:     0x6abcdef0
         Offset:   0xffe
         FileSize: 7
         MemSize:  9
         FirstSec: .text
         LastSec:  .text
-  # Program header with invalid properties.
+## Program header with invalid properties.
       - Type:     0x6abcdef0
         Offset:   0x3000
         FileSize: 3
         MemSize:  2
-  # Program header with 2 SHT_NOBITS sections.
+## Program header with 2 SHT_NOBITS sections.
       - Type:     0x6abcdef0
         Offset:   0x2004
         FirstSec: .data
         LastSec:  .nobits2
+  - Name: .text
+    Type: SHT_PROGBITS
+    Size: 4
+    ShOffset: 0x1000
+    AddressAlign: 0x1000
+  - Name: .rodata
+    Type: SHT_PROGBITS
+    Size: 4
+    ShOffset: 0x2000
+    AddressAlign: 0x1000
+  - Name: .data
+    Type: SHT_PROGBITS
+    ShOffset: 0x2004
+    Size: 4
+  - Name: .nobits1
+    Type: SHT_NOBITS
+    ShOffset: 0x2008
+    Size: 1
+  - Name: .nobits2
+    Type: SHT_NOBITS
+    # Intentionally set to 0x2009 though the previous section is SHT_NOBITS.
+    ShOffset: 0x2009
+    Size: 1
 
 ## 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
 
 # DEFAULT-OFFSET:      [Nr] Name Type     Address          Off
 # DEFAULT-OFFSET:      [ 1] .foo PROGBITS 0000000000001000 0000b0
 # DEFAULT-OFFSET-NEXT: [ 2] .bar PROGBITS 0000000000001001 0000b1
 
 # DEFAULT-OFFSET:       Type Offset
 # DEFAULT-OFFSET-NEXT:  LOAD 0x0000b0
 # DEFAULT-OFFSET-NEXT:  LOAD 0x0000b1
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: .foo
+        LastSec:  .bar
+      - Type:     PT_LOAD
+        FirstSec: .bar
+        LastSec:  .bar
   - Name:    .foo
     Type:    SHT_PROGBITS
     Flags:   [ SHF_ALLOC ]
     Size:    0x1
     Address: 0x1000
   - Name:  .bar
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
     Size:  0x1
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: .foo
-    LastSec:  .bar
-  - Type:     PT_LOAD
-    FirstSec: .bar
-    LastSec:  .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 | \
 # RUN:   FileCheck %s --check-prefixes=VALID-OFFSET,VALID-OFFSET-EQ
 
 # VALID-OFFSET: [Nr] Name Type     Address          Off
-# VALID-OFFSET: [ 1] .foo PROGBITS 0000000000000000 000078
+# VALID-OFFSET: [ 1] .foo PROGBITS 0000000000000038 000078
 
 # VALID-OFFSET:      Type Offset
 # VALID-OFFSET-EQ:   LOAD 0x000078
 # VALID-OFFSET-LESS: LOAD 0x000077
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
-  - Name:  .foo
-    Type:  SHT_PROGBITS
-    Flags: [ SHF_ALLOC ]
-    Size:  0x1
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - Type:    PT_LOAD
         Offset:  [[OFFSET]]
         FirstSec: .foo
         LastSec:  .foo
+  - Name:  .foo
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC ]
+    Size:  0x1
 
 ## 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".
 # RUN: yaml2obj --docnum=4 %s -o %t5
 # RUN: llvm-readelf %t5 --sections --program-headers | FileCheck %s --check-prefix=SHOFFSET
 
 # SHOFFSET: [Nr] Name Type     Address          Off
-# SHOFFSET: [ 1] .foo PROGBITS 0000000000000000 ffffffff
+# SHOFFSET: [ 1] .foo PROGBITS 0000000000000038 ffffffff
 
 # SHOFFSET:      Type Offset
 # SHOFFSET-NEXT: LOAD 0xffffff00
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        Offset:   0xFFFFFF00
+        FirstSec: .foo
+        LastSec:  .foo
   - 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
-    FirstSec: .foo
-    LastSec:  .foo

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

 # RUN: yaml2obj --docnum=1 %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
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    AddressAlign:    0x0000000000001000
-    Content:         "00000000"
-  - Name:            .init
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Content:         "00000000"
-    AddressAlign:    0x0000000000000010
-  - Name:            .data
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC ]
-    Content:         "00000000"
-    AddressAlign:    0x0000000000001000
-ProgramHeaders:
+  - Type: ProgramHeaderTable
+    Segments:
       - 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
         LastSec:  .data
       - Type: PT_GNU_EH_FRAME
       - Type: PT_GNU_STACK
       - Type: PT_GNU_RELRO
       - Type: PT_GNU_PROPERTY
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000001000
+    Content:         "00000000"
+  - Name:            .init
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Content:         "00000000"
+    AddressAlign:    0x0000000000000010
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Content:         "00000000"
+    AddressAlign:    0x0000000000001000
 
 #CHECK:     ProgramHeaders [
 #CHECK-NEXT:   ProgramHeader {
 #CHECK-NEXT:    Type: PT_LOAD
 #CHECK-NEXT:    Offset: 0x1000
 #CHECK-NEXT:    VirtualAddress: 0xAAAA1000
 #CHECK-NEXT:    PhysicalAddress: 0xFFFF1000
 #CHECK-NEXT:    FileSize: 20

 # UNKNOWN-ERR: error: unknown section or fill referenced: '.unknown2' by the 'LastSec' key of the program header with index 0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        FirstSec: [[FIRST=<none>]]
+        LastSec:  [[LAST=<none>]]
   - Name:   .foo
     Type:   SHT_PROGBITS
     Offset: 0x100
     Size:   0x10
   - Name:   .bar
     Type:   SHT_PROGBITS
     Offset: 0x200
     Size:   0x20
   - Name:   .zed
     Type:   SHT_PROGBITS
     Offset: 0x300
     Size:   0x30
   - Name:   .fill1
     Type:   Fill
     Offset: 0x400
     Size:   0x40
   - Name:   .fill2
     Type:   Fill
     Offset: 0x500
     Size:   0x50
-ProgramHeaders:
-  - Type:     PT_LOAD
-    FirstSec: [[FIRST=<none>]]
-    LastSec:  [[LAST=<none>]]
 
 ## Check we report an error when the index of the section specified by the "FirstSec" key
 ## is greater than the index of the section specified by the "LastSec" key.
 
 # RUN: not yaml2obj -DFIRST=".bar" -DLAST=".foo" --docnum=2 %s 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ORDER-ERR
 
 # ORDER-ERR: error: program header with index 0: the section index of .bar is greater than the index of .foo

 # FILL1: Type Offset   VirtAddr           PhysAddr           FileSiz  MemSiz
 # FILL1: LOAD 0x000100 0x0000000000000000 0x0000000000000000 0x000340 0x000340
 
 # RUN: yaml2obj --docnum=2 -DFIRST=".foo" -DLAST=".fill2" %s -o %t5b
 # RUN: llvm-readelf --program-headers %t5b | FileCheck %s --check-prefix=FILL2
 
 # FILL2: Type Offset   VirtAddr           PhysAddr           FileSiz  MemSiz
 # FILL2: LOAD 0x000100 0x0000000000000000 0x0000000000000000 0x000450 0x000450
+
+## Check that the size of the program header might affect the virtual
+## addresses and offsets of following sections.
+
+# RUN: yaml2obj --docnum=3 %s -o %t6.1
+# RUN: llvm-readelf --sections %t6.1 | FileCheck %s --check-prefix=SECTIONS-VA1
+# RUN: yaml2obj --docnum=3 -DTYPE2="" %s -o %t6.2
+# RUN: llvm-readelf --sections %t6.2 | FileCheck %s --check-prefix=SECTIONS-VA2
+
+##              [Nr] Name Type     Address          Off
+# SECTIONS-VA1: [ 1] .foo PROGBITS 0000000000000070 0000b0
+# SECTIONS-VA2: [ 1] .foo PROGBITS 0000000000000038 000078
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Type:   ProgramHeaderTable
+    Offset: [[OFFSET=<none>]]
+    Segments:
+      - Type: PT_LOAD
+      [[TYPE2=- Type: PT_LOAD]]
+  - Name:  .foo
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC ]
+
+## Check that we can place the program header table at an
+## arbitrary offset before other sections.
+
+# RUN: yaml2obj --docnum=3 -DOFFSET=0x100 %s -o %t6.3
+# RUN: llvm-readelf --file-header --sections %t6.3 | \
+# RUN:   FileCheck %s --check-prefix=OFFSET
+
+# OFFSET: Start of program headers:          256 (bytes into file)
+# OFFSET: Size of program headers:           56 (bytes)
+# OFFSET: Number of program headers:         2
+
+## 256 + 56 * 2 == 368 == 0x170.
+# OFFSET: [Nr] Name  Type     Address          Off
+# OFFSET: [ 1] .foo  PROGBITS 0000000000000070 000170
+
+## Check that we can place the program header table at an
+## arbitrary offset that is not alligned to the platform address size.
+
+# RUN: yaml2obj --docnum=3 -DOFFSET=0x101 %s -o %t6.4
+# RUN: llvm-readelf --file-header --sections %t6.4 | \
+# RUN:   FileCheck %s --check-prefix=MISALIGNED-OFFSET
+
+## 257 == 0x101.
+# MISALIGNED-OFFSET: Start of program headers: 257 (bytes into file)
+
+## Check we can place the program header table somewhere in
+## the middle of the sections list.
+
+# RUN: yaml2obj --docnum=4 %s -o %t7.1
+# RUN: llvm-readelf --file-header --sections %t7.1 | \
+# RUN:   FileCheck %s --check-prefixes=MIDDLE,MIDDLE1 -DSTART=64
+
+# RUN: yaml2obj --docnum=4 -DOFFSET=0x100 %s -o %t7.2
+# RUN: llvm-readelf --file-header --sections %t7.2 | \
+# RUN:   FileCheck %s --check-prefixes=MIDDLE,MIDDLE2 -DSTART=256
+
+# MIDDLE: Start of program headers: [[START]] (bytes into file)
+# MIDDLE:  [Nr] Name Type     Address          Off
+# MIDDLE:  [ 1] .foo PROGBITS 0000000000000000 000040
+# MIDDLE1: [ 2] .bar PROGBITS 0000000000000038 000078
+# MIDDLE2: [ 2] .bar PROGBITS 0000000000000038 000138
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name:  .foo
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC ]
+    Offset: [[FOOOFF=<none>]]
+  - Type:   ProgramHeaderTable
+    Offset: [[OFFSET=<none>]]
+    Segments:
+      - Type: PT_LOAD
+  - Name:  .bar
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC ]
+
+## Check we align the start of the program headers to the
+## platform address size automatically.
+
+# RUN: yaml2obj --docnum=4 %s -DFOOOFF=0x101 -o %t7.3
+# RUN: llvm-readelf --file-header %t7.3 | FileCheck %s --check-prefix=ALIGN
+
+## alignTo(8, 0x101) == 0x108 == 264.
+# ALIGN: Start of program headers: 264 (bytes into file)
+
+## Check we can omit the "Segments" key to create an empty program header table.
+
+# RUN: yaml2obj --docnum=5 %s -o %t8
+# RUN: llvm-readelf --file-header %t8 | FileCheck %s --check-prefix=EMPTY
+
+# EMPTY: Start of program headers:  64 (bytes into file)
+# EMPTY: Number of program headers: 0
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Type: ProgramHeaderTable
+
+## Check we don`t allow having multiple ProgramHeaderTable chunks.
+
+# RUN: not yaml2obj %s --docnum=6 -o /dev/null 2>&1 | FileCheck %s --check-prefix=MULTIPLE
+
+# MULTIPLE: error: multiple program header tables are not allowed
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+Sections:
+  - Type: ProgramHeaderTable
+  - Type: ProgramHeaderTable
+
+## Check that implicit sections are placed after the program header table by default.
+
+# RUN: yaml2obj --docnum=7 %s -o %t9
+# RUN: llvm-readelf --file-header --sections %t9 | FileCheck %s --check-prefix=IMPLICIT
+
+## 72 == 0x48.
+# IMPLICIT: Start of program headers: 72 (bytes into file)
+
+# IMPLICIT:      [Nr] Name      Type     Address          Off    Size
+# IMPLICIT:      [ 1] .foo      PROGBITS 0000000000000000 000040 000001
+# IMPLICIT-NEXT: [ 2] .strtab   STRTAB   0000000000000000 000048 000001
+# IMPLICIT-NEXT: [ 3] .shstrtab STRTAB   0000000000000000 000049 000018
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+    Size: 0x1
+  - Type: ProgramHeaderTable
+
+## Check we are able to explicitly place the program header table at the end of file.
+
+# RUN: yaml2obj --docnum=8 %s -o %t10
+# RUN: llvm-readelf --file-header --sections %t10 | FileCheck %s --check-prefix=LAST1
+
+# LAST1: Start of program headers:  280 (bytes into file)
+# LAST1: Size of program headers:   56 (bytes)
+# LAST1: Number of program headers: 2
+
+# LAST1: There are 3 section headers, starting at offset 0x40:
+# LAST1: [Nr] Name      Type   Address          Off    Size
+# LAST1: [ 2] .shstrtab STRTAB 0000000000000000 000101 000013
+## The program header table is placed here, at alignTo(8, 0x101 + 0x13) ==
+## alignTo(8, 0x114) = 0x118 == 280.
+
+## Check the size of the file: start of program headers (280) +
+## size of program headers(56) * number of program headers(2) == 392.
+
+# RUN: wc -c < %t10 | FileCheck %s --check-prefix=SIZE1
+# SIZE1: 392{{$}}
+
+## Check that the size of the program header table affects the file size.
+
+# RUN: yaml2obj --docnum=8 -DTYPE2="" %s -o %t11
+# RUN: llvm-readelf --file-header %t11 | FileCheck %s --check-prefix=LAST2
+
+# LAST2: Start of program headers:  280 (bytes into file)
+# LAST2: Size of program headers:   56 (bytes)
+# LAST2: Number of program headers: 1
+
+## Check the size of the file: start of program headers (280) +
+## size of program headers(56) * number of program headers(1) == 336.
+
+# RUN: wc -c < %t11 | FileCheck %s --check-prefix=SIZE2
+# SIZE2: 336{{$}}
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_EXEC
+Sections:
+  - Type: SectionHeaderTable
+  - Name: .strtab
+    Type: SHT_STRTAB
+  - Name: .shstrtab
+    Type: SHT_STRTAB
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type: PT_LOAD
+      [[TYPE2=- Type: PT_LOAD]]

llvm/tools/obj2yaml/elf2yaml.cpp

if (S.Type == ELF::SHT_STRTAB || S.Type == ELF::SHT_SYMTAB ||
     return S.Size || S.Flags.getValueOr(ELFYAML::ELF_SHF(0)) & ELF::SHF_ALLOC;
   }
 
   return true;
 }
 
 template <class ELFT>
 static void dumpSectionOffsets(const typename ELFT::Ehdr &Header,
-                               ArrayRef<ELFYAML::ProgramHeader> Phdrs,
+                               ELFYAML::ProgramHeaderTable *Phdrs,
                                std::vector<std::unique_ptr<ELFYAML::Chunk>> &V,
                                ArrayRef<typename ELFT::Shdr> S) {
   if (V.empty())
     return;
 
   uint64_t ExpectedOffset;
   if (Header.e_phoff > 0)
     ExpectedOffset = Header.e_phoff + Header.e_phentsize * Header.e_phnum;
return Sections[cast<ELFYAML::Section>(A.get())->OriginalSecNdx].sh_offset <
            Sections[cast<ELFYAML::Section>(B.get())->OriginalSecNdx].sh_offset;
   });
 
   // Dump program headers.
   Expected<std::vector<ELFYAML::ProgramHeader>> PhdrsOrErr =
       dumpProgramHeaders(Chunks);
   if (!PhdrsOrErr)
     return PhdrsOrErr.takeError();
-  Y->ProgramHeaders = std::move(*PhdrsOrErr);
 
-  dumpSectionOffsets<ELFT>(Obj.getHeader(), Y->ProgramHeaders, Chunks,
+  std::unique_ptr<ELFYAML::ProgramHeaderTable> ProgramHeaders;
+  if (PhdrsOrErr->size()) {
+    ProgramHeaders =
+        std::make_unique<ELFYAML::ProgramHeaderTable>(/*IsImplicit=*/false);
+    ProgramHeaders->Segments = std::move(*PhdrsOrErr);
+  }
+
+  dumpSectionOffsets<ELFT>(Obj.getHeader(), ProgramHeaders.get(), Chunks,
                            Sections);
 
   // Dump DWARF sections.
   Y->DWARF = dumpDWARFSections(Chunks);
 
   // We emit the "SectionHeaderTable" key when the order of sections in the
   // sections header table doesn't match the file order.
   const bool SectionsSorted =
       llvm::is_sorted(Chunks, [&](const std::unique_ptr<ELFYAML::Chunk> &A,
                                   const std::unique_ptr<ELFYAML::Chunk> &B) {
         return cast<ELFYAML::Section>(A.get())->OriginalSecNdx <
                cast<ELFYAML::Section>(B.get())->OriginalSecNdx;
       });
   if (!SectionsSorted) {
     std::unique_ptr<ELFYAML::SectionHeaderTable> SHT =
         std::make_unique<ELFYAML::SectionHeaderTable>(/*IsImplicit=*/false);
     SHT->Sections.emplace();
     for (ELFYAML::Section *S : OriginalOrder)
       SHT->Sections->push_back({S->Name});
     Chunks.push_back(std::move(SHT));
   }
 
+  // Currently we insert the program header table right after the SHT_NULL
+  // section, when it exists (when the section header table is present).
+  // TODO: we should insert it at a proper position.
+  if (ProgramHeaders) {
+    auto It = Chunks.empty() ? Chunks.begin() : Chunks.begin() + 1;
+    Chunks.insert(It, std::move(ProgramHeaders));
+  }
+
   llvm::erase_if(Chunks, [this, &Y](const std::unique_ptr<ELFYAML::Chunk> &C) {
-    if (isa<ELFYAML::SectionHeaderTable>(*C.get()))
+    if (C->Kind >= ELFYAML::Chunk::ChunkKind::SpecialChunksStart)
       return false;
 
     const ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get());
     return !shouldPrintSection(S, Sections[S.OriginalSecNdx], Y->DWARF);
   });
 
   Y->Chunks = std::move(Chunks);
   return Y.release();

llvm/unittests/Object/ELFObjectFileTest.cpp

TEST(ELFObjectFileTest, InvalidLoadSegmentsOrderTest) {
   SmallString<0> Storage;
   Expected<ELFObjectFile<ELF64LE>> ExpectedFile = toBinary<ELF64LE>(Storage, R"(
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
+  - Type: ProgramHeaderTable
+    Segments:
+      - Type:     PT_LOAD
+        VAddr:    0x2000
+        FirstSec: .bar
+        LastSec:  .bar
+      - Type:     PT_LOAD
+        VAddr:    0x1000
+        FirstSec: .foo
+        LastSec:  .foo
   - Name:         .foo
     Type:         SHT_PROGBITS
     Address:      0x1000
     Offset:       0x3000
     ContentArray: [ 0x11 ]
   - Name:         .bar
     Type:         SHT_PROGBITS
     Address:      0x2000
     Offset:       0x4000
     ContentArray: [ 0x99 ]
-ProgramHeaders:
-  - Type:     PT_LOAD
-    VAddr:    0x2000
-    FirstSec: .bar
-    LastSec:  .bar
-  - Type:     PT_LOAD
-    VAddr:    0x1000
-    FirstSec: .foo
-    LastSec:  .foo
 )");
 
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
 
   std::string WarnString;
   auto ToMappedAddr = [&](uint64_t Addr) -> const uint8_t * {
     Expected<const uint8_t *> DataOrErr =
         ExpectedFile->getELFFile().toMappedAddr(Addr, [&](const Twine &Msg) {