Add function to trace stack using frame pointers.

base/debug/stack_trace_posix.cc

Index: base/debug/stack_trace_posix.cc
diff --git a/base/debug/stack_trace_posix.cc b/base/debug/stack_trace_posix.cc
index fc3ee14c7b9d60958ad6d6000d94cbc616b6c7df..6ddef62a25219bd3dd1f61c39fd1423cabc41da5 100644
--- a/base/debug/stack_trace_posix.cc
+++ b/base/debug/stack_trace_posix.cc
@@ -743,6 +743,45 @@ void StackTrace::OutputToStream(std::ostream* os) const {
 }
 #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.