Pass only mangled function names to __cxa_demangle

[emaste]

Summary

The Itanium C++ ABI states the string passed to __cxa_demnagle "may be either an external name, i.e. with a "_Z" prefix, or an internal NTBS mangling, e.g. of a type for type_info."

llvm-symbolizer passes all names to cxa_demangle, which fails for many names on FreeBSD. Our cxa_demangle is currently not very strict about rejecting invalid names, and returns "unsigned int" for a function "main". On other platforms I believe llvm-symbolizer would produce incorrect output for functions with the same name as a mangled type - for example, returning "float" for a function "f".

This change checks that the name starts with the _Z prefix before passing it to __cxa_demangle.

http://llvm.org/pr18431

[emaste]

I missed that the _Z heuristic already exists, but was applied to global data only. Move the heuristic into DemangleName so that it is applied to function names too.

Add a new .c test specifically for llvm-symbolizer. I was going to modify dwarfdump-test.cc to make function f() extern "C", but don't want to have to deal with the binary objects that were already generated from it.

[samsonov]

LGTM (modulo comment below).

test/DebugInfo/Inputs/llvm-symbolizer-test.c

14

Update the build instructions.

[emaste]

Committed as r199404

test/DebugInfo/Inputs/llvm-symbolizer-test.c

+int f(int a, int b) {
+  return a + b;
+}
+
+int g(int a) {
+  return a + 1;
+}
+
+
+int main() {
+  return f(2, g(2));
+}
+
+// Built with Clang 3.3:
+// $ mkdir -p /tmp/dbginfo
+// $ cp llvm-symbolizer-test.c /tmp/dbginfo
+// $ cd /tmp/dbginfo
+// $ clang -g dwarfdump-test.cc -o <output>

test/DebugInfo/llvm-symbolizer.test

 RUN: echo "0x400559" > %t.input4
 RUN: echo "0x400436" >> %t.input4
 RUN: llvm-symbolizer --obj %p/Inputs/dwarfdump-test.elf-x86-64 < %t.input4 \
 RUN:   | FileCheck %s --check-prefix=BINARY
 
 BINARY:       main
 BINARY-NEXT: /tmp/dbginfo{{[/\\]}}dwarfdump-test.cc:16
 BINARY:      _start
+
+RUN: echo "0x400720" > %t.input5
+RUN: echo "0x4004a0" >> %t.input5
+RUN: echo "0x4006f0" >> %t.input5
+RUN: llvm-symbolizer --obj %p/Inputs/llvm-symbolizer-test.elf-x86-64 < %t.input5 \
+RUN:   | FileCheck %s --check-prefix=BINARY_C
+
+BINARY_C:       main
+BINARY_C-NEXT: /tmp/dbginfo{{[/\\]}}llvm-symbolizer-test.c:10
+BINARY_C:      _start
+BINARY_C:      {{g$}}

tools/llvm-symbolizer/LLVMSymbolize.h

private:
   ModuleInfo *getOrCreateModuleInfo(const std::string &ModuleName);
   /// \brief Returns pair of pointers to binary and debug binary.
   BinaryPair getOrCreateBinary(const std::string &Path);
   /// \brief Returns a parsed object file for a given architecture in a
   /// universal binary (or the binary itself if it is an object file).
   ObjectFile *getObjectFileFromBinary(Binary *Bin, const std::string &ArchName);
 
   std::string printDILineInfo(DILineInfo LineInfo) const;
-  static std::string DemangleGlobalName(const std::string &Name);
 
   // Owns all the parsed binaries and object files.
   SmallVector<Binary*, 4> ParsedBinariesAndObjects;
   // Owns module info objects.
   typedef std::map<std::string, ModuleInfo *> ModuleMapTy;
   ModuleMapTy Modules;
   typedef std::map<std::string, BinaryPair> BinaryMapTy;
   BinaryMapTy BinaryForPath;

tools/llvm-symbolizer/LLVMSymbolize.cpp

 std::string LLVMSymbolizer::symbolizeData(const std::string &ModuleName,
                                           uint64_t ModuleOffset) {
   std::string Name = kBadString;
   uint64_t Start = 0;
   uint64_t Size = 0;
   if (Opts.UseSymbolTable) {
     if (ModuleInfo *Info = getOrCreateModuleInfo(ModuleName)) {
       if (Info->symbolizeData(ModuleOffset, Name, Start, Size) && Opts.Demangle)
-        Name = DemangleGlobalName(Name);
+        Name = DemangleName(Name);
     }
   }
   std::stringstream ss;
   ss << Name << "\n" << Start << " " << Size << "\n";
   return ss.str();
 }
 
 void LLVMSymbolizer::flush() {

 #if !defined(_MSC_VER)
 // Assume that __cxa_demangle is provided by libcxxabi (except for Windows).
 extern "C" char *__cxa_demangle(const char *mangled_name, char *output_buffer,
                                 size_t *length, int *status);
 #endif
 
 std::string LLVMSymbolizer::DemangleName(const std::string &Name) {
 #if !defined(_MSC_VER)
+  // We can spoil names of symbols with C linkage, so use an heuristic
+  // approach to check if the name should be demangled.
+  if (Name.substr(0, 2) != "_Z")
+    return Name;
   int status = 0;
   char *DemangledName = __cxa_demangle(Name.c_str(), 0, 0, &status);
   if (status != 0)
     return Name;
   std::string Result = DemangledName;
   free(DemangledName);
   return Result;
 #else
   return Name;
 #endif
 }
 
-std::string LLVMSymbolizer::DemangleGlobalName(const std::string &Name) {
-  // We can spoil names of globals with C linkage, so use an heuristic
-  // approach to check if the name should be demangled.
-  return (Name.substr(0, 2) == "_Z") ? DemangleName(Name) : Name;
-}
-
 } // namespace symbolize
 } // namespace llvm