Move SetFastDoubleElementsCapacity into GrowCapacityAndConvert

src/elements.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/v8.h"
 
 #include "src/arguments.h"
 #include "src/conversions.h"
 #include "src/elements.h"
 #include "src/messages.h"
@@ skipping 626 matching lines @@
   }
 
   virtual void SetLength(Handle<JSArray> array, uint32_t length) final {
     ElementsAccessorSubclass::SetLengthImpl(array, length,
                                             handle(array->elements()));
   }
 
   static void SetLengthImpl(Handle<JSArray> array, uint32_t length,
                             Handle<FixedArrayBase> backing_store);
 
-  static void GrowCapacityAndConvert(Handle<JSObject> obj, int capacity) {
+  static void GrowCapacityAndConvertImpl(Handle<JSObject> obj,
+                                         uint32_t capacity) {
     UNIMPLEMENTED();
   }
 
+  virtual void GrowCapacityAndConvert(Handle<JSObject> object,
+                                      uint32_t capacity) final {
+    ElementsAccessorSubclass::GrowCapacityAndConvertImpl(object, capacity);
+  }
+
   virtual void Delete(Handle<JSObject> obj, uint32_t key,
                       LanguageMode language_mode) override = 0;
 
   static void CopyElementsImpl(FixedArrayBase* from, uint32_t from_start,
                                FixedArrayBase* to, ElementsKind from_kind,
                                uint32_t to_start, int packed_size,
                                int copy_size) {
     UNREACHABLE();
   }
 
@@ skipping 363 matching lines @@
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size)                       \
       case EXTERNAL_##TYPE##_ELEMENTS:                                        \
       case TYPE##_ELEMENTS:                                                   \
         UNREACHABLE();
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
 
 
-  static void GrowCapacityAndConvert(Handle<JSObject> obj, uint32_t capacity) {
+  static void GrowCapacityAndConvertImpl(Handle<JSObject> obj,
+                                         uint32_t capacity) {
     JSObject::SetFastElementsCapacitySmiMode set_capacity_mode =
         obj->HasFastSmiElements()
             ? JSObject::kAllowSmiElements
             : JSObject::kDontAllowSmiElements;
     JSObject::SetFastElementsCapacity(obj, capacity, set_capacity_mode);
   }
 };
 
 
 class FastPackedSmiElementsAccessor
@@ skipping 46 matching lines @@
 
 template<typename FastElementsAccessorSubclass,
          typename KindTraits>
 class FastDoubleElementsAccessor
     : public FastElementsAccessor<FastElementsAccessorSubclass, KindTraits> {
  public:
   explicit FastDoubleElementsAccessor(const char* name)
       : FastElementsAccessor<FastElementsAccessorSubclass,
                              KindTraits>(name) {}
 
-  static void GrowCapacityAndConvert(Handle<JSObject> obj, uint32_t capacity) {
-    JSObject::SetFastDoubleElementsCapacity(obj, capacity);
+  static void GrowCapacityAndConvertImpl(Handle<JSObject> object,
+                                         uint32_t capacity) {
+    Handle<FixedArrayBase> elements =
+        object->GetIsolate()->factory()->NewFixedDoubleArray(capacity);
+    ElementsKind from_kind = object->GetElementsKind();
+    ElementsKind to_kind = IsHoleyElementsKind(from_kind)
+                               ? FAST_HOLEY_DOUBLE_ELEMENTS
+                               : FAST_DOUBLE_ELEMENTS;
+
+    Handle<Map> new_map = JSObject::GetElementsTransitionMap(object, to_kind);
+
+    Handle<FixedArrayBase> old_elements(object->elements());
+    int packed = kPackedSizeNotKnown;
+    if (IsFastPackedElementsKind(from_kind) && object->IsJSArray()) {
+      packed = Smi::cast(JSArray::cast(*object)->length())->value();
+    }
+    CopyElementsImpl(*old_elements, 0, *elements, from_kind, 0, packed,
+                     ElementsAccessor::kCopyToEndAndInitializeToHole);
+
+    JSObject::SetMapAndElements(object, new_map, elements);
+    JSObject::ValidateElements(object);
+
+    if (FLAG_trace_elements_transitions) {
+      JSObject::PrintElementsTransition(stdout, object, from_kind, old_elements,
+                                        to_kind, elements);
+    }
   }
 
  protected:
   static void CopyElementsImpl(FixedArrayBase* from, uint32_t from_start,
                                FixedArrayBase* to, ElementsKind from_kind,
                                uint32_t to_start, int packed_size,
                                int copy_size) {
     DisallowHeapAllocation no_allocation;
     switch (from_kind) {
       case FAST_SMI_ELEMENTS:
@@ skipping 544 matching lines @@
           *backing_store, capacity - length);
     } else {
       // Otherwise, fill the unused tail with holes.
       for (uint32_t i = length; i < old_length; i++) {
         BackingStore::cast(*backing_store)->set_the_hole(i);
       }
     }
   } else {
     // Check whether the backing store should be expanded.
     capacity = Max(length, JSObject::NewElementsCapacity(capacity));
-    ElementsAccessorSubclass::GrowCapacityAndConvert(array, capacity);
+    ElementsAccessorSubclass::GrowCapacityAndConvertImpl(array, capacity);
   }
 
   array->set_length(Smi::FromInt(length));
   JSObject::ValidateElements(array);
 }
 
 
 MaybeHandle<Object> ArrayConstructInitializeElements(Handle<JSArray> array,
                                                      Arguments* args) {
   if (args->length() == 0) {
@@ skipping 79 matching lines @@
       break;
   }
 
   array->set_elements(*elms);
   array->set_length(Smi::FromInt(number_of_elements));
   return array;
 }
 
 }  // namespace internal
 }  // namespace v8