[turbofan] Also consume number type feedback for abstract equality.

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/types.h"
@@ skipping 231 matching lines @@
   }
   UNREACHABLE();
   return os;
 }
 
 CheckTaggedHoleMode CheckTaggedHoleModeOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kCheckTaggedHole, op->opcode());
   return OpParameter<CheckTaggedHoleMode>(op);
 }
 
+size_t hash_value(CheckTaggedInputMode mode) {
+  return static_cast<size_t>(mode);
+}
+
+std::ostream& operator<<(std::ostream& os, CheckTaggedInputMode mode) {
+  switch (mode) {
+    case CheckTaggedInputMode::kNumber:
+      return os << "Number";
+    case CheckTaggedInputMode::kNumberOrOddball:
+      return os << "NumberOrOddball";
+  }
+  UNREACHABLE();
+  return os;
+}
+
+CheckTaggedInputMode CheckTaggedInputModeOf(const Operator* op) {
+  DCHECK_EQ(IrOpcode::kCheckedTaggedToFloat64, op->opcode());
+  return OpParameter<CheckTaggedInputMode>(op);
+}
+
 std::ostream& operator<<(std::ostream& os, GrowFastElementsFlags flags) {
   bool empty = true;
   if (flags & GrowFastElementsFlag::kArrayObject) {
     os << "ArrayObject";
     empty = false;
   }
   if (flags & GrowFastElementsFlag::kDoubleElements) {
     if (!empty) os << "|";
     os << "DoubleElements";
     empty = false;
@@ skipping 31 matching lines @@
   DCHECK_EQ(IrOpcode::kTransitionElementsKind, op->opcode());
   return OpParameter<ElementsTransition>(op);
 }
 
 std::ostream& operator<<(std::ostream& os, NumberOperationHint hint) {
   switch (hint) {
     case NumberOperationHint::kSignedSmall:
       return os << "SignedSmall";
     case NumberOperationHint::kSigned32:
       return os << "Signed32";
+    case NumberOperationHint::kNumber:
+      return os << "Number";
     case NumberOperationHint::kNumberOrOddball:
       return os << "NumberOrOddball";
   }
   UNREACHABLE();
   return os;
 }
 
 size_t hash_value(NumberOperationHint hint) {
   return static_cast<uint8_t>(hint);
 }
@@ skipping 109 matching lines @@
   V(CheckTaggedPointer, 1, 1)         \
   V(CheckTaggedSigned, 1, 1)          \
   V(CheckedInt32Add, 2, 1)            \
   V(CheckedInt32Sub, 2, 1)            \
   V(CheckedInt32Div, 2, 1)            \
   V(CheckedInt32Mod, 2, 1)            \
   V(CheckedUint32Div, 2, 1)           \
   V(CheckedUint32Mod, 2, 1)           \
   V(CheckedUint32ToInt32, 1, 1)       \
   V(CheckedTaggedSignedToInt32, 1, 1) \
-  V(CheckedTaggedToFloat64, 1, 1)     \
   V(CheckedTruncateTaggedToWord32, 1, 1)
 
 struct SimplifiedOperatorGlobalCache final {
 #define PURE(Name, properties, value_input_count, control_input_count)     \
   struct Name##Operator final : public Operator {                          \
     Name##Operator()                                                       \
         : Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name, \
                    value_input_count, 0, control_input_count, 1, 0, 0) {}  \
   };                                                                       \
   Name##Operator k##Name;
@@ skipping 46 matching lines @@
         : Operator1<CheckForMinusZeroMode>(
               IrOpcode::kCheckedTaggedToInt32,
               Operator::kFoldable | Operator::kNoThrow, "CheckedTaggedToInt32",
               1, 1, 1, 1, 1, 0, kMode) {}
   };
   CheckedTaggedToInt32Operator<CheckForMinusZeroMode::kCheckForMinusZero>
       kCheckedTaggedToInt32CheckForMinusZeroOperator;
   CheckedTaggedToInt32Operator<CheckForMinusZeroMode::kDontCheckForMinusZero>
       kCheckedTaggedToInt32DontCheckForMinusZeroOperator;
 
+  template <CheckTaggedInputMode kMode>
+  struct CheckedTaggedToFloat64Operator final
+      : public Operator1<CheckTaggedInputMode> {
+    CheckedTaggedToFloat64Operator()
+        : Operator1<CheckTaggedInputMode>(
+              IrOpcode::kCheckedTaggedToFloat64,
+              Operator::kFoldable | Operator::kNoThrow,
+              "CheckedTaggedToFloat64", 1, 1, 1, 1, 1, 0, kMode) {}
+  };
+  CheckedTaggedToFloat64Operator<CheckTaggedInputMode::kNumber>
+      kCheckedTaggedToFloat64NumberOperator;
+  CheckedTaggedToFloat64Operator<CheckTaggedInputMode::kNumberOrOddball>
+      kCheckedTaggedToFloat64NumberOrOddballOperator;
+
   template <CheckFloat64HoleMode kMode>
   struct CheckFloat64HoleNaNOperator final
       : public Operator1<CheckFloat64HoleMode> {
     CheckFloat64HoleNaNOperator()
         : Operator1<CheckFloat64HoleMode>(
               IrOpcode::kCheckFloat64Hole,
               Operator::kFoldable | Operator::kNoThrow, "CheckFloat64Hole", 1,
               1, 1, 1, 1, 0, kMode) {}
   };
   CheckFloat64HoleNaNOperator<CheckFloat64HoleMode::kAllowReturnHole>
@@ skipping 39 matching lines @@
   template <NumberOperationHint kHint>                                      \
   struct Name##Operator final : public Operator1<NumberOperationHint> {     \
     Name##Operator()                                                        \
         : Operator1<NumberOperationHint>(                                   \
               IrOpcode::k##Name, Operator::kFoldable | Operator::kNoThrow,  \
               #Name, 2, 1, 1, 1, 1, 0, kHint) {}                            \
   };                                                                        \
   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
 
 #define BUFFER_ACCESS(Type, type, TYPE, ctype, size)                          \
   struct LoadBuffer##Type##Operator final : public Operator1<BufferAccess> {  \
     LoadBuffer##Type##Operator()                                              \
         : Operator1<BufferAccess>(                                            \
               IrOpcode::kLoadBuffer,                                          \
@@ skipping 58 matching lines @@
   switch (mode) {
     case CheckForMinusZeroMode::kCheckForMinusZero:
       return &cache_.kCheckedTaggedToInt32CheckForMinusZeroOperator;
     case CheckForMinusZeroMode::kDontCheckForMinusZero:
       return &cache_.kCheckedTaggedToInt32DontCheckForMinusZeroOperator;
   }
   UNREACHABLE();
   return nullptr;
 }
 
+const Operator* SimplifiedOperatorBuilder::CheckedTaggedToFloat64(
+    CheckTaggedInputMode mode) {
+  switch (mode) {
+    case CheckTaggedInputMode::kNumber:
+      return &cache_.kCheckedTaggedToFloat64NumberOperator;
+    case CheckTaggedInputMode::kNumberOrOddball:
+      return &cache_.kCheckedTaggedToFloat64NumberOrOddballOperator;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
+
 const Operator* SimplifiedOperatorBuilder::CheckMaps(int map_input_count) {
   // TODO(bmeurer): Cache the most important versions of this operator.
   DCHECK_LT(0, map_input_count);
   int const value_input_count = 1 + map_input_count;
   return new (zone()) Operator1<int>(           // --
       IrOpcode::kCheckMaps,                     // opcode
       Operator::kNoThrow | Operator::kNoWrite,  // flags
       "CheckMaps",                              // name
       value_input_count, 1, 1, 0, 1, 0,         // counts
       map_input_count);                         // parameter
@@ skipping 90 matching lines @@
   return nullptr;
 }
 
 #define SPECULATIVE_NUMBER_BINOP(Name)                                        \
   const Operator* SimplifiedOperatorBuilder::Name(NumberOperationHint hint) { \
     switch (hint) {                                                           \
       case NumberOperationHint::kSignedSmall:                                 \
         return &cache_.k##Name##SignedSmallOperator;                          \
       case NumberOperationHint::kSigned32:                                    \
         return &cache_.k##Name##Signed32Operator;                             \
+      case NumberOperationHint::kNumber:                                      \
+        return &cache_.k##Name##NumberOperator;                               \
       case NumberOperationHint::kNumberOrOddball:                             \
         return &cache_.k##Name##NumberOrOddballOperator;                      \
     }                                                                         \
     UNREACHABLE();                                                            \
     return nullptr;                                                           \
   }
 SPECULATIVE_NUMBER_BINOP_LIST(SPECULATIVE_NUMBER_BINOP)
 #undef SPECULATIVE_NUMBER_BINOP
 
 #define ACCESS_OP_LIST(V)                                             \
@@ skipping 12 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