Get a backtrace in Chrome for Android.

base/debug/stack_trace_android.cc

 // Copyright (c) 2012 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/stack_trace.h"
 
 #include <signal.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <unwind.h>  // TODO(dmikurube): Remove when get_backtrace() is used.
 
 #include "base/logging.h"
 
 #ifdef __MIPSEL__
 // SIGSTKFLT is not defined for MIPS.
 #define SIGSTKFLT SIGSEGV
 #endif
 
+// TODO(dmikurube): Remove when Bionic's get_backtrace() gets popular.
+// See Bionic's libc/bionic/debug_stacktrace.cpp.

[digit, 2013/04/30 16:58:13]

Maybe file a bug to track this and put a reference here about it?

[Dai Mikurube (NOT FULLTIME), 2013/04/30 17:15:23]

Done.

+namespace {
+
+/* depends how the system includes define this */
+#ifdef HAVE_UNWIND_CONTEXT_STRUCT
+typedef struct _Unwind_Context __unwind_context;
+#else
+typedef _Unwind_Context __unwind_context;
+#endif
+
+struct stack_crawl_state_t {
+  uintptr_t* frames;
+  size_t frame_count;
+  size_t max_depth;
+  bool have_skipped_self;
+
+  stack_crawl_state_t(uintptr_t* frames, size_t max_depth)
+      : frames(frames),
+        frame_count(0),
+        max_depth(max_depth),
+        have_skipped_self(false) {
+  }
+};
+
+static _Unwind_Reason_Code tracer(__unwind_context* context, void* arg) {
+  stack_crawl_state_t* state = static_cast<stack_crawl_state_t*>(arg);
+
+  uintptr_t ip = _Unwind_GetIP(context);
+
+  // The first stack frame is get_backtrace itself.  Skip it.

[digit, 2013/04/30 16:58:13]

I'd suggest replacing "get_backtrace" by "this function" instead to make this
copied comment less confusing :-)

[Dai Mikurube (NOT FULLTIME), 2013/04/30 17:15:23]

Done.

+  if (ip != 0 && !state->have_skipped_self) {
+    state->have_skipped_self = true;
+    return _URC_NO_REASON;
+  }
+
+  state->frames[state->frame_count++] = ip;
+  if (state->frame_count >= state->max_depth)
+    return _URC_END_OF_STACK;
+  else
+    return _URC_NO_REASON;
+}
+
+}
+
 namespace base {
 namespace debug {
 
 bool EnableInProcessStackDumping() {
   // When running in an application, our code typically expects SIGPIPE
   // to be ignored.  Therefore, when testing that same code, it should run
   // with SIGPIPE ignored as well.
   // TODO(phajdan.jr): De-duplicate this SIGPIPE code.
   struct sigaction action;
   memset(&action, 0, sizeof(action));
   action.sa_handler = SIG_IGN;
   sigemptyset(&action.sa_mask);
   return (sigaction(SIGPIPE, &action, NULL) == 0);
 }
 
 StackTrace::StackTrace() {
+  // TODO(dmikurube): Replace it with Bionic's get_backtrace().
+  // See Bionic's libc/bionic/debug_stacktrace.cpp.
+  stack_crawl_state_t state(reinterpret_cast<uintptr_t*>(trace_), kMaxTraces);
+  _Unwind_Backtrace(tracer, &state);
+  count_ = state.frame_count;
+  // TODO(dmikurube): Symbolize in Chrome.
 }
 
 // Sends fake SIGSTKFLT signals to let the Android linker and debuggerd dump
 // stack. See inlined comments and Android bionic/linker/debugger.c and
 // system/core/debuggerd/debuggerd.c for details.
 void StackTrace::PrintBacktrace() const {
   // Get the current handler of SIGSTKFLT for later use.
   sighandler_t sig_handler = signal(SIGSTKFLT, SIG_DFL);
   signal(SIGSTKFLT, sig_handler);
 
@@ skipping 12 matching lines @@
   // Restore the signal handler so that this method can work the next time.
   signal(SIGSTKFLT, sig_handler);
 }
 
 void StackTrace::OutputToStream(std::ostream* os) const {
   NOTIMPLEMENTED();
 }
 
 }  // namespace debug
 }  // namespace base