[turbofan] (reland) Compute tighter ranges for modulus in Typer.

test/cctest/compiler/test-typer.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 <functional>
 
+#include "src/codegen.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/typer.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/types-fuzz.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 
-
+// TODO(titzer): generate a large set of deterministic inputs for these tests.
 class TyperTester : public HandleAndZoneScope, public GraphAndBuilders {
  public:
   TyperTester()
       : GraphAndBuilders(main_zone()),
         types_(main_zone(), isolate()),
         typer_(graph(), MaybeHandle<Context>()),
         javascript_(main_zone()) {
     Node* s = graph()->NewNode(common()->Start(3));
     graph()->SetStart(s);
     context_node_ = graph()->NewNode(common()->Parameter(2), graph()->start());
@@ skipping 44 matching lines @@
     Node* p1 = Parameter(1);
     NodeProperties::SetBounds(p0, Bounds(lhs));
     NodeProperties::SetBounds(p1, Bounds(rhs));
     Node* n = graph()->NewNode(
         op, p0, p1, context_node_, graph()->start(), graph()->start());
     return NodeProperties::GetBounds(n).upper;
   }
 
   Type* RandomRange(bool int32 = false) {
     std::vector<double>& numbers = int32 ? int32s : integers;
+    double i = numbers[rng_->NextInt(static_cast<int>(numbers.size()))];
+    double j = numbers[rng_->NextInt(static_cast<int>(numbers.size()))];
+    return NewRange(i, j);
+  }
+
+  Type* NewRange(double i, double j) {
     Factory* f = isolate()->factory();
-    int i = rng_->NextInt(static_cast<int>(numbers.size()));
-    int j = rng_->NextInt(static_cast<int>(numbers.size()));
-    i::Handle<i::Object> min = f->NewNumber(numbers[i]);
-    i::Handle<i::Object> max = f->NewNumber(numbers[j]);
+    i::Handle<i::Object> min = f->NewNumber(i);
+    i::Handle<i::Object> max = f->NewNumber(j);
     if (min->Number() > max->Number()) std::swap(min, max);
     return Type::Range(min, max, main_zone());
   }
 
   double RandomInt(double min, double max) {
     switch (rng_->NextInt(4)) {
       case 0: return min;
       case 1: return max;
       default: break;
     }
     if (min == +V8_INFINITY) return +V8_INFINITY;
     if (max == -V8_INFINITY) return -V8_INFINITY;
     if (min == -V8_INFINITY && max == +V8_INFINITY) {
       return rng_->NextInt() * static_cast<double>(rng_->NextInt());
     }
     double result = nearbyint(min + (max - min) * rng_->NextDouble());
     if (IsMinusZero(result)) return 0;
     if (std::isnan(result)) return rng_->NextInt(2) ? min : max;
     DCHECK(min <= result && result <= max);
     return result;
   }
 
   double RandomInt(Type::RangeType* range) {
     return RandomInt(range->Min()->Number(), range->Max()->Number());
   }
 
+  // Careful, this function runs O(max_width^5) trials.
+  template <class BinaryFunction>
+  void TestBinaryArithOpCloseToZero(const Operator* op, BinaryFunction opfun,
+                                    int max_width) {
+    const int min_min = -2 - max_width / 2;
+    const int max_min = 2 + max_width / 2;
+    for (int width = 0; width < max_width; width++) {
+      for (int lmin = min_min; lmin <= max_min; lmin++) {
+        for (int rmin = min_min; rmin <= max_min; rmin++) {
+          Type* r1 = NewRange(lmin, lmin + width);
+          Type* r2 = NewRange(rmin, rmin + width);
+          Type* expected_type = TypeBinaryOp(op, r1, r2);
+
+          for (int x1 = lmin; x1 < lmin + width; x1++) {
+            for (int x2 = rmin; x2 < rmin + width; x2++) {
+              double result_value = opfun(x1, x2);
+              Type* result_type = Type::Constant(
+                  isolate()->factory()->NewNumber(result_value), main_zone());
+              CHECK(result_type->Is(expected_type));
+            }
+          }
+        }
+      }
+    }
+  }
+
   template <class BinaryFunction>
   void TestBinaryArithOp(const Operator* op, BinaryFunction opfun) {
+    TestBinaryArithOpCloseToZero(op, opfun, 8);
     for (int i = 0; i < 100; ++i) {
       Type::RangeType* r1 = RandomRange()->AsRange();
       Type::RangeType* r2 = RandomRange()->AsRange();
       Type* expected_type = TypeBinaryOp(op, r1, r2);
-      double x1 = RandomInt(r1);
-      double x2 = RandomInt(r2);
-      double result_value = opfun(x1, x2);
-      Type* result_type = Type::Constant(
-          isolate()->factory()->NewNumber(result_value), main_zone());
-      CHECK(result_type->Is(expected_type));
+      for (int i = 0; i < 10; i++) {
+        double x1 = RandomInt(r1);
+        double x2 = RandomInt(r2);
+        double result_value = opfun(x1, x2);
+        Type* result_type = Type::Constant(
+            isolate()->factory()->NewNumber(result_value), main_zone());
+        CHECK(result_type->Is(expected_type));
+      }
     }
   }
 
   template <class BinaryFunction>
   void TestBinaryCompareOp(const Operator* op, BinaryFunction opfun) {
     for (int i = 0; i < 100; ++i) {
       Type::RangeType* r1 = RandomRange()->AsRange();
       Type::RangeType* r2 = RandomRange()->AsRange();
       Type* expected_type = TypeBinaryOp(op, r1, r2);
-      double x1 = RandomInt(r1);
-      double x2 = RandomInt(r2);
-      bool result_value = opfun(x1, x2);
-      Type* result_type = Type::Constant(result_value ?
-          isolate()->factory()->true_value() :
-          isolate()->factory()->false_value(), main_zone());
-      CHECK(result_type->Is(expected_type));
+      for (int i = 0; i < 10; i++) {
+        double x1 = RandomInt(r1);
+        double x2 = RandomInt(r2);
+        bool result_value = opfun(x1, x2);
+        Type* result_type =
+            Type::Constant(result_value ? isolate()->factory()->true_value()
+                                        : isolate()->factory()->false_value(),
+                           main_zone());
+        CHECK(result_type->Is(expected_type));
+      }
     }
   }
 
   template <class BinaryFunction>
   void TestBinaryBitOp(const Operator* op, BinaryFunction opfun) {
     for (int i = 0; i < 100; ++i) {
       Type::RangeType* r1 = RandomRange(true)->AsRange();
       Type::RangeType* r2 = RandomRange(true)->AsRange();
       Type* expected_type = TypeBinaryOp(op, r1, r2);
-      int32_t x1 = static_cast<int32_t>(RandomInt(r1));
-      int32_t x2 = static_cast<int32_t>(RandomInt(r2));
-      double result_value = opfun(x1, x2);
-      Type* result_type = Type::Constant(
-          isolate()->factory()->NewNumber(result_value), main_zone());
-      CHECK(result_type->Is(expected_type));
+      for (int i = 0; i < 10; i++) {
+        int32_t x1 = static_cast<int32_t>(RandomInt(r1));
+        int32_t x2 = static_cast<int32_t>(RandomInt(r2));
+        double result_value = opfun(x1, x2);
+        Type* result_type = Type::Constant(
+            isolate()->factory()->NewNumber(result_value), main_zone());
+        CHECK(result_type->Is(expected_type));
+      }
     }
   }
 
   Type* RandomSubtype(Type* type) {
     Type* subtype;
     do {
       subtype = types_.Fuzz();
     } while (!subtype->Is(type));
     return subtype;
   }
@@ skipping 43 matching lines @@
   t.TestBinaryArithOp(t.javascript_.Multiply(), std::multiplies<double>());
 }
 
 
 TEST(TypeJSDivide) {
   TyperTester t;
   t.TestBinaryArithOp(t.javascript_.Divide(), std::divides<double>());
 }
 
 
+TEST(TypeJSModulus) {
+  TyperTester t;
+  t.TestBinaryArithOp(t.javascript_.Modulus(), modulo);
+}
+
+
 TEST(TypeJSBitwiseOr) {
   TyperTester t;
   t.TestBinaryBitOp(t.javascript_.BitwiseOr(), bit_or);
 }
 
 
 TEST(TypeJSBitwiseAnd) {
   TyperTester t;
   t.TestBinaryBitOp(t.javascript_.BitwiseAnd(), bit_and);
 }
@@ skipping 89 matching lines @@
   V(ShiftLeft) \
   V(ShiftRight) \
   V(ShiftRightLogical) \
   V(Add) \
   V(Subtract) \
   V(Multiply) \
   V(Divide) \
   V(Modulus)
 
 
-TEST(Monotonicity) {
-  TyperTester t;
-  #define TEST_OP(name) \
-      t.TestBinaryMonotonicity(t.javascript_.name());
-  JSBINOP_LIST(TEST_OP)
-  #undef TEST_OP
-}
+#define TEST_FUNC(name)                             \
+  TEST(Monotonicity_##name) {                       \
+    TyperTester t;                                  \
+    t.TestBinaryMonotonicity(t.javascript_.name()); \
+  }
+JSBINOP_LIST(TEST_FUNC)
+#undef TEST_FUNC