To fully support hydrogen code stubs which accept a variable number of arguments,

src/hydrogen-instructions.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1460 matching lines @@
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CompareMap)
 
  private:
   Handle<Map> map_;
 };
 
 
-class HReturn: public HTemplateControlInstruction<0, 2> {
+class HReturn: public HTemplateControlInstruction<0, 3> {
  public:
-  HReturn(HValue* value, HValue* context) {
+  HReturn(HValue* value, HValue* context, int parameter_count) {

[danno, 2013/03/07 15:11:14]

Do you really need this version? You can check in lithium if the value is a
constant, and it unifies this constructor with the other.

[mvstanton, 2013/03/07 16:48:49]

Done.

     SetOperandAt(0, value);
     SetOperandAt(1, context);
+    SetOperandAt(2, context);  // (unused)
+    ASSERT(parameter_count >= 0);
+    constant_parameter_count_ = parameter_count;
+  }
+
+  HReturn(HValue* value, HValue* context, HValue* parameter_count) {
+    SetOperandAt(0, value);
+    SetOperandAt(1, context);
+    SetOperandAt(2, parameter_count);
+    constant_parameter_count_ = -1;
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
   HValue* value() { return OperandAt(0); }
   HValue* context() { return OperandAt(1); }
 
+  bool has_constant_parameter_count() const {

[danno, 2013/03/07 15:11:14]

As noted above, you can determine this all in lithium-codegen-ia32.cc. If you
ask for a UseRegisterOrConstant in lithium-ia32.cc for this parameter, the
register allocation will choose a constant when it can, obviating the need to
track the "constantness" of the parameter count in hydrogen explicitly.

[mvstanton, 2013/03/07 16:48:49]

Done.

+    return constant_parameter_count_ >= 0;
+  }
+  int constant_parameter_count() const {
+    ASSERT(has_constant_parameter_count());
+    return constant_parameter_count_;
+  }
+  HValue* parameter_count() {
+    ASSERT(!has_constant_parameter_count());
+    return OperandAt(2);
+  }
+
   DECLARE_CONCRETE_INSTRUCTION(Return)
+
+ private:
+  int constant_parameter_count_;
 };
 
 
 class HAbnormalExit: public HTemplateControlInstruction<0, 0> {
  public:
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(AbnormalExit)
@@ skipping 4657 matching lines @@
   virtual bool IsDeletable() const { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_