Initial steps towards cleaning up integer arithmetic IR.

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 683 matching lines @@
                   RangeBoundary::kRangeBoundaryInt32) &&
       BinaryInt32OpInstr::IsSupported(mint_op->op_kind(),
                                       mint_op->left(),
                                       mint_op->right())) {
     BinaryInt32OpInstr* int32_op =
         new BinaryInt32OpInstr(mint_op->op_kind(),
                                mint_op->left()->CopyWithType(),
                                mint_op->right()->CopyWithType(),
                                mint_op->DeoptimizationTarget());
     int32_op->set_range(*mint_op->range());
-    int32_op->set_overflow(false);
+    int32_op->set_can_overflow(false);
     mint_op->ReplaceWith(int32_op, NULL);
   }
 }
 
 
 static void NarrowShiftMintOp(ShiftMintOpInstr* mint_op) {
   if (RangeUtils::Fits(mint_op->range(), RangeBoundary::kRangeBoundaryInt32) &&
       RangeUtils::Fits(mint_op->left()->definition()->range(),
                   RangeBoundary::kRangeBoundaryInt32) &&
       RangeUtils::Fits(mint_op->right()->definition()->range(),
                   RangeBoundary::kRangeBoundaryInt32) &&
       BinaryInt32OpInstr::IsSupported(mint_op->op_kind(),
                                       mint_op->left(),
                                       mint_op->right())) {
     BinaryInt32OpInstr* int32_op =
         new BinaryInt32OpInstr(mint_op->op_kind(),
                                mint_op->left()->CopyWithType(),
                                mint_op->right()->CopyWithType(),
                                mint_op->DeoptimizationTarget());
     int32_op->set_range(*mint_op->range());
-    int32_op->set_overflow(false);
+    int32_op->set_can_overflow(false);
     mint_op->ReplaceWith(int32_op, NULL);
   }
 }
 
 
 void RangeAnalysis::NarrowMintToInt32() {
   for (intptr_t i = 0; i < binary_mint_ops_.length(); i++) {
     NarrowBinaryMintOp(binary_mint_ops_[i]);
   }
 
@@ skipping 1250 matching lines @@
 
 
 void IfThenElseInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   const intptr_t min = Utils::Minimum(if_true_, if_false_);
   const intptr_t max = Utils::Maximum(if_true_, if_false_);
   *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
+static RangeBoundary::RangeSize RepresentationToRangeSize(Representation r) {
+  switch (r) {
+    case kTagged:
+      return RangeBoundary::kRangeBoundarySmi;
+    case kUnboxedInt32:
+      return RangeBoundary::kRangeBoundaryInt32;
+    case kUnboxedMint:
+      return RangeBoundary::kRangeBoundaryInt64;
+    default:
+      UNREACHABLE();
+      return RangeBoundary::kRangeBoundarySmi;
+  }
+}
+
+
+void BinaryIntegerOpInstr::InferRangeHelper(const Range* left_range,
+                                            const Range* right_range,
+                                            Range* range) {
+  // TODO(vegorov): canonicalize BinaryIntegerOp to always have constant on the
   // right and a non-constant on the left.
-  Definition* left_defn = left()->definition();
-
-  const Range* left_range = analysis->GetSmiRange(left());
-  const Range* right_range = analysis->GetSmiRange(right());
-
-  if (Range::IsUnknown(left_range) || Range::IsUnknown(right_range)) {
+  if (Range::IsUnknown(left_range) ||
+      Range::IsUnknown(right_range)) {

[srdjan, 2014/09/11 17:38:11]

One line?

     return;
   }
 
   Range::BinaryOp(op_kind(),
                   left_range,
                   right_range,
-                  left_defn,
+                  left()->definition(),
                   range);
   ASSERT(!Range::IsUnknown(range));
 
-  // Calculate overflowed status before clamping.
-  const bool overflowed = range->min().LowerBound().OverflowedSmi() ||
-                          range->max().UpperBound().OverflowedSmi();
-  set_overflow(overflowed);
+  const RangeBoundary::RangeSize range_size =
+      RepresentationToRangeSize(representation());
 
-  // Clamp value to be within smi range.
-  range->Clamp(RangeBoundary::kRangeBoundarySmi);
+  // Calculate overflowed status before clamping if operation is
+  // not truncating.
+  if (!is_truncating()) {
+    set_can_overflow(!range->Fits(range_size));
+  }
+
+  range->Clamp(range_size);
 }
 
 
+void BinarySmiOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
+  // TODO(vegorov) completely remove this once GetSmiRange is eliminated.
+  InferRangeHelper(analysis->GetSmiRange(left()),
+                   analysis->GetSmiRange(right()),
+                   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) {
+  InferRangeHelper(left()->definition()->range(),
+                   right()->definition()->range(),
+                   range);
+}
+
+
 void BoxInt32Instr::InferRange(RangeAnalysis* analysis, Range* range) {
   const Range* value_range = value()->definition()->range();
   if (!Range::IsUnknown(value_range)) {
     *range = *value_range;
   }
 }
 
 
 void UnboxInt32Instr::InferRange(RangeAnalysis* analysis, Range* range) {
   if (value()->definition()->Type()->ToCid() == kSmiCid) {
@@ skipping 35 matching lines @@
         RangeBoundary::FromConstant(static_cast<int64_t>(kMaxUint32)));
   } else {
     *range = *value_range;
     if (to() == kUnboxedInt32) {
       range->Clamp(RangeBoundary::kRangeBoundaryInt32);
     }
   }
 }
 
 
-void BinaryInt32OpInstr::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->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.
-  set_overflow(!range->Fits(RangeBoundary::kRangeBoundaryInt32));
-
-  // Clamp value to be within smi range.
-  range->Clamp(RangeBoundary::kRangeBoundaryInt32);
-}
-
-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 = 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.
-  set_can_overflow(!range->Fits(RangeBoundary::kRangeBoundaryInt64));
-
-  // 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 = 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 = value()->definition()->range();
   if (input_range != NULL) {
     bool is_smi = input_range->Fits(RangeBoundary::kRangeBoundarySmi);
     set_is_smi(is_smi);
     // The output range is the same as the input range.
     *range = *input_range;
   }
 }
 
@@ skipping 55 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart