Vector ICs: Introduce an InstanceType for the type 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/v8.h"
 
 #include "src/code-stubs.h"
 #include "src/ic/ic.h"
 #include "src/ic/ic-state.h"
 #include "src/objects.h"
@@ skipping 60 matching lines @@
 
 void TypeFeedbackVector::SetKind(FeedbackVectorICSlot slot, Code::Kind kind) {
   VectorICKind b = FromCodeKind(kind);
   int index = VectorICComputer::index(kReservedIndexCount, slot.ToInt());
   int data = Smi::cast(get(index))->value();
   int new_data = VectorICComputer::encode(data, slot.ToInt(), b);
   set(index, Smi::FromInt(new_data));
 }
 
 
-template Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(
-    Isolate* isolate, const FeedbackVectorSpec* spec);
-template Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(
-    Isolate* isolate, const ZoneFeedbackVectorSpec* spec);
+template int TypeFeedbackVector::SizeFor(const FeedbackVectorSpec* spec);
+template int TypeFeedbackVector::SizeFor(const ZoneFeedbackVectorSpec* spec);
+template void TypeFeedbackVector::Init(Isolate* isolate,
+                                       const FeedbackVectorSpec* spec);
+template void TypeFeedbackVector::Init(Isolate* isolate,
+                                       const ZoneFeedbackVectorSpec* spec);
 
 
 // static
 template <typename Spec>
-Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(Isolate* isolate,
-                                                        const Spec* spec) {
+int TypeFeedbackVector::SizeFor(const Spec* spec) {
+  const int slot_count = spec->slots();
+  const int ic_slot_count = spec->ic_slots();
+  // In this case, we'll use a sentinel, heap()->empty_feedback_vector().
+  if (slot_count == 0 && ic_slot_count == 0) {
+    return TypeFeedbackVector::kHeaderSize;
+  }
+  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;
+  return length * kPointerSize + TypeFeedbackVector::kHeaderSize;
+}
+
+
+template <typename Spec>
+void TypeFeedbackVector::Init(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;
-  if (length == kReservedIndexCount) {
-    return Handle<TypeFeedbackVector>::cast(
-        isolate->factory()->empty_fixed_array());
+
+  set_length(length);
+
+  // We shouldn't create one of these if we don't have useful information to
+  // store.
+  DCHECK(slot_count > 0 || ic_slot_count > 0);
+
+  if (ic_slot_count > 0) {
+    set(kFirstICSlotIndex,
+        Smi::FromInt(slot_count + index_count + kReservedIndexCount));
+  } else {
+    set(kFirstICSlotIndex, Smi::FromInt(length));
   }
-
-  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(kWithTypesIndex, Smi::FromInt(0));
-  array->set(kGenericCountIndex, Smi::FromInt(0));
+  set(kWithTypesIndex, Smi::FromInt(0));
+  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));
+    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);
+    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));
+    SetKind(FeedbackVectorICSlot(i), spec->GetKind(i));
   }
-  return 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)));
+  Handle<TypeFeedbackVector> result =
+      isolate->factory()->CopyTypeFeedbackVector(vector);
   return result;
 }
 
 
 bool TypeFeedbackVector::SpecDiffersFrom(
     const ZoneFeedbackVectorSpec* other_spec) const {
   if (other_spec->slots() != Slots() || other_spec->ic_slots() != ICSlots()) {
     return true;
   }
 
@@ skipping 533 matching lines @@
 void StoreICNexus::Clear(Code* host) {
   StoreIC::Clear(GetIsolate(), host, this);
 }
 
 
 void KeyedStoreICNexus::Clear(Code* host) {
   KeyedStoreIC::Clear(GetIsolate(), host, this);
 }
 }  // namespace internal
 }  // namespace v8