dart::GroupDebugger Class Reference

#include <debugger.h>

Public Member Functions
	GroupDebugger (IsolateGroup *isolate_group)
	~GroupDebugger ()
void	MakeCodeBreakpointAtUnsafe (const Function &func, BreakpointLocation *bpt)
void	MakeCodeBreakpointAt (const Function &func, BreakpointLocation *bpt)
CodeBreakpoint *	GetCodeBreakpoint (uword breakpoint_address)
BreakpointLocation *	GetBreakpointLocationFor (Debugger *debugger, uword breakpoint_address, CodeBreakpoint **pcbpt)
CodePtr	GetPatchedStubAddress (uword breakpoint_address)
void	RegisterBreakpointLocation (BreakpointLocation *location)
void	UnregisterBreakpointLocation (BreakpointLocation *location)
void	RemoveBreakpointLocation (BreakpointLocation *bpt_location)
void	UnlinkCodeBreakpoints (BreakpointLocation *bpt_location)
bool	HasActiveBreakpoint (uword pc)
bool	HasCodeBreakpointInFunctionUnsafe (const Function &func)
bool	HasCodeBreakpointInFunction (const Function &func)
bool	HasCodeBreakpointInCode (const Code &code)
bool	HasBreakpointInFunction (const Function &func)
bool	HasBreakpointInCode (const Code &code)
void	SyncBreakpointLocation (BreakpointLocation *loc)
void	Pause ()
bool	EnsureLocationIsInFunction (Zone *zone, const Function &function, BreakpointLocation *location)
void	NotifyCompilation (const Function &func)
void	VisitObjectPointers (ObjectPointerVisitor *visitor)
SafepointRwLock *	code_breakpoints_lock ()
SafepointRwLock *	breakpoint_locations_lock ()
RwLock *	single_stepping_set_lock ()
void	RegisterSingleSteppingDebugger (Thread *thread, const Debugger *debugger)
void	UnregisterSingleSteppingDebugger (Thread *thread, const Debugger *debugger)
bool	HasBreakpointUnsafe (Thread *thread, const Function &function)
bool	HasBreakpoint (Thread *thread, const Function &function)
bool	IsDebugging (Thread *thread, const Function &function)
IsolateGroup *	isolate_group ()

Detailed Description

Definition at line 571 of file debugger.h.

Constructor & Destructor Documentation

GroupDebugger()

dart::GroupDebugger::GroupDebugger ( IsolateGroup *  isolate_group )

explicit

Definition at line 1391 of file debugger.cc.

    : isolate_group_(isolate_group),
      code_breakpoints_lock_(new SafepointRwLock()),
      code_breakpoints_(nullptr),
      breakpoint_locations_lock_(new SafepointRwLock()),
      single_stepping_set_lock_(new RwLock()),
      needs_breakpoint_cleanup_(false) {}

~GroupDebugger()

dart::GroupDebugger::~GroupDebugger

(

)

Definition at line 1399 of file debugger.cc.

                              {
  while (code_breakpoints_ != nullptr) {
    CodeBreakpoint* cbpt = code_breakpoints_;
    code_breakpoints_ = code_breakpoints_->next();
    ASSERT(!cbpt->IsEnabled());
    delete cbpt;
  }
}

Member Function Documentation

breakpoint_locations_lock()

SafepointRwLock * dart::GroupDebugger::breakpoint_locations_lock ( )

inline

Definition at line 618 of file debugger.h.

                                               {
    return breakpoint_locations_lock_.get();
  }

code_breakpoints_lock()

SafepointRwLock * dart::GroupDebugger::code_breakpoints_lock ( )

inline

Definition at line 614 of file debugger.h.

                                           {
    return code_breakpoints_lock_.get();
  }

EnsureLocationIsInFunction()

bool dart::GroupDebugger::EnsureLocationIsInFunction	(	Zone *	zone,
		const Function &	function,
		BreakpointLocation *	location
	)

Definition at line 2916 of file debugger.cc.

                                                                             {
  const String& url = String::Handle(zone, location->url());
  if (!FunctionOverlaps(function, url, location->token_pos(),
                        location->end_token_pos())) {
    return false;
  }
 
  TokenPosition token_pos = location->token_pos();
#if !defined(DART_PRECOMPILED_RUNTIME)
  TokenPosition end_token_pos = location->end_token_pos();
  if (token_pos != end_token_pos && location->requested_column_number() >= 0) {
    // Narrow down the token position range to a single value
    // if requested column number is provided so that inner
    // Closure won't be missed.
    const Script& script = Script::Handle(location->script());
    token_pos = FindExactTokenPosition(script, token_pos,
                                       location->requested_column_number());
  }
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
  const Function& inner_function =
      Function::Handle(zone, FindInnermostClosure(zone, function, token_pos));
  if (!inner_function.IsNull()) {
    if (FLAG_verbose_debug) {
      OS::PrintErr(
          "Pending breakpoint remains unresolved in "
          "inner function '%s'\n",
          inner_function.ToFullyQualifiedCString());
    }
    return false;
  }
 
  // There is no local function within function that contains the
  // breakpoint token position.
  return true;
}

GetBreakpointLocationFor()

BreakpointLocation * dart::GroupDebugger::GetBreakpointLocationFor	(	Debugger *	debugger,
		uword	breakpoint_address,
		CodeBreakpoint **	pcbpt
	)

Definition at line 3893 of file debugger.cc.

                            {
  ASSERT(pcbpt != nullptr);
  SafepointReadRwLocker sl(Thread::Current(), code_breakpoints_lock());
  *pcbpt = code_breakpoints_;
  while (*pcbpt != nullptr) {
    if ((*pcbpt)->pc() == breakpoint_address) {
      return (*pcbpt)->FindBreakpointForDebugger(debugger);
    }
    *pcbpt = (*pcbpt)->next();
  }
  return nullptr;
}

GetCodeBreakpoint()

CodeBreakpoint * dart::GroupDebugger::GetCodeBreakpoint

(

uword

breakpoint_address

)

Definition at line 3882 of file debugger.cc.

                                                                         {
  CodeBreakpoint* cbpt = code_breakpoints_;
  while (cbpt != nullptr) {
    if (cbpt->pc() == breakpoint_address) {
      return cbpt;
    }
    cbpt = cbpt->next();
  }
  return nullptr;
}

GetPatchedStubAddress()

CodePtr dart::GroupDebugger::GetPatchedStubAddress

(

uword

breakpoint_address

)

Definition at line 3917 of file debugger.cc.

                                                                     {
  SafepointReadRwLocker sl(Thread::Current(), code_breakpoints_lock());
  CodeBreakpoint* cbpt = GetCodeBreakpoint(breakpoint_address);
  if (cbpt != nullptr) {
    return cbpt->OrigStubAddress();
  }
  UNREACHABLE();
  return Code::null();
}

HasActiveBreakpoint()

bool dart::GroupDebugger::HasActiveBreakpoint

(

uword

pc

)

Definition at line 3876 of file debugger.cc.

                                                {
  SafepointReadRwLocker sl(Thread::Current(), code_breakpoints_lock());
  CodeBreakpoint* cbpt = GetCodeBreakpoint(pc);
  return (cbpt != nullptr) && (cbpt->IsEnabled());
}

HasBreakpoint()

bool dart::GroupDebugger::HasBreakpoint	(	Thread *	thread,
		const Function &	function
	)

Definition at line 3441 of file debugger.cc.

                                                                          {
  bool hasBreakpoint = false;
  // Don't need to worry about the lock if mutators are stopped.
  if (thread->IsInStoppedMutatorsScope()) {
    hasBreakpoint = HasBreakpointUnsafe(thread, function);
  } else {
    SafepointReadRwLocker sl(thread, breakpoint_locations_lock());
    hasBreakpoint = HasBreakpointUnsafe(thread, function);
  }
  if (hasBreakpoint) {
    return true;
  }
 
  // TODO(aam): do we have to iterate over both code breakpoints and
  // breakpoint locations? Wouldn't be sufficient to iterate over only
  // one list? Could you have a CodeBreakpoint without corresponding
  // BreakpointLocation?
  if (HasCodeBreakpointInFunction(function)) {
    return true;
  }
 
  return false;
}

HasBreakpointInCode()

bool dart::GroupDebugger::HasBreakpointInCode

(

const Code &

code

)

Definition at line 438 of file debugger.cc.

                                                        {
  auto thread = Thread::Current();
  SafepointReadRwLocker sl(thread, code_breakpoints_lock());
  CodeBreakpoint* cbpt = code_breakpoints_;
  while (cbpt != nullptr) {
    if (code.ptr() == cbpt->code_) {
      return true;
    }
    cbpt = cbpt->next_;
  }
  return false;
}

HasBreakpointInFunction()

bool dart::GroupDebugger::HasBreakpointInFunction

(

const Function &

func

)

HasBreakpointUnsafe()

bool dart::GroupDebugger::HasBreakpointUnsafe	(	Thread *	thread,
		const Function &	function
	)

Definition at line 3424 of file debugger.cc.

                                                                  {
  DEBUG_ASSERT(thread->IsInStoppedMutatorsScope() ||
               breakpoint_locations_lock()->IsCurrentThreadReader());
  // Check if function has any breakpoints.
  String& url = String::Handle(thread->zone());
  for (intptr_t i = 0; i < breakpoint_locations_.length(); i++) {
    BreakpointLocation* location = breakpoint_locations_.At(i);
    url = location->url();
    if (FunctionOverlaps(function, url, location->token_pos(),
                         location->end_token_pos())) {
      return true;
    }
  }
  return false;
}

HasCodeBreakpointInCode()

bool dart::GroupDebugger::HasCodeBreakpointInCode

(

const Code &

code

)

HasCodeBreakpointInFunction()

bool dart::GroupDebugger::HasCodeBreakpointInFunction

(

const Function &

func

)

Definition at line 427 of file debugger.cc.

                                                                    {
  auto thread = Thread::Current();
  // Don't need to worry about the lock if mutators are stopped.
  if (thread->IsInStoppedMutatorsScope()) {
    return HasCodeBreakpointInFunctionUnsafe(func);
  } else {
    SafepointReadRwLocker sl(thread, code_breakpoints_lock());
    return HasCodeBreakpointInFunctionUnsafe(func);
  }
}

HasCodeBreakpointInFunctionUnsafe()

bool dart::GroupDebugger::HasCodeBreakpointInFunctionUnsafe

(

const Function &

func

)

Definition at line 414 of file debugger.cc.

                                                                          {
  DEBUG_ASSERT(code_breakpoints_lock()->IsCurrentThreadReader() ||
               Thread::Current()->IsInStoppedMutatorsScope());
  CodeBreakpoint* cbpt = code_breakpoints_;
  while (cbpt != nullptr) {
    if (func.ptr() == cbpt->function()) {
      return true;
    }
    cbpt = cbpt->next_;
  }
  return false;
}

IsDebugging()

bool dart::GroupDebugger::IsDebugging	(	Thread *	thread,
		const Function &	function
	)

Definition at line 3465 of file debugger.cc.

                                                                        {
  {
    ReadRwLocker ml(thread, single_stepping_set_lock());
    if (!single_stepping_set_.IsEmpty()) {
      return true;
    }
  }
  return HasBreakpoint(thread, function);
}

isolate_group()

IsolateGroup * dart::GroupDebugger::isolate_group ( )

inline

Definition at line 634 of file debugger.h.

{ return isolate_group_; }

MakeCodeBreakpointAt()

void dart::GroupDebugger::MakeCodeBreakpointAt	(	const Function &	func,
		BreakpointLocation *	bpt
	)

Definition at line 2269 of file debugger.cc.

                                                                  {
  auto thread = Thread::Current();
  if (thread->IsInStoppedMutatorsScope()) {
    MakeCodeBreakpointAtUnsafe(func, loc);
  } else {
    SafepointWriteRwLocker sl(thread, code_breakpoints_lock());
    MakeCodeBreakpointAtUnsafe(func, loc);
  }
}

MakeCodeBreakpointAtUnsafe()

void dart::GroupDebugger::MakeCodeBreakpointAtUnsafe	(	const Function &	func,
		BreakpointLocation *	bpt
	)

Definition at line 2211 of file debugger.cc.

                                                                        {
  DEBUG_ASSERT(Thread::Current()->IsInStoppedMutatorsScope() ||
               code_breakpoints_lock()->IsCurrentThreadWriter());
 
  ASSERT(loc->token_pos().IsReal());
  ASSERT((loc != nullptr) && loc->IsResolved());
  ASSERT(!func.HasOptimizedCode());
  ASSERT(func.HasCode());
  Code& code = Code::Handle(func.unoptimized_code());
  ASSERT(!code.IsNull());
  PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
  uword lowest_pc_offset = kUwordMax;
  UntaggedPcDescriptors::Kind lowest_kind = UntaggedPcDescriptors::kAnyKind;
  // Find the safe point with the lowest compiled code address
  // that maps to the token position of the source breakpoint.
  PcDescriptors::Iterator iter(desc, kSafepointKind);
  while (iter.MoveNext()) {
    if (iter.TokenPos() == loc->token_pos_) {
      if (iter.PcOffset() < lowest_pc_offset) {
        lowest_pc_offset = iter.PcOffset();
        lowest_kind = iter.Kind();
      }
    }
  }
  if (lowest_pc_offset == kUwordMax) {
    return;
  }
 
  uword lowest_pc = code.PayloadStart() + lowest_pc_offset;
  CodeBreakpoint* code_bpt = GetCodeBreakpoint(lowest_pc);
  if (code_bpt == nullptr) {
    // No code breakpoint for this code exists; create one.
    code_bpt = new CodeBreakpoint(code, loc, lowest_pc, lowest_kind);
    if (FLAG_verbose_debug) {
      OS::PrintErr("Setting code breakpoint at pos %s pc %#" Px " offset %#" Px
                   "\n",
                   loc->token_pos().ToCString(), lowest_pc,
                   lowest_pc - code.PayloadStart());
    }
    RegisterCodeBreakpoint(code_bpt);
  } else {
    if (FLAG_verbose_debug) {
      OS::PrintErr(
          "Adding location to existing code breakpoint at pos %s pc %#" Px
          " offset %#" Px "\n",
          loc->token_pos().ToCString(), lowest_pc,
          lowest_pc - code.PayloadStart());
    }
    if (!code_bpt->HasBreakpointLocation(loc)) {
      code_bpt->AddBreakpointLocation(loc);
    }
  }
  if (loc->AnyEnabled()) {
    code_bpt->Enable();
  }
}

NotifyCompilation()

void dart::GroupDebugger::NotifyCompilation

(

const Function &

func

)

Definition at line 2954 of file debugger.cc.

                                                              {
  if (!function.is_debuggable()) {
    return;
  }
  Function& resolved_function = Function::Handle(function.ptr());
  auto thread = Thread::Current();
  auto zone = thread->zone();
 
  // Going through BreakpointLocations of all isolates and debuggers looking
  // for those that can be resolved and added code breakpoints at now.
  //
  // The check below is used instead of breakpoint_locations_lock acquisition.
  // We don't need to acquire the lock if always run with stopped mutators.
  // We can't acquire the lock if we run with stopped mutators as that could
  // result in deadlock.
  RELEASE_ASSERT(thread->IsInStoppedMutatorsScope());
  for (intptr_t i = 0; i < breakpoint_locations_.length(); i++) {
    BreakpointLocation* location = breakpoint_locations_.At(i);
    if (EnsureLocationIsInFunction(zone, resolved_function, location)) {
      // All mutators are stopped (see RELEASE_ASSERT above). We temporarily
      // enter the isolate for which the breakpoint was registered.
      // The code path below may issue service events which will use the active
      // isolate's object-id ring for naming VM objects.
      ActiveIsolateScope active_isolate(thread,
                                        location->debugger()->isolate());
 
      // Ensure the location is resolved for the original function.
      TokenPosition exact_token_pos = TokenPosition::kNoSource;
#if !defined(DART_PRECOMPILED_RUNTIME)
      if (location->token_pos() != location->end_token_pos() &&
          location->requested_column_number() >= 0) {
        exact_token_pos = FindExactTokenPosition(
            Script::Handle(location->script()), location->token_pos(),
            location->requested_column_number());
      }
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
      location->EnsureIsResolved(function, exact_token_pos);
      if (FLAG_verbose_debug) {
        Breakpoint* bpt = location->breakpoints();
        while (bpt != nullptr) {
          OS::PrintErr("Setting breakpoint %" Pd " for %s '%s'\n", bpt->id(),
                       function.IsClosureFunction() ? "closure" : "function",
                       function.ToFullyQualifiedCString());
          bpt = bpt->next();
        }
      }
      MakeCodeBreakpointAt(function, location);
    }
  }
}

Pause()

void dart::GroupDebugger::Pause

(

)

Definition at line 3072 of file debugger.cc.

                          {
  SafepointWriteRwLocker sl(Thread::Current(), code_breakpoints_lock());
  if (needs_breakpoint_cleanup_) {
    RemoveUnlinkedCodeBreakpoints();
  }
}

RegisterBreakpointLocation()

void dart::GroupDebugger::RegisterBreakpointLocation

(

BreakpointLocation *

location

)

Definition at line 4020 of file debugger.cc.

                                                                           {
  DEBUG_ASSERT(breakpoint_locations_lock()->IsCurrentThreadWriter() ||
               Thread::Current()->IsInStoppedMutatorsScope());
  breakpoint_locations_.Add(location);
}

RegisterSingleSteppingDebugger()

void dart::GroupDebugger::RegisterSingleSteppingDebugger	(	Thread *	thread,
		const Debugger *	debugger
	)

Definition at line 3412 of file debugger.cc.

                                                                             {
  WriteRwLocker sl(Thread::Current(), single_stepping_set_lock());
  single_stepping_set_.Insert(debugger);
}

RemoveBreakpointLocation()

void dart::GroupDebugger::RemoveBreakpointLocation

(

BreakpointLocation *

bpt_location

)

single_stepping_set_lock()

RwLock * dart::GroupDebugger::single_stepping_set_lock ( )

inline

Definition at line 622 of file debugger.h.

{ return single_stepping_set_lock_.get(); }

SyncBreakpointLocation()

void dart::GroupDebugger::SyncBreakpointLocation

(

BreakpointLocation *

loc

)

Definition at line 2683 of file debugger.cc.

                                                                  {
  bool any_enabled = loc->AnyEnabled();
  SafepointWriteRwLocker sl(Thread::Current(), code_breakpoints_lock());
  CodeBreakpoint* cbpt = code_breakpoints_;
  while (cbpt != nullptr) {
    if (cbpt->HasBreakpointLocation(loc)) {
      if (any_enabled) {
        cbpt->Enable();
      } else {
        cbpt->Disable();
      }
    }
    cbpt = cbpt->next();
  }
}

UnlinkCodeBreakpoints()

void dart::GroupDebugger::UnlinkCodeBreakpoints

(

BreakpointLocation *

bpt_location

)

Definition at line 4040 of file debugger.cc.

                                                                          {
  ASSERT(bpt_location != nullptr);
  SafepointWriteRwLocker sl(Thread::Current(), code_breakpoints_lock());
  CodeBreakpoint* curr_bpt = code_breakpoints_;
  while (curr_bpt != nullptr) {
    if (curr_bpt->FindAndDeleteBreakpointLocation(bpt_location)) {
      curr_bpt->Disable();
      needs_breakpoint_cleanup_ = true;
    }
    curr_bpt = curr_bpt->next();
  }
}

UnregisterBreakpointLocation()

void dart::GroupDebugger::UnregisterBreakpointLocation

(

BreakpointLocation *

location

)

Definition at line 4026 of file debugger.cc.

                                                                             {
  ASSERT(breakpoint_locations_lock()->IsCurrentThreadWriter());
  for (intptr_t i = 0; i < breakpoint_locations_.length(); i++) {
    if (breakpoint_locations_.At(i) == location) {
      breakpoint_locations_.EraseAt(i);
      return;
    }
  }
}

UnregisterSingleSteppingDebugger()

void dart::GroupDebugger::UnregisterSingleSteppingDebugger	(	Thread *	thread,
		const Debugger *	debugger
	)

Definition at line 3418 of file debugger.cc.

                                                                               {
  WriteRwLocker sl(Thread::Current(), single_stepping_set_lock());
  single_stepping_set_.Remove(debugger);
}

VisitObjectPointers()

void dart::GroupDebugger::VisitObjectPointers

(

ObjectPointerVisitor *

visitor

)

Definition at line 3005 of file debugger.cc.

                                                                     {
  CodeBreakpoint* cbpt = code_breakpoints_;
  while (cbpt != nullptr) {
    cbpt->VisitObjectPointers(visitor);
    cbpt = cbpt->next();
  }
}

---

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