[WIP] Start adding JSCallWithVarargs

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 200 matching lines @@
   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 flags for a JavaScript call forwarding parameters. This
+// is used as parameter by JSCallVarargs operators.
+class CallVarargsParameters final {
+ public:
+  explicit CallVarargsParameters(size_t arity) : arity_(arity) {}
+
+  size_t arity() const { return arity_; }
+
+  bool operator==(CallVarargsParameters const& that) const {
+    return this->arity_ == that.arity_;
+  }
+  bool operator!=(CallVarargsParameters const& that) const {
+    return !(*this == that);
+  }
+
+ private:
+  friend size_t hash_value(CallVarargsParameters const& p) {
+    return p.arity_;
+  }
+
+  const size_t arity_;
+};
+
+std::ostream& operator<<(std::ostream&, CallVarargsParameters const&);
+
+CallVarargsParameters const& CallVarargsParametersOf(Operator const*)
+    WARN_UNUSED_RESULT;
+
 // Defines the arity and the call flags for a JavaScript function call. This is
 // used as a parameter by JSCall operators.
 class CallParameters final {
  public:
   CallParameters(size_t arity, CallFrequency frequency,
                  VectorSlotPair const& feedback, TailCallMode tail_call_mode,
                  ConvertReceiverMode convert_mode)
       : bit_field_(ArityField::encode(arity) |
                    ConvertReceiverModeField::encode(convert_mode) |
                    TailCallModeField::encode(tail_call_mode)),
@@ skipping 488 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(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* CallForwardVarargs(size_t arity, uint32_t start_index,
+                                     TailCallMode tail_call_mode);
+  const Operator* CallVarargs(size_t arity);
   const Operator* CallWithArrayLike(CallFrequency frequency);
   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());
@@ skipping 76 matching lines @@
   Zone* const zone_;
 
   DISALLOW_COPY_AND_ASSIGN(JSOperatorBuilder);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_