SIMD plumbing

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"
@@ skipping 152 matching lines @@
     }
   }
 
  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 {
+    const char* format = "f32x4s%"Pd"";
+    intptr_t len = OS::SNPrint(NULL, 0, format, stack_slot_index_);
+    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
+    OS::SNPrint(chars, len + 1, format, stack_slot_index_);
+    return chars;
+  }
+
+  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+    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));
+    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
+    *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
+    Isolate::Current()->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 {
+    const char* format = "ui32x4s%"Pd"";
+    intptr_t len = OS::SNPrint(NULL, 0, format, stack_slot_index_);
+    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
+    OS::SNPrint(chars, len + 1, format, stack_slot_index_);
+    return chars;
+  }
+
+  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+    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));
+    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
+    *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
+    Isolate::Current()->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);
+};
+
+
 // Deoptimization instruction creating return address using function and
 // deopt-id stored at 'object_table_index'. Uses the deopt-after
 // continuation point.
 class DeoptRetAfterAddressInstr : public DeoptInstr {
  public:
   DeoptRetAfterAddressInstr(intptr_t object_table_index, intptr_t deopt_id)
       : object_table_index_(object_table_index), deopt_id_(deopt_id) {
     ASSERT(object_table_index >= 0);
     ASSERT(deopt_id >= 0);
   }
@@ skipping 223 matching lines @@
     }
   }
 
  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 {
+    const char* format = "%s(f32x4)";
+    intptr_t len =
+        OS::SNPrint(NULL, 0, format, Assembler::FpuRegisterName(reg_));
+    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
+    OS::SNPrint(chars, len + 1, format, Assembler::FpuRegisterName(reg_));
+    return chars;
+  }
+
+  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+    simd128_value_t value = deopt_context->FpuRegisterValueAsSimd128(reg_);
+    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
+    *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
+    Isolate::Current()->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 kFloat32x4FpuRegister; }
+
+  virtual const char* ToCString() const {
+    const char* format = "%s(f32x4)";
+    intptr_t len =
+        OS::SNPrint(NULL, 0, format, Assembler::FpuRegisterName(reg_));
+    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
+    OS::SNPrint(chars, len + 1, format, Assembler::FpuRegisterName(reg_));
+    return chars;
+  }
+
+  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+    simd128_value_t value = deopt_context->FpuRegisterValueAsSimd128(reg_);
+    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
+    *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
+    Isolate::Current()->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_; }
@@ skipping 158 matching lines @@
   return code.GetDeoptAfterPcAtDeoptId(ret_after_instr->deopt_id());
 }
 
 
 DeoptInstr* DeoptInstr::Create(intptr_t kind_as_int, intptr_t from_index) {
   Kind kind = static_cast<Kind>(kind_as_int);
   switch (kind) {
     case kStackSlot: return new DeoptStackSlotInstr(from_index);
     case kDoubleStackSlot: return new DeoptDoubleStackSlotInstr(from_index);
     case kInt64StackSlot: return new DeoptInt64StackSlotInstr(from_index);
+    case kFloat32x4StackSlot:
+        return new DeoptFloat32x4StackSlotInstr(from_index);
+    case kUint32x4StackSlot:
+        return new DeoptUint32x4StackSlotInstr(from_index);
     case kRetAfterAddress: return new DeoptRetAfterAddressInstr(from_index);
     case kRetBeforeAddress: return new DeoptRetBeforeAddressInstr(from_index);
     case kConstant: return new DeoptConstantInstr(from_index);
     case kRegister: return new DeoptRegisterInstr(from_index);
     case kFpuRegister: return new DeoptFpuRegisterInstr(from_index);
     case kInt64FpuRegister: return new DeoptInt64FpuRegisterInstr(from_index);
+    case kFloat32x4FpuRegister:
+        return new DeoptFloat32x4FpuRegisterInstr(from_index);
+    case kUint32x4FpuRegister:
+        return new DeoptUint32x4FpuRegisterInstr(from_index);
     case kPcMarker: return new DeoptPcMarkerInstr(from_index);
     case kCallerFp: return new DeoptCallerFpInstr();
     case kCallerPc: return new DeoptCallerPcInstr();
     case kSuffix: return new DeoptSuffixInstr(from_index);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
@@ skipping 109 matching lines @@
     if (from_loc.representation() == kUnboxedDouble) {
       deopt_instr = new DeoptDoubleStackSlotInstr(from_index);
     } else {
       ASSERT(from_loc.representation() == kUnboxedMint);
       deopt_instr = new DeoptInt64StackSlotInstr(from_index);
     }
   } else {
     UNREACHABLE();
   }
   ASSERT(to_index == instructions_.length());
+  ASSERT(deopt_instr != NULL);
   instructions_.Add(deopt_instr);
 }
 
 
 void DeoptInfoBuilder::AddCallerFp(intptr_t to_index) {
   ASSERT(to_index == instructions_.length());
   instructions_.Add(new DeoptCallerFpInstr());
 }
 
 
@@ skipping 76 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