LCOV - code coverage report
Current view: top level - src/compiler - simplified-operator.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 306 533 57.4 %
Date: 2019-02-19 Functions: 556 1227 45.3 %

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

Generated by: LCOV version 1.10