: debug_context_(Handle<Context>()),

event_listener_(Handle<Object>()),

event_listener_data_(Handle<Object>()),

message_handler_(NULL),

command_received_(0),

command_queue_(isolate->logger(), kQueueInitialSize),

is_active_(false),

hook_on_function_call_(false),

is_suppressed_(false),

live_edit_enabled_(true), // TODO(yangguo): set to false by default.

break_disabled_(false),

break_points_active_(true),

in_debug_event_listener_(false),

break_on_exception_(false),

break_on_uncaught_exception_(false),

side_effect_check_failed_(false),

debug_info_list_(NULL),

feature_tracker_(isolate),

isolate_(isolate) {

ThreadInit();

// TODO(clemensh): Handle Wasm frames.

DCHECK(!frame->is_wasm());

auto summary = FrameSummary::GetFirst(frame).AsJavaScript();

int offset = summary.code_offset();

Handle<AbstractCode> abstract_code = summary.abstract_code();

if (abstract_code->IsCode()) offset = offset - 1;

Handle<DebugInfo> debug_info(summary.function()->shared()->GetDebugInfo());

auto it = BreakIterator::GetIterator(debug_info, abstract_code);

it->SkipTo(BreakIndexFromCodeOffset(debug_info, abstract_code, offset));

return it->GetBreakLocation();

JavaScriptFrame* frame,

List<BreakLocation>* result_out) {

auto summary = FrameSummary::GetFirst(frame).AsJavaScript();

int offset = summary.code_offset();

Handle<AbstractCode> abstract_code = summary.abstract_code();

if (abstract_code->IsCode()) offset = offset - 1;

int statement_position;

{

auto it = BreakIterator::GetIterator(debug_info, abstract_code);

it->SkipTo(BreakIndexFromCodeOffset(debug_info, abstract_code, offset));

statement_position = it->statement_position();

}

for (auto it = BreakIterator::GetIterator(debug_info, abstract_code);

!it->Done(); it->Next()) {

if (it->statement_position() == statement_position) {

result_out->Add(it->GetBreakLocation());

}

}

Handle<AbstractCode> abstract_code,

int offset) {

// Run through all break points to locate the one closest to the address.

int closest_break = 0;

int distance = kMaxInt;

DCHECK(0 <= offset && offset < abstract_code->Size());

for (auto it = BreakIterator::GetIterator(debug_info, abstract_code);

!it->Done(); it->Next()) {

// Check if this break point is closer that what was previously found.

if (it->code_offset() <= offset && offset - it->code_offset() < distance) {

closest_break = it->break_index();

distance = offset - it->code_offset();

// Check whether we can't get any closer.

if (distance == 0) break;

}

}

return closest_break;

// First check whether there is a break point with the same source position.

if (!debug_info->HasBreakPoint(position_)) return false;

// Then check whether a break point at that source position would have

// the same code offset. Otherwise it's just a break location that we can

// step to, but not actually a location where we can put a break point.

if (abstract_code_->IsCode()) {

DCHECK_EQ(debug_info->DebugCode(), abstract_code_->GetCode());

CodeBreakIterator it(debug_info, ALL_BREAK_LOCATIONS);

it.SkipToPosition(position_, BREAK_POSITION_ALIGNED);

return it.code_offset() == code_offset_;

} else {

DCHECK(abstract_code_->IsBytecodeArray());

BytecodeArrayBreakIterator it(debug_info, ALL_BREAK_LOCATIONS);

it.SkipToPosition(position_, BREAK_POSITION_ALIGNED);

return it.code_offset() == code_offset_;

}

Handle<DebugInfo> debug_info, Handle<AbstractCode> abstract_code,

BreakLocatorType type) {

if (abstract_code->IsBytecodeArray()) {

DCHECK(debug_info->HasDebugBytecodeArray());

return std::unique_ptr<BreakIterator>(

new BytecodeArrayBreakIterator(debug_info, type));

} else {

DCHECK(abstract_code->IsCode());

DCHECK(debug_info->HasDebugCode());

return std::unique_ptr<BreakIterator>(

new CodeBreakIterator(debug_info, type));

}

BreakLocatorType type)

: debug_info_(debug_info), break_index_(-1), break_locator_type_(type) {

position_ = debug_info->shared()->start_position();

statement_position_ = position_;

BreakPositionAlignment alignment) {

int distance = kMaxInt;

int closest_break = break_index();

while (!Done()) {

int next_position;

if (alignment == STATEMENT_ALIGNED) {

next_position = statement_position();

} else {

DCHECK(alignment == BREAK_POSITION_ALIGNED);

next_position = position();

}

if (source_position <= next_position &&

next_position - source_position < distance) {

closest_break = break_index();

distance = next_position - source_position;

// Check whether we can't get any closer.

if (distance == 0) break;

}

Next();

}

return closest_break;

BreakLocatorType type)

: BreakIterator(debug_info, type),

reloc_iterator_(debug_info->DebugCode(), GetModeMask(type)),

source_position_iterator_(

debug_info->DebugCode()->source_position_table()) {

// There is at least one break location.

DCHECK(!Done());

Next();

int mask = 0;

mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_RETURN);

mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_CALL);

if (isolate()->is_tail_call_elimination_enabled()) {

mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_TAIL_CALL);

}

if (type == ALL_BREAK_LOCATIONS) {

mask |= RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT_AT_POSITION);

mask |= RelocInfo::ModeMask(RelocInfo::DEBUGGER_STATEMENT);

}

return mask;

DisallowHeapAllocation no_gc;

DCHECK(!Done());

// Iterate through reloc info stopping at each breakable code target.

bool first = break_index_ == -1;

if (!first) reloc_iterator_.next();

first = false;

if (Done()) return;

int offset = code_offset();

while (!source_position_iterator_.done() &&

source_position_iterator_.code_offset() <= offset) {

position_ = source_position_iterator_.source_position().ScriptOffset();

if (source_position_iterator_.is_statement()) {

statement_position_ = position_;

}

source_position_iterator_.Advance();

}

DCHECK(RelocInfo::IsDebugBreakSlot(rmode()) ||

RelocInfo::IsDebuggerStatement(rmode()));

break_index_++;

if (RelocInfo::IsDebugBreakSlotAtReturn(rmode())) {

return DEBUG_BREAK_SLOT_AT_RETURN;

} else if (RelocInfo::IsDebugBreakSlotAtCall(rmode())) {

return DEBUG_BREAK_SLOT_AT_CALL;

} else if (RelocInfo::IsDebugBreakSlotAtTailCall(rmode())) {

return isolate()->is_tail_call_elimination_enabled()

? DEBUG_BREAK_SLOT_AT_TAIL_CALL

: DEBUG_BREAK_SLOT_AT_CALL;

} else if (RelocInfo::IsDebuggerStatement(rmode())) {

return DEBUGGER_STATEMENT;

} else if (RelocInfo::IsDebugBreakSlot(rmode())) {

return DEBUG_BREAK_SLOT;

} else {

return NOT_DEBUG_BREAK;

}

BreakPositionAlignment alignment) {

CodeBreakIterator it(debug_info_, break_locator_type_);

SkipTo(it.BreakIndexFromPosition(position, alignment));

DebugBreakType debug_break_type = GetDebugBreakType();

if (debug_break_type == DEBUGGER_STATEMENT) return;

DCHECK(debug_break_type >= DEBUG_BREAK_SLOT);

Builtins* builtins = isolate()->builtins();

Handle<Code> target = debug_break_type == DEBUG_BREAK_SLOT_AT_RETURN

? builtins->Return_DebugBreak()

: builtins->Slot_DebugBreak();

DebugCodegen::PatchDebugBreakSlot(isolate(), rinfo()->pc(), target);

DebugBreakType debug_break_type = GetDebugBreakType();

if (debug_break_type == DEBUGGER_STATEMENT) return;

DCHECK(debug_break_type >= DEBUG_BREAK_SLOT);

DebugCodegen::ClearDebugBreakSlot(isolate(), rinfo()->pc());

DebugBreakType debug_break_type = GetDebugBreakType();

if (debug_break_type == DEBUGGER_STATEMENT) return false;

DCHECK(debug_break_type >= DEBUG_BREAK_SLOT);

return DebugCodegen::DebugBreakSlotIsPatched(rinfo()->pc());

Handle<DebugInfo> debug_info, BreakLocatorType type)

: BreakIterator(debug_info, type),

source_position_iterator_(

debug_info->DebugBytecodeArray()->source_position_table()) {

// There is at least one break location.

DCHECK(!Done());

Next();

DisallowHeapAllocation no_gc;

DCHECK(!Done());

bool first = break_index_ == -1;

while (!Done()) {

if (!first) source_position_iterator_.Advance();

first = false;

if (Done()) return;

position_ = source_position_iterator_.source_position().ScriptOffset();

if (source_position_iterator_.is_statement()) {

statement_position_ = position_;

}

DCHECK(position_ >= 0);

DCHECK(statement_position_ >= 0);

DebugBreakType type = GetDebugBreakType();

if (type == NOT_DEBUG_BREAK) continue;

if (break_locator_type_ == ALL_BREAK_LOCATIONS) break;

DCHECK_EQ(CALLS_AND_RETURNS, break_locator_type_);

if (type == DEBUG_BREAK_SLOT_AT_CALL) break;

if (type == DEBUG_BREAK_SLOT_AT_RETURN) break;

}

break_index_++;

BytecodeArray* bytecode_array = debug_info_->OriginalBytecodeArray();

interpreter::Bytecode bytecode =

interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));

if (bytecode == interpreter::Bytecode::kDebugger) {

return DEBUGGER_STATEMENT;

} else if (bytecode == interpreter::Bytecode::kReturn) {

return DEBUG_BREAK_SLOT_AT_RETURN;

} else if (bytecode == interpreter::Bytecode::kTailCall) {

return isolate()->is_tail_call_elimination_enabled()

? DEBUG_BREAK_SLOT_AT_TAIL_CALL

: DEBUG_BREAK_SLOT_AT_CALL;

} else if (interpreter::Bytecodes::IsCallOrNew(bytecode)) {

return DEBUG_BREAK_SLOT_AT_CALL;

} else if (source_position_iterator_.is_statement()) {

return DEBUG_BREAK_SLOT;

} else {

return NOT_DEBUG_BREAK;

}

int position, BreakPositionAlignment alignment) {

BytecodeArrayBreakIterator it(debug_info_, break_locator_type_);

SkipTo(it.BreakIndexFromPosition(position, alignment));

DebugBreakType debug_break_type = GetDebugBreakType();

if (debug_break_type == DEBUGGER_STATEMENT) return;

DCHECK(debug_break_type >= DEBUG_BREAK_SLOT);

BytecodeArray* bytecode_array = debug_info_->DebugBytecodeArray();

interpreter::Bytecode bytecode =

interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));

if (interpreter::Bytecodes::IsDebugBreak(bytecode)) return;

interpreter::Bytecode debugbreak =

interpreter::Bytecodes::GetDebugBreak(bytecode);

bytecode_array->set(code_offset(),

interpreter::Bytecodes::ToByte(debugbreak));

DebugBreakType debug_break_type = GetDebugBreakType();

if (debug_break_type == DEBUGGER_STATEMENT) return;

DCHECK(debug_break_type >= DEBUG_BREAK_SLOT);

BytecodeArray* bytecode_array = debug_info_->DebugBytecodeArray();

BytecodeArray* original = debug_info_->OriginalBytecodeArray();

bytecode_array->set(code_offset(), original->get(code_offset()));

DebugBreakType debug_break_type = GetDebugBreakType();

if (debug_break_type == DEBUGGER_STATEMENT) return false;

DCHECK(debug_break_type >= DEBUG_BREAK_SLOT);

BytecodeArray* bytecode_array = debug_info_->DebugBytecodeArray();

interpreter::Bytecode bytecode =

interpreter::Bytecodes::FromByte(bytecode_array->get(code_offset()));

return interpreter::Bytecodes::IsDebugBreak(bytecode);

Handle<AbstractCode> code(

AbstractCode::cast(debug_info_->DebugBytecodeArray()));

return BreakLocation(code, GetDebugBreakType(), code_offset(), position_);

uint32_t mask = 1 << feature;

// Only count one sample per feature and isolate.

if (bitfield_ & mask) return;

isolate_->counters()->debug_feature_usage()->AddSample(feature);

bitfield_ |= mask;

thread_local_.break_count_ = 0;

thread_local_.break_id_ = 0;

thread_local_.break_frame_id_ = StackFrame::NO_ID;

thread_local_.last_step_action_ = StepNone;

thread_local_.last_statement_position_ = kNoSourcePosition;

thread_local_.last_fp_ = 0;

thread_local_.target_fp_ = 0;

thread_local_.return_value_ = Handle<Object>();

thread_local_.async_task_count_ = 0;

clear_suspended_generator();

// TODO(isolates): frames_are_dropped_?

base::NoBarrier_Store(&thread_local_.current_debug_scope_,

static_cast<base::AtomicWord>(0));

UpdateHookOnFunctionCall();

// Globalize the request debug info object and make it weak.

GlobalHandles* global_handles = debug_info->GetIsolate()->global_handles();

debug_info_ =

Handle<DebugInfo>::cast(global_handles->Create(debug_info)).location();

// Return if debugger is already loaded.

if (is_loaded()) return true;

// Bail out if we're already in the process of compiling the native

// JavaScript source code for the debugger.

if (is_suppressed_) return false;

SuppressDebug while_loading(this);

// Disable breakpoints and interrupts while compiling and running the

// debugger scripts including the context creation code.

DisableBreak disable(this);

PostponeInterruptsScope postpone(isolate_);

// Create the debugger context.

HandleScope scope(isolate_);

ExtensionConfiguration no_extensions;

// TODO(yangguo): we rely on the fact that first context snapshot is usable

// as debug context. This dependency is gone once we remove

// debug context completely.

static const int kFirstContextSnapshotIndex = 0;

Handle<Context> context = isolate_->bootstrapper()->CreateEnvironment(

MaybeHandle<JSGlobalProxy>(), v8::Local<ObjectTemplate>(), &no_extensions,

kFirstContextSnapshotIndex, v8::DeserializeInternalFieldsCallback(),

DEBUG_CONTEXT);

// Fail if no context could be created.

if (context.is_null()) return false;

debug_context_ = Handle<Context>::cast(

isolate_->global_handles()->Create(*context));

feature_tracker()->Track(DebugFeatureTracker::kActive);

return true;

ClearAllBreakPoints();

ClearStepping();

// Return debugger is not loaded.

if (!is_loaded()) return;

// Clear debugger context global handle.

GlobalHandles::Destroy(Handle<Object>::cast(debug_context_).location());

debug_context_ = Handle<Context>();

HandleScope scope(isolate_);

// Initialize LiveEdit.

LiveEdit::InitializeThreadLocal(this);

// Just continue if breaks are disabled or debugger cannot be loaded.

if (break_disabled()) return;

// Enter the debugger.

DebugScope debug_scope(this);

if (debug_scope.failed()) return;

// Postpone interrupt during breakpoint processing.

PostponeInterruptsScope postpone(isolate_);

// Return if we fail to retrieve debug info for javascript frames.

if (frame->is_java_script()) {

JavaScriptFrame* js_frame = JavaScriptFrame::cast(frame);

// Get the debug info (create it if it does not exist).

Handle<JSFunction> function(js_frame->function());

Handle<SharedFunctionInfo> shared(function->shared());

if (!EnsureDebugInfo(shared, function)) return;

}

BreakLocation location = BreakLocation::FromFrame(frame);

// Find actual break points, if any, and trigger debug break event.

MaybeHandle<FixedArray> break_points_hit;

if (!break_points_active()) {

// Don't try to find hit breakpoints.

} else if (frame->is_wasm_interpreter_entry()) {

// TODO(clemensh): Find hit breakpoints for wasm.

UNIMPLEMENTED();

} else {

// Get the debug info, which must exist if we reach here.

Handle<DebugInfo> debug_info(

JavaScriptFrame::cast(frame)->function()->shared()->GetDebugInfo(),

isolate_);

break_points_hit = CheckBreakPoints(debug_info, &location);

}

if (!break_points_hit.is_null()) {

// Clear all current stepping setup.

ClearStepping();

// Notify the debug event listeners.

Handle<JSArray> jsarr = isolate_->factory()->NewJSArrayWithElements(

break_points_hit.ToHandleChecked());

OnDebugBreak(jsarr, false);

return;

}

// No break point. Check for stepping.

StepAction step_action = last_step_action();

Address current_fp = frame->UnpaddedFP();

Address target_fp = thread_local_.target_fp_;

Address last_fp = thread_local_.last_fp_;

bool step_break = false;

switch (step_action) {

case StepNone:

return;

case StepOut:

// Step out has not reached the target frame yet.

if (current_fp < target_fp) return;

step_break = true;

break;

case StepNext:

// Step next should not break in a deeper frame.

if (current_fp < target_fp) return;

// For step-next, a tail call is like a return and should break.

step_break = location.IsTailCall();

// Fall through.

case StepIn: {

FrameSummary summary = FrameSummary::GetFirst(frame);

step_break = step_break || location.IsReturn() || current_fp != last_fp ||

thread_local_.last_statement_position_ !=

summary.SourceStatementPosition();

break;

}

case StepFrame:

step_break = current_fp != last_fp;

break;

}

// Clear all current stepping setup.

ClearStepping();

if (step_break) {

// Notify the debug event listeners.

OnDebugBreak(isolate_->factory()->undefined_value(), false);

} else {

// Re-prepare to continue.

PrepareStep(step_action);

}

BreakLocation* location,

bool* has_break_points) {

bool has_break_points_to_check =

break_points_active_ && location->HasBreakPoint(debug_info);

if (has_break_points) *has_break_points = has_break_points_to_check;

if (!has_break_points_to_check) return {};

Handle<Object> break_point_objects =

debug_info->GetBreakPointObjects(location->position());

return Debug::GetHitBreakPointObjects(break_point_objects);

// A break location is considered muted if break locations on the current

// statement have at least one break point, and all of these break points

// evaluate to false. Aside from not triggering a debug break event at the

// break location, we also do not trigger one for debugger statements, nor

// an exception event on exception at this location.

Object* fun = frame->function();

if (!fun->IsJSFunction()) return false;

JSFunction* function = JSFunction::cast(fun);

if (!function->shared()->HasDebugInfo()) return false;

HandleScope scope(isolate_);

Handle<DebugInfo> debug_info(function->shared()->GetDebugInfo());

// Enter the debugger.

DebugScope debug_scope(this);

if (debug_scope.failed()) return false;

List<BreakLocation> break_locations;

BreakLocation::AllAtCurrentStatement(debug_info, frame, &break_locations);

bool has_break_points_at_all = false;

for (int i = 0; i < break_locations.length(); i++) {

bool has_break_points;

MaybeHandle<FixedArray> check_result =

CheckBreakPoints(debug_info, &break_locations[i], &has_break_points);

has_break_points_at_all |= has_break_points;

if (has_break_points && !check_result.is_null()) return false;

}

return has_break_points_at_all;

Handle<Object> args[]) {

PostponeInterruptsScope no_interrupts(isolate_);

AssertDebugContext();

Handle<JSReceiver> holder =

Handle<JSReceiver>::cast(isolate_->natives_utils_object());

Handle<JSFunction> fun = Handle<JSFunction>::cast(

JSReceiver::GetProperty(isolate_, holder, name).ToHandleChecked());

Handle<Object> undefined = isolate_->factory()->undefined_value();

MaybeHandle<Object> maybe_exception;

return Execution::TryCall(isolate_, fun, undefined, argc, args,

Execution::MessageHandling::kReport,

&maybe_exception);

Factory* factory = isolate_->factory();

HandleScope scope(isolate_);

// Ignore check if break point object is not a JSObject.

if (!break_point_object->IsJSObject()) return true;

// Get the break id as an object.

Handle<Object> break_id = factory->NewNumberFromInt(Debug::break_id());

// Call IsBreakPointTriggered.

Handle<Object> argv[] = { break_id, break_point_object };

Handle<Object> result;

if (!CallFunction("IsBreakPointTriggered", arraysize(argv), argv)

.ToHandle(&result)) {

return false;

}

// Return whether the break point is triggered.

return result->IsTrue(isolate_);

Handle<Object> break_point_object,

int* source_position) {

HandleScope scope(isolate_);

// Make sure the function is compiled and has set up the debug info.

Handle<SharedFunctionInfo> shared(function->shared());

if (!EnsureDebugInfo(shared, function)) {

// Return if retrieving debug info failed.

return true;

}

Handle<DebugInfo> debug_info(shared->GetDebugInfo());

// Source positions starts with zero.

DCHECK(*source_position >= 0);

// Find the break point and change it.

*source_position =

FindBreakablePosition(debug_info, *source_position, STATEMENT_ALIGNED);

DebugInfo::SetBreakPoint(debug_info, *source_position, break_point_object);

// At least one active break point now.

DCHECK(debug_info->GetBreakPointCount() > 0);

ClearBreakPoints(debug_info);

ApplyBreakPoints(debug_info);

feature_tracker()->Track(DebugFeatureTracker::kBreakPoint);

return true;

Handle<Object> break_point_object,

int* source_position,

BreakPositionAlignment alignment) {

if (script->type() == Script::TYPE_WASM) {

// TODO(clemensh): set breakpoint for wasm.

return false;

}

HandleScope scope(isolate_);

// Obtain shared function info for the function.

Handle<Object> result =

FindSharedFunctionInfoInScript(script, *source_position);

if (result->IsUndefined(isolate_)) return false;

// Make sure the function has set up the debug info.

Handle<SharedFunctionInfo> shared = Handle<SharedFunctionInfo>::cast(result);

if (!EnsureDebugInfo(shared, Handle<JSFunction>::null())) {

// Return if retrieving debug info failed.

return false;

}

// Find position within function. The script position might be before the

// source position of the first function.

if (shared->start_position() > *source_position) {

*source_position = shared->start_position();

}

Handle<DebugInfo> debug_info(shared->GetDebugInfo());

// Find the break point and change it.

*source_position =

FindBreakablePosition(debug_info, *source_position, alignment);

DebugInfo::SetBreakPoint(debug_info, *source_position, break_point_object);

// At least one active break point now.

DCHECK(debug_info->GetBreakPointCount() > 0);

ClearBreakPoints(debug_info);

ApplyBreakPoints(debug_info);

feature_tracker()->Track(DebugFeatureTracker::kBreakPoint);

return true;

int source_position,

BreakPositionAlignment alignment) {

int statement_position;

int position;

if (debug_info->HasDebugCode()) {

CodeBreakIterator it(debug_info, ALL_BREAK_LOCATIONS);

it.SkipToPosition(source_position, alignment);

statement_position = it.statement_position();

position = it.position();

} else {

DCHECK(debug_info->HasDebugBytecodeArray());

BytecodeArrayBreakIterator it(debug_info, ALL_BREAK_LOCATIONS);

it.SkipToPosition(source_position, alignment);

statement_position = it.statement_position();

position = it.position();

}

return alignment == STATEMENT_ALIGNED ? statement_position : position;

DisallowHeapAllocation no_gc;

if (debug_info->break_points()->IsUndefined(isolate_)) return;

FixedArray* break_points = debug_info->break_points();

for (int i = 0; i < break_points->length(); i++) {

if (break_points->get(i)->IsUndefined(isolate_)) continue;

BreakPointInfo* info = BreakPointInfo::cast(break_points->get(i));

if (info->GetBreakPointCount() == 0) continue;

if (debug_info->HasDebugCode()) {

CodeBreakIterator it(debug_info, ALL_BREAK_LOCATIONS);

it.SkipToPosition(info->source_position(), BREAK_POSITION_ALIGNED);

it.SetDebugBreak();

}

if (debug_info->HasDebugBytecodeArray()) {

BytecodeArrayBreakIterator it(debug_info, ALL_BREAK_LOCATIONS);

it.SkipToPosition(info->source_position(), BREAK_POSITION_ALIGNED);

it.SetDebugBreak();

}

}

DisallowHeapAllocation no_gc;

if (debug_info->HasDebugCode()) {

for (CodeBreakIterator it(debug_info, ALL_BREAK_LOCATIONS); !it.Done();

it.Next()) {

it.ClearDebugBreak();

}

}

if (debug_info->HasDebugBytecodeArray()) {

for (BytecodeArrayBreakIterator it(debug_info, ALL_BREAK_LOCATIONS);

!it.Done(); it.Next()) {

it.ClearDebugBreak();

}

}

HandleScope scope(isolate_);

for (DebugInfoListNode* node = debug_info_list_; node != NULL;

node = node->next()) {

Handle<Object> result =

DebugInfo::FindBreakPointInfo(node->debug_info(), break_point_object);

if (result->IsUndefined(isolate_)) continue;

Handle<DebugInfo> debug_info = node->debug_info();

if (DebugInfo::ClearBreakPoint(debug_info, break_point_object)) {

ClearBreakPoints(debug_info);

if (debug_info->GetBreakPointCount() == 0) {

RemoveDebugInfoAndClearFromShared(debug_info);

} else {

ApplyBreakPoints(debug_info);

}

return;

}

}

for (DebugInfoListNode* node = debug_info_list_; node != NULL;

node = node->next()) {

ClearBreakPoints(node->debug_info());

}

// Remove all debug info.

while (debug_info_list_ != NULL) {

RemoveDebugInfoAndClearFromShared(debug_info_list_->debug_info());

}

BreakLocatorType type) {

// Debug utility functions are not subject to debugging.

if (function->native_context() == *debug_context()) return;

if (!function->shared()->IsSubjectToDebugging()) {

// Builtin functions are not subject to stepping, but need to be

// deoptimized, because optimized code does not check for debug

// step in at call sites.

Deoptimizer::DeoptimizeFunction(*function);

return;

}

// Make sure the function is compiled and has set up the debug info.

Handle<SharedFunctionInfo> shared(function->shared());

if (!EnsureDebugInfo(shared, function)) {

// Return if we failed to retrieve the debug info.

return;

}

// Flood the function with break points.

Handle<DebugInfo> debug_info(shared->GetDebugInfo());

if (debug_info->HasDebugCode()) {

for (CodeBreakIterator it(debug_info, type); !it.Done(); it.Next()) {

it.SetDebugBreak();

}

}

if (debug_info->HasDebugBytecodeArray()) {

for (BytecodeArrayBreakIterator it(debug_info, type); !it.Done();

it.Next()) {

it.SetDebugBreak();

}

}

if (type == BreakUncaughtException) {

break_on_uncaught_exception_ = enable;

} else {

break_on_exception_ = enable;

}

if (type == BreakUncaughtException) {

return break_on_uncaught_exception_;

} else {

return break_on_exception_;

}

Handle<Object> break_point_objects) {

DCHECK(!break_point_objects->IsUndefined(isolate_));

if (!break_point_objects->IsFixedArray()) {

if (!CheckBreakPoint(break_point_objects)) return {};

Handle<FixedArray> break_points_hit = isolate_->factory()->NewFixedArray(1);

break_points_hit->set(0, *break_point_objects);

return break_points_hit;

}

Handle<FixedArray> array(FixedArray::cast(*break_point_objects));

int num_objects = array->length();

Handle<FixedArray> break_points_hit =

isolate_->factory()->NewFixedArray(num_objects);

int break_points_hit_count = 0;

for (int i = 0; i < num_objects; ++i) {

Handle<Object> break_point_object(array->get(i), isolate_);

if (CheckBreakPoint(break_point_object)) {

break_points_hit->set(break_points_hit_count++, *break_point_object);

}

}

if (break_points_hit_count == 0) return {};

break_points_hit->Shrink(break_points_hit_count);

return break_points_hit;

CHECK(last_step_action() >= StepIn);

if (ignore_events()) return;

if (in_debug_scope()) return;

if (break_disabled()) return;

FloodWithOneShot(function);

CHECK(has_suspended_generator());

if (ignore_events()) return;

if (in_debug_scope()) return;

if (break_disabled()) return;

thread_local_.last_step_action_ = StepIn;

UpdateHookOnFunctionCall();

Handle<JSFunction> function(

JSGeneratorObject::cast(thread_local_.suspended_generator_)->function());

FloodWithOneShot(function);

clear_suspended_generator();

if (last_step_action() == StepNone) return;

if (ignore_events()) return;

if (in_debug_scope()) return;

if (break_disabled()) return;

ClearOneShot();

// Iterate through the JavaScript stack looking for handlers.

JavaScriptFrameIterator it(isolate_);

while (!it.done()) {

JavaScriptFrame* frame = it.frame();

if (frame->LookupExceptionHandlerInTable(nullptr, nullptr) > 0) break;

it.Advance();

}

if (last_step_action() == StepNext || last_step_action() == StepOut) {

while (!it.done()) {

Address current_fp = it.frame()->UnpaddedFP();

if (current_fp >= thread_local_.target_fp_) break;

it.Advance();

}

}

// Find the closest Javascript frame we can flood with one-shots.

while (!it.done() &&

!it.frame()->function()->shared()->IsSubjectToDebugging()) {

it.Advance();

}

if (it.done()) return; // No suitable Javascript catch handler.

FloodWithOneShot(Handle<JSFunction>(it.frame()->function()));

HandleScope scope(isolate_);

DCHECK(in_debug_scope());

// Get the frame where the execution has stopped and skip the debug frame if

// any. The debug frame will only be present if execution was stopped due to

// hitting a break point. In other situations (e.g. unhandled exception) the

// debug frame is not present.

StackFrame::Id frame_id = break_frame_id();

// If there is no JavaScript stack don't do anything.