Refactor some deoptimization code.

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"
 #include "vm/parser.h"
 #include "vm/stack_frame.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, compress_deopt_info, true,
             "Compress the size of the deoptimization info for optimized code.");
 DECLARE_FLAG(bool, trace_deoptimization);
 DECLARE_FLAG(bool, trace_deoptimization_verbose);
 
-DeoptimizationContext::DeoptimizationContext(intptr_t* to_frame_start,
-                                             intptr_t to_frame_size,
-                                             const Array& object_table,
-                                             intptr_t num_args,
-                                             DeoptReasonId deopt_reason)
-    : object_table_(object_table),
-      to_frame_(to_frame_start),
-      to_frame_size_(to_frame_size),
+DeoptContext::DeoptContext(const Array& object_table,
+                           intptr_t num_args,
+                           DeoptReasonId deopt_reason)
+    : object_table_(object_table.raw()),
+      to_frame_(NULL),
+      to_frame_size_(0),
       from_frame_(NULL),
       from_frame_size_(0),
-      registers_copy_(NULL),
-      fpu_registers_copy_(NULL),
+      cpu_registers_(NULL),
+      fpu_registers_(NULL),
       num_args_(num_args),
       deopt_reason_(deopt_reason),
-      isolate_(Isolate::Current()) {
-  from_frame_ = isolate_->deopt_frame_copy();
-  from_frame_size_ = isolate_->deopt_frame_copy_size();
-  registers_copy_ = isolate_->deopt_cpu_registers_copy();
-  fpu_registers_copy_ = isolate_->deopt_fpu_registers_copy();
-  // The deoptimized frame is filled starting just below the sp of its caller
-  // down to kDartFrameFixedSize words below its own sp.
-  // The chain of frame pointers is recreated from the fp of the caller.
+      isolate_(Isolate::Current()),
+      deferred_boxes_(NULL),
+      deferred_object_refs_(NULL),
+      deferred_objects_count_(0),
+      deferred_objects_(NULL) {
+}
+
+
+DeoptContext::~DeoptContext() {
+  // Delete all deferred objects.
+  for (intptr_t i = 0; i < deferred_objects_count_; i++) {
+    delete deferred_objects_[i];
+  }
+  delete[] deferred_objects_;
+  deferred_objects_ = NULL;
+  deferred_objects_count_ = 0;
+}
+
+
+void DeoptContext::SetToFrame(intptr_t* start,
+                              intptr_t size) {
+  ASSERT(start != NULL);
+  ASSERT(size >= 0);
+  ASSERT(to_frame_ == NULL);
+  to_frame_ = start;
+  to_frame_size_ = size;
+}
+
+
+void DeoptContext::SetFromFrame(intptr_t* start,
+                                intptr_t size) {
+  ASSERT(start != NULL);
+  ASSERT(size >= 0);
+  ASSERT(from_frame_ == NULL);
+  from_frame_ = start;
+  from_frame_size_ = size;
   caller_fp_ = GetFromFp();
 }
 
 
-intptr_t DeoptimizationContext::GetFromFp() const {
+void DeoptContext::SetSavedRegisters(fpu_register_t* fpu_registers,
+                                     intptr_t* cpu_registers) {
+  ASSERT(cpu_registers_ == NULL && fpu_registers_ == NULL);
+  cpu_registers_ = cpu_registers;
+  fpu_registers_ = fpu_registers;
+}
+
+
+void DeoptContext::VisitObjectPointers(ObjectPointerVisitor* visitor) {
+  visitor->VisitPointer(reinterpret_cast<RawObject**>(&object_table_));
+}
+
+
+intptr_t DeoptContext::GetFromFp() const {
   return from_frame_[from_frame_size_ - 1 - num_args_ - kParamEndSlotFromFp];
 }
 
 
-intptr_t DeoptimizationContext::GetFromPp() const {
+intptr_t DeoptContext::GetFromPp() const {
   return from_frame_[from_frame_size_ - 1 - num_args_ - kParamEndSlotFromFp +
       StackFrame::SavedCallerPpSlotFromFp()];
 }
 
 
-intptr_t DeoptimizationContext::GetFromPc() const {
+intptr_t DeoptContext::GetFromPc() const {
   return from_frame_[from_frame_size_ - num_args_ + kSavedPcSlotFromSp];
 }
 
 
-intptr_t DeoptimizationContext::GetCallerFp() const {
+intptr_t DeoptContext::GetCallerFp() const {
   return caller_fp_;
 }
 
 
-void DeoptimizationContext::SetCallerFp(intptr_t caller_fp) {
+void DeoptContext::SetCallerFp(intptr_t caller_fp) {
   caller_fp_ = caller_fp;
 }
 
 
+static void FillDeferredSlots(DeferredSlot** slot_list) {
+  DeferredSlot* slot = *slot_list;
+  *slot_list = NULL;
+
+  while (slot != NULL) {
+    DeferredSlot* current = slot;
+    slot = slot->next();
+
+    current->Materialize();
+
+    delete current;
+  }
+}
+
+
+// Materializes all deferred objects.  Returns the total number of
+// artificial arguments used during deoptimization.
+intptr_t DeoptContext::MaterializeDeferredObjects() {
+  // First materialize all unboxed "primitive" values (doubles, mints, simd)
+  // then materialize objects. The order is important: objects might be
+  // referencing boxes allocated on the first step. At the same time
+  // objects can't be referencing other deferred objects because storing
+  // an object into a field is always conservatively treated as escaping by
+  // allocation sinking and load forwarding.
+  FillDeferredSlots(&deferred_boxes_);
+  FillDeferredSlots(&deferred_object_refs_);
+
+  // Compute total number of artificial arguments used during deoptimization.
+  intptr_t deopt_arguments = 0;
+  for (intptr_t i = 0; i < DeferredObjectsCount(); i++) {
+    deopt_arguments += GetDeferredObject(i)->ArgumentCount();
+  }
+  return deopt_arguments;
+}
+
+
 // Deoptimization instruction moving value from optimized frame at
 // 'from_index' to specified slots in the unoptimized frame.
 // 'from_index' represents the slot index of the frame (0 being first argument)
 // and accounts for saved return address, frame pointer, pool pointer and pc
 // marker.
 class DeoptStackSlotInstr : public DeoptInstr {
  public:
   explicit DeoptStackSlotInstr(intptr_t from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kStackSlot; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "s%" Pd "", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     intptr_t* from_addr = deopt_context->GetFromFrameAddressAt(from_index);
     *to_addr = *from_addr;
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptStackSlotInstr);
 };
 
 
 class DeoptDoubleStackSlotInstr : public DeoptInstr {
  public:
   explicit DeoptDoubleStackSlotInstr(intptr_t from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kDoubleStackSlot; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "ds%" Pd "", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     double* from_addr = reinterpret_cast<double*>(
         deopt_context->GetFromFrameAddressAt(from_index));
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
-    Isolate::Current()->DeferDoubleMaterialization(
+    deopt_context->DeferDoubleMaterialization(
         *from_addr, reinterpret_cast<RawDouble**>(to_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 from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kInt64StackSlot; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "ms%" Pd "", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     int64_t* from_addr = reinterpret_cast<int64_t*>(
         deopt_context->GetFromFrameAddressAt(from_index));
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     if (Smi::IsValid64(*from_addr)) {
       *to_addr = reinterpret_cast<intptr_t>(
           Smi::New(static_cast<intptr_t>(*from_addr)));
     } else {
-      Isolate::Current()->DeferMintMaterialization(
+      deopt_context->DeferMintMaterialization(
           *from_addr, reinterpret_cast<RawMint**>(to_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 from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kFloat32x4StackSlot; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "f32x4s%" Pd "", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     simd128_value_t* from_addr = reinterpret_cast<simd128_value_t*>(
         deopt_context->GetFromFrameAddressAt(from_index));
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
-    Isolate::Current()->DeferFloat32x4Materialization(
+    deopt_context->DeferFloat32x4Materialization(
         *from_addr, reinterpret_cast<RawFloat32x4**>(to_addr));
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptFloat32x4StackSlotInstr);
 };
 
 
 class DeoptUint32x4StackSlotInstr : public DeoptInstr {
  public:
   explicit DeoptUint32x4StackSlotInstr(intptr_t from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kUint32x4StackSlot; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "ui32x4s%" Pd "", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     simd128_value_t* from_addr = reinterpret_cast<simd128_value_t*>(
         deopt_context->GetFromFrameAddressAt(from_index));
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
-    Isolate::Current()->DeferUint32x4Materialization(
+    deopt_context->DeferUint32x4Materialization(
         *from_addr, reinterpret_cast<RawUint32x4**>(to_addr));
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptUint32x4StackSlotInstr);
 };
 
 
@@ skipping 17 matching lines @@
         DeoptId::encode(deopt_id_);
   }
 
   virtual DeoptInstr::Kind kind() const { return kRetAddress; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "ret oti:%" Pd "(%" Pd ")", object_table_index_, deopt_id_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     Function& function = Function::Handle(deopt_context->isolate());
     function ^= deopt_context->ObjectAt(object_table_index_);
     const Code& code =
         Code::Handle(deopt_context->isolate(), function.unoptimized_code());
     ASSERT(!code.IsNull());
     uword continue_at_pc = code.GetPcForDeoptId(deopt_id_,
                                                 PcDescriptors::kDeopt);
     ASSERT(continue_at_pc != 0);
     *to_addr = continue_at_pc;
 
@@ skipping 33 matching lines @@
   }
 
   virtual intptr_t from_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kConstant; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "const oti:%" Pd "", object_table_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     const Object& obj = Object::Handle(
         deopt_context->isolate(), deopt_context->ObjectAt(object_table_index_));
     *reinterpret_cast<RawObject**>(to_addr) = obj.raw();
   }
 
  private:
   const intptr_t object_table_index_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptConstantInstr);
 };
 
 
 // Deoptimization instruction moving a CPU register.
 class DeoptRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<Register>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kRegister; }
 
   virtual const char* ToCString() const {
     return Assembler::RegisterName(reg_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     *to_addr = deopt_context->RegisterValue(reg_);
   }
 
  private:
   const Register reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptRegisterInstr);
 };
 
 
 // Deoptimization instruction moving an XMM register.
 class DeoptFpuRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptFpuRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kFpuRegister; }
 
   virtual const char* ToCString() const {
     return Assembler::FpuRegisterName(reg_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     double value = deopt_context->FpuRegisterValue(reg_);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
-    Isolate::Current()->DeferDoubleMaterialization(
+    deopt_context->DeferDoubleMaterialization(
         value, reinterpret_cast<RawDouble**>(to_addr));
   }
 
  private:
   const FpuRegister reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptFpuRegisterInstr);
 };
 
 
 class DeoptInt64FpuRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptInt64FpuRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kInt64FpuRegister; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "%s(m)", Assembler::FpuRegisterName(reg_));
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     int64_t value = deopt_context->FpuRegisterValueAsInt64(reg_);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     if (Smi::IsValid64(value)) {
       *to_addr = reinterpret_cast<intptr_t>(
           Smi::New(static_cast<intptr_t>(value)));
     } else {
-      Isolate::Current()->DeferMintMaterialization(
+      deopt_context->DeferMintMaterialization(
           value, reinterpret_cast<RawMint**>(to_addr));
     }
   }
 
  private:
   const FpuRegister reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptInt64FpuRegisterInstr);
 };
 
 
 // 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 from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kFloat32x4FpuRegister; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "%s(f32x4)", Assembler::FpuRegisterName(reg_));
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     simd128_value_t value = deopt_context->FpuRegisterValueAsSimd128(reg_);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
-    Isolate::Current()->DeferFloat32x4Materialization(
+    deopt_context->DeferFloat32x4Materialization(
         value, reinterpret_cast<RawFloat32x4**>(to_addr));
   }
 
  private:
   const FpuRegister reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptFloat32x4FpuRegisterInstr);
 };
 
 
 // Deoptimization instruction moving an XMM register.
 class DeoptUint32x4FpuRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptUint32x4FpuRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kUint32x4FpuRegister; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "%s(f32x4)", Assembler::FpuRegisterName(reg_));
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     simd128_value_t value = deopt_context->FpuRegisterValueAsSimd128(reg_);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
-    Isolate::Current()->DeferUint32x4Materialization(
+    deopt_context->DeferUint32x4Materialization(
         value, reinterpret_cast<RawUint32x4**>(to_addr));
   }
 
  private:
   const FpuRegister reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptUint32x4FpuRegisterInstr);
 };
 
 
 // Deoptimization instruction creating a PC marker for the code of
 // function at 'object_table_index'.
 class DeoptPcMarkerInstr : public DeoptInstr {
  public:
   explicit DeoptPcMarkerInstr(intptr_t object_table_index)
       : object_table_index_(object_table_index) {
     ASSERT(object_table_index >= 0);
   }
 
   virtual intptr_t from_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kPcMarker; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "pcmark oti:%" Pd "", object_table_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     Function& function = Function::Handle(deopt_context->isolate());
     function ^= deopt_context->ObjectAt(object_table_index_);
     if (function.IsNull()) {
       // Callee's PC marker is not used (pc of Deoptimize stub). Set to 0.
       *to_addr = 0;
       return;
     }
     const Code& code =
         Code::Handle(deopt_context->isolate(), function.unoptimized_code());
     ASSERT(!code.IsNull());
@@ skipping 31 matching lines @@
   }
 
   virtual intptr_t from_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kPp; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "pp oti:%" Pd "", object_table_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     Function& function = Function::Handle(deopt_context->isolate());
     function ^= deopt_context->ObjectAt(object_table_index_);
     const Code& code =
         Code::Handle(deopt_context->isolate(), function.unoptimized_code());
     ASSERT(!code.IsNull());
     const intptr_t pp = reinterpret_cast<intptr_t>(code.ObjectPool());
     *to_addr = pp;
   }
 
  private:
   intptr_t object_table_index_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptPpInstr);
 };
 
 
 // Deoptimization instruction copying the caller saved FP from optimized frame.
 class DeoptCallerFpInstr : public DeoptInstr {
  public:
   DeoptCallerFpInstr() {}
 
   virtual intptr_t from_index() const { return 0; }
   virtual DeoptInstr::Kind kind() const { return kCallerFp; }
 
   virtual const char* ToCString() const {
     return "callerfp";
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     *to_addr = deopt_context->GetCallerFp();
     deopt_context->SetCallerFp(reinterpret_cast<intptr_t>(
         to_addr - (kSavedCallerFpSlotFromFp * kWordSize)));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeoptCallerFpInstr);
 };
 
 
 // Deoptimization instruction copying the caller saved PP from optimized frame.
 class DeoptCallerPpInstr : public DeoptInstr {
  public:
   DeoptCallerPpInstr() {}
 
   virtual intptr_t from_index() const { return 0; }
   virtual DeoptInstr::Kind kind() const { return kCallerPp; }
 
   virtual const char* ToCString() const {
     return "callerpp";
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     *to_addr = deopt_context->GetFromPp();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeoptCallerPpInstr);
 };
 
 
 // Deoptimization instruction copying the caller return address from optimized
 // frame.
 class DeoptCallerPcInstr : public DeoptInstr {
  public:
   DeoptCallerPcInstr() {}
 
   virtual intptr_t from_index() const { return 0; }
   virtual DeoptInstr::Kind kind() const { return kCallerPc; }
 
   virtual const char* ToCString() const {
     return "callerpc";
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     *to_addr = deopt_context->GetFromPc();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeoptCallerPcInstr);
 };
 
 
 // Deoptimization instruction that indicates the rest of this DeoptInfo is a
 // suffix of another one.  The suffix contains the info number (0 based
@@ skipping 16 matching lines @@
     return InfoNumber::encode(info_number_) |
         SuffixLength::encode(suffix_length_);
   }
   virtual DeoptInstr::Kind kind() const { return kSuffix; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "suffix %" Pd ":%" Pd, info_number_, suffix_length_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     // The deoptimization info is uncompressed by translating away suffixes
     // before executing the instructions.
     UNREACHABLE();
   }
 
  private:
   // Static decoder functions in DeoptInstr have access to the bitfield
   // definitions.
   friend class DeoptInstr;
 
@@ skipping 18 matching lines @@
   }
 
   virtual intptr_t from_index() const { return index_; }
   virtual DeoptInstr::Kind kind() const { return kMaterializedObjectRef; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "mat ref #%" Pd "", index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
-    Isolate::Current()->DeferMaterializedObjectRef(
+    deopt_context->DeferMaterializedObjectRef(
         index_, to_addr);
   }
 
  private:
   intptr_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptMaterializedObjectRefInstr);
 };
 
 
 // Materialize object with the given number of fields.
 // Arguments for materialization (class and field-value pairs) are pushed
 // to the expression stack of the bottom-most frame.
 class DeoptMaterializeObjectInstr : public DeoptInstr {
  public:
   explicit DeoptMaterializeObjectInstr(intptr_t field_count)
       : field_count_(field_count) {
     ASSERT(field_count >= 0);
   }
 
   virtual intptr_t from_index() const { return field_count_; }
   virtual DeoptInstr::Kind kind() const { return kMaterializeObject; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "mat obj len:%" Pd "", field_count_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+  void Execute(DeoptContext* deopt_context, intptr_t* to_addr) {
     // This instructions are executed manually by the DeoptimizeWithDeoptInfo.
     UNREACHABLE();
   }
 
  private:
   intptr_t field_count_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptMaterializeObjectInstr);
 };
 
@@ skipping 368 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