Stack allocating block scoped variables.

src/full-codegen.h

 // 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 97 matching lines @@
   }
 
  private:
   class Breakable;
   class Iteration;
 
   class TestContext;
 
   class NestedStatement BASE_EMBEDDED {
    public:
-    explicit NestedStatement(FullCodeGenerator* codegen) : codegen_(codegen) {
-      // Link into codegen's nesting stack.
-      previous_ = codegen->nesting_stack_;
-      codegen->nesting_stack_ = this;
-    }
+    NestedStatement(FullCodeGenerator* codegen, int stack_delta);
     virtual ~NestedStatement() {
       // Unlink from codegen's nesting stack.
       ASSERT_EQ(this, codegen_->nesting_stack_);
       codegen_->nesting_stack_ = previous_;
     }
 
     virtual Breakable* AsBreakable() { return NULL; }
     virtual Iteration* AsIteration() { return NULL; }
 
     virtual bool IsContinueTarget(Statement* target) { return false; }
     virtual bool IsBreakTarget(Statement* target) { return false; }
 
     // Notify the statement that we are exiting it via break, continue, or
     // return and give it a chance to generate cleanup code.  Return the
     // next outer statement in the nesting stack.  We accumulate in
     // *stack_depth the amount to drop the stack and in *context_length the
     // number of context chain links to unwind as we traverse the nesting
     // stack from an exit to its target.
     virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
+      *stack_depth += stack_delta_;
       return previous_;
     }
 
+    // The depth of the stack of block local variables and handlers
+    // above the locals during the execution of this nested statement.
+    int StackDepth() const { return stack_depth_; }
+    // The depth of the stack before and after executing this nested statement.
+    int StackDepthBase() const { return stack_depth_ - stack_delta_; }
+
  protected:
     MacroAssembler* masm() { return codegen_->masm(); }
 
     FullCodeGenerator* codegen_;
     NestedStatement* previous_;
+    int stack_depth_;
+    int stack_delta_;
     DISALLOW_COPY_AND_ASSIGN(NestedStatement);
   };
 
   // A breakable statement such as a block.
   class Breakable : public NestedStatement {
    public:
-    Breakable(FullCodeGenerator* codegen, BreakableStatement* statement)
-        : NestedStatement(codegen), statement_(statement) {
+    Breakable(FullCodeGenerator* codegen,
+              BreakableStatement* statement,
+              int stack_delta = 0)
+        : NestedStatement(codegen, stack_delta), statement_(statement) {
     }
     virtual ~Breakable() {}
 
     virtual Breakable* AsBreakable() { return this; }
     virtual bool IsBreakTarget(Statement* target) {
       return statement() == target;
     }
 
     BreakableStatement* statement() { return statement_; }
     Label* break_label() { return &break_label_; }
 
    private:
     BreakableStatement* statement_;
     Label break_label_;
   };
 
   // An iteration statement such as a while, for, or do loop.
   class Iteration : public Breakable {
    public:
-    Iteration(FullCodeGenerator* codegen, IterationStatement* statement)
-        : Breakable(codegen, statement) {
+    Iteration(FullCodeGenerator* codegen,
+              IterationStatement* statement,
+              int stack_delta = 0)
+        : Breakable(codegen, statement, stack_delta) {
     }
     virtual ~Iteration() {}
 
     virtual Iteration* AsIteration() { return this; }
     virtual bool IsContinueTarget(Statement* target) {
       return statement() == target;
     }
 
     Label* continue_label() { return &continue_label_; }
 
    private:
     Label continue_label_;
   };
 
   // A nested block statement.
   class NestedBlock : public Breakable {
    public:
-    NestedBlock(FullCodeGenerator* codegen, Block* block)
-        : Breakable(codegen, block) {
-    }
+    NestedBlock(FullCodeGenerator* codegen, Block* block);
+
     virtual ~NestedBlock() {}
 
-    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
-      if (statement()->AsBlock()->block_scope() != NULL) {
-        ++(*context_length);
-      }
-      return previous_;
-    };
+    virtual NestedStatement* Exit(int* stack_depth, int* context_length);
   };
 
   // The try block of a try/catch statement.
   class TryCatch : public NestedStatement {
    public:
-    explicit TryCatch(FullCodeGenerator* codegen) : NestedStatement(codegen) {
+    static const int kElementCount =
+        StackHandlerConstants::kSize / kPointerSize;
+
+    explicit TryCatch(FullCodeGenerator* codegen)
+        : NestedStatement(codegen, kElementCount) {
     }
     virtual ~TryCatch() {}
 
     virtual NestedStatement* Exit(int* stack_depth, int* context_length);
   };
 
   // The try block of a try/finally statement.
   class TryFinally : public NestedStatement {
    public:
+    static const int kElementCount = 5;
+
     TryFinally(FullCodeGenerator* codegen, Label* finally_entry)
-        : NestedStatement(codegen), finally_entry_(finally_entry) {
+        : NestedStatement(codegen, kElementCount),
+          finally_entry_(finally_entry) {
     }
     virtual ~TryFinally() {}
 
     virtual NestedStatement* Exit(int* stack_depth, int* context_length);
 
    private:
     Label* finally_entry_;
   };
 
   // The finally block of a try/finally statement.
   class Finally : public NestedStatement {
    public:
     static const int kElementCount = 2;
 
-    explicit Finally(FullCodeGenerator* codegen) : NestedStatement(codegen) { }
+    explicit Finally(FullCodeGenerator* codegen)
+        : NestedStatement(codegen, kElementCount) { }
     virtual ~Finally() {}
-
-    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
-      *stack_depth += kElementCount;
-      return previous_;
-    }
   };
 
   // The body of a for/in loop.
   class ForIn : public Iteration {
    public:
     static const int kElementCount = 5;
 
     ForIn(FullCodeGenerator* codegen, ForInStatement* statement)
-        : Iteration(codegen, statement) {
+        : Iteration(codegen, statement, kElementCount) {
     }
     virtual ~ForIn() {}
-
-    virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
-      *stack_depth += kElementCount;
-      return previous_;
-    }
   };
 
 
   // The body of a with or catch.
   class WithOrCatch : public NestedStatement {
    public:
     explicit WithOrCatch(FullCodeGenerator* codegen)
-        : NestedStatement(codegen) {
+        : NestedStatement(codegen, 0) {
     }
     virtual ~WithOrCatch() {}
 
     virtual NestedStatement* Exit(int* stack_depth, int* context_length) {
       ++(*context_length);
       return previous_;
     }
   };
 
   // Type of a member function that generates inline code for a native function.
@@ skipping 482 matching lines @@
 
   friend class NestedStatement;
 
   DISALLOW_COPY_AND_ASSIGN(FullCodeGenerator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_