Revert of Provide call counts for constructor calls, surface them as a vector IC.

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 91 matching lines @@
   return false;
 }
 
 
 const char* TypeFeedbackMetadata::Kind2String(FeedbackVectorSlotKind kind) {
   switch (kind) {
     case FeedbackVectorSlotKind::INVALID:
       return "INVALID";
     case FeedbackVectorSlotKind::CALL_IC:
       return "CALL_IC";
-    case FeedbackVectorSlotKind::CONSTRUCT_IC:
-      return "CONSTRUCT_IC";
     case FeedbackVectorSlotKind::LOAD_IC:
       return "LOAD_IC";
     case FeedbackVectorSlotKind::KEYED_LOAD_IC:
       return "KEYED_LOAD_IC";
     case FeedbackVectorSlotKind::STORE_IC:
       return "STORE_IC";
     case FeedbackVectorSlotKind::KEYED_STORE_IC:
       return "KEYED_STORE_IC";
     case FeedbackVectorSlotKind::GENERAL:
       return "STUB";
@@ skipping 93 matching lines @@
     FeedbackVectorSlotKind kind = iter.kind();
 
     Object* obj = Get(slot);
     if (obj != uninitialized_sentinel) {
       switch (kind) {
         case FeedbackVectorSlotKind::CALL_IC: {
           CallICNexus nexus(this, slot);
           nexus.Clear(shared->code());
           break;
         }
-        case FeedbackVectorSlotKind::CONSTRUCT_IC: {
-          ConstructICNexus nexus(this, slot);
-          nexus.Clear(shared->code());
-          break;
-        }
         case FeedbackVectorSlotKind::LOAD_IC: {
           LoadICNexus nexus(this, slot);
           nexus.Clear(shared->code());
           break;
         }
         case FeedbackVectorSlotKind::KEYED_LOAD_IC: {
           KeyedLoadICNexus nexus(this, slot);
           nexus.Clear(shared->code());
           break;
         }
@@ skipping 243 matching lines @@
     return GENERIC;
   } else if (feedback->IsAllocationSite() || feedback->IsWeakCell()) {
     return MONOMORPHIC;
   }
 
   CHECK(feedback == *TypeFeedbackVector::UninitializedSentinel(isolate));
   return UNINITIALIZED;
 }
 
 
-Handle<Object> CallICNexus::GetCallFeedback() {
-  Object* feedback = GetFeedback();
-  if (feedback->IsWeakCell()) {
-    feedback = WeakCell::cast(feedback)->value();
-  }
-  if (!feedback->IsJSFunction() && !feedback->IsAllocationSite()) {
-    feedback = GetIsolate()->heap()->undefined_value();
-  }
-  return handle(feedback, GetIsolate());
-}
-
-
 int CallICNexus::ExtractCallCount() {
   Object* call_count = GetFeedbackExtra();
   if (call_count->IsSmi()) {
     int value = Smi::cast(call_count)->value() / 2;
     return value;
   }
   return -1;
 }
 
 
 void CallICNexus::Clear(Code* host) { CallIC::Clear(GetIsolate(), host, this); }
 
 
-void ConstructICNexus::Clear(Code* host) {
-  ConstructIC::Clear(GetIsolate(), host, this);
-}
-
-
 void CallICNexus::ConfigureMonomorphicArray() {
   Object* feedback = GetFeedback();
   if (!feedback->IsAllocationSite()) {
     Handle<AllocationSite> new_site =
         GetIsolate()->factory()->NewAllocationSite();
     SetFeedback(*new_site);
   }
   SetFeedbackExtra(Smi::FromInt(kCallCountIncrement), SKIP_WRITE_BARRIER);
 }
 
@@ skipping 332 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