Use same range info when emitting code and computing if instruction can deopt.

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 2238 matching lines @@
   return DependOnSameSymbol(min(), max()) && min().offset() > max().offset();
 }
 
 
 void Range::Clamp(RangeBoundary::RangeSize size) {
   min_ = min_.Clamp(size);
   max_ = max_.Clamp(size);
 }
 
 
+void Range::ClampToConstant(RangeBoundary::RangeSize size) {
+  min_ = min_.LowerBound().Clamp(size);
+  max_ = max_.UpperBound().Clamp(size);
+}
+
+
 void Range::Shl(const Range* left,
                 const Range* right,
                 RangeBoundary* result_min,
                 RangeBoundary* result_max) {
   ASSERT(left != NULL);
   ASSERT(right != NULL);
   ASSERT(result_min != NULL);
   ASSERT(result_max != NULL);
   RangeBoundary left_max = Range::ConstantMax(left);
   RangeBoundary left_min = Range::ConstantMin(left);
@@ skipping 610 matching lines @@
   // Calculate overflowed status before clamping if operation is
   // not truncating.
   if (!is_truncating()) {
     set_can_overflow(!range->Fits(range_size));
   }
 
   range->Clamp(range_size);
 }
 
 
+static void CacheRange(Range** slot,
+                       const Range* range,
+                       RangeBoundary::RangeSize size) {
+  if (range != NULL) {
+    if (*slot == NULL) {
+      *slot = new Range();
+    }
+    **slot = *range;
+
+    // Eliminate any symbolic dependencies from the range information.
+    (*slot)->ClampToConstant(size);
+  } else if (*slot != NULL) {
+    **slot = Range();  // Clear cached range information.
+  }
+}
+
+
 void BinarySmiOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
+  const Range* right_smi_range = analysis->GetSmiRange(right());
   // TODO(vegorov) completely remove this once GetSmiRange is eliminated.
-  InferRangeHelper(analysis->GetSmiRange(left()),
-                   analysis->GetSmiRange(right()), range);
+  if (op_kind() == Token::kSHR || op_kind() == Token::kSHL ||
+      op_kind() == Token::kMOD || op_kind() == Token::kTRUNCDIV) {
+    CacheRange(&right_range_, right_smi_range,
+               RangeBoundary::kRangeBoundarySmi);
+  }
+  InferRangeHelper(analysis->GetSmiRange(left()), right_smi_range, range);
 }
 
 
 void BinaryInt32OpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   InferRangeHelper(analysis->GetSmiRange(left()),
                    analysis->GetSmiRange(right()), range);
 }
 
 
 void BinaryMintOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   InferRangeHelper(left()->definition()->range(),
                    right()->definition()->range(), range);
 }
 
 
 void ShiftMintOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
+  CacheRange(&shift_range_, right()->definition()->range(),
+             RangeBoundary::kRangeBoundaryInt64);
   InferRangeHelper(left()->definition()->range(),
                    right()->definition()->range(), range);
 }
 
 
 void BoxIntegerInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   const Range* value_range = value()->definition()->range();
   if (!Range::IsUnknown(value_range)) {
     *range = *value_range;
   }
@@ skipping 127 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart