Provisional implementation of stack allocated catch variables.

src/scopes.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 189 matching lines @@
   scope_contains_with_ = false;
   scope_calls_eval_ = false;
   // Inherit the strict mode from the parent scope.
   strict_mode_ = (outer_scope != NULL) && outer_scope->strict_mode_;
   outer_scope_calls_eval_ = false;
   outer_scope_calls_non_strict_eval_ = false;
   inner_scope_calls_eval_ = false;
   outer_scope_is_eval_scope_ = false;
   force_eager_compilation_ = false;
   num_var_or_const_ = 0;
+  num_stack_allocs_ = 0;
   num_stack_slots_ = 0;
   num_heap_slots_ = 0;
   scope_info_ = scope_info;
+  if (!scope_info_.is_null()) {
+    source_beg_statement_pos_ = scope_info_->SourceBegStatementPos();
+    source_end_statement_pos_ = scope_info_->SourceEndStatementPos();
+  } else {
+    source_beg_statement_pos_ = -1;
+    source_end_statement_pos_ = -1;
+  }
 }
 
 
 Scope* Scope::DeserializeScopeChain(CompilationInfo* info,
                                     Scope* global_scope) {
   // Reconstruct the outer scope chain from a closure's context chain.
   ASSERT(!info->closure().is_null());
   Context* context = info->closure()->context();
   Scope* current_scope = NULL;
   Scope* innermost_scope = NULL;
@@ skipping 64 matching lines @@
   }
 
   // Declare convenience variables.
   // Declare and allocate receiver (even for the global scope, and even
   // if naccesses_ == 0).
   // NOTE: When loading parameters in the global scope, we must take
   // care not to access them as properties of the global object, but
   // instead load them directly from the stack. Currently, the only
   // such parameter is 'this' which is passed on the stack when
   // invoking scripts
-  if (is_catch_scope()) {
+  if (is_catch_scope() || is_with_scope()) {
     ASSERT(outer_scope() != NULL);
     receiver_ = outer_scope()->receiver();
   } else {
     Variable* var =
         variables_.Declare(this,
                            isolate_->factory()->this_symbol(),
                            Variable::VAR,
                            false,
                            Variable::THIS);
     var->set_rewrite(NewSlot(var, Slot::PARAMETER, -1));
@@ skipping 232 matching lines @@
 bool Scope::HasTrivialOuterContext() const {
   Scope* outer = outer_scope_;
   if (outer == NULL) return true;
   // Note that the outer context may be trivial in general, but the current
   // scope may be inside a 'with' statement in which case the outer context
   // for this scope is not trivial.
   return !scope_inside_with_ && outer->HasTrivialContext();
 }
 
 
+bool Scope::HasContext() const {
+  return num_heap_slots() > 0 || is_with_scope();
+}
+
+
 int Scope::ContextChainLength(Scope* scope) {
   int n = 0;
   for (Scope* s = this; s != scope; s = s->outer_scope_) {
     ASSERT(s != NULL);  // scope must be in the scope chain
-    if (s->num_heap_slots() > 0) n++;
+    if (s->HasContext()) n++;
   }
   return n;
 }
 
 
 Scope* Scope::DeclarationScope() {
   Scope* scope = this;
-  while (scope->is_catch_scope()) {
+  while (scope->is_catch_scope() || scope->is_with_scope()) {
     scope = scope->outer_scope();
   }
   return scope;
 }
 
 
 #ifdef DEBUG
 static const char* Header(Scope::Type type) {
   switch (type) {
     case Scope::EVAL_SCOPE: return "eval";
     case Scope::FUNCTION_SCOPE: return "function";
     case Scope::GLOBAL_SCOPE: return "global";
     case Scope::CATCH_SCOPE: return "catch";
+    case Scope::WITH_SCOPE: return "with";
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 static void Indent(int n, const char* str) {
   PrintF("%*s%s", n, "", str);
 }
 
@@ skipping 71 matching lines @@
     Indent(n1, "// outer scope calls 'eval' in non-strict context\n");
   }
   if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
   if (outer_scope_is_eval_scope_) {
     Indent(n1, "// outer scope is 'eval' scope\n");
   }
   if (num_stack_slots_ > 0) { Indent(n1, "// ");
   PrintF("%d stack slots\n", num_stack_slots_); }
   if (num_heap_slots_ > 0) { Indent(n1, "// ");
   PrintF("%d heap slots\n", num_heap_slots_); }
+  if (num_stack_allocs_ > 0) { Indent(n1, "// ");
+  PrintF("%d stack allocs\n", num_stack_allocs_); }
 
   // Print locals.
   PrettyPrinter printer;
   Indent(n1, "// function var\n");
   if (function_ != NULL) {
     PrintVar(&printer, n1, function_);
   }
 
   Indent(n1, "// temporary vars\n");
   for (int i = 0; i < temps_.length(); i++) {
@@ skipping 69 matching lines @@
     // only present - if at all - for function scopes.
     //
     // This lookup corresponds to a lookup in the "intermediate" scope sitting
     // between this scope and the outer scope. (ECMA-262, 3rd., requires that
     // the name of named function literal is kept in an intermediate scope
     // in between this scope and the next outer scope.)
     if (function_ != NULL && function_->name().is_identical_to(name)) {
       var = function_;
 
     } else if (outer_scope_ != NULL) {
-      var = outer_scope_->LookupRecursive(name, true, invalidated_local);
+      var = outer_scope_->LookupRecursive(name,
+                                          inner_lookup || is_function_scope(),
+                                          invalidated_local);
       // We may have found a variable in an outer scope. However, if
       // the current scope is inside a 'with', the actual variable may
       // be a property introduced via the 'with' statement. Then, the
       // variable we may have found is just a guess.
       if (scope_inside_with_)
         guess = true;
     }
 
     // If we did not find a variable, we are done.
     if (var == NULL)
@@ skipping 169 matching lines @@
 
 bool Scope::MustAllocateInContext(Variable* var) {
   // If var is accessed from an inner scope, or if there is a possibility
   // that it might be accessed from the current or an inner scope (through
   // an eval() call or a runtime with lookup), it must be allocated in the
   // context.
   //
   // Exceptions: temporary variables are never allocated in a context;
   // catch-bound variables are always allocated in a context.
   if (var->mode() == Variable::TEMPORARY) return false;
-  if (is_catch_scope()) return true;
+  if (is_catch_scope() && !DeclarationScope()->is_function_scope()) return true;
   return var->is_accessed_from_inner_scope() ||
       scope_calls_eval_ ||
       inner_scope_calls_eval_ ||
       scope_contains_with_ ||
       var->is_global();
 }
 
 
 bool Scope::HasArgumentsParameter() {
   for (int i = 0; i < params_.length(); i++) {
     if (params_[i]->name().is_identical_to(
             isolate_->factory()->arguments_symbol())) {
       return true;
     }
   }
   return false;
 }
 
 
 void Scope::AllocateStackSlot(Variable* var) {
-  var->set_rewrite(NewSlot(var, Slot::LOCAL, num_stack_slots_++));
+  Scope* scope = DeclarationScope();
+  var->set_rewrite(NewSlot(var, Slot::LOCAL, scope->num_stack_allocs_++));
+  num_stack_slots_++;
 }
 
 
 void Scope::AllocateHeapSlot(Variable* var) {
   var->set_rewrite(NewSlot(var, Slot::CONTEXT, num_heap_slots_++));
 }
 
 
 void Scope::AllocateParameterLocals() {
   ASSERT(is_function_scope());
@@ skipping 85 matching lines @@
   // allocated in the context, it must be the last slot in the context,
   // because of the current ScopeInfo implementation (see
   // ScopeInfo::ScopeInfo(FunctionScope* scope) constructor).
   if (function_ != NULL) {
     AllocateNonParameterLocal(function_);
   }
 }
 
 
 void Scope::AllocateVariablesRecursively() {
-  // Allocate variables for inner scopes.
+  // If scope is already resolved, we still need to allocate
+  // variables in inner scopes which might not had been resolved yet.
+  if (!already_resolved()) {
+    // The number of slots required for variables.
+    num_stack_slots_ = 0;
+    num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
+
+    // Allocate variables for this scope.
+    // Parameters must be allocated first, if any.
+    if (is_function_scope()) AllocateParameterLocals();
+    AllocateNonParameterLocals();
+
+    // Allocate context if necessary.
+    bool must_have_local_context = false;
+    if (scope_calls_eval_ || scope_contains_with_) {
+      // The context for the eval() call or 'with' statement in this scope.
+      // Unless we are in the global or an eval scope, we need a local
+      // context even if we didn't statically allocate any locals in it,
+      // and the compiler will access the context variable. If we are
+      // not in an inner scope, the scope is provided from the outside.
+      must_have_local_context = is_function_scope();
+    }
+
+    // If we didn't allocate any locals in the local context, then we only
+    // need the minimal number of slots if we must have a local context.
+    if (num_heap_slots_ == Context::MIN_CONTEXT_SLOTS &&
+        !must_have_local_context) {
+      num_heap_slots_ = 0;
+    }
+
+    // Allocation done.
+    ASSERT(num_heap_slots_ == 0 ||
+           num_heap_slots_ >= Context::MIN_CONTEXT_SLOTS);
+  }
+
+  // Allocate variables for inner scopes. Must be done after parameters and
+  // local variables to allow reservation of stack slots for variables from
+  // nested blocks.
   for (int i = 0; i < inner_scopes_.length(); i++) {
     inner_scopes_[i]->AllocateVariablesRecursively();
   }
-
-  // If scope is already resolved, we still need to allocate
-  // variables in inner scopes which might not had been resolved yet.
-  if (already_resolved()) return;
-  // The number of slots required for variables.
-  num_stack_slots_ = 0;
-  num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
-
-  // Allocate variables for this scope.
-  // Parameters must be allocated first, if any.
-  if (is_function_scope()) AllocateParameterLocals();
-  AllocateNonParameterLocals();
-
-  // Allocate context if necessary.
-  bool must_have_local_context = false;
-  if (scope_calls_eval_ || scope_contains_with_) {
-    // The context for the eval() call or 'with' statement in this scope.
-    // Unless we are in the global or an eval scope, we need a local
-    // context even if we didn't statically allocate any locals in it,
-    // and the compiler will access the context variable. If we are
-    // not in an inner scope, the scope is provided from the outside.
-    must_have_local_context = is_function_scope();
-  }
-
-  // If we didn't allocate any locals in the local context, then we only
-  // need the minimal number of slots if we must have a local context.
-  if (num_heap_slots_ == Context::MIN_CONTEXT_SLOTS &&
-      !must_have_local_context) {
-    num_heap_slots_ = 0;
-  }
-
-  // Allocation done.
-  ASSERT(num_heap_slots_ == 0 || num_heap_slots_ >= Context::MIN_CONTEXT_SLOTS);
 }
 
 } }  // namespace v8::internal