[turbofan] Introduce new JSConstructWithArrayLike operator.

src/compiler/js-operator.cc

 // 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.
 
 #include "src/compiler/js-operator.h"
 
 #include <limits>
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/feedback-vector.h"
 #include "src/handles-inl.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 std::ostream& operator<<(std::ostream& os, CallFrequency f) {
   if (f.IsUnknown()) return os << "unknown";
   return os << f.value();
 }
 
 CallFrequency CallFrequencyOf(Operator const* op) {
-  DCHECK_EQ(IrOpcode::kJSCallWithArrayLike, op->opcode());
+  DCHECK(op->opcode() == IrOpcode::kJSCallWithArrayLike ||
+         op->opcode() == IrOpcode::kJSConstructWithArrayLike);
   return OpParameter<CallFrequency>(op);
 }
 
 VectorSlotPair::VectorSlotPair() {}
 
 
 int VectorSlotPair::index() const {
   return vector_.is_null() ? -1 : FeedbackVector::GetIndex(slot_);
 }
 
@@ skipping 844 matching lines @@
                                              CallFrequency frequency,
                                              VectorSlotPair const& feedback) {
   ConstructParameters parameters(arity, frequency, feedback);
   return new (zone()) Operator1<ConstructParameters>(   // --
       IrOpcode::kJSConstruct, Operator::kNoProperties,  // opcode
       "JSConstruct",                                    // name
       parameters.arity(), 1, 1, 1, 1, 2,                // counts
       parameters);                                      // parameter
 }
 
+const Operator* JSOperatorBuilder::ConstructWithArrayLike(
+    CallFrequency frequency) {
+  return new (zone()) Operator1<CallFrequency>(  // --
+      IrOpcode::kJSConstructWithArrayLike,       // opcode
+      Operator::kNoProperties,                   // properties
+      "JSConstructWithArrayLike",                // name
+      3, 1, 1, 1, 1, 2,                          // counts
+      frequency);                                // parameter
+}
+
 const Operator* JSOperatorBuilder::ConstructWithSpread(uint32_t arity) {
   SpreadWithArityParameter parameters(arity);
   return new (zone()) Operator1<SpreadWithArityParameter>(        // --
       IrOpcode::kJSConstructWithSpread, Operator::kNoProperties,  // opcode
       "JSConstructWithSpread",                                    // name
       parameters.arity(), 1, 1, 1, 1, 2,                          // counts
       parameters);                                                // parameter
 }
 
 const Operator* JSOperatorBuilder::ConvertReceiver(
@@ skipping 263 matching lines @@
   return new (zone()) Operator1<Handle<ScopeInfo>>(               // --
       IrOpcode::kJSCreateScriptContext, Operator::kNoProperties,  // opcode
       "JSCreateScriptContext",                                    // name
       1, 1, 1, 1, 1, 2,                                           // counts
       scope_info);                                                // parameter
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8