[turbofan] Introduce a SpeculativeToNumber operator.

src/compiler/simplified-operator.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/simplified-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/types.h"
@@ skipping 353 matching lines @@
   }
   UNREACHABLE();
   return os;
 }
 
 size_t hash_value(NumberOperationHint hint) {
   return static_cast<uint8_t>(hint);
 }
 
 NumberOperationHint NumberOperationHintOf(const Operator* op) {
-  DCHECK(op->opcode() == IrOpcode::kSpeculativeNumberAdd ||
+  DCHECK(op->opcode() == IrOpcode::kSpeculativeToNumber ||
+         op->opcode() == IrOpcode::kSpeculativeNumberAdd ||
          op->opcode() == IrOpcode::kSpeculativeNumberSubtract ||
          op->opcode() == IrOpcode::kSpeculativeNumberMultiply ||
          op->opcode() == IrOpcode::kSpeculativeNumberDivide ||
          op->opcode() == IrOpcode::kSpeculativeNumberModulus ||
          op->opcode() == IrOpcode::kSpeculativeNumberShiftLeft ||
          op->opcode() == IrOpcode::kSpeculativeNumberShiftRight ||
          op->opcode() == IrOpcode::kSpeculativeNumberShiftRightLogical ||
          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseAnd ||
          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseOr ||
          op->opcode() == IrOpcode::kSpeculativeNumberBitwiseXor ||
@@ skipping 292 matching lines @@
   };                                                                        \
   Name##Operator<NumberOperationHint::kSignedSmall>                         \
       k##Name##SignedSmallOperator;                                         \
   Name##Operator<NumberOperationHint::kSigned32> k##Name##Signed32Operator; \
   Name##Operator<NumberOperationHint::kNumber> k##Name##NumberOperator;     \
   Name##Operator<NumberOperationHint::kNumberOrOddball>                     \
       k##Name##NumberOrOddballOperator;
   SPECULATIVE_NUMBER_BINOP_LIST(SPECULATIVE_NUMBER_BINOP)
 #undef SPECULATIVE_NUMBER_BINOP
 
+  template <NumberOperationHint kHint>
+  struct SpeculativeToNumberOperator final
+      : public Operator1<NumberOperationHint> {
+    SpeculativeToNumberOperator()
+        : Operator1<NumberOperationHint>(
+              IrOpcode::kSpeculativeToNumber,            // opcode
+              Operator::kFoldable | Operator::kNoThrow,  // flags
+              "SpeculativeToNumber",                     // name
+              1, 1, 1, 1, 1, 0,                          // counts
+              kHint) {}                                  // parameter
+  };
+  SpeculativeToNumberOperator<NumberOperationHint::kSignedSmall>
+      kSpeculativeToNumberSignedSmallOperator;
+  SpeculativeToNumberOperator<NumberOperationHint::kSigned32>
+      kSpeculativeToNumberSigned32Operator;
+  SpeculativeToNumberOperator<NumberOperationHint::kNumber>
+      kSpeculativeToNumberNumberOperator;
+  SpeculativeToNumberOperator<NumberOperationHint::kNumberOrOddball>
+      kSpeculativeToNumberNumberOrOddballOperator;
+
 #define BUFFER_ACCESS(Type, type, TYPE, ctype, size)                          \
   struct LoadBuffer##Type##Operator final : public Operator1<BufferAccess> {  \
     LoadBuffer##Type##Operator()                                              \
         : Operator1<BufferAccess>(                                            \
               IrOpcode::kLoadBuffer,                                          \
               Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite,   \
               "LoadBuffer", 3, 1, 1, 1, 1, 0,                                 \
               BufferAccess(kExternal##Type##Array)) {}                        \
   };                                                                          \
   struct StoreBuffer##Type##Operator final : public Operator1<BufferAccess> { \
@@ skipping 91 matching lines @@
   switch (mode) {
     case CheckFloat64HoleMode::kAllowReturnHole:
       return &cache_.kCheckFloat64HoleAllowReturnHoleOperator;
     case CheckFloat64HoleMode::kNeverReturnHole:
       return &cache_.kCheckFloat64HoleNeverReturnHoleOperator;
   }
   UNREACHABLE();
   return nullptr;
 }
 
+const Operator* SimplifiedOperatorBuilder::SpeculativeToNumber(
+    NumberOperationHint hint) {
+  switch (hint) {
+    case NumberOperationHint::kSignedSmall:
+      return &cache_.kSpeculativeToNumberSignedSmallOperator;
+    case NumberOperationHint::kSigned32:
+      return &cache_.kSpeculativeToNumberSigned32Operator;
+    case NumberOperationHint::kNumber:
+      return &cache_.kSpeculativeToNumberNumberOperator;
+    case NumberOperationHint::kNumberOrOddball:
+      return &cache_.kSpeculativeToNumberNumberOrOddballOperator;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
+
 const Operator* SimplifiedOperatorBuilder::EnsureWritableFastElements() {
   return &cache_.kEnsureWritableFastElements;
 }
 
 const Operator* SimplifiedOperatorBuilder::MaybeGrowFastElements(
     GrowFastElementsFlags flags) {
   return new (zone()) Operator1<GrowFastElementsFlags>(  // --
       IrOpcode::kMaybeGrowFastElements,                  // opcode
       Operator::kNoThrow,                                // flags
       "MaybeGrowFastElements",                           // name
@@ skipping 139 matching lines @@
                         Operator::kNoDeopt | Operator::kNoThrow | properties,  \
                         #Name, value_input_count, 1, control_input_count,      \
                         output_count, 1, 0, access);                           \
   }
 ACCESS_OP_LIST(ACCESS)
 #undef ACCESS
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8