[Interpreter] Collect type feedback for 'new' in the bytecode handler

src/builtins/builtins.h

 // Copyright 2011 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_BUILTINS_BUILTINS_H_
 #define V8_BUILTINS_BUILTINS_H_
 
 #include "src/base/flags.h"
 #include "src/handles.h"
 
@@ skipping 97 matching lines @@
   ASM(InterruptCheck)                                                       \
   ASM(StackCheck)                                                           \
   /* Interpreter */                                                         \
   ASM(InterpreterEntryTrampoline)                                           \
   ASM(InterpreterMarkBaselineOnReturn)                                      \
   ASM(InterpreterPushArgsAndCallFunction)                                   \
   ASM(InterpreterPushArgsAndTailCallFunction)                               \
   ASM(InterpreterPushArgsAndCall)                                           \
   ASM(InterpreterPushArgsAndTailCall)                                       \
   ASM(InterpreterPushArgsAndConstruct)                                      \
+  ASM(InterpreterPushArgsAndConstructFunction)                              \
   ASM(InterpreterEnterBytecodeDispatch)                                     \
   /* Code life-cycle */                                                     \
   ASM(CompileLazy)                                                          \
   ASM(CompileBaseline)                                                      \
   ASM(CompileOptimized)                                                     \
   ASM(CompileOptimizedConcurrent)                                           \
   ASM(InOptimizationQueue)                                                  \
   ASM(InstantiateAsmJs)                                                     \
   ASM(MarkCodeAsToBeExecutedOnce)                                           \
   ASM(MarkCodeAsExecutedOnce)                                               \
@@ skipping 316 matching lines @@
       TailCallMode tail_call_mode = TailCallMode::kDisallow);
   Handle<Code> Call(ConvertReceiverMode = ConvertReceiverMode::kAny,
                     TailCallMode tail_call_mode = TailCallMode::kDisallow);
   Handle<Code> CallBoundFunction(TailCallMode tail_call_mode);
   Handle<Code> NonPrimitiveToPrimitive(
       ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
   Handle<Code> OrdinaryToPrimitive(OrdinaryToPrimitiveHint hint);
   Handle<Code> InterpreterPushArgsAndCall(
       TailCallMode tail_call_mode,
       CallableType function_type = CallableType::kAny);
+  Handle<Code> InterpreterPushArgsAndConstruct(CallableType function_type);
 
   Code* builtin(Name name) {
     // Code::cast cannot be used here since we access builtins
     // during the marking phase of mark sweep. See IC::Clear.
     return reinterpret_cast<Code*>(builtins_[name]);
   }
 
   Address builtin_address(Name name) {
     return reinterpret_cast<Address>(&builtins_[name]);
   }
@@ skipping 337 matching lines @@
         masm, TailCallMode::kDisallow, CallableType::kJSFunction);
   }
   static void Generate_InterpreterPushArgsAndTailCallFunction(
       MacroAssembler* masm) {
     return Generate_InterpreterPushArgsAndCallImpl(masm, TailCallMode::kAllow,
                                                    CallableType::kJSFunction);
   }
   static void Generate_InterpreterPushArgsAndCallImpl(
       MacroAssembler* masm, TailCallMode tail_call_mode,
       CallableType function_type);
-  static void Generate_InterpreterPushArgsAndConstruct(MacroAssembler* masm);
+
+  static void Generate_InterpreterPushArgsAndConstruct(MacroAssembler* masm) {
+    return Generate_InterpreterPushArgsAndConstructImpl(masm,
+                                                        CallableType::kAny);
+  }
+  static void Generate_InterpreterPushArgsAndConstructFunction(
+      MacroAssembler* masm) {
+    return Generate_InterpreterPushArgsAndConstructImpl(
+        masm, CallableType::kJSFunction);
+  }
+  static void Generate_InterpreterPushArgsAndConstructImpl(
+      MacroAssembler* masm, CallableType function_type);
 
 #define DECLARE_CODE_AGE_BUILTIN_GENERATOR(C)              \
   static void Generate_Make##C##CodeYoungAgainEvenMarking( \
       MacroAssembler* masm);                               \
   static void Generate_Make##C##CodeYoungAgainOddMarking(MacroAssembler* masm);
   CODE_AGE_LIST(DECLARE_CODE_AGE_BUILTIN_GENERATOR)
 #undef DECLARE_CODE_AGE_BUILTIN_GENERATOR
 
   static void Generate_MarkCodeAsToBeExecutedOnce(MacroAssembler* masm);
   static void Generate_MarkCodeAsExecutedOnce(MacroAssembler* masm);
   static void Generate_MarkCodeAsExecutedTwice(MacroAssembler* masm);
 
   static void Generate_AtomicsLoad(CodeStubAssembler* assembler);
   static void Generate_AtomicsStore(CodeStubAssembler* assembler);
 
   static void InitBuiltinFunctionTable();
 
   bool initialized_;
 
   friend class BuiltinFunctionTable;
   friend class Isolate;
 
   DISALLOW_COPY_AND_ASSIGN(Builtins);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_BUILTINS_BUILTINS_H_