HydrogenCodeStubs consume stack arguments via descriptor.

src/interface-descriptors.h

 // Copyright 2014 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_CALL_INTERFACE_DESCRIPTOR_H_
 #define V8_CALL_INTERFACE_DESCRIPTOR_H_
 
 #include "src/assembler.h"
 #include "src/macro-assembler.h"
 
@@ skipping 51 matching lines @@
   V(MathPowInteger)                           \
   V(ContextOnly)                              \
   V(GrowArrayElements)                        \
   V(MathRoundVariantCallFromUnoptimizedCode)  \
   V(MathRoundVariantCallFromOptimizedCode)
 
 
 class CallInterfaceDescriptorData {
  public:
   CallInterfaceDescriptorData()
-      : stack_paramater_count_(-1),
-        register_param_count_(-1),
-        function_type_(nullptr) {}
+      : register_param_count_(-1), function_type_(nullptr) {}
 
   // A copy of the passed in registers and param_representations is made
   // and owned by the CallInterfaceDescriptorData.
 
-  void InitializePlatformIndependent(int stack_paramater_count,
-                                     Type::FunctionType* function_type) {
+  void InitializePlatformIndependent(Type::FunctionType* function_type) {
     function_type_ = function_type;
-    stack_paramater_count_ = stack_paramater_count;
   }
 
   // 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 CodeStubDescriptor class.
   void InitializePlatformSpecific(
       int register_parameter_count, Register* registers,
       PlatformInterfaceDescriptor* platform_descriptor = NULL);
 
   bool IsInitialized() const { return register_param_count_ >= 0; }
 
+  int param_count() const { return function_type_->Arity(); }
   int register_param_count() const { return register_param_count_; }
   Register register_param(int index) const { return register_params_[index]; }
   Register* register_params() const { return register_params_.get(); }
-  Type* register_param_type(int index) const {
-    return function_type_->Parameter(index);
-  }
+  Type* param_type(int index) const { return function_type_->Parameter(index); }
   PlatformInterfaceDescriptor* platform_specific_descriptor() const {
     return platform_specific_descriptor_;
   }
 
   Type::FunctionType* function_type() const { return function_type_; }
 
  private:
-  int stack_paramater_count_;
   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.
   base::SmartArrayPointer<Register> register_params_;
 
   // Specifies types for parameters and return
   Type::FunctionType* function_type_;
@@ skipping 16 matching lines @@
 
 
 class CallInterfaceDescriptor {
  public:
   CallInterfaceDescriptor() : data_(NULL) {}
   virtual ~CallInterfaceDescriptor() {}
 
   CallInterfaceDescriptor(Isolate* isolate, CallDescriptors::Key key)
       : data_(isolate->call_descriptor_data(key)) {}
 
+  int GetParameterCount() const { return data()->param_count(); }
+
   int GetRegisterParameterCount() const {
     return data()->register_param_count();
   }
 
   int GetStackParameterCount() const {
     return data()->function_type()->Arity() - data()->register_param_count();
   }
 
   Register GetRegisterParameter(int index) const {
     return data()->register_param(index);
   }
 
   Type* GetParameterType(int index) const {
-    DCHECK(index < data()->register_param_count());
-    return data()->register_param_type(index);
+    DCHECK(index < data()->param_count());
+    return data()->param_type(index);
   }
 
   // Some platforms have extra information to associate with the descriptor.
   PlatformInterfaceDescriptor* platform_specific_descriptor() const {
     return data()->platform_specific_descriptor();
   }
 
   Type::FunctionType* GetFunctionType() const {
     return data()->function_type();
   }
@@ skipping 17 matching lines @@
     UNREACHABLE();
   }
 
   void Initialize(Isolate* isolate, CallDescriptors::Key key) {
     if (!data()->IsInitialized()) {
       CallInterfaceDescriptorData* d = isolate->call_descriptor_data(key);
       InitializePlatformSpecific(d);
       Type::FunctionType* function_type =
           BuildCallInterfaceDescriptorFunctionType(isolate,
                                                    d->register_param_count());
-      d->InitializePlatformIndependent(0, function_type);
+      d->InitializePlatformIndependent(function_type);
     }
   }
 
  private:
   const CallInterfaceDescriptorData* data_;
 };
 
 
 #define DECLARE_DESCRIPTOR(name, base)                                         \
   explicit name(Isolate* isolate) : base(isolate, key()) {                     \
@@ skipping 39 matching lines @@
     kParameterCount
   };
   static const Register ReceiverRegister();
   static const Register NameRegister();
   static const Register ValueRegister();
 };
 
 
 class StoreTransitionDescriptor : public StoreDescriptor {
  public:
-  DECLARE_DESCRIPTOR(StoreTransitionDescriptor, StoreDescriptor)
+  DECLARE_DESCRIPTOR_WITH_CUSTOM_FUNCTION_TYPE(StoreTransitionDescriptor,
+                                               StoreDescriptor)
 
   // Extends StoreDescriptor with Map parameter.
   enum ParameterIndices {
     kReceiverIndex,
     kNameIndex,
     kValueIndex,
     kMapIndex,
     kParameterCount
   };
+
+  // MapRegister() is no_reg on ia32, instead it's on the stack.
   static const Register MapRegister();
 };
 
 
 class InstanceofDescriptor : public CallInterfaceDescriptor {
  public:
   DECLARE_DESCRIPTOR(InstanceofDescriptor, CallInterfaceDescriptor)
 
   enum ParameterIndices { kLeftIndex, kRightIndex, kParameterCount };
   static const Register left();
@@ skipping 369 matching lines @@
 }  // namespace v8::internal
 
 
 #if V8_TARGET_ARCH_ARM64
 #include "src/arm64/interface-descriptors-arm64.h"
 #elif V8_TARGET_ARCH_ARM
 #include "src/arm/interface-descriptors-arm.h"
 #endif
 
 #endif  // V8_CALL_INTERFACE_DESCRIPTOR_H_