llvm-nm: Add suport for symbol demangling (-C/--demangle)

[sbc100]

• add test

[davide]

See the comment inline. If you have an example of mangled symbols starting with ___Z, you might consider adding a test for it.

tools/llvm-nm/llvm-nm.cpp

668–669 ↗

(On Diff #104222)

I'm aware that Itanium mangled symbols start with _Z but I'm not aware of the ___Z prefix, do you have an example?

[sbc100]

tools/llvm-nm/llvm-nm.cpp

668–669 ↗

(On Diff #104222)

I'm mostly cargo culting this from elsewhere in the codebase.

See tools/llvm-cxxdump/llvm-cxxdump.cpp. It does a lot of checking for _Z symbols and it always checks for the double under version as well.

tools/llvm-objdump/MachODump.cpp seems to only check for the double under version.

tools/llvm-cxxfilt/llvm-cxxfilt.cpp checks both.

git grep __Z seems to indicate that its the Mach-O format the includes the extra _ which would explain why MachODump.cpp only checks for that.

I'll dig a bit deeper and try to add another test.

[sbc100]

• Add test coverage for Mach-O symbols which start with _

[sbc100]

Turned out to be mach-o thing. I added test coverage and a comment,

[sbc100]

• simplify test case

[davide]

I'm fine with this but I'd appreciate another pair of eyes as it's been a while since I touched the dumpers.

tools/llvm-nm/llvm-nm.cpp

759 ↗

(On Diff #104266)

Do you need a copy here?

[sbc100]

• simlify test case
• only strip leaning _ on MachO

[sbc100]

• remove redundant size check

[ruiu]

llvm/trunk/tools/llvm-nm/llvm-nm.cpp

667

This may be a dumb question, but does MachO use the Itanium mangling scheme?

Does it use both "__Z" and "_Z" as prefixes?

668

You can use startswith

[sbc100]

llvm/trunk/tools/llvm-nm/llvm-nm.cpp

667

The macho files that llvm generates certainly seem too (see the tests code in this CL).

It seems they always add the "_", so you either get "__Z" of MachO and "_Z" on Elf. One or the other, not both. Based purely on the empirical behaviour of llvm today.

llvm/trunk/docs/CommandGuide/llvm-nm.rst

 .. option:: --radix=RADIX, -t
 
  Specify the radix of the symbol address(es). Values accepted d(decimal),
  x(hexadecomal) and o(octal).
 
 BUGS
 ----
 
- * :program:`llvm-nm` cannot demangle C++ mangled names, like GNU :program:`nm`
-   can.
-
  * :program:`llvm-nm` does not support the full set of arguments that GNU
    :program:`nm` does.
 
 EXIT STATUS
 -----------
 
 :program:`llvm-nm` exits with an exit code of zero.
 
 SEE ALSO
 --------
 
 llvm-dis, ar(1), nm(1)

llvm/trunk/test/tools/llvm-nm/X86/demangle.ll

+; RUN: llc -filetype=obj -mtriple=x86_64-pc-linux -o %t.o %s
+; RUN: llvm-nm %t.o | FileCheck --check-prefix="MANGLED" %s
+; RUN: llvm-nm -C %t.o | FileCheck --check-prefix="DEMANGLED" %s
+; RUN: llvm-nm --demangle %t.o | FileCheck --check-prefix="DEMANGLED" %s
+
+; RUN: llc -filetype=obj -mtriple=x86_64-apple-darwin9 -o %t.macho %s
+; RUN: llvm-nm %t.macho | FileCheck --check-prefix="MACHO-MANGLED" %s
+; RUN: llvm-nm -C %t.macho | FileCheck --check-prefix="DEMANGLED" %s
+
+; RUN: llc -filetype=obj -mtriple=x86_64-pc-win32 -o %t.coff %s
+; RUN: llvm-nm %t.coff | FileCheck --check-prefix="COFF-MANGLED" %s
+; RUN: llvm-nm -C %t.coff | FileCheck --check-prefix="COFF-DEMANGLED" %s
+
+define i32 @_Z3fooi(i32) #0 {
+entry:
+  ret i32 1
+}
+
+define float @_Z3barf(float) #0 {
+entry:
+  ret float 0.000000e+00
+}
+
+; MANGLED:       0000000000000010 T _Z3barf
+; MANGLED:       0000000000000000 T _Z3fooi
+
+; MACHO-MANGLED: 0000000000000010 T __Z3barf
+; MACHO-MANGLED: 0000000000000000 T __Z3fooi
+
+; COFF-MANGLED:          00000010 T _Z3barf
+; COFF-MANGLED:          00000000 T _Z3fooi
+
+; DEMANGLED:     0000000000000010 T bar(float)
+; DEMANGLED:     0000000000000000 T foo(int)
+
+; COFF-DEMANGLED:        00000010 T bar(float)
+; COFF-DEMANGLED:        00000000 T foo(int)

llvm/trunk/tools/llvm-nm/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsDescs
   AllTargetsInfos
   Core
+  Demangle
   Object
   Support
   )
 
 add_llvm_tool(llvm-nm
   llvm-nm.cpp
 
   DEPENDS
   intrinsics_gen
   )

llvm/trunk/tools/llvm-nm/llvm-nm.cpp

 //
 // This "nm" supports many of the features of GNU "nm", including its different
 // output formats.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/COFF.h"
+#include "llvm/Demangle/Demangle.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
cl::alias NumericSortn("n", cl::desc("Alias for --numeric-sort"),
                        cl::aliasopt(NumericSort), cl::Grouping);
 cl::alias NumericSortv("v", cl::desc("Alias for --numeric-sort"),
                        cl::aliasopt(NumericSort), cl::Grouping);
 
 cl::opt<bool> NoSort("no-sort", cl::desc("Show symbols in order encountered"));
 cl::alias NoSortp("p", cl::desc("Alias for --no-sort"), cl::aliasopt(NoSort),
                   cl::Grouping);
 
+cl::opt<bool> Demangle("demangle", cl::desc("Demangle C++ symbol names"));
+cl::alias DemangleC("C", cl::desc("Alias for --demangle"), cl::aliasopt(Demangle),
+                    cl::Grouping);
+
 cl::opt<bool> ReverseSort("reverse-sort", cl::desc("Sort in reverse order"));
 cl::alias ReverseSortr("r", cl::desc("Alias for --reverse-sort"),
                        cl::aliasopt(ReverseSort), cl::Grouping);
 
 cl::opt<bool> PrintSize("print-size",
                         cl::desc("Show symbol size instead of address"));
 cl::alias PrintSizeS("S", cl::desc("Alias for --print-size"),
                      cl::aliasopt(PrintSize), cl::Grouping);
static void darwinPrintStab(MachOObjectFile *MachO, SymbolListT::iterator I) {
   outs() << Str << ' ';
   if (const char *stabString = getDarwinStabString(NType))
     format("%5.5s", stabString).print(Str, sizeof(Str));
   else
     format("   %02x", NType).print(Str, sizeof(Str));
   outs() << Str;
 }
 
+static Optional<std::string> demangle(StringRef Name, bool StripUnderscore) {
+  if (StripUnderscore && Name.size() > 0 && Name[0] == '_')
+    Name = Name.substr(1);
+
+  if (!Name.startswith("_Z"))
+    return None;
+
+  int Status;
+  std::unique_ptr<char> Undecorated(
+      itaniumDemangle(Name.str().c_str(), nullptr, nullptr, &Status));
+  if (Status != 0)
+    return None;
+
+  return std::string(Undecorated.get());
+}
+
 static bool symbolIsDefined(const NMSymbol &Sym) {
   return Sym.TypeChar != 'U' && Sym.TypeChar != 'w' && Sym.TypeChar != 'v';
 }
 
 static void sortAndPrintSymbolList(SymbolicFile &Obj, bool printName,
                                    const std::string &ArchiveName,
                                    const std::string &ArchitectureName) {
   if (!NoSort) {
if (isSymbolList64Bit(Obj)) {
     default:
       printFormat = OutputFormat == posix ? "%" PRId64 : "%08" PRId64;
     }
   }
 
   for (SymbolListT::iterator I = SymbolList.begin(), E = SymbolList.end();
        I != E; ++I) {
     uint32_t SymFlags;
+    std::string Name = I->Name.str();
+    MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
+    if (Demangle) {
+      if (Optional<std::string> Opt = demangle(I->Name, MachO))
+        Name = *Opt;
+    }
     if (I->Sym.getRawDataRefImpl().p)
       SymFlags = I->Sym.getFlags();
     else
       SymFlags = I->SymFlags;
 
     bool Undefined = SymFlags & SymbolRef::SF_Undefined;
     bool Global = SymFlags & SymbolRef::SF_Global;
     if ((!Undefined && UndefinedOnly) || (Undefined && DefinedOnly) ||
         (!Global && ExternalOnly) || (SizeSort && !PrintAddress))
       continue;
     if (PrintFileName) {
       if (!ArchitectureName.empty())
         outs() << "(for architecture " << ArchitectureName << "):";
       if (OutputFormat == posix && !ArchiveName.empty())
         outs() << ArchiveName << "[" << CurrentFilename << "]: ";
       else {
         if (!ArchiveName.empty())
           outs() << ArchiveName << ":";
         outs() << CurrentFilename << ": ";
       }
     }
-    if ((JustSymbolName || (UndefinedOnly && isa<MachOObjectFile>(Obj) &&
-                            OutputFormat != darwin)) && OutputFormat != posix) {
-      outs() << I->Name << "\n";
+    if ((JustSymbolName ||
+         (UndefinedOnly && MachO && OutputFormat != darwin)) &&
+        OutputFormat != posix) {
+      outs() << Name << "\n";
       continue;
     }
 
     char SymbolAddrStr[18] = "";
     char SymbolSizeStr[18] = "";
 
     // If the format is SysV or the symbol isn't defined, then print spaces.
     if (OutputFormat == sysv || !symbolIsDefined(*I)) {
       if (OutputFormat == posix) {
         format(printFormat, I->Address)
           .print(SymbolAddrStr, sizeof(SymbolAddrStr));
         format(printFormat, I->Size)
             .print(SymbolSizeStr, sizeof(SymbolSizeStr));
       } else {
         strcpy(SymbolAddrStr, printBlanks);
         strcpy(SymbolSizeStr, printBlanks);
       }
     }
 
-    MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
     // Otherwise, print the symbol address and size.
     if (symbolIsDefined(*I)) {
       if (Obj.isIR())
         strcpy(SymbolAddrStr, printDashes);
       else if(MachO && I->TypeChar == 'I')
         strcpy(SymbolAddrStr, printBlanks);
       else
         format(printFormat, I->Address)
           .print(SymbolAddrStr, sizeof(SymbolAddrStr));
       format(printFormat, I->Size).print(SymbolSizeStr, sizeof(SymbolSizeStr));
     }
 
     // If OutputFormat is darwin or we are printing Mach-O symbols in hex and
     // we have a MachOObjectFile, call darwinPrintSymbol to print as darwin's
     // nm(1) -m output or hex, else if OutputFormat is darwin or we are
     // printing Mach-O symbols in hex and not a Mach-O object fall back to
     // OutputFormat bsd (see below).
     if ((OutputFormat == darwin || FormatMachOasHex) && (MachO || Obj.isIR())) {
       darwinPrintSymbol(Obj, I, SymbolAddrStr, printBlanks, printDashes,
                         printFormat);
     } else if (OutputFormat == posix) {
-      outs() << I->Name << " " << I->TypeChar << " ";
+      outs() << Name << " " << I->TypeChar << " ";
       if (MachO)
         outs() << SymbolAddrStr << " " << "0" /* SymbolSizeStr */ << "\n";
       else
         outs() << SymbolAddrStr << " " << SymbolSizeStr << "\n";
     } else if (OutputFormat == bsd || (OutputFormat == darwin && !MachO)) {
       if (PrintAddress)
         outs() << SymbolAddrStr << ' ';
       if (PrintSize) {
         outs() << SymbolSizeStr;
         outs() << ' ';
       }
       outs() << I->TypeChar;
       if (I->TypeChar == '-' && MachO)
         darwinPrintStab(MachO, I);
-      outs() << " " << I->Name;
+      outs() << " " << Name;
       if (I->TypeChar == 'I' && MachO) {
         outs() << " (indirect for ";
         if (I->Sym.getRawDataRefImpl().p) {
           StringRef IndirectName;
           if (MachO->getIndirectName(I->Sym.getRawDataRefImpl(), IndirectName))
             outs() << "?)";
           else
             outs() << IndirectName << ")";
         } else
           outs() << I->IndirectName << ")";
       }
       outs() << "\n";
     } else if (OutputFormat == sysv) {
-      std::string PaddedName(I->Name);
+      std::string PaddedName(Name);
       while (PaddedName.length() < 20)
         PaddedName += " ";
       outs() << PaddedName << "|" << SymbolAddrStr << "|   " << I->TypeChar
              << "  |                  |" << SymbolSizeStr << "|     |\n";
     }
   }
 
   SymbolList.clear();