Support multi-arg fast push support

src/code-stubs-hydrogen.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 "src/bailout-reason.h"
 #include "src/crankshaft/hydrogen.h"
 #include "src/crankshaft/lithium.h"
 #include "src/field-index.h"
@@ skipping 60 matching lines @@
   CompilationInfo* info() { return info_; }
   CodeStub* stub() { return code_stub_; }
   HContext* context() { return context_; }
   Isolate* isolate() { return info_->isolate(); }
 
   HLoadNamedField* BuildLoadNamedField(HValue* object, FieldIndex index);
   void BuildStoreNamedField(HValue* object, HValue* value, FieldIndex index,
                             Representation representation,
                             bool transition_to_field);
 
-  HValue* BuildPushElement(HValue* object, HValue* value, ElementsKind kind);
+  HValue* BuildPushElement(HValue* object, HValue* argc,
+                           HValue* argument_elements, ElementsKind kind);
 
   enum ArgumentClass {
     NONE,
     SINGLE,
     MULTIPLE
   };
 
   HValue* UnmappedCase(HValue* elements, HValue* key, HValue* value);
   HValue* EmitKeyedSloppyArguments(HValue* receiver, HValue* key,
                                    HValue* value);
@@ skipping 683 matching lines @@
                         HObjectAccess::ForContextSlot(slot_index),
                         GetParameter(2), STORE_TO_INITIALIZED_ENTRY);
   return GetParameter(2);
 }
 
 
 Handle<Code> StoreScriptContextFieldStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
-HValue* CodeStubGraphBuilderBase::BuildPushElement(HValue* object,
-                                                   HValue* value,
+HValue* CodeStubGraphBuilderBase::BuildPushElement(HValue* object, HValue* argc,
+                                                   HValue* argument_elements,
                                                    ElementsKind kind) {
+  // Precheck whether all elements fit into the array.
+  if (!IsFastObjectElementsKind(kind)) {
+    LoopBuilder builder(this, context(), LoopBuilder::kPostIncrement);
+    HValue* start = graph()->GetConstant0();
+    HValue* key = builder.BeginBody(start, argc, Token::LT);
+    {
+      HInstruction* argument =
+          Add<HAccessArgumentsAt>(argument_elements, argc, key);
+      Representation r = IsFastSmiElementsKind(kind) ? Representation::Smi()
+                                                     : Representation::Double();
+      AddUncasted<HForceRepresentation>(argument, r);
+    }
+    builder.EndBody();
+  }
+
   HValue* length = Add<HLoadNamedField>(object, nullptr,
                                         HObjectAccess::ForArrayLength(kind));
-  HValue* key = length;
+  HValue* new_length = AddUncasted<HAdd>(length, argc);
+  HValue* max_key = AddUncasted<HSub>(new_length, graph()->GetConstant1());
+
   HValue* elements = Add<HLoadNamedField>(object, nullptr,
                                           HObjectAccess::ForElementsPointer());
-  elements = BuildCheckForCapacityGrow(object, elements, kind, length, key,
+  elements = BuildCheckForCapacityGrow(object, elements, kind, length, max_key,
                                        true, STORE);
-  AddElementAccess(elements, key, value, object, nullptr, kind, STORE);
-  return key;
+
+  LoopBuilder builder(this, context(), LoopBuilder::kPostIncrement);
+  HValue* start = graph()->GetConstant0();
+  HValue* key = builder.BeginBody(start, argc, Token::LT);
+  {
+    HValue* argument = Add<HAccessArgumentsAt>(argument_elements, argc, key);
+    HValue* index = AddUncasted<HAdd>(key, length);
+    AddElementAccess(elements, index, argument, object, nullptr, kind, STORE);
+  }
+  builder.EndBody();
+  return new_length;
 }
 
 template <>
 HValue* CodeStubGraphBuilder<FastArrayPushStub>::BuildCodeStub() {
   // TODO(verwaest): Fix deoptimizer messages.
   HValue* argc = GetArgumentsLength();
-  IfBuilder arg_check(this);
-  arg_check.If<HCompareNumericAndBranch>(argc, graph()->GetConstant1(),
-                                         Token::NE);
-  arg_check.ThenDeopt(Deoptimizer::kFastArrayPushFailed);
-  arg_check.End();
-
   HInstruction* argument_elements = Add<HArgumentsElements>(false, false);
   HInstruction* object = Add<HAccessArgumentsAt>(argument_elements, argc,
                                                  graph()->GetConstantMinus1());
-  HInstruction* value =
-      Add<HAccessArgumentsAt>(argument_elements, argc, graph()->GetConstant0());
-
   BuildCheckHeapObject(object);
   HValue* map = Add<HLoadNamedField>(object, nullptr, HObjectAccess::ForMap());
   Add<HCheckInstanceType>(object, HCheckInstanceType::IS_JS_ARRAY);
 
   // Disallow pushing onto prototypes. It might be the JSArray prototype.
   // Disallow pushing onto non-extensible objects.
   {
     HValue* bit_field2 =
         Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapBitField2());
     HValue* mask =
@@ skipping 98 matching lines @@
   STATIC_ASSERT(FAST_SMI_ELEMENTS < FAST_HOLEY_SMI_ELEMENTS);
   STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS < FAST_HOLEY_ELEMENTS);
   STATIC_ASSERT(FAST_ELEMENTS < FAST_HOLEY_ELEMENTS);
   STATIC_ASSERT(FAST_HOLEY_ELEMENTS < FAST_HOLEY_DOUBLE_ELEMENTS);
   STATIC_ASSERT(FAST_DOUBLE_ELEMENTS < FAST_HOLEY_DOUBLE_ELEMENTS);
   IfBuilder has_smi_elements(this);
   has_smi_elements.If<HCompareNumericAndBranch>(
       kind, Add<HConstant>(FAST_HOLEY_SMI_ELEMENTS), Token::LTE);
   has_smi_elements.Then();
   {
-    HValue* smi_value =
-        AddUncasted<HForceRepresentation>(value, Representation::Smi());
-    HValue* key = BuildPushElement(object, smi_value, FAST_HOLEY_SMI_ELEMENTS);
-    environment()->Push(key);
+    HValue* new_length = BuildPushElement(object, argc, argument_elements,
+                                          FAST_HOLEY_SMI_ELEMENTS);
+    environment()->Push(new_length);
   }
   has_smi_elements.Else();
   {
     IfBuilder has_object_elements(this);
     has_object_elements.If<HCompareNumericAndBranch>(
         kind, Add<HConstant>(FAST_HOLEY_ELEMENTS), Token::LTE);
     has_object_elements.Then();
     {
-      HValue* key = BuildPushElement(object, value, FAST_HOLEY_ELEMENTS);
-      environment()->Push(key);
+      HValue* new_length = BuildPushElement(object, argc, argument_elements,
+                                            FAST_HOLEY_ELEMENTS);
+      environment()->Push(new_length);
     }
     has_object_elements.Else();
     {
       IfBuilder has_double_elements(this);
       has_double_elements.If<HCompareNumericAndBranch>(
           kind, Add<HConstant>(FAST_HOLEY_DOUBLE_ELEMENTS), Token::LTE);
       has_double_elements.Then();
       {
-        HValue* double_value =
-            AddUncasted<HForceRepresentation>(value, Representation::Double());
-        HValue* key =
-            BuildPushElement(object, double_value, FAST_HOLEY_DOUBLE_ELEMENTS);
-        environment()->Push(key);
+        HValue* new_length = BuildPushElement(object, argc, argument_elements,
+                                              FAST_HOLEY_DOUBLE_ELEMENTS);
+        environment()->Push(new_length);
       }
       has_double_elements.ElseDeopt(Deoptimizer::kFastArrayPushFailed);
       has_double_elements.End();
     }
     has_object_elements.End();
   }
   has_smi_elements.End();
 
-  HValue* key = environment()->Pop();
-  return AddUncasted<HAdd>(key, graph()->GetConstant1());
+  return environment()->Pop();
 }
 
 Handle<Code> FastArrayPushStub::GenerateCode() { return DoGenerateCode(this); }
 
 template <>
 HValue* CodeStubGraphBuilder<GrowArrayElementsStub>::BuildCodeStub() {
   ElementsKind kind = casted_stub()->elements_kind();
   if (IsFastDoubleElementsKind(kind)) {
     info()->MarkAsSavesCallerDoubles();
   }
@@ skipping 1573 matching lines @@
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 }  // namespace internal
 }  // namespace v8