Bug 1146295: Remove "flags" macro argument in SIMD.h; r=h4writer
authorBenjamin Bouvier <benj@benj.me>
Mon, 23 Mar 2015 10:21:34 +0100
changeset 265107 8db04357fe91564a39b370e9ba8b3dce8544924e
parent 265106 04f99f21d1f2bccbde2fe1548578a8f50457ff2e
child 265108 bf1f3c86e45de07a73b1efe44b6554ae19cdb00e
push id4718
push userraliiev@mozilla.com
push dateMon, 11 May 2015 18:39:53 +0000
treeherdermozilla-beta@c20c4ef55f08 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersh4writer
bugs1146295
milestone39.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1146295: Remove "flags" macro argument in SIMD.h; r=h4writer
js/src/builtin/SIMD.cpp
js/src/builtin/SIMD.h
--- a/js/src/builtin/SIMD.cpp
+++ b/js/src/builtin/SIMD.cpp
@@ -1087,58 +1087,58 @@ Store(JSContext *cx, unsigned argc, Valu
     Elem *src = TypedObjectMemory<Elem*>(args[2]);
     Elem *dst = reinterpret_cast<Elem*>(static_cast<char*>(AnyTypedArrayViewData(typedArray)) + byteStart);
     memcpy(dst, src, sizeof(Elem) * NumElem);
 
     args.rval().setObject(args[2].toObject());
     return true;
 }
 
-#define DEFINE_SIMD_FLOAT32X4_FUNCTION(Name, Func, Operands, Flags) \
-bool                                                                \
-js::simd_float32x4_##Name(JSContext *cx, unsigned argc, Value *vp)  \
-{                                                                   \
-    return Func(cx, argc, vp);                                      \
+#define DEFINE_SIMD_FLOAT32X4_FUNCTION(Name, Func, Operands)       \
+bool                                                               \
+js::simd_float32x4_##Name(JSContext *cx, unsigned argc, Value *vp) \
+{                                                                  \
+    return Func(cx, argc, vp);                                     \
 }
 FLOAT32X4_FUNCTION_LIST(DEFINE_SIMD_FLOAT32X4_FUNCTION)
 #undef DEFINE_SIMD_FLOAT32X4_FUNCTION
 
-#define DEFINE_SIMD_FLOAT64X2_FUNCTION(Name, Func, Operands, Flags) \
-bool                                                                \
-js::simd_float64x2_##Name(JSContext *cx, unsigned argc, Value *vp)  \
-{                                                                   \
-    return Func(cx, argc, vp);                                      \
+#define DEFINE_SIMD_FLOAT64X2_FUNCTION(Name, Func, Operands)       \
+bool                                                               \
+js::simd_float64x2_##Name(JSContext *cx, unsigned argc, Value *vp) \
+{                                                                  \
+    return Func(cx, argc, vp);                                     \
 }
 FLOAT64X2_FUNCTION_LIST(DEFINE_SIMD_FLOAT64X2_FUNCTION)
 #undef DEFINE_SIMD_FLOAT64X2_FUNCTION
 
-#define DEFINE_SIMD_INT32X4_FUNCTION(Name, Func, Operands, Flags)   \
-bool                                                                \
-js::simd_int32x4_##Name(JSContext *cx, unsigned argc, Value *vp)    \
-{                                                                   \
-    return Func(cx, argc, vp);                                      \
+#define DEFINE_SIMD_INT32X4_FUNCTION(Name, Func, Operands)         \
+bool                                                               \
+js::simd_int32x4_##Name(JSContext *cx, unsigned argc, Value *vp)   \
+{                                                                  \
+    return Func(cx, argc, vp);                                     \
 }
 INT32X4_FUNCTION_LIST(DEFINE_SIMD_INT32X4_FUNCTION)
 #undef DEFINE_SIMD_INT32X4_FUNCTION
 
 const JSFunctionSpec js::Float32x4Methods[] = {
-#define SIMD_FLOAT32X4_FUNCTION_ITEM(Name, Func, Operands, Flags)   \
-        JS_FN(#Name, js::simd_float32x4_##Name, Operands, Flags),
+#define SIMD_FLOAT32X4_FUNCTION_ITEM(Name, Func, Operands)         \
+        JS_FN(#Name, js::simd_float32x4_##Name, Operands, 0),
         FLOAT32X4_FUNCTION_LIST(SIMD_FLOAT32X4_FUNCTION_ITEM)
 #undef SIMD_FLOAT32x4_FUNCTION_ITEM
         JS_FS_END
 };
 
 const JSFunctionSpec js::Float64x2Methods[] = {
-#define SIMD_FLOAT64X2_FUNCTION_ITEM(Name, Func, Operands, Flags)       \
-        JS_FN(#Name, js::simd_float64x2_##Name, Operands, Flags),
+#define SIMD_FLOAT64X2_FUNCTION_ITEM(Name, Func, Operands)         \
+        JS_FN(#Name, js::simd_float64x2_##Name, Operands, 0),
         FLOAT64X2_FUNCTION_LIST(SIMD_FLOAT64X2_FUNCTION_ITEM)
 #undef SIMD_FLOAT64X2_FUNCTION_ITEM
         JS_FS_END
 };
 
 const JSFunctionSpec js::Int32x4Methods[] = {
-#define SIMD_INT32X4_FUNCTION_ITEM(Name, Func, Operands, Flags)     \
-        JS_FN(#Name, js::simd_int32x4_##Name, Operands, Flags),
+#define SIMD_INT32X4_FUNCTION_ITEM(Name, Func, Operands)           \
+        JS_FN(#Name, js::simd_int32x4_##Name, Operands, 0),
         INT32X4_FUNCTION_LIST(SIMD_INT32X4_FUNCTION_ITEM)
 #undef SIMD_INT32X4_FUNCTION_ITEM
         JS_FS_END
 };
--- a/js/src/builtin/SIMD.h
+++ b/js/src/builtin/SIMD.h
@@ -15,181 +15,181 @@
 #include "vm/GlobalObject.h"
 
 /*
  * JS SIMD functions.
  * Spec matching polyfill:
  * https://github.com/johnmccutchan/ecmascript_simd/blob/master/src/ecmascript_simd.js
  */
 
-#define FLOAT32X4_UNARY_FUNCTION_LIST(V)                                            \
-  V(abs, (UnaryFunc<Float32x4, Abs, Float32x4>), 1, 0)                              \
-  V(check, (UnaryFunc<Float32x4, Identity, Float32x4>), 1, 0)                       \
-  V(fromFloat64x2, (FuncConvert<Float64x2, Float32x4> ), 1, 0)                      \
-  V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Float32x4>), 1, 0)               \
-  V(fromInt32x4, (FuncConvert<Int32x4, Float32x4> ), 1, 0)                          \
-  V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Float32x4>), 1, 0)                   \
-  V(neg, (UnaryFunc<Float32x4, Neg, Float32x4>), 1, 0)                              \
-  V(not, (CoercedUnaryFunc<Float32x4, Int32x4, Not, Float32x4>), 1, 0)              \
-  V(reciprocalApproximation, (UnaryFunc<Float32x4, RecApprox, Float32x4>), 1, 0)    \
-  V(reciprocalSqrtApproximation, (UnaryFunc<Float32x4, RecSqrtApprox, Float32x4>), 1, 0) \
-  V(splat, (FuncSplat<Float32x4>), 1, 0)                                            \
-  V(sqrt, (UnaryFunc<Float32x4, Sqrt, Float32x4>), 1, 0)
+#define FLOAT32X4_UNARY_FUNCTION_LIST(V)                                              \
+  V(abs, (UnaryFunc<Float32x4, Abs, Float32x4>), 1)                                   \
+  V(check, (UnaryFunc<Float32x4, Identity, Float32x4>), 1)                            \
+  V(fromFloat64x2, (FuncConvert<Float64x2, Float32x4> ), 1)                           \
+  V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Float32x4>), 1)                    \
+  V(fromInt32x4, (FuncConvert<Int32x4, Float32x4> ), 1)                               \
+  V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Float32x4>), 1)                        \
+  V(neg, (UnaryFunc<Float32x4, Neg, Float32x4>), 1)                                   \
+  V(not, (CoercedUnaryFunc<Float32x4, Int32x4, Not, Float32x4>), 1)                   \
+  V(reciprocalApproximation, (UnaryFunc<Float32x4, RecApprox, Float32x4>), 1)         \
+  V(reciprocalSqrtApproximation, (UnaryFunc<Float32x4, RecSqrtApprox, Float32x4>), 1) \
+  V(splat, (FuncSplat<Float32x4>), 1)                                                 \
+  V(sqrt, (UnaryFunc<Float32x4, Sqrt, Float32x4>), 1)
 
-#define FLOAT32X4_BINARY_FUNCTION_LIST(V)                                           \
-  V(add, (BinaryFunc<Float32x4, Add, Float32x4>), 2, 0)                             \
-  V(and, (CoercedBinaryFunc<Float32x4, Int32x4, And, Float32x4>), 2, 0)             \
-  V(div, (BinaryFunc<Float32x4, Div, Float32x4>), 2, 0)                             \
-  V(equal, (CompareFunc<Float32x4, Equal>), 2, 0)                                   \
-  V(greaterThan, (CompareFunc<Float32x4, GreaterThan>), 2, 0)                       \
-  V(greaterThanOrEqual, (CompareFunc<Float32x4, GreaterThanOrEqual>), 2, 0)         \
-  V(lessThan, (CompareFunc<Float32x4, LessThan>), 2, 0)                             \
-  V(lessThanOrEqual, (CompareFunc<Float32x4, LessThanOrEqual>), 2, 0)               \
-  V(load,    (Load<Float32x4, 4>), 2, 0)                                            \
-  V(loadXYZ, (Load<Float32x4, 3>), 2, 0)                                            \
-  V(loadXY,  (Load<Float32x4, 2>), 2, 0)                                            \
-  V(loadX,   (Load<Float32x4, 1>), 2, 0)                                            \
-  V(max, (BinaryFunc<Float32x4, Maximum, Float32x4>), 2, 0)                         \
-  V(maxNum, (BinaryFunc<Float32x4, MaxNum, Float32x4>), 2, 0)                       \
-  V(min, (BinaryFunc<Float32x4, Minimum, Float32x4>), 2, 0)                         \
-  V(minNum, (BinaryFunc<Float32x4, MinNum, Float32x4>), 2, 0)                       \
-  V(mul, (BinaryFunc<Float32x4, Mul, Float32x4>), 2, 0)                             \
-  V(notEqual, (CompareFunc<Float32x4, NotEqual>), 2, 0)                             \
-  V(or, (CoercedBinaryFunc<Float32x4, Int32x4, Or, Float32x4>), 2, 0)               \
-  V(store,    (Store<Float32x4, 4>), 3, 0)                                          \
-  V(storeXYZ, (Store<Float32x4, 3>), 3, 0)                                          \
-  V(storeXY,  (Store<Float32x4, 2>), 3, 0)                                          \
-  V(storeX,   (Store<Float32x4, 1>), 3, 0)                                          \
-  V(sub, (BinaryFunc<Float32x4, Sub, Float32x4>), 2, 0)                             \
-  V(withX, (FuncWith<Float32x4, WithX>), 2, 0)                                      \
-  V(withY, (FuncWith<Float32x4, WithY>), 2, 0)                                      \
-  V(withZ, (FuncWith<Float32x4, WithZ>), 2, 0)                                      \
-  V(withW, (FuncWith<Float32x4, WithW>), 2, 0)                                      \
-  V(xor, (CoercedBinaryFunc<Float32x4, Int32x4, Xor, Float32x4>), 2, 0)
+#define FLOAT32X4_BINARY_FUNCTION_LIST(V)                                             \
+  V(add, (BinaryFunc<Float32x4, Add, Float32x4>), 2)                                  \
+  V(and, (CoercedBinaryFunc<Float32x4, Int32x4, And, Float32x4>), 2)                  \
+  V(div, (BinaryFunc<Float32x4, Div, Float32x4>), 2)                                  \
+  V(equal, (CompareFunc<Float32x4, Equal>), 2)                                        \
+  V(greaterThan, (CompareFunc<Float32x4, GreaterThan>), 2)                            \
+  V(greaterThanOrEqual, (CompareFunc<Float32x4, GreaterThanOrEqual>), 2)              \
+  V(lessThan, (CompareFunc<Float32x4, LessThan>), 2)                                  \
+  V(lessThanOrEqual, (CompareFunc<Float32x4, LessThanOrEqual>), 2)                    \
+  V(load,    (Load<Float32x4, 4>), 2)                                                 \
+  V(loadXYZ, (Load<Float32x4, 3>), 2)                                                 \
+  V(loadXY,  (Load<Float32x4, 2>), 2)                                                 \
+  V(loadX,   (Load<Float32x4, 1>), 2)                                                 \
+  V(max, (BinaryFunc<Float32x4, Maximum, Float32x4>), 2)                              \
+  V(maxNum, (BinaryFunc<Float32x4, MaxNum, Float32x4>), 2)                            \
+  V(min, (BinaryFunc<Float32x4, Minimum, Float32x4>), 2)                              \
+  V(minNum, (BinaryFunc<Float32x4, MinNum, Float32x4>), 2)                            \
+  V(mul, (BinaryFunc<Float32x4, Mul, Float32x4>), 2)                                  \
+  V(notEqual, (CompareFunc<Float32x4, NotEqual>), 2)                                  \
+  V(or, (CoercedBinaryFunc<Float32x4, Int32x4, Or, Float32x4>), 2)                    \
+  V(store,    (Store<Float32x4, 4>), 3)                                               \
+  V(storeXYZ, (Store<Float32x4, 3>), 3)                                               \
+  V(storeXY,  (Store<Float32x4, 2>), 3)                                               \
+  V(storeX,   (Store<Float32x4, 1>), 3)                                               \
+  V(sub, (BinaryFunc<Float32x4, Sub, Float32x4>), 2)                                  \
+  V(withX, (FuncWith<Float32x4, WithX>), 2)                                           \
+  V(withY, (FuncWith<Float32x4, WithY>), 2)                                           \
+  V(withZ, (FuncWith<Float32x4, WithZ>), 2)                                           \
+  V(withW, (FuncWith<Float32x4, WithW>), 2)                                           \
+  V(xor, (CoercedBinaryFunc<Float32x4, Int32x4, Xor, Float32x4>), 2)
 
-#define FLOAT32X4_TERNARY_FUNCTION_LIST(V)                                          \
-  V(bitselect, BitSelect<Float32x4>, 3, 0)                                          \
-  V(clamp, Clamp<Float32x4>, 3, 0)                                                  \
-  V(select, Select<Float32x4>, 3, 0)
+#define FLOAT32X4_TERNARY_FUNCTION_LIST(V)                                            \
+  V(bitselect, BitSelect<Float32x4>, 3)                                               \
+  V(clamp, Clamp<Float32x4>, 3)                                                       \
+  V(select, Select<Float32x4>, 3)
 
-#define FLOAT32X4_SHUFFLE_FUNCTION_LIST(V)                                          \
-  V(swizzle, Swizzle<Float32x4>, 2, 0)                                              \
-  V(shuffle, Shuffle<Float32x4>, 3, 0)
+#define FLOAT32X4_SHUFFLE_FUNCTION_LIST(V)                                            \
+  V(swizzle, Swizzle<Float32x4>, 2)                                                   \
+  V(shuffle, Shuffle<Float32x4>, 3)
 
-#define FLOAT32X4_FUNCTION_LIST(V)                                                  \
-  FLOAT32X4_UNARY_FUNCTION_LIST(V)                                                  \
-  FLOAT32X4_BINARY_FUNCTION_LIST(V)                                                 \
-  FLOAT32X4_TERNARY_FUNCTION_LIST(V)                                                \
+#define FLOAT32X4_FUNCTION_LIST(V)                                                    \
+  FLOAT32X4_UNARY_FUNCTION_LIST(V)                                                    \
+  FLOAT32X4_BINARY_FUNCTION_LIST(V)                                                   \
+  FLOAT32X4_TERNARY_FUNCTION_LIST(V)                                                  \
   FLOAT32X4_SHUFFLE_FUNCTION_LIST(V)
 
-#define FLOAT64X2_UNARY_FUNCTION_LIST(V)                                            \
-  V(abs, (UnaryFunc<Float64x2, Abs, Float64x2>), 1, 0)                              \
-  V(check, (UnaryFunc<Float64x2, Identity, Float64x2>), 1, 0)                       \
-  V(fromFloat32x4, (FuncConvert<Float32x4, Float64x2> ), 1, 0)                      \
-  V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Float64x2>), 1, 0)               \
-  V(fromInt32x4, (FuncConvert<Int32x4, Float64x2> ), 1, 0)                          \
-  V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Float64x2>), 1, 0)                   \
-  V(neg, (UnaryFunc<Float64x2, Neg, Float64x2>), 1, 0)                              \
-  V(reciprocalApproximation, (UnaryFunc<Float64x2, RecApprox, Float64x2>), 1, 0)    \
-  V(reciprocalSqrtApproximation, (UnaryFunc<Float64x2, RecSqrtApprox, Float64x2>), 1, 0) \
-  V(splat, (FuncSplat<Float64x2>), 1, 0)                                            \
-  V(sqrt, (UnaryFunc<Float64x2, Sqrt, Float64x2>), 1, 0)
+#define FLOAT64X2_UNARY_FUNCTION_LIST(V)                                              \
+  V(abs, (UnaryFunc<Float64x2, Abs, Float64x2>), 1)                                   \
+  V(check, (UnaryFunc<Float64x2, Identity, Float64x2>), 1)                            \
+  V(fromFloat32x4, (FuncConvert<Float32x4, Float64x2> ), 1)                           \
+  V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Float64x2>), 1)                    \
+  V(fromInt32x4, (FuncConvert<Int32x4, Float64x2> ), 1)                               \
+  V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Float64x2>), 1)                        \
+  V(neg, (UnaryFunc<Float64x2, Neg, Float64x2>), 1)                                   \
+  V(reciprocalApproximation, (UnaryFunc<Float64x2, RecApprox, Float64x2>), 1)         \
+  V(reciprocalSqrtApproximation, (UnaryFunc<Float64x2, RecSqrtApprox, Float64x2>), 1) \
+  V(splat, (FuncSplat<Float64x2>), 1)                                                 \
+  V(sqrt, (UnaryFunc<Float64x2, Sqrt, Float64x2>), 1)
 
-#define FLOAT64X2_BINARY_FUNCTION_LIST(V)                                           \
-  V(add, (BinaryFunc<Float64x2, Add, Float64x2>), 2, 0)                             \
-  V(div, (BinaryFunc<Float64x2, Div, Float64x2>), 2, 0)                             \
-  V(equal, (CompareFunc<Float64x2, Equal>), 2, 0)                                   \
-  V(greaterThan, (CompareFunc<Float64x2, GreaterThan>), 2, 0)                       \
-  V(greaterThanOrEqual, (CompareFunc<Float64x2, GreaterThanOrEqual>), 2, 0)         \
-  V(lessThan, (CompareFunc<Float64x2, LessThan>), 2, 0)                             \
-  V(lessThanOrEqual, (CompareFunc<Float64x2, LessThanOrEqual>), 2, 0)               \
-  V(load,    (Load<Float64x2, 2>), 2, 0)                                            \
-  V(loadX,   (Load<Float64x2, 1>), 2, 0)                                            \
-  V(max, (BinaryFunc<Float64x2, Maximum, Float64x2>), 2, 0)                         \
-  V(maxNum, (BinaryFunc<Float64x2, MaxNum, Float64x2>), 2, 0)                       \
-  V(min, (BinaryFunc<Float64x2, Minimum, Float64x2>), 2, 0)                         \
-  V(minNum, (BinaryFunc<Float64x2, MinNum, Float64x2>), 2, 0)                       \
-  V(mul, (BinaryFunc<Float64x2, Mul, Float64x2>), 2, 0)                             \
-  V(notEqual, (CompareFunc<Float64x2, NotEqual>), 2, 0)                             \
-  V(store,    (Store<Float64x2, 2>), 3, 0)                                          \
-  V(storeX,   (Store<Float64x2, 1>), 3, 0)                                          \
-  V(sub, (BinaryFunc<Float64x2, Sub, Float64x2>), 2, 0)                             \
-  V(withX, (FuncWith<Float64x2, WithX>), 2, 0)                                      \
-  V(withY, (FuncWith<Float64x2, WithY>), 2, 0)
+#define FLOAT64X2_BINARY_FUNCTION_LIST(V)                                             \
+  V(add, (BinaryFunc<Float64x2, Add, Float64x2>), 2)                                  \
+  V(div, (BinaryFunc<Float64x2, Div, Float64x2>), 2)                                  \
+  V(equal, (CompareFunc<Float64x2, Equal>), 2)                                        \
+  V(greaterThan, (CompareFunc<Float64x2, GreaterThan>), 2)                            \
+  V(greaterThanOrEqual, (CompareFunc<Float64x2, GreaterThanOrEqual>), 2)              \
+  V(lessThan, (CompareFunc<Float64x2, LessThan>), 2)                                  \
+  V(lessThanOrEqual, (CompareFunc<Float64x2, LessThanOrEqual>), 2)                    \
+  V(load,    (Load<Float64x2, 2>), 2)                                                 \
+  V(loadX,   (Load<Float64x2, 1>), 2)                                                 \
+  V(max, (BinaryFunc<Float64x2, Maximum, Float64x2>), 2)                              \
+  V(maxNum, (BinaryFunc<Float64x2, MaxNum, Float64x2>), 2)                            \
+  V(min, (BinaryFunc<Float64x2, Minimum, Float64x2>), 2)                              \
+  V(minNum, (BinaryFunc<Float64x2, MinNum, Float64x2>), 2)                            \
+  V(mul, (BinaryFunc<Float64x2, Mul, Float64x2>), 2)                                  \
+  V(notEqual, (CompareFunc<Float64x2, NotEqual>), 2)                                  \
+  V(store,    (Store<Float64x2, 2>), 3)                                               \
+  V(storeX,   (Store<Float64x2, 1>), 3)                                               \
+  V(sub, (BinaryFunc<Float64x2, Sub, Float64x2>), 2)                                  \
+  V(withX, (FuncWith<Float64x2, WithX>), 2)                                           \
+  V(withY, (FuncWith<Float64x2, WithY>), 2)
 
-#define FLOAT64X2_TERNARY_FUNCTION_LIST(V)                                          \
-  V(bitselect, BitSelect<Float64x2>, 3, 0)                                          \
-  V(clamp, Clamp<Float64x2>, 3, 0)                                                  \
-  V(select, Select<Float64x2>, 3, 0)
+#define FLOAT64X2_TERNARY_FUNCTION_LIST(V)                                            \
+  V(bitselect, BitSelect<Float64x2>, 3)                                               \
+  V(clamp, Clamp<Float64x2>, 3)                                                       \
+  V(select, Select<Float64x2>, 3)
 
-#define FLOAT64X2_SHUFFLE_FUNCTION_LIST(V)                                          \
-  V(swizzle, Swizzle<Float64x2>, 2, 0)                                              \
-  V(shuffle, Shuffle<Float64x2>, 3, 0)
+#define FLOAT64X2_SHUFFLE_FUNCTION_LIST(V)                                            \
+  V(swizzle, Swizzle<Float64x2>, 2)                                                   \
+  V(shuffle, Shuffle<Float64x2>, 3)
 
-#define FLOAT64X2_FUNCTION_LIST(V)                                                  \
-  FLOAT64X2_UNARY_FUNCTION_LIST(V)                                                  \
-  FLOAT64X2_BINARY_FUNCTION_LIST(V)                                                 \
-  FLOAT64X2_TERNARY_FUNCTION_LIST(V)                                                \
+#define FLOAT64X2_FUNCTION_LIST(V)                                                    \
+  FLOAT64X2_UNARY_FUNCTION_LIST(V)                                                    \
+  FLOAT64X2_BINARY_FUNCTION_LIST(V)                                                   \
+  FLOAT64X2_TERNARY_FUNCTION_LIST(V)                                                  \
   FLOAT64X2_SHUFFLE_FUNCTION_LIST(V)
 
-#define INT32X4_UNARY_FUNCTION_LIST(V)                                              \
-  V(check, (UnaryFunc<Int32x4, Identity, Int32x4>), 1, 0)                           \
-  V(fromFloat32x4, (FuncConvert<Float32x4, Int32x4>), 1, 0)                         \
-  V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Int32x4>), 1, 0)                 \
-  V(fromFloat64x2, (FuncConvert<Float64x2, Int32x4>), 1, 0)                         \
-  V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Int32x4>), 1, 0)                 \
-  V(neg, (UnaryFunc<Int32x4, Neg, Int32x4>), 1, 0)                                  \
-  V(not, (UnaryFunc<Int32x4, Not, Int32x4>), 1, 0)                                  \
-  V(splat, (FuncSplat<Int32x4>), 0, 0)
+#define INT32X4_UNARY_FUNCTION_LIST(V)                                                \
+  V(check, (UnaryFunc<Int32x4, Identity, Int32x4>), 1)                                \
+  V(fromFloat32x4, (FuncConvert<Float32x4, Int32x4>), 1)                              \
+  V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Int32x4>), 1)                      \
+  V(fromFloat64x2, (FuncConvert<Float64x2, Int32x4>), 1)                              \
+  V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Int32x4>), 1)                      \
+  V(neg, (UnaryFunc<Int32x4, Neg, Int32x4>), 1)                                       \
+  V(not, (UnaryFunc<Int32x4, Not, Int32x4>), 1)                                       \
+  V(splat, (FuncSplat<Int32x4>), 0)
 
-#define INT32X4_BINARY_FUNCTION_LIST(V)                                             \
-  V(add, (BinaryFunc<Int32x4, Add, Int32x4>), 2, 0)                                 \
-  V(and, (BinaryFunc<Int32x4, And, Int32x4>), 2, 0)                                 \
-  V(equal, (CompareFunc<Int32x4, Equal>), 2, 0)                                     \
-  V(greaterThan, (CompareFunc<Int32x4, GreaterThan>), 2, 0)                         \
-  V(greaterThanOrEqual, (CompareFunc<Int32x4, GreaterThanOrEqual>), 2, 0)           \
-  V(lessThan, (CompareFunc<Int32x4, LessThan>), 2, 0)                               \
-  V(lessThanOrEqual, (CompareFunc<Int32x4, LessThanOrEqual>), 2, 0)                 \
-  V(load,    (Load<Int32x4, 4>), 2, 0)                                              \
-  V(loadXYZ, (Load<Int32x4, 3>), 2, 0)                                              \
-  V(loadXY,  (Load<Int32x4, 2>), 2, 0)                                              \
-  V(loadX,   (Load<Int32x4, 1>), 2, 0)                                              \
-  V(mul, (BinaryFunc<Int32x4, Mul, Int32x4>), 2, 0)                                 \
-  V(notEqual, (CompareFunc<Int32x4, NotEqual>), 2, 0)                               \
-  V(or, (BinaryFunc<Int32x4, Or, Int32x4>), 2, 0)                                   \
-  V(sub, (BinaryFunc<Int32x4, Sub, Int32x4>), 2, 0)                                 \
-  V(shiftLeftByScalar, (Int32x4BinaryScalar<ShiftLeft>), 2, 0)                      \
-  V(shiftRightArithmeticByScalar, (Int32x4BinaryScalar<ShiftRight>), 2, 0)          \
-  V(shiftRightLogicalByScalar, (Int32x4BinaryScalar<ShiftRightLogical>), 2, 0)      \
-  V(store,    (Store<Int32x4, 4>), 3, 0)                                            \
-  V(storeXYZ, (Store<Int32x4, 3>), 3, 0)                                            \
-  V(storeXY,  (Store<Int32x4, 2>), 3, 0)                                            \
-  V(storeX,   (Store<Int32x4, 1>), 3, 0)                                            \
-  V(withX, (FuncWith<Int32x4, WithX>), 2, 0)                                        \
-  V(withY, (FuncWith<Int32x4, WithY>), 2, 0)                                        \
-  V(withZ, (FuncWith<Int32x4, WithZ>), 2, 0)                                        \
-  V(withW, (FuncWith<Int32x4, WithW>), 2, 0)                                        \
-  V(xor, (BinaryFunc<Int32x4, Xor, Int32x4>), 2, 0)
+#define INT32X4_BINARY_FUNCTION_LIST(V)                                               \
+  V(add, (BinaryFunc<Int32x4, Add, Int32x4>), 2)                                      \
+  V(and, (BinaryFunc<Int32x4, And, Int32x4>), 2)                                      \
+  V(equal, (CompareFunc<Int32x4, Equal>), 2)                                          \
+  V(greaterThan, (CompareFunc<Int32x4, GreaterThan>), 2)                              \
+  V(greaterThanOrEqual, (CompareFunc<Int32x4, GreaterThanOrEqual>), 2)                \
+  V(lessThan, (CompareFunc<Int32x4, LessThan>), 2)                                    \
+  V(lessThanOrEqual, (CompareFunc<Int32x4, LessThanOrEqual>), 2)                      \
+  V(load,    (Load<Int32x4, 4>), 2)                                                   \
+  V(loadXYZ, (Load<Int32x4, 3>), 2)                                                   \
+  V(loadXY,  (Load<Int32x4, 2>), 2)                                                   \
+  V(loadX,   (Load<Int32x4, 1>), 2)                                                   \
+  V(mul, (BinaryFunc<Int32x4, Mul, Int32x4>), 2)                                      \
+  V(notEqual, (CompareFunc<Int32x4, NotEqual>), 2)                                    \
+  V(or, (BinaryFunc<Int32x4, Or, Int32x4>), 2)                                        \
+  V(sub, (BinaryFunc<Int32x4, Sub, Int32x4>), 2)                                      \
+  V(shiftLeftByScalar, (Int32x4BinaryScalar<ShiftLeft>), 2)                           \
+  V(shiftRightArithmeticByScalar, (Int32x4BinaryScalar<ShiftRight>), 2)               \
+  V(shiftRightLogicalByScalar, (Int32x4BinaryScalar<ShiftRightLogical>), 2)           \
+  V(store,    (Store<Int32x4, 4>), 3)                                                 \
+  V(storeXYZ, (Store<Int32x4, 3>), 3)                                                 \
+  V(storeXY,  (Store<Int32x4, 2>), 3)                                                 \
+  V(storeX,   (Store<Int32x4, 1>), 3)                                                 \
+  V(withX, (FuncWith<Int32x4, WithX>), 2)                                             \
+  V(withY, (FuncWith<Int32x4, WithY>), 2)                                             \
+  V(withZ, (FuncWith<Int32x4, WithZ>), 2)                                             \
+  V(withW, (FuncWith<Int32x4, WithW>), 2)                                             \
+  V(xor, (BinaryFunc<Int32x4, Xor, Int32x4>), 2)
 
-#define INT32X4_TERNARY_FUNCTION_LIST(V)                                            \
-  V(bitselect, BitSelect<Int32x4>, 3, 0)                                            \
-  V(select, Select<Int32x4>, 3, 0)
+#define INT32X4_TERNARY_FUNCTION_LIST(V)                                              \
+  V(bitselect, BitSelect<Int32x4>, 3)                                                 \
+  V(select, Select<Int32x4>, 3)
 
-#define INT32X4_QUARTERNARY_FUNCTION_LIST(V)                                        \
-  V(bool, Int32x4Bool, 4, 0)
+#define INT32X4_QUARTERNARY_FUNCTION_LIST(V)                                          \
+  V(bool, Int32x4Bool, 4)
 
-#define INT32X4_SHUFFLE_FUNCTION_LIST(V)                                            \
-  V(swizzle, Swizzle<Int32x4>, 2, 0)                                                \
-  V(shuffle, Shuffle<Int32x4>, 3, 0)
+#define INT32X4_SHUFFLE_FUNCTION_LIST(V)                                              \
+  V(swizzle, Swizzle<Int32x4>, 2)                                                     \
+  V(shuffle, Shuffle<Int32x4>, 3)
 
-#define INT32X4_FUNCTION_LIST(V)                                                    \
-  INT32X4_UNARY_FUNCTION_LIST(V)                                                    \
-  INT32X4_BINARY_FUNCTION_LIST(V)                                                   \
-  INT32X4_TERNARY_FUNCTION_LIST(V)                                                  \
-  INT32X4_QUARTERNARY_FUNCTION_LIST(V)                                              \
+#define INT32X4_FUNCTION_LIST(V)                                                      \
+  INT32X4_UNARY_FUNCTION_LIST(V)                                                      \
+  INT32X4_BINARY_FUNCTION_LIST(V)                                                     \
+  INT32X4_TERNARY_FUNCTION_LIST(V)                                                    \
+  INT32X4_QUARTERNARY_FUNCTION_LIST(V)                                                \
   INT32X4_SHUFFLE_FUNCTION_LIST(V)
 
 #define CONVERSION_INT32X4_SIMD_OP(_) \
     _(fromFloat32x4)                  \
     _(fromFloat32x4Bits)
 #define FOREACH_INT32X4_SIMD_OP(_)   \
     CONVERSION_INT32X4_SIMD_OP(_)    \
     _(shiftLeftByScalar)             \
@@ -337,30 +337,30 @@ template<typename V>
 JSObject *CreateSimd(JSContext *cx, const typename V::Elem *data);
 
 template<typename V>
 bool IsVectorObject(HandleValue v);
 
 template<typename V>
 bool ToSimdConstant(JSContext *cx, HandleValue v, jit::SimdConstant *out);
 
-#define DECLARE_SIMD_FLOAT32X4_FUNCTION(Name, Func, Operands, Flags) \
-extern bool                                                          \
+#define DECLARE_SIMD_FLOAT32X4_FUNCTION(Name, Func, Operands)   \
+extern bool                                                     \
 simd_float32x4_##Name(JSContext *cx, unsigned argc, Value *vp);
 FLOAT32X4_FUNCTION_LIST(DECLARE_SIMD_FLOAT32X4_FUNCTION)
 #undef DECLARE_SIMD_FLOAT32X4_FUNCTION
 
-#define DECLARE_SIMD_FLOAT64X2_FUNCTION(Name, Func, Operands, Flags) \
-extern bool                                                          \
+#define DECLARE_SIMD_FLOAT64X2_FUNCTION(Name, Func, Operands)   \
+extern bool                                                     \
 simd_float64x2_##Name(JSContext *cx, unsigned argc, Value *vp);
 FLOAT64X2_FUNCTION_LIST(DECLARE_SIMD_FLOAT64X2_FUNCTION)
 #undef DECLARE_SIMD_FLOAT64X2_FUNCTION
 
-#define DECLARE_SIMD_INT32x4_FUNCTION(Name, Func, Operands, Flags)   \
-extern bool                                                          \
+#define DECLARE_SIMD_INT32x4_FUNCTION(Name, Func, Operands)     \
+extern bool                                                     \
 simd_int32x4_##Name(JSContext *cx, unsigned argc, Value *vp);
 INT32X4_FUNCTION_LIST(DECLARE_SIMD_INT32x4_FUNCTION)
 #undef DECLARE_SIMD_INT32x4_FUNCTION
 
 JSObject *
 InitSIMDClass(JSContext *cx, HandleObject obj);
 
 }  /* namespace js */