dart::Debugger Class Reference

#include <debugger.h>

Public Types
enum	ResumeAction {   kContinue , kStepInto , kStepOver , kStepOut ,   kStepRewind , kStepOverAsyncSuspension }

Public Member Functions
	Debugger (Isolate *isolate)
	~Debugger ()
Isolate *	isolate () const
void	NotifyIsolateCreated ()
void	Shutdown ()
void	NotifyDoneLoading ()
Breakpoint *	SetBreakpointAtEntry (const Function &target_function, bool single_shot)
Breakpoint *	SetBreakpointAtActivation (const Instance &closure, bool single_shot)
Breakpoint *	BreakpointAtActivation (const Instance &closure)
Breakpoint *	SetBreakpointAtLine (const String &script_url, intptr_t line_number)
Breakpoint *	SetBreakpointAtLineCol (const String &script_url, intptr_t line_number, intptr_t column_number)
BreakpointLocation *	BreakpointLocationAtLineCol (const String &script_url, intptr_t line_number, intptr_t column_number)
bool	SetBreakpointState (Breakpoint *bpt, bool enable)
void	RemoveBreakpoint (intptr_t bp_id)
Breakpoint *	GetBreakpointById (intptr_t id)
void	AsyncStepInto (const Closure &awaiter)
void	Continue ()
bool	SetResumeAction (ResumeAction action, intptr_t frame_index=1, const char **error=nullptr)
bool	IsStepping () const
bool	IsSingleStepping () const
bool	IsPaused () const
bool	ignore_breakpoints () const
void	set_ignore_breakpoints (bool ignore_breakpoints)
void	EnterSingleStepMode ()
const ServiceEvent *	PauseEvent () const
void	SetExceptionPauseInfo (Dart_ExceptionPauseInfo pause_info)
Dart_ExceptionPauseInfo	GetExceptionPauseInfo () const
void	VisitObjectPointers (ObjectPointerVisitor *visitor)
DebuggerStackTrace *	StackTrace ()
DebuggerStackTrace *	AsyncAwaiterStackTrace ()
ErrorPtr	PauseBreakpoint ()
ErrorPtr	PauseStepping ()
ErrorPtr	PauseInterrupted ()
ErrorPtr	PausePostRequest ()
void	PauseException (const Instance &exc)
void	PauseDeveloper (const String &msg)
void	PrintBreakpointsToJSONArray (JSONArray *jsarr) const
void	PrintSettingsToJSONObject (JSONObject *jsobj) const
intptr_t	limitBreakpointId ()
void	RewindPostDeopt ()
void	SetBreakpointAtResumption (const Object &function_data)
void	ResumptionBreakpoint ()

Static Public Member Functions
static bool	IsDebuggable (const Function &func)

Friends
class	Isolate
class	BreakpointLocation

Detailed Description

Definition at line 659 of file debugger.h.

Member Enumeration Documentation

ResumeAction

enum dart::Debugger::ResumeAction

Enumerator
kContinue
kStepInto
kStepOver
kStepOut
kStepRewind
kStepOverAsyncSuspension

Definition at line 661 of file debugger.h.

                    {
    kContinue,
    kStepInto,
    kStepOver,
    kStepOut,
    kStepRewind,
    kStepOverAsyncSuspension,
  };

Constructor & Destructor Documentation

Debugger()

dart::Debugger::Debugger ( Isolate *  isolate )

explicit

Definition at line 1408 of file debugger.cc.

    : isolate_(isolate),
      next_id_(1),
      latent_locations_(nullptr),
      breakpoint_locations_(nullptr),
      resume_action_(kContinue),
      resume_frame_index_(-1),
      post_deopt_frame_index_(-1),
      ignore_breakpoints_(false),
      pause_event_(nullptr),
      stack_trace_(nullptr),
      async_awaiter_stack_trace_(nullptr),
      stepping_fp_(0),
      last_stepping_fp_(0),
      last_stepping_pos_(TokenPosition::kNoSource),
      skip_next_step_(false),
      exc_pause_info_(kNoPauseOnExceptions) {}

~Debugger()

dart::Debugger::~Debugger

(

)

Definition at line 1426 of file debugger.cc.

                    {
  ASSERT(!IsPaused());
  ASSERT(latent_locations_ == nullptr);
  ASSERT(breakpoint_locations_ == nullptr);
  ASSERT(stack_trace_ == nullptr);
  ASSERT(async_awaiter_stack_trace_ == nullptr);
}

Member Function Documentation

AsyncAwaiterStackTrace()

DebuggerStackTrace * dart::Debugger::AsyncAwaiterStackTrace

(

)

Definition at line 1802 of file debugger.cc.

                                                     {
  return (async_awaiter_stack_trace_ != nullptr)
             ? async_awaiter_stack_trace_
             : DebuggerStackTrace::CollectAsyncAwaiters();
}

AsyncStepInto()

void dart::Debugger::AsyncStepInto

(

const Closure &

awaiter

)

Definition at line 4165 of file debugger.cc.

                                                   {
  Zone* zone = Thread::Current()->zone();
 
  auto& suspend_state = SuspendState::Handle(zone);
  if (StackTraceUtils::GetSuspendState(awaiter, &suspend_state)) {
    const auto& function_data =
        Object::Handle(zone, suspend_state.function_data());
    SetBreakpointAtResumption(function_data);
  } else {
    SetBreakpointAtActivation(awaiter, /*single_shot=*/true);
  }
  Continue();
}

BreakpointAtActivation()

Breakpoint * dart::Debugger::BreakpointAtActivation

(

const Instance &

closure

)

Definition at line 2756 of file debugger.cc.

                                                                    {
  if (!closure.IsClosure()) {
    return nullptr;
  }
 
  BreakpointLocation* loc = breakpoint_locations_;
  while (loc != nullptr) {
    Breakpoint* bpt = loc->breakpoints();
    while (bpt != nullptr) {
      if (closure.ptr() == bpt->closure()) {
        return bpt;
      }
      bpt = bpt->next();
    }
    loc = loc->next();
  }
 
  return nullptr;
}

BreakpointLocationAtLineCol()

BreakpointLocation * dart::Debugger::BreakpointLocationAtLineCol	(	const String &	script_url,
		intptr_t	line_number,
		intptr_t	column_number
	)

Definition at line 2840 of file debugger.cc.

                            {
  Zone* zone = Thread::Current()->zone();
  Library& lib = Library::Handle(zone);
  GrowableHandlePtrArray<const Script> scripts(zone, 1);
  const GrowableObjectArray& libs = GrowableObjectArray::Handle(
      isolate_->group()->object_store()->libraries());
  bool is_package = script_url.StartsWith(Symbols::PackageScheme());
  bool is_dart_colon = script_url.StartsWith(Symbols::DartScheme());
  Script& script_for_lib = Script::Handle(zone);
  for (intptr_t i = 0; i < libs.Length(); i++) {
    lib ^= libs.At(i);
    // Ensure that all top-level members are loaded so their scripts
    // are available for look up. When certain script only contains
    // top level functions, scripts could still be loaded correctly.
    lib.EnsureTopLevelClassIsFinalized();
    bool useResolvedUri = !is_package && !is_dart_colon;
    script_for_lib = lib.LookupScript(script_url, useResolvedUri);
    if (!script_for_lib.IsNull()) {
      scripts.Add(script_for_lib);
    }
  }
  if (scripts.length() == 0) {
    // No script found with given url. Create a latent breakpoint which
    // will be set if the url is loaded later.
    BreakpointLocation* latent_bpt =
        GetLatentBreakpoint(script_url, line_number, column_number);
    if (FLAG_verbose_debug) {
      OS::PrintErr(
          "Set latent breakpoint in url '%s' at "
          "line %" Pd " col %" Pd "\n",
          script_url.ToCString(), line_number, column_number);
    }
    return latent_bpt;
  }
  TokenPosition first_token_idx = TokenPosition::kNoSource;
  TokenPosition last_token_idx = TokenPosition::kNoSource;
  // Assume all scripts with the same URL have the same token positions.
  scripts.At(0).TokenRangeAtLine(line_number, &first_token_idx,
                                 &last_token_idx);
  if (!first_token_idx.IsReal()) {
    // Script does not contain the given line number.
    if (FLAG_verbose_debug) {
      OS::PrintErr("Script '%s' does not contain line number %" Pd "\n",
                   script_url.ToCString(), line_number);
    }
    return nullptr;
  } else if (!last_token_idx.IsReal()) {
    // Line does not contain any tokens.
    if (FLAG_verbose_debug) {
      OS::PrintErr("No executable code at line %" Pd " in '%s'\n", line_number,
                   script_url.ToCString());
    }
    return nullptr;
  }
 
  BreakpointLocation* loc = nullptr;
  ASSERT(first_token_idx <= last_token_idx);
  while ((loc == nullptr) && (first_token_idx <= last_token_idx)) {
    loc = SetBreakpoint(scripts, first_token_idx, last_token_idx, line_number,
                        column_number, Function::Handle());
    first_token_idx = first_token_idx.Next();
  }
  if ((loc == nullptr) && FLAG_verbose_debug) {
    OS::PrintErr("No executable code at line %" Pd " in '%s'\n", line_number,
                 script_url.ToCString());
  }
  return loc;
}

Continue()

void dart::Debugger::Continue

(

)

Definition at line 4179 of file debugger.cc.

                        {
  SetResumeAction(kContinue);
  ResetSteppingFramePointer();
  NotifySingleStepping(false);
}

EnterSingleStepMode()

void dart::Debugger::EnterSingleStepMode

(

)

Definition at line 3102 of file debugger.cc.

                                   {
  ResetSteppingFramePointer();
  NotifySingleStepping(true);
}

GetBreakpointById()

Breakpoint * dart::Debugger::GetBreakpointById

(

intptr_t

id

)

Definition at line 4141 of file debugger.cc.

                                                   {
  Breakpoint* bpt = GetBreakpointByIdInTheList(id, breakpoint_locations_);
  if (bpt != nullptr) {
    return bpt;
  }
  return GetBreakpointByIdInTheList(id, latent_locations_);
}

GetExceptionPauseInfo()

Dart_ExceptionPauseInfo dart::Debugger::GetExceptionPauseInfo

(

)

const

Definition at line 1867 of file debugger.cc.

                                                              {
  return exc_pause_info_;
}

ignore_breakpoints()

bool dart::Debugger::ignore_breakpoints ( ) const

inline

Definition at line 718 of file debugger.h.

{ return ignore_breakpoints_; }

IsDebuggable()

bool dart::Debugger::IsDebuggable ( const Function &  func )

static

Definition at line 3426 of file debugger.cc.

                                                {
  if (!func.is_debuggable()) {
    return false;
  }
  const Class& cls = Class::Handle(func.Owner());
  const Library& lib = Library::Handle(cls.library());
  return lib.IsDebuggable();
}

isolate()

Isolate * dart::Debugger::isolate ( ) const

inline

Definition at line 673 of file debugger.h.

{ return isolate_; }

IsPaused()

bool dart::Debugger::IsPaused ( ) const

inline

Definition at line 716 of file debugger.h.

{ return pause_event_ != nullptr; }

IsSingleStepping()

bool dart::Debugger::IsSingleStepping ( ) const

inline

Definition at line 714 of file debugger.h.

{ return resume_action_ == kStepInto; }

IsStepping()

bool dart::Debugger::IsStepping ( ) const

inline

Definition at line 712 of file debugger.h.

{ return resume_action_ != kContinue; }

limitBreakpointId()

intptr_t dart::Debugger::limitBreakpointId ( )

inline

Definition at line 772 of file debugger.h.

{ return next_id_; }

NotifyDoneLoading()

void dart::Debugger::NotifyDoneLoading

(

)

Definition at line 3772 of file debugger.cc.

                                 {
  if (latent_locations_ == nullptr) {
    // Common, fast path.
    return;
  }
  auto thread = Thread::Current();
  auto isolate_group = thread->isolate_group();
  auto zone = thread->zone();
  Library& lib = Library::Handle(zone);
  Script& script = Script::Handle(zone);
  String& url = String::Handle(zone);
  BreakpointLocation* loc = latent_locations_;
  BreakpointLocation* prev_loc = nullptr;
  const GrowableObjectArray& libs =
      GrowableObjectArray::Handle(isolate_group->object_store()->libraries());
 
  GrowableHandlePtrArray<const Script> scripts(zone, 1);
  while (loc != nullptr) {
    url = loc->url();
    bool found_match = false;
    bool is_package = url.StartsWith(Symbols::PackageScheme());
    for (intptr_t i = 0; i < libs.Length(); i++) {
      lib ^= libs.At(i);
      script = lib.LookupScript(url, !is_package);
      if (!script.IsNull()) {
        scripts.Add(script);
      }
    }
    if (scripts.length() > 0) {
      // Found a script with matching url for this latent breakpoint.
      // Unlink the latent breakpoint from the list.
      found_match = true;
      BreakpointLocation* matched_loc = loc;
      loc = loc->next();
      if (prev_loc == nullptr) {
        latent_locations_ = loc;
      } else {
        prev_loc->set_next(loc);
      }
      // Now find the token range at the requested line and make a
      // new unresolved source breakpoint.
      intptr_t line_number = matched_loc->requested_line_number();
      intptr_t column_number = matched_loc->requested_column_number();
      ASSERT(line_number >= 0);
      TokenPosition first_token_pos = TokenPosition::kNoSource;
      TokenPosition last_token_pos = TokenPosition::kNoSource;
      scripts.At(0).TokenRangeAtLine(line_number, &first_token_pos,
                                     &last_token_pos);
      if (!first_token_pos.IsDebugPause() || !last_token_pos.IsDebugPause()) {
        // Script does not contain the given line number or there are no
        // tokens on the line. Drop the breakpoint silently.
        Breakpoint* bpt = matched_loc->breakpoints();
        while (bpt != nullptr) {
          if (FLAG_verbose_debug) {
            OS::PrintErr("No code found at line %" Pd
                         ": "
                         "dropping latent breakpoint %" Pd " in '%s'\n",
                         line_number, bpt->id(), url.ToCString());
          }
          Breakpoint* prev = bpt;
          bpt = bpt->next();
          delete prev;
        }
        delete matched_loc;
      } else {
        // We don't expect to already have a breakpoint for this location.
        // If there is one, assert in debug build but silently drop
        // the latent breakpoint in release build.
        BreakpointLocation* existing_loc =
            GetBreakpointLocation(url, first_token_pos, -1, column_number);
        ASSERT(existing_loc == nullptr);
        if (existing_loc == nullptr) {
          // Create and register a new source breakpoint for the
          // latent breakpoint.
          BreakpointLocation* unresolved_loc = new BreakpointLocation(
              this, scripts, first_token_pos, last_token_pos, line_number,
              column_number);
          RegisterBreakpointLocation(unresolved_loc);
 
          // Move breakpoints over.
          Breakpoint* bpt = matched_loc->breakpoints();
          unresolved_loc->set_breakpoints(bpt);
          matched_loc->set_breakpoints(nullptr);
          while (bpt != nullptr) {
            bpt->set_bpt_location(unresolved_loc);
            if (FLAG_verbose_debug) {
              OS::PrintErr(
                  "Converted latent breakpoint "
                  "%" Pd " in '%s' at line %" Pd " col %" Pd "\n",
                  bpt->id(), url.ToCString(), line_number, column_number);
            }
            bpt = bpt->next();
          }
          group_debugger()->SyncBreakpointLocation(unresolved_loc);
        }
        delete matched_loc;
        // Break out of the iteration over loaded libraries. If the
        // same url has been loaded into more than one library, we
        // only set a breakpoint in the first one.
        // TODO(hausner): There is one possible pitfall here.
        // If the user sets a latent breakpoint using a partial url that
        // ends up matching more than one script, the breakpoint might
        // get set in the wrong script.
        // It would be better if we could warn the user if multiple
        // scripts are matching.
        break;
      }
    }
    if (!found_match) {
      // No matching url found in any of the libraries.
      if (FLAG_verbose_debug) {
        Breakpoint* bpt = loc->breakpoints();
        while (bpt != nullptr) {
          OS::PrintErr(
              "No match found for latent breakpoint id "
              "%" Pd " with url '%s'\n",
              bpt->id(), url.ToCString());
          bpt = bpt->next();
        }
      }
      loc = loc->next();
    }
  }
}

NotifyIsolateCreated()

void dart::Debugger::NotifyIsolateCreated

(

)

Definition at line 3749 of file debugger.cc.

                                    {
  if (NeedsIsolateEvents()) {
    ServiceEvent event(isolate_, ServiceEvent::kIsolateStart);
    InvokeEventHandler(&event);
  }
}

PauseBreakpoint()

ErrorPtr dart::Debugger::PauseBreakpoint

(

)

Definition at line 3633 of file debugger.cc.

                                   {
  // We ignore this breakpoint when the VM is executing code invoked
  // by the debugger to evaluate variables values, or when we see a nested
  // breakpoint or exception event.
  if (ignore_breakpoints_ || IsPaused()) {
    return Error::null();
  }
  DebuggerStackTrace* stack_trace = DebuggerStackTrace::Collect();
  ASSERT(stack_trace->Length() > 0);
  ActivationFrame* top_frame = stack_trace->FrameAt(0);
  ASSERT(top_frame != nullptr);
  if (!Library::Handle(top_frame->Library()).IsDebuggable()) {
    return Error::null();
  }
 
  BreakpointLocation* bpt_location = nullptr;
  const char* cbpt_tostring = nullptr;
  {
    SafepointReadRwLocker cbl(Thread::Current(),
                              group_debugger()->code_breakpoints_lock());
    CodeBreakpoint* cbpt = nullptr;
    bpt_location = group_debugger()->GetBreakpointLocationFor(
        this, top_frame->pc(), &cbpt);
    if (bpt_location == nullptr) {
      // There might be no breakpoint locations for this isolate/debugger.
      return Error::null();
    }
    ASSERT(cbpt != nullptr);
    if (FLAG_verbose_debug) {
      cbpt_tostring = cbpt->ToCString();
    }
  }
 
  Breakpoint* bpt_hit = bpt_location->FindHitBreakpoint(top_frame);
  if (bpt_hit == nullptr) {
    return Error::null();
  }
 
  if (FLAG_verbose_debug) {
    OS::PrintErr(">>> hit %" Pd
                 " %s"
                 " (func %s token %s address %#" Px " offset %#" Px ")\n",
                 bpt_hit->id(), cbpt_tostring,
                 String::Handle(top_frame->QualifiedFunctionName()).ToCString(),
                 bpt_location->token_pos().ToCString(), top_frame->pc(),
                 top_frame->pc() - top_frame->code().PayloadStart());
  }
 
  CacheStackTraces(stack_trace, DebuggerStackTrace::CollectAsyncAwaiters());
  SignalPausedEvent(top_frame, bpt_hit);
  // When we single step from a user breakpoint, our next stepping
  // point will be at the exact same pc.  Skip it.
  HandleSteppingRequest(/*skip_next_step=*/true);
  ClearCachedStackTraces();
 
  // If any error occurred while in the debug message loop, return it here.
  return Thread::Current()->StealStickyError();
}

PauseDeveloper()

void dart::Debugger::PauseDeveloper

(

const String &

msg

)

Definition at line 3728 of file debugger.cc.

                                               {
  // We ignore this breakpoint when the VM is executing code invoked
  // by the debugger to evaluate variables values, or when we see a nested
  // breakpoint or exception event.
  if (ignore_breakpoints_ || IsPaused()) {
    return;
  }
 
  DebuggerStackTrace* stack_trace = DebuggerStackTrace::Collect();
  ASSERT(stack_trace->Length() > 0);
  CacheStackTraces(stack_trace, DebuggerStackTrace::CollectAsyncAwaiters());
  // TODO(johnmccutchan): Send |msg| to Observatory.
 
  // We are in the native call to Developer_debugger.  the developer
  // gets a better experience by not seeing this call. To accomplish
  // this, we continue execution until the call exits (step out).
  SetResumeAction(kStepOut);
  HandleSteppingRequest();
  ClearCachedStackTraces();
}

PauseEvent()

const ServiceEvent * dart::Debugger::PauseEvent ( ) const

inline

Definition at line 733 of file debugger.h.

{ return pause_event_; }

PauseException()

void dart::Debugger::PauseException

(

const Instance &

exc

)

Definition at line 1914 of file debugger.cc.

                                                 {
  if (FLAG_stress_async_stacks) {
    DebuggerStackTrace::CollectAsyncAwaiters();
  }
  // We ignore this exception event when the VM is executing code invoked
  // by the debugger to evaluate variables values, when we see a nested
  // breakpoint or exception event, or if the debugger is not
  // interested in exception events.
  if (ignore_breakpoints_ || IsPaused() ||
      (exc_pause_info_ == kNoPauseOnExceptions)) {
    return;
  }
  DebuggerStackTrace* async_awaiter_stack_trace =
      DebuggerStackTrace::CollectAsyncAwaiters();
  DebuggerStackTrace* stack_trace = DebuggerStackTrace::Collect();
  if (async_awaiter_stack_trace != nullptr) {
    if (!ShouldPauseOnException(async_awaiter_stack_trace, exc)) {
      return;
    }
  } else {
    if (!ShouldPauseOnException(stack_trace, exc)) {
      return;
    }
  }
  ServiceEvent event(isolate_, ServiceEvent::kPauseException);
  event.set_exception(&exc);
  if (stack_trace->Length() > 0) {
    event.set_top_frame(stack_trace->FrameAt(0));
  }
  CacheStackTraces(stack_trace, async_awaiter_stack_trace);
  Pause(&event);
  HandleSteppingRequest();  // we may get a rewind request
  ClearCachedStackTraces();
}

PauseInterrupted()

ErrorPtr dart::Debugger::PauseInterrupted

(

)

Definition at line 289 of file debugger.cc.

                                    {
  return PauseRequest(ServiceEvent::kPauseInterrupted);
}

PausePostRequest()

ErrorPtr dart::Debugger::PausePostRequest

(

)

Definition at line 293 of file debugger.cc.

                                    {
  return PauseRequest(ServiceEvent::kPausePostRequest);
}

PauseStepping()

ErrorPtr dart::Debugger::PauseStepping

(

)

Definition at line 3547 of file debugger.cc.

                                 {
  ASSERT(isolate_->single_step());
  // Don't pause recursively.
  if (IsPaused()) {
    return Error::null();
  }
  if (skip_next_step_) {
    skip_next_step_ = false;
    return Error::null();
  }
 
  // Check whether we are in a Dart function that the user is
  // interested in. If we saved the frame pointer of a stack frame
  // the user is interested in, we ignore the single step if we are
  // in a callee of that frame. Note that we assume that the stack
  // grows towards lower addresses.
  ActivationFrame* frame = TopDartFrame();
  ASSERT(frame != nullptr);
 
  if (stepping_fp_ != 0) {
    // There is an "interesting frame" set. Only pause at appropriate
    // locations in this frame.
    const ActivationFrame::Relation relation = frame->CompareTo(stepping_fp_);
    if (relation == ActivationFrame::kCallee) {
      // We are in a callee of the frame we're interested in.
      // Ignore this stepping break.
      return Error::null();
    } else if (relation == ActivationFrame::kCaller) {
      // We returned from the "interesting frame", there can be no more
      // stepping breaks for it. Pause at the next appropriate location
      // and let the user set the "interesting" frame again.
      ResetSteppingFramePointer();
    }
  }
 
  if (!frame->IsDebuggable()) {
    return Error::null();
  }
  if (!frame->TokenPos().IsDebugPause()) {
    return Error::null();
  }
 
  if (frame->fp() == last_stepping_fp_ &&
      frame->TokenPos() == last_stepping_pos_) {
    // Do not stop multiple times for the same token position.
    // Several 'debug checked' opcodes may be issued in the same token range.
    return Error::null();
  }
 
  // TODO(dartbug.com/48378): Consider aligning async/async* functions
  // with regular function wrt the first stop in the function prologue.
  if ((frame->function().IsAsyncFunction() ||
       frame->function().IsAsyncGenerator()) &&
      frame->GetSuspendStateVar() == Object::null()) {
    return Error::null();
  }
 
  // We are stopping in this frame at the token pos.
  last_stepping_fp_ = frame->fp();
  last_stepping_pos_ = frame->TokenPos();
 
  // If there is an active breakpoint at this pc, then we should have
  // already bailed out of this function in the skip_next_step_ test
  // above.
  ASSERT(!group_debugger()->HasActiveBreakpoint(frame->pc()));
 
  if (FLAG_verbose_debug) {
    OS::PrintErr(">>> single step break at %s:%" Pd ":%" Pd
                 " (func %s token %s address %#" Px " offset %#" Px ")\n",
                 String::Handle(frame->SourceUrl()).ToCString(),
                 frame->LineNumber(), frame->ColumnNumber(),
                 String::Handle(frame->QualifiedFunctionName()).ToCString(),
                 frame->TokenPos().ToCString(), frame->pc(),
                 frame->pc() - frame->code().PayloadStart());
  }
 
  CacheStackTraces(DebuggerStackTrace::Collect(),
                   DebuggerStackTrace::CollectAsyncAwaiters());
  SignalPausedEvent(frame, nullptr);
  HandleSteppingRequest();
  ClearCachedStackTraces();
 
  // If any error occurred while in the debug message loop, return it here.
  return Thread::Current()->StealStickyError();
}

PrintBreakpointsToJSONArray()

void dart::Debugger::PrintBreakpointsToJSONArray

(

JSONArray *

jsarr

)

const

Definition at line 451 of file debugger.cc.

                                                                 {
  PrintBreakpointsListToJSONArray(breakpoint_locations_, jsarr);
  PrintBreakpointsListToJSONArray(latent_locations_, jsarr);
}

PrintSettingsToJSONObject()

void dart::Debugger::PrintSettingsToJSONObject

(

JSONObject *

jsobj

)

const

Definition at line 468 of file debugger.cc.

                                                                {
  // This won't cut it when we support filtering by class, etc.
  switch (GetExceptionPauseInfo()) {
    case kNoPauseOnExceptions:
      jsobj->AddProperty("_exceptions", "none");
      break;
    case kPauseOnAllExceptions:
      jsobj->AddProperty("_exceptions", "all");
      break;
    case kPauseOnUnhandledExceptions:
      jsobj->AddProperty("_exceptions", "unhandled");
      break;
    default:
      UNREACHABLE();
  }
}

RemoveBreakpoint()

void dart::Debugger::RemoveBreakpoint

(

intptr_t

bp_id

)

Definition at line 3967 of file debugger.cc.

                                              {
  SafepointWriteRwLocker sl(Thread::Current(),
                            group_debugger()->breakpoint_locations_lock());
  if (RemoveBreakpointFromTheList(bp_id, &breakpoint_locations_)) {
    return;
  }
  RemoveBreakpointFromTheList(bp_id, &latent_locations_);
}

ResumptionBreakpoint()

void dart::Debugger::ResumptionBreakpoint

(

)

Definition at line 2783 of file debugger.cc.

                                    {
  ASSERT(!breakpoints_at_resumption_.is_empty());
  ASSERT(isolate_->has_resumption_breakpoints());
 
  ActivationFrame* top_frame = TopDartFrame();
  ASSERT(top_frame->function().IsSuspendableFunction());
  const auto& function_data =
      Object::Handle(top_frame->GetSuspendableFunctionData());
 
  for (intptr_t i = 0, n = breakpoints_at_resumption_.length(); i < n; ++i) {
    if (breakpoints_at_resumption_[i] == function_data.ptr()) {
      breakpoints_at_resumption_.RemoveAt(i);
      if (breakpoints_at_resumption_.is_empty()) {
        isolate_->set_has_resumption_breakpoints(false);
      }
      if (FLAG_verbose_debug) {
        OS::PrintErr(
            "ResumptionBreakpoint - hit a breakpoint, continue single "
            "stepping\n");
      }
      EnterSingleStepMode();
      return;
    }
  }
}

RewindPostDeopt()

void dart::Debugger::RewindPostDeopt

(

)

Definition at line 3383 of file debugger.cc.

                               {
  intptr_t rewind_frame = post_deopt_frame_index_;
  post_deopt_frame_index_ = -1;
  if (FLAG_trace_rewind) {
    OS::PrintErr("Post deopt, jumping to frame %" Pd "\n", rewind_frame);
    OS::PrintErr(
        "-------------------------\n"
        "All frames...\n\n");
    StackFrameIterator iterator(ValidationPolicy::kDontValidateFrames,
                                Thread::Current(),
                                StackFrameIterator::kNoCrossThreadIteration);
    StackFrame* frame = iterator.NextFrame();
    intptr_t num = 0;
    while ((frame != nullptr)) {
      OS::PrintErr("#%04" Pd " %s\n", num++, frame->ToCString());
      frame = iterator.NextFrame();
    }
  }
 
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  Code& code = Code::Handle(zone);
 
  StackFrameIterator iterator(ValidationPolicy::kDontValidateFrames,
                              Thread::Current(),
                              StackFrameIterator::kNoCrossThreadIteration);
  intptr_t current_frame = 0;
  for (StackFrame* frame = iterator.NextFrame(); frame != nullptr;
       frame = iterator.NextFrame()) {
    ASSERT(frame->IsValid());
    if (frame->IsDartFrame()) {
      code = frame->LookupDartCode();
      ASSERT(!code.is_optimized());
      if (current_frame == rewind_frame) {
        RewindToUnoptimizedFrame(frame, code);
        UNREACHABLE();
      }
      current_frame++;
    }
  }
}

set_ignore_breakpoints()

void dart::Debugger::set_ignore_breakpoints ( bool  ignore_breakpoints )

inline

Definition at line 719 of file debugger.h.

                                                       {
    ignore_breakpoints_ = ignore_breakpoints;
  }

SetBreakpointAtActivation()

Breakpoint * dart::Debugger::SetBreakpointAtActivation	(	const Instance &	closure,
		bool	single_shot
	)

Definition at line 2743 of file debugger.cc.

                                                                  {
  if (!closure.IsClosure()) {
    return nullptr;
  }
  const Function& func = Function::Handle(Closure::Cast(closure).function());
  const Script& script = Script::Handle(func.script());
  BreakpointLocation* bpt_location =
      SetBreakpoint(script, func.token_pos(), func.end_token_pos(), -1,
                    -1 /* no line/col */, func);
  return bpt_location->AddBreakpoint(this, Closure::Cast(closure), single_shot);
}

SetBreakpointAtEntry()

Breakpoint * dart::Debugger::SetBreakpointAtEntry	(	const Function &	target_function,
		bool	single_shot
	)

Definition at line 2722 of file debugger.cc.

                                                             {
  ASSERT(!target_function.IsNull());
  if (!target_function.is_debuggable()) {
    return nullptr;
  }
  const Script& script = Script::Handle(target_function.script());
  BreakpointLocation* bpt_location = SetBreakpoint(
      script, target_function.token_pos(), target_function.end_token_pos(), -1,
      -1 /* no requested line/col */, target_function);
  if (bpt_location == nullptr) {
    return nullptr;
  }
 
  if (single_shot) {
    return bpt_location->AddSingleShot(this);
  } else {
    return bpt_location->AddRepeated(this);
  }
}

SetBreakpointAtLine()

Breakpoint * dart::Debugger::SetBreakpointAtLine	(	const String &	script_url,
		intptr_t	line_number
	)

Definition at line 2809 of file debugger.cc.

                                                                {
  // Prevent future tests from calling this function in the wrong
  // execution state.  If you hit this assert, consider using
  // Dart_SetBreakpoint instead.
  ASSERT(Thread::Current()->execution_state() == Thread::kThreadInVM);
 
  BreakpointLocation* loc =
      BreakpointLocationAtLineCol(script_url, line_number, -1 /* no column */);
  if (loc != nullptr) {
    return loc->AddRepeated(this);
  }
  return nullptr;
}

SetBreakpointAtLineCol()

Breakpoint * dart::Debugger::SetBreakpointAtLineCol	(	const String &	script_url,
		intptr_t	line_number,
		intptr_t	column_number
	)

Definition at line 2824 of file debugger.cc.

                                                                     {
  // Prevent future tests from calling this function in the wrong
  // execution state.  If you hit this assert, consider using
  // Dart_SetBreakpoint instead.
  ASSERT(Thread::Current()->execution_state() == Thread::kThreadInVM);
 
  BreakpointLocation* loc =
      BreakpointLocationAtLineCol(script_url, line_number, column_number);
  if (loc != nullptr) {
    return loc->AddRepeated(this);
  }
  return nullptr;
}

SetBreakpointAtResumption()

void dart::Debugger::SetBreakpointAtResumption

(

const Object &

function_data

)

Definition at line 2776 of file debugger.cc.

                                                                    {
  ASSERT(!function_data.IsNull());
  ASSERT(function_data.IsInstance());
  breakpoints_at_resumption_.Add(function_data.ptr());
  isolate_->set_has_resumption_breakpoints(true);
}

SetBreakpointState()

bool dart::Debugger::SetBreakpointState	(	Breakpoint *	bpt,
		bool	enable
	)

Definition at line 3950 of file debugger.cc.

                                                              {
  SafepointWriteRwLocker sl(Thread::Current(),
                            group_debugger()->breakpoint_locations_lock());
  if (bpt->is_enabled() != enable) {
    if (FLAG_verbose_debug) {
      OS::PrintErr("Setting breakpoint %" Pd " to state: %s\n", bpt->id(),
                   enable ? "enabled" : "disabled");
    }
    enable ? bpt->Enable() : bpt->Disable();
    group_debugger()->SyncBreakpointLocation(bpt->bpt_location());
    return true;
  }
  return false;
}

SetExceptionPauseInfo()

void dart::Debugger::SetExceptionPauseInfo

(

Dart_ExceptionPauseInfo

pause_info

)

Definition at line 1860 of file debugger.cc.

                                                                       {
  ASSERT((pause_info == kNoPauseOnExceptions) ||
         (pause_info == kPauseOnUnhandledExceptions) ||
         (pause_info == kPauseOnAllExceptions));
  exc_pause_info_ = pause_info;
}

SetResumeAction()

bool dart::Debugger::SetResumeAction	(	ResumeAction	action,
		intptr_t	frame_index = 1,
		const char **	error = nullptr
	)

Definition at line 1486 of file debugger.cc.

                                                   {
  if (error != nullptr) {
    *error = nullptr;
  }
  resume_frame_index_ = -1;
  switch (action) {
    case kStepInto:
    case kStepOver:
    case kStepOut:
    case kContinue:
      set_resume_action(action);
      return true;
    case kStepRewind:
      if (!CanRewindFrame(frame_index, error)) {
        return false;
      }
      set_resume_action(kStepRewind);
      resume_frame_index_ = frame_index;
      return true;
    case kStepOverAsyncSuspension:
      return SetupStepOverAsyncSuspension(error);
    default:
      UNREACHABLE();
      return false;
  }
}

Shutdown()

void dart::Debugger::Shutdown

(

)

Definition at line 1434 of file debugger.cc.

                        {
  // TODO(johnmccutchan): Do not create a debugger for isolates that don't need
  // them. Then, assert here that isolate_ is not one of those isolates.
  if (Isolate::IsSystemIsolate(isolate_)) {
    return;
  }
  {
    SafepointWriteRwLocker sl(Thread::Current(),
                              group_debugger()->breakpoint_locations_lock());
    while (breakpoint_locations_ != nullptr) {
      BreakpointLocation* loc = breakpoint_locations_;
      group_debugger()->UnlinkCodeBreakpoints(loc);
      group_debugger()->UnregisterBreakpointLocation(loc);
      breakpoint_locations_ = breakpoint_locations_->next();
      delete loc;
    }
    while (latent_locations_ != nullptr) {
      BreakpointLocation* loc = latent_locations_;
      group_debugger()->UnlinkCodeBreakpoints(loc);
      group_debugger()->UnregisterBreakpointLocation(loc);
      latent_locations_ = latent_locations_->next();
      delete loc;
    }
  }
  if (NeedsIsolateEvents()) {
    ServiceEvent event(isolate_, ServiceEvent::kIsolateExit);
    InvokeEventHandler(&event);
  }
}

StackTrace()

DebuggerStackTrace * dart::Debugger::StackTrace

(

)

Definition at line 1797 of file debugger.cc.

                                         {
  return (stack_trace_ != nullptr) ? stack_trace_
                                   : DebuggerStackTrace::Collect();
}

VisitObjectPointers()

void dart::Debugger::VisitObjectPointers

(

ObjectPointerVisitor *

visitor

)

Definition at line 3037 of file debugger.cc.

                                                                {
  ASSERT(visitor != nullptr);
  BreakpointLocation* loc = breakpoint_locations_;
  while (loc != nullptr) {
    loc->VisitObjectPointers(visitor);
    loc = loc->next();
  }
  loc = latent_locations_;
  while (loc != nullptr) {
    loc->VisitObjectPointers(visitor);
    loc = loc->next();
  }
  for (intptr_t i = 0, n = breakpoints_at_resumption_.length(); i < n; ++i) {
    visitor->VisitPointer(&breakpoints_at_resumption_[i]);
  }
}

Friends And Related Function Documentation

BreakpointLocation

friend class BreakpointLocation

friend

Definition at line 927 of file debugger.h.

Isolate

friend class Isolate

friend

Definition at line 926 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