Allow HPushArgument to handle more than one argument.

src/hydrogen-instructions.h

 // 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.
 
 #ifndef V8_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include "v8.h"
 
 #include "allocation.h"
@@ skipping 109 matching lines @@
   V(LoadNamedGeneric)                          \
   V(LoadRoot)                                  \
   V(MapEnumLength)                             \
   V(MathFloorOfDiv)                            \
   V(MathMinMax)                                \
   V(Mod)                                       \
   V(Mul)                                       \
   V(OsrEntry)                                  \
   V(Parameter)                                 \
   V(Power)                                     \
-  V(PushArgument)                              \
+  V(PushArguments)                             \
   V(RegExpLiteral)                             \
   V(Return)                                    \
   V(Ror)                                       \
   V(Sar)                                       \
   V(SeqStringGetChar)                          \
   V(SeqStringSetChar)                          \
   V(Shl)                                       \
   V(Shr)                                       \
   V(Simulate)                                  \
   V(StackCheck)                                \
@@ skipping 2027 matching lines @@
   }
 
   DECLARE_CONCRETE_INSTRUCTION(LeaveInlined)
 
  private:
   HEnterInlined* entry_;
   int drop_count_;
 };
 
 
-class HPushArgument V8_FINAL : public HUnaryOperation {
+class HPushArguments V8_FINAL : public HInstruction {
  public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HPushArgument, HValue*);
+  DECLARE_INSTRUCTION_FACTORY_P1(HPushArguments, Zone*);
+  DECLARE_INSTRUCTION_FACTORY_P2(HPushArguments, Zone*, HValue*);
+  DECLARE_INSTRUCTION_FACTORY_P3(HPushArguments, Zone*, HValue*, HValue*);
+  DECLARE_INSTRUCTION_FACTORY_P4(HPushArguments, Zone*,
+                                 HValue*, HValue*, HValue*);
+  DECLARE_INSTRUCTION_FACTORY_P5(HPushArguments, Zone*,
+                                 HValue*, HValue*, HValue*, HValue*);
 
   virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
     return Representation::Tagged();
   }
 
-  virtual int argument_delta() const V8_OVERRIDE { return 1; }
-  HValue* argument() { return OperandAt(0); }
+  virtual int argument_delta() const V8_OVERRIDE { return inputs_.length(); }
+  HValue* argument(int i) { return OperandAt(i); }
 
-  DECLARE_CONCRETE_INSTRUCTION(PushArgument)
+  virtual int OperandCount() V8_FINAL V8_OVERRIDE { return inputs_.length(); }
+  virtual HValue* OperandAt(int i) const V8_FINAL V8_OVERRIDE {
+    return inputs_[i];
+  }
+
+  void AddArgument(HValue* arg) {
+    inputs_.Add(NULL, zone_);
+    SetOperandAt(inputs_.length() - 1, arg);
+  }
+
+  DECLARE_CONCRETE_INSTRUCTION(PushArguments)
+
+ protected:
+  virtual void InternalSetOperandAt(int i, HValue* value) V8_FINAL V8_OVERRIDE {
+    inputs_[i] = value;
+  }
 
  private:
-  explicit HPushArgument(HValue* value) : HUnaryOperation(value) {
+  HPushArguments(Zone* zone,
+                 HValue* arg1 = NULL, HValue* arg2 = NULL,
+                 HValue* arg3 = NULL, HValue* arg4 = NULL)
+      : HInstruction(HType::Tagged()), zone_(zone), inputs_(4, zone) {
     set_representation(Representation::Tagged());
+    if (arg1) {
+      inputs_.Add(NULL, zone);
+      SetOperandAt(0, arg1);
+    }
+    if (arg2) {
+      inputs_.Add(NULL, zone);
+      SetOperandAt(1, arg2);
+    }
+    if (arg3) {
+      inputs_.Add(NULL, zone);
+      SetOperandAt(2, arg3);
+    }
+    if (arg4) {
+      inputs_.Add(NULL, zone);
+      SetOperandAt(3, arg4);
+    }
   }
+
+  Zone* zone_;
+  ZoneList<HValue*> inputs_;
 };
 
 
 class HThisFunction V8_FINAL : public HTemplateInstruction<0> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P0(HThisFunction);
 
   virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
     return Representation::None();
   }
@@ skipping 5550 matching lines @@
   virtual bool IsDeletable() const V8_OVERRIDE { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_