Fix usage of literal cloning for large double arrays.

src/code-stubs.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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/ast/ast.h"
 #include "src/bootstrapper.h"
@@ skipping 2706 matching lines @@
   Node* closure = assembler.Parameter(Descriptor::kClosure);
   Node* literal_index = assembler.Parameter(Descriptor::kLiteralIndex);
   Node* pattern = assembler.Parameter(Descriptor::kPattern);
   Node* flags = assembler.Parameter(Descriptor::kFlags);
   Node* context = assembler.Parameter(Descriptor::kContext);
 
   assembler.Return(
       Generate(&assembler, closure, literal_index, pattern, flags, context));
 }
 
+// static
+bool FastCloneShallowArrayStub::IsSupported(ArrayLiteral* expr) {
+  return expr->depth() <= 1 &&
+         expr->values()->length() <= kMaximumClonedElements;

[Camillo Bruni, 2016/12/14 10:59:08]

How about putting this on the ArrayLiteral node instead?

[Michael Starzinger, 2016/12/14 14:01:03]

Done. Good idea, applied it to ArrayLiteral as well as to ObjectLiteral.

+}
+
 namespace {
 
 compiler::Node* NonEmptyShallowClone(CodeStubAssembler* assembler,
                                      compiler::Node* boilerplate,
                                      compiler::Node* boilerplate_map,
                                      compiler::Node* boilerplate_elements,
                                      compiler::Node* allocation_site,
                                      compiler::Node* capacity,
                                      ElementsKind kind) {
   typedef compiler::Node Node;
@@ skipping 480 matching lines @@
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {}
 
 }  // namespace internal
 }  // namespace v8