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

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/base/logging.h"
 #include "src/elements-kind.h"
 #include "src/objects.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 
 
 enum class FeedbackVectorSlotKind {
   // This kind means that the slot points to the middle of other slot
   // which occupies more than one feedback vector element.
   // There must be no such slots in the system.
   INVALID,
 
   CALL_IC,
+  CONSTRUCT_IC,
   LOAD_IC,
   KEYED_LOAD_IC,
   STORE_IC,
   KEYED_STORE_IC,
 
   // This is a general purpose slot that occupies one feedback vector element.
   GENERAL,
 
   KINDS_NUMBER  // Last value indicating number of kinds.
 };
 
 
 std::ostream& operator<<(std::ostream& os, FeedbackVectorSlotKind kind);
 
 
 template <typename Derived>
 class FeedbackVectorSpecBase {
  public:
   inline FeedbackVectorSlot AddSlot(FeedbackVectorSlotKind kind);
 
   FeedbackVectorSlot AddCallICSlot() {
     return AddSlot(FeedbackVectorSlotKind::CALL_IC);
   }
 
+  FeedbackVectorSlot AddConstructICSlot() {
+    return AddSlot(FeedbackVectorSlotKind::CONSTRUCT_IC);
+  }
+
   FeedbackVectorSlot AddLoadICSlot() {
     return AddSlot(FeedbackVectorSlotKind::LOAD_IC);
   }
 
   FeedbackVectorSlot AddKeyedLoadICSlot() {
     return AddSlot(FeedbackVectorSlotKind::KEYED_LOAD_IC);
   }
 
   FeedbackVectorSlot AddStoreICSlot() {
     return AddSlot(FeedbackVectorSlotKind::STORE_IC);
@@ skipping 88 matching lines @@
 #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 const int kFeedbackVectorSlotKindBits = 4;
   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);
 };
@@ skipping 223 matching lines @@
   // The reason for having a vector handle and a raw pointer is that we can and
   // should use handles during IC miss, but not during GC when we clear ICs. If
   // you have a handle to the vector that is better because more operations can
   // be done, like allocation.
   Handle<TypeFeedbackVector> vector_handle_;
   TypeFeedbackVector* vector_;
   FeedbackVectorSlot slot_;
 };
 
 
-class CallICNexus final : public FeedbackNexus {
+class CallICNexus : public FeedbackNexus {
  public:
   // Monomorphic call ics store call counts. Platform code needs to increment
   // the count appropriately (ie, by 2).
   static const int kCallCountIncrement = 2;
 
   CallICNexus(Handle<TypeFeedbackVector> vector, FeedbackVectorSlot slot)
       : FeedbackNexus(vector, slot) {
-    DCHECK_EQ(FeedbackVectorSlotKind::CALL_IC, vector->GetKind(slot));
+    DCHECK(vector->GetKind(slot) == FeedbackVectorSlotKind::CALL_IC ||
+           vector->GetKind(slot) == FeedbackVectorSlotKind::CONSTRUCT_IC);
   }
   CallICNexus(TypeFeedbackVector* vector, FeedbackVectorSlot slot)
       : FeedbackNexus(vector, slot) {
-    DCHECK_EQ(FeedbackVectorSlotKind::CALL_IC, vector->GetKind(slot));
+    DCHECK(vector->GetKind(slot) == FeedbackVectorSlotKind::CALL_IC ||
+           vector->GetKind(slot) == FeedbackVectorSlotKind::CONSTRUCT_IC);
   }
 
   void Clear(Code* host);
 
   void ConfigureMonomorphicArray();
   void ConfigureMonomorphic(Handle<JSFunction> function);
   void ConfigureMegamorphic() final;
   void ConfigureMegamorphic(int call_count);
 
   InlineCacheState StateFromFeedback() const final;
 
   int ExtractMaps(MapHandleList* maps) const final {
     // CallICs don't record map feedback.
     return 0;
   }
   MaybeHandle<Code> FindHandlerForMap(Handle<Map> map) const final {
     return MaybeHandle<Code>();
   }
   bool FindHandlers(CodeHandleList* code_list, int length = -1) const final {
     return length == 0;
   }
 
+  Handle<Object> GetCallFeedback();
   int ExtractCallCount();
 };
 
 
+class ConstructICNexus final : public CallICNexus {
+ public:
+  ConstructICNexus(Handle<TypeFeedbackVector> vector, FeedbackVectorSlot slot)
+      : CallICNexus(vector, slot) {}
+  ConstructICNexus(TypeFeedbackVector* vector, FeedbackVectorSlot slot)
+      : CallICNexus(vector, slot) {}
+
+  void Clear(Code* host);
+};
+
+
 class LoadICNexus : public FeedbackNexus {
  public:
   LoadICNexus(Handle<TypeFeedbackVector> vector, FeedbackVectorSlot slot)
       : FeedbackNexus(vector, slot) {
     DCHECK_EQ(FeedbackVectorSlotKind::LOAD_IC, vector->GetKind(slot));
   }
   explicit LoadICNexus(Isolate* isolate)
       : FeedbackNexus(
             TypeFeedbackVector::DummyVector(isolate),
             FeedbackVectorSlot(TypeFeedbackVector::kDummyLoadICSlot)) {}
@@ skipping 92 matching lines @@
   KeyedAccessStoreMode GetKeyedAccessStoreMode() const;
   IcCheckType GetKeyType() const;
 
   InlineCacheState StateFromFeedback() const override;
   Name* FindFirstName() const override;
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TRANSITIONS_H_