[turbofan] Type feedback for numeric comparisons.

src/compiler/type-hints.h

 // Copyright 2015 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.
 
 #ifndef V8_COMPILER_TYPE_HINTS_H_
 #define V8_COMPILER_TYPE_HINTS_H_
 
 #include "src/base/flags.h"
 #include "src/utils.h"
 
@@ skipping 46 matching lines @@
   typedef BitField<Hint, 0, 3> LeftField;
   typedef BitField<Hint, 3, 3> RightField;
   typedef BitField<Hint, 6, 3> ResultField;
 
   uint32_t bit_field_;
 };
 
 std::ostream& operator<<(std::ostream&, BinaryOperationHints::Hint);
 std::ostream& operator<<(std::ostream&, BinaryOperationHints);
 
+// Type hints for an binary operation.
+class CompareOperationHints final {
+ public:
+  enum Hint {
+    kNone,
+    kBoolean,
+    kSignedSmall,
+    kNumber,
+    kString,
+    kInternalizedString,
+    kUniqueName,
+    kReceiver,
+    kAny
+  };
+
+  CompareOperationHints() : CompareOperationHints(kNone, kNone, kNone) {}
+  CompareOperationHints(Hint left, Hint right, Hint combined)
+      : bit_field_(LeftField::encode(left) | RightField::encode(right) |
+                   CombinedField::encode(combined)) {}
+
+  static CompareOperationHints Any() {
+    return CompareOperationHints(kAny, kAny, kAny);
+  }
+
+  Hint left() const { return LeftField::decode(bit_field_); }
+  Hint right() const { return RightField::decode(bit_field_); }
+  Hint combined() const { return CombinedField::decode(bit_field_); }
+
+  bool operator==(CompareOperationHints const& that) const {
+    return this->bit_field_ == that.bit_field_;
+  }
+  bool operator!=(CompareOperationHints const& that) const {
+    return !(*this == that);
+  }
+
+  friend size_t hash_value(CompareOperationHints const& hints) {
+    return hints.bit_field_;
+  }
+
+ private:
+  typedef BitField<Hint, 0, 4> LeftField;
+  typedef BitField<Hint, 4, 4> RightField;
+  typedef BitField<Hint, 8, 4> CombinedField;
+
+  uint32_t bit_field_;
+};
+
+std::ostream& operator<<(std::ostream&, CompareOperationHints::Hint);
+std::ostream& operator<<(std::ostream&, CompareOperationHints);
 
 // Type hints for the ToBoolean type conversion.
 enum class ToBooleanHint : uint16_t {
   kNone = 0u,
   kUndefined = 1u << 0,
   kBoolean = 1u << 1,
   kNull = 1u << 2,
   kSmallInteger = 1u << 3,
   kReceiver = 1u << 4,
   kString = 1u << 5,
@@ skipping 10 matching lines @@
 
 std::ostream& operator<<(std::ostream&, ToBooleanHints);
 
 DEFINE_OPERATORS_FOR_FLAGS(ToBooleanHints)
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_TYPE_HINTS_H_