[turbofan] Fix HashCode/Equals for floating point operators.

src/base/functional.h

 // Copyright 2014 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_FUNCTIONAL_H_
 #define V8_BASE_FUNCTIONAL_H_
 
 #include <cstddef>
+#include <cstring>
 #include <functional>
 #include <utility>
 
 #include "include/v8stdint.h"
 #include "src/base/macros.h"
 
 namespace v8 {
 namespace base {
 
 // base::hash is an implementation of the hash function object specified by
@@ skipping 41 matching lines @@
 
 template <typename>
 struct hash;
 
 
 V8_INLINE size_t hash_combine() { return 0u; }
 V8_INLINE size_t hash_combine(size_t seed) { return seed; }
 size_t hash_combine(size_t seed, size_t value);
 template <typename T, typename... Ts>
 V8_INLINE size_t hash_combine(T const& v, Ts const&... vs) {
-  return hash_combine(hash<T>()(v), hash_combine(vs...));
+  return hash_combine(hash_combine(vs...), hash<T>()(v));

[Benedikt Meurer, 2014/10/08 05:56:34]

Reordered because we pass the seed as first parameter, and we don't need to
rehash the seed, therefore we want it to use the size_t specialization of
hash_combine.

 }
 
 
+template <typename Iterator>
+V8_INLINE size_t hash_range(Iterator first, Iterator last) {
+  size_t seed = 0;
+  for (; first != last; ++first) {
+    seed = hash_combine(seed, *first);
+  }
+  return seed;
+}
+
+
 #define V8_BASE_HASH_VALUE_TRIVIAL(type) \
   V8_INLINE size_t hash_value(type v) { return static_cast<size_t>(v); }
 V8_BASE_HASH_VALUE_TRIVIAL(bool)
 V8_BASE_HASH_VALUE_TRIVIAL(unsigned char)
 V8_BASE_HASH_VALUE_TRIVIAL(unsigned short)  // NOLINT(runtime/int)
 #undef V8_BASE_HASH_VALUE_TRIVIAL
 
 size_t hash_value(unsigned int);
 size_t hash_value(unsigned long);       // NOLINT(runtime/int)
 size_t hash_value(unsigned long long);  // NOLINT(runtime/int)
@@ skipping 12 matching lines @@
 V8_INLINE size_t hash_value(float v) {
   // 0 and -0 both hash to zero.
   return v != 0.0f ? hash_value(bit_cast<uint32_t>(v)) : 0;
 }
 
 V8_INLINE size_t hash_value(double v) {
   // 0 and -0 both hash to zero.
   return v != 0.0 ? hash_value(bit_cast<uint64_t>(v)) : 0;
 }
 
+template <typename T, size_t N>
+V8_INLINE size_t hash_value(const T (&v)[N]) {
+  return hash_range(v, v + N);
+}
+
+template <typename T, size_t N>
+V8_INLINE size_t hash_value(T (&v)[N]) {
+  return hash_range(v, v + N);
+}
+
 template <typename T>
 V8_INLINE size_t hash_value(T* const& v) {
   return hash_value(bit_cast<uintptr_t>(v));
 }
 
 template <typename T1, typename T2>
 V8_INLINE size_t hash_value(std::pair<T1, T2> const& v) {
   return hash_combine(v.first, v.second);
 }
 
@@ skipping 25 matching lines @@
 V8_BASE_HASH_SPECIALIZE(double)
 #undef V8_BASE_HASH_SPECIALIZE
 
 template <typename T>
 struct hash<T*> : public std::unary_function<T*, size_t> {
   V8_INLINE size_t operator()(T* const v) const {
     return ::v8::base::hash_value(v);
   }
 };
 
-template <typename T1, typename T2>
-struct hash<std::pair<T1, T2> >
-    : public std::unary_function<std::pair<T1, T2>, size_t> {
-  V8_INLINE size_t operator()(std::pair<T1, T2> const& v) const {
-    return ::v8::base::hash_value(v);
+
+// base::bit_equal_to is a function object class for bitwise equality
+// comparison, similar to std::equal_to, except that the comparison is performed
+// on the bit representation of the operands.
+//
+// base::bit_hash is a function object class for bitwise hashing, similar to
+// base::hash. It can be used together with base::bit_equal_to to implement a
+// hash data structure based on the bitwise representation of types.
+
+template <typename T>
+struct bit_equal_to : public std::binary_function<T, T, bool> {
+  V8_INLINE bool operator()(T const& lhs, T const& rhs) const {
+    return memcmp(&lhs, &rhs, sizeof(T)) == 0;
   }
 };
 
+template <typename T>
+struct bit_hash : public std::unary_function<T, size_t> {
+  V8_INLINE size_t operator()(T const& v) const {
+    uint8_t const* const p = reinterpret_cast<uint8_t const*>(&v);
+    return hash_range(p, p + sizeof(v));
+  }
+};
+
+#define V8_BASE_BIT_SPECIALIZE_TRIVIAL(type)                 \
+  template <>                                                \
+  struct bit_equal_to<type> : public std::equal_to<type> {}; \
+  template <>                                                \
+  struct bit_hash<type> : public hash<type> {};
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(signed char)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned char)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(short)           // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned short)  // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(long)                // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned long)       // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(long long)           // NOLINT(runtime/int)
+V8_BASE_BIT_SPECIALIZE_TRIVIAL(unsigned long long)  // NOLINT(runtime/int)
+#undef V8_BASE_BIT_SPECIALIZE_TRIVIAL
+
+#define V8_BASE_BIT_SPECIALIZE_BIT_CAST(type, btype)                          \
+  template <>                                                                 \
+  struct bit_equal_to<type> : public std::binary_function<type, type, bool> { \
+    V8_INLINE bool operator()(type lhs, type rhs) const {                     \
+      return bit_cast<btype>(lhs) == bit_cast<btype>(rhs);                    \
+    }                                                                         \
+  };                                                                          \
+  template <>                                                                 \
+  struct bit_hash<type> : public std::unary_function<type, size_t> {          \
+    V8_INLINE size_t operator()(type v) const {                               \
+      hash<btype> h;                                                          \
+      return h(bit_cast<btype>(v));                                           \
+    }                                                                         \
+  };
+V8_BASE_BIT_SPECIALIZE_BIT_CAST(float, uint32_t)
+V8_BASE_BIT_SPECIALIZE_BIT_CAST(double, uint64_t)
+#undef V8_BASE_BIT_SPECIALIZE_BIT_CAST
+
 }  // namespace base
 }  // namespace v8
 
 #endif  // V8_BASE_FUNCTIONAL_H_