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());
+}
+
+Node* CodeStubAssembler::FixedCowArrayMapConstant() {
+  return HeapConstant(isolate()->factory()->fixed_cow_array_map());
+}
+
 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::AllocateEmptyJSArray(ElementsKind kind,

[rmcilroy, 2016/09/13 20:29:59]

Maybe we should call this something like AllocateUninitializedJSArray to avoid
confusion with a valid empty array (since this won't be valid until elements is
set AFAIU). If so, I would just keep AllocateFilledJSArray as AllocateJSArray to
make it obvious this is the one everyone should use unless they know better.

[klaasb, 2016/09/14 18:24:51]

Done.

+                                              Node* array_map, Node* length,
+                                              Node* allocation_site,
+                                              ParameterMode mode,
+                                              Node* capacity) {
+  Comment("begin allocation of JSArray");
 
-  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) {
+    base_size += FixedArray::kHeaderSize;
+    total_size = ElementOffsetFromIndex(capacity, kind, 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);
+
   StoreMapNoWriteBarrier(array, array_map);
-  Node* empty_properties = LoadRoot(Heap::kEmptyFixedArrayRootIndex);
-  StoreObjectFieldNoWriteBarrier(array, JSArray::kPropertiesOffset,
-                                 empty_properties);
+
   StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset,
-                                 TagParameter(length_node, mode));
+                                 TagParameter(length, mode));
+
+  StoreObjectFieldRoot(array, JSArray::kPropertiesOffset,
+                       Heap::kEmptyFixedArrayRootIndex);
+
+  if (capacity != nullptr) {
+    Node* elements = InnerAllocate(array, elements_offset);
+    StoreObjectField(array, JSObject::kElementsOffset, elements);
+  }
 
   if (allocation_site != nullptr) {
     InitializeAllocationMemento(array, JSArray::kSize, allocation_site);
   }
 
+  return array;
+}
+
+Node* CodeStubAssembler::AllocateFilledJSArray(ElementsKind kind,
+                                               Node* array_map, Node* capacity,
+                                               Node* length,
+                                               Node* allocation_site,
+                                               ParameterMode mode) {
+  bool is_double = IsFastDoubleElementsKind(kind);
+  int elements_offset =
+      JSArray::kSize +
+      (allocation_site != nullptr ? AllocationMemento::kSize : 0);
+
+  // Allocate both array and elements object, and initialize the JSArray.
+  Node* array = AllocateEmptyJSArray(kind, array_map, length, allocation_site,
+                                     mode, capacity);
+  Node* elements = InnerAllocate(array, elements_offset);

[rmcilroy, 2016/09/13 20:29:58]

Do you do this twice? There is an InnerAllocate for AllocateEmptyJSArray if
capacity is nullptr. Maybe just avoid the capacity parameter on
AllocateEmptyJSArray and always do it here?

[klaasb, 2016/09/14 18:24:51]

We still want to allocate space for the array and the elements at the same time,
so we'd still need the parameter for that.
I changed AllocateUninitializedJSArray to return both which also gets rid of the
elements_offset calculation here and in the stub.

+
   // 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 843 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