[vm] Rename *MintOp to *Int64Op to emphasis that they operate on unboxed values.

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 232 matching lines @@
       }
     }
 
     for (ForwardInstructionIterator instr_it(block); !instr_it.Done();
          instr_it.Advance()) {
       Instruction* current = instr_it.Current();
       Definition* defn = current->AsDefinition();
       if (defn != NULL) {
         if (defn->HasSSATemp() && IsIntegerDefinition(defn)) {
           values_.Add(defn);
-          if (defn->IsBinaryMintOp()) {
-            binary_mint_ops_.Add(defn->AsBinaryMintOp());
-          } else if (defn->IsShiftMintOp()) {
-            shift_mint_ops_.Add(defn->AsShiftMintOp());
+          if (defn->IsBinaryInt64Op()) {
+            binary_int64_ops_.Add(defn->AsBinaryInt64Op());
+          } else if (defn->IsShiftInt64Op()) {
+            shift_int64_ops_.Add(defn->AsShiftInt64Op());
           }
         }
       } else if (current->IsCheckArrayBound()) {
         bounds_checks_.Add(current->AsCheckArrayBound());
       }
     }
   }
 }
 
 // For a comparison operation return an operation for the equivalent flipped
@@ skipping 1226 matching lines @@
     // Some constraints might be constraining constraints. Unwind the chain of
     // constraints until we reach the actual definition.
     while (def->IsConstraint()) {
       def = def->AsConstraint()->value()->definition();
     }
     constraints_[i]->ReplaceUsesWith(def);
     constraints_[i]->RemoveFromGraph();
   }
 }
 
-static void NarrowBinaryMintOp(BinaryMintOpInstr* mint_op) {
-  if (RangeUtils::Fits(mint_op->range(), RangeBoundary::kRangeBoundaryInt32) &&
-      RangeUtils::Fits(mint_op->left()->definition()->range(),
+static void NarrowBinaryInt64Op(BinaryInt64OpInstr* int64_op) {
+  if (RangeUtils::Fits(int64_op->range(), RangeBoundary::kRangeBoundaryInt32) &&
+      RangeUtils::Fits(int64_op->left()->definition()->range(),
                        RangeBoundary::kRangeBoundaryInt32) &&
-      RangeUtils::Fits(mint_op->right()->definition()->range(),
+      RangeUtils::Fits(int64_op->right()->definition()->range(),
                        RangeBoundary::kRangeBoundaryInt32) &&
-      BinaryInt32OpInstr::IsSupported(mint_op->op_kind(), mint_op->left(),
-                                      mint_op->right())) {
+      BinaryInt32OpInstr::IsSupported(int64_op->op_kind(), int64_op->left(),
+                                      int64_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());
+        int64_op->op_kind(), int64_op->left()->CopyWithType(),
+        int64_op->right()->CopyWithType(), int64_op->DeoptimizationTarget());
+    int32_op->set_range(*int64_op->range());
     int32_op->set_can_overflow(false);
-    mint_op->ReplaceWith(int32_op, NULL);
+    int64_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(),
+static void NarrowShiftInt64Op(ShiftInt64OpInstr* int64_op) {
+  if (RangeUtils::Fits(int64_op->range(), RangeBoundary::kRangeBoundaryInt32) &&
+      RangeUtils::Fits(int64_op->left()->definition()->range(),
                        RangeBoundary::kRangeBoundaryInt32) &&
-      RangeUtils::Fits(mint_op->right()->definition()->range(),
+      RangeUtils::Fits(int64_op->right()->definition()->range(),
                        RangeBoundary::kRangeBoundaryInt32) &&
-      BinaryInt32OpInstr::IsSupported(mint_op->op_kind(), mint_op->left(),
-                                      mint_op->right())) {
+      BinaryInt32OpInstr::IsSupported(int64_op->op_kind(), int64_op->left(),
+                                      int64_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());
+        int64_op->op_kind(), int64_op->left()->CopyWithType(),
+        int64_op->right()->CopyWithType(), int64_op->DeoptimizationTarget());
+    int32_op->set_range(*int64_op->range());
     int32_op->set_can_overflow(false);
-    mint_op->ReplaceWith(int32_op, NULL);
+    int64_op->ReplaceWith(int32_op, NULL);
   }
 }
 
 void RangeAnalysis::NarrowMintToInt32() {
-  for (intptr_t i = 0; i < binary_mint_ops_.length(); i++) {
-    NarrowBinaryMintOp(binary_mint_ops_[i]);
+  for (intptr_t i = 0; i < binary_int64_ops_.length(); i++) {
+    NarrowBinaryInt64Op(binary_int64_ops_[i]);
   }
 
-  for (intptr_t i = 0; i < shift_mint_ops_.length(); i++) {
-    NarrowShiftMintOp(shift_mint_ops_[i]);
+  for (intptr_t i = 0; i < shift_int64_ops_.length(); i++) {
+    NarrowShiftInt64Op(shift_int64_ops_[i]);
   }
 }
 
 IntegerInstructionSelector::IntegerInstructionSelector(FlowGraph* flow_graph)
     : flow_graph_(flow_graph) {
   ASSERT(flow_graph_ != NULL);
   zone_ = flow_graph_->zone();
   selected_uint32_defs_ =
       new (zone_) BitVector(zone_, flow_graph_->current_ssa_temp_index());
 }
@@ skipping 10 matching lines @@
     THR_Print("---- after integer ir selection -------\n");
     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->IsBoxInt64() || def->IsUnboxInt64() || def->IsBinaryMintOp() ||
-         def->IsShiftMintOp() || def->IsUnaryMintOp();
+  return def->IsBoxInt64() || def->IsUnboxInt64() || def->IsBinaryInt64Op() ||
+         def->IsShiftInt64Op() || def->IsUnaryInt64Op();
 }
 
 void IntegerInstructionSelector::FindPotentialUint32Definitions() {
   if (FLAG_trace_integer_ir_selection) {
     THR_Print("++++ Finding potential Uint32 definitions:\n");
   }
 
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done(); block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
 
     for (ForwardInstructionIterator instr_it(block); !instr_it.Done();
          instr_it.Advance()) {
       Instruction* current = instr_it.Current();
       Definition* defn = current->AsDefinition();
       if ((defn != NULL) && defn->HasSSATemp()) {
         if (IsPotentialUint32Definition(defn)) {
           if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
             THR_Print("Adding %s\n", current->ToCString());
           }
           potential_uint32_defs_.Add(defn);
         }
       }
     }
   }
 }
 
-// BinaryMintOp masks and stores into unsigned typed arrays that truncate the
+// BinaryInt64Op masks and stores into unsigned typed arrays that truncate the
 // value into a Uint32 range.
 bool IntegerInstructionSelector::IsUint32NarrowingDefinition(Definition* def) {
-  if (def->IsBinaryMintOp()) {
-    BinaryMintOpInstr* op = def->AsBinaryMintOp();
+  if (def->IsBinaryInt64Op()) {
+    BinaryInt64OpInstr* op = def->AsBinaryInt64Op();
     // Must be a mask operation.
     if (op->op_kind() != Token::kBIT_AND) {
       return false;
     }
     Range* range = op->range();
     if ((range == NULL) ||
         !range->IsWithin(0, static_cast<int64_t>(kMaxUint32))) {
       return false;
     }
     return true;
@@ skipping 33 matching lines @@
 
 bool IntegerInstructionSelector::CanBecomeUint32(Definition* def) {
   ASSERT(IsPotentialUint32Definition(def));
   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 (def->IsShiftInt64Op()) {
+    ShiftInt64OpInstr* op = def->AsShiftInt64Op();
     if (op->op_kind() == Token::kSHR) {
       Definition* shift_input = op->left()->definition();
       ASSERT(shift_input != NULL);
       Range* range = shift_input->range();
       if ((range == NULL) ||
           !range->IsWithin(0, static_cast<int64_t>(kMaxUint32))) {
         return false;
       }
     }
   }
@@ skipping 39 matching lines @@
     THR_Print("Reached fixed point\n");
   }
 }
 
 Definition* IntegerInstructionSelector::ConstructReplacementFor(
     Definition* def) {
   // Should only see mint definitions.
   ASSERT(IsPotentialUint32Definition(def));
   // Should not see constant instructions.
   ASSERT(!def->IsConstant());
-  if (def->IsBinaryMintOp()) {
-    BinaryMintOpInstr* op = def->AsBinaryMintOp();
+  if (def->IsBinaryInt64Op()) {
+    BinaryInt64OpInstr* op = def->AsBinaryInt64Op();
     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 (Z) BinaryUint32OpInstr(op_kind, left, right, deopt_id);
   } else if (def->IsBoxInt64()) {
     Value* value = def->AsBoxInt64()->value()->CopyWithType();
     return new (Z) BoxUint32Instr(value);
   } else if (def->IsUnboxInt64()) {
     UnboxInstr* unbox = def->AsUnboxInt64();
     Value* value = unbox->value()->CopyWithType();
     intptr_t deopt_id = unbox->DeoptimizationTarget();
     return new (Z) UnboxUint32Instr(value, deopt_id);
-  } else if (def->IsUnaryMintOp()) {
-    UnaryMintOpInstr* op = def->AsUnaryMintOp();
+  } else if (def->IsUnaryInt64Op()) {
+    UnaryInt64OpInstr* op = def->AsUnaryInt64Op();
     Token::Kind op_kind = op->op_kind();
     Value* value = op->value()->CopyWithType();
     intptr_t deopt_id = op->DeoptimizationTarget();
     return new (Z) UnaryUint32OpInstr(op_kind, value, deopt_id);
-  } else if (def->IsShiftMintOp()) {
-    ShiftMintOpInstr* op = def->AsShiftMintOp();
+  } else if (def->IsShiftInt64Op()) {
+    ShiftInt64OpInstr* op = def->AsShiftInt64Op();
     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 (Z) ShiftUint32OpInstr(op_kind, left, right, deopt_id);
   }
   UNREACHABLE();
   return NULL;
 }
 
@@ skipping 991 matching lines @@
   *range =
       Range(RangeBoundary::FromConstant(min), RangeBoundary::FromConstant(max));
 }
 
 static RangeBoundary::RangeSize RepresentationToRangeSize(Representation r) {
   switch (r) {
     case kTagged:
       return RangeBoundary::kRangeBoundarySmi;
     case kUnboxedInt32:
       return RangeBoundary::kRangeBoundaryInt32;
-    case kUnboxedMint:
+    case kUnboxedInt64:
       return RangeBoundary::kRangeBoundaryInt64;
     default:
       UNREACHABLE();
       return RangeBoundary::kRangeBoundarySmi;
   }
 }
 
 void BinaryIntegerOpInstr::InferRangeHelper(const Range* left_range,
                                             const Range* right_range,
                                             Range* range) {
@@ skipping 44 matching lines @@
                RangeBoundary::kRangeBoundarySmi);
   }
   InferRangeHelper(analysis->GetSmiRange(left()), right_smi_range, range);
 }
 
 void BinaryInt32OpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   InferRangeHelper(analysis->GetSmiRange(left()),
                    analysis->GetSmiRange(right()), range);
 }
 
-void BinaryMintOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
+void BinaryInt64OpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   InferRangeHelper(left()->definition()->range(),
                    right()->definition()->range(), range);
 }
 
-void ShiftMintOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
+void ShiftInt64OpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   CacheRange(&shift_range_, right()->definition()->range(),
              RangeBoundary::kRangeBoundaryInt64);
   InferRangeHelper(left()->definition()->range(),
                    right()->definition()->range(), range);
 }
 
 void BoxIntegerInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   const Range* value_range = value()->definition()->range();
   if (!Range::IsUnknown(value_range)) {
     *range = *value_range;
@@ skipping 46 matching lines @@
   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) ||
+  ASSERT((from() == kUnboxedInt32) || (from() == kUnboxedInt64) ||
          (from() == kUnboxedUint32));
-  ASSERT((to() == kUnboxedInt32) || (to() == kUnboxedMint) ||
+  ASSERT((to() == kUnboxedInt32) || (to() == kUnboxedInt64) ||
          (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),
@@ skipping 53 matching lines @@
       return max.offset() < canonical_length.offset();
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 }  // namespace dart