[turbofan] Initial support for Array constructor specialization.

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/runtime/runtime.h"
 
 namespace v8 {
@@ skipping 36 matching lines @@
 
 
 // Defines whether tail call optimization is allowed.
 enum class TailCallMode : unsigned { kAllow, kDisallow };
 
 size_t hash_value(TailCallMode);
 
 std::ostream& operator<<(std::ostream&, TailCallMode);
 
 
+// Defines the arity and the feedback for a JavaScript constructor call. This is
+// used as a parameter by JSCallConstruct operators.
+class CallConstructParameters final {
+ public:
+  CallConstructParameters(size_t arity, VectorSlotPair const& feedback)
+      : arity_(arity), feedback_(feedback) {}
+
+  size_t arity() const { return arity_; }
+  VectorSlotPair const& feedback() const { return feedback_; }
+
+ private:
+  size_t const arity_;
+  VectorSlotPair const feedback_;
+};
+
+bool operator==(CallConstructParameters const&, CallConstructParameters const&);
+bool operator!=(CallConstructParameters const&, CallConstructParameters const&);
+
+size_t hash_value(CallConstructParameters const&);
+
+std::ostream& operator<<(std::ostream&, CallConstructParameters const&);
+
+CallConstructParameters const& CallConstructParametersOf(Operator const*);
+
+
 // Defines the arity and the call flags for a JavaScript function call. This is
 // used as a parameter by JSCallFunction operators.
 class CallFunctionParameters final {
  public:
   CallFunctionParameters(size_t arity, LanguageMode language_mode,
                          VectorSlotPair const& feedback,
                          TailCallMode tail_call_mode,
                          ConvertReceiverMode convert_mode)
       : bit_field_(ArityField::encode(arity) |
                    ConvertReceiverModeField::encode(convert_mode) |
@@ skipping 253 matching lines @@
                 CreateArgumentsParameters const&);
 
 size_t hash_value(CreateArgumentsParameters const&);
 
 std::ostream& operator<<(std::ostream&, CreateArgumentsParameters const&);
 
 const CreateArgumentsParameters& CreateArgumentsParametersOf(
     const Operator* op);
 
 
+// Defines shared information for the array that should be created. This is
+// used as parameter by JSCreateArray operators.
+class CreateArrayParameters final {
+ public:
+  explicit CreateArrayParameters(
+      size_t arity,
+      MaybeHandle<AllocationSite> site = MaybeHandle<AllocationSite>())
+      : arity_(arity), site_(site) {}
+
+  size_t arity() const { return arity_; }
+  MaybeHandle<AllocationSite> site() const { return site_; }
+
+ private:
+  size_t const arity_;
+  MaybeHandle<AllocationSite> const site_;
+};
+
+bool operator==(CreateArrayParameters const&, CreateArrayParameters const&);
+bool operator!=(CreateArrayParameters const&, CreateArrayParameters const&);
+
+size_t hash_value(CreateArrayParameters const&);
+
+std::ostream& operator<<(std::ostream&, CreateArrayParameters const&);
+
+const CreateArrayParameters& CreateArrayParametersOf(const Operator* op);
+
+
 // Defines shared information for the closure that should be created. This is
 // used as a parameter by JSCreateClosure operators.
 class CreateClosureParameters final {
  public:
   CreateClosureParameters(Handle<SharedFunctionInfo> shared_info,
                           PretenureFlag pretenure)
       : shared_info_(shared_info), pretenure_(pretenure) {}
 
   Handle<SharedFunctionInfo> shared_info() const { return shared_info_; }
   PretenureFlag pretenure() const { return pretenure_; }
@@ skipping 44 matching lines @@
   const Operator* ToBoolean();
   const Operator* ToNumber();
   const Operator* ToString();
   const Operator* ToName();
   const Operator* ToObject();
   const Operator* Yield();
 
   const Operator* Create();
   const Operator* CreateArguments(CreateArgumentsParameters::Type type,
                                   int start_index);
+  const Operator* CreateArray(size_t arity, MaybeHandle<AllocationSite> site);
   const Operator* CreateClosure(Handle<SharedFunctionInfo> shared_info,
                                 PretenureFlag pretenure);
   const Operator* CreateLiteralArray(int literal_flags);
   const Operator* CreateLiteralObject(int literal_flags);
 
   const Operator* CallFunction(
       size_t arity, LanguageMode language_mode,
       VectorSlotPair const& feedback = VectorSlotPair(),
       ConvertReceiverMode convert_mode = ConvertReceiverMode::kAny,
       TailCallMode tail_call_mode = TailCallMode::kDisallow);
   const Operator* CallRuntime(Runtime::FunctionId id, size_t arity);
-  const Operator* CallConstruct(int arguments);
+  const Operator* CallConstruct(
+      size_t arity, VectorSlotPair const& feedback = VectorSlotPair());

[Michael Starzinger, 2015/11/20 12:06:47]

nit: Could we drop the default value? I would vote for being explicit at call
sites.

[Benedikt Meurer, 2015/11/20 12:28:52]

Done.

 
   const Operator* ConvertReceiver(ConvertReceiverMode convert_mode);
 
   const Operator* LoadProperty(LanguageMode language_mode,
                                VectorSlotPair const& feedback);
   const Operator* LoadNamed(LanguageMode language_mode, Handle<Name> name,
                             VectorSlotPair const& feedback);
 
   const Operator* StoreProperty(LanguageMode language_mode,
                                 VectorSlotPair const& feedback);
   const Operator* StoreNamed(LanguageMode language_mode, Handle<Name> name,
                              VectorSlotPair const& feedback);
 
   const Operator* DeleteProperty(LanguageMode language_mode);
 
   const Operator* HasProperty();
 
   const Operator* LoadGlobal(const Handle<Name>& name,
                              const VectorSlotPair& feedback,
                              TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
   const Operator* StoreGlobal(LanguageMode language_mode,
                               const Handle<Name>& name,
                               const VectorSlotPair& feedback);
 
   const Operator* LoadContext(size_t depth, size_t index, bool immutable);
   const Operator* StoreContext(size_t depth, size_t index);
 
+  const Operator* LoadNativeContext();

[Michael Starzinger, 2015/11/20 12:06:47]

nit: Move this down a bit so that the variable loads are together again.

[Benedikt Meurer, 2015/11/20 12:28:52]

As discussed offline: This will die once the contexts have a pointer to the
native context.

[Benedikt Meurer, 2015/11/20 12:28:52]

Done.

+
   const Operator* LoadDynamic(const Handle<String>& name,
                               TypeofMode typeof_mode);
 
   const Operator* TypeOf();
   const Operator* InstanceOf();
 
   const Operator* ForInDone();
   const Operator* ForInNext();
   const Operator* ForInPrepare();
   const Operator* ForInStep();
@@ skipping 17 matching lines @@
   Zone* const zone_;
 
   DISALLOW_COPY_AND_ASSIGN(JSOperatorBuilder);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_