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

runtime/vm/flow_graph.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/flow_graph.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 1512 matching lines @@
   const Representation to_rep =
       use->instruction()->RequiredInputRepresentation(use->use_index());
   if (from_rep == to_rep || to_rep == kNoRepresentation) {
     return;
   }
   InsertConversion(from_rep, to_rep, use, /*is_environment_use=*/false);
 }
 
 static bool IsUnboxedInteger(Representation rep) {
   return (rep == kUnboxedInt32) || (rep == kUnboxedUint32) ||
-         (rep == kUnboxedMint);
+         (rep == kUnboxedInt64);
 }
 
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
 static bool CanUnboxDouble() {
   return FlowGraphCompiler::SupportsUnboxedDoubles();
 }
 
@@ skipping 20 matching lines @@
 
   Definition* converted = NULL;
   if (IsUnboxedInteger(from) && IsUnboxedInteger(to)) {
     const intptr_t deopt_id = (to == kUnboxedInt32) && (deopt_target != NULL)
                                   ? deopt_target->DeoptimizationTarget()
                                   : Thread::kNoDeoptId;
     converted = new (Z)
         UnboxedIntConverterInstr(from, to, use->CopyWithType(), deopt_id);
   } else if ((from == kUnboxedInt32) && (to == kUnboxedDouble)) {
     converted = new Int32ToDoubleInstr(use->CopyWithType());
-  } else if ((from == kUnboxedMint) && (to == kUnboxedDouble) &&
+  } else if ((from == kUnboxedInt64) && (to == kUnboxedDouble) &&
              CanConvertUnboxedMintToDouble()) {
     const intptr_t deopt_id = (deopt_target != NULL)
                                   ? deopt_target->DeoptimizationTarget()
                                   : Thread::kNoDeoptId;
     ASSERT(CanUnboxDouble());
     converted = new MintToDoubleInstr(use->CopyWithType(), deopt_id);
   } else if ((from == kTagged) && Boxing::Supports(to)) {
     const intptr_t deopt_id = (deopt_target != NULL)
                                   ? deopt_target->DeoptimizationTarget()
                                   : Thread::kNoDeoptId;
@@ skipping 125 matching lines @@
 
       if (!has_unboxed_use) {
         should_unbox = false;
       }
     }
 
     if (should_unbox) {
       unboxed =
           RangeUtils::Fits(phi->range(), RangeBoundary::kRangeBoundaryInt32)
               ? kUnboxedInt32
-              : kUnboxedMint;
+              : kUnboxedInt64;
     }
   }
 
   phi->set_representation(unboxed);
 }
 
 void FlowGraph::SelectRepresentations() {
   // Conservatively unbox all phis that were proven to be of Double,
   // Float32x4, or Int32x4 type.
   for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
@@ skipping 149 matching lines @@
 
       const intptr_t defn_loop = loops[defn->GetBlock()->preorder_number()];
 
       // Process all inputs.
       for (intptr_t k = 0; k < defn->InputCount(); k++) {
         Definition* input = defn->InputAt(k)->definition();
         if (input->IsBinarySmiOp() && CanBeWidened(input->AsBinarySmiOp())) {
           worklist.Add(input);
         } else if (input->IsPhi() && (input->Type()->ToCid() == kSmiCid)) {
           worklist.Add(input);
-        } else if (input->IsBinaryMintOp()) {
+        } else if (input->IsBinaryInt64Op()) {
           // Mint operation produces untagged result. We avoid tagging.
           gain++;
           if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
             THR_Print("^ [%" Pd "] (i) %s\n", gain, input->ToCString());
           }
         } else if (defn_loop == loops[input->GetBlock()->preorder_number()] &&
                    (input->Type()->ToCid() == kSmiCid)) {
           // Input comes from the same loop, is known to be smi and requires
           // untagging.
           // TODO(vegorov) this heuristic assumes that values that are not
@@ skipping 21 matching lines @@
                         use->instruction()->ToCString());
             }
           }
           continue;
         } else if (use_defn->IsBinarySmiOp() &&
                    CanBeWidened(use_defn->AsBinarySmiOp())) {
           worklist.Add(use_defn);
         } else if (use_defn->IsPhi() &&
                    use_defn->AsPhi()->Type()->ToCid() == kSmiCid) {
           worklist.Add(use_defn);
-        } else if (use_defn->IsBinaryMintOp()) {
-          // BinaryMintOp requires untagging of its inputs.
-          // Converting kUnboxedInt32 to kUnboxedMint is essentially zero cost
+        } else if (use_defn->IsBinaryInt64Op()) {
+          // BinaryInt64Op requires untagging of its inputs.
+          // Converting kUnboxedInt32 to kUnboxedInt64 is essentially zero cost
           // sign extension operation.
           gain++;
           if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
             THR_Print("^ [%" Pd "] (u) %s\n", gain,
                       use->instruction()->ToCString());
           }
         } else if (defn_loop == loops[instr->GetBlock()->preorder_number()]) {
           gain--;
           if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
             THR_Print("v [%" Pd "] (u) %s\n", gain,
@@ skipping 112 matching lines @@
         BinarySmiOpInstr* binop = it.Current()->AsBinarySmiOp();
         if (binop->op_kind() == Token::kBIT_AND) {
           OptimizeLeftShiftBitAndSmiOp(&it, binop, binop->left()->definition(),
                                        binop->right()->definition());
         } else if ((binop->op_kind() == Token::kTRUNCDIV) ||
                    (binop->op_kind() == Token::kMOD)) {
           if (binop->HasUses()) {
             div_mod_merge.Add(binop);
           }
         }
-      } else if (it.Current()->IsBinaryMintOp()) {
-        BinaryMintOpInstr* mintop = it.Current()->AsBinaryMintOp();
+      } else if (it.Current()->IsBinaryInt64Op()) {
+        BinaryInt64OpInstr* mintop = it.Current()->AsBinaryInt64Op();
         if (mintop->op_kind() == Token::kBIT_AND) {
           OptimizeLeftShiftBitAndSmiOp(&it, mintop,
                                        mintop->left()->definition(),
                                        mintop->right()->definition());
         }
       } else if (it.Current()->IsInvokeMathCFunction()) {
         InvokeMathCFunctionInstr* math_unary =
             it.Current()->AsInvokeMathCFunction();
         if ((math_unary->recognized_kind() == MethodRecognizer::kMathSin) ||
             (math_unary->recognized_kind() == MethodRecognizer::kMathCos)) {
@@ skipping 94 matching lines @@
   if (bit_and_instr->InputAt(0)->IsSingleUse()) {
     smi_shift_left = AsSmiShiftLeftInstruction(left_instr);
   }
   if ((smi_shift_left == NULL) && (bit_and_instr->InputAt(1)->IsSingleUse())) {
     smi_shift_left = AsSmiShiftLeftInstruction(right_instr);
   }
   if (smi_shift_left == NULL) return;
 
   // Pattern recognized.
   smi_shift_left->mark_truncating();
-  ASSERT(bit_and_instr->IsBinarySmiOp() || bit_and_instr->IsBinaryMintOp());
-  if (bit_and_instr->IsBinaryMintOp()) {
+  ASSERT(bit_and_instr->IsBinarySmiOp() || bit_and_instr->IsBinaryInt64Op());
+  if (bit_and_instr->IsBinaryInt64Op()) {
     // Replace Mint op with Smi op.
     BinarySmiOpInstr* smi_op = new (Z) BinarySmiOpInstr(
         Token::kBIT_AND, new (Z) Value(left_instr), new (Z) Value(right_instr),
         Thread::kNoDeoptId);  // BIT_AND cannot deoptimize.
     bit_and_instr->ReplaceWith(smi_op, current_iterator);
   }
 }
 
 // Dart:
 //  var x = d % 10;
@@ skipping 69 matching lines @@
                                                 intptr_t index,
                                                 Representation rep,
                                                 intptr_t cid) {
   ExtractNthOutputInstr* extract =
       new (Z) ExtractNthOutputInstr(new (Z) Value(instr), index, rep, cid);
   instr->ReplaceUsesWith(extract);
   InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
 }  // namespace dart