Simplify range analysis algorithm.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2012, 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/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 2069 matching lines @@
 
 RangeBoundary RangeBoundary::UpperBound() const {
   if (IsConstant()) return *this;
   if (symbol()->range() == NULL) return MaxSmi();
   return Add(symbol()->range()->max().UpperBound(),
              RangeBoundary::FromConstant(offset_),
              MaxSmi());
 }
 
 
-bool Definition::InferRange(RangeOperator op) {
+void Definition::InferRange() {
   ASSERT(GetPropagatedCid() == kSmiCid);  // Has meaning only for smis.
   if (range_ == NULL) {
     range_ = Range::Unknown();
-    return true;
   }
-  return false;
 }
 
 
-bool ConstantInstr::InferRange(RangeOperator op) {
+void ConstantInstr::InferRange() {
   ASSERT(value_.IsSmi());
   if (range_ == NULL) {
     intptr_t value = Smi::Cast(value_).Value();
     range_ = new Range(RangeBoundary::FromConstant(value),
                        RangeBoundary::FromConstant(value));
-    return true;
   }
-  return false;
 }
 
 
-bool ConstraintInstr::InferRange(RangeOperator op) {
+void ConstraintInstr::InferRange() {
   Range* value_range = value()->definition()->range();
 
   // Compute intersection of constraint and value ranges.
-  return Range::Update(&range_,
+  range_ = new Range(
       RangeBoundary::Max(Range::ConstantMin(value_range),
                          Range::ConstantMin(constraint())),
       RangeBoundary::Min(Range::ConstantMax(value_range),
                          Range::ConstantMax(constraint())));
 }
 
 
-bool PhiInstr::InferRange(RangeOperator op) {
+void PhiInstr::InferRange() {
   RangeBoundary new_min;
   RangeBoundary new_max;
 
   for (intptr_t i = 0; i < InputCount(); i++) {
     Range* input_range = InputAt(i)->definition()->range();
     if (input_range == NULL) {
-      continue;
+      range_ = Range::Unknown();
+      return;
     }
 
     if (new_min.IsUnknown()) {
       new_min = Range::ConstantMin(input_range);
     } else {
       new_min = RangeBoundary::Min(new_min, Range::ConstantMin(input_range));
     }
 
     if (new_max.IsUnknown()) {
       new_max = Range::ConstantMax(input_range);
     } else {
       new_max = RangeBoundary::Max(new_max, Range::ConstantMax(input_range));
     }
   }
 
   ASSERT(new_min.IsUnknown() == new_max.IsUnknown());
   if (new_min.IsUnknown()) {
     range_ = Range::Unknown();
-    return false;
+    return;
   }
 
-  if (op == Definition::kRangeWiden) {
-    // Apply widening operator.
-    new_min = RangeBoundary::WidenMin(range_->min(), new_min);
-    new_max = RangeBoundary::WidenMax(range_->max(), new_max);
-  } else if (op == Definition::kRangeNarrow) {
-    // Apply narrowing operator.
-    new_min = RangeBoundary::NarrowMin(range_->min(), new_min);
-    new_max = RangeBoundary::NarrowMax(range_->max(), new_max);
-  }
-
-  return Range::Update(&range_, new_min, new_max);
+  range_ = new Range(new_min, new_max);
 }
 
 
-bool BinarySmiOpInstr::InferRange(RangeOperator op) {
+void BinarySmiOpInstr::InferRange() {
   Range* left_range = left()->definition()->range();
   Range* right_range = right()->definition()->range();
 
   if ((left_range == NULL) || (right_range == NULL)) {
-    return Range::Update(&range_,
-                         RangeBoundary::MinSmi(),
-                         RangeBoundary::MaxSmi());
+    range_ = new Range(RangeBoundary::MinSmi(), RangeBoundary::MaxSmi());
+    return;
   }
 
   RangeBoundary new_min;
   RangeBoundary new_max;
   switch (op_kind()) {
     case Token::kADD:
       new_min =
         RangeBoundary::Add(Range::ConstantMin(left_range),
                            Range::ConstantMin(right_range),
                            RangeBoundary::OverflowedMinSmi());
@@ skipping 10 matching lines @@
                            RangeBoundary::OverflowedMinSmi());
       new_max =
         RangeBoundary::Sub(Range::ConstantMax(left_range),
                            Range::ConstantMin(right_range),
                            RangeBoundary::OverflowedMaxSmi());
       break;
 
     default:
       if (range_ == NULL) {
         range_ = Range::Unknown();
-        return true;
       }
-      return false;
+      return;
   }
 
   ASSERT(!new_min.IsUnknown() && !new_max.IsUnknown());
   set_overflow(new_min.Overflowed() || new_max.Overflowed());
 
-  if (op == Definition::kRangeNarrow) {
-    new_min = new_min.Clamp();
-    new_max = new_max.Clamp();
-  }
-
-  return Range::Update(&range_, new_min, new_max);
+  range_ = new Range(new_min.Clamp(), new_max.Clamp());
 }
 
 
 #undef __
 
 }  // namespace dart