[stubs] Remove N-argument Hydrogen-based Array constructor stub

src/code-stubs.cc

 // Copyright 2012 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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 4483 matching lines @@
       os << "_One";
       break;
     case MORE_THAN_ONE:
       os << "_More_Than_One";
       break;
   }
   return;
 }
 
 
-std::ostream& ArrayConstructorStubBase::BasePrintName(
-    std::ostream& os,  // NOLINT
-    const char* name) const {
-  os << name << "_" << ElementsKindToString(elements_kind());
-  if (override_mode() == DISABLE_ALLOCATION_SITES) {
-    os << "_DISABLE_ALLOCATION_SITES";
-  }
-  return os;
-}
-
 bool ToBooleanICStub::UpdateStatus(Handle<Object> object) {
   Types new_types = types();
   Types old_types = new_types;
   bool to_boolean_value = new_types.UpdateStatus(isolate(), object);
   TraceTransition(old_types, new_types);
   set_sub_minor_key(TypesBits::update(sub_minor_key(), new_types.ToIntegral()));
   return to_boolean_value;
 }
 
 void ToBooleanICStub::PrintState(std::ostream& os) const {  // NOLINT
@@ skipping 117 matching lines @@
       assembler->IntPtrConstant(0), nullptr);
   assembler->Return(array);
 }
 
 namespace {
 
 void SingleArgumentConstructorCommon(CodeStubAssembler* assembler,
                                      ElementsKind elements_kind,
                                      compiler::Node* array_map,
                                      compiler::Node* allocation_site,
-                                     Runtime::FunctionId runtime_fallback,
                                      AllocationSiteMode mode) {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Label Label;
 
   Label ok(assembler);
   Label smi_size(assembler);
   Label small_smi_size(assembler);
   Label call_runtime(assembler, Label::kDeferred);
 
   Node* size = assembler->Parameter(
@@ skipping 18 matching lines @@
         elements_kind, array_map, size, size,
         mode == DONT_TRACK_ALLOCATION_SITE ? nullptr : allocation_site,
         CodeStubAssembler::SMI_PARAMETERS);
     assembler->Return(array);
   }
 
   assembler->Bind(&call_runtime);
   {
     Node* context = assembler->Parameter(
         ArraySingleArgumentConstructorDescriptor::kContextIndex);
-    Node* constructor = assembler->Parameter(
+    Node* function = assembler->Parameter(
         ArraySingleArgumentConstructorDescriptor::kFunctionIndex);
-    Node* argument_count = assembler->Parameter(
-        ArraySingleArgumentConstructorDescriptor::kArgumentsCountIndex);
-    Node* argument_base_offset = assembler->IntPtrAdd(
-        assembler->IntPtrConstant(CommonFrameConstants::kFixedFrameSizeAboveFp -
-                                  kPointerSize),
-        assembler->Word32Shl(argument_count,
-                             assembler->IntPtrConstant(kPointerSizeLog2)));
-    Node* argument_base = assembler->IntPtrAdd(assembler->LoadFramePointer(),
-                                               argument_base_offset);
-    Node* array = assembler->CallRuntime(
-        runtime_fallback, context, constructor, argument_base,
-        assembler->SmiTag(argument_count), allocation_site);
-    assembler->Return(array);
+    Node* array_size = assembler->Parameter(
+        ArraySingleArgumentConstructorDescriptor::kArraySizeSmiParameterIndex);
+    Node* allocation_site = assembler->Parameter(
+        ArraySingleArgumentConstructorDescriptor::kAllocationSiteIndex);
+    assembler->TailCallRuntime(Runtime::kNewArray, context, function,
+                               array_size, function, allocation_site);
   }
 }
 }  // namespace
 
 void ArraySingleArgumentConstructorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
   Node* function = assembler->Parameter(
       ArraySingleArgumentConstructorDescriptor::kFunctionIndex);
   Node* native_context =
       assembler->LoadObjectField(function, JSFunction::kContextOffset);
   Node* array_map =
       assembler->LoadJSArrayElementsMap(elements_kind(), native_context);
   AllocationSiteMode mode = override_mode() == DISABLE_ALLOCATION_SITES
                                 ? DONT_TRACK_ALLOCATION_SITE
                                 : AllocationSite::GetMode(elements_kind());
   Node* allocation_site = assembler->Parameter(
       ArrayNoArgumentConstructorDescriptor::kAllocationSiteIndex);
-  SingleArgumentConstructorCommon(
-      assembler, elements_kind(), array_map, allocation_site,
-      Runtime::kArraySingleArgumentConstructor, mode);
+  SingleArgumentConstructorCommon(assembler, elements_kind(), array_map,
+                                  allocation_site, mode);
 }
 
 void InternalArraySingleArgumentConstructorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
   Node* function = assembler->Parameter(
       ArraySingleArgumentConstructorDescriptor::kFunctionIndex);
   Node* array_map = assembler->LoadObjectField(
       function, JSFunction::kPrototypeOrInitialMapOffset);
-  SingleArgumentConstructorCommon(
-      assembler, elements_kind(), array_map, assembler->UndefinedConstant(),
-      Runtime::kArraySingleArgumentConstructor, DONT_TRACK_ALLOCATION_SITE);
+  SingleArgumentConstructorCommon(assembler, elements_kind(), array_map,
+                                  assembler->UndefinedConstant(),
+                                  DONT_TRACK_ALLOCATION_SITE);
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {
   minor_key_ = ArgumentCountBits::encode(ANY);
-  ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 }
 
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate,
                                            int argument_count)
     : PlatformCodeStub(isolate) {
   if (argument_count == 0) {
     minor_key_ = ArgumentCountBits::encode(NONE);
   } else if (argument_count == 1) {
     minor_key_ = ArgumentCountBits::encode(ONE);
   } else if (argument_count >= 2) {
     minor_key_ = ArgumentCountBits::encode(MORE_THAN_ONE);
   } else {
     UNREACHABLE();
   }
-  ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 }
 
-
-InternalArrayConstructorStub::InternalArrayConstructorStub(
-    Isolate* isolate) : PlatformCodeStub(isolate) {
-  InternalArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
-}
-
+InternalArrayConstructorStub::InternalArrayConstructorStub(Isolate* isolate)
+    : PlatformCodeStub(isolate) {}
 
 Representation RepresentationFromType(Type* type) {
   if (type->Is(Type::UntaggedIntegral())) {
     return Representation::Integer32();
   }
 
   if (type->Is(Type::TaggedSigned())) {
     return Representation::Smi();
   }
 
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8