Type Feedback Vector: Calculate profiler counts on the fly.

src/type-feedback-vector-inl.h

 // Copyright 2012 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_INL_H_
 #define V8_TYPE_FEEDBACK_VECTOR_INL_H_
 
 #include "src/type-feedback-vector.h"
 
 namespace v8 {
@@ skipping 63 matching lines @@
 }
 
 
 FeedbackVectorSlotKind TypeFeedbackVector::GetKind(
     FeedbackVectorSlot slot) const {
   DCHECK(!is_empty());
   return metadata()->GetKind(slot);
 }
 
 
-int TypeFeedbackVector::ic_with_type_info_count() {
-  return length() > 0 ? Smi::cast(get(kWithTypesIndex))->value() : 0;
-}
-
-
-void TypeFeedbackVector::change_ic_with_type_info_count(int delta) {
-  if (delta == 0) return;
-  int value = ic_with_type_info_count() + delta;
-  // Could go negative because of the debugger.
-  if (value >= 0) {
-    set(kWithTypesIndex, Smi::FromInt(value));
-  }
-}
-
-
-int TypeFeedbackVector::ic_generic_count() {
-  return length() > 0 ? Smi::cast(get(kGenericCountIndex))->value() : 0;
-}
-
-
-void TypeFeedbackVector::change_ic_generic_count(int delta) {
-  if (delta == 0) return;
-  int value = ic_generic_count() + delta;
-  if (value >= 0) {
-    set(kGenericCountIndex, Smi::FromInt(value));
-  }
-}
-
-
 int TypeFeedbackVector::GetIndex(FeedbackVectorSlot slot) const {
   DCHECK(slot.ToInt() < slot_count());
   return kReservedIndexCount + slot.ToInt();
 }
 
 
 // Conversion from an integer index to either a slot or an ic slot. The caller
 // should know what kind she expects.
 FeedbackVectorSlot TypeFeedbackVector::ToSlot(int index) const {
   DCHECK(index >= kReservedIndexCount && index < length());
   return FeedbackVectorSlot(index - kReservedIndexCount);
 }
 
 
 Object* TypeFeedbackVector::Get(FeedbackVectorSlot slot) const {
   return get(GetIndex(slot));
 }
 
 
 void TypeFeedbackVector::Set(FeedbackVectorSlot slot, Object* value,
                              WriteBarrierMode mode) {
   set(GetIndex(slot), value, mode);
 }
 
 
+void TypeFeedbackVector::ComputeCounts(int* with_type_info, int* generic) {
+  Object* uninitialized_sentinel =
+      TypeFeedbackVector::RawUninitializedSentinel(GetIsolate());
+  Object* megamorphic_sentinel =
+      *TypeFeedbackVector::MegamorphicSentinel(GetIsolate());
+  int with = 0;
+  int gen = 0;
+  TypeFeedbackMetadataIterator iter(metadata());
+  while (iter.HasNext()) {
+    FeedbackVectorSlot slot = iter.Next();
+    FeedbackVectorSlotKind kind = iter.kind();
+
+    Object* obj = Get(slot);
+    if (obj != uninitialized_sentinel &&
+        kind != FeedbackVectorSlotKind::GENERAL) {
+      if (obj->IsWeakCell() || obj->IsFixedArray() || obj->IsString()) {
+        with++;
+      } else if (obj == megamorphic_sentinel) {
+        gen++;
+      }
+    }
+  }
+
+  *with_type_info = with;
+  *generic = gen;
+}
+
+
 Handle<Object> TypeFeedbackVector::UninitializedSentinel(Isolate* isolate) {
   return isolate->factory()->uninitialized_symbol();
 }
 
 
 Handle<Object> TypeFeedbackVector::MegamorphicSentinel(Isolate* isolate) {
   return isolate->factory()->megamorphic_symbol();
 }
 
 
@@ skipping 34 matching lines @@
   int index = vector()->GetIndex(slot()) + 1;
   vector()->set(index, feedback_extra, mode);
 }
 
 
 Isolate* FeedbackNexus::GetIsolate() const { return vector()->GetIsolate(); }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TYPE_FEEDBACK_VECTOR_INL_H_