[llvm-objdump] - Print symbol addressed when dumping disassembly output (-d)

[grimar]

Summary

When GNU objdump dumps the input with -d it prints the symbol addresses,
for example:

0000000000000031 <foo>:
  31:	00 00                	add    %al,(%rax)
	...

0000000000000035 <bar>:
	...

when llvm-objdump dumps the same object, it doesn't do that:

foo:
		...
      39:	00 00 	addb	%al, (%rax)

bar:
		...
      39:	00 00 	addb	%al, (%rax)
      3b:	00 00 	addb	%al, (%rax)

The reason to do the same is the following:
I am working on a D56083, which implements -z/--disassemble-zeroes.
Normally the disassembly output will skip blocks of zeroes. Currently, by default GNU objdump
skip them, but llvm-objdump does not. And the issue is shown in the sample above.
If we omit the bytes at the beginning of the section (see bar above), then the first
address (0x0000000000000035) is not printed and it is inconvenient and makes the output
not so useful as we do not see the start address of the symbol then.

So I suggest to follow the GNU objdump behavior and also print the address unless the
-no-leading-addr flag is set.

[echristo]

Sure.

-eric

[jhenderson]

LGTM too. Not that I'm saying you should change it, as I don't know how complex it would be, but perhaps an alternative to consider might have been to disassemble the first zeroes after a symbol, even without -z. Something like this:

foo:
10: 00 00
...
bar:
40: 00 00
...

I'm not sure how desirable that is versus the alternative though (really, I'm not sure I see much benefit to the behaviour of not disassembling zeroes, but that's just me).

[grimar]

In D56123#1343558, @jhenderson wrote:

LGTM too. Not that I'm saying you should change it, as I don't know how complex it would be, but perhaps an alternative to consider might have been to disassemble the first zeroes after a symbol, even without -z. Something like this:

foo:
10: 00 00
...
bar:
40: 00 00
...

I'm not sure how desirable that is versus the alternative though (really, I'm not sure I see much benefit to the behaviour of not disassembling zeroes, but that's just me).

I am definitely not against of further tweaking of the -z/no -z behavior, but I think printing the symbol address (this patch) can and should be an independent thing.
Skipping/not-skipping any zeroes is a heuristic logic that might change and it better to reduce/eliminate/not introduce any dependencies/assumptions here I believe.

llvm/trunk/test/tools/llvm-objdump/X86/print-symbol-addr.s

+// RUN: llvm-mc %s -filetype=obj -triple=x86_64-pc-linux -o %t.o
+
+// Check we print the address of `foo` and `bar`.
+// RUN: llvm-objdump -d %t.o | FileCheck %s
+// CHECK:      Disassembly of section .text:
+// CHECK-NEXT: 0000000000000000 foo:
+// CHECK-NEXT:   0: {{.*}}  nop
+// CHECK-NEXT:   1: {{.*}}  nop
+// CHECK:      0000000000000002 bar:
+// CHECK-NEXT:   2: {{.*}}  nop
+
+// Check we do not print the addresses with -no-leading-addr.
+// RUN: llvm-objdump -d -no-leading-addr %t.o | FileCheck %s --check-prefix=NOADDR
+// NOADDR:      Disassembly of section .text:
+// NOADDR-NEXT: {{^}}foo:
+// NOADDR-NEXT:   {{.*}} nop
+// NOADDR-NEXT:   {{.*}} nop
+// NOADDR:      {{^}}bar:
+// NOADDR-NEXT:   {{.*}} nop
+
+.text
+.globl  foo
+.type   foo, @function
+foo:
+ nop
+ nop
+
+bar:
+ nop

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

for (unsigned si = 0, se = Symbols.size(); si != se; ++si) {
           const auto Limit = End - (std::min)(EndAlign, End - Start);
           while (End > Limit &&
             *reinterpret_cast<const support::ulittle32_t*>(&Bytes[End - 4]) == 0)
             End -= 4;
         }
       }
 
       outs() << '\n';
+      if (!NoLeadingAddr)
+        outs() << format("%016" PRIx64 " ", SectionAddr + Start);
+
       StringRef SymbolName = std::get<1>(Symbols[si]);
       if (Demangle)
         outs() << demangle(SymbolName) << ":\n";
       else
         outs() << SymbolName << ":\n";
 
       // Don't print raw contents of a virtual section. A virtual section
       // doesn't have any contents in the file.