Reland "Suppress canonicalization of Unbox() instruction that can deoptimize."

runtime/vm/flow_graph_range_analysis.cc

 // Copyright (c) 2014, 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/flow_graph_range_analysis.h"
 
 #include "vm/bit_vector.h"
 #include "vm/il_printer.h"
 
 namespace dart {
@@ skipping 2384 matching lines @@
   *result_min = RangeBoundary::Shr(
       left_min,
       left_min.ConstantValue() > 0 ? right_max : right_min);
 
   *result_max = RangeBoundary::Shr(
       left_max,
       left_max.ConstantValue() > 0 ? right_min : right_max);
 }
 
 
-bool Range::And(const Range* left_range,
+void Range::And(const Range* left_range,
                 const Range* right_range,
                 RangeBoundary* result_min,
                 RangeBoundary* result_max) {
   ASSERT(left_range != NULL);
   ASSERT(right_range != NULL);
   ASSERT(result_min != NULL);
   ASSERT(result_max != NULL);
 
   if (Range::ConstantMin(right_range).ConstantValue() >= 0) {
     *result_min = RangeBoundary::FromConstant(0);
     *result_max = Range::ConstantMax(right_range);
-    return true;
+    return;
   }
 
   if (Range::ConstantMin(left_range).ConstantValue() >= 0) {
     *result_min = RangeBoundary::FromConstant(0);
     *result_max = Range::ConstantMax(left_range);
-    return true;
+    return;
   }
 
-  return false;
+  *result_min = RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64);
+  *result_max = RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64);
 }
 
 
 static int BitSize(const Range* range) {
   const int64_t min = Range::ConstantMin(range).ConstantValue();
   const int64_t max = Range::ConstantMax(range).ConstantValue();
   return Utils::Maximum(Utils::BitLength(min), Utils::BitLength(max));
 }
 
 
@@ skipping 80 matching lines @@
                               RangeBoundary::NegativeInfinity());
   }
   if (!RangeBoundary::SymbolicSub(left_max, right_range->min(), result_max)) {
     *result_max = RangeBoundary::Sub(left_range->max().UpperBound(),
                                      right_range->min().LowerBound(),
                                      RangeBoundary::PositiveInfinity());
   }
 }
 
 
-bool Range::Mul(const Range* left_range,
+void Range::Mul(const Range* left_range,
                 const Range* right_range,
                 RangeBoundary* result_min,
                 RangeBoundary* result_max) {
   ASSERT(left_range != NULL);
   ASSERT(right_range != NULL);
   ASSERT(result_min != NULL);
   ASSERT(result_max != NULL);
 
   const int64_t left_max = ConstantAbsMax(left_range);
   const int64_t right_max = ConstantAbsMax(right_range);
   if ((left_max <= -kSmiMin) && (right_max <= -kSmiMin) &&
       ((left_max == 0) || (right_max <= kMaxInt64 / left_max))) {
     // Product of left and right max values stays in 64 bit range.
     const int64_t mul_max = left_max * right_max;
     const int64_t r_min =
         OnlyPositiveOrZero(*left_range, *right_range) ? 0 : -mul_max;
     *result_min = RangeBoundary::FromConstant(r_min);
     const int64_t r_max =
         OnlyNegativeOrZero(*left_range, *right_range) ? 0 : mul_max;
     *result_max = RangeBoundary::FromConstant(r_max);
-    return true;
+    return;
   }
 
   // TODO(vegorov): handle mixed sign case that leads to (-Infinity, 0] range.
   if (OnlyPositiveOrZero(*left_range, *right_range) ||
       OnlyNegativeOrZero(*left_range, *right_range)) {
     *result_min = RangeBoundary::FromConstant(0);
     *result_max = RangeBoundary::PositiveInfinity();
-    return true;
+    return;
   }
 
-  return false;
+  *result_min = RangeBoundary::NegativeInfinity();
+  *result_max = RangeBoundary::PositiveInfinity();
 }
 
 
 // Both the a and b ranges are >= 0.
 bool Range::OnlyPositiveOrZero(const Range& a, const Range& b) {
   return a.OnlyGreaterThanOrEqualTo(0) && b.OnlyGreaterThanOrEqualTo(0);
 }
 
 
 // Both the a and b ranges are <= 0.
@@ skipping 26 matching lines @@
   ASSERT(right_range->IsFinite());
 
   RangeBoundary min;
   RangeBoundary max;
   ASSERT(min.IsUnknown() && max.IsUnknown());
 
   switch (op) {
     case Token::kADD:
       Range::Add(left_range, right_range, &min, &max, left_defn);
       break;
+
     case Token::kSUB:
       Range::Sub(left_range, right_range, &min, &max, left_defn);
       break;
-    case Token::kMUL: {
-      if (!Range::Mul(left_range, right_range, &min, &max)) {
-        *result = Range::Full(RangeBoundary::kRangeBoundaryInt64);
-        return;
-      }
+
+    case Token::kMUL:
+      Range::Mul(left_range, right_range, &min, &max);
       break;
-    }
-    case Token::kSHL: {
+
+    case Token::kSHL:
       Range::Shl(left_range, right_range, &min, &max);
       break;
-    }
-    case Token::kSHR: {
+
+    case Token::kSHR:
       Range::Shr(left_range, right_range, &min, &max);
       break;
-    }
 
     case Token::kBIT_AND:
-      if (!Range::And(left_range, right_range, &min, &max)) {
-        *result = Range::Full(RangeBoundary::kRangeBoundaryInt64);
-        return;
-      }
+      Range::And(left_range, right_range, &min, &max);
       break;
 
     case Token::kBIT_XOR:
       Range::Xor(left_range, right_range, &min, &max);
       break;
 
+    case Token::kBIT_OR:
+      *result = Range::Full(RangeBoundary::kRangeBoundaryInt64);
+      return;
+
     default:
-      *result = Range::Full(RangeBoundary::kRangeBoundaryInt64);
+      *result = Range(RangeBoundary::NegativeInfinity(),
+                      RangeBoundary::PositiveInfinity());
       return;
   }
 
   ASSERT(!min.IsUnknown() && !max.IsUnknown());
 
   *result = Range(min, max);
 }
 
 
 void Definition::set_range(const Range& range) {
@@ skipping 478 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart