Introduce Runtime_GetAllScopesDetails to get all scopes at once for a frame.

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 12280 matching lines @@
   for (; !it.Done() && n < index; it.Next()) {
     n++;
   }
   if (it.Done()) {
     return isolate->heap()->undefined_value();
   }
   return MaterializeScopeDetails(isolate, &it);
 }
 
 
+// Return an array of scope details
+// args[0]: number: break id
+// args[1]: number: frame index
+// args[2]: number: inlined frame index
+//
+// The array returned contains arrays with the following information:
+// 0: Scope type
+// 1: Scope object

[Yang, 2014/03/04 11:31:35]

Now this seems just a broader case of %GetScopeDetails. Just an idea that you
may dismiss: we could share code and use an unified runtime function that takes
an optional scope index to distinguish between the two use cases.

+RUNTIME_FUNCTION(MaybeObject*, Runtime_GetAllScopesDetails) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 3);
+
+  // Check arguments.
+  Object* check;
+  { MaybeObject* maybe_check = Runtime_CheckExecutionState(
+      RUNTIME_ARGUMENTS(isolate, args));
+    if (!maybe_check->ToObject(&check)) return maybe_check;
+  }
+  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 = UnwrapFrameId(wrapped_id);
+  JavaScriptFrameIterator frame_it(isolate, id);
+  JavaScriptFrame* frame = frame_it.frame();
+
+  List<Handle<Object> > result(4);
+  ScopeIterator it(isolate, frame, inlined_jsframe_index);

[ulan, 2014/03/04 10:41:59]

This code seems to work, but it is fragile because it mixes handlified code with
raw pointers. ScopeIterator can cause GC, so after this point any raw pointer to
v8 heap from above may become invalid.

[aandrey, 2014/03/04 11:04:19]

You mean the JavaScriptFrame* pointer?
I'm not an expert here, but this code, up to the point, is just a carbon copy of
the above Runtime_GetScopeDetails.

The JavaScriptFrame class is BASE_EMBEDDED. Should it care on GC being run?

[ulan, 2014/03/04 11:28:15]

That pointer should be fine. This code works, but becomes confusing because of
mixing handles with maybe_object below.

[Yang, 2014/03/04 11:31:35]

Seems fine to me.

+  for (; !it.Done(); it.Next()) {
+    MaybeObject* maybe_object = MaterializeScopeDetails(isolate, &it);

[ulan, 2014/03/04 10:41:59]

MaterializeScopeDetails looks already handlified, it could just return a handle,
instead of maybe_objects. The you wouldn't need checks and conversions below.

[aandrey, 2014/03/04 11:04:19]

As far as I understand, it may return a Failure which inherits MaybeObject and
not Object, thus the return type is MaybeObject*.

What syntax would you suggest for MaterializeScopeDetails?

[ulan, 2014/03/04 11:28:15]

Something like this:

Handle<Object> MaterializeScopeDetails(Isolate* isolate,     ScopeIterator* it).
It could return empty handle in the case where it is currently returning
Failure, then the caller could do

Handle<Object> scope_details = MaterializeScopeDetails(isolate, &it);
RETURN_IF_EMPTY_HANDLE(isolate, scope_details);
result.Add(scope_details, isolate);

This way it is clear that all the code is handlified.

[Yang, 2014/03/04 11:31:35]

I suggest changing MaterializedScopeDetails to return a Handle<JSObject>. If the
scope_object is an empty handle, use RETURN_IF_EMPTY_HANDLE_VALUE to propagate
that empty handle to the caller. The caller should then check with
RETURN_IF_EMPTY_HANDLE.

I know it's not actually caused by this CL, but I since we are moving towards
less code with MaybeObject, this would be a nice small clean up.

[aandrey, 2014/03/04 12:39:07]

Done.

+    if (maybe_object->IsFailure()) return maybe_object;
+    result.Add(handle(maybe_object->ToObjectUnchecked(), isolate));
+  }
+
+  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);
+}
+
+
 RUNTIME_FUNCTION(MaybeObject*, Runtime_GetFunctionScopeCount) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
 
   // Check arguments.
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, fun, 0);
 
   // Count the visible scopes.
   int n = 0;
   for (ScopeIterator it(isolate, fun); !it.Done(); it.Next()) {
@@ skipping 2654 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal