Add function to trace stack using frame pointers.

base/debug/stack_trace_posix.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 <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stddef.h>
@@ skipping 725 matching lines @@
 #endif
 }
 
 #if !defined(__UCLIBC__)
 void StackTrace::OutputToStream(std::ostream* os) const {
   StreamBacktraceOutputHandler handler(os);
   ProcessBacktrace(trace_, count_, &handler);
 }
 #endif
 
+#if HAVE_TRACE_STACK_FRAME_POINTERS
+
+size_t TraceStackFramePointers(const void** out_trace,
+                               size_t max_depth,
+                               size_t skip_initial) {
+  uintptr_t fp = reinterpret_cast<uintptr_t>(__builtin_frame_address(0));

[Nico, 2016/04/18 19:42:05]

nit: call this sp

[Dmitry Skiba, 2016/04/20 16:32:56]

Done.

+
+  size_t depth = 0;
+  while (fp && depth < max_depth) {
+    if (skip_initial != 0) {
+      skip_initial--;
+    } else {
+      out_trace[depth++] = reinterpret_cast<const void**>(fp)[1];

[Nico, 2016/04/18 19:42:05]

you treat fp as void** almost everywhere, consider making it type void** instead
of uintptr_t

[Primiano Tucci (use gerrit), 2016/04/18 20:18:07]

the frame pointer can be invalid even at this stage, if by accident this
function did not emit a frame pointer (because your guessing is wrong).
I think you should move some of the basic checks (is this address aligned in a
reasonable zone) here, before you dereference fp the first time.

[Dmitry Skiba, 2016/04/20 16:32:56]

Hmm, since I don't have next_fp at that point, I can only check for alignment.

[Dmitry Skiba, 2016/04/20 16:32:56]

So we have these casts:

reinterpret_cast<uintptr_t>(__builtin_frame_address(0));
reinterpret_cast<const void**>(fp)[1];
reinterpret_cast<const uintptr_t*>(fp)[0];

If we change fp (sp) to be const void*, then we can avoid the first cast, but
get issues with checks in exchange. Checks operate on byte differences, so we
would need to turn next_fp into const void* too and insert (uintptr_t) casts in
every if().

If we change fp to be const void**, then we can avoid second cast, but others
two will remain.

So no matter how we change fp we will have casts. The current version gets rid
of (uintptr_t) casts in checks, so they are cleaner.

+    }
+
+    // Find out next frame pointer
+    // (heuristics are from TCMalloc's stacktrace functions)
+    {

[Primiano Tucci (use gerrit), 2016/04/18 20:18:08]

why this is inside a scope? Is there an if missing ?

[Dmitry Skiba, 2016/04/20 16:32:56]

Done.

+      uintptr_t next_fp = reinterpret_cast<const uintptr_t*>(fp)[0];
+
+      // With the stack growing downwards, older stack frame must be
+      // at a greater address that the current one.
+      if (next_fp <= fp) break;

[Primiano Tucci (use gerrit), 2016/04/18 20:18:08]

I think these checks should happen before you dereference fp above no?
If the first frame itself is invalid, you will just jump on random with that
next_fp = fp[0]

[Dmitry Skiba, 2016/04/20 16:32:56]

But this also dereferences fp, next_fp is fp[1].

+
+      // Assume stack frames larger than 100,000 bytes are bogus.
+      if (next_fp - fp > 100000) break;
+
+      // Check alignment.
+      if (next_fp & (sizeof(void*) - 1)) break;
+
+      fp = next_fp;
+    }
+  }
+
+  return depth;
+}
+
+#endif  // HAVE_TRACE_STACK_FRAME_POINTERS
+
 namespace internal {
 
 // NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
 char* itoa_r(intptr_t i, char* buf, size_t sz, int base, size_t padding) {
   // Make sure we can write at least one NUL byte.
   size_t n = 1;
   if (n > sz)
     return NULL;
 
   if (base < 2 || base > 16) {
@@ skipping 48 matching lines @@
     *ptr = *start;
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base