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

test/unittests/base/functional-unittest.cc

Index: test/unittests/base/functional-unittest.cc
diff --git a/test/unittests/base/functional-unittest.cc b/test/unittests/base/functional-unittest.cc
index d15aa5df042c8f9c403cdda1217f69438d897c7b..ae17d029ea000551209010f5ddd73766bab80c0f 100644
--- a/test/unittests/base/functional-unittest.cc
+++ b/test/unittests/base/functional-unittest.cc
@@ -97,6 +97,39 @@ TYPED_TEST(FunctionalTest, HashIsOkish) {
 }
 
 
+TYPED_TEST(FunctionalTest, HashValueArrayUsesHashRange) {
+  TypeParam values[128];
+  this->rng()->NextBytes(&values, sizeof(values));
+  EXPECT_EQ(hash_range(values, values + arraysize(values)), hash_value(values));
+}
+
+
+TYPED_TEST(FunctionalTest, BitEqualTo) {
+  bit_equal_to<TypeParam> pred;
+  for (size_t i = 0; i < 128; ++i) {
+    TypeParam v1, v2;
+    this->rng()->NextBytes(&v1, sizeof(v1));
+    this->rng()->NextBytes(&v2, sizeof(v2));
+    EXPECT_PRED2(pred, v1, v1);
+    EXPECT_PRED2(pred, v2, v2);
+    EXPECT_EQ(memcmp(&v1, &v2, sizeof(TypeParam)) == 0, pred(v1, v2));
+  }
+}
+
+
+TYPED_TEST(FunctionalTest, BitEqualToImpliesSameBitHash) {
+  bit_hash<TypeParam> h;
+  bit_equal_to<TypeParam> e;
+  TypeParam values[32];
+  this->rng()->NextBytes(&values, sizeof(values));
+  TRACED_FOREACH(TypeParam, v1, values) {
+    TRACED_FOREACH(TypeParam, v2, values) {
+      if (e(v1, v2)) EXPECT_EQ(h(v1), h(v2));
+    }
+  }
+}
+
+
 namespace {
 
 struct Foo {
@@ -125,5 +158,40 @@ TEST(FunctionalTest, HashUsesArgumentDependentLookup) {
   }
 }
 
+
+TEST(FunctionalTest, BitEqualToStructWithoutComparisonOperator) {
+  Foo const foo1 = {0, 0.0};
+  Foo const foo2 = {0, 0.0};
+  Foo const foo3 = {1, 0.0};
+  Foo const foo4 = {0, -0.0};
+  bit_equal_to<Foo> pred;
+  EXPECT_TRUE(pred(foo1, foo2));
+  EXPECT_FALSE(pred(foo1, foo3));
+  EXPECT_FALSE(pred(foo2, foo3));
+  EXPECT_FALSE(pred(foo3, foo4));
+}
+
+
+TEST(FunctionalTest, BitEqualToFloat) {
+  bit_equal_to<float> pred;
+  EXPECT_FALSE(pred(0.0f, -0.0f));
+  EXPECT_FALSE(pred(-0.0f, 0.0f));
+  float const qNaN = std::numeric_limits<float>::quiet_NaN();
+  float const sNaN = std::numeric_limits<float>::signaling_NaN();
+  EXPECT_PRED2(pred, qNaN, qNaN);
+  EXPECT_PRED2(pred, sNaN, sNaN);
+}
+
+
+TEST(FunctionalTest, BitEqualToDouble) {
+  bit_equal_to<double> pred;
+  EXPECT_FALSE(pred(0.0, -0.0));
+  EXPECT_FALSE(pred(-0.0, 0.0));
+  double const qNaN = std::numeric_limits<double>::quiet_NaN();
+  double const sNaN = std::numeric_limits<double>::signaling_NaN();
+  EXPECT_PRED2(pred, qNaN, qNaN);
+  EXPECT_PRED2(pred, sNaN, sNaN);
+}
+
 }  // namespace base
 }  // namespace v8