Experimental implementation: Exposing SIMD instructions into JavaScript

src/objects-inl.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 149 matching lines @@
 }
 
 
 bool Object::NonFailureIsHeapObject() {
   ASSERT(!this->IsFailure());
   return (reinterpret_cast<intptr_t>(this) & kSmiTagMask) != 0;
 }
 
 
 TYPE_CHECKER(HeapNumber, HEAP_NUMBER_TYPE)
+TYPE_CHECKER(Float32x4, FLOAT32x4_TYPE)
+TYPE_CHECKER(Int32x4, INT32x4_TYPE)
 TYPE_CHECKER(Symbol, SYMBOL_TYPE)
 
 
 bool Object::IsString() {
   return Object::IsHeapObject()
     && HeapObject::cast(this)->map()->instance_type() < FIRST_NONSTRING_TYPE;
 }
 
 
 bool Object::IsName() {
@@ skipping 294 matching lines @@
 }
 
 
 TYPE_CHECKER(ExternalByteArray, EXTERNAL_BYTE_ARRAY_TYPE)
 TYPE_CHECKER(ExternalUnsignedByteArray, EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE)
 TYPE_CHECKER(ExternalShortArray, EXTERNAL_SHORT_ARRAY_TYPE)
 TYPE_CHECKER(ExternalUnsignedShortArray, EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE)
 TYPE_CHECKER(ExternalIntArray, EXTERNAL_INT_ARRAY_TYPE)
 TYPE_CHECKER(ExternalUnsignedIntArray, EXTERNAL_UNSIGNED_INT_ARRAY_TYPE)
 TYPE_CHECKER(ExternalFloatArray, EXTERNAL_FLOAT_ARRAY_TYPE)
+TYPE_CHECKER(ExternalFloat32x4Array, EXTERNAL_FLOAT32x4_ARRAY_TYPE)
+TYPE_CHECKER(ExternalInt32x4Array, EXTERNAL_INT32x4_ARRAY_TYPE)
 TYPE_CHECKER(ExternalDoubleArray, EXTERNAL_DOUBLE_ARRAY_TYPE)
 
 
 bool MaybeObject::IsFailure() {
   return HAS_FAILURE_TAG(this);
 }
 
 
 bool MaybeObject::IsRetryAfterGC() {
   return HAS_FAILURE_TAG(this)
@@ skipping 489 matching lines @@
       uint32_t u[2];
     } c;
     c.d = value;
     (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset))) = c.u[0];
     (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset + 4))) = c.u[1];
   }
   #define WRITE_DOUBLE_FIELD(p, offset, value) \
     write_double_field(p, offset, value)
 #endif  // V8_TARGET_ARCH_MIPS
 
+#define READ_FLOAT32x4_FIELD(p, offset) \
+  (*reinterpret_cast<float32x4_value_t*>(FIELD_ADDR(p, offset)))
+
+#define WRITE_FLOAT32x4_FIELD(p, offset, value) \
+  (*reinterpret_cast<float32x4_value_t*>(FIELD_ADDR(p, offset)) = value)
+
+#define READ_INT32x4_FIELD(p, offset) \
+  (*reinterpret_cast<int32x4_value_t*>(FIELD_ADDR(p, offset)))
+
+#define WRITE_INT32x4_FIELD(p, offset, value) \
+  (*reinterpret_cast<int32x4_value_t*>(FIELD_ADDR(p, offset)) = value)
+
+#define READ_FLOAT_FIELD(p, offset) \
+  (*reinterpret_cast<float*>(FIELD_ADDR(p, offset)))
+
+#define WRITE_FLOAT_FIELD(p, offset, value) \
+  (*reinterpret_cast<float*>(FIELD_ADDR(p, offset)) = value)
 
 #define READ_INT_FIELD(p, offset) \
   (*reinterpret_cast<int*>(FIELD_ADDR(p, offset)))
 
 #define WRITE_INT_FIELD(p, offset, value) \
   (*reinterpret_cast<int*>(FIELD_ADDR(p, offset)) = value)
 
 #define READ_INTPTR_FIELD(p, offset) \
   (*reinterpret_cast<intptr_t*>(FIELD_ADDR(p, offset)))
 
@@ skipping 252 matching lines @@
   return ((READ_INT_FIELD(this, kExponentOffset) & kExponentMask) >>
           kExponentShift) - kExponentBias;
 }
 
 
 int HeapNumber::get_sign() {
   return READ_INT_FIELD(this, kExponentOffset) & kSignMask;
 }
 
 
+float32x4_value_t Float32x4::value() {
+  return READ_FLOAT32x4_FIELD(this, kValueOffset);
+}
+
+
+void Float32x4::set_value(float32x4_value_t value) {
+  WRITE_FLOAT32x4_FIELD(this, kValueOffset, value);
+}
+
+
+float Float32x4::x() {
+  return READ_FLOAT_FIELD(this, kValueOffset + 0 * kFloatSize);
+}
+
+
+float Float32x4::y() {
+  return READ_FLOAT_FIELD(this, kValueOffset + 1 * kFloatSize);
+}
+
+
+float Float32x4::z() {
+  return READ_FLOAT_FIELD(this, kValueOffset + 2 * kFloatSize);
+}
+
+
+float Float32x4::w() {
+  return READ_FLOAT_FIELD(this, kValueOffset + 3 * kFloatSize);
+}
+
+
+void Float32x4::set_x(float x) {
+  WRITE_FLOAT_FIELD(this, kValueOffset + 0 * kFloatSize, x);
+}
+
+
+void Float32x4::set_y(float y) {
+  WRITE_FLOAT_FIELD(this, kValueOffset + 1 * kFloatSize, y);
+}
+
+
+void Float32x4::set_z(float z) {
+  WRITE_FLOAT_FIELD(this, kValueOffset + 2 * kFloatSize, z);
+}
+
+
+void Float32x4::set_w(float w) {
+  WRITE_FLOAT_FIELD(this, kValueOffset + 3 * kFloatSize, w);
+}
+
+
+int32x4_value_t Int32x4::value() {
+  return READ_INT32x4_FIELD(this, kValueOffset);
+}
+
+
+void Int32x4::set_value(int32x4_value_t value) {
+  WRITE_INT32x4_FIELD(this, kValueOffset, value);
+}
+
+
+int32_t Int32x4::x() {
+  return READ_INT32_FIELD(this, kValueOffset + 0 * kInt32Size);
+}
+
+
+int32_t Int32x4::y() {
+  return READ_INT32_FIELD(this, kValueOffset + 1 * kInt32Size);
+}
+
+
+int32_t Int32x4::z() {
+  return READ_INT32_FIELD(this, kValueOffset + 2 * kInt32Size);
+}
+
+
+int32_t Int32x4::w() {
+  return READ_INT32_FIELD(this, kValueOffset + 3 * kInt32Size);
+}
+
+
+void Int32x4::set_x(int32_t x) {
+  WRITE_INT32_FIELD(this, kValueOffset + 0 * kInt32Size, x);
+}
+
+
+void Int32x4::set_y(int32_t y) {
+  WRITE_INT32_FIELD(this, kValueOffset + 1 * kInt32Size, y);
+}
+
+
+void Int32x4::set_z(int32_t z) {
+  WRITE_INT32_FIELD(this, kValueOffset + 2 * kInt32Size, z);
+}
+
+
+void Int32x4::set_w(int32_t w) {
+  WRITE_INT32_FIELD(this, kValueOffset + 3 * kInt32Size, w);
+}
+
+
 ACCESSORS(JSObject, properties, FixedArray, kPropertiesOffset)
 
 
 Object** FixedArray::GetFirstElementAddress() {
   return reinterpret_cast<Object**>(FIELD_ADDR(this, OffsetOfElementAt(0)));
 }
 
 
 bool FixedArray::ContainsOnlySmisOrHoles() {
   Object* the_hole = GetHeap()->the_hole_value();
@@ skipping 1328 matching lines @@
 CAST_ACCESSOR(ExternalString)
 CAST_ACCESSOR(ExternalAsciiString)
 CAST_ACCESSOR(ExternalTwoByteString)
 CAST_ACCESSOR(Symbol)
 CAST_ACCESSOR(Name)
 CAST_ACCESSOR(JSReceiver)
 CAST_ACCESSOR(JSObject)
 CAST_ACCESSOR(Smi)
 CAST_ACCESSOR(HeapObject)
 CAST_ACCESSOR(HeapNumber)
+CAST_ACCESSOR(Float32x4)
+CAST_ACCESSOR(Int32x4)
 CAST_ACCESSOR(Oddball)
 CAST_ACCESSOR(Cell)
 CAST_ACCESSOR(PropertyCell)
 CAST_ACCESSOR(SharedFunctionInfo)
 CAST_ACCESSOR(Map)
 CAST_ACCESSOR(JSFunction)
 CAST_ACCESSOR(GlobalObject)
 CAST_ACCESSOR(JSGlobalProxy)
 CAST_ACCESSOR(JSGlobalObject)
 CAST_ACCESSOR(JSBuiltinsObject)
@@ skipping 14 matching lines @@
 CAST_ACCESSOR(ByteArray)
 CAST_ACCESSOR(FreeSpace)
 CAST_ACCESSOR(ExternalArray)
 CAST_ACCESSOR(ExternalByteArray)
 CAST_ACCESSOR(ExternalUnsignedByteArray)
 CAST_ACCESSOR(ExternalShortArray)
 CAST_ACCESSOR(ExternalUnsignedShortArray)
 CAST_ACCESSOR(ExternalIntArray)
 CAST_ACCESSOR(ExternalUnsignedIntArray)
 CAST_ACCESSOR(ExternalFloatArray)
+CAST_ACCESSOR(ExternalFloat32x4Array)
+CAST_ACCESSOR(ExternalInt32x4Array)
 CAST_ACCESSOR(ExternalDoubleArray)
 CAST_ACCESSOR(ExternalPixelArray)
 CAST_ACCESSOR(Struct)
 CAST_ACCESSOR(AccessorInfo)
 
 
 #define MAKE_STRUCT_CAST(NAME, Name, name) CAST_ACCESSOR(Name)
   STRUCT_LIST(MAKE_STRUCT_CAST)
 #undef MAKE_STRUCT_CAST
 
@@ skipping 741 matching lines @@
 }
 
 
 void ExternalFloatArray::set(int index, float value) {
   ASSERT((index >= 0) && (index < this->length()));
   float* ptr = static_cast<float*>(external_pointer());
   ptr[index] = value;
 }
 
 
+float32x4_value_t ExternalFloat32x4Array::get_scalar(int index) {
+  ASSERT((index >= 0) && (index < this->length()));
+  float* ptr = static_cast<float*>(external_pointer());
+  float32x4_value_t value;
+  value.storage[0] = ptr[index * 4 + 0];
+  value.storage[1] = ptr[index * 4 + 1];
+  value.storage[2] = ptr[index * 4 + 2];
+  value.storage[3] = ptr[index * 4 + 3];
+  return value;
+}
+
+
+MaybeObject* ExternalFloat32x4Array::get(int index) {
+  float32x4_value_t value = get_scalar(index);
+  return GetHeap()->AllocateFloat32x4(value);
+}
+
+
+void ExternalFloat32x4Array::set(int index, const float32x4_value_t& value) {
+  ASSERT((index >= 0) && (index < this->length()));
+  float* ptr = static_cast<float*>(external_pointer());
+  ptr[index * 4 + 0] = value.storage[0];
+  ptr[index * 4 + 1] = value.storage[1];
+  ptr[index * 4 + 2] = value.storage[2];
+  ptr[index * 4 + 3] = value.storage[3];
+}
+
+
+int32x4_value_t ExternalInt32x4Array::get_scalar(int index) {
+  ASSERT((index >= 0) && (index < this->length()));
+  int32_t* ptr = static_cast<int32_t*>(external_pointer());
+  int32x4_value_t value;
+  value.storage[0] = ptr[index * 4 + 0];
+  value.storage[1] = ptr[index * 4 + 1];
+  value.storage[2] = ptr[index * 4 + 2];
+  value.storage[3] = ptr[index * 4 + 3];
+  return value;
+}
+
+
+MaybeObject* ExternalInt32x4Array::get(int index) {
+  int32x4_value_t value = get_scalar(index);
+  return GetHeap()->AllocateInt32x4(value);
+}
+
+
+void ExternalInt32x4Array::set(int index, const int32x4_value_t& value) {
+  ASSERT((index >= 0) && (index < this->length()));
+  int32_t* ptr = static_cast<int32_t*>(external_pointer());
+  ptr[index * 4 + 0] = value.storage[0];
+  ptr[index * 4 + 1] = value.storage[1];
+  ptr[index * 4 + 2] = value.storage[2];
+  ptr[index * 4 + 3] = value.storage[3];
+}
+
+
 double ExternalDoubleArray::get_scalar(int index) {
   ASSERT((index >= 0) && (index < this->length()));
   double* ptr = static_cast<double*>(external_pointer());
   return ptr[index];
 }
 
 
 MaybeObject* ExternalDoubleArray::get(int index) {
     return GetHeap()->NumberFromDouble(get_scalar(index));
 }
@@ skipping 2207 matching lines @@
 EXTERNAL_ELEMENTS_CHECK(Byte, EXTERNAL_BYTE_ARRAY_TYPE)
 EXTERNAL_ELEMENTS_CHECK(UnsignedByte, EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE)
 EXTERNAL_ELEMENTS_CHECK(Short, EXTERNAL_SHORT_ARRAY_TYPE)
 EXTERNAL_ELEMENTS_CHECK(UnsignedShort,
                         EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE)
 EXTERNAL_ELEMENTS_CHECK(Int, EXTERNAL_INT_ARRAY_TYPE)
 EXTERNAL_ELEMENTS_CHECK(UnsignedInt,
                         EXTERNAL_UNSIGNED_INT_ARRAY_TYPE)
 EXTERNAL_ELEMENTS_CHECK(Float,
                         EXTERNAL_FLOAT_ARRAY_TYPE)
+EXTERNAL_ELEMENTS_CHECK(Float32x4,
+                        EXTERNAL_FLOAT32x4_ARRAY_TYPE)
+EXTERNAL_ELEMENTS_CHECK(Int32x4,
+                        EXTERNAL_INT32x4_ARRAY_TYPE)
 EXTERNAL_ELEMENTS_CHECK(Double,
                         EXTERNAL_DOUBLE_ARRAY_TYPE)
 EXTERNAL_ELEMENTS_CHECK(Pixel, EXTERNAL_PIXEL_ARRAY_TYPE)
 
 
 bool JSObject::HasNamedInterceptor() {
   return map()->has_named_interceptor();
 }
 
 
@@ skipping 779 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_