llvm-objdump: Print symbol name if it's address is the same as the next one's

[kzhuravl]

Summary

Currently, if 2 symbols have the same address, the first symbol name is not
printed during disassembly, therefore missing it completely in the disassembled
text. This patch changes it to print first symbol's name in the case described.

[• espindola]

Given

foo:
bar:

nop

gnu objdump will print

0000000000000000 <bar>:

0:   90                      nop

With this patch we would print both foo and bar, correct? Why is this better? Should we report a bug on gnu objdump?

[t.p.northover]

Why is this better?

I know I've hit aliased functions in the past and had to run nm or something to find out where they are instead of just grepping the disassembly. So I'm definitely in favour.

[• espindola]

In D44544#1039975, @t.p.northover wrote:

Why is this better?

I know I've hit aliased functions in the past and had to run nm or something to find out where they are instead of just grepping the disassembly. So I'm definitely in favour.

As a compromise, LGTM if you first report a bug on GNU objdump so that we find out if they have any rationale for printing only one of the symbols.

test/CodeGen/Thumb/iabs.ll

 ; RUN: llc < %s -mtriple=thumb-unknown-unknown -filetype=obj -o %t.o
 ; RUN: llvm-objdump -disassemble -arch-name=thumb %t.o | FileCheck %s
 
 define i32 @test(i32 %a) {
         %tmp1neg = sub i32 0, %a
         %b = icmp sgt i32 %a, -1
         %abs = select i1 %b, i32 %a, i32 %tmp1neg
         ret i32 %abs
 
 ; This test just checks that 4 instructions were emitted
 
-; CHECK:      {{text}}
-; CHECK:      0:
+; CHECK:      test:
+; CHECK-NEXT: 0:
 ; CHECK-NEXT: 2:
 ; CHECK-NEXT: 4:
 ; CHECK-NEXT: 6:
 
 ; CHECK-NOT: 8:
 }
 

test/MC/AMDGPU/labels-with-same-address.s

+// RUN: llvm-mc -arch=amdgcn -mcpu=gfx803 -filetype=obj < %s | llvm-objdump -arch=amdgcn -mcpu=gfx803 --disassemble - | FileCheck %s
+
+
+// CHECK: s_branch BB0_1
+// CHECK: BB0_1:
+// CHECK: BB0_2:
+// CHECK: s_endpgm
+
+s_branch BB0_1
+
+BB0_1:
+BB0_2:
+s_endpgm

test/MC/ARM/elf-movt.s

 @ ASM:          movw    r0, :lower16:(GOT-(.LPC0_2+8))
 @ ASM-NEXT:     movt    r0, :upper16:(GOT-(.LPC0_2+8))
 @ ASM:          movw    r0, :lower16:(extern_symbol+1234)
 @ ASM-NEXT:     movt    r0, :upper16:(extern_symbol+1234)
 @ ASM:          movw    r0, :lower16:((foo-bar)+1234)
 @ ASM-NEXT:     movt    r0, :upper16:((foo-bar)+1234)
 
 @OBJ:      Disassembly of section .text:
-@OBJ-NEXT: barf:
+@OBJ:      barf:
 @OBJ-NEXT: 0:             f0 0f 0f e3     movw    r0, #65520
 @OBJ-NEXT: 00000000:         R_ARM_MOVW_PREL_NC   GOT
 @OBJ-NEXT: 4:             f4 0f 4f e3     movt    r0, #65524
 @OBJ-NEXT: 00000004:         R_ARM_MOVT_PREL      GOT
 @OBJ-NEXT: 8:             d2 04 00 e3     movw    r0, #1234
 @OBJ-NEXT: 00000008:         R_ARM_MOVW_ABS_NC    extern_symbol
 @OBJ-NEXT: c:             d2 04 40 e3     movt    r0, #1234
 @OBJ-NEXT: 0000000c:         R_ARM_MOVT_ABS       extern_symbol
 @OBJ-NEXT: 10:            d2 04 00 e3     movw    r0, #1234
 @OBJ-NEXT: 14:            00 00 40 e3     movt    r0, #0
 
 @THUMB:      Disassembly of section .text:
-@THUMB-NEXT: barf:
+@THUMB:      barf:
 @THUMB-NEXT: 0:             4f f6 f0 70     movw    r0, #65520
 @THUMB-NEXT: 00000000:         R_ARM_THM_MOVW_PREL_NC GOT
 @THUMB-NEXT: 4:             cf f6 f4 70     movt    r0, #65524
 @THUMB-NEXT: 00000004:         R_ARM_THM_MOVT_PREL    GOT
 @THUMB-NEXT: 8:             40 f2 d2 40     movw    r0, #1234
 @THUMB-NEXT: 00000008:         R_ARM_THM_MOVW_ABS_NC  extern_symbol
 @THUMB-NEXT: c:             c0 f2 d2 40     movt    r0, #1234
 @THUMB-NEXT: 0000000c:         R_ARM_THM_MOVT_ABS     extern_symbol
 @THUMB-NEXT: 10:            40 f2 d2 40     movw    r0, #1234
 @THUMB-NEXT: 14:            c0 f2 00 00     movt    r0, #0

test/MC/Mips/set-defined-symbol.s

 # RUN: llvm-mc %s -arch=mips -mcpu=mips32 -filetype=obj -o - | \
 # RUN:   llvm-objdump -d -r - | FileCheck %s
 
   .global foo
   .weak bar
   .set bar, b
   .set foo, b
   .set foo, a
 a:
   nop
-# CHECK-NOT: a:
+# CHECK: a:
 # CHECK: foo:
 
 b:
   nop
-# CHECK-NOT: b:
+# CHECK: b:
 # CHECK-NOT: foo:
 # CHECK: bar:

test/tools/llvm-objdump/X86/disasm-specific-funcs.test

 // RUN: yaml2obj -o %t.out %p/Inputs/simple-executable-x86_64.yaml
 // RUN: llvm-objdump -d %t.out -df=main | FileCheck %s
 
 // CHECK:              Disassembly of section .anothertext:
-// CHECK-NEXT:         main:
+// CHECK:              main:
 // CHECK-NEXT:         10:       55      pushq   %rbp
 // CHECK-NEXT:         11:       48 89 e5        movq    %rsp, %rbp
 // CHECK-NEXT:         14:       48 83 ec 20     subq    $32, %rsp
 // CHECK-NEXT:         18:       48 8d 04 25 a8 00 00 00         leaq    168, %rax
 // CHECK-NEXT:         20:       c7 45 fc 00 00 00 00    movl    $0, -4(%rbp)
 // CHECK-NEXT:         27:       48 89 45 f0     movq    %rax, -16(%rbp)
 // CHECK-NEXT:         2b:       48 8b 45 f0     movq    -16(%rbp), %rax
 // CHECK-NEXT:         2f:       8b 08   movl    (%rax), %ecx
 // CHECK-NEXT:         31:       89 4d ec        movl    %ecx, -20(%rbp)
 // CHECK-NEXT:         34:       e8 c7 ff ff ff  callq   -57
 // CHECK-NEXT:         39:       8b 4d ec        movl    -20(%rbp), %ecx
 // CHECK-NEXT:         3c:       01 c1   addl    %eax, %ecx
 // CHECK-NEXT:         3e:       89 c8   movl    %ecx, %eax
 // CHECK-NEXT:         40:       48 83 c4 20     addq    $32, %rsp
 // CHECK-NEXT:         44:       5d      popq    %rbp

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:      _start:
 CHECK-NEXT:   10:  c3  retl
+
+CHECK:      _fdata:
 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

test/tools/llvm-objdump/X86/start-stop-address.test

 // RUN: yaml2obj -o %t.out %p/Inputs/simple-executable-x86_64.yaml 
 // RUN: llvm-objdump -d %t.out --start-address=0x18 --stop-address=0x2f | FileCheck %s 
 // RUN: llvm-objdump -d %t.out --start-address=0xc --stop-address=0x11 | FileCheck %s --check-prefix "CROSSSECTION"
 // RUN: llvm-objdump -d %t.out --start-address=0x40 --stop-address=0x47 | FileCheck %s --check-prefix "CROSSDATA"
 
 // CHECK:              Disassembly of section .anothertext:
-// CHECK-NEXT:         main:
+// CHECK:              main:
 // CHECK-NEXT:         18:  48 8d 04 25 a8 00 00 00   leaq  168, %rax
 // CHECK-NEXT:         20:  c7 45 fc 00 00 00 00  movl  $0, -4(%rbp)
 // CHECK-NEXT:         27:  48 89 45 f0   movq  %rax, -16(%rbp)
 // CHECK-NEXT:         2b:  48 8b 45 f0   movq  -16(%rbp), %rax
 // CHECK-NOT:          2f:
 
 // CROSSSECTION:       Disassembly of section .text:
-// CROSSSECTION-NEXT:  foo:
+// CROSSSECTION:       foo:
 // CROSSSECTION-NEXT:  c: c3  retq
 // CROSSSECTION-NEXT:  d: 0f 1f 00  nopl  (%rax)
-// CROSSSECTION-NEXT:  Disassembly of section .anothertext:
-// CROSSSECTION-NEXT:  main:
+// CROSSSECTION:  Disassembly of section .anothertext:
+// CROSSSECTION:  main:
 // CROSSSECTION-NEXT:  10:  55  pushq %rbp
 // CROSSSECTION-NOT:   11:
 
 // CROSSDATA:          Disassembly of section .anothertext:
 // CROSSDATA:          main:
 // CROSSDATA:          40:  48 83 c4 20   addq  $32, %rsp
 // CROSSDATA:          44:  5d  popq  %rbp
 // CROSSDATA-DAG:      somedata:
 // CROSSDATA-NEXT:     45:   74 65                           te
 

tools/llvm-objdump/llvm-objdump.cpp

for (unsigned si = 0, se = Symbols.size(); si != se; ++si) {
       uint64_t Start = std::get<0>(Symbols[si]) - SectionAddr;
       // The end is either the section end or the beginning of the next
       // symbol.
       uint64_t End =
           (si == se - 1) ? SectSize : std::get<0>(Symbols[si + 1]) - SectionAddr;
       // Don't try to disassemble beyond the end of section contents.
       if (End > SectSize)
         End = SectSize;
-      // If this symbol has the same address as the next symbol, then skip it.
-      if (Start >= End)
-        continue;
 
       // Check if we need to skip symbol
       // Skip if the symbol's data is not between StartAddress and StopAddress
       if (End + SectionAddr < StartAddress ||
           Start + SectionAddr > StopAddress) {
         continue;
       }
 
for (unsigned si = 0, se = Symbols.size(); si != se; ++si) {
           while (End > Limit &&
             *reinterpret_cast<const support::ulittle32_t*>(&Bytes[End - 4]) == 0)
             End -= 4;
         }
       }
 
       outs() << '\n' << std::get<1>(Symbols[si]) << ":\n";
 
+      // If this symbol has the same address as the next symbol, then skip it.
+      if (Start >= End)
+        continue;
+
 #ifndef NDEBUG
       raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls();
 #else
       raw_ostream &DebugOut = nulls();
 #endif
 
       for (Index = Start; Index < End; Index += Size) {
         MCInst Inst;