SealHandleScope shs(isolate);

DCHECK_EQ(1, args.length());

CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);

HandleScope scope(isolate);

ReturnValueScope result_scope(isolate->debug());

isolate->debug()->set_return_value(*value);

// Get the top-most JavaScript frame.

JavaScriptFrameIterator it(isolate);

isolate->debug()->Break(it.frame());

return isolate->debug()->return_value();

SealHandleScope shs(isolate);

DCHECK_EQ(1, args.length());

CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);

HandleScope scope(isolate);

ReturnValueScope result_scope(isolate->debug());

isolate->debug()->set_return_value(*value);

// Get the top-most JavaScript frame.

JavaScriptFrameIterator it(isolate);

isolate->debug()->Break(it.frame());

// Return the handler from the original bytecode array.

DCHECK(it.frame()->is_interpreted());

InterpretedFrame* interpreted_frame =

reinterpret_cast<InterpretedFrame*>(it.frame());

SharedFunctionInfo* shared = interpreted_frame->function()->shared();

BytecodeArray* bytecode_array = shared->bytecode_array();

int bytecode_offset = interpreted_frame->GetBytecodeOffset();

interpreter::Bytecode bytecode =

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

return isolate->interpreter()->GetBytecodeHandler(

bytecode, interpreter::OperandScale::kSingle);

SealHandleScope shs(isolate);

DCHECK_EQ(0, args.length());

if (isolate->debug()->break_points_active()) {

isolate->debug()->HandleDebugBreak(kIgnoreIfTopFrameBlackboxed);

}

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

SealHandleScope shs(isolate);

DCHECK_EQ(2, args.length());

CHECK(args[0]->IsJSFunction() || args[0]->IsNullOrUndefined(isolate));

CONVERT_ARG_HANDLE_CHECKED(Object, callback, 0);

CONVERT_ARG_HANDLE_CHECKED(Object, data, 1);

if (callback->IsJSFunction()) {

JavaScriptDebugDelegate* delegate = new JavaScriptDebugDelegate(

isolate, Handle<JSFunction>::cast(callback), data);

isolate->debug()->SetDebugDelegate(delegate, true);

} else {

isolate->debug()->SetDebugDelegate(nullptr, false);

}

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

SealHandleScope shs(isolate);

DCHECK_EQ(0, args.length());

isolate->stack_guard()->RequestDebugBreak();

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

bool* has_caught = NULL) {

for (; it->IsFound(); it->Next()) {

switch (it->state()) {

case LookupIterator::NOT_FOUND:

case LookupIterator::TRANSITION:

UNREACHABLE();

case LookupIterator::ACCESS_CHECK:

// Ignore access checks.

break;

case LookupIterator::INTEGER_INDEXED_EXOTIC:

case LookupIterator::INTERCEPTOR:

case LookupIterator::JSPROXY:

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

case LookupIterator::ACCESSOR: {

Handle<Object> accessors = it->GetAccessors();

if (!accessors->IsAccessorInfo()) {

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

}

MaybeHandle<Object> maybe_result =

JSObject::GetPropertyWithAccessor(it);

Handle<Object> result;

if (!maybe_result.ToHandle(&result)) {

result = handle(it->isolate()->pending_exception(), it->isolate());

it->isolate()->clear_pending_exception();

if (has_caught != NULL) *has_caught = true;

}

return result;

}

case LookupIterator::DATA:

return it->GetDataValue();

}

}

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

Isolate* isolate, Handle<IteratorType> object) {

Factory* factory = isolate->factory();

Handle<IteratorType> iterator = Handle<IteratorType>::cast(object);

CHECK(iterator->kind()->IsSmi());

const char* kind = NULL;

switch (Smi::cast(iterator->kind())->value()) {

case IteratorType::kKindKeys:

kind = "keys";

break;

case IteratorType::kKindValues:

kind = "values";

break;

case IteratorType::kKindEntries:

kind = "entries";

break;

default:

UNREACHABLE();

}

Handle<FixedArray> result = factory->NewFixedArray(2 * 3);

Handle<String> has_more =

factory->NewStringFromAsciiChecked("[[IteratorHasMore]]");

result->set(0, *has_more);

result->set(1, isolate->heap()->ToBoolean(iterator->HasMore()));

Handle<String> index =

factory->NewStringFromAsciiChecked("[[IteratorIndex]]");

result->set(2, *index);

result->set(3, iterator->index());

Handle<String> iterator_kind =

factory->NewStringFromAsciiChecked("[[IteratorKind]]");

result->set(4, *iterator_kind);

Handle<String> kind_str = factory->NewStringFromAsciiChecked(kind);

result->set(5, *kind_str);

return factory->NewJSArrayWithElements(result);

Handle<Object> object) {

Factory* factory = isolate->factory();

if (object->IsJSBoundFunction()) {

Handle<JSBoundFunction> function = Handle<JSBoundFunction>::cast(object);

Handle<FixedArray> result = factory->NewFixedArray(2 * 3);

Handle<String> target =

factory->NewStringFromAsciiChecked("[[TargetFunction]]");

result->set(0, *target);

result->set(1, function->bound_target_function());

Handle<String> bound_this =

factory->NewStringFromAsciiChecked("[[BoundThis]]");

result->set(2, *bound_this);

result->set(3, function->bound_this());

Handle<String> bound_args =

factory->NewStringFromAsciiChecked("[[BoundArgs]]");

result->set(4, *bound_args);

Handle<FixedArray> bound_arguments =

factory->CopyFixedArray(handle(function->bound_arguments(), isolate));

Handle<JSArray> arguments_array =

factory->NewJSArrayWithElements(bound_arguments);

result->set(5, *arguments_array);

return factory->NewJSArrayWithElements(result);

} else if (object->IsJSMapIterator()) {

Handle<JSMapIterator> iterator = Handle<JSMapIterator>::cast(object);

return GetIteratorInternalProperties(isolate, iterator);

} else if (object->IsJSSetIterator()) {

Handle<JSSetIterator> iterator = Handle<JSSetIterator>::cast(object);

return GetIteratorInternalProperties(isolate, iterator);

} else if (object->IsJSGeneratorObject()) {

Handle<JSGeneratorObject> generator =

Handle<JSGeneratorObject>::cast(object);

const char* status = "suspended";

if (generator->is_closed()) {

status = "closed";

} else if (generator->is_executing()) {

status = "running";

} else {

DCHECK(generator->is_suspended());

}

Handle<FixedArray> result = factory->NewFixedArray(2 * 3);

Handle<String> generator_status =

factory->NewStringFromAsciiChecked("[[GeneratorStatus]]");

result->set(0, *generator_status);

Handle<String> status_str = factory->NewStringFromAsciiChecked(status);

result->set(1, *status_str);

Handle<String> function =

factory->NewStringFromAsciiChecked("[[GeneratorFunction]]");

result->set(2, *function);

result->set(3, generator->function());

Handle<String> receiver =

factory->NewStringFromAsciiChecked("[[GeneratorReceiver]]");

result->set(4, *receiver);

result->set(5, generator->receiver());

return factory->NewJSArrayWithElements(result);

} else if (object->IsJSPromise()) {

Handle<JSPromise> promise = Handle<JSPromise>::cast(object);

const char* status = JSPromise::Status(promise->status());

Handle<FixedArray> result = factory->NewFixedArray(2 * 2);

Handle<String> promise_status =

factory->NewStringFromAsciiChecked("[[PromiseStatus]]");

result->set(0, *promise_status);

Handle<String> status_str = factory->NewStringFromAsciiChecked(status);

result->set(1, *status_str);

Handle<Object> value_obj(promise->result(), isolate);

Handle<String> promise_value =

factory->NewStringFromAsciiChecked("[[PromiseValue]]");

result->set(2, *promise_value);

result->set(3, *value_obj);

return factory->NewJSArrayWithElements(result);

} else if (object->IsJSProxy()) {

Handle<JSProxy> js_proxy = Handle<JSProxy>::cast(object);

Handle<FixedArray> result = factory->NewFixedArray(3 * 2);

Handle<String> handler_str =

factory->NewStringFromAsciiChecked("[[Handler]]");

result->set(0, *handler_str);

result->set(1, js_proxy->handler());

Handle<String> target_str =

factory->NewStringFromAsciiChecked("[[Target]]");

result->set(2, *target_str);

result->set(3, js_proxy->target());

Handle<String> is_revoked_str =

factory->NewStringFromAsciiChecked("[[IsRevoked]]");

result->set(4, *is_revoked_str);

result->set(5, isolate->heap()->ToBoolean(js_proxy->IsRevoked()));

return factory->NewJSArrayWithElements(result);

} else if (object->IsJSValue()) {

Handle<JSValue> js_value = Handle<JSValue>::cast(object);

Handle<FixedArray> result = factory->NewFixedArray(2);

Handle<String> primitive_value =

factory->NewStringFromAsciiChecked("[[PrimitiveValue]]");

result->set(0, *primitive_value);

result->set(1, js_value->value());

return factory->NewJSArrayWithElements(result);

}

return factory->NewJSArray(0);

HandleScope scope(isolate);

DCHECK_EQ(1, args.length());

CONVERT_ARG_HANDLE_CHECKED(Object, obj, 0);

RETURN_RESULT_OR_FAILURE(isolate,

Runtime::GetInternalProperties(isolate, obj));

HandleScope scope(isolate);

DCHECK_EQ(2, args.length());

CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);

CONVERT_ARG_HANDLE_CHECKED(Object, name_obj, 1);

// Convert the {name_obj} to a Name.

Handle<Name> name;

ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,

Object::ToName(isolate, name_obj));

// Make sure to set the current context to the context before the debugger was

// entered (if the debugger is entered). The reason for switching context here

// is that for some property lookups (accessors and interceptors) callbacks

// into the embedding application can occour, and the embedding application

// could have the assumption that its own native context is the current

// context and not some internal debugger context.

SaveContext save(isolate);

if (isolate->debug()->in_debug_scope()) {

isolate->set_context(*isolate->debug()->debugger_entry()->GetContext());

}

// Check if the name is trivially convertible to an index and get the element

// if so.

uint32_t index;

// TODO(verwaest): Make sure DebugGetProperty can handle arrays, and remove

// this special case.

if (name->AsArrayIndex(&index)) {

Handle<FixedArray> details = isolate->factory()->NewFixedArray(2);

Handle<Object> element_or_char;

ASSIGN_RETURN_FAILURE_ON_EXCEPTION(

isolate, element_or_char, JSReceiver::GetElement(isolate, obj, index));

details->set(0, *element_or_char);

details->set(1, PropertyDetails::Empty().AsSmi());

return *isolate->factory()->NewJSArrayWithElements(details);

}

LookupIterator it(obj, name, LookupIterator::OWN);

bool has_caught = false;

Handle<Object> value = DebugGetProperty(&it, &has_caught);

if (!it.IsFound()) return isolate->heap()->undefined_value();

Handle<Object> maybe_pair;

if (it.state() == LookupIterator::ACCESSOR) {

maybe_pair = it.GetAccessors();

}

// If the callback object is a fixed array then it contains JavaScript

// getter and/or setter.

bool has_js_accessors = !maybe_pair.is_null() && maybe_pair->IsAccessorPair();

Handle<FixedArray> details =

isolate->factory()->NewFixedArray(has_js_accessors ? 6 : 3);

details->set(0, *value);

// TODO(verwaest): Get rid of this random way of handling interceptors.

PropertyDetails d = it.state() == LookupIterator::INTERCEPTOR

? PropertyDetails::Empty()

: it.property_details();

details->set(1, d.AsSmi());

details->set(

2, isolate->heap()->ToBoolean(it.state() == LookupIterator::INTERCEPTOR));

if (has_js_accessors) {

Handle<AccessorPair> accessors = Handle<AccessorPair>::cast(maybe_pair);

details->set(3, isolate->heap()->ToBoolean(has_caught));

Handle<Object> getter =

AccessorPair::GetComponent(accessors, ACCESSOR_GETTER);

Handle<Object> setter =

AccessorPair::GetComponent(accessors, ACCESSOR_SETTER);

details->set(4, *getter);

details->set(5, *setter);

}

return *isolate->factory()->NewJSArrayWithElements(details);

HandleScope scope(isolate);

DCHECK_EQ(2, args.length());

CONVERT_ARG_HANDLE_CHECKED(Object, obj, 0);

CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);

LookupIterator it(obj, name);

return *DebugGetProperty(&it);

SealHandleScope shs(isolate);

DCHECK_EQ(1, args.length());

CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);

return Smi::FromInt(static_cast<int>(details.kind()));

SealHandleScope shs(isolate);

DCHECK_EQ(1, args.length());

CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);

return Smi::FromInt(static_cast<int>(details.attributes()));

SealHandleScope shs(isolate);

DCHECK_EQ(1, args.length());

CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);

CHECK(isolate->debug()->CheckExecutionState(break_id));

return isolate->heap()->true_value();

HandleScope scope(isolate);

DCHECK_EQ(1, args.length());

CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);

CHECK(isolate->debug()->CheckExecutionState(break_id));

// Count all frames which are relevant to debugging stack trace.

int n = 0;

StackFrame::Id id = isolate->debug()->break_frame_id();

if (id == StackFrame::NO_ID) {

// If there is no JavaScript stack frame count is 0.

return Smi::kZero;

}

List<FrameSummary> frames(FLAG_max_inlining_levels + 1);

for (StackTraceFrameIterator it(isolate, id); !it.done(); it.Advance()) {

frames.Clear();

it.frame()->Summarize(&frames);

for (int i = frames.length() - 1; i >= 0; i--) {

// Omit functions from native and extension scripts.

if (frames[i].is_subject_to_debugging()) n++;

}

}

return Smi::FromInt(n);

HandleScope scope(isolate);

DCHECK_EQ(2, args.length());

CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);

CHECK(isolate->debug()->CheckExecutionState(break_id));

CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);

Heap* heap = isolate->heap();

// Find the relevant frame with the requested index.

StackFrame::Id id = isolate->debug()->break_frame_id();

if (id == StackFrame::NO_ID) {

// If there are no JavaScript stack frames return undefined.

return heap->undefined_value();

}

StackTraceFrameIterator it(isolate, id);

// Inlined frame index in optimized frame, starting from outer function.

int inlined_frame_index =

DebugFrameHelper::FindIndexedNonNativeFrame(&it, index);

if (inlined_frame_index == -1) return heap->undefined_value();

FrameInspector frame_inspector(it.frame(), inlined_frame_index, isolate);

// Traverse the saved contexts chain to find the active context for the

// selected frame.

SaveContext* save =

DebugFrameHelper::FindSavedContextForFrame(isolate, it.frame());

// Get the frame id.

Handle<Object> frame_id(DebugFrameHelper::WrapFrameId(it.frame()->id()),

isolate);

if (frame_inspector.summary().IsWasm()) {

// Create the details array (no dynamic information for wasm).

Handle<FixedArray> details =

isolate->factory()->NewFixedArray(kFrameDetailsFirstDynamicIndex);

// Add the frame id.

details->set(kFrameDetailsFrameIdIndex, *frame_id);

// Add the function name.

Handle<String> func_name = frame_inspector.summary().FunctionName();

details->set(kFrameDetailsFunctionIndex, *func_name);

// Add the script wrapper

Handle<Object> script_wrapper =

Script::GetWrapper(frame_inspector.GetScript());

details->set(kFrameDetailsScriptIndex, *script_wrapper);

// Add the arguments count.

details->set(kFrameDetailsArgumentCountIndex, Smi::kZero);

// Add the locals count

details->set(kFrameDetailsLocalCountIndex, Smi::kZero);

// Add the source position.

int position = frame_inspector.summary().SourcePosition();

details->set(kFrameDetailsSourcePositionIndex, Smi::FromInt(position));

// Add the constructor information.

details->set(kFrameDetailsConstructCallIndex, heap->ToBoolean(false));

// Add the at return information.

details->set(kFrameDetailsAtReturnIndex, heap->ToBoolean(false));

// Add flags to indicate information on whether this frame is

// bit 0: invoked in the debugger context.

// bit 1: optimized frame.

// bit 2: inlined in optimized frame

int flags = inlined_frame_index << 2;

if (*save->context() == *isolate->debug()->debug_context()) {

flags |= 1 << 0;

}

details->set(kFrameDetailsFlagsIndex, Smi::FromInt(flags));

return *isolate->factory()->NewJSArrayWithElements(details);

}

// Find source position in unoptimized code.

int position = frame_inspector.GetSourcePosition();

// Handle JavaScript frames.

bool is_optimized = it.frame()->is_optimized();

// Check for constructor frame.

bool constructor = frame_inspector.IsConstructor();

// Get scope info and read from it for local variable information.

Handle<JSFunction> function =

Handle<JSFunction>::cast(frame_inspector.GetFunction());

CHECK(function->shared()->IsSubjectToDebugging());

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

Handle<ScopeInfo> scope_info(shared->scope_info());

DCHECK(*scope_info != ScopeInfo::Empty(isolate));

// Get the locals names and values into a temporary array.

Handle<Object> maybe_context = frame_inspector.GetContext();

const int local_count_with_synthetic = maybe_context->IsContext()

? scope_info->LocalCount()

: scope_info->StackLocalCount();

int local_count = local_count_with_synthetic;

for (int slot = 0; slot < local_count_with_synthetic; ++slot) {

// Hide compiler-introduced temporary variables, whether on the stack or on

// the context.

if (ScopeInfo::VariableIsSynthetic(scope_info->LocalName(slot))) {

local_count--;

}

}

List<Handle<Object>> locals;

// Fill in the values of the locals.

int i = 0;

for (; i < scope_info->StackLocalCount(); ++i) {

// Use the value from the stack.

if (ScopeInfo::VariableIsSynthetic(scope_info->LocalName(i))) continue;

locals.Add(Handle<String>(scope_info->LocalName(i), isolate));

Handle<Object> value =

frame_inspector.GetExpression(scope_info->StackLocalIndex(i));

// TODO(yangguo): We convert optimized out values to {undefined} when they

// are passed to the debugger. Eventually we should handle them somehow.

if (value->IsOptimizedOut(isolate)) {

value = isolate->factory()->undefined_value();

}

locals.Add(value);

}

if (locals.length() < local_count * 2) {

// Get the context containing declarations.

DCHECK(maybe_context->IsContext());

Handle<Context> context(Context::cast(*maybe_context)->closure_context());

for (; i < scope_info->LocalCount(); ++i) {

Handle<String> name(scope_info->LocalName(i));

if (ScopeInfo::VariableIsSynthetic(*name)) continue;

VariableMode mode;

InitializationFlag init_flag;

MaybeAssignedFlag maybe_assigned_flag;

locals.Add(name);

int context_slot_index = ScopeInfo::ContextSlotIndex(

scope_info, name, &mode, &init_flag, &maybe_assigned_flag);

Object* value = context->get(context_slot_index);

locals.Add(Handle<Object>(value, isolate));

}

}

// Check whether this frame is positioned at return. If not top

// frame or if the frame is optimized it cannot be at a return.

bool at_return = false;

if (!is_optimized && index == 0) {

at_return = isolate->debug()->IsBreakAtReturn(it.javascript_frame());

}

// If positioned just before return find the value to be returned and add it

// to the frame information.

Handle<Object> return_value = isolate->factory()->undefined_value();

if (at_return) {

return_value = handle(isolate->debug()->return_value(), isolate);

}

// Now advance to the arguments adapter frame (if any). It contains all

// the provided parameters whereas the function frame always have the number

// of arguments matching the functions parameters. The rest of the

// information (except for what is collected above) is the same.

if ((inlined_frame_index == 0) &&

it.javascript_frame()->has_adapted_arguments()) {

it.AdvanceToArgumentsFrame();

frame_inspector.SetArgumentsFrame(it.frame());

}

// Find the number of arguments to fill. At least fill the number of

// parameters for the function and fill more if more parameters are provided.

int argument_count = scope_info->ParameterCount();

if (argument_count < frame_inspector.GetParametersCount()) {

argument_count = frame_inspector.GetParametersCount();

}

// Calculate the size of the result.

int details_size = kFrameDetailsFirstDynamicIndex +

2 * (argument_count + local_count) + (at_return ? 1 : 0);

Handle<FixedArray> details = isolate->factory()->NewFixedArray(details_size);

// Add the frame id.

details->set(kFrameDetailsFrameIdIndex, *frame_id);

// Add the function (same as in function frame).

details->set(kFrameDetailsFunctionIndex, *(frame_inspector.GetFunction()));

// Add the script wrapper

Handle<Object> script_wrapper =

Script::GetWrapper(frame_inspector.GetScript());

details->set(kFrameDetailsScriptIndex, *script_wrapper);

// Add the arguments count.

details->set(kFrameDetailsArgumentCountIndex, Smi::FromInt(argument_count));

// Add the locals count

details->set(kFrameDetailsLocalCountIndex, Smi::FromInt(local_count));

// Add the source position.

if (position != kNoSourcePosition) {

details->set(kFrameDetailsSourcePositionIndex, Smi::FromInt(position));

} else {

details->set(kFrameDetailsSourcePositionIndex, heap->undefined_value());

}

// Add the constructor information.

details->set(kFrameDetailsConstructCallIndex, heap->ToBoolean(constructor));

// Add the at return information.

details->set(kFrameDetailsAtReturnIndex, heap->ToBoolean(at_return));

// Add flags to indicate information on whether this frame is

// bit 0: invoked in the debugger context.

// bit 1: optimized frame.

// bit 2: inlined in optimized frame

int flags = 0;

if (*save->context() == *isolate->debug()->debug_context()) {

flags |= 1 << 0;

}

if (is_optimized) {

flags |= 1 << 1;

flags |= inlined_frame_index << 2;

}

details->set(kFrameDetailsFlagsIndex, Smi::FromInt(flags));

// Fill the dynamic part.

int details_index = kFrameDetailsFirstDynamicIndex;

// Add arguments name and value.

for (int i = 0; i < argument_count; i++) {

// Name of the argument.

if (i < scope_info->ParameterCount()) {

details->set(details_index++, scope_info->ParameterName(i));

} else {

details->set(details_index++, heap->undefined_value());

}

// Parameter value.

if (i < frame_inspector.GetParametersCount()) {

// Get the value from the stack.

details->set(details_index++, *(frame_inspector.GetParameter(i)));

} else {

details->set(details_index++, heap->undefined_value());

}

}

// Add locals name and value from the temporary copy from the function frame.

for (const auto& local : locals) details->set(details_index++, *local);

// Add the value being returned.

if (at_return) {

details->set(details_index++, *return_value);

}

// Add the receiver (same as in function frame).

Handle<Object> receiver = frame_inspector.summary().receiver();

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

// Optimized frames only restore the receiver as best-effort (see

// OptimizedFrame::Summarize).

DCHECK_IMPLIES(!is_optimized && is_sloppy(shared->language_mode()),

receiver->IsJSReceiver());

details->set(kFrameDetailsReceiverIndex, *receiver);

DCHECK_EQ(details_size, details_index);

return *isolate->factory()->NewJSArrayWithElements(details);

HandleScope scope(isolate);

DCHECK_EQ(2, args.length());

CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);

CHECK(isolate->debug()->CheckExecutionState(break_id));

CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);

// Get the frame where the debugging is performed.

StackFrame::Id id = DebugFrameHelper::UnwrapFrameId(wrapped_id);

StackTraceFrameIterator it(isolate, id);

StandardFrame* frame = it.frame();

if (it.frame()->is_wasm()) return 0;

FrameInspector frame_inspector(frame, 0, isolate);

// Count the visible scopes.

int n = 0;

for (ScopeIterator it(isolate, &frame_inspector); !it.Done(); it.Next()) {

n++;

}

return Smi::FromInt(n);

HandleScope scope(isolate);

DCHECK_EQ(4, args.length());

CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);

CHECK(isolate->debug()->CheckExecutionState(break_id));

CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);

CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);

CONVERT_NUMBER_CHECKED(int, index, Int32, args[3]);

// Get the frame where the debugging is performed.

StackFrame::Id id = DebugFrameHelper::UnwrapFrameId(wrapped_id);

StackTraceFrameIterator frame_it(isolate, id);

// Wasm has no scopes, this must be javascript.

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

FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);

// Find the requested scope.

int n = 0;

ScopeIterator it(isolate, &frame_inspector);

for (; !it.Done() && n < index; it.Next()) {

n++;

}

if (it.Done()) {

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

}

RETURN_RESULT_OR_FAILURE(isolate, it.MaterializeScopeDetails());

HandleScope scope(isolate);

DCHECK(args.length() == 3 || args.length() == 4);

CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);

CHECK(isolate->debug()->CheckExecutionState(break_id));

CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);

CONVERT_NUMBER_CHECKED(int, inlined_frame_index, Int32, args[2]);

ScopeIterator::Option option = ScopeIterator::DEFAULT;

if (args.length() == 4) {

CONVERT_BOOLEAN_ARG_CHECKED(flag, 3);

if (flag) option = ScopeIterator::IGNORE_NESTED_SCOPES;

}

// Get the frame where the debugging is performed.

StackFrame::Id id = DebugFrameHelper::UnwrapFrameId(wrapped_id);

StackTraceFrameIterator frame_it(isolate, id);

StandardFrame* frame = frame_it.frame();

// Handle wasm frames specially. They provide exactly two scopes (global /

// local).

if (frame->is_wasm_interpreter_entry()) {

Handle<WasmDebugInfo> debug_info(

WasmInterpreterEntryFrame::cast(frame)->wasm_instance()->debug_info(),

isolate);

return *WasmDebugInfo::GetScopeDetails(debug_info, frame->fp(),

inlined_frame_index);

}

FrameInspector frame_inspector(frame, inlined_frame_index, isolate);

List<Handle<JSObject>> result(4);

ScopeIterator it(isolate, &frame_inspector, option);

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

Handle<JSObject> details;

ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,

it.MaterializeScopeDetails());

result.Add(details);

}

Handle<FixedArray> array = isolate->factory()->NewFixedArray(result.length());

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

array->set(i, *result[i]);

}

return *isolate->factory()->NewJSArrayWithElements(array);

HandleScope scope(isolate);

DCHECK_EQ(1, args.length());

// Check arguments.

CONVERT_ARG_HANDLE_CHECKED(JSReceiver, function, 0);

// Count the visible scopes.

int n = 0;

if (function->IsJSFunction()) {

for (ScopeIterator it(isolate, Handle<JSFunction>::cast(function));

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

n++;

}

}

return Smi::FromInt(n);

HandleScope scope(isolate);

DCHECK_EQ(2, args.length());

// Check arguments.

CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);

CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);

// Find the requested scope.

int n = 0;

ScopeIterator it(isolate, fun);

for (; !it.Done() && n < index; it.Next()) {

n++;

}

if (it.Done()) {

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

}

RETURN_RESULT_OR_FAILURE(isolate, it.MaterializeScopeDetails());

HandleScope scope(isolate);

DCHECK_EQ(1, args.length());

if (!args[0]->IsJSGeneratorObject()) return Smi::kZero;

// Check arguments.

CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, gen, 0);

// Count the visible scopes.

int n = 0;

for (ScopeIterator it(isolate, gen); !it.Done(); it.Next()) {

n++;

}

return Smi::FromInt(n);

HandleScope scope(isolate);

DCHECK_EQ(2, args.length());

if (!args[0]->IsJSGeneratorObject()) {

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

}

// Check arguments.

CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, gen, 0);

CONVERT_NUMBER_CHECKED(int, index, Int32, args[1]);

// Find the requested scope.

int n = 0;

ScopeIterator it(isolate, gen);

for (; !it.Done() && n < index; it.Next()) {

n++;

}

if (it.Done()) {

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

}

RETURN_RESULT_OR_FAILURE(isolate, it.MaterializeScopeDetails());

Handle<String> variable_name,

Handle<Object> new_value) {

for (int n = 0; !it->Done() && n < index; it->Next()) {

n++;

}

if (it->Done()) {

return false;

}

return it->SetVariableValue(variable_name, new_value);

HandleScope scope(isolate);

DCHECK_EQ(6, args.length());

// Check arguments.

CONVERT_NUMBER_CHECKED(int, index, Int32, args[3]);

CONVERT_ARG_HANDLE_CHECKED(String, variable_name, 4);

CONVERT_ARG_HANDLE_CHECKED(Object, new_value, 5);

bool res;

if (args[0]->IsNumber()) {

CONVERT_NUMBER_CHECKED(int, break_id, Int32, args[0]);

CHECK(isolate->debug()->CheckExecutionState(break_id));

CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);

CONVERT_NUMBER_CHECKED(int, inlined_jsframe_index, Int32, args[2]);

// Get the frame where the debugging is performed.

StackFrame::Id id = DebugFrameHelper::UnwrapFrameId(wrapped_id);

StackTraceFrameIterator frame_it(isolate, id);

// Wasm has no scopes, this must be javascript.