[turbofan] Simplify BinaryOperationHints and CompareOperationHints.

src/ic/ic-state.h

 // 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.
 
 #ifndef V8_IC_STATE_H_
 #define V8_IC_STATE_H_
 
 #include "src/macro-assembler.h"
 
 namespace v8 {
@@ skipping 110 matching lines @@
   Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
 
   Type* GetLeftType() const { return KindToType(left_kind_); }
   Type* GetRightType() const { return KindToType(right_kind_); }
   Type* GetResultType() const;
 
   void Update(Handle<Object> left, Handle<Object> right, Handle<Object> result);
 
   Isolate* isolate() const { return isolate_; }
 
+  enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
+  Kind kind() const {
+    return KindGeneralize(KindGeneralize(left_kind_, right_kind_),
+                          result_kind_);
+  }
+
  private:
   friend std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s);
 
-  enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
-
   Kind UpdateKind(Handle<Object> object, Kind kind) const;
 
   static const char* KindToString(Kind kind);
   static Type* KindToType(Kind kind);
   static bool KindMaybeSmi(Kind kind) {
     return (kind >= SMI && kind <= NUMBER) || kind == GENERIC;
   }
+  static bool KindLessGeneralThan(Kind kind1, Kind kind2) {
+    if (kind1 == NONE) return true;
+    if (kind1 == kind2) return true;
+    if (kind2 == GENERIC) return true;
+    if (kind2 == STRING) return false;
+    return kind1 <= kind2;
+  }
+  static Kind KindGeneralize(Kind kind1, Kind kind2) {
+    if (KindLessGeneralThan(kind1, kind2)) return kind2;
+    if (KindLessGeneralThan(kind2, kind1)) return kind1;
+    return GENERIC;
+  }
 
   // We truncate the last bit of the token.
   STATIC_ASSERT(LAST_TOKEN - FIRST_TOKEN < (1 << 4));
   class OpField : public BitField<int, 0, 4> {};
   class ResultKindField : public BitField<Kind, 4, 3> {};
   class LeftKindField : public BitField<Kind, 7, 3> {};
   // When fixed right arg is set, we don't need to store the right kind.
   // Thus the two fields can overlap.
   class HasFixedRightArgField : public BitField<bool, 10, 1> {};
   class FixedRightArgValueField : public BitField<int, 11, 4> {};
@@ skipping 97 matching lines @@
                                                << LanguageModeState::kShift;
 
  private:
   const ExtraICState state_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_IC_STATE_H_