Port FastCloneShallowArrayStub to Turbofan

src/code-stub-assembler.h

 // 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.
 
 #ifndef V8_CODE_STUB_ASSEMBLER_H_
 #define V8_CODE_STUB_ASSEMBLER_H_
 
 #include <functional>
 
 #include "src/compiler/code-assembler.h"
@@ skipping 54 matching lines @@
     return value;
   }
 
   compiler::Node* TagParameter(compiler::Node* value, ParameterMode mode) {
     if (mode != SMI_PARAMETERS) value = SmiTag(value);
     return value;
   }
 
   compiler::Node* BooleanMapConstant();
   compiler::Node* EmptyStringConstant();
+  compiler::Node* FixedArrayMapConstant();
+  compiler::Node* FixedCowArrayMapConstant();
+  compiler::Node* FixedDoubleArrayMapConstant();
   compiler::Node* HeapNumberMapConstant();
   compiler::Node* NoContextConstant();
   compiler::Node* NanConstant();
   compiler::Node* NullConstant();
   compiler::Node* MinusZeroConstant();
   compiler::Node* UndefinedConstant();
   compiler::Node* TheHoleConstant();
   compiler::Node* HashSeed();
   compiler::Node* StaleRegisterConstant();
 
@@ skipping 118 matching lines @@
   // Load the Map of an HeapObject.
   compiler::Node* LoadMap(compiler::Node* object);
   // Load the instance type of an HeapObject.
   compiler::Node* LoadInstanceType(compiler::Node* object);
   // Checks that given heap object has given instance type.
   void AssertInstanceType(compiler::Node* object, InstanceType instance_type);
   // Load the properties backing store of a JSObject.
   compiler::Node* LoadProperties(compiler::Node* object);
   // Load the elements backing store of a JSObject.
   compiler::Node* LoadElements(compiler::Node* object);
+  // Load the length of a JSArray instance.
+  compiler::Node* LoadJSArrayLength(compiler::Node* array);
   // Load the length of a fixed array base instance.
   compiler::Node* LoadFixedArrayBaseLength(compiler::Node* array);
   // Load the length of a fixed array base instance.
   compiler::Node* LoadAndUntagFixedArrayBaseLength(compiler::Node* array);
   // Load the bit field of a Map.
   compiler::Node* LoadMapBitField(compiler::Node* map);
   // Load bit field 2 of a map.
   compiler::Node* LoadMapBitField2(compiler::Node* map);
   // Load bit field 3 of a map.
   compiler::Node* LoadMapBitField3(compiler::Node* map);
@@ skipping 87 matching lines @@
   compiler::Node* AllocateHeapNumberWithValue(compiler::Node* value,
                                               MutableMode mode = IMMUTABLE);
   // Allocate a SeqOneByteString with the given length.
   compiler::Node* AllocateSeqOneByteString(int length);
   compiler::Node* AllocateSeqOneByteString(compiler::Node* context,
                                            compiler::Node* length);
   // Allocate a SeqTwoByteString with the given length.
   compiler::Node* AllocateSeqTwoByteString(int length);
   compiler::Node* AllocateSeqTwoByteString(compiler::Node* context,
                                            compiler::Node* length);
-  // Allocated an JSArray
+  // Allocate a JSArray without elements and initialize the header fields.
+  compiler::Node* AllocateUninitializedJSArrayWithoutElements(
+      ElementsKind kind, compiler::Node* array_map, compiler::Node* length,
+      compiler::Node* allocation_site);
+  // Allocate and return a JSArray and its uninitialized elements.
+  // Also initializes JSArray header fields.
+  std::pair<compiler::Node*, compiler::Node*>
+  AllocateUninitializedJSArrayWithElements(
+      ElementsKind kind, compiler::Node* array_map, compiler::Node* length,
+      compiler::Node* allocation_site, compiler::Node* capacity,
+      ParameterMode capacity_mode = INTEGER_PARAMETERS);

[Michael Starzinger, 2016/09/19 14:20:38]

It is somewhat un-intuitive that the ParameterMode applies only to the capacity
but not to the length. AFAICT the only place this contract is encoded is in the
name of the argument. We should at least clearify that in the comment to this
function.

Alternatively we could pass in two ParameterMode arguments, each applying to
their respective node only.

[klaasb, 2016/09/19 14:46:37]

Well, it also doesn't apply to any of the other two Node* parameters, which is
also only kind of encoded in their names. ;)
I'll clarify. 
The method is only using the length in one way. Doing this would suggest to me
that something significant should happen depending on the ParameterMode, but it
would really only delay the (potential) tagging until the use.
In general I don't really like specifying the types of parameters separately as
another parameter, but typing the Nodes might be a bit overkill and might
introduce compile time issues (templates...).

+  // Allocate a JSArray and fill elements with zero.

[Michael Starzinger, 2016/09/19 14:20:38]

nit: s/zero/the hole/

[klaasb, 2016/09/19 14:46:37]

Done, oops.

   compiler::Node* AllocateJSArray(ElementsKind kind, compiler::Node* array_map,
                                   compiler::Node* capacity,
                                   compiler::Node* length,
                                   compiler::Node* allocation_site = nullptr,
                                   ParameterMode mode = INTEGER_PARAMETERS);
 
   compiler::Node* AllocateFixedArray(ElementsKind kind,
                                      compiler::Node* capacity,
                                      ParameterMode mode = INTEGER_PARAMETERS,
                                      AllocationFlags flags = kNone);
@@ skipping 424 matching lines @@
                                          int base_size = 0);
 
   compiler::Node* AllocateRawAligned(compiler::Node* size_in_bytes,
                                      AllocationFlags flags,
                                      compiler::Node* top_address,
                                      compiler::Node* limit_address);
   compiler::Node* AllocateRawUnaligned(compiler::Node* size_in_bytes,
                                        AllocationFlags flags,
                                        compiler::Node* top_adddress,
                                        compiler::Node* limit_address);
+  // Allocate and return a JSArray of given total size in bytes with header
+  // fields initialized.
+  compiler::Node* AllocateUninitializedJSArray(ElementsKind kind,
+                                               compiler::Node* array_map,
+                                               compiler::Node* length,
+                                               compiler::Node* allocation_site,
+                                               compiler::Node* size_in_bytes);
 
   compiler::Node* SmiShiftBitsConstant();
 
   // Emits keyed sloppy arguments load if the |value| is nullptr or store
   // otherwise. Returns either the loaded value or |value|.
   compiler::Node* EmitKeyedSloppyArguments(compiler::Node* receiver,
                                            compiler::Node* key,
                                            compiler::Node* value,
                                            Label* bailout);
 
   static const int kElementLoopUnrollThreshold = 8;
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(CodeStubAssembler::AllocationFlags);
 
 }  // namespace internal
 }  // namespace v8
 #endif  // V8_CODE_STUB_ASSEMBLER_H_