[llvm-objdump] Annotate symbol names under `--symbolize-operands`.

[Esme]

Summary

We would like to disassemble an object file and annotate it with the variables that are being accessed.
This patch achieves the feature by walking through the relocations and annotate instructions with their target symbol names.

[MaskRay]

To access the relocation information, I'd prefer that the user specifies -r:

88: 01 00 00 48   bl 0x88 <foo+0x48>
          0000000000000088:  R_PPC64_REL24        extern

Without the relocation type information, the 4 addend for R_PPC64_REL16_LO may be confusing.

; CHECK-NEXT:     c4:       addi 2, 2, 0                    #  <.TOC.+0x4>

PS: ET_EXEC/ET_DYN PowerPC binary has the problem described by https://reviews.llvm.org/D116677#3239375 . If you want to contribute to this area...

llvm/test/tools/llvm-objdump/ELF/PowerPC/disassemble-symbolize-operands.ll

 then:                                             ; preds = %bb
   call void @extern()
   br label %endif
 endif:                                             ; preds = %bb28, %bb
   br i1 %breakcond, label %loop, label %loopexit
 loopexit:
   ret void
 }
+
+;; Expect to annotate the symbol names.
+; CHECK-LABEL: <fun>:
+; CHECK-NEXT:     c0:       addis 2, 12, 0                  #  <.TOC.>
+; CHECK-NEXT:     c4:       addi 2, 2, 0                    #  <.TOC.+0x4>
+; CHECK-NEXT:     c8:       addis 3, 2, 0                   #  <.toc>
+; CHECK-NEXT:     cc:       addis 4, 2, 0                   #  <val1>
+; CHECK-NEXT:     d0:       ld 3, 0(3)                      #  <.toc>
+; CHECK-NEXT:     d4:       lwz 4, 0(4)                     #  <val1>
+
+@val1 = dso_local global i32 10, align 4
+@val2 = external global i32, align 4
+
+define dso_local signext i32 @fun() #0 {
+entry:
+  %0 = load i32, i32* @val1, align 4
+  %1 = load i32, i32* @val2, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}

llvm/test/tools/llvm-objdump/X86/disassemble-symbolize-operands.ll

+; RUN: llc -mtriple=x86_64-pc-linux %s -filetype=obj -o %t
+; RUN: llvm-objdump %t -d --symbolize-operands --no-show-raw-insn \
+; RUN:   | FileCheck %s
+
+; CHECK-LABEL: <fun>:
+; CHECK-NEXT:      0:       movl , %eax <fun+0x6>        #  <val1-0x4>
+; CHECK-NEXT:      6:       movq , %rcx <fun+0xd>        #  <val2-0x4>
+; CHECK-NEXT:      d:       addl (%rcx), %eax
+; CHECK-NEXT:      f:       retq
+
+@val1 = dso_local global i32 10, align 4
+@val2 = external global i32, align 4
+
+define dso_local signext i32 @fun() #0 {
+entry:
+  %0 = load i32, i32* @val1, align 4
+  %1 = load i32, i32* @val2, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}

llvm/test/tools/llvm-objdump/XCOFF/disassemble-symbolize-operands.ll

 then:                                             ; preds = %bb
   call void @extern()
   br label %endif
 endif:                                             ; preds = %bb28, %bb
   br i1 %breakcond, label %loop, label %loopexit
 loopexit:
   ret void
 }
+
+;; Expect to annotate the symbol names.
+; CHECK-LABEL: <.fun>:
+; CHECK-NEXT:      bc:       lwz 3, 0(2)                     #  <val1>
+; CHECK-NEXT:      c0:       lwz 4, 4(2)                     #  <val2>
+
+@val1 = dso_local global i32 10, align 4
+@val2 = external global i32, align 4
+
+define dso_local signext i32 @fun() #0 {
+entry:
+  %0 = load i32, i32* @val1, align 4
+  %1 = load i32, i32* @val2, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}

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

static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj,
                               SourcePrinter &SP, bool InlineRelocs) {
   const MCSubtargetInfo *STI = PrimarySTI;
   MCDisassembler *DisAsm = PrimaryDisAsm;
   bool PrimaryIsThumb = false;
   if (isArmElf(Obj))
     PrimaryIsThumb = STI->checkFeatures("+thumb-mode");
 
   std::map<SectionRef, std::vector<RelocationRef>> RelocMap;
-  if (InlineRelocs)
+  if (InlineRelocs || SymbolizeOperands)
     RelocMap = getRelocsMap(*Obj);
   bool Is64Bits = Obj->getBytesInAddress() > 4;
 
   // Create a mapping from virtual address to symbol name.  This is used to
   // pretty print the symbols while disassembling.
   std::map<SectionRef, SectionSymbolsTy> AllSymbols;
   SectionSymbolsTy AbsoluteSymbols;
   const StringRef FileName = Obj->getFileName();
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
               } else if (LabelAvailable) {
                 *TargetOS << " <" << AllLabels[Target] << ">";
               }
               // By convention, each record in the comment stream should be
               // terminated.
               if (TargetOS == &CommentStream)
                 *TargetOS << "\n";
             }
+
+            // Walk the relocations and annotate the target symbol name on the
+            // right of the instruction.
+            if (SymbolizeOperands && !InlineRelocs) {
+              TargetOS = &CommentStream;
+              while (RelCur != RelEnd) {
+                uint64_t Offset = RelCur->getOffset() - RelAdjustment;
+                if (Offset >= Index + Size)
+                  break;
+
+                SmallString<32> Val;
+                if (Error E = getRelocationValueString(*RelCur, Val))
+                  reportError(std::move(E), Obj->getFileName());
+                *TargetOS << " <" << Val << ">";
+
+                ++RelCur;
+              }
+            }
           }
         }
 
         assert(Ctx.getAsmInfo());
         emitPostInstructionInfo(FOS, *Ctx.getAsmInfo(), *STI,
                                 CommentStream.str(), LVP);
         Comments.clear();