SIMD plumbing

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 1431 matching lines @@
       if (ContainsCid(classes, owner_cid)) {
         DeoptimizeAt(optimized_code, frame->pc());
       }
     }
   }
 }
 
 
 // Copy saved registers into the isolate buffer.
 static void CopySavedRegisters(uword saved_registers_address) {
-  double* fpu_registers_copy = new double[kNumberOfFpuRegisters];
+  fpu_register_t* fpu_registers_copy =
+      new fpu_register_t[kNumberOfFpuRegisters];
   ASSERT(fpu_registers_copy != NULL);
   for (intptr_t i = 0; i < kNumberOfFpuRegisters; i++) {
-    fpu_registers_copy[i] = *reinterpret_cast<double*>(saved_registers_address);
-    saved_registers_address += kDoubleSize;
+    fpu_registers_copy[i] =
+        *reinterpret_cast<fpu_register_t*>(saved_registers_address);
+    saved_registers_address += kFpuRegisterSize;
   }
   Isolate::Current()->set_deopt_fpu_registers_copy(fpu_registers_copy);
 
   intptr_t* cpu_registers_copy = new intptr_t[kNumberOfCpuRegisters];
   ASSERT(cpu_registers_copy != NULL);
   for (intptr_t i = 0; i < kNumberOfCpuRegisters; i++) {
     cpu_registers_copy[i] =
         *reinterpret_cast<intptr_t*>(saved_registers_address);
     saved_registers_address += kWordSize;
   }
@@ skipping 31 matching lines @@
 // Copies saved registers and caller's frame into temporary buffers.
 // Returns the stack size of unoptimized frame.
 DEFINE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                           uword saved_registers_address) {
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
 
   // All registers have been saved below last-fp.
   const uword last_fp = saved_registers_address +
-      kNumberOfCpuRegisters * kWordSize + kNumberOfFpuRegisters * kDoubleSize;
+                        kNumberOfCpuRegisters * kWordSize +
+                        kNumberOfFpuRegisters * kFpuRegisterSize;
   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());
 
 
@@ skipping 81 matching lines @@
   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* cpu_registers_copy = isolate->deopt_cpu_registers_copy();
-  double* fpu_registers_copy = isolate->deopt_fpu_registers_copy();
+  fpu_register_t* fpu_registers_copy = isolate->deopt_fpu_registers_copy();
 
   intptr_t deopt_reason = kDeoptUnknown;
   const DeoptInfo& deopt_info = DeoptInfo::Handle(
       optimized_code.GetDeoptInfoAtPc(caller_frame->pc(), &deopt_reason));
   ASSERT(!deopt_info.IsNull());
 
   const intptr_t caller_fp = DeoptimizeWithDeoptInfo(optimized_code,
                                                      deopt_info,
                                                      *caller_frame,
                                                      deopt_reason);
 
   isolate->SetDeoptFrameCopy(NULL, 0);
   isolate->set_deopt_cpu_registers_copy(NULL);
   isolate->set_deopt_fpu_registers_copy(NULL);
   delete[] frame_copy;
   delete[] cpu_registers_copy;
   delete[] fpu_registers_copy;
 
   return caller_fp;
 }
 END_LEAF_RUNTIME_ENTRY
 
 
 // This is the last step in the deoptimization, GC can occur.
 DEFINE_RUNTIME_ENTRY(DeoptimizeMaterializeDoubles, 0) {
-  DeferredDouble* deferred_double = Isolate::Current()->DetachDeferredDoubles();
+  DeferredObject* deferred_object = Isolate::Current()->DetachDeferredObjects();
 
-  while (deferred_double != NULL) {
-    DeferredDouble* current = deferred_double;
-    deferred_double = deferred_double->next();
+  while (deferred_object != NULL) {
+    DeferredObject* current = deferred_object;
+    deferred_object  = deferred_object->next();
 
-    RawDouble** slot = current->slot();
-    *slot = Double::New(current->value());
-
-    if (FLAG_trace_deoptimization_verbose) {
-      OS::PrintErr("materializing double at %"Px": %g\n",
-                reinterpret_cast<uword>(current->slot()),
-                current->value());
-    }
+    current->materialize();
 
     delete current;
   }
 
-  DeferredMint* deferred_mint = Isolate::Current()->DetachDeferredMints();
-
-  while (deferred_mint != NULL) {
-    DeferredMint* current = deferred_mint;
-    deferred_mint = deferred_mint->next();
-
-    RawMint** slot = current->slot();
-    ASSERT(!Smi::IsValid64(current->value()));
-    *slot = Mint::New(current->value());
-
-    if (FLAG_trace_deoptimization_verbose) {
-      OS::PrintErr("materializing mint at %"Px": %"Pd64"\n",
-                reinterpret_cast<uword>(current->slot()),
-                current->value());
-    }
-
-    delete current;
-  }
   // Since this is the only step where GC can occur during deoptimization,
   // use it to report the source line where deoptimization occured.
   if (FLAG_trace_deoptimization) {
     DartFrameIterator iterator;
     StackFrame* top_frame = iterator.NextFrame();
     ASSERT(top_frame != NULL);
     const Code& code = Code::Handle(top_frame->LookupDartCode());
     const Function& top_function = Function::Handle(code.function());
     const Script& script = Script::Handle(top_function.script());
     const intptr_t token_pos = code.GetTokenIndexOfPC(top_frame->pc());
@@ skipping 45 matching lines @@
     if (right < 0) {
       remainder -= right;
     } else {
       remainder += right;
     }
   }
   return remainder;
 }
 
 }  // namespace dart