Refactored interface of FeedbackVectorSpec and friends.

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 18 matching lines @@
 void TypeFeedbackVector::SetKind(FeedbackVectorICSlot 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(
+    Isolate* isolate, const StaticFeedbackVectorSpec* spec);
+template Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(
     Isolate* isolate, const FeedbackVectorSpec* spec);
-template Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(
-    Isolate* isolate, const ZoneFeedbackVectorSpec* spec);
 
 
 // static
 template <typename Spec>
 Handle<TypeFeedbackVector> TypeFeedbackVector::Allocate(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()) +
@@ skipping 25 matching lines @@
   }
 
   Handle<TypeFeedbackVector> vector = Handle<TypeFeedbackVector>::cast(array);
   for (int i = 0; i < ic_slot_count; i++) {
     vector->SetKind(FeedbackVectorICSlot(i), spec->GetKind(i));
   }
   return vector;
 }
 
 
-template int TypeFeedbackVector::GetIndexFromSpec(const ZoneFeedbackVectorSpec*,
+template int TypeFeedbackVector::GetIndexFromSpec(const FeedbackVectorSpec*,
                                                   FeedbackVectorICSlot);
-template int TypeFeedbackVector::GetIndexFromSpec(const ZoneFeedbackVectorSpec*,
+template int TypeFeedbackVector::GetIndexFromSpec(const FeedbackVectorSpec*,
                                                   FeedbackVectorSlot);
 
 
 // static
 template <typename Spec>
 int TypeFeedbackVector::GetIndexFromSpec(const Spec* spec,
                                          FeedbackVectorSlot slot) {
   const int ic_slot_count = spec->ic_slots();
   const int index_count = VectorICComputer::word_count(ic_slot_count);
   return kReservedIndexCount + index_count + slot.ToInt();
@@ skipping 16 matching lines @@
 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};
-  FeedbackVectorSpec spec(0, 1, kinds);
+  StaticFeedbackVectorSpec spec(0, 1, kinds);
   Handle<TypeFeedbackVector> feedback_vector =
       isolate->factory()->NewTypeFeedbackVector(&spec);
   DCHECK(PushAppliedArgumentsIndex() ==
          feedback_vector->GetIndex(FeedbackVectorICSlot(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 ZoneFeedbackVectorSpec* other_spec) const {
+    const FeedbackVectorSpec* other_spec) const {
   if (other_spec->slots() != Slots() || other_spec->ic_slots() != ICSlots()) {
     return true;
   }
 
   int ic_slots = ICSlots();
   for (int i = 0; i < ic_slots; i++) {
     if (GetKind(FeedbackVectorICSlot(i)) != other_spec->GetKind(i)) {
       return true;
     }
   }
@@ skipping 674 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