Extend Range analysis to 64-bit range and mint operations

runtime/vm/intermediate_language_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/intermediate_language.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 TEST_CASE(InstructionTests) {
@@ skipping 104 matching lines @@
 
   Range* unsatisfiable_right = new Range(RangeBoundary::PositiveInfinity(),
                                          RangeBoundary::FromConstant(0));
   EXPECT(unsatisfiable_right->IsUnsatisfiable());
 
   Range* unsatisfiable_left = new Range(RangeBoundary::FromConstant(0),
                                         RangeBoundary::NegativeInfinity());
   EXPECT(unsatisfiable_left->IsUnsatisfiable());
 }
 
+
+TEST_CASE(RangeUtils) {
+  // NULL case for IsSmiMinOrUnderflow().
+  EXPECT(Range::IsSmiMinimumOrUnderflow(NULL));
+
+  // Unknown case for IsSmiMinOrUnderflow().
+  EXPECT(Range::IsSmiMinimumOrUnderflow(Range::Unknown()));
+
+  // [-inf, 0] case for IsSmiMinOrUnderflow().
+  EXPECT(Range::IsSmiMinimumOrUnderflow(
+      new Range(RangeBoundary::NegativeInfinity(),
+                RangeBoundary::FromConstant(0))));
+
+  // [0, inf] case for IsSmiMinOrUnderflow().
+  EXPECT(!Range::IsSmiMinimumOrUnderflow(
+      new Range(RangeBoundary::FromConstant(0),
+                RangeBoundary::PositiveInfinity())));
+
+  // [kSmiMin - 1, 0] case for IsSmiMinOrUnderflow().
+  EXPECT(Range::IsSmiMinimumOrUnderflow(
+      new Range(RangeBoundary::FromConstant(kSmiMin - 1),
+                RangeBoundary::FromConstant(0))));
+
+  // [kSmiMin, 0] case for IsSmiMinOrUnderflow().
+  EXPECT(Range::IsSmiMinimumOrUnderflow(
+      new Range(RangeBoundary::FromConstant(kSmiMin),
+                RangeBoundary::FromConstant(0))));
+
+  // [kSmiMin + 1, 0] case for IsSmiMinOrUnderflow().
+  EXPECT(!Range::IsSmiMinimumOrUnderflow(
+      new Range(RangeBoundary::FromConstant(kSmiMin + 1),
+                RangeBoundary::FromConstant(0))));
+
+  // NULL case for IsSmiMaximumOrOverflow().
+  EXPECT(Range::IsSmiMaximumOrOverflow(NULL));
+
+  // Unknown case for IsSmiMaximumOrOverflow().
+  EXPECT(Range::IsSmiMaximumOrOverflow(Range::Unknown()));
+
+  // [-inf, 0] case for IsSmiMaxOrOverflow().
+  EXPECT(!Range::IsSmiMaximumOrOverflow(
+      new Range(RangeBoundary::NegativeInfinity(),
+                RangeBoundary::FromConstant(0))));
+
+  // [0, inf] case for IsSmiMaxOrOverflow().
+  EXPECT(Range::IsSmiMaximumOrOverflow(
+      new Range(RangeBoundary::FromConstant(0),
+                RangeBoundary::PositiveInfinity())));
+
+  // [0, kSmiMax - 1] case for IsSmiMaxOrOverflow().
+  EXPECT(!Range::IsSmiMaximumOrOverflow(
+      new Range(RangeBoundary::FromConstant(0),
+                RangeBoundary::FromConstant(kSmiMax - 1))));
+
+  // [0, kSmiMax] case for IsSmiMaxOrOverflow().
+  EXPECT(Range::IsSmiMaximumOrOverflow(
+      new Range(RangeBoundary::FromConstant(0),
+                RangeBoundary::FromConstant(kSmiMax))));
+
+  // [0, kSmiMax + 1] case for IsSmiMaxOrOverflow().
+  EXPECT(Range::IsSmiMaximumOrOverflow(
+      new Range(RangeBoundary::FromConstant(0),
+                RangeBoundary::FromConstant(kSmiMax + 1))));
+
+  // [-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) == RangeBoundary::kMax);
+  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().Value() == 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().Value() == 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().Value() == 5);
+  EXPECT(result->max().Value() == 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().Value() == 0x0);
+  EXPECT(result->max().Value() == 0xf);
+}
+
+
 }  // namespace dart