Make concrete classes for individual call descriptors.

src/hydrogen-instructions.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_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include "src/v8.h"
 
 #include "src/allocation.h"
@@ skipping 2302 matching lines @@
 
   bool pass_argument_count_;
   bool has_stack_check_;
 };
 
 
 class HCallWithDescriptor FINAL : public HInstruction {
  public:
   static HCallWithDescriptor* New(Zone* zone, HValue* context, HValue* target,
                                   int argument_count,
-                                  const CallInterfaceDescriptor* descriptor,
+                                  CallInterfaceDescriptor descriptor,
                                   const Vector<HValue*>& operands) {
-    DCHECK(operands.length() == descriptor->GetEnvironmentLength());
+    DCHECK(operands.length() == descriptor.GetEnvironmentLength());
     HCallWithDescriptor* res =
         new(zone) HCallWithDescriptor(target, argument_count,
                                       descriptor, operands, zone);
     return res;
   }
 
   virtual int OperandCount() const FINAL OVERRIDE {
     return values_.length();
   }
   virtual HValue* OperandAt(int index) const FINAL OVERRIDE {
     return values_[index];
   }
 
   virtual Representation RequiredInputRepresentation(
       int index) FINAL OVERRIDE {
     if (index == 0) {
       return Representation::Tagged();
     } else {
       int par_index = index - 1;
-      DCHECK(par_index < descriptor_->GetEnvironmentLength());
-      return descriptor_->GetParameterRepresentation(par_index);
+      DCHECK(par_index < descriptor_.GetEnvironmentLength());
+      return descriptor_.GetParameterRepresentation(par_index);
     }
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor)
 
   virtual HType CalculateInferredType() FINAL OVERRIDE {
     return HType::Tagged();
   }
 
   virtual int argument_count() const {
     return argument_count_;
   }
 
   virtual int argument_delta() const OVERRIDE {
     return -argument_count_;
   }
 
-  const CallInterfaceDescriptor* descriptor() const { return descriptor_; }
+  CallInterfaceDescriptor descriptor() const { return descriptor_; }
 
   HValue* target() {
     return OperandAt(0);
   }
 
   virtual OStream& PrintDataTo(OStream& os) const OVERRIDE;  // NOLINT
 
  private:
   // The argument count includes the receiver.
   HCallWithDescriptor(HValue* target, int argument_count,
-                      const CallInterfaceDescriptor* descriptor,
+                      CallInterfaceDescriptor descriptor,
                       const Vector<HValue*>& operands, Zone* zone)
       : descriptor_(descriptor),
-        values_(descriptor->GetEnvironmentLength() + 1, zone) {
+        values_(descriptor.GetEnvironmentLength() + 1, zone) {
     argument_count_ = argument_count;
     AddOperand(target, zone);
     for (int i = 0; i < operands.length(); i++) {
       AddOperand(operands[i], zone);
     }
     this->set_representation(Representation::Tagged());
     this->SetAllSideEffects();
   }
 
   void AddOperand(HValue* v, Zone* zone) {
     values_.Add(NULL, zone);
     SetOperandAt(values_.length() - 1, v);
   }
 
   void InternalSetOperandAt(int index,
                             HValue* value) FINAL OVERRIDE {
     values_[index] = value;
   }
 
-  const CallInterfaceDescriptor* descriptor_;
+  CallInterfaceDescriptor descriptor_;
   ZoneList<HValue*> values_;
   int argument_count_;
 };
 
 
 class HInvokeFunction FINAL : public HBinaryCall {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInvokeFunction, HValue*, int);
 
   HInvokeFunction(HValue* context,
@@ skipping 5440 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_