IR refactoring: consolidate all boxing and unboxing instructions.

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 488 matching lines @@
   Definition* defn = value->definition();
   const Range* range = defn->range();
 
   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
+    // pass through UnboxInt64Instr 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*.
     return &smi_range_;
   }
 
   return range;
 }
 
 
@@ skipping 1120 matching lines @@
     FlowGraphPrinter printer(*flow_graph_);
     printer.PrintBlocks();
   }
 }
 
 
 bool IntegerInstructionSelector::IsPotentialUint32Definition(Definition* def) {
   // TODO(johnmccutchan): Consider Smi operations, to avoid unnecessary tagging
   // & untagged of intermediate results.
   // TODO(johnmccutchan): Consider phis.
-  return def->IsBoxInteger()   ||   // BoxMint.
-         def->IsUnboxInteger() ||   // UnboxMint.
+  return def->IsBoxInt64() ||
+         def->IsUnboxInt64() ||
          def->IsBinaryMintOp() ||
          def->IsShiftMintOp()  ||
          def->IsUnaryMintOp();
 }
 
 
 void IntegerInstructionSelector::FindPotentialUint32Definitions() {
   if (FLAG_trace_integer_ir_selection) {
     OS::Print("++++ Finding potential Uint32 definitions:\n");
   }
@@ skipping 71 matching lines @@
         !selected_uint32_defs_->Contains(defn->ssa_temp_index())) {
       return false;
     }
   }
   return true;
 }
 
 
 bool IntegerInstructionSelector::CanBecomeUint32(Definition* def) {
   ASSERT(IsPotentialUint32Definition(def));
-  if (def->IsBoxInteger()) {
-    // If a BoxInteger's input is a candidate, the box is a candidate.
-    BoxIntegerInstr* box = def->AsBoxInteger();
-    Definition* box_input = box->value()->definition();
+  if (def->IsBoxInt64()) {
+    // If a BoxInt64's input is a candidate, the box is a candidate.
+    Definition* box_input = def->AsBoxInt64()->value()->definition();
     return selected_uint32_defs_->Contains(box_input->ssa_temp_index());
   }
   // A right shift with an input outside of Uint32 range cannot be converted
   // because we need the high bits.
   if (def->IsShiftMintOp()) {
     ShiftMintOpInstr* op = def->AsShiftMintOp();
     if (op->op_kind() == Token::kSHR) {
       Definition* shift_input = op->left()->definition();
       ASSERT(shift_input != NULL);
       Range* range = shift_input->range();
@@ skipping 54 matching lines @@
   ASSERT(IsPotentialUint32Definition(def));
   // Should not see constant instructions.
   ASSERT(!def->IsConstant());
   if (def->IsBinaryMintOp()) {
     BinaryMintOpInstr* op = def->AsBinaryMintOp();
     Token::Kind op_kind = op->op_kind();
     Value* left = op->left()->CopyWithType();
     Value* right = op->right()->CopyWithType();
     intptr_t deopt_id = op->DeoptimizationTarget();
     return new(I) BinaryUint32OpInstr(op_kind, left, right, deopt_id);
-  } else if (def->IsBoxInteger()) {
-    BoxIntegerInstr* box = def->AsBoxInteger();
-    Value* value = box->value()->CopyWithType();
+  } else if (def->IsBoxInt64()) {
+    Value* value = def->AsBoxInt64()->value()->CopyWithType();
     return new(I) BoxUint32Instr(value);
-  } else if (def->IsUnboxInteger()) {
-    UnboxIntegerInstr* unbox = def->AsUnboxInteger();
+  } else if (def->IsUnboxInt64()) {
+    UnboxInstr* unbox = def->AsUnboxInt64();
     Value* value = unbox->value()->CopyWithType();
-    intptr_t deopt_id = unbox->deopt_id();
+    intptr_t deopt_id = unbox->DeoptimizationTarget();
     return new(I) UnboxUint32Instr(value, deopt_id);
   } else if (def->IsUnaryMintOp()) {
     UnaryMintOpInstr* op = def->AsUnaryMintOp();
     Token::Kind op_kind = op->op_kind();
     Value* value = op->value()->CopyWithType();
     intptr_t deopt_id = op->DeoptimizationTarget();
     return new(I) UnaryUint32OpInstr(op_kind, value, deopt_id);
   } else if (def->IsShiftMintOp()) {
     ShiftMintOpInstr* op = def->AsShiftMintOp();
     Token::Kind op_kind = op->op_kind();
@@ skipping 1062 matching lines @@
 }
 
 
 void ShiftMintOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   InferRangeHelper(left()->definition()->range(),
                    right()->definition()->range(),
                    range);
 }
 
 
-void BoxInt32Instr::InferRange(RangeAnalysis* analysis, Range* range) {
+void BoxIntegerInstr::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) {
     const Range* value_range = analysis->GetSmiRange(value());
     if (!Range::IsUnknown(value_range)) {
       *range = *value_range;
     }
   } else if (value()->definition()->IsMintDefinition() ||
              value()->definition()->IsInt32Definition()) {
     const Range* value_range = value()->definition()->range();
     if (!Range::IsUnknown(value_range)) {
       *range = *value_range;
     }
   } else if (value()->Type()->ToCid() == kSmiCid) {
     *range = Range::Full(RangeBoundary::kRangeBoundarySmi);
   } else {
     *range = Range::Full(RangeBoundary::kRangeBoundaryInt32);
   }
 }
 
 
+void UnboxInt64Instr::InferRange(RangeAnalysis* analysis, Range* range) {
+  const Range* value_range = value()->definition()->range();
+  if (value_range != NULL) {
+    *range = *value_range;
+  } else if (!value()->definition()->IsMintDefinition() &&
+             (value()->definition()->Type()->ToCid() != kSmiCid)) {
+    *range = Range::Full(RangeBoundary::kRangeBoundaryInt64);
+  }
+}
+
+
 void UnboxedIntConverterInstr::InferRange(RangeAnalysis* analysis,
                                           Range* range) {
   ASSERT((from() == kUnboxedInt32) ||
          (from() == kUnboxedMint) ||
          (from() == kUnboxedUint32));
   ASSERT((to() == kUnboxedInt32) ||
          (to() == kUnboxedMint) ||
          (to() == kUnboxedUint32));
   const Range* value_range = value()->definition()->range();
   if (Range::IsUnknown(value_range)) {
     return;
   }
 
   if (to() == kUnboxedUint32) {
     // TODO(vegorov): improve range information for unboxing to Uint32.
     *range = Range(
         RangeBoundary::FromConstant(0),
         RangeBoundary::FromConstant(static_cast<int64_t>(kMaxUint32)));
   } else {
     *range = *value_range;
     if (to() == kUnboxedInt32) {
       range->Clamp(RangeBoundary::kRangeBoundaryInt32);
     }
   }
 }
 
 
-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;
-  }
-}
-
-
-void UnboxIntegerInstr::InferRange(RangeAnalysis* analysis, Range* range) {
-  const Range* value_range = value()->definition()->range();
-  if (value_range != NULL) {
-    *range = *value_range;
-  } else if (!value()->definition()->IsMintDefinition() &&
-             (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) {
     if (!(index()->BindsToConstant() && index()->BoundConstant().IsSmi())) {
       return false;
     }
 
     Range range;
@@ skipping 42 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart