Port FastCloneShallowArrayStub to Turbofan

src/code-stub-assembler.h

Index: src/code-stub-assembler.h
diff --git a/src/code-stub-assembler.h b/src/code-stub-assembler.h
index f122523090d787cf7b24dd3a2179019de23fcdef..7a065e1037921320417149fe9641898448fc6ebc 100644
--- a/src/code-stub-assembler.h
+++ b/src/code-stub-assembler.h
@@ -72,6 +72,9 @@ class CodeStubAssembler : public compiler::CodeAssembler {
 
   compiler::Node* BooleanMapConstant();
   compiler::Node* EmptyStringConstant();
+  compiler::Node* FixedArrayMapConstant();
+  compiler::Node* FixedCowArrayMapConstant();
+  compiler::Node* FixedDoubleArrayMapConstant();
   compiler::Node* HeapNumberMapConstant();
   compiler::Node* NoContextConstant();
   compiler::Node* NanConstant();
@@ -210,6 +213,8 @@ class CodeStubAssembler : public compiler::CodeAssembler {
   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.
@@ -317,7 +322,18 @@ class CodeStubAssembler : public compiler::CodeAssembler {
   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,
@@ -762,6 +778,13 @@ class CodeStubAssembler : public compiler::CodeAssembler {
                                        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();