CallConstruct also gets call count information if megamorphic.

src/interpreter/interpreter-assembler.cc

 // Copyright 2015 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/interpreter/interpreter-assembler.h"
 
 #include <limits>
 #include <ostream>
 
 #include "src/code-factory.h"
@@ skipping 474 matching lines @@
     Node* stack_pointer_after_call = LoadStackPointer();
     Node* stack_pointer_before_call = stack_pointer_before_call_;
     stack_pointer_before_call_ = nullptr;
     AbortIfWordNotEqual(stack_pointer_before_call, stack_pointer_after_call,
                         kUnexpectedStackPointer);
   }
 }
 
 Node* InterpreterAssembler::IncrementCallCount(Node* type_feedback_vector,
                                                Node* slot_id) {
+  Comment("increment call count");
   Node* call_count_slot = IntPtrAdd(slot_id, IntPtrConstant(1));
   Node* call_count =
       LoadFixedArrayElement(type_feedback_vector, call_count_slot);
   Node* new_count = SmiAdd(call_count, SmiTag(Int32Constant(1)));
   // Count is Smi, so we don't need a write barrier.
   return StoreFixedArrayElement(type_feedback_vector, call_count_slot,
                                 new_count, SKIP_WRITE_BARRIER);
 }
 
 Node* InterpreterAssembler::CallJSWithFeedback(Node* function, Node* context,
@@ skipping 236 matching lines @@
   Node* is_js_function =
       WordEqual(instance_type, Int32Constant(JS_FUNCTION_TYPE));
   BranchIf(is_js_function, &js_function, &call_construct);
 
   Bind(&js_function);
   {
     // Cache the called function in a feedback vector slot. Cache states
     // are uninitialized, monomorphic (indicated by a JSFunction), and
     // megamorphic.
     // TODO(mythria/v8:5210): Check if it is better to mark extra_checks as a
-    // deferred block so that call_construct_function will be scheduled just
-    // after increment_count and in the fast path we can reduce one branch in
-    // the
-    // fast path.
-    Label increment_count(this), extra_checks(this),
-        call_construct_function(this);
+    // deferred block so that call_construct_function will be scheduled.
+    Label extra_checks(this), call_construct_function(this);
 
     Node* feedback_element =
         LoadFixedArrayElement(type_feedback_vector, slot_id);
     Node* feedback_value = LoadWeakCellValue(feedback_element);
     Node* is_monomorphic = WordEqual(constructor, feedback_value);
-    BranchIf(is_monomorphic, &increment_count, &extra_checks);
+    BranchIf(is_monomorphic, &call_construct_function, &extra_checks);
 
     Bind(&extra_checks);
     {
       Label mark_megamorphic(this), initialize(this),
           check_allocation_site(this), check_initialized(this),
-          set_alloc_feedback_and_inc_count(this);
+          set_alloc_feedback_and_call(this);
       {
         // Check if it is a megamorphic target
         Comment("check if megamorphic");
         Node* is_megamorphic = WordEqual(
             feedback_element,
             HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate())));
         GotoIf(is_megamorphic, &call_construct_function);
 
         Comment("check if weak cell");
         Node* is_weak_cell = WordEqual(LoadMap(feedback_element),
@@ skipping 12 matching lines @@
         Node* is_allocation_site =
             WordEqual(LoadObjectField(feedback_element, 0),
                       LoadRoot(Heap::kAllocationSiteMapRootIndex));
         GotoUnless(is_allocation_site, &check_initialized);
 
         // Make sure the function is the Array() function
         Node* context_slot =
             LoadFixedArrayElement(LoadNativeContext(context),
                                   Int32Constant(Context::ARRAY_FUNCTION_INDEX));
         Node* is_array_function = WordEqual(context_slot, constructor);
-        BranchIf(is_array_function, &set_alloc_feedback_and_inc_count,
+        BranchIf(is_array_function, &set_alloc_feedback_and_call,
                  &mark_megamorphic);
       }
 
-      Bind(&set_alloc_feedback_and_inc_count);
+      Bind(&set_alloc_feedback_and_call);
       {
         allocation_feedback.Bind(feedback_element);
-        Goto(&increment_count);
+        Goto(&call_construct_function);
       }
 
       Bind(&check_initialized);
       {
         // Check if it is uninitialized.
         Comment("check if uninitialized");
         Node* is_uninitialized = WordEqual(
             feedback_element, LoadRoot(Heap::kuninitialized_symbolRootIndex));
         BranchIf(is_uninitialized, &initialize, &mark_megamorphic);
       }
 
       Bind(&initialize);
       {
-        Label initialize_count(this), create_weak_cell(this),
-            create_allocation_site(this);
+        Label create_weak_cell(this), create_allocation_site(this);
         Comment("initialize the feedback element");
         // Check that it is the Array() function.
         Node* context_slot =
             LoadFixedArrayElement(LoadNativeContext(context),
                                   Int32Constant(Context::ARRAY_FUNCTION_INDEX));
         Node* is_array_function = WordEqual(context_slot, constructor);
         BranchIf(is_array_function, &create_allocation_site, &create_weak_cell);
 
         Bind(&create_allocation_site);
         {
           // TODO(mythria): Inline the creation of allocation site.
           CreateAllocationSiteStub create_stub(isolate());
           CallStub(create_stub.GetCallInterfaceDescriptor(),
                    HeapConstant(create_stub.GetCode()), context,
                    type_feedback_vector, SmiTag(slot_id));
           Node* feedback_element =
               LoadFixedArrayElement(type_feedback_vector, slot_id);
           allocation_feedback.Bind(feedback_element);
-          Goto(&initialize_count);
+          Goto(&call_construct_function);
         }
 
         Bind(&create_weak_cell);
         {
           CreateWeakCellInFeedbackVector(type_feedback_vector, SmiTag(slot_id),
                                          constructor);
-          Goto(&initialize_count);
-        }
-
-        Bind(&initialize_count);
-        {
-          Node* call_count_slot = IntPtrAdd(slot_id, IntPtrConstant(1));
-          // Count is Smi, so we don't need a write barrier.
-          StoreFixedArrayElement(type_feedback_vector, call_count_slot,
-                                 SmiTag(Int32Constant(1)), SKIP_WRITE_BARRIER);
           Goto(&call_construct_function);
         }
       }
 
       Bind(&mark_megamorphic);
       {
         // MegamorphicSentinel is an immortal immovable object so
         // write-barrier is not needed.
         Comment("transition to megamorphic");
         DCHECK(
             Heap::RootIsImmortalImmovable(Heap::kmegamorphic_symbolRootIndex));
         StoreFixedArrayElement(
             type_feedback_vector, slot_id,
             HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate())),
             SKIP_WRITE_BARRIER);
         Goto(&call_construct_function);
       }
     }
 
-    Bind(&increment_count);
-    {
-      // Increment the call count.
-      Comment("increment call count");
-      Node* call_count_slot = IntPtrAdd(slot_id, IntPtrConstant(1));
-      Node* call_count =
-          LoadFixedArrayElement(type_feedback_vector, call_count_slot);
-      Node* new_count = SmiAdd(call_count, SmiTag(Int32Constant(1)));
-      // Count is Smi, so we don't need a write barrier.
-      StoreFixedArrayElement(type_feedback_vector, call_count_slot, new_count,
-                             SKIP_WRITE_BARRIER);
-      Goto(&call_construct_function);
-    }
-
     Bind(&call_construct_function);
     {
       Comment("call using callConstructFunction");
+      IncrementCallCount(type_feedback_vector, slot_id);
       Callable callable_function = CodeFactory::InterpreterPushArgsAndConstruct(
           isolate(), CallableType::kJSFunction);
       return_value.Bind(CallStub(callable_function.descriptor(),
                                  HeapConstant(callable_function.code()),
                                  context, arg_count, new_target, constructor,
                                  allocation_feedback.value(), first_arg));
       Goto(&end);
     }
   }
 
@@ skipping 455 matching lines @@
     Goto(&loop);
   }
   Bind(&done_loop);
 
   return array;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8