ContextSlotCache::Update() handlified.

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 "v8.h"
 
 #include "scopeinfo.h"
 #include "scopes.h"
@@ skipping 289 matching lines @@
 
     int start = scope_info->ContextLocalNameEntriesIndex();
     int end = scope_info->ContextLocalNameEntriesIndex() +
         scope_info->ContextLocalCount();
     for (int i = start; i < end; ++i) {
       if (*name == scope_info->get(i)) {
         int var = i - start;
         *mode = scope_info->ContextLocalMode(var);
         *init_flag = scope_info->ContextLocalInitFlag(var);
         result = Context::MIN_CONTEXT_SLOTS + var;
-        context_slot_cache->Update(
-            *scope_info, *name, *mode, *init_flag, result);
+        context_slot_cache->Update(scope_info, name, *mode, *init_flag, result);
         ASSERT(result < scope_info->ContextLength());
         return result;
       }
     }
     // Cache as not found. Mode and init flag don't matter.
     context_slot_cache->Update(
-        *scope_info, *name, INTERNAL, kNeedsInitialization, -1);
+        scope_info, name, INTERNAL, kNeedsInitialization, -1);
   }
   return -1;
 }
 
 
 int ScopeInfo::ParameterIndex(String* name) {
   ASSERT(name->IsInternalizedString());
   if (length() > 0) {
     // We must read parameters from the end since for
     // multiply declared parameters the value of the
@@ skipping 96 matching lines @@
   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,
+void ContextSlotCache::Update(Handle<Object> data,
+                              Handle<String> name,
                               VariableMode mode,
                               InitializationFlag init_flag,
                               int slot_index) {
   String* internalized_name;

[Yang, 2014/04/30 15:14:26]

Also add DisallowHeapAllocation scopes in all those methods.

[Igor Sheludko, 2014/04/30 17:02:13]

Done.

   ASSERT(slot_index > kNotFound);
   if (name->GetIsolate()->heap()->InternalizeStringIfExists(
-          name, &internalized_name)) {
-    int index = Hash(data, internalized_name);
+          *name, &internalized_name)) {
+    int index = Hash(*data, internalized_name);
     Key& key = keys_[index];
-    key.data = data;
+    key.data = *data;
     key.name = internalized_name;
     // Please note value only takes a uint as index.
     values_[index] = Value(mode, init_flag, slot_index - kNotFound).raw();
 #ifdef DEBUG
     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,
+void ContextSlotCache::ValidateEntry(Handle<Object> data,
+                                     Handle<String> name,
                                      VariableMode mode,
                                      InitializationFlag init_flag,
                                      int slot_index) {
   String* internalized_name;
   if (name->GetIsolate()->heap()->InternalizeStringIfExists(
-          name, &internalized_name)) {
-    int index = Hash(data, name);
+          *name, &internalized_name)) {
+    int index = Hash(*data, *name);
     Key& key = keys_[index];
-    ASSERT(key.data == data);
-    ASSERT(key.name->Equals(name));
+    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,
@@ skipping 63 matching lines @@
     } else {
       ASSERT(var->index() >= 0);
       info->set_index(i, var->index());
     }
   }
   ASSERT(i == info->length());
   return info;
 }
 
 } }  // namespace v8::internal