// Copyright 2012 the V8 project authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#include "src/debug/debug.h"

#include "src/api.h"

#include "src/arguments.h"

#include "src/bootstrapper.h"

#include "src/code-stubs.h"

#include "src/codegen.h"

#include "src/compilation-cache.h"

#include "src/compiler.h"

#include "src/deoptimizer.h"

#include "src/execution.h"

#include "src/frames-inl.h"

#include "src/full-codegen/full-codegen.h"

#include "src/global-handles.h"

#include "src/isolate-inl.h"

#include "src/list.h"

#include "src/log.h"

#include "src/messages.h"

#include "src/snapshot/natives.h"

#include "include/v8-debug.h"

namespace v8 {

namespace internal {

Debug::Debug(Isolate* isolate)

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

in_debug_event_listener_(false),

break_on_exception_(false),

break_on_uncaught_exception_(false),

debug_info_list_(NULL),

isolate_(isolate) {

ThreadInit();

}

static v8::Local<v8::Context> GetDebugEventContext(Isolate* isolate) {

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

}

BreakLocation::BreakLocation(Handle<DebugInfo> debug_info, RelocInfo* rinfo,

int position, int statement_position)

: debug_info_(debug_info),

pc_offset_(static_cast<int>(rinfo->pc() - debug_info->code()->entry())),

rmode_(rinfo->rmode()),

data_(rinfo->data()),

position_(position),

statement_position_(statement_position) {}

BreakLocation::Iterator::Iterator(Handle<DebugInfo> debug_info,

BreakLocatorType type)

: debug_info_(debug_info),

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

break_index_(-1),

position_(1),

statement_position_(1) {

if (!Done()) Next();

}

int BreakLocation::Iterator::GetModeMask(BreakLocatorType type) {

int mask = 0;

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

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

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

if (type == ALL_BREAK_LOCATIONS) {

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

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

}

return mask;

}

void BreakLocation::Iterator::Next() {

DisallowHeapAllocation no_gc;

DCHECK(!Done());

// Iterate through reloc info for code and original code stopping at each

// breakable code target.

bool first = break_index_ == -1;

while (!Done()) {

if (!first) reloc_iterator_.next();

first = false;

if (Done()) return;

// Whenever a statement position or (plain) position is passed update the

// current value of these.

if (RelocInfo::IsPosition(rmode())) {

if (RelocInfo::IsStatementPosition(rmode())) {

statement_position_ = static_cast<int>(

rinfo()->data() - debug_info_->shared()->start_position());

}

// Always update the position as we don't want that to be before the

// statement position.

position_ = static_cast<int>(rinfo()->data() -

debug_info_->shared()->start_position());

DCHECK(position_ >= 0);

DCHECK(statement_position_ >= 0);

continue;

}

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

RelocInfo::IsDebuggerStatement(rmode()));

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

// Set the positions to the end of the function.

if (debug_info_->shared()->HasSourceCode()) {

position_ = debug_info_->shared()->end_position() -

debug_info_->shared()->start_position() - 1;

} else {

position_ = 0;

}

statement_position_ = position_;

}

break;

}

break_index_++;

}

// Find the break point at the supplied address, or the closest one before

// the address.

BreakLocation BreakLocation::FromAddress(Handle<DebugInfo> debug_info,

BreakLocatorType type, Address pc) {

Iterator it(debug_info, type);

it.SkipTo(BreakIndexFromAddress(debug_info, type, pc));

return it.GetBreakLocation();

}

// Find the break point at the supplied address, or the closest one before

// the address.

void BreakLocation::FromAddressSameStatement(Handle<DebugInfo> debug_info,

BreakLocatorType type, Address pc,

List<BreakLocation>* result_out) {

int break_index = BreakIndexFromAddress(debug_info, type, pc);

Iterator it(debug_info, type);

it.SkipTo(break_index);

int statement_position = it.statement_position();

while (!it.Done() && it.statement_position() == statement_position) {

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

it.Next();

}

}

int BreakLocation::BreakIndexFromAddress(Handle<DebugInfo> debug_info,

BreakLocatorType type, Address pc) {

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

int closest_break = 0;

int distance = kMaxInt;

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

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

if (it.pc() <= pc && pc - it.pc() < distance) {

closest_break = it.break_index();

distance = static_cast<int>(pc - it.pc());

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

if (distance == 0) break;

}

}

return closest_break;

}

BreakLocation BreakLocation::FromPosition(Handle<DebugInfo> debug_info,

BreakLocatorType type, int position,

BreakPositionAlignment alignment) {

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

// position.

int closest_break = 0;

int distance = kMaxInt;

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

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

distance = next_position - position;

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

if (distance == 0) break;

}

}

Iterator it(debug_info, type);

it.SkipTo(closest_break);

return it.GetBreakLocation();

}

void BreakLocation::SetBreakPoint(Handle<Object> break_point_object) {

// 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_, pc_offset_, position_,

statement_position_, break_point_object);

}

void BreakLocation::ClearBreakPoint(Handle<Object> break_point_object) {

// Clear the break point information.

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

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

if (!HasBreakPoint()) {

ClearDebugBreak();

DCHECK(!IsDebugBreak());

}

}

void BreakLocation::SetOneShot() {

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

}

void BreakLocation::ClearOneShot() {

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

}

void BreakLocation::SetDebugBreak() {

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

Builtins* builtins = debug_info_->GetIsolate()->builtins();

Handle<Code> target =

IsReturn() ? builtins->Return_DebugBreak() : builtins->Slot_DebugBreak();

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

DCHECK(IsDebugBreak());

}

void BreakLocation::ClearDebugBreak() {

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

if (IsDebuggerStatement()) return;

DCHECK(IsDebugBreakSlot());

DebugCodegen::ClearDebugBreakSlot(pc());

DCHECK(!IsDebugBreak());

}

bool BreakLocation::IsStepInLocation() const {

return IsConstructCall() || IsCall();

}

bool BreakLocation::IsDebugBreak() const {

if (IsDebugBreakSlot()) {

return rinfo().IsPatchedDebugBreakSlotSequence();

}

return false;

}

Handle<Object> BreakLocation::BreakPointObjects() const {

return debug_info_->GetBreakPointObjects(pc_offset_);

}

// Threading support.

void Debug::ThreadInit() {

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_.step_count_ = 0;

thread_local_.last_fp_ = 0;

thread_local_.queued_step_count_ = 0;

thread_local_.step_into_fp_ = 0;

thread_local_.step_out_fp_ = 0;

// TODO(isolates): frames_are_dropped_?

base::NoBarrier_Store(&thread_local_.current_debug_scope_,

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

thread_local_.restarter_frame_function_pointer_ = NULL;

}

char* Debug::ArchiveDebug(char* storage) {

char* to = storage;

MemCopy(to, reinterpret_cast<char*>(&thread_local_), sizeof(ThreadLocal));

ThreadInit();

return storage + ArchiveSpacePerThread();

}

char* Debug::RestoreDebug(char* storage) {

char* from = storage;

MemCopy(reinterpret_cast<char*>(&thread_local_), from, sizeof(ThreadLocal));

return storage + ArchiveSpacePerThread();

}

int Debug::ArchiveSpacePerThread() {

return sizeof(ThreadLocal);

}

DebugInfoListNode::DebugInfoListNode(DebugInfo* debug_info): next_(NULL) {

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

}

DebugInfoListNode::~DebugInfoListNode() {

if (debug_info_ == nullptr) return;

GlobalHandles::Destroy(reinterpret_cast<Object**>(debug_info_));

debug_info_ = nullptr;

}

bool Debug::Load() {

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

return true;

}

void Debug::Unload() {

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

}

void Debug::Break(Arguments args, JavaScriptFrame* frame) {

Heap* heap = isolate_->heap();

HandleScope scope(isolate_);

DCHECK(args.length() == 0);

// 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 point where execution has stopped.

// PC points to the instruction after the current one, possibly a break

// location as well. So the "- 1" to exclude it from the search.

Address call_pc = frame->pc() - 1;

BreakLocation break_location =

BreakLocation::FromAddress(debug_info, ALL_BREAK_LOCATIONS, call_pc);

// Check whether step next reached a new statement.

if (!StepNextContinue(&break_location, frame)) {

// Decrease steps left if performing multiple steps.

if (thread_local_.step_count_ > 0) {

thread_local_.step_count_--;

}

}

// If there is one or more real break points check whether any of these are

// triggered.

Handle<Object> break_points_hit(heap->undefined_value(), isolate_);

if (break_location.HasBreakPoint()) {

Handle<Object> break_point_objects = break_location.BreakPointObjects();

break_points_hit = CheckBreakPoints(break_point_objects);

}

// If step out is active skip everything until the frame where we need to step

// out to is reached, unless real breakpoint is hit.

if (StepOutActive() &&

frame->fp() != thread_local_.step_out_fp_ &&

break_points_hit->IsUndefined() ) {

// Step count should always be 0 for StepOut.

DCHECK(thread_local_.step_count_ == 0);

} else if (!break_points_hit->IsUndefined() ||

(thread_local_.last_step_action_ != StepNone &&

thread_local_.step_count_ == 0)) {

// Notify debugger if a real break point is triggered or if performing

// single stepping with no more steps to perform. Otherwise do another step.

// Clear all current stepping setup.

ClearStepping();

if (thread_local_.queued_step_count_ > 0) {

// Perform queued steps

int step_count = thread_local_.queued_step_count_;

// Clear queue

thread_local_.queued_step_count_ = 0;

PrepareStep(StepNext, step_count, StackFrame::NO_ID);

} else {

// Notify the debug event listeners.

OnDebugBreak(break_points_hit, false);

}

} else if (thread_local_.last_step_action_ != StepNone) {

// Hold on to last step action as it is cleared by the call to

// ClearStepping.

StepAction step_action = thread_local_.last_step_action_;

int step_count = thread_local_.step_count_;

// If StepNext goes deeper in code, StepOut until original frame

// and keep step count queued up in the meantime.

if (step_action == StepNext && frame->fp() < thread_local_.last_fp_) {

// Count frames until target frame

int count = 0;

JavaScriptFrameIterator it(isolate_);

while (!it.done() && it.frame()->fp() < thread_local_.last_fp_) {

count++;

it.Advance();

}

// Check that we indeed found the frame we are looking for.

CHECK(!it.done() && (it.frame()->fp() == thread_local_.last_fp_));

if (step_count > 1) {

// Save old count and action to continue stepping after StepOut.

thread_local_.queued_step_count_ = step_count - 1;

}

// Set up for StepOut to reach target frame.

step_action = StepOut;

step_count = count;

}

// Clear all current stepping setup.

ClearStepping();

// Set up for the remaining steps.

PrepareStep(step_action, step_count, StackFrame::NO_ID);

}

}

// Check the break point objects for whether one or more are actually

// triggered. This function returns a JSArray with the break point objects

// which is triggered.

Handle<Object> Debug::CheckBreakPoints(Handle<Object> break_point_objects) {

Factory* factory = isolate_->factory();

// 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> o(array->get(i), isolate_);

if (CheckBreakPoint(o)) {

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

}

}

} else {

break_points_hit = factory->NewFixedArray(1);

if (CheckBreakPoint(break_point_objects)) {

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

}

}

// Return undefined if no break points were triggered.

if (break_points_hit_count == 0) {

return factory->undefined_value();

}

// Return break points hit as a JSArray.

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

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

return result;

}

MaybeHandle<Object> Debug::CallFunction(const char* name, int argc,

Handle<Object> args[]) {

PostponeInterruptsScope no_interrupts(isolate_);

AssertDebugContext();

Handle<Object> holder = isolate_->natives_utils_object();

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

Object::GetProperty(isolate_, holder, name, STRICT).ToHandleChecked());

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

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

}

// Check whether a single break point object is triggered.

bool Debug::CheckBreakPoint(Handle<Object> break_point_object) {

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

}

bool Debug::SetBreakPoint(Handle<JSFunction> function,

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, ALL_BREAK_LOCATIONS, *source_position, STATEMENT_ALIGNED);

*source_position = location.statement_position();

location.SetBreakPoint(break_point_object);

// At least one active break point now.

return debug_info->GetBreakPointCount() > 0;

}

bool Debug::SetBreakPointForScript(Handle<Script> script,

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, ALL_BREAK_LOCATIONS, position, alignment);

location.SetBreakPoint(break_point_object);

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;

}

void Debug::ClearBreakPoint(Handle<Object> break_point_object) {

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

// Find the break point and clear it.

Address pc = debug_info->code()->entry() +

break_point_info->code_position()->value();

BreakLocation location =

BreakLocation::FromAddress(debug_info, ALL_BREAK_LOCATIONS, pc);

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

}

}

// Clear out all the debug break code. This is ONLY supposed to be used when

// shutting down the debugger as it will leave the break point information in

// DebugInfo even though the code is patched back to the non break point state.

void Debug::ClearAllBreakPoints() {

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

node = node->next()) {

for (BreakLocation::Iterator it(node->debug_info(), ALL_BREAK_LOCATIONS);

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

it.GetBreakLocation().ClearDebugBreak();

}

}

// Remove all debug info.

while (debug_info_list_ != NULL) {

RemoveDebugInfoAndClearFromShared(debug_info_list_->debug_info());

}

}

void Debug::FloodWithOneShot(Handle<JSFunction> function,

BreakLocatorType type) {

// 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 (BreakLocation::Iterator it(debug_info, type); !it.Done(); it.Next()) {

it.GetBreakLocation().SetOneShot();

}

}

void Debug::FloodBoundFunctionWithOneShot(Handle<JSFunction> function) {

Handle<FixedArray> new_bindings(function->function_bindings());

Handle<Object> bindee(new_bindings->get(JSFunction::kBoundFunctionIndex),

isolate_);

if (!bindee.is_null() && bindee->IsJSFunction()) {

Handle<JSFunction> bindee_function(JSFunction::cast(*bindee));

FloodWithOneShotGeneric(bindee_function);

}

}

void Debug::FloodDefaultConstructorWithOneShot(Handle<JSFunction> function) {

DCHECK(function->shared()->is_default_constructor());

// Instead of stepping into the function we directly step into the super class

// constructor.

Isolate* isolate = function->GetIsolate();

PrototypeIterator iter(isolate, function);

Handle<Object> proto = PrototypeIterator::GetCurrent(iter);

if (!proto->IsJSFunction()) return; // Object.prototype

Handle<JSFunction> function_proto = Handle<JSFunction>::cast(proto);

FloodWithOneShotGeneric(function_proto);

}

void Debug::FloodWithOneShotGeneric(Handle<JSFunction> function,

Handle<Object> holder) {

if (function->shared()->bound()) {

FloodBoundFunctionWithOneShot(function);

} else if (function->shared()->is_default_constructor()) {

FloodDefaultConstructorWithOneShot(function);

} else {

Isolate* isolate = function->GetIsolate();

// Don't allow step into functions in the native context.

if (function->shared()->code() ==

isolate->builtins()->builtin(Builtins::kFunctionApply) ||

function->shared()->code() ==

isolate->builtins()->builtin(Builtins::kFunctionCall)) {

// Handle function.apply and function.call separately to flood the

// function to be called and not the code for Builtins::FunctionApply or

// Builtins::FunctionCall. The receiver of call/apply is the target

// function.

if (!holder.is_null() && holder->IsJSFunction()) {

Handle<JSFunction> js_function = Handle<JSFunction>::cast(holder);

FloodWithOneShotGeneric(js_function);

}

} else {

FloodWithOneShot(function);

}

}

}

void Debug::FloodHandlerWithOneShot() {

// Iterate through the JavaScript stack looking for handlers.

StackFrame::Id id = break_frame_id();

if (id == StackFrame::NO_ID) {

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

return;

}

for (JavaScriptFrameIterator it(isolate_, id); !it.done(); it.Advance()) {

JavaScriptFrame* frame = it.frame();

int stack_slots = 0; // The computed stack slot count is not used.

if (frame->LookupExceptionHandlerInTable(&stack_slots, NULL) > 0) {

// Flood the function with the catch/finally block with break points.

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

return;

}

}

}

void Debug::ChangeBreakOnException(ExceptionBreakType type, bool enable) {

if (type == BreakUncaughtException) {

break_on_uncaught_exception_ = enable;

} else {

break_on_exception_ = enable;

}

}

bool Debug::IsBreakOnException(ExceptionBreakType type) {

if (type == BreakUncaughtException) {

return break_on_uncaught_exception_;

} else {

return break_on_exception_;

}

}

FrameSummary GetFirstFrameSummary(JavaScriptFrame* frame) {

List<FrameSummary> frames(FLAG_max_inlining_levels + 1);

frame->Summarize(&frames);

return frames.first();

}

void Debug::PrepareStep(StepAction step_action,

int step_count,

StackFrame::Id frame_id) {

HandleScope scope(isolate_);

DCHECK(in_debug_scope());

// Remember this step action and count.

thread_local_.last_step_action_ = step_action;

if (step_action == StepOut) {

// For step out target frame will be found on the stack so there is no need

// to set step counter for it. It's expected to always be 0 for StepOut.

thread_local_.step_count_ = 0;

} else {

thread_local_.step_count_ = step_count;

}

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

if (id == StackFrame::NO_ID) {

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

return;

}

if (frame_id != StackFrame::NO_ID) {

id = frame_id;

}

JavaScriptFrameIterator frames_it(isolate_, id);

JavaScriptFrame* frame = frames_it.frame();

// First of all ensure there is one-shot break points in the top handler

// if any.

FloodHandlerWithOneShot();

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

// be the case when calling unknown function and having the debugger stopped

// in an unhandled exception.

if (!frame->function()->IsJSFunction()) {

// Step out: Find the calling JavaScript frame and flood it with

// breakpoints.

frames_it.Advance();

// Fill the function to return to with one-shot break points.

JSFunction* function = frames_it.frame()->function();

FloodWithOneShot(Handle<JSFunction>(function));

return;

}

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

FrameSummary summary = GetFirstFrameSummary(frame);

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

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

if (!EnsureDebugInfo(shared, function)) {

// Return if ensuring debug info failed.

return;

}

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

// Refresh frame summary if the code has been recompiled for debugging.

if (shared->code() != *summary.code()) summary = GetFirstFrameSummary(frame);

// PC points to the instruction after the current one, possibly a break

// location as well. So the "- 1" to exclude it from the search.

Address call_pc = summary.pc() - 1;

BreakLocation location =

BreakLocation::FromAddress(debug_info, ALL_BREAK_LOCATIONS, call_pc);

// If this is the last break code target step out is the only possibility.

if (location.IsReturn() || step_action == StepOut) {

if (step_action == StepOut) {

// Skip step_count frames starting with the current one.

while (step_count-- > 0 && !frames_it.done()) {

frames_it.Advance();

}

} else {

DCHECK(location.IsReturn());

frames_it.Advance();

}

// Skip native and extension functions on the stack.

while (!frames_it.done() &&

!frames_it.frame()->function()->IsSubjectToDebugging()) {

frames_it.Advance();

}

// Step out: If there is a JavaScript caller frame, we need to

// flood it with breakpoints.

if (!frames_it.done()) {

// Fill the function to return to with one-shot break points.

JSFunction* function = frames_it.frame()->function();

FloodWithOneShot(Handle<JSFunction>(function));

// Set target frame pointer.

ActivateStepOut(frames_it.frame());

}

return;

}

if (step_action != StepNext && step_action != StepMin) {

// If there's restarter frame on top of the stack, just get the pointer

// to function which is going to be restarted.

if (thread_local_.restarter_frame_function_pointer_ != NULL) {

Handle<JSFunction> restarted_function(

JSFunction::cast(*thread_local_.restarter_frame_function_pointer_));

FloodWithOneShot(restarted_function);

} else if (location.IsCall()) {

// Find target function on the expression stack.

// Expression stack looks like this (top to bottom):

// argN

// ...

// arg0

// Receiver

// Function to call

int num_expressions_without_args =

frame->ComputeExpressionsCount() - location.CallArgumentsCount();

DCHECK(num_expressions_without_args >= 2);

Object* fun = frame->GetExpression(num_expressions_without_args - 2);

// Flood the actual target of call/apply.

if (fun->IsJSFunction()) {

Isolate* isolate = JSFunction::cast(fun)->GetIsolate();

Code* apply = isolate->builtins()->builtin(Builtins::kFunctionApply);

Code* call = isolate->builtins()->builtin(Builtins::kFunctionCall);

// Find target function on the expression stack for expression like

// Function.call.call...apply(...)

int i = 1;

while (fun->IsJSFunction()) {

Code* code = JSFunction::cast(fun)->shared()->code();

if (code != apply && code != call) break;

DCHECK(num_expressions_without_args >= i);

fun = frame->GetExpression(num_expressions_without_args - i);

i--;

}

}

if (fun->IsJSFunction()) {

Handle<JSFunction> js_function(JSFunction::cast(fun));

FloodWithOneShotGeneric(js_function);

}

}

ActivateStepIn(frame);

}

// Fill the current function with one-shot break points even for step in on

// a call target as the function called might be a native function for

// which step in will not stop. It also prepares for stepping in

// getters/setters.

// If we are stepping into another frame, only fill calls and returns.

FloodWithOneShot(function, step_action == StepFrame ? CALLS_AND_RETURNS

: ALL_BREAK_LOCATIONS);

// Remember source position and frame to handle step next.

thread_local_.last_statement_position_ =

debug_info->code()->SourceStatementPosition(summary.pc());

thread_local_.last_fp_ = frame->UnpaddedFP();

}