Stack allocating block scoped variables.

src/runtime.cc

 // Copyright 2011 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 11141 matching lines @@
       SetProperty(catch_scope, name, thrown_object, NONE, kNonStrictMode),
       Handle<JSObject>());
   return catch_scope;
 }
 
 
 // Create a plain JSObject which materializes the block scope for the specified
 // block context.
 static Handle<JSObject> MaterializeBlockScope(
     Isolate* isolate,
-    Handle<Context> context) {
-  ASSERT(context->IsBlockContext());
-  Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
+    Handle<Context> context,
+    Handle<ScopeInfo> scope_info,
+    JavaScriptFrame* frame,
+    int inlined_frame_index) {
+  FrameInspector frame_inspector(frame, inlined_frame_index, isolate);
 
   // Allocate and initialize a JSObject with all the arguments, stack locals
   // heap locals and extension properties of the debugged function.
   Handle<JSObject> block_scope =
       isolate->factory()->NewJSObject(isolate->object_function());
 
+  // Second fill all stack locals.
+  int stack_slots_depth = scope_info->StackSlotsDepth();
+  for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
+    int index = i + stack_slots_depth;
+    RETURN_IF_EMPTY_HANDLE_VALUE(
+        isolate,
+        SetProperty(block_scope,
+                    Handle<String>(scope_info->StackLocalName(i)),
+                    Handle<Object>(frame_inspector.GetExpression(index)),
+                    NONE,
+                    kNonStrictMode),
+        Handle<JSObject>());
+  }
+
   // Fill all context locals.
-  if (!CopyContextLocalsToScopeObject(
-          isolate, scope_info, context, block_scope)) {
-    return Handle<JSObject>();
+  if (scope_info->HasContext()) {
+    ASSERT(context->IsBlockContext());
+    ASSERT(context->extension() == *scope_info);
+    if (!CopyContextLocalsToScopeObject(
+            isolate, scope_info, context, block_scope)) {
+      return Handle<JSObject>();
+    }
   }
 
   return block_scope;
 }
 
 
 // Iterate over the actual scopes visible from a stack frame. The iteration
 // proceeds from the innermost visible nested scope outwards. All scopes are
-// backed by an actual context except the local scope, which is inserted
-// "artificially" in the context chain.
+// backed by an actual context except the local function scope and local block
+// scopes, which is inserted "artificially" in the context chain.
 class ScopeIterator {
  public:
   enum ScopeType {
     ScopeTypeGlobal = 0,
     ScopeTypeLocal,
     ScopeTypeWith,
     ScopeTypeClosure,
     ScopeTypeCatch,
     ScopeTypeBlock
   };
@@ skipping 53 matching lines @@
       if (scope_info->Type() != FUNCTION_SCOPE) {
         // Global or eval code.
         CompilationInfo info(script);
         if (scope_info->Type() == GLOBAL_SCOPE) {
           info.MarkAsGlobal();
         } else {
           ASSERT(scope_info->Type() == EVAL_SCOPE);
           info.MarkAsEval();
           info.SetCallingContext(Handle<Context>(function_->context()));
         }
-        if (ParserApi::Parse(&info, kNoParsingFlags) && Scope::Analyze(&info)) {
+        if (ParserApi::Parse(&info, kNoParsingFlags) &&
+            Compiler::MakeCode(&info)) {
           scope = info.function()->scope();
         }
       } else {
         // Function code
         CompilationInfo info(shared_info);
-        if (ParserApi::Parse(&info, kNoParsingFlags) && Scope::Analyze(&info)) {
+        if (ParserApi::Parse(&info, kNoParsingFlags) &&
+            Compiler::MakeCode(&info)) {
           scope = info.function()->scope();
         }
       }
 
       // Retrieve the scope chain for the current position.
       if (scope != NULL) {
         int source_position = shared_info->code()->SourcePosition(frame_->pc());
         scope->GetNestedScopeChain(&nested_scope_chain_, source_position);
       } else {
         // A failed reparse indicates that the preparser has diverged from the
@@ skipping 83 matching lines @@
         return MaterializeLocalScope(isolate_, frame_, inlined_frame_index_);
       case ScopeIterator::ScopeTypeWith:
         // Return the with object.
         return Handle<JSObject>(JSObject::cast(CurrentContext()->extension()));
       case ScopeIterator::ScopeTypeCatch:
         return MaterializeCatchScope(isolate_, CurrentContext());
       case ScopeIterator::ScopeTypeClosure:
         // Materialize the content of the closure scope into a JSObject.
         return MaterializeClosure(isolate_, CurrentContext());
       case ScopeIterator::ScopeTypeBlock:
-        return MaterializeBlockScope(isolate_, CurrentContext());
+        return MaterializeBlockScope(isolate_,
+                                     CurrentContext(),
+                                     CurrentScopeInfo(),
+                                     frame_,
+                                     inlined_frame_index_);
     }
     UNREACHABLE();
     return Handle<JSObject>();
   }
 
   Handle<ScopeInfo> CurrentScopeInfo() {
     if (!nested_scope_chain_.is_empty()) {
       return nested_scope_chain_.last();
     } else if (context_->IsBlockContext()) {
       return Handle<ScopeInfo>(ScopeInfo::cast(context_->extension()));
@@ skipping 567 matching lines @@
     if (scope_info->Type() == CATCH_SCOPE) {
       Handle<String> name(String::cast(current->extension()));
       Handle<Object> thrown_object(current->get(Context::THROWN_OBJECT_INDEX));
       context =
           isolate->factory()->NewCatchContext(function,
                                               context,
                                               name,
                                               thrown_object);
     } else if (scope_info->Type() == BLOCK_SCOPE) {
       // Materialize the contents of the block scope into a JSObject.
-      Handle<JSObject> block_scope_object =
-          MaterializeBlockScope(isolate, current);
+      Handle<JSObject> block_scope_object =  MaterializeBlockScope(
+          isolate, current, scope_info, frame, inlined_frame_index);
       if (block_scope_object.is_null()) {
         return Handle<Context>::null();
       }
       // Allocate a new function context for the debug evaluation and set the
       // extension object.
       Handle<Context> new_context =
           isolate->factory()->NewFunctionContext(Context::MIN_CONTEXT_SLOTS,
                                                  function);
       new_context->set_extension(*block_scope_object);
       new_context->set_previous(*context);
@@ skipping 1594 matching lines @@
   } else {
     // 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);
   }
 }
 
 
 } }  // namespace v8::internal