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

runtime/vm/aot_optimizer.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/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 751 matching lines @@
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Don't generate smi code if the IC data is marked because
         // of an overflow.
         operands_type = ic_data.HasDeoptReason(ICData::kDeoptBinarySmiOp)
                             ? kMintCid
                             : kSmiCid;
       } else if (HasTwoMintOrSmi(ic_data) &&
                  FlowGraphCompiler::SupportsUnboxedMints()) {
         // Don't generate mint code if the IC data is marked because of an
         // overflow.
-        if (ic_data.HasDeoptReason(ICData::kDeoptBinaryMintOp)) return false;
+        if (ic_data.HasDeoptReason(ICData::kDeoptBinaryInt64Op)) return false;
         operands_type = kMintCid;
       } else if (ShouldSpecializeForDouble(ic_data)) {
         operands_type = kDoubleCid;
       } else if (HasOnlyTwoOf(ic_data, kFloat32x4Cid)) {
         operands_type = kFloat32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kInt32x4Cid)) {
         ASSERT(op_kind != Token::kMUL);  // Int32x4 doesn't have a multiply op.
         operands_type = kInt32x4Cid;
       } else if (HasOnlyTwoOf(ic_data, kFloat64x2Cid)) {
         operands_type = kFloat64x2Cid;
@@ skipping 26 matching lines @@
       } else {
         return false;
       }
       break;
     case Token::kSHR:
     case Token::kSHL:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Left shift may overflow from smi into mint or big ints.
         // Don't generate smi code if the IC data is marked because
         // of an overflow.
-        if (ic_data.HasDeoptReason(ICData::kDeoptBinaryMintOp)) {
+        if (ic_data.HasDeoptReason(ICData::kDeoptBinaryInt64Op)) {
           return false;
         }
         operands_type = ic_data.HasDeoptReason(ICData::kDeoptBinarySmiOp)
                             ? kMintCid
                             : kSmiCid;
       } else if (HasTwoMintOrSmi(ic_data) &&
                  HasOnlyOneSmi(ICData::Handle(
                      Z, ic_data.AsUnaryClassChecksForArgNr(1)))) {
         // Don't generate mint code if the IC data is marked because of an
         // overflow.
-        if (ic_data.HasDeoptReason(ICData::kDeoptBinaryMintOp)) {
+        if (ic_data.HasDeoptReason(ICData::kDeoptBinaryInt64Op)) {
           return false;
         }
         // Check for smi/mint << smi or smi/mint >> smi.
         operands_type = kMintCid;
       } else {
         return false;
       }
       break;
     case Token::kMOD:
     case Token::kTRUNCDIV:
@@ skipping 30 matching lines @@
           call->env(), FlowGraph::kEffect);
     }
 
     BinaryDoubleOpInstr* double_bin_op = new (Z)
         BinaryDoubleOpInstr(op_kind, new (Z) Value(left), new (Z) Value(right),
                             call->deopt_id(), call->token_pos());
     ReplaceCall(call, double_bin_op);
   } else if (operands_type == kMintCid) {
     if (!FlowGraphCompiler::SupportsUnboxedMints()) return false;
     if ((op_kind == Token::kSHR) || (op_kind == Token::kSHL)) {
-      ShiftMintOpInstr* shift_op = new (Z) ShiftMintOpInstr(
+      ShiftInt64OpInstr* shift_op = new (Z) ShiftInt64OpInstr(
           op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
       ReplaceCall(call, shift_op);
     } else {
-      BinaryMintOpInstr* bin_op = new (Z) BinaryMintOpInstr(
+      BinaryInt64OpInstr* bin_op = new (Z) BinaryInt64OpInstr(
           op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
       ReplaceCall(call, bin_op);
     }
   } else if (operands_type == kFloat32x4Cid) {
     return InlineFloat32x4BinaryOp(call, op_kind);
   } else if (operands_type == kInt32x4Cid) {
     return InlineInt32x4BinaryOp(call, op_kind);
   } else if (operands_type == kFloat64x2Cid) {
     return InlineFloat64x2BinaryOp(call, op_kind);
   } else if (op_kind == Token::kMOD) {
@@ skipping 53 matching lines @@
     InsertBefore(call,
                  new (Z) CheckSmiInstr(new (Z) Value(input), call->deopt_id(),
                                        call->token_pos()),
                  call->env(), FlowGraph::kEffect);
     unary_op = new (Z)
         UnarySmiOpInstr(op_kind, new (Z) Value(input), call->deopt_id());
   } else if ((op_kind == Token::kBIT_NOT) &&
              HasOnlySmiOrMint(*call->ic_data()) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     unary_op = new (Z)
-        UnaryMintOpInstr(op_kind, new (Z) Value(input), call->deopt_id());
+        UnaryInt64OpInstr(op_kind, new (Z) Value(input), call->deopt_id());
   } else if (HasOnlyOneDouble(*call->ic_data()) &&
              (op_kind == Token::kNEGATE) && CanUnboxDouble()) {
     AddReceiverCheck(call);
     unary_op = new (Z) UnaryDoubleOpInstr(Token::kNEGATE, new (Z) Value(input),
                                           call->deopt_id());
   } else {
     return false;
   }
   ASSERT(unary_op != NULL);
   ReplaceCall(call, unary_op);
@@ skipping 1037 matching lines @@
       break;
     }
     default:
       break;
   }
 }
 
 void AotOptimizer::VisitLoadCodeUnits(LoadCodeUnitsInstr* instr) {
 // TODO(zerny): Use kUnboxedUint32 once it is fully supported/optimized.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM)
-  if (!instr->can_pack_into_smi()) instr->set_representation(kUnboxedMint);
+  if (!instr->can_pack_into_smi()) instr->set_representation(kUnboxedInt64);
 #endif
 }
 
 bool AotOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
                                            const ICData& unary_ic_data) {
   ASSERT((unary_ic_data.NumberOfChecks() > 0) &&
          (unary_ic_data.NumArgsTested() == 1));
   if (I->type_checks()) {
     // Checked mode setters are inlined like normal methods by conventional
     // inlining.
@@ skipping 60 matching lines @@
                                   FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart