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

#include "src/api.h"

#include "src/arguments.h"

#include "src/assembler-inl.h"

#include "src/bootstrapper.h"

#include "src/code-stubs.h"

#include "src/codegen.h"

#include "src/compilation-cache.h"

#include "src/compiler-dispatcher/optimizing-compile-dispatcher.h"

#include "src/compiler.h"

#include "src/debug/debug-evaluate.h"

#include "src/debug/liveedit.h"

#include "src/deoptimizer.h"

#include "src/execution.h"

#include "src/frames-inl.h"

#include "src/global-handles.h"

#include "src/globals.h"

#include "src/interpreter/interpreter.h"

#include "src/isolate-inl.h"

#include "src/log.h"

#include "src/messages.h"

#include "src/objects/debug-objects-inl.h"

#include "src/snapshot/natives.h"

#include "src/wasm/wasm-objects-inl.h"

#include "include/v8-debug.h"

namespace v8 {

namespace internal {

Debug::Debug(Isolate* isolate)

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

}

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

JavaScriptFrame* frame) {

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

int offset = summary.code_offset();

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

BreakIterator it(debug_info);

it.SkipTo(BreakIndexFromCodeOffset(debug_info, abstract_code, offset));

return it.GetBreakLocation();

}

void BreakLocation::AllAtCurrentStatement(

Handle<DebugInfo> debug_info, JavaScriptFrame* frame,

std::vector<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;

{

BreakIterator it(debug_info);

it.SkipTo(BreakIndexFromCodeOffset(debug_info, abstract_code, offset));

statement_position = it.statement_position();

}

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

if (it.statement_position() == statement_position) {

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

}

}

}

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

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 (BreakIterator it(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;

}

bool BreakLocation::HasBreakPoint(Handle<DebugInfo> debug_info) const {

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

DCHECK(abstract_code_->IsBytecodeArray());

BreakIterator it(debug_info);

it.SkipToPosition(position_);

return it.code_offset() == code_offset_;

}

debug::BreakLocationType BreakLocation::type() const {

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;

}

BreakIterator::BreakIterator(Handle<DebugInfo> debug_info)

: debug_info_(debug_info),

break_index_(-1),

source_position_iterator_(

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

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

statement_position_ = position_;

// There is at least one break location.

DCHECK(!Done());

Next();

}

int BreakIterator::BreakIndexFromPosition(int source_position) {

int distance = kMaxInt;

int closest_break = break_index();

while (!Done()) {

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

}

void BreakIterator::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_LE(0, position_);

DCHECK_LE(0, statement_position_);

DebugBreakType type = GetDebugBreakType();

if (type != NOT_DEBUG_BREAK) break;

}

break_index_++;

}

DebugBreakType BreakIterator::GetDebugBreakType() {

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

}

}

void BreakIterator::SkipToPosition(int position) {

BreakIterator it(debug_info_);

SkipTo(it.BreakIndexFromPosition(position));

}

void BreakIterator::SetDebugBreak() {

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

}

void BreakIterator::ClearDebugBreak() {

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

}

BreakLocation BreakIterator::GetBreakLocation() {

Handle<AbstractCode> code(

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

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

}

void DebugFeatureTracker::Track(DebugFeatureTracker::Feature feature) {

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;

}

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

thread_local_.last_breakpoint_id_ = 0;

clear_suspended_generator();

thread_local_.restart_fp_ = nullptr;

base::Relaxed_Store(&thread_local_.current_debug_scope_,

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

UpdateHookOnFunctionCall();

}

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

// Simply reset state. Don't archive anything.

ThreadInit();

return storage + ArchiveSpacePerThread();

}

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

// Simply reset state. Don't restore anything.

ThreadInit();

return storage + ArchiveSpacePerThread();

}

int Debug::ArchiveSpacePerThread() { return 0; }

void Debug::Iterate(RootVisitor* v) {

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

}

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

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;

}

void Debug::Unload() {

ClearAllBreakPoints();

ClearStepping();

RemoveAllCoverageInfos();

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

}

void Debug::Break(JavaScriptFrame* frame) {

// 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 (!EnsureBreakInfo(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.

OnDebugBreak(break_points_hit.ToHandleChecked());

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;

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

} else {

// Re-prepare to continue.

PrepareStep(step_action);

}

}

// Find break point objects for this location, if any, and evaluate them.

// Return an array of break point objects that evaluated true, or an empty

// handle if none evaluated true.

MaybeHandle<FixedArray> Debug::CheckBreakPoints(Handle<DebugInfo> debug_info,

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

}

bool Debug::IsMutedAtCurrentLocation(JavaScriptFrame* frame) {

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()->HasBreakInfo()) return false;

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

// Enter the debugger.

DebugScope debug_scope(this);

if (debug_scope.failed()) return false;

std::vector<BreakLocation> break_locations;

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

bool has_break_points_at_all = false;

for (size_t i = 0; i < break_locations.size(); 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;

}

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

Handle<Object> args[],

bool catch_exceptions) {

AllowJavascriptExecutionDebugOnly allow_script(isolate_);

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

if (catch_exceptions) {

MaybeHandle<Object> maybe_exception;

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

Execution::MessageHandling::kReport,

&maybe_exception);

} else {

return Execution::Call(isolate_, 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_);

// TODO(kozyatinskiy): replace this if by DCHEK once the JS debug API has been

// removed.

if (break_point_object->IsBreakPoint()) {

Handle<BreakPoint> break_point =

Handle<BreakPoint>::cast(break_point_object);

if (!break_point->condition()->length()) return true;

Handle<String> condition(break_point->condition());

Handle<Object> result;

// Since we call CheckBreakpoint only for deoptimized frame on top of stack,

// we can use 0 as index of inlined frame.

if (!DebugEvaluate::Local(isolate_, break_frame_id(),

/* inlined_jsframe_index */ 0, condition, false)

.ToHandle(&result)) {

if (isolate_->has_pending_exception()) {

isolate_->clear_pending_exception();

}

return false;

}

return result->BooleanValue();

}

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

}

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 (!EnsureBreakInfo(shared)) return true;

PrepareFunctionForBreakPoints(shared);

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

// Source positions starts with zero.

DCHECK_LE(0, *source_position);

// Find the break point and change it.

*source_position = FindBreakablePosition(debug_info, *source_position);

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

// At least one active break point now.

DCHECK_LT(0, debug_info->GetBreakPointCount());

ClearBreakPoints(debug_info);

ApplyBreakPoints(debug_info);

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

return true;

}

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

Handle<Object> break_point_object,

int* source_position) {

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 (!EnsureBreakInfo(shared)) return false;

PrepareFunctionForBreakPoints(shared);

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

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

// At least one active break point now.

DCHECK_LT(0, debug_info->GetBreakPointCount());

ClearBreakPoints(debug_info);

ApplyBreakPoints(debug_info);

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

return true;

}

int Debug::FindBreakablePosition(Handle<DebugInfo> debug_info,

int source_position) {

DCHECK(debug_info->HasDebugBytecodeArray());

BreakIterator it(debug_info);

it.SkipToPosition(source_position);

return it.position();

}

void Debug::ApplyBreakPoints(Handle<DebugInfo> debug_info) {

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;

DCHECK(debug_info->HasDebugBytecodeArray());

BreakIterator it(debug_info);

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

it.SetDebugBreak();

}

}

void Debug::ClearBreakPoints(Handle<DebugInfo> debug_info) {

// If we attempt to clear breakpoints but none exist, simply return. This can

// happen e.g. CoverageInfos exit but no breakpoints are set.

if (!debug_info->HasDebugBytecodeArray()) return;

DisallowHeapAllocation no_gc;

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

it.ClearDebugBreak();

}

}

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

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

RemoveBreakInfoAndMaybeFree(debug_info);

} else {

ApplyBreakPoints(debug_info);

}

return;

}

}

}

bool Debug::SetBreakpoint(Handle<Script> script, Handle<String> condition,

int* offset, int* id) {

*id = ++thread_local_.last_breakpoint_id_;

Handle<BreakPoint> breakpoint =

isolate_->factory()->NewBreakPoint(*id, condition);

return SetBreakPointForScript(script, breakpoint, offset);

}

void Debug::RemoveBreakpoint(int id) {

Handle<BreakPoint> breakpoint = isolate_->factory()->NewBreakPoint(

id, isolate_->factory()->empty_string());

ClearBreakPoint(breakpoint);

}

// Clear out all the debug break code.

void Debug::ClearAllBreakPoints() {

ClearAllDebugInfos([=](Handle<DebugInfo> info) {

ClearBreakPoints(info);

return info->ClearBreakInfo();

});

}

void Debug::FloodWithOneShot(Handle<SharedFunctionInfo> shared,

bool returns_only) {

if (IsBlackboxed(shared)) return;

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

if (!EnsureBreakInfo(shared)) return;

PrepareFunctionForBreakPoints(shared);

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

// Flood the function with break points.

DCHECK(debug_info->HasDebugBytecodeArray());

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

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

it.SetDebugBreak();

}

}

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

}

}

MaybeHandle<FixedArray> Debug::GetHitBreakPointObjects(

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;

}

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

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

}

void Debug::PrepareStepInSuspendedGenerator() {

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

}

void Debug::PrepareStepOnThrow() {

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;

std::vector<SharedFunctionInfo*> infos;

frame->GetFunctions(&infos);

current_frame_count -= infos.size();

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

}

std::vector<FrameSummary> summaries;

frame->Summarize(&summaries);

for (size_t i = summaries.size(); i != 0; i--, current_frame_count--) {

const FrameSummary& summary = summaries[i - 1];

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.size() > 1) {

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

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

BytecodeArray* bytecode = code->GetBytecodeArray();

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

int code_offset = summary.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(

summary.AsJavaScript().function()->shared());

if (IsBlackboxed(info)) continue;

FloodWithOneShot(info);

return;

}

}

}

}

void Debug::PrepareStep(StepAction step_action) {

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;

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

thread_local_.last_step_action_ = step_action;

StackTraceFrameIterator frames_it(isolate_, frame_id);

StandardFrame* frame = frames_it.frame();

// Handle stepping in wasm functions via the wasm interpreter.

if (frame->is_wasm()) {

// If the top frame is compiled, we cannot step.

if (frame->is_wasm_compiled()) return;

WasmInterpreterEntryFrame* wasm_frame =

WasmInterpreterEntryFrame::cast(frame);

wasm_frame->wasm_instance()->debug_info()->PrepareStep(step_action);

return;

}

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

DCHECK(js_frame->function()->IsJSFunction());

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

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

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

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

if (!EnsureBreakInfo(shared)) return;

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

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

// Any step at a return is a step-out and we need to schedule DebugOnFunction

// call callback.

if (location.IsReturn()) {

// On StepOut we'll ignore our further calls to current function in

// PrepareStepIn callback.

if (last_step_action() == StepOut) {

thread_local_.ignore_step_into_function_ = *function;

}

step_action = StepOut;

thread_local_.last_step_action_ = StepIn;

}

UpdateHookOnFunctionCall();

// A step-next in blackboxed function is a step-out.

if (step_action == StepNext && IsBlackboxed(shared)) step_action = StepOut;

thread_local_.last_statement_position_ =

summary.abstract_code()->SourceStatementPosition(summary.code_offset());

int current_frame_count = CurrentFrameCount();

thread_local_.last_frame_count_ = current_frame_count;

// No longer perform the current async step.

clear_suspended_generator();

switch (step_action) {

case StepNone:

UNREACHABLE();

break;

case StepOut: {

// Clear last position info. For stepping out it does not matter.

thread_local_.last_statement_position_ = kNoSourcePosition;

thread_local_.last_frame_count_ = -1;

if (!location.IsReturn() && !IsBlackboxed(shared)) {

// At not return position we flood return positions with one shots and

// will repeat StepOut automatically at next break.

thread_local_.target_frame_count_ = current_frame_count;

thread_local_.fast_forward_to_return_ = true;

FloodWithOneShot(shared, true);

return;

}

// Skip the current frame, find the first frame we want to step out to

// and deoptimize every frame along the way.

bool in_current_frame = true;

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

// TODO(clemensh): Implement stepping out from JS to wasm.

if (frames_it.frame()->is_wasm()) continue;

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

if (last_step_action() == StepIn) {

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

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

}

HandleScope scope(isolate_);

std::vector<Handle<SharedFunctionInfo>> infos;

frame->GetFunctions(&infos);

for (; !infos.empty(); current_frame_count--) {

Handle<SharedFunctionInfo> info = infos.back();

infos.pop_back();

if (in_current_frame) {

// We want to skip out, so skip the current frame.

in_current_frame = false;

continue;

}

if (IsBlackboxed(info)) continue;

FloodWithOneShot(info);

thread_local_.target_frame_count_ = current_frame_count;

return;

}

}

break;

}

case StepNext:

thread_local_.target_frame_count_ = current_frame_count;

// Fall through.

case StepIn:

// TODO(clemensh): Implement stepping from JS into wasm.

FloodWithOneShot(shared);

break;

}

}

// Simple function for returning the source positions for active break points.

Handle<Object> Debug::GetSourceBreakLocations(

Handle<SharedFunctionInfo> shared) {

Isolate* isolate = shared->GetIsolate();

if (!shared->HasBreakInfo()) {

return isolate->factory()->undefined_value();

}

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

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

return isolate->factory()->undefined_value();

}

Handle<FixedArray> locations =

isolate->factory()->NewFixedArray(debug_info->GetBreakPointCount());

int count = 0;

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

if (!debug_info->break_points()->get(i)->IsUndefined(isolate)) {

BreakPointInfo* break_point_info =

BreakPointInfo::cast(debug_info->break_points()->get(i));

int break_points = break_point_info->GetBreakPointCount();

if (break_points == 0) continue;

for (int j = 0; j < break_points; ++j) {

locations->set(count++,

Smi::FromInt(break_point_info->source_position()));

}

}

}

return locations;

}