[yaml2obj] - Support selecting the location of the section header table.

[grimar]

Summary

I've found that sometimes it might be convenient when writing a test to not
put anything after all sections data. Currently we write the section header
table there.

This adds the Location sub key to SectionHeaderTable key:

SectionHeaderTable:
  Location:  <value>

Location can be either AfterSecData or BeforeSecData currently.
This allows to place the section header table before sections data.

This patch also opens road to implement placing the section header table at
an arbitrary position (i.e. between sections).

[MaskRay]

The placement was changed by D67221. This patch adds an option to change the placement which is definitely useful. A design with the syntax is requires so I think it'd be best to wait after @jhenderson comes back from the vacation. I haven't look hard whether the code can be simplified yet.

llvm/lib/ObjectYAML/ELFYAML.cpp

882

Most binary utilities do not capitalize diagnostics.

llvm/test/tools/yaml2obj/ELF/section-headers-location.yaml

1

Test that the "Location" key of "SectionHeaderTable" tag can change the placement of the section header table.

4

"AfterSecData" is the default which places the section header table after all section contents (i.e. at the end of the file)

39

"Location" cannot be used when "NoHeaders" is true

(Personally I think words like "Check" "we do not allow" can be removed)

[jhenderson]

If there's a case where this is useful, I definitely support it. More generally, we may want to be able to do the same with program header table placement. I don't know if we have a use-case for that yet, but it's probably worth keeping it in mind as we design this. BeforeSecData is therefore a little bit ambiguous here. For example, between the ELF header and program header table is also "before" the section data. Maybe the key words should be AfterEhdr, AfterPhdrs, AfterSections (or possibly AtEOF for the last one). We could probably not have one of AfterEhdr or AfterPhdrs for now. Longer-term, I could imagine it might be useful to allow arbitrary offsets for the section header table, so we should consider this in our design too.

I've got a few competing ideas, and am listing them here to see what others think.

Option 1: encode location in SectionHeaderTable, possibly using the keyword Offset (I think Offset is better than Location, for consistency, with named values like AfterSections or AfterSecData being special values). The offset would work the same as Offset does for sections, and we'd need to effectively insert the section header table block between sections at the requested position, when specified as an arbitrary value.
Option 2: add section header offset property to the FileHeader which controls the section header table position. This is basically the same as the previous idea, but with the location specified in a different place. The advantage with this approach is that in the future, the same approach could be followed with the program header table. It also could sit alongside the ESHoff (I forget its exact spelling) field nicely (the latter providing the value in the header itself, whilst the position is determined by a SectionHeaderOffset field or similar.
Option 3: Have a separate "Layout" block within the YAML which would allow you to define the layout. It might look a bit like this:

Layout:
  - FileHeader
  - Section1
  - ProgramHeaders
  - Section2
  - SectionHeaders
  - Section3

I'm not sure how this option would work alongside Offset values for sections, or what should happen if e.g. the file header entry were to be omitted.

I am kind of leaning towards option 2, but see benefits to all the approaches. What do you think?

(I haven't looked at the new code or test yet. I'll do that after the design has been discussed further)

[grimar]

In D93678#2476962, @jhenderson wrote:

Option 3: Have a separate "Layout" block within the YAML which would allow you to define the layout. It might look a bit like this:

Layout:
  - FileHeader
  - Section1
  - ProgramHeaders
  - Section2
  - SectionHeaders
  - Section3

I'm not sure how this option would work alongside Offset values for sections, or what should happen if e.g. the file header entry were to be omitted.

If we really want to add a way to select where program headers are placed and also to support placing both program headers and section headers at an arbitrary offsets,
then I see the following solution:

Currently, internally, we have a list of Chunks, which consists of sections and a special Fill chunk.
If we rename the "Sections" YAML key to "Layout" (or alike), then we might be able to introduce 2 more special optional chunks: ProgramHeaders and SectionHeaders.

Then we will be able to write YAMLs like this:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Layout:
  - Name: .section1
    Type: SHT_PROGBITS
    Size: 0
  - Type: SectionHeaders
     Offset: 0x1000
  - Name: .section2
     Type: SHT_PROGBITS
     Offset: 0x1200
  - Type: ProgramHeaders

I.e. it might look kind of close to what you've suggested in "Option 3", but doesn't introduce a one more separate YAML block, but allows to reuse the "Sections" block.

Perhaps, we can just have the "Sections" name unchanged for now and think about changing it (or keeping) later, when the functionality will be committed.

[jhenderson]

In D93678#2492777, @grimar wrote:

In D93678#2476962, @jhenderson wrote:

Option 3: Have a separate "Layout" block within the YAML which would allow you to define the layout. It might look a bit like this:

Layout:
  - FileHeader
  - Section1
  - ProgramHeaders
  - Section2
  - SectionHeaders
  - Section3

I'm not sure how this option would work alongside Offset values for sections, or what should happen if e.g. the file header entry were to be omitted.

If we really want to add a way to select where program headers are placed and also to support placing both program headers and section headers at an arbitrary offsets,
then I see the following solution:

Currently, internally, we have a list of Chunks, which consists of sections and a special Fill chunk.
If we rename the "Sections" YAML key to "Layout" (or alike), then we might be able to introduce 2 more special optional chunks: ProgramHeaders and SectionHeaders.

Then we will be able to write YAMLs like this:

--- !ELF
FileHeader:
  Class: ELFCLASS64
  Data:  ELFDATA2LSB
  Type:  ET_DYN
Layout:
  - Name: .section1
    Type: SHT_PROGBITS
    Size: 0
  - Type: SectionHeaders
     Offset: 0x1000
  - Name: .section2
     Type: SHT_PROGBITS
     Offset: 0x1200
  - Type: ProgramHeaders

I.e. it might look kind of close to what you've suggested in "Option 3", but doesn't introduce a one more separate YAML block, but allows to reuse the "Sections" block.

Perhaps, we can just have the "Sections" name unchanged for now and think about changing it (or keeping) later, when the functionality will be committed.

Making program headers and the section header table kinds of Chunk makes a lot of sense to me, and I think would fit the design well. Indeed, the general concept is similar to one we already implement in a proprietary objcopy-like tool for performing layout. My main question with this proposal is this: do we want a list (whether called "Layout" or "Sections"), which defines properties of Sections and Fills, but not of the section header table and program header table (apart from their position)? It feels inconsistent to me. We could potentially move the ProgramHeaders and SectionHeaderTable elements into a member of the Layout tag, as in the rough example below (exact syntax would need finalising), but I'm not convinced whether it looks nice or not.

Layout:
  - ProgramHeaderTable:
      Offset: 0x100
      ProgramHeaders:
        - Type: PT_LOAD
        - Type: PT_LOAD
        ...
  - Section:
    Type: SHT_PROGBITS
    Name: .foo
    Offset: 0x200
  - Fill:
    Offset: 0x1000
    Size: 0x20
  - SectionHeaderTable:
    ...

(or similar to what you posted). An alternative would be to move the Offset aspect of the sections into the Layout table only, and possibly moving Fills into that Layout block too out of the Sections list. This has the advantage that layout information is generally kept in the Layout table, whilst the details of what a thing actually is (e.g. section type, size, address etc) are kept in appropriate parts of the document. This is closer to my original option 3:

FileHeader:
  ...
Sections:
  - Name: .foo
    Type: SHT_PROGBITS
  - Name: .bar
    Type: SHT_PROGBITS
SectionHeaderTable:
  ...
ProgramHeaders:
  ...
Layout:
   - Type: Section
    Name: .foo
    Offset: 0x1000
  - Type: Fill
    # Offset could be implicitly calculated here; fills move out of Sections to Layout.
    Size: 0x100
  - Type: SectionHeaderTable
    Offset: 0x2000
  - Type: ProgramHeaderTable
    Offset: 0x3000
  - Type: Section
    Name: .bar
    Offset: 0x3500

I think I mildly prefer the second one, as it'll be easier to retrofit and feels a little cleaner. We'd need some implicit rules that the program header table appears at the front and the section header table at the back if they aren't specifically mentioned in either case.

[grimar]

In D93678#2476962, @jhenderson wrote:

An alternative would be to move the Offset aspect of the sections into the Layout table only, and possibly moving Fills into that Layout block too out of the Sections list. This has the advantage that layout information is generally kept in the Layout table, whilst the details of what a thing actually is (e.g. section type, size, address etc) are kept in appropriate parts of the document. This is closer to my original option 3:

FileHeader:
  ...
Sections:
  - Name: .foo
    Type: SHT_PROGBITS
  - Name: .bar
    Type: SHT_PROGBITS
SectionHeaderTable:
  ...
ProgramHeaders:
  ...
Layout:
   - Type: Section
    Name: .foo
    Offset: 0x1000
  - Type: Fill
    # Offset could be implicitly calculated here; fills move out of Sections to Layout.
    Size: 0x100
  - Type: SectionHeaderTable
    Offset: 0x2000
  - Type: ProgramHeaderTable
    Offset: 0x3000
  - Type: Section
    Name: .bar
    Offset: 0x3500

I think I mildly prefer the second one, as it'll be easier to retrofit and feels a little cleaner. We'd need some implicit rules that the program header table appears at the front and the section header table at the back if they aren't specifically mentioned in either case.

My concern is that it might hurt readability of some of our test cases, where we have a correlation between section addresses/sizes and offsets (an often case I think):
if we will have the "Offset" aspect in "Layout" and "Address"/"Size"/"Content" in "Sections", it makes more difficult to adjust them as "Size"/"Content" affects on "Offset" directly. And the latter one might need to affect on "Address".

Another concern is that having 2 lists might cause the confusion: currently we place sections in the order they are mentioned in "Sections".
With this new scheme I assume the order from "Layout" will be used and the order of sections in "Sections" becomes not important. It feels slightly more complicated, e.g.
people might try to describe program headers using the "Sections", though they need to use the "Layout". We might add the check to verify that the order is synchronized of course, but still...

Personally I'd prefer the first option you mentioned.
Also, if we think about Symbols and DynamicSymbols keys: currently it is impossible to describe
multiple symbol tables, because Symbols is implicitly attached to .symtab and DynamicSymbols is attached to .dynsym.
Though instead we could move them to allow describing multiple symbol tables and the whole structure might look like:

--- !ELF
FileHeader:
  Class:   ELFCLASS32
  Data:    ELFDATA2LSB
  Type:    ET_REL
  Machine: EM_386
Layout:
  - ProgramHeaderTable:
      Offset: 0x100
      ProgramHeaders:
        - Type: PT_LOAD
        - Type: PT_LOAD
        ...
  - Section:
    Type: SHT_PROGBITS
    Name: .foo
    Offset: 0x200
  - Type: Fill
    Offset: 0x1000
    Size: 0x20
  - Name: .symtab
    Type: SHT_SYMTAB
    Symbols:
      - Type:  STT_SECTION
        Index: 0
  - Name: .dynsym_custom
    Type: SHT_DYNSYM
    Symbols:
      - Name: foo
  - Name: .dynsym
    Type: SHT_DYNSYM
    Symbols:
      - Name: foo
      - Name: bar
  - SectionHeaderTable:
    ...

[jhenderson]

That's a good point about the address/offset comment. I'm happy with the other idea then. @MaskRay, do you have any thoughts?

[grimar]

D95140 was posted instead.

llvm/include/llvm/ObjectYAML/ELFYAML.h

 struct SectionHeader {
   StringRef Name;
 };
 
 struct SectionHeaderTable {
   Optional<std::vector<SectionHeader>> Sections;
   Optional<std::vector<SectionHeader>> Excluded;
   Optional<bool> NoHeaders;
+
+  static constexpr StringRef BeforeSec = "BeforeSecData";
+  static constexpr StringRef AfterSec = "AfterSecData";
+  Optional<StringRef> Location;
 };
 
 struct Symbol {
   StringRef Name;
   ELF_STT Type;
   Optional<StringRef> Section;
   Optional<ELF_SHN> Index;
   ELF_STB Binding;

llvm/lib/ObjectYAML/ELFEmitter.cpp

if (checkLimit(Num))
       OS.write_zeros(Num);
   }
 
   void write(const char *Ptr, size_t Size) {
     if (checkLimit(Size))
       OS.write(Ptr, Size);
   }
 
+  void writeAt(uint64_t Pos, const char *Ptr, uint64_t Size) {
+    if (!checkLimit(0))
+      return;
+    assert(Pos - InitialOffset + Size <= Buf.size());
+    memcpy(Buf.data() + Pos - InitialOffset, Ptr, Size);
+  }
+
   void write(unsigned char C) {
     if (checkLimit(1))
       OS.write(C);
   }
 
   unsigned writeULEB128(uint64_t Val) {
     if (!checkLimit(sizeof(uint64_t)))
       return 0;
template <class ELFT> class ELFState {
   unsigned toSectionIndex(StringRef S, StringRef LocSec, StringRef LocSym = "");
   unsigned toSymbolIndex(StringRef S, StringRef LocSec, bool IsDynamic);
 
   void buildSectionIndex();
   void buildSymbolIndexes();
   void initProgramHeaders(std::vector<Elf_Phdr> &PHeaders);
   bool initImplicitHeader(ContiguousBlobAccumulator &CBA, Elf_Shdr &Header,
                           StringRef SecName, ELFYAML::Section *YAMLSec);
-  void initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
+  Optional<uint64_t> initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                                         ContiguousBlobAccumulator &CBA);
   void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
void ELFState<ELFT>::writeELFHeader(raw_ostream &OS, Optional<uint64_t> SHOff) {
   else if (SHOff)
     Header.e_shoff = *SHOff;
   else
     Header.e_shoff = 0;
 
   if (Doc.Header.EShNum)
     Header.e_shnum = *Doc.Header.EShNum;
   else if (!Doc.SectionHeaders ||
-           (Doc.SectionHeaders->NoHeaders && !*Doc.SectionHeaders->NoHeaders))
+           (Doc.SectionHeaders->NoHeaders && !*Doc.SectionHeaders->NoHeaders) ||
+           (Doc.SectionHeaders->Location && !Doc.SectionHeaders->Sections &&
+            !Doc.SectionHeaders->Excluded))
     Header.e_shnum = Doc.getSections().size();
   else if (!SHOff)
     Header.e_shnum = 0;
   else
     Header.e_shnum =
         (Doc.SectionHeaders->Sections ? Doc.SectionHeaders->Sections->size()
                                       : 0) +
         /*Null section*/ 1;
static uint64_t writeContent(ContiguousBlobAccumulator &CBA,
 
   if (!Size)
     return ContentSize;
 
   CBA.writeZeros(*Size - ContentSize);
   return *Size;
 }
 
+// Returns the offset of the section header table, or None when it is absent.
 template <class ELFT>
-void ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
-                                        ContiguousBlobAccumulator &CBA) {
+Optional<uint64_t>
+ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
   // Ensure SHN_UNDEF entry is present. An all-zero section header is a
   // valid SHN_UNDEF entry since SHT_NULL == 0.
   SHeaders.resize(Doc.getSections().size());
 
-  for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
-    if (ELFYAML::Fill *S = dyn_cast<ELFYAML::Fill>(D.get())) {
+  // In this method we initialize and write the section header table.
+  // We are going to iterate over all chunks to finalize each section header
+  // entry. When we need to place the section header table before the sections
+  // data we reserve the space for it.
+  Optional<uint64_t> SHOff;
+  if (Doc.SectionHeaders && Doc.SectionHeaders->Location &&
+      *Doc.SectionHeaders->Location == ELFYAML::SectionHeaderTable::BeforeSec) {
+    // If needed, align the start of the section header table.
+    SHOff = alignToOffset(CBA, sizeof(typename ELFT::uint),
+                          /*Offset=*/None);
+    CBA.writeZeros(SHeaders.size() * sizeof(Elf_Shdr));
+  }
+
+  for (size_t I = 0, E = Doc.Chunks.size(); I != E; ++I) {
+    ELFYAML::Chunk *D = Doc.Chunks[I].get();
+    if (ELFYAML::Fill *S = dyn_cast<ELFYAML::Fill>(D)) {
       S->Offset = alignToOffset(CBA, /*Align=*/1, S->Offset);
       writeFill(*S, CBA);
       LocationCounter += S->Size;
       continue;
     }
 
-    ELFYAML::Section *Sec = cast<ELFYAML::Section>(D.get());
-    bool IsFirstUndefSection = D == Doc.Chunks.front();
+    ELFYAML::Section *Sec = cast<ELFYAML::Section>(D);
+    bool IsFirstUndefSection = D == Doc.Chunks.front().get();
     if (IsFirstUndefSection && Sec->IsImplicit)
       continue;
 
     // We have a few sections like string or symbol tables that are usually
     // added implicitly to the end. However, if they are explicitly specified
     // in the YAML, we need to write them here. This ensures the file offset
     // remains correct.
     Elf_Shdr &SHeader = SHeaders[SN2I.get(Sec->Name)];
if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
       llvm_unreachable("Unknown section type");
     }
 
     LocationCounter += SHeader.sh_size;
 
     // Override section fields if requested.
     overrideFields<ELFT>(Sec, SHeader);
   }
+
+  if (!Doc.SectionHeaders || !Doc.SectionHeaders->NoHeaders.getValueOr(false)) {
+    if (SHOff) {
+      // We have already reserved the space for the section header table.
+      // Write it there.
+      CBA.writeAt(*SHOff, (char *)SHeaders.data(),
+                  (uint64_t)SHeaders.size() * sizeof(Elf_Shdr));
+    } else {
+      // If needed, align the start of the section header table.
+      SHOff = alignToOffset(CBA, sizeof(typename ELFT::uint),
+                            /*Offset=*/None);
+      CBA.write((char *)SHeaders.data(),
+                (uint64_t)SHeaders.size() * sizeof(Elf_Shdr));
+    }
+  }
+
+  return SHOff;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::assignSectionAddress(Elf_Shdr &SHeader,
                                           ELFYAML::Section *YAMLSec) {
   if (YAMLSec && YAMLSec->Address) {
     SHeader.sh_addr = *YAMLSec->Address;
     LocationCounter = *YAMLSec->Address;
void ELFState<ELFT>::writeFill(ELFYAML::Fill &Fill,
   CBA.writeAsBinary(*Fill.Pattern, Fill.Size - Written);
 }
 
 template <class ELFT>
 DenseMap<StringRef, size_t> ELFState<ELFT>::buildSectionHeaderReorderMap() {
   if (!Doc.SectionHeaders || Doc.SectionHeaders->NoHeaders)
     return DenseMap<StringRef, size_t>();
 
+  if (Doc.SectionHeaders->Location && !Doc.SectionHeaders->Sections &&
+      !Doc.SectionHeaders->Excluded)
+    return DenseMap<StringRef, size_t>();
+
   DenseMap<StringRef, size_t> Ret;
   size_t SecNdx = 0;
   StringSet<> Seen;
 
   auto AddSection = [&](const ELFYAML::SectionHeader &Hdr) {
     if (!Ret.try_emplace(Hdr.Name, ++SecNdx).second)
       reportError("repeated section name: '" + Hdr.Name +
                   "' in the section header description");
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);
 
   std::vector<Elf_Shdr> SHeaders;
-  State.initSectionHeaders(SHeaders, CBA);
+  Optional<uint64_t> SHOff = State.initSectionHeaders(SHeaders, CBA);
 
   // Now we can decide segment offsets.
   State.setProgramHeaderLayout(PHeaders, SHeaders);
 
-  // If needed, align the start of the section header table, which is written
-  // after all section data.
-  const bool HasSectionHeaders =
-      !Doc.SectionHeaders || !Doc.SectionHeaders->NoHeaders.getValueOr(false);
-  Optional<uint64_t> SHOff;
-  if (HasSectionHeaders)
-    SHOff = State.alignToOffset(CBA, sizeof(typename ELFT::uint),
-                                /*Offset=*/None);
-  bool ReachedLimit = SHOff.getValueOr(CBA.getOffset()) +
-                          arrayDataSize(makeArrayRef(SHeaders)) >
-                      MaxSize;
+  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, SHOff);
   writeArrayData(OS, makeArrayRef(PHeaders));
   CBA.writeBlobToStream(OS);
-  if (HasSectionHeaders)
-    writeArrayData(OS, makeArrayRef(SHeaders));
   return true;
 }
 
 namespace llvm {
 namespace yaml {
 
 bool yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH,
               uint64_t MaxSize) {

llvm/lib/ObjectYAML/ELFYAML.cpp

 #include <cassert>
 #include <cstdint>
 
 namespace llvm {
 
 ELFYAML::Chunk::~Chunk() = default;
 
 namespace ELFYAML {
+
+constexpr StringRef SectionHeaderTable::BeforeSec;
+constexpr StringRef SectionHeaderTable::AfterSec;
+
 unsigned Object::getMachine() const {
   if (Header.Machine)
     return *Header.Machine;
   return llvm::ELF::EM_NONE;
 }
 } // namespace ELFYAML
 
 namespace yaml {
void MappingTraits<ELFYAML::SectionHeader>::mapping(
   IO.mapRequired("Name", SHdr.Name);
 }
 
 void MappingTraits<ELFYAML::SectionHeaderTable>::mapping(
     IO &IO, ELFYAML::SectionHeaderTable &SectionHeader) {
   IO.mapOptional("Sections", SectionHeader.Sections);
   IO.mapOptional("Excluded", SectionHeader.Excluded);
   IO.mapOptional("NoHeaders", SectionHeader.NoHeaders);
+  IO.mapOptional("Location", SectionHeader.Location);
 }
 
 std::string MappingTraits<ELFYAML::SectionHeaderTable>::validate(
     IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable) {
+  if (SecHdrTable.Location) {
+    if (SecHdrTable.NoHeaders.getValueOr(false))
+      return "NoHeaders can't be set together with Location";
+    if (*SecHdrTable.Location != ELFYAML::SectionHeaderTable::AfterSec &&
+        *SecHdrTable.Location != ELFYAML::SectionHeaderTable::BeforeSec)
+      return ("Allowed values for Location are: " +
+              ELFYAML::SectionHeaderTable::BeforeSec + ", " +
+              ELFYAML::SectionHeaderTable::AfterSec)
+          .str();
+  }
+
   if (SecHdrTable.NoHeaders && (SecHdrTable.Sections || SecHdrTable.Excluded))
     return "NoHeaders can't be used together with Sections/Excluded";
-  if (!SecHdrTable.NoHeaders && !SecHdrTable.Sections && !SecHdrTable.Excluded)
+  if (!SecHdrTable.NoHeaders && !SecHdrTable.Sections &&
+      !SecHdrTable.Excluded && !SecHdrTable.Location)
     return "SectionHeaderTable can't be empty. Use 'NoHeaders' key to drop the "
            "section header table";
   return "";
 }
 
 void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
                                                  ELFYAML::FileHeader &FileHdr) {
   IO.mapRequired("Class", FileHdr.Class);

llvm/test/tools/yaml2obj/ELF/section-headers-location.yaml

+## Check how we can use the "Location" key of the "SectionHeaderTable" tag to
+## specify where the section header table should be placed.
+
+## Check we can set the "Location" key to "AfterSecData" to place the section
+## header table after all sections data.
+## Check it is the default location for the section header table.
+## Check we can use the "Location" key alone.
+
+# RUN: yaml2obj %s -o %t.after.1
+# RUN: llvm-readelf --file-headers --section-headers %t.after.1 | \
+# RUN:   FileCheck %s --check-prefix=AFTER
+
+# RUN: yaml2obj -DLOC=AfterSecData %s -o %t.after.2
+# RUN: llvm-readelf --file-headers --section-headers %t.after.2 | \
+# RUN:   FileCheck %s --check-prefix=AFTER
+
+# AFTER: Start of section headers:  96 (bytes into file)
+# AFTER: Size of section headers:   64 (bytes)
+# AFTER: Number of section headers: 4
+
+## .shstrtab is the last section in the object.
+## Start of section headers (96) == alignTo(0x41 + 0x18, /*Address size=*/8).
+# AFTER: There are 4 section headers
+# AFTER:   [Nr] Name      Type   Address Off    Size
+# AFTER:   [ 3] .shstrtab STRTAB [[#]]   000041 000018
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+SectionHeaderTable:
+  Location:  [[LOC=AfterSecData]]
+  NoHeaders: [[NOHEADERS=<none>]]
+
+## Check we do not allow using the "Location" key when the
+## "NoHeaders" key is set to true.
+# RUN: not yaml2obj %s -DNOHEADERS=true -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=NO-HEADERS-ERR
+
+# NO-HEADERS-ERR: error: NoHeaders can't be set together with Location
+
+## Check we can use the "Location" key when the "NoHeaders" key is set to false.
+# RUN: yaml2obj %s -DNOHEADERS=false -o %t.after.3
+# RUN: llvm-readelf --file-headers --section-headers %t.after.3 | \
+# RUN:   FileCheck %s --check-prefix=AFTER
+
+## Check we can set the "Location" key to "BeforeSecData" to place the section
+## header table before all sections data.
+
+# RUN: yaml2obj -DLOC=BeforeSecData %s -o %t.before.1
+# RUN: llvm-readelf --file-headers --section-headers %t.before.1 | \
+# RUN:   FileCheck %s --check-prefix=BEFORE
+
+# BEFORE: Start of section headers:  64 (bytes into file)
+# BEFORE: Size of section headers:   64 (bytes)
+# BEFORE: Number of section headers: 4
+
+## The first section is placed right after the section header table:
+## Start of section headers (64) + Size of section headers (64) *
+##   Number of section headers (4) == 320 == 0x140.
+
+# BEFORE: [Nr] Name Type     Address Off
+# BEFORE: [ 1] .foo PROGBITS [[#]]   000140
+
+## Check we don't allow any other values for the "Location" key.
+
+# RUN: not yaml2obj %s -DLOC=foo -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=UNKNOWN-ERR
+# RUN: not yaml2obj %s -DLOC=0x123 -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=UNKNOWN-ERR
+
+# UNKNOWN-ERR: error: Allowed values for Location are: BeforeSecData, AfterSecData