The metadata part of TypeFeedbackVector is extracted to TypeFeedbackMetadata array.

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 103 matching lines @@
   friend class FeedbackVectorSpecBase<FeedbackVectorSpec>;
 
   void append(FeedbackVectorSlotKind kind) {
     slot_kinds_.push_back(static_cast<unsigned char>(kind));
   }
 
   ZoneVector<unsigned char> slot_kinds_;
 };
 
 
+// The shape of the TypeFeedbackMetadata is an array with:
+// 0: slot_count
+// 1..N: slot kinds packed into a bit vector
+//
+class TypeFeedbackMetadata : public FixedArray {
+ public:
+  // Casting.
+  static inline TypeFeedbackMetadata* cast(Object* obj);
+
+  static const int kSlotsCountIndex = 0;
+  static const int kReservedIndexCount = 1;
+
+  // Returns number of feedback vector elements used by given slot kind.
+  static inline int GetSlotSize(FeedbackVectorSlotKind kind);
+
+  bool SpecDiffersFrom(const FeedbackVectorSpec* other_spec) const;
+
+  // Returns number of slots in the vector.
+  inline int slot_count() const;
+
+  // Returns slot kind for given slot.
+  FeedbackVectorSlotKind GetKind(FeedbackVectorSlot slot) const;
+
+  template <typename Spec>
+  static Handle<TypeFeedbackMetadata> New(Isolate* isolate, const Spec* spec);
+
+#ifdef OBJECT_PRINT
+  // For gdb debugging.
+  void Print();
+#endif  // OBJECT_PRINT
+
+  DECLARE_PRINTER(TypeFeedbackMetadata)
+
+  static const char* Kind2String(FeedbackVectorSlotKind kind);
+
+ private:
+  static const int kFeedbackVectorSlotKindBits = 3;
+  STATIC_ASSERT(static_cast<int>(FeedbackVectorSlotKind::KINDS_NUMBER) <
+                (1 << kFeedbackVectorSlotKindBits));
+
+  void SetKind(FeedbackVectorSlot slot, FeedbackVectorSlotKind kind);
+
+  typedef BitSetComputer<FeedbackVectorSlotKind, kFeedbackVectorSlotKindBits,
+                         kSmiValueSize, uint32_t> VectorICComputer;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(TypeFeedbackMetadata);
+};
+
+
 // The shape of the TypeFeedbackVector is an array with:
-// 0: slot_count
+// 0: feedback metadata
 // 1: ics_with_types
 // 2: ics_with_generic_info
-// 3: slots metadata (a bit vector of slot kinds)
-// ...
-// N: feedback slot #0 (N >= 3)
+// 3: feedback slot #0 (N >= 3)
 // ...
 // N + slot_count - 1: feedback slot #(slot_count-1)
 //
 class TypeFeedbackVector : public FixedArray {
  public:
   // Casting.
   static inline TypeFeedbackVector* cast(Object* obj);
 
-  static const int kSlotsCountIndex = 0;
+  static const int kMetadataIndex = 0;
   static const int kWithTypesIndex = 1;
   static const int kGenericCountIndex = 2;
   static const int kReservedIndexCount = 3;
 
-  // Returns number of feedback vector elements used by given slot kind.
-  static inline int GetSlotSize(FeedbackVectorSlotKind kind);
-
   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 FeedbackVectorSpec* other_spec) const;
 
   inline bool is_empty() const;
 
   // Returns number of slots in the vector.
-  inline int Slots() const;
+  inline int slot_count() const;
+
+  inline TypeFeedbackMetadata* metadata() const;
 
   // Conversion from a slot to an integer index to the underlying array.
   inline int GetIndex(FeedbackVectorSlot slot) const;
   static int GetIndexFromSpec(const FeedbackVectorSpec* spec,
                               FeedbackVectorSlot slot);
 
   // Conversion from an integer index to the underlying array to a slot.
   inline FeedbackVectorSlot ToSlot(int index) const;
   inline Object* Get(FeedbackVectorSlot slot) const;
   inline void Set(FeedbackVectorSlot slot, Object* value,
                   WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // Returns slot kind for given slot.
-  FeedbackVectorSlotKind GetKind(FeedbackVectorSlot slot) const;
+  inline FeedbackVectorSlotKind GetKind(FeedbackVectorSlot slot) const;
 
-  template <typename Spec>
-  static Handle<TypeFeedbackVector> New(Isolate* isolate, const Spec* spec);
+  static Handle<TypeFeedbackVector> New(Isolate* isolate,
+                                        Handle<TypeFeedbackMetadata> metadata);
 
   static Handle<TypeFeedbackVector> Copy(Isolate* isolate,
                                          Handle<TypeFeedbackVector> vector);
 
 #ifdef OBJECT_PRINT
   // For gdb debugging.
   void Print();
 #endif  // OBJECT_PRINT
 
   DECLARE_PRINTER(TypeFeedbackVector)
@@ skipping 29 matching lines @@
   static Handle<TypeFeedbackVector> DummyVector(Isolate* isolate);
   static FeedbackVectorSlot DummySlot(int dummyIndex) {
     DCHECK(dummyIndex >= 0 && dummyIndex <= kDummyKeyedStoreICSlot);
     return FeedbackVectorSlot(dummyIndex);
   }
 
   static int PushAppliedArgumentsIndex();
   static Handle<TypeFeedbackVector> CreatePushAppliedArgumentsVector(
       Isolate* isolate);
 
-  static const char* Kind2String(FeedbackVectorSlotKind kind);
-
  private:
-  static const int kFeedbackVectorSlotKindBits = 3;
-  STATIC_ASSERT(static_cast<int>(FeedbackVectorSlotKind::KINDS_NUMBER) <
-                (1 << kFeedbackVectorSlotKindBits));
-
-  void SetKind(FeedbackVectorSlot slot, FeedbackVectorSlotKind kind);
-
-  typedef BitSetComputer<FeedbackVectorSlotKind, kFeedbackVectorSlotKindBits,
-                         kSmiValueSize, uint32_t> VectorICComputer;
-
   void ClearSlotsImpl(SharedFunctionInfo* shared, bool force_clear);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TypeFeedbackVector);
 };
 
 
 // The following asserts protect an optimization in type feedback vector
 // code that looks into the contents of a slot assuming to find a String,
 // a Symbol, an AllocationSite, a WeakCell, or a FixedArray.
 STATIC_ASSERT(WeakCell::kSize >= 2 * kPointerSize);
 STATIC_ASSERT(WeakCell::kValueOffset == AllocationSite::kTransitionInfoOffset);
 STATIC_ASSERT(WeakCell::kValueOffset == FixedArray::kLengthOffset);
 STATIC_ASSERT(WeakCell::kValueOffset == Name::kHashFieldSlot);
 // Verify that an empty hash field looks like a tagged object, but can't
 // possibly be confused with a pointer.
 STATIC_ASSERT((Name::kEmptyHashField & kHeapObjectTag) == kHeapObjectTag);
 STATIC_ASSERT(Name::kEmptyHashField == 0x3);
 // Verify that a set hash field will not look like a tagged object.
 STATIC_ASSERT(Name::kHashNotComputedMask == kHeapObjectTag);
 
 
 class TypeFeedbackMetadataIterator {
  public:
-  explicit TypeFeedbackMetadataIterator(Handle<TypeFeedbackVector> metadata)
+  explicit TypeFeedbackMetadataIterator(Handle<TypeFeedbackMetadata> metadata)
       : metadata_handle_(metadata),
         slot_(FeedbackVectorSlot(0)),
         slot_kind_(FeedbackVectorSlotKind::INVALID) {}
 
-  explicit TypeFeedbackMetadataIterator(TypeFeedbackVector* metadata)
+  explicit TypeFeedbackMetadataIterator(TypeFeedbackMetadata* metadata)
       : metadata_(metadata),
         slot_(FeedbackVectorSlot(0)),
         slot_kind_(FeedbackVectorSlotKind::INVALID) {}
 
-  bool HasNext() const { return slot_.ToInt() < metadata()->Slots(); }
+  bool HasNext() const { return slot_.ToInt() < metadata()->slot_count(); }
 
   FeedbackVectorSlot Next() {
     DCHECK(HasNext());
     FeedbackVectorSlot slot = slot_;
     slot_kind_ = metadata()->GetKind(slot);
     slot_ = FeedbackVectorSlot(slot_.ToInt() + entry_size());
     return slot;
   }
 
   // Returns slot kind of the last slot returned by Next().
   FeedbackVectorSlotKind kind() const {
     DCHECK_NE(FeedbackVectorSlotKind::INVALID, slot_kind_);
     DCHECK_NE(FeedbackVectorSlotKind::KINDS_NUMBER, slot_kind_);
     return slot_kind_;
   }
 
   // Returns entry size of the last slot returned by Next().
-  int entry_size() const { return TypeFeedbackVector::GetSlotSize(kind()); }
+  int entry_size() const { return TypeFeedbackMetadata::GetSlotSize(kind()); }
 
  private:
-  TypeFeedbackVector* metadata() const {
+  TypeFeedbackMetadata* metadata() const {
     return !metadata_handle_.is_null() ? *metadata_handle_ : metadata_;
   }
 
   // The reason for having a handle and a raw pointer to the meta data is
   // to have a single iterator implementation for both "handlified" and raw
   // pointer use cases.
-  Handle<TypeFeedbackVector> metadata_handle_;
-  TypeFeedbackVector* metadata_;
+  Handle<TypeFeedbackMetadata> metadata_handle_;
+  TypeFeedbackMetadata* metadata_;
   FeedbackVectorSlot slot_;
   FeedbackVectorSlotKind slot_kind_;
 };
 
 
 // A FeedbackNexus is the combination of a TypeFeedbackVector and a slot.
 // Derived classes customize the update and retrieval of feedback.
 class FeedbackNexus {
  public:
   FeedbackNexus(Handle<TypeFeedbackVector> vector, FeedbackVectorSlot slot)
@@ skipping 201 matching lines @@
   KeyedAccessStoreMode GetKeyedAccessStoreMode() const;
   IcCheckType GetKeyType() const;
 
   InlineCacheState StateFromFeedback() const override;
   Name* FindFirstName() const override;
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TRANSITIONS_H_