Stack-allocate block variables

src/ia32/full-codegen-ia32.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_IA32
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
@@ skipping 126 matching lines @@
   FrameScope frame_scope(masm_, StackFrame::MANUAL);
 
   info->set_prologue_offset(masm_->pc_offset());
   __ Prologue(info->IsCodePreAgingActive());
   info->AddNoFrameRange(0, masm_->pc_offset());
 
   { Comment cmnt(masm_, "[ Allocate locals");
     int locals_count = info->scope()->num_stack_slots();
     // Generators allocate locals, if any, in context slots.
     DCHECK(!info->function()->is_generator() || locals_count == 0);
-    if (locals_count == 1) {
-      __ push(Immediate(isolate()->factory()->undefined_value()));
-    } else if (locals_count > 1) {
-      if (locals_count >= 128) {
-        Label ok;
-        __ mov(ecx, esp);
-        __ sub(ecx, Immediate(locals_count * kPointerSize));
-        ExternalReference stack_limit =
-            ExternalReference::address_of_real_stack_limit(isolate());
-        __ cmp(ecx, Operand::StaticVariable(stack_limit));
-        __ j(above_equal, &ok, Label::kNear);
-        __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
-        __ bind(&ok);
-      }
-      __ mov(eax, Immediate(isolate()->factory()->undefined_value()));
-      const int kMaxPushes = 32;
-      if (locals_count >= kMaxPushes) {
-        int loop_iterations = locals_count / kMaxPushes;
-        __ mov(ecx, loop_iterations);
-        Label loop_header;
-        __ bind(&loop_header);
-        // Do pushes.
-        for (int i = 0; i < kMaxPushes; i++) {
-          __ push(eax);
-        }
-        __ dec(ecx);
-        __ j(not_zero, &loop_header, Label::kNear);
-      }
-      int remaining = locals_count % kMaxPushes;
-      // Emit the remaining pushes.
-      for (int i  = 0; i < remaining; i++) {
-        __ push(eax);
-      }
-    }
+    AllocateLocals(locals_count);
   }
 
   bool function_in_register = true;
 
   // Possibly allocate a local context.
   int heap_slots = info->scope()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
   if (heap_slots > 0) {
     Comment cmnt(masm_, "[ Allocate context");
     bool need_write_barrier = true;
     // Argument to NewContext is the function, which is still in edi.
@@ skipping 124 matching lines @@
 
   // Always emit a 'return undefined' in case control fell off the end of
   // the body.
   { Comment cmnt(masm_, "[ return <undefined>;");
     __ mov(eax, isolate()->factory()->undefined_value());
     EmitReturnSequence();
   }
 }
 
 
+void FullCodeGenerator::AllocateLocals(int locals_count) {
+  if (locals_count == 1) {
+    __ push(Immediate(isolate()->factory()->undefined_value()));
+  } else if (locals_count > 1) {
+    if (locals_count >= 128) {
+      Label ok;
+      __ mov(ecx, esp);
+      __ sub(ecx, Immediate(locals_count * kPointerSize));
+      ExternalReference stack_limit =
+          ExternalReference::address_of_real_stack_limit(isolate());
+      __ cmp(ecx, Operand::StaticVariable(stack_limit));
+      __ j(above_equal, &ok, Label::kNear);
+      __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
+      __ bind(&ok);
+    }
+    __ mov(eax, Immediate(isolate()->factory()->undefined_value()));
+    const int kMaxPushes = 32;
+    if (locals_count >= kMaxPushes) {
+      int loop_iterations = locals_count / kMaxPushes;
+      __ mov(ecx, loop_iterations);
+      Label loop_header;
+      __ bind(&loop_header);
+      // Do pushes.
+      for (int i = 0; i < kMaxPushes; i++) {
+        __ push(eax);
+      }
+      __ dec(ecx);
+      __ j(not_zero, &loop_header, Label::kNear);
+    }
+    int remaining = locals_count % kMaxPushes;
+    // Emit the remaining pushes.
+    for (int i  = 0; i < remaining; i++) {
+      __ push(eax);
+    }
+  }
+}
+
+
+void FullCodeGenerator::DeallocateLocals(int local_count) {
+  if (local_count > 0) {
+    __ add(esp, Immediate(local_count * kPointerSize));
+  }
+}
+
+
 void FullCodeGenerator::ClearAccumulator() {
   __ Move(eax, Immediate(Smi::FromInt(0)));
 }
 
 
 void FullCodeGenerator::EmitProfilingCounterDecrement(int delta) {
   __ mov(ebx, Immediate(profiling_counter_));
   __ sub(FieldOperand(ebx, Cell::kValueOffset),
          Immediate(Smi::FromInt(delta)));
 }
@@ skipping 323 matching lines @@
     __ j(cc, if_true);
     __ jmp(if_false);
   }
 }
 
 
 MemOperand FullCodeGenerator::StackOperand(Variable* var) {
   DCHECK(var->IsStackAllocated());
   // Offset is negative because higher indexes are at lower addresses.
   int offset = -var->index() * kPointerSize;
+  Scope* var_scope = var->scope();
+  while (!var_scope->is_function_scope() && !var_scope->is_script_scope()) {
+    var_scope = var_scope->outer_scope();
+    offset -= var_scope->num_stack_slots() * kPointerSize;
+  }
   // Adjust by a (parameter or local) base offset.
   if (var->IsParameter()) {
     offset += (info_->scope()->num_parameters() + 1) * kPointerSize;
   } else {
     offset += JavaScriptFrameConstants::kLocal0Offset;
   }
   return Operand(ebp, offset);
 }
 
 
@@ skipping 4498 matching lines @@
   DCHECK_EQ(isolate->builtins()->OsrAfterStackCheck()->entry(),
             Assembler::target_address_at(call_target_address,
                                          unoptimized_code));
   return OSR_AFTER_STACK_CHECK;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32