Import google-glog's Symbolize() and use it in debug_util_posix.cc.

base/debug_util_posix.cc

 // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "build/build_config.h"
 #include "base/debug_util.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #if defined(__GLIBCXX__)
 #include <cxxabi.h>
 #endif
 
+#include <iostream>
 #include <string>
 
 #if defined(OS_MACOSX)
 #include <AvailabilityMacros.h>
 #endif
 
 #include "base/basictypes.h"
 #include "base/compat_execinfo.h"
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/safe_strerror_posix.h"
 #include "base/scoped_ptr.h"
 #include "base/string_piece.h"
+#include "base/string_util.h"
+
+#if defined(USE_SYMBOLIZE)
+#include "base/third_party/symbolize/symbolize.h"

[Evan Martin, 2010/01/25 18:10:40]

It seems this included file then then does
  #include "glog/logging.h"

Why does this compile?  I would think there needs to be a
-Ithird_party/symbolize on the compile command line somewhere.

[satorux1, 2010/01/25 21:15:50]

That's a good question. I don't know the detail of how relative paths are
resolved but it just compiles.

For instance, this just includes everything needed.

% cd chromium/src
% g++ -DUSE_SYMBOLIZE -I. -E base/debug_util_posix.cc > /tmp/out

I'll let you know if I learn more about the magic.

+#endif
 
 namespace {
 // The prefix used for mangled symbols, per the Itanium C++ ABI:
 // http://www.codesourcery.com/cxx-abi/abi.html#mangling
 const char kMangledSymbolPrefix[] = "_Z";
 
 // Characters that can be used for symbols, generated by Ruby:
 // (('a'..'z').to_a+('A'..'Z').to_a+('0'..'9').to_a + ['_']).join
 const char kSymbolCharacters[] =
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
@@ skipping 36 matching lines @@
       // Next time, we'll start right after the demangled symbol we inserted.
       search_from = mangled_start + strlen(demangled_symbol.get());
     } else {
       // Failed to demangle.  Retry after the "_Z" we just found.
       search_from = mangled_start + 2;
     }
   }
 
 #endif  // defined(__GLIBCXX__)
 }
+
+// Gets the backtrace as a vector of strings. If possible, resolve symbol
+// names and attach these. Otherwise just use raw addresses. Returns true
+// if any symbol name is resolved.
+bool GetBacktraceStrings(void **trace, int size,
+                         std::vector<std::string>* trace_strings) {
+  bool symbolized = false;
+
+#if defined(USE_SYMBOLIZE)
+  for (int i = 0; i < size; ++i) {
+    char symbol[1024];
+    // Subtract by one as return address of function may be in the next
+    // function when a function is annotated as noreturn.
+    if (google::Symbolize(static_cast<char *>(trace[i]) - 1,
+                          symbol, sizeof(symbol))) {
+      // Don't call DemangleSymbols() here as the symbol is demangled by
+      // google::Symbolize().
+      trace_strings->push_back(StringPrintf("%s [%p]", symbol, trace[i]));
+      symbolized = true;
+    } else {
+      trace_strings->push_back(StringPrintf("%p", trace[i]));
+    }
+  }
+#else
+  scoped_ptr_malloc<char*> trace_symbols(backtrace_symbols(trace, size));
+  if (trace_symbols.get()) {
+    for (int i = 0; i < size; ++i) {
+      std::string trace_symbol = trace_symbols.get()[i];
+      DemangleSymbols(&trace_symbol);
+      trace_strings->push_back(trace_symbol);
+    }
+    symbolized = true;
+  } else {
+    for (int i = 0; i < size; ++i) {
+      trace_strings->push_back(StringPrintf("%p", trace[i]));
+    }
+  }
+#endif  // defined(USE_SYMBOLIZE)
+
+  return symbolized;
+}
+
 }  // namespace
 
 // static
 bool DebugUtil::SpawnDebuggerOnProcess(unsigned /* process_id */) {
   NOTIMPLEMENTED();
   return false;
 }
 
 #if defined(OS_MACOSX)
 
@@ skipping 103 matching lines @@
   // return values, we take no chance.
   count_ = std::max(backtrace(trace_, arraysize(trace_)), 0);
 }
 
 void StackTrace::PrintBacktrace() {
 #if defined(OS_MACOSX) && MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
   if (backtrace_symbols_fd == NULL)
     return;
 #endif
   fflush(stderr);
-  backtrace_symbols_fd(trace_, count_, STDERR_FILENO);
+  std::vector<std::string> trace_strings;
+  GetBacktraceStrings(trace_, count_, &trace_strings);
+  for (size_t i = 0; i < trace_strings.size(); ++i) {
+    std::cerr << "\t" << trace_strings[i] << "\n";
+  }
 }
 
 void StackTrace::OutputToStream(std::ostream* os) {
 #if defined(OS_MACOSX) && MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
   if (backtrace_symbols == NULL)
     return;
 #endif
-  scoped_ptr_malloc<char*> trace_symbols(backtrace_symbols(trace_, count_));
-
-  // If we can't retrieve the symbols, print an error and just dump the raw
-  // addresses.
-  if (trace_symbols.get() == NULL) {
+  std::vector<std::string> trace_strings;
+  if (GetBacktraceStrings(trace_, count_, &trace_strings)) {
+    (*os) << "Backtrace:\n";
+  } else {
     (*os) << "Unable get symbols for backtrace (" << safe_strerror(errno)
           << "). Dumping raw addresses in trace:\n";
-    for (int i = 0; i < count_; ++i) {
-      (*os) << "\t" << trace_[i] << "\n";
-    }
-  } else {
-    (*os) << "Backtrace:\n";
-    for (int i = 0; i < count_; ++i) {
-      std::string trace_symbol(trace_symbols.get()[i]);
-      DemangleSymbols(&trace_symbol);
-      (*os) << "\t" << trace_symbol << "\n";
-    }
+  }
+
+  for (size_t i = 0; i < trace_strings.size(); ++i) {
+    (*os) << "\t" << trace_strings[i] << "\n";
   }
 }