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

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 #define RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/flags.h"
@@ skipping 421 matching lines @@
   M(CheckEitherNonSmi)                                                         \
   M(BinaryDoubleOp)                                                            \
   M(DoubleTestOp)                                                              \
   M(MathUnary)                                                                 \
   M(MathMinMax)                                                                \
   M(Box)                                                                       \
   M(Unbox)                                                                     \
   M(BoxInt64)                                                                  \
   M(UnboxInt64)                                                                \
   M(CaseInsensitiveCompareUC16)                                                \
-  M(BinaryMintOp)                                                              \
-  M(ShiftMintOp)                                                               \
-  M(UnaryMintOp)                                                               \
+  M(BinaryInt64Op)                                                             \
+  M(ShiftInt64Op)                                                              \
+  M(UnaryInt64Op)                                                              \
   M(CheckArrayBound)                                                           \
   M(GenericCheckBound)                                                         \
   M(Constraint)                                                                \
   M(StringToCharCode)                                                          \
   M(OneByteStringFromCharCode)                                                 \
   M(StringInterpolate)                                                         \
   M(InvokeMathCFunction)                                                       \
   M(TruncDivMod)                                                               \
   M(GuardFieldClass)                                                           \
   M(GuardFieldLength)                                                          \
@@ skipping 1274 matching lines @@
     ASSERT(index >= 0);
     ssa_temp_index_ = index;
   }
   bool HasSSATemp() const { return ssa_temp_index_ >= 0; }
   void ClearSSATempIndex() { ssa_temp_index_ = -1; }
   bool HasPairRepresentation() const {
 #if defined(TARGET_ARCH_X64)
     return representation() == kPairOfTagged;
 #else
     return (representation() == kPairOfTagged) ||
-           (representation() == kUnboxedMint);
+           (representation() == kUnboxedInt64);
 #endif
   }
 
   // Compile time type of the definition, which may be requested before type
   // propagation during graph building.
   CompileType* Type() {
     if (type_ == NULL) {
       type_ = new CompileType(ComputeType());
     }
     return type_;
@@ skipping 1393 matching lines @@
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
-    if (operation_cid() == kMintCid) return kUnboxedMint;
+    if (operation_cid() == kMintCid) return kUnboxedInt64;
     return kTagged;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareInstr);
 };
 
 class RelationalOpInstr : public TemplateComparison<2, NoThrow, Pure> {
@@ skipping 15 matching lines @@
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
-    if (operation_cid() == kMintCid) return kUnboxedMint;
+    if (operation_cid() == kMintCid) return kUnboxedInt64;
     return kTagged;
   }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RelationalOpInstr);
 };
 
 // TODO(vegorov): ComparisonInstr should be switched to use IfTheElseInstr for
@@ skipping 1501 matching lines @@
 };
 
 class Boxing : public AllStatic {
  public:
   static bool Supports(Representation rep) {
     switch (rep) {
       case kUnboxedDouble:
       case kUnboxedFloat32x4:
       case kUnboxedFloat64x2:
       case kUnboxedInt32x4:
-      case kUnboxedMint:
+      case kUnboxedInt64:
       case kUnboxedInt32:
       case kUnboxedUint32:
         return true;
       default:
         return false;
     }
   }
 
   static intptr_t ValueOffset(Representation rep) {
     switch (rep) {
       case kUnboxedDouble:
         return Double::value_offset();
 
       case kUnboxedFloat32x4:
         return Float32x4::value_offset();
 
       case kUnboxedFloat64x2:
         return Float64x2::value_offset();
 
       case kUnboxedInt32x4:
         return Int32x4::value_offset();
 
-      case kUnboxedMint:
+      case kUnboxedInt64:
         return Mint::value_offset();
 
       default:
         UNREACHABLE();
         return 0;
     }
   }
 
   static intptr_t BoxCid(Representation rep) {
     switch (rep) {
-      case kUnboxedMint:
+      case kUnboxedInt64:
         return kMintCid;
       case kUnboxedDouble:
         return kDoubleCid;
       case kUnboxedFloat32x4:
         return kFloat32x4Cid;
       case kUnboxedFloat64x2:
         return kFloat64x2Cid;
       case kUnboxedInt32x4:
         return kInt32x4Cid;
       default:
@@ skipping 93 matching lines @@
       : BoxInteger32Instr(kUnboxedUint32, value) {}
 
   DECLARE_INSTRUCTION_NO_BACKEND(BoxUint32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxUint32Instr);
 };
 
 class BoxInt64Instr : public BoxIntegerInstr {
  public:
-  explicit BoxInt64Instr(Value* value) : BoxIntegerInstr(kUnboxedMint, value) {}
+  explicit BoxInt64Instr(Value* value)
+      : BoxIntegerInstr(kUnboxedInt64, value) {}
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DECLARE_INSTRUCTION(BoxInt64)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInt64Instr);
 };
 
 class UnboxInstr : public TemplateDefinition<1, NoThrow, Pure> {
@@ skipping 126 matching lines @@
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxInt32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt32Instr);
 };
 
 class UnboxInt64Instr : public UnboxIntegerInstr {
  public:
   UnboxInt64Instr(Value* value, intptr_t deopt_id)
-      : UnboxIntegerInstr(kUnboxedMint, kNoTruncation, value, deopt_id) {}
+      : UnboxIntegerInstr(kUnboxedInt64, kNoTruncation, value, deopt_id) {}
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxInt64)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt64Instr);
 };
 
 bool Definition::IsMintDefinition() {
-  return (Type()->ToCid() == kMintCid) || IsBinaryMintOp() || IsUnaryMintOp() ||
-         IsShiftMintOp() || IsBoxInt64() || IsUnboxInt64();
+  return (Type()->ToCid() == kMintCid) || IsBinaryInt64Op() ||
+         IsUnaryInt64Op() || IsShiftInt64Op() || IsBoxInt64() || IsUnboxInt64();
 }
 
 class MathUnaryInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   enum MathUnaryKind {
     kIllegal,
     kSqrt,
     kDoubleSquare,
   };
   MathUnaryInstr(MathUnaryKind kind, Value* value, intptr_t deopt_id)
@@ skipping 1664 matching lines @@
     ASSERT(idx == 0);
     return kUnboxedUint32;
   }
 
   DECLARE_INSTRUCTION(UnaryUint32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnaryUint32OpInstr);
 };
 
-class UnaryMintOpInstr : public UnaryIntegerOpInstr {
+class UnaryInt64OpInstr : public UnaryIntegerOpInstr {
  public:
-  UnaryMintOpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
+  UnaryInt64OpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : UnaryIntegerOpInstr(op_kind, value, deopt_id) {
     ASSERT(op_kind == Token::kBIT_NOT);
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual CompileType ComputeType() const;
 
-  virtual Representation representation() const { return kUnboxedMint; }
+  virtual Representation representation() const { return kUnboxedInt64; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
-    return kUnboxedMint;
+    return kUnboxedInt64;
   }
 
-  DECLARE_INSTRUCTION(UnaryMintOp)
+  DECLARE_INSTRUCTION(UnaryInt64Op)
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(UnaryMintOpInstr);
+  DISALLOW_COPY_AND_ASSIGN(UnaryInt64OpInstr);
 };
 
 class CheckedSmiOpInstr : public TemplateDefinition<2, Throws> {
  public:
   CheckedSmiOpInstr(Token::Kind op_kind,
                     Value* left,
                     Value* right,
                     InstanceCallInstr* call)
       : TemplateDefinition(call->deopt_id()), call_(call), op_kind_(op_kind) {
     ASSERT(call->type_args_len() == 0);
@@ skipping 272 matching lines @@
   }
 
   virtual CompileType ComputeType() const;
 
   DECLARE_INSTRUCTION(ShiftUint32Op)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShiftUint32OpInstr);
 };
 
-class BinaryMintOpInstr : public BinaryIntegerOpInstr {
+class BinaryInt64OpInstr : public BinaryIntegerOpInstr {
  public:
-  BinaryMintOpInstr(Token::Kind op_kind,
-                    Value* left,
-                    Value* right,
-                    intptr_t deopt_id)
+  BinaryInt64OpInstr(Token::Kind op_kind,
+                     Value* left,
+                     Value* right,
+                     intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id) {
     if (FLAG_limit_ints_to_64_bits) {
       mark_truncating();
     }
   }
 
   virtual bool ComputeCanDeoptimize() const {
     switch (op_kind()) {
       case Token::kADD:
       case Token::kSUB:
         return can_overflow();
       case Token::kMUL:
 // Note that ARM64 does not support operations with unboxed mints,
 // so it is not handled here.
 #if defined(TARGET_ARCH_X64)
         return can_overflow();  // Deopt if overflow.
 #else
         // IA32, ARM
         return true;  // Deopt if inputs are not int32.
 #endif
       default:
         return false;
     }
   }
 
-  virtual Representation representation() const { return kUnboxedMint; }
+  virtual Representation representation() const { return kUnboxedInt64; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
-    return kUnboxedMint;
+    return kUnboxedInt64;
   }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
-  DECLARE_INSTRUCTION(BinaryMintOp)
+  DECLARE_INSTRUCTION(BinaryInt64Op)
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(BinaryMintOpInstr);
+  DISALLOW_COPY_AND_ASSIGN(BinaryInt64OpInstr);
 };
 
-class ShiftMintOpInstr : public BinaryIntegerOpInstr {
+class ShiftInt64OpInstr : public BinaryIntegerOpInstr {
  public:
-  ShiftMintOpInstr(Token::Kind op_kind,
-                   Value* left,
-                   Value* right,
-                   intptr_t deopt_id)
+  ShiftInt64OpInstr(Token::Kind op_kind,
+                    Value* left,
+                    Value* right,
+                    intptr_t deopt_id)
       : BinaryIntegerOpInstr(op_kind, left, right, deopt_id),
         shift_range_(NULL) {
     ASSERT((op_kind == Token::kSHR) || (op_kind == Token::kSHL));
     if (FLAG_limit_ints_to_64_bits) {
       mark_truncating();
     }
   }
 
   Range* shift_range() const { return shift_range_; }
 
   virtual bool ComputeCanDeoptimize() const {
     return (!IsShiftCountInRange()) ||
            (can_overflow() && (op_kind() == Token::kSHL));
   }
 
-  virtual Representation representation() const { return kUnboxedMint; }
+  virtual Representation representation() const { return kUnboxedInt64; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
-    return (idx == 0) ? kUnboxedMint : kTagged;
+    return (idx == 0) ? kUnboxedInt64 : kTagged;
   }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
   virtual CompileType ComputeType() const;
 
-  DECLARE_INSTRUCTION(ShiftMintOp)
+  DECLARE_INSTRUCTION(ShiftInt64Op)
 
  private:
   static const intptr_t kMintShiftCountLimit = 63;
 
   // Returns true if the shift amount is guranteed to be in
   // [0..kMintShiftCountLimit] range.
   bool IsShiftCountInRange() const;
 
   Range* shift_range_;
 
-  DISALLOW_COPY_AND_ASSIGN(ShiftMintOpInstr);
+  DISALLOW_COPY_AND_ASSIGN(ShiftInt64OpInstr);
 };
 
 // Handles only NEGATE.
 class UnaryDoubleOpInstr : public TemplateDefinition<1, NoThrow, Pure> {
  public:
   UnaryDoubleOpInstr(Token::Kind op_kind, Value* value, intptr_t deopt_id)
       : TemplateDefinition(deopt_id), op_kind_(op_kind) {
     ASSERT(op_kind == Token::kNEGATE);
     SetInputAt(0, value);
   }
@@ skipping 132 matching lines @@
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(MintToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const {
     ASSERT(index == 0);
-    return kUnboxedMint;
+    return kUnboxedInt64;
   }
 
   virtual Representation representation() const { return kUnboxedDouble; }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
@@ skipping 507 matching lines @@
  public:
   UnboxedIntConverterInstr(Representation from,
                            Representation to,
                            Value* value,
                            intptr_t deopt_id)
       : TemplateDefinition(deopt_id),
         from_representation_(from),
         to_representation_(to),
         is_truncating_(to == kUnboxedUint32) {
     ASSERT(from != to);
-    ASSERT((from == kUnboxedMint) || (from == kUnboxedUint32) ||
+    ASSERT((from == kUnboxedInt64) || (from == kUnboxedUint32) ||
            (from == kUnboxedInt32));
-    ASSERT((to == kUnboxedMint) || (to == kUnboxedUint32) ||
+    ASSERT((to == kUnboxedInt64) || (to == kUnboxedUint32) ||
            (to == kUnboxedInt32));
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   Representation from() const { return from_representation_; }
   Representation to() const { return to_representation_; }
   bool is_truncating() const { return is_truncating_; }
 
@@ skipping 295 matching lines @@
 #define DEFINE_UNIMPLEMENTED_INSTRUCTION(Name)                                 \
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {     \
     UNIMPLEMENTED();                                                           \
     return NULL;                                                               \
   }                                                                            \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_