Remove some unnecessary binding initialization checks.

src/scopeinfo.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 130 matching lines @@
   // 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(&CompareLocal);
 
   // Add context locals' names.
   ASSERT(index == scope_info->ContextLocalNameEntriesIndex());
   for (int i = 0; i < num_context_locals; ++i) {
     scope_info->set(index++, *context_locals[i]->name());
   }
 
-  // Add context locals' modes.
-  ASSERT(index == scope_info->ContextLocalModeEntriesIndex());
+  // Add context locals' info.
+  ASSERT(index == scope_info->ContextLocalInfoEntriesIndex());
   for (int i = 0; i < num_context_locals; ++i) {
-    scope_info->set(index++, Smi::FromInt(context_locals[i]->mode()));
+    Variable* var = context_locals[i];
+    uint32_t value = ContextLocalMode::encode(var->mode()) |
+        ContextLocalInitFlag::encode(var->initialization_flag());
+    scope_info->set(index++, Smi::FromInt(value));
   }
 
   // If present, add the function variable name and its index.
   ASSERT(index == scope_info->FunctionNameEntryIndex());
   if (has_function_name) {
     int var_index = scope->function()->var()->index();
     scope_info->set(index++, *scope->function()->name());
     scope_info->set(index++, Smi::FromInt(var_index));
     ASSERT(function_name_info != STACK ||
            (var_index == scope_info->num_stack_locals() &&
@@ skipping 133 matching lines @@
 
 Handle<String> ScopeInfo::context_local_name(int var) {
   ASSERT(0 <= var && var < num_context_locals());
   int info_index = ContextLocalNameEntriesIndex() + var;
   return Handle<String>(String::cast(get(info_index)));
 }
 
 
 VariableMode ScopeInfo::context_local_mode(int var) {
   ASSERT(0 <= var && var < num_context_locals());
-  int info_index = ContextLocalModeEntriesIndex() + var;
-  return static_cast<VariableMode>(Smi::cast(get(info_index))->value());
+  int info_index = ContextLocalInfoEntriesIndex() + var;
+  int value = Smi::cast(get(info_index))->value();
+  return ContextLocalMode::decode(value);
 }
 
 
+InitializationFlag ScopeInfo::context_local_init_flag(int var) {
+  ASSERT(0 <= var && var < num_context_locals());
+  int info_index = ContextLocalInfoEntriesIndex() + var;
+  int value = Smi::cast(get(info_index))->value();
+  return ContextLocalInitFlag::decode(value);
+}
+
+
 int ScopeInfo::StackSlotIndex(String* name) {
   ASSERT(name->IsSymbol());
   if (length() > 0) {
     int start = StackLocalEntriesIndex();
     int end = StackLocalEntriesIndex() + num_stack_locals();
     for (int i = start; i < end; ++i) {
       if (name == get(i)) {
         return i - start;
       }
     }
   }
   return -1;
 }
 
 
-int ScopeInfo::ContextSlotIndex(String* name, VariableMode* mode) {
+int ScopeInfo::ContextSlotIndex(String* name,
+                                VariableMode* mode,
+                                InitializationFlag* init_flag) {
   ASSERT(name->IsSymbol());
   if (length() > 0) {
     ContextSlotCache* context_slot_cache = GetIsolate()->context_slot_cache();
-    int result = context_slot_cache->Lookup(this, name, mode);
+    int result = context_slot_cache->Lookup(this, name, mode, init_flag);
     if (result != ContextSlotCache::kNotFound) {
       ASSERT(result < NumberOfContextSlots());
       return result;
     }
 
     int start = ContextLocalNameEntriesIndex();
     int end = ContextLocalNameEntriesIndex() + num_context_locals();
     for (int i = start; i < end; ++i) {
       if (name == get(i)) {
         int var = i - start;
         VariableMode mode_value = context_local_mode(var);
+        InitializationFlag init_flag_value = context_local_init_flag(var);
         if (mode != NULL) *mode = mode_value;
+        if (init_flag != NULL) *init_flag = init_flag_value;
         result = Context::MIN_CONTEXT_SLOTS + var;
-        context_slot_cache->Update(this, name, mode_value, result);
+        context_slot_cache->Update(
+            this, name, mode_value, init_flag_value, result);
         ASSERT(result < NumberOfContextSlots());
         return result;
       }
     }
-    context_slot_cache->Update(this, name, INTERNAL, -1);
+    context_slot_cache->Update(this, name, INTERNAL, NEEDS_INITIALIZATION, -1);
   }
   return -1;
 }
 
 
 int ScopeInfo::ParameterIndex(String* name) {
   ASSERT(name->IsSymbol());
   if (length() > 0) {
     // We must read parameters from the end since for
     // multiply declared parameters the value of the
@@ skipping 34 matching lines @@
 int ScopeInfo::StackLocalEntriesIndex() {
   return ParameterEntriesIndex() + num_parameters();
 }
 
 
 int ScopeInfo::ContextLocalNameEntriesIndex() {
   return StackLocalEntriesIndex() + num_stack_locals();
 }
 
 
-int ScopeInfo::ContextLocalModeEntriesIndex() {
+int ScopeInfo::ContextLocalInfoEntriesIndex() {
   return ContextLocalNameEntriesIndex() + num_context_locals();
 }
 
 
 int ScopeInfo::FunctionNameEntryIndex() {
-  return ContextLocalModeEntriesIndex() + num_context_locals();
+  return ContextLocalInfoEntriesIndex() + num_context_locals();
 }
 
 
 int ContextSlotCache::Hash(Object* data, String* name) {
   // Uses only lower 32 bits if pointers are larger.
   uintptr_t addr_hash =
       static_cast<uint32_t>(reinterpret_cast<uintptr_t>(data)) >> 2;
   return static_cast<int>((addr_hash ^ name->Hash()) % kLength);
 }
 
 
 int ContextSlotCache::Lookup(Object* data,
                              String* name,
-                             VariableMode* mode) {
+                             VariableMode* mode,
+                             InitializationFlag* init_flag) {
   int index = Hash(data, name);
   Key& key = keys_[index];
   if ((key.data == data) && key.name->Equals(name)) {
     Value result(values_[index]);
     if (mode != NULL) *mode = result.mode();
+    if (init_flag != NULL) *init_flag = result.initialization_flag();
     return result.index() + kNotFound;
   }
   return kNotFound;
 }
 
 
 void ContextSlotCache::Update(Object* data,
                               String* name,
                               VariableMode mode,
+                              InitializationFlag init_flag,
                               int slot_index) {
   String* symbol;
   ASSERT(slot_index > kNotFound);
   if (HEAP->LookupSymbolIfExists(name, &symbol)) {
     int index = Hash(data, symbol);
     Key& key = keys_[index];
     key.data = data;
     key.name = symbol;
     // Please note value only takes a uint as index.
-    values_[index] = Value(mode, slot_index - kNotFound).raw();
+    values_[index] = Value(mode, init_flag, slot_index - kNotFound).raw();
 #ifdef DEBUG
-    ValidateEntry(data, name, mode, slot_index);
+    ValidateEntry(data, name, mode, init_flag, slot_index);
 #endif
   }
 }
 
 
 void ContextSlotCache::Clear() {
   for (int index = 0; index < kLength; index++) keys_[index].data = NULL;
 }
 
 
 #ifdef DEBUG
 
 void ContextSlotCache::ValidateEntry(Object* data,
                                      String* name,
                                      VariableMode mode,
+                                     InitializationFlag init_flag,
                                      int slot_index) {
   String* symbol;
   if (HEAP->LookupSymbolIfExists(name, &symbol)) {
     int index = Hash(data, name);
     Key& key = keys_[index];
     ASSERT(key.data == data);
     ASSERT(key.name->Equals(name));
     Value result(values_[index]);
     ASSERT(result.mode() == mode);
+    ASSERT(result.initialization_flag() == init_flag);
     ASSERT(result.index() + kNotFound == slot_index);
   }
 }
 
 
 static void PrintList(const char* list_name,
                       int nof_internal_slots,
                       int start,
                       int end,
                       ScopeInfo* scope_info) {
@@ skipping 32 matching lines @@
             Context::MIN_CONTEXT_SLOTS,
             ContextLocalNameEntriesIndex(),
             ContextLocalNameEntriesIndex() + num_context_locals(),
             this);
 
   PrintF("}\n");
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal