Group lexical context variables for faster look up.

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/bootstrapper.h"
 #include "src/scopeinfo.h"
@@ skipping 131 matching lines @@
   }
 
   // Add context globals' names.
   DCHECK(index == scope_info->ContextGlobalNameEntriesIndex());
   for (int i = 0; i < context_global_count; ++i) {
     scope_info->set(index++, *context_globals[i]->name());
   }
 
   // Add context locals' info.
   DCHECK(index == scope_info->ContextLocalInfoEntriesIndex());
+  bool encountered_lexical = false;
+  int lexical_context_local_count = 0;
   for (int i = 0; i < context_local_count; ++i) {
     Variable* var = context_locals[i];
     uint32_t value =
         ContextLocalMode::encode(var->mode()) |
         ContextLocalInitFlag::encode(var->initialization_flag()) |
         ContextLocalMaybeAssignedFlag::encode(var->maybe_assigned());
     scope_info->set(index++, Smi::FromInt(value));
+    if (encountered_lexical) {
+      // Check that context locals are sorted so that lexicals are at the end.
+      DCHECK(IsLexicalVariableMode(var->mode()));
+    } else if (IsLexicalVariableMode(var->mode())) {
+      lexical_context_local_count = context_local_count - i;
+    }
   }
 
+  scope_info->SetLexicalContextLocalCount(lexical_context_local_count);
+
   // Add context globals' info.
   DCHECK(index == scope_info->ContextGlobalInfoEntriesIndex());
   for (int i = 0; i < context_global_count; ++i) {
     Variable* var = context_globals[i];
     // TODO(ishell): do we need this kind of info for globals here?
     uint32_t value =
         ContextLocalMode::encode(var->mode()) |
         ContextLocalInitFlag::encode(var->initialization_flag()) |
         ContextLocalMaybeAssignedFlag::encode(var->maybe_assigned());
     scope_info->set(index++, Smi::FromInt(value));
@@ skipping 44 matching lines @@
           scope_info->ContextLength() == 0));
   return scope_info;
 }
 
 
 Handle<ScopeInfo> ScopeInfo::CreateGlobalThisBinding(Isolate* isolate) {
   DCHECK(isolate->bootstrapper()->IsActive());
 
   const int stack_local_count = 0;
   const int context_local_count = 1;
+  const int lexical_context_local_count = 1;
   const int context_global_count = 0;
   const int strong_mode_free_variable_count = 0;
   const bool simple_parameter_list = true;
   const VariableAllocationInfo receiver_info = CONTEXT;
   const VariableAllocationInfo function_name_info = NONE;
   const VariableMode function_variable_mode = VAR;
   const bool has_function_name = false;
   const bool has_receiver = true;
   const int parameter_count = 0;
   const int length = kVariablePartIndex + parameter_count +
@@ skipping 12 matching lines @@
               ReceiverVariableField::encode(receiver_info) |
               FunctionVariableField::encode(function_name_info) |
               FunctionVariableMode::encode(function_variable_mode) |
               AsmModuleField::encode(false) | AsmFunctionField::encode(false) |
               IsSimpleParameterListField::encode(simple_parameter_list) |
               FunctionKindField::encode(FunctionKind::kNormalFunction);
   scope_info->SetFlags(flags);
   scope_info->SetParameterCount(parameter_count);
   scope_info->SetStackLocalCount(stack_local_count);
   scope_info->SetContextLocalCount(context_local_count);
+  scope_info->SetLexicalContextLocalCount(lexical_context_local_count);
   scope_info->SetContextGlobalCount(context_global_count);
   scope_info->SetStrongModeFreeVariableCount(strong_mode_free_variable_count);
 
   int index = kVariablePartIndex;
   const int first_slot_index = 0;
   DCHECK(index == scope_info->StackLocalFirstSlotIndex());
   scope_info->set(index++, Smi::FromInt(first_slot_index));
   DCHECK(index == scope_info->StackLocalEntriesIndex());
 
   // Here we add info for context-allocated "this".
@@ skipping 298 matching lines @@
     // Cache as not found. Mode, location, init flag and maybe assigned flag
     // don't matter.
     context_slot_cache->Update(scope_info, name, TEMPORARY,
                                VariableLocation::CONTEXT, kNeedsInitialization,
                                kNotAssigned, -1);
   }
   return -1;
 }
 
 
+int ScopeInfo::LexicalContextSlotIndex(Handle<ScopeInfo> scope_info,
+                                       Handle<String> name) {
+  DCHECK(name->IsInternalizedString());
+  if (scope_info->length() > 0) {
+    // TODO(yangguo): consider using the context slot cache here.
+    int total_count = scope_info->ContextLocalCount();
+    int lexical_count = scope_info->LexicalContextLocalCount();
+    int non_lexical_count = total_count - lexical_count;
+
+    int start = scope_info->ContextLocalNameEntriesIndex();
+    int end = start + total_count;
+    int lexical_start = start + non_lexical_count;
+
+    for (int i = lexical_start; i < end; ++i) {
+      if (*name == scope_info->get(i)) {
+        int var = i - start;
+        DCHECK(IsLexicalVariableMode(scope_info->ContextLocalMode(var)));
+        return Context::MIN_CONTEXT_SLOTS + var;
+      }
+    }
+  }
+  return -1;
+}
+
+
 String* ScopeInfo::ContextSlotName(int slot_index) {
   int const var = slot_index - Context::MIN_CONTEXT_SLOTS;
   DCHECK_LE(0, var);
   DCHECK_LT(var, ContextLocalCount() + ContextGlobalCount());
   return ContextLocalName(var);
 }
 
 
 int ScopeInfo::ParameterIndex(String* name) {
   DCHECK(name->IsInternalizedString());
@@ skipping 245 matching lines @@
     info->set_mode(i, var->mode());
     DCHECK(var->index() >= 0);
     info->set_index(i, var->index());
   }
   DCHECK(i == info->length());
   return info;
 }
 
 }  // namespace internal
 }  // namespace v8