Cleaner fall-back stack capture for --enable-heap-profiling=native.

base/debug/stack_trace.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 <string.h>
 
 #include <algorithm>
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/macros.h"
 
-#if HAVE_TRACE_STACK_FRAME_POINTERS
+#if HAVE_TRACE_STACK_FRAME_POINTERS()
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 #include <pthread.h>
 #include "base/process/process_handle.h"
 #include "base/threading/platform_thread.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include <pthread.h>
 #endif
 
 #if defined(OS_LINUX) && defined(__GLIBC__)
 extern "C" void* __libc_stack_end;
 #endif
 
-#endif  // HAVE_TRACE_STACK_FRAME_POINTERS
+#endif  // HAVE_TRACE_STACK_FRAME_POINTERS()
 
 namespace base {
 namespace debug {
 
 namespace {
 
-#if HAVE_TRACE_STACK_FRAME_POINTERS && !defined(OS_WIN)
+#if HAVE_TRACE_STACK_FRAME_POINTERS()
 
 #if defined(__arm__) && defined(__GNUC__) && !defined(__clang__)
 // GCC and LLVM generate slightly different frames on ARM, see
 // https://llvm.org/bugs/show_bug.cgi?id=18505 - LLVM generates
 // x86-compatible frame, while GCC needs adjustment.
 constexpr size_t kStackFrameAdjustment = sizeof(uintptr_t);
 #else
 constexpr size_t kStackFrameAdjustment = 0;
 #endif
 
@@ skipping 86 matching lines @@
 // TraceStackFramePointers() visits |parent_fp| after visiting |fp|.
 // Both frame pointers must come from __builtin_frame_address().
 // Returns previous stack frame |fp| was linked to.
 void* LinkStackFrames(void* fpp, void* parent_fp) {
   uintptr_t fp = reinterpret_cast<uintptr_t>(fpp) - kStackFrameAdjustment;
   void* prev_parent_fp = reinterpret_cast<void**>(fp)[0];
   reinterpret_cast<void**>(fp)[0] = parent_fp;
   return prev_parent_fp;
 }
 
-#endif  // HAVE_TRACE_STACK_FRAME_POINTERS && !defined(OS_WIN)
+#endif  // HAVE_TRACE_STACK_FRAME_POINTERS()
 
 }  // namespace
 
-#if HAVE_TRACE_STACK_FRAME_POINTERS
+#if HAVE_TRACE_STACK_FRAME_POINTERS()
 uintptr_t GetStackEnd() {
 #if defined(OS_ANDROID)
   // Bionic reads proc/maps on every call to pthread_getattr_np() when called
   // from the main thread. So we need to cache end of stack in that case to get
   // acceptable performance.
   // For all other threads pthread_getattr_np() is fast enough as it just reads
   // values from its pthread_t argument.
   static uintptr_t main_stack_end = 0;
 
   bool is_main_thread = GetCurrentProcId() == PlatformThread::CurrentId();
@@ skipping 27 matching lines @@
 
 // No easy way to get end of the stack for non-main threads,
 // see crbug.com/617730.
 #elif defined(OS_MACOSX)
   return reinterpret_cast<uintptr_t>(pthread_get_stackaddr_np(pthread_self()));
 #endif
 
   // Don't know how to get end of the stack.
   return 0;
 }
-#endif  // HAVE_TRACE_STACK_FRAME_POINTERS
+#endif  // HAVE_TRACE_STACK_FRAME_POINTERS()
 
 StackTrace::StackTrace() : StackTrace(arraysize(trace_)) {}
 
 StackTrace::StackTrace(const void* const* trace, size_t count) {
   count = std::min(count, arraysize(trace_));
   if (count)
     memcpy(trace_, trace, count * sizeof(trace_[0]));
   count_ = count;
 }
 
 const void *const *StackTrace::Addresses(size_t* count) const {
   *count = count_;
   if (count_)
     return trace_;
   return NULL;
 }
 
 std::string StackTrace::ToString() const {
   std::stringstream stream;
 #if !defined(__UCLIBC__)
   OutputToStream(&stream);
 #endif
   return stream.str();
 }
 
-#if HAVE_TRACE_STACK_FRAME_POINTERS
+#if HAVE_TRACE_STACK_FRAME_POINTERS()
 
 size_t TraceStackFramePointers(const void** out_trace,
                                size_t max_depth,
                                size_t skip_initial) {
-// TODO(699863): Merge the frame-pointer based stack unwinder into the
-// base::debug::StackTrace platform-specific implementation files.
-#if defined(OS_WIN)
-  StackTrace stack(max_depth);
-  size_t count = 0;
-  const void* const* frames = stack.Addresses(&count);
-  if (count < skip_initial)
-    return 0u;
-  count -= skip_initial;
-  memcpy(out_trace, frames + skip_initial, count * sizeof(void*));
-  return count;
-#elif defined(OS_POSIX)
   // Usage of __builtin_frame_address() enables frame pointers in this
   // function even if they are not enabled globally. So 'fp' will always
   // be valid.
   uintptr_t fp = reinterpret_cast<uintptr_t>(__builtin_frame_address(0)) -
                     kStackFrameAdjustment;
 
   uintptr_t stack_end = GetStackEnd();
 
   size_t depth = 0;
   while (depth < max_depth) {
@@ skipping 13 matching lines @@
     if (next_fp) {
       fp = next_fp;
       continue;
     }
 
     // Failed to find next frame.
     break;
   }
 
   return depth;
-#endif
 }
 
-#if !defined(OS_WIN)
 ScopedStackFrameLinker::ScopedStackFrameLinker(void* fp, void* parent_fp)
     : fp_(fp),
       parent_fp_(parent_fp),
       original_parent_fp_(LinkStackFrames(fp, parent_fp)) {}
 
 ScopedStackFrameLinker::~ScopedStackFrameLinker() {
   void* previous_parent_fp = LinkStackFrames(fp_, original_parent_fp_);
   CHECK_EQ(parent_fp_, previous_parent_fp)
       << "Stack frame's parent pointer has changed!";
 }
-#endif  // !defined(OS_WIN)
 
-#endif  // HAVE_TRACE_STACK_FRAME_POINTERS
+#endif  // HAVE_TRACE_STACK_FRAME_POINTERS()
 
 }  // namespace debug
 }  // namespace base