[turbofan] Initial support for Array constructor specialization.

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"
@@ skipping 45 matching lines @@
     case TailCallMode::kAllow:
       return os << "ALLOW_TAIL_CALLS";
     case TailCallMode::kDisallow:
       return os << "DISALLOW_TAIL_CALLS";
   }
   UNREACHABLE();
   return os;
 }
 
 
+bool operator==(CallConstructParameters const& lhs,
+                CallConstructParameters const& rhs) {
+  return lhs.arity() == rhs.arity() && lhs.feedback() == rhs.feedback();
+}
+
+
+bool operator!=(CallConstructParameters const& lhs,
+                CallConstructParameters const& rhs) {
+  return !(lhs == rhs);
+}
+
+
+size_t hash_value(CallConstructParameters const& p) {
+  return base::hash_combine(p.arity(), p.feedback());
+}
+
+
+std::ostream& operator<<(std::ostream& os, CallConstructParameters const& p) {
+  return os << p.arity();
+}
+
+
+CallConstructParameters const& CallConstructParametersOf(Operator const* op) {
+  DCHECK_EQ(IrOpcode::kJSCallConstruct, op->opcode());
+  return OpParameter<CallConstructParameters>(op);
+}
+
+
 std::ostream& operator<<(std::ostream& os, CallFunctionParameters const& p) {
   os << p.arity() << ", " << p.language_mode() << ", " << p.convert_mode()
      << ", " << p.tail_call_mode();
   return os;
 }
 
 
 const CallFunctionParameters& CallFunctionParametersOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kJSCallFunction, op->opcode());
   return OpParameter<CallFunctionParameters>(op);
@@ skipping 239 matching lines @@
 }
 
 
 const CreateArgumentsParameters& CreateArgumentsParametersOf(
     const Operator* op) {
   DCHECK_EQ(IrOpcode::kJSCreateArguments, op->opcode());
   return OpParameter<CreateArgumentsParameters>(op);
 }
 
 
+bool operator==(CreateArrayParameters const& lhs,
+                CreateArrayParameters const& rhs) {
+  return lhs.arity() == rhs.arity() &&
+         lhs.site().location() == rhs.site().location();
+}
+
+
+bool operator!=(CreateArrayParameters const& lhs,
+                CreateArrayParameters const& rhs) {
+  return !(lhs == rhs);
+}
+
+
+size_t hash_value(CreateArrayParameters const& p) {
+  return base::hash_combine(p.arity(), p.site().location());
+}
+
+
+std::ostream& operator<<(std::ostream& os, CreateArrayParameters const& p) {
+  os << p.arity();
+  Handle<AllocationSite> site;
+  if (p.site().ToHandle(&site)) os << ", " << Brief(*site);
+  return os;
+}
+
+
+const CreateArrayParameters& CreateArrayParametersOf(const Operator* op) {
+  DCHECK_EQ(IrOpcode::kJSCreateArray, op->opcode());
+  return OpParameter<CreateArrayParameters>(op);
+}
+
+
 bool operator==(CreateClosureParameters const& lhs,
                 CreateClosureParameters const& rhs) {
   return lhs.pretenure() == rhs.pretenure() &&
          lhs.shared_info().location() == rhs.shared_info().location();
 }
 
 
 bool operator!=(CreateClosureParameters const& lhs,
                 CreateClosureParameters const& rhs) {
   return !(lhs == rhs);
@@ skipping 32 matching lines @@
   V(HasProperty, Operator::kNoProperties, 2, 1)       \
   V(TypeOf, Operator::kEliminatable, 1, 1)            \
   V(InstanceOf, Operator::kNoProperties, 2, 1)        \
   V(ForInDone, Operator::kPure, 2, 1)                 \
   V(ForInNext, Operator::kNoProperties, 4, 1)         \
   V(ForInPrepare, Operator::kNoProperties, 1, 3)      \
   V(ForInStep, Operator::kPure, 1, 1)                 \
   V(LoadMessage, Operator::kNoThrow, 0, 1)            \
   V(StoreMessage, Operator::kNoThrow, 1, 0)           \
   V(StackCheck, Operator::kNoProperties, 0, 0)        \
+  V(LoadNativeContext, Operator::kEliminatable, 1, 1) \
   V(CreateWithContext, Operator::kNoProperties, 2, 1) \
   V(CreateModuleContext, Operator::kNoProperties, 2, 1)
 
 
 #define CACHED_OP_LIST_WITH_LANGUAGE_MODE(V)           \
   V(LessThan, Operator::kNoProperties, 2, 1)           \
   V(GreaterThan, Operator::kNoProperties, 2, 1)        \
   V(LessThanOrEqual, Operator::kNoProperties, 2, 1)    \
   V(GreaterThanOrEqual, Operator::kNoProperties, 2, 1) \
   V(BitwiseOr, Operator::kNoProperties, 2, 1)          \
@@ skipping 99 matching lines @@
   const Runtime::Function* f = Runtime::FunctionForId(parameters.id());
   DCHECK(f->nargs == -1 || f->nargs == static_cast<int>(parameters.arity()));
   return new (zone()) Operator1<CallRuntimeParameters>(   // --
       IrOpcode::kJSCallRuntime, Operator::kNoProperties,  // opcode
       "JSCallRuntime",                                    // name
       parameters.arity(), 1, 1, f->result_size, 1, 2,     // inputs/outputs
       parameters);                                        // parameter
 }
 
 
-const Operator* JSOperatorBuilder::CallConstruct(int arguments) {
-  return new (zone()) Operator1<int>(                       // --
+const Operator* JSOperatorBuilder::CallConstruct(
+    size_t arity, VectorSlotPair const& feedback) {
+  CallConstructParameters parameters(arity, feedback);
+  return new (zone()) Operator1<CallConstructParameters>(   // --
       IrOpcode::kJSCallConstruct, Operator::kNoProperties,  // opcode
       "JSCallConstruct",                                    // name
-      arguments, 1, 1, 1, 1, 2,                             // counts
-      arguments);                                           // parameter
+      parameters.arity(), 1, 1, 1, 1, 2,                    // counts
+      parameters);                                          // parameter
 }
 
 
 const Operator* JSOperatorBuilder::ConvertReceiver(
     ConvertReceiverMode convert_mode) {
   return new (zone()) Operator1<ConvertReceiverMode>(    // --
       IrOpcode::kJSConvertReceiver, Operator::kNoThrow,  // opcode
       "JSConvertReceiver",                               // name
       1, 1, 1, 1, 1, 0,                                  // counts
       convert_mode);                                     // parameter
@@ skipping 118 matching lines @@
   DCHECK_IMPLIES(start_index, type == CreateArgumentsParameters::kRestArray);
   CreateArgumentsParameters parameters(type, start_index);
   return new (zone()) Operator1<CreateArgumentsParameters>(  // --
       IrOpcode::kJSCreateArguments, Operator::kNoThrow,      // opcode
       "JSCreateArguments",                                   // name
       1, 1, 1, 1, 1, 0,                                      // counts
       parameters);                                           // parameter
 }
 
 
+const Operator* JSOperatorBuilder::CreateArray(
+    size_t arity, MaybeHandle<AllocationSite> site) {
+  // constructor, new_target, arg1, ..., argN
+  int const value_input_count = static_cast<int>(arity) + 2;
+  CreateArrayParameters parameters(arity, site);
+  return new (zone()) Operator1<CreateArrayParameters>(   // --
+      IrOpcode::kJSCreateArray, Operator::kNoProperties,  // opcode
+      "JSCreateArray",                                    // name
+      value_input_count, 1, 1, 1, 1, 2,                   // counts
+      parameters);                                        // parameter
+}
+
+
 const Operator* JSOperatorBuilder::CreateClosure(
     Handle<SharedFunctionInfo> shared_info, PretenureFlag pretenure) {
   CreateClosureParameters parameters(shared_info, pretenure);
   return new (zone()) Operator1<CreateClosureParameters>(  // --
       IrOpcode::kJSCreateClosure, Operator::kNoThrow,      // opcode
       "JSCreateClosure",                                   // name
       0, 1, 1, 1, 1, 0,                                    // counts
       parameters);                                         // parameter
 }
 
@@ skipping 50 matching lines @@
   return new (zone()) Operator1<Handle<ScopeInfo>>(               // --
       IrOpcode::kJSCreateScriptContext, Operator::kNoProperties,  // opcode
       "JSCreateScriptContext",                                    // name
       1, 1, 1, 1, 1, 2,                                           // counts
       scpope_info);                                               // parameter
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8