LCOV - code coverage report
Current view: top level - src/compiler - js-operator.h (source / functions) Hit Total Coverage
Test: app.info Lines: 25 43 58.1 %
Date: 2019-02-19 Functions: 1 7 14.3 %

          Line data    Source code
       1             : // Copyright 2013 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_COMPILER_JS_OPERATOR_H_
       6             : #define V8_COMPILER_JS_OPERATOR_H_
       7             : 
       8             : #include "src/base/compiler-specific.h"
       9             : #include "src/globals.h"
      10             : #include "src/maybe-handles.h"
      11             : #include "src/runtime/runtime.h"
      12             : #include "src/type-hints.h"
      13             : #include "src/vector-slot-pair.h"
      14             : 
      15             : namespace v8 {
      16             : namespace internal {
      17             : 
      18             : class AllocationSite;
      19             : class ObjectBoilerplateDescription;
      20             : class ArrayBoilerplateDescription;
      21             : class FeedbackCell;
      22             : class SharedFunctionInfo;
      23             : 
      24             : namespace compiler {
      25             : 
      26             : // Forward declarations.
      27             : class Operator;
      28             : struct JSOperatorGlobalCache;
      29             : 
      30             : // Defines the frequency a given Call/Construct site was executed. For some
      31             : // call sites the frequency is not known.
      32             : class CallFrequency final {
      33             :  public:
      34      595067 :   CallFrequency() : value_(std::numeric_limits<float>::quiet_NaN()) {}
      35      642791 :   explicit CallFrequency(float value) : value_(value) {
      36             :     DCHECK(!std::isnan(value));
      37             :   }
      38             : 
      39             :   bool IsKnown() const { return !IsUnknown(); }
      40      990948 :   bool IsUnknown() const { return std::isnan(value_); }
      41             :   float value() const {
      42             :     DCHECK(IsKnown());
      43      163189 :     return value_;
      44             :   }
      45             : 
      46           0 :   bool operator==(CallFrequency const& that) const {
      47           0 :     return bit_cast<uint32_t>(this->value_) == bit_cast<uint32_t>(that.value_);
      48             :   }
      49             :   bool operator!=(CallFrequency const& that) const { return !(*this == that); }
      50             : 
      51           0 :   friend size_t hash_value(CallFrequency f) {
      52           0 :     return bit_cast<uint32_t>(f.value_);
      53             :   }
      54             : 
      55             :   static constexpr float kNoFeedbackCallFrequency = -1;
      56             : 
      57             :  private:
      58             :   float value_;
      59             : };
      60             : 
      61             : std::ostream& operator<<(std::ostream&, CallFrequency);
      62             : 
      63             : CallFrequency CallFrequencyOf(Operator const* op) V8_WARN_UNUSED_RESULT;
      64             : 
      65             : // Defines the flags for a JavaScript call forwarding parameters. This
      66             : // is used as parameter by JSConstructForwardVarargs operators.
      67             : class ConstructForwardVarargsParameters final {
      68             :  public:
      69             :   ConstructForwardVarargsParameters(size_t arity, uint32_t start_index)
      70         720 :       : bit_field_(ArityField::encode(arity) |
      71             :                    StartIndexField::encode(start_index)) {}
      72             : 
      73             :   size_t arity() const { return ArityField::decode(bit_field_); }
      74           0 :   uint32_t start_index() const { return StartIndexField::decode(bit_field_); }
      75             : 
      76             :   bool operator==(ConstructForwardVarargsParameters const& that) const {
      77           0 :     return this->bit_field_ == that.bit_field_;
      78             :   }
      79             :   bool operator!=(ConstructForwardVarargsParameters const& that) const {
      80             :     return !(*this == that);
      81             :   }
      82             : 
      83             :  private:
      84           0 :   friend size_t hash_value(ConstructForwardVarargsParameters const& p) {
      85           0 :     return p.bit_field_;
      86             :   }
      87             : 
      88             :   typedef BitField<size_t, 0, 16> ArityField;
      89             :   typedef BitField<uint32_t, 16, 16> StartIndexField;
      90             : 
      91             :   uint32_t const bit_field_;
      92             : };
      93             : 
      94             : std::ostream& operator<<(std::ostream&,
      95             :                          ConstructForwardVarargsParameters const&);
      96             : 
      97             : ConstructForwardVarargsParameters const& ConstructForwardVarargsParametersOf(
      98             :     Operator const*) V8_WARN_UNUSED_RESULT;
      99             : 
     100             : // Defines the arity and the feedback for a JavaScript constructor call. This is
     101             : // used as a parameter by JSConstruct and JSConstructWithSpread operators.
     102             : class ConstructParameters final {
     103             :  public:
     104             :   ConstructParameters(uint32_t arity, CallFrequency frequency,
     105             :                       VectorSlotPair const& feedback)
     106       41295 :       : arity_(arity), frequency_(frequency), feedback_(feedback) {}
     107             : 
     108             :   uint32_t arity() const { return arity_; }
     109             :   CallFrequency frequency() const { return frequency_; }
     110             :   VectorSlotPair const& feedback() const { return feedback_; }
     111             : 
     112             :  private:
     113             :   uint32_t const arity_;
     114             :   CallFrequency const frequency_;
     115             :   VectorSlotPair const feedback_;
     116             : };
     117             : 
     118             : bool operator==(ConstructParameters const&, ConstructParameters const&);
     119             : bool operator!=(ConstructParameters const&, ConstructParameters const&);
     120             : 
     121             : size_t hash_value(ConstructParameters const&);
     122             : 
     123             : std::ostream& operator<<(std::ostream&, ConstructParameters const&);
     124             : 
     125             : ConstructParameters const& ConstructParametersOf(Operator const*);
     126             : 
     127             : // Defines the flags for a JavaScript call forwarding parameters. This
     128             : // is used as parameter by JSCallForwardVarargs operators.
     129             : class CallForwardVarargsParameters final {
     130             :  public:
     131             :   CallForwardVarargsParameters(size_t arity, uint32_t start_index)
     132         366 :       : bit_field_(ArityField::encode(arity) |
     133             :                    StartIndexField::encode(start_index)) {}
     134             : 
     135             :   size_t arity() const { return ArityField::decode(bit_field_); }
     136           0 :   uint32_t start_index() const { return StartIndexField::decode(bit_field_); }
     137             : 
     138             :   bool operator==(CallForwardVarargsParameters const& that) const {
     139           0 :     return this->bit_field_ == that.bit_field_;
     140             :   }
     141             :   bool operator!=(CallForwardVarargsParameters const& that) const {
     142             :     return !(*this == that);
     143             :   }
     144             : 
     145             :  private:
     146           0 :   friend size_t hash_value(CallForwardVarargsParameters const& p) {
     147           0 :     return p.bit_field_;
     148             :   }
     149             : 
     150             :   typedef BitField<size_t, 0, 15> ArityField;
     151             :   typedef BitField<uint32_t, 15, 15> StartIndexField;
     152             : 
     153             :   uint32_t const bit_field_;
     154             : };
     155             : 
     156             : std::ostream& operator<<(std::ostream&, CallForwardVarargsParameters const&);
     157             : 
     158             : CallForwardVarargsParameters const& CallForwardVarargsParametersOf(
     159             :     Operator const*) V8_WARN_UNUSED_RESULT;
     160             : 
     161             : // Defines the arity and the call flags for a JavaScript function call. This is
     162             : // used as a parameter by JSCall and JSCallWithSpread operators.
     163             : class CallParameters final {
     164             :  public:
     165             :   CallParameters(size_t arity, CallFrequency const& frequency,
     166             :                  VectorSlotPair const& feedback,
     167             :                  ConvertReceiverMode convert_mode,
     168             :                  SpeculationMode speculation_mode)
     169      791254 :       : bit_field_(ArityField::encode(arity) |
     170      791254 :                    SpeculationModeField::encode(speculation_mode) |
     171             :                    ConvertReceiverModeField::encode(convert_mode)),
     172             :         frequency_(frequency),
     173      791254 :         feedback_(feedback) {}
     174             : 
     175             :   size_t arity() const { return ArityField::decode(bit_field_); }
     176             :   CallFrequency const& frequency() const { return frequency_; }
     177             :   ConvertReceiverMode convert_mode() const {
     178             :     return ConvertReceiverModeField::decode(bit_field_);
     179             :   }
     180             :   VectorSlotPair const& feedback() const { return feedback_; }
     181             : 
     182             :   SpeculationMode speculation_mode() const {
     183             :     return SpeculationModeField::decode(bit_field_);
     184             :   }
     185             : 
     186           0 :   bool operator==(CallParameters const& that) const {
     187           0 :     return this->bit_field_ == that.bit_field_ &&
     188           0 :            this->frequency_ == that.frequency_ &&
     189           0 :            this->feedback_ == that.feedback_;
     190             :   }
     191             :   bool operator!=(CallParameters const& that) const { return !(*this == that); }
     192             : 
     193             :  private:
     194           0 :   friend size_t hash_value(CallParameters const& p) {
     195           0 :     return base::hash_combine(p.bit_field_, p.frequency_, p.feedback_);
     196             :   }
     197             : 
     198             :   typedef BitField<size_t, 0, 28> ArityField;
     199             :   typedef BitField<SpeculationMode, 28, 1> SpeculationModeField;
     200             :   typedef BitField<ConvertReceiverMode, 29, 2> ConvertReceiverModeField;
     201             : 
     202             :   uint32_t const bit_field_;
     203             :   CallFrequency const frequency_;
     204             :   VectorSlotPair const feedback_;
     205             : };
     206             : 
     207             : size_t hash_value(CallParameters const&);
     208             : 
     209             : std::ostream& operator<<(std::ostream&, CallParameters const&);
     210             : 
     211             : const CallParameters& CallParametersOf(const Operator* op);
     212             : 
     213             : 
     214             : // Defines the arity and the ID for a runtime function call. This is used as a
     215             : // parameter by JSCallRuntime operators.
     216             : class CallRuntimeParameters final {
     217             :  public:
     218             :   CallRuntimeParameters(Runtime::FunctionId id, size_t arity)
     219             :       : id_(id), arity_(arity) {}
     220             : 
     221             :   Runtime::FunctionId id() const { return id_; }
     222             :   size_t arity() const { return arity_; }
     223             : 
     224             :  private:
     225             :   const Runtime::FunctionId id_;
     226             :   const size_t arity_;
     227             : };
     228             : 
     229             : bool operator==(CallRuntimeParameters const&, CallRuntimeParameters const&);
     230             : bool operator!=(CallRuntimeParameters const&, CallRuntimeParameters const&);
     231             : 
     232             : size_t hash_value(CallRuntimeParameters const&);
     233             : 
     234             : std::ostream& operator<<(std::ostream&, CallRuntimeParameters const&);
     235             : 
     236             : const CallRuntimeParameters& CallRuntimeParametersOf(const Operator* op);
     237             : 
     238             : 
     239             : // Defines the location of a context slot relative to a specific scope. This is
     240             : // used as a parameter by JSLoadContext and JSStoreContext operators and allows
     241             : // accessing a context-allocated variable without keeping track of the scope.
     242             : class ContextAccess final {
     243             :  public:
     244             :   ContextAccess(size_t depth, size_t index, bool immutable);
     245             : 
     246     2359110 :   size_t depth() const { return depth_; }
     247     1156376 :   size_t index() const { return index_; }
     248             :   bool immutable() const { return immutable_; }
     249             : 
     250             :  private:
     251             :   // For space reasons, we keep this tightly packed, otherwise we could just use
     252             :   // a simple int/int/bool POD.
     253             :   const bool immutable_;
     254             :   const uint16_t depth_;
     255             :   const uint32_t index_;
     256             : };
     257             : 
     258             : bool operator==(ContextAccess const&, ContextAccess const&);
     259             : bool operator!=(ContextAccess const&, ContextAccess const&);
     260             : 
     261             : size_t hash_value(ContextAccess const&);
     262             : 
     263             : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, ContextAccess const&);
     264             : 
     265             : V8_EXPORT_PRIVATE ContextAccess const& ContextAccessOf(Operator const*);
     266             : 
     267             : // Defines the slot count and ScopeType for a new function or eval context. This
     268             : // is used as a parameter by the JSCreateFunctionContext operator.
     269             : class CreateFunctionContextParameters final {
     270             :  public:
     271             :   CreateFunctionContextParameters(Handle<ScopeInfo> scope_info, int slot_count,
     272             :                                   ScopeType scope_type);
     273             : 
     274             :   Handle<ScopeInfo> scope_info() const { return scope_info_; }
     275             :   int slot_count() const { return slot_count_; }
     276             :   ScopeType scope_type() const { return scope_type_; }
     277             : 
     278             :  private:
     279             :   Handle<ScopeInfo> scope_info_;
     280             :   int const slot_count_;
     281             :   ScopeType const scope_type_;
     282             : };
     283             : 
     284             : bool operator==(CreateFunctionContextParameters const& lhs,
     285             :                 CreateFunctionContextParameters const& rhs);
     286             : bool operator!=(CreateFunctionContextParameters const& lhs,
     287             :                 CreateFunctionContextParameters const& rhs);
     288             : 
     289             : size_t hash_value(CreateFunctionContextParameters const& parameters);
     290             : 
     291             : std::ostream& operator<<(std::ostream& os,
     292             :                          CreateFunctionContextParameters const& parameters);
     293             : 
     294             : CreateFunctionContextParameters const& CreateFunctionContextParametersOf(
     295             :     Operator const*);
     296             : 
     297             : // Defines parameters for JSStoreNamedOwn operator.
     298             : class StoreNamedOwnParameters final {
     299             :  public:
     300             :   StoreNamedOwnParameters(Handle<Name> name, VectorSlotPair const& feedback)
     301       31410 :       : name_(name), feedback_(feedback) {}
     302             : 
     303             :   Handle<Name> name() const { return name_; }
     304             :   VectorSlotPair const& feedback() const { return feedback_; }
     305             : 
     306             :  private:
     307             :   Handle<Name> const name_;
     308             :   VectorSlotPair const feedback_;
     309             : };
     310             : 
     311             : bool operator==(StoreNamedOwnParameters const&, StoreNamedOwnParameters const&);
     312             : bool operator!=(StoreNamedOwnParameters const&, StoreNamedOwnParameters const&);
     313             : 
     314             : size_t hash_value(StoreNamedOwnParameters const&);
     315             : 
     316             : std::ostream& operator<<(std::ostream&, StoreNamedOwnParameters const&);
     317             : 
     318             : const StoreNamedOwnParameters& StoreNamedOwnParametersOf(const Operator* op);
     319             : 
     320             : // Defines the feedback, i.e., vector and index, for storing a data property in
     321             : // an object literal. This is used as a parameter by JSCreateEmptyLiteralArray
     322             : // and JSStoreDataPropertyInLiteral operators.
     323             : class FeedbackParameter final {
     324             :  public:
     325             :   explicit FeedbackParameter(VectorSlotPair const& feedback)
     326       69846 :       : feedback_(feedback) {}
     327             : 
     328             :   VectorSlotPair const& feedback() const { return feedback_; }
     329             : 
     330             :  private:
     331             :   VectorSlotPair const feedback_;
     332             : };
     333             : 
     334             : bool operator==(FeedbackParameter const&, FeedbackParameter const&);
     335             : bool operator!=(FeedbackParameter const&, FeedbackParameter const&);
     336             : 
     337             : size_t hash_value(FeedbackParameter const&);
     338             : 
     339             : std::ostream& operator<<(std::ostream&, FeedbackParameter const&);
     340             : 
     341             : const FeedbackParameter& FeedbackParameterOf(const Operator* op);
     342             : 
     343             : // Defines the property of an object for a named access. This is
     344             : // used as a parameter by the JSLoadNamed and JSStoreNamed operators.
     345             : class NamedAccess final {
     346             :  public:
     347             :   NamedAccess(LanguageMode language_mode, Handle<Name> name,
     348             :               VectorSlotPair const& feedback)
     349      613236 :       : name_(name), feedback_(feedback), language_mode_(language_mode) {}
     350             : 
     351             :   Handle<Name> name() const { return name_; }
     352             :   LanguageMode language_mode() const { return language_mode_; }
     353             :   VectorSlotPair const& feedback() const { return feedback_; }
     354             : 
     355             :  private:
     356             :   Handle<Name> const name_;
     357             :   VectorSlotPair const feedback_;
     358             :   LanguageMode const language_mode_;
     359             : };
     360             : 
     361             : bool operator==(NamedAccess const&, NamedAccess const&);
     362             : bool operator!=(NamedAccess const&, NamedAccess const&);
     363             : 
     364             : size_t hash_value(NamedAccess const&);
     365             : 
     366             : std::ostream& operator<<(std::ostream&, NamedAccess const&);
     367             : 
     368             : const NamedAccess& NamedAccessOf(const Operator* op);
     369             : 
     370             : 
     371             : // Defines the property being loaded from an object by a named load. This is
     372             : // used as a parameter by JSLoadGlobal operator.
     373             : class LoadGlobalParameters final {
     374             :  public:
     375             :   LoadGlobalParameters(const Handle<Name>& name, const VectorSlotPair& feedback,
     376             :                        TypeofMode typeof_mode)
     377     1027826 :       : name_(name), feedback_(feedback), typeof_mode_(typeof_mode) {}
     378             : 
     379             :   const Handle<Name>& name() const { return name_; }
     380             :   TypeofMode typeof_mode() const { return typeof_mode_; }
     381             : 
     382             :   const VectorSlotPair& feedback() const { return feedback_; }
     383             : 
     384             :  private:
     385             :   const Handle<Name> name_;
     386             :   const VectorSlotPair feedback_;
     387             :   const TypeofMode typeof_mode_;
     388             : };
     389             : 
     390             : bool operator==(LoadGlobalParameters const&, LoadGlobalParameters const&);
     391             : bool operator!=(LoadGlobalParameters const&, LoadGlobalParameters const&);
     392             : 
     393             : size_t hash_value(LoadGlobalParameters const&);
     394             : 
     395             : std::ostream& operator<<(std::ostream&, LoadGlobalParameters const&);
     396             : 
     397             : const LoadGlobalParameters& LoadGlobalParametersOf(const Operator* op);
     398             : 
     399             : 
     400             : // Defines the property being stored to an object by a named store. This is
     401             : // used as a parameter by JSStoreGlobal operator.
     402             : class StoreGlobalParameters final {
     403             :  public:
     404             :   StoreGlobalParameters(LanguageMode language_mode,
     405             :                         const VectorSlotPair& feedback,
     406             :                         const Handle<Name>& name)
     407      216149 :       : language_mode_(language_mode), name_(name), feedback_(feedback) {}
     408             : 
     409             :   LanguageMode language_mode() const { return language_mode_; }
     410             :   const VectorSlotPair& feedback() const { return feedback_; }
     411             :   const Handle<Name>& name() const { return name_; }
     412             : 
     413             :  private:
     414             :   const LanguageMode language_mode_;
     415             :   const Handle<Name> name_;
     416             :   const VectorSlotPair feedback_;
     417             : };
     418             : 
     419             : bool operator==(StoreGlobalParameters const&, StoreGlobalParameters const&);
     420             : bool operator!=(StoreGlobalParameters const&, StoreGlobalParameters const&);
     421             : 
     422             : size_t hash_value(StoreGlobalParameters const&);
     423             : 
     424             : std::ostream& operator<<(std::ostream&, StoreGlobalParameters const&);
     425             : 
     426             : const StoreGlobalParameters& StoreGlobalParametersOf(const Operator* op);
     427             : 
     428             : 
     429             : // Defines the property of an object for a keyed access. This is used
     430             : // as a parameter by the JSLoadProperty and JSStoreProperty operators.
     431             : class PropertyAccess final {
     432             :  public:
     433             :   PropertyAccess(LanguageMode language_mode, VectorSlotPair const& feedback)
     434       55095 :       : feedback_(feedback), language_mode_(language_mode) {}
     435             : 
     436             :   LanguageMode language_mode() const { return language_mode_; }
     437             :   VectorSlotPair const& feedback() const { return feedback_; }
     438             : 
     439             :  private:
     440             :   VectorSlotPair const feedback_;
     441             :   LanguageMode const language_mode_;
     442             : };
     443             : 
     444             : bool operator==(PropertyAccess const&, PropertyAccess const&);
     445             : bool operator!=(PropertyAccess const&, PropertyAccess const&);
     446             : 
     447             : size_t hash_value(PropertyAccess const&);
     448             : 
     449             : std::ostream& operator<<(std::ostream&, PropertyAccess const&);
     450             : 
     451             : PropertyAccess const& PropertyAccessOf(const Operator* op);
     452             : 
     453             : 
     454             : // CreateArgumentsType is used as parameter to JSCreateArguments nodes.
     455             : CreateArgumentsType const& CreateArgumentsTypeOf(const Operator* op);
     456             : 
     457             : 
     458             : // Defines shared information for the array that should be created. This is
     459             : // used as parameter by JSCreateArray operators.
     460             : class CreateArrayParameters final {
     461             :  public:
     462             :   explicit CreateArrayParameters(size_t arity, MaybeHandle<AllocationSite> site)
     463             :       : arity_(arity), site_(site) {}
     464             : 
     465             :   size_t arity() const { return arity_; }
     466             :   MaybeHandle<AllocationSite> site() const { return site_; }
     467             : 
     468             :  private:
     469             :   size_t const arity_;
     470             :   MaybeHandle<AllocationSite> const site_;
     471             : };
     472             : 
     473             : bool operator==(CreateArrayParameters const&, CreateArrayParameters const&);
     474             : bool operator!=(CreateArrayParameters const&, CreateArrayParameters const&);
     475             : 
     476             : size_t hash_value(CreateArrayParameters const&);
     477             : 
     478             : std::ostream& operator<<(std::ostream&, CreateArrayParameters const&);
     479             : 
     480             : const CreateArrayParameters& CreateArrayParametersOf(const Operator* op);
     481             : 
     482             : // Defines shared information for the array iterator that should be created.
     483             : // This is used as parameter by JSCreateArrayIterator operators.
     484             : class CreateArrayIteratorParameters final {
     485             :  public:
     486             :   explicit CreateArrayIteratorParameters(IterationKind kind) : kind_(kind) {}
     487             : 
     488        2861 :   IterationKind kind() const { return kind_; }
     489             : 
     490             :  private:
     491             :   IterationKind const kind_;
     492             : };
     493             : 
     494             : bool operator==(CreateArrayIteratorParameters const&,
     495             :                 CreateArrayIteratorParameters const&);
     496             : bool operator!=(CreateArrayIteratorParameters const&,
     497             :                 CreateArrayIteratorParameters const&);
     498             : 
     499             : size_t hash_value(CreateArrayIteratorParameters const&);
     500             : 
     501             : std::ostream& operator<<(std::ostream&, CreateArrayIteratorParameters const&);
     502             : 
     503             : const CreateArrayIteratorParameters& CreateArrayIteratorParametersOf(
     504             :     const Operator* op);
     505             : 
     506             : // Defines shared information for the array iterator that should be created.
     507             : // This is used as parameter by JSCreateCollectionIterator operators.
     508             : class CreateCollectionIteratorParameters final {
     509             :  public:
     510         163 :   explicit CreateCollectionIteratorParameters(CollectionKind collection_kind,
     511             :                                               IterationKind iteration_kind)
     512         163 :       : collection_kind_(collection_kind), iteration_kind_(iteration_kind) {
     513         163 :     CHECK(!(collection_kind == CollectionKind::kSet &&
     514             :             iteration_kind == IterationKind::kKeys));
     515         163 :   }
     516             : 
     517             :   CollectionKind collection_kind() const { return collection_kind_; }
     518             :   IterationKind iteration_kind() const { return iteration_kind_; }
     519             : 
     520             :  private:
     521             :   CollectionKind const collection_kind_;
     522             :   IterationKind const iteration_kind_;
     523             : };
     524             : 
     525             : bool operator==(CreateCollectionIteratorParameters const&,
     526             :                 CreateCollectionIteratorParameters const&);
     527             : bool operator!=(CreateCollectionIteratorParameters const&,
     528             :                 CreateCollectionIteratorParameters const&);
     529             : 
     530             : size_t hash_value(CreateCollectionIteratorParameters const&);
     531             : 
     532             : std::ostream& operator<<(std::ostream&,
     533             :                          CreateCollectionIteratorParameters const&);
     534             : 
     535             : const CreateCollectionIteratorParameters& CreateCollectionIteratorParametersOf(
     536             :     const Operator* op);
     537             : 
     538             : // Defines shared information for the bound function that should be created.
     539             : // This is used as parameter by JSCreateBoundFunction operators.
     540             : class CreateBoundFunctionParameters final {
     541             :  public:
     542             :   CreateBoundFunctionParameters(size_t arity, Handle<Map> map)
     543             :       : arity_(arity), map_(map) {}
     544             : 
     545             :   size_t arity() const { return arity_; }
     546             :   Handle<Map> map() const { return map_; }
     547             : 
     548             :  private:
     549             :   size_t const arity_;
     550             :   Handle<Map> const map_;
     551             : };
     552             : 
     553             : bool operator==(CreateBoundFunctionParameters const&,
     554             :                 CreateBoundFunctionParameters const&);
     555             : bool operator!=(CreateBoundFunctionParameters const&,
     556             :                 CreateBoundFunctionParameters const&);
     557             : 
     558             : size_t hash_value(CreateBoundFunctionParameters const&);
     559             : 
     560             : std::ostream& operator<<(std::ostream&, CreateBoundFunctionParameters const&);
     561             : 
     562             : const CreateBoundFunctionParameters& CreateBoundFunctionParametersOf(
     563             :     const Operator* op);
     564             : 
     565             : // Defines shared information for the closure that should be created. This is
     566             : // used as a parameter by JSCreateClosure operators.
     567             : class CreateClosureParameters final {
     568             :  public:
     569             :   CreateClosureParameters(Handle<SharedFunctionInfo> shared_info,
     570             :                           Handle<FeedbackCell> feedback_cell, Handle<Code> code,
     571             :                           PretenureFlag pretenure)
     572             :       : shared_info_(shared_info),
     573             :         feedback_cell_(feedback_cell),
     574             :         code_(code),
     575             :         pretenure_(pretenure) {}
     576             : 
     577             :   Handle<SharedFunctionInfo> shared_info() const { return shared_info_; }
     578             :   Handle<FeedbackCell> feedback_cell() const { return feedback_cell_; }
     579             :   Handle<Code> code() const { return code_; }
     580             :   PretenureFlag pretenure() const { return pretenure_; }
     581             : 
     582             :  private:
     583             :   Handle<SharedFunctionInfo> const shared_info_;
     584             :   Handle<FeedbackCell> const feedback_cell_;
     585             :   Handle<Code> const code_;
     586             :   PretenureFlag const pretenure_;
     587             : };
     588             : 
     589             : bool operator==(CreateClosureParameters const&, CreateClosureParameters const&);
     590             : bool operator!=(CreateClosureParameters const&, CreateClosureParameters const&);
     591             : 
     592             : size_t hash_value(CreateClosureParameters const&);
     593             : 
     594             : std::ostream& operator<<(std::ostream&, CreateClosureParameters const&);
     595             : 
     596             : const CreateClosureParameters& CreateClosureParametersOf(const Operator* op);
     597             : 
     598             : // Defines shared information for the literal that should be created. This is
     599             : // used as parameter by JSCreateLiteralArray, JSCreateLiteralObject and
     600             : // JSCreateLiteralRegExp operators.
     601             : class CreateLiteralParameters final {
     602             :  public:
     603             :   CreateLiteralParameters(Handle<HeapObject> constant,
     604             :                           VectorSlotPair const& feedback, int length, int flags)
     605             :       : constant_(constant),
     606             :         feedback_(feedback),
     607             :         length_(length),
     608       29672 :         flags_(flags) {}
     609             : 
     610             :   Handle<HeapObject> constant() const { return constant_; }
     611             :   VectorSlotPair const& feedback() const { return feedback_; }
     612             :   int length() const { return length_; }
     613             :   int flags() const { return flags_; }
     614             : 
     615             :  private:
     616             :   Handle<HeapObject> const constant_;
     617             :   VectorSlotPair const feedback_;
     618             :   int const length_;
     619             :   int const flags_;
     620             : };
     621             : 
     622             : bool operator==(CreateLiteralParameters const&, CreateLiteralParameters const&);
     623             : bool operator!=(CreateLiteralParameters const&, CreateLiteralParameters const&);
     624             : 
     625             : size_t hash_value(CreateLiteralParameters const&);
     626             : 
     627             : std::ostream& operator<<(std::ostream&, CreateLiteralParameters const&);
     628             : 
     629             : const CreateLiteralParameters& CreateLiteralParametersOf(const Operator* op);
     630             : 
     631             : class CloneObjectParameters final {
     632             :  public:
     633             :   CloneObjectParameters(VectorSlotPair const& feedback, int flags)
     634          76 :       : feedback_(feedback), flags_(flags) {}
     635             : 
     636             :   VectorSlotPair const& feedback() const { return feedback_; }
     637             :   int flags() const { return flags_; }
     638             : 
     639             :  private:
     640             :   VectorSlotPair const feedback_;
     641             :   int const flags_;
     642             : };
     643             : 
     644             : bool operator==(CloneObjectParameters const&, CloneObjectParameters const&);
     645             : bool operator!=(CloneObjectParameters const&, CloneObjectParameters const&);
     646             : 
     647             : size_t hash_value(CloneObjectParameters const&);
     648             : 
     649             : std::ostream& operator<<(std::ostream&, CloneObjectParameters const&);
     650             : 
     651             : const CloneObjectParameters& CloneObjectParametersOf(const Operator* op);
     652             : 
     653             : // Descriptor used by the JSForInPrepare and JSForInNext opcodes.
     654             : enum class ForInMode : uint8_t {
     655             :   kUseEnumCacheKeysAndIndices,
     656             :   kUseEnumCacheKeys,
     657             :   kGeneric
     658             : };
     659             : 
     660             : size_t hash_value(ForInMode);
     661             : 
     662             : std::ostream& operator<<(std::ostream&, ForInMode);
     663             : 
     664             : ForInMode ForInModeOf(Operator const* op) V8_WARN_UNUSED_RESULT;
     665             : 
     666             : BinaryOperationHint BinaryOperationHintOf(const Operator* op);
     667             : 
     668             : CompareOperationHint CompareOperationHintOf(const Operator* op);
     669             : 
     670             : int RegisterCountOf(Operator const* op) V8_WARN_UNUSED_RESULT;
     671             : 
     672             : int GeneratorStoreValueCountOf(const Operator* op) V8_WARN_UNUSED_RESULT;
     673             : int RestoreRegisterIndexOf(const Operator* op) V8_WARN_UNUSED_RESULT;
     674             : 
     675             : Handle<ScopeInfo> ScopeInfoOf(const Operator* op) V8_WARN_UNUSED_RESULT;
     676             : 
     677             : // Interface for building JavaScript-level operators, e.g. directly from the
     678             : // AST. Most operators have no parameters, thus can be globally shared for all
     679             : // graphs.
     680             : class V8_EXPORT_PRIVATE JSOperatorBuilder final
     681             :     : public NON_EXPORTED_BASE(ZoneObject) {
     682             :  public:
     683             :   explicit JSOperatorBuilder(Zone* zone);
     684             : 
     685             :   const Operator* Equal(CompareOperationHint hint);
     686             :   const Operator* StrictEqual(CompareOperationHint hint);
     687             :   const Operator* LessThan(CompareOperationHint hint);
     688             :   const Operator* GreaterThan(CompareOperationHint hint);
     689             :   const Operator* LessThanOrEqual(CompareOperationHint hint);
     690             :   const Operator* GreaterThanOrEqual(CompareOperationHint hint);
     691             : 
     692             :   const Operator* BitwiseOr();
     693             :   const Operator* BitwiseXor();
     694             :   const Operator* BitwiseAnd();
     695             :   const Operator* ShiftLeft();
     696             :   const Operator* ShiftRight();
     697             :   const Operator* ShiftRightLogical();
     698             :   const Operator* Add(BinaryOperationHint hint);
     699             :   const Operator* Subtract();
     700             :   const Operator* Multiply();
     701             :   const Operator* Divide();
     702             :   const Operator* Modulus();
     703             :   const Operator* Exponentiate();
     704             : 
     705             :   const Operator* BitwiseNot();
     706             :   const Operator* Decrement();
     707             :   const Operator* Increment();
     708             :   const Operator* Negate();
     709             : 
     710             :   const Operator* ToLength();
     711             :   const Operator* ToName();
     712             :   const Operator* ToNumber();
     713             :   const Operator* ToNumberConvertBigInt();
     714             :   const Operator* ToNumeric();
     715             :   const Operator* ToObject();
     716             :   const Operator* ToString();
     717             : 
     718             :   const Operator* Create();
     719             :   const Operator* CreateArguments(CreateArgumentsType type);
     720             :   const Operator* CreateArray(size_t arity, MaybeHandle<AllocationSite> site);
     721             :   const Operator* CreateArrayIterator(IterationKind);
     722             :   const Operator* CreateAsyncFunctionObject(int register_count);
     723             :   const Operator* CreateCollectionIterator(CollectionKind, IterationKind);
     724             :   const Operator* CreateBoundFunction(size_t arity, Handle<Map> map);
     725             :   const Operator* CreateClosure(Handle<SharedFunctionInfo> shared_info,
     726             :                                 Handle<FeedbackCell> feedback_cell,
     727             :                                 Handle<Code> code,
     728             :                                 PretenureFlag pretenure = NOT_TENURED);
     729             :   const Operator* CreateIterResultObject();
     730             :   const Operator* CreateStringIterator();
     731             :   const Operator* CreateKeyValueArray();
     732             :   const Operator* CreateObject();
     733             :   const Operator* CreatePromise();
     734             :   const Operator* CreateTypedArray();
     735             :   const Operator* CreateLiteralArray(
     736             :       Handle<ArrayBoilerplateDescription> constant,
     737             :       VectorSlotPair const& feedback, int literal_flags,
     738             :       int number_of_elements);
     739             :   const Operator* CreateEmptyLiteralArray(VectorSlotPair const& feedback);
     740             :   const Operator* CreateArrayFromIterable();
     741             :   const Operator* CreateEmptyLiteralObject();
     742             : 
     743             :   const Operator* CreateLiteralObject(
     744             :       Handle<ObjectBoilerplateDescription> constant,
     745             :       VectorSlotPair const& feedback, int literal_flags,
     746             :       int number_of_properties);
     747             :   const Operator* CloneObject(VectorSlotPair const& feedback,
     748             :                               int literal_flags);
     749             :   const Operator* CreateLiteralRegExp(Handle<String> constant_pattern,
     750             :                                       VectorSlotPair const& feedback,
     751             :                                       int literal_flags);
     752             : 
     753             :   const Operator* CallForwardVarargs(size_t arity, uint32_t start_index);
     754             :   const Operator* Call(
     755             :       size_t arity, CallFrequency const& frequency = CallFrequency(),
     756             :       VectorSlotPair const& feedback = VectorSlotPair(),
     757             :       ConvertReceiverMode convert_mode = ConvertReceiverMode::kAny,
     758             :       SpeculationMode speculation_mode = SpeculationMode::kDisallowSpeculation);
     759             :   const Operator* CallWithArrayLike(CallFrequency frequency);
     760             :   const Operator* CallWithSpread(
     761             :       uint32_t arity, CallFrequency const& frequency = CallFrequency(),
     762             :       VectorSlotPair const& feedback = VectorSlotPair(),
     763             :       SpeculationMode speculation_mode = SpeculationMode::kDisallowSpeculation);
     764             :   const Operator* CallRuntime(Runtime::FunctionId id);
     765             :   const Operator* CallRuntime(Runtime::FunctionId id, size_t arity);
     766             :   const Operator* CallRuntime(const Runtime::Function* function, size_t arity);
     767             : 
     768             :   const Operator* ConstructForwardVarargs(size_t arity, uint32_t start_index);
     769             :   const Operator* Construct(uint32_t arity,
     770             :                             CallFrequency frequency = CallFrequency(),
     771             :                             VectorSlotPair const& feedback = VectorSlotPair());
     772             :   const Operator* ConstructWithArrayLike(CallFrequency frequency);
     773             :   const Operator* ConstructWithSpread(
     774             :       uint32_t arity, CallFrequency frequency = CallFrequency(),
     775             :       VectorSlotPair const& feedback = VectorSlotPair());
     776             : 
     777             :   const Operator* LoadProperty(VectorSlotPair const& feedback);
     778             :   const Operator* LoadNamed(Handle<Name> name, VectorSlotPair const& feedback);
     779             : 
     780             :   const Operator* StoreProperty(LanguageMode language_mode,
     781             :                                 VectorSlotPair const& feedback);
     782             :   const Operator* StoreNamed(LanguageMode language_mode, Handle<Name> name,
     783             :                              VectorSlotPair const& feedback);
     784             : 
     785             :   const Operator* StoreNamedOwn(Handle<Name> name,
     786             :                                 VectorSlotPair const& feedback);
     787             :   const Operator* StoreDataPropertyInLiteral(const VectorSlotPair& feedback);
     788             :   const Operator* StoreInArrayLiteral(const VectorSlotPair& feedback);
     789             : 
     790             :   const Operator* DeleteProperty();
     791             : 
     792             :   const Operator* HasProperty();
     793             : 
     794             :   const Operator* GetSuperConstructor();
     795             : 
     796             :   const Operator* CreateGeneratorObject();
     797             : 
     798             :   const Operator* LoadGlobal(const Handle<Name>& name,
     799             :                              const VectorSlotPair& feedback,
     800             :                              TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
     801             :   const Operator* StoreGlobal(LanguageMode language_mode,
     802             :                               const Handle<Name>& name,
     803             :                               const VectorSlotPair& feedback);
     804             : 
     805             :   const Operator* LoadContext(size_t depth, size_t index, bool immutable);
     806             :   const Operator* StoreContext(size_t depth, size_t index);
     807             : 
     808             :   const Operator* LoadModule(int32_t cell_index);
     809             :   const Operator* StoreModule(int32_t cell_index);
     810             : 
     811             :   const Operator* HasInPrototypeChain();
     812             :   const Operator* InstanceOf(const VectorSlotPair& feedback);
     813             :   const Operator* OrdinaryHasInstance();
     814             : 
     815             :   const Operator* AsyncFunctionEnter();
     816             :   const Operator* AsyncFunctionReject();
     817             :   const Operator* AsyncFunctionResolve();
     818             : 
     819             :   const Operator* ForInEnumerate();
     820             :   const Operator* ForInNext(ForInMode);
     821             :   const Operator* ForInPrepare(ForInMode);
     822             : 
     823             :   const Operator* LoadMessage();
     824             :   const Operator* StoreMessage();
     825             : 
     826             :   // Used to implement Ignition's SuspendGenerator bytecode.
     827             :   const Operator* GeneratorStore(int value_count);
     828             : 
     829             :   // Used to implement Ignition's SwitchOnGeneratorState bytecode.
     830             :   const Operator* GeneratorRestoreContinuation();
     831             :   const Operator* GeneratorRestoreContext();
     832             : 
     833             :   // Used to implement Ignition's ResumeGenerator bytecode.
     834             :   const Operator* GeneratorRestoreRegister(int index);
     835             :   const Operator* GeneratorRestoreInputOrDebugPos();
     836             : 
     837             :   const Operator* StackCheck();
     838             :   const Operator* Debugger();
     839             : 
     840             :   const Operator* FulfillPromise();
     841             :   const Operator* PerformPromiseThen();
     842             :   const Operator* PromiseResolve();
     843             :   const Operator* RejectPromise();
     844             :   const Operator* ResolvePromise();
     845             : 
     846             :   const Operator* CreateFunctionContext(Handle<ScopeInfo> scope_info,
     847             :                                         int slot_count, ScopeType scope_type);
     848             :   const Operator* CreateCatchContext(const Handle<ScopeInfo>& scope_info);
     849             :   const Operator* CreateWithContext(const Handle<ScopeInfo>& scope_info);
     850             :   const Operator* CreateBlockContext(const Handle<ScopeInfo>& scpope_info);
     851             : 
     852             :   const Operator* ObjectIsArray();
     853             :   const Operator* ParseInt();
     854             :   const Operator* RegExpTest();
     855             : 
     856             :  private:
     857             :   Zone* zone() const { return zone_; }
     858             : 
     859             :   const JSOperatorGlobalCache& cache_;
     860             :   Zone* const zone_;
     861             : 
     862             :   DISALLOW_COPY_AND_ASSIGN(JSOperatorBuilder);
     863             : };
     864             : 
     865             : }  // namespace compiler
     866             : }  // namespace internal
     867             : }  // namespace v8
     868             : 
     869             : #endif  // V8_COMPILER_JS_OPERATOR_H_

Generated by: LCOV version 1.10