Revert of [base] Define CHECK comparison for signed vs. unsigned

src/base/logging.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_BASE_LOGGING_H_
 #define V8_BASE_LOGGING_H_
 
 #include <cstring>
 #include <sstream>
 #include <string>
@@ skipping 97 matching lines @@
 DEFINE_MAKE_CHECK_OP_STRING(int)
 DEFINE_MAKE_CHECK_OP_STRING(long)       // NOLINT(runtime/int)
 DEFINE_MAKE_CHECK_OP_STRING(long long)  // NOLINT(runtime/int)
 DEFINE_MAKE_CHECK_OP_STRING(unsigned int)
 DEFINE_MAKE_CHECK_OP_STRING(unsigned long)       // NOLINT(runtime/int)
 DEFINE_MAKE_CHECK_OP_STRING(unsigned long long)  // NOLINT(runtime/int)
 DEFINE_MAKE_CHECK_OP_STRING(char const*)
 DEFINE_MAKE_CHECK_OP_STRING(void const*)
 #undef DEFINE_MAKE_CHECK_OP_STRING
 
-// is_signed_vs_unsigned::value is true if both types are integral, Lhs is
-// signed, and Rhs is unsigned. False in all other cases.
-template <typename Lhs, typename Rhs>
-struct is_signed_vs_unsigned {
-  enum : bool {
-    value = std::is_integral<Lhs>::value && std::is_integral<Rhs>::value &&
-            std::is_signed<Lhs>::value && std::is_unsigned<Rhs>::value
-  };
-};
-// Same thing, other way around: Lhs is unsigned, Rhs signed.
-template <typename Lhs, typename Rhs>
-struct is_unsigned_vs_signed : public is_signed_vs_unsigned<Rhs, Lhs> {};
-
-// Specialize the compare functions for signed vs. unsigned comparisons.
-// std::enable_if ensures that this template is only instantiable if both Lhs
-// and Rhs are integral types, and their signedness does not match.
-#define MAKE_UNSIGNED(Type, value) \
-  static_cast<typename std::make_unsigned<Type>::type>(value)
-#define DEFINE_SIGNED_MISMATCH_COMP(CHECK, NAME, IMPL)                  \
-  template <typename Lhs, typename Rhs>                                 \
-  V8_INLINE typename std::enable_if<CHECK<Lhs, Rhs>::value, bool>::type \
-      Cmp##NAME##Impl(Lhs const& lhs, Rhs const& rhs) {                 \
-    return IMPL;                                                        \
-  }
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, EQ,
-                            lhs >= 0 && MAKE_UNSIGNED(Lhs, lhs) == rhs)
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, LT,
-                            lhs < 0 || MAKE_UNSIGNED(Lhs, lhs) < rhs)
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, LE,
-                            lhs <= 0 || MAKE_UNSIGNED(Lhs, lhs) <= rhs)
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, NE, !CmpEQImpl(lhs, rhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, GT, !CmpLEImpl(lhs, rhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, GE, !CmpLTImpl(lhs, rhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, EQ, CmpEQImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, NE, CmpNEImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, LT, CmpGTImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, LE, CmpGEImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, GT, CmpLTImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, GE, CmpLEImpl(rhs, lhs))
-#undef MAKE_UNSIGNED
-#undef DEFINE_SIGNED_MISMATCH_COMP
-
 // Helper functions for CHECK_OP macro.
 // The (float, float) and (double, double) instantiations are explicitly
-// externalized to ensure proper 32/64-bit comparisons on x86.
-// The Cmp##NAME##Impl function is only instantiable if one of the two types is
-// not integral or their signedness matches (i.e. whenever no specialization is
-// required, see above). Otherwise it is disabled by the enable_if construct,
-// and the compiler will pick a specialization from above.
+// externialized to ensure proper 32/64-bit comparisons on x86.
 #define DEFINE_CHECK_OP_IMPL(NAME, op)                                         \
   template <typename Lhs, typename Rhs>                                        \
-  V8_INLINE                                                                    \
-      typename std::enable_if<!is_signed_vs_unsigned<Lhs, Rhs>::value &&       \
-                                  !is_unsigned_vs_signed<Lhs, Rhs>::value,     \
-                              bool>::type                                      \
-          Cmp##NAME##Impl(typename PassType<Lhs>::type lhs,                    \
-                          typename PassType<Rhs>::type rhs) {                  \
-    return lhs op rhs;                                                         \
-  }                                                                            \
-  template <typename Lhs, typename Rhs>                                        \
   V8_INLINE std::string* Check##NAME##Impl(typename PassType<Lhs>::type lhs,   \
                                            typename PassType<Rhs>::type rhs,   \
                                            char const* msg) {                  \
-    bool cmp = Cmp##NAME##Impl<Lhs, Rhs>(lhs, rhs);                            \
-    return V8_LIKELY(cmp) ? nullptr                                            \
-                          : MakeCheckOpString<Lhs, Rhs>(lhs, rhs, msg);        \
+    return V8_LIKELY(lhs op rhs) ? nullptr                                     \
+                                 : MakeCheckOpString<Lhs, Rhs>(lhs, rhs, msg); \
   }                                                                            \
   extern template V8_BASE_EXPORT std::string* Check##NAME##Impl<float, float>( \
-      float lhs, float rhs, char const* msg);                                  \
+      const float lhs, const float rhs, char const* msg);                      \
   extern template V8_BASE_EXPORT std::string*                                  \
-      Check##NAME##Impl<double, double>(double lhs, double rhs,                \
+      Check##NAME##Impl<double, double>(const double lhs, const double rhs,    \
                                         char const* msg);
 DEFINE_CHECK_OP_IMPL(EQ, ==)
 DEFINE_CHECK_OP_IMPL(NE, !=)
 DEFINE_CHECK_OP_IMPL(LE, <=)
 DEFINE_CHECK_OP_IMPL(LT, < )
 DEFINE_CHECK_OP_IMPL(GE, >=)
 DEFINE_CHECK_OP_IMPL(GT, > )
 #undef DEFINE_CHECK_OP_IMPL
 
 #define CHECK_EQ(lhs, rhs) CHECK_OP(EQ, ==, lhs, rhs)
@@ skipping 30 matching lines @@
 #define DCHECK_GT(v1, v2)      ((void) 0)
 #define DCHECK_GE(v1, v2)      ((void) 0)
 #define DCHECK_LT(v1, v2)      ((void) 0)
 #define DCHECK_LE(v1, v2)      ((void) 0)
 #define DCHECK_NULL(val)       ((void) 0)
 #define DCHECK_NOT_NULL(val)   ((void) 0)
 #define DCHECK_IMPLIES(v1, v2) ((void) 0)
 #endif
 
 #endif  // V8_BASE_LOGGING_H_