[ic] LoadGlobalIC caches PropertyCells in the feedback vector.

src/type-feedback-vector.cc

 // Copyright 2014 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 "src/type-feedback-vector.h"
 
 #include "src/code-stubs.h"
 #include "src/ic/ic.h"
 #include "src/ic/ic-state.h"
 #include "src/objects.h"
@@ skipping 161 matching lines @@
   if (length == kReservedIndexCount) {
     return Handle<TypeFeedbackVector>::cast(factory->empty_fixed_array());
   }
 
   Handle<FixedArray> array = factory->NewFixedArray(length, TENURED);
   array->set(kMetadataIndex, *metadata);
 
   // Ensure we can skip the write barrier
   Handle<Object> uninitialized_sentinel = UninitializedSentinel(isolate);
   DCHECK_EQ(*factory->uninitialized_symbol(), *uninitialized_sentinel);
-  for (int i = kReservedIndexCount; i < length; i++) {
-    array->set(i, *uninitialized_sentinel, SKIP_WRITE_BARRIER);
+  for (int i = 0; i < slot_count;) {
+    FeedbackVectorSlot slot(i);
+    FeedbackVectorSlotKind kind = metadata->GetKind(slot);
+    int index = TypeFeedbackVector::GetIndex(slot);
+    int entry_size = TypeFeedbackMetadata::GetSlotSize(kind);
+
+    Object* value;
+    if (FLAG_new_load_global_ic &&
+        kind == FeedbackVectorSlotKind::LOAD_GLOBAL_IC) {
+      value = *factory->empty_weak_cell();
+    } else {
+      value = *uninitialized_sentinel;
+    }
+    array->set(index, value, SKIP_WRITE_BARRIER);
+    for (int j = 1; j < entry_size; j++) {
+      array->set(index + j, *uninitialized_sentinel, SKIP_WRITE_BARRIER);
+    }
+    i += entry_size;
   }
-
   return Handle<TypeFeedbackVector>::cast(array);
 }
 
 
 // static
 int TypeFeedbackVector::GetIndexFromSpec(const FeedbackVectorSpec* spec,
                                          FeedbackVectorSlot slot) {
   return kReservedIndexCount + slot.ToInt();
 }
 
@@ skipping 245 matching lines @@
     return MONOMORPHIC;
   }
 
   return UNINITIALIZED;
 }
 
 InlineCacheState LoadGlobalICNexus::StateFromFeedback() const {
   Isolate* isolate = GetIsolate();
   Object* feedback = GetFeedback();
 
-  if (feedback == *TypeFeedbackVector::UninitializedSentinel(isolate)) {
-    return UNINITIALIZED;
-  } else if (feedback == *TypeFeedbackVector::MegamorphicSentinel(isolate)) {
-    return MEGAMORPHIC;
-  } else if (feedback == *TypeFeedbackVector::PremonomorphicSentinel(isolate)) {
-    return PREMONOMORPHIC;
-  } else if (feedback->IsFixedArray()) {
-    // Determine state purely by our structure, don't check if the maps are
-    // cleared.
-    return POLYMORPHIC;
-  } else if (feedback->IsWeakCell()) {
-    // Don't check if the map is cleared.
-    return MONOMORPHIC;
+  if (FLAG_new_load_global_ic) {
+    Object* extra = GetFeedbackExtra();
+    if (!WeakCell::cast(feedback)->cleared() ||
+        extra != *TypeFeedbackVector::UninitializedSentinel(isolate)) {
+      return MONOMORPHIC;
+    }
+
+  } else {
+    if (feedback == *TypeFeedbackVector::UninitializedSentinel(isolate)) {
+      return UNINITIALIZED;
+    } else if (feedback == *TypeFeedbackVector::MegamorphicSentinel(isolate)) {
+      return MEGAMORPHIC;
+    } else if (feedback ==
+               *TypeFeedbackVector::PremonomorphicSentinel(isolate)) {
+      return PREMONOMORPHIC;
+    } else if (feedback->IsFixedArray()) {
+      // Determine state purely by our structure, don't check if the maps are
+      // cleared.
+      return POLYMORPHIC;
+    } else if (feedback->IsWeakCell()) {
+      // Don't check if the map is cleared.
+      return MONOMORPHIC;
+    }
   }
-
   return UNINITIALIZED;
 }
 
 InlineCacheState KeyedLoadICNexus::StateFromFeedback() const {
   Isolate* isolate = GetIsolate();
   Object* feedback = GetFeedback();
 
   if (feedback == *TypeFeedbackVector::UninitializedSentinel(isolate)) {
     return UNINITIALIZED;
   } else if (feedback == *TypeFeedbackVector::PremonomorphicSentinel(isolate)) {
@@ skipping 135 matching lines @@
   SetFeedbackExtra(*handler);
 }
 
 void LoadGlobalICNexus::ConfigureMonomorphic(Handle<Map> receiver_map,
                                              Handle<Code> handler) {
   Handle<WeakCell> cell = Map::WeakCellForMap(receiver_map);
   SetFeedback(*cell);
   SetFeedbackExtra(*handler);
 }
 
+void LoadGlobalICNexus::ConfigureUninitialized() {
+  Isolate* isolate = GetIsolate();
+  SetFeedback(isolate->heap()->empty_weak_cell(), SKIP_WRITE_BARRIER);
+  SetFeedbackExtra(*TypeFeedbackVector::UninitializedSentinel(isolate),
+                   SKIP_WRITE_BARRIER);
+}
+
+void LoadGlobalICNexus::ConfigurePropertyCellMode(Handle<PropertyCell> cell) {
+  Isolate* isolate = GetIsolate();
+  SetFeedback(*isolate->factory()->NewWeakCell(cell));
+  SetFeedbackExtra(*TypeFeedbackVector::UninitializedSentinel(isolate),
+                   SKIP_WRITE_BARRIER);
+}
+
+void LoadGlobalICNexus::ConfigureHandlerMode(Handle<Code> handler) {
+  SetFeedback(GetIsolate()->heap()->empty_weak_cell());
+  SetFeedbackExtra(*handler);
+}
+
 void KeyedLoadICNexus::ConfigureMonomorphic(Handle<Name> name,
                                             Handle<Map> receiver_map,
                                             Handle<Code> handler) {
   Handle<WeakCell> cell = Map::WeakCellForMap(receiver_map);
   if (name.is_null()) {
     SetFeedback(*cell);
     SetFeedbackExtra(*handler);
   } else {
     Handle<FixedArray> array = EnsureExtraArrayOfSize(2);
     SetFeedback(*name);
@@ skipping 305 matching lines @@
 
 IcCheckType KeyedStoreICNexus::GetKeyType() const {
   Object* feedback = GetFeedback();
   if (feedback == *TypeFeedbackVector::MegamorphicSentinel(GetIsolate())) {
     return static_cast<IcCheckType>(Smi::cast(GetFeedbackExtra())->value());
   }
   return IsPropertyNameFeedback(feedback) ? PROPERTY : ELEMENT;
 }
 }  // namespace internal
 }  // namespace v8