[llvm-readobj] - Dump the ELF file type better.

[grimar]

Summary

Currently llvm-readelf might print "OS Specific/Processor Specific/<unknown>"
hint when dumping the ELF file type. The patch teaches llvm-readobj to do the same.

This fixes https://bugs.llvm.org/show_bug.cgi?id=40868

I am removing Object/elf-unknown-type.test test because it is not in the right place,
it is outdated and very limited.
The readobj/ELF/file-types.test checks the functionality much better.

[MaskRay]

llvm/tools/llvm-readobj/ELFDumper.cpp

3516

static

llvm/test/Object/elf-unknown-type.test

-# RUN: yaml2obj %s | llvm-readobj --file-headers - | FileCheck %s
-
-!ELF
-FileHeader: !FileHeader
-  Class: ELFCLASS64
-  Data: ELFDATA2LSB
-  Type: 42
-  Machine: EM_X86_64
-
-# CHECK: Type: 0x2A

llvm/test/tools/llvm-readobj/ELF/file-types.test

 # GNU-CORE:   Type: CORE (Core file)
 
 ## Test what we dump for an arbitrary unknown ELF type.
 # RUN: yaml2obj %s -DTYPE=0xFDFF -o %t.unknown
 # RUN: llvm-readobj -h %t.unknown | FileCheck %s --match-full-lines --check-prefix LLVM-UNNKNOWN
 # RUN: llvm-readelf -h %t.unknown | FileCheck %s --match-full-lines --check-prefix GNU-UNNKNOWN
 
 # LLVM-UNNKNOWN: ElfHeader {
-# LLVM-UNNKNOWN:   Type: 0xFDFF
+# LLVM-UNNKNOWN:   Type: Unknown (0xFDFF)
 
 # GNU-UNNKNOWN: ELF Header:
 # GNU-UNNKNOWN:   Type: <unknown>: fdff
 
 # RUN: yaml2obj %s -DTYPE=0xfe00 -o %t6
 # RUN: llvm-readobj -h %t6 | FileCheck %s --match-full-lines --check-prefix LLVM-LOOS
 # RUN: llvm-readelf -h %t6 | FileCheck %s --match-full-lines --check-prefix GNU-LOOS
 
 # LLVM-LOOS: ElfHeader {
-# LLVM-LOOS:   Type: 0xFE00
+# LLVM-LOOS:   Type: OS Specific (0xFE00)
 
 # GNU-LOOS: ELF Header:
 # GNU-LOOS:   Type: OS Specific: (fe00)
 
 # RUN: yaml2obj %s -DTYPE=0xfeff -o %t7
 # RUN: llvm-readobj -h %t7 | FileCheck %s --match-full-lines --check-prefix LLVM-HIOS
 # RUN: llvm-readelf -h %t7 | FileCheck %s --match-full-lines --check-prefix GNU-HIOS
 
 # LLVM-HIOS: ElfHeader {
-# LLVM-HIOS:   Type: 0xFEFF
+# LLVM-HIOS:   Type: OS Specific (0xFEFF)
 
 # GNU-HIOS: ELF Header:
 # GNU-HIOS:   Type: OS Specific: (feff)
 
 # RUN: yaml2obj %s -DTYPE=0xff00 -o %t8
 # RUN: llvm-readobj -h %t8 | FileCheck %s --match-full-lines --check-prefix LLVM-LOPROC
 # RUN: llvm-readelf -h %t8 | FileCheck %s --match-full-lines --check-prefix GNU-LOPROC
 
 # LLVM-LOPROC: ElfHeader {
-# LLVM-LOPROC:   Type: 0xFF00
+# LLVM-LOPROC:   Type: Processor Specific (0xFF00)
 
 # GNU-LOPROC: ELF Header:
 # GNU-LOPROC:   Type: Processor Specific: (ff00)
 
 # RUN: yaml2obj %s -DTYPE=0xffff -o %t9
 # RUN: llvm-readobj -h %t9 | FileCheck %s --match-full-lines --check-prefix LLVM-HIPROC
 # RUN: llvm-readelf -h %t9 | FileCheck %s --match-full-lines --check-prefix GNU-HIPROC
 
 # LLVM-HIPROC: ElfHeader {
-# LLVM-HIPROC:   Type: 0xFFFF
+# LLVM-HIPROC:   Type: Processor Specific (0xFFFF)
 
 # GNU-HIPROC: ELF Header:
 # GNU-HIPROC:   Type: Processor Specific: (ffff)

llvm/tools/llvm-readobj/ELFDumper.cpp

static std::string getSectionHeaderTableIndexString(const ELFFile<ELFT> &Obj,
   }
 
   if (ArrOrErr->empty())
     return "65535 (corrupt: out of range)";
   return to_string(ElfHeader.e_shstrndx) + " (" +
          to_string((*ArrOrErr)[0].sh_link) + ")";
 }
 
+const EnumEntry<unsigned> *getObjectFileEnumEntry(unsigned Type) {
+  auto It = llvm::find_if(ElfObjectFileType, [&](const EnumEntry<unsigned> &E) {
+    return E.Value == Type;
+  });
+  if (It != makeArrayRef(ElfObjectFileType).end())
+    return It;
+  return nullptr;
+}
+
 template <class ELFT> void GNUStyle<ELFT>::printFileHeaders() {
   const Elf_Ehdr &e = this->Obj.getHeader();
   OS << "ELF Header:\n";
   OS << "  Magic:  ";
   std::string Str;
   for (int i = 0; i < ELF::EI_NIDENT; i++)
     OS << format(" %02x", static_cast<int>(e.e_ident[i]));
   OS << "\n";
   Str = printEnum(e.e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
   printFields(OS, "Class:", Str);
   Str = printEnum(e.e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding));
   printFields(OS, "Data:", Str);
   OS.PadToColumn(2u);
   OS << "Version:";
   OS.PadToColumn(37u);
   OS << to_hexString(e.e_ident[ELF::EI_VERSION]);
   if (e.e_version == ELF::EV_CURRENT)
     OS << " (current)";
   OS << "\n";
   Str = printEnum(e.e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI));
   printFields(OS, "OS/ABI:", Str);
   printFields(OS,
               "ABI Version:", std::to_string(e.e_ident[ELF::EI_ABIVERSION]));
 
-  Str = printEnum(e.e_type, makeArrayRef(ElfObjectFileType));
-  if (makeArrayRef(ElfObjectFileType).end() ==
-      llvm::find_if(ElfObjectFileType, [&](const EnumEntry<unsigned> &E) {
-        return E.Value == e.e_type;
-      })) {
+  if (const EnumEntry<unsigned> *E = getObjectFileEnumEntry(e.e_type)) {
+    Str = E->AltName.str();
+  } else {
     if (e.e_type >= ET_LOPROC)
-      Str = "Processor Specific: (" + Str + ")";
+      Str = "Processor Specific: (" + to_hexString(e.e_type, false) + ")";
     else if (e.e_type >= ET_LOOS)
-      Str = "OS Specific: (" + Str + ")";
+      Str = "OS Specific: (" + to_hexString(e.e_type, false) + ")";
     else
-      Str = "<unknown>: " + Str;
+      Str = "<unknown>: " + to_hexString(e.e_type, false);
   }
   printFields(OS, "Type:", Str);
 
   Str = printEnum(e.e_machine, makeArrayRef(ElfMachineType));
   printFields(OS, "Machine:", Str);
   Str = "0x" + to_hexString(e.e_version);
   printFields(OS, "Version:", Str);
   Str = "0x" + to_hexString(e.e_entry);
DictScope D(W, "ElfHeader");
           break;
         }
       }
       W.printEnum("OS/ABI", E.e_ident[ELF::EI_OSABI], OSABI);
       W.printNumber("ABIVersion", E.e_ident[ELF::EI_ABIVERSION]);
       W.printBinary("Unused", makeArrayRef(E.e_ident).slice(ELF::EI_PAD));
     }
 
-    W.printEnum("Type", E.e_type, makeArrayRef(ElfObjectFileType));
+    std::string TypeStr = "0x";
+    if (const EnumEntry<unsigned> *Ent = getObjectFileEnumEntry(E.e_type)) {
+      TypeStr = Ent->Name.str();
+    } else {
+      if (E.e_type >= ET_LOPROC)
+        TypeStr = "Processor Specific";
+      else if (E.e_type >= ET_LOOS)
+        TypeStr = "OS Specific";
+      else
+        TypeStr = "Unknown";
+    }
+    W.printString("Type", TypeStr + " (0x" + to_hexString(E.e_type) + ")");
+
     W.printEnum("Machine", E.e_machine, makeArrayRef(ElfMachineType));
     W.printNumber("Version", E.e_version);
     W.printHex("Entry", E.e_entry);
     W.printHex("ProgramHeaderOffset", E.e_phoff);
     W.printHex("SectionHeaderOffset", E.e_shoff);
     if (E.e_machine == EM_MIPS)
       W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderMipsFlags),
                    unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),