[simd.js] Single SIMD128_VALUE_TYPE for all Simd128Values.

src/objects.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.
 
 #ifndef V8_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 
 #include "src/allocation.h"
@@ skipping 357 matching lines @@
   V(INTERNALIZED_STRING_TYPE)                                   \
   V(ONE_BYTE_INTERNALIZED_STRING_TYPE)                          \
   V(EXTERNAL_INTERNALIZED_STRING_TYPE)                          \
   V(EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE)                 \
   V(EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE)       \
   V(SHORT_EXTERNAL_INTERNALIZED_STRING_TYPE)                    \
   V(SHORT_EXTERNAL_ONE_BYTE_INTERNALIZED_STRING_TYPE)           \
   V(SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE) \
                                                                 \
   V(SYMBOL_TYPE)                                                \
-  V(FLOAT32X4_TYPE)                                             \
-  V(INT32X4_TYPE)                                               \
-  V(BOOL32X4_TYPE)                                              \
-  V(INT16X8_TYPE)                                               \
-  V(BOOL16X8_TYPE)                                              \
-  V(INT8X16_TYPE)                                               \
-  V(BOOL8X16_TYPE)                                              \
+  V(SIMD128_VALUE_TYPE)                                         \
                                                                 \
   V(MAP_TYPE)                                                   \
   V(CODE_TYPE)                                                  \
   V(ODDBALL_TYPE)                                               \
   V(CELL_TYPE)                                                  \
   V(PROPERTY_CELL_TYPE)                                         \
                                                                 \
   V(HEAP_NUMBER_TYPE)                                           \
   V(MUTABLE_HEAP_NUMBER_TYPE)                                   \
   V(FOREIGN_TYPE)                                               \
@@ skipping 273 matching lines @@
 
   // Objects allocated in their own spaces (never in new space).
   MAP_TYPE,
   CODE_TYPE,
   ODDBALL_TYPE,
 
   // "Data", objects that cannot contain non-map-word pointers to heap
   // objects.
   HEAP_NUMBER_TYPE,
   MUTABLE_HEAP_NUMBER_TYPE,
-  FLOAT32X4_TYPE,  // FIRST_SIMD_VALUE_TYPE
-  INT32X4_TYPE,
-  BOOL32X4_TYPE,
-  INT16X8_TYPE,
-  BOOL16X8_TYPE,
-  INT8X16_TYPE,
-  BOOL8X16_TYPE,  // LAST_SIMD_VALUE_TYPE
+  SIMD128_VALUE_TYPE,
   FOREIGN_TYPE,
   BYTE_ARRAY_TYPE,
   BYTECODE_ARRAY_TYPE,
   FREE_SPACE_TYPE,
   FIXED_INT8_ARRAY_TYPE,  // FIRST_FIXED_TYPED_ARRAY_TYPE
   FIXED_UINT8_ARRAY_TYPE,
   FIXED_INT16_ARRAY_TYPE,
   FIXED_UINT16_ARRAY_TYPE,
   FIXED_INT32_ARRAY_TYPE,
   FIXED_UINT32_ARRAY_TYPE,
@@ skipping 63 matching lines @@
   JS_FUNCTION_TYPE,  // LAST_JS_OBJECT_TYPE, LAST_JS_RECEIVER_TYPE
 
   // Pseudo-types
   FIRST_TYPE = 0x0,
   LAST_TYPE = JS_FUNCTION_TYPE,
   FIRST_NAME_TYPE = FIRST_TYPE,
   LAST_NAME_TYPE = SYMBOL_TYPE,
   FIRST_UNIQUE_NAME_TYPE = INTERNALIZED_STRING_TYPE,
   LAST_UNIQUE_NAME_TYPE = SYMBOL_TYPE,
   FIRST_NONSTRING_TYPE = SYMBOL_TYPE,
-  // Boundaries for testing for a SIMD types.
-  FIRST_SIMD_VALUE_TYPE = FLOAT32X4_TYPE,
-  LAST_SIMD_VALUE_TYPE = BOOL8X16_TYPE,
   // Boundaries for testing for a fixed typed array.
   FIRST_FIXED_TYPED_ARRAY_TYPE = FIXED_INT8_ARRAY_TYPE,
   LAST_FIXED_TYPED_ARRAY_TYPE = FIXED_UINT8_CLAMPED_ARRAY_TYPE,
   // Boundary for promotion to old space.
   LAST_DATA_TYPE = FILLER_TYPE,
   // Boundary for objects represented as JSReceiver (i.e. JSObject or JSProxy).
   // Note that there is no range for JSObject or JSProxy, since their subtypes
   // are not continuous in this enum! The enum ranges instead reflect the
   // external class names, where proxies are treated as either ordinary objects,
   // or functions.
@@ skipping 814 matching lines @@
   static const int kInfinityOrNanExponent =
       (kExponentMask >> kExponentShift) - kExponentBias;
   static const int kMantissaBitsInTopWord = 20;
   static const int kNonMantissaBitsInTopWord = 12;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(HeapNumber);
 };
 
 
-// The SimdValue128 class describes heap allocated 128 bit SIMD values.
+// The Simd128Value class describes heap allocated 128 bit SIMD values.
 class Simd128Value : public HeapObject {
  public:
   DECLARE_CAST(Simd128Value)
 
+  DECLARE_PRINTER(Simd128Value)
+  DECLARE_VERIFIER(Simd128Value)
+
   // Checks that another instance is bit-wise equal.
   bool BitwiseEquals(const Simd128Value* other) const;
   // Computes a hash from the 128 bit value, viewed as 4 32-bit integers.
   uint32_t Hash() const;
   // Copies the 16 bytes of SIMD data to the destination address.
   void CopyBits(void* destination) const;
 
   // Layout description.
   static const int kValueOffset = HeapObject::kHeaderSize;
   static const int kSize = kValueOffset + kSimd128Size;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Simd128Value);
 };
 
 
-#define SIMD128_TYPES(V)            \
-  V(Float32x4, float32x4, 4, float) \
-  V(Int32x4, int32x4, 4, int32_t)   \
-  V(Bool32x4, bool32x4, 4, bool)    \
-  V(Int16x8, int16x8, 8, int16_t)   \
-  V(Bool16x8, bool16x8, 8, bool)    \
-  V(Int8x16, int8x16, 16, int8_t)   \
-  V(Bool8x16, bool8x16, 16, bool)
+// V has parameters (TYPE, Type, type, lane count, lane type)
+#define SIMD128_TYPES(V)                       \
+  V(FLOAT32X4, Float32x4, float32x4, 4, float) \
+  V(INT32X4, Int32x4, int32x4, 4, int32_t)     \
+  V(BOOL32X4, Bool32x4, bool32x4, 4, bool)     \
+  V(INT16X8, Int16x8, int16x8, 8, int16_t)     \
+  V(BOOL16X8, Bool16x8, bool16x8, 8, bool)     \
+  V(INT8X16, Int8x16, int8x16, 16, int8_t)     \
+  V(BOOL8X16, Bool8x16, bool8x16, 16, bool)
 
-#define SIMD128_VALUE_CLASS(name, type, lane_count, lane_type) \
-  class name : public Simd128Value {                           \
-   public:                                                     \
-    inline lane_type get_lane(int lane) const;                 \
-    inline void set_lane(int lane, lane_type value);           \
-                                                               \
-    DECLARE_CAST(name)                                         \
-                                                               \
-    DECLARE_PRINTER(name)                                      \
-    DECLARE_VERIFIER(name)                                     \
-                                                               \
-   private:                                                    \
-    DISALLOW_IMPLICIT_CONSTRUCTORS(name);                      \
+#define SIMD128_VALUE_CLASS(TYPE, Type, type, lane_count, lane_type) \
+  class Type final : public Simd128Value {                           \
+   public:                                                           \
+    inline lane_type get_lane(int lane) const;                       \
+    inline void set_lane(int lane, lane_type value);                 \
+                                                                     \
+    DECLARE_CAST(Type)                                               \
+                                                                     \
+    DECLARE_PRINTER(Type)                                            \
+                                                                     \
+   private:                                                          \
+    DISALLOW_IMPLICIT_CONSTRUCTORS(Type);                            \
   };
-
 SIMD128_TYPES(SIMD128_VALUE_CLASS)
+#undef SIMD128_VALUE_CLASS
 
 
 enum EnsureElementsMode {
   DONT_ALLOW_DOUBLE_ELEMENTS,
   ALLOW_COPIED_DOUBLE_ELEMENTS,
   ALLOW_CONVERTED_DOUBLE_ELEMENTS
 };
 
 
 // Indicator for one component of an AccessorPair.
@@ skipping 8899 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_