Experimental implementation: Exposing SIMD instructions into JavaScript

src/deoptimizer.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 37 matching lines @@
   union conversion {
     double d;
     uint32_t u[2];
   } c;
   c.u[0] = *reinterpret_cast<uint32_t*>(p);
   c.u[1] = *reinterpret_cast<uint32_t*>(p + 4);
   return c.d;
 #endif  // V8_HOST_CAN_READ_UNALIGNED
 }
 
+static inline float32x4_value_t read_float32x4_value(Address p) {
+  return Memory::float32x4_at(p);
+}
+
+static inline int32x4_value_t read_int32x4_value(Address p) {
+  return Memory::int32x4_at(p);
+}
 
 class FrameDescription;
 class TranslationIterator;
 class DeoptimizedFrameInfo;
 
 template<typename T>
 class HeapNumberMaterializationDescriptor BASE_EMBEDDED {
  public:
   HeapNumberMaterializationDescriptor(T destination, double value)
       : destination_(destination), value_(value) { }
 
   T destination() const { return destination_; }
   double value() const { return value_; }
 
  private:
   T destination_;
   double value_;
 };
 
 
+template<typename T>
+class Float32x4MaterializationDescriptor BASE_EMBEDDED {
+ public:
+  Float32x4MaterializationDescriptor(T destination, float32x4_value_t value)
+      : destination_(destination), value_(value) { }
+
+  T destination() const { return destination_; }
+  float32x4_value_t value() const { return value_; }
+
+ private:
+  T destination_;
+  float32x4_value_t value_;
+};
+
+
+template<typename T>
+class Int32x4MaterializationDescriptor BASE_EMBEDDED {
+ public:
+  Int32x4MaterializationDescriptor(T destination, int32x4_value_t value)
+      : destination_(destination), value_(value) { }
+
+  T destination() const { return destination_; }
+  int32x4_value_t value() const { return value_; }
+
+ private:
+  T destination_;
+  int32x4_value_t value_;
+};
+
+
 class ObjectMaterializationDescriptor BASE_EMBEDDED {
  public:
   ObjectMaterializationDescriptor(
       Address slot_address, int frame, int length, int duplicate, bool is_args)
       : slot_address_(slot_address),
         jsframe_index_(frame),
         object_length_(length),
         duplicate_object_(duplicate),
         is_arguments_(is_args) { }
 
@@ skipping 254 matching lines @@
 
   unsigned ComputeIncomingArgumentSize(JSFunction* function) const;
   unsigned ComputeOutgoingArgumentSize() const;
 
   Object* ComputeLiteral(int index) const;
 
   void AddObjectStart(intptr_t slot_address, int argc, bool is_arguments);
   void AddObjectDuplication(intptr_t slot, int object_index);
   void AddObjectTaggedValue(intptr_t value);
   void AddObjectDoubleValue(double value);
+  void AddObjectFloat32x4Value(float32x4_value_t value);
+  void AddObjectInt32x4Value(int32x4_value_t value);
   void AddDoubleValue(intptr_t slot_address, double value);
+  void AddFloat32x4Value(intptr_t slot_address, float32x4_value_t value);
+  void AddInt32x4Value(intptr_t slot_address, int32x4_value_t value);
 
   bool ArgumentsObjectIsAdapted(int object_index) {
     ObjectMaterializationDescriptor desc = deferred_objects_.at(object_index);
     int reverse_jsframe_index = jsframe_count_ - desc.jsframe_index() - 1;
     return jsframe_has_adapted_arguments_[reverse_jsframe_index];
   }
 
   Handle<JSFunction> ArgumentsObjectFunction(int object_index) {
     ObjectMaterializationDescriptor desc = deferred_objects_.at(object_index);
     int reverse_jsframe_index = jsframe_count_ - desc.jsframe_index() - 1;
@@ skipping 62 matching lines @@
   int output_count_;
   // Number of output js frames.
   int jsframe_count_;
   // Array of output frame descriptions.
   FrameDescription** output_;
 
   // Deferred values to be materialized.
   List<Object*> deferred_objects_tagged_values_;
   List<HeapNumberMaterializationDescriptor<int> >
       deferred_objects_double_values_;
+  List<Float32x4MaterializationDescriptor<int> >
+      deferred_objects_float32x4_values_;
+  List<Int32x4MaterializationDescriptor<int> >
+      deferred_objects_int32x4_values_;
   List<ObjectMaterializationDescriptor> deferred_objects_;
   List<HeapNumberMaterializationDescriptor<Address> > deferred_heap_numbers_;
+  List<Float32x4MaterializationDescriptor<Address> > deferred_float32x4s_;
+  List<Int32x4MaterializationDescriptor<Address> > deferred_int32x4s_;
 
   // Output frame information. Only used during heap object materialization.
   List<Handle<JSFunction> > jsframe_functions_;
   List<bool> jsframe_has_adapted_arguments_;
 
   // Materialized objects. Only used during heap object materialization.
   List<Handle<Object> >* materialized_values_;
   List<Handle<Object> >* materialized_objects_;
   int materialization_value_index_;
   int materialization_object_index_;
@@ skipping 41 matching lines @@
 
   intptr_t GetFrameSlot(unsigned offset) {
     return *GetFrameSlotPointer(offset);
   }
 
   double GetDoubleFrameSlot(unsigned offset) {
     intptr_t* ptr = GetFrameSlotPointer(offset);
     return read_double_value(reinterpret_cast<Address>(ptr));
   }
 
+  float32x4_value_t GetFloat32x4FrameSlot(unsigned offset) {
+    intptr_t* ptr = GetFrameSlotPointer(offset);
+    return read_float32x4_value(reinterpret_cast<Address>(ptr));
+  }
+
+  int32x4_value_t GetInt32x4FrameSlot(unsigned offset) {
+    intptr_t* ptr = GetFrameSlotPointer(offset);
+    return read_int32x4_value(reinterpret_cast<Address>(ptr));
+  }
+
   void SetFrameSlot(unsigned offset, intptr_t value) {
     *GetFrameSlotPointer(offset) = value;
   }
 
   void SetCallerPc(unsigned offset, intptr_t value);
 
   void SetCallerFp(unsigned offset, intptr_t value);
 
   intptr_t GetRegister(unsigned n) const {
 #if DEBUG
     // This convoluted ASSERT is needed to work around a gcc problem that
     // improperly detects an array bounds overflow in optimized debug builds
     // when using a plain ASSERT.
     if (n >= ARRAY_SIZE(registers_)) {
       ASSERT(false);
       return 0;
     }
 #endif
     return registers_[n];
   }
 
   double GetDoubleRegister(unsigned n) const {
-    ASSERT(n < ARRAY_SIZE(double_registers_));
-    return double_registers_[n];
+    ASSERT(n < ARRAY_SIZE(xmm_registers_));
+    return xmm_registers_[n].d[0];
+  }
+
+  float32x4_value_t GetFloat32x4Register(unsigned n) const {
+    ASSERT(n < ARRAY_SIZE(xmm_registers_));
+    return xmm_registers_[n].f;
+  }
+
+  int32x4_value_t GetInt32x4Register(unsigned n) const {
+    ASSERT(n < ARRAY_SIZE(xmm_registers_));
+    return xmm_registers_[n].u;
+  }
+
+  xmm_value_t GetXMMRegister(unsigned n) const {
+    ASSERT(n < ARRAY_SIZE(xmm_registers_));
+    return xmm_registers_[n];
   }
 
   void SetRegister(unsigned n, intptr_t value) {
     ASSERT(n < ARRAY_SIZE(registers_));
     registers_[n] = value;
   }
 
   void SetDoubleRegister(unsigned n, double value) {
-    ASSERT(n < ARRAY_SIZE(double_registers_));
-    double_registers_[n] = value;
+    ASSERT(n < ARRAY_SIZE(xmm_registers_));
+    xmm_registers_[n].d[0] = value;
+  }
+
+  void SetXMMRegister(unsigned n, xmm_value_t value) {
+    ASSERT(n < ARRAY_SIZE(xmm_registers_));
+    xmm_registers_[n] = value;
   }
 
   intptr_t GetTop() const { return top_; }
   void SetTop(intptr_t top) { top_ = top; }
 
   intptr_t GetPc() const { return pc_; }
   void SetPc(intptr_t pc) { pc_ = pc; }
 
   intptr_t GetFp() const { return fp_; }
   void SetFp(intptr_t fp) { fp_ = fp; }
@@ skipping 18 matching lines @@
   // Get the expression stack height for a unoptimized frame.
   unsigned GetExpressionCount();
 
   // Get the expression stack value for an unoptimized frame.
   Object* GetExpression(int index);
 
   static int registers_offset() {
     return OFFSET_OF(FrameDescription, registers_);
   }
 
-  static int double_registers_offset() {
-    return OFFSET_OF(FrameDescription, double_registers_);
+  static int xmm_registers_offset() {
+    return OFFSET_OF(FrameDescription, xmm_registers_);
   }
 
   static int frame_size_offset() {
     return OFFSET_OF(FrameDescription, frame_size_);
   }
 
   static int pc_offset() {
     return OFFSET_OF(FrameDescription, pc_);
   }
 
@@ skipping 11 matching lines @@
 
  private:
   static const uint32_t kZapUint32 = 0xbeeddead;
 
   // Frame_size_ must hold a uint32_t value.  It is only a uintptr_t to
   // keep the variable-size array frame_content_ of type intptr_t at
   // the end of the structure aligned.
   uintptr_t frame_size_;  // Number of bytes.
   JSFunction* function_;
   intptr_t registers_[Register::kNumRegisters];
-  double double_registers_[DoubleRegister::kMaxNumRegisters];
+  xmm_value_t xmm_registers_[XMMRegister::kMaxNumRegisters];
   intptr_t top_;
   intptr_t pc_;
   intptr_t fp_;
   intptr_t context_;
   StackFrame::Type type_;
   Smi* state_;
 
   // Continuation is the PC where the execution continues after
   // deoptimizing.
   intptr_t continuation_;
@@ skipping 81 matching lines @@
   V(SETTER_STUB_FRAME)                                                         \
   V(ARGUMENTS_ADAPTOR_FRAME)                                                   \
   V(COMPILED_STUB_FRAME)                                                       \
   V(DUPLICATED_OBJECT)                                                         \
   V(ARGUMENTS_OBJECT)                                                          \
   V(CAPTURED_OBJECT)                                                           \
   V(REGISTER)                                                                  \
   V(INT32_REGISTER)                                                            \
   V(UINT32_REGISTER)                                                           \
   V(DOUBLE_REGISTER)                                                           \
+  V(FLOAT32x4_REGISTER)                                                        \
+  V(INT32x4_REGISTER)                                                          \
   V(STACK_SLOT)                                                                \
   V(INT32_STACK_SLOT)                                                          \
   V(UINT32_STACK_SLOT)                                                         \
   V(DOUBLE_STACK_SLOT)                                                         \
+  V(FLOAT32x4_STACK_SLOT)                                                      \
+  V(INT32x4_STACK_SLOT)                                                        \
   V(LITERAL)
 
 
 class Translation BASE_EMBEDDED {
  public:
 #define DECLARE_TRANSLATION_OPCODE_ENUM(item) item,
   enum Opcode {
     TRANSLATION_OPCODE_LIST(DECLARE_TRANSLATION_OPCODE_ENUM)
     LAST = LITERAL
   };
@@ skipping 18 matching lines @@
   void BeginConstructStubFrame(int literal_id, unsigned height);
   void BeginGetterStubFrame(int literal_id);
   void BeginSetterStubFrame(int literal_id);
   void BeginArgumentsObject(int args_length);
   void BeginCapturedObject(int length);
   void DuplicateObject(int object_index);
   void StoreRegister(Register reg);
   void StoreInt32Register(Register reg);
   void StoreUint32Register(Register reg);
   void StoreDoubleRegister(DoubleRegister reg);
+  void StoreFloat32x4Register(Float32x4Register reg);
+  void StoreInt32x4Register(Float32x4Register reg);
   void StoreStackSlot(int index);
   void StoreInt32StackSlot(int index);
   void StoreUint32StackSlot(int index);
   void StoreDoubleStackSlot(int index);
+  void StoreFloat32x4StackSlot(int index);
+  void StoreInt32x4StackSlot(int index);
   void StoreLiteral(int literal_id);
   void StoreArgumentsObject(bool args_known, int args_index, int args_length);
 
   Zone* zone() const { return zone_; }
 
   static int NumberOfOperandsFor(Opcode opcode);
 
 #if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
   static const char* StringFor(Opcode opcode);
 #endif
 
   // A literal id which refers to the JSFunction itself.
   static const int kSelfLiteralId = -239;
 
  private:
   TranslationBuffer* buffer_;
   int index_;
   Zone* zone_;
 };
 
 
 class SlotRef BASE_EMBEDDED {
  public:
   enum SlotRepresentation {
     UNKNOWN,
     TAGGED,
     INT32,
     UINT32,
     DOUBLE,
+    FLOAT32x4,
+    INT32x4,
     LITERAL
   };
 
   SlotRef()
       : addr_(NULL), representation_(UNKNOWN) { }
 
   SlotRef(Address addr, SlotRepresentation representation)
       : addr_(addr), representation_(representation) { }
 
   SlotRef(Isolate* isolate, Object* literal)
@@ skipping 20 matching lines @@
         } else {
           return isolate->factory()->NewNumber(static_cast<double>(value));
         }
       }
 
       case DOUBLE: {
         double value = read_double_value(addr_);
         return isolate->factory()->NewNumber(value);
       }
 
+      case FLOAT32x4: {
+        float32x4_value_t value = read_float32x4_value(addr_);
+        return isolate->factory()->NewFloat32x4(value);
+      }
+
+      case INT32x4: {
+        int32x4_value_t value = read_int32x4_value(addr_);
+        return isolate->factory()->NewInt32x4(value);
+      }
+
       case LITERAL:
         return literal_;
 
       default:
         UNREACHABLE();
         return Handle<Object>::null();
     }
   }
 
   static Vector<SlotRef> ComputeSlotMappingForArguments(
@@ skipping 100 matching lines @@
   Object** expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_