[llvm-objdump] Print memory operand addresses as regular comments

[ikudrin]

Summary

The patch reuses the common code to print memory operand addresses as instruction comments. This helps to align the comments and enables using target-specific comment markers when evaluateMemoryOperandAddress() is implemented for them.

[MaskRay]

LGTM.

[ikudrin]

• Fixed test failures in lld/test/MachO

[int3]

lgtm

lld/test/MachO/dso-handle.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 
 # RUN: %lld -lSystem %t.o -o %t
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
-# CHECK:      leaq {{.*}} # 0x100000000
-# CHECK-NEXT: leaq {{.*}} # 0x100000000
+# CHECK:      leaq {{.*}} ## 0x100000000
+# CHECK-NEXT: leaq {{.*}} ## 0x100000000
 
 # RUN: %lld -dylib %t.o -o %t.dylib
 # RUN: llvm-objdump -d --no-show-raw-insn --rebase --section-headers %t.dylib | FileCheck %s --check-prefix=DYLIB-CHECK
-# DYLIB-CHECK:      leaq {{.*}} # 0x0
-# DYLIB-CHECK-NEXT: leaq {{.*}} # 0x0
+# DYLIB-CHECK:      leaq {{.*}} ## 0x0
+# DYLIB-CHECK-NEXT: leaq {{.*}} ## 0x0
 
 # DYLIB-LABEL: Sections:
 # DYLIB:       __data        00000008 [[#%x,DATA:]] DATA
 # DYLIB-LABEL: Rebase table:
 # DYLIB-NEXT:  segment  section  address            type
 # DYLIB-NEXT:  __DATA   __data   0x{{0*}}[[#DATA]]  pointer
 
 # RUN: llvm-objdump --syms %t.dylib | FileCheck %s --check-prefix=SYMS

lld/test/MachO/dylink-ordinal.s

 # REQUIRES: x86
 
 ## --no-leading-lines needed for .tbd files.
 # RUN: rm -rf %t; split-file --no-leading-lines %s %t
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/main.s -o %t/main.o
 # RUN: %lld -o %t/main -L%t -lFoo -lBar -lSystem %t/main.o
 # RUN: llvm-objdump --lazy-bind -d --no-show-raw-insn %t/main | FileCheck %s
 
 # CHECK: callq 0x[[#%x,FOO_OFF:]]
 # CHECK-NEXT: callq 0x[[#%x,BAR_OFF:]]
 
-# CHECK: [[#%x,BAR_OFF]]: jmpq {{.*}} # 0x[[#%x,BAR_BIND:]]
-# CHECK: [[#%x,FOO_OFF]]: jmpq {{.*}} # 0x[[#%x,FOO_BIND:]]
+# CHECK: [[#%x,BAR_OFF]]: jmpq {{.*}} ## 0x[[#%x,BAR_BIND:]]
+# CHECK: [[#%x,FOO_OFF]]: jmpq {{.*}} ## 0x[[#%x,FOO_BIND:]]
 
 # CHECK-LABEL: Lazy bind table:
 # CHECK-DAG: __DATA __la_symbol_ptr 0x[[#%x,FOO_BIND]] Foo _foo
 # CHECK-DAG: __DATA __la_symbol_ptr 0x[[#%x,BAR_BIND]] Foo _bar
 
 # RUN: llvm-nm -m %t/main | FileCheck --check-prefix=NM %s
 
 # NM-DAG: _bar (from Foo)

lld/test/MachO/mattrs.ll

 ; FMA-NEXT: vrcpss       %xmm0, %xmm0, %xmm1
 ; FMA-NEXT: vfmsub213ss  [[#]](%rip), %xmm1, %xmm0
 ; FMA-NEXT: vfnmadd132ss %xmm1, %xmm1, %xmm0
 ; FMA-NEXT: retq
 
 ; NO-FMA:      <_foo>:
 ; NO-FMA-NEXT: vrcpss %xmm0, %xmm0, %xmm1
 ; NO-FMA-NEXT: vmulss %xmm1, %xmm0, %xmm0
-; NO-FMA-NEXT: vmovss [[#]](%rip), %xmm2
+; NO-FMA-NEXT: vmovss [[#]](%rip), %xmm2  ## xmm2 =
+; NO-FMA-NEXT:                            ## 0x
 ; NO-FMA-NEXT: vsubss %xmm0, %xmm2, %xmm0
 ; NO-FMA-NEXT: vmulss %xmm0, %xmm1, %xmm0
 ; NO-FMA-NEXT: vaddss %xmm0, %xmm1, %xmm0
 ; NO-FMA-NEXT: retq
 
 target triple = "x86_64-apple-darwin"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define float @foo(float %x) #0 {
   %div = fdiv fast float 1.0, %x
   ret float %div
 }
 
 attributes #0 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf,vec-divf" }

lld/test/MachO/static-link.s

 #
 # RUN: llvm-objdump --syms -d -r %t/test | FileCheck %s
 
 # CHECK: SYMBOL TABLE:
 # CHECK: {{0+}}[[ADDR:[0-9a-f]+]] g     O __TEXT,__cstring _goodbye_world
 
 # CHECK: Disassembly of section __TEXT,__text
 # CHECK-LABEL: <_main>:
-# CHECK: leaq {{.*}}(%rip), %rsi   # 0x[[ADDR]] <_goodbye_world>
+# CHECK: leaq {{.*}}(%rip), %rsi   ## 0x[[ADDR]] <_goodbye_world>
 
 .section __TEXT,__text
 .global _main
 
 _main:
   movl $0x2000004, %eax                 # write()
   mov $1, %rdi                          # stdout
   leaq _goodbye_world(%rip), %rsi
   mov $15, %rdx                         # length
   syscall
   mov $0, %rax
   ret

lld/test/MachO/tapi-link.s

 # REQUIRES: x86
 
 # RUN: split-file %s %t --no-leading-lines
 
 # RUN: llvm-mc -filetype obj -triple x86_64-apple-darwin %t/test.s -o %t/test.o
 
 # RUN: %lld -o %t/test -lSystem -lc++ -framework CoreFoundation %t/libNested.tbd %t/test.o
 # RUN: llvm-objdump --bind --no-show-raw-insn -d -r %t/test | FileCheck %s
 
 ## libReexportSystem.tbd tests that we can reference symbols from a dylib,
 ## re-exported by a top-level tapi document, which itself is re-exported by
 ## another top-level tapi document.
 # RUN: %lld -o %t/with-reexport %S/Inputs/libReexportSystem.tbd -lc++ -framework CoreFoundation %t/libNested.tbd %t/test.o
 # RUN: llvm-objdump --bind --no-show-raw-insn -d -r %t/with-reexport | FileCheck %s
 
 # CHECK: Disassembly of section __TEXT,__text:
-# CHECK: movq {{.*}} # 0x[[ADDR:[0-9a-f]+]]
+# CHECK: movq {{.*}} ## 0x[[ADDR:[0-9a-f]+]]
 
 # CHECK: Bind table:
 # CHECK-DAG: __DATA_CONST __got 0x[[ADDR]] pointer 0 libSystem ___nan
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 CoreFoundation _OBJC_CLASS_$_NSObject
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 CoreFoundation _OBJC_METACLASS_$_NSObject
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 CoreFoundation _OBJC_IVAR_$_NSConstantArray._count
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 CoreFoundation _OBJC_EHTYPE_$_NSException
 # CHECK-DAG: __DATA __data {{.*}} pointer 0 libc++abi      ___gxx_personality_v0

lld/test/MachO/tlv-dylib.s

 # DYLIB:       Rebase table:
 # DYLIB-NEXT:  segment  section            address     type
 # DYLIB-EMPTY:
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
 # RUN: %lld -lSystem -L%t -ltlv %t/test.o -o %t/test
 # RUN: llvm-objdump --bind -d --no-show-raw-insn %t/test | FileCheck %s
 
-# CHECK:      movq [[#]](%rip), %rax # 0x[[#%x, FOO:]]
-# CHECK-NEXT: movq [[#]](%rip), %rax # 0x[[#%x, BAR:]]
-# CHECK-NEXT: movq [[#]](%rip), %rax # 0x[[#%x, BAZ:]]
+# CHECK:      movq [[#]](%rip), %rax ## 0x[[#%x, FOO:]]
+# CHECK-NEXT: movq [[#]](%rip), %rax ## 0x[[#%x, BAR:]]
+# CHECK-NEXT: movq [[#]](%rip), %rax ## 0x[[#%x, BAZ:]]
 
 # CHECK-LABEL: Bind table:
 # CHECK-DAG: __DATA       __thread_ptrs  0x{{0*}}[[#%x, FOO]] pointer 0   libtlv   _foo
 # CHECK-DAG: __DATA       __thread_ptrs  0x{{0*}}[[#%x, BAR]] pointer 0   libtlv   _bar
 # CHECK-DAG: __DATA_CONST __got          0x{{0*}}[[#%x, BAZ]] pointer 0   libtlv   _baz
 
 ## Check `type` on the various TLV sections, and check that
 ## nothing's after S_THREAD_LOCAL_ZEROFILL.

lld/test/MachO/tlv.s

 ## Check that we always put __thread_bss immediately after __thread_data,
 ## regardless of the order of the input files.
 # RUN: %lld -lSystem %t/tbss.o %t/regular.o -o %t/regular-and-tbss
 # RUN: llvm-objdump --section-headers %t/regular-and-tbss | FileCheck %s --check-prefix=SECTION-ORDER
 
 # HEADER: MH_HAS_TLV_DESCRIPTORS
 
 # REG:       <_main>:
-# REG-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_foo>
-# REG-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_bar>
+# REG-NEXT:  leaq    {{.*}}(%rip), %rax  ## {{.*}} <_foo>
+# REG-NEXT:  leaq    {{.*}}(%rip), %rax  ## {{.*}} <_bar>
 # REG-NEXT:  retq
 
 # TBSS:       <_f>:
-# TBSS-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_baz>
-# TBSS-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_qux>
+# TBSS-NEXT:  leaq    {{.*}}(%rip), %rax  ## {{.*}} <_baz>
+# TBSS-NEXT:  leaq    {{.*}}(%rip), %rax  ## {{.*}} <_qux>
 # TBSS-NEXT:  retq
 
 # REG-TLVP:      00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 # REG-TLVP-NEXT: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 # REG-TLVP-NEXT: 00 00 00 00 00 00 00 00 08 00 00 00 00 00 00 00
 
 # TBSS-TLVP:      00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 # TBSS-TLVP-NEXT: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

lld/test/MachO/weak-binding.s

 
 # CHECK:      Contents of section __DATA,__la_symbol_ptr:
 ## Check that this section contains a nonzero pointer. It should point to
 ## _weak_external_fn, but we don't have a good way of testing the exact value as
 ## the bytes here are in little-endian order.
 # CHECK-NEXT: {{[0-9a-f]+}} {{[0-9a-f ]*[1-9a-f]+[0-9a-f ]*}}
 
 # CHECK:      <_main>:
-# CHECK-NEXT: movq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_DY_GOT_ADDR:]]
-# CHECK-NEXT: movq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_EXT_GOT_ADDR:]]
-# CHECK-NEXT: leaq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_INT_GOT_ADDR:]]
-# CHECK-NEXT: movq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_TLV_ADDR:]]
-# CHECK-NEXT: movq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_DY_TLV_ADDR:]]
-# CHECK-NEXT: leaq  [[#]](%rip), %rax  # 0x[[#%X,WEAK_INT_TLV_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  ## 0x[[#%X,WEAK_DY_GOT_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  ## 0x[[#%X,WEAK_EXT_GOT_ADDR:]]
+# CHECK-NEXT: leaq  [[#]](%rip), %rax  ## 0x[[#%X,WEAK_INT_GOT_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  ## 0x[[#%X,WEAK_TLV_ADDR:]]
+# CHECK-NEXT: movq  [[#]](%rip), %rax  ## 0x[[#%X,WEAK_DY_TLV_ADDR:]]
+# CHECK-NEXT: leaq  [[#]](%rip), %rax  ## 0x[[#%X,WEAK_INT_TLV_ADDR:]]
 # CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 # CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 # CHECK-NEXT: callq 0x{{[0-9a-f]*}}
 
 # CHECK-LABEL: Rebase table:
 # CHECK:       __DATA        __la_symbol_ptr 0x[[#%x,WEAK_EXT_FN:]]  pointer
 
 # CHECK-LABEL: Bind table:

lld/test/MachO/x86-64-reloc-got-load.s

 # REQUIRES: x86
 
 ## Check that we perform relaxation for GOT_LOAD relocations to defined symbols.
 ## Note: GOT_LOAD relocations to dylib symbols are already tested in dylink.s.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: %lld -o %t %t.o
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s
-# CHECK: leaq [[#]](%rip), %rax  # {{.*}} <_foo>
+# CHECK: leaq [[#]](%rip), %rax  ## {{.*}} <_foo>
 
 .globl _main, _foo
 
 _main:
   movq _foo@GOTPCREL(%rip), %rax
   ret
 
 _foo:
   .space 0

lld/test/MachO/x86-64-reloc-signed.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: echo _t > %t.order
 # RUN: %lld -o %t -order_file %t.order %t.o
 # RUN: llvm-objdump --section-headers --syms -D %t | FileCheck %s
 
 # CHECK-LABEL: Sections:
 # CHECK:       __foo         {{[0-9a-f]+}}  [[#%x,FOO:]]  DATA
 
 # CHECK-LABEL: SYMBOL TABLE:
 # CHECK:       [[#%x,S:]]  g     O __DATA,__data _s
 
 # CHECK-LABEL: Disassembly of section
 # CHECK:      <_main>:
-# CHECK-NEXT:   movl {{.*}}  # 0x[[#S]]
+# CHECK-NEXT:   movl {{.*}}  ## imm =
+# CHECK-NEXT:                ## 0x[[#S]]
 # CHECK-NEXT:   callq {{.*}}
-# CHECK-NEXT:   movl {{.*}}  # 0x[[#S + 2]]
+# CHECK-NEXT:   movl {{.*}}  ## 0x[[#S + 2]]
 # CHECK-NEXT:   callq {{.*}}
-# CHECK-NEXT:   movb {{.*}}  # 0x[[#S]]
+# CHECK-NEXT:   movb {{.*}}  ## 0x[[#S]]
 # CHECK-NEXT:   callq {{.*}}
 # CHECK:      <__not_text>:
-# CHECK-NEXT:   movl {{.*}}  # 0x[[#FOO + 8]]
+# CHECK-NEXT:   movl {{.*}}  ## imm =
+# CHECK-NEXT:                ## 0x[[#FOO + 8]]
 # CHECK-NEXT:   callq {{.*}}
-# CHECK-NEXT:   movl {{.*}}  # 0x[[#FOO + 8 + 2]]
+# CHECK-NEXT:   movl {{.*}}  ## 0x[[#FOO + 8 + 2]]
 # CHECK-NEXT:   callq {{.*}}
-# CHECK-NEXT:   movb {{.*}}  # 0x[[#FOO + 8]]
+# CHECK-NEXT:   movb {{.*}}  ## 0x[[#FOO + 8]]
 # CHECK-NEXT:   callq {{.*}}
 
 .section __TEXT,__text
 .globl _main
 _main:
   ## Symbol relocations
   movl $0x434241, _s(%rip)  # X86_64_RELOC_SIGNED_4
   callq _f

llvm/test/tools/llvm-objdump/X86/disassemble-align.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t
 
 # Use '|' to show where the tabs line up.
 # RUN: llvm-objdump -d --print-imm-hex %t | tr '\t' '|' | \
 # RUN:   FileCheck --match-full-lines --strict-whitespace %s
 
 # RUN: llvm-objdump -d --print-imm-hex --no-show-raw-insn %t | tr '\t' '|' | \
 # RUN:   FileCheck -check-prefix=NORAW --match-full-lines -strict-whitespace %s
 
 # Instructions are expected to be aligned if the instruction in hex is not too long.
 
 #      CHECK:       0: c3                           |retq
-# CHECK-NEXT:       1: 48 8b 05 56 34 12 00         |movq|0x123456(%rip), %rax  # 0x12345e <.text+0x12345e>
+# CHECK-NEXT:       1: 48 8b 05 56 34 12 00         |movq|0x123456(%rip), %rax    # 0x12345e <.text+0x12345e>
 # CHECK-NEXT:       8: 48 b8 54 55 55 55 55 55 55 55|movabsq|$0x5555555555555554, %rax # imm = 0x5555555555555554
 # CHECK-NEXT:      12: 8f ea 00 12 4c 02 40 00 00 00 00     |lwpval|$0x0, 0x40(%rdx,%rax), %r15d
 # CHECK-NEXT:      1d: 8f ea 00 12 04 25 f0 1c f0 1c 00 00 00 00    |lwpins|$0x0, 0x1cf01cf0, %r15d
 # CHECK-NEXT:      2b: ff ff                        |<unknown>
 
 #      NORAW:       0:      |retq
-# NORAW-NEXT:       1:      |movq|0x123456(%rip), %rax  # 0x12345e <.text+0x12345e>
+# NORAW-NEXT:       1:      |movq|0x123456(%rip), %rax    # 0x12345e <.text+0x12345e>
 # NORAW-NEXT:       8:      |movabsq|$0x5555555555555554, %rax # imm = 0x5555555555555554
 # NORAW-NEXT:      12:      |lwpval|$0x0, 0x40(%rdx,%rax), %r15d
 # NORAW-NEXT:      1d:      |lwpins|$0x0, 0x1cf01cf0, %r15d
 # NORAW-NEXT:      2b:      |<unknown>
 
 .text
   retq
   movq 0x123456(%rip),%rax
   movabs $0x5555555555555554,%rax
   lwpval $0x0, 0x40(%rdx,%rax), %r15d
   lwpins $0x0, 0x1cf01cf0, %r15d
   .word 0xffff

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

for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
 
           IP->setCommentStream(llvm::nulls());
 
           // If disassembly has failed, avoid analysing invalid/incomplete
           // instruction information. Otherwise, try to resolve the target
           // address (jump target or memory operand address) and print it on the
           // right of the instruction.
           if (Disassembled && MIA) {
+            // Branch targets are printed just after the instructions.
+            llvm::raw_ostream *TargetOS = &FOS;
             uint64_t Target;
             bool PrintTarget =
                 MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target);
             if (!PrintTarget)
               if (Optional<uint64_t> MaybeTarget =
                       MIA->evaluateMemoryOperandAddress(
                           Inst, SectionAddr + Index, Size)) {
                 Target = *MaybeTarget;
                 PrintTarget = true;
                 // Do not print real address when symbolizing.
-                if (!SymbolizeOperands)
-                  FOS << "  # 0x" << Twine::utohexstr(Target);
+                if (!SymbolizeOperands) {
+                  // Memory operand addresses are printed as comments.
+                  TargetOS = &CommentStream;
+                  *TargetOS << "0x" << Twine::utohexstr(Target);
+                }
               }
             if (PrintTarget) {
               // In a relocatable object, the target's section must reside in
               // the same section as the call instruction or it is accessed
               // through a relocation.
               //
               // In a non-relocatable object, the target may be in any section.
               // In that case, locate the section(s) containing the target
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
               bool LabelAvailable = AllLabels.count(Target);
               if (TargetSym != nullptr) {
                 uint64_t TargetAddress = TargetSym->Addr;
                 uint64_t Disp = Target - TargetAddress;
                 std::string TargetName = TargetSym->Name.str();
                 if (Demangle)
                   TargetName = demangle(TargetName);
 
-                FOS << " <";
+                *TargetOS << " <";
                 if (!Disp) {
                   // Always Print the binary symbol precisely corresponding to
                   // the target address.
-                  FOS << TargetName;
+                  *TargetOS << TargetName;
                 } else if (!LabelAvailable) {
                   // Always Print the binary symbol plus an offset if there's no
                   // local label corresponding to the target address.
-                  FOS << TargetName << "+0x" << Twine::utohexstr(Disp);
+                  *TargetOS << TargetName << "+0x" << Twine::utohexstr(Disp);
                 } else {
-                  FOS << AllLabels[Target];
+                  *TargetOS << AllLabels[Target];
                 }
-                FOS << ">";
+                *TargetOS << ">";
               } else if (LabelAvailable) {
-                FOS << " <" << AllLabels[Target] << ">";
+                *TargetOS << " <" << AllLabels[Target] << ">";
               }
+              // By convention, each record in the comment stream should be
+              // terminated.
+              if (TargetOS == &CommentStream)
+                *TargetOS << "\n";
             }
           }
         }
 
         assert(Ctx.getAsmInfo());
         emitPostInstructionInfo(FOS, *Ctx.getAsmInfo(), *STI,
                                 CommentStream.str(), LVP);
         Comments.clear();