[llvm-readelf] - Change letters used for SHF_ARM_PURECODE and SHF_X86_64_LARGE flags.

[grimar]

Summary

GNU uses l for SHF_X86_64_LARGE and y for SHF_ARM_PURECODE.
Lets follow.

To do this I had to refactor and refine how we print the help flags description.
It was too generic and inconsistent with GNU readelf.

Depends on https://reviews.llvm.org/D71462

[grimar]

I've found that we also seems need to update "Key to Flags:" printed

For example. when SHF_ARM_PURECODE is used, GNU readelf prints:

Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  y (purecode), p (processor specific)

When SHF_X86_64_LARGE is used, it prints:

Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  l (large), p (processor specific)

I am doing to update the patch with this change.

[MaskRay]

llvm/tools/llvm-readobj/ELFDumper.cpp

1504

Str += 'l'

1508

SHF_ARM_PURECODE

[grimar]

• Addressed comments.
• Fixed the flags description printed.

llvm/tools/llvm-readobj/ELFDumper.cpp

1508

I've removed these lines. They are not needed actually because of Flags &= ~Flag.

[jhenderson]

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

2

section and flag descriptions

5

I'd probably delete the phrase "help text" here as it could be confused with the output of --help, and is unnecessary ("key" already implies its a descriptive piece of help text).

I'd also rephrase slightly:
"to show how the default flag key is printed."

7

--check-prefix here and below.

61

a EM_X86_64 -> an EM_X86_64
for the SHF_X86_64_LARGE

62

Check we mention it in the flag key.

127

a EM_ARM -> an EM_ARM
for the SHF_ARM_PURECODE

128

Same comment as above.

llvm/test/tools/llvm-readobj/ELF/section-arch-flags.test

101

Why does it look strange? (Also "Despite the fact...")

[grimar]

llvm/test/tools/llvm-readobj/ELF/section-arch-flags.test

101

Because we print o, p and x last, so one might think that the order is UPPER CASE letters and lower case after them.
But lE violates this.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/section-arch-flags.test

101

Okay, I'd change this statement to simply say something like:

"GNU prints 'l' before 'E', despite otherwise printing upper-case letters first".

[grimar]

• Addressed review comments.

[jhenderson]

LGTM, except for one comment.

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

1

If this should be interpreted as "section descriptions and flag descriptions", then sections -> section.

llvm/test/MC/ARM/elf-execute-only-section.ll

 ; RUN: llc < %s -mtriple=thumbv8m.base-eabi -mattr=+execute-only -filetype=obj %s -o - | \
 ; RUN: llvm-readelf -S | FileCheck %s
 ; RUN: llc < %s -mtriple=thumbv8m.main-eabi -mattr=+execute-only -filetype=obj %s -o - | \
 ; RUN: llvm-readelf -S | FileCheck %s
 ; RUN: llc < %s -mtriple=thumbv7m-eabi -mattr=+execute-only -filetype=obj %s -o - | \
 ; RUN: llvm-readelf -S | FileCheck %s
 
-; CHECK-NOT: {{.text[ ]+PROGBITS[ ]+[0-9]+ [0-9]+ [0-9]+ [0-9]+ AX[^p]}}
-; CHECK: {{.text[ ]+PROGBITS[ ]+[0-9]+ [0-9]+ [0-9]+ [0-9]+ AXp}}
+; CHECK-NOT: {{.text[ ]+PROGBITS[ ]+[0-9]+ [0-9]+ [0-9]+ [0-9]+ AX[^y]}}
+; CHECK: {{.text[ ]+PROGBITS[ ]+[0-9]+ [0-9]+ [0-9]+ [0-9]+ AXy}}
 define void @test_func() {
 entry:
   ret void
 }

llvm/test/tools/llvm-readobj/ELF/check-output-order.test

 ## This test checks that `--all --needed-libs` output is the same as the
 ## printing order in code. One common reason the output could become
 ## out-of-order is when more than one stream are printing at the same time.
 ## https://bugs.llvm.org/show_bug.cgi?id=42140
 
 # RUN: yaml2obj %s -o %t
 # RUN: llvm-readelf --all --needed-libs %t | FileCheck %s
 
 # CHECK: ELF Header
 # CHECK:   Section header string table index
 # CHECK: There are 5 section headers, starting at offset
 # CHECK: Section Headers:
-# CHECK:   O (extra OS processing required) o (OS specific), p (processor specific)
+# CHECK: Key to Flags:
 # CHECK: There are no relocations in this file.
 # CHECK: Symbol table '.symtab' contains 1 entries
 # CHECK:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
 # CHECK: Dynamic section at offset
 # CHECK:   0x0000000000000000 (NULL)               0x0
 # CHECK: NeededLibraries [
 # CHECK: ]
 # CHECK: Elf file type is DYN (Shared object file)

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

+## In this test case we check how we print sections and flag descriptions for different targets.
+
+## EM_386 is a target that does not have any processor and OS specific flags,
+## we use it to show how the default flag key is printed.
+
 # RUN: yaml2obj --docnum=1 %s -o %t-i386.o
-# RUN: llvm-readelf -S %t-i386.o | FileCheck %s -check-prefix ELF32
+# RUN: llvm-readelf -S %t-i386.o | FileCheck %s --check-prefix=ELF32 --strict-whitespace --match-full-lines
 
-# ELF32:      There are 8 section headers, starting at offset 0x90:
+#       ELF32:There are 8 section headers, starting at offset 0x90:
 # ELF32-EMPTY:
-# ELF32-NEXT: Section Headers:
-# ELF32-NEXT:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
-# ELF32-NEXT:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
-# ELF32-NEXT:   [ 1] .text             PROGBITS        00000000 000034 000001 00  AX  0   0  4
-# ELF32-NEXT:   [ 2] .rel.text         REL             00000000 000038 000000 08      5   1  4
-# ELF32-NEXT:   [ 3] .data             PROGBITS        00000000 000038 000000 00  WA  0   0  4
-# ELF32-NEXT:   [ 4] .bss              NOBITS          00000000 000038 000000 00  WA  0   0  4
-# ELF32-NEXT:   [ 5] .symtab           SYMTAB          00000000 000038 000020 10      6   2  8
-# ELF32-NEXT:   [ 6] .strtab           STRTAB          00000000 000058 000007 00      0   0  1
-# ELF32-NEXT:   [ 7] .shstrtab         STRTAB          00000000 00005f 000030 00      0   0  1
-# ELF32-NEXT: Key to Flags:
-# ELF32-NEXT:   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)
-# ELF32-NEXT:   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
-# ELF32-NEXT:   O (extra OS processing required) o (OS specific), p (processor specific)
+# ELF32-NEXT:Section Headers:
+# ELF32-NEXT:  [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# ELF32-NEXT:  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# ELF32-NEXT:  [ 1] .text             PROGBITS        00000000 000034 000001 00  AX  0   0  4
+# ELF32-NEXT:  [ 2] .rel.text         REL             00000000 000038 000000 08      5   1  4
+# ELF32-NEXT:  [ 3] .data             PROGBITS        00000000 000038 000000 00  WA  0   0  4
+# ELF32-NEXT:  [ 4] .bss              NOBITS          00000000 000038 000000 00  WA  0   0  4
+# ELF32-NEXT:  [ 5] .symtab           SYMTAB          00000000 000038 000020 10      6   2  8
+# ELF32-NEXT:  [ 6] .strtab           STRTAB          00000000 000058 000007 00      0   0  1
+# ELF32-NEXT:  [ 7] .shstrtab         STRTAB          00000000 00005f 000030 00      0   0  1
+# ELF32-NEXT:Key to Flags:
+# ELF32-NEXT:  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
+# ELF32-NEXT:  L (link order), O (extra OS processing required), G (group), T (TLS),
+# ELF32-NEXT:  C (compressed), x (unknown), o (OS specific), E (exclude),
+# ELF32-NEXT:  p (processor specific)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   OSABI:   ELFOSABI_GNU
   Type:    ET_REL
   Machine: EM_386
- Name:         .bss
     Type:         SHT_NOBITS
     Flags:        [ SHF_WRITE, SHF_ALLOC ]
     AddressAlign: 0x0000000000000004
 Symbols:
   - Name:         .text
     Type:         STT_SECTION
     Section:      .text
 
+## For an EM_X86_64 target we print "l" for the SHF_X86_64_LARGE section flag.
+## Check we mention it in the flag key.
+
 # RUN: yaml2obj --docnum=2 %s -o %t-x64.o
-# RUN: llvm-readelf -S %t-x64.o | FileCheck %s -check-prefix ELF64
+# RUN: llvm-readelf -S %t-x64.o | FileCheck %s --check-prefix=ELF64 --strict-whitespace --match-full-lines
 
 ## Check that --wide is the same as -W and ignored and also
 ## that --section is the same as -S.
 # RUN: llvm-readobj --wide --sections %t-x64.o --elf-output-style=GNU \
-# RUN:   | FileCheck %s -check-prefix ELF64
+# RUN:   | FileCheck %s --check-prefix=ELF64
 # RUN: llvm-readobj -W --sections %t-x64.o --elf-output-style=GNU \
-# RUN:   | FileCheck %s -check-prefix ELF64
-# RUN: llvm-readelf -W -S %t-x64.o | FileCheck %s -check-prefix ELF64
+# RUN:   | FileCheck %s --check-prefix=ELF64
+# RUN: llvm-readelf -W -S %t-x64.o | FileCheck %s --check-prefix=ELF64
 
-# ELF64:      There are 8 section headers, starting at offset 0xb0:
-# ELF64-EMPTY: 
-# ELF64-NEXT: Section Headers:
-# ELF64-NEXT:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
-# ELF64-NEXT:   [ 0]                   NULL            0000000000000000 000000 000000 00  0  0  0
-# ELF64-NEXT:   [ 1] .text             PROGBITS        0000000000000000 000040 000001 00  AX 0   0  4
-# ELF64-NEXT:   [ 2] .rela.text        RELA            0000000000000000 000048 000000 18  5  1  8
-# ELF64-NEXT:   [ 3] .data             PROGBITS        0000000000000000 000048 000000 00  WA 0   0  4
-# ELF64-NEXT:   [ 4] .bss              NOBITS          0000000000000000 000048 000000 00  WA 0   0  4
-# ELF64-NEXT:   [ 5] .symtab           SYMTAB          0000000000000000 000048 000030 18  6  2  8
-# ELF64-NEXT:   [ 6] .strtab           STRTAB          0000000000000000 000078 000007 00  0  0  1
-# ELF64-NEXT:   [ 7] .shstrtab         STRTAB          0000000000000000 00007f 000031 00  0  0  1
-# ELF64-NEXT: Key to Flags:
-# ELF64-NEXT:   W (write), A (alloc), X (execute), M (merge), S (strings), l (large)
-# ELF64-NEXT:   I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)
-# ELF64-NEXT:   O (extra OS processing required) o (OS specific), p (processor specific)
+#       ELF64:There are 8 section headers, starting at offset 0xb0:
+# ELF64-EMPTY:
+# ELF64-NEXT:Section Headers:
+# ELF64-NEXT:  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# ELF64-NEXT:  [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+# ELF64-NEXT:  [ 1] .text             PROGBITS        0000000000000000 000040 000001 00  AX  0   0  4
+# ELF64-NEXT:  [ 2] .rela.text        RELA            0000000000000000 000048 000000 18      5   1  8
+# ELF64-NEXT:  [ 3] .data             PROGBITS        0000000000000000 000048 000000 00  WA  0   0  4
+# ELF64-NEXT:  [ 4] .bss              NOBITS          0000000000000000 000048 000000 00  WA  0   0  4
+# ELF64-NEXT:  [ 5] .symtab           SYMTAB          0000000000000000 000048 000030 18      6   2  8
+# ELF64-NEXT:  [ 6] .strtab           STRTAB          0000000000000000 000078 000007 00      0   0  1
+# ELF64-NEXT:  [ 7] .shstrtab         STRTAB          0000000000000000 00007f 000031 00      0   0  1
+# ELF64-NEXT:Key to Flags:
+# ELF64-NEXT:  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
+# ELF64-NEXT:  L (link order), O (extra OS processing required), G (group), T (TLS),
+# ELF64-NEXT:  C (compressed), x (unknown), o (OS specific), E (exclude),
+# ELF64-NEXT:  l (large), p (processor specific)
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   OSABI:   ELFOSABI_GNU
   Type:    ET_REL
   Machine: EM_X86_64
Sections:
   - Name:         .bss
     Type:         SHT_NOBITS
     Flags:        [ SHF_WRITE, SHF_ALLOC ]
     AddressAlign: 0x0000000000000004
 Symbols:
   - Name:    .text
     Type:    STT_SECTION
     Section: .text
+
+## For an EM_ARM target we print "y" for the SHF_ARM_PURECODE section flag.
+## Check we mention it in the flag key.
+
+# RUN: yaml2obj --docnum=3 %s -o %t-arm.o
+# RUN: llvm-readelf -S %t-arm.o | FileCheck %s --check-prefix=ARM --strict-whitespace --match-full-lines
+
+#      ARM:Key to Flags:
+# ARM-NEXT:  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
+# ARM-NEXT:  L (link order), O (extra OS processing required), G (group), T (TLS),
+# ARM-NEXT:  C (compressed), x (unknown), o (OS specific), E (exclude),
+# ARM-NEXT:  y (purecode), p (processor specific)
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_ARM
+Sections: []

llvm/test/tools/llvm-readobj/ELF/section-arch-flags.test

Sections:
   - Name:  .mips
     Type:  SHT_PROGBITS
     Flags: [ SHF_MIPS_STRING ]
 
 # RUN: yaml2obj --docnum 4 %s -o %t-x86_64.o
 # RUN: llvm-readobj -S %t-x86_64.o | FileCheck --check-prefix=X86_64-LLVM %s
 # RUN: llvm-readelf -S %t-x86_64.o | FileCheck --check-prefix=X86_64-GNU %s
 
-# X86_64-LLVM:      Flags [ (0x10000000)
+# X86_64-LLVM:      Name: .x86_64
+# X86_64-LLVM-NEXT: Type: SHT_PROGBITS
+# X86_64-LLVM-NEXT: Flags [ (0x10000000)
 # X86_64-LLVM-NEXT:   SHF_X86_64_LARGE (0x10000000)
 # X86_64-LLVM-NEXT: ]
 
-# X86_64-GNU: [Nr] Name    Type     Address          Off    Size   ES Flg Lk Inf Al
-# X86_64-GNU: [ 1] .x86_64 PROGBITS 0000000000000000 000040 000000 00   p 0   0  0
+# X86_64-LLVM:      Name: .with.exclude
+# X86_64-LLVM-NEXT: Type: SHT_PROGBITS
+# X86_64-LLVM-NEXT: Flags [ (0x90000000)
+# X86_64-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
+# X86_64-LLVM-NEXT:   SHF_X86_64_LARGE (0x10000000)
+# X86_64-LLVM-NEXT: ]
+
+## GNU prints 'l' before 'E', despite otherwise printing upper-case letters first.
+# X86_64-GNU: [Nr] Name          Type     Address          Off    Size   ES Flg Lk Inf Al
+# X86_64-GNU: [ 1] .x86_64       PROGBITS 0000000000000000 000040 000000 00   l 0   0  0
+# X86_64-GNU: [ 2] .with.exclude PROGBITS 0000000000000000 000040 000000 00  lE 0   0  0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name:  .x86_64
     Type:  SHT_PROGBITS
     Flags: [ SHF_X86_64_LARGE ]
+  - Name:  .with.exclude
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_X86_64_LARGE, SHF_EXCLUDE ]
 
 # RUN: yaml2obj --docnum 5 %s -o %t-arm.o
 # RUN: llvm-readobj -S %t-arm.o | FileCheck --check-prefix=ARM-LLVM %s
 # RUN: llvm-readelf -S %t-arm.o | FileCheck --check-prefix=ARM-GNU %s
 
 # ARM-LLVM:      Flags [ (0x20000000)
 # ARM-LLVM-NEXT:   SHF_ARM_PURECODE (0x20000000)
 # ARM-LLVM-NEXT: ]
 
 # ARM-GNU: [Nr] Name Type     Address          Off    Size   ES Flg Lk Inf Al
-# ARM-GNU: [ 1] foo  PROGBITS 0000000000000000 000040 000000 00   p 0   0  0
+# ARM-GNU: [ 1] foo  PROGBITS 0000000000000000 000040 000000 00   y 0   0  0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_ARM
 Sections:
   - Name:  foo
     Type:  SHT_PROGBITS
     Flags: [ SHF_ARM_PURECODE ]

llvm/tools/llvm-readobj/ELFDumper.cpp

static const EnumEntry<unsigned> ElfMipsSectionFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_ADDR   ),
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_STRING )
 };
 
 static const EnumEntry<unsigned> ElfX86_64SectionFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_X86_64_LARGE)
 };
 
-static std::string getGNUFlags(uint64_t Flags) {
+static std::string getGNUFlags(unsigned EMachine, uint64_t Flags) {
   // Here we are trying to build the flags string in the same way as GNU does.
   // It is not that straightforward. Imagine we have sh_flags == 0x90000000.
   // SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000.
   // GNU readelf will not print "E" or "Ep" in this case, but will print just
   // "p". It only will print "E" when no other processor flag is set.
   std::string Str;
   bool HasUnknownFlag = false;
   bool HasOSFlag = false;
while (Flags) {
     });
     if (I != std::end(ElfSectionFlags)) {
       Str += I->AltName;
       continue;
     }
 
     // If we did not find a matching regular flag, then we deal with an OS
     // specific flag, processor specific flag or an unknown flag.
-    if (Flag & ELF::SHF_MASKOS) {
+    if (EMachine == EM_X86_64 && Flag == SHF_X86_64_LARGE) {
+      Str += 'l';
+    } else if (EMachine == EM_ARM && Flag == SHF_ARM_PURECODE) {
+      Str += 'y';
+    } else if (Flag & ELF::SHF_MASKOS) {
       HasOSFlag = true;
       Flags &= ~ELF::SHF_MASKOS;
     } else if (Flag & ELF::SHF_MASKPROC) {
       HasProcFlag = true;
       // Mask off all the processor-specific bits. This removes the SHF_EXCLUDE
       // bit if set so that it doesn't also get printed.
       Flags &= ~ELF::SHF_MASKPROC;
     } else {
       HasUnknownFlag = true;
static std::string getSectionTypeString(unsigned Arch, unsigned Type) {
   case SHT_GNU_versym:
     return "VERSYM";
   default:
     return getSectionTypeOffsetString(Type);
   }
   return "";
 }
 
+static void printSectionDescription(formatted_raw_ostream &OS,
+                                    unsigned EMachine) {
+  OS << "Key to Flags:\n";
+  OS << "  W (write), A (alloc), X (execute), M (merge), S (strings), I "
+        "(info),\n";
+  OS << "  L (link order), O (extra OS processing required), G (group), T "
+        "(TLS),\n";
+  OS << "  C (compressed), x (unknown), o (OS specific), E (exclude),\n";
+
+  if (EMachine == EM_X86_64)
+    OS << "  l (large), ";
+  else if (EMachine == EM_ARM)
+    OS << "  y (purecode), ";
+  else
+    OS << "  ";
+
+  OS << "p (processor specific)\n";
+}
+
 template <class ELFT>
 void GNUStyle<ELFT>::printSectionHeaders(const ELFO *Obj) {
   unsigned Bias = ELFT::Is64Bits ? 0 : 8;
   ArrayRef<Elf_Shdr> Sections = unwrapOrError(this->FileName, Obj->sections());
   OS << "There are " << to_string(Sections.size())
      << " section headers, starting at offset "
      << "0x" << to_hexString(Obj->getHeader()->e_shoff, false) << ":\n\n";
   OS << "Section Headers:\n";
Fields[1].Str = unwrapOrError<StringRef>(
         ElfObj->getFileName(), Obj->getSectionName(&Sec, this->WarningHandler));
     Fields[2].Str =
         getSectionTypeString(Obj->getHeader()->e_machine, Sec.sh_type);
     Fields[3].Str =
         to_string(format_hex_no_prefix(Sec.sh_addr, ELFT::Is64Bits ? 16 : 8));
     Fields[4].Str = to_string(format_hex_no_prefix(Sec.sh_offset, 6));
     Fields[5].Str = to_string(format_hex_no_prefix(Sec.sh_size, 6));
     Fields[6].Str = to_string(format_hex_no_prefix(Sec.sh_entsize, 2));
-    Fields[7].Str = getGNUFlags(Sec.sh_flags);
+    Fields[7].Str = getGNUFlags(Obj->getHeader()->e_machine, Sec.sh_flags);
     Fields[8].Str = to_string(Sec.sh_link);
     Fields[9].Str = to_string(Sec.sh_info);
     Fields[10].Str = to_string(Sec.sh_addralign);
 
     OS.PadToColumn(Fields[0].Column);
     OS << "[" << right_justify(Fields[0].Str, 2) << "]";
     for (int i = 1; i < 7; i++)
       printField(Fields[i]);
     OS.PadToColumn(Fields[7].Column);
     OS << right_justify(Fields[7].Str, 3);
     OS.PadToColumn(Fields[8].Column);
     OS << right_justify(Fields[8].Str, 2);
     OS.PadToColumn(Fields[9].Column);
     OS << right_justify(Fields[9].Str, 3);
     OS.PadToColumn(Fields[10].Column);
     OS << right_justify(Fields[10].Str, 2);
     OS << "\n";
     ++SectionIndex;
   }
-  OS << "Key to Flags:\n"
-     << "  W (write), A (alloc), X (execute), M (merge), S (strings), l "
-        "(large)\n"
-     << "  I (info), L (link order), G (group), T (TLS), E (exclude),\
- x (unknown)\n"
-     << "  O (extra OS processing required) o (OS specific),\
- p (processor specific)\n";
+  printSectionDescription(OS, Obj->getHeader()->e_machine);
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printSymtabMessage(const ELFO *Obj, StringRef Name,
                                         size_t Entries,
                                         bool NonVisibilityBitsUsed) {
   if (!Name.empty())
     OS << "\nSymbol table '" << Name << "' contains " << Entries