[turbofan] Introduce a SpeculativeToNumber operator.

src/compiler/operation-typer.cc

 // Copyright 2016 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/operation-typer.h"
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/type-cache.h"
 #include "src/compiler/types.h"
 #include "src/factory.h"
@@ skipping 950 matching lines @@
   return type;
 }
 
 Type* OperationTyper::NumberPow(Type* lhs, Type* rhs) {
   DCHECK(lhs->Is(Type::Number()));
   DCHECK(rhs->Is(Type::Number()));
   // TODO(turbofan): We should be able to do better here.
   return Type::Number();
 }
 
-#define SPECULATIVE_NUMBER_BINOP(Name)                                     \
-  Type* OperationTyper::Speculative##Name(Type* lhs, Type* rhs) {          \
-    lhs = ToNumber(Type::Intersect(lhs, Type::NumberOrOddball(), zone())); \
-    rhs = ToNumber(Type::Intersect(rhs, Type::NumberOrOddball(), zone())); \
-    return Name(lhs, rhs);                                                 \
+#define SPECULATIVE_NUMBER_BINOP(Name)                            \
+  Type* OperationTyper::Speculative##Name(Type* lhs, Type* rhs) { \
+    lhs = SpeculativeToNumber(lhs);                               \
+    rhs = SpeculativeToNumber(rhs);                               \
+    return Name(lhs, rhs);                                        \
   }
 SPECULATIVE_NUMBER_BINOP(NumberAdd)
 SPECULATIVE_NUMBER_BINOP(NumberSubtract)
 SPECULATIVE_NUMBER_BINOP(NumberMultiply)
 SPECULATIVE_NUMBER_BINOP(NumberDivide)
 SPECULATIVE_NUMBER_BINOP(NumberModulus)
 SPECULATIVE_NUMBER_BINOP(NumberBitwiseOr)
 SPECULATIVE_NUMBER_BINOP(NumberBitwiseAnd)
 SPECULATIVE_NUMBER_BINOP(NumberBitwiseXor)
 SPECULATIVE_NUMBER_BINOP(NumberShiftLeft)
 SPECULATIVE_NUMBER_BINOP(NumberShiftRight)
 SPECULATIVE_NUMBER_BINOP(NumberShiftRightLogical)
 #undef SPECULATIVE_NUMBER_BINOP
 
+Type* OperationTyper::SpeculativeToNumber(Type* type) {
+  return ToNumber(Type::Intersect(type, Type::NumberOrOddball(), zone()));
+}
+
 Type* OperationTyper::ToPrimitive(Type* type) {
   if (type->Is(Type::Primitive()) && !type->Maybe(Type::Receiver())) {
     return type;
   }
   return Type::Primitive();
 }
 
 Type* OperationTyper::Invert(Type* type) {
   DCHECK(type->Is(Type::Boolean()));
   DCHECK(type->IsInhabited());
@@ skipping 22 matching lines @@
   return singleton_true();
 }
 
 Type* OperationTyper::TypeTypeGuard(const Operator* sigma_op, Type* input) {
   return Type::Intersect(input, TypeGuardTypeOf(sigma_op), zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8