SIMD plumbing

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 "lib/mirrors.h"
 #include "vm/code_observers.h"
@@ skipping 13 matching lines @@
 #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);
 
 class IsolateMessageHandler : public MessageHandler {
  public:
   explicit IsolateMessageHandler(Isolate* isolate);
   ~IsolateMessageHandler();
 
   const char* name() const;
   void MessageNotify(Message::Priority priority);
   bool HandleMessage(Message* message);
 
@@ skipping 203 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_slot = Mint::New(value());
+
+  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);
+  }
+}
+
+
 Isolate::Isolate()
     : store_buffer_block_(),
       store_buffer_(),
       message_notify_callback_(NULL),
       name_(NULL),
       start_time_(OS::GetCurrentTimeMicros()),
       main_port_(0),
       heap_(NULL),
       object_store_(NULL),
       top_context_(Context::null()),
@@ skipping 12 matching lines @@
       stack_limit_(0),
       saved_stack_limit_(0),
       message_handler_(NULL),
       spawn_data_(0),
       gc_prologue_callbacks_(),
       gc_epilogue_callbacks_(),
       deopt_cpu_registers_copy_(NULL),
       deopt_fpu_registers_copy_(NULL),
       deopt_frame_copy_(NULL),
       deopt_frame_copy_size_(0),
-      deferred_doubles_(NULL),
-      deferred_mints_(NULL) {
+      deferred_objects_(NULL) {
 }
 
 
 Isolate::~Isolate() {
   delete [] name_;
   delete heap_;
   delete object_store_;
   delete api_state_;
   delete stub_code_;
   delete debugger_;
@@ skipping 383 matching lines @@
                       isolate->saved_stack_limit(),
                       heap->Used(Heap::kNew) / KB,
                       heap->Capacity(Heap::kNew) / KB,
                       heap->Used(Heap::kOld) / KB,
                       heap->Capacity(Heap::kOld) / KB);
   ASSERT(n < 256);
   return strdup(buffer);
 }
 
 }  // namespace dart