[yaml2obj] - Implement the "SectionHeaderTable" tag.

[grimar]

Summary

With the "SectionHeaderTable" it is now possible to reorder
entries in the section header table.

It also allows to stop emitting the table.

[MaskRay]

This is a good idea.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1457

try_emplace can remove {}

1463

Use ArrayRef::slice to skip SHT_NULL.

1468

section name should be present in the Sections list

1472

auto &

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

31

Fill not indented correctly.

39

Can Sections be omitted?

[grimar]

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

39

It was done intentionally. I am thinking about adding a one more "Location"/"Offset" tag here in a follow-up
which should allow placing the table before/after sections or, perhaps, to a particular location either:

SectionHeaderTable:
  Offset: AutoBefore
  Sections:
  ...

(Something like was mentioned here: https://reviews.llvm.org/D78927#inline-732176)

[jhenderson]

Mostly looks good, but a number of small comments from me.

llvm/include/llvm/ObjectYAML/ELFYAML.h

88

If there's nothing stopping it, I'd prefer to make this SectionHeader (in commong with FileHeader and ProgramHeader). Variable names could then be changed to SecHdr where necessary.

520

SectionHeaders

llvm/lib/ObjectYAML/ELFEmitter.cpp

320

I'm not convinced we should do this. This field doesn't change according to the ELF gABI when there are no section headers (unlike e_shnum and e_shoff).

331

Maybe change this to else if (Doc.SectionHeader && Doc.SectionHeader->sections.empty()) and then get rid of the (!Doc.SectionHeader) clause, since it has the same effect as the final else.

339

I take it Doc.getSections() includes a null section header already?

343

I'm wondering whether we should make the null section explicit in the SectionHeaderTable block. This allows us to omit that section header entirely, or to have just a section header table containing only the null shdr.

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

61

I'm not sure what this message is trying to say, but I'm assuming it's "omits any section that exists." which I think would be a clearer way of phrasing.

62

Rather than calling the section "undefined", which implies something to do with SHN_UNDEF, let's go with "non-existent".

63–64

I don't feel strongly about this, so if you prefer this way, that's fine, but I personally prefer the first line to end with | \ and the second line to be indented slightly, i.e.

# RUN: not yaml2obj ... | \
# RUN:   FileCheck ...

The reasoning is 1) the '|' shows the command is done, and 2), the indentation shows it's a continuation implicitly.

105

"section header" -> "section header table" (or possibly just "section headers")

[grimar]

• Rebased.
• Addressed review comments.

[MaskRay]

llvm/lib/ObjectYAML/ELFEmitter.cpp

343

Making the SHT_NULL section explicit in SectionHeaderTable seems fine, but how do we encode it?

The SHT_NULL section in Sections remains on-demand implicit.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

320

OK. I've reverted this piece.

339

Yes. It is either defined explicitly in a YAML or we implicilty add it much earlier:

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));
...

343

This allows us to omit that section header entirely, or to have just a section header table containing only the null shdr.

Is it useful? (I am not sure I can imagine a use case except creating of a specific broken object,
though it should be possible to create such using SHOff even right now. I.e. SHOff could point to a hand crafted table. Or just to the first header directly, to skip the null one. I agree that is not that straightforward though).

The current implementation is that SectionHeaderTable must list all sections (null section is an exception). I think it is a nice propery,
because it seems can be easy to forget to mention a section and omit it by mistake. E.g. in this patch I've to add implicit sections like ".shstrtab" and ".strtab" manually.

Perhaps, we might introduce a new explicit syntax to describe omitted sections if you want to have such feature. E.g:

SectionHeaderTable:
  Sections:
  ...
  Excluded:
    - foo
    - bar

I'm wondering whether we should make the null section explicit

My concern is that we'll have an unnecessary noise in most of the test cases that use SectionHeaderTable then. Usually
test cases do not need to do anything with the SHT_NULL section. Perhaps, the new explicit syntax might help here too.
Like:

SectionHeaderTable:
  CreateImplicitNullSection: false

1457

Nice!

1463

getSections() returns std::vector..

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

63–64

I usually also do in this way I think. Not sure why did differently that time. Fixed.

[grimar]

(For some reason seems I also forgot to push "submit" for my comments previously. Sorry!).

[jhenderson]

LGTM, with two nits.

llvm/lib/ObjectYAML/ELFEmitter.cpp

343

Let's leave it for a future extension for when the need arises, with the suggested explicit syntax.

1473

Formatting here looks off to me? Also, why not const &?

(I think @MaskRay was suggesting const auto &It with a space in the right place)

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

106

when do not -> when we do not

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1473

Ah.. I understood it differently: there is just a single line where It is used and it is obvious it does not change. LLVM uses auto without const in many places (as well as with the const), so I've removed it because assumed that the comment was about that we can omit it for the slightly shorter code.

I do not have any preference by myself, because I do not like using "auto" in general and so both ways does not look very nice to me. I'll return the "const" back since the initial comment was misunderstood.

[grimar]

• Addressed comments.

@MaskRay, are you OK with it?

[MaskRay]

Looks great!

llvm/lib/ObjectYAML/ELFEmitter.cpp

1473

const auto & is fine. The full type may be too cumbersome to type.

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct FileHeader {
   llvm::yaml::Hex64 Entry;
 
   Optional<llvm::yaml::Hex16> SHEntSize;
   Optional<llvm::yaml::Hex64> SHOff;
   Optional<llvm::yaml::Hex16> SHNum;
   Optional<llvm::yaml::Hex16> SHStrNdx;
 };
 
+struct SecHdr {
+  StringRef Name;
+};
+
+struct SectionHeaderTable {
+  std::vector<SecHdr> Sections;
+};
+
 struct SectionName {
   StringRef Section;
 };
 
 struct ProgramHeader {
   ELF_PT Type;
   ELF_PF Flags;
   llvm::yaml::Hex64 VAddr;
struct MipsABIFlags : Section {
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::MipsABIFlags;
   }
 };
 
 struct Object {
   FileHeader Header;
+  Optional<SectionHeaderTable> SectionHeader;
   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

 } // end namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::LinkerOption)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SecHdr)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1> {
   static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value);
 };
 
 template <>
 struct MappingTraits<ELFYAML::FileHeader> {
   static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
 };
 
+template <> struct MappingTraits<ELFYAML::SectionHeaderTable> {
+  static void mapping(IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable);
+};
+
+template <> struct MappingTraits<ELFYAML::SecHdr> {
+  static void mapping(IO &IO, ELFYAML::SecHdr &SHdr);
+};
+
 template <> struct MappingTraits<ELFYAML::ProgramHeader> {
   static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
 };
 
 template <>
 struct MappingTraits<ELFYAML::Symbol> {
   static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
   static StringRef validate(IO &IO, ELFYAML::Symbol &Symbol);

llvm/lib/ObjectYAML/ELFEmitter.cpp

void writeSectionContent(Elf_Shdr &SHeader,
                            ContiguousBlobAccumulator &CBA);
 
   void writeFill(ELFYAML::Fill &Fill, ContiguousBlobAccumulator &CBA);
 
   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 
   void assignSectionAddress(Elf_Shdr &SHeader, ELFYAML::Section *YAMLSec);
 
+  DenseMap<StringRef, size_t> buildSectionHeaderReorderMap();
+
   BumpPtrAllocator StringAlloc;
   uint64_t alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
                          llvm::Optional<llvm::yaml::Hex64> Offset);
 
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
 };
void ELFState<ELFT>::writeELFHeader(ContiguousBlobAccumulator &CBA, raw_ostream &OS) {
   Header.e_version = EV_CURRENT;
   Header.e_entry = Doc.Header.Entry;
   Header.e_phoff = Doc.ProgramHeaders.size() ? sizeof(Header) : 0;
   Header.e_flags = Doc.Header.Flags;
   Header.e_ehsize = sizeof(Elf_Ehdr);
   Header.e_phentsize = Doc.ProgramHeaders.size() ? sizeof(Elf_Phdr) : 0;
   Header.e_phnum = Doc.ProgramHeaders.size();
 
-  Header.e_shentsize =
-      Doc.Header.SHEntSize ? (uint16_t)*Doc.Header.SHEntSize : sizeof(Elf_Shdr);
+  if (Doc.Header.SHEntSize)
+    Header.e_shentsize = *Doc.Header.SHEntSize;
+  else if (!Doc.SectionHeader || !Doc.SectionHeader->Sections.empty())
+    Header.e_shentsize = sizeof(Elf_Shdr);
+  else
+    Header.e_shentsize = 0;
+
   // Align the start of the section header table, which is written after all
   // other sections to the end of the file.
   uint64_t SHOff =
       alignToOffset(CBA, sizeof(typename ELFT::uint), /*Offset=*/None);
-  Header.e_shoff =
-      Doc.Header.SHOff ? typename ELFT::uint(*Doc.Header.SHOff) : SHOff;
-  Header.e_shnum =
-      Doc.Header.SHNum ? (uint16_t)*Doc.Header.SHNum : Doc.getSections().size();
-  Header.e_shstrndx = Doc.Header.SHStrNdx ? (uint16_t)*Doc.Header.SHStrNdx
-                                          : SN2I.get(".shstrtab");
+
+  if (Doc.Header.SHOff)
+    Header.e_shoff = *Doc.Header.SHOff;
+  else if (!Doc.SectionHeader)
+    Header.e_shoff = SHOff;
+  else if (Doc.SectionHeader->Sections.empty())
+    Header.e_shoff = 0;
+  else
+    Header.e_shoff = SHOff;
+
+  if (Doc.Header.SHNum)
+    Header.e_shnum = *Doc.Header.SHNum;
+  else if (!Doc.SectionHeader)
+    Header.e_shnum = Doc.getSections().size();
+  else if (Doc.SectionHeader->Sections.empty())
+    Header.e_shnum = 0;
+  else
+    Header.e_shnum = Doc.SectionHeader->Sections.size() + /*Null section*/ 1;
+
+  if (Doc.Header.SHStrNdx)
+    Header.e_shstrndx = *Doc.Header.SHStrNdx;
+  else if (!Doc.SectionHeader || !Doc.SectionHeader->Sections.empty())
+    Header.e_shstrndx = SN2I.get(".shstrtab");
+  else
+    Header.e_shstrndx = 0;
 
   OS.write((const char *)&Header, sizeof(Header));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
   for (const auto &YamlPhdr : Doc.ProgramHeaders) {
     Elf_Phdr Phdr;
void ELFState<ELFT>::writeFill(ELFYAML::Fill &Fill,
 
   // Fill the content with the specified pattern.
   uint64_t Written = 0;
   for (; Written + PatternSize <= Fill.Size; Written += PatternSize)
     Fill.Pattern->writeAsBinary(OS);
   Fill.Pattern->writeAsBinary(OS, Fill.Size - Written);
 }
 
+template <class ELFT>
+DenseMap<StringRef, size_t> ELFState<ELFT>::buildSectionHeaderReorderMap() {
+  if (!Doc.SectionHeader || Doc.SectionHeader->Sections.empty())
+    return DenseMap<StringRef, size_t>();
+
+  DenseMap<StringRef, size_t> Ret;
+  size_t SecNdx = 0;
+  StringSet<> Seen;
+  for (const ELFYAML::SecHdr &Hdr : Doc.SectionHeader->Sections) {
+    if (!Ret.insert({Hdr.Name, ++SecNdx}).second)
+      reportError("repeated section name: '" + Hdr.Name +
+                  "' in the section header description");
+    Seen.insert(Hdr.Name);
+  }
+
+  for (const ELFYAML::Section *S : Doc.getSections()) {
+    // Ignore special first SHT_NULL section.
+    if (S == Doc.getSections().front())
+      continue;
+    if (!Seen.count(S->Name))
+      reportError("section header must list the '" + S->Name + "' section");
+    Seen.erase(S->Name);
+  }
+
+  for (const auto& It : Seen)
+    reportError("section header contains undefined section '" + It.getKey() + "'");
+  return Ret;
+}
+
 template <class ELFT> void ELFState<ELFT>::buildSectionIndex() {
+  // A YAML description can have an explicit section header declaration that allows
+  // to change the order of section headers.
+  DenseMap<StringRef, size_t> ReorderMap = buildSectionHeaderReorderMap();
+
   size_t SecNdx = -1;
   for (const std::unique_ptr<ELFYAML::Chunk> &C : Doc.Chunks) {
     if (!isa<ELFYAML::Section>(C.get()))
       continue;
     ++SecNdx;
 
-    if (!SN2I.addName(C->Name, SecNdx))
+    size_t Index = ReorderMap.empty() ? SecNdx : ReorderMap.lookup(C->Name);
+    if (!SN2I.addName(C->Name, Index))
       llvm_unreachable("buildSectionIndex() failed");
     DotShStrtab.add(ELFYAML::dropUniqueSuffix(C->Name));
   }
 
   DotShStrtab.finalize();
 }
 
 template <class ELFT> void ELFState<ELFT>::buildSymbolIndexes() {

llvm/lib/ObjectYAML/ELFYAML.cpp

 
 void ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1>::bitset(
     IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
   BCase(ODDSPREG);
 #undef BCase
 }
 
+void MappingTraits<ELFYAML::SecHdr>::mapping(IO &IO, ELFYAML::SecHdr &SHdr) {
+  IO.mapRequired("Name", SHdr.Name);
+}
+
+void MappingTraits<ELFYAML::SectionHeaderTable>::mapping(
+    IO &IO, ELFYAML::SectionHeaderTable &SectionHeader) {
+  IO.mapRequired("Sections", SectionHeader.Sections);
+}
+
 void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
                                                  ELFYAML::FileHeader &FileHdr) {
   IO.mapRequired("Class", FileHdr.Class);
   IO.mapRequired("Data", FileHdr.Data);
   IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
   IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
   IO.mapRequired("Type", FileHdr.Type);
   IO.mapRequired("Machine", FileHdr.Machine);
void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,
   IO.mapOptional("Addend", Rel.Addend, (ELFYAML::YAMLIntUInt)0);
 }
 
 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("SectionHeaderTable", Object.SectionHeader);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Chunks);
   IO.mapOptional("Symbols", Object.Symbols);
   IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
   IO.setContext(nullptr);
 }
 
 void MappingTraits<ELFYAML::LinkerOption>::mapping(IO &IO,

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

+## Check we can use "SectionHeaderTable" tag to reorder section header entries.
+
+## This is a general test that has sections with unique prefixes, a fill and a
+## section without the unique prefix. The section header table describes sections
+## in the same order they are listed in the YAML.
+# RUN: yaml2obj %s --docnum=1 -o %t1 -DSEC1=".section [1]" -DSEC2=".section [2]" -DSEC3=".section.foo"
+# RUN: llvm-readelf --section-headers %t1 | FileCheck %s --check-prefix=NO-OP
+
+# NO-OP:      Section Headers:
+# NO-OP-NEXT:   [Nr] Name         Type     Address          Off    Size   ES Flg Lk Inf Al
+# NO-OP-NEXT:   [ 0]              NULL     0000000000000000 000000 000000 00      0   0  0
+# NO-OP-NEXT:   [ 1] .section     PROGBITS 0000000000000000 000040 000010 00      0   0  0
+# NO-OP-NEXT:   [ 2] .section     PROGBITS 0000000000000000 000050 000020 00      0   0  0
+# NO-OP-NEXT:   [ 3] .section.foo PROGBITS 0000000000000000 0000a0 000040 00      0   0  0
+# NO-OP-NEXT:   [ 4] .strtab      STRTAB   0000000000000000 0000e0 000001 00      0   0  1
+# NO-OP-NEXT:   [ 5] .shstrtab    STRTAB   0000000000000000 0000e1 000029 00      0   0  1
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .section [1]
+    Type: SHT_PROGBITS
+    Size: 0x10
+  - Name: .section [2]
+    Type: SHT_PROGBITS
+    Size: 0x20
+  - Type: Fill
+    Name:    .filler
+    Size:    0x30
+    Pattern: ""
+  - Name: .section.foo
+    Type: SHT_PROGBITS
+    Size: 0x40
+SectionHeaderTable:
+  Sections:
+    - Name: [[SEC1]]
+    - Name: [[SEC2]]
+    - Name: [[SEC3]]
+    - Name: .strtab
+    - Name: .shstrtab
+
+## Show we are able to reorder sections.
+# RUN: yaml2obj %s -o %t2 -DSEC3=".section [1]" -DSEC2=".section [2]" -DSEC1=".section.foo"
+# RUN: llvm-readelf --section-headers %t2 | FileCheck %s --check-prefix=REORDERED
+
+# REORDERED:      Section Headers:
+# REORDERED-NEXT:   [Nr] Name         Type     Address          Off    Size   ES Flg Lk Inf Al
+# REORDERED-NEXT:   [ 0]              NULL     0000000000000000 000000 000000 00      0   0  0
+# REORDERED-NEXT:   [ 1] .section.foo PROGBITS 0000000000000000 0000a0 000040 00      0   0  0
+# REORDERED-NEXT:   [ 2] .section     PROGBITS 0000000000000000 000050 000020 00      0   0  0
+# REORDERED-NEXT:   [ 3] .section     PROGBITS 0000000000000000 000040 000010 00      0   0  0
+# REORDERED-NEXT:   [ 4] .strtab      STRTAB   0000000000000000 0000e0 000001 00      0   0  1
+# REORDERED-NEXT:   [ 5] .shstrtab    STRTAB   0000000000000000 0000e1 000029 00      0   0  1
+
+## Show we report proper errors when the section header description:
+##  a) contains a repeated section name.
+##  b) does not list any of existent section(s).
+##  c) contains a undefined section.
+# RUN: not yaml2obj %s -o /dev/null -DSEC1=".section.foo" -DSEC2="unknown" -DSEC3=".section.foo" 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=ERR1
+#   d) contains a repeated implicit section name.
+#   e) contains a fill name.
+# RUN: not yaml2obj %s -o /dev/null -DSEC1=".strtab" -DSEC2=".shstrtab" -DSEC3=".filler" 2>&1 \
+# RUN:   | FileCheck %s --check-prefix=ERR2
+
+# ERR1:      error: repeated section name: '.section.foo' in the section header description
+# ERR1-NEXT: error: section header must list the '.section [1]' section
+# ERR1-NEXT: error: section header must list the '.section [2]' section
+# ERR1-NEXT: error: section header contains undefined section 'unknown'
+
+# ERR2:      error: repeated section name: '.strtab' in the section header description
+# ERR2-NEXT: error: repeated section name: '.shstrtab' in the section header description
+# ERR2-NEXT: error: section header must list the '.section [1]' section
+# ERR2-NEXT: error: section header must list the '.section [2]' section
+# ERR2-NEXT: error: section header must list the '.section.foo' section
+# ERR2-NEXT: error: section header contains undefined section '.filler'
+
+## Test that we are able to specify an empty sections list for
+## the "SectionHeaderTable" tag to produce no section header. 
+# RUN: yaml2obj %s --docnum=2 -o %t3
+# RUN: llvm-readelf --file-headers %t3 | FileCheck %s --check-prefix=NO-HEADERS
+
+# NO-HEADERS: Start of section headers:          0 (bytes into file)
+# NO-HEADERS: Size of section headers:           0 (bytes)
+# NO-HEADERS: Number of section headers:         0
+# NO-HEADERS: Section header string table index: 0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+SectionHeaderTable:
+  Sections: []
+
+## Test that we are still able to override e_shentsize, e_shoff,
+## e_shnum and e_shstrndx fields even when do not produce the section header.
+# RUN: yaml2obj %s --docnum=3 -o %t4
+# RUN: llvm-readelf --file-headers %t4 | FileCheck %s --check-prefix=NO-HEADERS-OVERRIDE
+
+# NO-HEADERS-OVERRIDE: Start of section headers:          2 (bytes into file)
+# NO-HEADERS-OVERRIDE: Size of section headers:           64 (bytes)
+# NO-HEADERS-OVERRIDE: Number of section headers:         3
+# NO-HEADERS-OVERRIDE: Section header string table index: 4
+
+--- !ELF
+FileHeader:
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_REL
+  Machine:   EM_X86_64
+  SHEntSize: 64
+  SHOff:     0x2
+  SHNum:     0x3
+  SHStrNdx:  0x4
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+SectionHeaderTable:
+  Sections: []
+
+## Check that section indices are updated properly in other places when we
+## reorder sections in the section header table.
+# RUN: yaml2obj %s --docnum=4 -o %t5 -DSEC1=".foo" -DSEC2=".bar"
+# RUN: llvm-readelf --section-headers --symbols %t5 | FileCheck %s --check-prefix=INDICES-A
+# RUN: yaml2obj %s --docnum=4 -o %t6 -DSEC2=".foo" -DSEC1=".bar"
+# RUN: llvm-readelf --section-headers --symbols %t6 | FileCheck %s --check-prefix=INDICES-B
+
+# INDICES-A:      [Nr] Name       Type     Address          Off    Size   ES Flg Lk
+# INDICES-A:      [ 1] .foo       PROGBITS 0000000000000000 000040 000000 00      0
+# INDICES-A-NEXT: [ 2] .bar       PROGBITS 0000000000000000 000040 000000 00      0
+# INDICES-A-NEXT: [ 3] .another.1 PROGBITS 0000000000000000 000040 000000 00      1
+# INDICES-A-NEXT: [ 4] .another.2 PROGBITS 0000000000000000 000040 000000 00      2
+
+# INDICES-A:      Num:    Value          Size Type    Bind   Vis       Ndx Name
+# INDICES-A:        1: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT     1 foo
+# INDICES-A-NEXT:   2: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT     2 bar
+
+# INDICES-B:      [ 1] .bar       PROGBITS 0000000000000000 000040 000000 00      0
+# INDICES-B-NEXT: [ 2] .foo       PROGBITS 0000000000000000 000040 000000 00      0
+# INDICES-B-NEXT: [ 3] .another.1 PROGBITS 0000000000000000 000040 000000 00      2
+# INDICES-B-NEXT: [ 4] .another.2 PROGBITS 0000000000000000 000040 000000 00      1
+
+# INDICES-B:      Num: Value            Size Type   Bind  Vis     Ndx Name
+# INDICES-B:        1: 0000000000000000    0 NOTYPE LOCAL DEFAULT   2 foo
+# INDICES-B-NEXT:   2: 0000000000000000    0 NOTYPE LOCAL DEFAULT   1 bar
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+  - Name: .bar
+    Type: SHT_PROGBITS
+  - Name: .another.1
+    Link: .foo
+    Type: SHT_PROGBITS
+  - Name: .another.2
+    Link: .bar
+    Type: SHT_PROGBITS
+SectionHeaderTable:
+  Sections:
+    - Name: [[SEC1]]
+    - Name: [[SEC2]]
+    - Name: .another.1
+    - Name: .another.2
+    - Name: .symtab
+    - Name: .strtab
+    - Name: .shstrtab
+Symbols:
+  - Name:    foo
+    Section: .foo
+  - Name:    bar
+    Section: .bar