[llvm-objdump] - Do not include reserved undefined symbol in -t output.

[grimar]

Summary

This is https://bugs.llvm.org/show_bug.cgi?id=26892,

GNU objdump hides the special symbol entry:

SYMBOL TABLE:
000000000000a7e0 l     F .text	00000000000003f9 bi_copymodules

while llvm-objdump does not:

SYMBOL TABLE:
0000000000000000         *UND*		 00000000 
000000000000a7e0 l     F .text		 000003f9 bi_copymodules

Patch makes the behavior of the llvm-objdump to be consistent with the GNU objdump.

[jhenderson]

LGTM, with a couple of nits.

tools/llvm-objdump/llvm-objdump.cpp

1977 ↗

(On Diff #179491)

dumping ELF -> dumping an ELF

1978 ↗

(On Diff #179491)

output to be -> the output

[grimar]

Thanks, James!

llvm/trunk/test/tools/llvm-objdump/X86/demangle.s

 # RUN: llvm-mc %s -filetype=obj -triple=x86_64-pc-linux -o %t
 # RUN: llvm-objdump -syms -reloc -demangle %t | FileCheck %s
 
 ## Check we demangle symbols when printing relocations.
 # CHECK:      000000000000001 R_X86_64_PLT32 foo()-4
 
 ## Check we demangle symbols when printing symbol table.
 # CHECK:      SYMBOL TABLE:
-# CHECK-NEXT: 0000000000000000         *UND*           00000000
 # CHECK-NEXT: 0000000000000000 g     F .text           00000000 foo()
 
 ## Check the case when relocations are inlined into disassembly.
 # RUN: llvm-objdump -d -r -demangle %t | FileCheck %s --check-prefix=INLINE
 # INLINE:      Disassembly of section .text:
 # INLINE-NEXT: foo():
 # INLINE-NEXT:  0: {{.*}}  callq   0 <_Z3foov+0x5>
 # INLINE-NEXT:  0000000000000001:  R_X86_64_PLT32 foo()-4
 
 .text
 .globl _Z3foov
 .type _Z3foov,@function
 _Z3foov:
  callq _Z3foov@PLT

llvm/trunk/test/tools/llvm-objdump/X86/out-of-section-sym.test

 // Check that llvm-objdump does not attempt to disassemble symbols outside
 // of section boundaries.
 // RUN: llvm-objdump -d -t %p/Inputs/out-of-section-sym.elf-i386 | FileCheck %s
 
 CHECK: Disassembly of section .text:
 CHECK-NEXT: _start:
 CHECK-NEXT:   10:  c3  retl
 CHECK-NEXT: SYMBOL TABLE:
-CHECK-NEXT: 00000000         *UND*  00000000
 CHECK-NEXT: 00000010 l    d  .text  00000000 .text
 CHECK-NEXT: 00000010         .text  00000000 _start
 CHECK-NEXT: 00000020         .text  00000000 _fdata
 CHECK-NEXT: 00000010         .text  00000000 _ftext

llvm/trunk/test/tools/llvm-objdump/symbol-table-elf.test

 # RUN: yaml2obj %s > %t
 # RUN: llvm-objdump --syms %t > %t1
 # RUN: llvm-objdump -t     %t > %t2
 # RUN: cmp %t1 %t2
 # RUN: FileCheck %s --input-file=%t1
 
 # CHECK:      SYMBOL TABLE:
-# CHECK-NEXT: 0000000000000000         *UND*     00000000
 # CHECK-NEXT: 0000000000001004 l     F .text     00000000 lfoo
 # CHECK-NEXT: 0000000000001008 l     O .text     00000000 lbar
 # CHECK-NEXT: 0000000000001004 g     F .text     00000000 foo
 # CHECK-NEXT: 0000000000001008 g     O .text     00000000 bar
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

 void llvm::PrintSymbolTable(const ObjectFile *o, StringRef ArchiveName,
                             StringRef ArchitectureName) {
   outs() << "SYMBOL TABLE:\n";
 
   if (const COFFObjectFile *coff = dyn_cast<const COFFObjectFile>(o)) {
     printCOFFSymbolTable(coff);
     return;
   }
-  for (const SymbolRef &Symbol : o->symbols()) {
+
+  for (auto I = o->symbol_begin(), E = o->symbol_end(); I != E; ++I) {
+    // Skip printing the special zero symbol when dumping an ELF file.
+    // This makes the output consistent with the GNU objdump.
+    if (I == o->symbol_begin() && isa<ELFObjectFileBase>(o))
+      continue;
+
+    const SymbolRef &Symbol = *I;
     Expected<uint64_t> AddressOrError = Symbol.getAddress();
     if (!AddressOrError)
       report_error(ArchiveName, o->getFileName(), AddressOrError.takeError(),
                    ArchitectureName);
     uint64_t Address = *AddressOrError;
     if ((Address < StartAddress) || (Address > StopAddress))
       continue;
     Expected<SymbolRef::Type> TypeOrError = Symbol.getType();