[llvm-readobj] Fix bugs with unrecognized types in switch statements

[rprichard]

Summary

Add missing breaks. Several functions used nested switch statements,
where the outer switch branches based on the architecture, and the inner
switch handles architecture-specific types. If the type isn't
architecture-specific, break out to the generic types rather than fall
through.

getElfPtType: For GNU-style output, llvm-readobj prints
"<unknown>: 0xnnnnnnnn" for an unrecognized segment type, unless the
architecture is EM_ARM, EM_MIPS, or EM_MIPS_RS3_LE, in which case it
prints "". This behavior appears accidental, so instead, always print
the "<unknown>: 0xnnnnnnnn" string.

[rprichard]

I didn't see a good way to write a regression test. I tested it by hand with this script:

#!/bin/sh
touch empty.s

#TOOLCHAIN=/x/clang7/bin
TOOLCHAIN=/x/llvm-upstream/stage1/bin

# ARM binary test (test getElfSegmentType and getElfPtType)
echo ==== ARM test
$TOOLCHAIN/clang -target arm -c empty.s 2>/dev/null
$TOOLCHAIN/ld.lld -pie empty.o -o arm.out 2>/dev/null
# Change PT_GNU_RELRO(0x6474e552) to 0x70000002.
sed -i -e 's/\x52\xe5\x74\x64/\x02\x00\x00\x70/g' arm.out
$TOOLCHAIN/llvm-readobj -l arm.out | grep 0x70000002
$TOOLCHAIN/llvm-readelf -l arm.out | grep '0x00040 0x01000'

# x86_64 binary test (test getSectionTypeString)
echo ==== x86_64 test
$TOOLCHAIN/clang -target x86_64 -c empty.s 2>/dev/null
$TOOLCHAIN/ld.lld -pie empty.o -o x86_64.out 2>/dev/null
# Change SHT_GNU_HASH(0x6ffffff6) to 0x70000006.
sed -i -e 's/\xf6\xff\xff\x6f/\x06\x00\x00\x70/g' x86_64.out
$TOOLCHAIN/llvm-readelf -S x86_64.out | grep gnu.hash

# MIPS binary test (test getTypeString for dynamic entries)
echo ==== mipsel test
$TOOLCHAIN/clang -target mipsel -c empty.s 2>/dev/null
$TOOLCHAIN/ld.lld -pie empty.o -o mips.out 2>/dev/null
# Change DT_MIPS_RLD_VERSION(0x70000001) to 0x70000000.
sed -i -e 's/\x01\x00\x00\x70/\x00\x00\x00\x70/g' mips.out
$TOOLCHAIN/llvm-readobj -d mips.out | grep 0x70000000

Clang 7.0.0 output (bad):

==== ARM test
    Type: PT_MIPS_OPTIONS (0x70000002)
                 0x001000 0x00001000 0x00001000 0x00040 0x01000 R   0x1
==== x86_64 test
  [ 2] .gnu.hash         MIPS_REGINFO    00000000000001e0 0001e0 00001c 00   A  1   0  8
==== mipsel test
  0x70000000 PPC64_GLINK          0x1

New output:

==== ARM test
    Type:  (0x70000002)
  <unknown>: 0x70000002 0x001000 0x00001000 0x00001000 0x00040 0x01000 R   0x1
==== x86_64 test
  [ 2] .gnu.hash                         00000000000001e0 0001e0 00001c 00   A  1   0  8
==== mipsel test
  0x70000000 unknown              0x1

[grimar]

I think it is possible just to add a precompiled binary(ies) to tools\llvm-readobj\Inputs and write the corresponding test(s).
But honestly I am not in favor of using precompiled binaries and in this case, perhaps it is fine to skip the test,
the issue seems to be obvious, so LGTM.

llvm/trunk/tools/llvm-readobj/ELFDumper.cpp

 static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
   // Check potentially overlapped processor-specific
   // program header type.
   switch (Arch) {
   case ELF::EM_ARM:
     switch (Type) {
     LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
     }
+    break;
   case ELF::EM_MIPS:
   case ELF::EM_MIPS_RS3_LE:
     switch (Type) {
     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);
     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC);
     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS);
     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS);
     }
+    break;
   }
 
   switch (Type) {
   LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL   );
   LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD   );
   LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC);
   LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP );
   LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE   );
switch (Type) {
     LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_STACK)
     LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_RELRO)
   default:
     // All machine specific PT_* types
     switch (Arch) {
     case ELF::EM_ARM:
       if (Type == ELF::PT_ARM_EXIDX)
         return "EXIDX";
-      return "";
+      break;
     case ELF::EM_MIPS:
     case ELF::EM_MIPS_RS3_LE:
       switch (Type) {
       case PT_MIPS_REGINFO:
         return "REGINFO";
       case PT_MIPS_RTPROC:
         return "RTPROC";
       case PT_MIPS_OPTIONS:
         return "OPTIONS";
       case PT_MIPS_ABIFLAGS:
         return "ABIFLAGS";
       }
-      return "";
+      break;
     }
   }
   return std::string("<unknown>: ") + to_string(format_hex(Type, 1));
 }
 
 static const EnumEntry<unsigned> ElfSegmentFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
   LLVM_READOBJ_ENUM_ENT(ELF, PF_W),

 }
 
 static const char *getTypeString(unsigned Arch, uint64_t Type) {
 #define DYNAMIC_TAG(n, v)
   switch (Arch) {
   case EM_HEXAGON:
     switch (Type) {
 #define HEXAGON_DYNAMIC_TAG(name, value)                                       \
-  case DT_##name:                                                              \
+    case DT_##name:                                                            \
       return #name;
 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef HEXAGON_DYNAMIC_TAG
     }
+    break;
 
   case EM_MIPS:
     switch (Type) {
 #define MIPS_DYNAMIC_TAG(name, value)                                          \
-  case DT_##name:                                                              \
+    case DT_##name:                                                            \
       return #name;
 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef MIPS_DYNAMIC_TAG
     }
+    break;
 
-    case EM_PPC64:
-      switch(Type) {
 #define PPC64_DYNAMIC_TAG(name, value)                                         \
     case DT_##name:                                                            \
       return #name;
 #include "llvm/BinaryFormat/DynamicTags.def"
 #undef PPC64_DYNAMIC_TAG
     }
+    break;
   }
 #undef DYNAMIC_TAG
   switch (Type) {
 // Now handle all dynamic tags except the architecture specific ones
 #define MIPS_DYNAMIC_TAG(name, value)
 #define HEXAGON_DYNAMIC_TAG(name, value)
 #define PPC64_DYNAMIC_TAG(name, value)
 // Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
case SHT_ARM_PREEMPTMAP:
       return "ARM_PREEMPTMAP";
     case SHT_ARM_ATTRIBUTES:
       return "ARM_ATTRIBUTES";
     case SHT_ARM_DEBUGOVERLAY:
       return "ARM_DEBUGOVERLAY";
     case SHT_ARM_OVERLAYSECTION:
       return "ARM_OVERLAYSECTION";
     }
+    break;
   case EM_X86_64:
     switch (Type) {
     case SHT_X86_64_UNWIND:
       return "X86_64_UNWIND";
     }
+    break;
   case EM_MIPS:
   case EM_MIPS_RS3_LE:
     switch (Type) {
     case SHT_MIPS_REGINFO:
       return "MIPS_REGINFO";
     case SHT_MIPS_OPTIONS:
       return "MIPS_OPTIONS";
     case SHT_MIPS_ABIFLAGS:
       return "MIPS_ABIFLAGS";
     case SHT_MIPS_DWARF:
       return "SHT_MIPS_DWARF";
     }
+    break;
   }
   switch (Type) {
   case SHT_NULL:
     return "NULL";
   case SHT_PROGBITS:
     return "PROGBITS";
   case SHT_SYMTAB:
     return "SYMTAB";