[turbofan] Introduce a SpeculativeToNumber operator.

src/compiler/js-type-hint-lowering.cc

 // Copyright 2017 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/js-type-hint-lowering.h"
 
 #include "src/compiler/js-graph.h"
 #include "src/compiler/operator-properties.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/feedback-vector.h"
 #include "src/type-hints.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+namespace {
+
+bool BinaryOperationHintToNumberOperationHint(
+    BinaryOperationHint binop_hint, NumberOperationHint* number_hint) {
+  switch (binop_hint) {
+    case BinaryOperationHint::kSignedSmall:
+      *number_hint = NumberOperationHint::kSignedSmall;
+      return true;
+    case BinaryOperationHint::kSigned32:
+      *number_hint = NumberOperationHint::kSigned32;
+      return true;
+    case BinaryOperationHint::kNumberOrOddball:
+      *number_hint = NumberOperationHint::kNumberOrOddball;
+      return true;
+    case BinaryOperationHint::kAny:
+    case BinaryOperationHint::kNone:
+    case BinaryOperationHint::kString:
+      break;
+  }
+  return false;
+}
+
+}  // namespace
+
 class JSSpeculativeBinopBuilder final {
  public:
   JSSpeculativeBinopBuilder(const JSTypeHintLowering* lowering,
                             const Operator* op, Node* left, Node* right,
                             Node* effect, Node* control, FeedbackSlot slot)
       : lowering_(lowering),
         op_(op),
         left_(left),
         right_(right),
         effect_(effect),
         control_(control),
         slot_(slot) {}
 
   BinaryOperationHint GetBinaryOperationHint() {
     DCHECK_EQ(FeedbackSlotKind::kBinaryOp, feedback_vector()->GetKind(slot_));
     BinaryOpICNexus nexus(feedback_vector(), slot_);
     return nexus.GetBinaryOperationFeedback();
   }
 
   CompareOperationHint GetCompareOperationHint() {
     DCHECK_EQ(FeedbackSlotKind::kCompareOp, feedback_vector()->GetKind(slot_));
     CompareICNexus nexus(feedback_vector(), slot_);
     return nexus.GetCompareOperationFeedback();
   }
 
   bool GetBinaryNumberOperationHint(NumberOperationHint* hint) {
-    switch (GetBinaryOperationHint()) {
-      case BinaryOperationHint::kSignedSmall:
-        *hint = NumberOperationHint::kSignedSmall;
-        return true;
-      case BinaryOperationHint::kSigned32:
-        *hint = NumberOperationHint::kSigned32;
-        return true;
-      case BinaryOperationHint::kNumberOrOddball:
-        *hint = NumberOperationHint::kNumberOrOddball;
-        return true;
-      case BinaryOperationHint::kAny:
-      case BinaryOperationHint::kNone:
-      case BinaryOperationHint::kString:
-        break;
-    }
-    return false;
+    return BinaryOperationHintToNumberOperationHint(GetBinaryOperationHint(),
+                                                    hint);
   }
 
   bool GetCompareNumberOperationHint(NumberOperationHint* hint) {
     switch (GetCompareOperationHint()) {
       case CompareOperationHint::kSignedSmall:
         *hint = NumberOperationHint::kSignedSmall;
         return true;
       case CompareOperationHint::kNumber:
         *hint = NumberOperationHint::kNumber;
         return true;
@@ skipping 152 matching lines @@
       }
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
   return Reduction();
 }
 
+Reduction JSTypeHintLowering::ReduceToNumberOperation(Node* input, Node* effect,
+                                                      Node* control,
+                                                      FeedbackSlot slot) const {
+  DCHECK(!slot.IsInvalid());
+  BinaryOpICNexus nexus(feedback_vector(), slot);
+  NumberOperationHint hint;
+  if (BinaryOperationHintToNumberOperationHint(
+          nexus.GetBinaryOperationFeedback(), &hint)) {
+    Node* node = jsgraph()->graph()->NewNode(
+        jsgraph()->simplified()->SpeculativeToNumber(hint), input, effect,
+        control);
+    return Reduction(node);
+  }
+  return Reduction();
+}
+
 Reduction JSTypeHintLowering::ReduceLoadNamedOperation(
     const Operator* op, Node* obj, Node* effect, Node* control,
     FeedbackSlot slot) const {
   DCHECK_EQ(IrOpcode::kJSLoadNamed, op->opcode());
   DCHECK(!slot.IsInvalid());
   LoadICNexus nexus(feedback_vector(), slot);
   if (Node* node = TryBuildSoftDeopt(
           nexus, effect, control,
           DeoptimizeReason::kInsufficientTypeFeedbackForGenericNamedAccess)) {
     return Reduction(node);
@@ skipping 54 matching lines @@
     Node* frame_state = NodeProperties::FindFrameStateBefore(deoptimize);
     deoptimize->ReplaceInput(0, frame_state);
     return deoptimize;
   }
   return nullptr;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8