StubCallInterfaceDescriptor takes a context register.

src/code-stubs-hydrogen.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 "src/v8.h"
 
 #include "src/code-stubs.h"
 #include "src/field-index.h"
 #include "src/hydrogen.h"
 #include "src/lithium.h"
@@ skipping 21 matching lines @@
 
 
 class CodeStubGraphBuilderBase : public HGraphBuilder {
  public:
   CodeStubGraphBuilderBase(Isolate* isolate, HydrogenCodeStub* stub)
       : HGraphBuilder(&info_),
         arguments_length_(NULL),
         info_(stub, isolate),
         context_(NULL) {
     descriptor_ = stub->GetInterfaceDescriptor();
-    parameters_.Reset(new HParameter*[descriptor_->register_param_count()]);
+    int parameter_count = descriptor_->register_param_count() - 1;

[danno, 2014/07/16 13:19:59]

GetEnvironmentParameterCount

[mvstanton, 2014/07/17 09:04:04]

Done.

+    parameters_.Reset(new HParameter*[parameter_count]);
   }
   virtual bool BuildGraph();
 
  protected:
   virtual HValue* BuildCodeStub() = 0;
   HParameter* GetParameter(int parameter) {
     ASSERT(parameter < descriptor_->register_param_count());
     return parameters_[parameter];
   }
   HValue* GetArgumentsLength() {
@@ skipping 56 matching lines @@
   // Update the static counter each time a new code stub is generated.
   isolate()->counters()->code_stubs()->Increment();
 
   if (FLAG_trace_hydrogen_stubs) {
     const char* name = CodeStub::MajorName(stub()->MajorKey(), false);
     PrintF("-----------------------------------------------------------\n");
     PrintF("Compiling stub %s using hydrogen\n", name);
     isolate()->GetHTracer()->TraceCompilation(&info_);
   }
 
-  int param_count = descriptor_->register_param_count();
+  // Every descriptor has a context register parameter, which we don't need
+  // to include here.
+  int param_count = descriptor_->register_param_count() - 1;

[danno, 2014/07/16 13:19:59]

Use GetEnvironmentLength(), then comment is unnecessary

[mvstanton, 2014/07/17 09:04:04]

Done. (but I used GetEnvironmentParameterCount() as suggested in the line 42
comment)

   HEnvironment* start_environment = graph()->start_environment();
   HBasicBlock* next_block = CreateBasicBlock(start_environment);
   Goto(next_block);
   next_block->SetJoinId(BailoutId::StubEntry());
   set_current_block(next_block);
 
   bool runtime_stack_params = descriptor_->stack_parameter_count().is_valid();
   HInstruction* stack_parameter_count = NULL;
   for (int i = 0; i < param_count; ++i) {
-    Representation r = descriptor_->GetRegisterParameterRepresentation(i);
-    HParameter* param = Add<HParameter>(i, HParameter::REGISTER_PARAMETER, r);
+    int parameter_index = i+1;

[danno, 2014/07/16 13:19:59]

nit: make sure to clang format your patch. Comment about accounting for the
context parameter?

[mvstanton, 2014/07/17 09:04:04]

I got rid of this whole notion of "convert a parameter index to a descriptor
register parameter index" with the +1 thing. I just made a new method
GetEnvironmentParameterRegister() and GetEnvironmentParameterRepresentation().

After addressing the feedback to do something like that in deoptimizer.cc, it
made sense to come back and touch this too.

+    Representation r = descriptor_->GetParameterRepresentation(parameter_index);
+    HParameter* param = Add<HParameter>(parameter_index,
+                                        HParameter::REGISTER_PARAMETER, r);
     start_environment->Bind(i, param);
     parameters_[i] = param;
-    if (descriptor_->IsParameterCountRegister(i)) {
+    if (descriptor_->IsParameterCountRegister(parameter_index)) {
       param->set_type(HType::Smi());
       stack_parameter_count = param;
       arguments_length_ = stack_parameter_count;
     }
   }
 
   ASSERT(!runtime_stack_params || arguments_length_ != NULL);
   if (!runtime_stack_params) {
     stack_parameter_count = graph()->GetConstantMinus1();
     arguments_length_ = graph()->GetConstant0();
@@ skipping 1581 matching lines @@
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericElementStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 } }  // namespace v8::internal