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

src/code-stubs-hydrogen.cc

 // 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 39 matching lines @@
   if (chunk == NULL) {
     FATAL(graph->info()->bailout_reason());
   }
   return chunk;
 }
 
 
 class CodeStubGraphBuilderBase : public HGraphBuilder {
  public:
   CodeStubGraphBuilderBase(Isolate* isolate, HydrogenCodeStub* stub)
-      : HGraphBuilder(&info_), info_(stub, isolate), context_(NULL) {
+      : HGraphBuilder(&info_),
+        arguments_length_(NULL),
+        info_(stub, isolate),
+        context_(NULL) {
     int major_key = stub->MajorKey();
     descriptor_ = isolate->code_stub_interface_descriptor(major_key);
     if (descriptor_->register_param_count_ < 0) {
       stub->InitializeInterfaceDescriptor(isolate, descriptor_);
     }
     parameters_.Reset(new HParameter*[descriptor_->register_param_count_]);
   }
   virtual bool BuildGraph();
 
  protected:
-  virtual void BuildCodeStub() = 0;
-  HParameter* GetParameter(int parameter) { return parameters_[parameter]; }
+  virtual HValue* BuildCodeStub() = 0;
+  HParameter* GetParameter(int parameter) {
+    ASSERT(parameter < descriptor_->register_param_count_);
+    return parameters_[parameter];
+  }
+  HValue* GetArgumentsLength() {
+    // This is initialized in BuildGraph()
+    ASSERT(arguments_length_ != NULL);
+    return arguments_length_;
+  }
   CompilationInfo* info() { return &info_; }
   HydrogenCodeStub* stub() { return info_.code_stub(); }
   HContext* context() { return context_; }
   Isolate* isolate() { return info_.isolate(); }
 
  private:
   SmartArrayPointer<HParameter*> parameters_;
+  HValue* arguments_length_;
   CompilationInfoWithZone info_;
   CodeStubInterfaceDescriptor* descriptor_;
   HContext* context_;
 };
 
 
 bool CodeStubGraphBuilderBase::BuildGraph() {
   if (FLAG_trace_hydrogen) {
     const char* name = CodeStub::MajorName(stub()->MajorKey(), false);
     PrintF("-----------------------------------------------------------\n");
     PrintF("Compiling stub %s using hydrogen\n", name);
     isolate()->GetHTracer()->TraceCompilation(&info_);
   }
 
   Zone* zone = this->zone();
-  HEnvironment* start_environment =
-      new(zone) HEnvironment(zone, descriptor_->register_param_count_);
+  int param_count = descriptor_->register_param_count_;
+  HEnvironment* start_environment = graph()->start_environment();
   HBasicBlock* next_block = CreateBasicBlock(start_environment);
-
   current_block()->Goto(next_block);
   next_block->SetJoinId(BailoutId::StubEntry());
   set_current_block(next_block);
 
   HConstant* undefined_constant = new(zone) HConstant(
       isolate()->factory()->undefined_value(), Representation::Tagged());
   AddInstruction(undefined_constant);
   graph()->set_undefined_constant(undefined_constant);
 
-  int param_count = descriptor_->register_param_count_;
   for (int i = 0; i < param_count; ++i) {
     HParameter* param =
         new(zone) HParameter(i, HParameter::REGISTER_PARAMETER);
     AddInstruction(param);
     start_environment->Bind(i, param);
     parameters_[i] = param;
   }
 
+  HInstruction* stack_parameter_count;
+  if (descriptor_->stack_parameter_count_ != NULL) {
+    ASSERT(descriptor_->environment_length() == (param_count + 1));
+    stack_parameter_count = new(zone) HParameter(param_count,
+        HParameter::REGISTER_PARAMETER);
+    // it's essential to bind this value to the environment in case of deopt
+    start_environment->Bind(param_count, stack_parameter_count);
+    AddInstruction(stack_parameter_count);
+  } else {
+    ASSERT(descriptor_->environment_length() == param_count);
+    stack_parameter_count = AddInstruction(new(zone)
+        HConstant(-1, Representation::Integer32()));
+  }
+
+  arguments_length_ = stack_parameter_count;
+
   context_ = new(zone) HContext();
   AddInstruction(context_);
-  start_environment->Bind(param_count, context_);
+  start_environment->BindContext(context_);
 
   AddSimulate(BailoutId::StubEntry());
 
-  BuildCodeStub();
-
+  HValue* return_value = BuildCodeStub();
+  HReturn* hreturn_instruction = new(zone) HReturn(return_value,
+                                                   context_,
+                                                   stack_parameter_count);
+  current_block()->Finish(hreturn_instruction);
   return true;
 }
 
 template <class Stub>
 class CodeStubGraphBuilder: public CodeStubGraphBuilderBase {
  public:
   explicit CodeStubGraphBuilder(Stub* stub)
       : CodeStubGraphBuilderBase(Isolate::Current(), stub) {}
 
  protected:
-  virtual void BuildCodeStub();
+  virtual HValue* BuildCodeStub();
   Stub* casted_stub() { return static_cast<Stub*>(stub()); }
 };
 
 
 template <>
-void CodeStubGraphBuilder<FastCloneShallowObjectStub>::BuildCodeStub() {
+HValue* CodeStubGraphBuilder<FastCloneShallowObjectStub>::BuildCodeStub() {
   Zone* zone = this->zone();
   Factory* factory = isolate()->factory();
 
   HInstruction* boilerplate =
       AddInstruction(new(zone) HLoadKeyed(GetParameter(0),
                                           GetParameter(1),
                                           NULL,
                                           FAST_ELEMENTS));
 
   CheckBuilder builder(this, BailoutId::StubEntry());
@@ skipping 19 matching lines @@
     HInstruction* value =
         AddInstruction(new(zone) HLoadNamedField(boilerplate, true, i));
     AddInstruction(new(zone) HStoreNamedField(object,
                                               factory->empty_string(),
                                               value,
                                               true, i));
     AddSimulate(BailoutId::StubEntry());
   }
 
   builder.End();
-
-  HReturn* ret = new(zone) HReturn(object, context());
-  current_block()->Finish(ret);
+  return object;
 }
 
 
 Handle<Code> FastCloneShallowObjectStub::GenerateCode() {
   CodeStubGraphBuilder<FastCloneShallowObjectStub> builder(this);
   LChunk* chunk = OptimizeGraph(builder.CreateGraph());
   return chunk->Codegen(Code::COMPILED_STUB);
 }
 
 
 template <>
-void CodeStubGraphBuilder<KeyedLoadFastElementStub>::BuildCodeStub() {
-  Zone* zone = this->zone();
-
+HValue* CodeStubGraphBuilder<KeyedLoadFastElementStub>::BuildCodeStub() {
   HInstruction* load = BuildUncheckedMonomorphicElementAccess(
       GetParameter(0), GetParameter(1), NULL, NULL,
       casted_stub()->is_js_array(), casted_stub()->elements_kind(),
       false, Representation::Tagged());
   AddInstruction(load);
-
-  HReturn* ret = new(zone) HReturn(load, context());
-  current_block()->Finish(ret);
+  return load;
 }
 
 
 Handle<Code> KeyedLoadFastElementStub::GenerateCode() {
   CodeStubGraphBuilder<KeyedLoadFastElementStub> builder(this);
   LChunk* chunk = OptimizeGraph(builder.CreateGraph());
   return chunk->Codegen(Code::COMPILED_STUB);
 }
 
 
 template <>
-void CodeStubGraphBuilder<TransitionElementsKindStub>::BuildCodeStub() {
+HValue* CodeStubGraphBuilder<TransitionElementsKindStub>::BuildCodeStub() {
   Zone* zone = this->zone();
 
   HValue* js_array = GetParameter(0);
   HValue* map = GetParameter(1);
 
   info()->MarkAsSavesCallerDoubles();
 
   AddInstruction(new(zone) HTrapAllocationMemento(js_array));
 
   HInstruction* array_length =
@@ skipping 65 matching lines @@
                                             factory->elements_field_string(),
                                             new_elements, true,
                                             JSArray::kElementsOffset));
   AddSimulate(BailoutId::StubEntry());
 
   if_builder.End();
 
   AddInstruction(new(zone) HStoreNamedField(js_array, factory->length_string(),
                                             map, true, JSArray::kMapOffset));
   AddSimulate(BailoutId::StubEntry());
-
-  HReturn* ret = new(zone) HReturn(js_array, context());
-  current_block()->Finish(ret);
+  return js_array;
 }
 
 
 template <>
-void CodeStubGraphBuilder<ArrayNoArgumentConstructorStub>::BuildCodeStub() {
+HValue* CodeStubGraphBuilder<ArrayNoArgumentConstructorStub>::BuildCodeStub() {
   HInstruction* deopt = new(zone()) HSoftDeoptimize();
   AddInstruction(deopt);
   current_block()->MarkAsDeoptimizing();
-  HReturn* ret = new(zone()) HReturn(GetParameter(0), context());
-  current_block()->Finish(ret);
+  return GetParameter(0);
 }
 
 
 Handle<Code> ArrayNoArgumentConstructorStub::GenerateCode() {
   CodeStubGraphBuilder<ArrayNoArgumentConstructorStub> builder(this);
   LChunk* chunk = OptimizeGraph(builder.CreateGraph());
   return chunk->Codegen(Code::COMPILED_STUB);
 }
 
 
 template <>
-void CodeStubGraphBuilder<ArraySingleArgumentConstructorStub>::BuildCodeStub() {
+HValue* CodeStubGraphBuilder<ArraySingleArgumentConstructorStub>::
+    BuildCodeStub() {
   HInstruction* deopt = new(zone()) HSoftDeoptimize();
   AddInstruction(deopt);
   current_block()->MarkAsDeoptimizing();
-  HReturn* ret = new(zone()) HReturn(GetParameter(0), context());
-  current_block()->Finish(ret);
+  return GetParameter(0);
 }
 
 
 Handle<Code> TransitionElementsKindStub::GenerateCode() {
   CodeStubGraphBuilder<TransitionElementsKindStub> builder(this);
   LChunk* chunk = OptimizeGraph(builder.CreateGraph());
   return chunk->Codegen(Code::COMPILED_STUB);
 }
 
 
 Handle<Code> ArraySingleArgumentConstructorStub::GenerateCode() {
   CodeStubGraphBuilder<ArraySingleArgumentConstructorStub> builder(this);
   LChunk* chunk = OptimizeGraph(builder.CreateGraph());
   return chunk->Codegen(Code::COMPILED_STUB);
 }
 
 
 template <>
-void CodeStubGraphBuilder<ArrayNArgumentsConstructorStub>::BuildCodeStub() {
+HValue* CodeStubGraphBuilder<ArrayNArgumentsConstructorStub>::BuildCodeStub() {
   HInstruction* deopt = new(zone()) HSoftDeoptimize();
   AddInstruction(deopt);
   current_block()->MarkAsDeoptimizing();
-  HReturn* ret = new(zone()) HReturn(GetParameter(0), context());
-  current_block()->Finish(ret);
+  return GetParameter(0);
 }
 
 
 Handle<Code> ArrayNArgumentsConstructorStub::GenerateCode() {
   CodeStubGraphBuilder<ArrayNArgumentsConstructorStub> builder(this);
   LChunk* chunk = OptimizeGraph(builder.CreateGraph());
   return chunk->Codegen(Code::COMPILED_STUB);
 }
 
 } }  // namespace v8::internal