: debug_context_(Handle<Context>()),

is_active_(false),

hook_on_function_call_(false),

is_suppressed_(false),

live_edit_enabled_(false),

break_disabled_(false),

break_points_active_(true),

break_on_exception_(false),

break_on_uncaught_exception_(false),

side_effect_check_failed_(false),

debug_info_list_(NULL),

feature_tracker_(isolate),

isolate_(isolate) {

ThreadInit();

JavaScriptFrame* frame) {

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

int offset = summary.code_offset();

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

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

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::GetTop(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);

it.SkipToPosition(position_, BREAK_POSITION_ALIGNED);

return it.code_offset() == code_offset_;

} else {

DCHECK(abstract_code_->IsBytecodeArray());

BytecodeArrayBreakIterator it(debug_info);

it.SkipToPosition(position_, BREAK_POSITION_ALIGNED);

return it.code_offset() == code_offset_;

}

switch (type_) {

case DEBUGGER_STATEMENT:

return debug::kDebuggerStatementBreakLocation;

case DEBUG_BREAK_SLOT_AT_CALL:

return debug::kCallBreakLocation;

case DEBUG_BREAK_SLOT_AT_RETURN:

return debug::kReturnBreakLocation;

default:

return debug::kCommonBreakLocation;

}

return debug::kCommonBreakLocation;

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

if (abstract_code->IsBytecodeArray()) {

DCHECK(debug_info->HasDebugBytecodeArray());

return std::unique_ptr<BreakIterator>(

new BytecodeArrayBreakIterator(debug_info));

} else {

DCHECK(abstract_code->IsCode());

DCHECK(debug_info->HasDebugCode());

return std::unique_ptr<BreakIterator>(new CodeBreakIterator(debug_info));

}

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

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;

: BreakIterator(debug_info),

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

source_position_iterator_(

debug_info->DebugCode()->SourcePositionTable()) {

// 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);

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

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

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()));

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::IsDebugBreakSlot(rmode())) {

return DEBUG_BREAK_SLOT;

} else {

return NOT_DEBUG_BREAK;

}

BreakPositionAlignment alignment) {

CodeBreakIterator it(debug_info_);

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

DebugBreakType debug_break_type = GetDebugBreakType();

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);

Handle<DebugInfo> debug_info)

: BreakIterator(debug_info),

source_position_iterator_(

debug_info->DebugBytecodeArray()->SourcePositionTable()) {

// 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) 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::IsCallOrConstruct(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_);

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_frame_count_ = -1;

thread_local_.fast_forward_to_return_ = false;

thread_local_.ignore_step_into_function_ = Smi::kZero;

thread_local_.target_frame_count_ = -1;

thread_local_.return_value_ = Smi::kZero;

thread_local_.async_task_count_ = 0;

clear_suspended_generator();

thread_local_.restart_fp_ = nullptr;

base::NoBarrier_Store(&thread_local_.current_debug_scope_,

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

UpdateHookOnFunctionCall();

v->VisitRootPointer(Root::kDebug, &thread_local_.return_value_);

v->VisitRootPointer(Root::kDebug, &thread_local_.suspended_generator_);

v->VisitRootPointer(Root::kDebug, &thread_local_.ignore_step_into_function_);

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

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

debug_info_ = 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::DeserializeEmbedderFieldsCallback(),

DEBUG_CONTEXT);

// Fail if no context could be created.

if (context.is_null()) return false;

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

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

return true;

ClearAllBreakPoints();

ClearStepping();

RemoveDebugDelegate();

// 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>();

// 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_);

DisableBreak no_recursive_break(this);

// Return if we fail to retrieve debug info.

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

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

if (!EnsureDebugInfo(shared)) return;

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

// Find the break location where execution has stopped.

BreakLocation location = BreakLocation::FromFrame(debug_info, frame);

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

MaybeHandle<FixedArray> 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);

return;

}

// No break point. Check for stepping.

StepAction step_action = last_step_action();

int current_frame_count = CurrentFrameCount();

int target_frame_count = thread_local_.target_frame_count_;

int last_frame_count = thread_local_.last_frame_count_;

// StepOut at not return position was requested and return break locations

// were flooded with one shots.

if (thread_local_.fast_forward_to_return_) {

DCHECK(location.IsReturn());

// We have to ignore recursive calls to function.

if (current_frame_count > target_frame_count) return;

ClearStepping();

PrepareStep(StepOut);

return;

}

bool step_break = false;

switch (step_action) {

case StepNone:

return;

case StepOut:

// Step out should not break in a deeper frame than target frame.

if (current_frame_count > target_frame_count) return;

step_break = true;

break;

case StepNext:

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

if (current_frame_count > target_frame_count) 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::GetTop(frame);

step_break = step_break || location.IsReturn() ||

current_frame_count != last_frame_count ||

thread_local_.last_statement_position_ !=

summary.SourceStatementPosition();

break;

}

}

// Clear all current stepping setup.

ClearStepping();

if (step_break) {

// Notify the debug event listeners.

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

} 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);

HandleScope scope(isolate_);

// 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.

FrameSummary summary = FrameSummary::GetTop(frame);

DCHECK(!summary.IsWasm());

Handle<JSFunction> function = summary.AsJavaScript().function();

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

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)) 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) {

Handle<WasmCompiledModule> compiled_module(

WasmCompiledModule::cast(script->wasm_compiled_module()), isolate_);

return WasmCompiledModule::SetBreakPoint(compiled_module, source_position,

break_point_object);

}

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)) 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);

it.SkipToPosition(source_position, alignment);

statement_position = it.statement_position();

position = it.position();

} else {

DCHECK(debug_info->HasDebugBytecodeArray());

BytecodeArrayBreakIterator it(debug_info);

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);

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

it.SetDebugBreak();

}

if (debug_info->HasDebugBytecodeArray()) {

BytecodeArrayBreakIterator it(debug_info);

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

it.SetDebugBreak();

}

}

DisallowHeapAllocation no_gc;

if (debug_info->HasDebugCode()) {

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

it.ClearDebugBreak();

}

}

if (debug_info->HasDebugBytecodeArray()) {

for (BytecodeArrayBreakIterator it(debug_info); !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());

}

bool returns_only) {

if (IsBlackboxed(shared)) return;

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

if (!EnsureDebugInfo(shared)) return;

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

// Flood the function with break points.

if (debug_info->HasDebugCode()) {

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

if (returns_only && !it.GetBreakLocation().IsReturn()) continue;

it.SetDebugBreak();

}

}

if (debug_info->HasDebugBytecodeArray()) {

for (BytecodeArrayBreakIterator it(debug_info); !it.Done(); it.Next()) {

if (returns_only && !it.GetBreakLocation().IsReturn()) continue;

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;

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

if (IsBlackboxed(shared)) return;

if (*function == thread_local_.ignore_step_into_function_) return;

thread_local_.ignore_step_into_function_ = Smi::kZero;

FloodWithOneShot(Handle<SharedFunctionInfo>(function->shared(), isolate_));

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(Handle<SharedFunctionInfo>(function->shared(), isolate_));

clear_suspended_generator();

if (last_step_action() == StepNone) return;

if (ignore_events()) return;

if (in_debug_scope()) return;

if (break_disabled()) return;

ClearOneShot();

int current_frame_count = CurrentFrameCount();

// 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;

List<SharedFunctionInfo*> infos;

frame->GetFunctions(&infos);

current_frame_count -= infos.length();

it.Advance();

}

// No handler found. Nothing to instrument.

if (it.done()) return;

bool found_handler = false;

// Iterate frames, including inlined frames. First, find the handler frame.

// Then skip to the frame we want to break in, then instrument for stepping.

for (; !it.done(); it.Advance()) {

JavaScriptFrame* frame = JavaScriptFrame::cast(it.frame());

if (last_step_action() == StepIn) {

// Deoptimize frame to ensure calls are checked for step-in.

Deoptimizer::DeoptimizeFunction(frame->function());

}

List<FrameSummary> summaries;

frame->Summarize(&summaries);

for (int i = summaries.length() - 1; i >= 0; i--, current_frame_count--) {

if (!found_handler) {

// We have yet to find the handler. If the frame inlines multiple

// functions, we have to check each one for the handler.

// If it only contains one function, we already found the handler.

if (summaries.length() > 1) {

Handle<AbstractCode> code =

summaries[i].AsJavaScript().abstract_code();

CHECK_EQ(AbstractCode::INTERPRETED_FUNCTION, code->kind());

BytecodeArray* bytecode = code->GetBytecodeArray();

HandlerTable* table = HandlerTable::cast(bytecode->handler_table());

int code_offset = summaries[i].code_offset();

HandlerTable::CatchPrediction prediction;

int index = table->LookupRange(code_offset, nullptr, &prediction);

if (index > 0) found_handler = true;

} else {

found_handler = true;

}

}

if (found_handler) {

// We found the handler. If we are stepping next or out, we need to

// iterate until we found the suitable target frame to break in.

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

current_frame_count > thread_local_.target_frame_count_) {

continue;

}

Handle<SharedFunctionInfo> info(

summaries[i].AsJavaScript().function()->shared());

if (IsBlackboxed(info)) continue;

FloodWithOneShot(info);

return;

}

}

}

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();