Distinction between FeedbackVectorICSlot and FeedbackVectorSlot eliminated.

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"
 #include "src/type-feedback-vector-inl.h"
 
 namespace v8 {
 namespace internal {
 
 std::ostream& operator<<(std::ostream& os, FeedbackVectorSlotKind kind) {
   return os << TypeFeedbackVector::Kind2String(kind);
 }
 
 
 FeedbackVectorSlotKind TypeFeedbackVector::GetKind(
-    FeedbackVectorICSlot slot) const {
+    FeedbackVectorSlot slot) const {
   int index = VectorICComputer::index(kReservedIndexCount, slot.ToInt());
   int data = Smi::cast(get(index))->value();
   return VectorICComputer::decode(data, slot.ToInt());
 }
 
 
-void TypeFeedbackVector::SetKind(FeedbackVectorICSlot slot,
+void TypeFeedbackVector::SetKind(FeedbackVectorSlot slot,
                                  FeedbackVectorSlotKind kind) {
   int index = VectorICComputer::index(kReservedIndexCount, slot.ToInt());
   int data = Smi::cast(get(index))->value();
   int new_data = VectorICComputer::encode(data, slot.ToInt(), kind);
   set(index, Smi::FromInt(new_data));
 }
 
 
-template Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(
+template Handle<TypeFeedbackVector> TypeFeedbackVector::New(
     Isolate* isolate, const StaticFeedbackVectorSpec* spec);
-template Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(
+template Handle<TypeFeedbackVector> TypeFeedbackVector::New(
     Isolate* isolate, const FeedbackVectorSpec* spec);
 
 
 // static
 template <typename Spec>
-Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(Isolate* isolate,
-                                                        const Spec* spec) {
+Handle<TypeFeedbackVector> TypeFeedbackVector::New(Isolate* isolate,
+                                                   const Spec* spec) {
   const int slot_count = spec->slots();
-  const int ic_slot_count = spec->ic_slots();
-  const int index_count = VectorICComputer::word_count(ic_slot_count);
-  const int length = slot_count + (ic_slot_count * elements_per_ic_slot()) +
-                     index_count + kReservedIndexCount;
+  const int index_count = VectorICComputer::word_count(slot_count);
+  const int length = slot_count + index_count + kReservedIndexCount;
   if (length == kReservedIndexCount) {
     return Handle<TypeFeedbackVector>::cast(
         isolate->factory()->empty_fixed_array());
   }
+#ifdef DEBUG
+  for (int i = 0; i < slot_count;) {
+    FeedbackVectorSlotKind kind = spec->GetKind(i);
+    int entry_size = TypeFeedbackVector::GetSlotSize(kind);
+    for (int j = 1; j < entry_size; j++) {
+      FeedbackVectorSlotKind kind = spec->GetKind(i + j);
+      DCHECK_EQ(FeedbackVectorSlotKind::INVALID, kind);
+    }
+    i += entry_size;
+  }
+#endif
 
   Handle<FixedArray> array = isolate->factory()->NewFixedArray(length, TENURED);
-  if (ic_slot_count > 0) {
-    array->set(kFirstICSlotIndex,
-               Smi::FromInt(slot_count + index_count + kReservedIndexCount));
-  } else {
-    array->set(kFirstICSlotIndex, Smi::FromInt(length));
-  }
+  array->set(kSlotsCountIndex, Smi::FromInt(slot_count));
   array->set(kWithTypesIndex, Smi::FromInt(0));
   array->set(kGenericCountIndex, Smi::FromInt(0));
   // Fill the indexes with zeros.
   for (int i = 0; i < index_count; i++) {
     array->set(kReservedIndexCount + i, Smi::FromInt(0));
   }
 
   // Ensure we can skip the write barrier
   Handle<Object> uninitialized_sentinel = UninitializedSentinel(isolate);
   DCHECK_EQ(isolate->heap()->uninitialized_symbol(), *uninitialized_sentinel);
   for (int i = kReservedIndexCount + index_count; i < length; i++) {
     array->set(i, *uninitialized_sentinel, SKIP_WRITE_BARRIER);
   }
 
   Handle<TypeFeedbackVector> vector = Handle<TypeFeedbackVector>::cast(array);
-  for (int i = 0; i < ic_slot_count; i++) {
-    vector->SetKind(FeedbackVectorICSlot(i), spec->GetKind(i));
+  for (int i = 0; i < slot_count; i++) {
+    vector->SetKind(FeedbackVectorSlot(i), spec->GetKind(i));
   }
   return vector;
 }
 
 
-template int TypeFeedbackVector::GetIndexFromSpec(const FeedbackVectorSpec*,
-                                                  FeedbackVectorICSlot);
-template int TypeFeedbackVector::GetIndexFromSpec(const FeedbackVectorSpec*,
-                                                  FeedbackVectorSlot);
-
-
 // static
-template <typename Spec>
-int TypeFeedbackVector::GetIndexFromSpec(const Spec* spec,
+int TypeFeedbackVector::GetIndexFromSpec(const FeedbackVectorSpec* spec,
                                          FeedbackVectorSlot slot) {
-  const int ic_slot_count = spec->ic_slots();
-  const int index_count = VectorICComputer::word_count(ic_slot_count);
+  const int slot_count = spec->slots();
+  const int index_count = VectorICComputer::word_count(slot_count);
   return kReservedIndexCount + index_count + slot.ToInt();
 }
 
 
-// static
-template <typename Spec>
-int TypeFeedbackVector::GetIndexFromSpec(const Spec* spec,
-                                         FeedbackVectorICSlot slot) {
-  const int slot_count = spec->slots();
-  const int ic_slot_count = spec->ic_slots();
-  const int index_count = VectorICComputer::word_count(ic_slot_count);
-  return kReservedIndexCount + index_count + slot_count +
-         slot.ToInt() * elements_per_ic_slot();
-}
-
-
 // static
 int TypeFeedbackVector::PushAppliedArgumentsIndex() {
   const int index_count = VectorICComputer::word_count(1);
   return kReservedIndexCount + index_count;
 }
 
 
 // static
 Handle<TypeFeedbackVector> TypeFeedbackVector::CreatePushAppliedArgumentsVector(
     Isolate* isolate) {
-  FeedbackVectorSlotKind kinds[] = {FeedbackVectorSlotKind::KEYED_LOAD_IC};
-  StaticFeedbackVectorSpec spec(0, 1, kinds);
+  FeedbackVectorSlotKind kinds[] = {FeedbackVectorSlotKind::KEYED_LOAD_IC,
+                                    FeedbackVectorSlotKind::INVALID};
+  StaticFeedbackVectorSpec spec(arraysize(kinds), kinds);

[mvstanton, 2015/10/01 10:24:31]

This confused me a minute, but then I see what you are doing - you are laying
out the actual words instead of speaking in terms of slots.

It seems like a mismatch - also over in heap.cc you have to do that.

Is it possible, to take the kinds[] input as slots instead of a specification
for the detailed layout of those slots?

It leaks information about the internal layout and exact size of each kind of ic
slot. It'd be better to hide the fact that for a KEYED_LOAD_IC slot, it's second
(and third, etc.) words will be coded as INVALID.

As an example, you'd have

FVSK kinds[] = {FVSK::KEYED_LOAD_IC, FVSK::GENERIC,
                FVSK::KEYED_LOAD_IC};
...

[Igor Sheludko, 2015/10/01 12:46:29]

I remade StaticFeedbackVectorSpec to be less confusing.

   Handle<TypeFeedbackVector> feedback_vector =
-      isolate->factory()->NewTypeFeedbackVector(&spec);
+      TypeFeedbackVector::New(isolate, &spec);
   DCHECK(PushAppliedArgumentsIndex() ==
-         feedback_vector->GetIndex(FeedbackVectorICSlot(0)));
+         feedback_vector->GetIndex(FeedbackVectorSlot(0)));
   return feedback_vector;
 }
 
 
 // static
 Handle<TypeFeedbackVector> TypeFeedbackVector::Copy(
     Isolate* isolate, Handle<TypeFeedbackVector> vector) {
   Handle<TypeFeedbackVector> result;
   result = Handle<TypeFeedbackVector>::cast(
       isolate->factory()->CopyFixedArray(Handle<FixedArray>::cast(vector)));
   return result;
 }
 
 
 bool TypeFeedbackVector::SpecDiffersFrom(
     const FeedbackVectorSpec* other_spec) const {
-  if (other_spec->slots() != Slots() || other_spec->ic_slots() != ICSlots()) {
+  if (other_spec->slots() != Slots()) {
     return true;
   }
 
-  int ic_slots = ICSlots();
-  for (int i = 0; i < ic_slots; i++) {
-    if (GetKind(FeedbackVectorICSlot(i)) != other_spec->GetKind(i)) {
+  int slots = Slots();
+  for (int i = 0; i < slots; i++) {
+    if (GetKind(FeedbackVectorSlot(i)) != other_spec->GetKind(i)) {
       return true;
     }
   }
   return false;
 }
 
 
 // This logic is copied from
 // StaticMarkingVisitor<StaticVisitor>::VisitCodeTarget.
-static bool ClearLogic(Heap* heap) {
-  return FLAG_cleanup_code_caches_at_gc &&
-         heap->isolate()->serializer_enabled();
+static bool ClearLogic(Isolate* isolate) {
+  return FLAG_cleanup_code_caches_at_gc && isolate->serializer_enabled();
 }
 
 
 void TypeFeedbackVector::ClearSlotsImpl(SharedFunctionInfo* shared,
                                         bool force_clear) {
-  int slots = Slots();
-  Heap* heap = GetIsolate()->heap();
+  Isolate* isolate = GetIsolate();
 
-  if (!force_clear && !ClearLogic(heap)) return;
+  if (!force_clear && !ClearLogic(isolate)) return;
 
   Object* uninitialized_sentinel =
-      TypeFeedbackVector::RawUninitializedSentinel(heap);
-  for (int i = 0; i < slots; i++) {
-    FeedbackVectorSlot slot(i);
-    Object* obj = Get(slot);
-    if (obj->IsHeapObject()) {
-      InstanceType instance_type =
-          HeapObject::cast(obj)->map()->instance_type();
-      // AllocationSites are exempt from clearing. They don't store Maps
-      // or Code pointers which can cause memory leaks if not cleared
-      // regularly.
-      if (instance_type != ALLOCATION_SITE_TYPE) {
-        Set(slot, uninitialized_sentinel, SKIP_WRITE_BARRIER);
-      }
-    }
-  }
-}
+      TypeFeedbackVector::RawUninitializedSentinel(isolate);
 
+  TypeFeedbackMetadataIterator iter(this);

[mvstanton, 2015/10/01 10:24:31]

This iterator is pretty cool!

+  while (iter.HasNext()) {
+    FeedbackVectorSlot slot = iter.Next();
+    FeedbackVectorSlotKind kind = iter.kind();
 
-void TypeFeedbackVector::ClearICSlotsImpl(SharedFunctionInfo* shared,
-                                          bool force_clear) {
-  Heap* heap = GetIsolate()->heap();
-
-  if (!force_clear && !ClearLogic(heap)) return;
-
-  int slots = ICSlots();
-  Code* host = shared->code();
-  Object* uninitialized_sentinel =
-      TypeFeedbackVector::RawUninitializedSentinel(heap);
-  for (int i = 0; i < slots; i++) {
-    FeedbackVectorICSlot slot(i);
     Object* obj = Get(slot);
     if (obj != uninitialized_sentinel) {
-      FeedbackVectorSlotKind kind = GetKind(slot);
       switch (kind) {
         case FeedbackVectorSlotKind::CALL_IC: {
           CallICNexus nexus(this, slot);
-          nexus.Clear(host);
+          nexus.Clear(shared->code());
           break;
         }
         case FeedbackVectorSlotKind::LOAD_IC: {
           LoadICNexus nexus(this, slot);
-          nexus.Clear(host);
+          nexus.Clear(shared->code());
           break;
         }
         case FeedbackVectorSlotKind::KEYED_LOAD_IC: {
           KeyedLoadICNexus nexus(this, slot);
-          nexus.Clear(host);
+          nexus.Clear(shared->code());
           break;
         }
         case FeedbackVectorSlotKind::STORE_IC: {
           DCHECK(FLAG_vector_stores);
           StoreICNexus nexus(this, slot);
-          nexus.Clear(host);
+          nexus.Clear(shared->code());
           break;
         }
         case FeedbackVectorSlotKind::KEYED_STORE_IC: {
           DCHECK(FLAG_vector_stores);
           KeyedStoreICNexus nexus(this, slot);
-          nexus.Clear(host);
+          nexus.Clear(shared->code());
           break;
         }
-        case FeedbackVectorSlotKind::UNUSED:
+        case FeedbackVectorSlotKind::STUB: {
+          if (obj->IsHeapObject()) {
+            InstanceType instance_type =
+                HeapObject::cast(obj)->map()->instance_type();
+            // AllocationSites are exempt from clearing. They don't store Maps
+            // or Code pointers which can cause memory leaks if not cleared
+            // regularly.
+            if (instance_type != ALLOCATION_SITE_TYPE) {
+              Set(slot, uninitialized_sentinel, SKIP_WRITE_BARRIER);
+            }
+          }
+          break;
+        }
+        case FeedbackVectorSlotKind::INVALID:
         case FeedbackVectorSlotKind::KINDS_NUMBER:
           UNREACHABLE();
           break;
       }
     }
   }
 }
 
 
 // static
 void TypeFeedbackVector::ClearAllKeyedStoreICs(Isolate* isolate) {
   DCHECK(FLAG_vector_stores);
   SharedFunctionInfo::Iterator iterator(isolate);
   SharedFunctionInfo* shared;
   while ((shared = iterator.Next())) {
     TypeFeedbackVector* vector = shared->feedback_vector();
     vector->ClearKeyedStoreICs(shared);
   }
 }
 
 
 void TypeFeedbackVector::ClearKeyedStoreICs(SharedFunctionInfo* shared) {
-  Heap* heap = GetIsolate()->heap();
+  Isolate* isolate = GetIsolate();
 
-  int slots = ICSlots();
   Code* host = shared->code();
   Object* uninitialized_sentinel =
-      TypeFeedbackVector::RawUninitializedSentinel(heap);
-  for (int i = 0; i < slots; i++) {
-    FeedbackVectorICSlot slot(i);
+      TypeFeedbackVector::RawUninitializedSentinel(isolate);
+
+  TypeFeedbackMetadataIterator iter(this);
+  while (iter.HasNext()) {
+    FeedbackVectorSlot slot = iter.Next();
+    FeedbackVectorSlotKind kind = iter.kind();
+    if (kind != FeedbackVectorSlotKind::KEYED_STORE_IC) continue;
     Object* obj = Get(slot);
     if (obj != uninitialized_sentinel) {
-      FeedbackVectorSlotKind kind = GetKind(slot);
-      if (kind == FeedbackVectorSlotKind::KEYED_STORE_IC) {
-        DCHECK(FLAG_vector_stores);
-        KeyedStoreICNexus nexus(this, slot);
-        nexus.Clear(host);
-      }
+      DCHECK(FLAG_vector_stores);
+      KeyedStoreICNexus nexus(this, slot);
+      nexus.Clear(host);
     }
   }
 }
 
 
 // static
 Handle<TypeFeedbackVector> TypeFeedbackVector::DummyVector(Isolate* isolate) {
   return Handle<TypeFeedbackVector>::cast(isolate->factory()->dummy_vector());
 }
 
 
 const char* TypeFeedbackVector::Kind2String(FeedbackVectorSlotKind kind) {
   switch (kind) {
-    case FeedbackVectorSlotKind::UNUSED:
-      return "UNUSED";
+    case FeedbackVectorSlotKind::INVALID:
+      return "INVALID";
     case FeedbackVectorSlotKind::CALL_IC:
       return "CALL_IC";
     case FeedbackVectorSlotKind::LOAD_IC:
       return "LOAD_IC";
     case FeedbackVectorSlotKind::KEYED_LOAD_IC:
       return "KEYED_LOAD_IC";
     case FeedbackVectorSlotKind::STORE_IC:
       return "STORE_IC";
     case FeedbackVectorSlotKind::KEYED_STORE_IC:
       return "KEYED_STORE_IC";
+    case FeedbackVectorSlotKind::STUB:
+      return "STUB";
     case FeedbackVectorSlotKind::KINDS_NUMBER:
       break;
   }
   UNREACHABLE();
   return "?";
 }
 
 
 Handle<FixedArray> FeedbackNexus::EnsureArrayOfSize(int length) {
   Isolate* isolate = GetIsolate();
@@ skipping 519 matching lines @@
   return mode;
 }
 
 
 IcCheckType KeyedStoreICNexus::GetKeyType() const {
   // The structure of the vector slots tells us the type.
   return GetFeedback()->IsName() ? PROPERTY : ELEMENT;
 }
 }  // namespace internal
 }  // namespace v8