Extend Range analysis to 64-bit range and mint operations

runtime/vm/intermediate_language_test.cc

Index: runtime/vm/intermediate_language_test.cc
diff --git a/runtime/vm/intermediate_language_test.cc b/runtime/vm/intermediate_language_test.cc
index 5d42bcbef96d411fc62e83e7610601e0a76d56e9..6b57bac9cc4e782879ae86a490aa281de4ca9ae6 100644
--- a/runtime/vm/intermediate_language_test.cc
+++ b/runtime/vm/intermediate_language_test.cc
@@ -122,4 +122,226 @@ TEST_CASE(RangeTestsInfinity) {
   EXPECT(unsatisfiable_left->IsUnsatisfiable());
 }
 
+
+TEST_CASE(RangeUtils) {
+  // NULL case for IncludesNegativeInfinity().
+  EXPECT(Range::IncludesNegativeInfinity(NULL));
+
+  // [-inf, 0] case for IncludesNegativeInfinity().
+  EXPECT(Range::IncludesNegativeInfinity(
+      new Range(RangeBoundary::NegativeInfinity(),
+                RangeBoundary::FromConstant(0))));
+
+  // [0, inf] case for IncludesNegativeInfinity().
+  EXPECT(!Range::IncludesNegativeInfinity(
+      new Range(RangeBoundary::FromConstant(0),
+                RangeBoundary::PositiveInfinity())));
+
+  // NULL case for IncludesPositiveInfinity().
+  EXPECT(Range::IncludesPositiveInfinity(NULL));
+
+  // [-inf, 0] case for IncludesPositiveInfinity().
+  EXPECT(!Range::IncludesPositiveInfinity(
+      new Range(RangeBoundary::NegativeInfinity(),
+                RangeBoundary::FromConstant(0))));
+
+  // [0, inf] case for IncludesPositiveInfinity().
+  EXPECT(Range::IncludesPositiveInfinity(
+      new Range(RangeBoundary::FromConstant(0),
+                RangeBoundary::PositiveInfinity())));
+
+  // [-inf, +inf].
+  const Range& range_0 = *(new Range(RangeBoundary::NegativeInfinity(),
+                                     RangeBoundary::PositiveInfinity()));
+  // [-inf, -1].
+  const Range& range_a = *(new Range(RangeBoundary::NegativeInfinity(),
+                                     RangeBoundary::FromConstant(-1)));
+  // [-inf, 0].
+  const Range& range_b = *(new Range(RangeBoundary::NegativeInfinity(),
+                                     RangeBoundary::FromConstant(0)));
+  // [-inf, 1].
+  const Range& range_c = *(new Range(RangeBoundary::NegativeInfinity(),
+                                     RangeBoundary::FromConstant(1)));
+  // [-1, +inf]
+  const Range& range_d = *(new Range(RangeBoundary::FromConstant(-1),
+                                     RangeBoundary::PositiveInfinity()));
+  // [0, +inf]
+  const Range& range_e = *(new Range(RangeBoundary::FromConstant(0),
+                                     RangeBoundary::PositiveInfinity()));
+  // [1, +inf].
+  const Range& range_f = *(new Range(RangeBoundary::FromConstant(1),
+                                     RangeBoundary::PositiveInfinity()));
+  // [1, 2].
+  const Range& range_g = *(new Range(RangeBoundary::FromConstant(1),
+                                     RangeBoundary::FromConstant(2)));
+  // [-1, -2].
+  const Range& range_h = *(new Range(RangeBoundary::FromConstant(-1),
+                                     RangeBoundary::FromConstant(-2)));
+  // [-1, 1].
+  const Range& range_i = *(new Range(RangeBoundary::FromConstant(-1),
+                                     RangeBoundary::FromConstant(1)));
+
+  // OnlyPositiveOrZero.
+  EXPECT(!Range::OnlyPositiveOrZero(range_a, range_b));
+  EXPECT(!Range::OnlyPositiveOrZero(range_b, range_c));
+  EXPECT(!Range::OnlyPositiveOrZero(range_c, range_d));
+  EXPECT(!Range::OnlyPositiveOrZero(range_d, range_e));
+  EXPECT(Range::OnlyPositiveOrZero(range_e, range_f));
+  EXPECT(!Range::OnlyPositiveOrZero(range_d, range_d));
+  EXPECT(Range::OnlyPositiveOrZero(range_e, range_e));
+  EXPECT(Range::OnlyPositiveOrZero(range_f, range_g));
+  EXPECT(!Range::OnlyPositiveOrZero(range_g, range_h));
+  EXPECT(!Range::OnlyPositiveOrZero(range_i, range_i));
+
+  // OnlyNegativeOrZero.
+  EXPECT(Range::OnlyNegativeOrZero(range_a, range_b));
+  EXPECT(!Range::OnlyNegativeOrZero(range_b, range_c));
+  EXPECT(Range::OnlyNegativeOrZero(range_b, range_b));
+  EXPECT(!Range::OnlyNegativeOrZero(range_c, range_c));
+  EXPECT(!Range::OnlyNegativeOrZero(range_c, range_d));
+  EXPECT(!Range::OnlyNegativeOrZero(range_d, range_e));
+  EXPECT(!Range::OnlyNegativeOrZero(range_e, range_f));
+  EXPECT(!Range::OnlyNegativeOrZero(range_f, range_g));
+  EXPECT(!Range::OnlyNegativeOrZero(range_g, range_h));
+  EXPECT(Range::OnlyNegativeOrZero(range_h, range_h));
+  EXPECT(!Range::OnlyNegativeOrZero(range_i, range_i));
+
+  // [-inf, +inf].
+  EXPECT(!Range::OnlyNegativeOrZero(range_0, range_0));
+  EXPECT(!Range::OnlyPositiveOrZero(range_0, range_0));
+
+  EXPECT(Range::ConstantAbsMax(&range_0) == -Smi::kMinValue);
+  EXPECT(Range::ConstantAbsMax(&range_h) == 2);
+  EXPECT(Range::ConstantAbsMax(&range_i) == 1);
+
+  // RangeBOundary.Equals.
+  EXPECT(RangeBoundary::FromConstant(1).Equals(
+      RangeBoundary::FromConstant(1)));
+  EXPECT(!RangeBoundary::FromConstant(2).Equals(
+      RangeBoundary::FromConstant(1)));
+  EXPECT(RangeBoundary::PositiveInfinity().Equals(
+      RangeBoundary::PositiveInfinity()));
+  EXPECT(!RangeBoundary::PositiveInfinity().Equals(
+      RangeBoundary::NegativeInfinity()));
+  EXPECT(RangeBoundary::NegativeInfinity().Equals(
+      RangeBoundary::NegativeInfinity()));
+  EXPECT(!RangeBoundary::NegativeInfinity().Equals(
+      RangeBoundary::PositiveInfinity()));
+  EXPECT(!RangeBoundary::FromConstant(1).Equals(
+      RangeBoundary::NegativeInfinity()));
+  EXPECT(!RangeBoundary::FromConstant(1).Equals(
+      RangeBoundary::NegativeInfinity()));
+  EXPECT(!RangeBoundary::FromConstant(2).Equals(
+      RangeBoundary::PositiveInfinity()));
+}
+
+
+TEST_CASE(RangeBinaryOp) {
+  // Test that [0, +inf] + [-inf, 0] = [-inf, +inf].
+  Range* range_a = new Range(RangeBoundary::FromConstant(0),
+                             RangeBoundary::PositiveInfinity());
+  EXPECT(range_a->min().ConstantValue() == 0);
+  EXPECT(range_a->max().IsPositiveInfinity());
+  Range* range_b = new Range(RangeBoundary::NegativeInfinity(),
+                             RangeBoundary::FromConstant(0));
+  EXPECT(range_b->min().IsNegativeInfinity());
+  EXPECT(range_b->max().ConstantValue() == 0);
+  Range* result = Range::BinaryOp(Token::kADD,
+                                  range_a->min(),
+                                  range_a->max(),
+                                  range_a,
+                                  range_b,
+                                  NULL);
+  ASSERT(result != NULL);
+  EXPECT(result->min().IsNegativeInfinity());
+  EXPECT(result->max().IsPositiveInfinity());
+
+  // Test that [5, 10] + [0, 5] = [5, 15].
+  Range* range_c = new Range(RangeBoundary::FromConstant(5),
+                             RangeBoundary::FromConstant(10));
+  Range* range_d = new Range(RangeBoundary::FromConstant(0),
+                             RangeBoundary::FromConstant(5));
+  result = Range::BinaryOp(Token::kADD,
+                           range_c->min(),
+                           range_c->max(),
+                           range_c,
+                           range_d,
+                           NULL);
+  ASSERT(result != NULL);
+  EXPECT(result->min().ConstantValue() == 5);
+  EXPECT(result->max().ConstantValue() == 15);
+
+
+  // Test that [0xff, 0xfff] & [0xf, 0xf] = [0x0, 0xf].
+  Range* range_e = new Range(RangeBoundary::FromConstant(0xff),
+                             RangeBoundary::FromConstant(0xfff));
+  Range* range_f = new Range(RangeBoundary::FromConstant(0xf),
+                             RangeBoundary::FromConstant(0xf));
+  result = Range::BinaryOp(Token::kBIT_AND,
+                           range_e->min(),
+                           range_e->max(),
+                           range_e,
+                           range_f,
+                           Range::Unknown());
+  ASSERT(result != NULL);
+  EXPECT(result->min().ConstantValue() == 0x0);
+  EXPECT(result->max().ConstantValue() == 0xf);
+}
+
+
+TEST_CASE(RangeMinMax) {
+  // Constants.
+  // MIN(0, 1) == 0
+  EXPECT(RangeBoundary::Min(
+      RangeBoundary::FromConstant(0),
+      RangeBoundary::FromConstant(1)).ConstantValue() == 0);
+  // MIN(0, -1) == -1
+  EXPECT(RangeBoundary::Min(
+      RangeBoundary::FromConstant(0),
+      RangeBoundary::FromConstant(-1)).ConstantValue() == -1);
+
+  // MIN(1, 0) == 0
+  EXPECT(RangeBoundary::Min(
+      RangeBoundary::FromConstant(1),
+      RangeBoundary::FromConstant(0)).ConstantValue() == 0);
+  // MIN(-1, 0) == -1
+  EXPECT(RangeBoundary::Min(
+      RangeBoundary::FromConstant(-1),
+      RangeBoundary::FromConstant(0)).ConstantValue() == -1);
+
+  // MAX(0, 1) == 1
+  EXPECT(RangeBoundary::Max(
+      RangeBoundary::FromConstant(0),
+      RangeBoundary::FromConstant(1)).ConstantValue() == 1);
+  // MAX(0, -1) == 0
+  EXPECT(RangeBoundary::Max(
+      RangeBoundary::FromConstant(0),
+      RangeBoundary::FromConstant(-1)).ConstantValue() == 0);
+
+  // MAX(1, 0) == 1
+  EXPECT(RangeBoundary::Max(
+      RangeBoundary::FromConstant(1),
+      RangeBoundary::FromConstant(0)).ConstantValue() == 1);
+  // MAX(-1, 0) == 0
+  EXPECT(RangeBoundary::Max(
+      RangeBoundary::FromConstant(-1),
+      RangeBoundary::FromConstant(0)).ConstantValue() == 0);
+
+  // Infinities.
+  RangeBoundary n_infinity = RangeBoundary::NegativeInfinity();
+  RangeBoundary p_infinity = RangeBoundary::PositiveInfinity();
+
+  // MIN(-inf, +inf) == -inf.
+  EXPECT(RangeBoundary::Min(n_infinity, p_infinity).Equals(n_infinity));
+
+  // MIN(+inf, -inf) == -inf.
+  EXPECT(RangeBoundary::Min(p_infinity, n_infinity).Equals(n_infinity));
+
+  // MAX(-inf, +inf) == +inf.
+  EXPECT(RangeBoundary::Max(n_infinity, p_infinity).Equals(p_infinity));
+
+  // MAX(+inf, -inf) == +inf.
+  EXPECT(RangeBoundary::Max(p_infinity, n_infinity).Equals(p_infinity));
+}
+
 }  // namespace dart