[llvm-objdump][XCOFF] Print more symbol info in relocation

[jasonliu]

Summary

Print more symbol info in relocation printing when --symbol-description is specified.

[DiggerLin]

llvm/test/tools/llvm-objdump/XCOFF/print-reloc.test

39

nit: space align

llvm/tools/llvm-objdump/XCOFFDump.cpp

15–17

MCDisassembler.h already in the llvm-objdump.h

67–68

why not use StringRef ?

[jasonliu]

llvm/test/tools/llvm-objdump/XCOFF/print-reloc.test

39

Discussed offline: there is no issue here.

llvm/tools/llvm-objdump/XCOFFDump.cpp

67–68

How do we use StringRef if we need to do some string manipulation?

[DiggerLin]

llvm/tools/llvm-objdump/XCOFFDump.cpp

37

SymName is a std::string . It should be
SymName = demangle(SymName); ?

[jhenderson]

Looks good to me, with the minor fixes @DiggerLin suggested.

[jasonliu]

Address coments.

[hubert.reinterpretcast]

llvm/tools/llvm-objdump/XCOFFDump.cpp

73

This part can be done with Twine, realizing the string at the point of the assignment.

77

To reduce the amount of std::string operations, the append of this could be moved into the concatenation in the if above and an append in an else. Even if we were to have this line, it should use the StringRef iterators directly.

83

Same comment regarding Twine.

[jasonliu]

Use Twine whenever possible.

[hubert.reinterpretcast]

LGTM with minor comment. The output looks great; thanks!

llvm/tools/llvm-objdump/XCOFFDump.cpp

81

I said "append", and I meant it. With Result.append(SymbolName.begin(), SymbolName.end()), if the string is small, only one copy would be done (as opposed to two, plus move operation overhead). If the string is long, then we still save on the move operation.

[jasonliu]

llvm/tools/llvm-objdump/XCOFFDump.cpp

81

Thanks for the detailed explanation. Addressed in the commit.

llvm/test/tools/llvm-objdump/XCOFF/disassemble-symbol-description.test

 # REQUIRES: powerpc-registered-target
 
 # RUN: llvm-objdump -D %p/Inputs/xcoff-section-headers.o | \
 # RUN:   FileCheck --check-prefixes=COMMON,PLAIN %s
 
 # RUN: llvm-objdump -D --symbol-description %p/Inputs/xcoff-section-headers.o | \
 # RUN:   FileCheck --check-prefixes=COMMON,DESC %s
 
+# RUN: llvm-objdump -D -r --symbol-description %p/Inputs/xcoff-section-headers.o | \
+# RUN:   FileCheck --check-prefixes=COMMON,DESC,RELOC %s
+
 # xcoff-section-headers.o Compiled with IBM XL C/C++ for AIX, V16.1.0
 # compiler command: xlc -qtls -o xcoff-section-headers.o -c test.c
 
 ## test.c:
 ## int a;
 ## int b = 12345;
 ## __thread int c;
 ## __thread double d = 3.14159;
 ##
 ## int func(void)  {
 ##   return a;
 ## }
 
 COMMON: Inputs/xcoff-section-headers.o: file format aixcoff-rs6000
 COMMON: Disassembly of section .text:
 PLAIN:      00000000 <.text>:
 DESC:       00000000 (idx: 4) .text:
 COMMON-NEXT:        0: 80 62 00 04                    lwz 3, 4(2)
+RELOC:                              00000002:  R_TOC        (idx: 26) a[TC]
 COMMON-NEXT:        4: 80 63 00 00                    lwz 3, 0(3)
 COMMON-NEXT:        8: 4e 80 00 20                    blr
 COMMON-NEXT:        c: 00 00 00 00                    <unknown>
 COMMON-NEXT:       10: 00 00 20 40                    <unknown>
 COMMON-NEXT:       14: 00 00 00 01                    <unknown>
 COMMON-NEXT:       18: 00 00 00 0c                    <unknown>
 COMMON-NEXT:       1c: 00 04 66 75                    <unknown>
 COMMON-NEXT:       20: 6e 63 00 00                    xoris 3, 19, 0
 COMMON-NEXT:    ...
 COMMON: Disassembly of section .data:
 PLAIN:      00000080 <func>:
 DESC:       00000080 (idx: 22) func[TC]:
 COMMON-NEXT:       80: 00 00 00 94                    <unknown>
+RELOC:                              00000080:  R_POS        (idx: 20) func[DS]
 PLAIN:      00000084 <a>:
 DESC:       00000084 (idx: 26) a[TC]:
 COMMON-NEXT:       84: 00 00 00 a4                    <unknown>
+RELOC:                              00000084:  R_POS        (idx: 24) a[RW]
 PLAIN:      00000088 <b>:
 DESC:       00000088 (idx: 30) b[TC]:
 COMMON-NEXT:       88: 00 00 00 a0                    <unknown>
+RELOC:                              00000088:  R_POS        (idx: 28) b[RW]
 PLAIN:      0000008c <c>:
 DESC:       0000008c (idx: 34) c[TC]:
 COMMON-NEXT:       8c: 00 00 00 08                    <unknown>
+RELOC:                              0000008c:  R_TLS        (idx: 32) c[UL]
 PLAIN:      00000090 <d>:
 DESC:       00000090 (idx: 38) d[TC]:
 COMMON-NEXT:       90: 00 00 00 00                    <unknown>
+RELOC:                              00000090:  R_TLS        (idx: 36) d[TL]
 PLAIN:      00000094 <func>:
 DESC:       00000094 (idx: 20) func[DS]:
 COMMON-NEXT:       94: 00 00 00 00                    <unknown>
+RELOC:                              00000094:  R_POS        (idx: 16) .func
 COMMON-NEXT:       98: 00 00 00 80                    <unknown>
+RELOC:                              00000098:  R_POS        (idx: 18) TOC[TC0]
 COMMON-NEXT:       9c: 00 00 00 00                    <unknown>
 PLAIN:      000000a0 <b>:
 DESC:       000000a0 (idx: 28) b[RW]:
 COMMON-NEXT:       a0: 00 00 30 39                    <unknown>
 COMMON: Disassembly of section .bss:
 PLAIN:      000000a4 <a>:
 DESC:       000000a4 (idx: 24) a[RW]:
 COMMON-NEXT: ...

llvm/test/tools/llvm-objdump/XCOFF/print-reloc.test

 # REQUIRES: powerpc-registered-target
 
 # RUN: llvm-objdump -r %p/Inputs/xcoff-section-headers.o | \
 # RUN:   FileCheck --match-full-lines --strict-whitespace %s
 
+# RUN: llvm-objdump -r --symbol-description %p/Inputs/xcoff-section-headers.o | \
+# RUN:   FileCheck --match-full-lines --strict-whitespace --check-prefix=DESCP %s
+
 ## xcoff-section-headers.o Compiled with IBM XL C/C++ for AIX, V16.1.0
 ## compiler command: xlc -qtls -o xcoff-section-headers.o -c test.c
 ## test.c:
 ## int a;
 ## int b = 12345;
 ## __thread int c;
 ## __thread double d = 3.14159;
 ##

  CHECK-NEXT:00000000 R_POS                    func
  CHECK-NEXT:00000004 R_POS                    a
  CHECK-NEXT:00000008 R_POS                    b
  CHECK-NEXT:0000000c R_TLS                    c
  CHECK-NEXT:00000010 R_TLS                    d
  CHECK-NEXT:00000014 R_POS                    .func
  CHECK-NEXT:00000018 R_POS                    TOC
 CHECK-EMPTY:
+
+      DESCP:RELOCATION RECORDS FOR [.text]:
+ DESCP-NEXT:OFFSET   TYPE                     VALUE
+ DESCP-NEXT:00000002 R_TOC                    (idx: 26) a[TC]
+DESCP-EMPTY:
+      DESCP:RELOCATION RECORDS FOR [.data]:
+ DESCP-NEXT:OFFSET   TYPE                     VALUE
+ DESCP-NEXT:00000000 R_POS                    (idx: 20) func[DS]
+ DESCP-NEXT:00000004 R_POS                    (idx: 24) a[RW]
+ DESCP-NEXT:00000008 R_POS                    (idx: 28) b[RW]
+ DESCP-NEXT:0000000c R_TLS                    (idx: 32) c[UL]
+ DESCP-NEXT:00000010 R_TLS                    (idx: 36) d[TL]
+ DESCP-NEXT:00000014 R_POS                    (idx: 16) .func
+ DESCP-NEXT:00000018 R_POS                    (idx: 18) TOC[TC0]
+DESCP-EMPTY:

llvm/tools/llvm-objdump/XCOFFDump.h

 
 namespace objdump {
 Optional<XCOFF::StorageMappingClass>
 getXCOFFSymbolCsectSMC(const object::XCOFFObjectFile *Obj,
                        const object::SymbolRef &Sym);
 
 bool isLabel(const object::XCOFFObjectFile *Obj, const object::SymbolRef &Sym);
 
-void printXCOFFSymbolDescription(const SymbolInfoTy &SymbolInfo,
+std::string getXCOFFSymbolDescription(const SymbolInfoTy &SymbolInfo,
                                       StringRef SymbolName);
 
 Error getXCOFFRelocationValueString(const object::XCOFFObjectFile *Obj,
                                     const object::RelocationRef &RelRef,
                                     llvm::SmallVectorImpl<char> &Result);
 } // namespace objdump
 } // namespace llvm
 #endif

llvm/tools/llvm-objdump/XCOFFDump.cpp

 //===-- XCOFFDump.cpp - XCOFF-specific dumper -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the XCOFF-specific dumper for llvm-objdump.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "XCOFFDump.h"
-#include "llvm/MC/MCDisassembler/MCDisassembler.h"
+
+#include "llvm-objdump.h"
+#include "llvm/Demangle/Demangle.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 Error objdump::getXCOFFRelocationValueString(const XCOFFObjectFile *Obj,
                                              const RelocationRef &Rel,
                                              SmallVectorImpl<char> &Result) {
   symbol_iterator SymI = Rel.getSymbol();
   if (SymI == Obj->symbol_end())
     return make_error<GenericBinaryError>(
         "invalid symbol reference in relocation entry",
         object_error::parse_failed);
 
   Expected<StringRef> SymNameOrErr = SymI->getName();
   if (!SymNameOrErr)
     return SymNameOrErr.takeError();
-  StringRef SymName = *SymNameOrErr;
+
+  std::string SymName = (*SymNameOrErr).str();
+  if (Demangle)
+    SymName = demangle(SymName);
+
+  if (SymbolDescription)
+    SymName = getXCOFFSymbolDescription(createSymbolInfo(Obj, *SymI), SymName);
+
   Result.append(SymName.begin(), SymName.end());
   return Error::success();
 }
 
 Optional<XCOFF::StorageMappingClass>
 objdump::getXCOFFSymbolCsectSMC(const XCOFFObjectFile *Obj,
                                 const SymbolRef &Sym) {
   XCOFFSymbolRef SymRef(Sym.getRawDataRefImpl(), Obj);
bool objdump::isLabel(const XCOFFObjectFile *Obj, const SymbolRef &Sym) {
   XCOFFSymbolRef SymRef(Sym.getRawDataRefImpl(), Obj);
 
   if (SymRef.hasCsectAuxEnt())
     return SymRef.getXCOFFCsectAuxEnt32()->isLabel();
 
   return false;
 }
 
-void objdump::printXCOFFSymbolDescription(const SymbolInfoTy &SymbolInfo,
+std::string objdump::getXCOFFSymbolDescription(const SymbolInfoTy &SymbolInfo,
                                                StringRef SymbolName) {
   assert(SymbolInfo.isXCOFF() && "Must be a XCOFFSymInfo.");
-
+  std::string Result;
   // Dummy symbols have no symbol index.
   if (SymbolInfo.XCOFFSymInfo.Index)
-    outs() << "(idx: " << SymbolInfo.XCOFFSymInfo.Index.getValue() << ") ";
+    Result = std::string("(idx: ") +
+             std::to_string(SymbolInfo.XCOFFSymInfo.Index.getValue()) +
+             std::string(") ");
 
-  outs() << SymbolName;
+  Result.append(SymbolName.str());
 
   if (SymbolInfo.XCOFFSymInfo.StorageMappingClass &&
       !SymbolInfo.XCOFFSymInfo.IsLabel) {
     const XCOFF::StorageMappingClass Smc =
         SymbolInfo.XCOFFSymInfo.StorageMappingClass.getValue();
-    outs() << "[" << XCOFF::getMappingClassString(Smc) << "]";
+    Result.append(std::string("[") +
+                  std::string(XCOFF::getMappingClassString(Smc)) +
+                  std::string("]"));
   }
+
+  return Result;
 }

llvm/tools/llvm-objdump/llvm-objdump.h

 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_OBJDUMP_LLVM_OBJDUMP_H
 #define LLVM_TOOLS_LLVM_OBJDUMP_LLVM_OBJDUMP_H
 
 #include "llvm/ADT/StringSet.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 class StringRef;
 

 extern cl::opt<std::string> MCPU;
 extern cl::opt<bool> NoShowRawInsn;
 extern cl::opt<bool> NoLeadingAddr;
 extern cl::opt<bool> PrintImmHex;
 extern cl::opt<bool> PrivateHeaders;
 extern cl::opt<bool> Relocations;
 extern cl::opt<bool> SectionHeaders;
 extern cl::opt<bool> SectionContents;
+extern cl::opt<bool> SymbolDescription;
 extern cl::opt<bool> SymbolTable;
 extern cl::opt<std::string> TripleName;
 extern cl::opt<bool> UnwindInfo;
 
 extern StringSet<> FoundSectionSet;
 
 } // namespace objdump
 

 T unwrapOrError(Expected<T> EO, Ts &&... Args) {
   if (EO)
     return std::move(*EO);
   reportError(EO.takeError(), std::forward<Ts>(Args)...);
 }
 
 std::string getFileNameForError(const object::Archive::Child &C,
                                 unsigned Index);
+SymbolInfoTy createSymbolInfo(const object::ObjectFile *Obj,
+                              const object::SymbolRef &Symbol);
 
 } // end namespace llvm
 
 #endif

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

cl::opt<bool> objdump::DisassembleAll(
     "disassemble-all",
     cl::desc("Display assembler mnemonics for the machine instructions"),
     cl::cat(ObjdumpCat));
 static cl::alias DisassembleAllShort("D",
                                      cl::desc("Alias for --disassemble-all"),
                                      cl::NotHidden, cl::Grouping,
                                      cl::aliasopt(DisassembleAll));
 
-static cl::opt<bool>
-    SymbolDescription("symbol-description",
-                      cl::desc("Add symbol description for disassembly. This "
-                               "option is for XCOFF files only"),
-                      cl::init(false), cl::cat(ObjdumpCat));
+cl::opt<bool> objdump::SymbolDescription(
+    "symbol-description",
 
 static cl::list<std::string>
     DisassembleSymbols("disassemble-symbols", cl::CommaSeparated,
                        cl::desc("List of symbols to disassemble. "
                                 "Accept demangled names when --demangle is "
                                 "specified, otherwise accept mangled names"),
                        cl::cat(ObjdumpCat));
 
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
         }
       }
 
       outs() << '\n';
       if (!NoLeadingAddr)
         outs() << format(Is64Bits ? "%016" PRIx64 " " : "%08" PRIx64 " ",
                          SectionAddr + Start + VMAAdjustment);
       if (Obj->isXCOFF() && SymbolDescription) {
-        printXCOFFSymbolDescription(Symbols[SI], SymbolName);
-        outs() << ":\n";
+        outs() << getXCOFFSymbolDescription(Symbols[SI], 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.
       if (Section.isVirtual()) {
         outs() << "...\n";
         continue;