LCOV - code coverage report
Current view: top level - src/compiler - simplified-operator.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 281 489 57.5 %
Date: 2019-04-18 Functions: 574 1261 45.5 %

          Line data    Source code
       1             : // Copyright 2012 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             : #include "src/compiler/simplified-operator.h"
       6             : 
       7             : #include "src/base/lazy-instance.h"
       8             : #include "src/compiler/opcodes.h"
       9             : #include "src/compiler/operator.h"
      10             : #include "src/compiler/types.h"
      11             : #include "src/handles-inl.h"
      12             : #include "src/objects-inl.h"
      13             : #include "src/objects/map.h"
      14             : #include "src/objects/name.h"
      15             : 
      16             : namespace v8 {
      17             : namespace internal {
      18             : namespace compiler {
      19             : 
      20           0 : size_t hash_value(BaseTaggedness base_taggedness) {
      21           0 :   return static_cast<uint8_t>(base_taggedness);
      22             : }
      23             : 
      24      141818 : std::ostream& operator<<(std::ostream& os, BaseTaggedness base_taggedness) {
      25      141818 :   switch (base_taggedness) {
      26             :     case kUntaggedBase:
      27       86324 :       return os << "untagged base";
      28             :     case kTaggedBase:
      29       55494 :       return os << "tagged base";
      30             :   }
      31           0 :   UNREACHABLE();
      32             : }
      33             : 
      34         126 : bool operator==(FieldAccess const& lhs, FieldAccess const& rhs) {
      35             :   // On purpose we don't include the write barrier kind here, as this method is
      36             :   // really only relevant for eliminating loads and they don't care about the
      37             :   // write barrier mode.
      38         252 :   return lhs.base_is_tagged == rhs.base_is_tagged && lhs.offset == rhs.offset &&
      39         252 :          lhs.map.address() == rhs.map.address() &&
      40         126 :          lhs.machine_type == rhs.machine_type;
      41             : }
      42             : 
      43           0 : size_t hash_value(FieldAccess const& access) {
      44             :   // On purpose we don't include the write barrier kind here, as this method is
      45             :   // really only relevant for eliminating loads and they don't care about the
      46             :   // write barrier mode.
      47             :   return base::hash_combine(access.base_is_tagged, access.offset,
      48           0 :                             access.machine_type);
      49             : }
      50             : 
      51           0 : size_t hash_value(LoadSensitivity load_sensitivity) {
      52           0 :   return static_cast<size_t>(load_sensitivity);
      53             : }
      54             : 
      55           0 : std::ostream& operator<<(std::ostream& os, LoadSensitivity load_sensitivity) {
      56           0 :   switch (load_sensitivity) {
      57             :     case LoadSensitivity::kCritical:
      58           0 :       return os << "Critical";
      59             :     case LoadSensitivity::kSafe:
      60           0 :       return os << "Safe";
      61             :     case LoadSensitivity::kUnsafe:
      62           0 :       return os << "Unsafe";
      63             :   }
      64           0 :   UNREACHABLE();
      65             : }
      66             : 
      67           0 : std::ostream& operator<<(std::ostream& os, FieldAccess const& access) {
      68           0 :   os << "[" << access.base_is_tagged << ", " << access.offset << ", ";
      69             : #ifdef OBJECT_PRINT
      70             :   Handle<Name> name;
      71             :   if (access.name.ToHandle(&name)) {
      72             :     name->NamePrint(os);
      73             :     os << ", ";
      74             :   }
      75             :   Handle<Map> map;
      76             :   if (access.map.ToHandle(&map)) {
      77             :     os << Brief(*map) << ", ";
      78             :   }
      79             : #endif
      80           0 :   os << access.type << ", " << access.machine_type << ", "
      81           0 :      << access.write_barrier_kind;
      82           0 :   if (FLAG_untrusted_code_mitigations) {
      83           0 :     os << ", " << access.load_sensitivity;
      84             :   }
      85           0 :   os << "]";
      86           0 :   return os;
      87             : }
      88             : 
      89             : template <>
      90           0 : void Operator1<FieldAccess>::PrintParameter(std::ostream& os,
      91             :                                             PrintVerbosity verbose) const {
      92           0 :   if (verbose == PrintVerbosity::kVerbose) {
      93           0 :     os << parameter();
      94             :   } else {
      95           0 :     os << "[+" << parameter().offset << "]";
      96             :   }
      97           0 : }
      98             : 
      99          46 : bool operator==(ElementAccess const& lhs, ElementAccess const& rhs) {
     100             :   // On purpose we don't include the write barrier kind here, as this method is
     101             :   // really only relevant for eliminating loads and they don't care about the
     102             :   // write barrier mode.
     103          46 :   return lhs.base_is_tagged == rhs.base_is_tagged &&
     104          92 :          lhs.header_size == rhs.header_size &&
     105          46 :          lhs.machine_type == rhs.machine_type;
     106             : }
     107             : 
     108           0 : size_t hash_value(ElementAccess const& access) {
     109             :   // On purpose we don't include the write barrier kind here, as this method is
     110             :   // really only relevant for eliminating loads and they don't care about the
     111             :   // write barrier mode.
     112             :   return base::hash_combine(access.base_is_tagged, access.header_size,
     113           0 :                             access.machine_type);
     114             : }
     115             : 
     116             : 
     117      141818 : std::ostream& operator<<(std::ostream& os, ElementAccess const& access) {
     118      283636 :   os << access.base_is_tagged << ", " << access.header_size << ", "
     119      283636 :      << access.type << ", " << access.machine_type << ", "
     120      283636 :      << access.write_barrier_kind;
     121      141818 :   if (FLAG_untrusted_code_mitigations) {
     122           0 :     os << ", " << access.load_sensitivity;
     123             :   }
     124      141818 :   return os;
     125             : }
     126             : 
     127    29343517 : const FieldAccess& FieldAccessOf(const Operator* op) {
     128             :   DCHECK_NOT_NULL(op);
     129             :   DCHECK(op->opcode() == IrOpcode::kLoadField ||
     130             :          op->opcode() == IrOpcode::kStoreField);
     131    29343517 :   return OpParameter<FieldAccess>(op);
     132             : }
     133             : 
     134             : 
     135      405433 : const ElementAccess& ElementAccessOf(const Operator* op) {
     136             :   DCHECK_NOT_NULL(op);
     137             :   DCHECK(op->opcode() == IrOpcode::kLoadElement ||
     138             :          op->opcode() == IrOpcode::kStoreElement);
     139      405433 :   return OpParameter<ElementAccess>(op);
     140             : }
     141             : 
     142       49439 : ExternalArrayType ExternalArrayTypeOf(const Operator* op) {
     143             :   DCHECK(op->opcode() == IrOpcode::kLoadTypedElement ||
     144             :          op->opcode() == IrOpcode::kLoadDataViewElement ||
     145             :          op->opcode() == IrOpcode::kStoreTypedElement ||
     146             :          op->opcode() == IrOpcode::kStoreDataViewElement);
     147       49439 :   return OpParameter<ExternalArrayType>(op);
     148             : }
     149             : 
     150         873 : ConvertReceiverMode ConvertReceiverModeOf(Operator const* op) {
     151             :   DCHECK_EQ(IrOpcode::kConvertReceiver, op->opcode());
     152         873 :   return OpParameter<ConvertReceiverMode>(op);
     153             : }
     154             : 
     155           0 : size_t hash_value(CheckFloat64HoleMode mode) {
     156           0 :   return static_cast<size_t>(mode);
     157             : }
     158             : 
     159           0 : std::ostream& operator<<(std::ostream& os, CheckFloat64HoleMode mode) {
     160           0 :   switch (mode) {
     161             :     case CheckFloat64HoleMode::kAllowReturnHole:
     162           0 :       return os << "allow-return-hole";
     163             :     case CheckFloat64HoleMode::kNeverReturnHole:
     164           0 :       return os << "never-return-hole";
     165             :   }
     166           0 :   UNREACHABLE();
     167             : }
     168             : 
     169        2364 : CheckFloat64HoleParameters const& CheckFloat64HoleParametersOf(
     170             :     Operator const* op) {
     171             :   DCHECK_EQ(IrOpcode::kCheckFloat64Hole, op->opcode());
     172        2364 :   return OpParameter<CheckFloat64HoleParameters>(op);
     173             : }
     174             : 
     175           0 : std::ostream& operator<<(std::ostream& os,
     176             :                          CheckFloat64HoleParameters const& params) {
     177           0 :   os << params.mode();
     178           0 :   if (params.feedback().IsValid()) os << "; " << params.feedback();
     179           0 :   return os;
     180             : }
     181             : 
     182           0 : size_t hash_value(const CheckFloat64HoleParameters& params) {
     183           0 :   return base::hash_combine(params.mode(), params.feedback());
     184             : }
     185             : 
     186           0 : bool operator==(CheckFloat64HoleParameters const& lhs,
     187             :                 CheckFloat64HoleParameters const& rhs) {
     188           0 :   return lhs.mode() == rhs.mode() && lhs.feedback() == rhs.feedback();
     189             : }
     190             : 
     191           0 : bool operator!=(CheckFloat64HoleParameters const& lhs,
     192             :                 CheckFloat64HoleParameters const& rhs) {
     193           0 :   return !(lhs == rhs);
     194             : }
     195             : 
     196       59197 : CheckForMinusZeroMode CheckMinusZeroModeOf(const Operator* op) {
     197             :   DCHECK(op->opcode() == IrOpcode::kChangeFloat64ToTagged ||
     198             :          op->opcode() == IrOpcode::kCheckedInt32Mul);
     199       59197 :   return OpParameter<CheckForMinusZeroMode>(op);
     200             : }
     201             : 
     202           0 : size_t hash_value(CheckForMinusZeroMode mode) {
     203       73401 :   return static_cast<size_t>(mode);
     204             : }
     205             : 
     206         100 : std::ostream& operator<<(std::ostream& os, CheckForMinusZeroMode mode) {
     207         100 :   switch (mode) {
     208             :     case CheckForMinusZeroMode::kCheckForMinusZero:
     209          50 :       return os << "check-for-minus-zero";
     210             :     case CheckForMinusZeroMode::kDontCheckForMinusZero:
     211          50 :       return os << "dont-check-for-minus-zero";
     212             :   }
     213           0 :   UNREACHABLE();
     214             : }
     215             : 
     216           0 : std::ostream& operator<<(std::ostream& os, CheckMapsFlags flags) {
     217             :   bool empty = true;
     218           0 :   if (flags & CheckMapsFlag::kTryMigrateInstance) {
     219           0 :     os << "TryMigrateInstance";
     220             :     empty = false;
     221             :   }
     222           0 :   if (empty) os << "None";
     223           0 :   return os;
     224             : }
     225             : 
     226           0 : bool operator==(CheckMapsParameters const& lhs,
     227             :                 CheckMapsParameters const& rhs) {
     228           0 :   return lhs.flags() == rhs.flags() && lhs.maps() == rhs.maps() &&
     229           0 :          lhs.feedback() == rhs.feedback();
     230             : }
     231             : 
     232           0 : size_t hash_value(CheckMapsParameters const& p) {
     233           0 :   return base::hash_combine(p.flags(), p.maps(), p.feedback());
     234             : }
     235             : 
     236           0 : std::ostream& operator<<(std::ostream& os, CheckMapsParameters const& p) {
     237           0 :   os << p.flags() << p.maps();
     238           0 :   if (p.feedback().IsValid()) {
     239           0 :     os << "; " << p.feedback();
     240             :   }
     241           0 :   return os;
     242             : }
     243             : 
     244      385837 : CheckMapsParameters const& CheckMapsParametersOf(Operator const* op) {
     245             :   DCHECK_EQ(IrOpcode::kCheckMaps, op->opcode());
     246      385837 :   return OpParameter<CheckMapsParameters>(op);
     247             : }
     248             : 
     249       22837 : ZoneHandleSet<Map> const& CompareMapsParametersOf(Operator const* op) {
     250             :   DCHECK_EQ(IrOpcode::kCompareMaps, op->opcode());
     251       22837 :   return OpParameter<ZoneHandleSet<Map>>(op);
     252             : }
     253             : 
     254       15084 : ZoneHandleSet<Map> const& MapGuardMapsOf(Operator const* op) {
     255             :   DCHECK_EQ(IrOpcode::kMapGuard, op->opcode());
     256       15084 :   return OpParameter<ZoneHandleSet<Map>>(op);
     257             : }
     258             : 
     259           0 : size_t hash_value(CheckTaggedInputMode mode) {
     260           0 :   return static_cast<size_t>(mode);
     261             : }
     262             : 
     263          36 : std::ostream& operator<<(std::ostream& os, CheckTaggedInputMode mode) {
     264          36 :   switch (mode) {
     265             :     case CheckTaggedInputMode::kNumber:
     266          18 :       return os << "Number";
     267             :     case CheckTaggedInputMode::kNumberOrOddball:
     268          18 :       return os << "NumberOrOddball";
     269             :   }
     270           0 :   UNREACHABLE();
     271             : }
     272             : 
     273           0 : std::ostream& operator<<(std::ostream& os, GrowFastElementsMode mode) {
     274           0 :   switch (mode) {
     275             :     case GrowFastElementsMode::kDoubleElements:
     276           0 :       return os << "DoubleElements";
     277             :     case GrowFastElementsMode::kSmiOrObjectElements:
     278           0 :       return os << "SmiOrObjectElements";
     279             :   }
     280           0 :   UNREACHABLE();
     281             : }
     282             : 
     283           0 : bool operator==(const GrowFastElementsParameters& lhs,
     284             :                 const GrowFastElementsParameters& rhs) {
     285           0 :   return lhs.mode() == rhs.mode() && lhs.feedback() == rhs.feedback();
     286             : }
     287             : 
     288           0 : inline size_t hash_value(const GrowFastElementsParameters& params) {
     289           0 :   return base::hash_combine(params.mode(), params.feedback());
     290             : }
     291             : 
     292           0 : std::ostream& operator<<(std::ostream& os,
     293             :                          const GrowFastElementsParameters& params) {
     294           0 :   os << params.mode();
     295           0 :   if (params.feedback().IsValid()) {
     296           0 :     os << params.feedback();
     297             :   }
     298           0 :   return os;
     299             : }
     300             : 
     301       13521 : const GrowFastElementsParameters& GrowFastElementsParametersOf(
     302             :     const Operator* op) {
     303             :   DCHECK_EQ(IrOpcode::kMaybeGrowFastElements, op->opcode());
     304       13521 :   return OpParameter<GrowFastElementsParameters>(op);
     305             : }
     306             : 
     307           0 : bool operator==(ElementsTransition const& lhs, ElementsTransition const& rhs) {
     308           0 :   return lhs.mode() == rhs.mode() &&
     309           0 :          lhs.source().address() == rhs.source().address() &&
     310           0 :          lhs.target().address() == rhs.target().address();
     311             : }
     312             : 
     313           0 : size_t hash_value(ElementsTransition transition) {
     314             :   return base::hash_combine(static_cast<uint8_t>(transition.mode()),
     315           0 :                             transition.source().address(),
     316           0 :                             transition.target().address());
     317             : }
     318             : 
     319           0 : std::ostream& operator<<(std::ostream& os, ElementsTransition transition) {
     320           0 :   switch (transition.mode()) {
     321             :     case ElementsTransition::kFastTransition:
     322           0 :       return os << "fast-transition from " << Brief(*transition.source())
     323           0 :                 << " to " << Brief(*transition.target());
     324             :     case ElementsTransition::kSlowTransition:
     325           0 :       return os << "slow-transition from " << Brief(*transition.source())
     326           0 :                 << " to " << Brief(*transition.target());
     327             :   }
     328           0 :   UNREACHABLE();
     329             : }
     330             : 
     331        1805 : ElementsTransition const& ElementsTransitionOf(const Operator* op) {
     332             :   DCHECK_EQ(IrOpcode::kTransitionElementsKind, op->opcode());
     333        1805 :   return OpParameter<ElementsTransition>(op);
     334             : }
     335             : 
     336             : namespace {
     337             : 
     338             : // Parameters for the TransitionAndStoreElement opcode.
     339             : class TransitionAndStoreElementParameters final {
     340             :  public:
     341             :   TransitionAndStoreElementParameters(Handle<Map> double_map,
     342             :                                       Handle<Map> fast_map);
     343             : 
     344             :   Handle<Map> double_map() const { return double_map_; }
     345             :   Handle<Map> fast_map() const { return fast_map_; }
     346             : 
     347             :  private:
     348             :   Handle<Map> const double_map_;
     349             :   Handle<Map> const fast_map_;
     350             : };
     351             : 
     352             : TransitionAndStoreElementParameters::TransitionAndStoreElementParameters(
     353             :     Handle<Map> double_map, Handle<Map> fast_map)
     354             :     : double_map_(double_map), fast_map_(fast_map) {}
     355             : 
     356             : bool operator==(TransitionAndStoreElementParameters const& lhs,
     357             :                 TransitionAndStoreElementParameters const& rhs) {
     358           0 :   return lhs.fast_map().address() == rhs.fast_map().address() &&
     359           0 :          lhs.double_map().address() == rhs.double_map().address();
     360             : }
     361             : 
     362             : size_t hash_value(TransitionAndStoreElementParameters parameters) {
     363           0 :   return base::hash_combine(parameters.fast_map().address(),
     364           0 :                             parameters.double_map().address());
     365             : }
     366             : 
     367           0 : std::ostream& operator<<(std::ostream& os,
     368             :                          TransitionAndStoreElementParameters parameters) {
     369           0 :   return os << "fast-map" << Brief(*parameters.fast_map()) << " double-map"
     370           0 :             << Brief(*parameters.double_map());
     371             : }
     372             : 
     373             : }  // namespace
     374             : 
     375             : namespace {
     376             : 
     377             : // Parameters for the TransitionAndStoreNonNumberElement opcode.
     378             : class TransitionAndStoreNonNumberElementParameters final {
     379             :  public:
     380             :   TransitionAndStoreNonNumberElementParameters(Handle<Map> fast_map,
     381             :                                                Type value_type);
     382             : 
     383             :   Handle<Map> fast_map() const { return fast_map_; }
     384             :   Type value_type() const { return value_type_; }
     385             : 
     386             :  private:
     387             :   Handle<Map> const fast_map_;
     388             :   Type value_type_;
     389             : };
     390             : 
     391             : TransitionAndStoreNonNumberElementParameters::
     392             :     TransitionAndStoreNonNumberElementParameters(Handle<Map> fast_map,
     393             :                                                  Type value_type)
     394             :     : fast_map_(fast_map), value_type_(value_type) {}
     395             : 
     396             : bool operator==(TransitionAndStoreNonNumberElementParameters const& lhs,
     397             :                 TransitionAndStoreNonNumberElementParameters const& rhs) {
     398           0 :   return lhs.fast_map().address() == rhs.fast_map().address() &&
     399             :          lhs.value_type() == rhs.value_type();
     400             : }
     401             : 
     402           0 : size_t hash_value(TransitionAndStoreNonNumberElementParameters parameters) {
     403           0 :   return base::hash_combine(parameters.fast_map().address(),
     404           0 :                             parameters.value_type());
     405             : }
     406             : 
     407           0 : std::ostream& operator<<(
     408             :     std::ostream& os, TransitionAndStoreNonNumberElementParameters parameters) {
     409           0 :   return os << parameters.value_type() << ", fast-map"
     410           0 :             << Brief(*parameters.fast_map());
     411             : }
     412             : 
     413             : }  // namespace
     414             : 
     415             : namespace {
     416             : 
     417             : // Parameters for the TransitionAndStoreNumberElement opcode.
     418             : class TransitionAndStoreNumberElementParameters final {
     419             :  public:
     420             :   explicit TransitionAndStoreNumberElementParameters(Handle<Map> double_map);
     421             : 
     422          28 :   Handle<Map> double_map() const { return double_map_; }
     423             : 
     424             :  private:
     425             :   Handle<Map> const double_map_;
     426             : };
     427             : 
     428             : TransitionAndStoreNumberElementParameters::
     429             :     TransitionAndStoreNumberElementParameters(Handle<Map> double_map)
     430             :     : double_map_(double_map) {}
     431             : 
     432             : bool operator==(TransitionAndStoreNumberElementParameters const& lhs,
     433             :                 TransitionAndStoreNumberElementParameters const& rhs) {
     434           0 :   return lhs.double_map().address() == rhs.double_map().address();
     435             : }
     436             : 
     437             : size_t hash_value(TransitionAndStoreNumberElementParameters parameters) {
     438           0 :   return base::hash_combine(parameters.double_map().address());
     439             : }
     440             : 
     441           0 : std::ostream& operator<<(std::ostream& os,
     442             :                          TransitionAndStoreNumberElementParameters parameters) {
     443           0 :   return os << "double-map" << Brief(*parameters.double_map());
     444             : }
     445             : 
     446             : }  // namespace
     447             : 
     448         708 : Handle<Map> DoubleMapParameterOf(const Operator* op) {
     449         708 :   if (op->opcode() == IrOpcode::kTransitionAndStoreElement) {
     450             :     return OpParameter<TransitionAndStoreElementParameters>(op).double_map();
     451          28 :   } else if (op->opcode() == IrOpcode::kTransitionAndStoreNumberElement) {
     452             :     return OpParameter<TransitionAndStoreNumberElementParameters>(op)
     453             :         .double_map();
     454             :   }
     455           0 :   UNREACHABLE();
     456             :   return Handle<Map>::null();
     457             : }
     458             : 
     459          25 : Type ValueTypeParameterOf(const Operator* op) {
     460             :   DCHECK_EQ(IrOpcode::kTransitionAndStoreNonNumberElement, op->opcode());
     461             :   return OpParameter<TransitionAndStoreNonNumberElementParameters>(op)
     462          25 :       .value_type();
     463             : }
     464             : 
     465         813 : Handle<Map> FastMapParameterOf(const Operator* op) {
     466         813 :   if (op->opcode() == IrOpcode::kTransitionAndStoreElement) {
     467             :     return OpParameter<TransitionAndStoreElementParameters>(op).fast_map();
     468          50 :   } else if (op->opcode() == IrOpcode::kTransitionAndStoreNonNumberElement) {
     469             :     return OpParameter<TransitionAndStoreNonNumberElementParameters>(op)
     470             :         .fast_map();
     471             :   }
     472           0 :   UNREACHABLE();
     473             :   return Handle<Map>::null();
     474             : }
     475             : 
     476         234 : std::ostream& operator<<(std::ostream& os, NumberOperationHint hint) {
     477         234 :   switch (hint) {
     478             :     case NumberOperationHint::kSignedSmall:
     479          66 :       return os << "SignedSmall";
     480             :     case NumberOperationHint::kSignedSmallInputs:
     481          42 :       return os << "SignedSmallInputs";
     482             :     case NumberOperationHint::kSigned32:
     483          42 :       return os << "Signed32";
     484             :     case NumberOperationHint::kNumber:
     485          42 :       return os << "Number";
     486             :     case NumberOperationHint::kNumberOrOddball:
     487          42 :       return os << "NumberOrOddball";
     488             :   }
     489           0 :   UNREACHABLE();
     490             : }
     491             : 
     492           0 : size_t hash_value(NumberOperationHint hint) {
     493           0 :   return static_cast<uint8_t>(hint);
     494             : }
     495             : 
     496     1142804 : NumberOperationHint NumberOperationHintOf(const Operator* op) {
     497             :   DCHECK(op->opcode() == IrOpcode::kSpeculativeNumberAdd ||
     498             :          op->opcode() == IrOpcode::kSpeculativeNumberSubtract ||
     499             :          op->opcode() == IrOpcode::kSpeculativeNumberMultiply ||
     500             :          op->opcode() == IrOpcode::kSpeculativeNumberDivide ||
     501             :          op->opcode() == IrOpcode::kSpeculativeNumberModulus ||
     502             :          op->opcode() == IrOpcode::kSpeculativeNumberShiftLeft ||
     503             :          op->opcode() == IrOpcode::kSpeculativeNumberShiftRight ||
     504             :          op->opcode() == IrOpcode::kSpeculativeNumberShiftRightLogical ||
     505             :          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseAnd ||
     506             :          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseOr ||
     507             :          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseXor ||
     508             :          op->opcode() == IrOpcode::kSpeculativeNumberEqual ||
     509             :          op->opcode() == IrOpcode::kSpeculativeNumberLessThan ||
     510             :          op->opcode() == IrOpcode::kSpeculativeNumberLessThanOrEqual ||
     511             :          op->opcode() == IrOpcode::kSpeculativeSafeIntegerAdd ||
     512             :          op->opcode() == IrOpcode::kSpeculativeSafeIntegerSubtract);
     513     1142804 :   return OpParameter<NumberOperationHint>(op);
     514             : }
     515             : 
     516           0 : bool operator==(NumberOperationParameters const& lhs,
     517             :                 NumberOperationParameters const& rhs) {
     518           0 :   return lhs.hint() == rhs.hint() && lhs.feedback() == rhs.feedback();
     519             : }
     520             : 
     521           0 : size_t hash_value(NumberOperationParameters const& p) {
     522           0 :   return base::hash_combine(p.hint(), p.feedback());
     523             : }
     524             : 
     525           0 : std::ostream& operator<<(std::ostream& os, NumberOperationParameters const& p) {
     526           0 :   return os << p.hint() << " " << p.feedback();
     527             : }
     528             : 
     529      133151 : NumberOperationParameters const& NumberOperationParametersOf(
     530             :     Operator const* op) {
     531             :   DCHECK_EQ(IrOpcode::kSpeculativeToNumber, op->opcode());
     532      133151 :   return OpParameter<NumberOperationParameters>(op);
     533             : }
     534             : 
     535           0 : size_t hash_value(AllocateParameters info) {
     536             :   return base::hash_combine(info.type(),
     537           0 :                             static_cast<int>(info.allocation_type()));
     538             : }
     539             : 
     540           0 : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
     541             :                                            AllocateParameters info) {
     542           0 :   return os << info.type() << ", " << info.allocation_type();
     543             : }
     544             : 
     545           0 : bool operator==(AllocateParameters const& lhs, AllocateParameters const& rhs) {
     546           0 :   return lhs.allocation_type() == rhs.allocation_type() &&
     547           0 :          lhs.type() == rhs.type();
     548             : }
     549             : 
     550      390781 : AllocationType AllocationTypeOf(const Operator* op) {
     551      390781 :   if (op->opcode() == IrOpcode::kNewDoubleElements ||
     552             :       op->opcode() == IrOpcode::kNewSmiOrObjectElements) {
     553         504 :     return OpParameter<AllocationType>(op);
     554             :   }
     555             :   DCHECK(op->opcode() == IrOpcode::kAllocate ||
     556             :          op->opcode() == IrOpcode::kAllocateRaw);
     557      390277 :   return OpParameter<AllocateParameters>(op).allocation_type();
     558             : }
     559             : 
     560      141352 : Type AllocateTypeOf(const Operator* op) {
     561             :   DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
     562      141352 :   return OpParameter<AllocateParameters>(op).type();
     563             : }
     564             : 
     565         430 : UnicodeEncoding UnicodeEncodingOf(const Operator* op) {
     566             :   DCHECK(op->opcode() == IrOpcode::kStringFromSingleCodePoint ||
     567             :          op->opcode() == IrOpcode::kStringCodePointAt);
     568         430 :   return OpParameter<UnicodeEncoding>(op);
     569             : }
     570             : 
     571        2468 : AbortReason AbortReasonOf(const Operator* op) {
     572             :   DCHECK_EQ(IrOpcode::kRuntimeAbort, op->opcode());
     573        2468 :   return static_cast<AbortReason>(OpParameter<int>(op));
     574             : }
     575             : 
     576       67988 : const CheckTaggedInputParameters& CheckTaggedInputParametersOf(
     577             :     const Operator* op) {
     578             :   DCHECK(op->opcode() == IrOpcode::kCheckedTruncateTaggedToWord32 ||
     579             :          op->opcode() == IrOpcode::kCheckedTaggedToFloat64);
     580       67988 :   return OpParameter<CheckTaggedInputParameters>(op);
     581             : }
     582             : 
     583           0 : std::ostream& operator<<(std::ostream& os,
     584             :                          const CheckTaggedInputParameters& params) {
     585           0 :   os << params.mode();
     586           0 :   if (params.feedback().IsValid()) {
     587           0 :     os << "; " << params.feedback();
     588             :   }
     589           0 :   return os;
     590             : }
     591             : 
     592           0 : size_t hash_value(const CheckTaggedInputParameters& params) {
     593           0 :   return base::hash_combine(params.mode(), params.feedback());
     594             : }
     595             : 
     596           0 : bool operator==(CheckTaggedInputParameters const& lhs,
     597             :                 CheckTaggedInputParameters const& rhs) {
     598           0 :   return lhs.mode() == rhs.mode() && lhs.feedback() == rhs.feedback();
     599             : }
     600             : 
     601        4968 : const CheckMinusZeroParameters& CheckMinusZeroParametersOf(const Operator* op) {
     602             :   DCHECK(op->opcode() == IrOpcode::kCheckedTaggedToInt32 ||
     603             :          op->opcode() == IrOpcode::kCheckedTaggedToInt64 ||
     604             :          op->opcode() == IrOpcode::kCheckedFloat64ToInt32 ||
     605             :          op->opcode() == IrOpcode::kCheckedFloat64ToInt64);
     606        4968 :   return OpParameter<CheckMinusZeroParameters>(op);
     607             : }
     608             : 
     609           0 : std::ostream& operator<<(std::ostream& os,
     610             :                          const CheckMinusZeroParameters& params) {
     611           0 :   os << params.mode();
     612           0 :   if (params.feedback().IsValid()) {
     613           0 :     os << "; " << params.feedback();
     614             :   }
     615           0 :   return os;
     616             : }
     617             : 
     618           0 : size_t hash_value(const CheckMinusZeroParameters& params) {
     619           0 :   return base::hash_combine(params.mode(), params.feedback());
     620             : }
     621             : 
     622           0 : bool operator==(CheckMinusZeroParameters const& lhs,
     623             :                 CheckMinusZeroParameters const& rhs) {
     624           0 :   return lhs.mode() == rhs.mode() && lhs.feedback() == rhs.feedback();
     625             : }
     626             : 
     627             : #define PURE_OP_LIST(V)                                            \
     628             :   V(BooleanNot, Operator::kNoProperties, 1, 0)                     \
     629             :   V(NumberEqual, Operator::kCommutative, 2, 0)                     \
     630             :   V(NumberLessThan, Operator::kNoProperties, 2, 0)                 \
     631             :   V(NumberLessThanOrEqual, Operator::kNoProperties, 2, 0)          \
     632             :   V(NumberAdd, Operator::kCommutative, 2, 0)                       \
     633             :   V(NumberSubtract, Operator::kNoProperties, 2, 0)                 \
     634             :   V(NumberMultiply, Operator::kCommutative, 2, 0)                  \
     635             :   V(NumberDivide, Operator::kNoProperties, 2, 0)                   \
     636             :   V(NumberModulus, Operator::kNoProperties, 2, 0)                  \
     637             :   V(NumberBitwiseOr, Operator::kCommutative, 2, 0)                 \
     638             :   V(NumberBitwiseXor, Operator::kCommutative, 2, 0)                \
     639             :   V(NumberBitwiseAnd, Operator::kCommutative, 2, 0)                \
     640             :   V(NumberShiftLeft, Operator::kNoProperties, 2, 0)                \
     641             :   V(NumberShiftRight, Operator::kNoProperties, 2, 0)               \
     642             :   V(NumberShiftRightLogical, Operator::kNoProperties, 2, 0)        \
     643             :   V(NumberImul, Operator::kCommutative, 2, 0)                      \
     644             :   V(NumberAbs, Operator::kNoProperties, 1, 0)                      \
     645             :   V(NumberClz32, Operator::kNoProperties, 1, 0)                    \
     646             :   V(NumberCeil, Operator::kNoProperties, 1, 0)                     \
     647             :   V(NumberFloor, Operator::kNoProperties, 1, 0)                    \
     648             :   V(NumberFround, Operator::kNoProperties, 1, 0)                   \
     649             :   V(NumberAcos, Operator::kNoProperties, 1, 0)                     \
     650             :   V(NumberAcosh, Operator::kNoProperties, 1, 0)                    \
     651             :   V(NumberAsin, Operator::kNoProperties, 1, 0)                     \
     652             :   V(NumberAsinh, Operator::kNoProperties, 1, 0)                    \
     653             :   V(NumberAtan, Operator::kNoProperties, 1, 0)                     \
     654             :   V(NumberAtan2, Operator::kNoProperties, 2, 0)                    \
     655             :   V(NumberAtanh, Operator::kNoProperties, 1, 0)                    \
     656             :   V(NumberCbrt, Operator::kNoProperties, 1, 0)                     \
     657             :   V(NumberCos, Operator::kNoProperties, 1, 0)                      \
     658             :   V(NumberCosh, Operator::kNoProperties, 1, 0)                     \
     659             :   V(NumberExp, Operator::kNoProperties, 1, 0)                      \
     660             :   V(NumberExpm1, Operator::kNoProperties, 1, 0)                    \
     661             :   V(NumberLog, Operator::kNoProperties, 1, 0)                      \
     662             :   V(NumberLog1p, Operator::kNoProperties, 1, 0)                    \
     663             :   V(NumberLog10, Operator::kNoProperties, 1, 0)                    \
     664             :   V(NumberLog2, Operator::kNoProperties, 1, 0)                     \
     665             :   V(NumberMax, Operator::kNoProperties, 2, 0)                      \
     666             :   V(NumberMin, Operator::kNoProperties, 2, 0)                      \
     667             :   V(NumberPow, Operator::kNoProperties, 2, 0)                      \
     668             :   V(NumberRound, Operator::kNoProperties, 1, 0)                    \
     669             :   V(NumberSign, Operator::kNoProperties, 1, 0)                     \
     670             :   V(NumberSin, Operator::kNoProperties, 1, 0)                      \
     671             :   V(NumberSinh, Operator::kNoProperties, 1, 0)                     \
     672             :   V(NumberSqrt, Operator::kNoProperties, 1, 0)                     \
     673             :   V(NumberTan, Operator::kNoProperties, 1, 0)                      \
     674             :   V(NumberTanh, Operator::kNoProperties, 1, 0)                     \
     675             :   V(NumberTrunc, Operator::kNoProperties, 1, 0)                    \
     676             :   V(NumberToBoolean, Operator::kNoProperties, 1, 0)                \
     677             :   V(NumberToInt32, Operator::kNoProperties, 1, 0)                  \
     678             :   V(NumberToString, Operator::kNoProperties, 1, 0)                 \
     679             :   V(NumberToUint32, Operator::kNoProperties, 1, 0)                 \
     680             :   V(NumberToUint8Clamped, Operator::kNoProperties, 1, 0)           \
     681             :   V(NumberSilenceNaN, Operator::kNoProperties, 1, 0)               \
     682             :   V(StringConcat, Operator::kNoProperties, 3, 0)                   \
     683             :   V(StringToNumber, Operator::kNoProperties, 1, 0)                 \
     684             :   V(StringFromSingleCharCode, Operator::kNoProperties, 1, 0)       \
     685             :   V(StringIndexOf, Operator::kNoProperties, 3, 0)                  \
     686             :   V(StringLength, Operator::kNoProperties, 1, 0)                   \
     687             :   V(StringToLowerCaseIntl, Operator::kNoProperties, 1, 0)          \
     688             :   V(StringToUpperCaseIntl, Operator::kNoProperties, 1, 0)          \
     689             :   V(TypeOf, Operator::kNoProperties, 1, 1)                         \
     690             :   V(PlainPrimitiveToNumber, Operator::kNoProperties, 1, 0)         \
     691             :   V(PlainPrimitiveToWord32, Operator::kNoProperties, 1, 0)         \
     692             :   V(PlainPrimitiveToFloat64, Operator::kNoProperties, 1, 0)        \
     693             :   V(ChangeTaggedSignedToInt32, Operator::kNoProperties, 1, 0)      \
     694             :   V(ChangeTaggedSignedToInt64, Operator::kNoProperties, 1, 0)      \
     695             :   V(ChangeTaggedToInt32, Operator::kNoProperties, 1, 0)            \
     696             :   V(ChangeTaggedToInt64, Operator::kNoProperties, 1, 0)            \
     697             :   V(ChangeTaggedToUint32, Operator::kNoProperties, 1, 0)           \
     698             :   V(ChangeTaggedToFloat64, Operator::kNoProperties, 1, 0)          \
     699             :   V(ChangeTaggedToTaggedSigned, Operator::kNoProperties, 1, 0)     \
     700             :   V(ChangeCompressedToTaggedSigned, Operator::kNoProperties, 1, 0) \
     701             :   V(ChangeTaggedToCompressedSigned, Operator::kNoProperties, 1, 0) \
     702             :   V(ChangeFloat64ToTaggedPointer, Operator::kNoProperties, 1, 0)   \
     703             :   V(ChangeInt31ToTaggedSigned, Operator::kNoProperties, 1, 0)      \
     704             :   V(ChangeInt32ToTagged, Operator::kNoProperties, 1, 0)            \
     705             :   V(ChangeInt64ToTagged, Operator::kNoProperties, 1, 0)            \
     706             :   V(ChangeUint32ToTagged, Operator::kNoProperties, 1, 0)           \
     707             :   V(ChangeUint64ToTagged, Operator::kNoProperties, 1, 0)           \
     708             :   V(ChangeTaggedToBit, Operator::kNoProperties, 1, 0)              \
     709             :   V(ChangeBitToTagged, Operator::kNoProperties, 1, 0)              \
     710             :   V(TruncateTaggedToBit, Operator::kNoProperties, 1, 0)            \
     711             :   V(TruncateTaggedPointerToBit, Operator::kNoProperties, 1, 0)     \
     712             :   V(TruncateTaggedToWord32, Operator::kNoProperties, 1, 0)         \
     713             :   V(TruncateTaggedToFloat64, Operator::kNoProperties, 1, 0)        \
     714             :   V(ObjectIsArrayBufferView, Operator::kNoProperties, 1, 0)        \
     715             :   V(ObjectIsBigInt, Operator::kNoProperties, 1, 0)                 \
     716             :   V(ObjectIsCallable, Operator::kNoProperties, 1, 0)               \
     717             :   V(ObjectIsConstructor, Operator::kNoProperties, 1, 0)            \
     718             :   V(ObjectIsDetectableCallable, Operator::kNoProperties, 1, 0)     \
     719             :   V(ObjectIsMinusZero, Operator::kNoProperties, 1, 0)              \
     720             :   V(NumberIsMinusZero, Operator::kNoProperties, 1, 0)              \
     721             :   V(ObjectIsNaN, Operator::kNoProperties, 1, 0)                    \
     722             :   V(NumberIsNaN, Operator::kNoProperties, 1, 0)                    \
     723             :   V(ObjectIsNonCallable, Operator::kNoProperties, 1, 0)            \
     724             :   V(ObjectIsNumber, Operator::kNoProperties, 1, 0)                 \
     725             :   V(ObjectIsReceiver, Operator::kNoProperties, 1, 0)               \
     726             :   V(ObjectIsSmi, Operator::kNoProperties, 1, 0)                    \
     727             :   V(ObjectIsString, Operator::kNoProperties, 1, 0)                 \
     728             :   V(ObjectIsSymbol, Operator::kNoProperties, 1, 0)                 \
     729             :   V(ObjectIsUndetectable, Operator::kNoProperties, 1, 0)           \
     730             :   V(NumberIsFloat64Hole, Operator::kNoProperties, 1, 0)            \
     731             :   V(NumberIsFinite, Operator::kNoProperties, 1, 0)                 \
     732             :   V(ObjectIsFiniteNumber, Operator::kNoProperties, 1, 0)           \
     733             :   V(NumberIsInteger, Operator::kNoProperties, 1, 0)                \
     734             :   V(ObjectIsSafeInteger, Operator::kNoProperties, 1, 0)            \
     735             :   V(NumberIsSafeInteger, Operator::kNoProperties, 1, 0)            \
     736             :   V(ObjectIsInteger, Operator::kNoProperties, 1, 0)                \
     737             :   V(ConvertTaggedHoleToUndefined, Operator::kNoProperties, 1, 0)   \
     738             :   V(SameValue, Operator::kCommutative, 2, 0)                       \
     739             :   V(SameValueNumbersOnly, Operator::kCommutative, 2, 0)            \
     740             :   V(NumberSameValue, Operator::kCommutative, 2, 0)                 \
     741             :   V(ReferenceEqual, Operator::kCommutative, 2, 0)                  \
     742             :   V(StringEqual, Operator::kCommutative, 2, 0)                     \
     743             :   V(StringLessThan, Operator::kNoProperties, 2, 0)                 \
     744             :   V(StringLessThanOrEqual, Operator::kNoProperties, 2, 0)          \
     745             :   V(ToBoolean, Operator::kNoProperties, 1, 0)                      \
     746             :   V(NewConsString, Operator::kNoProperties, 3, 0)                  \
     747             :   V(PoisonIndex, Operator::kNoProperties, 1, 0)
     748             : 
     749             : #define EFFECT_DEPENDENT_OP_LIST(V)                  \
     750             :   V(StringCharCodeAt, Operator::kNoProperties, 2, 1) \
     751             :   V(StringSubstring, Operator::kNoProperties, 3, 1)  \
     752             :   V(DateNow, Operator::kNoProperties, 0, 1)
     753             : 
     754             : #define SPECULATIVE_NUMBER_BINOP_LIST(V)      \
     755             :   SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(V) \
     756             :   V(SpeculativeNumberEqual)                   \
     757             :   V(SpeculativeNumberLessThan)                \
     758             :   V(SpeculativeNumberLessThanOrEqual)
     759             : 
     760             : #define CHECKED_OP_LIST(V)                \
     761             :   V(CheckEqualsInternalizedString, 2, 0)  \
     762             :   V(CheckEqualsSymbol, 2, 0)              \
     763             :   V(CheckHeapObject, 1, 1)                \
     764             :   V(CheckInternalizedString, 1, 1)        \
     765             :   V(CheckNotTaggedHole, 1, 1)             \
     766             :   V(CheckReceiver, 1, 1)                  \
     767             :   V(CheckReceiverOrNullOrUndefined, 1, 1) \
     768             :   V(CheckSymbol, 1, 1)                    \
     769             :   V(CheckedInt32Add, 2, 1)                \
     770             :   V(CheckedInt32Div, 2, 1)                \
     771             :   V(CheckedInt32Mod, 2, 1)                \
     772             :   V(CheckedInt32Sub, 2, 1)                \
     773             :   V(CheckedUint32Div, 2, 1)               \
     774             :   V(CheckedUint32Mod, 2, 1)
     775             : 
     776             : #define CHECKED_WITH_FEEDBACK_OP_LIST(V)    \
     777             :   V(CheckBounds, 2, 1)                      \
     778             :   V(CheckNumber, 1, 1)                      \
     779             :   V(CheckSmi, 1, 1)                         \
     780             :   V(CheckString, 1, 1)                      \
     781             :   V(CheckedInt32ToTaggedSigned, 1, 1)       \
     782             :   V(CheckedInt64ToInt32, 1, 1)              \
     783             :   V(CheckedInt64ToTaggedSigned, 1, 1)       \
     784             :   V(CheckedTaggedSignedToInt32, 1, 1)       \
     785             :   V(CheckedTaggedToTaggedPointer, 1, 1)     \
     786             :   V(CheckedTaggedToTaggedSigned, 1, 1)      \
     787             :   V(CheckedCompressedToTaggedPointer, 1, 1) \
     788             :   V(CheckedCompressedToTaggedSigned, 1, 1)  \
     789             :   V(CheckedTaggedToCompressedPointer, 1, 1) \
     790             :   V(CheckedTaggedToCompressedSigned, 1, 1)  \
     791             :   V(CheckedUint32ToInt32, 1, 1)             \
     792             :   V(CheckedUint32ToTaggedSigned, 1, 1)      \
     793             :   V(CheckedUint64Bounds, 2, 1)              \
     794             :   V(CheckedUint64ToInt32, 1, 1)             \
     795             :   V(CheckedUint64ToTaggedSigned, 1, 1)
     796             : 
     797             : #define CHECKED_BOUNDS_OP_LIST(V) V(CheckedUint32Bounds)
     798             : 
     799       28928 : struct SimplifiedOperatorGlobalCache final {
     800             : #define PURE(Name, properties, value_input_count, control_input_count)     \
     801             :   struct Name##Operator final : public Operator {                          \
     802             :     Name##Operator()                                                       \
     803             :         : Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name, \
     804             :                    value_input_count, 0, control_input_count, 1, 0, 0) {}  \
     805             :   };                                                                       \
     806             :   Name##Operator k##Name;
     807     3471360 :   PURE_OP_LIST(PURE)
     808             : #undef PURE
     809             : 
     810             : #define EFFECT_DEPENDENT(Name, properties, value_input_count,              \
     811             :                          control_input_count)                              \
     812             :   struct Name##Operator final : public Operator {                          \
     813             :     Name##Operator()                                                       \
     814             :         : Operator(IrOpcode::k##Name,                                      \
     815             :                    Operator::kNoDeopt | Operator::kNoWrite |               \
     816             :                        Operator::kNoThrow | properties,                    \
     817             :                    #Name, value_input_count, 1, control_input_count, 1, 1, \
     818             :                    0) {}                                                   \
     819             :   };                                                                       \
     820             :   Name##Operator k##Name;
     821       86784 :   EFFECT_DEPENDENT_OP_LIST(EFFECT_DEPENDENT)
     822             : #undef EFFECT_DEPENDENT
     823             : 
     824             : #define CHECKED(Name, value_input_count, value_output_count)             \
     825             :   struct Name##Operator final : public Operator {                        \
     826             :     Name##Operator()                                                     \
     827             :         : Operator(IrOpcode::k##Name,                                    \
     828             :                    Operator::kFoldable | Operator::kNoThrow, #Name,      \
     829             :                    value_input_count, 1, 1, value_output_count, 1, 0) {} \
     830             :   };                                                                     \
     831             :   Name##Operator k##Name;
     832      404992 :   CHECKED_OP_LIST(CHECKED)
     833             : #undef CHECKED
     834             : 
     835             : #define CHECKED_WITH_FEEDBACK(Name, value_input_count, value_output_count) \
     836             :   struct Name##Operator final : public Operator1<CheckParameters> {        \
     837             :     Name##Operator()                                                       \
     838             :         : Operator1<CheckParameters>(                                      \
     839             :               IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow, \
     840             :               #Name, value_input_count, 1, 1, value_output_count, 1, 0,    \
     841             :               CheckParameters(VectorSlotPair())) {}                        \
     842             :   };                                                                       \
     843             :   Name##Operator k##Name;
     844     1099264 :   CHECKED_WITH_FEEDBACK_OP_LIST(CHECKED_WITH_FEEDBACK)
     845             : #undef CHECKED_WITH_FEEDBACK
     846             : 
     847             : #define CHECKED_BOUNDS(Name)                                                  \
     848             :   struct Name##Operator final : public Operator1<CheckBoundsParameters> {     \
     849             :     Name##Operator(VectorSlotPair feedback, CheckBoundsParameters::Mode mode) \
     850             :         : Operator1<CheckBoundsParameters>(                                   \
     851             :               IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow,    \
     852             :               #Name, 2, 1, 1, 1, 1, 0,                                        \
     853             :               CheckBoundsParameters(feedback, mode)) {}                       \
     854             :   };                                                                          \
     855             :   Name##Operator k##Name##Deopting = {                                        \
     856             :       VectorSlotPair(), CheckBoundsParameters::kDeoptOnOutOfBounds};          \
     857             :   Name##Operator k##Name##Aborting = {                                        \
     858             :       VectorSlotPair(), CheckBoundsParameters::kAbortOnOutOfBounds};
     859      124660 :   CHECKED_BOUNDS_OP_LIST(CHECKED_BOUNDS)
     860             : #undef CHECKED_BOUNDS
     861             : 
     862             :   template <DeoptimizeReason kDeoptimizeReason>
     863           0 :   struct CheckIfOperator final : public Operator1<CheckIfParameters> {
     864     1157120 :     CheckIfOperator()
     865             :         : Operator1<CheckIfParameters>(
     866             :               IrOpcode::kCheckIf, Operator::kFoldable | Operator::kNoThrow,
     867             :               "CheckIf", 1, 1, 1, 0, 1, 0,
     868     2314240 :               CheckIfParameters(kDeoptimizeReason, VectorSlotPair())) {}
     869             :   };
     870             : #define CHECK_IF(Name, message) \
     871             :   CheckIfOperator<DeoptimizeReason::k##Name> kCheckIf##Name;
     872             :   DEOPTIMIZE_REASON_LIST(CHECK_IF)
     873             : #undef CHECK_IF
     874             : 
     875             :   template <UnicodeEncoding kEncoding>
     876           0 :   struct StringCodePointAtOperator final : public Operator1<UnicodeEncoding> {
     877       57856 :     StringCodePointAtOperator()
     878             :         : Operator1<UnicodeEncoding>(IrOpcode::kStringCodePointAt,
     879             :                                      Operator::kFoldable | Operator::kNoThrow,
     880             :                                      "StringCodePointAt", 2, 1, 1, 1, 1, 0,
     881       57856 :                                      kEncoding) {}
     882             :   };
     883             :   StringCodePointAtOperator<UnicodeEncoding::UTF16>
     884             :       kStringCodePointAtOperatorUTF16;
     885             :   StringCodePointAtOperator<UnicodeEncoding::UTF32>
     886             :       kStringCodePointAtOperatorUTF32;
     887             : 
     888             :   template <UnicodeEncoding kEncoding>
     889           0 :   struct StringFromSingleCodePointOperator final
     890             :       : public Operator1<UnicodeEncoding> {
     891       57856 :     StringFromSingleCodePointOperator()
     892             :         : Operator1<UnicodeEncoding>(
     893             :               IrOpcode::kStringFromSingleCodePoint, Operator::kPure,
     894       57856 :               "StringFromSingleCodePoint", 1, 0, 0, 1, 0, 0, kEncoding) {}
     895             :   };
     896             :   StringFromSingleCodePointOperator<UnicodeEncoding::UTF16>
     897             :       kStringFromSingleCodePointOperatorUTF16;
     898             :   StringFromSingleCodePointOperator<UnicodeEncoding::UTF32>
     899             :       kStringFromSingleCodePointOperatorUTF32;
     900             : 
     901           0 :   struct FindOrderedHashMapEntryOperator final : public Operator {
     902       28928 :     FindOrderedHashMapEntryOperator()
     903             :         : Operator(IrOpcode::kFindOrderedHashMapEntry, Operator::kEliminatable,
     904       28928 :                    "FindOrderedHashMapEntry", 2, 1, 1, 1, 1, 0) {}
     905             :   };
     906             :   FindOrderedHashMapEntryOperator kFindOrderedHashMapEntry;
     907             : 
     908           0 :   struct FindOrderedHashMapEntryForInt32KeyOperator final : public Operator {
     909       28928 :     FindOrderedHashMapEntryForInt32KeyOperator()
     910             :         : Operator(IrOpcode::kFindOrderedHashMapEntryForInt32Key,
     911             :                    Operator::kEliminatable,
     912       28928 :                    "FindOrderedHashMapEntryForInt32Key", 2, 1, 1, 1, 1, 0) {}
     913             :   };
     914             :   FindOrderedHashMapEntryForInt32KeyOperator
     915             :       kFindOrderedHashMapEntryForInt32Key;
     916             : 
     917           0 :   struct ArgumentsFrameOperator final : public Operator {
     918       28928 :     ArgumentsFrameOperator()
     919             :         : Operator(IrOpcode::kArgumentsFrame, Operator::kPure, "ArgumentsFrame",
     920       28928 :                    0, 0, 0, 1, 0, 0) {}
     921             :   };
     922             :   ArgumentsFrameOperator kArgumentsFrame;
     923             : 
     924             :   template <CheckForMinusZeroMode kMode>
     925           0 :   struct ChangeFloat64ToTaggedOperator final
     926             :       : public Operator1<CheckForMinusZeroMode> {
     927       57856 :     ChangeFloat64ToTaggedOperator()
     928             :         : Operator1<CheckForMinusZeroMode>(
     929             :               IrOpcode::kChangeFloat64ToTagged, Operator::kPure,
     930       57856 :               "ChangeFloat64ToTagged", 1, 0, 0, 1, 0, 0, kMode) {}
     931             :   };
     932             :   ChangeFloat64ToTaggedOperator<CheckForMinusZeroMode::kCheckForMinusZero>
     933             :       kChangeFloat64ToTaggedCheckForMinusZeroOperator;
     934             :   ChangeFloat64ToTaggedOperator<CheckForMinusZeroMode::kDontCheckForMinusZero>
     935             :       kChangeFloat64ToTaggedDontCheckForMinusZeroOperator;
     936             : 
     937             :   template <CheckForMinusZeroMode kMode>
     938           0 :   struct CheckedInt32MulOperator final
     939             :       : public Operator1<CheckForMinusZeroMode> {
     940       57856 :     CheckedInt32MulOperator()
     941             :         : Operator1<CheckForMinusZeroMode>(
     942             :               IrOpcode::kCheckedInt32Mul,
     943             :               Operator::kFoldable | Operator::kNoThrow, "CheckedInt32Mul", 2, 1,
     944       57856 :               1, 1, 1, 0, kMode) {}
     945             :   };
     946             :   CheckedInt32MulOperator<CheckForMinusZeroMode::kCheckForMinusZero>
     947             :       kCheckedInt32MulCheckForMinusZeroOperator;
     948             :   CheckedInt32MulOperator<CheckForMinusZeroMode::kDontCheckForMinusZero>
     949             :       kCheckedInt32MulDontCheckForMinusZeroOperator;
     950             : 
     951             :   template <CheckForMinusZeroMode kMode>
     952           0 :   struct CheckedFloat64ToInt32Operator final
     953             :       : public Operator1<CheckMinusZeroParameters> {
     954       57856 :     CheckedFloat64ToInt32Operator()
     955             :         : Operator1<CheckMinusZeroParameters>(
     956             :               IrOpcode::kCheckedFloat64ToInt32,
     957             :               Operator::kFoldable | Operator::kNoThrow, "CheckedFloat64ToInt32",
     958             :               1, 1, 1, 1, 1, 0,
     959      115712 :               CheckMinusZeroParameters(kMode, VectorSlotPair())) {}
     960             :   };
     961             :   CheckedFloat64ToInt32Operator<CheckForMinusZeroMode::kCheckForMinusZero>
     962             :       kCheckedFloat64ToInt32CheckForMinusZeroOperator;
     963             :   CheckedFloat64ToInt32Operator<CheckForMinusZeroMode::kDontCheckForMinusZero>
     964             :       kCheckedFloat64ToInt32DontCheckForMinusZeroOperator;
     965             : 
     966             :   template <CheckForMinusZeroMode kMode>
     967           0 :   struct CheckedFloat64ToInt64Operator final
     968             :       : public Operator1<CheckMinusZeroParameters> {
     969       57856 :     CheckedFloat64ToInt64Operator()
     970             :         : Operator1<CheckMinusZeroParameters>(
     971             :               IrOpcode::kCheckedFloat64ToInt64,
     972             :               Operator::kFoldable | Operator::kNoThrow, "CheckedFloat64ToInt64",
     973             :               1, 1, 1, 1, 1, 0,
     974      115712 :               CheckMinusZeroParameters(kMode, VectorSlotPair())) {}
     975             :   };
     976             :   CheckedFloat64ToInt64Operator<CheckForMinusZeroMode::kCheckForMinusZero>
     977             :       kCheckedFloat64ToInt64CheckForMinusZeroOperator;
     978             :   CheckedFloat64ToInt64Operator<CheckForMinusZeroMode::kDontCheckForMinusZero>
     979             :       kCheckedFloat64ToInt64DontCheckForMinusZeroOperator;
     980             : 
     981             :   template <CheckForMinusZeroMode kMode>
     982           0 :   struct CheckedTaggedToInt32Operator final
     983             :       : public Operator1<CheckMinusZeroParameters> {
     984       57856 :     CheckedTaggedToInt32Operator()
     985             :         : Operator1<CheckMinusZeroParameters>(
     986             :               IrOpcode::kCheckedTaggedToInt32,
     987             :               Operator::kFoldable | Operator::kNoThrow, "CheckedTaggedToInt32",
     988             :               1, 1, 1, 1, 1, 0,
     989      115712 :               CheckMinusZeroParameters(kMode, VectorSlotPair())) {}
     990             :   };
     991             :   CheckedTaggedToInt32Operator<CheckForMinusZeroMode::kCheckForMinusZero>
     992             :       kCheckedTaggedToInt32CheckForMinusZeroOperator;
     993             :   CheckedTaggedToInt32Operator<CheckForMinusZeroMode::kDontCheckForMinusZero>
     994             :       kCheckedTaggedToInt32DontCheckForMinusZeroOperator;
     995             : 
     996             :   template <CheckForMinusZeroMode kMode>
     997           0 :   struct CheckedTaggedToInt64Operator final
     998             :       : public Operator1<CheckMinusZeroParameters> {
     999       57856 :     CheckedTaggedToInt64Operator()
    1000             :         : Operator1<CheckMinusZeroParameters>(
    1001             :               IrOpcode::kCheckedTaggedToInt64,
    1002             :               Operator::kFoldable | Operator::kNoThrow, "CheckedTaggedToInt64",
    1003             :               1, 1, 1, 1, 1, 0,
    1004      115712 :               CheckMinusZeroParameters(kMode, VectorSlotPair())) {}
    1005             :   };
    1006             :   CheckedTaggedToInt64Operator<CheckForMinusZeroMode::kCheckForMinusZero>
    1007             :       kCheckedTaggedToInt64CheckForMinusZeroOperator;
    1008             :   CheckedTaggedToInt64Operator<CheckForMinusZeroMode::kDontCheckForMinusZero>
    1009             :       kCheckedTaggedToInt64DontCheckForMinusZeroOperator;
    1010             : 
    1011             :   template <CheckTaggedInputMode kMode>
    1012           0 :   struct CheckedTaggedToFloat64Operator final
    1013             :       : public Operator1<CheckTaggedInputParameters> {
    1014       57856 :     CheckedTaggedToFloat64Operator()
    1015             :         : Operator1<CheckTaggedInputParameters>(
    1016             :               IrOpcode::kCheckedTaggedToFloat64,
    1017             :               Operator::kFoldable | Operator::kNoThrow,
    1018             :               "CheckedTaggedToFloat64", 1, 1, 1, 1, 1, 0,
    1019      115712 :               CheckTaggedInputParameters(kMode, VectorSlotPair())) {}
    1020             :   };
    1021             :   CheckedTaggedToFloat64Operator<CheckTaggedInputMode::kNumber>
    1022             :       kCheckedTaggedToFloat64NumberOperator;
    1023             :   CheckedTaggedToFloat64Operator<CheckTaggedInputMode::kNumberOrOddball>
    1024             :       kCheckedTaggedToFloat64NumberOrOddballOperator;
    1025             : 
    1026             :   template <CheckTaggedInputMode kMode>
    1027           0 :   struct CheckedTruncateTaggedToWord32Operator final
    1028             :       : public Operator1<CheckTaggedInputParameters> {
    1029       57856 :     CheckedTruncateTaggedToWord32Operator()
    1030             :         : Operator1<CheckTaggedInputParameters>(
    1031             :               IrOpcode::kCheckedTruncateTaggedToWord32,
    1032             :               Operator::kFoldable | Operator::kNoThrow,
    1033             :               "CheckedTruncateTaggedToWord32", 1, 1, 1, 1, 1, 0,
    1034      115712 :               CheckTaggedInputParameters(kMode, VectorSlotPair())) {}
    1035             :   };
    1036             :   CheckedTruncateTaggedToWord32Operator<CheckTaggedInputMode::kNumber>
    1037             :       kCheckedTruncateTaggedToWord32NumberOperator;
    1038             :   CheckedTruncateTaggedToWord32Operator<CheckTaggedInputMode::kNumberOrOddball>
    1039             :       kCheckedTruncateTaggedToWord32NumberOrOddballOperator;
    1040             : 
    1041             :   template <ConvertReceiverMode kMode>
    1042           0 :   struct ConvertReceiverOperator final : public Operator1<ConvertReceiverMode> {
    1043       86784 :     ConvertReceiverOperator()
    1044             :         : Operator1<ConvertReceiverMode>(  // --
    1045             :               IrOpcode::kConvertReceiver,  // opcode
    1046             :               Operator::kEliminatable,     // flags
    1047             :               "ConvertReceiver",           // name
    1048             :               2, 1, 1, 1, 1, 0,            // counts
    1049       86784 :               kMode) {}                    // param
    1050             :   };
    1051             :   ConvertReceiverOperator<ConvertReceiverMode::kAny>
    1052             :       kConvertReceiverAnyOperator;
    1053             :   ConvertReceiverOperator<ConvertReceiverMode::kNullOrUndefined>
    1054             :       kConvertReceiverNullOrUndefinedOperator;
    1055             :   ConvertReceiverOperator<ConvertReceiverMode::kNotNullOrUndefined>
    1056             :       kConvertReceiverNotNullOrUndefinedOperator;
    1057             : 
    1058             :   template <CheckFloat64HoleMode kMode>
    1059           0 :   struct CheckFloat64HoleNaNOperator final
    1060             :       : public Operator1<CheckFloat64HoleParameters> {
    1061       57856 :     CheckFloat64HoleNaNOperator()
    1062             :         : Operator1<CheckFloat64HoleParameters>(
    1063             :               IrOpcode::kCheckFloat64Hole,
    1064             :               Operator::kFoldable | Operator::kNoThrow, "CheckFloat64Hole", 1,
    1065             :               1, 1, 1, 1, 0,
    1066      115712 :               CheckFloat64HoleParameters(kMode, VectorSlotPair())) {}
    1067             :   };
    1068             :   CheckFloat64HoleNaNOperator<CheckFloat64HoleMode::kAllowReturnHole>
    1069             :       kCheckFloat64HoleAllowReturnHoleOperator;
    1070             :   CheckFloat64HoleNaNOperator<CheckFloat64HoleMode::kNeverReturnHole>
    1071             :       kCheckFloat64HoleNeverReturnHoleOperator;
    1072             : 
    1073           0 :   struct EnsureWritableFastElementsOperator final : public Operator {
    1074       28928 :     EnsureWritableFastElementsOperator()
    1075             :         : Operator(                                     // --
    1076             :               IrOpcode::kEnsureWritableFastElements,    // opcode
    1077             :               Operator::kNoDeopt | Operator::kNoThrow,  // flags
    1078             :               "EnsureWritableFastElements",             // name
    1079       28928 :               2, 1, 1, 1, 1, 0) {}                      // counts
    1080             :   };
    1081             :   EnsureWritableFastElementsOperator kEnsureWritableFastElements;
    1082             : 
    1083             :   template <GrowFastElementsMode kMode>
    1084           0 :   struct GrowFastElementsOperator final
    1085             :       : public Operator1<GrowFastElementsParameters> {
    1086       57856 :     GrowFastElementsOperator()
    1087             :         : Operator1(IrOpcode::kMaybeGrowFastElements, Operator::kNoThrow,
    1088             :                     "MaybeGrowFastElements", 4, 1, 1, 1, 1, 0,
    1089      115712 :                     GrowFastElementsParameters(kMode, VectorSlotPair())) {}
    1090             :   };
    1091             : 
    1092             :   GrowFastElementsOperator<GrowFastElementsMode::kDoubleElements>
    1093             :       kGrowFastElementsOperatorDoubleElements;
    1094             :   GrowFastElementsOperator<GrowFastElementsMode::kSmiOrObjectElements>
    1095             :       kGrowFastElementsOperatorSmiOrObjectElements;
    1096             : 
    1097           0 :   struct LoadFieldByIndexOperator final : public Operator {
    1098       28928 :     LoadFieldByIndexOperator()
    1099             :         : Operator(                         // --
    1100             :               IrOpcode::kLoadFieldByIndex,  // opcode
    1101             :               Operator::kEliminatable,      // flags,
    1102             :               "LoadFieldByIndex",           // name
    1103       28928 :               2, 1, 1, 1, 1, 0) {}          // counts;
    1104             :   };
    1105             :   LoadFieldByIndexOperator kLoadFieldByIndex;
    1106             : 
    1107           0 :   struct LoadStackArgumentOperator final : public Operator {
    1108       28928 :     LoadStackArgumentOperator()
    1109             :         : Operator(                          // --
    1110             :               IrOpcode::kLoadStackArgument,  // opcode
    1111             :               Operator::kNoDeopt | Operator::kNoThrow |
    1112             :                   Operator::kNoWrite,  // flags
    1113             :               "LoadStackArgument",     // name
    1114       28928 :               2, 1, 1, 1, 1, 0) {}     // counts
    1115             :   };
    1116             :   LoadStackArgumentOperator kLoadStackArgument;
    1117             : 
    1118           0 :   struct LoadMessageOperator final : public Operator {
    1119       28928 :     LoadMessageOperator()
    1120             :         : Operator(                    // --
    1121             :               IrOpcode::kLoadMessage,  // opcode
    1122             :               Operator::kNoDeopt | Operator::kNoThrow |
    1123             :                   Operator::kNoWrite,  // flags
    1124             :               "LoadMessage",           // name
    1125       28928 :               1, 1, 1, 1, 1, 0) {}     // counts
    1126             :   };
    1127             :   LoadMessageOperator kLoadMessage;
    1128             : 
    1129           0 :   struct StoreMessageOperator final : public Operator {
    1130       28928 :     StoreMessageOperator()
    1131             :         : Operator(                     // --
    1132             :               IrOpcode::kStoreMessage,  // opcode
    1133             :               Operator::kNoDeopt | Operator::kNoThrow |
    1134             :                   Operator::kNoRead,  // flags
    1135             :               "StoreMessage",         // name
    1136       28928 :               2, 1, 1, 0, 1, 0) {}    // counts
    1137             :   };
    1138             :   StoreMessageOperator kStoreMessage;
    1139             : 
    1140             : #define SPECULATIVE_NUMBER_BINOP(Name)                                      \
    1141             :   template <NumberOperationHint kHint>                                      \
    1142             :   struct Name##Operator final : public Operator1<NumberOperationHint> {     \
    1143             :     Name##Operator()                                                        \
    1144             :         : Operator1<NumberOperationHint>(                                   \
    1145             :               IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow,  \
    1146             :               #Name, 2, 1, 1, 1, 1, 0, kHint) {}                            \
    1147             :   };                                                                        \
    1148             :   Name##Operator<NumberOperationHint::kSignedSmall>                         \
    1149             :       k##Name##SignedSmallOperator;                                         \
    1150             :   Name##Operator<NumberOperationHint::kSignedSmallInputs>                   \
    1151             :       k##Name##SignedSmallInputsOperator;                                   \
    1152             :   Name##Operator<NumberOperationHint::kSigned32> k##Name##Signed32Operator; \
    1153             :   Name##Operator<NumberOperationHint::kNumber> k##Name##NumberOperator;     \
    1154             :   Name##Operator<NumberOperationHint::kNumberOrOddball>                     \
    1155             :       k##Name##NumberOrOddballOperator;
    1156     4628480 :   SPECULATIVE_NUMBER_BINOP_LIST(SPECULATIVE_NUMBER_BINOP)
    1157             : #undef SPECULATIVE_NUMBER_BINOP
    1158             : 
    1159             :   template <NumberOperationHint kHint>
    1160           0 :   struct SpeculativeToNumberOperator final
    1161             :       : public Operator1<NumberOperationParameters> {
    1162      115712 :     SpeculativeToNumberOperator()
    1163             :         : Operator1<NumberOperationParameters>(
    1164             :               IrOpcode::kSpeculativeToNumber,
    1165             :               Operator::kFoldable | Operator::kNoThrow, "SpeculativeToNumber",
    1166             :               1, 1, 1, 1, 1, 0,
    1167      231424 :               NumberOperationParameters(kHint, VectorSlotPair())) {}
    1168             :   };
    1169             :   SpeculativeToNumberOperator<NumberOperationHint::kSignedSmall>
    1170             :       kSpeculativeToNumberSignedSmallOperator;
    1171             :   SpeculativeToNumberOperator<NumberOperationHint::kSigned32>
    1172             :       kSpeculativeToNumberSigned32Operator;
    1173             :   SpeculativeToNumberOperator<NumberOperationHint::kNumber>
    1174             :       kSpeculativeToNumberNumberOperator;
    1175             :   SpeculativeToNumberOperator<NumberOperationHint::kNumberOrOddball>
    1176             :       kSpeculativeToNumberNumberOrOddballOperator;
    1177             : };
    1178             : 
    1179             : namespace {
    1180     4164459 : DEFINE_LAZY_LEAKY_OBJECT_GETTER(SimplifiedOperatorGlobalCache,
    1181             :                                 GetSimplifiedOperatorGlobalCache)
    1182             : }
    1183             : 
    1184     4135531 : SimplifiedOperatorBuilder::SimplifiedOperatorBuilder(Zone* zone)
    1185     4135531 :     : cache_(*GetSimplifiedOperatorGlobalCache()), zone_(zone) {}
    1186             : 
    1187             : #define GET_FROM_CACHE(Name, ...) \
    1188             :   const Operator* SimplifiedOperatorBuilder::Name() { return &cache_.k##Name; }
    1189     1265227 : PURE_OP_LIST(GET_FROM_CACHE)
    1190        4130 : EFFECT_DEPENDENT_OP_LIST(GET_FROM_CACHE)
    1191      204881 : CHECKED_OP_LIST(GET_FROM_CACHE)
    1192       17747 : GET_FROM_CACHE(ArgumentsFrame)
    1193         181 : GET_FROM_CACHE(FindOrderedHashMapEntry)
    1194          16 : GET_FROM_CACHE(FindOrderedHashMapEntryForInt32Key)
    1195         311 : GET_FROM_CACHE(LoadFieldByIndex)
    1196             : #undef GET_FROM_CACHE
    1197             : 
    1198             : #define GET_FROM_CACHE_WITH_FEEDBACK(Name, value_input_count,               \
    1199             :                                      value_output_count)                    \
    1200             :   const Operator* SimplifiedOperatorBuilder::Name(                          \
    1201             :       const VectorSlotPair& feedback) {                                     \
    1202             :     if (!feedback.IsValid()) {                                              \
    1203             :       return &cache_.k##Name;                                               \
    1204             :     }                                                                       \
    1205             :     return new (zone()) Operator1<CheckParameters>(                         \
    1206             :         IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow, #Name, \
    1207             :         value_input_count, 1, 1, value_output_count, 1, 0,                  \
    1208             :         CheckParameters(feedback));                                         \
    1209             :   }
    1210      651566 : CHECKED_WITH_FEEDBACK_OP_LIST(GET_FROM_CACHE_WITH_FEEDBACK)
    1211             : #undef GET_FROM_CACHE_WITH_FEEDBACK
    1212             : 
    1213             : #define GET_FROM_CACHE_WITH_FEEDBACK(Name)                                \
    1214             :   const Operator* SimplifiedOperatorBuilder::Name(                        \
    1215             :       const VectorSlotPair& feedback, CheckBoundsParameters::Mode mode) { \
    1216             :     if (!feedback.IsValid()) {                                            \
    1217             :       switch (mode) {                                                     \
    1218             :         case CheckBoundsParameters::kDeoptOnOutOfBounds:                  \
    1219             :           return &cache_.k##Name##Deopting;                               \
    1220             :         case CheckBoundsParameters::kAbortOnOutOfBounds:                  \
    1221             :           return &cache_.k##Name##Aborting;                               \
    1222             :       }                                                                   \
    1223             :     }                                                                     \
    1224             :     return new (zone())                                                   \
    1225             :         SimplifiedOperatorGlobalCache::Name##Operator(feedback, mode);    \
    1226             :   }
    1227      114138 : CHECKED_BOUNDS_OP_LIST(GET_FROM_CACHE_WITH_FEEDBACK)
    1228             : #undef GET_FROM_CACHE_WITH_FEEDBACK
    1229             : 
    1230           0 : bool IsCheckedWithFeedback(const Operator* op) {
    1231             : #define CASE(Name, ...) case IrOpcode::k##Name:
    1232           0 :   switch (op->opcode()) {
    1233             :     CHECKED_WITH_FEEDBACK_OP_LIST(CASE) return true;
    1234             :     default:
    1235           0 :       return false;
    1236             :   }
    1237             : #undef CASE
    1238             : }
    1239             : 
    1240        2662 : const Operator* SimplifiedOperatorBuilder::RuntimeAbort(AbortReason reason) {
    1241             :   return new (zone()) Operator1<int>(           // --
    1242             :       IrOpcode::kRuntimeAbort,                  // opcode
    1243             :       Operator::kNoThrow | Operator::kNoDeopt,  // flags
    1244             :       "RuntimeAbort",                           // name
    1245             :       0, 1, 1, 0, 1, 0,                         // counts
    1246        5324 :       static_cast<int>(reason));                // parameter
    1247             : }
    1248             : 
    1249       16208 : const Operator* SimplifiedOperatorBuilder::CheckIf(
    1250             :     DeoptimizeReason reason, const VectorSlotPair& feedback) {
    1251       16208 :   if (!feedback.IsValid()) {
    1252       15617 :     switch (reason) {
    1253             : #define CHECK_IF(Name, message)   \
    1254             :   case DeoptimizeReason::k##Name: \
    1255             :     return &cache_.kCheckIf##Name;
    1256         181 :     DEOPTIMIZE_REASON_LIST(CHECK_IF)
    1257             : #undef CHECK_IF
    1258             :     }
    1259             :   }
    1260             :   return new (zone()) Operator1<CheckIfParameters>(
    1261             :       IrOpcode::kCheckIf, Operator::kFoldable | Operator::kNoThrow, "CheckIf",
    1262             :       1, 1, 1, 0, 1, 0, CheckIfParameters(reason, feedback));
    1263             : }
    1264             : 
    1265       71511 : const Operator* SimplifiedOperatorBuilder::ChangeFloat64ToTagged(
    1266             :     CheckForMinusZeroMode mode) {
    1267       71511 :   switch (mode) {
    1268             :     case CheckForMinusZeroMode::kCheckForMinusZero:
    1269       41847 :       return &cache_.kChangeFloat64ToTaggedCheckForMinusZeroOperator;
    1270             :     case CheckForMinusZeroMode::kDontCheckForMinusZero:
    1271       29664 :       return &cache_.kChangeFloat64ToTaggedDontCheckForMinusZeroOperator;
    1272             :   }
    1273           0 :   UNREACHABLE();
    1274             : }
    1275             : 
    1276        6121 : const Operator* SimplifiedOperatorBuilder::CheckedInt32Mul(
    1277             :     CheckForMinusZeroMode mode) {
    1278        6121 :   switch (mode) {
    1279             :     case CheckForMinusZeroMode::kCheckForMinusZero:
    1280        4013 :       return &cache_.kCheckedInt32MulCheckForMinusZeroOperator;
    1281             :     case CheckForMinusZeroMode::kDontCheckForMinusZero:
    1282        2108 :       return &cache_.kCheckedInt32MulDontCheckForMinusZeroOperator;
    1283             :   }
    1284           0 :   UNREACHABLE();
    1285             : }
    1286             : 
    1287        2586 : const Operator* SimplifiedOperatorBuilder::CheckedFloat64ToInt32(
    1288             :     CheckForMinusZeroMode mode, const VectorSlotPair& feedback) {
    1289        2586 :   if (!feedback.IsValid()) {
    1290        2561 :     switch (mode) {
    1291             :       case CheckForMinusZeroMode::kCheckForMinusZero:
    1292        2177 :         return &cache_.kCheckedFloat64ToInt32CheckForMinusZeroOperator;
    1293             :       case CheckForMinusZeroMode::kDontCheckForMinusZero:
    1294         384 :         return &cache_.kCheckedFloat64ToInt32DontCheckForMinusZeroOperator;
    1295             :     }
    1296             :   }
    1297             :   return new (zone()) Operator1<CheckMinusZeroParameters>(
    1298             :       IrOpcode::kCheckedFloat64ToInt32,
    1299             :       Operator::kFoldable | Operator::kNoThrow, "CheckedFloat64ToInt32", 1, 1,
    1300             :       1, 1, 1, 0, CheckMinusZeroParameters(mode, feedback));
    1301             : }
    1302             : 
    1303          62 : const Operator* SimplifiedOperatorBuilder::CheckedFloat64ToInt64(
    1304             :     CheckForMinusZeroMode mode, const VectorSlotPair& feedback) {
    1305          62 :   if (!feedback.IsValid()) {
    1306          22 :     switch (mode) {
    1307             :       case CheckForMinusZeroMode::kCheckForMinusZero:
    1308           6 :         return &cache_.kCheckedFloat64ToInt64CheckForMinusZeroOperator;
    1309             :       case CheckForMinusZeroMode::kDontCheckForMinusZero:
    1310          16 :         return &cache_.kCheckedFloat64ToInt64DontCheckForMinusZeroOperator;
    1311             :     }
    1312             :   }
    1313             :   return new (zone()) Operator1<CheckMinusZeroParameters>(
    1314             :       IrOpcode::kCheckedFloat64ToInt64,
    1315             :       Operator::kFoldable | Operator::kNoThrow, "CheckedFloat64ToInt64", 1, 1,
    1316             :       1, 1, 1, 0, CheckMinusZeroParameters(mode, feedback));
    1317             : }
    1318             : 
    1319        2641 : const Operator* SimplifiedOperatorBuilder::CheckedTaggedToInt32(
    1320             :     CheckForMinusZeroMode mode, const VectorSlotPair& feedback) {
    1321        2641 :   if (!feedback.IsValid()) {
    1322        2281 :     switch (mode) {
    1323             :       case CheckForMinusZeroMode::kCheckForMinusZero:
    1324           9 :         return &cache_.kCheckedTaggedToInt32CheckForMinusZeroOperator;
    1325             :       case CheckForMinusZeroMode::kDontCheckForMinusZero:
    1326        2272 :         return &cache_.kCheckedTaggedToInt32DontCheckForMinusZeroOperator;
    1327             :     }
    1328             :   }
    1329             :   return new (zone()) Operator1<CheckMinusZeroParameters>(
    1330             :       IrOpcode::kCheckedTaggedToInt32, Operator::kFoldable | Operator::kNoThrow,
    1331             :       "CheckedTaggedToInt32", 1, 1, 1, 1, 1, 0,
    1332             :       CheckMinusZeroParameters(mode, feedback));
    1333             : }
    1334             : 
    1335         133 : const Operator* SimplifiedOperatorBuilder::CheckedTaggedToInt64(
    1336             :     CheckForMinusZeroMode mode, const VectorSlotPair& feedback) {
    1337         133 :   if (!feedback.IsValid()) {
    1338          22 :     switch (mode) {
    1339             :       case CheckForMinusZeroMode::kCheckForMinusZero:
    1340           6 :         return &cache_.kCheckedTaggedToInt64CheckForMinusZeroOperator;
    1341             :       case CheckForMinusZeroMode::kDontCheckForMinusZero:
    1342          16 :         return &cache_.kCheckedTaggedToInt64DontCheckForMinusZeroOperator;
    1343             :     }
    1344             :   }
    1345             :   return new (zone()) Operator1<CheckMinusZeroParameters>(
    1346             :       IrOpcode::kCheckedTaggedToInt64, Operator::kFoldable | Operator::kNoThrow,
    1347             :       "CheckedTaggedToInt64", 1, 1, 1, 1, 1, 0,
    1348             :       CheckMinusZeroParameters(mode, feedback));
    1349             : }
    1350             : 
    1351       54446 : const Operator* SimplifiedOperatorBuilder::CheckedTaggedToFloat64(
    1352             :     CheckTaggedInputMode mode, const VectorSlotPair& feedback) {
    1353       54446 :   if (!feedback.IsValid()) {
    1354       22574 :     switch (mode) {
    1355             :       case CheckTaggedInputMode::kNumber:
    1356        8094 :         return &cache_.kCheckedTaggedToFloat64NumberOperator;
    1357             :       case CheckTaggedInputMode::kNumberOrOddball:
    1358       14480 :         return &cache_.kCheckedTaggedToFloat64NumberOrOddballOperator;
    1359             :     }
    1360             :   }
    1361             :   return new (zone()) Operator1<CheckTaggedInputParameters>(
    1362             :       IrOpcode::kCheckedTaggedToFloat64,
    1363             :       Operator::kFoldable | Operator::kNoThrow, "CheckedTaggedToFloat64", 1, 1,
    1364             :       1, 1, 1, 0, CheckTaggedInputParameters(mode, feedback));
    1365             : }
    1366             : 
    1367        1388 : const Operator* SimplifiedOperatorBuilder::CheckedTruncateTaggedToWord32(
    1368             :     CheckTaggedInputMode mode, const VectorSlotPair& feedback) {
    1369        1388 :   if (!feedback.IsValid()) {
    1370        1352 :     switch (mode) {
    1371             :       case CheckTaggedInputMode::kNumber:
    1372         876 :         return &cache_.kCheckedTruncateTaggedToWord32NumberOperator;
    1373             :       case CheckTaggedInputMode::kNumberOrOddball:
    1374         476 :         return &cache_.kCheckedTruncateTaggedToWord32NumberOrOddballOperator;
    1375             :     }
    1376             :   }
    1377             :   return new (zone()) Operator1<CheckTaggedInputParameters>(
    1378             :       IrOpcode::kCheckedTruncateTaggedToWord32,
    1379             :       Operator::kFoldable | Operator::kNoThrow, "CheckedTruncateTaggedToWord32",
    1380             :       1, 1, 1, 1, 1, 0, CheckTaggedInputParameters(mode, feedback));
    1381             : }
    1382             : 
    1383       90528 : const Operator* SimplifiedOperatorBuilder::CheckMaps(
    1384             :     CheckMapsFlags flags, ZoneHandleSet<Map> maps,
    1385             :     const VectorSlotPair& feedback) {
    1386             :   CheckMapsParameters const parameters(flags, maps, feedback);
    1387             :   return new (zone()) Operator1<CheckMapsParameters>(  // --
    1388             :       IrOpcode::kCheckMaps,                            // opcode
    1389             :       Operator::kNoThrow | Operator::kNoWrite,         // flags
    1390             :       "CheckMaps",                                     // name
    1391             :       1, 1, 1, 0, 1, 0,                                // counts
    1392       90528 :       parameters);                                     // parameter
    1393             : }
    1394             : 
    1395        6671 : const Operator* SimplifiedOperatorBuilder::MapGuard(ZoneHandleSet<Map> maps) {
    1396             :   DCHECK_LT(0, maps.size());
    1397             :   return new (zone()) Operator1<ZoneHandleSet<Map>>(  // --
    1398             :       IrOpcode::kMapGuard, Operator::kEliminatable,   // opcode
    1399             :       "MapGuard",                                     // name
    1400             :       1, 1, 1, 0, 1, 0,                               // counts
    1401       13342 :       maps);                                          // parameter
    1402             : }
    1403             : 
    1404        6934 : const Operator* SimplifiedOperatorBuilder::CompareMaps(
    1405             :     ZoneHandleSet<Map> maps) {
    1406             :   DCHECK_LT(0, maps.size());
    1407             :   return new (zone()) Operator1<ZoneHandleSet<Map>>(  // --
    1408             :       IrOpcode::kCompareMaps,                         // opcode
    1409             :       Operator::kEliminatable,                        // flags
    1410             :       "CompareMaps",                                  // name
    1411             :       1, 1, 1, 1, 1, 0,                               // counts
    1412       13868 :       maps);                                          // parameter
    1413             : }
    1414             : 
    1415       73886 : const Operator* SimplifiedOperatorBuilder::ConvertReceiver(
    1416             :     ConvertReceiverMode mode) {
    1417       73886 :   switch (mode) {
    1418             :     case ConvertReceiverMode::kAny:
    1419        1185 :       return &cache_.kConvertReceiverAnyOperator;
    1420             :     case ConvertReceiverMode::kNullOrUndefined:
    1421       71866 :       return &cache_.kConvertReceiverNullOrUndefinedOperator;
    1422             :     case ConvertReceiverMode::kNotNullOrUndefined:
    1423         835 :       return &cache_.kConvertReceiverNotNullOrUndefinedOperator;
    1424             :   }
    1425           0 :   UNREACHABLE();
    1426             :   return nullptr;
    1427             : }
    1428             : 
    1429         618 : const Operator* SimplifiedOperatorBuilder::CheckFloat64Hole(
    1430             :     CheckFloat64HoleMode mode, VectorSlotPair const& feedback) {
    1431         618 :   if (!feedback.IsValid()) {
    1432         603 :     switch (mode) {
    1433             :       case CheckFloat64HoleMode::kAllowReturnHole:
    1434         428 :         return &cache_.kCheckFloat64HoleAllowReturnHoleOperator;
    1435             :       case CheckFloat64HoleMode::kNeverReturnHole:
    1436         175 :         return &cache_.kCheckFloat64HoleNeverReturnHoleOperator;
    1437             :     }
    1438           0 :     UNREACHABLE();
    1439             :   }
    1440             :   return new (zone()) Operator1<CheckFloat64HoleParameters>(
    1441             :       IrOpcode::kCheckFloat64Hole, Operator::kFoldable | Operator::kNoThrow,
    1442             :       "CheckFloat64Hole", 1, 1, 1, 1, 1, 0,
    1443             :       CheckFloat64HoleParameters(mode, feedback));
    1444             : }
    1445             : 
    1446       75054 : const Operator* SimplifiedOperatorBuilder::SpeculativeToNumber(
    1447             :     NumberOperationHint hint, const VectorSlotPair& feedback) {
    1448       75054 :   if (!feedback.IsValid()) {
    1449       17383 :     switch (hint) {
    1450             :       case NumberOperationHint::kSignedSmall:
    1451        7559 :         return &cache_.kSpeculativeToNumberSignedSmallOperator;
    1452             :       case NumberOperationHint::kSignedSmallInputs:
    1453             :         break;
    1454             :       case NumberOperationHint::kSigned32:
    1455           6 :         return &cache_.kSpeculativeToNumberSigned32Operator;
    1456             :       case NumberOperationHint::kNumber:
    1457        6428 :         return &cache_.kSpeculativeToNumberNumberOperator;
    1458             :       case NumberOperationHint::kNumberOrOddball:
    1459        3384 :         return &cache_.kSpeculativeToNumberNumberOrOddballOperator;
    1460             :     }
    1461             :   }
    1462             :   return new (zone()) Operator1<NumberOperationParameters>(
    1463             :       IrOpcode::kSpeculativeToNumber, Operator::kFoldable | Operator::kNoThrow,
    1464             :       "SpeculativeToNumber", 1, 1, 1, 1, 1, 0,
    1465             :       NumberOperationParameters(hint, feedback));
    1466             : }
    1467             : 
    1468        1352 : const Operator* SimplifiedOperatorBuilder::EnsureWritableFastElements() {
    1469        1352 :   return &cache_.kEnsureWritableFastElements;
    1470             : }
    1471             : 
    1472        2873 : const Operator* SimplifiedOperatorBuilder::MaybeGrowFastElements(
    1473             :     GrowFastElementsMode mode, const VectorSlotPair& feedback) {
    1474        2873 :   if (!feedback.IsValid()) {
    1475        1082 :     switch (mode) {
    1476             :       case GrowFastElementsMode::kDoubleElements:
    1477         142 :         return &cache_.kGrowFastElementsOperatorDoubleElements;
    1478             :       case GrowFastElementsMode::kSmiOrObjectElements:
    1479         940 :         return &cache_.kGrowFastElementsOperatorSmiOrObjectElements;
    1480             :     }
    1481             :   }
    1482             :   return new (zone()) Operator1<GrowFastElementsParameters>(  // --
    1483             :       IrOpcode::kMaybeGrowFastElements,                       // opcode
    1484             :       Operator::kNoThrow,                                     // flags
    1485             :       "MaybeGrowFastElements",                                // name
    1486             :       4, 1, 1, 1, 1, 0,                                       // counts
    1487             :       GrowFastElementsParameters(mode, feedback));            // parameter
    1488             : }
    1489             : 
    1490         556 : const Operator* SimplifiedOperatorBuilder::TransitionElementsKind(
    1491             :     ElementsTransition transition) {
    1492             :   return new (zone()) Operator1<ElementsTransition>(  // --
    1493             :       IrOpcode::kTransitionElementsKind,              // opcode
    1494             :       Operator::kNoDeopt | Operator::kNoThrow,        // flags
    1495             :       "TransitionElementsKind",                       // name
    1496             :       1, 1, 1, 0, 1, 0,                               // counts
    1497        1112 :       transition);                                    // parameter
    1498             : }
    1499             : 
    1500             : namespace {
    1501             : 
    1502             : struct ArgumentsLengthParameters {
    1503             :   int formal_parameter_count;
    1504             :   bool is_rest_length;
    1505             : };
    1506             : 
    1507             : bool operator==(ArgumentsLengthParameters first,
    1508             :                 ArgumentsLengthParameters second) {
    1509           0 :   return first.formal_parameter_count == second.formal_parameter_count &&
    1510             :          first.is_rest_length == second.is_rest_length;
    1511             : }
    1512             : 
    1513       41310 : size_t hash_value(ArgumentsLengthParameters param) {
    1514       41310 :   return base::hash_combine(param.formal_parameter_count, param.is_rest_length);
    1515             : }
    1516             : 
    1517           0 : std::ostream& operator<<(std::ostream& os, ArgumentsLengthParameters param) {
    1518           0 :   return os << param.formal_parameter_count << ", "
    1519           0 :             << (param.is_rest_length ? "rest length" : "not rest length");
    1520             : }
    1521             : 
    1522             : }  // namespace
    1523             : 
    1524       17747 : const Operator* SimplifiedOperatorBuilder::ArgumentsLength(
    1525             :     int formal_parameter_count, bool is_rest_length) {
    1526             :   return new (zone()) Operator1<ArgumentsLengthParameters>(  // --
    1527             :       IrOpcode::kArgumentsLength,                            // opcode
    1528             :       Operator::kPure,                                       // flags
    1529             :       "ArgumentsLength",                                     // name
    1530             :       1, 0, 0, 1, 0, 0,                                      // counts
    1531             :       ArgumentsLengthParameters{formal_parameter_count,
    1532       35494 :                                 is_rest_length});  // parameter
    1533             : }
    1534             : 
    1535       16941 : int FormalParameterCountOf(const Operator* op) {
    1536             :   DCHECK_EQ(IrOpcode::kArgumentsLength, op->opcode());
    1537       16941 :   return OpParameter<ArgumentsLengthParameters>(op).formal_parameter_count;
    1538             : }
    1539             : 
    1540       36002 : bool IsRestLengthOf(const Operator* op) {
    1541             :   DCHECK_EQ(IrOpcode::kArgumentsLength, op->opcode());
    1542       36002 :   return OpParameter<ArgumentsLengthParameters>(op).is_rest_length;
    1543             : }
    1544             : 
    1545           0 : bool operator==(CheckParameters const& lhs, CheckParameters const& rhs) {
    1546           0 :   return lhs.feedback() == rhs.feedback();
    1547             : }
    1548             : 
    1549           0 : size_t hash_value(CheckParameters const& p) { return hash_value(p.feedback()); }
    1550             : 
    1551           0 : std::ostream& operator<<(std::ostream& os, CheckParameters const& p) {
    1552          26 :   return os << p.feedback();
    1553             : }
    1554             : 
    1555      388751 : CheckParameters const& CheckParametersOf(Operator const* op) {
    1556      388751 :   if (op->opcode() == IrOpcode::kCheckedUint32Bounds) {
    1557           0 :     return OpParameter<CheckBoundsParameters>(op).check_parameters();
    1558             :   }
    1559             : #define MAKE_OR(name, arg2, arg3) op->opcode() == IrOpcode::k##name ||
    1560      388751 :   CHECK((CHECKED_WITH_FEEDBACK_OP_LIST(MAKE_OR) false));
    1561             : #undef MAKE_OR
    1562      388751 :   return OpParameter<CheckParameters>(op);
    1563             : }
    1564             : 
    1565           0 : bool operator==(CheckBoundsParameters const& lhs,
    1566             :                 CheckBoundsParameters const& rhs) {
    1567           0 :   return lhs.check_parameters() == rhs.check_parameters() &&
    1568           0 :          lhs.mode() == rhs.mode();
    1569             : }
    1570             : 
    1571           0 : size_t hash_value(CheckBoundsParameters const& p) {
    1572           0 :   return base::hash_combine(hash_value(p.check_parameters()), p.mode());
    1573             : }
    1574             : 
    1575           0 : std::ostream& operator<<(std::ostream& os, CheckBoundsParameters const& p) {
    1576           0 :   os << p.check_parameters() << ",";
    1577           0 :   switch (p.mode()) {
    1578             :     case CheckBoundsParameters::kDeoptOnOutOfBounds:
    1579           0 :       os << "deopt";
    1580           0 :       break;
    1581             :     case CheckBoundsParameters::kAbortOnOutOfBounds:
    1582           0 :       os << "abort";
    1583           0 :       break;
    1584             :   }
    1585           0 :   return os;
    1586             : }
    1587             : 
    1588       52521 : CheckBoundsParameters const& CheckBoundsParametersOf(Operator const* op) {
    1589       52521 :   CHECK_EQ(op->opcode(), IrOpcode::kCheckedUint32Bounds);
    1590       52521 :   return OpParameter<CheckBoundsParameters>(op);
    1591             : }
    1592             : 
    1593           0 : bool operator==(CheckIfParameters const& lhs, CheckIfParameters const& rhs) {
    1594           0 :   return lhs.reason() == rhs.reason() && lhs.feedback() == rhs.feedback();
    1595             : }
    1596             : 
    1597           0 : size_t hash_value(CheckIfParameters const& p) {
    1598           0 :   return base::hash_combine(p.reason(), p.feedback());
    1599             : }
    1600             : 
    1601           0 : std::ostream& operator<<(std::ostream& os, CheckIfParameters const& p) {
    1602           0 :   return os << p.reason() << p.feedback();
    1603             : }
    1604             : 
    1605       14522 : CheckIfParameters const& CheckIfParametersOf(Operator const* op) {
    1606       14522 :   CHECK(op->opcode() == IrOpcode::kCheckIf);
    1607       14522 :   return OpParameter<CheckIfParameters>(op);
    1608             : }
    1609             : 
    1610          28 : const Operator* SimplifiedOperatorBuilder::NewDoubleElements(
    1611             :     AllocationType allocation) {
    1612             :   return new (zone()) Operator1<AllocationType>(  // --
    1613             :       IrOpcode::kNewDoubleElements,               // opcode
    1614             :       Operator::kEliminatable,                    // flags
    1615             :       "NewDoubleElements",                        // name
    1616             :       1, 1, 1, 1, 1, 0,                           // counts
    1617          28 :       allocation);                                // parameter
    1618             : }
    1619             : 
    1620         459 : const Operator* SimplifiedOperatorBuilder::NewSmiOrObjectElements(
    1621             :     AllocationType allocation) {
    1622             :   return new (zone()) Operator1<AllocationType>(  // --
    1623             :       IrOpcode::kNewSmiOrObjectElements,          // opcode
    1624             :       Operator::kEliminatable,                    // flags
    1625             :       "NewSmiOrObjectElements",                   // name
    1626             :       1, 1, 1, 1, 1, 0,                           // counts
    1627         459 :       allocation);                                // parameter
    1628             : }
    1629             : 
    1630       17747 : const Operator* SimplifiedOperatorBuilder::NewArgumentsElements(
    1631             :     int mapped_count) {
    1632             :   return new (zone()) Operator1<int>(   // --
    1633             :       IrOpcode::kNewArgumentsElements,  // opcode
    1634             :       Operator::kEliminatable,          // flags
    1635             :       "NewArgumentsElements",           // name
    1636             :       2, 1, 0, 1, 1, 0,                 // counts
    1637       17747 :       mapped_count);                    // parameter
    1638             : }
    1639             : 
    1640       35498 : int NewArgumentsElementsMappedCountOf(const Operator* op) {
    1641             :   DCHECK_EQ(IrOpcode::kNewArgumentsElements, op->opcode());
    1642       35498 :   return OpParameter<int>(op);
    1643             : }
    1644             : 
    1645      138914 : const Operator* SimplifiedOperatorBuilder::Allocate(Type type,
    1646             :                                                     AllocationType allocation) {
    1647             :   return new (zone()) Operator1<AllocateParameters>(
    1648             :       IrOpcode::kAllocate,
    1649             :       Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite, "Allocate",
    1650      138914 :       1, 1, 1, 1, 1, 0, AllocateParameters(type, allocation));
    1651             : }
    1652             : 
    1653      233308 : const Operator* SimplifiedOperatorBuilder::AllocateRaw(
    1654             :     Type type, AllocationType allocation) {
    1655             :   return new (zone()) Operator1<AllocateParameters>(
    1656             :       IrOpcode::kAllocateRaw,
    1657             :       Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite,
    1658      233309 :       "AllocateRaw", 1, 1, 1, 1, 1, 1, AllocateParameters(type, allocation));
    1659             : }
    1660             : 
    1661         548 : const Operator* SimplifiedOperatorBuilder::StringCodePointAt(
    1662             :     UnicodeEncoding encoding) {
    1663         548 :   switch (encoding) {
    1664             :     case UnicodeEncoding::UTF16:
    1665          87 :       return &cache_.kStringCodePointAtOperatorUTF16;
    1666             :     case UnicodeEncoding::UTF32:
    1667         461 :       return &cache_.kStringCodePointAtOperatorUTF32;
    1668             :   }
    1669           0 :   UNREACHABLE();
    1670             : }
    1671             : 
    1672         215 : const Operator* SimplifiedOperatorBuilder::StringFromSingleCodePoint(
    1673             :     UnicodeEncoding encoding) {
    1674         215 :   switch (encoding) {
    1675             :     case UnicodeEncoding::UTF16:
    1676          87 :       return &cache_.kStringFromSingleCodePointOperatorUTF16;
    1677             :     case UnicodeEncoding::UTF32:
    1678         128 :       return &cache_.kStringFromSingleCodePointOperatorUTF32;
    1679             :   }
    1680           0 :   UNREACHABLE();
    1681             : }
    1682             : 
    1683             : #define SPECULATIVE_NUMBER_BINOP(Name)                                        \
    1684             :   const Operator* SimplifiedOperatorBuilder::Name(NumberOperationHint hint) { \
    1685             :     switch (hint) {                                                           \
    1686             :       case NumberOperationHint::kSignedSmall:                                 \
    1687             :         return &cache_.k##Name##SignedSmallOperator;                          \
    1688             :       case NumberOperationHint::kSignedSmallInputs:                           \
    1689             :         return &cache_.k##Name##SignedSmallInputsOperator;                    \
    1690             :       case NumberOperationHint::kSigned32:                                    \
    1691             :         return &cache_.k##Name##Signed32Operator;                             \
    1692             :       case NumberOperationHint::kNumber:                                      \
    1693             :         return &cache_.k##Name##NumberOperator;                               \
    1694             :       case NumberOperationHint::kNumberOrOddball:                             \
    1695             :         return &cache_.k##Name##NumberOrOddballOperator;                      \
    1696             :     }                                                                         \
    1697             :     UNREACHABLE();                                                            \
    1698             :     return nullptr;                                                           \
    1699             :   }
    1700      324597 : SPECULATIVE_NUMBER_BINOP_LIST(SPECULATIVE_NUMBER_BINOP)
    1701             : #undef SPECULATIVE_NUMBER_BINOP
    1702             : 
    1703             : #define ACCESS_OP_LIST(V)                                                \
    1704             :   V(LoadField, FieldAccess, Operator::kNoWrite, 1, 1, 1)                 \
    1705             :   V(StoreField, FieldAccess, Operator::kNoRead, 2, 1, 0)                 \
    1706             :   V(LoadElement, ElementAccess, Operator::kNoWrite, 2, 1, 1)             \
    1707             :   V(StoreElement, ElementAccess, Operator::kNoRead, 3, 1, 0)             \
    1708             :   V(LoadTypedElement, ExternalArrayType, Operator::kNoWrite, 4, 1, 1)    \
    1709             :   V(StoreTypedElement, ExternalArrayType, Operator::kNoRead, 5, 1, 0)    \
    1710             :   V(LoadDataViewElement, ExternalArrayType, Operator::kNoWrite, 5, 1, 1) \
    1711             :   V(StoreDataViewElement, ExternalArrayType, Operator::kNoRead, 6, 1, 0)
    1712             : 
    1713             : #define ACCESS(Name, Type, properties, value_input_count, control_input_count, \
    1714             :                output_count)                                                   \
    1715             :   const Operator* SimplifiedOperatorBuilder::Name(const Type& access) {        \
    1716             :     return new (zone())                                                        \
    1717             :         Operator1<Type>(IrOpcode::k##Name,                                     \
    1718             :                         Operator::kNoDeopt | Operator::kNoThrow | properties,  \
    1719             :                         #Name, value_input_count, 1, control_input_count,      \
    1720             :                         output_count, 1, 0, access);                           \
    1721             :   }
    1722    10944538 : ACCESS_OP_LIST(ACCESS)
    1723             : #undef ACCESS
    1724             : 
    1725       29794 : const Operator* SimplifiedOperatorBuilder::LoadMessage() {
    1726       29794 :   return &cache_.kLoadMessage;
    1727             : }
    1728             : 
    1729       29796 : const Operator* SimplifiedOperatorBuilder::StoreMessage() {
    1730       29796 :   return &cache_.kStoreMessage;
    1731             : }
    1732             : 
    1733         586 : const Operator* SimplifiedOperatorBuilder::LoadStackArgument() {
    1734         586 :   return &cache_.kLoadStackArgument;
    1735             : }
    1736             : 
    1737         341 : const Operator* SimplifiedOperatorBuilder::TransitionAndStoreElement(
    1738             :     Handle<Map> double_map, Handle<Map> fast_map) {
    1739             :   TransitionAndStoreElementParameters parameters(double_map, fast_map);
    1740             :   return new (zone()) Operator1<TransitionAndStoreElementParameters>(
    1741             :       IrOpcode::kTransitionAndStoreElement,
    1742             :       Operator::kNoDeopt | Operator::kNoThrow, "TransitionAndStoreElement", 3,
    1743         341 :       1, 1, 0, 1, 0, parameters);
    1744             : }
    1745             : 
    1746          70 : const Operator* SimplifiedOperatorBuilder::StoreSignedSmallElement() {
    1747             :   return new (zone()) Operator(IrOpcode::kStoreSignedSmallElement,
    1748         140 :                                Operator::kNoDeopt | Operator::kNoThrow,
    1749         140 :                                "StoreSignedSmallElement", 3, 1, 1, 0, 1, 0);
    1750             : }
    1751             : 
    1752          28 : const Operator* SimplifiedOperatorBuilder::TransitionAndStoreNumberElement(
    1753             :     Handle<Map> double_map) {
    1754             :   TransitionAndStoreNumberElementParameters parameters(double_map);
    1755             :   return new (zone()) Operator1<TransitionAndStoreNumberElementParameters>(
    1756             :       IrOpcode::kTransitionAndStoreNumberElement,
    1757             :       Operator::kNoDeopt | Operator::kNoThrow,
    1758          28 :       "TransitionAndStoreNumberElement", 3, 1, 1, 0, 1, 0, parameters);
    1759             : }
    1760             : 
    1761          25 : const Operator* SimplifiedOperatorBuilder::TransitionAndStoreNonNumberElement(
    1762             :     Handle<Map> fast_map, Type value_type) {
    1763             :   TransitionAndStoreNonNumberElementParameters parameters(fast_map, value_type);
    1764             :   return new (zone()) Operator1<TransitionAndStoreNonNumberElementParameters>(
    1765             :       IrOpcode::kTransitionAndStoreNonNumberElement,
    1766             :       Operator::kNoDeopt | Operator::kNoThrow,
    1767          25 :       "TransitionAndStoreNonNumberElement", 3, 1, 1, 0, 1, 0, parameters);
    1768             : }
    1769             : 
    1770             : #undef PURE_OP_LIST
    1771             : #undef EFFECT_DEPENDENT_OP_LIST
    1772             : #undef SPECULATIVE_NUMBER_BINOP_LIST
    1773             : #undef CHECKED_WITH_FEEDBACK_OP_LIST
    1774             : #undef CHECKED_BOUNDS_OP_LIST
    1775             : #undef CHECKED_OP_LIST
    1776             : #undef ACCESS_OP_LIST
    1777             : 
    1778             : }  // namespace compiler
    1779             : }  // namespace internal
    1780      122036 : }  // namespace v8

Generated by: LCOV version 1.10