Fix HPushArguments instruction.

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 2044 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(LeaveInlined)
 
  private:
   HEnterInlined* entry_;
   int drop_count_;
 };
 
 
 class HPushArguments V8_FINAL : public HInstruction {
  public:
-  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*);
+  static HPushArguments* New(Zone* zone, HValue* context) {
+    return new(zone) HPushArguments(zone);
+  }
+  static HPushArguments* New(Zone* zone, HValue* context, HValue* arg1) {
+    HPushArguments* instr = new(zone) HPushArguments(zone);
+    instr->AddInput(arg1);
+    return instr;
+  }
+  static HPushArguments* New(Zone* zone, HValue* context, HValue* arg1,
+                             HValue* arg2) {
+    HPushArguments* instr = new(zone) HPushArguments(zone);
+    instr->AddInput(arg1);
+    instr->AddInput(arg2);
+    return instr;
+  }
+  static HPushArguments* New(Zone* zone, HValue* context, HValue* arg1,
+                             HValue* arg2, HValue* arg3) {
+    HPushArguments* instr = new(zone) HPushArguments(zone);
+    instr->AddInput(arg1);
+    instr->AddInput(arg2);
+    instr->AddInput(arg3);
+    return instr;
+  }
+  static HPushArguments* New(Zone* zone, HValue* context, HValue* arg1,
+                             HValue* arg2, HValue* arg3, HValue* arg4) {
+    HPushArguments* instr = new(zone) HPushArguments(zone);
+    instr->AddInput(arg1);
+    instr->AddInput(arg2);
+    instr->AddInput(arg3);
+    instr->AddInput(arg4);
+    return instr;
+  }
 
   virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
     return Representation::Tagged();
   }
 
   virtual int argument_delta() const V8_OVERRIDE { return inputs_.length(); }
   HValue* argument(int i) { return OperandAt(i); }
 
   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);
-  }
+  void AddInput(HValue* value);
 
   DECLARE_CONCRETE_INSTRUCTION(PushArguments)
 
  protected:
   virtual void InternalSetOperandAt(int i, HValue* value) V8_FINAL V8_OVERRIDE {
     inputs_[i] = value;
   }
 
  private:
-  HPushArguments(Zone* zone,
-                 HValue* arg1 = NULL, HValue* arg2 = NULL,
-                 HValue* arg3 = NULL, HValue* arg4 = NULL)
-      : HInstruction(HType::Tagged()), zone_(zone), inputs_(4, zone) {
+  explicit HPushArguments(Zone* zone)
+      : HInstruction(HType::Tagged()), 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 5582 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_