Check stack pointer to be inside stack when unwinding.

base/trace_event/heap_profiler_allocation_context_tracker.cc

 // Copyright 2015 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/trace_event/heap_profiler_allocation_context_tracker.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/atomicops.h"
@@ skipping 147 matching lines @@
 AllocationContext AllocationContextTracker::GetContextSnapshot() {
   AllocationContext ctx;
 
   if (ignore_scope_depth_) {
     ctx.backtrace.frames[0] = StackFrame::FromTraceEventName(kTracingOverhead);
     ctx.type_name = kTracingOverhead;
     ctx.backtrace.frame_count = 1;
     return ctx;
   }
 
+  // Ignore reentrancy during the call.
+  ignore_scope_depth_++;
+
   CaptureMode mode = static_cast<CaptureMode>(
       subtle::NoBarrier_Load(&capture_mode_));
 
   auto backtrace = std::begin(ctx.backtrace.frames);
   auto backtrace_end = std::end(ctx.backtrace.frames);
 
   if (!thread_name_) {
-    // Ignore the string allocation made by GetAndLeakThreadName to avoid
-    // reentrancy.
-    ignore_scope_depth_++;
     thread_name_ = GetAndLeakThreadName();
     ANNOTATE_LEAKING_OBJECT_PTR(thread_name_);
     DCHECK(thread_name_);
-    ignore_scope_depth_--;
   }
 
   // Add the thread name as the first entry in pseudo stack.
   if (thread_name_) {
     *backtrace++ = StackFrame::FromThreadName(thread_name_);
   }
 
   switch (mode) {
     case CaptureMode::DISABLED:
       {
@@ skipping 11 matching lines @@
       }
     case CaptureMode::NATIVE_STACK:
       {
         // Backtrace contract requires us to return bottom frames, i.e.
         // from main() and up. Stack unwinding produces top frames, i.e.
         // from this point and up until main(). We request many frames to
         // make sure we reach main(), and then copy bottom portion of them.
         const void* frames[128];
         static_assert(arraysize(frames) >= Backtrace::kMaxFrameCount,
                       "not requesting enough frames to fill Backtrace");
 #if HAVE_TRACE_STACK_FRAME_POINTERS && !defined(OS_NACL)

[Primiano Tucci (use gerrit), 2016/05/27 16:49:43]

tip: maybe exclude OS_NACL in HAVE_TRACE_STACK_FRAME_POINTERS so you have to
check only for HAVE_TRACE_STACK_FRAME_POINTERS without putting OS_NACL
everywhere?

[Dmitry Skiba, 2016/05/27 18:50:09]

OS_NACL is there because in NaCl mode stack_trace.cc is not compiled. So
stack_trace.h/cc itself is fine, and it shouldn't care about NACL. The problem
is in this file which (without NACL check) tries to use something that is not
available. 

[Primiano Tucci (use gerrit), 2016/05/31 16:13:06]

Yeah but since we generally don't care about what happens in nacl, can we be
aggressive (always set HAVE_TRACE_STACK_FRAME_POINTERS =  false on nacl) in
favor of code readability?

         size_t frame_count = debug::TraceStackFramePointers(
             frames,
             arraysize(frames),
-            1 /* exclude this function from the trace */ );
+            1 /* exclude this function from the trace */,
+            &stack_info_);
 #else
         size_t frame_count = 0;
         NOTREACHED();
 #endif
 
         // Copy frames backwards
         size_t backtrace_capacity = backtrace_end - backtrace;
         size_t top_frame_index = (backtrace_capacity >= frame_count) ?
             0 :
             frame_count - backtrace_capacity;
         for (size_t i = frame_count; i > top_frame_index;) {
           const void* frame = frames[--i];
           *backtrace++ = StackFrame::FromProgramCounter(frame);
         }
         break;
       }
   }
 
   ctx.backtrace.frame_count = backtrace - std::begin(ctx.backtrace.frames);
 
   // TODO(ssid): Fix crbug.com/594803 to add file name as 3rd dimension
   // (component name) in the heap profiler and not piggy back on the type name.
   ctx.type_name = task_contexts_.empty() ? nullptr : task_contexts_.back();
 
+  ignore_scope_depth_--;
   return ctx;
 }
 
 }  // namespace trace_event
 }  // namespace base