[obj2yaml,yaml2obj] - Refine how we set/dump the sh_entsize field.

[grimar]

Summary

This reuses the code from yaml2obj (moves it to ELFYAML.h).
With it we can set the sh_entsize in a single place in obj2yaml.

Note that it also fixes a bug of yaml2obj: we do not
set the sh_entsize field for the SHT_ARM_EXIDX section properly.

[jhenderson]

Could you explain why this patch fixes the ARM_EXIDX sh_entsize specifically? I don't see anything immediately that would only fix that section (and not other sections).

llvm/test/tools/obj2yaml/ELF/mips-abi-flags.yaml

54–55

Do you think this deserves a case where the entsize is not default?

llvm/test/tools/obj2yaml/ELF/sht-symtab-shndx.yaml

191

Really, this comment has nothing to do with the first RUN below it. Probably you should move it to the ENTSIZE=4 case.

[grimar]

In D93858#2478697, @jhenderson wrote:

Could you explain why this patch fixes the ARM_EXIDX sh_entsize specifically? I don't see anything immediately that would only fix that section (and not other sections).

It's because writeSectionContent(..., const ELFYAML::ARMIndexTableSection &Section, ...) doesn't set the EntSize field as it supposed to. This patch
generalizes the logic, now we set this field in the single place, and so the issue was revealed (see arm-exidx-section.yaml).

[grimar]

• Addressed review comments.

llvm/test/tools/obj2yaml/ELF/mips-abi-flags.yaml

54–55

Done.

[jhenderson]

LGTM.

llvm/include/llvm/ObjectYAML/ELFYAML.h

 /// of ELF.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECTYAML_ELFYAML_H
 #define LLVM_OBJECTYAML_ELFYAML_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Object/ELFTypes.h"
 #include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <cstdint>
 #include <memory>
 #include <vector>
 
 namespace llvm {

 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_ISA)
 
 LLVM_YAML_STRONG_TYPEDEF(StringRef, YAMLFlowString)
 LLVM_YAML_STRONG_TYPEDEF(int64_t, YAMLIntUInt)
 
+template <class ELFT>
+unsigned getDefaultShEntSize(unsigned EMachine, ELF_SHT SecType,
+                             StringRef SecName) {
+  if (EMachine == ELF::EM_MIPS && SecType == ELF::SHT_MIPS_ABIFLAGS)
+    return sizeof(object::Elf_Mips_ABIFlags<ELFT>);
+
+  switch (SecType) {
+  case ELF::SHT_GROUP:
+    return sizeof(typename ELFT::Word);
+  case ELF::SHT_REL:
+    return sizeof(typename ELFT::Rel);
+  case ELF::SHT_RELA:
+    return sizeof(typename ELFT::Rela);
+  case ELF::SHT_RELR:
+    return sizeof(typename ELFT::Relr);
+  case ELF::SHT_DYNAMIC:
+    return sizeof(typename ELFT::Dyn);
+  case ELF::SHT_HASH:
+    return sizeof(typename ELFT::Word);
+  case ELF::SHT_SYMTAB_SHNDX:
+    return sizeof(typename ELFT::Word);
+  case ELF::SHT_GNU_versym:
+    return sizeof(typename ELFT::Half);
+  case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
+    return sizeof(object::Elf_CGProfile_Impl<ELFT>);
+  default:
+    if (SecName == ".debug_str")
+      return 1;
+    return 0;
+  }
+}
+
 // For now, hardcode 64 bits everywhere that 32 or 64 would be needed
 // since 64-bit can hold 32-bit values too.
 struct FileHeader {
   ELF_ELFCLASS Class;
   ELF_ELFDATA Data;
   ELF_ELFOSABI OSABI;
   llvm::yaml::Hex8 ABIVersion;
   ELF_ET Type;

llvm/lib/ObjectYAML/ELFEmitter.cpp

for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
     if (!IsFirstUndefSection || Sec->Offset)
       SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, Sec->Offset);
 
     assignSectionAddress(SHeader, Sec);
 
     if (Sec->Link)
       SHeader.sh_link = toSectionIndex(*Sec->Link, Sec->Name);
 
+    if (Sec->EntSize)
+      SHeader.sh_entsize = *Sec->EntSize;
+    else
+      SHeader.sh_entsize = ELFYAML::getDefaultShEntSize<ELFT>(
+          Doc.Header.Machine.getValueOr(ELF::EM_NONE), Sec->Type, Sec->Name);
+
     if (IsFirstUndefSection) {
       if (auto RawSec = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
         // We do not write any content for special SHN_UNDEF section.
         if (RawSec->Size)
           SHeader.sh_size = *RawSec->Size;
         if (RawSec->Info)
           SHeader.sh_info = *RawSec->Info;
       }
-      if (Sec->EntSize)
-        SHeader.sh_entsize = *Sec->EntSize;
 
       LocationCounter += SHeader.sh_size;
       overrideFields<ELFT>(Sec, SHeader);
       continue;
     }
 
     if (!isa<ELFYAML::NoBitsSection>(Sec) && (Sec->Content || Sec->Size))
       SHeader.sh_size = writeContent(CBA, Sec->Content, Sec->Size);
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   if (shouldAllocateFileSpace(Doc.ProgramHeaders, S))
     CBA.writeZeros(*S.Size);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  if (Section.EntSize)
-    SHeader.sh_entsize = *Section.EntSize;
-
   if (Section.Info)
     SHeader.sh_info = *Section.Info;
 }
 
 static bool isMips64EL(const ELFYAML::Object &Obj) {
   return Obj.getMachine() == llvm::ELF::EM_MIPS &&
          Obj.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64) &&
          Obj.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RelocationSection &Section,
     ContiguousBlobAccumulator &CBA) {
   assert((Section.Type == llvm::ELF::SHT_REL ||
           Section.Type == llvm::ELF::SHT_RELA) &&
          "Section type is not SHT_REL nor SHT_RELA");
 
-  bool IsRela = Section.Type == llvm::ELF::SHT_RELA;
-  if (Section.EntSize)
-    SHeader.sh_entsize = *Section.EntSize;
-  else
-    SHeader.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
-
   // For relocation section set link to .symtab by default.
   unsigned Link = 0;
   if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   if (!Section.RelocatableSec.empty())
     SHeader.sh_info = toSectionIndex(Section.RelocatableSec, Section.Name);
 
   if (!Section.Relocations)
     return;
 
+  const bool IsRela = Section.Type == llvm::ELF::SHT_RELA;
   for (const ELFYAML::Relocation &Rel : *Section.Relocations) {
     const bool IsDynamic = Section.Link && (*Section.Link == ".dynsym");
     unsigned SymIdx =
         Rel.Symbol ? toSymbolIndex(*Rel.Symbol, Section.Name, IsDynamic) : 0;
     if (IsRela) {
       Elf_Rela REntry;
       zero(REntry);
       REntry.r_offset = Rel.Offset;
void ELFState<ELFT>::writeSectionContent(
   SHeader.sh_size = (IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel)) *
                     Section.Relocations->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::RelrSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  SHeader.sh_entsize =
-      Section.EntSize ? uint64_t(*Section.EntSize) : sizeof(Elf_Relr);
-
   if (!Section.Entries)
     return;
 
   for (llvm::yaml::Hex64 E : *Section.Entries) {
     if (!ELFT::Is64Bits && E > UINT32_MAX)
       reportError(Section.Name + ": the value is too large for 32-bits: 0x" +
                   Twine::utohexstr(E));
     CBA.write<uintX_t>(E, ELFT::TargetEndianness);
   }
 
   SHeader.sh_size = sizeof(uintX_t) * Section.Entries->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::SymtabShndxSection &Shndx,
     ContiguousBlobAccumulator &CBA) {
-  SHeader.sh_entsize = Shndx.EntSize ? (uint64_t)*Shndx.EntSize : 4;
-
   if (Shndx.Content || Shndx.Size) {
     SHeader.sh_size = writeContent(CBA, Shndx.Content, Shndx.Size);
     return;
   }
 
   if (!Shndx.Entries)
     return;
 
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   assert(Section.Type == llvm::ELF::SHT_GROUP &&
          "Section type is not SHT_GROUP");
 
   unsigned Link = 0;
   if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
-  if (Section.EntSize)
-    SHeader.sh_entsize = *Section.EntSize;
-  else
-    SHeader.sh_entsize = sizeof(typename ELFT::Word);
-
   if (Section.Signature)
     SHeader.sh_info =
         toSymbolIndex(*Section.Signature, Section.Name, /*IsDynamic=*/false);
 
   if (!Section.Members)
     return;
 
   for (const ELFYAML::SectionOrType &Member : *Section.Members) {
     unsigned int SectionIndex = 0;
     if (Member.sectionNameOrType == "GRP_COMDAT")
       SectionIndex = llvm::ELF::GRP_COMDAT;
     else
       SectionIndex = toSectionIndex(Member.sectionNameOrType, Section.Name);
     CBA.write<uint32_t>(SectionIndex, ELFT::TargetEndianness);
   }
   SHeader.sh_size = SHeader.sh_entsize * Section.Members->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::SymverSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  SHeader.sh_entsize = Section.EntSize ? (uint64_t)*Section.EntSize : 2;
-
   if (!Section.Entries)
     return;
 
   for (uint16_t Version : *Section.Entries)
     CBA.write<uint16_t>(Version, ELFT::TargetEndianness);
   SHeader.sh_size = Section.Entries->size() * SHeader.sh_entsize;
 }
 
ELFState<ELFT>::alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
   CBA.writeZeros(AlignedOffset - CurrentOffset);
   return AlignedOffset;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::CallGraphProfileSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  if (Section.EntSize)
-    SHeader.sh_entsize = *Section.EntSize;
-  else
-    SHeader.sh_entsize = 16;
-
   unsigned Link = 0;
   if (!Section.Link && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   if (!Section.Entries)
     return;
 

 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::HashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
   if (!Section.Link && !ExcludedSectionHeaders.count(".dynsym") &&
       SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
-  if (Section.EntSize)
-    SHeader.sh_entsize = *Section.EntSize;
-  else
-    SHeader.sh_entsize = sizeof(typename ELFT::Word);
-
   if (!Section.Bucket)
     return;
 
   if (!Section.Bucket)
     return;
 
   CBA.write<uint32_t>(
       Section.NBucket.getValueOr(llvm::yaml::Hex64(Section.Bucket->size())),

 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::MipsABIFlags &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_MIPS_ABIFLAGS &&
          "Section type is not SHT_MIPS_ABIFLAGS");
 
   object::Elf_Mips_ABIFlags<ELFT> Flags;
   zero(Flags);
-  SHeader.sh_entsize = sizeof(Flags);
   SHeader.sh_size = SHeader.sh_entsize;
 
   Flags.version = Section.Version;
   Flags.isa_level = Section.ISALevel;
   Flags.isa_rev = Section.ISARevision;
   Flags.gpr_size = Section.GPRSize;
   Flags.cpr1_size = Section.CPR1Size;
   Flags.cpr2_size = Section.CPR2Size;
   Flags.fp_abi = Section.FpABI;
   Flags.isa_ext = Section.ISAExtension;
   Flags.ases = Section.ASEs;
   Flags.flags1 = Section.Flags1;
   Flags.flags2 = Section.Flags2;
   CBA.write((const char *)&Flags, sizeof(Flags));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::DynamicSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_DYNAMIC &&
          "Section type is not SHT_DYNAMIC");
 
-  if (Section.EntSize)
-    SHeader.sh_entsize = *Section.EntSize;
-  else
-    SHeader.sh_entsize = 2 * sizeof(uintX_t);
-
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::DynamicEntry &DE : *Section.Entries) {
     CBA.write<uintX_t>(DE.Tag, ELFT::TargetEndianness);
     CBA.write<uintX_t>(DE.Val, ELFT::TargetEndianness);
   }
   SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries->size();

llvm/test/Object/obj2yaml.test

 # ELF-MIPSEL-NEXT:     Type:            SHT_MIPS_REGINFO
 # ELF-MIPSEL-NEXT:     Flags:           [ SHF_ALLOC ]
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x1
 # ELF-MIPSEL-NEXT:     Content:         '000000000000000000000000000000000000000000000000'
 # ELF-MIPSEL-NEXT:   - Name:            .MIPS.abiflags
 # ELF-MIPSEL-NEXT:     Type:            SHT_MIPS_ABIFLAGS
 # ELF-MIPSEL-NEXT:     Flags:           [ SHF_ALLOC ]
 # ELF-MIPSEL-NEXT:     AddressAlign:    0x8
+# ELF-MIPSEL-NEXT:     EntSize:         0x0
 # ELF-MIPSEL-NEXT:     ISA:             MIPS32
 # ELF-MIPSEL-NEXT:     ISARevision:     0x1
 # ELF-MIPSEL-NEXT:     FpABI:           FP_DOUBLE
 # ELF-MIPSEL-NEXT:     GPRSize:         REG_32
 # ELF-MIPSEL-NEXT:     CPR1Size:        REG_32
 # ELF-MIPSEL-NEXT:     Flags1:          [ ODDSPREG ]
 # ELF-MIPSEL-NEXT:   - Name:            .rel.text
 # ELF-MIPSEL-NEXT:     Type:            SHT_REL

llvm/test/tools/obj2yaml/ELF/call-graph-profile-section.yaml

 ## Test how we dump SHT_LLVM_CALL_GRAPH_PROFILE sections for 32 and 64-bit targets.
 
 ## Test we use the "Entries" property when it is possible to dump values correctly.
 
 # RUN: yaml2obj -D BITS=64 -D ENCODE=LSB %s -o %t.le64
 # RUN: obj2yaml %t.le64 | FileCheck %s --check-prefix=BASIC
 # RUN: yaml2obj -D BITS=64 -D ENCODE=MSB %s -o %t.be64
 # RUN: obj2yaml %t.be64 | FileCheck %s --check-prefix=BASIC
 # RUN: yaml2obj -D BITS=32 -D ENCODE=LSB %s -o %t.le32
 # RUN: obj2yaml %t.le32 | FileCheck %s --check-prefix=BASIC
 # RUN: yaml2obj -D BITS=32 -D ENCODE=MSB %s -o %t.be32
 # RUN: obj2yaml %t.be32 | FileCheck %s --check-prefix=BASIC
 
 # BASIC:      Sections:
-# BASIC-NEXT:   - Name:    .llvm.call-graph-profile
-# BASIC-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# BASIC-NEXT:     Link:    .symtab
-# BASIC-NEXT:     EntSize: 0x10
+# BASIC-NEXT:   - Name: .llvm.call-graph-profile
+# BASIC-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# BASIC-NEXT:     Link: .symtab
 # BASIC-NEXT:     Entries:
 # BASIC-NEXT:       - From:   foo
 # BASIC-NEXT:         To:     bar
 # BASIC-NEXT:         Weight: 89
 # BASIC-NEXT:       - From:   bar
 # BASIC-NEXT:         To:     foo
 # BASIC-NEXT:         Weight: 98
 # BASIC-NEXT: Symbols:

 # RUN: obj2yaml %t.invalid | FileCheck %s --check-prefix=INVALID
 
 # INVALID:      --- !ELF
 # INVALID-NEXT: FileHeader:
 # INVALID-NEXT:   Class: ELFCLASS32
 # INVALID-NEXT:   Data:  ELFDATA2MSB
 # INVALID-NEXT:   Type:  ET_DYN
 # INVALID-NEXT: Sections:
-# INVALID-NEXT:   - Name:    .empty
-# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link:    .symtab
-# INVALID-NEXT:     EntSize: 0x10
-# INVALID-NEXT:   - Name:    .multiple.16.valid
-# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link:    .symtab
-# INVALID-NEXT:     EntSize: 0x10
+# INVALID-NEXT:   - Name: .empty
+# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# INVALID-NEXT:     Link: .symtab
+# INVALID-NEXT:   - Name: .multiple.16.valid
+# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     Entries:
 # INVALID-NEXT:       - From:   foo
 # INVALID-NEXT:         To:     bar
 # INVALID-NEXT:         Weight: 3
-# INVALID-NEXT:   - Name:    .non.multiple.16
-# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link:    .symtab
-# INVALID-NEXT:     EntSize: 0x10
+# INVALID-NEXT:   - Name: .non.multiple.16
+# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     Content: '0000000100000002000000000000000300'
-# INVALID-NEXT:   - Name:    .multiple.16.invalid
-# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link:    .symtab
-# INVALID-NEXT:     EntSize: 0x10
+# INVALID-NEXT:   - Name: .multiple.16.invalid
+# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     Content: 00112233445566778899AABBCCDDEEFF
-# INVALID-NEXT:   - Name:    .unknown.symbol.1
-# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link:    .symtab
-# INVALID-NEXT:     EntSize: 0x10
+# INVALID-NEXT:   - Name: .unknown.symbol.1
+# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     Content: 000000FF000000020000000000000003
-# INVALID-NEXT:   - Name:    .unknown.symbol.2
-# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link:    .symtab
-# INVALID-NEXT:     EntSize: 0x10
+# INVALID-NEXT:   - Name: .unknown.symbol.2
+# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     Content: 00000001000000FF0000000000000003
-# INVALID-NEXT:   - Name:    .link.to.symtable
-# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link:    .symtab
-# INVALID-NEXT:     EntSize: 0x10
+# INVALID-NEXT:   - Name: .link.to.symtable
+# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     Entries:
 # INVALID-NEXT:       - From:   foo
 # INVALID-NEXT:         To:     bar
 # INVALID-NEXT:         Weight: 0
-# INVALID-NEXT:   - Name:    .link.to.non.symtable.1
-# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     EntSize: 0x10
+# INVALID-NEXT:   - Name: .link.to.non.symtable.1
+# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Content: '00000001000000020000000000000000'
-# INVALID-NEXT:   - Name:    .link.to.non.symtable.2
-# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link:    .empty
-# INVALID-NEXT:     EntSize: 0x10
+# INVALID-NEXT:   - Name: .link.to.non.symtable.2
+# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
+# INVALID-NEXT:     Link: .empty
 # INVALID-NEXT:     Content: '00000001000000020000000000000000'
-# INVALID-NEXT:   - Name: .zero.entry.size
-# INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
-# INVALID-NEXT:     Link: .symtab
+# INVALID-NEXT:   - Name:    .zero.entry.size
+# INVALID-NEXT:     Type:    SHT_LLVM_CALL_GRAPH_PROFILE
+# INVALID-NEXT:     Link:    .symtab
+# INVALID-NEXT:     EntSize: 0x0
 # INVALID-NEXT:     Entries:
 # INVALID-NEXT:       - From:   foo
 # INVALID-NEXT:         To:     bar
 # INVALID-NEXT:         Weight: 0
 # INVALID-NEXT:   - Name: .invalid.entry.size
 # INVALID-NEXT:     Type: SHT_LLVM_CALL_GRAPH_PROFILE
 # INVALID-NEXT:     Link: .symtab
 # INVALID-NEXT:     EntSize: 0x1
##         is not a symbol table.
   - Name: .link.to.non.symtable.2
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     Link: 1
     Entries:
       - From:   1
         To:     2
         Weight: 0
 ## Case 5: Check we can dump a section that has a sh_entsize that is not a multiple of 16.
+##         Check that in these cases we print the "EntSize" key.
   - Name: .zero.entry.size
     Type: SHT_LLVM_CALL_GRAPH_PROFILE
     EntSize: 0
     Entries:
       - From:   1
         To:     2
         Weight: 0
   - Name: .invalid.entry.size

llvm/test/tools/obj2yaml/ELF/mips-abi-flags.yaml

 ## Check how obj2yaml dumps SHT_MIPS_ABIFLAGS sections.
 
 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 # CHECK:      Sections:
 # CHECK-NEXT:   - Name:         .MIPS.abiflags
 # CHECK-NEXT:     Type:         SHT_MIPS_ABIFLAGS
 # CHECK-NEXT:     AddressAlign: 0x8
-# CHECK-NEXT:     EntSize:      0x18
 # CHECK-NEXT:     ISA:          MIPS64
 # CHECK-NEXT:     ISARevision:  0x5
 # CHECK-NEXT:     ISAExtension: EXT_OCTEON3
 # CHECK-NEXT:     ASEs:         [ DSP, DSPR2, VIRT ]
 # CHECK-NEXT:     FpABI:        FP_DOUBLE
 # CHECK-NEXT:     GPRSize:      REG_64
 # CHECK-NEXT:     CPR1Size:     REG_64
 # CHECK-NEXT:     Flags1:       [ ODDSPREG ]

 # RUN: yaml2obj %s --docnum=2 -DMACHINE=EM_NONE -o %t2.notmips
 # RUN: obj2yaml %t2.notmips | FileCheck %s --check-prefix=NOT-MIPS
 
 # RUN: yaml2obj %s --docnum=2 -DMACHINE=EM_MIPS -o %t2.mips
 # RUN: obj2yaml %t2.mips | FileCheck %s --check-prefix=MIPS
 
 # MIPS:      - Name: .MIPS.abiflags
 # MIPS-NEXT:   Type: SHT_MIPS_ABIFLAGS
+## We don't print the "EntSize" key, because 0x18 is the default value
+## for the sh_entsize field of SHT_MIPS_ABIFLAGS.
 # MIPS-NEXT:   ISA:  0x0
 # MIPS-NEXT: ...
 
 # NOT-MIPS:      - Name:    .MIPS.abiflags
 # NOT-MIPS-NEXT:   Type:    0x7000002A
+## We print the "EntSize" key, because 0x7000002A only means
+## "SHT_MIPS_ABIFLAGS" when machine is EM_MIPS, so 0x18 is not a known default value.
+# NOT-MIPS-NEXT:   EntSize: 0x18
 # NOT-MIPS-NEXT:   Content: '000000000000000000000000000000000000000000000000'
 # NOT-MIPS-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2MSB
   Type:    ET_REL
   Machine: [[MACHINE]]
 Sections:
-  - Name:   .MIPS.abiflags
-    Type:   SHT_PROGBITS
-    ShType: 0x7000002a ## SHT_MIPS_ABIFLAGS.
-    Size:   0x18
+  - Name:    .MIPS.abiflags
+    Type:    SHT_PROGBITS
+    ShType:  0x7000002a ## SHT_MIPS_ABIFLAGS.
+    Size:    0x18
+    EntSize: 0x18

llvm/test/tools/obj2yaml/ELF/sht-symtab-shndx.yaml

 ## Check that obj2yaml is able to dump a normal object which
 ## contains the SHT_SYMTAB_SHNDX section and symbols with
 ## section index == SHN_XINDEX.
 
 # RUN: yaml2obj --docnum=1 %s -o %t1
 # RUN: obj2yaml %t1 | FileCheck %s --check-prefix=CASE1
 
 # CASE1:      --- !ELF
 # CASE1-NEXT: FileHeader:
 # CASE1-NEXT:   Class: ELFCLASS64
 # CASE1-NEXT:   Data:  ELFDATA2LSB
 # CASE1-NEXT:   Type:  ET_REL
 # CASE1-NEXT: Sections:
-# CASE1-NEXT:   - Name:    bar
-# CASE1-NEXT:     Type:    SHT_PROGBITS
-# CASE1-NEXT:   - Name:    .symtab_shndx
-# CASE1-NEXT:     Type:    SHT_SYMTAB_SHNDX
-# CASE1-NEXT:     Link:    .symtab
-# CASE1-NEXT:     EntSize: 0x4
+# CASE1-NEXT:   - Name: bar
+# CASE1-NEXT:     Type: SHT_PROGBITS
+# CASE1-NEXT:   - Name: .symtab_shndx
+# CASE1-NEXT:     Type: SHT_SYMTAB_SHNDX
+# CASE1-NEXT:     Link: .symtab
 # CASE1-NEXT:     Entries: [ 0, 1, 2 ]
 # CASE1-NEXT: Symbols:
 # CASE1-NEXT:   - Name:  bar
 # CASE1-NEXT:     Type:  STT_SECTION
 # CASE1-NEXT:     Index: SHN_XINDEX
 # CASE1-NEXT:   - Name:  .symtab_shndx
 # CASE1-NEXT:     Type:  STT_SECTION
 # CASE1-NEXT:     Index: SHN_XINDEX
FileHeader:
   Type:  ET_REL
 Sections:
   - Name:    .symtab_shndx
     Type:    SHT_SYMTAB_SHNDX
     Entries: [ 0 ]
     Link:    .foo
   - Name:    .foo
     Type:    SHT_PROGBITS
+
+## Check that we are unable to dump the SHT_SYMTAB_SHNDX section when its
+## sh_entsize has an unexpected value (not equal to 4).
+## Check we don't print the "EntSize" field when the "sh_entsize" field has the default value.
+
+# RUN: yaml2obj -DENTSIZE=0xff --docnum=7 %s -o %t7.entsize.bad
+# RUN: not obj2yaml %t7.entsize.bad 2>&1 | \
+# RUN:   FileCheck %s -DFILE=%t7.entsize.bad --check-prefix=CASE7-BAD
+
+# CASE7-BAD: Error reading file: [[FILE]]: unable to read extended section indexes: section [index 1] has invalid sh_entsize: expected 4, but got 255
+
+# RUN: yaml2obj -DENTSIZE=4 --docnum=7 %s -o %t7.entsize.ok
+# RUN: obj2yaml %t7.entsize.ok | FileCheck %s -DFILE=%t7.entsize.ok --check-prefix=CASE7
+
+# CASE7:      - Name:    .symtab_shndx
+# CASE7-NEXT:   Type:    SHT_SYMTAB_SHNDX
+# CASE7-NEXT:   Link:    .symtab
+# CASE7-NEXT:   Entries: [ 0 ]
+# CASE7-NEXT: Symbols:
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+Sections:
+  - Name:    .symtab_shndx
+    Type:    SHT_SYMTAB_SHNDX
+    EntSize: [[ENTSIZE]]
+    Entries: [ 0 ]
+    Link:    .symtab
+Symbols: []

llvm/test/tools/obj2yaml/ELF/versym-section.yaml

 # RUN: yaml2obj %s -o %t
 # RUN: obj2yaml %t | FileCheck %s
 
 ## Check we are able to yamalize the SHT_GNU_versym section.
 
 # CHECK:      --- !ELF
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Class: ELFCLASS64
 # CHECK-NEXT:   Data:  ELFDATA2LSB
 # CHECK-NEXT:   Type:  ET_EXEC
 # CHECK-NEXT:   Entry: 0x201000
 # CHECK-NEXT: Sections:
-# CHECK-NEXT:   - Name:            .gnu.version
-# CHECK-NEXT:     Type:            SHT_GNU_versym
-# CHECK-NEXT:     Flags:           [ SHF_ALLOC ]
-# CHECK-NEXT:     Address:         0x200210
-# CHECK-NEXT:     Link:            .dynsym
-# CHECK-NEXT:     AddressAlign:    0x2
-# CHECK-NEXT:     EntSize:         0x2
-# CHECK-NEXT:     Entries:         [ 0, 3, 4 ]
+# CHECK-NEXT:   - Name:         .gnu.version
+# CHECK-NEXT:     Type:         SHT_GNU_versym
+# CHECK-NEXT:     Flags:        [ SHF_ALLOC ]
+# CHECK-NEXT:     Address:      0x200210
+# CHECK-NEXT:     Link:         .dynsym
+# CHECK-NEXT:     AddressAlign: 0x2
+# CHECK-NEXT:     Entries:      [ 0, 3, 4 ]
 # CHECK-NEXT:   - Name:
 # CHECK:      DynamicSymbols:
 # CHECK-NEXT:   - Name:    f1
 # CHECK-NEXT:     Binding: STB_GLOBAL
 # CHECK-NEXT:   - Name:    f2
 # CHECK-NEXT:     Binding: STB_GLOBAL
 
 --- !ELF

llvm/test/tools/yaml2obj/ELF/arm-exidx-section.yaml

 
 ## Check we can set arbitrary section properties for a SHT_ARM_EXIDX section.
 ## Also check that we are able to specify none of "Entries", "Content" nor "Size" keys.
 
 # RUN: yaml2obj --docnum=2 %s -o %t.props.o
 # RUN: llvm-readelf --sections %t.props.o | FileCheck %s --check-prefix=PROPERTIES
 
 # PROPERTIES: [Nr] Name       Type      Address          Off    Size   ES Flg Lk    Inf Al
-# PROPERTIES: [ 1] .ARM.exidx ARM_EXIDX 0000000000001122 000055 000000 00 AMS 13124 0   85
+# PROPERTIES: [ 1] .ARM.exidx ARM_EXIDX 0000000000001122 000055 000000 66 AMS 13124 0   85
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_ARM
 Sections:

llvm/tools/obj2yaml/elf2yaml.cpp

Error ELFDumper<ELFT>::dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
   if (!NameOrErr)
     return NameOrErr.takeError();
   R.Symbol = NameOrErr.get();
 
   return Error::success();
 }
 
 template <class ELFT>
-static unsigned getDefaultShEntSize(ELFYAML::ELF_SHT SecType,
-                                    StringRef SecName) {
-  switch (SecType) {
-  case ELF::SHT_GROUP:
-    return sizeof(typename ELFT::Word);
-  case ELF::SHT_REL:
-    return sizeof(typename ELFT::Rel);
-  case ELF::SHT_RELA:
-    return sizeof(typename ELFT::Rela);
-  case ELF::SHT_RELR:
-    return sizeof(typename ELFT::Relr);
-  case ELF::SHT_DYNAMIC:
-    return sizeof(typename ELFT::Dyn);
-  case ELF::SHT_HASH:
-    return sizeof(typename ELFT::Word);
-  default:
-    if (SecName == ".debug_str")
-      return 1;
-    return 0;
-  }
-}
-
-template <class ELFT>
 Error ELFDumper<ELFT>::dumpCommonSection(const Elf_Shdr *Shdr,
                                          ELFYAML::Section &S) {
   // Dump fields. We do not dump the ShOffset field. When not explicitly
   // set, the value is set by yaml2obj automatically.
   S.Type = Shdr->sh_type;
   if (Shdr->sh_flags)
     S.Flags = static_cast<ELFYAML::ELF_SHF>(Shdr->sh_flags);
   if (Shdr->sh_addr)
     S.Address = static_cast<uint64_t>(Shdr->sh_addr);
   S.AddressAlign = Shdr->sh_addralign;
 
   S.OriginalSecNdx = Shdr - &Sections[0];
 
   auto NameOrErr = getUniquedSectionName(Shdr);
   if (!NameOrErr)
     return NameOrErr.takeError();
   S.Name = NameOrErr.get();
 
-  if (Shdr->sh_entsize != getDefaultShEntSize<ELFT>(S.Type, S.Name))
+  if (Shdr->sh_entsize != ELFYAML::getDefaultShEntSize<ELFT>(
+                              Obj.getHeader().e_machine, S.Type, S.Name))
     S.EntSize = static_cast<llvm::yaml::Hex64>(Shdr->sh_entsize);
 
   if (Shdr->sh_link != ELF::SHN_UNDEF) {
     auto LinkSection = Obj.getSection(Shdr->sh_link);
     if (!LinkSection)
       return make_error<StringError>(
           "unable to resolve sh_link reference in section '" + S.Name +
               "': " + toString(LinkSection.takeError()),