Don't check for reaching type in the RangeAnalysis::GetRange.

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 181 matching lines @@
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 ConstraintInstr* RangeAnalysis::InsertConstraintFor(Value* use,
                                                     Definition* defn,
                                                     Range* constraint_range,
                                                     Instruction* after) {
-  // Avoid constraining inside the dead code.
-  if (!use->IsSmiValue()) return NULL;
-
   // No need to constrain constants.
   if (defn->IsConstant()) return NULL;
 
   // Check if the value is already constrained to avoid inserting duplicated
   // constraints.
   ConstraintInstr* constraint = after->next()->AsConstraint();
   while (constraint != NULL) {
     if ((constraint->value()->definition() == defn) &&
         constraint->constraint()->Equals(constraint_range)) {
       return NULL;
@@ skipping 100 matching lines @@
   for (intptr_t i = 0; i < values_.length(); i++) {
     InsertConstraintsFor(values_[i]);
   }
 
   for (intptr_t i = 0; i < constraints_.length(); i++) {
     InsertConstraintsFor(constraints_[i]);
   }
 }
 
 
-const Range* RangeAnalysis::GetRange(Value* value) const {
+const Range* RangeAnalysis::GetSmiRange(Value* value) const {
   Definition* defn = value->definition();
   const Range* range = defn->range();
 
-  if ((range == NULL) &&
-      (value->Type()->ToCid() == kSmiCid) &&
-      (defn->Type()->ToCid() != kSmiCid)) {
+  if ((range == NULL) && (defn->Type()->ToCid() != kSmiCid)) {
     // Type propagator determined that reaching type for this use is Smi.
     // However the definition itself is not a smi-definition and
     // thus it will never have range assigned to it. Just return the widest
     // range possible for this value.
     // We don't need to handle kMintCid here because all external mints
     // (e.g. results of loads or function call) can be used only after they
     // pass through UnboxIntegerInstr which is considered as mint-definition
     // and will have a range assigned to it.
     // Note: that we can't return NULL here because it is used as lattice's
     // bottom element to indicate that the range was not computed *yet*.
@@ skipping 1414 matching lines @@
   }
 
   return limit;
 }
 
 
 void PhiInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   ASSERT(Type()->ToCid() == kSmiCid);
   for (intptr_t i = 0; i < InputCount(); i++) {
     Value* input = InputAt(i);
-    Join(range, input->definition(), analysis->GetRange(input));
+    Join(range, input->definition(), analysis->GetSmiRange(input));
   }
 
   BlockEntryInstr* phi_block = GetBlock();
   range->set_min(EnsureAcyclicSymbol(
       phi_block, range->min(), RangeBoundary::MinSmi()));
   range->set_max(EnsureAcyclicSymbol(
       phi_block, range->max(), RangeBoundary::MaxSmi()));
 }
 
 
 void ConstantInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   if (value_.IsSmi()) {
     int64_t value = Smi::Cast(value_).Value();
     *range = Range(RangeBoundary::FromConstant(value),
                    RangeBoundary::FromConstant(value));
   } else if (value_.IsMint()) {
     int64_t value = Mint::Cast(value_).value();
     *range = Range(RangeBoundary::FromConstant(value),
                    RangeBoundary::FromConstant(value));
   } else {
     // Only Smi and Mint supported.
     UNREACHABLE();
   }
 }
 
 
 void ConstraintInstr::InferRange(RangeAnalysis* analysis, Range* range) {
-  // Only constraining smi values.
-  ASSERT(value()->IsSmiValue());
-
-  const Range* value_range = analysis->GetRange(value());
+  const Range* value_range = analysis->GetSmiRange(value());
   if (Range::IsUnknown(value_range)) {
     return;
   }
 
   // TODO(vegorov) check if precision of the analysis can be improved by
   // recognizing intersections of the form:
   //
   //       (..., S+x] ^ [S+x, ...) = [S+x, S+x]
   //
   Range result = value_range->Intersect(constraint());
@@ skipping 88 matching lines @@
   *range = Range(RangeBoundary::FromConstant(min),
                  RangeBoundary::FromConstant(max));
 }
 
 
 void BinarySmiOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   // TODO(vegorov): canonicalize BinarySmiOp to always have constant on the
   // right and a non-constant on the left.
   Definition* left_defn = left()->definition();
 
-  const Range* left_range = analysis->GetRange(left());
-  const Range* right_range = analysis->GetRange(right());
+  const Range* left_range = analysis->GetSmiRange(left());
+  const Range* right_range = analysis->GetSmiRange(right());
 
   if (Range::IsUnknown(left_range) || Range::IsUnknown(right_range)) {
     return;
   }
 
   Range::BinaryOp(op_kind(),
                   left_range,
                   right_range,
                   left_defn,
                   range);
   ASSERT(!Range::IsUnknown(range));
 
   // Calculate overflowed status before clamping.
   const bool overflowed = range->min().LowerBound().OverflowedSmi() ||
                           range->max().UpperBound().OverflowedSmi();
   set_overflow(overflowed);
 
   // Clamp value to be within smi range.
   range->Clamp(RangeBoundary::kRangeBoundarySmi);
 }
 
 
 void BinaryMintOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   // TODO(vegorov): canonicalize BinaryMintOpInstr to always have constant on
   // the right and a non-constant on the left.
   Definition* left_defn = left()->definition();
 
-  const Range* left_range = analysis->GetRange(left());
-  const Range* right_range = analysis->GetRange(right());
+  const Range* left_range = left_defn->range();
+  const Range* right_range = right()->definition()->range();
 
   if (Range::IsUnknown(left_range) || Range::IsUnknown(right_range)) {
     return;
   }
 
   Range::BinaryOp(op_kind(),
                   left_range,
                   right_range,
                   left_defn,
                   range);
   ASSERT(!Range::IsUnknown(range));
 
   // Calculate overflowed status before clamping.
   const bool overflowed = range->min().LowerBound().OverflowedMint() ||
                           range->max().UpperBound().OverflowedMint();
   set_can_overflow(overflowed);
 
   // Clamp value to be within mint range.
   range->Clamp(RangeBoundary::kRangeBoundaryInt64);
 }
 
 
 void ShiftMintOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   Definition* left_defn = left()->definition();
 
-  const Range* left_range = analysis->GetRange(left());
-  const Range* right_range = analysis->GetRange(right());
+  const Range* left_range = left_defn->range();
+  const Range* right_range = right()->definition()->range();
 
   if (Range::IsUnknown(left_range) || Range::IsUnknown(right_range)) {
     return;
   }
 
   Range::BinaryOp(op_kind(),
                   left_range,
                   right_range,
                   left_defn,
                   range);
   ASSERT(!Range::IsUnknown(range));
 
   // Calculate overflowed status before clamping.
   const bool overflowed = range->min().LowerBound().OverflowedMint() ||
                           range->max().UpperBound().OverflowedMint();
   set_can_overflow(overflowed);
 
   // Clamp value to be within mint range.
   range->Clamp(RangeBoundary::kRangeBoundaryInt64);
 }
 
 
 void BoxIntegerInstr::InferRange(RangeAnalysis* analysis, Range* range) {
-  const Range* input_range = analysis->GetRange(value());
+  const Range* input_range = value()->definition()->range();
   if (input_range != NULL) {
     bool is_smi = !input_range->min().LowerBound().OverflowedSmi() &&
                   !input_range->max().UpperBound().OverflowedSmi();
     set_is_smi(is_smi);
     // The output range is the same as the input range.
     *range = *input_range;
   }
 }
 
 
 void UnboxIntegerInstr::InferRange(RangeAnalysis* analysis, Range* range) {
-  const Range* value_range = analysis->GetRange(value());
+  const Range* value_range = value()->definition()->range();
   if (value_range != NULL) {
     *range = *value_range;
   } else if (!value()->definition()->IsMintDefinition() &&
-             (value()->Type()->ToCid() != kSmiCid)) {
+             (value()->definition()->Type()->ToCid() != kSmiCid)) {
     *range = Range::Full(RangeBoundary::kRangeBoundaryInt64);
   }
 }
 
 
 bool CheckArrayBoundInstr::IsRedundant(const RangeBoundary& length) {
   Range* index_range = index()->definition()->range();
 
   // Range of the index is unknown can't decide if the check is redundant.
   if (index_range == NULL) {
@@ skipping 38 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart