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

test/unittests/base/functional-unittest.cc

 // 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.
 
 #include "src/base/functional.h"
 
 #include <limits>
 #include <set>
 
 #include "test/unittests/test-utils.h"
@@ skipping 79 matching lines @@
   }
   std::set<size_t> hs;
   for (const auto& v : vs) {
     hash<TypeParam> h;
     hs.insert(h(v));
   }
   EXPECT_LE(vs.size() / 4u, hs.size());
 }
 
 
+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 {
   int x;
   double y;
 };
 
 
 size_t hash_value(Foo const& v) { return hash_combine(v.x, v.y); }
 
 }  // namespace
 
 
 TEST(FunctionalTest, HashUsesArgumentDependentLookup) {
   const int kIntValues[] = {std::numeric_limits<int>::min(), -1, 0, 1, 42,
                             std::numeric_limits<int>::max()};
   const double kDoubleValues[] = {
       std::numeric_limits<double>::min(), -1, -0, 0, 1,
       std::numeric_limits<double>::max()};
   TRACED_FOREACH(int, x, kIntValues) {
     TRACED_FOREACH(double, y, kDoubleValues) {
       hash<Foo> h;
       Foo foo = {x, y};
       EXPECT_EQ(hash_combine(x, y), h(foo));
     }
   }
 }
 
+
+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