Port FastCloneShallowArrayStub to Turbofan

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 28 matching lines @@
 }
 
 Node* CodeStubAssembler::BooleanMapConstant() {
   return HeapConstant(isolate()->factory()->boolean_map());
 }
 
 Node* CodeStubAssembler::EmptyStringConstant() {
   return LoadRoot(Heap::kempty_stringRootIndex);
 }
 
+Node* CodeStubAssembler::FixedArrayMapConstant() {
+  return HeapConstant(isolate()->factory()->fixed_array_map());
+  // return LoadRoot(Heap::kFixedArrayMapRootIndex);
+}
+
+Node* CodeStubAssembler::FixedCowArrayMapConstant() {
+  return HeapConstant(isolate()->factory()->fixed_cow_array_map());
+  // return LoadRoot(Heap::kFixedCOWArrayMapRootIndex);
+}
+
+Node* CodeStubAssembler::FixedDoubleArrayMapConstant() {
+  return HeapConstant(isolate()->factory()->fixed_double_array_map());
+  // return LoadRoot(Heap::kFixedDoubleArrayMapRootIndex);
+}
+
 Node* CodeStubAssembler::HeapNumberMapConstant() {
   return LoadRoot(Heap::kHeapNumberMapRootIndex);
 }
 
 Node* CodeStubAssembler::NoContextConstant() {
   return SmiConstant(Smi::FromInt(0));
 }
 
 Node* CodeStubAssembler::MinusZeroConstant() {
   return LoadRoot(Heap::kMinusZeroValueRootIndex);
@@ skipping 934 matching lines @@
 }
 
 Node* CodeStubAssembler::LoadProperties(Node* object) {
   return LoadObjectField(object, JSObject::kPropertiesOffset);
 }
 
 Node* CodeStubAssembler::LoadElements(Node* object) {
   return LoadObjectField(object, JSObject::kElementsOffset);
 }
 
+Node* CodeStubAssembler::LoadJSArrayLength(compiler::Node* array) {
+  return LoadObjectField(array, JSArray::kLengthOffset);
+}
+
 Node* CodeStubAssembler::LoadFixedArrayBaseLength(compiler::Node* array) {
   return LoadObjectField(array, FixedArrayBase::kLengthOffset);
 }
 
 Node* CodeStubAssembler::LoadAndUntagFixedArrayBaseLength(Node* array) {
   return LoadAndUntagObjectField(array, FixedArrayBase::kLengthOffset);
 }
 
 Node* CodeStubAssembler::LoadMapBitField(Node* map) {
   return LoadObjectField(map, Map::kBitFieldOffset, MachineType::Uint8());
@@ skipping 346 matching lines @@
     Node* result = CallRuntime(Runtime::kAllocateSeqTwoByteString, context,
                                SmiFromWord(length));
     var_result.Bind(result);
     Goto(&if_join);
   }
 
   Bind(&if_join);
   return var_result.value();
 }
 
-Node* CodeStubAssembler::AllocateJSArray(ElementsKind kind, Node* array_map,
-                                         Node* capacity_node, Node* length_node,
-                                         compiler::Node* allocation_site,
-                                         ParameterMode mode) {
-  bool is_double = IsFastDoubleElementsKind(kind);
-  int base_size = JSArray::kSize + FixedArray::kHeaderSize;
-  int elements_offset = JSArray::kSize;
+Node* CodeStubAssembler::AllocateUninitializedJSArrayWithoutElements(
+    ElementsKind kind, Node* array_map, Node* length, Node* allocation_site) {
+  return AllocateUninitializedJSArray(kind, array_map, length, allocation_site)
+      .first;
+}
 
+std::pair<Node*, Node*> CodeStubAssembler::AllocateUninitializedJSArray(
+    ElementsKind kind, Node* array_map, Node* length, Node* allocation_site,
+    Node* capacity, ParameterMode capacity_mode) {
   Comment("begin allocation of JSArray");
 
+  int base_size = JSArray::kSize;
+
   if (allocation_site != nullptr) {
     base_size += AllocationMemento::kSize;
-    elements_offset += AllocationMemento::kSize;
   }
 
-  Node* total_size =
-      ElementOffsetFromIndex(capacity_node, kind, mode, base_size);
+  int elements_offset = base_size;
+  Node* total_size;
+
+  // Compute space for elements if capacity is not null.
+  if (capacity != nullptr) {

[rmcilroy, 2016/09/16 08:53:51]

Not a great fan of this being an optional nullptr and having to pass
ParameterMode capacity_mode too.How about just passing in elements_size or
total_size as a node and do the calculation outside this function?

[klaasb, 2016/09/19 12:17:59]

Done.

+    base_size += FixedArray::kHeaderSize;
+    total_size =
+        ElementOffsetFromIndex(capacity, kind, capacity_mode, base_size);
+  } else {
+    total_size = IntPtrConstant(base_size);
+  }
 
   // Allocate both array and elements object, and initialize the JSArray.
-  Heap* heap = isolate()->heap();
   Node* array = Allocate(total_size);
+
+  Comment("write JSArray headers");
   StoreMapNoWriteBarrier(array, array_map);
-  Node* empty_properties = LoadRoot(Heap::kEmptyFixedArrayRootIndex);
-  StoreObjectFieldNoWriteBarrier(array, JSArray::kPropertiesOffset,
-                                 empty_properties);
-  StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset,
-                                 TagParameter(length_node, mode));
+
+  StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset, length);
+
+  StoreObjectFieldRoot(array, JSArray::kPropertiesOffset,
+                       Heap::kEmptyFixedArrayRootIndex);
 
   if (allocation_site != nullptr) {
     InitializeAllocationMemento(array, JSArray::kSize, allocation_site);
   }
 
+  if (capacity != nullptr) {
+    Node* elements = InnerAllocate(array, elements_offset);
+    StoreObjectField(array, JSObject::kElementsOffset, elements);
+    return {array, elements};
+  }
+
+  return {array, nullptr};

[rmcilroy, 2016/09/16 08:53:51]

Also not keen on this maybe returning a nullptr. Maybe just add another function
for allocating an array with elements (which calls this one).

[klaasb, 2016/09/19 12:17:59]

Done.

+}
+
+Node* CodeStubAssembler::AllocateJSArray(ElementsKind kind, Node* array_map,
+                                         Node* capacity, Node* length,
+                                         Node* allocation_site,
+                                         ParameterMode mode) {
+  bool is_double = IsFastDoubleElementsKind(kind);
+
+  // Allocate both array and elements object, and initialize the JSArray.
+  Node *array, *elements;
+  std::tie(array, elements) =
+      AllocateUninitializedJSArray(kind, array_map, TagParameter(length, mode),
+                                   allocation_site, capacity, mode);
+
   // Setup elements object.
-  Node* elements = InnerAllocate(array, elements_offset);
-  StoreObjectFieldNoWriteBarrier(array, JSArray::kElementsOffset, elements);
+  Heap* heap = isolate()->heap();
   Handle<Map> elements_map(is_double ? heap->fixed_double_array_map()
                                      : heap->fixed_array_map());
   StoreMapNoWriteBarrier(elements, HeapConstant(elements_map));
   StoreObjectFieldNoWriteBarrier(elements, FixedArray::kLengthOffset,
-                                 TagParameter(capacity_node, mode));
+                                 TagParameter(capacity, mode));
 
   // Fill in the elements with holes.
-  FillFixedArrayWithValue(kind, elements, IntPtrConstant(0), capacity_node,
+  FillFixedArrayWithValue(kind, elements, IntPtrConstant(0), capacity,
                           Heap::kTheHoleValueRootIndex, mode);
 
   return array;
 }
 
 Node* CodeStubAssembler::AllocateFixedArray(ElementsKind kind,
                                             Node* capacity_node,
                                             ParameterMode mode,
                                             AllocationFlags flags) {
   Node* total_size = GetFixedAarrayAllocationSize(capacity_node, kind, mode);
@@ skipping 2431 matching lines @@
                                                     Label* miss) {
   Variable var_length(this, MachineType::PointerRepresentation());
   Label if_array(this), length_loaded(this, &var_length);
   GotoIf(is_jsarray_condition, &if_array);
   {
     var_length.Bind(SmiUntag(LoadFixedArrayBaseLength(elements)));
     Goto(&length_loaded);
   }
   Bind(&if_array);
   {
-    var_length.Bind(SmiUntag(LoadObjectField(object, JSArray::kLengthOffset)));
+    var_length.Bind(SmiUntag(LoadJSArrayLength(object)));
     Goto(&length_loaded);
   }
   Bind(&length_loaded);
   GotoUnless(UintPtrLessThan(intptr_index, var_length.value()), miss);
 }
 
 void CodeStubAssembler::EmitElementLoad(Node* object, Node* elements,
                                         Node* elements_kind, Node* intptr_index,
                                         Node* is_jsarray_condition,
                                         Label* if_hole, Label* rebox_double,
@@ skipping 321 matching lines @@
                                       &var_handler, &try_polymorphic);
   Bind(&if_handler);
   {
     HandleLoadICHandlerCase(p, var_handler.value(), &miss);
   }
 
   Bind(&try_polymorphic);
   {
     // Check polymorphic case.
     Comment("LoadIC_try_polymorphic");
-    GotoUnless(
-        WordEqual(LoadMap(feedback), LoadRoot(Heap::kFixedArrayMapRootIndex)),
-        &try_megamorphic);
+    GotoUnless(WordEqual(LoadMap(feedback), FixedArrayMapConstant()),
+               &try_megamorphic);
     HandlePolymorphicCase(p, receiver_map, feedback, &if_handler, &var_handler,
                           &miss, 2);
   }
 
   Bind(&try_megamorphic);
   {
     // Check megamorphic case.
     GotoUnless(
         WordEqual(feedback, LoadRoot(Heap::kmegamorphic_symbolRootIndex)),
         &miss);
@@ skipping 23 matching lines @@
                                       &var_handler, &try_polymorphic);
   Bind(&if_handler);
   {
     HandleLoadICHandlerCase(p, var_handler.value(), &miss, kSupportElements);
   }
 
   Bind(&try_polymorphic);
   {
     // Check polymorphic case.
     Comment("KeyedLoadIC_try_polymorphic");
-    GotoUnless(
-        WordEqual(LoadMap(feedback), LoadRoot(Heap::kFixedArrayMapRootIndex)),
-        &try_megamorphic);
+    GotoUnless(WordEqual(LoadMap(feedback), FixedArrayMapConstant()),
+               &try_megamorphic);
     HandlePolymorphicCase(p, receiver_map, feedback, &if_handler, &var_handler,
                           &miss, 2);
   }
 
   Bind(&try_megamorphic);
   {
     // Check megamorphic case.
     Comment("KeyedLoadIC_try_megamorphic");
     GotoUnless(
         WordEqual(feedback, LoadRoot(Heap::kmegamorphic_symbolRootIndex)),
@@ skipping 330 matching lines @@
       StoreFixedArrayElement(the_context, mapped_index, value,
                              UPDATE_WRITE_BARRIER, INTPTR_PARAMETERS);
     }
     Goto(&end);
   }
 
   Bind(&if_unmapped);
   {
     Node* backing_store = LoadFixedArrayElement(elements, IntPtrConstant(1), 0,
                                                 INTPTR_PARAMETERS);
-    GotoIf(WordNotEqual(LoadMap(backing_store),
-                        LoadRoot(Heap::kFixedArrayMapRootIndex)),
+    GotoIf(WordNotEqual(LoadMap(backing_store), FixedArrayMapConstant()),
            bailout);
 
     Node* backing_store_length =
         LoadAndUntagFixedArrayBaseLength(backing_store);
     GotoIf(UintPtrGreaterThanOrEqual(key, backing_store_length), bailout);
 
     // The key falls into unmapped range.
     if (is_load) {
       Node* result =
           LoadFixedArrayElement(backing_store, key, 0, INTPTR_PARAMETERS);
@@ skipping 101 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