Allow HPushArgument to handle more than one argument.

src/lithium.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 "v8.h"
 #include "lithium.h"
 #include "scopes.h"
 #include "serialize.h"
 
 #if V8_TARGET_ARCH_IA32
@@ skipping 491 matching lines @@
                                zone());
   int argument_index = *argument_index_accumulator;
 
   // Store the environment description into the environment
   // (with holes for nested objects)
   for (int i = 0; i < hydrogen_env->length(); ++i) {
     if (hydrogen_env->is_special_index(i)) continue;
 
     LOperand* op;
     HValue* value = hydrogen_env->values()->at(i);
-    CHECK(!value->IsPushArgument());  // Do not deopt outgoing arguments
+    CHECK(!value->IsPushArguments());  // Do not deopt outgoing arguments
     if (value->IsArgumentsObject() || value->IsCapturedObject()) {
       op = LEnvironment::materialization_marker();
     } else {
       op = UseAny(value);
     }
     result->AddValue(op,
                      value->representation(),
                      value->CheckFlag(HInstruction::kUint32));
   }
 
@@ skipping 60 matching lines @@
     result->AddNewObject(is_arguments ? length - 1 : length, is_arguments);
   }
   // Store the captured object's fields into the environment
   for (int i = is_arguments ? 1 : 0; i < length; ++i) {
     LOperand* op;
     HValue* arg_value = value->OperandAt(i);
     if (arg_value->IsArgumentsObject() || arg_value->IsCapturedObject()) {
       // Insert a hole for nested objects
       op = LEnvironment::materialization_marker();
     } else {
-      ASSERT(!arg_value->IsPushArgument());
+      ASSERT(!arg_value->IsPushArguments());
       // For ordinary values, tell the register allocator we need the value
       // to be alive here
       op = UseAny(arg_value);
     }
     result->AddValue(op,
                      arg_value->representation(),
                      arg_value->CheckFlag(HInstruction::kUint32));
   }
   // Recursively store all the nested captured objects into the environment
   for (int i = is_arguments ? 1 : 0; i < length; ++i) {
@@ skipping 14 matching lines @@
 
 
 LPhase::~LPhase() {
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceLithium(name(), chunk_);
   }
 }
 
 
 } }  // namespace v8::internal