Revert "[torque] Port some constructor builtins to Torque."

This reverts commit ce249dbb.

Reason for revert: https://ci.chromium.org/p/v8/builders/ci/V8%20Linux64%20GC%20Stress%20-%20custom%20snapshot/32375

Original change's description:
> [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}

TBR=bbudge@chromium.org,jgruber@chromium.org,leszeks@chromium.org,tebbi@chromium.org

Change-Id: I76272a4d439ef95213fdfb659bdbcb71e16daec6
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: v8:9891
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2321111Reviewed-by: Shu-yu Guo <syg@chromium.org>
Commit-Queue: Shu-yu Guo <syg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69084}

BUILD.gn

@@ -1114,7 +1114,6 @@ 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,7 +1107,6 @@ 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,12 +522,6 @@ 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,7 +413,8 @@ TNode<JSObject> BaseCollectionsAssembler::AllocateJSCollectionSlow(
     TNode<Context> context, TNode<JSFunction> constructor,
     TNode<JSReceiver> new_target) {
   ConstructorBuiltinsAssembler constructor_assembler(this->state());
-  return constructor_assembler.FastNewObject(context, constructor, new_target);
+  return constructor_assembler.EmitFastNewObject(context, constructor,
+                                                 new_target);
 }
 
 void BaseCollectionsAssembler::GenerateConstructor(

src/builtins/builtins-constructor-gen.h

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

src/builtins/builtins-definitions.h

@@ -94,6 +94,14 @@ 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)                                            \
                                                                                \
@@ -591,6 +599,7 @@ namespace internal {
   TFS(MapIteratorToList, kSource)                                              \
                                                                                \
   /* ES #sec-number-constructor */                                             \
+  TFJ(NumberConstructor, kDontAdaptArgumentsSentinel)                          \
   CPP(NumberPrototypeToExponential)                                            \
   CPP(NumberPrototypeToFixed)                                                  \
   CPP(NumberPrototypeToLocaleString)                                           \
@@ -628,6 +637,7 @@ namespace internal {
                                                                                \
   /* Object */                                                                 \
   /* ES #sec-object-constructor */                                             \
+  TFJ(ObjectConstructor, kDontAdaptArgumentsSentinel)                          \
   TFJ(ObjectAssign, kDontAdaptArgumentsSentinel)                               \
   /* ES #sec-object.create */                                                  \
   TFJ(ObjectCreate, kDontAdaptArgumentsSentinel)                               \
@@ -778,6 +788,7 @@ 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.FastNewObject(
+      var_regexp = CAST(constructor_assembler.EmitFastNewObject(
           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::FastNewObject(
+extern macro ConstructorBuiltinsAssembler::EmitFastNewObject(
     Context, JSFunction, JSReceiver): JSObject;
 
 extern macro
@@ -71,8 +71,8 @@ PromiseConstructor(
   if (promiseFun == newTarget) {
     result = NewJSPromise();
   } else {
-    result = UnsafeCast<JSPromise>(
-        FastNewObject(context, promiseFun, UnsafeCast<JSReceiver>(newTarget)));
+    result = UnsafeCast<JSPromise>(EmitFastNewObject(
+        context, promiseFun, UnsafeCast<JSReceiver>(newTarget)));
     PromiseInit(result);
     if (IsPromiseHookEnabledOrHasAsyncEventDelegate()) {
       runtime::PromiseHookInit(result, Undefined);

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

@@ -46,6 +46,11 @@ 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,6 +46,11 @@ 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,6 +49,11 @@ 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,6 +177,12 @@ 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,6 +59,7 @@ namespace internal {
   V(ContextOnly)                         \
   V(CppBuiltinAdaptor)                   \
   V(EphemeronKeyBarrier)                 \
+  V(FastNewFunctionContext)              \
   V(FastNewObject)                       \
   V(FrameDropperTrampoline)              \
   V(GetIteratorStackParameter)           \
@@ -836,6 +837,17 @@ 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,6 +72,11 @@ 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,6 +72,11 @@ 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,6 +46,11 @@ 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,6 +46,11 @@ 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,6 +48,11 @@ 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.CreateRegExpLiteral(feedback_vector, slot,
-                                                     pattern, flags, context);
+  result = constructor_assembler.EmitCreateRegExpLiteral(
+      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.CreateShallowArrayLiteral(
-        CAST(feedback_vector), slot, context, TRACK_ALLOCATION_SITE,
-        &call_runtime);
+    TNode<JSArray> result = constructor_assembler.EmitCreateShallowArrayLiteral(
+        CAST(feedback_vector), slot, context, &call_runtime,
+        TRACK_ALLOCATION_SITE);
     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.CreateEmptyArrayLiteral(
+  result = constructor_assembler.EmitCreateEmptyArrayLiteral(
       CAST(maybe_feedback_vector), slot, context);
   Goto(&end);
 
@@ -2356,8 +2356,9 @@ 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.CreateShallowObjectLiteral(
-        CAST(feedback_vector), slot, &if_not_fast_clone);
+    TNode<HeapObject> result =
+        constructor_assembler.EmitCreateShallowObjectLiteral(
+            CAST(feedback_vector), slot, &if_not_fast_clone);
     SetAccumulator(result);
     Dispatch();
   }
@@ -2390,7 +2391,7 @@ IGNITION_HANDLER(CreateEmptyObjectLiteral, InterpreterAssembler) {
   TNode<Context> context = GetContext();
   ConstructorBuiltinsAssembler constructor_assembler(state());
   TNode<JSObject> result =
-      constructor_assembler.CreateEmptyObjectLiteral(context);
+      constructor_assembler.EmitCreateEmptyObjectLiteral(context);
   SetAccumulator(result);
   Dispatch();
 }
@@ -2520,7 +2521,7 @@ IGNITION_HANDLER(CreateFunctionContext, InterpreterAssembler) {
   TNode<Uint32T> slots = BytecodeOperandUImm(1);
   TNode<Context> context = GetContext();
   ConstructorBuiltinsAssembler constructor_assembler(state());
-  SetAccumulator(constructor_assembler.FastNewFunctionContext(
+  SetAccumulator(constructor_assembler.EmitFastNewFunctionContext(
       scope_info, slots, context, FUNCTION_SCOPE));
   Dispatch();
 }
@@ -2534,7 +2535,7 @@ IGNITION_HANDLER(CreateEvalContext, InterpreterAssembler) {
   TNode<Uint32T> slots = BytecodeOperandUImm(1);
   TNode<Context> context = GetContext();
   ConstructorBuiltinsAssembler constructor_assembler(state());
-  SetAccumulator(constructor_assembler.FastNewFunctionContext(
+  SetAccumulator(constructor_assembler.EmitFastNewFunctionContext(
       scope_info, slots, context, EVAL_SCOPE));
   Dispatch();
 }