: 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),

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

debug_info_list_(NULL),

feature_tracker_(isolate),

isolate_(isolate) {

ThreadInit();

Handle<Context> context = isolate->debug()->debugger_entry()->GetContext();

// Isolate::context() may have been NULL when "script collected" event

// occured.

if (context.is_null()) return v8::Local<v8::Context>();

Handle<Context> native_context(context->native_context());

return v8::Utils::ToLocal(native_context);

int code_offset, int position,

int statement_position)

: debug_info_(debug_info),

code_offset_(code_offset),

type_(type),

position_(position),

int offset) {

base::SmartPointer<Iterator> it(GetIterator(debug_info));

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

return it->GetBreakLocation();

List<FrameSummary> frames(FLAG_max_inlining_levels + 1);

frame->Summarize(&frames);

return frames.first();

// Code offset points to the instruction after the call. Subtract 1 to

// exclude that instruction from the search. For bytecode, the code offset

// still points to the call.

return is_interpreted ? code_offset : code_offset - 1;

JavaScriptFrame* frame) {

FrameSummary summary = GetFirstFrameSummary(frame);

int call_offset =

CallOffsetFromCodeOffset(summary.code_offset(), frame->is_interpreted());

return FromCodeOffset(debug_info, call_offset);

int statement_position,

List<BreakLocation>* result_out) {

for (base::SmartPointer<Iterator> it(GetIterator(debug_info)); !it->Done();

it->Next()) {

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

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

}

}

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 < debug_info->abstract_code()->Size());

for (base::SmartPointer<Iterator> it(GetIterator(debug_info)); !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;

int position,

BreakPositionAlignment alignment) {

// Run through all break points to locate the one closest to the source

// position.

int distance = kMaxInt;

base::SmartPointer<Iterator> it(GetIterator(debug_info));

BreakLocation closest_break = it->GetBreakLocation();

while (!it->Done()) {

int next_position;

if (alignment == STATEMENT_ALIGNED) {

next_position = it->statement_position();

} else {

DCHECK(alignment == BREAK_POSITION_ALIGNED);

next_position = it->position();

}

if (position <= next_position && next_position - position < distance) {

closest_break = it->GetBreakLocation();

distance = next_position - position;

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

if (distance == 0) break;

}

it->Next();

}

return closest_break;

// If there is not already a real break point here patch code with debug

// break.

if (!HasBreakPoint()) SetDebugBreak();

DCHECK(IsDebugBreak() || IsDebuggerStatement());

// Set the break point information.

DebugInfo::SetBreakPoint(debug_info_, code_offset_, position_,

statement_position_, break_point_object);

// Clear the break point information.

DebugInfo::ClearBreakPoint(debug_info_, code_offset_, break_point_object);

// If there are no more break points here remove the debug break.

if (!HasBreakPoint()) {

ClearDebugBreak();

DCHECK(!IsDebugBreak());

}

// Debugger statement always calls debugger. No need to modify it.

if (IsDebuggerStatement()) return;

// If there is a real break point here no more to do.

if (HasBreakPoint()) {

DCHECK(IsDebugBreak());

return;

}

// Patch code with debug break.

SetDebugBreak();

// Debugger statement always calls debugger. No need to modify it.

if (IsDebuggerStatement()) return;

// If there is a real break point here no more to do.

if (HasBreakPoint()) {

DCHECK(IsDebugBreak());

return;

}

// Patch code removing debug break.

ClearDebugBreak();

DCHECK(!IsDebugBreak());

// Debugger statement always calls debugger. No need to modify it.

if (IsDebuggerStatement()) return;

// If there is already a break point here just return. This might happen if

// the same code is flooded with break points twice. Flooding the same

// function twice might happen when stepping in a function with an exception

// handler as the handler and the function is the same.

if (IsDebugBreak()) return;

DCHECK(IsDebugBreakSlot());

if (abstract_code()->IsCode()) {

Code* code = abstract_code()->GetCode();

DCHECK(code->kind() == Code::FUNCTION);

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

Handle<Code> target = IsReturn() ? builtins->Return_DebugBreak()

: builtins->Slot_DebugBreak();

Address pc = code->instruction_start() + code_offset();

DebugCodegen::PatchDebugBreakSlot(isolate(), pc, target);

} else {

BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();

interpreter::Bytecode bytecode =

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

interpreter::Bytecode debugbreak =

interpreter::Bytecodes::GetDebugBreak(bytecode);

bytecode_array->set(code_offset(),

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

}

DCHECK(IsDebugBreak());

// Debugger statement always calls debugger. No need to modify it.

if (IsDebuggerStatement()) return;

DCHECK(IsDebugBreakSlot());

if (abstract_code()->IsCode()) {

Code* code = abstract_code()->GetCode();

DCHECK(code->kind() == Code::FUNCTION);

Address pc = code->instruction_start() + code_offset();

DebugCodegen::ClearDebugBreakSlot(isolate(), pc);

} else {

BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();

BytecodeArray* original = debug_info_->original_bytecode_array();

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

}

DCHECK(!IsDebugBreak());

if (IsDebuggerStatement()) return false;

DCHECK(IsDebugBreakSlot());

if (abstract_code()->IsCode()) {

Code* code = abstract_code()->GetCode();

DCHECK(code->kind() == Code::FUNCTION);

Address pc = code->instruction_start() + code_offset();

return DebugCodegen::DebugBreakSlotIsPatched(pc);

} else {

BytecodeArray* bytecode_array = abstract_code()->GetBytecodeArray();

interpreter::Bytecode bytecode =

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

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

}

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_ = RelocInfo::kNoPosition;

thread_local_.last_fp_ = 0;

thread_local_.target_fp_ = 0;

thread_local_.step_in_enabled_ = false;

thread_local_.return_value_ = Handle<Object>();

// TODO(isolates): frames_are_dropped_?

base::NoBarrier_Store(&thread_local_.current_debug_scope_,

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

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

PostponeInterruptsScope postpone(isolate_);

// Create the debugger context.

HandleScope scope(isolate_);

ExtensionConfiguration no_extensions;

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

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

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

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

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

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

if (!EnsureDebugInfo(shared, function)) {

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

return;

}

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

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

Handle<Object> break_points_hit = CheckBreakPoints(&location);

if (!break_points_hit->IsUndefined()) {

// Clear all current stepping setup.

ClearStepping();

// Notify the debug event listeners.

OnDebugBreak(break_points_hit, 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 = GetFirstFrameSummary(frame);

int offset = summary.code_offset();

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

(current_fp != last_fp) ||

(thread_local_.last_statement_position_ !=

location.abstract_code()->SourceStatementPosition(offset));

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

}

bool* has_break_points) {

Factory* factory = isolate_->factory();

bool has_break_points_to_check =

break_points_active_ && location->HasBreakPoint();

if (has_break_points) *has_break_points = has_break_points_to_check;

if (!has_break_points_to_check) return factory->undefined_value();

Handle<Object> break_point_objects = location->BreakPointObjects();

// Count the number of break points hit. If there are multiple break points

// they are in a FixedArray.

Handle<FixedArray> break_points_hit;

int break_points_hit_count = 0;

DCHECK(!break_point_objects->IsUndefined());

if (break_point_objects->IsFixedArray()) {

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

break_points_hit = factory->NewFixedArray(array->length());

for (int i = 0; i < array->length(); 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);

}

}

} else {

break_points_hit = factory->NewFixedArray(1);

if (CheckBreakPoint(break_point_objects)) {

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

}

}

if (break_points_hit_count == 0) return factory->undefined_value();

Handle<JSArray> result = factory->NewJSArrayWithElements(break_points_hit);

result->set_length(Smi::FromInt(break_points_hit_count));

return result;

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

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

List<BreakLocation> break_locations;

BreakLocation::AllForStatementPosition(

debug_info, current_position.statement_position(), &break_locations);

bool has_break_points_at_all = false;

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

bool has_break_points;

Handle<Object> check_result =

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

has_break_points_at_all |= has_break_points;

if (has_break_points && !check_result->IsUndefined()) 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();

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

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

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.

BreakLocation location = BreakLocation::FromPosition(

debug_info, *source_position, STATEMENT_ALIGNED);

*source_position = location.statement_position();

location.SetBreakPoint(break_point_object);

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

// At least one active break point now.

return debug_info->GetBreakPointCount() > 0;

Handle<Object> break_point_object,

int* source_position,

BreakPositionAlignment alignment) {

HandleScope scope(isolate_);

// Obtain shared function info for the function.

Handle<Object> result =

FindSharedFunctionInfoInScript(script, *source_position);

if (result->IsUndefined()) 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.

int position;

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

position = 0;

} else {

position = *source_position - shared->start_position();

}

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

// Source positions starts with zero.

DCHECK(position >= 0);

// Find the break point and change it.

BreakLocation location =

BreakLocation::FromPosition(debug_info, position, alignment);

location.SetBreakPoint(break_point_object);

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

position = (alignment == STATEMENT_ALIGNED) ? location.statement_position()

: location.position();

*source_position = position + shared->start_position();

// At least one active break point now.

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

return true;

HandleScope scope(isolate_);

DebugInfoListNode* node = debug_info_list_;

while (node != NULL) {

Handle<Object> result =

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

if (!result->IsUndefined()) {

// Get information in the break point.

Handle<BreakPointInfo> break_point_info =

Handle<BreakPointInfo>::cast(result);

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

BreakLocation location = BreakLocation::FromCodeOffset(

debug_info, break_point_info->code_offset());

location.ClearBreakPoint(break_point_object);

// If there are no more break points left remove the debug info for this

// function.

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

RemoveDebugInfoAndClearFromShared(debug_info);

}

return;

}

node = node->next();

}

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

node = node->next()) {

for (base::SmartPointer<BreakLocation::Iterator> it(

BreakLocation::GetIterator(node->debug_info()));

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

it->GetBreakLocation().ClearDebugBreak();

}

}

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

for (base::SmartPointer<BreakLocation::Iterator> it(

BreakLocation::GetIterator(debug_info, type));

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

it->GetBreakLocation().SetOneShot();

}

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

}

if (!is_active()) return;

if (last_step_action() < StepIn) return;

if (in_debug_scope()) return;

if (thread_local_.step_in_enabled_) {

FloodWithOneShot(function);

}

if (!is_active()) return;

if (last_step_action() == StepNone) return;

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

}

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

if (frame_id == StackFrame::NO_ID) return;

JavaScriptFrameIterator frames_it(isolate_, frame_id);

JavaScriptFrame* frame = frames_it.frame();

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

// Remember this step action and count.

thread_local_.last_step_action_ = step_action;

STATIC_ASSERT(StepFrame > StepIn);

thread_local_.step_in_enabled_ = (step_action >= StepIn);

// If the function on the top frame is unresolved perform step out. This will