StubCallInterfaceDescriptor takes a context register.

src/code-stubs.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_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/codegen.h"
@@ skipping 253 matching lines @@
 
  protected:
   // Generates the assembler code for the stub.
   virtual void Generate(MacroAssembler* masm) = 0;
 };
 
 
 enum StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE };
 enum HandlerArgumentsMode { DONT_PASS_ARGUMENTS, PASS_ARGUMENTS };
 
-class CodeStubInterfaceDescriptor {
+class InterfaceDescriptor {
+ public:
+  bool initialized() const { return register_param_count_ >= 0; }

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

style: should be IsInitialized()

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

Done.

+
+  int GetEnvironmentLength() const {
+    return register_param_count_;
+  }

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

I think with a little more "duplication", you can make this clearer. In addition
to GetEnvironmentLength, you should have GetEnvironmentParameterCount (which
should actually be register_param_count_ - 1), which is used really where you
current -1 due to the smaller environment, and there you shouldn't have to do
the math.

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

I fully factored this out so that customers who prefer to think of parameters
without the context register have methods to do so, and customers who need the
full set (including context) can have what they want. Nobody has to do
adjustments like "+1" and "-1" any more to deal with the context register.

+
+  int register_param_count() const { return register_param_count_; }

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

For consistency, make this GetRegisterParameterCount() 

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

Done.

+
+  Register GetParameterRegister(int index) const {
+    return register_params_[index];
+  }
+
+  Representation GetParameterRepresentation(int index) const {
+    ASSERT(index < register_param_count_);
+    if (register_param_representations_.get() == NULL) {
+      return Representation::Tagged();
+    }
+
+    return register_param_representations_[index];
+  }
+
+  static const Register ContextRegister();
+
+ protected:
+  InterfaceDescriptor();
+  virtual ~InterfaceDescriptor() {}
+
+  void Initialize(int register_parameter_count, Register* registers,
+                  Representation* register_param_representations);
+
+ private:
+  int register_param_count_;
+
+  // The Register params are allocated dynamically by the
+  // InterfaceDescriptor, and freed on destruction. This is because static
+  // arrays of Registers cause creation of runtime static initializers
+  // which we don't want.
+  SmartArrayPointer<Register> register_params_;
+  // Specifies Representations for the stub's parameter. Points to an array of
+  // Representations of the same length of the numbers of parameters to the
+  // stub, or if NULL (the default value), Representation of each parameter
+  // assumed to be Tagged().
+  SmartArrayPointer<Representation> register_param_representations_;
+
+  DISALLOW_COPY_AND_ASSIGN(InterfaceDescriptor);
+};
+
+
+class CodeStubInterfaceDescriptor: public InterfaceDescriptor {
  public:
   CodeStubInterfaceDescriptor();
 
   void Initialize(int register_parameter_count, Register* registers,
                   Address deoptimization_handler = NULL,
                   Representation* register_param_representations = NULL,
                   int hint_stack_parameter_count = -1,
                   StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE);
   void Initialize(int register_parameter_count, Register* registers,
                   Register stack_parameter_count,
                   Address deoptimization_handler = NULL,
                   Representation* register_param_representations = NULL,
                   int hint_stack_parameter_count = -1,
                   StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE,
                   HandlerArgumentsMode handler_mode = DONT_PASS_ARGUMENTS);
-  bool initialized() const { return register_param_count_ >= 0; }
-
-  int environment_length() const {
-    return register_param_count_;
-  }
 
   void SetMissHandler(ExternalReference handler) {
     miss_handler_ = handler;
     has_miss_handler_ = true;
     // Our miss handler infrastructure doesn't currently support
     // variable stack parameter counts.
     ASSERT(!stack_parameter_count_.is_valid());
   }
 
   ExternalReference miss_handler() const {
     ASSERT(has_miss_handler_);
     return miss_handler_;
   }
 
   bool has_miss_handler() const {
     return has_miss_handler_;
   }
 
-  Register GetParameterRegister(int index) const {
-    return register_params_[index];
-  }
-
-  Representation GetRegisterParameterRepresentation(int index) const {
-    ASSERT(index < register_param_count_);
-    if (register_param_representations_.get() == NULL) {
-      return Representation::Tagged();
-    }
-
-    return register_param_representations_[index];
-  }
-
   bool IsParameterCountRegister(int index) const {
     return GetParameterRegister(index).is(stack_parameter_count_);
   }
 
   int GetHandlerParameterCount() const {
-    int params = environment_length();
+    // Context is dealt with as a defined part of the frame, not as a parameter.
+    int params = GetEnvironmentLength() - 1;
     if (handler_arguments_mode_ == PASS_ARGUMENTS) {
       params += 1;
     }
     return params;
   }
 
-  int register_param_count() const { return register_param_count_; }
   int hint_stack_parameter_count() const { return hint_stack_parameter_count_; }
   Register stack_parameter_count() const { return stack_parameter_count_; }
   StubFunctionMode function_mode() const { return function_mode_; }
   Address deoptimization_handler() const { return deoptimization_handler_; }
-  Representation* register_param_representations() const {
-    return register_param_representations_.get();
-  }
 
  private:
-  int register_param_count_;
-
   Register stack_parameter_count_;
   // If hint_stack_parameter_count_ > 0, the code stub can optimize the
   // return sequence. Default value is -1, which means it is ignored.
   int hint_stack_parameter_count_;
   StubFunctionMode function_mode_;
-  // The Register params are allocated dynamically by the
-  // CodeStubInterfaceDescriptor, and freed on destruction. This is because
-  // static arrays of Registers cause creation of runtime static initializers
-  // which we don't want.
-  SmartArrayPointer<Register> register_params_;
-  // Specifies Representations for the stub's parameter. Points to an array of
-  // Representations of the same length of the numbers of parameters to the
-  // stub, or if NULL (the default value), Representation of each parameter
-  // assumed to be Tagged().
-  SmartArrayPointer<Representation> register_param_representations_;
 
   Address deoptimization_handler_;
   HandlerArgumentsMode handler_arguments_mode_;
 
   ExternalReference miss_handler_;
   bool has_miss_handler_;
-  DISALLOW_COPY_AND_ASSIGN(CodeStubInterfaceDescriptor);
 };
 
 
 class PlatformCallInterfaceDescriptor;
 
 
-class CallInterfaceDescriptor {
+class CallInterfaceDescriptor: public InterfaceDescriptor {
  public:
   CallInterfaceDescriptor()
-      : register_param_count_(-1),
-        register_params_(NULL),
-        param_representations_(NULL),
-        platform_specific_descriptor_(NULL) { }
+      : platform_specific_descriptor_(NULL) { }
 
   // A copy of the passed in registers and param_representations is made
   // and owned by the CallInterfaceDescriptor.
 
   // TODO(mvstanton): Instead of taking parallel arrays register and
   // param_representations, how about a struct that puts the representation
   // and register side by side (eg, RegRep(r1, Representation::Tagged()).
   // The same should go for the CodeStubInterfaceDescriptor class.
   void Initialize(int register_parameter_count, Register* registers,
                   Representation* param_representations,
                   PlatformCallInterfaceDescriptor* platform_descriptor = NULL);
 
-  bool initialized() const { return register_param_count_ >= 0; }
-
-  int environment_length() const {
-    return register_param_count_;
-  }
-
-  Representation GetParameterRepresentation(int index) const {
-    return param_representations_[index];
-  }
-
-  Register GetParameterRegister(int index) const {
-    return register_params_[index];
-  }
-
   PlatformCallInterfaceDescriptor* platform_specific_descriptor() const {
     return platform_specific_descriptor_;
   }
 
  private:
-  int register_param_count_;
-  SmartArrayPointer<Register> register_params_;
-  SmartArrayPointer<Representation> param_representations_;
   PlatformCallInterfaceDescriptor* platform_specific_descriptor_;
 };
 
 
 class HydrogenCodeStub : public CodeStub {
  public:
   enum InitializationState {
     UNINITIALIZED,
     INITIALIZED
   };
@@ skipping 2111 matching lines @@
 
 
 class CallDescriptors {
  public:
   static void InitializeForIsolate(Isolate* isolate);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_