[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 108 matching lines @@
                                                                              \
   /* Stack and interrupt check */                                            \
   ASM(InterruptCheck)                                                        \
   ASM(StackCheck)                                                            \
                                                                              \
   /* Interpreter */                                                          \
   ASM(InterpreterEntryTrampoline)                                            \
   ASM(InterpreterMarkBaselineOnReturn)                                       \
   ASM(InterpreterPushArgsAndCall)                                            \
   ASM(InterpreterPushArgsAndCallFunction)                                    \
-  ASM(InterpreterPushArgsAndConstruct)                                       \
   ASM(InterpreterPushArgsAndTailCall)                                        \
   ASM(InterpreterPushArgsAndTailCallFunction)                                \
+  ASM(InterpreterPushArgsAndConstruct)                                       \
+  ASM(InterpreterPushArgsAndConstructFunction)                               \
   ASM(InterpreterEnterBytecodeDispatch)                                      \
   ASM(InterpreterOnStackReplacement)                                         \
                                                                              \
   /* Code life-cycle */                                                      \
   ASM(CompileLazy)                                                           \
   ASM(CompileBaseline)                                                       \
   ASM(CompileOptimized)                                                      \
   ASM(CompileOptimizedConcurrent)                                            \
   ASM(InOptimizationQueue)                                                   \
   ASM(InstantiateAsmJs)                                                      \
@@ skipping 432 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 24 matching lines @@
   static void Generate_CallBoundFunctionImpl(MacroAssembler* masm,
                                              TailCallMode tail_call_mode);
 
   static void Generate_Call(MacroAssembler* masm, ConvertReceiverMode mode,
                             TailCallMode tail_call_mode);
 
   static void Generate_InterpreterPushArgsAndCallImpl(
       MacroAssembler* masm, TailCallMode tail_call_mode,
       CallableType function_type);
 
+  static void Generate_InterpreterPushArgsAndConstructImpl(
+      MacroAssembler* masm, CallableType function_type);
+
   static void Generate_DatePrototype_GetField(MacroAssembler* masm,
                                               int field_index);
 
   enum class MathMaxMinKind { kMax, kMin };
   static void Generate_MathMaxMin(MacroAssembler* masm, MathMaxMinKind kind);
 
 #define DECLARE_ASM(Name, ...) \
   static void Generate_##Name(MacroAssembler* masm);
 #define DECLARE_TF(Name, ...) \
   static void Generate_##Name(CodeStubAssembler* csasm);
@@ skipping 12 matching lines @@
 
   friend class Isolate;
 
   DISALLOW_COPY_AND_ASSIGN(Builtins);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_BUILTINS_BUILTINS_H_