Unbox phis that were proven to be of type Double.

runtime/vm/code_generator.cc

 // Copyright (c) 2012, 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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 1379 matching lines @@
     }
   }
   *deopt_id = Isolate::kNoDeoptId;
   *deopt_reason = kDeoptUnknown;
   *deopt_index = -1;
 }
 
 
 
 // Copy saved registers into the isolate buffer.
-static void CopySavedRegisters(intptr_t* saved_registers_address) {
-  intptr_t* registers_copy = new intptr_t[kNumberOfCpuRegisters];
-  ASSERT(registers_copy != NULL);
-  ASSERT(saved_registers_address != NULL);
+static void CopySavedRegisters(uword saved_registers_address) {
+  double* xmm_registers_copy = new double[kNumberOfXmmRegisters];
+  ASSERT(xmm_registers_copy != NULL);
+  for (intptr_t i = 0; i < kNumberOfXmmRegisters; i++) {
+    xmm_registers_copy[i] = *reinterpret_cast<double*>(saved_registers_address);
+    saved_registers_address += kDoubleSize;
+  }
+  Isolate::Current()->set_deopt_xmm_registers_copy(xmm_registers_copy);
+
+  intptr_t* cpu_registers_copy = new intptr_t[kNumberOfCpuRegisters];
+  ASSERT(cpu_registers_copy != NULL);
   for (intptr_t i = 0; i < kNumberOfCpuRegisters; i++) {
-    registers_copy[i] = *saved_registers_address;
-    saved_registers_address++;
+    cpu_registers_copy[i] =
+        *reinterpret_cast<intptr_t*>(saved_registers_address);
+    saved_registers_address += kWordSize;
   }
-  Isolate::Current()->set_deopt_registers_copy(registers_copy);
+  Isolate::Current()->set_deopt_cpu_registers_copy(cpu_registers_copy);
 }
 
 
 // Copy optimized frame into the isolate buffer.
 // The first incoming argument is stored at the last entry in the
 // copied frame buffer.
 static void CopyFrame(const Code& optimized_code, const StackFrame& frame) {
   const Function& function = Function::Handle(optimized_code.function());
   // Do not copy incoming arguments if there are optional arguments (they
   // are copied into local space at method entry).
@@ skipping 13 matching lines @@
   for (intptr_t i = 0; i < frame_copy_size; i++) {
     frame_copy[i] = *(start + i);
   }
   Isolate::Current()->SetDeoptFrameCopy(frame_copy, frame_copy_size);
 }
 
 
 // Copies saved registers and caller's frame into temporary buffers.
 // Returns the stack size of unoptimzied frame.
 DEFINE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
-                          intptr_t* saved_registers_address) {
+                          uword saved_registers_address) {
   Isolate* isolate = Isolate::Current();
   Zone zone(isolate);
   HANDLESCOPE(isolate);
 
   // All registers have been saved below last-fp.
-  const uword last_fp =
-      reinterpret_cast<uword>(saved_registers_address + kNumberOfCpuRegisters);
+  const uword last_fp = saved_registers_address +
+      kNumberOfCpuRegisters * kWordSize + kNumberOfXmmRegisters * kDoubleSize;
   CopySavedRegisters(saved_registers_address);
 
   // Get optimized code and frame that need to be deoptimized.
   DartFrameIterator iterator(last_fp);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
   ASSERT(optimized_code.is_optimized());
 
   intptr_t deopt_id, deopt_reason, deopt_index;
@@ skipping 90 matching lines @@
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
   const Function& function = Function::Handle(optimized_code.function());
   ASSERT(!function.IsNull());
   const Code& unoptimized_code = Code::Handle(function.unoptimized_code());
   ASSERT(!optimized_code.IsNull() && optimized_code.is_optimized());
   ASSERT(!unoptimized_code.IsNull() && !unoptimized_code.is_optimized());
 
   intptr_t* frame_copy = isolate->deopt_frame_copy();
-  intptr_t* registers_copy = isolate->deopt_registers_copy();
+  intptr_t* cpu_registers_copy = isolate->deopt_cpu_registers_copy();
+  double* xmm_registers_copy = isolate->deopt_xmm_registers_copy();
 
   intptr_t deopt_id, deopt_reason, deopt_index;
   GetDeoptIxDescrAtPc(optimized_code, caller_frame->pc(),
                       &deopt_id, &deopt_reason, &deopt_index);
   ASSERT(deopt_id != Isolate::kNoDeoptId);
   uword continue_at_pc = unoptimized_code.GetDeoptPcAtDeoptId(deopt_id);
   if (FLAG_trace_deopt) {
     OS::Print("  -> continue at 0x%x\n", continue_at_pc);
     // TODO(srdjan): If we could allow GC, we could print the line where
     // deoptimization occured.
@@ skipping 20 matching lines @@
       if (FLAG_trace_deopt) {
         OS::Print("%d. 0x%x\n", i, frame_copy[i]);
       }
       *(start + i) = frame_copy[i];
     }
   } else {
     DeoptimizeWithDeoptInfo(optimized_code, deopt_info, *caller_frame);
   }
 
   isolate->SetDeoptFrameCopy(NULL, 0);
-  isolate->set_deopt_registers_copy(NULL);
+  isolate->set_deopt_cpu_registers_copy(NULL);
+  isolate->set_deopt_xmm_registers_copy(NULL);
   delete[] frame_copy;
-  delete[] registers_copy;
+  delete[] cpu_registers_copy;
+  delete[] xmm_registers_copy;
 
   // Clear invocation counter so that the function gets optimized after
   // classes have been collected.
   function.set_usage_counter(0);
   function.set_deoptimization_counter(function.deoptimization_counter() + 1);
 
   if (function.HasOptimizedCode()) {
     function.SwitchToUnoptimizedCode();
   }
 }
 END_LEAF_RUNTIME_ENTRY
 
+
+DEFINE_RUNTIME_ENTRY(DeoptimizeMaterializeDoubles, 0) {
+  DeferredDouble* deferred_double = Isolate::Current()->DetachDeferredDoubles();
+
+  while (deferred_double != NULL) {
+    DeferredDouble* current = deferred_double;
+    deferred_double = deferred_double->next();
+
+    RawDouble** slot = current->slot();
+    *slot = Double::New(current->value());
+
+    if (FLAG_trace_deopt) {
+      OS::Print("materialing double at 0x%" PRIxPTR ": %g\n",
+                current->slot(),
+                current->value());
+    }
+
+    delete current;
+  }
+}
+
+
 }  // namespace dart