[stubs] Cleanup FixedArray copying builtin

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"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
@@ skipping 1374 matching lines @@
       mode == SMI_PARAMETERS ? capacity_node : SmiTag(capacity_node));
 
   FillFixedArrayWithHole(kind, elements, IntPtrConstant(0), capacity_node,
                          mode);
 
   return array;
 }
 
 Node* CodeStubAssembler::AllocateFixedArray(ElementsKind kind,
                                             Node* capacity_node,
-                                            ParameterMode mode) {
-  Node* total_size = ElementOffsetFromIndex(capacity_node, kind, mode,
-                                            FixedArray::kHeaderSize);
+                                            ParameterMode mode,
+                                            AllocationFlags flags) {
+  Node* total_size = GetFixedAarrayAllocationSize(capacity_node, kind, mode);
 
   // Allocate both array and elements object, and initialize the JSArray.
-  Node* array = Allocate(total_size);
+  Node* array = Allocate(total_size, flags);
   Heap* heap = isolate()->heap();
   Handle<Map> map(IsFastDoubleElementsKind(kind)
                       ? heap->fixed_double_array_map()
                       : heap->fixed_array_map());
-  StoreMapNoWriteBarrier(array, HeapConstant(map));
+  if (flags & kPretenured) {
+    StoreObjectField(array, JSObject::kMapOffset, HeapConstant(map));
+  } else {
+    StoreMapNoWriteBarrier(array, HeapConstant(map));
+  }
   StoreObjectFieldNoWriteBarrier(
       array, FixedArray::kLengthOffset,
       mode == INTEGER_PARAMETERS ? SmiTag(capacity_node) : capacity_node);
   return array;
 }
 
 void CodeStubAssembler::FillFixedArrayWithHole(ElementsKind kind,
                                                compiler::Node* array,
                                                compiler::Node* from_node,
                                                compiler::Node* to_node,
@@ skipping 170 matching lines @@
   Node* max_gap = IntPtrOrSmiConstant(JSObject::kMaxGap, mode);
   Node* max_capacity = IntPtrAdd(capacity, max_gap);
   GotoIf(UintPtrGreaterThanOrEqual(key, max_capacity), fail);
 
   // Calculate the capacity of the new backing tore
   Node* new_capacity = CalculateNewElementsCapacity(
       IntPtrAdd(key, IntPtrOrSmiConstant(1, mode)), mode);
 
   // If size of the allocation for the new capacity doesn't fit in a page
   // that we can bump-pointer allocate from, fall back to the runtime,
-  int max_size = ((Page::kMaxRegularHeapObjectSize - FixedArray::kHeaderSize) >>
-                  ElementsKindToShiftSize(kind));
+  int max_size = FixedArrayBase::GetMaxLengthForNewSpaceAllocation(kind);
   GotoIf(UintPtrGreaterThanOrEqual(new_capacity,
                                    IntPtrOrSmiConstant(max_size, mode)),
          fail);
 
   // Allocate the new backing store.
   Node* new_elements = AllocateFixedArray(kind, new_capacity, mode);
 
   // Fill in the added capacity in the new store with holes.
   FillFixedArrayWithHole(kind, new_elements, capacity, new_capacity, mode);
 
@@ skipping 2338 matching lines @@
                        Heap::kTheHoleValueRootIndex);
 
   // Store the WeakCell in the feedback vector.
   StoreFixedArrayElement(feedback_vector, slot, cell, UPDATE_WRITE_BARRIER,
                          CodeStubAssembler::SMI_PARAMETERS);
   return cell;
 }
 
 }  // namespace internal
 }  // namespace v8