[simd.js] Macro-ize more SIMD code (2).

src/objects-inl.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 1240 matching lines @@
 
 #define WRITE_INT_FIELD(p, offset, value) \
   (*reinterpret_cast<int*>(FIELD_ADDR(p, offset)) = value)
 
 #define READ_INTPTR_FIELD(p, offset) \
   (*reinterpret_cast<const intptr_t*>(FIELD_ADDR_CONST(p, offset)))
 
 #define WRITE_INTPTR_FIELD(p, offset, value) \
   (*reinterpret_cast<intptr_t*>(FIELD_ADDR(p, offset)) = value)
 
+#define READ_UINT8_FIELD(p, offset) \
+  (*reinterpret_cast<const uint8_t*>(FIELD_ADDR_CONST(p, offset)))
+
+#define WRITE_UINT8_FIELD(p, offset, value) \
+  (*reinterpret_cast<uint8_t*>(FIELD_ADDR(p, offset)) = value)
+
+#define READ_INT8_FIELD(p, offset) \
+  (*reinterpret_cast<const int8_t*>(FIELD_ADDR_CONST(p, offset)))
+
+#define WRITE_INT8_FIELD(p, offset, value) \
+  (*reinterpret_cast<int8_t*>(FIELD_ADDR(p, offset)) = value)
+
 #define READ_UINT16_FIELD(p, offset) \
   (*reinterpret_cast<const uint16_t*>(FIELD_ADDR_CONST(p, offset)))
 
 #define WRITE_UINT16_FIELD(p, offset, value) \
   (*reinterpret_cast<uint16_t*>(FIELD_ADDR(p, offset)) = value)
 
 #define READ_INT16_FIELD(p, offset) \
   (*reinterpret_cast<const int16_t*>(FIELD_ADDR_CONST(p, offset)))
 
 #define WRITE_INT16_FIELD(p, offset, value) \
@@ skipping 266 matching lines @@
   bool Type::Equals(Type* that) {                                     \
     for (int lane = 0; lane < lane_count; ++lane) {                   \
       if (this->get_lane(lane) != that->get_lane(lane)) return false; \
     }                                                                 \
     return true;                                                      \
   }
 SIMD128_TYPES(SIMD128_VALUE_EQUALS)
 #undef SIMD128_VALUE_EQUALS
 
 
-float Float32x4::get_lane(int lane) const {
-  DCHECK(lane < 4 && lane >= 0);
 #if defined(V8_TARGET_LITTLE_ENDIAN)
-  return READ_FLOAT_FIELD(this, kValueOffset + lane * kFloatSize);
+#define SIMD128_READ_LANE(lane_type, lane_count, field_type, field_size) \
+  lane_type value =                                                      \
+      READ_##field_type##_FIELD(this, kValueOffset + lane * field_size);
 #elif defined(V8_TARGET_BIG_ENDIAN)
-  return READ_FLOAT_FIELD(this, kValueOffset + (3 - lane) * kFloatSize);
+#define SIMD128_READ_LANE(lane_type, lane_count, field_type, field_size) \
+  lane_type value = READ_##field_type##_FIELD(                           \
+      this, kValueOffset + (lane_count - lane - 1) * field_size);
 #else
 #error Unknown byte ordering
 #endif
-}
 
-
-void Float32x4::set_lane(int lane, float value) {
-  DCHECK(lane < 4 && lane >= 0);
 #if defined(V8_TARGET_LITTLE_ENDIAN)
-  WRITE_FLOAT_FIELD(this, kValueOffset + lane * kFloatSize, value);
+#define SIMD128_WRITE_LANE(lane_count, field_type, field_size, value) \
+  WRITE_##field_type##_FIELD(this, kValueOffset + lane * field_size, value);
 #elif defined(V8_TARGET_BIG_ENDIAN)
-  WRITE_FLOAT_FIELD(this, kValueOffset + (3 - lane) * kFloatSize, value);
+#define SIMD128_WRITE_LANE(lane_count, field_type, field_size, value) \
+  WRITE_##field_type##_FIELD(                                         \
+      this, kValueOffset + (lane_count - lane - 1) * field_size, value);
 #else
 #error Unknown byte ordering
 #endif
-}
+
+#define SIMD128_NUMERIC_LANE_FNS(type, lane_type, lane_count, field_type, \
+                                 field_size)                              \
+  lane_type type::get_lane(int lane) const {                              \
+    DCHECK(lane < lane_count && lane >= 0);                               \
+    SIMD128_READ_LANE(lane_type, lane_count, field_type, field_size)      \
+    return value;                                                         \
+  }                                                                       \
+                                                                          \
+  void type::set_lane(int lane, lane_type value) {                        \
+    DCHECK(lane < lane_count && lane >= 0);                               \
+    SIMD128_WRITE_LANE(lane_count, field_type, field_size, value)         \
+  }
+
+SIMD128_NUMERIC_LANE_FNS(Float32x4, float, 4, FLOAT, kFloatSize)
+SIMD128_NUMERIC_LANE_FNS(Int32x4, int32_t, 4, INT32, kInt32Size)
+SIMD128_NUMERIC_LANE_FNS(Int16x8, int16_t, 8, INT16, kShortSize)
+SIMD128_NUMERIC_LANE_FNS(Int8x16, int8_t, 16, INT8, kCharSize)
+#undef SIMD128_NUMERIC_LANE_FNS
 
 
-int32_t Int32x4::get_lane(int lane) const {
-  DCHECK(lane < 4 && lane >= 0);
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  return READ_INT32_FIELD(this, kValueOffset + lane * kInt32Size);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  return READ_INT32_FIELD(this, kValueOffset + (3 - lane) * kInt32Size);
-#else
-#error Unknown byte ordering
-#endif
-}
+#define SIMD128_BOOLEAN_LANE_FNS(type, lane_type, lane_count, field_type, \
+                                 field_size)                              \
+  bool type::get_lane(int lane) const {                                   \
+    DCHECK(lane < lane_count && lane >= 0);                               \
+    SIMD128_READ_LANE(lane_type, lane_count, field_type, field_size)      \
+    DCHECK(value == 0 || value == -1);                                    \
+    return value != 0;                                                    \
+  }                                                                       \
+                                                                          \
+  void type::set_lane(int lane, bool value) {                             \
+    DCHECK(lane < lane_count && lane >= 0);                               \
+    int32_t int_val = value ? -1 : 0;                                     \
+    SIMD128_WRITE_LANE(lane_count, field_type, field_size, int_val)       \
+  }
 
+SIMD128_BOOLEAN_LANE_FNS(Bool32x4, int32_t, 4, INT32, kInt32Size)
+SIMD128_BOOLEAN_LANE_FNS(Bool16x8, int16_t, 8, INT16, kShortSize)
+SIMD128_BOOLEAN_LANE_FNS(Bool8x16, int8_t, 16, INT8, kCharSize)
+#undef SIMD128_BOOLEAN_LANE_FNS
 
-void Int32x4::set_lane(int lane, int32_t value) {
-  DCHECK(lane < 4 && lane >= 0);
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  WRITE_INT32_FIELD(this, kValueOffset + lane * kInt32Size, value);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  WRITE_INT32_FIELD(this, kValueOffset + (3 - lane) * kInt32Size, value);
-#else
-#error Unknown byte ordering
-#endif
-}
-
-
-bool Bool32x4::get_lane(int lane) const {
-  DCHECK(lane < 4 && lane >= 0);
-  int32_t value;
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  value = READ_INT32_FIELD(this, kValueOffset + lane * kInt32Size);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  value = READ_INT32_FIELD(this, kValueOffset + (3 - lane) * kInt32Size);
-#else
-#error Unknown byte ordering
-#endif
-  DCHECK(value == 0 || value == -1);
-  return value != 0;
-}
-
-
-void Bool32x4::set_lane(int lane, bool value) {
-  DCHECK(lane < 4 && lane >= 0);
-  int32_t int_val = value ? -1 : 0;
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  WRITE_INT32_FIELD(this, kValueOffset + lane * kInt32Size, int_val);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  WRITE_INT32_FIELD(this, kValueOffset + (3 - lane) * kInt32Size, int_val);
-#else
-#error Unknown byte ordering
-#endif
-}
-
-
-int16_t Int16x8::get_lane(int lane) const {
-  DCHECK(lane < 8 && lane >= 0);
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  return READ_INT16_FIELD(this, kValueOffset + lane * kShortSize);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  return READ_INT16_FIELD(this, kValueOffset + (7 - lane) * kShortSize);
-#else
-#error Unknown byte ordering
-#endif
-}
-
-
-void Int16x8::set_lane(int lane, int16_t value) {
-  DCHECK(lane < 8 && lane >= 0);
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  WRITE_INT16_FIELD(this, kValueOffset + lane * kShortSize, value);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  WRITE_INT16_FIELD(this, kValueOffset + (7 - lane) * kShortSize, value);
-#else
-#error Unknown byte ordering
-#endif
-}
-
-
-bool Bool16x8::get_lane(int lane) const {
-  DCHECK(lane < 8 && lane >= 0);
-  int16_t value;
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  return READ_INT16_FIELD(this, kValueOffset + lane * kShortSize);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  return READ_INT16_FIELD(this, kValueOffset + (7 - lane) * kShortSize);
-#else
-#error Unknown byte ordering
-#endif
-  DCHECK(value == 0 || value == -1);
-  return value != 0;
-}
-
-
-void Bool16x8::set_lane(int lane, bool value) {
-  DCHECK(lane < 8 && lane >= 0);
-  int16_t int_val = value ? -1 : 0;
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  WRITE_INT16_FIELD(this, kValueOffset + lane * kShortSize, int_val);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  WRITE_INT16_FIELD(this, kValueOffset + (7 - lane) * kShortSize, int_val);
-#else
-#error Unknown byte ordering
-#endif
-}
-
-
-int8_t Int8x16::get_lane(int lane) const {
-  DCHECK(lane < 16 && lane >= 0);
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  return READ_BYTE_FIELD(this, kValueOffset + lane * kCharSize);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  return READ_BYTE_FIELD(this, kValueOffset + (15 - lane) * kCharSize);
-#else
-#error Unknown byte ordering
-#endif
-}
-
-
-void Int8x16::set_lane(int lane, int8_t value) {
-  DCHECK(lane < 16 && lane >= 0);
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  WRITE_BYTE_FIELD(this, kValueOffset + lane * kCharSize, value);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  WRITE_BYTE_FIELD(this, kValueOffset + (15 - lane) * kCharSize, value);
-#else
-#error Unknown byte ordering
-#endif
-}
-
-
-bool Bool8x16::get_lane(int lane) const {
-  DCHECK(lane < 16 && lane >= 0);
-  int8_t value;
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  value = READ_BYTE_FIELD(this, kValueOffset + lane * kCharSize);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  value = READ_BYTE_FIELD(this, kValueOffset + (15 - lane) * kCharSize);
-#else
-#error Unknown byte ordering
-#endif
-  DCHECK(value == 0 || value == -1);
-  return value != 0;
-}
-
-
-void Bool8x16::set_lane(int lane, bool value) {
-  DCHECK(lane < 16 && lane >= 0);
-  int8_t int_val = value ? -1 : 0;
-#if defined(V8_TARGET_LITTLE_ENDIAN)
-  WRITE_BYTE_FIELD(this, kValueOffset + lane * kCharSize, int_val);
-#elif defined(V8_TARGET_BIG_ENDIAN)
-  WRITE_BYTE_FIELD(this, kValueOffset + (15 - lane) * kCharSize, int_val);
-#else
-#error Unknown byte ordering
-#endif
-}
+#undef SIMD128_READ_LANE
+#undef SIMD128_WRITE_LANE
 
 
 ACCESSORS(JSObject, properties, FixedArray, kPropertiesOffset)
 
 
 Object** FixedArray::GetFirstElementAddress() {
   return reinterpret_cast<Object**>(FIELD_ADDR(this, OffsetOfElementAt(0)));
 }
 
 
@@ skipping 6158 matching lines @@
 #undef WRITE_FIELD
 #undef NOBARRIER_WRITE_FIELD
 #undef WRITE_BARRIER
 #undef CONDITIONAL_WRITE_BARRIER
 #undef READ_DOUBLE_FIELD
 #undef WRITE_DOUBLE_FIELD
 #undef READ_INT_FIELD
 #undef WRITE_INT_FIELD
 #undef READ_INTPTR_FIELD
 #undef WRITE_INTPTR_FIELD
+#undef READ_UINT8_FIELD
+#undef WRITE_UINT8_FIELD
+#undef READ_INT8_FIELD
+#undef WRITE_INT8_FIELD
 #undef READ_UINT16_FIELD
 #undef WRITE_UINT16_FIELD
 #undef READ_INT16_FIELD
 #undef WRITE_INT16_FIELD
 #undef READ_UINT32_FIELD
 #undef WRITE_UINT32_FIELD
 #undef READ_INT32_FIELD
 #undef WRITE_INT32_FIELD
 #undef READ_FLOAT_FIELD
 #undef WRITE_FLOAT_FIELD
 #undef READ_UINT64_FIELD
 #undef WRITE_UINT64_FIELD
 #undef READ_INT64_FIELD
 #undef WRITE_INT64_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_