dart::DebuggerStackTrace Class Reference

#include <debugger.h>

Inheritance diagram for dart::DebuggerStackTrace:

Public Member Functions
	DebuggerStackTrace (int capacity)
intptr_t	Length () const
ActivationFrame *	FrameAt (int i) const
ActivationFrame *	GetHandlerFrame (const Instance &exc_obj) const
bool	has_async_catch_error () const
void	set_has_async_catch_error (bool has_async_catch_error)
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

Static Public Member Functions
static DebuggerStackTrace *	Collect ()
static DebuggerStackTrace *	CollectAsyncAwaiters ()
static DebuggerStackTrace *	From (const class StackTrace &ex_trace)

Friends
class	Debugger

Detailed Description

Definition at line 458 of file debugger.h.

Constructor & Destructor Documentation

DebuggerStackTrace()

dart::DebuggerStackTrace::DebuggerStackTrace ( int  capacity )

inlineexplicit

Definition at line 460 of file debugger.h.

      : thread_(Thread::Current()), zone_(thread_->zone()), trace_(capacity) {}

Member Function Documentation

Collect()

DebuggerStackTrace * dart::DebuggerStackTrace::Collect ( )

static

Definition at line 1671 of file debugger.cc.

                                                {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  Code& code = Code::Handle(zone);
  DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
 
  StackFrameIterator iterator(ValidationPolicy::kDontValidateFrames, thread,
                              StackFrameIterator::kNoCrossThreadIteration);
  for (StackFrame* frame = iterator.NextFrame(); frame != nullptr;
       frame = iterator.NextFrame()) {
    ASSERT(frame->IsValid());
    if (FLAG_trace_debugger_stacktrace) {
      OS::PrintErr("CollectStackTrace: visiting frame:\n\t%s\n",
                   frame->ToCString());
    }
    if (frame->IsDartFrame()) {
      code = frame->LookupDartCode();
      stack_trace->AppendCodeFrames(frame, code);
    }
  }
  return stack_trace;
}

CollectAsyncAwaiters()

DebuggerStackTrace * dart::DebuggerStackTrace::CollectAsyncAwaiters ( )

static

Definition at line 1732 of file debugger.cc.

                                                             {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
 
  Function& function = Function::Handle(zone);
 
  constexpr intptr_t kDefaultStackAllocation = 8;
  auto stack_trace = new DebuggerStackTrace(kDefaultStackAllocation);
 
  bool has_async = false;
  bool has_async_catch_error = false;
  StackTraceUtils::CollectFrames(
      thread, /*skip_frames=*/0,
      [&](const StackTraceUtils::Frame& frame) {
        if (frame.frame != nullptr) {  // Synchronous portion of the stack.
          stack_trace->AppendCodeFrames(frame.frame, frame.code);
        } else {
          has_async = true;
 
          if (frame.code.ptr() == StubCode::AsynchronousGapMarker().ptr()) {
            stack_trace->AddAsyncSuspension();
            return;
          }
 
          // Skip invisible function frames.
          function ^= frame.code.function();
          if (!function.is_visible()) {
            return;
          }
 
          const uword absolute_pc = frame.code.PayloadStart() + frame.pc_offset;
          stack_trace->AddAsyncAwaiterFrame(absolute_pc, frame.code,
                                            frame.closure);
        }
      },
      &has_async_catch_error);
 
  // If the entire stack is sync, return no (async) trace.
  if (!has_async) {
    return nullptr;
  }
 
  stack_trace->set_has_async_catch_error(has_async_catch_error);
 
  return stack_trace;
}

FrameAt()

ActivationFrame * dart::DebuggerStackTrace::FrameAt ( int  i ) const

inline

Definition at line 465 of file debugger.h.

{ return trace_[i]; }

From()

DebuggerStackTrace * dart::DebuggerStackTrace::From ( const class StackTrace &  ex_trace )

static

Definition at line 1808 of file debugger.cc.

                                                                             {
  DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
  Function& function = Function::Handle();
  Object& code_object = Object::Handle();
  Code& code = Code::Handle();
 
  const uword fp = 0;
  const uword sp = 0;
  const Array& deopt_frame = Array::Handle();
  const intptr_t deopt_frame_offset = -1;
 
  for (intptr_t i = 0; i < ex_trace.Length(); i++) {
    code_object = ex_trace.CodeAtFrame(i);
    // Pre-allocated StackTraces may include empty slots, either (a) to indicate
    // where frames were omitted in the case a stack has more frames than the
    // pre-allocated trace (such as a stack overflow) or (b) because a stack has
    // fewer frames that the pre-allocated trace (such as memory exhaustion with
    // a shallow stack).
    if (!code_object.IsNull()) {
      code ^= code_object.ptr();
      ASSERT(code.IsFunctionCode());
      function = code.function();
      if (function.is_visible()) {
        ASSERT(function.ptr() == code.function());
        uword pc = code.PayloadStart() + ex_trace.PcOffsetAtFrame(i);
        if (code.is_optimized() && ex_trace.expand_inlined()) {
          // Traverse inlined frames.
          for (InlinedFunctionsIterator it(code, pc); !it.Done();
               it.Advance()) {
            function = it.function();
            code = it.code();
            ASSERT(function.ptr() == code.function());
            uword pc = it.pc();
            ASSERT(pc != 0);
            ASSERT(code.PayloadStart() <= pc);
            ASSERT(pc < (code.PayloadStart() + code.Size()));
 
            ActivationFrame* activation = new ActivationFrame(
                pc, fp, sp, code, deopt_frame, deopt_frame_offset);
            stack_trace->AddActivation(activation);
          }
        } else {
          ActivationFrame* activation = new ActivationFrame(
              pc, fp, sp, code, deopt_frame, deopt_frame_offset);
          stack_trace->AddActivation(activation);
        }
      }
    }
  }
  return stack_trace;
}

GetHandlerFrame()

ActivationFrame * dart::DebuggerStackTrace::GetHandlerFrame

(

const Instance &

exc_obj

)

const

Definition at line 733 of file debugger.cc.

                                   {
  if (FLAG_trace_debugger_stacktrace) {
    OS::PrintErr("GetHandlerFrame(%s)\n", exc_obj.ToCString());
  }
 
  for (intptr_t frame_index = 0; frame_index < Length(); frame_index++) {
    ActivationFrame* frame = FrameAt(frame_index);
    const bool can_handle = frame->HandlesException(exc_obj);
    if (FLAG_trace_debugger_stacktrace) {
      OS::PrintErr("    #%04" Pd " (%s) %s", frame_index,
                   can_handle ? "+" : "-", frame->ToCString());
    }
    if (can_handle) {
      return frame;
    }
  }
  return nullptr;
}

has_async_catch_error()

bool dart::DebuggerStackTrace::has_async_catch_error ( ) const

inline

Definition at line 477 of file debugger.h.

{ return has_async_catch_error_; }

Length()

intptr_t dart::DebuggerStackTrace::Length ( ) const

inline

Definition at line 463 of file debugger.h.

{ return trace_.length(); }

set_has_async_catch_error()

void dart::DebuggerStackTrace::set_has_async_catch_error ( bool  has_async_catch_error )

inline

Definition at line 478 of file debugger.h.

                                                             {
    has_async_catch_error_ = has_async_catch_error;
  }

Friends And Related Symbol Documentation

Debugger

friend class Debugger

friend

Definition at line 496 of file debugger.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/debugger.h
• third_party/dart-lang/sdk/runtime/vm/debugger.cc