Cleanup mint deoptimization instruction names

runtime/vm/deopt_instructions.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/deopt_instructions.h"
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/intermediate_language.h"
 #include "vm/locations.h"
@@ skipping 170 matching lines @@
 void DeoptContext::SetCallerFp(intptr_t caller_fp) {
   caller_fp_ = caller_fp;
 }
 
 
 static bool IsObjectInstruction(DeoptInstr::Kind kind) {
   switch (kind) {
     case DeoptInstr::kConstant:
     case DeoptInstr::kStackSlot:
     case DeoptInstr::kDoubleStackSlot:
-    case DeoptInstr::kInt64StackSlot:
-    case DeoptInstr::kInt64StackSlotPair:
+    case DeoptInstr::kMintStackSlotPair:
     case DeoptInstr::kFloat32x4StackSlot:
     case DeoptInstr::kInt32x4StackSlot:
     case DeoptInstr::kFloat64x2StackSlot:
     case DeoptInstr::kPp:
     case DeoptInstr::kCallerPp:
     case DeoptInstr::kMaterializedObjectRef:
       return true;
 
     case DeoptInstr::kRegister:
     case DeoptInstr::kFpuRegister:
-    case DeoptInstr::kInt64RegisterPair:
-    case DeoptInstr::kInt64StackSlotRegister:
+    case DeoptInstr::kMintRegisterPair:
+    case DeoptInstr::kMintStackSlotRegister:
     case DeoptInstr::kFloat32x4FpuRegister:
     case DeoptInstr::kInt32x4FpuRegister:
     case DeoptInstr::kFloat64x2FpuRegister:
       // TODO(turnidge): Sometimes we encounter a deopt instruction
       // with a register source while deoptimizing frames during
       // debugging but we haven't saved our register set.  This
       // happens specifically when using the VMService to inspect the
       // stack.  In that case, the register values will have been
       // saved before the StackOverflow runtime call but we do not
       // actually keep track of which registers were saved and
@@ skipping 219 matching lines @@
         *source_addr, reinterpret_cast<RawDouble**>(dest_addr));
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptDoubleStackSlotInstr);
 };
 
 
-class DeoptInt64StackSlotInstr : public DeoptInstr {
- public:
-  explicit DeoptInt64StackSlotInstr(intptr_t source_index)
-      : stack_slot_index_(source_index) {
-    ASSERT(stack_slot_index_ >= 0);
-  }
-
-  virtual intptr_t source_index() const { return stack_slot_index_; }
-  virtual DeoptInstr::Kind kind() const { return kInt64StackSlot; }
-
-  virtual const char* ToCString() const {
-    return Isolate::Current()->current_zone()->PrintToString(
-        "int64 stack slot:%" Pd "", stack_slot_index_);
-  }
-
-  void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
-    intptr_t source_index =
-       deopt_context->source_frame_size() - stack_slot_index_ - 1;
-    int64_t* source_addr = reinterpret_cast<int64_t*>(
-        deopt_context->GetSourceFrameAddressAt(source_index));
-    *reinterpret_cast<RawSmi**>(dest_addr) = Smi::New(0);
-    if (Smi::IsValid64(*source_addr)) {
-      *dest_addr = reinterpret_cast<intptr_t>(
-          Smi::New(static_cast<intptr_t>(*source_addr)));
-    } else {
-      deopt_context->DeferMintMaterialization(
-          *source_addr, reinterpret_cast<RawMint**>(dest_addr));
-    }
-  }
-
- private:
-  const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
-
-  DISALLOW_COPY_AND_ASSIGN(DeoptInt64StackSlotInstr);
-};
-
-
 class DeoptFloat32x4StackSlotInstr : public DeoptInstr {
  public:
   explicit DeoptFloat32x4StackSlotInstr(intptr_t source_index)
       : stack_slot_index_(source_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t source_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kFloat32x4StackSlot; }
 
@@ skipping 223 matching lines @@
         value, reinterpret_cast<RawDouble**>(dest_addr));
   }
 
  private:
   const FpuRegister reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptFpuRegisterInstr);
 };
 
 
-class DeoptInt64RegisterPairInstr: public DeoptInstr {
+class DeoptMintRegisterPairInstr: public DeoptInstr {
  public:
-  DeoptInt64RegisterPairInstr(intptr_t lo_reg_as_int, intptr_t hi_reg_as_int)
+  DeoptMintRegisterPairInstr(intptr_t lo_reg_as_int, intptr_t hi_reg_as_int)
       : lo_reg_(static_cast<Register>(lo_reg_as_int)),
         hi_reg_(static_cast<Register>(hi_reg_as_int)) {}
 
   virtual intptr_t source_index() const {
     return EncodeRegisters(static_cast<intptr_t>(lo_reg_),
                            static_cast<intptr_t>(hi_reg_));
   }
-  virtual DeoptInstr::Kind kind() const { return kInt64RegisterPair; }
+  virtual DeoptInstr::Kind kind() const { return kMintRegisterPair; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "int64 register pair: %s,%s", Assembler::RegisterName(hi_reg_),
                                       Assembler::RegisterName(lo_reg_));
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
     uint32_t lo_value = deopt_context->RegisterValue(lo_reg_);
     int32_t hi_value = deopt_context->RegisterValue(hi_reg_);
@@ skipping 22 matching lines @@
   }
 
   static intptr_t DecodeHiRegister(intptr_t v) {
     return HiRegister::decode(v);
   }
 
  private:
   const Register lo_reg_;
   const Register hi_reg_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeoptInt64RegisterPairInstr);
+  DISALLOW_COPY_AND_ASSIGN(DeoptMintRegisterPairInstr);
 };
 
 
-class DeoptInt64StackSlotPairInstr: public DeoptInstr {
+class DeoptMintStackSlotPairInstr: public DeoptInstr {
  public:
-  DeoptInt64StackSlotPairInstr(intptr_t lo_slot, intptr_t hi_slot)
+  DeoptMintStackSlotPairInstr(intptr_t lo_slot, intptr_t hi_slot)
       : lo_slot_(static_cast<Register>(lo_slot)),
         hi_slot_(static_cast<Register>(hi_slot)) {}
 
   virtual intptr_t source_index() const {
     return EncodeSlots(static_cast<intptr_t>(lo_slot_),
                        static_cast<intptr_t>(hi_slot_));
   }
-  virtual DeoptInstr::Kind kind() const { return kInt64StackSlotPair; }
+  virtual DeoptInstr::Kind kind() const { return kMintStackSlotPair; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "int64 stack slots: %" Pd", %" Pd "", lo_slot_, hi_slot_);
   }
 
   void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
     intptr_t lo_source_index =
         deopt_context->source_frame_size() - lo_slot_ - 1;
     int32_t* lo_source_addr = reinterpret_cast<int32_t*>(
@@ skipping 27 matching lines @@
   }
 
   static intptr_t DecodeHiSlot(intptr_t v) {
     return HiSlot::decode(v);
   }
 
  private:
   const intptr_t lo_slot_;
   const intptr_t hi_slot_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeoptInt64StackSlotPairInstr);
+  DISALLOW_COPY_AND_ASSIGN(DeoptMintStackSlotPairInstr);
 };
 
 
-class DeoptInt64StackSlotRegisterInstr : public DeoptInstr {
+class DeoptMintStackSlotRegisterInstr : public DeoptInstr {
  public:
-  DeoptInt64StackSlotRegisterInstr(intptr_t source_index,
-                                   intptr_t reg_as_int,
-                                   bool flip)
+  DeoptMintStackSlotRegisterInstr(intptr_t source_index,
+                                  intptr_t reg_as_int,
+                                  bool flip)
       : slot_(source_index),
         reg_(static_cast<Register>(reg_as_int)),
         flip_(flip) {
     // when flip_ is false, stack slot is low bits and reg is high bits.
     // when flip_ is true, stack slot is high bits and reg is low bits.
   }
 
   virtual intptr_t source_index() const {
     return Encode(static_cast<intptr_t>(slot_),
                   static_cast<intptr_t>(reg_),
                   flip_ ? 1 : 0);
   }
-  virtual DeoptInstr::Kind kind() const { return kInt64StackSlotRegister; }
+  virtual DeoptInstr::Kind kind() const { return kMintStackSlotRegister; }
 
   virtual const char* ToCString() const {
     if (flip_) {
       return Isolate::Current()->current_zone()->PrintToString(
           "int64 reg: %s, stack slot:  %" Pd "", Assembler::RegisterName(reg_),
                                                  slot_);
     } else {
       return Isolate::Current()->current_zone()->PrintToString(
           "int64 stack slot: %" Pd", reg: %s", slot_,
                                                Assembler::RegisterName(reg_));
@@ skipping 46 matching lines @@
   }
 
   static bool DecodeFlip(intptr_t v) {
     return Flip::decode(v);
   }
 
  private:
   const intptr_t slot_;
   const Register reg_;
   const bool flip_;
-  DISALLOW_COPY_AND_ASSIGN(DeoptInt64StackSlotRegisterInstr);
+  DISALLOW_COPY_AND_ASSIGN(DeoptMintStackSlotRegisterInstr);
 };
 
 
 // Deoptimization instruction moving an XMM register.
 class DeoptFloat32x4FpuRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptFloat32x4FpuRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t source_index() const { return static_cast<intptr_t>(reg_); }
@@ skipping 360 matching lines @@
   ASSERT(res != 0);
   return res;
 }
 
 
 DeoptInstr* DeoptInstr::Create(intptr_t kind_as_int, intptr_t source_index) {
   Kind kind = static_cast<Kind>(kind_as_int);
   switch (kind) {
     case kStackSlot: return new DeoptStackSlotInstr(source_index);
     case kDoubleStackSlot: return new DeoptDoubleStackSlotInstr(source_index);
-    case kInt64StackSlot: return new DeoptInt64StackSlotInstr(source_index);
     case kFloat32x4StackSlot:
         return new DeoptFloat32x4StackSlotInstr(source_index);
     case kFloat64x2StackSlot:
         return new DeoptFloat64x2StackSlotInstr(source_index);
     case kInt32x4StackSlot:
         return new DeoptInt32x4StackSlotInstr(source_index);
     case kRetAddress: return new DeoptRetAddressInstr(source_index);
     case kConstant: return new DeoptConstantInstr(source_index);
     case kRegister: return new DeoptRegisterInstr(source_index);
     case kFpuRegister: return new DeoptFpuRegisterInstr(source_index);
-    case kInt64RegisterPair: {
+    case kMintRegisterPair: {
       intptr_t lo_reg_as_int =
-          DeoptInt64RegisterPairInstr::LoRegister::decode(source_index);
+          DeoptMintRegisterPairInstr::LoRegister::decode(source_index);
       intptr_t hi_reg_as_int =
-          DeoptInt64RegisterPairInstr::HiRegister::decode(source_index);
-      return new DeoptInt64RegisterPairInstr(lo_reg_as_int, hi_reg_as_int);
+          DeoptMintRegisterPairInstr::HiRegister::decode(source_index);
+      return new DeoptMintRegisterPairInstr(lo_reg_as_int, hi_reg_as_int);
     }
-    case kInt64StackSlotPair: {
+    case kMintStackSlotPair: {
       intptr_t lo_slot =
-          DeoptInt64StackSlotPairInstr::LoSlot::decode(source_index);
+          DeoptMintStackSlotPairInstr::LoSlot::decode(source_index);
       intptr_t hi_slot =
-          DeoptInt64StackSlotPairInstr::HiSlot::decode(source_index);
-      return new DeoptInt64StackSlotPairInstr(lo_slot, hi_slot);
+          DeoptMintStackSlotPairInstr::HiSlot::decode(source_index);
+      return new DeoptMintStackSlotPairInstr(lo_slot, hi_slot);
     }
-    case kInt64StackSlotRegister: {
+    case kMintStackSlotRegister: {
       intptr_t slot =
-          DeoptInt64StackSlotRegisterInstr::Slot::decode(source_index);
+          DeoptMintStackSlotRegisterInstr::Slot::decode(source_index);
       intptr_t reg_as_int =
-          DeoptInt64StackSlotRegisterInstr::Reg::decode(source_index);
-      bool flip = DeoptInt64StackSlotRegisterInstr::Flip::decode(source_index);
-      return new DeoptInt64StackSlotRegisterInstr(slot, reg_as_int, flip);
+          DeoptMintStackSlotRegisterInstr::Reg::decode(source_index);
+      bool flip = DeoptMintStackSlotRegisterInstr::Flip::decode(source_index);
+      return new DeoptMintStackSlotRegisterInstr(slot, reg_as_int, flip);
     }
     case kFloat32x4FpuRegister:
         return new DeoptFloat32x4FpuRegisterInstr(source_index);
     case kFloat64x2FpuRegister:
         return new DeoptFloat64x2FpuRegisterInstr(source_index);
     case kInt32x4FpuRegister:
         return new DeoptInt32x4FpuRegisterInstr(source_index);
     case kPcMarker: return new DeoptPcMarkerInstr(source_index);
     case kPp: return new DeoptPpInstr(source_index);
     case kCallerFp: return new DeoptCallerFpInstr();
@@ skipping 130 matching lines @@
     } else {
       ASSERT(value->definition()->representation() == kUnboxedFloat64x2);
       deopt_instr =
           new(isolate()) DeoptFloat64x2FpuRegisterInstr(source_loc.fpu_reg());
     }
   } else if (source_loc.IsStackSlot()) {
     ASSERT(value->definition()->representation() == kTagged);
     intptr_t source_index = CalculateStackIndex(source_loc);
     deopt_instr = new(isolate()) DeoptStackSlotInstr(source_index);
   } else if (source_loc.IsDoubleStackSlot()) {
+    ASSERT(value->definition()->representation() == kUnboxedDouble);
     intptr_t source_index = CalculateStackIndex(source_loc);
-    if (value->definition()->representation() == kUnboxedDouble) {
-      deopt_instr = new(isolate()) DeoptDoubleStackSlotInstr(source_index);
-    } else {
-      ASSERT(value->definition()->representation() == kUnboxedMint);
-      deopt_instr = new(isolate()) DeoptInt64StackSlotInstr(source_index);
-    }
+    deopt_instr = new(isolate()) DeoptDoubleStackSlotInstr(source_index);
   } else if (source_loc.IsQuadStackSlot()) {
     intptr_t source_index = CalculateStackIndex(source_loc);
     if (value->definition()->representation() == kUnboxedFloat32x4) {
       deopt_instr = new(isolate()) DeoptFloat32x4StackSlotInstr(source_index);
     } else if (value->definition()->representation() == kUnboxedInt32x4) {
       deopt_instr = new(isolate()) DeoptInt32x4StackSlotInstr(source_index);
     } else {
       ASSERT(value->definition()->representation() == kUnboxedFloat64x2);
       deopt_instr = new(isolate()) DeoptFloat64x2StackSlotInstr(source_index);
     }
   } else if (source_loc.IsPairLocation()) {
     ASSERT(value->definition()->representation() == kUnboxedMint);
     // There are four cases to consider here:
     // (R = Register, S = Stack slot).
     // 1) R, R.
     // 2) S, S.
     // 3) R, S.
     // 4) S, R.
     PairLocation* pair = source_loc.AsPairLocation();
     if (pair->At(0).IsRegister() && pair->At(1).IsRegister()) {
       deopt_instr =
-          new(isolate()) DeoptInt64RegisterPairInstr(pair->At(0).reg(),
-                                                     pair->At(1).reg());
+          new(isolate()) DeoptMintRegisterPairInstr(pair->At(0).reg(),
+                                                    pair->At(1).reg());
     } else if (pair->At(0).IsStackSlot() && pair->At(1).IsStackSlot()) {
-      deopt_instr = new(isolate()) DeoptInt64StackSlotPairInstr(
+      deopt_instr = new(isolate()) DeoptMintStackSlotPairInstr(
           CalculateStackIndex(pair->At(0)),
           CalculateStackIndex(pair->At(1)));
     } else if (pair->At(0).IsRegister() && pair->At(1).IsStackSlot()) {
-      deopt_instr = new(isolate()) DeoptInt64StackSlotRegisterInstr(
+      deopt_instr = new(isolate()) DeoptMintStackSlotRegisterInstr(
           CalculateStackIndex(pair->At(1)),
           pair->At(0).reg(),
           true);
     } else {
       ASSERT(pair->At(0).IsStackSlot() && pair->At(1).IsRegister());
-      deopt_instr = new(isolate()) DeoptInt64StackSlotRegisterInstr(
+      deopt_instr = new(isolate()) DeoptMintStackSlotRegisterInstr(
           CalculateStackIndex(pair->At(0)),
           pair->At(1).reg(),
           false);
     }
   } else if (source_loc.IsInvalid() &&
              value->definition()->IsMaterializeObject()) {
     const intptr_t index = FindMaterialization(
         value->definition()->AsMaterializeObject());
     ASSERT(index >= 0);
     deopt_instr = new(isolate()) DeoptMaterializedObjectRefInstr(index);
@@ skipping 168 matching lines @@
                           Smi* offset,
                           DeoptInfo* info,
                           Smi* reason) {
   intptr_t i = index * kEntrySize;
   *offset ^= table.At(i);
   *info ^= table.At(i + 1);
   *reason ^= table.At(i + 2);
 }
 
 }  // namespace dart