[turbofan] Avoid allocating rest parameters for spread calls.

src/compiler/js-operator.h

 // Copyright 2013 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_COMPILER_JS_OPERATOR_H_
 #define V8_COMPILER_JS_OPERATOR_H_
 
 #include "src/base/compiler-specific.h"
 #include "src/globals.h"
 #include "src/handles.h"
@@ skipping 72 matching lines @@
 size_t hash_value(VectorSlotPair const&);
 
 
 // The ConvertReceiverMode is used as parameter by JSConvertReceiver operators.
 ConvertReceiverMode ConvertReceiverModeOf(Operator const* op);
 
 
 // The ToBooleanHints are used as parameter by JSToBoolean operators.
 ToBooleanHints ToBooleanHintsOf(Operator const* op);
 
+// Defines the flags for a JavaScript call forwarding parameters. This
+// is used as parameter by JSConstructForwardVarargs operators.
+class ConstructForwardVarargsParameters final {
+ public:
+  ConstructForwardVarargsParameters(size_t arity, uint32_t start_index)
+      : bit_field_(ArityField::encode(arity) |
+                   StartIndexField::encode(start_index)) {}
+
+  size_t arity() const { return ArityField::decode(bit_field_); }
+  uint32_t start_index() const { return StartIndexField::decode(bit_field_); }
+
+  bool operator==(ConstructForwardVarargsParameters const& that) const {
+    return this->bit_field_ == that.bit_field_;
+  }
+  bool operator!=(ConstructForwardVarargsParameters const& that) const {
+    return !(*this == that);
+  }
+
+ private:
+  friend size_t hash_value(ConstructForwardVarargsParameters const& p) {
+    return p.bit_field_;
+  }
+
+  typedef BitField<size_t, 0, 16> ArityField;
+  typedef BitField<uint32_t, 16, 16> StartIndexField;
+
+  uint32_t const bit_field_;
+};
+
+std::ostream& operator<<(std::ostream&,
+                         ConstructForwardVarargsParameters const&);
+
+ConstructForwardVarargsParameters const& ConstructForwardVarargsParametersOf(
+    Operator const*) WARN_UNUSED_RESULT;
 
 // Defines the arity and the feedback for a JavaScript constructor call. This is
 // used as a parameter by JSConstruct operators.
 class ConstructParameters final {
  public:
   ConstructParameters(uint32_t arity, CallFrequency frequency,
                       VectorSlotPair const& feedback)
       : arity_(arity), frequency_(frequency), feedback_(feedback) {}
 
   uint32_t arity() const { return arity_; }
@@ skipping 36 matching lines @@
 size_t hash_value(SpreadWithArityParameter const&);
 
 std::ostream& operator<<(std::ostream&, SpreadWithArityParameter const&);
 
 SpreadWithArityParameter const& SpreadWithArityParameterOf(Operator const*);
 
 // Defines the flags for a JavaScript call forwarding parameters. This
 // is used as parameter by JSCallForwardVarargs operators.
 class CallForwardVarargsParameters final {
  public:
-  CallForwardVarargsParameters(uint32_t start_index,
+  CallForwardVarargsParameters(size_t arity, uint32_t start_index,
                                TailCallMode tail_call_mode)
-      : bit_field_(StartIndexField::encode(start_index) |
+      : bit_field_(ArityField::encode(arity) |
+                   StartIndexField::encode(start_index) |
                    TailCallModeField::encode(tail_call_mode)) {}
 
+  size_t arity() const { return ArityField::decode(bit_field_); }
   uint32_t start_index() const { return StartIndexField::decode(bit_field_); }
   TailCallMode tail_call_mode() const {
     return TailCallModeField::decode(bit_field_);
   }
 
   bool operator==(CallForwardVarargsParameters const& that) const {
     return this->bit_field_ == that.bit_field_;
   }
   bool operator!=(CallForwardVarargsParameters const& that) const {
     return !(*this == that);
   }
 
  private:
   friend size_t hash_value(CallForwardVarargsParameters const& p) {
     return p.bit_field_;
   }
 
-  typedef BitField<uint32_t, 0, 30> StartIndexField;
-  typedef BitField<TailCallMode, 31, 1> TailCallModeField;
+  typedef BitField<size_t, 0, 15> ArityField;
+  typedef BitField<uint32_t, 15, 15> StartIndexField;
+  typedef BitField<TailCallMode, 30, 1> TailCallModeField;
 
   uint32_t const bit_field_;
 };
 
 std::ostream& operator<<(std::ostream&, CallForwardVarargsParameters const&);
 
 CallForwardVarargsParameters const& CallForwardVarargsParametersOf(
     Operator const*) WARN_UNUSED_RESULT;
 
 // Defines the arity and the call flags for a JavaScript function call. This is
@@ skipping 475 matching lines @@
   const Operator* CreateKeyValueArray();
   const Operator* CreateLiteralArray(Handle<ConstantElementsPair> constant,
                                      int literal_flags, int literal_index,
                                      int number_of_elements);
   const Operator* CreateLiteralObject(Handle<BoilerplateDescription> constant,
                                       int literal_flags, int literal_index,
                                       int number_of_properties);
   const Operator* CreateLiteralRegExp(Handle<String> constant_pattern,
                                       int literal_flags, int literal_index);
 
-  const Operator* CallForwardVarargs(uint32_t start_index,
+  const Operator* CallForwardVarargs(size_t arity, uint32_t start_index,
                                      TailCallMode tail_call_mode);
   const Operator* Call(
       size_t arity, CallFrequency frequency = CallFrequency(),
       VectorSlotPair const& feedback = VectorSlotPair(),
       ConvertReceiverMode convert_mode = ConvertReceiverMode::kAny,
       TailCallMode tail_call_mode = TailCallMode::kDisallow);
   const Operator* CallWithSpread(uint32_t arity);
   const Operator* CallRuntime(Runtime::FunctionId id);
   const Operator* CallRuntime(Runtime::FunctionId id, size_t arity);
   const Operator* CallRuntime(const Runtime::Function* function, size_t arity);
+
+  const Operator* ConstructForwardVarargs(size_t arity, uint32_t start_index);
   const Operator* Construct(uint32_t arity,
                             CallFrequency frequency = CallFrequency(),
                             VectorSlotPair const& feedback = VectorSlotPair());
   const Operator* ConstructWithSpread(uint32_t arity);
 
   const Operator* ConvertReceiver(ConvertReceiverMode convert_mode);
 
   const Operator* LoadProperty(VectorSlotPair const& feedback);
   const Operator* LoadNamed(Handle<Name> name, VectorSlotPair const& feedback);
 
@@ skipping 64 matching lines @@
   Zone* const zone_;
 
   DISALLOW_COPY_AND_ASSIGN(JSOperatorBuilder);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_