Stack-allocate block variables

src/full-codegen.h

 // 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.
 
 #ifndef V8_FULL_CODEGEN_H_
 #define V8_FULL_CODEGEN_H_
 
 #include "src/v8.h"
 
 #include "src/allocation.h"
 #include "src/assert-scope.h"
 #include "src/ast.h"
 #include "src/bit-vector.h"
 #include "src/code-stubs.h"
 #include "src/codegen.h"
 #include "src/compiler.h"
 #include "src/globals.h"
 #include "src/objects.h"
+#include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class JumpPatchSite;
 
 // AST node visitor which can tell whether a given statement will be breakable
 // when the code is compiled by the full compiler in the debugger. This means
 // that there will be an IC (load/store/call) in the code generated for the
@@ skipping 180 matching lines @@
 
   // A nested block statement.
   class NestedBlock : public Breakable {
    public:
     NestedBlock(FullCodeGenerator* codegen, Block* block)
         : Breakable(codegen, block) {
     }
     virtual ~NestedBlock() {}
 
     virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
-      if (statement()->AsBlock()->scope() != NULL) {
+      Scope* block_scope = statement()->AsBlock()->scope();
+      if (block_scope != nullptr && block_scope->ContextLocalCount() > 0) {
         ++(*context_length);
       }
+      if (block_scope != nullptr) {
+        *stack_depth += block_scope->num_stack_slots();
+      }
       return previous_;
     }
   };
 
   // The try block of a try/catch statement.
   class TryCatch : public NestedStatement {
    public:
     explicit TryCatch(FullCodeGenerator* codegen) : NestedStatement(codegen) {
     }
     virtual ~TryCatch() {}
@@ skipping 667 matching lines @@
    public:
     EnterBlockScopeIfNeeded(FullCodeGenerator* codegen, Scope* scope,
                             BailoutId entry_id, BailoutId declarations_id,
                             BailoutId exit_id);
     ~EnterBlockScopeIfNeeded();
 
    private:
     MacroAssembler* masm() const { return codegen_->masm(); }
 
     FullCodeGenerator* codegen_;
-    Scope* scope_;
     Scope* saved_scope_;
     BailoutId exit_id_;
+    bool needs_block_context_;
+    bool num_stack_slots_;
   };
 
+  void AllocateLocals(int local_count);
+  void DeallocateLocals(int local_count);
+
   MacroAssembler* masm_;
   CompilationInfo* info_;
   Scope* scope_;
   Label return_label_;
   NestedStatement* nesting_stack_;
   int loop_depth_;
   ZoneList<Handle<Object> >* globals_;
   Handle<FixedArray> modules_;
   int module_index_;
   const ExpressionContext* context_;
@@ skipping 112 matching lines @@
 
   Address start_;
   Address instruction_start_;
   uint32_t length_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_