Fix assertion failure in range analysis.

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 423 matching lines @@
 
   return (max.ConstantValue() >= new_max.ConstantValue()) ?
       max : RangeBoundary::MaxConstant(size);
 }
 
 
 // Given the current range of a phi and a newly computed range check
 // if we can perform narrowing: use newly computed minimum to improve precision
 // of the computed range. We do it only if current minimum was widened and is
 // equal to MinSmi.
-// Newly computed minimum is expected to be greater of equal then old one as
+// Newly computed minimum is expected to be greater or equal than old one as
 // we are running after widening phase.
 static RangeBoundary NarrowMin(const Range* range,
                                const Range* new_range,
                                RangeBoundary::RangeSize size) {
 #ifdef DEBUG
   const RangeBoundary min = Range::ConstantMin(range, size);
   const RangeBoundary new_min = Range::ConstantMin(new_range, size);
   ASSERT(min.ConstantValue() <= new_min.ConstantValue());
 #endif
   // TODO(vegorov): consider using negative infinity to indicate widened bound.
   return range->min().IsMinimumOrBelow(size) ? new_range->min() : range->min();
 }
 
 
 // Given the current range of a phi and a newly computed range check
 // if we can perform narrowing: use newly computed maximum to improve precision
 // of the computed range. We do it only if current maximum was widened and is
 // equal to MaxSmi.
-// Newly computed minimum is expected to be greater of equal then old one as
+// Newly computed maximum is expected to be less or equal than old one as
 // we are running after widening phase.
 static RangeBoundary NarrowMax(const Range* range,
                                const Range* new_range,
                                RangeBoundary::RangeSize size) {
 #ifdef DEBUG
   const RangeBoundary max = Range::ConstantMax(range, size);
   const RangeBoundary new_max = Range::ConstantMax(new_range, size);
   ASSERT(max.ConstantValue() >= new_max.ConstantValue());
 #endif
   // TODO(vegorov): consider using positive infinity to indicate widened bound.
@@ skipping 721 matching lines @@
   if ((range == NULL) || !range->max().IsSymbol()) return false;
 
 
   if (Utils::WillAddOverflow(range->max().offset(), a->offset())) {
     *a = RangeBoundary::PositiveInfinity();
     return true;
   }
 
   const int64_t offset = range->max().offset() + a->offset();
 
-
   *a = CanonicalizeBoundary(
       RangeBoundary::FromDefinition(range->max().symbol(), offset),
       RangeBoundary::PositiveInfinity());
 
   return true;
 }
 
 
 static bool CanonicalizeMinBoundary(RangeBoundary* a) {
   if (!a->IsSymbol()) return false;
@@ skipping 18 matching lines @@
 typedef bool (*BoundaryOp)(RangeBoundary*);
 
 static bool CanonicalizeForComparison(RangeBoundary* a,
                                       RangeBoundary* b,
                                       BoundaryOp op,
                                       const RangeBoundary& overflow) {
   if (!a->IsSymbol() || !b->IsSymbol()) {
     return false;
   }
 
-  if (DependOnSameSymbol(*a, *b)) {
-    return true;
-  }
-
-
-  RangeBoundary canonical_a = CanonicalizeBoundary(*a, overflow);
-  RangeBoundary canonical_b = CanonicalizeBoundary(*b, overflow);
+  RangeBoundary canonical_a = *a;
+  RangeBoundary canonical_b = *b;
 
   do {
     if (DependOnSameSymbol(canonical_a, canonical_b)) {
       *a = canonical_a;
       *b = canonical_b;
       return true;
     }
   } while (op(&canonical_a) || op(&canonical_b));
 
   return false;
@@ skipping 928 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart