symbolize: don't stringify errno if we're using google::Symbolize.

base/debug_util_posix.cc

 // Copyright (c) 2010 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 "base/debug_util.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ skipping 81 matching lines @@
       search_from = mangled_start + 2;
     }
   }
 
 #endif  // defined(__GLIBCXX__)
 }
 #endif  // !defined(USE_SYMBOLIZE)
 
 // 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.
+// if any symbol name is resolved.  Returns false on error and *may* fill
+// in |error_message| if an error message is available.
 bool GetBacktraceStrings(void **trace, int size,
-                         std::vector<std::string>* trace_strings) {
+                         std::vector<std::string>* trace_strings,
+                         std::string* error_message) {
   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(
           base::StringPrintf("%s [%p]", symbol, trace[i]));
       symbolized = true;
     } else {
       trace_strings->push_back(base::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 {
+    if (error_message)
+      *error_message = safe_strerror(errno);
     for (int i = 0; i < size; ++i) {
       trace_strings->push_back(base::StringPrintf("%p", trace[i]));
     }
   }
 #endif  // defined(USE_SYMBOLIZE)
 
   return symbolized;
 }
 
 }  // namespace
@@ skipping 132 matching lines @@
   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);
   std::vector<std::string> trace_strings;
-  GetBacktraceStrings(trace_, count_, &trace_strings);
+  GetBacktraceStrings(trace_, count_, &trace_strings, NULL);
   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
   std::vector<std::string> trace_strings;
-  if (GetBacktraceStrings(trace_, count_, &trace_strings)) {
+  std::string error_message;
+  if (GetBacktraceStrings(trace_, count_, &trace_strings, &error_message)) {
     (*os) << "Backtrace:\n";
   } else {
-    (*os) << "Unable get symbols for backtrace (" << safe_strerror(errno)
-          << "). Dumping raw addresses in trace:\n";
+    if (!error_message.empty())
+      error_message = " (" + error_message + ")";
+    (*os) << "Unable to get symbols for backtrace" << error_message << ". "
+          << "Dumping raw addresses in trace:\n";
   }
 
   for (size_t i = 0; i < trace_strings.size(); ++i) {
     (*os) << "\t" << trace_strings[i] << "\n";
   }
 }