SealHandleScope shs(isolate);

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

CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);

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

// Get the top-most JavaScript frame.

JavaScriptFrameIterator it(isolate);

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

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

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

SealHandleScope shs(isolate);

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

CONVERT_ARG_HANDLE_CHECKED(Object, value, 0);

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(args.length() == 0);

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

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

}

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

SealHandleScope shs(isolate);

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

RUNTIME_ASSERT(args[0]->IsJSFunction() || args[0]->IsUndefined() ||

args[0]->IsNull());

CONVERT_ARG_HANDLE_CHECKED(Object, callback, 0);

CONVERT_ARG_HANDLE_CHECKED(Object, data, 1);

isolate->debug()->SetEventListener(callback, data);

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

SealHandleScope shs(isolate);

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

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

Handle<Name> name) {

LookupIterator it(object, name);

return DebugGetProperty(&it);

Isolate* isolate, Handle<IteratorType> object) {

Factory* factory = isolate->factory();

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

RUNTIME_ASSERT_HANDLIFIED(iterator->kind()->IsSmi(), JSArray);

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:

RUNTIME_ASSERT_HANDLIFIED(false, JSArray);

}

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::IsPromise(object)) {

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

Handle<Object> status_obj =

DebugGetProperty(promise, isolate->factory()->promise_status_symbol());

RUNTIME_ASSERT_HANDLIFIED(status_obj->IsSmi(), JSArray);

const char* status = "rejected";

int status_val = Handle<Smi>::cast(status_obj)->value();

switch (status_val) {

case +1:

status = "resolved";

break;

case 0:

status = "pending";

break;

default:

DCHECK_EQ(-1, status_val);

}

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 =

DebugGetProperty(promise, isolate->factory()->promise_value_symbol());

Handle<String> promise_value =

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

result->set(2, *promise_value);

result->set(3, *value_obj);

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(args.length() == 1);

CONVERT_ARG_HANDLE_CHECKED(Object, obj, 0);

Handle<JSArray> result;

ASSIGN_RETURN_FAILURE_ON_EXCEPTION(

isolate, result, Runtime::GetInternalProperties(isolate, obj));

return *result;

HandleScope scope(isolate);

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

CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);

CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);

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

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(args.length() == 2);

CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);

CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);

LookupIterator it(obj, name);

return *DebugGetProperty(&it);

SealHandleScope shs(isolate);

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

CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);

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

SealHandleScope shs(isolate);

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

CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);

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

SealHandleScope shs(isolate);

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

CONVERT_PROPERTY_DETAILS_CHECKED(details, 0);

// TODO(verwaest): Works only for dictionary mode holders.

return Smi::FromInt(details.dictionary_index());

HandleScope scope(isolate);

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

CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);

RUNTIME_ASSERT(obj->HasNamedInterceptor());

CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);

Handle<Object> result;

ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,

JSObject::GetProperty(obj, name));

return *result;

HandleScope scope(isolate);

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

CONVERT_ARG_HANDLE_CHECKED(JSObject, obj, 0);

RUNTIME_ASSERT(obj->HasIndexedInterceptor());

CONVERT_NUMBER_CHECKED(uint32_t, index, Uint32, args[1]);

Handle<Object> result;

ASSIGN_RETURN_FAILURE_ON_EXCEPTION(

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

return *result;

SealHandleScope shs(isolate);

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

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

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

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

HandleScope scope(isolate);

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

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

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

}

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

List<FrameSummary> frames(FLAG_max_inlining_levels + 1);

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

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

// Omit functions from native and extension scripts.

if (frames[i].function()->shared()->IsSubjectToDebugging()) n++;

}

}

return Smi::FromInt(n);

HandleScope scope(isolate);

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

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

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

}

JavaScriptFrameIterator it(isolate, id);

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

int inlined_jsframe_index =

DebugFrameHelper::FindIndexedNonNativeFrame(&it, index);

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

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

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

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

// Find source position in unoptimized code.

int position = frame_inspector.GetSourcePosition();

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

RUNTIME_ASSERT(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.

int local_count = scope_info->LocalCount();

for (int slot = 0; slot < scope_info->LocalCount(); ++slot) {

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

// the context.

if (scope_info->LocalIsSynthetic(slot)) local_count--;

}

Handle<FixedArray> locals =

isolate->factory()->NewFixedArray(local_count * 2);

// Fill in the values of the locals.

int local = 0;

int i = 0;

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

// Use the value from the stack.

if (scope_info->LocalIsSynthetic(i)) continue;

locals->set(local * 2, scope_info->LocalName(i));

Handle<Object> value = frame_inspector.GetExpression(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()) value = isolate->factory()->undefined_value();

locals->set(local * 2 + 1, *value);

local++;

}

if (local < local_count) {

// Get the context containing declarations.

Handle<Context> context(

Handle<Context>::cast(frame_inspector.GetContext())->closure_context());

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

if (scope_info->LocalIsSynthetic(i)) continue;

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

VariableMode mode;

InitializationFlag init_flag;

MaybeAssignedFlag maybe_assigned_flag;

locals->set(local * 2, *name);

int context_slot_index = ScopeInfo::ContextSlotIndex(

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

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

locals->set(local * 2 + 1, value);

local++;

}

}

// 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.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 = isolate->debug()->return_value();

}

// 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_jsframe_index == 0) && it.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 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 != RelocInfo::kNoPosition) {

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_jsframe_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 (int i = 0; i < local_count * 2; i++) {

details->set(details_index++, locals->get(i));

}

// 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(it.frame()->receiver(), isolate);

DCHECK(!function->shared()->IsBuiltin());

DCHECK_IMPLIES(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(args.length() == 2);

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

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

JavaScriptFrameIterator it(isolate, id);

JavaScriptFrame* frame = it.frame();

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(args.length() == 4);

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

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

JavaScriptFrameIterator frame_it(isolate, id);

JavaScriptFrame* frame = 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();

}

Handle<JSObject> details;

ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,

it.MaterializeScopeDetails());

return *details;

HandleScope scope(isolate);

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

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

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

CONVERT_SMI_ARG_CHECKED(wrapped_id, 1);

CONVERT_NUMBER_CHECKED(int, inlined_jsframe_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);

JavaScriptFrameIterator frame_it(isolate, id);

JavaScriptFrame* frame = frame_it.frame();

FrameInspector frame_inspector(frame, inlined_jsframe_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(args.length() == 2);

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

}

Handle<JSObject> details;

ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, details,

it.MaterializeScopeDetails());

return *details;

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(args.length() == 6);

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

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

JavaScriptFrameIterator frame_it(isolate, id);

JavaScriptFrame* frame = frame_it.frame();

FrameInspector frame_inspector(frame, inlined_jsframe_index, isolate);

ScopeIterator it(isolate, &frame_inspector);

res = SetScopeVariableValue(&it, index, variable_name, new_value);

} else {

CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);

ScopeIterator it(isolate, fun);

res = SetScopeVariableValue(&it, index, variable_name, new_value);

}

return isolate->heap()->ToBoolean(res);

HandleScope scope(isolate);

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

#ifdef DEBUG

// Print the scopes for the top frame.

StackFrameLocator locator(isolate);

JavaScriptFrame* frame = locator.FindJavaScriptFrame(0);

FrameInspector frame_inspector(frame, 0, isolate);

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

it.DebugPrint();

}

#endif

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

HandleScope scope(isolate);

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

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

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

// Count all archived V8 threads.

int n = 0;

for (ThreadState* thread = isolate->thread_manager()->FirstThreadStateInUse();

thread != NULL; thread = thread->Next()) {

n++;

}

// Total number of threads is current thread and archived threads.

return Smi::FromInt(n + 1);

HandleScope scope(isolate);

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

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

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

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

// Allocate array for result.

Handle<FixedArray> details =

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