Use range information for optimizing integer boxing and fix bug in range analysis.

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 300 matching lines @@
   return class_id() == other_load->class_id();
 }
 
 
 ConstantInstr::ConstantInstr(const Object& value) : value_(value) {
   // Check that the value is not an incorrect Integer representation.
   ASSERT(!value.IsBigint() ||
          !BigintOperations::FitsIntoSmi(Bigint::Cast(value)));
   ASSERT(!value.IsBigint() ||
          !BigintOperations::FitsIntoInt64(Bigint::Cast(value)));
-  ASSERT(!value.IsMint() || !Smi::IsValid64(Mint::Cast(value).AsInt64Value()));
+  ASSERT(!value.IsMint() || !Smi::IsValid(Mint::Cast(value).AsInt64Value()));
 }
 
 
 bool ConstantInstr::AttributesEqual(Instruction* other) const {
   ConstantInstr* other_constant = other->AsConstant();
   ASSERT(other_constant != NULL);
   return (value().raw() == other_constant->value().raw());
 }
 
 
@@ skipping 2263 matching lines @@
   ASSERT(value_boundary.IsConstant());
   ASSERT(shift_count >= 0);
   int64_t limit = 64 - shift_count;
   int64_t value = static_cast<int64_t>(value_boundary.ConstantValue());
 
   if ((value == 0) ||
       (shift_count == 0) ||
       ((limit > 0) && (Utils::IsInt(limit, value)))) {
     // Result stays in 64 bit range.
     int64_t result = value << shift_count;
-    return Smi::IsValid64(result) ? RangeBoundary(result) : overflow;
+    return Smi::IsValid(result) ? RangeBoundary(result) : overflow;
   }
 
   return overflow;
 }
 
 
 static RangeBoundary CanonicalizeBoundary(const RangeBoundary& a,
                                           const RangeBoundary& overflow) {
   if (a.IsConstant() || a.IsInfinity()) {
     return a;
@@ skipping 632 matching lines @@
 
   range_ = possible_range;
 
   ASSERT(!range_->min().IsUnknown() && !range_->max().IsUnknown());
 
   // Clamp value to be within mint range.
   range_->Clamp(RangeBoundary::kRangeBoundaryInt64);
 }
 
 
+void ShiftMintOpInstr::InferRange() {
+  Definition* left_defn = left()->definition();
+
+  Range* left_range = left_defn->range();
+  Range* right_range = right()->definition()->range();
+
+  if ((left_range == NULL) || (right_range == NULL)) {
+    range_ = Range::Unknown();
+    return;
+  }
+
+  Range* possible_range = Range::BinaryOp(op_kind(),
+                                          left_range,
+                                          right_range,
+                                          left_defn);
+
+  if ((range_ == NULL) && (possible_range == NULL)) {
+    // Initialize.
+    range_ = Range::Unknown();
+    return;
+  }
+
+  if (possible_range == NULL) {
+    // Nothing new.
+    return;
+  }
+
+  range_ = possible_range;
+
+  ASSERT(!range_->min().IsUnknown() && !range_->max().IsUnknown());
+
+  // Clamp value to be within mint range.
+  range_->Clamp(RangeBoundary::kRangeBoundaryInt64);
+}
+

[Vyacheslav Egorov (Google), 2014/06/24 12:18:12]

one more empty line

[Florian Schneider, 2014/06/24 12:35:06]

Done.

+void BoxIntegerInstr::InferRange() {
+  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;
+  }
+}
+
+
 bool Range::IsPositive() const {
   if (min().IsNegativeInfinity()) {
     return false;
   }
   if (min().LowerBound().ConstantValue() < 0) {
     return false;
   }
   if (max().IsPositiveInfinity()) {
     return true;
   }
@@ skipping 228 matching lines @@
   ASSERT(right_range != NULL);
   ASSERT(result_min != NULL);
   ASSERT(result_max != NULL);
 
   const int64_t left_max = ConstantAbsMax(left_range);
   const int64_t right_max = ConstantAbsMax(right_range);
   if ((left_max <= -kSmiMin) && (right_max <= -kSmiMin) &&
       ((left_max == 0) || (right_max <= kMaxInt64 / left_max))) {
     // Product of left and right max values stays in 64 bit range.
     const int64_t mul_max = left_max * right_max;
-    if (Smi::IsValid64(mul_max) && Smi::IsValid64(-mul_max)) {
+    if (Smi::IsValid(mul_max) && Smi::IsValid(-mul_max)) {
       const intptr_t r_min =
           OnlyPositiveOrZero(*left_range, *right_range) ? 0 : -mul_max;
       *result_min = RangeBoundary::FromConstant(r_min);
       const intptr_t r_max =
           OnlyNegativeOrZero(*left_range, *right_range) ? 0 : mul_max;
       *result_max = RangeBoundary::FromConstant(r_max);
       return true;
     }
   }
   return false;
@@ skipping 400 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart