[interpreter] Inline FastCloneShallowArrayStub into bytecode handler

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 5686 matching lines @@
       assembler->isolate()->counters()->inlined_copied_elements(), 1);
 
   return array;
 }
 
 }  // namespace
 
 // static
 compiler::Node* FastCloneShallowArrayStub::Generate(
     CodeStubAssembler* assembler, compiler::Node* closure,
-    compiler::Node* literal_index, compiler::Node* constant_elements,
-    compiler::Node* context, AllocationSiteMode allocation_site_mode) {
+    compiler::Node* literal_index, compiler::Node* context,
+    AllocationSiteMode allocation_site_mode,

[rmcilroy, 2016/09/16 08:52:26]

nit - allocation_site_mode at the end of parameters.

[klaasb, 2016/09/19 13:53:57]

Done.

+    CodeStubAssembler::Label* call_runtime) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   typedef compiler::Node Node;
 
-  Label call_runtime(assembler, Label::kDeferred), zero_capacity(assembler),
-      cow_elements(assembler), fast_elements(assembler),
-      return_result(assembler);
+  Label zero_capacity(assembler), cow_elements(assembler),
+      fast_elements(assembler), return_result(assembler);
   Variable result(assembler, MachineRepresentation::kTagged);
 
   Node* undefined = assembler->UndefinedConstant();
 
   Node* literals_array =
       assembler->LoadObjectField(closure, JSFunction::kLiteralsOffset);
   Node* allocation_site = assembler->LoadFixedArrayElement(
       literals_array, literal_index,
       LiteralsArray::kFirstLiteralIndex * kPointerSize,
       CodeStubAssembler::SMI_PARAMETERS);
 
   assembler->GotoIf(assembler->WordEqual(allocation_site, undefined),
-                    &call_runtime);
+                    call_runtime);
 
   Node* boilerplate = assembler->LoadObjectField(
       allocation_site, AllocationSite::kTransitionInfoOffset);
   Node* boilerplate_map = assembler->LoadMap(boilerplate);
   Node* boilerplate_elements = assembler->LoadElements(boilerplate);
   Node* capacity = assembler->LoadFixedArrayBaseLength(boilerplate_elements);
   allocation_site =
       allocation_site_mode == TRACK_ALLOCATION_SITE ? allocation_site : nullptr;
 
   Node* zero = assembler->SmiConstant(Smi::FromInt(0));
@@ skipping 66 matching lines @@
   assembler->Bind(&allocate_without_elements);
   {
     Node* array = assembler->AllocateUninitializedJSArrayWithoutElements(
         FAST_ELEMENTS, boilerplate_map, length.value(), allocation_site);
     assembler->StoreObjectField(array, JSObject::kElementsOffset,
                                 elements.value());
     result.Bind(array);
     assembler->Goto(&return_result);
   }
 
-  assembler->Bind(&call_runtime);
-  {
-    assembler->Comment("call runtime");
-    Node* flags = assembler->SmiConstant(
-        Smi::FromInt(ArrayLiteral::kShallowElements |
-                     (allocation_site_mode == TRACK_ALLOCATION_SITE
-                          ? 0
-                          : ArrayLiteral::kDisableMementos)));
-    Node* array =
-        assembler->CallRuntime(Runtime::kCreateArrayLiteral, context, closure,
-                               literal_index, constant_elements, flags);
-    result.Bind(array);
-    assembler->Goto(&return_result);
-  }
-
   assembler->Bind(&return_result);
   return result.value();
 }
 
 void FastCloneShallowArrayStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
+  typedef CodeStubAssembler::Label Label;
   Node* closure = assembler->Parameter(Descriptor::kClosure);
   Node* literal_index = assembler->Parameter(Descriptor::kLiteralIndex);
   Node* constant_elements = assembler->Parameter(Descriptor::kConstantElements);
   Node* context = assembler->Parameter(Descriptor::kContext);
+  Label call_runtime(assembler, Label::kDeferred);
+  assembler->Return(Generate(assembler, closure, literal_index, context,
+                             allocation_site_mode(), &call_runtime));
 
-  assembler->Return(Generate(assembler, closure, literal_index,
-                             constant_elements, context,
-                             allocation_site_mode()));
+  assembler->Bind(&call_runtime);
+  {
+    assembler->Comment("call runtime");
+    Node* flags = assembler->SmiConstant(
+        Smi::FromInt(ArrayLiteral::kShallowElements |
+                     (allocation_site_mode() == TRACK_ALLOCATION_SITE
+                          ? 0
+                          : ArrayLiteral::kDisableMementos)));
+    assembler->Return(assembler->CallRuntime(Runtime::kCreateArrayLiteral,
+                                             context, closure, literal_index,
+                                             constant_elements, flags));
+  }
 }
 
 void CreateAllocationSiteStub::GenerateAheadOfTime(Isolate* isolate) {
   CreateAllocationSiteStub stub(isolate);
   stub.GetCode();
 }
 
 
 void CreateWeakCellStub::GenerateAheadOfTime(Isolate* isolate) {
   CreateWeakCellStub stub(isolate);
@@ skipping 387 matching lines @@
 
   if (type == MachineType::Pointer()) {
     return Representation::External();
   }
 
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8