if (from == to) return;

base::MutexGuard guard(&mutex_);

auto it = objects_.find(from);

if (it == objects_.end()) {

// If temporary object was collected we can get MoveEvent which moves

// existing non temporary object to the address where we had temporary

// object. So we should mark new address as non temporary.

objects_.erase(to);

return;

}

objects_.erase(it);

objects_.insert(to);

if (IsJSObject(*obj) &&

Handle<JSObject>::cast(obj)->GetEmbedderFieldCount()) {

// Embedder may store any pointers using embedder fields and implements

// non trivial logic, e.g. create wrappers lazily and store pointer to

// native object inside embedder field. We should consider all objects

// with embedder fields as non temporary.

return false;

}

return objects_.find(obj->address()) != objects_.end();

: is_active_(false),

hook_on_function_call_(false),

is_suppressed_(false),

break_disabled_(false),

break_points_active_(true),

break_on_caught_exception_(false),

break_on_uncaught_exception_(false),

side_effect_check_failed_(false),

debug_infos_(isolate),

isolate_(isolate) {

ThreadInit();

JavaScriptFrame* frame) {

if (debug_info->CanBreakAtEntry()) {

return BreakLocation(Debug::kBreakAtEntryPosition, DEBUG_BREAK_AT_ENTRY);

}

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

Handle<DebugInfo> debug_info, std::vector<BreakLocation>& break_locations,

bool* has_break_points) {

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

debug_info->GetBreakPointCount(isolate_));

int break_points_hit_count = 0;

bool has_break_points_at_all = false;

for (size_t i = 0; i < break_locations.size(); i++) {

bool location_has_break_points;

MaybeHandle<FixedArray> check_result = CheckBreakPoints(

debug_info, &break_locations[i], &location_has_break_points);

has_break_points_at_all |= location_has_break_points;

if (!check_result.is_null()) {

Handle<FixedArray> break_points_current_hit =

check_result.ToHandleChecked();

int num_objects = break_points_current_hit->length();

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

break_points_hit->set(break_points_hit_count++,

break_points_current_hit->get(j));

}

}

}

*has_break_points = has_break_points_at_all;

if (break_points_hit_count == 0) return {};

break_points_hit->Shrink(isolate_, break_points_hit_count);

return break_points_hit;

Handle<DebugInfo> debug_info, JavaScriptFrame* frame,

std::vector<BreakLocation>* result_out) {

DCHECK(!debug_info->CanBreakAtEntry());

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

int offset = summary.code_offset();

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

PtrComprCageBase cage_base = GetPtrComprCageBase(*debug_info);

if (IsCode(*abstract_code, cage_base)) 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());

}

}

JavaScriptFrame* frame) const {

DCHECK(IsSuspend());

DCHECK_GE(generator_obj_reg_index_, 0);

Tagged<Object> generator_obj =

UnoptimizedFrame::cast(frame)->ReadInterpreterRegister(

generator_obj_reg_index_);

return JSGeneratorObject::cast(generator_obj);

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

Handle<DebugInfo> debug_info) const {

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

if (!debug_info->HasBreakInfo() ||

!debug_info->HasBreakPoint(isolate, position_)) {

return false;

}

if (debug_info->CanBreakAtEntry()) {

DCHECK_EQ(Debug::kBreakAtEntryPosition, position_);

return debug_info->BreakAtEntry();

} else {

// 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(IsBytecodeArray(*abstract_code_, isolate));

BreakIterator it(debug_info);

it.SkipToPosition(position_);

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;

// Externally, suspend breaks should look like normal breaks.

case DEBUG_BREAK_SLOT_AT_SUSPEND:

default:

return debug::kCommonBreakLocation;

}

: debug_info_(debug_info),

break_index_(-1),

source_position_iterator_(

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

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

statement_position_ = position_;

// There is at least one break location.

DCHECK(!Done());

Next();

for (; !Done(); Next()) {

if (GetDebugBreakType() == DEBUG_BREAK_SLOT_AT_SUSPEND) continue;

if (source_position <= position()) {

int first_break = break_index();

for (; !Done(); Next()) {

if (GetDebugBreakType() == DEBUG_BREAK_SLOT_AT_SUSPEND) continue;

if (source_position == position()) return break_index();

}

return first_break;

}

}

return break_index();

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

Tagged<BytecodeArray> bytecode_array = debug_info_->OriginalBytecodeArray();

interpreter::Bytecode bytecode =

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

// Make sure we read the actual bytecode, not a prefix scaling bytecode.

if (interpreter::Bytecodes::IsPrefixScalingBytecode(bytecode)) {

bytecode = interpreter::Bytecodes::FromByte(

bytecode_array->get(code_offset() + 1));

}

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

// SuspendGenerator should always only carry an expression position that

// is used in stack trace construction, but should never be a breakable

// position reported to the debugger front-end.

DCHECK(!source_position_iterator_.is_statement());

return DEBUG_BREAK_SLOT_AT_SUSPEND;

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

}

DebugBreakType debug_break_type = GetDebugBreakType();

if (debug_break_type == DEBUGGER_STATEMENT) return;

HandleScope scope(isolate());

DCHECK(debug_break_type >= DEBUG_BREAK_SLOT);

Handle<BytecodeArray> bytecode_array(debug_info_->DebugBytecodeArray(),

isolate());

interpreter::BytecodeArrayIterator(bytecode_array, code_offset())

.ApplyDebugBreak();

DebugBreakType debug_break_type = GetDebugBreakType();

if (debug_break_type == DEBUGGER_STATEMENT) return;

DCHECK(debug_break_type >= DEBUG_BREAK_SLOT);

Tagged<BytecodeArray> bytecode_array = debug_info_->DebugBytecodeArray();

Tagged<BytecodeArray> original = debug_info_->OriginalBytecodeArray();

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

Handle<AbstractCode> code(

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

DebugBreakType type = GetDebugBreakType();

int generator_object_reg_index = -1;

int generator_suspend_id = -1;

if (type == DEBUG_BREAK_SLOT_AT_SUSPEND) {

// For suspend break, we'll need the generator object to be able to step

// over the suspend as if it didn't return. We get the interpreter register

// index that holds the generator object by reading it directly off the

// bytecode array, and we'll read the actual generator object off the

// interpreter stack frame in GetGeneratorObjectForSuspendedFrame.

Tagged<BytecodeArray> bytecode_array = debug_info_->OriginalBytecodeArray();

interpreter::BytecodeArrayIterator iterator(

handle(bytecode_array, isolate()), code_offset());

DCHECK_EQ(iterator.current_bytecode(),

interpreter::Bytecode::kSuspendGenerator);

interpreter::Register generator_obj_reg = iterator.GetRegisterOperand(0);

generator_object_reg_index = generator_obj_reg.index();

// Also memorize the suspend ID, to be able to decide whether

// we are paused on the implicit initial yield later.

generator_suspend_id = iterator.GetUnsignedImmediateOperand(3);

}

return BreakLocation(code, type, code_offset(), position_,

generator_object_reg_index, generator_suspend_id);

thread_local_.break_frame_id_ = StackFrameId::NO_ID;

thread_local_.last_step_action_ = StepNone;

thread_local_.last_statement_position_ = kNoSourcePosition;

thread_local_.last_bytecode_offset_ = kFunctionEntryBytecodeOffset;

thread_local_.last_frame_count_ = -1;

thread_local_.fast_forward_to_return_ = false;

thread_local_.ignore_step_into_function_ = Smi::zero();

thread_local_.target_frame_count_ = -1;

thread_local_.return_value_ = Smi::zero();

thread_local_.last_breakpoint_id_ = 0;

clear_restart_frame();

clear_suspended_generator();

base::Relaxed_Store(&thread_local_.current_debug_scope_,

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

thread_local_.break_on_next_function_call_ = false;

thread_local_.scheduled_break_on_next_function_call_ = false;

UpdateHookOnFunctionCall();

thread_local_.promise_stack_ = Smi::zero();

v->VisitRootPointer(Root::kDebug, nullptr,

FullObjectSlot(&thread_local_data->return_value_));

v->VisitRootPointer(Root::kDebug, nullptr,

FullObjectSlot(&thread_local_data->suspended_generator_));

v->VisitRootPointer(

Root::kDebug, nullptr,

FullObjectSlot(&thread_local_data->ignore_step_into_function_));

v->VisitRootPointer(Root::kDebug, nullptr,

FullObjectSlot(&thread_local_data->promise_stack_));

Tagged<DebugInfo> debug_info) {

DisallowGarbageCollection no_gc;

base::SharedMutexGuard<base::kExclusive> mutex_guard(

isolate_->shared_function_info_access());

DCHECK_EQ(sfi, debug_info->shared());

DCHECK(!Contains(sfi));

HandleLocation location =

isolate_->global_handles()->Create(debug_info).location();

list_.push_back(location);

map_.emplace(sfi->unique_id(), location);

DCHECK(Contains(sfi));

DCHECK_EQ(list_.size(), map_.size());

auto it = map_.find(sfi->unique_id());

if (it == map_.end()) return false;

DCHECK_EQ(DebugInfo::cast(Object(*it->second))->shared(), sfi);

return true;

Tagged<SharedFunctionInfo> sfi) const {

auto it = map_.find(sfi->unique_id());

if (it == map_.end()) return {};

Tagged<DebugInfo> di = DebugInfo::cast(Object(*it->second));

DCHECK_EQ(di->shared(), sfi);

return di;

DebugInfoCollection::Iterator it(this);

for (; it.HasNext(); it.Advance()) {

Tagged<DebugInfo> debug_info = it.Next();

if (debug_info->shared() != sfi) continue;

it.DeleteNext();

return;

}

UNREACHABLE();

base::SharedMutexGuard<base::kExclusive> mutex_guard(

isolate_->shared_function_info_access());

Tagged<DebugInfo> debug_info = EntryAsDebugInfo(index);

Tagged<SharedFunctionInfo> sfi = debug_info->shared();

DCHECK(Contains(sfi));

auto it = map_.find(sfi->unique_id());

HandleLocation location = it->second;

DCHECK_EQ(location, list_[index]);

map_.erase(it);

list_[index] = list_.back();

list_.pop_back();

GlobalHandles::Destroy(location);

DCHECK(!Contains(sfi));

DCHECK_EQ(list_.size(), map_.size());

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

ClearAllBreakPoints();

ClearStepping();

RemoveAllCoverageInfos();

ClearAllDebuggerHints();

debug_delegate_ = nullptr;

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

if (!debug_delegate_) {

return debug::DebugDelegate::ActionAfterInstrumentation::

kPauseIfBreakpointsHit;

}

DCHECK(in_debug_scope());

HandleScope scope(isolate_);

DisableBreak no_recursive_break(this);

return debug_delegate_->BreakOnInstrumentation(

v8::Utils::ToLocal(isolate_->native_context()), kInstrumentationId);

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

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

if (break_disabled()) return;

// Enter the debugger.

DebugScope debug_scope(this);

DisableBreak no_recursive_break(this);

// Return if we fail to retrieve debug info.

Handle<SharedFunctionInfo> shared(break_target->shared(), isolate_);

if (!EnsureBreakInfo(shared)) return;

PrepareFunctionForDebugExecution(shared);

Handle<DebugInfo> debug_info(TryGetDebugInfo(*shared).value(), isolate_);

// Find the break location where execution has stopped.

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

const bool hitInstrumentationBreak =

IsBreakOnInstrumentation(debug_info, location);

bool shouldPauseAfterInstrumentation = false;

if (hitInstrumentationBreak) {

debug::DebugDelegate::ActionAfterInstrumentation action =

OnInstrumentationBreak();

switch (action) {

case debug::DebugDelegate::ActionAfterInstrumentation::kPause:

shouldPauseAfterInstrumentation = true;

break;

case debug::DebugDelegate::ActionAfterInstrumentation::

kPauseIfBreakpointsHit:

shouldPauseAfterInstrumentation = false;

break;

case debug::DebugDelegate::ActionAfterInstrumentation::kContinue:

return;

}

}

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

bool has_break_points;

bool scheduled_break =

scheduled_break_on_function_call() || shouldPauseAfterInstrumentation;

MaybeHandle<FixedArray> break_points_hit =

CheckBreakPoints(debug_info, &location, &has_break_points);

if (!break_points_hit.is_null() || break_on_next_function_call() ||

scheduled_break) {

StepAction lastStepAction = last_step_action();

debug::BreakReasons break_reasons;

if (scheduled_break) {

break_reasons.Add(debug::BreakReason::kScheduled);

}

// Clear all current stepping setup.

ClearStepping();

// Notify the debug event listeners.

OnDebugBreak(!break_points_hit.is_null()

? break_points_hit.ToHandleChecked()

: isolate_->factory()->empty_fixed_array(),

lastStepAction, break_reasons);

return;

}

// Debug break at function entry, do not worry about stepping.

if (location.IsDebugBreakAtEntry()) {

DCHECK(debug_info->BreakAtEntry());

return;

}

DCHECK_NOT_NULL(frame);

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

// We might hit an instrumentation breakpoint before running into a

// return/suspend location.

DCHECK(location.IsReturnOrSuspend() || hitInstrumentationBreak);

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

// StepOut should not break in a deeper frame than target frame.

if (current_frame_count > target_frame_count) return;

step_break = true;

break;

case StepOver:

// StepOver should not break in a deeper frame than target frame.

if (current_frame_count > target_frame_count) return;

V8_FALLTHROUGH;

case StepInto: {

// StepInto and StepOver should enter "generator stepping" mode, except

// for the implicit initial yield in generators, where it should simply

// step out of the generator function.

if (location.IsSuspend()) {

DCHECK(!has_suspended_generator());

ClearStepping();

if (!IsGeneratorFunction(shared->kind()) ||

location.generator_suspend_id() > 0) {

thread_local_.suspended_generator_ =

location.GetGeneratorObjectForSuspendedFrame(frame);

} else {

PrepareStep(StepOut);

}

return;

}

FrameSummary summary = FrameSummary::GetTop(frame);

const bool frame_or_statement_changed =

current_frame_count != last_frame_count ||

thread_local_.last_statement_position_ !=

summary.SourceStatementPosition();

// If we stayed on the same frame and reached the same bytecode offset

// since the last step, we are in a loop and should pause. Otherwise

// we keep "stepping" through the loop without ever acutally pausing.

const bool potential_single_statement_loop =

current_frame_count == last_frame_count &&

thread_local_.last_bytecode_offset_ == summary.code_offset();

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

potential_single_statement_loop ||

frame_or_statement_changed;

break;

}

}

StepAction lastStepAction = last_step_action();

// Clear all current stepping setup.

ClearStepping();

if (step_break) {

// Notify the debug event listeners.

OnDebugBreak(isolate_->factory()->empty_fixed_array(), lastStepAction);

} else {

// Re-prepare to continue.

PrepareStep(step_action);

}

const BreakLocation& location) {

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

bool has_break_points_to_check =

break_points_active_ && location.HasBreakPoint(isolate_, debug_info);

if (!has_break_points_to_check) return {};

Handle<Object> break_points =

debug_info->GetBreakPoints(isolate_, location.position());

DCHECK(!IsUndefined(*break_points, isolate_));

if (!IsFixedArray(*break_points)) {

const Handle<BreakPoint> break_point =

Handle<BreakPoint>::cast(break_points);

return break_point->id() == kInstrumentationId;

}

Handle<FixedArray> array(FixedArray::cast(*break_points), isolate_);

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

const Handle<BreakPoint> break_point =

Handle<BreakPoint>::cast(handle(array->get(i), isolate_));

if (break_point->id() == kInstrumentationId) {

return true;

}

}

return false;

BreakLocation* location,

bool* has_break_points) {

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

bool has_break_points_to_check =

break_points_active_ && location->HasBreakPoint(isolate_, debug_info);

if (!has_break_points_to_check) {

*has_break_points = false;

return {};

}

return Debug::GetHitBreakPoints(debug_info, location->position(),

has_break_points);

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

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

HandleScope scope(isolate_);

bool has_break_points;

MaybeHandle<FixedArray> checked =

GetHitBreakpointsAtCurrentStatement(frame, &has_break_points);

return has_break_points && checked.is_null();

Handle<DebugInfo>* out) {

if (!debug_info.has_value()) return false;

*out = handle(debug_info.value(), isolate);

return true;

JavaScriptFrame* frame, bool* has_break_points) {

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

FrameSummary summary = FrameSummary::GetTop(frame);

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

Handle<DebugInfo> debug_info;

if (!ToHandle(isolate_, TryGetDebugInfo(function->shared()), &debug_info) ||

!debug_info->HasBreakInfo()) {

*has_break_points = false;

return {};

}

// Enter the debugger.

DebugScope debug_scope(this);

std::vector<BreakLocation> break_locations;

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

return CheckBreakPointsForLocations(debug_info, break_locations,

has_break_points);

bool is_break_at_entry) {

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

HandleScope scope(isolate_);

// Instrumentation breakpoints are handled separately.

if (break_point->id() == kInstrumentationId) {

return false;

}

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

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

MaybeHandle<Object> maybe_result;

Handle<Object> result;

if (is_break_at_entry) {

maybe_result = DebugEvaluate::WithTopmostArguments(isolate_, condition);

} else {

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

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

const int inlined_jsframe_index = 0;

const bool throw_on_side_effect = false;

maybe_result =

DebugEvaluate::Local(isolate_, break_frame_id(), inlined_jsframe_index,

condition, throw_on_side_effect);

}

Handle<Object> maybe_exception;

bool exception_thrown = true;

if (maybe_result.ToHandle(&result)) {

exception_thrown = false;

} else if (isolate_->has_pending_exception()) {

maybe_exception = handle(isolate_->pending_exception(), isolate_);

isolate_->clear_pending_exception();

}

CHECK(in_debug_scope());

DisableBreak no_recursive_break(this);

{

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebuggerCallback);

debug_delegate_->BreakpointConditionEvaluated(

v8::Utils::ToLocal(isolate_->native_context()), break_point->id(),

exception_thrown, v8::Utils::ToLocal(maybe_exception));

}

return !result.is_null() ? Object::BooleanValue(*result, isolate_) : false;

Handle<BreakPoint> break_point,

int* source_position) {

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

HandleScope scope(isolate_);

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

if (!EnsureBreakInfo(shared)) return false;

PrepareFunctionForDebugExecution(shared);

Handle<DebugInfo> debug_info(TryGetDebugInfo(*shared).value(), isolate_);

// 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(isolate_, debug_info, *source_position, break_point);

// At least one active break point now.

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

ClearBreakPoints(debug_info);

ApplyBreakPoints(debug_info);

return true;

Handle<String> condition,

int* source_position, int* id) {

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

*id = ++thread_local_.last_breakpoint_id_;

Handle<BreakPoint> break_point =

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

#if V8_ENABLE_WEBASSEMBLY

if (script->type() == Script::Type::kWasm) {

RecordWasmScriptWithBreakpoints(script);

return WasmScript::SetBreakPoint(script, source_position, break_point);

}

#endif // V8_ENABLE_WEBASSEMBLY

HandleScope scope(isolate_);

// Obtain shared function info for the innermost function containing this

// position.

Handle<Object> result =

FindInnermostContainingFunctionInfo(script, *source_position);

if (IsUndefined(*result, isolate_)) return false;

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

if (!EnsureBreakInfo(shared)) return false;

PrepareFunctionForDebugExecution(shared);

// Find the nested shared function info that is closest to the position within

// the containing function.

shared = FindClosestSharedFunctionInfoFromPosition(*source_position, script,

shared);

// Set the breakpoint in the function.

return SetBreakpoint(shared, break_point, source_position);

int source_position) {

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

if (debug_info->CanBreakAtEntry()) {

return kBreakAtEntryPosition;

} else {

DCHECK(debug_info->HasInstrumentedBytecodeArray());

BreakIterator it(debug_info);

it.SkipToPosition(source_position);

return it.position();

}

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

DisallowGarbageCollection no_gc;

if (debug_info->CanBreakAtEntry()) {

debug_info->SetBreakAtEntry();

} else {

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

Tagged<FixedArray> break_points = debug_info->break_points();

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

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

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

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

DCHECK(debug_info->HasInstrumentedBytecodeArray());

BreakIterator it(debug_info);

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

it.SetDebugBreak();

}

}

debug_info->SetDebugExecutionMode(DebugInfo::kBreakpoints);

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

if (debug_info->CanBreakAtEntry()) {

debug_info->ClearBreakAtEntry();

} else {

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

// can happen e.g. CoverageInfos exist but no breakpoints are set.

if (!debug_info->HasInstrumentedBytecodeArray() ||

!debug_info->HasBreakInfo()) {

return;

}

DisallowGarbageCollection no_gc;

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

it.ClearDebugBreak();

}

}

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

HandleScope scope(isolate_);

DebugInfoCollection::Iterator it(&debug_infos_);

for (; it.HasNext(); it.Advance()) {

Handle<DebugInfo> debug_info(it.Next(), isolate_);

if (!debug_info->HasBreakInfo()) continue;

Handle<Object> result =

DebugInfo::FindBreakPointInfo(isolate_, debug_info, break_point);

if (IsUndefined(*result, isolate_)) continue;

if (DebugInfo::ClearBreakPoint(isolate_, debug_info, break_point)) {

ClearBreakPoints(debug_info);

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

debug_info->ClearBreakInfo(isolate_);

if (debug_info->IsEmpty()) it.DeleteNext();

} else {

ApplyBreakPoints(debug_info);

}

return;

}

}

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

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

Handle<DebugInfo> debug_info = GetOrCreateDebugInfo(shared);

int id = debug_info->debugging_id();

if (id == DebugInfo::kNoDebuggingId) {

id = isolate_->heap()->NextDebuggingId();

debug_info->set_debugging_id(id);

}

return id;

Handle<String> condition, int* id,

BreakPointKind kind) {

RCS_SCOPE(isolate_, RuntimeCallCounterId::kDebugger);

if (kind == kInstrumentation) {

*id = kInstrumentationId;