[llvm-readobj][ELF]Add demangling support

[jhenderson]

Summary

This change adds demangling support to the ELF side of llvm-readobj, under the switch --demangle/-C. It relies on a refactor proposed in D56721.

The following places are demangled: symbol table dumps (static and dynamic), relocation dumps (static and dynamic), addrsig dumps, call graph profile dumps, and group sections.

Although GNU readelf doesn't support demangling, it is still a useful feature to have, and brings it on a par with llvm-objdump's capabilities.

This fixes https://bugs.llvm.org/show_bug.cgi?id=40054.

[jhenderson]

Add documentation update.

(The documentation is already missing many options, but I might as well avoid making it worse!)

[rupprecht]

test/tools/llvm-readobj/demangle.test

26

This is a really annoying nit, but could you indent the expected side so it reads more easily, vs being indented based on how long the check prefix is? e.g. for this block:

# LLVMCOMMON:       xRelocations [
# LLVMCOMMON:       x  Section {{.*}} .rela.text.foo {
# LLVMDEMANGLE-NEXT:x    {{ }}foo(char){{ }}
# LLVMMANGLED-NEXT: x    {{ }}_Z3fooc{{ }}
# LLVMCOMMON-NEXT:  x  }
# LLVMCOMMON:       x]

(x's for clarity, showing the margin)

[grimar]

test/tools/llvm-readobj/demangle.test

14

I already saw such way (using 'diff' tool) just recently somewhere in LLVM mails,
but I am not sure what is the benefit of doing that? I mean isn't it easier to do in the usual way:

# RUN: llvm-readobj --symbols --relocations --dyn-symbols --dyn-relocations \
# RUN:              --elf-section-groups --elf-cg-profile --addrsig         \
# RUN:              --demangle %t.so | FileCheck %s --check-prefixes=LLVMCOMMON,LLVMDEMANGLE
# RUN: llvm-readobj --symbols --relocations --dyn-symbols --dyn-relocations \
# RUN:              --elf-section-groups --elf-cg-profile --addrsig         \
# RUN:              -C --demangle %t.so | FileCheck %s --check-prefixes=LLVMCOMMON,LLVMDEMANGLE

That would avoid creating 2 files and calling the diff. And since calling tools and creating files affect on a
speed of the test execution, I think it is good to try to reduce it.

I am not sure it is really worth to compare the whole output between the option and its alias.
I just think it is not common and a bit excessive.

67

I would suggest to remove LLVMCOMMON and just use LLVMDEMANGLE/LLVMMANGLED, something like:

...
# LLVMDEMANGLE:           Addrsig [
# LLVMDEMANGLE-NEXT:   Sym: foo(char){{ }}
# LLVMDEMANGLE-NEXT:   Sym: blah(float){{ }}
# LLVMDEMANGLE-NEXT:  ]
...

...
# LLVMMANGLED:           Addrsig [
# LLVMMANGLED-NEXT:   Sym: foo(char){{ }}
# LLVMMANGLED-NEXT:   Sym: blah(float){{ }}
# LLVMMANGLED-NEXT:  ]
...

(I think introducing 3 tags for a FileCheck call is unnecessary overcomplication here, it should look and read simpler if you have only 2).

206

Does not seem you need .llvm_addrsig or .llvm.call-graph-profile? Could you reduce the yaml to keep only important parts?

218

The same, seems you do not need it.

tools/llvm-readobj/llvm-readobj.cpp

191

I noticed a small inconsistency in llvm-objdump about printing/not-printing the aliased with -help.
Seems they should only be printed witch -help-hidden, but atm two of them are always printed.
I was going to suggest a patch for this.

Seems you should not use cl::NotHidden here?

[jhenderson]

test/tools/llvm-readobj/demangle.test

14

That's actually four tool calls (llvm-readobj x 2 + FileCheck x 2). This approach is the same number of calls (llvm-readobj x 2 + FileCheck + diff). I don't know, but I wouldn't be surprised if diff is as fast as the second FileCheck run, although I see your point about creating the extra files (although I doubt it makes more than a small fraction of a second difference).

I personally have a marginal preference for this approach overall, as I think it's a little easier to read, and has the potential to catch odd bugs, but I don't feel strongly about it, and would change it to progress the review. However, a more important issue is consistency. Due to the bug in llvm-readelf mentioned in the test below, the GNU output has to use a single file across multiple runs (or to run FileCheck twice). As that already pipes to a file, keeping the LLVM ones piping to a file helps keep things consistent.

26

Sure. I'm the king of nit-picking, so feel free to pick at them however minor they may seem!

67

Whilst for the Addrsig bit, it's not too bad, I and a colleague found it much less readable for things like the relocation dumps. It also is less maintainable if we ever change the format slightly, as it requires updating two different places. Finally, it is harder to see where the actual differences are if written as you've suggested.

I think with the fix suggested by @rupprecht, and one small tweak (adding a '-' between LLVM/GNU and COMMON etc.) it is a little clearer and easier to distinguish the prefixes.

206

They are needed to test the demangling of symbols in those two dumps. If they aren't in the yaml, they won't be tested (and they go through a separate call path to the other symbol names, so it's not like we're duplicating coverage).

218

llvm-readobj looks up dynamic data from the PT_DYNAMIC segment, not the .dynamic section, and uses that to dump dynamic relocations (who have a separate method for printing to static relocations, so need testing separately). The address information is dependent on the PT_LOAD the sections are in, hence we need both segments.

tools/llvm-readobj/llvm-readobj.cpp

191

I agree it's inconsistent, and I'd like to improve that, but I'd actually lean towards having short options in the main help text, not just help-hidden. If you see a usage of "-C" (or whatever) in a build script, and it's not visible in the help text, it could be confusing for users unfamiliar with the tool. Putting it under -help-hidden doesn't help, because this is not a normal (outside LLVM) way of getting short alias information.

[jhenderson]

Improve readability of test with improved indentation and renaming LLVM/GNU* to LLVM-/GNU-*

[grimar]

Thanks for the answers, James. LGTM.

test/tools/llvm-readobj/demangle.test

14

(although I doubt it makes more than a small fraction of a second difference).

Yes, but check-llvm already might take minutes to finish :) More tests - more slowdown.

I am OK with it as is.

16

nit: full stop is missing.

206

Oops, indeed I did not notice you are using them. Sorry.

tools/llvm-readobj/llvm-readobj.cpp

191

That sounds good. I was not sure what the way will be preferred (I supposed hiding aliases was intentional), but for me, it would be more convenient to see them under -help (that was why I found this initially, I did not see the lines I would expect to see, but saw the other lines at the same time).

[jhenderson]

Add missing full stops. Thanks @grimar and @rupprecht. I'll commit this once my slow Linux machine has finished checking another commit.

[jhenderson]

Rebase on the latest version of D56721.

[jhenderson]

tools/llvm-readobj/ELFDumper.cpp

800

This line didn't compile with my GCC build. I had to change it to:

return opts::Demangle ? demangle(Name) : Name.str();

docs/CommandGuide/llvm-readobj.rst

 .. option:: -program-headers
 
  Display the ELF program headers (only for ELF object files).
 
 .. option:: -elf-section-groups, -g
 
  Display section groups (only for ELF object files).
 
+.. option:: -demangle, -C
+
+ Print demangled symbol names in the output.
+
 EXIT STATUS
 -----------
 
 :program:`llvm-readobj` returns 0.

test/tools/llvm-readobj/demangle.test

+## Show that llvm-readelf + llvm-readobj demangle symbol names in symbol tables
+## (including dynamic symbols), relocations (including dynamic relocations), and groups.
+
+# RUN: yaml2obj %s > %t.so
+
+## Check LLVM output style.
+# RUN: llvm-readobj --symbols --relocations --dyn-symbols --dyn-relocations \
+# RUN:              --elf-section-groups --elf-cg-profile --addrsig         \
+# RUN:              --demangle %t.so > %t.llvm.long
+# RUN: llvm-readobj --symbols --relocations --dyn-symbols --dyn-relocations \
+# RUN:              --elf-section-groups --elf-cg-profile --addrsig         \
+# RUN:              -C %t.so > %t.llvm.short
+# RUN: FileCheck %s --input-file %t.llvm.long --check-prefixes=LLVMCOMMON,LLVMDEMANGLE
+# RUN: diff %t.llvm.long %t.llvm.short
+
+## Check that default is no demangling
+# RUN: llvm-readobj --symbols --relocations --dyn-symbols --dyn-relocations \
+# RUN:              --elf-section-groups --elf-cg-profile --addrsig         \
+# RUN:              %t.so > %t.llvm.default
+# RUN: llvm-readobj --symbols --relocations --dyn-symbols --dyn-relocations \
+# RUN:              --elf-section-groups --elf-cg-profile --addrsig         \
+# RUN:              --demangle=false %t.so > %t.llvm.nodemangle
+# RUN: FileCheck %s --input-file %t.llvm.default --check-prefixes=LLVMCOMMON,LLVMMANGLED
+# RUN: diff %t.llvm.default %t.llvm.nodemangle
+
+# LLVMCOMMON: Relocations [
+# LLVMCOMMON:      Section {{.*}} .rela.text.foo {
+# LLVMDEMANGLE-NEXT: {{ }}foo(char){{ }}
+# LLVMMANGLED-NEXT:  {{ }}_Z3fooc{{ }}
+# LLVMCOMMON-NEXT: }
+# LLVMCOMMON: ]
+
+# LLVMCOMMON: Dynamic Relocations {
+# LLVMDEMANGLE-NEXT: {{ }}foo(int){{ }}
+# LLVMMANGLED-NEXT:  {{ }}_Z3fooi{{ }}
+# LLVMCOMMON-NEXT: }
+
+# LLVMCOMMON: Symbols [
+# LLVMDEMANGLE:  Name: foo(char){{ }}
+# LLVMDEMANGLE:  Name: blah(float){{ }}
+# LLVMMANGLED:   Name: _Z3fooc{{ }}
+# LLVMMANGLED:   Name: _Z4blahf{{ }}
+# LLVMCOMMON: ]
+
+# LLVMCOMMON: DynamicSymbols [
+# LLVMDEMANGLE: Name: foo(int){{ }}
+# LLVMMANGLED:  Name: _Z3fooi{{ }}
+# LLVMCOMMON: ]
+
+# LLVMCOMMON: Groups {
+# LLVMDEMANGLE:  Signature: foo(char){{$}}
+# LLVMMANGLED:   Signature: _Z3fooc{{$}}
+# LLVMCOMMON: }
+
+# LLVMCOMMON: CGProfile [
+# LLVMDEMANGLE: From: foo(char){{ }}
+# LLVMDEMANGLE: To:   blah(float){{ }}
+# LLVMMANGLED:  From: _Z3fooc{{ }}
+# LLVMMANGLED:  To:   _Z4blahf{{ }}
+# LLVMCOMMON: ]
+
+# LLVMCOMMON: Addrsig [
+# LLVMDEMANGLE-NEXT: Sym: foo(char){{ }}
+# LLVMDEMANGLE-NEXT: Sym: blah(float){{ }}
+# LLVMMANGLED-NEXT:  Sym: _Z3fooc{{ }}
+# LLVMMANGLED-NEXT:  Sym: _Z4blahf{{ }}
+# LLVMCOMMON-NEXT: ]
+
+## Check GNU output style.
+## FIXME: The extra run for --symbols is because GNU mode only prints the dynamic symbols,
+## if --dyn-symbols is specified, even if --symbols is specified.
+# RUN: llvm-readelf --relocations --dyn-symbols --dyn-relocations \
+# RUN:              --elf-section-groups --demangle %t.so > %t.gnu.long
+# RUN: llvm-readelf --symbols --demangle %t.so >> %t.gnu.long
+# RUN: llvm-readelf --relocations --dyn-symbols --dyn-relocations \
+# RUN:              --elf-section-groups -C %t.so > %t.gnu.short
+# RUN: llvm-readelf --symbols -C %t.so >> %t.gnu.short
+# RUN: FileCheck %s --input-file %t.gnu.long --check-prefixes=GNUCOMMON,GNUDEMANGLE
+# RUN: diff %t.gnu.long %t.gnu.short
+
+## Check that default is no demangling
+# RUN: llvm-readelf --relocations --dyn-symbols --dyn-relocations \
+# RUN:              --elf-section-groups %t.so > %t.gnu.default
+# RUN: llvm-readelf --symbols %t.so >> %t.gnu.default
+# RUN: llvm-readelf --relocations --dyn-symbols --dyn-relocations \
+# RUN:              --elf-section-groups --demangle=false %t.so > %t.gnu.nodemangle
+# RUN: llvm-readelf --symbols --demangle=false %t.so >> %t.gnu.nodemangle
+# RUN: FileCheck %s --input-file %t.gnu.default --check-prefixes=GNUCOMMON,GNUMANGLED
+# RUN: diff %t.gnu.default %t.gnu.nodemangle
+
+# GNUCOMMON:      Relocation section '.rela.text.foo' at offset {{.*}} contains 1 entries:
+# GNUCOMMON-NEXT:   Offset Info Type Symbol's Value Symbol's Name + Addend
+# GNUDEMANGLE-NEXT: foo(char){{ }}
+# GNUMANGLED-NEXT: _Z3fooc{{ }}
+
+# GNUCOMMON: 'RELA' relocation section at offset {{.*}} contains 24 bytes:
+# GNUCOMMON-NEXT: Offset Info Type Symbol's Value Symbol's Name + Addend
+# GNUDEMANGLE-NEXT: foo(int){{ }}
+# GNUMANGLED-NEXT: _Z3fooi{{ }}
+
+# GNUCOMMON: Symbol table '.dynsym' contains 2 entries:
+# GNUCOMMON-NEXT: Num: Value            Size Type   Bind  Vis     Ndx Name
+# GNUCOMMON-NEXT:   0: 0000000000000000    0 NOTYPE LOCAL DEFAULT UND
+# GNUDEMANGLE-NEXT: foo(int){{$}}
+# GNUMANGLED-NEXT:  _Z3fooi{{$}}
+
+# GNUCOMMON: COMDAT group section [{{.*}}] `.group'
+# GNUDEMANGLE-SAME: [foo(char)]
+# GNUMANGLED-SAME:  [_Z3fooc]
+
+# GNUCOMMON: Symbol table '.symtab' contains 3 entries:
+# GNUCOMMON-NEXT: Num: Value            Size Type   Bind  Vis     Ndx Name
+# GNUCOMMON-NEXT:   0: 0000000000000000    0 NOTYPE LOCAL DEFAULT UND
+# GNUDEMANGLE-NEXT: foo(char){{$}}
+# GNUDEMANGLE-NEXT: blah(float){{$}}
+# GNUMANGLED-NEXT:  _Z3fooc{{$}}
+# GNUMANGLED-NEXT:  _Z4blahf{{$}}
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_X86_64
+Sections:
+  ## TODO:  Replace the raw section contents with more meaningful dynamic
+  ## tags/symbols/etc, once yaml2obj supports it.
+  ## FIXME: yaml2obj does not currently allow custom addresses for .dynstr and
+  ## .dynsym if DynamicSymbols are specified.
+  ## See https://bugs.llvm.org/show_bug.cgi?id=40339
+  - Name:         .dynstr
+    Type:         SHT_STRTAB
+    Flags:        [ SHF_ALLOC ]
+    AddressAlign: 0x100
+    EntSize:      0x1
+    ## "\0_Z3fooi\0"
+    Content: "005f5a33666f6f6900"
+  - Name:         .dynsym
+    Type:         SHT_DYNSYM
+    Flags:        [ SHF_ALLOC ]
+    Link:         .dynstr
+    Info:         1
+    Address:      0x100
+    AddressAlign: 0x100
+    EntSize:      0x18
+    ## Null symbol;
+    ## st_name: 1; st_info: Global | Func; st_other: 0;
+    ##   st_shndx: .text.foo; st_value: 0x2000; st_size: 0
+    Content: "000000000000000000000000000000000000000000000000010000001200050000200000000000000000000000000000"
+  - Name:         .rela.dyn
+    Type:         SHT_RELA
+    Flags:        [ SHF_ALLOC ]
+    Link:         .dynsym
+    Info:         .text.foo
+    Address:      0x200
+    AddressAlign: 0x100
+    EntSize:      0x18
+    Relocations:
+      - Offset: 0x10
+        ## FIXME: This should be a lookup in the corresponding symbol table, not necessarily the static symbol table.
+        ## See https://bugs.llvm.org/show_bug.cgi?id=40337.
+        Symbol: _Z3fooc
+        Type:   R_X86_64_PC32
+        Addend: 0x4
+  - Name:         .dynamic
+    Type:         SHT_DYNAMIC
+    Flags:        [ SHF_ALLOC ]
+    Link:         .dynstr
+    Address:      0x1000
+    AddressAlign: 0x1000
+    ## DT_STRTAB  - 0x0
+    ## DT_STRSZ   - 0x9
+    ## DT_SYMTAB  - 0x100
+    ## DT_SYMENT  - 0x18
+    ## DT_RELA    - 0x200
+    ## DT_RELASZ  - 0x18
+    ## DT_RELAENT - 0x18
+    ## DT_NULL    - 0x0
+    Content: "050000000000000000000000000000000a000000000000000900000000000000060000000000000000010000000000000b00000000000000180000000000000007000000000000000002000000000000080000000000000018000000000000000900000000000000180000000000000000000000000000000000000000000000"
+  - Name:  .text.foo
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC, SHF_EXECINSTR, SHF_GROUP ]
+    Size:  0x40
+    Address: 0x2000
+    AddressAlign: 0x2000
+  - Name:  .group
+    Type:  SHT_GROUP
+    Link:  .symtab
+    Info:  _Z3fooc
+    Members:
+      - SectionOrType: GRP_COMDAT
+      - SectionOrType: .text.foo
+  - Name: .rela.text.foo
+    Type: SHT_RELA
+    Link: .symtab
+    Info: .text.foo
+    Relocations:
+      - Offset: 0x10
+        Symbol: _Z3fooc
+        Type:   R_X86_64_PC32
+  - Name: .llvm.call-graph-profile
+    Type: SHT_LLVM_CALL_GRAPH_PROFILE
+    Link: .symtab
+    EntSize: 16
+    Content: "01000000020000002000000000000000"
+  - Name: .llvm_addrsig
+    Type: SHT_LLVM_ADDRSIG
+    Link: .symtab
+    Content: "0102"
+Symbols:
+  Global:
+    - Name:    _Z3fooc
+      Type:    STT_FUNC
+      Section: .text.foo
+    - Name:    _Z4blahf
+      Type:    STT_FUNC
+      Section: .text.foo
+ProgramHeaders:
+  - Type:  PT_LOAD
+    Flags: [ PF_R, PF_X ]
+    VAddr: 0x0
+    PAddr: 0x0
+    Sections:
+      - Section: .dynsym
+      - Section: .dynstr
+      - Section: .rela.dyn
+      - Section: .dynamic
+      - Section: .text.foo
+  - Type:  PT_DYNAMIC
+    Flags: [ PF_R ]
+    VAddr: 0x1000
+    PAddr: 0x1000
+    Sections:
+      - Section: .dynamic

tools/llvm-readobj/ELFDumper.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Demangle/Demangle.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ELFTypes.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/StackMapParser.h"
 #include "llvm/Support/AMDGPUMetadata.h"
 #include "llvm/Support/ARMAttributeParser.h"
public:
   Elf_Rel_Range dyn_rels() const;
   Elf_Rela_Range dyn_relas() const;
   Elf_Relr_Range dyn_relrs() const;
   std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable,
                                 bool IsDynamic) const;
   void getSectionNameIndex(const Elf_Sym *Symbol, const Elf_Sym *FirstSym,
                            StringRef &SectionName,
                            unsigned &SectionIndex) const;
-  StringRef getStaticSymbolName(uint32_t Index) const;
+  std::string getStaticSymbolName(uint32_t Index) const;
 
   void printSymbolsHelper(bool IsDynamic) const;
   const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; }
   const Elf_Shdr *getDotCGProfileSec() const { return DotCGProfileSec; }
   const Elf_Shdr *getDotAddrsigSec() const { return DotAddrsigSec; }
   ArrayRef<Elf_Word> getShndxTable() const { return ShndxTable; }
   StringRef getDynamicStringTable() const { return DynamicStringTable; }
   const DynRegionInfo &getDynRelRegion() const { return DynRelRegion; }
if (entry.isVerdef()) {
     name_offset = entry.getVernaux()->vna_name;
     IsDefault = false;
   }
   if (name_offset >= StrTab.size())
     reportError("Invalid string offset");
   return StringRef(StrTab.data() + name_offset);
 }
 
+static std::string maybeDemangle(StringRef Name) {
+  return opts::Demangle ? demangle(Name.data()) : Name;
+}
+
 template <typename ELFT>
-StringRef ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const {
+std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const {
   const ELFFile<ELFT> *Obj = ObjF->getELFFile();
   StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*DotSymtabSec));
   Elf_Sym_Range Syms = unwrapOrError(Obj->symbols(DotSymtabSec));
   if (Index >= Syms.size())
     reportError("Invalid symbol index");
   const Elf_Sym *Sym = &Syms[Index];
-  return unwrapOrError(Sym->getName(StrTable));
+  return maybeDemangle(unwrapOrError(Sym->getName(StrTable)));
 }
 
 template <typename ELFT>
 std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol,
                                                StringRef StrTable,
                                                bool IsDynamic) const {
-  StringRef SymbolName = unwrapOrError(Symbol->getName(StrTable));
+  std::string SymbolName =
+      maybeDemangle(unwrapOrError(Symbol->getName(StrTable)));
   if (!IsDynamic)
     return SymbolName;
 
-  std::string FullSymbolName(SymbolName);
-
   bool IsDefault;
   StringRef Version = getSymbolVersion(StrTable, &*Symbol, IsDefault);
   if (!Version.empty()) {
-    FullSymbolName += (IsDefault ? "@@" : "@");
-    FullSymbolName += Version;
+    SymbolName += (IsDefault ? "@@" : "@");
+    SymbolName += Version;
   }
-  return FullSymbolName;
+  return SymbolName;
 }
 
 template <typename ELFT>
 void ELFDumper<ELFT>::getSectionNameIndex(const Elf_Sym *Symbol,
                                           const Elf_Sym *FirstSym,
                                           StringRef &SectionName,
                                           unsigned &SectionIndex) const {
   SectionIndex = Symbol->st_shndx;

 namespace {
 struct GroupMember {
   StringRef Name;
   uint64_t Index;
 };
 
 struct GroupSection {
   StringRef Name;
-  StringRef Signature;
+  std::string Signature;
   uint64_t ShName;
   uint64_t Index;
   uint32_t Link;
   uint32_t Info;
   uint32_t Type;
   std::vector<GroupMember> Members;
 };
 
for (const Elf_Shdr &Sec : unwrapOrError(Obj->sections())) {
     StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
     const Elf_Sym *Sym =
         unwrapOrError(Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info));
     auto Data =
         unwrapOrError(Obj->template getSectionContentsAsArray<Elf_Word>(&Sec));
 
     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
     StringRef Signature = StrTable.data() + Sym->st_name;
-    Ret.push_back({Name, 
-                   Signature, 
-                   Sec.sh_name, 
+    Ret.push_back({Name,
+                   maybeDemangle(Signature),
+                   Sec.sh_name,
                    I - 1,
                    Sec.sh_link,
                    Sec.sh_info,
-                   Data[0], 
+                   Data[0],
                    {}});
 
     std::vector<GroupMember> &GM = Ret.back().Members;
     for (uint32_t Ndx : Data.slice(1)) {
       auto Sec = unwrapOrError(Obj->getSection(Ndx));
       const StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
       GM.push_back({Name, Ndx});
     }
if (V.empty())
     OS << "There are no section groups in this file.\n";
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
                                      const Elf_Rela &R, bool IsRela) {
   std::string Offset, Info, Addend, Value;
   SmallString<32> RelocName;
-  StringRef TargetName;
+  std::string TargetName;
   const Elf_Sym *Sym = nullptr;
   unsigned Width = ELFT::Is64Bits ? 16 : 8;
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
 
   // First two fields are bit width dependent. The rest of them are after are
   // fixed width.
   Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias};
   Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName);
   Sym = unwrapOrError(Obj->getRelocationSymbol(&R, SymTab));
   if (Sym && Sym->getType() == ELF::STT_SECTION) {
     const Elf_Shdr *Sec = unwrapOrError(
         Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable()));
     TargetName = unwrapOrError(Obj->getSectionName(Sec));
   } else if (Sym) {
     StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab));
-    TargetName = unwrapOrError(Sym->getName(StrTable));
+    TargetName = maybeDemangle(unwrapOrError(Sym->getName(StrTable)));
   }
 
   if (Sym && IsRela) {
     if (R.r_addend < 0)
       Addend = " - ";
     else
       Addend = " + ";
   }
for (const Elf_Phdr &Phdr : unwrapOrError(Obj->program_headers())) {
     OS.flush();
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela R,
                                             bool IsRela) {
   SmallString<32> RelocName;
-  StringRef SymbolName;
+  std::string SymbolName;
   unsigned Width = ELFT::Is64Bits ? 16 : 8;
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
   // First two fields are bit width dependent. The rest of them are after are
   // fixed width.
   Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias};
 
   uint32_t SymIndex = R.getSymbol(Obj->isMips64EL());
   const Elf_Sym *Sym = this->dumper()->dynamic_symbols().begin() + SymIndex;
   Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName);
-  SymbolName =
-      unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable()));
+  SymbolName = maybeDemangle(
+      unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable())));
   std::string Addend, Info, Offset, Value;
   Offset = to_string(format_hex_no_prefix(R.r_offset, Width));
   Info = to_string(format_hex_no_prefix(R.r_info, Width));
   Value = to_string(format_hex_no_prefix(Sym->getValue(), Width));
   int64_t RelAddend = R.r_addend;
   if (!SymbolName.empty() && IsRela) {
     if (R.r_addend < 0)
       Addend = " - ";
void LLVMStyle<ELFT>::printRelocations(const Elf_Shdr *Sec, const ELFO *Obj) {
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printRelocation(const ELFO *Obj, Elf_Rela Rel,
                                       const Elf_Shdr *SymTab) {
   SmallString<32> RelocName;
   Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
-  StringRef TargetName;
+  std::string TargetName;
   const Elf_Sym *Sym = unwrapOrError(Obj->getRelocationSymbol(&Rel, SymTab));
   if (Sym && Sym->getType() == ELF::STT_SECTION) {
     const Elf_Shdr *Sec = unwrapOrError(
         Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable()));
     TargetName = unwrapOrError(Obj->getSectionName(Sec));
   } else if (Sym) {
     StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab));
-    TargetName = unwrapOrError(Sym->getName(StrTable));
+    TargetName = maybeDemangle(unwrapOrError(Sym->getName(StrTable)));
   }
 
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Rel.r_offset);
     W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
     W.printNumber("Symbol", !TargetName.empty() ? TargetName : "-",
                   Rel.getSymbol(Obj->isMips64EL()));
void LLVMStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
   W.unindent();
   W.startLine() << "}\n";
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel) {
   SmallString<32> RelocName;
   Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
-  StringRef SymbolName;
+  std::string SymbolName;
   uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL());
   const Elf_Sym *Sym = this->dumper()->dynamic_symbols().begin() + SymIndex;
-  SymbolName =
-      unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable()));
+  SymbolName = maybeDemangle(
+      unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable())));
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printHex("Offset", Rel.r_offset);
     W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
     W.printString("Symbol", !SymbolName.empty() ? SymbolName : "-");
     W.printHex("Addend", Rel.r_addend);
   } else {
     raw_ostream &OS = W.startLine();

tools/llvm-readobj/llvm-readobj.h

 namespace opts {
   extern llvm::cl::opt<bool> SectionRelocations;
   extern llvm::cl::opt<bool> SectionSymbols;
   extern llvm::cl::opt<bool> SectionData;
   extern llvm::cl::opt<bool> DynamicSymbols;
   extern llvm::cl::opt<bool> ExpandRelocs;
   extern llvm::cl::opt<bool> RawRelr;
   extern llvm::cl::opt<bool> CodeViewSubsectionBytes;
+  extern llvm::cl::opt<bool> Demangle;
   enum OutputStyleTy { LLVM, GNU };
   extern llvm::cl::opt<OutputStyleTy> Output;
 } // namespace opts
 
 #define LLVM_READOBJ_ENUM_ENT(ns, enum) \
   { #enum, ns::enum }
 
 #define LLVM_READOBJ_ENUM_CLASS_ENT(enum_class, enum) \
   { #enum, std::underlying_type<enum_class>::type(enum_class::enum) }
 
 #endif

tools/llvm-readobj/llvm-readobj.cpp

cl::alias StringDumpShort("p", cl::desc("Alias for --string-dump"),
                             cl::aliasopt(StringDump));
 
   // -hex-dump, -x
   cl::list<std::string> HexDump("hex-dump", cl::desc("<number|name>"),
                                 cl::ZeroOrMore);
   cl::alias HexDumpShort("x", cl::desc("Alias for --hex-dump"),
                          cl::aliasopt(HexDump));
 
+  // -demangle, -C
+  cl::opt<bool> Demangle("demangle",
+                         cl::desc("Demangle symbol names in output"));
+  cl::alias DemangleShort("C", cl::desc("Alias for --demangle"),
+                          cl::aliasopt(Demangle), cl::NotHidden);
+
   // -hash-table
   cl::opt<bool> HashTable("hash-table",
     cl::desc("Display ELF hash table"));
 
   // -gnu-hash-table
   cl::opt<bool> GnuHashTable("gnu-hash-table",
     cl::desc("Display ELF .gnu.hash section"));