Eliminate overflow check for non-overflowing smi << operations.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, 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/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 1220 matching lines @@
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       return false;
     case Token::kSHR: {
       // Can't deopt if shift-count is known positive.
       Range* right_range = this->right()->definition()->range();
       return (right_range == NULL) || !right_range->IsPositive();
     }
     case Token::kSHL: {
       Range* right_range = this->right()->definition()->range();
-      if ((right_range != NULL) && is_truncating()) {
+      if ((right_range != NULL) && IsTruncating()) {
         // Can deoptimize if right can be negative.
         return !right_range->IsPositive();
       }
       return true;
     }
     case Token::kMOD: {
       Range* right_range = this->right()->definition()->range();
       return (right_range == NULL) || right_range->Overlaps(0, 0);
     }
     default:
@@ skipping 1948 matching lines @@
     // Nothing new.
     return;
   }
 
   range_ = possible_range;
 
   ASSERT(!range_->min().IsUnknown() && !range_->max().IsUnknown());
   // Calculate overflowed status before clamping.
   const bool overflowed = range_->min().LowerBound().OverflowedSmi() ||
                           range_->max().UpperBound().OverflowedSmi();
-
   // Clamp value to be within smi range.
   range_->Clamp(RangeBoundary::kRangeBoundarySmi);
 
   set_overflow(overflowed);
 }
 
 
 void BinaryMintOpInstr::InferRange() {
   // TODO(vegorov): canonicalize BinaryMintOpInstr to always have constant on
   // the right and a non-constant on the left.
@@ skipping 148 matching lines @@
 
   *result_max = RangeBoundary::Shl(
       left_max,
       left_max.ConstantValue() > 0 ? right_max : right_min,
       left_max.ConstantValue() > 0
           ? RangeBoundary::PositiveInfinity()
           : RangeBoundary::NegativeInfinity());
 }
 
 
+void Range::Shr(const Range* left,
+                const Range* right,
+                RangeBoundary* result_min,
+                RangeBoundary* result_max) {
+  RangeBoundary left_max = Range::ConstantMax(left);
+  RangeBoundary left_min = Range::ConstantMin(left);
+  // A negative shift count always deoptimizes (and throws), so the minimum
+  // shift count is zero.
+  int64_t right_max = Utils::Maximum(Range::ConstantMax(right).ConstantValue(),
+                                     static_cast<int64_t>(0));
+  int64_t right_min = Utils::Maximum(Range::ConstantMin(right).ConstantValue(),
+                                     static_cast<int64_t>(0));
+
+  *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,
                 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) {
@@ skipping 151 matching lines @@
     case Token::kMUL: {
       if (!Range::Mul(left_range, right_range, &min, &max)) {
         return NULL;
       }
       break;
     }
     case Token::kSHL: {
       Range::Shl(left_range, right_range, &min, &max);
       break;
     }
+    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)) {
         return NULL;
       }
       break;
     default:
       return NULL;
       break;
   }
 
@@ skipping 328 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart