Stack allocating block scoped variables.

src/full-codegen.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 777 matching lines @@
   }
 }
 
 
 void FullCodeGenerator::VisitBlock(Block* stmt) {
   Comment cmnt(masm_, "[ Block");
   NestedBlock nested_block(this, stmt);
   SetStatementPosition(stmt);
 
   Scope* saved_scope = scope();
-  // Push a block context when entering a block with block scoped variables.
   if (stmt->block_scope() != NULL) {
-    { Comment cmnt(masm_, "[ Extend block context");
-      scope_ = stmt->block_scope();
+    scope_ = stmt->block_scope();
+    int num_stack_slots = scope_->num_stack_slots();
+
+    // Allocate stack locals.
+    if (num_stack_slots > 0) {
+      Comment cmnt(masm_, "[ Allocate block stack locals");
+      if (num_stack_slots == 1) {
+        __ Push(isolate()->factory()->the_hole_value());
+      } else {
+        __ Move(result_register(), isolate()->factory()->the_hole_value());
+        for (int i = 0; i < num_stack_slots; i++) {
+          __ push(result_register());
+        }
+      }
+    }
+
+    // Allocate context locals.
+    if (scope_->num_heap_slots() > 0) {
+      Comment cmnt(masm_, "[ Extend block context");
       Handle<ScopeInfo> scope_info = scope_->GetScopeInfo();
-      int heap_slots = scope_info->ContextLength() - Context::MIN_CONTEXT_SLOTS;
+      int heap_slots =
+          scope_info->ContextLength() - Context::MIN_CONTEXT_SLOTS;
       __ Push(scope_info);
       PushFunctionArgumentForContextAllocation();
       if (heap_slots <= FastNewBlockContextStub::kMaximumSlots) {
         FastNewBlockContextStub stub(heap_slots);
         __ CallStub(&stub);
       } else {
         __ CallRuntime(Runtime::kPushBlockContext, 2);
       }
 
       // Replace the context stored in the frame.
       StoreToFrameField(StandardFrameConstants::kContextOffset,
                         context_register());
     }
     { Comment cmnt(masm_, "[ Declarations");
       VisitDeclarations(scope_->declarations());
     }
   }
   PrepareForBailoutForId(stmt->EntryId(), NO_REGISTERS);
   VisitStatements(stmt->statements());
   scope_ = saved_scope;
   __ bind(nested_block.break_label());
   PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
 
-  // Pop block context if necessary.
   if (stmt->block_scope() != NULL) {
-    LoadContextField(context_register(), Context::PREVIOUS_INDEX);
-    // Update local stack frame context field.
-    StoreToFrameField(StandardFrameConstants::kContextOffset,
-                      context_register());
+    Scope* scope = stmt->block_scope();
+    int num_stack_slots = scope->num_stack_slots();
+
+    // Pop block context if necessary.
+    if (scope->num_heap_slots() > 0) {
+      LoadContextField(context_register(), Context::PREVIOUS_INDEX);
+      // Update local stack frame context field.
+      StoreToFrameField(StandardFrameConstants::kContextOffset,
+                        context_register());
+    }
+
+    // Deallocate stack locals.
+    if (num_stack_slots > 0) {
+      __ Drop(num_stack_slots);
+    }
   }
 }
 
 
 void FullCodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
   Comment cmnt(masm_, "[ ExpressionStatement");
   SetStatementPosition(stmt);
   VisitForEffect(stmt->expression());
 }
 
@@ skipping 421 matching lines @@
 
 
 void FullCodeGenerator::VisitThrow(Throw* expr) {
   Comment cmnt(masm_, "[ Throw");
   VisitForStackValue(expr->exception());
   __ CallRuntime(Runtime::kThrow, 1);
   // Never returns here.
 }
 
 
+FullCodeGenerator::NestedStatement::NestedStatement(
+    FullCodeGenerator* codegen, int stack_delta)
+    : codegen_(codegen), stack_delta_(stack_delta) {
+  // Link into codegen's nesting stack.
+  previous_ = codegen->nesting_stack_;
+  codegen->nesting_stack_ = this;
+  stack_depth_ = stack_delta_;
+  if (previous_ != NULL) {
+    stack_depth_ += previous_->StackDepth();
+  } else {
+    stack_depth_ += codegen->function()->scope()->num_stack_slots();
+  }
+}
+
+
+FullCodeGenerator::NestedBlock::NestedBlock(
+    FullCodeGenerator* codegen, Block* block)
+  : Breakable(codegen,
+              block,
+              block->block_scope() == NULL ? 0
+              : block->block_scope()->num_stack_slots()) {
+  Scope* scope = block->block_scope();
+  if (scope != NULL) {
+    scope->set_stack_slots_depth(StackDepthBase());
+  }
+}
+
+
+FullCodeGenerator::NestedStatement* FullCodeGenerator::NestedBlock::Exit(
+    int* stack_depth,
+    int* context_length) {
+  Scope* scope = statement()->AsBlock()->block_scope();
+  if (scope != NULL) {
+    if (scope->num_heap_slots() > 0) ++(*context_length);
+    *stack_depth += scope->num_stack_slots();
+  }
+  return previous_;
+}
+
+
 FullCodeGenerator::NestedStatement* FullCodeGenerator::TryCatch::Exit(
     int* stack_depth,
     int* context_length) {
   // The macros used here must preserve the result register.
   __ Drop(*stack_depth);
   __ PopTryHandler();
   *stack_depth = 0;
   return previous_;
 }
 
@@ skipping 17 matching lines @@
   }
 
   return false;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal