[torque] Port some constructor builtins to Torque.

- FastNewFunctionContextEval
- FastNewFunctionContextFunction
- CreateEmptyLiteralObject
- CreateRegExpLiteral
- CreateEmptyArrayLiteral
- CreateShallowArrayLiteral
- CreateShallowObjectLiteral
- NumberConstructor
- ObjectConstructor
- GenericLazyDeoptContinuation

Bug: v8:9891

Change-Id: Idd4bf035d8dbeec03b9ef727e1bfb80eab4bc43c
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2311411
Commit-Queue: Bill Budge <bbudge@chromium.org>
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69082}

BUILD.gn

@@ -1114,6 +1114,7 @@ torque_files = [
   "src/builtins/builtins-string.tq",
   "src/builtins/cast.tq",
   "src/builtins/collections.tq",
+  "src/builtins/constructor.tq",
   "src/builtins/conversion.tq",
   "src/builtins/convert.tq",
   "src/builtins/console.tq",

src/ast/ast.h

@@ -1107,6 +1107,7 @@ class AggregateLiteral : public MaterializedLiteral {
     kIsShallow = 1,
     kDisableMementos = 1 << 1,
     kNeedsInitialAllocationSite = 1 << 2,
+    kIsShallowAndDisableMementos = kIsShallow | kDisableMementos,
   };
 
   bool is_initialized() const { return 0 < depth_; }

src/builtins/base.tq

@@ -522,6 +522,12 @@ transitioning macro ToInteger_Inline(implicit context: Context)(input: JSAny):
   }
 }
 
+extern enum BigIntHandling extends int32
+constexpr 'CodeStubAssembler::BigIntHandling' { kConvertToNumber, kThrow }
+
+extern transitioning macro ToNumber(implicit context: Context)(
+    JSAny, constexpr BigIntHandling): Number;
+
 extern transitioning macro ToLength_Inline(implicit context: Context)(JSAny):
     Number;
 extern transitioning macro ToNumber_Inline(implicit context: Context)(JSAny):

src/builtins/builtins-collections-gen.cc

@@ -413,8 +413,7 @@ TNode<JSObject> BaseCollectionsAssembler::AllocateJSCollectionSlow(
     TNode<Context> context, TNode<JSFunction> constructor,
     TNode<JSReceiver> new_target) {
   ConstructorBuiltinsAssembler constructor_assembler(this->state());
-  return constructor_assembler.EmitFastNewObject(context, constructor,
-                                                 new_target);
+  return constructor_assembler.FastNewObject(context, constructor, new_target);
 }
 
 void BaseCollectionsAssembler::GenerateConstructor(

src/builtins/builtins-constructor-gen.h

@@ -15,37 +15,38 @@ class ConstructorBuiltinsAssembler : public CodeStubAssembler {
   explicit ConstructorBuiltinsAssembler(compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
-  TNode<Context> EmitFastNewFunctionContext(TNode<ScopeInfo> scope_info,
-                                            TNode<Uint32T> slots,
-                                            TNode<Context> context,
-                                            ScopeType scope_type);
+  TNode<Context> FastNewFunctionContext(TNode<ScopeInfo> scope_info,
+                                        TNode<Uint32T> slots,
+                                        TNode<Context> context,
+                                        ScopeType scope_type);
 
-  TNode<JSRegExp> EmitCreateRegExpLiteral(
-      TNode<HeapObject> maybe_feedback_vector, TNode<TaggedIndex> slot,
-      TNode<Object> pattern, TNode<Smi> flags, TNode<Context> context);
+  TNode<JSRegExp> CreateRegExpLiteral(TNode<HeapObject> maybe_feedback_vector,
+                                      TNode<TaggedIndex> slot,
+                                      TNode<Object> pattern, TNode<Smi> flags,
+                                      TNode<Context> context);
 
-  TNode<JSArray> EmitCreateShallowArrayLiteral(
+  TNode<JSArray> CreateShallowArrayLiteral(
       TNode<FeedbackVector> feedback_vector, TNode<TaggedIndex> slot,
-      TNode<Context> context, Label* call_runtime,
-      AllocationSiteMode allocation_site_mode);
+      TNode<Context> context, AllocationSiteMode allocation_site_mode,
+      Label* call_runtime);
 
-  TNode<JSArray> EmitCreateEmptyArrayLiteral(
-      TNode<FeedbackVector> feedback_vector, TNode<TaggedIndex> slot,
-      TNode<Context> context);
+  TNode<JSArray> CreateEmptyArrayLiteral(TNode<FeedbackVector> feedback_vector,
+                                         TNode<TaggedIndex> slot,
+                                         TNode<Context> context);
 
-  TNode<HeapObject> EmitCreateShallowObjectLiteral(
+  TNode<HeapObject> CreateShallowObjectLiteral(
       TNode<FeedbackVector> feedback_vector, TNode<TaggedIndex> slot,
       Label* call_runtime);
-  TNode<JSObject> EmitCreateEmptyObjectLiteral(TNode<Context> context);
+  TNode<JSObject> CreateEmptyObjectLiteral(TNode<Context> context);
 
-  TNode<JSObject> EmitFastNewObject(TNode<Context> context,
-                                    TNode<JSFunction> target,
-                                    TNode<JSReceiver> new_target);
+  TNode<JSObject> FastNewObject(TNode<Context> context,
+                                TNode<JSFunction> target,
+                                TNode<JSReceiver> new_target);
 
-  TNode<JSObject> EmitFastNewObject(TNode<Context> context,
-                                    TNode<JSFunction> target,
-                                    TNode<JSReceiver> new_target,
-                                    Label* call_runtime);
+  TNode<JSObject> FastNewObject(TNode<Context> context,
+                                TNode<JSFunction> target,
+                                TNode<JSReceiver> new_target,
+                                Label* call_runtime);
 };
 
 }  // namespace internal

src/builtins/builtins-definitions.h

@@ -94,14 +94,6 @@ namespace internal {
   ASM(JSBuiltinsConstructStub, Dummy)                                          \
   TFC(FastNewObject, FastNewObject)                                            \
   TFS(FastNewClosure, kSharedFunctionInfo, kFeedbackCell)                      \
-  TFC(FastNewFunctionContextEval, FastNewFunctionContext)                      \
-  TFC(FastNewFunctionContextFunction, FastNewFunctionContext)                  \
-  TFS(CreateEmptyLiteralObject)                                                \
-  TFS(CreateRegExpLiteral, kFeedbackVector, kSlot, kPattern, kFlags)           \
-  TFS(CreateEmptyArrayLiteral, kFeedbackVector, kSlot)                         \
-  TFS(CreateShallowArrayLiteral, kFeedbackVector, kSlot, kConstantElements)    \
-  TFS(CreateShallowObjectLiteral, kFeedbackVector, kSlot,                      \
-      kObjectBoilerplateDescription, kFlags)                                   \
   /* ES6 section 9.5.14 [[Construct]] ( argumentsList, newTarget) */           \
   TFC(ConstructProxy, JSTrampoline)                                            \
                                                                                \
@@ -599,7 +591,6 @@ namespace internal {
   TFS(MapIteratorToList, kSource)                                              \
                                                                                \
   /* ES #sec-number-constructor */                                             \
-  TFJ(NumberConstructor, kDontAdaptArgumentsSentinel)                          \
   CPP(NumberPrototypeToExponential)                                            \
   CPP(NumberPrototypeToFixed)                                                  \
   CPP(NumberPrototypeToLocaleString)                                           \
@@ -637,7 +628,6 @@ namespace internal {
                                                                                \
   /* Object */                                                                 \
   /* ES #sec-object-constructor */                                             \
-  TFJ(ObjectConstructor, kDontAdaptArgumentsSentinel)                          \
   TFJ(ObjectAssign, kDontAdaptArgumentsSentinel)                               \
   /* ES #sec-object.create */                                                  \
   TFJ(ObjectCreate, kDontAdaptArgumentsSentinel)                               \
@@ -788,7 +778,6 @@ namespace internal {
   /* TypedArray */                                                             \
   /* ES #sec-typedarray-constructors */                                        \
   TFJ(TypedArrayBaseConstructor, 0, kReceiver)                                 \
-  TFJ(GenericLazyDeoptContinuation, 1, kReceiver, kResult)                     \
   TFJ(TypedArrayConstructor, kDontAdaptArgumentsSentinel)                      \
   CPP(TypedArrayPrototypeBuffer)                                               \
   /* ES6 #sec-get-%typedarray%.prototype.bytelength */                         \

src/builtins/builtins-regexp-gen.cc

@@ -1104,7 +1104,7 @@ TF_BUILTIN(RegExpConstructor, RegExpBuiltinsAssembler) {
     BIND(&allocate_generic);
     {
       ConstructorBuiltinsAssembler constructor_assembler(this->state());
-      var_regexp = CAST(constructor_assembler.EmitFastNewObject(
+      var_regexp = CAST(constructor_assembler.FastNewObject(
           context, regexp_function, CAST(var_new_target.value())));
       Goto(&next);
     }

src/builtins/constructor.tq

+// Copyright 2020 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/ast/ast.h"
+
+namespace runtime {
+extern runtime CreateArrayLiteral(
+    Context, FeedbackVector, TaggedIndex, ArrayBoilerplateDescription,
+    Smi): HeapObject;
+extern runtime CreateObjectLiteral(
+    Context, FeedbackVector, TaggedIndex, ObjectBoilerplateDescription,
+    Smi): HeapObject;
+}
+
+namespace constructor {
+
+extern builtin FastNewObject(Context, JSFunction, JSReceiver): JSObject;
+
+extern enum AllocationSiteMode constexpr 'AllocationSiteMode' {
+  DONT_TRACK_ALLOCATION_SITE,
+  TRACK_ALLOCATION_SITE
+}
+
+const kIsShallowAndDisableMementos: constexpr int31
+    generates 'AggregateLiteral::Flags::kIsShallowAndDisableMementos';
+const kEvalScope: constexpr ScopeType generates 'ScopeType::EVAL_SCOPE';
+const kFunctionScope:
+    constexpr ScopeType generates 'ScopeType::FUNCTION_SCOPE';
+
+extern macro ConstructorBuiltinsAssembler::FastNewFunctionContext(
+    ScopeInfo, uint32, Context, constexpr ScopeType): Context;
+extern macro ConstructorBuiltinsAssembler::CreateRegExpLiteral(
+    HeapObject, TaggedIndex, Object, Smi, Context): JSRegExp;
+extern macro ConstructorBuiltinsAssembler::CreateShallowArrayLiteral(
+    FeedbackVector, TaggedIndex, Context,
+    constexpr AllocationSiteMode): HeapObject labels CallRuntime;
+extern macro ConstructorBuiltinsAssembler::CreateEmptyArrayLiteral(
+    FeedbackVector, TaggedIndex, Context): HeapObject;
+extern macro ConstructorBuiltinsAssembler::CreateShallowObjectLiteral(
+    FeedbackVector, TaggedIndex): HeapObject labels CallRuntime;
+extern macro ConstructorBuiltinsAssembler::CreateEmptyObjectLiteral(Context):
+    JSObject;
+
+builtin FastNewFunctionContextEval(implicit context: Context)(
+    scopeInfo: ScopeInfo, slots: uint32): Context {
+  return FastNewFunctionContext(scopeInfo, slots, context, kEvalScope);
+}
+
+builtin FastNewFunctionContextFunction(implicit context: Context)(
+    scopeInfo: ScopeInfo, slots: uint32): Context {
+  return FastNewFunctionContext(scopeInfo, slots, context, kFunctionScope);
+}
+
+builtin CreateRegExpLiteral(implicit context: Context)(
+    maybeFeedbackVector: HeapObject, slot: TaggedIndex, pattern: Object,
+    flags: Smi): JSRegExp {
+  return CreateRegExpLiteral(
+      maybeFeedbackVector, slot, pattern, flags, context);
+}
+
+builtin CreateShallowArrayLiteral(implicit context: Context)(
+    feedbackVector: FeedbackVector, slot: TaggedIndex,
+    constantElements: ArrayBoilerplateDescription): HeapObject {
+  try {
+    return CreateShallowArrayLiteral(
+        feedbackVector, slot, context,
+        AllocationSiteMode::DONT_TRACK_ALLOCATION_SITE)
+        otherwise CallRuntime;
+  } label CallRuntime deferred {
+    tail runtime::CreateArrayLiteral(
+        context, feedbackVector, slot, constantElements,
+        SmiConstant(kIsShallowAndDisableMementos));
+  }
+}
+
+builtin CreateEmptyArrayLiteral(implicit context: Context)(
+    feedbackVector: FeedbackVector, slot: TaggedIndex): HeapObject {
+  return CreateEmptyArrayLiteral(feedbackVector, slot, context);
+}
+
+builtin CreateShallowObjectLiteral(implicit context: Context)(
+    feedbackVector: FeedbackVector, slot: TaggedIndex,
+    desc: ObjectBoilerplateDescription, flags: Smi): HeapObject {
+  try {
+    return CreateShallowObjectLiteral(feedbackVector, slot)
+        otherwise CallRuntime;
+  } label CallRuntime deferred {
+    tail runtime::CreateObjectLiteral(
+        context, feedbackVector, slot, desc, flags);
+  }
+}
+
+// ES #sec-object-constructor
+transitioning javascript builtin
+ObjectConstructor(
+    js-implicit context: NativeContext, receiver: JSAny, newTarget: JSAny,
+    target: JSFunction)(...arguments): JSAny {
+  if (newTarget == Undefined || newTarget == target) {
+    // Not Subclass.
+    const value = arguments[0];
+    if (arguments.length <= 0 || value == Undefined || value == Null) {
+      // New object.
+      return CreateEmptyObjectLiteral(context);
+    } else {
+      return ToObject(context, value);
+    }
+  } else {
+    // Subclass.
+    return FastNewObject(context, target, UnsafeCast<JSReceiver>(newTarget));
+  }
+}
+
+builtin CreateEmptyLiteralObject(implicit context: Context)(): JSAny {
+  return CreateEmptyObjectLiteral(context);
+}
+
+// ES #sec-number-constructor
+transitioning javascript builtin
+NumberConstructor(
+    js-implicit context: NativeContext, receiver: JSAny, newTarget: JSAny,
+    target: JSFunction)(...arguments): JSAny {
+  // 1. If no arguments were passed to this function invocation, let n be +0.
+  let n: Number = 0;
+  if (arguments.length > 0) {
+    // 2. Else,
+    //    a. Let prim be ? ToNumeric(value).
+    //    b. If Type(prim) is BigInt, let n be the Number value for prim.
+    //    c. Otherwise, let n be prim.
+    const value = arguments[0];
+    n = ToNumber(value, BigIntHandling::kConvertToNumber);
+  }
+
+  // 3. If NewTarget is undefined, return n.
+  if (newTarget == Undefined) return n;
+
+  // 4. Let O be ? OrdinaryCreateFromConstructor(NewTarget,
+  //    "%NumberPrototype%", « [[NumberData]] »).
+  // 5. Set O.[[NumberData]] to n.
+  // 6. Return O.
+
+  // We ignore the normal target parameter and load the value from the
+  // current frame here in order to reduce register pressure on the fast path.
+  const target: JSFunction = LoadTargetFromFrame();
+  const result = UnsafeCast<JSPrimitiveWrapper>(
+      FastNewObject(context, target, UnsafeCast<JSReceiver>(newTarget)));
+  result.value = n;
+  return result;
+}
+
+javascript builtin
+GenericLazyDeoptContinuation(js-implicit context: NativeContext)(result: JSAny):
+    JSAny {
+  return result;
+}
+
+}  // namespace constructor

src/builtins/promise-constructor.tq

@@ -36,7 +36,7 @@ HasAccessCheckFailed(implicit context: Context)(
   return false;
 }
 
-extern macro ConstructorBuiltinsAssembler::EmitFastNewObject(
+extern macro ConstructorBuiltinsAssembler::FastNewObject(
     Context, JSFunction, JSReceiver): JSObject;
 
 extern macro
@@ -71,8 +71,8 @@ PromiseConstructor(
   if (promiseFun == newTarget) {
     result = NewJSPromise();
   } else {
-    result = UnsafeCast<JSPromise>(EmitFastNewObject(
-        context, promiseFun, UnsafeCast<JSReceiver>(newTarget)));
+    result = UnsafeCast<JSPromise>(
+        FastNewObject(context, promiseFun, UnsafeCast<JSReceiver>(newTarget)));
     PromiseInit(result);
     if (IsPromiseHookEnabledOrHasAsyncEventDelegate()) {
       runtime::PromiseHookInit(result, Undefined);

src/codegen/arm/interface-descriptors-arm.cc

@@ -46,11 +46,6 @@ void EphemeronKeyBarrierDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
 }
 
-const Register FastNewFunctionContextDescriptor::ScopeInfoRegister() {
-  return r1;
-}
-const Register FastNewFunctionContextDescriptor::SlotsRegister() { return r0; }
-
 const Register LoadDescriptor::ReceiverRegister() { return r1; }
 const Register LoadDescriptor::NameRegister() { return r2; }
 const Register LoadDescriptor::SlotRegister() { return r0; }

src/codegen/arm64/interface-descriptors-arm64.cc

@@ -46,11 +46,6 @@ void EphemeronKeyBarrierDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
 }
 
-const Register FastNewFunctionContextDescriptor::ScopeInfoRegister() {
-  return x1;
-}
-const Register FastNewFunctionContextDescriptor::SlotsRegister() { return x0; }
-
 const Register LoadDescriptor::ReceiverRegister() { return x1; }
 const Register LoadDescriptor::NameRegister() { return x2; }
 const Register LoadDescriptor::SlotRegister() { return x0; }

src/codegen/ia32/interface-descriptors-ia32.cc

@@ -49,11 +49,6 @@ void EphemeronKeyBarrierDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
 }
 
-const Register FastNewFunctionContextDescriptor::ScopeInfoRegister() {
-  return edi;
-}
-const Register FastNewFunctionContextDescriptor::SlotsRegister() { return eax; }
-
 const Register LoadDescriptor::ReceiverRegister() { return edx; }
 const Register LoadDescriptor::NameRegister() { return ecx; }
 const Register LoadDescriptor::SlotRegister() { return eax; }

src/codegen/interface-descriptors.cc

@@ -177,12 +177,6 @@ void InterpreterCEntry2Descriptor::InitializePlatformSpecific(
   InterpreterCEntryDescriptor_InitializePlatformSpecific(data);
 }
 
-void FastNewFunctionContextDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  Register registers[] = {ScopeInfoRegister(), SlotsRegister()};
-  data->InitializePlatformSpecific(arraysize(registers), registers);
-}
-
 void FastNewObjectDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   Register registers[] = {TargetRegister(), NewTargetRegister()};

src/codegen/interface-descriptors.h

@@ -59,7 +59,6 @@ namespace internal {
   V(ContextOnly)                         \
   V(CppBuiltinAdaptor)                   \
   V(EphemeronKeyBarrier)                 \
-  V(FastNewFunctionContext)              \
   V(FastNewObject)                       \
   V(FrameDropperTrampoline)              \
   V(GetIteratorStackParameter)           \
@@ -837,17 +836,6 @@ class LoadGlobalWithVectorDescriptor : public LoadGlobalDescriptor {
 #endif
 };
 
-class FastNewFunctionContextDescriptor : public CallInterfaceDescriptor {
- public:
-  DEFINE_PARAMETERS(kScopeInfo, kSlots)
-  DEFINE_PARAMETER_TYPES(MachineType::AnyTagged(),  // kScopeInfo
-                         MachineType::Uint32())     // kSlots
-  DECLARE_DESCRIPTOR(FastNewFunctionContextDescriptor, CallInterfaceDescriptor)
-
-  static const Register ScopeInfoRegister();
-  static const Register SlotsRegister();
-};
-
 class FastNewObjectDescriptor : public CallInterfaceDescriptor {
  public:
   DEFINE_PARAMETERS(kTarget, kNewTarget)

src/codegen/mips/interface-descriptors-mips.cc

@@ -72,11 +72,6 @@ void EphemeronKeyBarrierDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
 }
 
-const Register FastNewFunctionContextDescriptor::ScopeInfoRegister() {
-  return a1;
-}
-const Register FastNewFunctionContextDescriptor::SlotsRegister() { return a0; }
-
 const Register LoadDescriptor::ReceiverRegister() { return a1; }
 const Register LoadDescriptor::NameRegister() { return a2; }
 const Register LoadDescriptor::SlotRegister() { return a0; }

src/codegen/mips64/interface-descriptors-mips64.cc

@@ -72,11 +72,6 @@ void EphemeronKeyBarrierDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
 }
 
-const Register FastNewFunctionContextDescriptor::ScopeInfoRegister() {
-  return a1;
-}
-const Register FastNewFunctionContextDescriptor::SlotsRegister() { return a0; }
-
 const Register LoadDescriptor::ReceiverRegister() { return a1; }
 const Register LoadDescriptor::NameRegister() { return a2; }
 const Register LoadDescriptor::SlotRegister() { return a0; }

src/codegen/ppc/interface-descriptors-ppc.cc

@@ -46,11 +46,6 @@ void EphemeronKeyBarrierDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
 }
 
-const Register FastNewFunctionContextDescriptor::ScopeInfoRegister() {
-  return r4;
-}
-const Register FastNewFunctionContextDescriptor::SlotsRegister() { return r3; }
-
 const Register LoadDescriptor::ReceiverRegister() { return r4; }
 const Register LoadDescriptor::NameRegister() { return r5; }
 const Register LoadDescriptor::SlotRegister() { return r3; }

src/codegen/s390/interface-descriptors-s390.cc

@@ -46,11 +46,6 @@ void EphemeronKeyBarrierDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
 }
 
-const Register FastNewFunctionContextDescriptor::ScopeInfoRegister() {
-  return r3;
-}
-const Register FastNewFunctionContextDescriptor::SlotsRegister() { return r2; }
-
 const Register LoadDescriptor::ReceiverRegister() { return r3; }
 const Register LoadDescriptor::NameRegister() { return r4; }
 const Register LoadDescriptor::SlotRegister() { return r2; }

src/codegen/x64/interface-descriptors-x64.cc

@@ -48,11 +48,6 @@ void EphemeronKeyBarrierDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
 }
 
-const Register FastNewFunctionContextDescriptor::ScopeInfoRegister() {
-  return rdi;
-}
-const Register FastNewFunctionContextDescriptor::SlotsRegister() { return rax; }
-
 const Register LoadDescriptor::ReceiverRegister() { return rdx; }
 const Register LoadDescriptor::NameRegister() { return rcx; }
 const Register LoadDescriptor::SlotRegister() { return rax; }

src/interpreter/interpreter-generator.cc

@@ -2239,8 +2239,8 @@ IGNITION_HANDLER(CreateRegExpLiteral, InterpreterAssembler) {
   TVARIABLE(JSRegExp, result);
 
   ConstructorBuiltinsAssembler constructor_assembler(state());
-  result = constructor_assembler.EmitCreateRegExpLiteral(
-      feedback_vector, slot, pattern, flags, context);
+  result = constructor_assembler.CreateRegExpLiteral(feedback_vector, slot,
+                                                     pattern, flags, context);
   SetAccumulator(result.value());
   Dispatch();
 }
@@ -2266,9 +2266,9 @@ IGNITION_HANDLER(CreateArrayLiteral, InterpreterAssembler) {
   BIND(&fast_shallow_clone);
   {
     ConstructorBuiltinsAssembler constructor_assembler(state());
-    TNode<JSArray> result = constructor_assembler.EmitCreateShallowArrayLiteral(
-        CAST(feedback_vector), slot, context, &call_runtime,
-        TRACK_ALLOCATION_SITE);
+    TNode<JSArray> result = constructor_assembler.CreateShallowArrayLiteral(
+        CAST(feedback_vector), slot, context, TRACK_ALLOCATION_SITE,
+        &call_runtime);
     SetAccumulator(result);
     Dispatch();
   }
@@ -2301,7 +2301,7 @@ IGNITION_HANDLER(CreateEmptyArrayLiteral, InterpreterAssembler) {
   GotoIf(IsUndefined(maybe_feedback_vector), &no_feedback);
 
   ConstructorBuiltinsAssembler constructor_assembler(state());
-  result = constructor_assembler.EmitCreateEmptyArrayLiteral(
+  result = constructor_assembler.CreateEmptyArrayLiteral(
       CAST(maybe_feedback_vector), slot, context);
   Goto(&end);
 
@@ -2356,9 +2356,8 @@ IGNITION_HANDLER(CreateObjectLiteral, InterpreterAssembler) {
   {
     // If we can do a fast clone do the fast-path in CreateShallowObjectLiteral.
     ConstructorBuiltinsAssembler constructor_assembler(state());
-    TNode<HeapObject> result =
-        constructor_assembler.EmitCreateShallowObjectLiteral(
-            CAST(feedback_vector), slot, &if_not_fast_clone);
+    TNode<HeapObject> result = constructor_assembler.CreateShallowObjectLiteral(
+        CAST(feedback_vector), slot, &if_not_fast_clone);
     SetAccumulator(result);
     Dispatch();
   }
@@ -2391,7 +2390,7 @@ IGNITION_HANDLER(CreateEmptyObjectLiteral, InterpreterAssembler) {
   TNode<Context> context = GetContext();
   ConstructorBuiltinsAssembler constructor_assembler(state());
   TNode<JSObject> result =
-      constructor_assembler.EmitCreateEmptyObjectLiteral(context);
+      constructor_assembler.CreateEmptyObjectLiteral(context);
   SetAccumulator(result);
   Dispatch();
 }
@@ -2521,7 +2520,7 @@ IGNITION_HANDLER(CreateFunctionContext, InterpreterAssembler) {
   TNode<Uint32T> slots = BytecodeOperandUImm(1);
   TNode<Context> context = GetContext();
   ConstructorBuiltinsAssembler constructor_assembler(state());
-  SetAccumulator(constructor_assembler.EmitFastNewFunctionContext(
+  SetAccumulator(constructor_assembler.FastNewFunctionContext(
       scope_info, slots, context, FUNCTION_SCOPE));
   Dispatch();
 }
@@ -2535,7 +2534,7 @@ IGNITION_HANDLER(CreateEvalContext, InterpreterAssembler) {
   TNode<Uint32T> slots = BytecodeOperandUImm(1);
   TNode<Context> context = GetContext();
   ConstructorBuiltinsAssembler constructor_assembler(state());
-  SetAccumulator(constructor_assembler.EmitFastNewFunctionContext(
+  SetAccumulator(constructor_assembler.FastNewFunctionContext(
       scope_info, slots, context, EVAL_SCOPE));
   Dispatch();
 }