Add llvm::object::getELFSectionTypeName()

[arichardson]

Summary

This is motivated by https://reviews.llvm.org/D32488 where I am trying to
add printing of the section type for incompatible sections to LLD error
messages. This patch allows us to use the same code in llvm-readobj and
LLD instead of duplicating the function inside LLD.

[grimar]

lib/Object/ELF.cpp

153

I would use some macro here. Like in original code and
above in this file used for relocations:

#define ELF_RELOC(name, value)                              \
  case ELF::name:                                                       \
    return #name;                                                       \

It should do code shorter and be less errorprone.
May be worth to rename ELF_RELOC to something more generic and reuse,
or introduce new one. Not sure here.

[ruiu]

lib/Object/ELF.cpp

153

Yes, since this file already uses a macro, it is better to use a macro too for consistency in this case.

[ruiu]

lib/Object/ELF.cpp

240

It is probably more convenient to return 0x<hex> from this function for unknown types.

[arichardson]

Used a macro instead

[arichardson]

lib/Object/ELF.cpp

240

This would mean that llvm-readobj would output Type: 0x1234567 (0x1234567) as it always appends the hex value. Also we can't return a const char* then and would need to return std::string.

As the name of the function is getELFSectionTypeName() I think it is fine to return "" for unknown names because there is no known name for that section type.

[ruiu]

lib/Object/ELF.cpp

240

Then how about returning "Unknown"? That's what getELFRelocationTypeName defined above is doing, so it is good from the perspective of consistency too.

[arichardson]

return "Unknown" in the default case

[ruiu]

LGTM

lib/Object/ELF.cpp

18

Fix alignment.

[davide]

Fine with this.

[arichardson]

I don't have commit access, could you please commit for me?

include/llvm/Object/ELF.h

 #include <cstdint>
 #include <limits>
 #include <utility>
 
 namespace llvm {
 namespace object {
 
 StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type);
+StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type);
 
 // Subclasses of ELFFile may need this for template instantiation
 inline std::pair<unsigned char, unsigned char>
 getElfArchType(StringRef Object) {
   if (Object.size() < ELF::EI_NIDENT)
     return std::make_pair((uint8_t)ELF::ELFCLASSNONE,
                           (uint8_t)ELF::ELFDATANONE);
   return std::make_pair((uint8_t)Object[ELF::EI_CLASS],

lib/Object/ELF.cpp

 //===- ELF.cpp - ELF object file implementation ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/ELF.h"
 
 using namespace llvm;
 using namespace object;
 
-#define ELF_RELOC(name, value)                                          \
-  case ELF::name:                                                       \
+
+#define STRINGIFY_ENUM_CASE(ns, name)                                   \
+  case ns::name:                                                      \
     return #name;                                                       \
 
+#define ELF_RELOC(name, value) STRINGIFY_ENUM_CASE(ELF, name)
+
+
 StringRef llvm::object::getELFRelocationTypeName(uint32_t Machine,
                                                  uint32_t Type) {
   switch (Machine) {
   case ELF::EM_X86_64:
     switch (Type) {
 #include "llvm/Support/ELFRelocs/x86_64.def"
     default:
       break;
#include "llvm/Support/ELFRelocs/BPF.def"
     break;
   default:
     break;
   }
   return "Unknown";
 }
 
 #undef ELF_RELOC
+
+StringRef llvm::object::getELFSectionTypeName(uint32_t Machine, unsigned Type) {
+  switch (Machine) {
+  case ELF::EM_ARM:
+    switch (Type) {
+    STRINGIFY_ENUM_CASE(ELF, SHT_ARM_EXIDX);
+    STRINGIFY_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
+    STRINGIFY_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
+    STRINGIFY_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
+    STRINGIFY_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
+    }
+    break;
+  case ELF::EM_HEXAGON:
+    switch (Type) {
+    STRINGIFY_ENUM_CASE(ELF, SHT_HEX_ORDERED);
+    }
+    break;
+  case ELF::EM_X86_64:
+    switch (Type) {
+    STRINGIFY_ENUM_CASE(ELF, SHT_X86_64_UNWIND);
+    }
+    break;
+  case ELF::EM_MIPS:
+  case ELF::EM_MIPS_RS3_LE:
+    switch (Type) {
+    STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
+    STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
+    STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
+    STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_DWARF);
+    }
+    break;
+  default:
+    break;
+  }
+
+  switch (Type) {
+  STRINGIFY_ENUM_CASE(ELF, SHT_NULL);
+  STRINGIFY_ENUM_CASE(ELF, SHT_PROGBITS);
+  STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB);
+  STRINGIFY_ENUM_CASE(ELF, SHT_STRTAB);
+  STRINGIFY_ENUM_CASE(ELF, SHT_RELA);
+  STRINGIFY_ENUM_CASE(ELF, SHT_HASH);
+  STRINGIFY_ENUM_CASE(ELF, SHT_DYNAMIC);
+  STRINGIFY_ENUM_CASE(ELF, SHT_NOTE);
+  STRINGIFY_ENUM_CASE(ELF, SHT_NOBITS);
+  STRINGIFY_ENUM_CASE(ELF, SHT_REL);
+  STRINGIFY_ENUM_CASE(ELF, SHT_SHLIB);
+  STRINGIFY_ENUM_CASE(ELF, SHT_DYNSYM);
+  STRINGIFY_ENUM_CASE(ELF, SHT_INIT_ARRAY);
+  STRINGIFY_ENUM_CASE(ELF, SHT_FINI_ARRAY);
+  STRINGIFY_ENUM_CASE(ELF, SHT_PREINIT_ARRAY);
+  STRINGIFY_ENUM_CASE(ELF, SHT_GROUP);
+  STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX);
+  STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);
+  STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);
+  STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef);
+  STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed);
+  STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym);
+  default:
+    return "Unknown";
+  }
+}

tools/llvm-readobj/ELFDumper.cpp

static const EnumEntry<unsigned> ElfSymbolTypes[] = {
     {"GNU_IFunc", "IFUNC",   ELF::STT_GNU_IFUNC}};
 
 static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = {
   { "AMDGPU_HSA_KERNEL",            ELF::STT_AMDGPU_HSA_KERNEL },
   { "AMDGPU_HSA_INDIRECT_FUNCTION", ELF::STT_AMDGPU_HSA_INDIRECT_FUNCTION },
   { "AMDGPU_HSA_METADATA",          ELF::STT_AMDGPU_HSA_METADATA }
 };
 
-static const char *getElfSectionType(unsigned Arch, unsigned Type) {
-  switch (Arch) {
-  case ELF::EM_ARM:
-    switch (Type) {
-    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_EXIDX);
-    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
-    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
-    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
-    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
-    }
-  case ELF::EM_HEXAGON:
-    switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
-  case ELF::EM_X86_64:
-    switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
-  case ELF::EM_MIPS:
-  case ELF::EM_MIPS_RS3_LE:
-    switch (Type) {
-    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
-    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
-    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
-    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_DWARF);
-    }
-  }
-
-  switch (Type) {
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NULL              );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_PROGBITS          );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB            );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_STRTAB            );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_RELA              );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_HASH              );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNAMIC           );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOTE              );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOBITS            );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_REL               );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SHLIB             );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNSYM            );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_INIT_ARRAY        );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_FINI_ARRAY        );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_PREINIT_ARRAY     );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GROUP             );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX      );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES    );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH          );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef        );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed       );
-  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym        );
-  default: return "";
-  }
-}
-
 static const char *getGroupType(uint32_t Flag) {
   if (Flag & ELF::GRP_COMDAT)
     return "COMDAT";
   else
     return "(unknown)";
 }
 
 static const EnumEntry<unsigned> ElfSectionFlags[] = {
for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
     ++SectionIndex;
 
     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
 
     DictScope SectionD(W, "Section");
     W.printNumber("Index", SectionIndex);
     W.printNumber("Name", Name, Sec.sh_name);
     W.printHex("Type",
-               getElfSectionType(Obj->getHeader()->e_machine, Sec.sh_type),
+               object::getELFSectionTypeName(Obj->getHeader()->e_machine, Sec.sh_type),
                Sec.sh_type);
     std::vector<EnumEntry<unsigned>> SectionFlags(std::begin(ElfSectionFlags),
                                                   std::end(ElfSectionFlags));
     switch (Obj->getHeader()->e_machine) {
     case EM_AMDGPU:
       SectionFlags.insert(SectionFlags.end(), std::begin(ElfAMDGPUSectionFlags),
                           std::end(ElfAMDGPUSectionFlags));
       break;