[stubs] Convert InternalArrayNoArgumentsConstructor to a TurboFan stub

src/code-stub-assembler.cc

 // Copyright 2016 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-stub-assembler.h"
 #include "src/code-factory.h"
 
 namespace v8 {
 namespace internal {
 
@@ skipping 538 matching lines @@
   Node* offset = IntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag +
                                 index * kPointerSize);
   return Load(MachineType::AnyTagged(), object, offset);
 }
 
 Node* CodeStubAssembler::LoadNativeContext(Node* context) {
   return LoadFixedArrayElementConstantIndex(context,
                                             Context::NATIVE_CONTEXT_INDEX);
 }
 
+Node* CodeStubAssembler::LoadJSArrayElementsMap(ElementsKind kind,
+                                                Node* native_context) {
+  return LoadFixedArrayElementConstantIndex(native_context,
+                                            Context::ArrayMapIndex(kind));
+}
+
 Node* CodeStubAssembler::StoreHeapNumberValue(Node* object, Node* value) {
   return StoreNoWriteBarrier(
       MachineRepresentation::kFloat64, object,
       IntPtrConstant(HeapNumber::kValueOffset - kHeapObjectTag), value);
 }
 
 Node* CodeStubAssembler::StoreObjectField(
     Node* object, int offset, Node* value) {
   return Store(MachineRepresentation::kTagged, object,
                IntPtrConstant(offset - kHeapObjectTag), value);
@@ skipping 94 matching lines @@
 Node* CodeStubAssembler::AllocateSeqTwoByteString(int length) {
   Node* result = Allocate(SeqTwoByteString::SizeFor(length));
   StoreMapNoWriteBarrier(result, LoadRoot(Heap::kStringMapRootIndex));
   StoreObjectFieldNoWriteBarrier(result, SeqTwoByteString::kLengthOffset,
                                  SmiConstant(Smi::FromInt(length)));
   StoreObjectFieldNoWriteBarrier(result, SeqTwoByteString::kHashFieldSlot,
                                  IntPtrConstant(String::kEmptyHashField));
   return result;
 }
 
-Node* CodeStubAssembler::AllocateJSArray(ElementsKind kind,
-                                         Node* native_context, int capacity,
-                                         int length,
+Node* CodeStubAssembler::AllocateJSArray(ElementsKind kind, Node* array_map,
+                                         int capacity, int length,
                                          compiler::Node* allocation_site) {
   bool is_double = IsFastDoubleElementsKind(kind);
   int element_size = is_double ? kDoubleSize : kPointerSize;
   int total_size =
       JSArray::kSize + FixedArray::kHeaderSize + element_size * capacity;
   int elements_offset = JSArray::kSize;
 
   if (allocation_site != nullptr) {
     total_size += AllocationMemento::kSize;
     elements_offset += AllocationMemento::kSize;
   }
 
   // Allocate both array and elements object, and initialize the JSArray.
   Heap* heap = isolate()->heap();
   Node* array = Allocate(total_size);
-  Node* array_map = LoadFixedArrayElementConstantIndex(
-      native_context, Context::ArrayMapIndex(kind));
   StoreMapNoWriteBarrier(array, array_map);
   Node* empty_properties =
       HeapConstant(Handle<HeapObject>(heap->empty_fixed_array()));
   StoreObjectFieldNoWriteBarrier(array, JSArray::kPropertiesOffset,
                                  empty_properties);
   StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset,
                                  SmiConstant(Smi::FromInt(length)));
 
   if (allocation_site != nullptr) {
     InitializeAllocationMemento(array, JSArray::kSize, allocation_site);
@@ skipping 556 matching lines @@
 }
 
 Node* CodeStubAssembler::BitFieldDecode(Node* word32, uint32_t shift,
                                         uint32_t mask) {
   return Word32Shr(Word32And(word32, Int32Constant(mask)),
                    Int32Constant(shift));
 }
 
 }  // namespace internal
 }  // namespace v8