[llvm-objdump] - Demangle the symbols when printing symbol table and relocations.

[grimar]

Summary

This is https://bugs.llvm.org/show_bug.cgi?id=40009,

llvm-objdump does not demangle the symbols when prints symbol
table and/or relocations.

Patch teaches it to do that.

[jhenderson]

Can you confirm is the following case is covered by this change? Inline listing of relocations when dumping disassembly (i.e. -d -r) also print the symbol name.

LGTM, if it does.

test/tools/llvm-objdump/X86/demangle.s

5

print -> printing

8

Ditto.

[grimar]

Thanks, James! Yes, it works, I updated the test case.

[jhenderson]

Okay, great! LGTM with the updates.

test/tools/llvm-objdump/X86/demangle.s

+# RUN: llvm-mc %s -filetype=obj -triple=x86_64-pc-linux -o %t
+# RUN: llvm-objdump -syms -reloc -demangle %t | FileCheck %s
+
+## Check we demangle symbols when printing relocations.
+# CHECK:      000000000000001 R_X86_64_PLT32 foo()-4
+
+## Check we demangle symbols when printing symbol table.
+# CHECK:      SYMBOL TABLE:
+# CHECK-NEXT: 0000000000000000         *UND*           00000000
+# CHECK-NEXT: 0000000000000000 g     F .text           00000000 foo()
+
+## Check the case when relocations are inlined into disassembly.
+# RUN: llvm-objdump -d -r -demangle %t | FileCheck %s --check-prefix=INLINE
+# INLINE:      Disassembly of section .text:
+# INLINE-NEXT: foo():
+# INLINE-NEXT:  0: {{.*}}  callq   0 <_Z3foov+0x5>
+# INLINE-NEXT:  0000000000000001:  R_X86_64_PLT32 foo()-4
+
+.text
+.globl _Z3foov
+.type _Z3foov,@function
+_Z3foov:
+ callq _Z3foov@PLT

tools/llvm-objdump/llvm-objdump.cpp

static std::error_code getRelocationValueString(const ELFObjectFile<ELFT> *Obj,
   }
   case ELF::SHT_RELA: {
     const Elf_Rela *ERela = Obj->getRela(Rel);
     addend = ERela->r_addend;
     undef = ERela->getSymbol(false) == 0;
     break;
   }
   }
-  StringRef Target;
+  std::string Target;
   if (!undef) {
     symbol_iterator SI = RelRef.getSymbol();
     const Elf_Sym *symb = Obj->getSymbol(SI->getRawDataRefImpl());
     if (symb->getType() == ELF::STT_SECTION) {
       Expected<section_iterator> SymSI = SI->getSection();
       if (!SymSI)
         return errorToErrorCode(SymSI.takeError());
       const Elf_Shdr *SymSec = Obj->getSection((*SymSI)->getRawDataRefImpl());
       auto SecName = EF.getSectionName(SymSec);
       if (!SecName)
         return errorToErrorCode(SecName.takeError());
       Target = *SecName;
     } else {
       Expected<StringRef> SymName = symb->getName(StrTab);
       if (!SymName)
         return errorToErrorCode(SymName.takeError());
-      Target = *SymName;
+      Target = Demangle ? demangle(*SymName) : *SymName;
     }
   } else
     Target = "*ABS*";
 
   // Default scheme is to print Target, as well as "+ <addend>" for nonzero
   // addend. Should be acceptable for all normal purposes.
   std::string fmtbuf;
   raw_string_ostream fmt(fmtbuf);
for (auto PltEntry : ElfObj->getPltAddresses()) {
         continue;
       StringRef Name = Saver.save((*NameOrErr + "@plt").str());
 
       AllSymbols[*Plt].emplace_back(PltEntry.second, Name, SymbolType);
     }
   }
 }
 
+static std::string demangle(StringRef Name) {
+  char *Demangled = nullptr;
+  size_t Size = 0;
+  if (Name.startswith("_Z"))
+    Demangled = itaniumDemangle(Name.data(), Demangled, &Size, nullptr);
+  else if (Name.startswith("?"))
+    Demangled = microsoftDemangle(Name.data(), Demangled, &Size, nullptr);
+
+  if (!Demangled)
+    return Name;
+
+  std::string Ret = Demangled;
+  free(Demangled);
+  return Ret;
+}
+
 static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
   if (StartAddress > StopAddress)
     error("Start address should be less than stop address");
 
   const Target *TheTarget = getTarget(Obj);
 
   // Package up features to be passed to target/subtarget
   SubtargetFeatures Features = Obj->getFeatures();
for (unsigned si = 0, se = Symbols.size(); si != se; ++si) {
           const uint64_t EndAlign = 256;
           const auto Limit = End - (std::min)(EndAlign, End - Start);
           while (End > Limit &&
             *reinterpret_cast<const support::ulittle32_t*>(&Bytes[End - 4]) == 0)
             End -= 4;
         }
       }
 
-      auto PrintSymbol = [](StringRef Name) {
-        outs() << '\n' << Name << ":\n";
-      };
+      outs() << '\n';
       StringRef SymbolName = std::get<1>(Symbols[si]);
-      if (Demangle) {
-        char *DemangledSymbol = nullptr;
-        size_t Size = 0;
-        int Status = -1;
-        if (SymbolName.startswith("_Z"))
-          DemangledSymbol = itaniumDemangle(SymbolName.data(), DemangledSymbol,
-                                            &Size, &Status);
-        else if (SymbolName.startswith("?"))
-          DemangledSymbol = microsoftDemangle(SymbolName.data(),
-                                              DemangledSymbol, &Size, &Status);
-
-        if (Status == 0 && DemangledSymbol)
-          PrintSymbol(StringRef(DemangledSymbol));
-        else
-          PrintSymbol(SymbolName);
-
-        if (DemangledSymbol)
-          free(DemangledSymbol);
-      } else
-        PrintSymbol(SymbolName);
+      if (Demangle)
+        outs() << demangle(SymbolName) << ":\n";
+        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;
       }
 
if (Common || isa<ELFObjectFileBase>(o)) {
       uint64_t Val =
           Common ? Symbol.getAlignment() : ELFSymbolRef(Symbol).getSize();
       outs() << format("\t %08" PRIx64 " ", Val);
     }
 
     if (Hidden) {
       outs() << ".hidden ";
     }
-    outs() << Name
-           << '\n';
+
+    if (Demangle)
+      outs() << demangle(Name) << '\n';
+    else
+      outs() << Name << '\n';
   }
 }
 
 static void PrintUnwindInfo(const ObjectFile *o) {
   outs() << "Unwind info:\n\n";
 
   if (const COFFObjectFile *coff = dyn_cast<COFFObjectFile>(o)) {
     printCOFFUnwindInfo(coff);