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

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 1313 matching lines @@
       return can_overflow() || !RangeUtils::IsPositive(right_range());
 
     case Token::kMOD:
       return RangeUtils::CanBeZero(right_range());
 
     default:
       return can_overflow();
   }
 }
 
-bool ShiftMintOpInstr::IsShiftCountInRange() const {
+bool ShiftInt64OpInstr::IsShiftCountInRange() const {
   return RangeUtils::IsWithin(shift_range(), 0, kMintShiftCountLimit);
 }
 
 bool BinaryIntegerOpInstr::RightIsPowerOfTwoConstant() const {
   if (!right()->definition()->IsConstant()) return false;
   const Object& constant = right()->definition()->AsConstant()->value();
   if (!constant.IsSmi()) return false;
   const intptr_t int_value = Smi::Cast(constant).Value();
   return Utils::IsPowerOfTwo(Utils::Abs(int_value));
 }
 
 static intptr_t RepresentationBits(Representation r) {
   switch (r) {
     case kTagged:
       return kBitsPerWord - 1;
     case kUnboxedInt32:
     case kUnboxedUint32:
       return 32;
-    case kUnboxedMint:
+    case kUnboxedInt64:
       return 64;
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
 static int64_t RepresentationMask(Representation r) {
   return static_cast<int64_t>(static_cast<uint64_t>(-1) >>
                               (64 - RepresentationBits(r)));
 }
 
 static bool ToIntegerConstant(Value* value, int64_t* result) {
   if (!value->BindsToConstant()) {
     UnboxInstr* unbox = value->definition()->AsUnbox();
     if (unbox != NULL) {
       switch (unbox->representation()) {
         case kUnboxedDouble:
-        case kUnboxedMint:
+        case kUnboxedInt64:
           return ToIntegerConstant(unbox->value(), result);
 
         case kUnboxedUint32:
           if (ToIntegerConstant(unbox->value(), result)) {
             *result &= RepresentationMask(kUnboxedUint32);
             return true;
           }
           break;
 
         // No need to handle Unbox<Int32>(Constant(C)) because it gets
@@ skipping 131 matching lines @@
   UnaryIntegerOpInstr* op = NULL;
   switch (representation) {
     case kTagged:
       op = new UnarySmiOpInstr(op_kind, value, deopt_id);
       break;
     case kUnboxedInt32:
       return NULL;
     case kUnboxedUint32:
       op = new UnaryUint32OpInstr(op_kind, value, deopt_id);
       break;
-    case kUnboxedMint:
-      op = new UnaryMintOpInstr(op_kind, value, deopt_id);
+    case kUnboxedInt64:
+      op = new UnaryInt64OpInstr(op_kind, value, deopt_id);
       break;
     default:
       UNREACHABLE();
       return NULL;
   }
 
   if (op == NULL) {
     return op;
   }
 
@@ skipping 24 matching lines @@
       }
       op = new BinaryInt32OpInstr(op_kind, left, right, deopt_id);
       break;
     case kUnboxedUint32:
       if ((op_kind == Token::kSHR) || (op_kind == Token::kSHL)) {
         op = new ShiftUint32OpInstr(op_kind, left, right, deopt_id);
       } else {
         op = new BinaryUint32OpInstr(op_kind, left, right, deopt_id);
       }
       break;
-    case kUnboxedMint:
+    case kUnboxedInt64:
       if ((op_kind == Token::kSHR) || (op_kind == Token::kSHL)) {
-        op = new ShiftMintOpInstr(op_kind, left, right, deopt_id);
+        op = new ShiftInt64OpInstr(op_kind, left, right, deopt_id);
       } else {
-        op = new BinaryMintOpInstr(op_kind, left, right, deopt_id);
+        op = new BinaryInt64OpInstr(op_kind, left, right, deopt_id);
       }
       break;
     default:
       UNREACHABLE();
       return NULL;
   }
 
   if (!Range::IsUnknown(range)) {
     op->set_range(*range);
   }
@@ skipping 11 matching lines @@
   switch (rep) {
     case kTagged:  // Smi case.
       return value.IsSmi();
 
     case kUnboxedInt32:
       if (value.IsSmi() || value.IsMint()) {
         return Utils::IsInt(32, value.AsInt64Value());
       }
       return false;
 
-    case kUnboxedMint:
+    case kUnboxedInt64:
       return value.IsSmi() || value.IsMint();
 
     case kUnboxedUint32:  // Only truncating Uint32 arithmetic is supported.
     default:
       UNREACHABLE();
   }
 
   return false;
 }
 
@@ skipping 711 matching lines @@
 
 Definition* UnboxedIntConverterInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!HasUses()) return NULL;
 
   UnboxedIntConverterInstr* box_defn =
       value()->definition()->AsUnboxedIntConverter();
   if ((box_defn != NULL) && (box_defn->representation() == from())) {
     if (box_defn->from() == to()) {
       // Do not erase truncating conversions from 64-bit value to 32-bit values
       // because such conversions erase upper 32 bits.
-      if ((box_defn->from() == kUnboxedMint) && box_defn->is_truncating()) {
+      if ((box_defn->from() == kUnboxedInt64) && box_defn->is_truncating()) {
         return this;
       }
       return box_defn->value()->definition();
     }
 
     UnboxedIntConverterInstr* converter = new UnboxedIntConverterInstr(
         box_defn->from(), representation(), box_defn->value()->CopyWithType(),
         (to() == kUnboxedInt32) ? GetDeoptId() : Thread::kNoDeoptId);
     if ((representation() == kUnboxedInt32) && is_truncating()) {
       converter->mark_truncating();
     }
     flow_graph->InsertBefore(this, converter, env(), FlowGraph::kValue);
     return converter;
   }
 
   UnboxInt64Instr* unbox_defn = value()->definition()->AsUnboxInt64();
-  if (unbox_defn != NULL && (from() == kUnboxedMint) &&
+  if (unbox_defn != NULL && (from() == kUnboxedInt64) &&
       (to() == kUnboxedInt32) && unbox_defn->HasOnlyInputUse(value())) {
     // TODO(vegorov): there is a duplication of code between UnboxedIntCoverter
     // and code path that unboxes Mint into Int32. We should just schedule
     // these instructions close to each other instead of fusing them.
     Definition* replacement =
         new UnboxInt32Instr(is_truncating() ? UnboxInt32Instr::kTruncate
                                             : UnboxInt32Instr::kNoTruncation,
                             unbox_defn->value()->CopyWithType(), GetDeoptId());
     flow_graph->InsertBefore(this, replacement, env(), FlowGraph::kValue);
     return replacement;
@@ skipping 339 matching lines @@
 }
 
 BoxInstr* BoxInstr::Create(Representation from, Value* value) {
   switch (from) {
     case kUnboxedInt32:
       return new BoxInt32Instr(value);
 
     case kUnboxedUint32:
       return new BoxUint32Instr(value);
 
-    case kUnboxedMint:
+    case kUnboxedInt64:
       return new BoxInt64Instr(value);
 
     case kUnboxedDouble:
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
     case kUnboxedInt32x4:
       return new BoxInstr(from, value);
 
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 UnboxInstr* UnboxInstr::Create(Representation to,
                                Value* value,
                                intptr_t deopt_id) {
   switch (to) {
     case kUnboxedInt32:
       return new UnboxInt32Instr(UnboxInt32Instr::kNoTruncation, value,
                                  deopt_id);
 
     case kUnboxedUint32:
       return new UnboxUint32Instr(value, deopt_id);
 
-    case kUnboxedMint:
+    case kUnboxedInt64:
       return new UnboxInt64Instr(value, deopt_id);
 
     case kUnboxedDouble:
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
     case kUnboxedInt32x4:
       return new UnboxInstr(to, value, deopt_id);
 
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 bool UnboxInstr::CanConvertSmi() const {
   switch (representation()) {
     case kUnboxedDouble:
-    case kUnboxedMint:
+    case kUnboxedInt64:
       return true;
 
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
     case kUnboxedInt32x4:
       return false;
 
     default:
       UNREACHABLE();
       return false;
@@ skipping 1287 matching lines @@
                      "native function '%s' (%" Pd " arguments) cannot be found",
                      native_name().ToCString(), function().NumParameters());
   }
   set_is_auto_scope(auto_setup_scope);
   set_native_c_function(native_function);
 }
 
 #undef __
 
 }  // namespace dart