Revert of Collect type profile for DevTools.

src/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/feedback-vector.h"
 #include "src/code-stubs.h"
 #include "src/feedback-vector-inl.h"
 #include "src/ic/ic-inl.h"
 #include "src/ic/ic-state.h"
 #include "src/objects.h"
@@ skipping 131 matching lines @@
     case FeedbackSlotKind::kCompareOp:
       return "INTERPRETER_COMPARE_IC";
     case FeedbackSlotKind::kToBoolean:
       return "TO_BOOLEAN_IC";
     case FeedbackSlotKind::kStoreDataPropertyInLiteral:
       return "STORE_DATA_PROPERTY_IN_LITERAL_IC";
     case FeedbackSlotKind::kCreateClosure:
       return "kCreateClosure";
     case FeedbackSlotKind::kLiteral:
       return "LITERAL";
-    case FeedbackSlotKind::kTypeProfile:
-      return "TYPE_PROFILE";
     case FeedbackSlotKind::kGeneral:
       return "STUB";
     case FeedbackSlotKind::kKindsNumber:
       break;
   }
   UNREACHABLE();
   return "?";
 }
 
-bool FeedbackMetadata::HasTypeProfileSlot() {
-  FeedbackMetadataIterator iter(this);
-  while (iter.HasNext()) {
-    iter.Next();
-    FeedbackSlotKind kind = iter.kind();
-    if (kind == FeedbackSlotKind::kTypeProfile) {
-      return true;
-    }
-  }
-  return false;
-}
-
 FeedbackSlotKind FeedbackVector::GetKind(FeedbackSlot slot) const {
   DCHECK(!is_empty());
   return metadata()->GetKind(slot);
 }
 
 // static
 Handle<FeedbackVector> FeedbackVector::New(Isolate* isolate,
                                            Handle<SharedFunctionInfo> shared) {
   Factory* factory = isolate->factory();
 
@@ skipping 41 matching lines @@
         break;
       case FeedbackSlotKind::kLoadProperty:
       case FeedbackSlotKind::kLoadKeyed:
       case FeedbackSlotKind::kStoreNamedSloppy:
       case FeedbackSlotKind::kStoreNamedStrict:
       case FeedbackSlotKind::kStoreOwnNamed:
       case FeedbackSlotKind::kStoreKeyedSloppy:
       case FeedbackSlotKind::kStoreKeyedStrict:
       case FeedbackSlotKind::kStoreDataPropertyInLiteral:
       case FeedbackSlotKind::kGeneral:
-      case FeedbackSlotKind::kTypeProfile:
         array->set(index, *uninitialized_sentinel, SKIP_WRITE_BARRIER);
         break;
 
       case FeedbackSlotKind::kInvalid:
       case FeedbackSlotKind::kKindsNumber:
         UNREACHABLE();
         array->set(index, Smi::kZero, SKIP_WRITE_BARRIER);
         break;
     }
     for (int j = 1; j < entry_size; j++) {
@@ skipping 97 matching lines @@
           break;
         }
         case FeedbackSlotKind::kBinaryOp:
         case FeedbackSlotKind::kCompareOp: {
           DCHECK(Get(slot)->IsSmi());
           // don't clear these smi slots.
           // Set(slot, Smi::kZero);
           break;
         }
         case FeedbackSlotKind::kCreateClosure: {
-          case FeedbackSlotKind::kTypeProfile:
-            break;
+          break;
         }
         case FeedbackSlotKind::kGeneral: {
           if (obj->IsHeapObject()) {
             InstanceType instance_type =
                 HeapObject::cast(obj)->map()->instance_type();
             // AllocationSites are exempt from clearing. They don't store Maps
             // or Code pointers which can cause memory leaks if not cleared
             // regularly.
             if (instance_type != ALLOCATION_SITE_TYPE) {
               Set(slot, uninitialized_sentinel, SKIP_WRITE_BARRIER);
@@ skipping 666 matching lines @@
 }
 
 void StoreDataPropertyInLiteralICNexus::ConfigureMonomorphic(
     Handle<Name> name, Handle<Map> receiver_map) {
   Handle<WeakCell> cell = Map::WeakCellForMap(receiver_map);
 
   SetFeedback(*cell);
   SetFeedbackExtra(*name);
 }
 
-InlineCacheState CollectTypeProfileNexus::StateFromFeedback() const {
-  Isolate* isolate = GetIsolate();
-  Object* const feedback = GetFeedback();
-
-  if (feedback == *FeedbackVector::UninitializedSentinel(isolate)) {
-    return UNINITIALIZED;
-  }
-  return MONOMORPHIC;
-}
-
-void CollectTypeProfileNexus::Collect(Handle<Name> type) {
-  Isolate* isolate = GetIsolate();
-
-  Object* const feedback = GetFeedback();
-  Handle<ArrayList> types;
-
-  if (feedback == *FeedbackVector::UninitializedSentinel(isolate)) {
-    types = ArrayList::New(isolate, 1);
-  } else {
-    types = Handle<ArrayList>(ArrayList::cast(feedback), isolate);
-  }
-  // TODO(franzih): Somehow sort this list. Either avoid duplicates
-  // or use the common base type.
-  SetFeedback(*ArrayList::Add(types, type));
-}
-
-void CollectTypeProfileNexus::Print() const {
-  Isolate* isolate = GetIsolate();
-
-  Object* const feedback = GetFeedback();
-
-  if (feedback == *FeedbackVector::UninitializedSentinel(isolate)) {
-    return;
-  }
-
-  Handle<ArrayList> list;
-  list = Handle<ArrayList>(ArrayList::cast(feedback), isolate);
-
-  for (int i = 0; i < list->Length(); i++) {
-    Name* name = Name::cast(list->Get(i));
-    name->Print();
-  }
-}
-
 }  // namespace internal
 }  // namespace v8