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

runtime/vm/intermediate_language_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/compiler.h"
@@ skipping 3255 matching lines @@
       (CanConvertSmi() && (value()->Type()->ToCid() == kSmiCid));
 
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = needs_temp ? 1 : 0;
   LocationSummary* summary = new (zone)
       LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   if (needs_temp) {
     summary->set_temp(0, Location::RequiresRegister());
   }
-  if (representation() == kUnboxedMint) {
+  if (representation() == kUnboxedInt64) {
     summary->set_out(0, Location::Pair(Location::RegisterLocation(EAX),
                                        Location::RegisterLocation(EDX)));
   } else {
     summary->set_out(0, Location::RequiresFpuRegister());
   }
   return summary;
 }
 
 void UnboxInstr::EmitLoadFromBox(FlowGraphCompiler* compiler) {
   const Register box = locs()->in(0).reg();
 
   switch (representation()) {
-    case kUnboxedMint: {
+    case kUnboxedInt64: {
       PairLocation* result = locs()->out(0).AsPairLocation();
       __ movl(result->At(0).reg(), FieldAddress(box, ValueOffset()));
       __ movl(result->At(1).reg(),
               FieldAddress(box, ValueOffset() + kWordSize));
       break;
     }
 
     case kUnboxedDouble: {
       const FpuRegister result = locs()->out(0).fpu_reg();
       __ movsd(result, FieldAddress(box, ValueOffset()));
@@ skipping 11 matching lines @@
     default:
       UNREACHABLE();
       break;
   }
 }
 
 void UnboxInstr::EmitSmiConversion(FlowGraphCompiler* compiler) {
   const Register box = locs()->in(0).reg();
 
   switch (representation()) {
-    case kUnboxedMint: {
+    case kUnboxedInt64: {
       PairLocation* result = locs()->out(0).AsPairLocation();
       ASSERT(result->At(0).reg() == EAX);
       ASSERT(result->At(1).reg() == EDX);
       __ movl(EAX, box);
       __ SmiUntag(EAX);
       __ cdq();
       break;
     }
 
     case kUnboxedDouble: {
@@ skipping 265 matching lines @@
   summary->set_in(0, Location::RequiresRegister());
   // The smi index is either untagged (element size == 1), or it is left smi
   // tagged (for all element sizes > 1).
   summary->set_in(1, (index_scale() == 1) ? Location::WritableRegister()
                                           : Location::RequiresRegister());
   if (might_box) {
     summary->set_temp(0, Location::RequiresRegister());
     summary->set_temp(1, Location::RequiresRegister());
   }
 
-  if (representation() == kUnboxedMint) {
+  if (representation() == kUnboxedInt64) {
     summary->set_out(0, Location::Pair(Location::RequiresRegister(),
                                        Location::RequiresRegister()));
   } else {
     ASSERT(representation() == kTagged);
     summary->set_out(0, Location::RequiresRegister());
   }
 
   return summary;
 }
 
 void LoadCodeUnitsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The string register points to the backing store for external strings.
   const Register str = locs()->in(0).reg();
   const Location index = locs()->in(1);
 
   Address element_address = Assembler::ElementAddressForRegIndex(
       IsExternal(), class_id(), index_scale(), str, index.reg());
 
   if ((index_scale() == 1)) {
     __ SmiUntag(index.reg());
   }
 
-  if (representation() == kUnboxedMint) {
+  if (representation() == kUnboxedInt64) {
     ASSERT(compiler->is_optimizing());
     ASSERT(locs()->out(0).IsPairLocation());
     PairLocation* result_pair = locs()->out(0).AsPairLocation();
     Register result1 = result_pair->At(0).reg();
     Register result2 = result_pair->At(1).reg();
 
     switch (class_id()) {
       case kOneByteStringCid:
       case kExternalOneByteStringCid:
         ASSERT(element_count() == 4);
@@ skipping 2048 matching lines @@
     Register index = index_loc.reg();
     Register length = length_loc.reg();
     if (index_cid != kSmiCid) {
       __ BranchIfNotSmi(index, deopt);
     }
     __ cmpl(length, index);
     __ j(BELOW_EQUAL, deopt);
   }
 }
 
-LocationSummary* BinaryMintOpInstr::MakeLocationSummary(Zone* zone,
-                                                        bool opt) const {
+LocationSummary* BinaryInt64OpInstr::MakeLocationSummary(Zone* zone,
+                                                         bool opt) const {
   const intptr_t kNumInputs = 2;
   switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
     case Token::kADD:
     case Token::kSUB:
     case Token::kMUL: {
       const intptr_t kNumTemps = (op_kind() == Token::kMUL) ? 1 : 0;
       LocationSummary* summary = new (zone) LocationSummary(
@@ skipping 10 matching lines @@
         summary->set_temp(0, Location::RequiresRegister());
       }
       return summary;
     }
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
-void BinaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BinaryInt64OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   PairLocation* left_pair = locs()->in(0).AsPairLocation();
   Register left_lo = left_pair->At(0).reg();
   Register left_hi = left_pair->At(1).reg();
   PairLocation* right_pair = locs()->in(1).AsPairLocation();
   Register right_lo = right_pair->At(0).reg();
   Register right_hi = right_pair->At(1).reg();
   PairLocation* out_pair = locs()->out(0).AsPairLocation();
   Register out_lo = out_pair->At(0).reg();
   Register out_hi = out_pair->At(1).reg();
   ASSERT(out_lo == left_lo);
   ASSERT(out_hi == left_hi);
 
   Label* deopt = NULL;
   if (CanDeoptimize()) {
-    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
+    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryInt64Op);
   }
   switch (op_kind()) {
     case Token::kBIT_AND:
       __ andl(left_lo, right_lo);
       __ andl(left_hi, right_hi);
       break;
     case Token::kBIT_OR:
       __ orl(left_lo, right_lo);
       __ orl(left_hi, right_hi);
       break;
@@ skipping 33 matching lines @@
       __ imull(right_lo);  // Result in EDX:EAX.
       ASSERT(out_lo == EAX);
       ASSERT(out_hi == EDX);
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
-LocationSummary* ShiftMintOpInstr::MakeLocationSummary(Zone* zone,
-                                                       bool opt) const {
+LocationSummary* ShiftInt64OpInstr::MakeLocationSummary(Zone* zone,
+                                                        bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps =
       (op_kind() == Token::kSHL) && CanDeoptimize() ? 2 : 0;
   LocationSummary* summary = new (zone)
       LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::Pair(Location::RequiresRegister(),
                                     Location::RequiresRegister()));
   summary->set_in(1, Location::FixedRegisterOrSmiConstant(right(), ECX));
   if ((op_kind() == Token::kSHL) && CanDeoptimize()) {
     summary->set_temp(0, Location::RequiresRegister());
     summary->set_temp(1, Location::RequiresRegister());
   }
   summary->set_out(0, Location::SameAsFirstInput());
   return summary;
 }
 
-void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ShiftInt64OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   PairLocation* left_pair = locs()->in(0).AsPairLocation();
   Register left_lo = left_pair->At(0).reg();
   Register left_hi = left_pair->At(1).reg();
   PairLocation* out_pair = locs()->out(0).AsPairLocation();
   Register out_lo = out_pair->At(0).reg();
   Register out_hi = out_pair->At(1).reg();
   ASSERT(out_lo == left_lo);
   ASSERT(out_hi == left_hi);
 
   Label* deopt = NULL;
   if (CanDeoptimize()) {
-    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
+    deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryInt64Op);
   }
   if (locs()->in(1).IsConstant()) {
     // Code for a constant shift amount.
     ASSERT(locs()->in(1).constant().IsSmi());
     const int32_t shift = Smi::Cast(locs()->in(1).constant()).Value();
     ASSERT(shift >= 0);
     switch (op_kind()) {
       case Token::kSHR: {
         if (shift > 31) {
           __ movl(left_lo, left_hi);        // Shift by 32.
@@ skipping 138 matching lines @@
         }
         break;
       }
       default:
         UNREACHABLE();
     }
     __ Bind(&done);
   }
 }
 
-LocationSummary* UnaryMintOpInstr::MakeLocationSummary(Zone* zone,
-                                                       bool opt) const {
+LocationSummary* UnaryInt64OpInstr::MakeLocationSummary(Zone* zone,
+                                                        bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new (zone)
       LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::Pair(Location::RequiresRegister(),
                                     Location::RequiresRegister()));
   summary->set_out(0, Location::SameAsFirstInput());
   return summary;
 }
 
-void UnaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void UnaryInt64OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(op_kind() == Token::kBIT_NOT);
   PairLocation* left_pair = locs()->in(0).AsPairLocation();
   Register left_lo = left_pair->At(0).reg();
   Register left_hi = left_pair->At(1).reg();
   PairLocation* out_pair = locs()->out(0).AsPairLocation();
   Register out_lo = out_pair->At(0).reg();
   Register out_hi = out_pair->At(1).reg();
   ASSERT(out_lo == left_lo);
   ASSERT(out_hi == left_hi);
   __ notl(left_lo);
@@ skipping 24 matching lines @@
   return summary;
 }
 
 void ShiftUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t kShifterLimit = 31;
 
   Register left = locs()->in(0).reg();
   Register out = locs()->out(0).reg();
   ASSERT(left == out);
 
-  Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryMintOp);
+  Label* deopt =
+      compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinaryInt64Op);
 
   if (locs()->in(1).IsConstant()) {
     // Shifter is constant.
 
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     const intptr_t shift_value = Smi::Cast(constant).Value();
 
     // Do the shift: (shift_value > 0) && (shift_value <= kShifterLimit).
     switch (op_kind()) {
@@ skipping 71 matching lines @@
 LocationSummary* UnboxedIntConverterInstr::MakeLocationSummary(Zone* zone,
                                                                bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new (zone)
       LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   if ((from() == kUnboxedInt32 || from() == kUnboxedUint32) &&
       (to() == kUnboxedInt32 || to() == kUnboxedUint32)) {
     summary->set_in(0, Location::RequiresRegister());
     summary->set_out(0, Location::SameAsFirstInput());
-  } else if (from() == kUnboxedMint) {
+  } else if (from() == kUnboxedInt64) {
     summary->set_in(
         0, Location::Pair(CanDeoptimize() ? Location::WritableRegister()
                                           : Location::RequiresRegister(),
                           Location::RequiresRegister()));
     summary->set_out(0, Location::RequiresRegister());
   } else if (from() == kUnboxedUint32) {
     summary->set_in(0, Location::RequiresRegister());
     summary->set_out(0, Location::Pair(Location::RequiresRegister(),
                                        Location::RequiresRegister()));
   } else if (from() == kUnboxedInt32) {
@@ skipping 10 matching lines @@
     ASSERT(locs()->out(0).reg() == locs()->in(0).reg());
   } else if (from() == kUnboxedUint32 && to() == kUnboxedInt32) {
     // Representations are bitwise equivalent.
     ASSERT(locs()->out(0).reg() == locs()->in(0).reg());
     if (CanDeoptimize()) {
       Label* deopt =
           compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnboxInteger);
       __ testl(locs()->out(0).reg(), locs()->out(0).reg());
       __ j(NEGATIVE, deopt);
     }
-  } else if (from() == kUnboxedMint) {
-    // TODO(vegorov) kUnboxedMint -> kInt32 conversion is currently usually
+  } else if (from() == kUnboxedInt64) {
+    // TODO(vegorov) kUnboxedInt64 -> kInt32 conversion is currently usually
     // dominated by a CheckSmi(BoxInt64(val)) which is an artifact of ordering
     // of optimization passes and the way we check smi-ness of values.
     // Optimize it away.
     ASSERT(to() == kUnboxedInt32 || to() == kUnboxedUint32);
     PairLocation* in_pair = locs()->in(0).AsPairLocation();
     Register in_lo = in_pair->At(0).reg();
     Register in_hi = in_pair->At(1).reg();
     Register out = locs()->out(0).reg();
     // Copy low word.
     __ movl(out, in_lo);
     if (CanDeoptimize()) {
       Label* deopt =
           compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnboxInteger);
       __ sarl(in_lo, Immediate(31));
       __ cmpl(in_lo, in_hi);
       __ j(NOT_EQUAL, deopt);
     }
   } else if (from() == kUnboxedUint32) {
-    ASSERT(to() == kUnboxedMint);
+    ASSERT(to() == kUnboxedInt64);
     Register in = locs()->in(0).reg();
     PairLocation* out_pair = locs()->out(0).AsPairLocation();
     Register out_lo = out_pair->At(0).reg();
     Register out_hi = out_pair->At(1).reg();
     // Copy low word.
     __ movl(out_lo, in);
     // Zero upper word.
     __ xorl(out_hi, out_hi);
   } else if (from() == kUnboxedInt32) {
-    ASSERT(to() == kUnboxedMint);
+    ASSERT(to() == kUnboxedInt64);
     PairLocation* out_pair = locs()->out(0).AsPairLocation();
     Register out_lo = out_pair->At(0).reg();
     Register out_hi = out_pair->At(1).reg();
     ASSERT(locs()->in(0).reg() == EAX);
     ASSERT(out_lo == EAX && out_hi == EDX);
     __ cdq();
   } else {
     UNREACHABLE();
   }
 }
@@ skipping 287 matching lines @@
   ASSERT(!compiler->is_optimizing());
   __ Call(*StubCode::DebugStepCheck_entry());
   compiler->EmitCallsiteMetaData(token_pos(), deopt_id_, stub_kind_, locs());
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32