Refactor some deoptimization code.

runtime/vm/isolate.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/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "lib/mirrors.h"
 #include "vm/code_observers.h"
 #include "vm/compiler_stats.h"
 #include "vm/coverage.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
+#include "vm/deopt_instructions.h"
 #include "vm/heap.h"
 #include "vm/heap_histogram.h"
 #include "vm/message_handler.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/port.h"
 #include "vm/reusable_handles.h"
 #include "vm/service.h"
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/thread.h"
 #include "vm/timer.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, report_usage_count, false,
             "Track function usage and report.");
 DEFINE_FLAG(bool, trace_isolates, false,
             "Trace isolate creation and shut down.");
-DECLARE_FLAG(bool, trace_deoptimization_verbose);
 
 
 void Isolate::RegisterClass(const Class& cls) {
   class_table()->Register(cls);
   if (object_histogram() != NULL) object_histogram()->RegisterClass(cls);
 }
 
 
 class IsolateMessageHandler : public MessageHandler {
  public:
@@ skipping 211 matching lines @@
 
 
 #if defined(DEBUG)
 // static
 void BaseIsolate::AssertCurrent(BaseIsolate* isolate) {
   ASSERT(isolate == Isolate::Current());
 }
 #endif
 
 
-void DeferredDouble::Materialize() {
-  RawDouble** double_slot = reinterpret_cast<RawDouble**>(slot());
-  *double_slot = Double::New(value());
-
-  if (FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("materializing double at %" Px ": %g\n",
-                 reinterpret_cast<uword>(slot()), value());
-  }
-}
-
-
-void DeferredMint::Materialize() {
-  RawMint** mint_slot = reinterpret_cast<RawMint**>(slot());
-  ASSERT(!Smi::IsValid64(value()));
-  Mint& mint = Mint::Handle();
-  mint ^= Integer::New(value());
-  *mint_slot = mint.raw();
-
-  if (FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("materializing mint at %" Px ": %" Pd64 "\n",
-                 reinterpret_cast<uword>(slot()), value());
-  }
-}
-
-
-void DeferredFloat32x4::Materialize() {
-  RawFloat32x4** float32x4_slot = reinterpret_cast<RawFloat32x4**>(slot());
-  RawFloat32x4* raw_float32x4 = Float32x4::New(value());
-  *float32x4_slot = raw_float32x4;
-
-  if (FLAG_trace_deoptimization_verbose) {
-    float x = raw_float32x4->x();
-    float y = raw_float32x4->y();
-    float z = raw_float32x4->z();
-    float w = raw_float32x4->w();
-    OS::PrintErr("materializing Float32x4 at %" Px ": %g,%g,%g,%g\n",
-                 reinterpret_cast<uword>(slot()), x, y, z, w);
-  }
-}
-
-
-void DeferredUint32x4::Materialize() {
-  RawUint32x4** uint32x4_slot = reinterpret_cast<RawUint32x4**>(slot());
-  RawUint32x4* raw_uint32x4 = Uint32x4::New(value());
-  *uint32x4_slot = raw_uint32x4;
-
-  if (FLAG_trace_deoptimization_verbose) {
-    uint32_t x = raw_uint32x4->x();
-    uint32_t y = raw_uint32x4->y();
-    uint32_t z = raw_uint32x4->z();
-    uint32_t w = raw_uint32x4->w();
-    OS::PrintErr("materializing Uint32x4 at %" Px ": %x,%x,%x,%x\n",
-                 reinterpret_cast<uword>(slot()), x, y, z, w);
-  }
-}
-
-
-void DeferredObjectRef::Materialize() {
-  DeferredObject* obj = Isolate::Current()->GetDeferredObject(index());
-  *slot() = obj->object();
-  if (FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("writing instance ref at %" Px ": %s\n",
-                 reinterpret_cast<uword>(slot()),
-                 Instance::Handle(obj->object()).ToCString());
-  }
-}
-
-
-RawInstance* DeferredObject::object() {
-  if (object_ == NULL) {
-    Materialize();
-  }
-  return object_->raw();
-}
-
-
-void DeferredObject::Materialize() {
-  Class& cls = Class::Handle();
-  cls ^= GetClass();
-
-  if (FLAG_trace_deoptimization_verbose) {
-    OS::PrintErr("materializing instance of %s (%" Px ", %" Pd " fields)\n",
-                 cls.ToCString(),
-                 reinterpret_cast<uword>(args_),
-                 field_count_);
-  }
-
-  const Instance& obj = Instance::ZoneHandle(Instance::New(cls));
-
-  Field& field = Field::Handle();
-  Object& value = Object::Handle();
-  for (intptr_t i = 0; i < field_count_; i++) {
-    field ^= GetField(i);
-    value = GetValue(i);
-    obj.SetField(field, value);
-
-    if (FLAG_trace_deoptimization_verbose) {
-      OS::PrintErr("    %s <- %s\n",
-                   String::Handle(field.name()).ToCString(),
-                   value.ToCString());
-    }
-  }
-
-  object_ = &obj;
-}
-
-
 #define REUSABLE_HANDLE_INITIALIZERS(object)                                   \
   object##_handle_(NULL),
 
 Isolate::Isolate()
     : store_buffer_(),
       message_notify_callback_(NULL),
       name_(NULL),
       start_time_(OS::GetCurrentTimeMicros()),
       main_port_(0),
       heap_(NULL),
@@ skipping 12 matching lines @@
       deopt_id_(0),
       mutex_(new Mutex()),
       stack_limit_(0),
       saved_stack_limit_(0),
       message_handler_(NULL),
       spawn_data_(0),
       is_runnable_(false),
       gc_prologue_callbacks_(),
       gc_epilogue_callbacks_(),
       defer_finalization_count_(0),
-      deopt_cpu_registers_copy_(NULL),
-      deopt_fpu_registers_copy_(NULL),
-      deopt_frame_copy_(NULL),
-      deopt_frame_copy_size_(0),
-      deferred_boxes_(NULL),
-      deferred_object_refs_(NULL),
-      deferred_objects_count_(0),
-      deferred_objects_(NULL),
+      deopt_context_(NULL),
       stacktrace_(NULL),
       stack_frame_index_(-1),
       object_histogram_(NULL),
       object_id_ring_(NULL),
       REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_INITIALIZERS)
       reusable_handles_() {
   if (FLAG_print_object_histogram && (Dart::vm_isolate() != NULL)) {
     object_histogram_ = new ObjectHistogram(this);
   }
 }
 #undef REUSABLE_HANDLE_INITIALIZERS
 
 
 Isolate::~Isolate() {
   delete [] name_;
   delete heap_;
   delete object_store_;
   delete api_state_;
   delete stub_code_;
   delete debugger_;
 #if defined(USING_SIMULATOR)
   delete simulator_;
 #endif
   delete mutex_;
   mutex_ = NULL;  // Fail fast if interrupts are scheduled on a dead isolate.
   delete message_handler_;
   message_handler_ = NULL;  // Fail fast if we send messages to a dead isolate.
+  ASSERT(deopt_context_ == NULL);  // No deopt in progress when isolate deleted.
   delete object_histogram_;
 }
 
 void Isolate::SetCurrent(Isolate* current) {
   Thread::SetThreadLocal(isolate_key, reinterpret_cast<uword>(current));
 }
 
 
 // The single thread local key which stores all the thread local data
 // for a thread. Since an Isolate is the central repository for
@@ skipping 400 matching lines @@
   // Visit the dart api state for all local and persistent handles.
   if (api_state() != NULL) {
     api_state()->VisitObjectPointers(visitor, visit_prologue_weak_handles);
   }
 
   // Visit the top context which is stored in the isolate.
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&top_context_));
 
   // Visit objects in the debugger.
   debugger()->VisitObjectPointers(visitor);
+
+  // Visit objects that are being used for deoptimization.
+  if (deopt_context() != NULL) {
+    deopt_context()->VisitObjectPointers(visitor);
+  }
 }
 
 
 void Isolate::VisitWeakPersistentHandles(HandleVisitor* visitor,
                                          bool visit_prologue_weak_handles) {
   if (api_state() != NULL) {
     api_state()->VisitWeakHandles(visitor, visit_prologue_weak_handles);
   }
 }
 
@@ skipping 195 matching lines @@
 
 
 template<class T>
 T* Isolate::AllocateReusableHandle() {
   T* handle = reinterpret_cast<T*>(reusable_handles_.AllocateScopedHandle());
   T::initializeHandle(handle, T::null());
   return handle;
 }
 
 
-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;
-  }
-}
-
-
-void Isolate::MaterializeDeferredBoxes() {
-  FillDeferredSlots(&deferred_boxes_);
-}
-
-
-void Isolate::MaterializeDeferredObjects() {
-  FillDeferredSlots(&deferred_object_refs_);
-}
-
-
 static char* GetRootScriptUri(Isolate* isolate) {
   const Library& library =
       Library::Handle(isolate->object_store()->root_library());
   ASSERT(!library.IsNull());
   const String& script_name = String::Handle(library.url());
   return isolate->current_zone()->MakeCopyOfString(script_name.ToCString());
 }
 
 
 IsolateSpawnState::IsolateSpawnState(const Function& func,
@@ skipping 70 matching lines @@
   return func.raw();
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(isolate());
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart