LCOV - code coverage report
Current view: top level - src/compiler - simplified-operator.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 152 287 53.0 %
Date: 2017-04-26 Functions: 379 829 45.7 %

          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             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : namespace compiler {
      15             : 
      16           0 : size_t hash_value(BaseTaggedness base_taggedness) {
      17           0 :   return static_cast<uint8_t>(base_taggedness);
      18             : }
      19             : 
      20      117852 : std::ostream& operator<<(std::ostream& os, BaseTaggedness base_taggedness) {
      21      117852 :   switch (base_taggedness) {
      22             :     case kUntaggedBase:
      23       71736 :       return os << "untagged base";
      24             :     case kTaggedBase:
      25       46116 :       return os << "tagged base";
      26             :   }
      27           0 :   UNREACHABLE();
      28             :   return os;
      29             : }
      30             : 
      31             : 
      32       60808 : MachineType BufferAccess::machine_type() const {
      33       60808 :   switch (external_array_type_) {
      34             :     case kExternalUint8Array:
      35             :     case kExternalUint8ClampedArray:
      36             :       return MachineType::Uint8();
      37             :     case kExternalInt8Array:
      38             :       return MachineType::Int8();
      39             :     case kExternalUint16Array:
      40             :       return MachineType::Uint16();
      41             :     case kExternalInt16Array:
      42             :       return MachineType::Int16();
      43             :     case kExternalUint32Array:
      44             :       return MachineType::Uint32();
      45             :     case kExternalInt32Array:
      46             :       return MachineType::Int32();
      47             :     case kExternalFloat32Array:
      48             :       return MachineType::Float32();
      49             :     case kExternalFloat64Array:
      50             :       return MachineType::Float64();
      51             :   }
      52           0 :   UNREACHABLE();
      53             :   return MachineType::None();
      54             : }
      55             : 
      56             : 
      57          56 : bool operator==(BufferAccess lhs, BufferAccess rhs) {
      58          56 :   return lhs.external_array_type() == rhs.external_array_type();
      59             : }
      60             : 
      61             : 
      62           0 : bool operator!=(BufferAccess lhs, BufferAccess rhs) { return !(lhs == rhs); }
      63             : 
      64             : 
      65           0 : size_t hash_value(BufferAccess access) {
      66           0 :   return base::hash<ExternalArrayType>()(access.external_array_type());
      67             : }
      68             : 
      69             : 
      70           0 : std::ostream& operator<<(std::ostream& os, BufferAccess access) {
      71           0 :   switch (access.external_array_type()) {
      72             : #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
      73             :   case kExternal##Type##Array:                          \
      74             :     return os << #Type;
      75           0 :     TYPED_ARRAYS(TYPED_ARRAY_CASE)
      76             : #undef TYPED_ARRAY_CASE
      77             :   }
      78           0 :   UNREACHABLE();
      79             :   return os;
      80             : }
      81             : 
      82             : 
      83       50418 : BufferAccess const BufferAccessOf(const Operator* op) {
      84             :   DCHECK(op->opcode() == IrOpcode::kLoadBuffer ||
      85             :          op->opcode() == IrOpcode::kStoreBuffer);
      86       50418 :   return OpParameter<BufferAccess>(op);
      87             : }
      88             : 
      89             : 
      90         127 : bool operator==(FieldAccess const& lhs, FieldAccess const& rhs) {
      91             :   // On purpose we don't include the write barrier kind here, as this method is
      92             :   // really only relevant for eliminating loads and they don't care about the
      93             :   // write barrier mode.
      94         254 :   return lhs.base_is_tagged == rhs.base_is_tagged && lhs.offset == rhs.offset &&
      95         254 :          lhs.map.address() == rhs.map.address() &&
      96         127 :          lhs.machine_type == rhs.machine_type;
      97             : }
      98             : 
      99             : 
     100           0 : bool operator!=(FieldAccess const& lhs, FieldAccess const& rhs) {
     101           0 :   return !(lhs == rhs);
     102             : }
     103             : 
     104             : 
     105           0 : size_t hash_value(FieldAccess const& access) {
     106             :   // On purpose we don't include the write barrier kind here, as this method is
     107             :   // really only relevant for eliminating loads and they don't care about the
     108             :   // write barrier mode.
     109             :   return base::hash_combine(access.base_is_tagged, access.offset,
     110           0 :                             access.machine_type);
     111             : }
     112             : 
     113             : 
     114           0 : std::ostream& operator<<(std::ostream& os, FieldAccess const& access) {
     115           0 :   os << "[" << access.base_is_tagged << ", " << access.offset << ", ";
     116             : #ifdef OBJECT_PRINT
     117             :   Handle<Name> name;
     118             :   if (access.name.ToHandle(&name)) {
     119             :     name->Print(os);
     120             :     os << ", ";
     121             :   }
     122             :   Handle<Map> map;
     123             :   if (access.map.ToHandle(&map)) {
     124             :     os << Brief(*map) << ", ";
     125             :   }
     126             : #endif
     127           0 :   access.type->PrintTo(os);
     128           0 :   os << ", " << access.machine_type << ", " << access.write_barrier_kind << "]";
     129           0 :   return os;
     130             : }
     131             : 
     132             : template <>
     133           0 : void Operator1<FieldAccess>::PrintParameter(std::ostream& os,
     134             :                                             PrintVerbosity verbose) const {
     135           0 :   if (verbose == PrintVerbosity::kVerbose) {
     136           0 :     os << parameter();
     137             :   } else {
     138           0 :     os << "[+" << parameter().offset << "]";
     139             :   }
     140           0 : }
     141             : 
     142          70 : bool operator==(ElementAccess const& lhs, ElementAccess const& rhs) {
     143             :   // On purpose we don't include the write barrier kind here, as this method is
     144             :   // really only relevant for eliminating loads and they don't care about the
     145             :   // write barrier mode.
     146          70 :   return lhs.base_is_tagged == rhs.base_is_tagged &&
     147         140 :          lhs.header_size == rhs.header_size &&
     148          70 :          lhs.machine_type == rhs.machine_type;
     149             : }
     150             : 
     151             : 
     152           0 : bool operator!=(ElementAccess const& lhs, ElementAccess const& rhs) {
     153           0 :   return !(lhs == rhs);
     154             : }
     155             : 
     156             : 
     157           0 : size_t hash_value(ElementAccess const& access) {
     158             :   // On purpose we don't include the write barrier kind here, as this method is
     159             :   // really only relevant for eliminating loads and they don't care about the
     160             :   // write barrier mode.
     161             :   return base::hash_combine(access.base_is_tagged, access.header_size,
     162           0 :                             access.machine_type);
     163             : }
     164             : 
     165             : 
     166      117852 : std::ostream& operator<<(std::ostream& os, ElementAccess const& access) {
     167      117852 :   os << access.base_is_tagged << ", " << access.header_size << ", ";
     168      117852 :   access.type->PrintTo(os);
     169      117852 :   os << ", " << access.machine_type << ", " << access.write_barrier_kind;
     170      117852 :   return os;
     171             : }
     172             : 
     173             : 
     174    13334603 : const FieldAccess& FieldAccessOf(const Operator* op) {
     175             :   DCHECK_NOT_NULL(op);
     176             :   DCHECK(op->opcode() == IrOpcode::kLoadField ||
     177             :          op->opcode() == IrOpcode::kStoreField);
     178    13334603 :   return OpParameter<FieldAccess>(op);
     179             : }
     180             : 
     181             : 
     182     1204866 : const ElementAccess& ElementAccessOf(const Operator* op) {
     183             :   DCHECK_NOT_NULL(op);
     184             :   DCHECK(op->opcode() == IrOpcode::kLoadElement ||
     185             :          op->opcode() == IrOpcode::kStoreElement);
     186     1204866 :   return OpParameter<ElementAccess>(op);
     187             : }
     188             : 
     189       32970 : ExternalArrayType ExternalArrayTypeOf(const Operator* op) {
     190             :   DCHECK(op->opcode() == IrOpcode::kLoadTypedElement ||
     191             :          op->opcode() == IrOpcode::kStoreTypedElement);
     192       32970 :   return OpParameter<ExternalArrayType>(op);
     193             : }
     194             : 
     195           0 : size_t hash_value(CheckFloat64HoleMode mode) {
     196           0 :   return static_cast<size_t>(mode);
     197             : }
     198             : 
     199           0 : std::ostream& operator<<(std::ostream& os, CheckFloat64HoleMode mode) {
     200           0 :   switch (mode) {
     201             :     case CheckFloat64HoleMode::kAllowReturnHole:
     202           0 :       return os << "allow-return-hole";
     203             :     case CheckFloat64HoleMode::kNeverReturnHole:
     204           0 :       return os << "never-return-hole";
     205             :   }
     206           0 :   UNREACHABLE();
     207             :   return os;
     208             : }
     209             : 
     210        2298 : CheckFloat64HoleMode CheckFloat64HoleModeOf(const Operator* op) {
     211             :   DCHECK_EQ(IrOpcode::kCheckFloat64Hole, op->opcode());
     212        2298 :   return OpParameter<CheckFloat64HoleMode>(op);
     213             : }
     214             : 
     215       62029 : CheckForMinusZeroMode CheckMinusZeroModeOf(const Operator* op) {
     216             :   DCHECK(op->opcode() == IrOpcode::kChangeFloat64ToTagged ||
     217             :          op->opcode() == IrOpcode::kCheckedInt32Mul ||
     218             :          op->opcode() == IrOpcode::kCheckedFloat64ToInt32 ||
     219             :          op->opcode() == IrOpcode::kCheckedTaggedToInt32);
     220       62029 :   return OpParameter<CheckForMinusZeroMode>(op);
     221             : }
     222             : 
     223       85713 : size_t hash_value(CheckForMinusZeroMode mode) {
     224       85713 :   return static_cast<size_t>(mode);
     225             : }
     226             : 
     227          10 : std::ostream& operator<<(std::ostream& os, CheckForMinusZeroMode mode) {
     228          10 :   switch (mode) {
     229             :     case CheckForMinusZeroMode::kCheckForMinusZero:
     230           5 :       return os << "check-for-minus-zero";
     231             :     case CheckForMinusZeroMode::kDontCheckForMinusZero:
     232           5 :       return os << "dont-check-for-minus-zero";
     233             :   }
     234           0 :   UNREACHABLE();
     235             :   return os;
     236             : }
     237             : 
     238           0 : std::ostream& operator<<(std::ostream& os, CheckMapsFlags flags) {
     239             :   bool empty = true;
     240           0 :   if (flags & CheckMapsFlag::kTryMigrateInstance) {
     241           0 :     os << "TryMigrateInstance";
     242             :     empty = false;
     243             :   }
     244           0 :   if (empty) os << "None";
     245           0 :   return os;
     246             : }
     247             : 
     248           0 : bool operator==(CheckMapsParameters const& lhs,
     249             :                 CheckMapsParameters const& rhs) {
     250           0 :   return lhs.flags() == rhs.flags() && lhs.maps() == rhs.maps();
     251             : }
     252             : 
     253           0 : bool operator!=(CheckMapsParameters const& lhs,
     254             :                 CheckMapsParameters const& rhs) {
     255           0 :   return !(lhs == rhs);
     256             : }
     257             : 
     258           0 : size_t hash_value(CheckMapsParameters const& p) {
     259           0 :   return base::hash_combine(p.flags(), p.maps());
     260             : }
     261             : 
     262           0 : std::ostream& operator<<(std::ostream& os, CheckMapsParameters const& p) {
     263             :   ZoneHandleSet<Map> const& maps = p.maps();
     264           0 :   os << p.flags();
     265           0 :   for (size_t i = 0; i < maps.size(); ++i) {
     266           0 :     os << ", " << Brief(*maps[i]);
     267             :   }
     268           0 :   return os;
     269             : }
     270             : 
     271      212156 : CheckMapsParameters const& CheckMapsParametersOf(Operator const* op) {
     272             :   DCHECK_EQ(IrOpcode::kCheckMaps, op->opcode());
     273      212156 :   return OpParameter<CheckMapsParameters>(op);
     274             : }
     275             : 
     276           0 : size_t hash_value(CheckTaggedInputMode mode) {
     277           0 :   return static_cast<size_t>(mode);
     278             : }
     279             : 
     280           0 : std::ostream& operator<<(std::ostream& os, CheckTaggedInputMode mode) {
     281           0 :   switch (mode) {
     282             :     case CheckTaggedInputMode::kNumber:
     283           0 :       return os << "Number";
     284             :     case CheckTaggedInputMode::kNumberOrOddball:
     285           0 :       return os << "NumberOrOddball";
     286             :   }
     287           0 :   UNREACHABLE();
     288             :   return os;
     289             : }
     290             : 
     291       20767 : CheckTaggedInputMode CheckTaggedInputModeOf(const Operator* op) {
     292             :   DCHECK_EQ(IrOpcode::kCheckedTaggedToFloat64, op->opcode());
     293       20767 :   return OpParameter<CheckTaggedInputMode>(op);
     294             : }
     295             : 
     296           0 : std::ostream& operator<<(std::ostream& os, GrowFastElementsFlags flags) {
     297             :   bool empty = true;
     298           0 :   if (flags & GrowFastElementsFlag::kArrayObject) {
     299           0 :     os << "ArrayObject";
     300             :     empty = false;
     301             :   }
     302           0 :   if (flags & GrowFastElementsFlag::kDoubleElements) {
     303           0 :     if (!empty) os << "|";
     304           0 :     os << "DoubleElements";
     305             :     empty = false;
     306             :   }
     307           0 :   if (flags & GrowFastElementsFlag::kHoleyElements) {
     308           0 :     if (!empty) os << "|";
     309           0 :     os << "HoleyElements";
     310             :     empty = false;
     311             :   }
     312           0 :   if (empty) os << "None";
     313           0 :   return os;
     314             : }
     315             : 
     316        6505 : GrowFastElementsFlags GrowFastElementsFlagsOf(const Operator* op) {
     317             :   DCHECK_EQ(IrOpcode::kMaybeGrowFastElements, op->opcode());
     318        6505 :   return OpParameter<GrowFastElementsFlags>(op);
     319             : }
     320             : 
     321           0 : bool operator==(ElementsTransition const& lhs, ElementsTransition const& rhs) {
     322           0 :   return lhs.mode() == rhs.mode() &&
     323           0 :          lhs.source().address() == rhs.source().address() &&
     324           0 :          lhs.target().address() == rhs.target().address();
     325             : }
     326             : 
     327           0 : bool operator!=(ElementsTransition const& lhs, ElementsTransition const& rhs) {
     328           0 :   return !(lhs == rhs);
     329             : }
     330             : 
     331           0 : size_t hash_value(ElementsTransition transition) {
     332           0 :   return base::hash_combine(static_cast<uint8_t>(transition.mode()),
     333             :                             transition.source().address(),
     334           0 :                             transition.target().address());
     335             : }
     336             : 
     337           0 : std::ostream& operator<<(std::ostream& os, ElementsTransition transition) {
     338           0 :   switch (transition.mode()) {
     339             :     case ElementsTransition::kFastTransition:
     340           0 :       return os << "fast-transition from " << Brief(*transition.source())
     341           0 :                 << " to " << Brief(*transition.target());
     342             :     case ElementsTransition::kSlowTransition:
     343           0 :       return os << "slow-transition from " << Brief(*transition.source())
     344           0 :                 << " to " << Brief(*transition.target());
     345             :   }
     346           0 :   UNREACHABLE();
     347             :   return os;
     348             : }
     349             : 
     350        1286 : ElementsTransition const& ElementsTransitionOf(const Operator* op) {
     351             :   DCHECK_EQ(IrOpcode::kTransitionElementsKind, op->opcode());
     352        1286 :   return OpParameter<ElementsTransition>(op);
     353             : }
     354             : 
     355           0 : std::ostream& operator<<(std::ostream& os, NumberOperationHint hint) {
     356           0 :   switch (hint) {
     357             :     case NumberOperationHint::kSignedSmall:
     358           0 :       return os << "SignedSmall";
     359             :     case NumberOperationHint::kSigned32:
     360           0 :       return os << "Signed32";
     361             :     case NumberOperationHint::kNumber:
     362           0 :       return os << "Number";
     363             :     case NumberOperationHint::kNumberOrOddball:
     364           0 :       return os << "NumberOrOddball";
     365             :   }
     366           0 :   UNREACHABLE();
     367             :   return os;
     368             : }
     369             : 
     370           0 : size_t hash_value(NumberOperationHint hint) {
     371           0 :   return static_cast<uint8_t>(hint);
     372             : }
     373             : 
     374     1097592 : NumberOperationHint NumberOperationHintOf(const Operator* op) {
     375             :   DCHECK(op->opcode() == IrOpcode::kSpeculativeToNumber ||
     376             :          op->opcode() == IrOpcode::kSpeculativeNumberAdd ||
     377             :          op->opcode() == IrOpcode::kSpeculativeNumberSubtract ||
     378             :          op->opcode() == IrOpcode::kSpeculativeNumberMultiply ||
     379             :          op->opcode() == IrOpcode::kSpeculativeNumberDivide ||
     380             :          op->opcode() == IrOpcode::kSpeculativeNumberModulus ||
     381             :          op->opcode() == IrOpcode::kSpeculativeNumberShiftLeft ||
     382             :          op->opcode() == IrOpcode::kSpeculativeNumberShiftRight ||
     383             :          op->opcode() == IrOpcode::kSpeculativeNumberShiftRightLogical ||
     384             :          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseAnd ||
     385             :          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseOr ||
     386             :          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseXor ||
     387             :          op->opcode() == IrOpcode::kSpeculativeNumberEqual ||
     388             :          op->opcode() == IrOpcode::kSpeculativeNumberLessThan ||
     389             :          op->opcode() == IrOpcode::kSpeculativeNumberLessThanOrEqual);
     390     1097592 :   return OpParameter<NumberOperationHint>(op);
     391             : }
     392             : 
     393           0 : size_t hash_value(AllocateParameters info) {
     394           0 :   return base::hash_combine(info.type(), info.pretenure());
     395             : }
     396             : 
     397           0 : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
     398             :                                            AllocateParameters info) {
     399           0 :   info.type()->PrintTo(os);
     400           0 :   return os << ", " << info.pretenure();
     401             : }
     402             : 
     403           0 : bool operator==(AllocateParameters const& lhs, AllocateParameters const& rhs) {
     404           0 :   return lhs.pretenure() == rhs.pretenure() && lhs.type() == rhs.type();
     405             : }
     406             : 
     407           0 : bool operator!=(AllocateParameters const& lhs, AllocateParameters const& rhs) {
     408           0 :   return !(lhs == rhs);
     409             : }
     410             : 
     411      166162 : PretenureFlag PretenureFlagOf(const Operator* op) {
     412             :   DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
     413      166162 :   return OpParameter<AllocateParameters>(op).pretenure();
     414             : }
     415             : 
     416      112796 : Type* AllocateTypeOf(const Operator* op) {
     417             :   DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
     418      112796 :   return OpParameter<AllocateParameters>(op).type();
     419             : }
     420             : 
     421          57 : UnicodeEncoding UnicodeEncodingOf(const Operator* op) {
     422             :   DCHECK(op->opcode() == IrOpcode::kStringFromCodePoint);
     423          57 :   return OpParameter<UnicodeEncoding>(op);
     424             : }
     425             : 
     426             : #define PURE_OP_LIST(V)                                          \
     427             :   V(BooleanNot, Operator::kNoProperties, 1, 0)                   \
     428             :   V(NumberEqual, Operator::kCommutative, 2, 0)                   \
     429             :   V(NumberLessThan, Operator::kNoProperties, 2, 0)               \
     430             :   V(NumberLessThanOrEqual, Operator::kNoProperties, 2, 0)        \
     431             :   V(NumberAdd, Operator::kCommutative, 2, 0)                     \
     432             :   V(NumberSubtract, Operator::kNoProperties, 2, 0)               \
     433             :   V(NumberMultiply, Operator::kCommutative, 2, 0)                \
     434             :   V(NumberDivide, Operator::kNoProperties, 2, 0)                 \
     435             :   V(NumberModulus, Operator::kNoProperties, 2, 0)                \
     436             :   V(NumberBitwiseOr, Operator::kCommutative, 2, 0)               \
     437             :   V(NumberBitwiseXor, Operator::kCommutative, 2, 0)              \
     438             :   V(NumberBitwiseAnd, Operator::kCommutative, 2, 0)              \
     439             :   V(NumberShiftLeft, Operator::kNoProperties, 2, 0)              \
     440             :   V(NumberShiftRight, Operator::kNoProperties, 2, 0)             \
     441             :   V(NumberShiftRightLogical, Operator::kNoProperties, 2, 0)      \
     442             :   V(NumberImul, Operator::kCommutative, 2, 0)                    \
     443             :   V(NumberAbs, Operator::kNoProperties, 1, 0)                    \
     444             :   V(NumberClz32, Operator::kNoProperties, 1, 0)                  \
     445             :   V(NumberCeil, Operator::kNoProperties, 1, 0)                   \
     446             :   V(NumberFloor, Operator::kNoProperties, 1, 0)                  \
     447             :   V(NumberFround, Operator::kNoProperties, 1, 0)                 \
     448             :   V(NumberAcos, Operator::kNoProperties, 1, 0)                   \
     449             :   V(NumberAcosh, Operator::kNoProperties, 1, 0)                  \
     450             :   V(NumberAsin, Operator::kNoProperties, 1, 0)                   \
     451             :   V(NumberAsinh, Operator::kNoProperties, 1, 0)                  \
     452             :   V(NumberAtan, Operator::kNoProperties, 1, 0)                   \
     453             :   V(NumberAtan2, Operator::kNoProperties, 2, 0)                  \
     454             :   V(NumberAtanh, Operator::kNoProperties, 1, 0)                  \
     455             :   V(NumberCbrt, Operator::kNoProperties, 1, 0)                   \
     456             :   V(NumberCos, Operator::kNoProperties, 1, 0)                    \
     457             :   V(NumberCosh, Operator::kNoProperties, 1, 0)                   \
     458             :   V(NumberExp, Operator::kNoProperties, 1, 0)                    \
     459             :   V(NumberExpm1, Operator::kNoProperties, 1, 0)                  \
     460             :   V(NumberLog, Operator::kNoProperties, 1, 0)                    \
     461             :   V(NumberLog1p, Operator::kNoProperties, 1, 0)                  \
     462             :   V(NumberLog10, Operator::kNoProperties, 1, 0)                  \
     463             :   V(NumberLog2, Operator::kNoProperties, 1, 0)                   \
     464             :   V(NumberMax, Operator::kNoProperties, 2, 0)                    \
     465             :   V(NumberMin, Operator::kNoProperties, 2, 0)                    \
     466             :   V(NumberPow, Operator::kNoProperties, 2, 0)                    \
     467             :   V(NumberRound, Operator::kNoProperties, 1, 0)                  \
     468             :   V(NumberSign, Operator::kNoProperties, 1, 0)                   \
     469             :   V(NumberSin, Operator::kNoProperties, 1, 0)                    \
     470             :   V(NumberSinh, Operator::kNoProperties, 1, 0)                   \
     471             :   V(NumberSqrt, Operator::kNoProperties, 1, 0)                   \
     472             :   V(NumberTan, Operator::kNoProperties, 1, 0)                    \
     473             :   V(NumberTanh, Operator::kNoProperties, 1, 0)                   \
     474             :   V(NumberTrunc, Operator::kNoProperties, 1, 0)                  \
     475             :   V(NumberToBoolean, Operator::kNoProperties, 1, 0)              \
     476             :   V(NumberToInt32, Operator::kNoProperties, 1, 0)                \
     477             :   V(NumberToUint32, Operator::kNoProperties, 1, 0)               \
     478             :   V(NumberToUint8Clamped, Operator::kNoProperties, 1, 0)         \
     479             :   V(NumberSilenceNaN, Operator::kNoProperties, 1, 0)             \
     480             :   V(StringCharAt, Operator::kNoProperties, 2, 1)                 \
     481             :   V(StringCharCodeAt, Operator::kNoProperties, 2, 1)             \
     482             :   V(StringFromCharCode, Operator::kNoProperties, 1, 0)           \
     483             :   V(StringIndexOf, Operator::kNoProperties, 3, 0)                \
     484             :   V(PlainPrimitiveToNumber, Operator::kNoProperties, 1, 0)       \
     485             :   V(PlainPrimitiveToWord32, Operator::kNoProperties, 1, 0)       \
     486             :   V(PlainPrimitiveToFloat64, Operator::kNoProperties, 1, 0)      \
     487             :   V(ChangeTaggedSignedToInt32, Operator::kNoProperties, 1, 0)    \
     488             :   V(ChangeTaggedToInt32, Operator::kNoProperties, 1, 0)          \
     489             :   V(ChangeTaggedToUint32, Operator::kNoProperties, 1, 0)         \
     490             :   V(ChangeTaggedToFloat64, Operator::kNoProperties, 1, 0)        \
     491             :   V(ChangeTaggedToTaggedSigned, Operator::kNoProperties, 1, 0)   \
     492             :   V(ChangeFloat64ToTaggedPointer, Operator::kNoProperties, 1, 0) \
     493             :   V(ChangeInt31ToTaggedSigned, Operator::kNoProperties, 1, 0)    \
     494             :   V(ChangeInt32ToTagged, Operator::kNoProperties, 1, 0)          \
     495             :   V(ChangeUint32ToTagged, Operator::kNoProperties, 1, 0)         \
     496             :   V(ChangeTaggedToBit, Operator::kNoProperties, 1, 0)            \
     497             :   V(ChangeBitToTagged, Operator::kNoProperties, 1, 0)            \
     498             :   V(TruncateTaggedToBit, Operator::kNoProperties, 1, 0)          \
     499             :   V(TruncateTaggedPointerToBit, Operator::kNoProperties, 1, 0)   \
     500             :   V(TruncateTaggedToWord32, Operator::kNoProperties, 1, 0)       \
     501             :   V(TruncateTaggedToFloat64, Operator::kNoProperties, 1, 0)      \
     502             :   V(ObjectIsDetectableCallable, Operator::kNoProperties, 1, 0)   \
     503             :   V(ObjectIsNaN, Operator::kNoProperties, 1, 0)                  \
     504             :   V(ObjectIsNonCallable, Operator::kNoProperties, 1, 0)          \
     505             :   V(ObjectIsNumber, Operator::kNoProperties, 1, 0)               \
     506             :   V(ObjectIsReceiver, Operator::kNoProperties, 1, 0)             \
     507             :   V(ObjectIsSmi, Operator::kNoProperties, 1, 0)                  \
     508             :   V(ObjectIsString, Operator::kNoProperties, 1, 0)               \
     509             :   V(ObjectIsSymbol, Operator::kNoProperties, 1, 0)               \
     510             :   V(ObjectIsUndetectable, Operator::kNoProperties, 1, 0)         \
     511             :   V(ConvertTaggedHoleToUndefined, Operator::kNoProperties, 1, 0) \
     512             :   V(ReferenceEqual, Operator::kCommutative, 2, 0)                \
     513             :   V(StringEqual, Operator::kCommutative, 2, 0)                   \
     514             :   V(StringLessThan, Operator::kNoProperties, 2, 0)               \
     515             :   V(StringLessThanOrEqual, Operator::kNoProperties, 2, 0)
     516             : 
     517             : #define SPECULATIVE_NUMBER_BINOP_LIST(V)      \
     518             :   SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(V) \
     519             :   V(SpeculativeNumberEqual)                   \
     520             :   V(SpeculativeNumberLessThan)                \
     521             :   V(SpeculativeNumberLessThanOrEqual)
     522             : 
     523             : #define CHECKED_OP_LIST(V)              \
     524             :   V(CheckBounds, 2, 1)                  \
     525             :   V(CheckHeapObject, 1, 1)              \
     526             :   V(CheckIf, 1, 0)                      \
     527             :   V(CheckInternalizedString, 1, 1)      \
     528             :   V(CheckNumber, 1, 1)                  \
     529             :   V(CheckReceiver, 1, 1)                \
     530             :   V(CheckSmi, 1, 1)                     \
     531             :   V(CheckString, 1, 1)                  \
     532             :   V(CheckTaggedHole, 1, 1)              \
     533             :   V(CheckedInt32Add, 2, 1)              \
     534             :   V(CheckedInt32Sub, 2, 1)              \
     535             :   V(CheckedInt32Div, 2, 1)              \
     536             :   V(CheckedInt32Mod, 2, 1)              \
     537             :   V(CheckedUint32Div, 2, 1)             \
     538             :   V(CheckedUint32Mod, 2, 1)             \
     539             :   V(CheckedUint32ToInt32, 1, 1)         \
     540             :   V(CheckedUint32ToTaggedSigned, 1, 1)  \
     541             :   V(CheckedInt32ToTaggedSigned, 1, 1)   \
     542             :   V(CheckedTaggedSignedToInt32, 1, 1)   \
     543             :   V(CheckedTaggedToTaggedSigned, 1, 1)  \
     544             :   V(CheckedTaggedToTaggedPointer, 1, 1) \
     545             :   V(CheckedTruncateTaggedToWord32, 1, 1)
     546             : 
     547       21918 : struct SimplifiedOperatorGlobalCache final {
     548             : #define PURE(Name, properties, value_input_count, control_input_count)     \
     549             :   struct Name##Operator final : public Operator {                          \
     550             :     Name##Operator()                                                       \
     551             :         : Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name, \
     552             :                    value_input_count, 0, control_input_count, 1, 0, 0) {}  \
     553             :   };                                                                       \
     554             :   Name##Operator k##Name;
     555     1950702 :   PURE_OP_LIST(PURE)
     556             : #undef PURE
     557             : 
     558             : #define CHECKED(Name, value_input_count, value_output_count)             \
     559             :   struct Name##Operator final : public Operator {                        \
     560             :     Name##Operator()                                                     \
     561             :         : Operator(IrOpcode::k##Name,                                    \
     562             :                    Operator::kFoldable | Operator::kNoThrow, #Name,      \
     563             :                    value_input_count, 1, 1, value_output_count, 1, 0) {} \
     564             :   };                                                                     \
     565             :   Name##Operator k##Name;
     566      482196 :   CHECKED_OP_LIST(CHECKED)
     567             : #undef CHECKED
     568             : 
     569             :   template <UnicodeEncoding kEncoding>
     570           0 :   struct StringFromCodePointOperator final : public Operator1<UnicodeEncoding> {
     571       43836 :     StringFromCodePointOperator()
     572             :         : Operator1<UnicodeEncoding>(IrOpcode::kStringFromCodePoint,
     573             :                                      Operator::kPure, "StringFromCodePoint", 1,
     574       43836 :                                      0, 0, 1, 0, 0, kEncoding) {}
     575             :   };
     576             :   StringFromCodePointOperator<UnicodeEncoding::UTF16>
     577             :       kStringFromCodePointOperatorUTF16;
     578             :   StringFromCodePointOperator<UnicodeEncoding::UTF32>
     579             :       kStringFromCodePointOperatorUTF32;
     580             : 
     581           0 :   struct ArrayBufferWasNeuteredOperator final : public Operator {
     582       21918 :     ArrayBufferWasNeuteredOperator()
     583             :         : Operator(IrOpcode::kArrayBufferWasNeutered, Operator::kEliminatable,
     584       21918 :                    "ArrayBufferWasNeutered", 1, 1, 1, 1, 1, 0) {}
     585             :   };
     586             :   ArrayBufferWasNeuteredOperator kArrayBufferWasNeutered;
     587             : 
     588           0 :   struct ArgumentsFrameOperator final : public Operator {
     589       21918 :     ArgumentsFrameOperator()
     590             :         : Operator(IrOpcode::kArgumentsFrame, Operator::kPure, "ArgumentsFrame",
     591       21918 :                    0, 0, 0, 1, 0, 0) {}
     592             :   };
     593             :   ArgumentsFrameOperator kArgumentsFrame;
     594             : 
     595           0 :   struct NewUnmappedArgumentsElementsOperator final : public Operator {
     596       21918 :     NewUnmappedArgumentsElementsOperator()
     597             :         : Operator(IrOpcode::kNewUnmappedArgumentsElements,
     598             :                    Operator::kEliminatable, "NewUnmappedArgumentsElements", 2,
     599       21918 :                    1, 0, 1, 1, 0) {}
     600             :   };
     601             :   NewUnmappedArgumentsElementsOperator kNewUnmappedArgumentsElements;
     602             : 
     603             :   template <CheckForMinusZeroMode kMode>
     604           0 :   struct ChangeFloat64ToTaggedOperator final
     605             :       : public Operator1<CheckForMinusZeroMode> {
     606       43836 :     ChangeFloat64ToTaggedOperator()
     607             :         : Operator1<CheckForMinusZeroMode>(
     608             :               IrOpcode::kChangeFloat64ToTagged, Operator::kPure,
     609       43836 :               "ChangeFloat64ToTagged", 1, 0, 0, 1, 0, 0, kMode) {}
     610             :   };
     611             :   ChangeFloat64ToTaggedOperator<CheckForMinusZeroMode::kCheckForMinusZero>
     612             :       kChangeFloat64ToTaggedCheckForMinusZeroOperator;
     613             :   ChangeFloat64ToTaggedOperator<CheckForMinusZeroMode::kDontCheckForMinusZero>
     614             :       kChangeFloat64ToTaggedDontCheckForMinusZeroOperator;
     615             : 
     616             :   template <CheckForMinusZeroMode kMode>
     617           0 :   struct CheckedInt32MulOperator final
     618             :       : public Operator1<CheckForMinusZeroMode> {
     619       43836 :     CheckedInt32MulOperator()
     620             :         : Operator1<CheckForMinusZeroMode>(
     621             :               IrOpcode::kCheckedInt32Mul,
     622             :               Operator::kFoldable | Operator::kNoThrow, "CheckedInt32Mul", 2, 1,
     623       43836 :               1, 1, 1, 0, kMode) {}
     624             :   };
     625             :   CheckedInt32MulOperator<CheckForMinusZeroMode::kCheckForMinusZero>
     626             :       kCheckedInt32MulCheckForMinusZeroOperator;
     627             :   CheckedInt32MulOperator<CheckForMinusZeroMode::kDontCheckForMinusZero>
     628             :       kCheckedInt32MulDontCheckForMinusZeroOperator;
     629             : 
     630             :   template <CheckForMinusZeroMode kMode>
     631           0 :   struct CheckedFloat64ToInt32Operator final
     632             :       : public Operator1<CheckForMinusZeroMode> {
     633       43836 :     CheckedFloat64ToInt32Operator()
     634             :         : Operator1<CheckForMinusZeroMode>(
     635             :               IrOpcode::kCheckedFloat64ToInt32,
     636             :               Operator::kFoldable | Operator::kNoThrow, "CheckedFloat64ToInt32",
     637       43836 :               1, 1, 1, 1, 1, 0, kMode) {}
     638             :   };
     639             :   CheckedFloat64ToInt32Operator<CheckForMinusZeroMode::kCheckForMinusZero>
     640             :       kCheckedFloat64ToInt32CheckForMinusZeroOperator;
     641             :   CheckedFloat64ToInt32Operator<CheckForMinusZeroMode::kDontCheckForMinusZero>
     642             :       kCheckedFloat64ToInt32DontCheckForMinusZeroOperator;
     643             : 
     644             :   template <CheckForMinusZeroMode kMode>
     645           0 :   struct CheckedTaggedToInt32Operator final
     646             :       : public Operator1<CheckForMinusZeroMode> {
     647       43836 :     CheckedTaggedToInt32Operator()
     648             :         : Operator1<CheckForMinusZeroMode>(
     649             :               IrOpcode::kCheckedTaggedToInt32,
     650             :               Operator::kFoldable | Operator::kNoThrow, "CheckedTaggedToInt32",
     651       43836 :               1, 1, 1, 1, 1, 0, kMode) {}
     652             :   };
     653             :   CheckedTaggedToInt32Operator<CheckForMinusZeroMode::kCheckForMinusZero>
     654             :       kCheckedTaggedToInt32CheckForMinusZeroOperator;
     655             :   CheckedTaggedToInt32Operator<CheckForMinusZeroMode::kDontCheckForMinusZero>
     656             :       kCheckedTaggedToInt32DontCheckForMinusZeroOperator;
     657             : 
     658             :   template <CheckTaggedInputMode kMode>
     659           0 :   struct CheckedTaggedToFloat64Operator final
     660             :       : public Operator1<CheckTaggedInputMode> {
     661       43836 :     CheckedTaggedToFloat64Operator()
     662             :         : Operator1<CheckTaggedInputMode>(
     663             :               IrOpcode::kCheckedTaggedToFloat64,
     664             :               Operator::kFoldable | Operator::kNoThrow,
     665       43836 :               "CheckedTaggedToFloat64", 1, 1, 1, 1, 1, 0, kMode) {}
     666             :   };
     667             :   CheckedTaggedToFloat64Operator<CheckTaggedInputMode::kNumber>
     668             :       kCheckedTaggedToFloat64NumberOperator;
     669             :   CheckedTaggedToFloat64Operator<CheckTaggedInputMode::kNumberOrOddball>
     670             :       kCheckedTaggedToFloat64NumberOrOddballOperator;
     671             : 
     672             :   template <CheckFloat64HoleMode kMode>
     673           0 :   struct CheckFloat64HoleNaNOperator final
     674             :       : public Operator1<CheckFloat64HoleMode> {
     675       43836 :     CheckFloat64HoleNaNOperator()
     676             :         : Operator1<CheckFloat64HoleMode>(
     677             :               IrOpcode::kCheckFloat64Hole,
     678             :               Operator::kFoldable | Operator::kNoThrow, "CheckFloat64Hole", 1,
     679       43836 :               1, 1, 1, 1, 0, kMode) {}
     680             :   };
     681             :   CheckFloat64HoleNaNOperator<CheckFloat64HoleMode::kAllowReturnHole>
     682             :       kCheckFloat64HoleAllowReturnHoleOperator;
     683             :   CheckFloat64HoleNaNOperator<CheckFloat64HoleMode::kNeverReturnHole>
     684             :       kCheckFloat64HoleNeverReturnHoleOperator;
     685             : 
     686           0 :   struct EnsureWritableFastElementsOperator final : public Operator {
     687       21918 :     EnsureWritableFastElementsOperator()
     688             :         : Operator(                                     // --
     689             :               IrOpcode::kEnsureWritableFastElements,    // opcode
     690             :               Operator::kNoDeopt | Operator::kNoThrow,  // flags
     691             :               "EnsureWritableFastElements",             // name
     692       21918 :               2, 1, 1, 1, 1, 0) {}                      // counts
     693             :   };
     694             :   EnsureWritableFastElementsOperator kEnsureWritableFastElements;
     695             : 
     696             : #define SPECULATIVE_NUMBER_BINOP(Name)                                      \
     697             :   template <NumberOperationHint kHint>                                      \
     698             :   struct Name##Operator final : public Operator1<NumberOperationHint> {     \
     699             :     Name##Operator()                                                        \
     700             :         : Operator1<NumberOperationHint>(                                   \
     701             :               IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow,  \
     702             :               #Name, 2, 1, 1, 1, 1, 0, kHint) {}                            \
     703             :   };                                                                        \
     704             :   Name##Operator<NumberOperationHint::kSignedSmall>                         \
     705             :       k##Name##SignedSmallOperator;                                         \
     706             :   Name##Operator<NumberOperationHint::kSigned32> k##Name##Signed32Operator; \
     707             :   Name##Operator<NumberOperationHint::kNumber> k##Name##NumberOperator;     \
     708             :   Name##Operator<NumberOperationHint::kNumberOrOddball>                     \
     709             :       k##Name##NumberOrOddballOperator;
     710     2454816 :   SPECULATIVE_NUMBER_BINOP_LIST(SPECULATIVE_NUMBER_BINOP)
     711             : #undef SPECULATIVE_NUMBER_BINOP
     712             : 
     713             :   template <NumberOperationHint kHint>
     714           0 :   struct SpeculativeToNumberOperator final
     715             :       : public Operator1<NumberOperationHint> {
     716       87672 :     SpeculativeToNumberOperator()
     717             :         : Operator1<NumberOperationHint>(
     718             :               IrOpcode::kSpeculativeToNumber,            // opcode
     719             :               Operator::kFoldable | Operator::kNoThrow,  // flags
     720             :               "SpeculativeToNumber",                     // name
     721             :               1, 1, 1, 1, 1, 0,                          // counts
     722       87672 :               kHint) {}                                  // parameter
     723             :   };
     724             :   SpeculativeToNumberOperator<NumberOperationHint::kSignedSmall>
     725             :       kSpeculativeToNumberSignedSmallOperator;
     726             :   SpeculativeToNumberOperator<NumberOperationHint::kSigned32>
     727             :       kSpeculativeToNumberSigned32Operator;
     728             :   SpeculativeToNumberOperator<NumberOperationHint::kNumber>
     729             :       kSpeculativeToNumberNumberOperator;
     730             :   SpeculativeToNumberOperator<NumberOperationHint::kNumberOrOddball>
     731             :       kSpeculativeToNumberNumberOrOddballOperator;
     732             : 
     733             : #define BUFFER_ACCESS(Type, type, TYPE, ctype, size)                          \
     734             :   struct LoadBuffer##Type##Operator final : public Operator1<BufferAccess> {  \
     735             :     LoadBuffer##Type##Operator()                                              \
     736             :         : Operator1<BufferAccess>(                                            \
     737             :               IrOpcode::kLoadBuffer,                                          \
     738             :               Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite,   \
     739             :               "LoadBuffer", 3, 1, 1, 1, 1, 0,                                 \
     740             :               BufferAccess(kExternal##Type##Array)) {}                        \
     741             :   };                                                                          \
     742             :   struct StoreBuffer##Type##Operator final : public Operator1<BufferAccess> { \
     743             :     StoreBuffer##Type##Operator()                                             \
     744             :         : Operator1<BufferAccess>(                                            \
     745             :               IrOpcode::kStoreBuffer,                                         \
     746             :               Operator::kNoDeopt | Operator::kNoRead | Operator::kNoThrow,    \
     747             :               "StoreBuffer", 4, 1, 1, 0, 1, 0,                                \
     748             :               BufferAccess(kExternal##Type##Array)) {}                        \
     749             :   };                                                                          \
     750             :   LoadBuffer##Type##Operator kLoadBuffer##Type;                               \
     751             :   StoreBuffer##Type##Operator kStoreBuffer##Type;
     752      789048 :   TYPED_ARRAYS(BUFFER_ACCESS)
     753             : #undef BUFFER_ACCESS
     754             : };
     755             : 
     756             : 
     757             : static base::LazyInstance<SimplifiedOperatorGlobalCache>::type kCache =
     758             :     LAZY_INSTANCE_INITIALIZER;
     759             : 
     760             : 
     761      601572 : SimplifiedOperatorBuilder::SimplifiedOperatorBuilder(Zone* zone)
     762      601573 :     : cache_(kCache.Get()), zone_(zone) {}
     763             : 
     764             : #define GET_FROM_CACHE(Name, ...) \
     765             :   const Operator* SimplifiedOperatorBuilder::Name() { return &cache_.k##Name; }
     766     1359593 : PURE_OP_LIST(GET_FROM_CACHE)
     767      469970 : CHECKED_OP_LIST(GET_FROM_CACHE)
     768         271 : GET_FROM_CACHE(ArrayBufferWasNeutered)
     769        4410 : GET_FROM_CACHE(ArgumentsFrame)
     770        4410 : GET_FROM_CACHE(NewUnmappedArgumentsElements)
     771             : #undef GET_FROM_CACHE
     772             : 
     773       79209 : const Operator* SimplifiedOperatorBuilder::ChangeFloat64ToTagged(
     774             :     CheckForMinusZeroMode mode) {
     775       79209 :   switch (mode) {
     776             :     case CheckForMinusZeroMode::kCheckForMinusZero:
     777       30580 :       return &cache_.kChangeFloat64ToTaggedCheckForMinusZeroOperator;
     778             :     case CheckForMinusZeroMode::kDontCheckForMinusZero:
     779       48629 :       return &cache_.kChangeFloat64ToTaggedDontCheckForMinusZeroOperator;
     780             :   }
     781           0 :   UNREACHABLE();
     782             :   return nullptr;
     783             : }
     784             : 
     785        7143 : const Operator* SimplifiedOperatorBuilder::CheckedInt32Mul(
     786             :     CheckForMinusZeroMode mode) {
     787        7143 :   switch (mode) {
     788             :     case CheckForMinusZeroMode::kCheckForMinusZero:
     789        4315 :       return &cache_.kCheckedInt32MulCheckForMinusZeroOperator;
     790             :     case CheckForMinusZeroMode::kDontCheckForMinusZero:
     791        2828 :       return &cache_.kCheckedInt32MulDontCheckForMinusZeroOperator;
     792             :   }
     793           0 :   UNREACHABLE();
     794             :   return nullptr;
     795             : }
     796             : 
     797        6960 : const Operator* SimplifiedOperatorBuilder::CheckedFloat64ToInt32(
     798             :     CheckForMinusZeroMode mode) {
     799        6960 :   switch (mode) {
     800             :     case CheckForMinusZeroMode::kCheckForMinusZero:
     801        2363 :       return &cache_.kCheckedFloat64ToInt32CheckForMinusZeroOperator;
     802             :     case CheckForMinusZeroMode::kDontCheckForMinusZero:
     803        4597 :       return &cache_.kCheckedFloat64ToInt32DontCheckForMinusZeroOperator;
     804             :   }
     805           0 :   UNREACHABLE();
     806             :   return nullptr;
     807             : }
     808             : 
     809        3072 : const Operator* SimplifiedOperatorBuilder::CheckedTaggedToInt32(
     810             :     CheckForMinusZeroMode mode) {
     811        3072 :   switch (mode) {
     812             :     case CheckForMinusZeroMode::kCheckForMinusZero:
     813           0 :       return &cache_.kCheckedTaggedToInt32CheckForMinusZeroOperator;
     814             :     case CheckForMinusZeroMode::kDontCheckForMinusZero:
     815        3072 :       return &cache_.kCheckedTaggedToInt32DontCheckForMinusZeroOperator;
     816             :   }
     817           0 :   UNREACHABLE();
     818             :   return nullptr;
     819             : }
     820             : 
     821       22572 : const Operator* SimplifiedOperatorBuilder::CheckedTaggedToFloat64(
     822             :     CheckTaggedInputMode mode) {
     823       22572 :   switch (mode) {
     824             :     case CheckTaggedInputMode::kNumber:
     825        2282 :       return &cache_.kCheckedTaggedToFloat64NumberOperator;
     826             :     case CheckTaggedInputMode::kNumberOrOddball:
     827       20290 :       return &cache_.kCheckedTaggedToFloat64NumberOrOddballOperator;
     828             :   }
     829           0 :   UNREACHABLE();
     830             :   return nullptr;
     831             : }
     832             : 
     833       68681 : const Operator* SimplifiedOperatorBuilder::CheckMaps(CheckMapsFlags flags,
     834       68681 :                                                      ZoneHandleSet<Map> maps) {
     835             :   CheckMapsParameters const parameters(flags, maps);
     836             :   return new (zone()) Operator1<CheckMapsParameters>(  // --
     837             :       IrOpcode::kCheckMaps,                            // opcode
     838             :       Operator::kNoThrow | Operator::kNoWrite,         // flags
     839             :       "CheckMaps",                                     // name
     840             :       1, 1, 1, 0, 1, 0,                                // counts
     841       68681 :       parameters);                                     // parameter
     842             : }
     843             : 
     844         772 : const Operator* SimplifiedOperatorBuilder::CheckFloat64Hole(
     845             :     CheckFloat64HoleMode mode) {
     846         772 :   switch (mode) {
     847             :     case CheckFloat64HoleMode::kAllowReturnHole:
     848         710 :       return &cache_.kCheckFloat64HoleAllowReturnHoleOperator;
     849             :     case CheckFloat64HoleMode::kNeverReturnHole:
     850          62 :       return &cache_.kCheckFloat64HoleNeverReturnHoleOperator;
     851             :   }
     852           0 :   UNREACHABLE();
     853             :   return nullptr;
     854             : }
     855             : 
     856        2219 : const Operator* SimplifiedOperatorBuilder::SpeculativeToNumber(
     857             :     NumberOperationHint hint) {
     858        2219 :   switch (hint) {
     859             :     case NumberOperationHint::kSignedSmall:
     860        2107 :       return &cache_.kSpeculativeToNumberSignedSmallOperator;
     861             :     case NumberOperationHint::kSigned32:
     862           0 :       return &cache_.kSpeculativeToNumberSigned32Operator;
     863             :     case NumberOperationHint::kNumber:
     864           0 :       return &cache_.kSpeculativeToNumberNumberOperator;
     865             :     case NumberOperationHint::kNumberOrOddball:
     866         112 :       return &cache_.kSpeculativeToNumberNumberOrOddballOperator;
     867             :   }
     868           0 :   UNREACHABLE();
     869             :   return nullptr;
     870             : }
     871             : 
     872         172 : const Operator* SimplifiedOperatorBuilder::EnsureWritableFastElements() {
     873         172 :   return &cache_.kEnsureWritableFastElements;
     874             : }
     875             : 
     876        1398 : const Operator* SimplifiedOperatorBuilder::MaybeGrowFastElements(
     877        1398 :     GrowFastElementsFlags flags) {
     878             :   return new (zone()) Operator1<GrowFastElementsFlags>(  // --
     879             :       IrOpcode::kMaybeGrowFastElements,                  // opcode
     880             :       Operator::kNoThrow,                                // flags
     881             :       "MaybeGrowFastElements",                           // name
     882             :       4, 1, 1, 1, 1, 0,                                  // counts
     883        2796 :       flags);                                            // parameter
     884             : }
     885             : 
     886         433 : const Operator* SimplifiedOperatorBuilder::TransitionElementsKind(
     887         433 :     ElementsTransition transition) {
     888             :   return new (zone()) Operator1<ElementsTransition>(  // --
     889             :       IrOpcode::kTransitionElementsKind,              // opcode
     890             :       Operator::kNoDeopt | Operator::kNoThrow,        // flags
     891             :       "TransitionElementsKind",                       // name
     892             :       1, 1, 1, 0, 1, 0,                               // counts
     893         866 :       transition);                                    // parameter
     894             : }
     895             : 
     896             : namespace {
     897             : 
     898             : struct ArgumentsLengthParameters {
     899             :   int formal_parameter_count;
     900             :   bool is_rest_length;
     901             : };
     902             : 
     903             : bool operator==(ArgumentsLengthParameters first,
     904             :                 ArgumentsLengthParameters second) {
     905           0 :   return first.formal_parameter_count == second.formal_parameter_count &&
     906             :          first.is_rest_length == second.is_rest_length;
     907             : }
     908             : 
     909        8551 : size_t hash_value(ArgumentsLengthParameters param) {
     910        8551 :   return base::hash_combine(param.formal_parameter_count, param.is_rest_length);
     911             : }
     912             : 
     913           0 : std::ostream& operator<<(std::ostream& os, ArgumentsLengthParameters param) {
     914           0 :   return os << param.formal_parameter_count << ", "
     915           0 :             << (param.is_rest_length ? "rest length" : "not rest length");
     916             : }
     917             : 
     918             : }  // namespace
     919             : 
     920        4410 : const Operator* SimplifiedOperatorBuilder::ArgumentsLength(
     921        4410 :     int formal_parameter_count, bool is_rest_length) {
     922             :   return new (zone()) Operator1<ArgumentsLengthParameters>(  // --
     923             :       IrOpcode::kArgumentsLength,                            // opcode
     924             :       Operator::kPure,                                       // flags
     925             :       "ArgumentsLength",                                     // name
     926             :       1, 0, 0, 1, 0, 0,                                      // counts
     927             :       ArgumentsLengthParameters{formal_parameter_count,
     928        8820 :                                 is_rest_length});  // parameter
     929             : }
     930             : 
     931        3998 : int FormalParameterCountOf(const Operator* op) {
     932             :   DCHECK(op->opcode() == IrOpcode::kArgumentsLength);
     933        3998 :   return OpParameter<ArgumentsLengthParameters>(op).formal_parameter_count;
     934             : }
     935             : 
     936        5830 : bool IsRestLengthOf(const Operator* op) {
     937             :   DCHECK(op->opcode() == IrOpcode::kArgumentsLength);
     938        5830 :   return OpParameter<ArgumentsLengthParameters>(op).is_rest_length;
     939             : }
     940             : 
     941      160255 : const Operator* SimplifiedOperatorBuilder::Allocate(Type* type,
     942      160255 :                                                     PretenureFlag pretenure) {
     943             :   return new (zone()) Operator1<AllocateParameters>(
     944             :       IrOpcode::kAllocate,
     945             :       Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite, "Allocate",
     946      160256 :       1, 1, 1, 1, 1, 0, AllocateParameters(type, pretenure));
     947             : }
     948             : 
     949             : 
     950        5829 : const Operator* SimplifiedOperatorBuilder::LoadBuffer(BufferAccess access) {
     951        5829 :   switch (access.external_array_type()) {
     952             : #define LOAD_BUFFER(Type, type, TYPE, ctype, size) \
     953             :   case kExternal##Type##Array:                     \
     954             :     return &cache_.kLoadBuffer##Type;
     955         285 :     TYPED_ARRAYS(LOAD_BUFFER)
     956             : #undef LOAD_BUFFER
     957             :   }
     958           0 :   UNREACHABLE();
     959             :   return nullptr;
     960             : }
     961             : 
     962             : 
     963        4018 : const Operator* SimplifiedOperatorBuilder::StoreBuffer(BufferAccess access) {
     964        4018 :   switch (access.external_array_type()) {
     965             : #define STORE_BUFFER(Type, type, TYPE, ctype, size) \
     966             :   case kExternal##Type##Array:                      \
     967             :     return &cache_.kStoreBuffer##Type;
     968          63 :     TYPED_ARRAYS(STORE_BUFFER)
     969             : #undef STORE_BUFFER
     970             :   }
     971           0 :   UNREACHABLE();
     972             :   return nullptr;
     973             : }
     974             : 
     975          45 : const Operator* SimplifiedOperatorBuilder::StringFromCodePoint(
     976             :     UnicodeEncoding encoding) {
     977          45 :   switch (encoding) {
     978             :     case UnicodeEncoding::UTF16:
     979          45 :       return &cache_.kStringFromCodePointOperatorUTF16;
     980             :     case UnicodeEncoding::UTF32:
     981           0 :       return &cache_.kStringFromCodePointOperatorUTF32;
     982             :   }
     983           0 :   UNREACHABLE();
     984             :   return nullptr;
     985             : }
     986             : 
     987             : #define SPECULATIVE_NUMBER_BINOP(Name)                                        \
     988             :   const Operator* SimplifiedOperatorBuilder::Name(NumberOperationHint hint) { \
     989             :     switch (hint) {                                                           \
     990             :       case NumberOperationHint::kSignedSmall:                                 \
     991             :         return &cache_.k##Name##SignedSmallOperator;                          \
     992             :       case NumberOperationHint::kSigned32:                                    \
     993             :         return &cache_.k##Name##Signed32Operator;                             \
     994             :       case NumberOperationHint::kNumber:                                      \
     995             :         return &cache_.k##Name##NumberOperator;                               \
     996             :       case NumberOperationHint::kNumberOrOddball:                             \
     997             :         return &cache_.k##Name##NumberOrOddballOperator;                      \
     998             :     }                                                                         \
     999             :     UNREACHABLE();                                                            \
    1000             :     return nullptr;                                                           \
    1001             :   }
    1002      328591 : SPECULATIVE_NUMBER_BINOP_LIST(SPECULATIVE_NUMBER_BINOP)
    1003             : #undef SPECULATIVE_NUMBER_BINOP
    1004             : 
    1005             : #define ACCESS_OP_LIST(V)                                             \
    1006             :   V(LoadField, FieldAccess, Operator::kNoWrite, 1, 1, 1)              \
    1007             :   V(StoreField, FieldAccess, Operator::kNoRead, 2, 1, 0)              \
    1008             :   V(LoadElement, ElementAccess, Operator::kNoWrite, 2, 1, 1)          \
    1009             :   V(StoreElement, ElementAccess, Operator::kNoRead, 3, 1, 0)          \
    1010             :   V(LoadTypedElement, ExternalArrayType, Operator::kNoWrite, 4, 1, 1) \
    1011             :   V(StoreTypedElement, ExternalArrayType, Operator::kNoRead, 5, 1, 0)
    1012             : 
    1013             : #define ACCESS(Name, Type, properties, value_input_count, control_input_count, \
    1014             :                output_count)                                                   \
    1015             :   const Operator* SimplifiedOperatorBuilder::Name(const Type& access) {        \
    1016             :     return new (zone())                                                        \
    1017             :         Operator1<Type>(IrOpcode::k##Name,                                     \
    1018             :                         Operator::kNoDeopt | Operator::kNoThrow | properties,  \
    1019             :                         #Name, value_input_count, 1, control_input_count,      \
    1020             :                         output_count, 1, 0, access);                           \
    1021             :   }
    1022     7026386 : ACCESS_OP_LIST(ACCESS)
    1023             : #undef ACCESS
    1024             : 
    1025             : }  // namespace compiler
    1026             : }  // namespace internal
    1027             : }  // namespace v8

Generated by: LCOV version 1.10