[yaml2obj] - Rename FileHeader::SH* fields.

[grimar]

Summary

In D83482 we agreed to name e_* fields that are used for overriding
values (like e_phoff) as EPh* (e.g. EPhOff).

Currently we have a set of e_sh* fields that are named inconsistently
with this rule. This patch renames all of them.

[jhenderson]

LGTM, with request.

llvm/lib/ObjectYAML/ELFYAML.cpp

872–873

This assert extension might better belong in a separate patch, to avoid confusing issues.

[grimar]

llvm/lib/ObjectYAML/ELFYAML.cpp

872–873

OK, I'll remove.

[MaskRay]

(Honestly if we could start over, I would hope we just use lower-case elf.h variable names, e.g. e_phoff)

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct FileHeader {
   ELF_ET Type;
   ELF_EM Machine;
   ELF_EF Flags;
   llvm::yaml::Hex64 Entry;
 
   Optional<llvm::yaml::Hex64> EPhOff;
   Optional<llvm::yaml::Hex16> EPhEntSize;
   Optional<llvm::yaml::Hex16> EPhNum;
-
-  Optional<llvm::yaml::Hex16> SHEntSize;
-  Optional<llvm::yaml::Hex64> SHOff;
-  Optional<llvm::yaml::Hex16> SHNum;
-  Optional<llvm::yaml::Hex16> SHStrNdx;
+  Optional<llvm::yaml::Hex16> EShEntSize;
+  Optional<llvm::yaml::Hex64> EShOff;
+  Optional<llvm::yaml::Hex16> EShNum;
+  Optional<llvm::yaml::Hex16> EShStrNdx;
 };
 
 struct SectionHeader {
   StringRef Name;
 };
 
 struct SectionHeaderTable {
   Optional<std::vector<SectionHeader>> Sections;

llvm/lib/ObjectYAML/ELFEmitter.cpp

void ELFState<ELFT>::writeELFHeader(raw_ostream &OS, uint64_t SHOff) {
 
   if (Doc.Header.EPhNum)
     Header.e_phnum = *Doc.Header.EPhNum;
   else if (!Doc.ProgramHeaders.empty())
     Header.e_phnum = Doc.ProgramHeaders.size();
   else
     Header.e_phnum = 0;
 
-  Header.e_shentsize =
-      Doc.Header.SHEntSize ? (uint16_t)*Doc.Header.SHEntSize : sizeof(Elf_Shdr);
+  Header.e_shentsize = Doc.Header.EShEntSize ? (uint16_t)*Doc.Header.EShEntSize
+                                             : sizeof(Elf_Shdr);
 
   const bool NoShdrs =
       Doc.SectionHeaders && Doc.SectionHeaders->NoHeaders.getValueOr(false);
 
-  if (Doc.Header.SHOff)
-    Header.e_shoff = *Doc.Header.SHOff;
+  if (Doc.Header.EShOff)
+    Header.e_shoff = *Doc.Header.EShOff;
   else if (NoShdrs)
     Header.e_shoff = 0;
   else
     Header.e_shoff = SHOff;
 
-  if (Doc.Header.SHNum)
-    Header.e_shnum = *Doc.Header.SHNum;
+  if (Doc.Header.EShNum)
+    Header.e_shnum = *Doc.Header.EShNum;
   else if (!Doc.SectionHeaders)
     Header.e_shnum = Doc.getSections().size();
   else if (NoShdrs)
     Header.e_shnum = 0;
   else
     Header.e_shnum =
         (Doc.SectionHeaders->Sections ? Doc.SectionHeaders->Sections->size()
                                       : 0) +
         /*Null section*/ 1;
 
-  if (Doc.Header.SHStrNdx)
-    Header.e_shstrndx = *Doc.Header.SHStrNdx;
+  if (Doc.Header.EShStrNdx)
+    Header.e_shstrndx = *Doc.Header.EShStrNdx;
   else if (NoShdrs || ExcludedSectionHeaders.count(".shstrtab"))
     Header.e_shstrndx = 0;
   else
     Header.e_shstrndx = SN2I.get(".shstrtab");
 
   OS.write((const char *)&Header, sizeof(Header));
 }
 

llvm/lib/ObjectYAML/ELFYAML.cpp

void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
   IO.mapRequired("Type", FileHdr.Type);
   IO.mapRequired("Machine", FileHdr.Machine);
   IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
   IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
 
   // obj2yaml does not dump these fields.
   assert(!IO.outputting() ||
          (!FileHdr.EPhOff && !FileHdr.EPhEntSize && !FileHdr.EPhNum));
   IO.mapOptional("EPhOff", FileHdr.EPhOff);
   IO.mapOptional("EPhEntSize", FileHdr.EPhEntSize);
   IO.mapOptional("EPhNum", FileHdr.EPhNum);
-
-  IO.mapOptional("SHEntSize", FileHdr.SHEntSize);
-  IO.mapOptional("SHOff", FileHdr.SHOff);
-  IO.mapOptional("SHNum", FileHdr.SHNum);
-  IO.mapOptional("SHStrNdx", FileHdr.SHStrNdx);
+  IO.mapOptional("EShEntSize", FileHdr.EShEntSize);
+  IO.mapOptional("EShOff", FileHdr.EShOff);
+  IO.mapOptional("EShNum", FileHdr.EShNum);
+  IO.mapOptional("EShStrNdx", FileHdr.EShStrNdx);
 }
 
 void MappingTraits<ELFYAML::ProgramHeader>::mapping(
     IO &IO, ELFYAML::ProgramHeader &Phdr) {
   IO.mapRequired("Type", Phdr.Type);
   IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
   IO.mapOptional("Sections", Phdr.Sections);
   IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));

llvm/test/Object/invalid.test

 
 # RUN: yaml2obj %s --docnum=9 -o %t9
 # RUN: not llvm-readobj -S %t9 2>&1 | FileCheck --check-prefix=INVALID-SH-ENTSIZE %s
 
 # INVALID-SH-ENTSIZE: error: {{.*}}: invalid  e_shentsize in ELF header: 1
 
 --- !ELF
 FileHeader:
-  Class:     ELFCLASS64
-  Data:      ELFDATA2LSB
-  Type:      ET_REL
-  Machine:   EM_X86_64
-  SHEntSize: 1
+  Class:      ELFCLASS64
+  Data:       ELFDATA2LSB
+  Type:       ET_REL
+  Machine:    EM_X86_64
+  EShEntSize: 1
 
 ## Check that llvm-readobj reports a warning if .symtab has sh_size
 ## that is not a multiple of sh_entsize.
 
 # RUN: yaml2obj %s --docnum=10 -o %t10
 # RUN: llvm-readobj --symbols %t10 2>&1 | FileCheck -DFILE=%t10 --check-prefix=INVALID-SYMTAB-SIZE %s
 
 # INVALID-SYMTAB-SIZE: warning: '[[FILE]]': unable to read symbols from the SHT_SYMTAB section: section [index 1] has an invalid sh_size (1) which is not a multiple of its sh_entsize (24)

 
 # RUN: yaml2obj %s --docnum=15 -o %t15
 # RUN: not llvm-readobj -S %t15 2>&1 | FileCheck --check-prefix=INVALID-SECTION-NUM %s
 
 # INVALID-SECTION-NUM: error: {{.*}}: section table goes past the end of file
  
 --- !ELF
 FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_REL
-  Machine: EM_X86_64
-  SHNum:   0xFF
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64
+  EShNum:   0xFF
 
 ## Check llvm-readobj does not crash on a truncated ELF.
 
 ## Create a truncated ELF object with ELFCLASSNONE class using echo.
 ## 0x7f, 'E', 'L', 'F', ELFCLASS64(2), ELFDATA2LSB(1),
 ## EV_CURRENT(1), ELFOSABI_LINUX(3), <padding zero bytes>, ET_REL(1), EM_NONE(0)
 # RUN: echo -e -n "\x7f\x45\x4c\x46\x02\x01\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" > %t11
 # RUN: not llvm-readobj -r %t11 2>&1 | FileCheck --check-prefix=INVALID-BUFFER %s

 
 # 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:
-  Class:    ELFCLASS64
-  Data:     ELFDATA2LSB
-  Type:     ET_REL
-  Machine:  EM_X86_64
-  SHStrNdx: 0xFF
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_REL
+  Machine:   EM_X86_64
+  EShStrNdx: 0xFF
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
 
 ## We report an error if the number of sections stored in sh_size
 ## is greater than UINT64_MAX / sizeof(Elf_Shdr) == 288230376151711743.
 ## Here we check that do not crash on a border value.
 
 # RUN: yaml2obj --docnum=25 %s -o %t25
 # RUN: not llvm-readobj -h %t25 2>&1 | FileCheck -DFILE=%t25 --check-prefix=INVALID-SEC-NUM1 %s
 
 # INVALID-SEC-NUM1: error: '[[FILE]]': invalid section header table offset (e_shoff = 0x58) or invalid number of sections specified in the first section header's sh_size field (0x3ffffffffffffff)
 
 --- !ELF
 FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_REL
-  Machine: EM_X86_64
-  SHNum:   0x0
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64
+  EShNum:   0x0
 Sections:
   - Type: SHT_NULL
     Size: 288230376151711743
 
 ## See above, but now we test the UINT64_MAX / sizeof(Elf_Shdr) value.
 ## The error is slightly different in this case.
 
 # RUN: yaml2obj --docnum=26 %s -o %t26
 # RUN: not llvm-readobj -h %t26 2>&1 | FileCheck -DFILE=%t26 --check-prefix=INVALID-SEC-NUM2 %s
 
 # INVALID-SEC-NUM2: error: '[[FILE]]': invalid number of sections specified in the NULL section's sh_size field (288230376151711744)
 
 --- !ELF
 FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_REL
-  Machine: EM_X86_64
-  SHNum:   0x0
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_X86_64
+  EShNum:   0x0
 Sections:
   - Type: SHT_NULL
     Size: 288230376151711744
 
 ## Check the case when SHOff is too large. SHOff + sizeof(Elf_Shdr) overflows the uint64 type.
 
 # RUN: yaml2obj --docnum=27 %s -o %t27
 # RUN: not llvm-readobj -h %t27 2>&1 | FileCheck -DFILE=%t27 --check-prefix=INVALID-SEC-NUM3 %s
 
 # INVALID-SEC-NUM3: error: '[[FILE]]': section header table goes past the end of the file: e_shoff = 0xffffffffffffffff
  
 --- !ELF
 FileHeader:
-  Class:    ELFCLASS64
-  Data:     ELFDATA2LSB
-  Type:     ET_REL
-  Machine:  EM_X86_64
-  SHOff:    0xffffffffffffffff
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+  EShOff:  0xffffffffffffffff
 
 ## Check that llvm-objdump reports an error when it tries to dump a
 ## symbol name and .strtab is empty.
 
 # RUN: yaml2obj %s --docnum=28 -o %t28
 # RUN: not llvm-objdump --syms %t28 2>&1 | FileCheck -DFILE=%t28 --check-prefix=STRTAB-EMPTY2 %s
 
 # STRTAB-EMPTY2: error: '[[FILE]]': SHT_STRTAB string table section [index 1] is empty

 
 # RUN: yaml2obj --docnum=30 %s -o %t30
 # RUN: not llvm-objcopy %t30 2>&1 | FileCheck %s -DFILE=%t30 --check-prefix=INVALID-SHSTRTAB-INDEX
 
 # INVALID-SHSTRTAB-INDEX: error: section header string table index 255 does not exist
 
 --- !ELF
 FileHeader:
-  Class:    ELFCLASS64
-  Data:     ELFDATA2LSB
-  Type:     ET_REL
-  Machine:  EM_X86_64
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_REL
+  Machine:   EM_X86_64
 ## SHN_XINDEX == 0xffff.
-  SHStrNdx: 0xffff
+  EShStrNdx: 0xffff
 Sections:
   - Type: SHT_NULL
     Link: 0xff
 
 ## Check the case when the e_phoff field is invalid.
 # RUN: yaml2obj --docnum=31 %s -o %t31
 # RUN: not llvm-objdump --private-headers %t31 2>&1 | FileCheck -DFILE=%t31 %s --check-prefix=INVALID-PHOFF
 

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
 ## We simulate no section header table by
 ## overriding the ELF header properties.
-  SHOff:   0x0
-  SHNum:   0x0
+  EShOff:  0x0
+  EShNum:  0x0
 Sections:
   - Name:    .rela.dyn
     Type:    SHT_RELA
     Relocations:
       - Type:   R_X86_64_NONE
         Symbol: 0x1
   - Name: .dynamic
     Type: SHT_DYNAMIC

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

 
 --- !ELF
 FileHeader:
   Class:      ELFCLASS64
   Data:       ELFDATA2LSB
   Type:       ET_EXEC
   Machine:    EM_X86_64
   EPhEntSize: [[PHENTSIZE=56]]
-  SHNum:      [[SHNUM=6]]
+  EShNum:     [[SHNUM=6]]
 Sections:
   - Name:         .note.ABI-tag
     Type:         SHT_NOTE
     AddressAlign: 0x0000000000000004
     Content:      040000001000000001000000474E550000000000020000000600000020000000
   - Name:         .note.gnu.build-id
     Type:         SHT_NOTE
     Flags:        [ SHF_ALLOC ]

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

 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_DYN
   Machine: EM_X86_64
 ## We simulate no section header table by
 ## overriding the ELF header properties.
-  SHOff:   0x0
-  SHNum:   0x0
+  EShOff:  0x0
+  EShNum:  0x0
 Sections:
   - Name:   .hash
     Type:   SHT_HASH
     Flags:  [ SHF_ALLOC ]
     Bucket: [ 0 ]
     Chain:  [ 1 ]
   - Name:  .dynamic
     Type:  SHT_DYNAMIC

llvm/test/tools/llvm-readobj/ELF/invalid-shstrndx.test

 # LLVM-NEXT: Name: <?> (1)
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
-  SHStrNdx:  0xFF
+  EShStrNdx: 0xFF

llvm/test/tools/llvm-readobj/ELF/many-sections.s

 # GNU1: There are 3 section headers, starting at offset 0x58
 
 # RUN: llvm-readobj --file-headers %t1 | FileCheck %s --check-prefix=LLVM1
 # LLVM1: SectionHeaderCount: 0 (3)
 # LLVM1: StringTableSectionIndex: 65535 (2)
 
 --- !ELF
 FileHeader:
-  Class:    ELFCLASS64
-  Data:     ELFDATA2LSB
-  Type:     ET_REL
-  Machine:  EM_X86_64
-  SHNum:    0
-  SHStrNdx: 0xffff ## SHN_XINDEX
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_REL
+  Machine:   EM_X86_64
+  EShNum:    0
+  EShStrNdx: 0xffff ## SHN_XINDEX
 Sections:
   - Type: SHT_NULL
     Link: .shstrtab
     Size: 0x3
 
 ## Another case is when e_shoff field set to zero, but not e_shstrndx.
 ## We want to show that this corrupt case is handled correctly.
 

 # LLVM2:       SectionHeaderCount: 0
 # LLVM2:       StringTableSectionIndex: 65535 (corrupt: out of range)
 # LLVM2-NEXT: }
 # LLVM2-NEXT: Sections [
 # LLVM2-NEXT: ]
 
 --- !ELF
 FileHeader:
-  Class:    ELFCLASS64
-  Data:     ELFDATA2LSB
-  Type:     ET_REL
-  Machine:  EM_X86_64
-  SHOff:    0
-  SHNum:    0
-  SHStrNdx: 0xffff ## SHN_XINDEX
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_REL
+  Machine:   EM_X86_64
+  EShOff:    0
+  EShNum:    0
+  EShStrNdx: 0xffff ## SHN_XINDEX
 Sections:
   - Type: SHT_NULL
     Link: .shstrtab
     Size: 0x3

llvm/test/tools/llvm-readobj/ELF/sections-no-section-header-string-table.test

 # LLVM-NEXT:     Info: 0
 # LLVM-NEXT:     AddressAlignment: 1
 # LLVM-NEXT:     EntrySize: 0
 # LLVM-NEXT:   }
 # LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
-  Class:    ELFCLASS64
-  Data:     ELFDATA2LSB
-  Type:     ET_DYN
-  Machine:  EM_X86_64
-  SHStrNdx: 0
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_DYN
+  Machine:   EM_X86_64
+  EShStrNdx: 0
 Sections:
   - Name:   .foo
     Type:   SHT_PROGBITS
     ShName: 0
   - Name:   .bar
     Type:   SHT_PROGBITS
     ShName: 1

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

 # STRTAB-LINK-ERR-GNU-NEXT:      1: 0000000000000001     0 NOTYPE  GLOBAL DEFAULT     1 <?>
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
-  SHStrNdx:  [[SHSTRTAB=2]]
+  EShStrNdx: [[SHSTRTAB=2]]
 Sections:
   - Name:    .symtab
     Type:    SHT_SYMTAB
     Link:    [[LINK=.strtab]]
     EntSize: [[ENTSIZE=0x18]]
 ## Define the .shstrtab section to reveal its position.
   - Name: .shstrtab
     Type: SHT_STRTAB

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

 
 ## 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
-  Machine:   EM_X86_64
-  SHEntSize:  [[SHENTSIZE=64]]
-  SHOff:      [[SHOFF=200]]
-  SHNum:      [[SHNUM=3]]
-  SHStrNdx:   [[SHSTRNDX=2]]
+  Class:      ELFCLASS64
+  Data:       ELFDATA2LSB
+  Type:       ET_REL
+  Machine:    EM_X86_64
+  EShEntSize: [[SHENTSIZE=64]]
+  EShOff:     [[SHOFF=200]]
+  EShNum:     [[SHNUM=3]]
+  EShStrNdx:  [[SHSTRNDX=2]]
   EPhOff:     [[PHOFF=64]]
   EPhEntSize: [[PHENTSIZE=56]]
   EPhNum:     [[PHNUM=2]]
 ProgramHeaders:
   - Type:     PT_LOAD
     Sections: []
   - Type:     PT_LOAD
     Sections: []

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

 # NO-HEADERS-OVERRIDE: Section header string table index: 4
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   Machine:   EM_X86_64
-  SHOff:     0x2
-  SHNum:     0x3
-  SHStrNdx:  0x4
+  EShOff:    0x2
+  EShNum:    0x3
+  EShStrNdx: 0x4
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
 SectionHeaderTable:
   NoHeaders: true
 
 ## Check that section indices are updated properly in other places when we
 ## reorder sections in the section header table.

llvm/tools/obj2yaml/elf2yaml.cpp

if (S.Type == ELF::SHT_STRTAB || S.Type == ELF::SHT_SYMTAB ||
     return S.Flags.getValueOr(ELFYAML::ELF_SHF(0)) & ELF::SHF_ALLOC;
 
   return true;
 }
 
 template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
   auto Y = std::make_unique<ELFYAML::Object>();
 
-  // Dump header. We do not dump EPh* and SH* fields. When not explicitly set,
+  // Dump header. We do not dump EPh* and ESh* fields. When not explicitly set,
   // the values are set by yaml2obj automatically and there is no need to dump
   // them here.
   Y->Header.Class = ELFYAML::ELF_ELFCLASS(Obj.getHeader()->getFileClass());
   Y->Header.Data = ELFYAML::ELF_ELFDATA(Obj.getHeader()->getDataEncoding());
   Y->Header.OSABI = Obj.getHeader()->e_ident[ELF::EI_OSABI];
   Y->Header.ABIVersion = Obj.getHeader()->e_ident[ELF::EI_ABIVERSION];
   Y->Header.Type = Obj.getHeader()->e_type;
   Y->Header.Machine = Obj.getHeader()->e_machine;