Stack allocate lexical locals + hoist stack slots

src/scopeinfo.cc

 // Copyright 2011 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 <stdlib.h>
 
 #include "src/v8.h"
 
 #include "src/scopeinfo.h"
 #include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 
 
 Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone,
                                     Scope* scope) {
   // Collect stack and context locals.
   ZoneList<Variable*> stack_locals(scope->StackLocalCount(), zone);
   ZoneList<Variable*> context_locals(scope->ContextLocalCount(), zone);
   ZoneList<Variable*> strong_mode_free_variables(0, zone);
 
   scope->CollectStackAndContextLocals(&stack_locals, &context_locals,
                                       &strong_mode_free_variables);
   const int stack_local_count = stack_locals.length();
   const int context_local_count = context_locals.length();
   const int strong_mode_free_variable_count =
       strong_mode_free_variables.length();
   // Make sure we allocate the correct amount.
-  DCHECK(scope->StackLocalCount() == stack_local_count);
   DCHECK(scope->ContextLocalCount() == context_local_count);
 
   bool simple_parameter_list =
       scope->is_function_scope() ? scope->is_simple_parameter_list() : true;
 
   // Determine use and location of the function variable if it is present.
   FunctionVariableInfo function_name_info;
   VariableMode function_variable_mode;
   if (scope->is_function_scope() && scope->function() != NULL) {
     Variable* var = scope->function()->proxy()->var();
     if (!var->is_used()) {
       function_name_info = UNUSED;
     } else if (var->IsContextSlot()) {
       function_name_info = CONTEXT;
     } else {
       DCHECK(var->IsStackLocal());
       function_name_info = STACK;
     }
     function_variable_mode = var->mode();
   } else {
     function_name_info = NONE;
     function_variable_mode = VAR;
   }
 
   const bool has_function_name = function_name_info != NONE;
   const int parameter_count = scope->num_parameters();
-  const int length = kVariablePartIndex + parameter_count + stack_local_count +
-                     2 * context_local_count +
+  const int length = kVariablePartIndex + parameter_count +
+                     (1 + stack_local_count) + 2 * context_local_count +
                      3 * strong_mode_free_variable_count +
                      (has_function_name ? 2 : 0);
 
   Factory* factory = isolate->factory();
   Handle<ScopeInfo> scope_info = factory->NewScopeInfo(length);
 
   // Encode the flags.
   int flags = ScopeTypeField::encode(scope->scope_type()) |
               CallsEvalField::encode(scope->calls_eval()) |
               LanguageModeField::encode(scope->language_mode()) |
@@ skipping 13 matching lines @@
   int index = kVariablePartIndex;
   // Add parameters.
   DCHECK(index == scope_info->ParameterEntriesIndex());
   for (int i = 0; i < parameter_count; ++i) {
     scope_info->set(index++, *scope->parameter(i)->name());
   }
 
   // Add stack locals' names. We are assuming that the stack locals'
   // slots are allocated in increasing order, so we can simply add
   // them to the ScopeInfo object.
+  int first_slot_index;
+  if (stack_local_count > 0) {
+    first_slot_index = stack_locals[0]->index();
+  } else {
+    first_slot_index = 0;
+  }
+  DCHECK(index == scope_info->StackLocalFirstSlotIndex());
+  scope_info->set(index++, Smi::FromInt(first_slot_index));
   DCHECK(index == scope_info->StackLocalEntriesIndex());
   for (int i = 0; i < stack_local_count; ++i) {
-    DCHECK(stack_locals[i]->index() == i);
+    DCHECK(stack_locals[i]->index() == first_slot_index + i);
     scope_info->set(index++, *stack_locals[i]->name());
   }
 
   // Due to usage analysis, context-allocated locals are not necessarily in
   // increasing order: Some of them may be parameters which are allocated before
   // the non-parameter locals. When the non-parameter locals are sorted
   // according to usage, the allocated slot indices may not be in increasing
   // order with the variable list anymore. Thus, we first need to sort them by
   // context slot index before adding them to the ScopeInfo object.
   context_locals.Sort(&Variable::CompareIndex);
@@ skipping 33 matching lines @@
                                  ->strong_mode_reference_end_position()));
     scope_info->set(index++, *end_position);
   }
 
   // If present, add the function variable name and its index.
   DCHECK(index == scope_info->FunctionNameEntryIndex());
   if (has_function_name) {
     int var_index = scope->function()->proxy()->var()->index();
     scope_info->set(index++, *scope->function()->proxy()->name());
     scope_info->set(index++, Smi::FromInt(var_index));
-    DCHECK(function_name_info != STACK ||
-           (var_index == scope_info->StackLocalCount() &&
-            var_index == scope_info->StackSlotCount() - 1));
     DCHECK(function_name_info != CONTEXT ||
            var_index == scope_info->ContextLength() - 1);
   }
 
   DCHECK(index == scope_info->length());
   DCHECK(scope->num_parameters() == scope_info->ParameterCount());
-  DCHECK(scope->num_stack_slots() == scope_info->StackSlotCount());
   DCHECK(scope->num_heap_slots() == scope_info->ContextLength() ||
          (scope->num_heap_slots() == kVariablePartIndex &&
           scope_info->ContextLength() == 0));
   return scope_info;
 }
 
 
 ScopeInfo* ScopeInfo::Empty(Isolate* isolate) {
   return reinterpret_cast<ScopeInfo*>(isolate->heap()->empty_fixed_array());
 }
@@ skipping 94 matching lines @@
 }
 
 
 String* ScopeInfo::StackLocalName(int var) {
   DCHECK(0 <= var && var < StackLocalCount());
   int info_index = StackLocalEntriesIndex() + var;
   return String::cast(get(info_index));
 }
 
 
+int ScopeInfo::StackLocalIndex(int var) {
+  DCHECK(0 <= var && var < StackLocalCount());
+  int first_slot_index = Smi::cast(get(StackLocalFirstSlotIndex()))->value();
+  return first_slot_index + var;
+}
+
+
 String* ScopeInfo::ContextLocalName(int var) {
   DCHECK(0 <= var && var < ContextLocalCount());
   int info_index = ContextLocalNameEntriesIndex() + var;
   return String::cast(get(info_index));
 }
 
 
 VariableMode ScopeInfo::ContextLocalMode(int var) {
   DCHECK(0 <= var && var < ContextLocalCount());
   int info_index = ContextLocalInfoEntriesIndex() + var;
@@ skipping 54 matching lines @@
   bool ok = get(info_index)->ToInt32(&value);
   USE(ok);
   DCHECK(ok);
   return value;
 }
 
 
 int ScopeInfo::StackSlotIndex(String* name) {
   DCHECK(name->IsInternalizedString());
   if (length() > 0) {
+    int first_slot_index = Smi::cast(get(StackLocalFirstSlotIndex()))->value();
     int start = StackLocalEntriesIndex();
     int end = StackLocalEntriesIndex() + StackLocalCount();
     for (int i = start; i < end; ++i) {
       if (name == get(i)) {
-        return i - start;
+        return i - start + first_slot_index;
       }
     }
   }
   return -1;
 }
 
 
 int ScopeInfo::ContextSlotIndex(Handle<ScopeInfo> scope_info,
                                 Handle<String> name, VariableMode* mode,
                                 InitializationFlag* init_flag,
@@ skipping 85 matching lines @@
   Isolate* isolate = scope_info->GetIsolate();
   int local_count = scope_info->ContextLocalCount();
   if (local_count == 0) return true;
   // Fill all context locals to the context extension.
   int first_context_var = scope_info->StackLocalCount();
   int start = scope_info->ContextLocalNameEntriesIndex();
   for (int i = 0; i < local_count; ++i) {
     if (scope_info->LocalIsSynthetic(first_context_var + i)) continue;
     int context_index = Context::MIN_CONTEXT_SLOTS + i;
     Handle<Object> value = Handle<Object>(context->get(context_index), isolate);
-    // Do not reflect variables under TDZ in scope object.
+    // Reflect variables under TDZ as undefined in scope object.
     if (value->IsTheHole()) continue;
     RETURN_ON_EXCEPTION_VALUE(
         isolate, Runtime::DefineObjectProperty(
                      scope_object,
                      Handle<String>(String::cast(scope_info->get(i + start))),
                      value, ::NONE),
         false);
   }
   return true;
 }
 
 
 int ScopeInfo::ParameterEntriesIndex() {
   DCHECK(length() > 0);
   return kVariablePartIndex;
 }
 
 
+int ScopeInfo::StackLocalFirstSlotIndex() {
+  return ParameterEntriesIndex() + ParameterCount();
+}
+
+
 int ScopeInfo::StackLocalEntriesIndex() {
-  return ParameterEntriesIndex() + ParameterCount();
+  return StackLocalFirstSlotIndex() + 1;
 }
 
 
 int ScopeInfo::ContextLocalNameEntriesIndex() {
   return StackLocalEntriesIndex() + StackLocalCount();
 }
 
 
 int ScopeInfo::ContextLocalInfoEntriesIndex() {
   return ContextLocalNameEntriesIndex() + ContextLocalCount();
@@ skipping 156 matching lines @@
     info->set_name(i, *(it.export_name()->string()));
     info->set_mode(i, var->mode());
     DCHECK(var->index() >= 0);
     info->set_index(i, var->index());
   }
   DCHECK(i == info->length());
   return info;
 }
 
 } }  // namespace v8::internal