Refactored interface of FeedbackVectorSpec and friends.

src/type-feedback-vector.h

 // 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.
 
 #ifndef V8_TYPE_FEEDBACK_VECTOR_H_
 #define V8_TYPE_FEEDBACK_VECTOR_H_
 
 #include <vector>
 
 #include "src/checks.h"
@@ skipping 15 matching lines @@
   STORE_IC,
   KEYED_STORE_IC,
 
   KINDS_NUMBER  // Last value indicating number of kinds.
 };
 
 
 std::ostream& operator<<(std::ostream& os, FeedbackVectorSlotKind kind);
 
 
-class FeedbackVectorSpec {
+class StaticFeedbackVectorSpec {
  public:
-  FeedbackVectorSpec() : slots_(0), ic_slots_(0), ic_kinds_(NULL) {}
-  explicit FeedbackVectorSpec(int slots)
-      : slots_(slots), ic_slots_(0), ic_kinds_(NULL) {}
-  FeedbackVectorSpec(int slots, int ic_slots,
-                     FeedbackVectorSlotKind* ic_slot_kinds)
+  StaticFeedbackVectorSpec() : slots_(0), ic_slots_(0), ic_kinds_(NULL) {}
+  StaticFeedbackVectorSpec(int slots, int ic_slots,
+                           FeedbackVectorSlotKind* ic_slot_kinds)
       : slots_(slots), ic_slots_(ic_slots), ic_kinds_(ic_slot_kinds) {}
 
   int slots() const { return slots_; }
 
   int ic_slots() const { return ic_slots_; }
 
   FeedbackVectorSlotKind GetKind(int ic_slot) const {
     DCHECK(ic_slots_ > 0 && ic_slot < ic_slots_);
     return ic_kinds_[ic_slot];
   }
 
  private:
   int slots_;
   int ic_slots_;
   FeedbackVectorSlotKind* ic_kinds_;
 };
 
 
-class ZoneFeedbackVectorSpec {
+class FeedbackVectorSpec {
  public:
-  explicit ZoneFeedbackVectorSpec(Zone* zone)
+  explicit FeedbackVectorSpec(Zone* zone)
       : slots_(0), ic_slots_(0), ic_slot_kinds_(zone) {}
 
-  ZoneFeedbackVectorSpec(Zone* zone, int slots, int ic_slots)
-      : slots_(slots), ic_slots_(ic_slots), ic_slot_kinds_(ic_slots, zone) {}
-
   int slots() const { return slots_; }
-  void increase_slots(int count) { slots_ += count; }
+  void increase_slots(int count) {
+    DCHECK_LT(0, count);
+    slots_ += count;
+  }
 
   int ic_slots() const { return ic_slots_; }
   void increase_ic_slots(int count) {
+    DCHECK_LT(0, count);
     ic_slots_ += count;
     ic_slot_kinds_.resize(ic_slots_);
   }
 
-  void SetKind(int ic_slot, FeedbackVectorSlotKind kind) {
-    ic_slot_kinds_[ic_slot] = static_cast<unsigned char>(kind);
+  FeedbackVectorICSlot AddSlot(FeedbackVectorSlotKind kind) {
+    int slot = ic_slots_;
+    increase_ic_slots(1);
+    ic_slot_kinds_[slot] = static_cast<unsigned char>(kind);
+    return FeedbackVectorICSlot(slot);
+  }
+
+  FeedbackVectorICSlot AddSlots(FeedbackVectorSlotKind kind, int count) {
+    int slot = ic_slots_;
+    increase_ic_slots(count);
+    for (int i = 0; i < count; i++) {
+      ic_slot_kinds_[slot + i] = static_cast<unsigned char>(kind);
+    }
+    return FeedbackVectorICSlot(slot);
+  }
+
+  FeedbackVectorICSlot AddCallICSlot() {
+    return AddSlot(FeedbackVectorSlotKind::CALL_IC);
+  }
+
+  FeedbackVectorICSlot AddLoadICSlot() {
+    return AddSlot(FeedbackVectorSlotKind::LOAD_IC);
+  }
+
+  FeedbackVectorICSlot AddLoadICSlots(int count) {
+    return AddSlots(FeedbackVectorSlotKind::LOAD_IC, count);
+  }
+
+  FeedbackVectorICSlot AddKeyedLoadICSlot() {
+    return AddSlot(FeedbackVectorSlotKind::KEYED_LOAD_IC);
+  }
+
+  FeedbackVectorICSlot AddStoreICSlots(int count) {
+    return AddSlots(FeedbackVectorSlotKind::STORE_IC, count);
+  }
+
+  FeedbackVectorSlot AddStubSlot() {
+    int slot = slots_;
+    increase_slots(1);
+    return FeedbackVectorSlot(slot);
+  }
+
+  FeedbackVectorSlot AddStubSlots(int count) {
+    int slot = slots_;
+    increase_slots(count);
+    return FeedbackVectorSlot(slot);
   }
 
   FeedbackVectorSlotKind GetKind(int ic_slot) const {
     return static_cast<FeedbackVectorSlotKind>(ic_slot_kinds_.at(ic_slot));
   }
 
  private:
   int slots_;
   int ic_slots_;
   ZoneVector<unsigned char> ic_slot_kinds_;
@@ skipping 23 matching lines @@
 
   static int elements_per_ic_slot() { return 2; }
 
   inline int first_ic_slot_index() const;
   inline int ic_with_type_info_count();
   inline void change_ic_with_type_info_count(int delta);
   inline int ic_generic_count();
   inline void change_ic_generic_count(int delta);
   inline int ic_metadata_length() const;
 
-  bool SpecDiffersFrom(const ZoneFeedbackVectorSpec* other_spec) const;
+  bool SpecDiffersFrom(const FeedbackVectorSpec* other_spec) const;
 
   inline int Slots() const;
   inline int ICSlots() const;
 
   // Conversion from a slot or ic slot to an integer index to the underlying
   // array.
   inline int GetIndex(FeedbackVectorSlot slot) const;
   inline int GetIndex(FeedbackVectorICSlot slot) const;
 
   template <typename Spec>
@@ skipping 317 matching lines @@
   KeyedAccessStoreMode GetKeyedAccessStoreMode() const;
   IcCheckType GetKeyType() const;
 
   InlineCacheState StateFromFeedback() const override;
   Name* FindFirstName() const override;
 };
 }
 }  // namespace v8::internal
 
 #endif  // V8_TRANSITIONS_H_