--- a/js/src/builtin/SIMD.cpp
+++ b/js/src/builtin/SIMD.cpp
@@ -158,16 +158,31 @@ class Int16x8Defn {
static const SimdTypeDescr::Type type = SimdTypeDescr::Int16x8;
static const JSFunctionSpec Methods[];
};
class Int32x4Defn {
public:
static const SimdTypeDescr::Type type = SimdTypeDescr::Int32x4;
static const JSFunctionSpec Methods[];
};
+class Uint8x16Defn {
+ public:
+ static const SimdTypeDescr::Type type = SimdTypeDescr::Uint8x16;
+ static const JSFunctionSpec Methods[];
+};
+class Uint16x8Defn {
+ public:
+ static const SimdTypeDescr::Type type = SimdTypeDescr::Uint16x8;
+ static const JSFunctionSpec Methods[];
+};
+class Uint32x4Defn {
+ public:
+ static const SimdTypeDescr::Type type = SimdTypeDescr::Uint32x4;
+ static const JSFunctionSpec Methods[];
+};
class Float32x4Defn {
public:
static const SimdTypeDescr::Type type = SimdTypeDescr::Float32x4;
static const JSFunctionSpec Methods[];
};
class Float64x2Defn {
public:
static const SimdTypeDescr::Type type = SimdTypeDescr::Float64x2;
@@ -244,16 +259,40 @@ const JSFunctionSpec Int16x8Defn::Method
const JSFunctionSpec Int32x4Defn::Methods[] = {
#define SIMD_INT32X4_FUNCTION_ITEM(Name, Func, Operands) \
JS_INLINABLE_FN(#Name, js::simd_int32x4_##Name, Operands, 0, SimdInt32x4),
INT32X4_FUNCTION_LIST(SIMD_INT32X4_FUNCTION_ITEM)
#undef SIMD_INT32X4_FUNCTION_ITEM
JS_FS_END
};
+const JSFunctionSpec Uint8x16Defn::Methods[] = {
+#define SIMD_UINT8X16_FUNCTION_ITEM(Name, Func, Operands) \
+ JS_FN(#Name, js::simd_uint8x16_##Name, Operands, 0),
+ UINT8X16_FUNCTION_LIST(SIMD_UINT8X16_FUNCTION_ITEM)
+#undef SIMD_UINT8X16_FUNCTION_ITEM
+ JS_FS_END
+};
+
+const JSFunctionSpec Uint16x8Defn::Methods[] = {
+#define SIMD_UINT16X8_FUNCTION_ITEM(Name, Func, Operands) \
+ JS_FN(#Name, js::simd_uint16x8_##Name, Operands, 0),
+ UINT16X8_FUNCTION_LIST(SIMD_UINT16X8_FUNCTION_ITEM)
+#undef SIMD_UINT16X8_FUNCTION_ITEM
+ JS_FS_END
+};
+
+const JSFunctionSpec Uint32x4Defn::Methods[] = {
+#define SIMD_UINT32X4_FUNCTION_ITEM(Name, Func, Operands) \
+ JS_FN(#Name, js::simd_uint32x4_##Name, Operands, 0),
+ UINT32X4_FUNCTION_LIST(SIMD_UINT32X4_FUNCTION_ITEM)
+#undef SIMD_UINT32X4_FUNCTION_ITEM
+ JS_FS_END
+};
+
const JSFunctionSpec Bool8x16Defn::Methods[] = {
#define SIMD_BOOL8X16_FUNCTION_ITEM(Name, Func, Operands) \
JS_FN(#Name, js::simd_bool8x16_##Name, Operands, 0),
BOOL8X16_FUNCTION_LIST(SIMD_BOOL8X16_FUNCTION_ITEM)
#undef SIMD_BOOL8X16_FUNCTION_ITEM
JS_FS_END
};
@@ -370,16 +409,19 @@ SimdTypeDescr::call(JSContext* cx, unsig
Rooted<TypedObject*> result(cx, TypedObject::createZeroed(cx, descr, 0));
if (!result)
return false;
switch (descr->type()) {
case SimdTypeDescr::Int8x16: return FillLanes< ::Int8x16>(cx, result, args);
case SimdTypeDescr::Int16x8: return FillLanes< ::Int16x8>(cx, result, args);
case SimdTypeDescr::Int32x4: return FillLanes< ::Int32x4>(cx, result, args);
+ case SimdTypeDescr::Uint8x16: return FillLanes< ::Uint8x16>(cx, result, args);
+ case SimdTypeDescr::Uint16x8: return FillLanes< ::Uint16x8>(cx, result, args);
+ case SimdTypeDescr::Uint32x4: return FillLanes< ::Uint32x4>(cx, result, args);
case SimdTypeDescr::Float32x4: return FillLanes< ::Float32x4>(cx, result, args);
case SimdTypeDescr::Float64x2: return FillLanes< ::Float64x2>(cx, result, args);
case SimdTypeDescr::Bool8x16: return FillLanes< ::Bool8x16>(cx, result, args);
case SimdTypeDescr::Bool16x8: return FillLanes< ::Bool16x8>(cx, result, args);
case SimdTypeDescr::Bool32x4: return FillLanes< ::Bool32x4>(cx, result, args);
case SimdTypeDescr::Bool64x2: return FillLanes< ::Bool64x2>(cx, result, args);
}
@@ -448,16 +490,31 @@ js::InitSIMDClass(JSContext* cx, HandleO
if (!i16x8)
return nullptr;
RootedObject i32x4(cx);
i32x4 = CreateAndBindSimdClass<Int32x4Defn>(cx, global, globalSimdObject, cx->names().int32x4);
if (!i32x4)
return nullptr;
+ RootedObject u8x16(cx);
+ u8x16 = CreateAndBindSimdClass<Uint8x16Defn>(cx, global, globalSimdObject, cx->names().uint8x16);
+ if (!u8x16)
+ return nullptr;
+
+ RootedObject u16x8(cx);
+ u16x8 = CreateAndBindSimdClass<Uint16x8Defn>(cx, global, globalSimdObject, cx->names().uint16x8);
+ if (!u16x8)
+ return nullptr;
+
+ RootedObject u32x4(cx);
+ u32x4 = CreateAndBindSimdClass<Uint32x4Defn>(cx, global, globalSimdObject, cx->names().uint32x4);
+ if (!u32x4)
+ return nullptr;
+
RootedObject f32x4(cx);
f32x4 = CreateAndBindSimdClass<Float32x4Defn>(cx, global, globalSimdObject, cx->names().float32x4);
if (!f32x4)
return nullptr;
RootedObject f64x2(cx);
f64x2 = CreateAndBindSimdClass<Float64x2Defn>(cx, global, globalSimdObject, cx->names().float64x2);
if (!f64x2)
@@ -922,20 +979,26 @@ struct NeverThrow
};
// While int32 to float conversions can be lossy, these conversions have
// defined behavior in C++, so we don't need to care about them here. In practice,
// this means round to nearest, tie with even (zero bit in significand).
template<>
struct ThrowOnConvert<int32_t, float> : public NeverThrow {};
+template<>
+struct ThrowOnConvert<uint32_t, float> : public NeverThrow {};
+
// All int32 can be safely converted to doubles.
template<>
struct ThrowOnConvert<int32_t, double> : public NeverThrow {};
+template<>
+struct ThrowOnConvert<uint32_t, double> : public NeverThrow {};
+
// All floats can be safely converted to doubles.
template<>
struct ThrowOnConvert<float, double> : public NeverThrow {};
// Double to float conversion for inputs which aren't in the float range are
// undefined behavior in C++, but they're defined in IEEE754.
template<>
struct ThrowOnConvert<double, float> : public NeverThrow {};
@@ -956,26 +1019,35 @@ struct ThrowIfNotInRange
d > double(mozilla::MaxValue<IntegerType>::value);
}
};
template<>
struct ThrowOnConvert<double, int32_t> : public ThrowIfNotInRange<double, int32_t> {};
template<>
+struct ThrowOnConvert<double, uint32_t> : public ThrowIfNotInRange<double, uint32_t> {};
+
+template<>
struct ThrowOnConvert<float, int32_t> : public ThrowIfNotInRange<float, int32_t> {};
+template<>
+struct ThrowOnConvert<float, uint32_t> : public ThrowIfNotInRange<float, uint32_t> {};
+
template<typename V, typename Vret>
static bool
FuncConvert(JSContext* cx, unsigned argc, Value* vp)
{
typedef typename V::Elem Elem;
typedef typename Vret::Elem RetElem;
+ static_assert(!mozilla::IsSame<V,Vret>::value, "Can't convert SIMD type to itself");
static_assert(V::lanes == Vret::lanes, "Can only convert from same number of lanes");
+ static_assert(!mozilla::IsIntegral<Elem>::value || !mozilla::IsIntegral<RetElem>::value,
+ "Cannot convert between integer SIMD types");
CallArgs args = CallArgsFromVp(argc, vp);
if (args.length() != 1 || !IsVectorObject<V>(args[0]))
return ErrorBadArgs(cx);
Elem* val = TypedObjectMemory<Elem*>(args[0]);
RetElem result[Vret::lanes];
@@ -990,18 +1062,23 @@ FuncConvert(JSContext* cx, unsigned argc
return StoreResult<Vret>(cx, args, result);
}
template<typename V, typename Vret>
static bool
FuncConvertBits(JSContext* cx, unsigned argc, Value* vp)
{
+ typedef typename V::Elem Elem;
typedef typename Vret::Elem RetElem;
+ static_assert(!mozilla::IsSame<V, Vret>::value, "Can't convert SIMD type to itself");
+ static_assert(V::lanes * sizeof(Elem) == Vret::lanes * sizeof(RetElem),
+ "Can only bitcast from the same number of bits");
+
CallArgs args = CallArgsFromVp(argc, vp);
if (args.length() != 1 || !IsVectorObject<V>(args[0]))
return ErrorBadArgs(cx);
// While we could just pass the typedMem of args[0] as StoreResults' last
// argument, a GC could move the pointer to its memory in the meanwhile.
// For consistency with other SIMD functions, simply copy the input in a
// temporary array.
@@ -1227,22 +1304,50 @@ INT16X8_FUNCTION_LIST(DEFINE_SIMD_INT16X
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
+#define DEFINE_SIMD_UINT8X16_FUNCTION(Name, Func, Operands) \
+bool \
+js::simd_uint8x16_##Name(JSContext* cx, unsigned argc, Value* vp) \
+{ \
+ return Func(cx, argc, vp); \
+}
+UINT8X16_FUNCTION_LIST(DEFINE_SIMD_UINT8X16_FUNCTION)
+#undef DEFINE_SIMD_UINT8X16_FUNCTION
+
+#define DEFINE_SIMD_UINT16X8_FUNCTION(Name, Func, Operands) \
+bool \
+js::simd_uint16x8_##Name(JSContext* cx, unsigned argc, Value* vp) \
+{ \
+ return Func(cx, argc, vp); \
+}
+UINT16X8_FUNCTION_LIST(DEFINE_SIMD_UINT16X8_FUNCTION)
+#undef DEFINE_SIMD_UINT16X8_FUNCTION
+
+#define DEFINE_SIMD_UINT32X4_FUNCTION(Name, Func, Operands) \
+bool \
+js::simd_uint32x4_##Name(JSContext* cx, unsigned argc, Value* vp) \
+{ \
+ return Func(cx, argc, vp); \
+}
+UINT32X4_FUNCTION_LIST(DEFINE_SIMD_UINT32X4_FUNCTION)
+#undef DEFINE_SIMD_UINT32X4_FUNCTION
+
#define DEFINE_SIMD_BOOL8X16_FUNCTION(Name, Func, Operands) \
bool \
js::simd_bool8x16_##Name(JSContext* cx, unsigned argc, Value* vp) \
{ \
return Func(cx, argc, vp); \
}
+
BOOL8X16_FUNCTION_LIST(DEFINE_SIMD_BOOL8X16_FUNCTION)
#undef DEFINE_SIMD_BOOL8X16_FUNCTION
#define DEFINE_SIMD_BOOL16X8_FUNCTION(Name, Func, Operands) \
bool \
js::simd_bool16x8_##Name(JSContext* cx, unsigned argc, Value* vp) \
{ \
return Func(cx, argc, vp); \
--- a/js/src/builtin/SIMD.h
+++ b/js/src/builtin/SIMD.h
@@ -15,16 +15,17 @@
#include "vm/GlobalObject.h"
/*
* JS SIMD functions.
* Spec matching polyfill:
* https://github.com/tc39/ecmascript_simd/blob/master/src/ecmascript_simd.js
*/
+// Bool8x16.
#define BOOL8X16_UNARY_FUNCTION_LIST(V) \
V(not, (UnaryFunc<Bool8x16, LogicalNot, Bool8x16>), 1) \
V(check, (UnaryFunc<Bool8x16, Identity, Bool8x16>), 1) \
V(splat, (FuncSplat<Bool8x16>), 1) \
V(allTrue, (AllTrue<Bool8x16>), 1) \
V(anyTrue, (AnyTrue<Bool8x16>), 1)
#define BOOL8X16_BINARY_FUNCTION_LIST(V) \
@@ -36,16 +37,17 @@
#define BOOL8X16_TERNARY_FUNCTION_LIST(V) \
V(replaceLane, (ReplaceLane<Bool8x16>), 3)
#define BOOL8X16_FUNCTION_LIST(V) \
BOOL8X16_UNARY_FUNCTION_LIST(V) \
BOOL8X16_BINARY_FUNCTION_LIST(V) \
BOOL8X16_TERNARY_FUNCTION_LIST(V)
+// Bool 16x8.
#define BOOL16X8_UNARY_FUNCTION_LIST(V) \
V(not, (UnaryFunc<Bool16x8, LogicalNot, Bool16x8>), 1) \
V(check, (UnaryFunc<Bool16x8, Identity, Bool16x8>), 1) \
V(splat, (FuncSplat<Bool16x8>), 1) \
V(allTrue, (AllTrue<Bool16x8>), 1) \
V(anyTrue, (AnyTrue<Bool16x8>), 1)
#define BOOL16X8_BINARY_FUNCTION_LIST(V) \
@@ -57,16 +59,17 @@
#define BOOL16X8_TERNARY_FUNCTION_LIST(V) \
V(replaceLane, (ReplaceLane<Bool16x8>), 3)
#define BOOL16X8_FUNCTION_LIST(V) \
BOOL16X8_UNARY_FUNCTION_LIST(V) \
BOOL16X8_BINARY_FUNCTION_LIST(V) \
BOOL16X8_TERNARY_FUNCTION_LIST(V)
+// Bool32x4.
#define BOOL32X4_UNARY_FUNCTION_LIST(V) \
V(not, (UnaryFunc<Bool32x4, LogicalNot, Bool32x4>), 1) \
V(check, (UnaryFunc<Bool32x4, Identity, Bool32x4>), 1) \
V(splat, (FuncSplat<Bool32x4>), 1) \
V(allTrue, (AllTrue<Bool32x4>), 1) \
V(anyTrue, (AnyTrue<Bool32x4>), 1)
#define BOOL32X4_BINARY_FUNCTION_LIST(V) \
@@ -78,16 +81,17 @@
#define BOOL32X4_TERNARY_FUNCTION_LIST(V) \
V(replaceLane, (ReplaceLane<Bool32x4>), 3)
#define BOOL32X4_FUNCTION_LIST(V) \
BOOL32X4_UNARY_FUNCTION_LIST(V) \
BOOL32X4_BINARY_FUNCTION_LIST(V) \
BOOL32X4_TERNARY_FUNCTION_LIST(V)
+// Bool64x2.
#define BOOL64X2_UNARY_FUNCTION_LIST(V) \
V(not, (UnaryFunc<Bool64x2, LogicalNot, Bool64x2>), 1) \
V(check, (UnaryFunc<Bool64x2, Identity, Bool64x2>), 1) \
V(splat, (FuncSplat<Bool64x2>), 1) \
V(allTrue, (AllTrue<Bool64x2>), 1) \
V(anyTrue, (AnyTrue<Bool64x2>), 1)
#define BOOL64X2_BINARY_FUNCTION_LIST(V) \
@@ -99,24 +103,29 @@
#define BOOL64X2_TERNARY_FUNCTION_LIST(V) \
V(replaceLane, (ReplaceLane<Bool64x2>), 3)
#define BOOL64X2_FUNCTION_LIST(V) \
BOOL64X2_UNARY_FUNCTION_LIST(V) \
BOOL64X2_BINARY_FUNCTION_LIST(V) \
BOOL64X2_TERNARY_FUNCTION_LIST(V)
+// Float32x4.
#define FLOAT32X4_UNARY_FUNCTION_LIST(V) \
V(abs, (UnaryFunc<Float32x4, Abs, Float32x4>), 1) \
V(check, (UnaryFunc<Float32x4, Identity, Float32x4>), 1) \
V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Float32x4>), 1) \
- V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Float32x4>), 1) \
- V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Float32x4>), 1) \
- V(fromInt32x4, (FuncConvert<Int32x4, Float32x4> ), 1) \
- V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Float32x4>), 1) \
+ V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Float32x4>), 1) \
+ V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Float32x4>), 1) \
+ V(fromInt32x4, (FuncConvert<Int32x4, Float32x4>), 1) \
+ V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Float32x4>), 1) \
+ V(fromUint8x16Bits, (FuncConvertBits<Uint8x16, Float32x4>), 1) \
+ V(fromUint16x8Bits, (FuncConvertBits<Uint16x8, Float32x4>), 1) \
+ V(fromUint32x4, (FuncConvert<Uint32x4, Float32x4>), 1) \
+ V(fromUint32x4Bits, (FuncConvertBits<Uint32x4, Float32x4>), 1) \
V(neg, (UnaryFunc<Float32x4, Neg, 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) \
@@ -152,23 +161,27 @@
V(shuffle, Shuffle<Float32x4>, 6)
#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)
+// Float64x2.
#define FLOAT64X2_UNARY_FUNCTION_LIST(V) \
V(abs, (UnaryFunc<Float64x2, Abs, Float64x2>), 1) \
V(check, (UnaryFunc<Float64x2, Identity, Float64x2>), 1) \
V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Float64x2>), 1) \
- V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Float64x2>), 1) \
- V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Float64x2>), 1) \
- V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Float64x2>), 1) \
+ V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Float64x2>), 1) \
+ V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Float64x2>), 1) \
+ V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Float64x2>), 1) \
+ V(fromUint8x16Bits, (FuncConvertBits<Uint8x16, Float64x2>), 1) \
+ V(fromUint16x8Bits, (FuncConvertBits<Uint16x8, Float64x2>), 1) \
+ V(fromUint32x4Bits, (FuncConvertBits<Uint32x4, 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) \
@@ -200,22 +213,26 @@
V(shuffle, Shuffle<Float64x2>, 4)
#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)
+// Int8x16.
#define INT8X16_UNARY_FUNCTION_LIST(V) \
V(check, (UnaryFunc<Int8x16, Identity, Int8x16>), 1) \
V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Int8x16>), 1) \
V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Int8x16>), 1) \
- V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Int8x16>), 1) \
- V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Int8x16>), 1) \
+ V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Int8x16>), 1) \
+ V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Int8x16>), 1) \
+ V(fromUint8x16Bits, (FuncConvertBits<Uint8x16, Int8x16>), 1) \
+ V(fromUint16x8Bits, (FuncConvertBits<Uint16x8, Int8x16>), 1) \
+ V(fromUint32x4Bits, (FuncConvertBits<Uint32x4, Int8x16>), 1) \
V(neg, (UnaryFunc<Int8x16, Neg, Int8x16>), 1) \
V(not, (UnaryFunc<Int8x16, Not, Int8x16>), 1) \
V(splat, (FuncSplat<Int8x16>), 1)
#define INT8X16_BINARY_FUNCTION_LIST(V) \
V(add, (BinaryFunc<Int8x16, Add, Int8x16>), 2) \
V(and, (BinaryFunc<Int8x16, And, Int8x16>), 2) \
V(equal, (CompareFunc<Int8x16, Equal, Bool8x16>), 2) \
@@ -244,22 +261,74 @@
V(shuffle, Shuffle<Int8x16>, 18)
#define INT8X16_FUNCTION_LIST(V) \
INT8X16_UNARY_FUNCTION_LIST(V) \
INT8X16_BINARY_FUNCTION_LIST(V) \
INT8X16_TERNARY_FUNCTION_LIST(V) \
INT8X16_SHUFFLE_FUNCTION_LIST(V)
+// Uint8x16.
+#define UINT8X16_UNARY_FUNCTION_LIST(V) \
+ V(check, (UnaryFunc<Uint8x16, Identity, Uint8x16>), 1) \
+ V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Uint8x16>), 1) \
+ V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Uint8x16>), 1) \
+ V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Uint8x16>), 1) \
+ V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Uint8x16>), 1) \
+ V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Uint8x16>), 1) \
+ V(fromUint16x8Bits, (FuncConvertBits<Uint16x8, Uint8x16>), 1) \
+ V(fromUint32x4Bits, (FuncConvertBits<Uint32x4, Uint8x16>), 1) \
+ V(neg, (UnaryFunc<Uint8x16, Neg, Uint8x16>), 1) \
+ V(not, (UnaryFunc<Uint8x16, Not, Uint8x16>), 1) \
+ V(splat, (FuncSplat<Uint8x16>), 1)
+
+#define UINT8X16_BINARY_FUNCTION_LIST(V) \
+ V(add, (BinaryFunc<Uint8x16, Add, Uint8x16>), 2) \
+ V(and, (BinaryFunc<Uint8x16, And, Uint8x16>), 2) \
+ V(equal, (CompareFunc<Uint8x16, Equal, Bool8x16>), 2) \
+ V(extractLane, (ExtractLane<Uint8x16>), 2) \
+ V(greaterThan, (CompareFunc<Uint8x16, GreaterThan, Bool8x16>), 2) \
+ V(greaterThanOrEqual, (CompareFunc<Uint8x16, GreaterThanOrEqual, Bool8x16>), 2) \
+ V(lessThan, (CompareFunc<Uint8x16, LessThan, Bool8x16>), 2) \
+ V(lessThanOrEqual, (CompareFunc<Uint8x16, LessThanOrEqual, Bool8x16>), 2) \
+ V(load, (Load<Uint8x16, 16>), 2) \
+ V(mul, (BinaryFunc<Uint8x16, Mul, Uint8x16>), 2) \
+ V(notEqual, (CompareFunc<Uint8x16, NotEqual, Bool8x16>), 2) \
+ V(or, (BinaryFunc<Uint8x16, Or, Uint8x16>), 2) \
+ V(sub, (BinaryFunc<Uint8x16, Sub, Uint8x16>), 2) \
+ V(shiftLeftByScalar, (BinaryScalar<Uint8x16, ShiftLeft>), 2) \
+ V(shiftRightArithmeticByScalar, (BinaryScalar<Uint8x16, ShiftRightArithmetic>), 2) \
+ V(shiftRightLogicalByScalar, (BinaryScalar<Uint8x16, ShiftRightLogical>), 2) \
+ V(xor, (BinaryFunc<Uint8x16, Xor, Uint8x16>), 2)
+
+#define UINT8X16_TERNARY_FUNCTION_LIST(V) \
+ V(replaceLane, (ReplaceLane<Uint8x16>), 3) \
+ V(select, (Select<Uint8x16, Bool8x16>), 3) \
+ V(store, (Store<Uint8x16, 16>), 3)
+
+#define UINT8X16_SHUFFLE_FUNCTION_LIST(V) \
+ V(swizzle, Swizzle<Uint8x16>, 17) \
+ V(shuffle, Shuffle<Uint8x16>, 18)
+
+#define UINT8X16_FUNCTION_LIST(V) \
+ UINT8X16_UNARY_FUNCTION_LIST(V) \
+ UINT8X16_BINARY_FUNCTION_LIST(V) \
+ UINT8X16_TERNARY_FUNCTION_LIST(V) \
+ UINT8X16_SHUFFLE_FUNCTION_LIST(V)
+
+// Int16x8.
#define INT16X8_UNARY_FUNCTION_LIST(V) \
V(check, (UnaryFunc<Int16x8, Identity, Int16x8>), 1) \
V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Int16x8>), 1) \
V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Int16x8>), 1) \
- V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Int16x8>), 1) \
- V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Int16x8>), 1) \
+ V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Int16x8>), 1) \
+ V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Int16x8>), 1) \
+ V(fromUint8x16Bits, (FuncConvertBits<Uint8x16, Int16x8>), 1) \
+ V(fromUint16x8Bits, (FuncConvertBits<Uint16x8, Int16x8>), 1) \
+ V(fromUint32x4Bits, (FuncConvertBits<Uint32x4, Int16x8>), 1) \
V(neg, (UnaryFunc<Int16x8, Neg, Int16x8>), 1) \
V(not, (UnaryFunc<Int16x8, Not, Int16x8>), 1) \
V(splat, (FuncSplat<Int16x8>), 1)
#define INT16X8_BINARY_FUNCTION_LIST(V) \
V(add, (BinaryFunc<Int16x8, Add, Int16x8>), 2) \
V(and, (BinaryFunc<Int16x8, And, Int16x8>), 2) \
V(equal, (CompareFunc<Int16x8, Equal, Bool16x8>), 2) \
@@ -288,23 +357,75 @@
V(shuffle, Shuffle<Int16x8>, 10)
#define INT16X8_FUNCTION_LIST(V) \
INT16X8_UNARY_FUNCTION_LIST(V) \
INT16X8_BINARY_FUNCTION_LIST(V) \
INT16X8_TERNARY_FUNCTION_LIST(V) \
INT16X8_SHUFFLE_FUNCTION_LIST(V)
+// Uint16x8.
+#define UINT16X8_UNARY_FUNCTION_LIST(V) \
+ V(check, (UnaryFunc<Uint16x8, Identity, Uint16x8>), 1) \
+ V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Uint16x8>), 1) \
+ V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Uint16x8>), 1) \
+ V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Uint16x8>), 1) \
+ V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Uint16x8>), 1) \
+ V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Uint16x8>), 1) \
+ V(fromUint8x16Bits, (FuncConvertBits<Uint8x16, Uint16x8>), 1) \
+ V(fromUint32x4Bits, (FuncConvertBits<Uint32x4, Uint16x8>), 1) \
+ V(neg, (UnaryFunc<Uint16x8, Neg, Uint16x8>), 1) \
+ V(not, (UnaryFunc<Uint16x8, Not, Uint16x8>), 1) \
+ V(splat, (FuncSplat<Uint16x8>), 1)
+
+#define UINT16X8_BINARY_FUNCTION_LIST(V) \
+ V(add, (BinaryFunc<Uint16x8, Add, Uint16x8>), 2) \
+ V(and, (BinaryFunc<Uint16x8, And, Uint16x8>), 2) \
+ V(equal, (CompareFunc<Uint16x8, Equal, Bool16x8>), 2) \
+ V(extractLane, (ExtractLane<Uint16x8>), 2) \
+ V(greaterThan, (CompareFunc<Uint16x8, GreaterThan, Bool16x8>), 2) \
+ V(greaterThanOrEqual, (CompareFunc<Uint16x8, GreaterThanOrEqual, Bool16x8>), 2) \
+ V(lessThan, (CompareFunc<Uint16x8, LessThan, Bool16x8>), 2) \
+ V(lessThanOrEqual, (CompareFunc<Uint16x8, LessThanOrEqual, Bool16x8>), 2) \
+ V(load, (Load<Uint16x8, 8>), 2) \
+ V(mul, (BinaryFunc<Uint16x8, Mul, Uint16x8>), 2) \
+ V(notEqual, (CompareFunc<Uint16x8, NotEqual, Bool16x8>), 2) \
+ V(or, (BinaryFunc<Uint16x8, Or, Uint16x8>), 2) \
+ V(sub, (BinaryFunc<Uint16x8, Sub, Uint16x8>), 2) \
+ V(shiftLeftByScalar, (BinaryScalar<Uint16x8, ShiftLeft>), 2) \
+ V(shiftRightArithmeticByScalar, (BinaryScalar<Uint16x8, ShiftRightArithmetic>), 2) \
+ V(shiftRightLogicalByScalar, (BinaryScalar<Uint16x8, ShiftRightLogical>), 2) \
+ V(xor, (BinaryFunc<Uint16x8, Xor, Uint16x8>), 2)
+
+#define UINT16X8_TERNARY_FUNCTION_LIST(V) \
+ V(replaceLane, (ReplaceLane<Uint16x8>), 3) \
+ V(select, (Select<Uint16x8, Bool16x8>), 3) \
+ V(store, (Store<Uint16x8, 8>), 3)
+
+#define UINT16X8_SHUFFLE_FUNCTION_LIST(V) \
+ V(swizzle, Swizzle<Uint16x8>, 9) \
+ V(shuffle, Shuffle<Uint16x8>, 10)
+
+#define UINT16X8_FUNCTION_LIST(V) \
+ UINT16X8_UNARY_FUNCTION_LIST(V) \
+ UINT16X8_BINARY_FUNCTION_LIST(V) \
+ UINT16X8_TERNARY_FUNCTION_LIST(V) \
+ UINT16X8_SHUFFLE_FUNCTION_LIST(V)
+
+// Int32x4.
#define INT32X4_UNARY_FUNCTION_LIST(V) \
V(check, (UnaryFunc<Int32x4, Identity, Int32x4>), 1) \
- V(fromFloat32x4, (FuncConvert<Float32x4, Int32x4>), 1) \
+ V(fromFloat32x4, (FuncConvert<Float32x4, Int32x4>), 1) \
V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Int32x4>), 1) \
V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Int32x4>), 1) \
- V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Int32x4>), 1) \
- V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Int32x4>), 1) \
+ V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Int32x4>), 1) \
+ V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Int32x4>), 1) \
+ V(fromUint8x16Bits, (FuncConvertBits<Uint8x16, Int32x4>), 1) \
+ V(fromUint16x8Bits, (FuncConvertBits<Uint16x8, Int32x4>), 1) \
+ V(fromUint32x4Bits, (FuncConvertBits<Uint32x4, 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) \
V(and, (BinaryFunc<Int32x4, And, Int32x4>), 2) \
V(equal, (CompareFunc<Int32x4, Equal, Bool32x4>), 2) \
@@ -339,16 +460,71 @@
V(shuffle, Shuffle<Int32x4>, 6)
#define INT32X4_FUNCTION_LIST(V) \
INT32X4_UNARY_FUNCTION_LIST(V) \
INT32X4_BINARY_FUNCTION_LIST(V) \
INT32X4_TERNARY_FUNCTION_LIST(V) \
INT32X4_SHUFFLE_FUNCTION_LIST(V)
+// Uint32x4.
+#define UINT32X4_UNARY_FUNCTION_LIST(V) \
+ V(check, (UnaryFunc<Uint32x4, Identity, Uint32x4>), 1) \
+ V(fromFloat32x4, (FuncConvert<Float32x4, Uint32x4>), 1) \
+ V(fromFloat32x4Bits, (FuncConvertBits<Float32x4, Uint32x4>), 1) \
+ V(fromFloat64x2Bits, (FuncConvertBits<Float64x2, Uint32x4>), 1) \
+ V(fromInt8x16Bits, (FuncConvertBits<Int8x16, Uint32x4>), 1) \
+ V(fromInt16x8Bits, (FuncConvertBits<Int16x8, Uint32x4>), 1) \
+ V(fromInt32x4Bits, (FuncConvertBits<Int32x4, Uint32x4>), 1) \
+ V(fromUint8x16Bits, (FuncConvertBits<Uint8x16, Uint32x4>), 1) \
+ V(fromUint16x8Bits, (FuncConvertBits<Uint16x8, Uint32x4>), 1) \
+ V(neg, (UnaryFunc<Uint32x4, Neg, Uint32x4>), 1) \
+ V(not, (UnaryFunc<Uint32x4, Not, Uint32x4>), 1) \
+ V(splat, (FuncSplat<Uint32x4>), 0)
+
+#define UINT32X4_BINARY_FUNCTION_LIST(V) \
+ V(add, (BinaryFunc<Uint32x4, Add, Uint32x4>), 2) \
+ V(and, (BinaryFunc<Uint32x4, And, Uint32x4>), 2) \
+ V(equal, (CompareFunc<Uint32x4, Equal, Bool32x4>), 2) \
+ V(extractLane, (ExtractLane<Uint32x4>), 2) \
+ V(greaterThan, (CompareFunc<Uint32x4, GreaterThan, Bool32x4>), 2) \
+ V(greaterThanOrEqual, (CompareFunc<Uint32x4, GreaterThanOrEqual, Bool32x4>), 2) \
+ V(lessThan, (CompareFunc<Uint32x4, LessThan, Bool32x4>), 2) \
+ V(lessThanOrEqual, (CompareFunc<Uint32x4, LessThanOrEqual, Bool32x4>), 2) \
+ V(load, (Load<Uint32x4, 4>), 2) \
+ V(load3, (Load<Uint32x4, 3>), 2) \
+ V(load2, (Load<Uint32x4, 2>), 2) \
+ V(load1, (Load<Uint32x4, 1>), 2) \
+ V(mul, (BinaryFunc<Uint32x4, Mul, Uint32x4>), 2) \
+ V(notEqual, (CompareFunc<Uint32x4, NotEqual, Bool32x4>), 2) \
+ V(or, (BinaryFunc<Uint32x4, Or, Uint32x4>), 2) \
+ V(sub, (BinaryFunc<Uint32x4, Sub, Uint32x4>), 2) \
+ V(shiftLeftByScalar, (BinaryScalar<Uint32x4, ShiftLeft>), 2) \
+ V(shiftRightArithmeticByScalar, (BinaryScalar<Uint32x4, ShiftRightArithmetic>), 2) \
+ V(shiftRightLogicalByScalar, (BinaryScalar<Uint32x4, ShiftRightLogical>), 2) \
+ V(xor, (BinaryFunc<Uint32x4, Xor, Uint32x4>), 2)
+
+#define UINT32X4_TERNARY_FUNCTION_LIST(V) \
+ V(replaceLane, (ReplaceLane<Uint32x4>), 3) \
+ V(select, (Select<Uint32x4, Bool32x4>), 3) \
+ V(store, (Store<Uint32x4, 4>), 3) \
+ V(store3, (Store<Uint32x4, 3>), 3) \
+ V(store2, (Store<Uint32x4, 2>), 3) \
+ V(store1, (Store<Uint32x4, 1>), 3)
+
+#define UINT32X4_SHUFFLE_FUNCTION_LIST(V) \
+ V(swizzle, Swizzle<Uint32x4>, 5) \
+ V(shuffle, Shuffle<Uint32x4>, 6)
+
+#define UINT32X4_FUNCTION_LIST(V) \
+ UINT32X4_UNARY_FUNCTION_LIST(V) \
+ UINT32X4_BINARY_FUNCTION_LIST(V) \
+ UINT32X4_TERNARY_FUNCTION_LIST(V) \
+ UINT32X4_SHUFFLE_FUNCTION_LIST(V)
+
/*
* The FOREACH macros below partition all of the SIMD operations into disjoint
* sets.
*/
// Operations available on all SIMD types. Mixed arity.
#define FOREACH_COMMON_SIMD_OP(_) \
_(extractLane) \
@@ -643,41 +819,77 @@ struct Float64x2 {
struct Int8x16 {
typedef int8_t Elem;
static const unsigned lanes = 16;
static const SimdTypeDescr::Type type = SimdTypeDescr::Int8x16;
static bool Cast(JSContext* cx, JS::HandleValue v, Elem* out) {
return ToInt8(cx, v, out);
}
static Value ToValue(Elem value) {
- return Int32Value(value);
+ return NumberValue(value);
}
};
struct Int16x8 {
typedef int16_t Elem;
static const unsigned lanes = 8;
static const SimdTypeDescr::Type type = SimdTypeDescr::Int16x8;
static bool Cast(JSContext* cx, JS::HandleValue v, Elem* out) {
return ToInt16(cx, v, out);
}
static Value ToValue(Elem value) {
- return Int32Value(value);
+ return NumberValue(value);
}
};
struct Int32x4 {
typedef int32_t Elem;
static const unsigned lanes = 4;
static const SimdTypeDescr::Type type = SimdTypeDescr::Int32x4;
static bool Cast(JSContext* cx, JS::HandleValue v, Elem* out) {
return ToInt32(cx, v, out);
}
static Value ToValue(Elem value) {
- return Int32Value(value);
+ return NumberValue(value);
+ }
+};
+
+struct Uint8x16 {
+ typedef uint8_t Elem;
+ static const unsigned lanes = 16;
+ static const SimdTypeDescr::Type type = SimdTypeDescr::Uint8x16;
+ static bool Cast(JSContext* cx, JS::HandleValue v, Elem* out) {
+ return ToUint8(cx, v, out);
+ }
+ static Value ToValue(Elem value) {
+ return NumberValue(value);
+ }
+};
+
+struct Uint16x8 {
+ typedef uint16_t Elem;
+ static const unsigned lanes = 8;
+ static const SimdTypeDescr::Type type = SimdTypeDescr::Uint16x8;
+ static bool Cast(JSContext* cx, JS::HandleValue v, Elem* out) {
+ return ToUint16(cx, v, out);
+ }
+ static Value ToValue(Elem value) {
+ return NumberValue(value);
+ }
+};
+
+struct Uint32x4 {
+ typedef uint32_t Elem;
+ static const unsigned lanes = 4;
+ static const SimdTypeDescr::Type type = SimdTypeDescr::Uint32x4;
+ static bool Cast(JSContext* cx, JS::HandleValue v, Elem* out) {
+ return ToUint32(cx, v, out);
+ }
+ static Value ToValue(Elem value) {
+ return NumberValue(value);
}
};
struct Bool8x16 {
typedef int8_t Elem;
static const unsigned lanes = 16;
static const SimdTypeDescr::Type type = SimdTypeDescr::Bool8x16;
static bool Cast(JSContext* cx, JS::HandleValue v, Elem* out) {
@@ -762,16 +974,34 @@ INT16X8_FUNCTION_LIST(DECLARE_SIMD_INT16
#undef DECLARE_SIMD_INT16X8_FUNCTION
#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
+#define DECLARE_SIMD_UINT8X16_FUNCTION(Name, Func, Operands) \
+extern bool \
+simd_uint8x16_##Name(JSContext* cx, unsigned argc, Value* vp);
+UINT8X16_FUNCTION_LIST(DECLARE_SIMD_UINT8X16_FUNCTION)
+#undef DECLARE_SIMD_UINT8X16_FUNCTION
+
+#define DECLARE_SIMD_UINT16X8_FUNCTION(Name, Func, Operands) \
+extern bool \
+simd_uint16x8_##Name(JSContext* cx, unsigned argc, Value* vp);
+UINT16X8_FUNCTION_LIST(DECLARE_SIMD_UINT16X8_FUNCTION)
+#undef DECLARE_SIMD_UINT16X8_FUNCTION
+
+#define DECLARE_SIMD_UINT32x4_FUNCTION(Name, Func, Operands) \
+extern bool \
+simd_uint32x4_##Name(JSContext* cx, unsigned argc, Value* vp);
+UINT32X4_FUNCTION_LIST(DECLARE_SIMD_UINT32x4_FUNCTION)
+#undef DECLARE_SIMD_UINT32x4_FUNCTION
+
#define DECLARE_SIMD_BOOL8X16_FUNCTION(Name, Func, Operands) \
extern bool \
simd_bool8x16_##Name(JSContext* cx, unsigned argc, Value* vp);
BOOL8X16_FUNCTION_LIST(DECLARE_SIMD_BOOL8X16_FUNCTION)
#undef DECLARE_SIMD_BOOL8X16_FUNCTION
#define DECLARE_SIMD_BOOL16X8_FUNCTION(Name, Func, Operands) \
extern bool \
--- a/js/src/builtin/TypedObject.cpp
+++ b/js/src/builtin/TypedObject.cpp
@@ -415,16 +415,19 @@ js::ReferenceTypeDescr::call(JSContext*
int32_t
SimdTypeDescr::size(Type t)
{
MOZ_ASSERT(unsigned(t) <= SimdTypeDescr::Type::LAST_TYPE);
switch (t) {
case SimdTypeDescr::Int8x16:
case SimdTypeDescr::Int16x8:
case SimdTypeDescr::Int32x4:
+ case SimdTypeDescr::Uint8x16:
+ case SimdTypeDescr::Uint16x8:
+ case SimdTypeDescr::Uint32x4:
case SimdTypeDescr::Float32x4:
case SimdTypeDescr::Float64x2:
case SimdTypeDescr::Bool8x16:
case SimdTypeDescr::Bool16x8:
case SimdTypeDescr::Bool32x4:
case SimdTypeDescr::Bool64x2:
return 16;
}
@@ -2632,16 +2635,46 @@ js::GetInt32x4TypeDescr(JSContext* cx, u
CallArgs args = CallArgsFromVp(argc, vp);
Rooted<GlobalObject*> global(cx, cx->global());
MOZ_ASSERT(global);
args.rval().setObject(*global->getOrCreateSimdTypeDescr<Int32x4>(cx));
return true;
}
bool
+js::GetUint8x16TypeDescr(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ Rooted<GlobalObject*> global(cx, cx->global());
+ MOZ_ASSERT(global);
+ args.rval().setObject(*global->getOrCreateSimdTypeDescr<Uint8x16>(cx));
+ return true;
+}
+
+bool
+js::GetUint16x8TypeDescr(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ Rooted<GlobalObject*> global(cx, cx->global());
+ MOZ_ASSERT(global);
+ args.rval().setObject(*global->getOrCreateSimdTypeDescr<Uint16x8>(cx));
+ return true;
+}
+
+bool
+js::GetUint32x4TypeDescr(JSContext* cx, unsigned argc, Value* vp)
+{
+ CallArgs args = CallArgsFromVp(argc, vp);
+ Rooted<GlobalObject*> global(cx, cx->global());
+ MOZ_ASSERT(global);
+ args.rval().setObject(*global->getOrCreateSimdTypeDescr<Uint32x4>(cx));
+ return true;
+}
+
+bool
js::GetBool8x16TypeDescr(JSContext* cx, unsigned argc, Value* vp)
{
CallArgs args = CallArgsFromVp(argc, vp);
Rooted<GlobalObject*> global(cx, cx->global());
MOZ_ASSERT(global);
args.rval().setObject(*global->getOrCreateSimdTypeDescr<Bool8x16>(cx));
return true;
}
--- a/js/src/builtin/TypedObject.h
+++ b/js/src/builtin/TypedObject.h
@@ -332,16 +332,19 @@ class ComplexTypeDescr : public TypeDesc
*/
class SimdTypeDescr : public ComplexTypeDescr
{
public:
enum Type {
Int8x16 = JS_SIMDTYPEREPR_INT8X16,
Int16x8 = JS_SIMDTYPEREPR_INT16X8,
Int32x4 = JS_SIMDTYPEREPR_INT32X4,
+ Uint8x16 = JS_SIMDTYPEREPR_UINT8X16,
+ Uint16x8 = JS_SIMDTYPEREPR_UINT16X8,
+ Uint32x4 = JS_SIMDTYPEREPR_UINT32X4,
Float32x4 = JS_SIMDTYPEREPR_FLOAT32X4,
Float64x2 = JS_SIMDTYPEREPR_FLOAT64X2,
Bool8x16 = JS_SIMDTYPEREPR_BOOL8X16,
Bool16x8 = JS_SIMDTYPEREPR_BOOL16X8,
Bool32x4 = JS_SIMDTYPEREPR_BOOL32X4,
Bool64x2 = JS_SIMDTYPEREPR_BOOL64X2,
LAST_TYPE = Bool64x2
};
@@ -830,86 +833,110 @@ bool ClampToUint8(JSContext* cx, unsigne
* to access them; eventually this should be linked into the module
* system.
*/
bool GetTypedObjectModule(JSContext* cx, unsigned argc, Value* vp);
/*
* Usage: GetFloat32x4TypeDescr()
*
- * Returns the float32x4 type object. SIMD pseudo-module must have
+ * Returns the Float32x4 type object. SIMD pseudo-module must have
* been initialized for this to be safe.
*/
bool GetFloat32x4TypeDescr(JSContext* cx, unsigned argc, Value* vp);
/*
* Usage: GetFloat64x2TypeDescr()
*
- * Returns the float64x2 type object. SIMD pseudo-module must have
+ * Returns the Float64x2 type object. SIMD pseudo-module must have
* been initialized for this to be safe.
*/
bool GetFloat64x2TypeDescr(JSContext* cx, unsigned argc, Value* vp);
/*
* Usage: GetBool8x16TypeDescr()
*
- * Returns the bool8x16 type object. SIMD pseudo-module must have
+ * Returns the Bool8x16 type object. SIMD pseudo-module must have
* been initialized for this to be safe.
*/
bool GetBool8x16TypeDescr(JSContext* cx, unsigned argc, Value* vp);
/*
* Usage: GetBool16x8TypeDescr()
*
- * Returns the bool16x8 type object. SIMD pseudo-module must have
+ * Returns the Bool16x8 type object. SIMD pseudo-module must have
* been initialized for this to be safe.
*/
bool GetBool16x8TypeDescr(JSContext* cx, unsigned argc, Value* vp);
/*
* Usage: GetBool32x4TypeDescr()
*
- * Returns the bool32x4 type object. SIMD pseudo-module must have
+ * Returns the Bool32x4 type object. SIMD pseudo-module must have
* been initialized for this to be safe.
*/
bool GetBool32x4TypeDescr(JSContext* cx, unsigned argc, Value* vp);
/*
* Usage: GetBool64x2TypeDescr()
*
- * Returns the bool64x2 type object. SIMD pseudo-module must have
+ * Returns the Bool64x2 type object. SIMD pseudo-module must have
* been initialized for this to be safe.
*/
bool GetBool64x2TypeDescr(JSContext* cx, unsigned argc, Value* vp);
/*
* Usage: GetInt8x16TypeDescr()
*
- * Returns the int8x16 type object. SIMD pseudo-module must have
+ * Returns the Int8x16 type object. SIMD pseudo-module must have
* been initialized for this to be safe.
*/
bool GetInt8x16TypeDescr(JSContext* cx, unsigned argc, Value* vp);
/*
* Usage: GetInt16x8TypeDescr()
*
- * Returns the int16x8 type object. SIMD pseudo-module must have
+ * Returns the Int16x8 type object. SIMD pseudo-module must have
* been initialized for this to be safe.
*/
bool GetInt16x8TypeDescr(JSContext* cx, unsigned argc, Value* vp);
/*
* Usage: GetInt32x4TypeDescr()
*
- * Returns the int32x4 type object. SIMD pseudo-module must have
+ * Returns the Int32x4 type object. SIMD pseudo-module must have
* been initialized for this to be safe.
*/
bool GetInt32x4TypeDescr(JSContext* cx, unsigned argc, Value* vp);
/*
+ * Usage: GetUint8x16TypeDescr()
+ *
+ * Returns the Uint8x16 type object. SIMD pseudo-module must have
+ * been initialized for this to be safe.
+ */
+bool GetUint8x16TypeDescr(JSContext* cx, unsigned argc, Value* vp);
+
+/*
+ * Usage: GetUint16x8TypeDescr()
+ *
+ * Returns the Uint16x8 type object. SIMD pseudo-module must have
+ * been initialized for this to be safe.
+ */
+bool GetUint16x8TypeDescr(JSContext* cx, unsigned argc, Value* vp);
+
+/*
+ * Usage: GetUint32x4TypeDescr()
+ *
+ * Returns the Uint32x4 type object. SIMD pseudo-module must have
+ * been initialized for this to be safe.
+ */
+bool GetUint32x4TypeDescr(JSContext* cx, unsigned argc, Value* vp);
+
+/*
* Usage: Store_int8(targetDatum, targetOffset, value)
* ...
* Store_uint8(targetDatum, targetOffset, value)
* ...
* Store_float32(targetDatum, targetOffset, value)
* Store_float64(targetDatum, targetOffset, value)
*
* Intrinsic function. Stores `value` into the memory referenced by
--- a/js/src/builtin/TypedObject.js
+++ b/js/src/builtin/TypedObject.js
@@ -190,16 +190,54 @@ function TypedObjectGetSimd(descr, typed
case JS_SIMDTYPEREPR_INT32X4:
var x = Load_int32(typedObj, offset + 0);
var y = Load_int32(typedObj, offset + 4);
var z = Load_int32(typedObj, offset + 8);
var w = Load_int32(typedObj, offset + 12);
return GetInt32x4TypeDescr()(x, y, z, w);
+ case JS_SIMDTYPEREPR_UINT8X16:
+ var s0 = Load_uint8(typedObj, offset + 0);
+ var s1 = Load_uint8(typedObj, offset + 1);
+ var s2 = Load_uint8(typedObj, offset + 2);
+ var s3 = Load_uint8(typedObj, offset + 3);
+ var s4 = Load_uint8(typedObj, offset + 4);
+ var s5 = Load_uint8(typedObj, offset + 5);
+ var s6 = Load_uint8(typedObj, offset + 6);
+ var s7 = Load_uint8(typedObj, offset + 7);
+ var s8 = Load_uint8(typedObj, offset + 8);
+ var s9 = Load_uint8(typedObj, offset + 9);
+ var s10 = Load_uint8(typedObj, offset + 10);
+ var s11 = Load_uint8(typedObj, offset + 11);
+ var s12 = Load_uint8(typedObj, offset + 12);
+ var s13 = Load_uint8(typedObj, offset + 13);
+ var s14 = Load_uint8(typedObj, offset + 14);
+ var s15 = Load_uint8(typedObj, offset + 15);
+ return GetUint8x16TypeDescr()(s0, s1, s2, s3, s4, s5, s6, s7,
+ s8, s9, s10, s11, s12, s13, s14, s15);
+
+ case JS_SIMDTYPEREPR_UINT16X8:
+ var s0 = Load_uint16(typedObj, offset + 0);
+ var s1 = Load_uint16(typedObj, offset + 2);
+ var s2 = Load_uint16(typedObj, offset + 4);
+ var s3 = Load_uint16(typedObj, offset + 6);
+ var s4 = Load_uint16(typedObj, offset + 8);
+ var s5 = Load_uint16(typedObj, offset + 10);
+ var s6 = Load_uint16(typedObj, offset + 12);
+ var s7 = Load_uint16(typedObj, offset + 14);
+ return GetUint16x8TypeDescr()(s0, s1, s2, s3, s4, s5, s6, s7);
+
+ case JS_SIMDTYPEREPR_UINT32X4:
+ var x = Load_uint32(typedObj, offset + 0);
+ var y = Load_uint32(typedObj, offset + 4);
+ var z = Load_uint32(typedObj, offset + 8);
+ var w = Load_uint32(typedObj, offset + 12);
+ return GetUint32x4TypeDescr()(x, y, z, w);
+
case JS_SIMDTYPEREPR_BOOL8X16:
var s0 = Load_int8(typedObj, offset + 0);
var s1 = Load_int8(typedObj, offset + 1);
var s2 = Load_int8(typedObj, offset + 2);
var s3 = Load_int8(typedObj, offset + 3);
var s4 = Load_int8(typedObj, offset + 4);
var s5 = Load_int8(typedObj, offset + 5);
var s6 = Load_int8(typedObj, offset + 6);
@@ -439,16 +477,50 @@ function TypedObjectSetSimd(descr, typed
case JS_SIMDTYPEREPR_INT32X4:
case JS_SIMDTYPEREPR_BOOL32X4:
case JS_SIMDTYPEREPR_BOOL64X2:
Store_int32(typedObj, offset + 0, Load_int32(fromValue, 0));
Store_int32(typedObj, offset + 4, Load_int32(fromValue, 4));
Store_int32(typedObj, offset + 8, Load_int32(fromValue, 8));
Store_int32(typedObj, offset + 12, Load_int32(fromValue, 12));
break;
+ case JS_SIMDTYPEREPR_UINT8X16:
+ Store_uint8(typedObj, offset + 0, Load_uint8(fromValue, 0));
+ Store_uint8(typedObj, offset + 1, Load_uint8(fromValue, 1));
+ Store_uint8(typedObj, offset + 2, Load_uint8(fromValue, 2));
+ Store_uint8(typedObj, offset + 3, Load_uint8(fromValue, 3));
+ Store_uint8(typedObj, offset + 4, Load_uint8(fromValue, 4));
+ Store_uint8(typedObj, offset + 5, Load_uint8(fromValue, 5));
+ Store_uint8(typedObj, offset + 6, Load_uint8(fromValue, 6));
+ Store_uint8(typedObj, offset + 7, Load_uint8(fromValue, 7));
+ Store_uint8(typedObj, offset + 8, Load_uint8(fromValue, 8));
+ Store_uint8(typedObj, offset + 9, Load_uint8(fromValue, 9));
+ Store_uint8(typedObj, offset + 10, Load_uint8(fromValue, 10));
+ Store_uint8(typedObj, offset + 11, Load_uint8(fromValue, 11));
+ Store_uint8(typedObj, offset + 12, Load_uint8(fromValue, 12));
+ Store_uint8(typedObj, offset + 13, Load_uint8(fromValue, 13));
+ Store_uint8(typedObj, offset + 14, Load_uint8(fromValue, 14));
+ Store_uint8(typedObj, offset + 15, Load_uint8(fromValue, 15));
+ break;
+ case JS_SIMDTYPEREPR_UINT16X8:
+ Store_uint16(typedObj, offset + 0, Load_uint16(fromValue, 0));
+ Store_uint16(typedObj, offset + 2, Load_uint16(fromValue, 2));
+ Store_uint16(typedObj, offset + 4, Load_uint16(fromValue, 4));
+ Store_uint16(typedObj, offset + 6, Load_uint16(fromValue, 6));
+ Store_uint16(typedObj, offset + 8, Load_uint16(fromValue, 8));
+ Store_uint16(typedObj, offset + 10, Load_uint16(fromValue, 10));
+ Store_uint16(typedObj, offset + 12, Load_uint16(fromValue, 12));
+ Store_uint16(typedObj, offset + 14, Load_uint16(fromValue, 14));
+ break;
+ case JS_SIMDTYPEREPR_UINT32X4:
+ Store_uint32(typedObj, offset + 0, Load_uint32(fromValue, 0));
+ Store_uint32(typedObj, offset + 4, Load_uint32(fromValue, 4));
+ Store_uint32(typedObj, offset + 8, Load_uint32(fromValue, 8));
+ Store_uint32(typedObj, offset + 12, Load_uint32(fromValue, 12));
+ break;
default:
assert(false, "Unhandled Simd type: " + type);
}
}
///////////////////////////////////////////////////////////////////////////
// C++ Wrappers
//
@@ -570,16 +642,22 @@ function TypedObjectArrayRedimension(new
function SimdProtoString(type) {
switch (type) {
case JS_SIMDTYPEREPR_INT8X16:
return "Int8x16";
case JS_SIMDTYPEREPR_INT16X8:
return "Int16x8";
case JS_SIMDTYPEREPR_INT32X4:
return "Int32x4";
+ case JS_SIMDTYPEREPR_UINT8X16:
+ return "Uint8x16";
+ case JS_SIMDTYPEREPR_UINT16X8:
+ return "Uint16x8";
+ case JS_SIMDTYPEREPR_UINT32X4:
+ return "Uint32x4";
case JS_SIMDTYPEREPR_FLOAT32X4:
return "Float32x4";
case JS_SIMDTYPEREPR_FLOAT64X2:
return "Float64x2";
case JS_SIMDTYPEREPR_BOOL8X16:
return "Bool8x16";
case JS_SIMDTYPEREPR_BOOL16X8:
return "Bool16x8";
@@ -629,24 +707,24 @@ function SimdToSource() {
var s1 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 0);
var s2 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 1);
var s3 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 2);
var s4 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 3);
var s5 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 4);
var s6 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 5);
var s7 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 6);
var s8 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 7);
- var s9 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 0);
- var s10 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 1);
- var s11 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 2);
- var s12 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 3);
- var s13 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 4);
- var s14 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 5);
- var s15 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 6);
- var s16 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 7);
+ var s9 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 8);
+ var s10 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 9);
+ var s11 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 10);
+ var s12 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 11);
+ var s13 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 12);
+ var s14 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 13);
+ var s15 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 14);
+ var s16 = callFunction(std_SIMD_Int8x16_extractLane, null, this, 15);
return `SIMD.${protoString}(${s1}, ${s2}, ${s3}, ${s4}, ${s5}, ${s6}, ${s7}, ${s8}, ${s9}, ${s10}, ${s11}, ${s12}, ${s13}, ${s14}, ${s15}, ${s16})`;
}
case JS_SIMDTYPEREPR_INT16X8: {
var s1 = callFunction(std_SIMD_Int16x8_extractLane, null, this, 0);
var s2 = callFunction(std_SIMD_Int16x8_extractLane, null, this, 1);
var s3 = callFunction(std_SIMD_Int16x8_extractLane, null, this, 2);
var s4 = callFunction(std_SIMD_Int16x8_extractLane, null, this, 3);
var s5 = callFunction(std_SIMD_Int16x8_extractLane, null, this, 4);
@@ -657,16 +735,53 @@ function SimdToSource() {
}
case JS_SIMDTYPEREPR_INT32X4: {
var x = callFunction(std_SIMD_Int32x4_extractLane, null, this, 0);
var y = callFunction(std_SIMD_Int32x4_extractLane, null, this, 1);
var z = callFunction(std_SIMD_Int32x4_extractLane, null, this, 2);
var w = callFunction(std_SIMD_Int32x4_extractLane, null, this, 3);
return `SIMD.${protoString}(${x}, ${y}, ${z}, ${w})`;
}
+ case JS_SIMDTYPEREPR_UINT8X16: {
+ var s1 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 0);
+ var s2 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 1);
+ var s3 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 2);
+ var s4 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 3);
+ var s5 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 4);
+ var s6 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 5);
+ var s7 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 6);
+ var s8 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 7);
+ var s9 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 8);
+ var s10 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 9);
+ var s11 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 10);
+ var s12 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 11);
+ var s13 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 12);
+ var s14 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 13);
+ var s15 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 14);
+ var s16 = callFunction(std_SIMD_Uint8x16_extractLane, null, this, 15);
+ return `SIMD.${protoString}(${s1}, ${s2}, ${s3}, ${s4}, ${s5}, ${s6}, ${s7}, ${s8}, ${s9}, ${s10}, ${s11}, ${s12}, ${s13}, ${s14}, ${s15}, ${s16})`;
+ }
+ case JS_SIMDTYPEREPR_UINT16X8: {
+ var s1 = callFunction(std_SIMD_Uint16x8_extractLane, null, this, 0);
+ var s2 = callFunction(std_SIMD_Uint16x8_extractLane, null, this, 1);
+ var s3 = callFunction(std_SIMD_Uint16x8_extractLane, null, this, 2);
+ var s4 = callFunction(std_SIMD_Uint16x8_extractLane, null, this, 3);
+ var s5 = callFunction(std_SIMD_Uint16x8_extractLane, null, this, 4);
+ var s6 = callFunction(std_SIMD_Uint16x8_extractLane, null, this, 5);
+ var s7 = callFunction(std_SIMD_Uint16x8_extractLane, null, this, 6);
+ var s8 = callFunction(std_SIMD_Uint16x8_extractLane, null, this, 7);
+ return `SIMD.${protoString}(${s1}, ${s2}, ${s3}, ${s4}, ${s5}, ${s6}, ${s7}, ${s8})`;
+ }
+ case JS_SIMDTYPEREPR_UINT32X4: {
+ var x = callFunction(std_SIMD_Uint32x4_extractLane, null, this, 0);
+ var y = callFunction(std_SIMD_Uint32x4_extractLane, null, this, 1);
+ var z = callFunction(std_SIMD_Uint32x4_extractLane, null, this, 2);
+ var w = callFunction(std_SIMD_Uint32x4_extractLane, null, this, 3);
+ return `SIMD.${protoString}(${x}, ${y}, ${z}, ${w})`;
+ }
case JS_SIMDTYPEREPR_FLOAT32X4: {
var x = callFunction(std_SIMD_Float32x4_extractLane, null, this, 0);
var y = callFunction(std_SIMD_Float32x4_extractLane, null, this, 1);
var z = callFunction(std_SIMD_Float32x4_extractLane, null, this, 2);
var w = callFunction(std_SIMD_Float32x4_extractLane, null, this, 3);
return `SIMD.${protoString}(${x}, ${y}, ${z}, ${w})`;
}
case JS_SIMDTYPEREPR_FLOAT64X2: {
--- a/js/src/builtin/TypedObjectConstants.h
+++ b/js/src/builtin/TypedObjectConstants.h
@@ -101,16 +101,19 @@
#define JS_REFERENCETYPEREPR_STRING 2
// These constants are for use exclusively in JS code. In C++ code, prefer
// SimdTypeDescr::Int32x4 etc, since that allows you to write a switch which
// will receive a warning if you omit a case.
#define JS_SIMDTYPEREPR_INT8X16 0
#define JS_SIMDTYPEREPR_INT16X8 1
#define JS_SIMDTYPEREPR_INT32X4 2
-#define JS_SIMDTYPEREPR_FLOAT32X4 3
-#define JS_SIMDTYPEREPR_FLOAT64X2 4
-#define JS_SIMDTYPEREPR_BOOL8X16 5
-#define JS_SIMDTYPEREPR_BOOL16X8 6
-#define JS_SIMDTYPEREPR_BOOL32X4 7
-#define JS_SIMDTYPEREPR_BOOL64X2 8
+#define JS_SIMDTYPEREPR_UINT8X16 3
+#define JS_SIMDTYPEREPR_UINT16X8 4
+#define JS_SIMDTYPEREPR_UINT32X4 5
+#define JS_SIMDTYPEREPR_FLOAT32X4 6
+#define JS_SIMDTYPEREPR_FLOAT64X2 7
+#define JS_SIMDTYPEREPR_BOOL8X16 8
+#define JS_SIMDTYPEREPR_BOOL16X8 9
+#define JS_SIMDTYPEREPR_BOOL32X4 10
+#define JS_SIMDTYPEREPR_BOOL64X2 11
#endif
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -11242,16 +11242,19 @@ MIRType
IonBuilder::SimdTypeDescrToMIRType(SimdTypeDescr::Type type)
{
switch (type) {
case SimdTypeDescr::Int32x4: return MIRType_Int32x4;
case SimdTypeDescr::Float32x4: return MIRType_Float32x4;
case SimdTypeDescr::Bool32x4: return MIRType_Bool32x4;
case SimdTypeDescr::Int8x16:
case SimdTypeDescr::Int16x8:
+ case SimdTypeDescr::Uint8x16:
+ case SimdTypeDescr::Uint16x8:
+ case SimdTypeDescr::Uint32x4:
case SimdTypeDescr::Float64x2:
case SimdTypeDescr::Bool8x16:
case SimdTypeDescr::Bool16x8:
case SimdTypeDescr::Bool64x2: return MIRType_Undefined;
}
MOZ_CRASH("unimplemented MIR type for a SimdTypeDescr::Type");
}
--- a/js/src/jit/MCallOptimize.cpp
+++ b/js/src/jit/MCallOptimize.cpp
@@ -3587,16 +3587,19 @@ SimdTypeToArrayElementType(SimdTypeDescr
// Bool vectors don't have load/store operations.
case SimdTypeDescr::Bool8x16:
case SimdTypeDescr::Bool16x8:
case SimdTypeDescr::Bool32x4:
case SimdTypeDescr::Bool64x2: break;
// Not yet implemented.
case SimdTypeDescr::Int8x16:
case SimdTypeDescr::Int16x8:
+ case SimdTypeDescr::Uint8x16:
+ case SimdTypeDescr::Uint16x8:
+ case SimdTypeDescr::Uint32x4:
case SimdTypeDescr::Float64x2: break;
}
MOZ_CRASH("unexpected simd type");
}
bool
IonBuilder::prepareForSimdLoadStore(CallInfo& callInfo, Scalar::Type simdType, MInstruction** elements,
MDefinition** index, Scalar::Type* arrayType)
--- a/js/src/jit/Recover.cpp
+++ b/js/src/jit/Recover.cpp
@@ -1358,16 +1358,25 @@ RSimdBox::recover(JSContext* cx, Snapsho
MOZ_CRASH("NYI, RSimdBox of Float64x2");
break;
case SimdTypeDescr::Int8x16:
MOZ_CRASH("NYI, RSimdBox of Int8x16");
break;
case SimdTypeDescr::Int16x8:
MOZ_CRASH("NYI, RSimdBox of Int16x8");
break;
+ case SimdTypeDescr::Uint8x16:
+ MOZ_CRASH("NYI, RSimdBox of UInt8x16");
+ break;
+ case SimdTypeDescr::Uint16x8:
+ MOZ_CRASH("NYI, RSimdBox of UInt16x8");
+ break;
+ case SimdTypeDescr::Uint32x4:
+ MOZ_CRASH("NYI, RSimdBox of UInt32x4");
+ break;
case SimdTypeDescr::Bool8x16:
MOZ_CRASH("NYI, RSimdBox of Bool8x16");
break;
case SimdTypeDescr::Bool16x8:
MOZ_CRASH("NYI, RSimdBox of Bool16x8");
break;
case SimdTypeDescr::Bool64x2:
MOZ_CRASH("NYI, RSimdBox of Bool64x2");
--- a/js/src/tests/ecma_7/SIMD/ToSource.js
+++ b/js/src/tests/ecma_7/SIMD/ToSource.js
@@ -1,19 +1,43 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
function test() {
var Float32x4 = SIMD.Float32x4;
var f = Float32x4(11, 22, 33, 44);
assertEq(f.toSource(), "SIMD.Float32x4(11, 22, 33, 44)");
+ var Float64x2 = SIMD.Float64x2;
+ var f = Float64x2(11, 22, 33, 44);
+ assertEq(f.toSource(), "SIMD.Float64x2(11, 22)");
+
+ var Int8x16 = SIMD.Int8x16;
+ var f = Int8x16(11, 22, 33, 44, -11, -22, -33, -44, 1, 2, 3, 4, -1, -2, -3, -4);
+ assertEq(f.toSource(), "SIMD.Int8x16(11, 22, 33, 44, -11, -22, -33, -44, 1, 2, 3, 4, -1, -2, -3, -4)");
+
+ var Int16x8 = SIMD.Int16x8;
+ var f = Int16x8(11, 22, 33, 44, -11, -22, -33, -44);
+ assertEq(f.toSource(), "SIMD.Int16x8(11, 22, 33, 44, -11, -22, -33, -44)");
+
var Int32x4 = SIMD.Int32x4;
var f = Int32x4(11, 22, 33, 44);
assertEq(f.toSource(), "SIMD.Int32x4(11, 22, 33, 44)");
+ var Uint8x16 = SIMD.Uint8x16;
+ var f = Uint8x16(11, 22, 33, 44, 245, 234, 223, 212, 1, 2, 3, 4, 255, 254, 0, 250);
+ assertEq(f.toSource(), "SIMD.Uint8x16(11, 22, 33, 44, 245, 234, 223, 212, 1, 2, 3, 4, 255, 254, 0, 250)");
+
+ var Uint16x8 = SIMD.Uint16x8;
+ var f = Uint16x8(11, 22, 33, 44, 65535, 65534, 65533, 65532);
+ assertEq(f.toSource(), "SIMD.Uint16x8(11, 22, 33, 44, 65535, 65534, 65533, 65532)");
+
+ var Uint32x4 = SIMD.Uint32x4;
+ var f = Uint32x4(11, 22, 4294967295, 4294967294);
+ assertEq(f.toSource(), "SIMD.Uint32x4(11, 22, 4294967295, 4294967294)");
+
var Bool8x16 = SIMD.Bool8x16;
var f = Bool8x16(true, true, false, false, false, true, true, false, true, true, true, true, false, false, false, false);
assertEq(f.toSource(), "SIMD.Bool8x16(true, true, false, false, false, true, true, false, true, true, true, true, false, false, false, false)");
var Bool16x8 = SIMD.Bool16x8;
var f = Bool16x8(true, true, false, false, true, false, false, true);
assertEq(f.toSource(), "SIMD.Bool16x8(true, true, false, false, true, false, false, true)");
--- a/js/src/tests/ecma_7/SIMD/binary-operations.js
+++ b/js/src/tests/ecma_7/SIMD/binary-operations.js
@@ -1,18 +1,22 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
var Float32x4 = SIMD.Float32x4;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
var Bool8x16 = SIMD.Bool8x16;
var Bool16x8 = SIMD.Bool16x8;
var Bool32x4 = SIMD.Bool32x4;
var Bool64x2 = SIMD.Bool64x2;
+// Float32x4.
function testFloat32x4add() {
function addf(a, b) {
return Math.fround(Math.fround(a) + Math.fround(b));
}
var vals = [
[[1, 2, 3, 4], [10, 20, 30, 40]],
[[1.57, 2.27, 3.57, 4.19], [10.31, 20.49, 30.41, 40.72]],
@@ -74,16 +78,17 @@ function testFloat32x4sub() {
var i8x16vals = [
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]],
[[INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, -2, -3, -4, -5, -6, -7, -8, -9],
[1, 1, -1, -1, INT8_MAX, INT8_MAX, INT8_MIN, INT8_MIN, 8, 9, 10, 11, 12, 13, 14, 15]]
];
+// Int8x16.
function testInt8x16add() {
function addi(a, b) {
return (a + b) << 24 >> 24;
}
for (var [v,w] of i8x16vals) {
testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.add, addi);
}
@@ -134,23 +139,85 @@ function testInt8x16xor() {
return (a ^ b) << 24 >> 24;
}
for (var [v,w] of i8x16vals) {
testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.xor, xori);
}
}
+// Uint8x16.
+function testUint8x16add() {
+ function addi(a, b) {
+ return (a + b) << 24 >>> 24;
+ }
+
+ for (var [v,w] of i8x16vals) {
+ testBinaryFunc(Uint8x16(...v), Uint8x16(...w), Uint8x16.add, addi);
+ }
+}
+
+function testUint8x16and() {
+ function andi(a, b) {
+ return (a & b) << 24 >>> 24;
+ }
+
+ for (var [v,w] of i8x16vals) {
+ testBinaryFunc(Uint8x16(...v), Uint8x16(...w), Uint8x16.and, andi);
+ }
+}
+
+function testUint8x16mul() {
+ function muli(x, y) {
+ return (x * y) << 24 >>> 24;
+ }
+
+ for (var [v,w] of i8x16vals) {
+ testBinaryFunc(Uint8x16(...v), Uint8x16(...w), Uint8x16.mul, muli);
+ }
+}
+
+function testUint8x16or() {
+ function ori(a, b) {
+ return (a | b) << 24 >>> 24;
+ }
+
+ for (var [v,w] of i8x16vals) {
+ testBinaryFunc(Uint8x16(...v), Uint8x16(...w), Uint8x16.or, ori);
+ }
+}
+
+function testUint8x16sub() {
+ function subi(a, b) {
+ return (a - b) << 24 >>> 24;
+ }
+
+ for (var [v,w] of i8x16vals) {
+ testBinaryFunc(Uint8x16(...v), Uint8x16(...w), Uint8x16.sub, subi);
+ }
+}
+
+function testUint8x16xor() {
+ function xori(a, b) {
+ return (a ^ b) << 24 >>> 24;
+ }
+
+ for (var [v,w] of i8x16vals) {
+ testBinaryFunc(Uint8x16(...v), Uint8x16(...w), Uint8x16.xor, xori);
+ }
+}
+
var i16x8vals = [
[[1, 2, 3, 4, 5, 6, 7, 8],
[10, 20, 30, 40, 50, 60, 70, 80]],
[[INT16_MAX, INT16_MIN, INT16_MAX, INT16_MIN, INT16_MAX, INT16_MIN, INT16_MAX, INT16_MIN],
[1, 1, -1, -1, INT16_MAX, INT16_MAX, INT16_MIN, INT16_MIN]]
];
+// Int16x8.
function testInt16x8add() {
function addi(a, b) {
return (a + b) << 16 >> 16;
}
for (var [v,w] of i16x8vals) {
testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.add, addi);
}
@@ -201,102 +268,216 @@ function testInt16x8xor() {
return (a ^ b) << 16 >> 16;
}
for (var [v,w] of i16x8vals) {
testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.xor, xori);
}
}
+// Uint16x8.
+function testUint16x8add() {
+ function addi(a, b) {
+ return (a + b) << 16 >>> 16;
+ }
+
+ for (var [v,w] of i16x8vals) {
+ testBinaryFunc(Uint16x8(...v), Uint16x8(...w), Uint16x8.add, addi);
+ }
+}
+
+function testUint16x8and() {
+ function andi(a, b) {
+ return (a & b) << 16 >>> 16;
+ }
+
+ for (var [v,w] of i16x8vals) {
+ testBinaryFunc(Uint16x8(...v), Uint16x8(...w), Uint16x8.and, andi);
+ }
+}
+
+function testUint16x8mul() {
+ function muli(x, y) {
+ return (x * y) << 16 >>> 16;
+ }
+
+ for (var [v,w] of i16x8vals) {
+ testBinaryFunc(Uint16x8(...v), Uint16x8(...w), Uint16x8.mul, muli);
+ }
+}
+
+function testUint16x8or() {
+ function ori(a, b) {
+ return (a | b) << 16 >>> 16;
+ }
+
+ for (var [v,w] of i16x8vals) {
+ testBinaryFunc(Uint16x8(...v), Uint16x8(...w), Uint16x8.or, ori);
+ }
+}
+
+function testUint16x8sub() {
+ function subi(a, b) {
+ return (a - b) << 16 >>> 16;
+ }
+
+ for (var [v,w] of i16x8vals) {
+ testBinaryFunc(Uint16x8(...v), Uint16x8(...w), Uint16x8.sub, subi);
+ }
+}
+
+function testUint16x8xor() {
+ function xori(a, b) {
+ return (a ^ b) << 16 >>> 16;
+ }
+
+ for (var [v,w] of i16x8vals) {
+ testBinaryFunc(Uint16x8(...v), Uint16x8(...w), Uint16x8.xor, xori);
+ }
+}
+
+var i32x4vals = [
+ [[1, 2, 3, 4], [10, 20, 30, 40]],
+ [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [1, -1, 0, 0]],
+ [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [INT32_MIN, INT32_MAX, INT32_MAX, INT32_MIN]],
+ [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [-1, -1, INT32_MIN, INT32_MIN]],
+ [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [-1, 1, INT32_MAX, INT32_MIN]],
+ [[UINT32_MAX, 0, UINT32_MAX, 0], [1, -1, 0, 0]],
+ [[UINT32_MAX, 0, UINT32_MAX, 0], [-1, -1, INT32_MIN, INT32_MIN]],
+ [[UINT32_MAX, 0, UINT32_MAX, 0], [1, -1, 0, 0]],
+ [[UINT32_MAX, 0, UINT32_MAX, 0], [-1, 1, INT32_MAX, INT32_MIN]]
+];
+
+// Int32x4.
function testInt32x4add() {
function addi(a, b) {
return (a + b) | 0;
}
- var valsExp = [
- [[1, 2, 3, 4], [10, 20, 30, 40]],
- [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [1, -1, 0, 0]]
- ];
-
- for (var [v,w] of valsExp) {
+ for (var [v,w] of i32x4vals) {
testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.add, addi);
}
}
function testInt32x4and() {
function andi(a, b) {
return (a & b) | 0;
}
- var valsExp = [
- [[1, 2, 3, 4], [10, 20, 30, 40]],
- [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [INT32_MIN, INT32_MAX, INT32_MAX, INT32_MIN]]
- ];
-
- for (var [v,w] of valsExp) {
+ for (var [v,w] of i32x4vals) {
testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.and, andi);
}
}
function testInt32x4mul() {
function muli(x, y) {
- return (x * y) | 0;
+ // Deal with lost precision in the 53-bit double mantissa.
+ // Compute two 48-bit products. Truncate and combine them.
+ var hi = (x * (y >>> 16)) | 0;
+ var lo = (x * (y & 0xffff)) | 0;
+ return (lo + (hi << 16)) | 0;
}
- var valsExp = [
- [[1, 2, 3, 4], [10, 20, 30, 40]],
- [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [-1, -1, INT32_MIN, INT32_MIN]]
- ];
-
- for (var [v,w] of valsExp) {
+ for (var [v,w] of i32x4vals) {
testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.mul, muli);
}
}
function testInt32x4or() {
function ori(a, b) {
return (a | b) | 0;
}
- var valsExp = [
- [[1, 2, 3, 4], [10, 20, 30, 40]],
- [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [INT32_MIN, INT32_MAX, INT32_MAX, INT32_MIN]]
- ];
-
- for (var [v,w] of valsExp) {
+ for (var [v,w] of i32x4vals) {
testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.or, ori);
}
}
function testInt32x4sub() {
function subi(a, b) {
return (a - b) | 0;
}
- var valsExp = [
- [[10, 20, 30, 40], [1, 2, 3, 4]],
- [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [-1, 1, INT32_MAX, INT32_MIN]]
- ];
- for (var [v,w] of valsExp) {
+ for (var [v,w] of i32x4vals) {
testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.sub, subi);
}
}
function testInt32x4xor() {
function xori(a, b) {
return (a ^ b) | 0;
}
- var valsExp = [
- [[1, 2, 3, 4], [10, 20, 30, 40]],
- [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [INT32_MIN, INT32_MAX, INT32_MAX, INT32_MIN]]
- ];
+ for (var [v,w] of i32x4vals) {
+ testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.xor, xori);
+ }
+}
+
+// Uint32x4.
+function testUint32x4add() {
+ function addi(a, b) {
+ return (a + b) >>> 0;
+ }
+
+ for (var [v,w] of i32x4vals) {
+ testBinaryFunc(Uint32x4(...v), Uint32x4(...w), Uint32x4.add, addi);
+ }
+}
+
+function testUint32x4and() {
+ function andi(a, b) {
+ return (a & b) >>> 0;
+ }
+
+ for (var [v,w] of i32x4vals) {
+ testBinaryFunc(Uint32x4(...v), Uint32x4(...w), Uint32x4.and, andi);
+ }
+}
- for (var [v,w] of valsExp) {
- testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.xor, xori);
+function testUint32x4mul() {
+ function muli(x, y) {
+ // Deal with lost precision in the 53-bit double mantissa.
+ // Compute two 48-bit products. Truncate and combine them.
+ var hi = (x * (y >>> 16)) >>> 0;
+ var lo = (x * (y & 0xffff)) >>> 0;
+ return (lo + (hi << 16)) >>> 0;
+ }
+
+ for (var [v,w] of i32x4vals) {
+ testBinaryFunc(Uint32x4(...v), Uint32x4(...w), Uint32x4.mul, muli);
+ }
+}
+
+function testUint32x4or() {
+ function ori(a, b) {
+ return (a | b) >>> 0;
+ }
+
+ for (var [v,w] of i32x4vals) {
+ testBinaryFunc(Uint32x4(...v), Uint32x4(...w), Uint32x4.or, ori);
+ }
+}
+
+function testUint32x4sub() {
+ function subi(a, b) {
+ return (a - b) >>> 0;
+ }
+
+ for (var [v,w] of i32x4vals) {
+ testBinaryFunc(Uint32x4(...v), Uint32x4(...w), Uint32x4.sub, subi);
+ }
+}
+
+function testUint32x4xor() {
+ function xori(a, b) {
+ return (a ^ b) >>> 0;
+ }
+
+ for (var [v,w] of i32x4vals) {
+ testBinaryFunc(Uint32x4(...v), Uint32x4(...w), Uint32x4.xor, xori);
}
}
var b8x16vals = [
[[true, true, true, true, false, false, false, false, true, true, true, true, false, false, false, false],
[false, true, false, true, false, true, false, true, true, true, true, true, false, false, false, false]]
];
@@ -441,30 +622,51 @@ function test() {
testInt8x16add();
testInt8x16and();
testInt8x16mul();
testInt8x16or();
testInt8x16sub();
testInt8x16xor();
+ testUint8x16add();
+ testUint8x16and();
+ testUint8x16mul();
+ testUint8x16or();
+ testUint8x16sub();
+ testUint8x16xor();
+
testInt16x8add();
testInt16x8and();
testInt16x8mul();
testInt16x8or();
testInt16x8sub();
testInt16x8xor();
+ testUint16x8add();
+ testUint16x8and();
+ testUint16x8mul();
+ testUint16x8or();
+ testUint16x8sub();
+ testUint16x8xor();
+
testInt32x4add();
testInt32x4and();
testInt32x4mul();
testInt32x4or();
testInt32x4sub();
testInt32x4xor();
+ testUint32x4add();
+ testUint32x4and();
+ testUint32x4mul();
+ testUint32x4or();
+ testUint32x4sub();
+ testUint32x4xor();
+
testBool8x16and();
testBool8x16or();
testBool8x16xor();
testBool16x8and();
testBool16x8or();
testBool16x8xor();
--- a/js/src/tests/ecma_7/SIMD/check.js
+++ b/js/src/tests/ecma_7/SIMD/check.js
@@ -1,129 +1,210 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
function test() {
var i4 = SIMD.Int32x4(1,2,3,4);
var i8 = SIMD.Int16x8(1,2,3,4,5,6,7,8);
var i16 = SIMD.Int8x16(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
+ var u4 = SIMD.Uint32x4(1,2,3,4);
+ var u8 = SIMD.Uint16x8(1,2,3,4,5,6,7,8);
+ var u16 = SIMD.Uint8x16(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var f4 = SIMD.Float32x4(NaN, -0, Infinity, 13.37);
var f2 = SIMD.Float64x2(-0, 13.37);
var b2 = SIMD.Bool64x2(true, false);
var b4 = SIMD.Bool32x4(true, true, false, false);
var b8 = SIMD.Bool16x8(true, true, false, false, true, true, false, false);
var b16 = SIMD.Bool8x16(true, true, false, false, true, true, false, false, true, true, false, false, true, true, false, false);
var ci4 = SIMD.Int32x4.check(i4);
assertEqX4(ci4, simdToArray(i4));
assertThrowsInstanceOf(() => SIMD.Int32x4.check(f4), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.check(f2), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.check(i8), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Int32x4.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Int32x4.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Int32x4.check(u16), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.check(b2), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.check(b4), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.check(b8), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.check(b16), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.check("i swear i'm a vector"), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.check({}), TypeError);
var ci8 = SIMD.Int16x8.check(i8);
assertEqX8(ci8, simdToArray(i8));
assertThrowsInstanceOf(() => SIMD.Int16x8.check(i4), TypeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Int16x8.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Int16x8.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Int16x8.check(u16), TypeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.check(f4), TypeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.check(f2), TypeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.check(b2), TypeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.check(b4), TypeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.check(b8), TypeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.check(b16), TypeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.check("i swear i'm a vector"), TypeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.check({}), TypeError);
var ci16 = SIMD.Int8x16.check(i16);
assertEqX16(ci16, simdToArray(i16));
assertThrowsInstanceOf(() => SIMD.Int8x16.check(i4), TypeError);
assertThrowsInstanceOf(() => SIMD.Int8x16.check(i8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Int8x16.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Int8x16.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Int8x16.check(u16), TypeError);
assertThrowsInstanceOf(() => SIMD.Int8x16.check(f4), TypeError);
assertThrowsInstanceOf(() => SIMD.Int8x16.check(f2), TypeError);
assertThrowsInstanceOf(() => SIMD.Int8x16.check(b2), TypeError);
assertThrowsInstanceOf(() => SIMD.Int8x16.check(b4), TypeError);
assertThrowsInstanceOf(() => SIMD.Int8x16.check(b8), TypeError);
assertThrowsInstanceOf(() => SIMD.Int8x16.check(b16), TypeError);
assertThrowsInstanceOf(() => SIMD.Int8x16.check("i swear i'm a vector"), TypeError);
assertThrowsInstanceOf(() => SIMD.Int8x16.check({}), TypeError);
+ var cu4 = SIMD.Uint32x4.check(u4);
+ assertEqX4(cu4, simdToArray(u4));
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(f4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(f2), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(i4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(i8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(u16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(b2), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(b4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(b8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check(b16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check("i swear i'm a vector"), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.check({}), TypeError);
+
+ var cu8 = SIMD.Uint16x8.check(u8);
+ assertEqX8(cu8, simdToArray(u8));
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(i4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(i8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(u16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(f4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(f2), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(b2), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(b4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(b8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check(b16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check("i swear i'm a vector"), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.check({}), TypeError);
+
+ var cu16 = SIMD.Uint8x16.check(u16);
+ assertEqX16(cu16, simdToArray(u16));
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(i4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(i8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(f4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(f2), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(b2), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(b4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(b8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check(b16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check("i swear i'm a vector"), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.check({}), TypeError);
+
var cf4 = SIMD.Float32x4.check(f4);
assertEqX4(cf4, simdToArray(f4));
assertThrowsInstanceOf(() => SIMD.Float32x4.check(i4), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.check(i8), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Float32x4.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Float32x4.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Float32x4.check(u16), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.check(f2), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.check(b2), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.check(b4), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.check(b8), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.check(b16), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.check("i swear i'm a vector"), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.check({}), TypeError);
var cf2 = SIMD.Float64x2.check(f2);
assertEqX2(cf2, simdToArray(f2));
assertThrowsInstanceOf(() => SIMD.Float64x2.check(f4), TypeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.check(i4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Float64x2.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Float64x2.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Float64x2.check(u16), TypeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.check(i8), TypeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.check(i16), TypeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.check(b2), TypeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.check(b4), TypeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.check(b8), TypeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.check(b16), TypeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.check("i swear i'm a vector"), TypeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.check({}), TypeError);
var cb2 = SIMD.Bool64x2.check(b2);
assertEqX2(cb2, simdToArray(b2));
assertThrowsInstanceOf(() => SIMD.Bool64x2.check(f4), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool64x2.check(f2), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool64x2.check(i8), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool64x2.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool64x2.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool64x2.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool64x2.check(u16), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool64x2.check(b4), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool64x2.check(b8), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool64x2.check(b16), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool64x2.check("i swear i'm a vector"), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool64x2.check({}), TypeError);
var cb4 = SIMD.Bool32x4.check(b4);
assertEqX4(cb4, simdToArray(b4));
assertThrowsInstanceOf(() => SIMD.Bool32x4.check(f4), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool32x4.check(f2), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool32x4.check(i4), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool32x4.check(i8), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool32x4.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool32x4.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool32x4.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool32x4.check(u16), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool32x4.check(b2), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool32x4.check(b8), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool32x4.check(b16), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool32x4.check("i swear i'm a vector"), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool32x4.check({}), TypeError);
var cb8 = SIMD.Bool16x8.check(b8);
assertEqX8(cb8, simdToArray(b8));
- assertThrowsInstanceOf(() => SIMD.Bool16x8.check(i4), TypeError);
- assertThrowsInstanceOf(() => SIMD.Bool16x8.check(i16), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool16x8.check(f4), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool16x8.check(f2), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool16x8.check(i4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool16x8.check(i8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool16x8.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool16x8.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool16x8.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool16x8.check(u16), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool16x8.check(b2), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool16x8.check(b4), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool16x8.check(b16), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool16x8.check("i swear i'm a vector"), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool16x8.check({}), TypeError);
var cb16 = SIMD.Bool8x16.check(b16);
assertEqX16(cb16, simdToArray(b16));
+ assertThrowsInstanceOf(() => SIMD.Bool8x16.check(f4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool8x16.check(f2), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool8x16.check(i4), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool8x16.check(i8), TypeError);
- assertThrowsInstanceOf(() => SIMD.Bool8x16.check(f4), TypeError);
- assertThrowsInstanceOf(() => SIMD.Bool8x16.check(f2), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool8x16.check(i16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool8x16.check(u4), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool8x16.check(u8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Bool8x16.check(u16), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool8x16.check(b2), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool8x16.check(b4), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool8x16.check(b8), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool8x16.check("i swear i'm a vector"), TypeError);
assertThrowsInstanceOf(() => SIMD.Bool8x16.check({}), TypeError);
if (typeof reportCompare === "function")
reportCompare(true, true);
--- a/js/src/tests/ecma_7/SIMD/comparisons.js
+++ b/js/src/tests/ecma_7/SIMD/comparisons.js
@@ -5,16 +5,19 @@
* https://creativecommons.org/publicdomain/zero/1.0/
*/
var Float32x4 = SIMD.Float32x4;
var Float64x2 = SIMD.Float64x2;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
var Bool8x16 = SIMD.Bool8x16;
var Bool16x8 = SIMD.Bool16x8;
var Bool32x4 = SIMD.Bool32x4;
var Bool64x2 = SIMD.Bool64x2;
var fround = Math.fround;
@@ -108,16 +111,73 @@ function testLessThanOrEqualInt32x4(v, w
}
function testGreaterThanInt32x4(v, w) {
testBinaryCompare(v, w, Int32x4.greaterThan, (x, y) => x > y, Bool32x4);
}
function testGreaterThanOrEqualInt32x4(v, w) {
testBinaryCompare(v, w, Int32x4.greaterThanOrEqual, (x, y) => x >= y, Bool32x4);
}
+function testEqualUint8x16(v, w) {
+ testBinaryCompare(v, w, Uint8x16.equal, (x, y) => x == y, Bool8x16);
+}
+function testNotEqualUint8x16(v, w) {
+ testBinaryCompare(v, w, Uint8x16.notEqual, (x, y) => x != y, Bool8x16);
+}
+function testLessThanUint8x16(v, w) {
+ testBinaryCompare(v, w, Uint8x16.lessThan, (x, y) => x < y, Bool8x16);
+}
+function testLessThanOrEqualUint8x16(v, w) {
+ testBinaryCompare(v, w, Uint8x16.lessThanOrEqual, (x, y) => x <= y, Bool8x16);
+}
+function testGreaterThanUint8x16(v, w) {
+ testBinaryCompare(v, w, Uint8x16.greaterThan, (x, y) => x > y, Bool8x16);
+}
+function testGreaterThanOrEqualUint8x16(v, w) {
+ testBinaryCompare(v, w, Uint8x16.greaterThanOrEqual, (x, y) => x >= y, Bool8x16);
+}
+
+function testEqualUint16x8(v, w) {
+ testBinaryCompare(v, w, Uint16x8.equal, (x, y) => x == y, Bool16x8);
+}
+function testNotEqualUint16x8(v, w) {
+ testBinaryCompare(v, w, Uint16x8.notEqual, (x, y) => x != y, Bool16x8);
+}
+function testLessThanUint16x8(v, w) {
+ testBinaryCompare(v, w, Uint16x8.lessThan, (x, y) => x < y, Bool16x8);
+}
+function testLessThanOrEqualUint16x8(v, w) {
+ testBinaryCompare(v, w, Uint16x8.lessThanOrEqual, (x, y) => x <= y, Bool16x8);
+}
+function testGreaterThanUint16x8(v, w) {
+ testBinaryCompare(v, w, Uint16x8.greaterThan, (x, y) => x > y, Bool16x8);
+}
+function testGreaterThanOrEqualUint16x8(v, w) {
+ testBinaryCompare(v, w, Uint16x8.greaterThanOrEqual, (x, y) => x >= y, Bool16x8);
+}
+
+function testEqualUint32x4(v, w) {
+ testBinaryCompare(v, w, Uint32x4.equal, (x, y) => x == y, Bool32x4);
+}
+function testNotEqualUint32x4(v, w) {
+ testBinaryCompare(v, w, Uint32x4.notEqual, (x, y) => x != y, Bool32x4);
+}
+function testLessThanUint32x4(v, w) {
+ testBinaryCompare(v, w, Uint32x4.lessThan, (x, y) => x < y, Bool32x4);
+}
+function testLessThanOrEqualUint32x4(v, w) {
+ testBinaryCompare(v, w, Uint32x4.lessThanOrEqual, (x, y) => x <= y, Bool32x4);
+}
+function testGreaterThanUint32x4(v, w) {
+ testBinaryCompare(v, w, Uint32x4.greaterThan, (x, y) => x > y, Bool32x4);
+}
+function testGreaterThanOrEqualUint32x4(v, w) {
+ testBinaryCompare(v, w, Uint32x4.greaterThanOrEqual, (x, y) => x >= y, Bool32x4);
+}
+
function test() {
var Float32x4val = [
Float32x4(1, 20, 30, 4),
Float32x4(10, 2, 3, 40),
Float32x4(9.999, 2.1234, 30.4443, 4),
Float32x4(10, 2.1233, 30.4444, 4.0001),
Float32x4(NaN, -Infinity, +Infinity, -0),
Float32x4(+Infinity, NaN, -0, -Infinity),
@@ -217,13 +277,73 @@ function test() {
testNotEqualInt32x4(v, w);
testLessThanInt32x4(v, w);
testLessThanOrEqualInt32x4(v, w);
testGreaterThanInt32x4(v, w);
testGreaterThanOrEqualInt32x4(v, w);
}
}
+ var Uint8x16val = [
+ Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
+ Uint8x16(-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16),
+ Uint8x16(-1, 2, -3, 4, -5, 6, -7, 8, -9, 10, -11, 12, -13, 14, -15, 16),
+ Uint8x16(1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16),
+ Uint8x16(UINT8_MAX, UINT8_MAX, 0, 0, 0 + 1, UINT8_MAX - 1, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16),
+ Uint8x16(UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX - 1, 0 + 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, -16)
+ ];
+
+ for (v of Uint8x16val) {
+ for (w of Uint8x16val) {
+ testEqualUint8x16(v, w);
+ testNotEqualUint8x16(v, w);
+ testLessThanUint8x16(v, w);
+ testLessThanOrEqualUint8x16(v, w);
+ testGreaterThanUint8x16(v, w);
+ testGreaterThanOrEqualUint8x16(v, w);
+ }
+ }
+
+ var Uint16x8val = [
+ Uint16x8(1, 2, 3, 4, 5, 6, 7, 8),
+ Uint16x8(-1, -2, -3, -4, -5, -6, -7, -8),
+ Uint16x8(-1, 2, -3, 4, -5, 6, -7, 8),
+ Uint16x8(1, -2, 3, -4, 5, -6, 7, -8),
+ Uint16x8(UINT16_MAX, UINT16_MAX, 0, 0, 0 + 1, UINT16_MAX - 1, -7, -8),
+ Uint16x8(UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX - 1, 0 + 1, 7, -8)
+ ];
+
+ for (v of Uint16x8val) {
+ for (w of Uint16x8val) {
+ testEqualUint16x8(v, w);
+ testNotEqualUint16x8(v, w);
+ testLessThanUint16x8(v, w);
+ testLessThanOrEqualUint16x8(v, w);
+ testGreaterThanUint16x8(v, w);
+ testGreaterThanOrEqualUint16x8(v, w);
+ }
+ }
+
+ var Uint32x4val = [
+ Uint32x4(1, 2, 3, 4),
+ Uint32x4(-1, -2, -3, -4),
+ Uint32x4(-1, 2, -3, 4),
+ Uint32x4(1, -2, 3, -4),
+ Uint32x4(UINT32_MAX, UINT32_MAX, 0, 0),
+ Uint32x4(UINT32_MAX, 0, UINT32_MAX, 0)
+ ];
+
+ for (v of Uint32x4val) {
+ for (w of Uint32x4val) {
+ testEqualUint32x4(v, w);
+ testNotEqualUint32x4(v, w);
+ testLessThanUint32x4(v, w);
+ testLessThanOrEqualUint32x4(v, w);
+ testGreaterThanUint32x4(v, w);
+ testGreaterThanOrEqualUint32x4(v, w);
+ }
+ }
+
if (typeof reportCompare === "function")
reportCompare(true, true);
}
test();
--- a/js/src/tests/ecma_7/SIMD/constructors.js
+++ b/js/src/tests/ecma_7/SIMD/constructors.js
@@ -1,15 +1,18 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
var Float64x2 = SIMD.Float64x2;
var Float32x4 = SIMD.Float32x4;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
var Bool8x16 = SIMD.Bool8x16;
var Bool16x8 = SIMD.Bool16x8;
var Bool32x4 = SIMD.Bool32x4;
var Bool64x2 = SIMD.Bool64x2;
function TestInt8x16Ctor() {
// Constructors.
assertEqX16(Int8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]);
@@ -54,16 +57,65 @@ function TestInt32x4Ctor() {
assertEqX4(Int32x4(1, 2, 3), [1,2,3,0]);
assertEqX4(Int32x4(1, 2), [1,2,0,0]);
assertEqX4(Int32x4(1), [1,0,0,0]);
assertEqX4(Int32x4(), [0,0,0,0]);
assertEqX4(Int32x4(1, 2, 3, 4, 5), [1,2,3,4]);
assertEqX4(Int32x4(1, 2, 3, 4, 5, 6), [1,2,3,4]);
}
+function TestUint8x16Ctor() {
+ // Constructors.
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15), [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), [1,2,3,4,5,6,7,8,9,10,11,12,13,14,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13), [1,2,3,4,5,6,7,8,9,10,11,12,13,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), [1,2,3,4,5,6,7,8,9,10,11,12,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11), [1,2,3,4,5,6,7,8,9,10,11,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), [1,2,3,4,5,6,7,8,9,10,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9), [1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8), [1,2,3,4,5,6,7,8,0,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7), [1,2,3,4,5,6,7,0,0,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6), [1,2,3,4,5,6,0,0,0,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5), [1,2,3,4,5,0,0,0,0,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4), [1,2,3,4,0,0,0,0,0,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3), [1,2,3,0,0,0,0,0,0,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2), [1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1), [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17), [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]);
+ assertEqX16(Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18), [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]);
+}
+
+function TestUint16x8Ctor() {
+ // Constructors.
+ assertEqX8(Uint16x8(1, 2, 3, 4, 5, 6, 7, 8), [1,2,3,4,5,6,7,8]);
+ assertEqX8(Uint16x8(1, 2, 3, 4, 5, 6, 7), [1,2,3,4,5,6,7,0]);
+ assertEqX8(Uint16x8(1, 2, 3, 4, 5, 6), [1,2,3,4,5,6,0,0]);
+ assertEqX8(Uint16x8(1, 2, 3, 4, 5), [1,2,3,4,5,0,0,0]);
+ assertEqX8(Uint16x8(1, 2, 3, 4), [1,2,3,4,0,0,0,0]);
+ assertEqX8(Uint16x8(1, 2, 3), [1,2,3,0,0,0,0,0]);
+ assertEqX8(Uint16x8(1, 2), [1,2,0,0,0,0,0,0]);
+ assertEqX8(Uint16x8(1), [1,0,0,0,0,0,0,0]);
+ assertEqX8(Uint16x8(), [0,0,0,0,0,0,0,0]);
+ assertEqX8(Uint16x8(1, 2, 3, 4, 5, 6, 7, 8, 9), [1,2,3,4,5,6,7,8]);
+ assertEqX8(Uint16x8(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), [1,2,3,4,5,6,7,8]);
+}
+
+function TestUint32x4Ctor() {
+ // Constructors.
+ assertEqX4(Uint32x4(1, 2, 3, 4), [1,2,3,4]);
+ assertEqX4(Uint32x4(1, 2, 3), [1,2,3,0]);
+ assertEqX4(Uint32x4(1, 2), [1,2,0,0]);
+ assertEqX4(Uint32x4(1), [1,0,0,0]);
+ assertEqX4(Uint32x4(), [0,0,0,0]);
+ assertEqX4(Uint32x4(1, 2, 3, 4, 5), [1,2,3,4]);
+ assertEqX4(Uint32x4(1, 2, 3, 4, 5, 6), [1,2,3,4]);
+}
+
function TestFloat32x4Ctor() {
assertEqX4(Float32x4(1, 2, 3, 4), [1,2,3,4]);
assertEqX4(Float32x4(1, 2, 3), [1,2,3,NaN]);
assertEqX4(Float32x4(1, 2), [1,2,NaN,NaN]);
assertEqX4(Float32x4(1), [1,NaN,NaN,NaN]);
assertEqX4(Float32x4(), [NaN,NaN,NaN,NaN]);
assertEqX4(Float32x4(1, 2, 3, 4, 5), [1,2,3,4]);
assertEqX4(Float32x4(1, 2, 3, 4, 5, 6), [1,2,3,4]);
@@ -154,16 +206,19 @@ function TestBool64x2Ctor() {
}
function test() {
TestFloat32x4Ctor();
TestFloat64x2Ctor();
TestInt8x16Ctor();
TestInt16x8Ctor();
TestInt32x4Ctor();
+ TestUint8x16Ctor();
+ TestUint16x8Ctor();
+ TestUint32x4Ctor();
TestBool8x16Ctor();
TestBool16x8Ctor();
TestBool32x4Ctor();
TestBool64x2Ctor();
if (typeof reportCompare === "function")
reportCompare(true, true);
}
--- a/js/src/tests/ecma_7/SIMD/conversions.js
+++ b/js/src/tests/ecma_7/SIMD/conversions.js
@@ -1,14 +1,17 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
var Float32x4 = SIMD.Float32x4;
var Float64x2 = SIMD.Float64x2;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
function testFloat32x4FromFloat64x2Bits() {
var valsExp = [
[[2.000000473111868, 512.0001225471497], [1.0, 2.0, 3.0, 4.0]],
[[-0, NaN], [0, -0, 0, NaN]],
[[Infinity, -Infinity], [0, NaN, 0, NaN]]
];
@@ -32,16 +35,36 @@ function testFloat32x4FromInt8x16Bits()
for (var v of vals) {
var i = Int8x16(...v);
assertEqX4(Float32x4.fromInt8x16Bits(i), expected(i, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX4(Float32x4.fromInt8x16Bits(i), expected(i, SharedArrayBuffer));
}
}
+function testFloat32x4FromUint8x16Bits() {
+ function expected(v, Buffer) {
+ var u8 = new Uint8Array(new Buffer(16));
+ var f32 = new Float32Array(u8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) u8[i] = asArr[i];
+ return [f32[0], f32[1], f32[2], f32[3]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+ [0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX,
+ UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0]];
+ for (var v of vals) {
+ var i = Uint8x16(...v);
+ assertEqX4(Float32x4.fromUint8x16Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Float32x4.fromUint8x16Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
function testFloat32x4FromInt16x8Bits() {
function expected(v, Buffer) {
var i16 = new Int16Array(new Buffer(16));
var f32 = new Float32Array(i16.buffer);
var asArr = simdToArray(v);
for (var i = 0; i < 8; i++) i16[i] = asArr[i];
return [f32[0], f32[1], f32[2], f32[3]];
}
@@ -51,16 +74,35 @@ function testFloat32x4FromInt16x8Bits()
for (var v of vals) {
var i = Int16x8(...v);
assertEqX4(Float32x4.fromInt16x8Bits(i), expected(i, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX4(Float32x4.fromInt16x8Bits(i), expected(i, SharedArrayBuffer));
}
}
+function testFloat32x4FromUint16x8Bits() {
+ function expected(v, Buffer) {
+ var u16 = new Uint16Array(new Buffer(16));
+ var f32 = new Float32Array(u16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) u16[i] = asArr[i];
+ return [f32[0], f32[1], f32[2], f32[3]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8],
+ [0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX]];
+ for (var v of vals) {
+ var i = Uint16x8(...v);
+ assertEqX4(Float32x4.fromUint16x8Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Float32x4.fromUint16x8Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
function testFloat32x4FromInt32x4() {
function expected(v) {
return v.map(Math.fround);
}
var vals = [
[1, 2, 3, 4],
[INT32_MIN, INT32_MAX, Math.pow(2, 30) - 1, -Math.pow(2, 30)]
];
@@ -104,27 +146,91 @@ function testFloat32x4FromInt32x4() {
assertEqX4(v, [Math.pow(2, 31),
Math.pow(2, 30),
last,
Math.pow(2, 31)
]);
}
}
+function testFloat32x4FromUint32x4() {
+ function expected(v) {
+ return v.map(Math.fround);
+ }
+ var vals = [
+ [1, 2, 3, 4],
+ [0, UINT32_MAX, Math.pow(2, 30) - 1, Math.pow(2, 31)]
+ ];
+
+ for (var v of vals) {
+ assertEqX4(Float32x4.fromUint32x4(Uint32x4(...v)), expected(v));
+ }
+
+ // Check that rounding to nearest, even is applied.
+ {
+ var num = makeFloat(0, 150 + 2, 0);
+ var next = makeFloat(0, 150 + 2, 1);
+ assertEq(num + 4, next);
+
+ v = Float32x4.fromUint32x4(Uint32x4(num, num + 1, num + 2, num + 3));
+ assertEqX4(v, [num, num, /* even */ num, next]);
+ }
+
+ {
+ var num = makeFloat(0, 150 + 2, 1);
+ var next = makeFloat(0, 150 + 2, 2);
+ assertEq(num + 4, next);
+
+ v = Float32x4.fromUint32x4(Uint32x4(num, num + 1, num + 2, num + 3));
+ assertEqX4(v, [num, num, /* even */ next, next]);
+ }
+
+ {
+ var last = makeFloat(0, 157, 0x7fffff);
+
+ assertEq(last, Math.fround(last), "float");
+ assertEq(last < Math.pow(2, 31), true, "less than 2**31");
+ assertEq(last | 0, last, "it should be an integer, as exponent >= 150");
+
+ var diff = (Math.pow(2, 31) - 1) - last;
+ v = Float32x4.fromUint32x4(Uint32x4(Math.pow(2, 31) - 1,
+ Math.pow(2, 30) + 1,
+ last + (diff / 2) | 0, // nearest is last
+ last + (diff / 2) + 1 | 0 // nearest is Math.pow(2, 31)
+ ));
+ assertEqX4(v, [Math.pow(2, 31),
+ Math.pow(2, 30),
+ last,
+ Math.pow(2, 31)
+ ]);
+ }
+}
+
function testFloat32x4FromInt32x4Bits() {
var valsExp = [
[[100, 200, 300, 400], [1.401298464324817e-43, 2.802596928649634e-43, 4.203895392974451e-43, 5.605193857299268e-43]],
[[INT32_MIN, INT32_MAX, 0, 0], [-0, NaN, 0, 0]]
];
for (var [v,w] of valsExp) {
assertEqX4(Float32x4.fromInt32x4Bits(Int32x4(...v)), w);
}
}
+function testFloat32x4FromUint32x4Bits() {
+ var valsExp = [
+ [[100, 200, 300, 400], [1.401298464324817e-43, 2.802596928649634e-43, 4.203895392974451e-43, 5.605193857299268e-43]],
+ [[INT32_MIN, INT32_MAX, 0, 0], [-0, NaN, 0, 0]]
+ ];
+
+ for (var [v,w] of valsExp) {
+ assertEqX4(Float32x4.fromUint32x4Bits(Uint32x4(...v)), w);
+ }
+}
+
function testFloat64x2FromFloat32x4Bits() {
var valsExp = [
[[0, 1.875, 0, 2], [1.0, 2.0]],
[[NaN, -0, Infinity, -Infinity], [-1.058925634e-314, -1.404448428688076e+306]]
];
for (var [v,w] of valsExp) {
assertEqX2(Float64x2.fromFloat32x4Bits(Float32x4(...v)), w);
@@ -147,16 +253,37 @@ function testFloat64x2FromInt8x16Bits()
for (var v of vals) {
var f = Int8x16(...v);
assertEqX2(Float64x2.fromInt8x16Bits(f), expected(f, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX2(Float64x2.fromInt8x16Bits(f), expected(f, SharedArrayBuffer));
}
}
+function testFloat64x2FromUint8x16Bits() {
+ function expected(v, Buffer) {
+ var u8 = new Uint8Array(new Buffer(16));
+ var f64 = new Float64Array(u8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) u8[i] = asArr[i];
+ return [f64[0], f64[1]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+ [0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX,
+ UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0]];
+
+ for (var v of vals) {
+ var f = Uint8x16(...v);
+ assertEqX2(Float64x2.fromUint8x16Bits(f), expected(f, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX2(Float64x2.fromUint8x16Bits(f), expected(f, SharedArrayBuffer));
+ }
+}
+
function testFloat64x2FromInt16x8Bits() {
function expected(v, Buffer) {
var i16 = new Int16Array(new Buffer(16));
var f64 = new Float64Array(i16.buffer);
var asArr = simdToArray(v);
for (var i = 0; i < 8; i++) i16[i] = asArr[i];
return [f64[0], f64[1]];
}
@@ -167,27 +294,58 @@ function testFloat64x2FromInt16x8Bits()
for (var v of vals) {
var f = Int16x8(...v);
assertEqX2(Float64x2.fromInt16x8Bits(f), expected(f, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX2(Float64x2.fromInt16x8Bits(f), expected(f, SharedArrayBuffer));
}
}
+function testFloat64x2FromUint16x8Bits() {
+ function expected(v, Buffer) {
+ var u16 = new Uint16Array(new Buffer(16));
+ var f64 = new Float64Array(u16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) u16[i] = asArr[i];
+ return [f64[0], f64[1]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8],
+ [0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX]];
+
+ for (var v of vals) {
+ var f = Uint16x8(...v);
+ assertEqX2(Float64x2.fromUint16x8Bits(f), expected(f, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX2(Float64x2.fromUint16x8Bits(f), expected(f, SharedArrayBuffer));
+ }
+}
+
function testFloat64x2FromInt32x4Bits() {
var valsExp = [
[[0x00000000, 0x3ff00000, 0x0000000, 0x40000000], [1.0, 2.0]],
[[0xabcdef12, 0x3ff00000, 0x21fedcba, 0x40000000], [1.0000006400213732, 2.0000002532866263]]
];
for (var [v,w] of valsExp) {
assertEqX2(Float64x2.fromInt32x4Bits(Int32x4(...v)), w);
}
}
+function testFloat64x2FromUint32x4Bits() {
+ var valsExp = [
+ [[0x00000000, 0x3ff00000, 0x0000000, 0x40000000], [1.0, 2.0]],
+ [[0xabcdef12, 0x3ff00000, 0x21fedcba, 0x40000000], [1.0000006400213732, 2.0000002532866263]]
+ ];
+
+ for (var [v,w] of valsExp) {
+ assertEqX2(Float64x2.fromUint32x4Bits(Uint32x4(...v)), w);
+ }
+}
+
function testInt32x4FromFloat32x4() {
var d = Float32x4(1.1, 2.2, 3.3, 4.6);
assertEqX4(Int32x4.fromFloat32x4(d), [1, 2, 3, 4]);
var d = Float32x4(NaN, 0, 0, 0);
assertThrowsInstanceOf(() => SIMD.Int32x4.fromFloat32x4(d), RangeError);
var d = Float32x4(Infinity, 0, 0, 0);
@@ -210,40 +368,87 @@ function testInt32x4FromFloat32x4() {
var d = Float32x4(makeFloat(1, 127 + 31, 0), 0, 0, 0);
var e = SIMD.Int32x4.fromFloat32x4(d);
assertEqX4(e, [INT32_MIN, 0, 0, 0]);
var d = Float32x4(makeFloat(1, 127 + 31, 1), 0, 0, 0);
assertThrowsInstanceOf(() => SIMD.Int32x4.fromFloat32x4(d), RangeError);
}
+function testUint32x4FromFloat32x4() {
+ var d = Float32x4(1.1, 2.2, 3.3, 4.6);
+ assertEqX4(Uint32x4.fromFloat32x4(d), [1, 2, 3, 4]);
+
+ var d = Float32x4(NaN, 0, 0, 0);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.fromFloat32x4(d), RangeError);
+
+ var d = Float32x4(Infinity, 0, 0, 0);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.fromFloat32x4(d), RangeError);
+
+ var d = Float32x4(-Infinity, 0, 0, 0);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.fromFloat32x4(d), RangeError);
+
+ // Test high boundaries: float(0, 158, 0x7fffff) < UINT32_MAX < float(0, 159, 0)
+ var d = Float32x4(makeFloat(0, 127 + 32, 0), 0, 0, 0);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.fromFloat32x4(d), RangeError);
+
+ var lastFloat = makeFloat(0, 127 + 31, 0x7FFFFF);
+ var d = Float32x4(lastFloat, 0, 0, 0);
+ var e = SIMD.Uint32x4.fromFloat32x4(d);
+ assertEqX4(e, [lastFloat, 0, 0, 0]);
+}
+
function testInt32x4FromFloat32x4Bits() {
var valsExp = [
[[1, 2, 3, 4], [0x3f800000 | 0, 0x40000000 | 0, 0x40400000 | 0, 0x40800000 | 0]],
[[NaN, -0, Infinity, -Infinity], [0x7fc00000 | 0, 0x80000000 | 0, 0x7f800000 | 0, 0xff800000 | 0]]
];
for (var [v,w] of valsExp) {
assertEqX4(Int32x4.fromFloat32x4Bits(Float32x4(...v)), w);
}
}
+function testUint32x4FromFloat32x4Bits() {
+ var valsExp = [
+ [[1, 2, 3, 4], [0x3f800000, 0x40000000, 0x40400000, 0x40800000]],
+ [[NaN, -0, Infinity, -Infinity], [0x7fc00000, 0x80000000, 0x7f800000, 0xff800000]]
+ ];
+
+ for (var [v,w] of valsExp) {
+ assertEqX4(Uint32x4.fromFloat32x4Bits(Float32x4(...v)), w);
+ }
+}
+
function testInt32x4FromFloat64x2Bits() {
var valsExp = [
[[1.0, 2.0], [0x00000000, 0x3FF00000, 0x00000000, 0x40000000]],
[[+Infinity, -Infinity], [0x00000000, 0x7ff00000, 0x00000000, -0x100000]],
[[-0, NaN], [0x00000000, -0x80000000, 0x00000000, 0x7ff80000]],
[[1.0000006400213732, 2.0000002532866263], [-0x543210ee, 0x3ff00000, 0x21fedcba, 0x40000000]]
];
for (var [v,w] of valsExp) {
assertEqX4(Int32x4.fromFloat64x2Bits(Float64x2(...v)), w);
}
}
+function testUint32x4FromFloat64x2Bits() {
+ var valsExp = [
+ [[1.0, 2.0], [0x00000000, 0x3FF00000, 0x00000000, 0x40000000]],
+ [[+Infinity, -Infinity], [0x00000000, 0x7ff00000, 0x00000000, 0xfff00000]],
+ [[-0, NaN], [0x00000000, 0x80000000, 0x00000000, 0x7ff80000]],
+ [[1.0000006400213732, 2.0000002532866263], [0xabcdef12, 0x3ff00000, 0x21fedcba, 0x40000000]]
+ ];
+
+ for (var [v,w] of valsExp) {
+ assertEqX4(Uint32x4.fromFloat64x2Bits(Float64x2(...v)), w);
+ }
+}
+
function testInt32x4FromInt8x16Bits() {
function expected(v, Buffer) {
var i8 = new Int8Array(new Buffer(16));
var i32 = new Int32Array(i8.buffer);
var asArr = simdToArray(v);
for (var i = 0; i < 16; i++) i8[i] = asArr[i];
return [i32[0], i32[1], i32[2], i32[3]];
}
@@ -255,16 +460,37 @@ function testInt32x4FromInt8x16Bits() {
for (var v of vals) {
var i = Int8x16(...v);
assertEqX4(Int32x4.fromInt8x16Bits(i), expected(i, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX4(Int32x4.fromInt8x16Bits(i), expected(i, SharedArrayBuffer));
}
}
+function testInt32x4FromUint8x16Bits() {
+ function expected(v, Buffer) {
+ var u8 = new Uint8Array(new Buffer(16));
+ var i32 = new Int32Array(u8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) u8[i] = asArr[i];
+ return [i32[0], i32[1], i32[2], i32[3]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+ [0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX,
+ UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0]];
+
+ for (var v of vals) {
+ var i = Uint8x16(...v);
+ assertEqX4(Int32x4.fromUint8x16Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Int32x4.fromUint8x16Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
function testInt32x4FromInt16x8Bits() {
function expected(v, Buffer) {
var i16 = new Int16Array(new Buffer(16));
var i32 = new Int32Array(i16.buffer);
var asArr = simdToArray(v);
for (var i = 0; i < 8; i++) i16[i] = asArr[i];
return [i32[0], i32[1], i32[2], i32[3]];
}
@@ -275,16 +501,55 @@ function testInt32x4FromInt16x8Bits() {
for (var v of vals) {
var i = Int16x8(...v);
assertEqX4(Int32x4.fromInt16x8Bits(i), expected(i, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX4(Int32x4.fromInt16x8Bits(i), expected(i, SharedArrayBuffer));
}
}
+function testInt32x4FromUint16x8Bits() {
+ function expected(v, Buffer) {
+ var u16 = new Uint16Array(new Buffer(16));
+ var i32 = new Int32Array(u16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) u16[i] = asArr[i];
+ return [i32[0], i32[1], i32[2], i32[3]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8],
+ [0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX]];
+
+ for (var v of vals) {
+ var i = Uint16x8(...v);
+ assertEqX4(Int32x4.fromUint16x8Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Int32x4.fromUint16x8Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testInt32x4FromUint32x4Bits() {
+ function expected(v, Buffer) {
+ var u32 = new Uint32Array(new Buffer(16));
+ var i32 = new Int32Array(u32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) u32[i] = asArr[i];
+ return [i32[0], i32[1], i32[2], i32[3]];
+ }
+
+ var vals = [[0, 1, -2, 3], [INT8_MIN, UINT32_MAX, INT32_MIN, INT32_MAX]];
+
+ for (var v of vals) {
+ var i = Uint32x4(...v);
+ assertEqX4(Int32x4.fromUint32x4Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Int32x4.fromUint32x4Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
function testInt8x16FromFloat32x4Bits() {
function expected(v, Buffer) {
var f32 = new Float32Array(new Buffer(16));
var i8 = new Int8Array(f32.buffer);
var asArr = simdToArray(v);
for (var i = 0; i < 4; i++) f32[i] = asArr[i];
return [i8[0], i8[1], i8[2], i8[3], i8[4], i8[5], i8[6], i8[7],
i8[8], i8[9], i8[10], i8[11], i8[12], i8[13], i8[14], i8[15]];
@@ -314,16 +579,36 @@ function testInt8x16FromFloat64x2Bits()
for (var v of vals) {
var f = Float64x2(...v);
assertEqX16(Int8x16.fromFloat64x2Bits(f), expected(f, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX16(Int8x16.fromFloat64x2Bits(f), expected(f, SharedArrayBuffer));
}
}
+function testInt8x16FromUint8x16Bits() {
+ function expected(v, Buffer) {
+ var u8 = new Uint8Array(new Buffer(16));
+ var i8 = new Int8Array(u8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) u8[i] = asArr[i];
+ return [i8[0], i8[1], i8[2], i8[3], i8[4], i8[5], i8[6], i8[7],
+ i8[8], i8[9], i8[10], i8[11], i8[12], i8[13], i8[14], i8[15]];
+ }
+
+ var vals = [[0, 1, -2, 3, -4, 5, INT8_MIN, UINT8_MAX, -6, 7, -8, 9, -10, 11, -12, 13]];
+
+ for (var v of vals) {
+ var i = Uint8x16(...v);
+ assertEqX16(Int8x16.fromUint8x16Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Int8x16.fromUint8x16Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
function testInt8x16FromInt16x8Bits() {
function expected(v, Buffer) {
var i16 = new Int16Array(new Buffer(16));
var i8 = new Int8Array(i16.buffer);
var asArr = simdToArray(v);
for (var i = 0; i < 8; i++) i16[i] = asArr[i];
return [i8[0], i8[1], i8[2], i8[3], i8[4], i8[5], i8[6], i8[7],
i8[8], i8[9], i8[10], i8[11], i8[12], i8[13], i8[14], i8[15]];
@@ -333,16 +618,35 @@ function testInt8x16FromInt16x8Bits() {
for (var v of vals) {
var i = Int16x8(...v);
assertEqX16(Int8x16.fromInt16x8Bits(i), expected(i, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX16(Int8x16.fromInt16x8Bits(i), expected(i, SharedArrayBuffer));
}
}
+function testInt8x16FromUint16x8Bits() {
+ function expected(v, Buffer) {
+ var u16 = new Uint16Array(new Buffer(16));
+ var i8 = new Int8Array(u16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) u16[i] = asArr[i];
+ return [i8[0], i8[1], i8[2], i8[3], i8[4], i8[5], i8[6], i8[7],
+ i8[8], i8[9], i8[10], i8[11], i8[12], i8[13], i8[14], i8[15]];
+ }
+
+ var vals = [[0, 1, -2, UINT16_MAX, INT8_MIN, INT8_MAX, INT16_MIN, INT16_MAX]];
+ for (var v of vals) {
+ var i = Uint16x8(...v);
+ assertEqX16(Int8x16.fromUint16x8Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Int8x16.fromUint16x8Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
function testInt8x16FromInt32x4Bits() {
function expected(v, Buffer) {
var i32 = new Int32Array(new Buffer(16));
var i8 = new Int8Array(i32.buffer);
var asArr = simdToArray(v);
for (var i = 0; i < 4; i++) i32[i] = asArr[i];
return [i8[0], i8[1], i8[2], i8[3], i8[4], i8[5], i8[6], i8[7],
i8[8], i8[9], i8[10], i8[11], i8[12], i8[13], i8[14], i8[15]];
@@ -352,16 +656,35 @@ function testInt8x16FromInt32x4Bits() {
for (var v of vals) {
var i = Int32x4(...v);
assertEqX16(Int8x16.fromInt32x4Bits(i), expected(i, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX16(Int8x16.fromInt32x4Bits(i), expected(i, SharedArrayBuffer));
}
}
+function testInt8x16FromUint32x4Bits() {
+ function expected(v, Buffer) {
+ var u32 = new Uint32Array(new Buffer(16));
+ var i8 = new Int8Array(u32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 4; i++) u32[i] = asArr[i];
+ return [i8[0], i8[1], i8[2], i8[3], i8[4], i8[5], i8[6], i8[7],
+ i8[8], i8[9], i8[10], i8[11], i8[12], i8[13], i8[14], i8[15]];
+ }
+
+ var vals = [[0, 1, -2, 3], [INT8_MIN, INT8_MAX, INT32_MIN, INT32_MAX]];
+ for (var v of vals) {
+ var i = Uint32x4(...v);
+ assertEqX16(Int8x16.fromUint32x4Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Int8x16.fromUint32x4Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
function testInt16x8FromFloat32x4Bits() {
function expected(v, Buffer) {
var f32 = new Float32Array(new Buffer(16));
var i16 = new Int16Array(f32.buffer);
var asArr = simdToArray(v);
for (var i = 0; i < 4; i++) f32[i] = asArr[i];
return [i16[0], i16[1], i16[2], i16[3], i16[4], i16[5], i16[6], i16[7]];
}
@@ -409,16 +732,55 @@ function testInt16x8FromInt8x16Bits() {
for (var v of vals) {
var i = Int8x16(...v);
assertEqX8(Int16x8.fromInt8x16Bits(i), expected(i, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX8(Int16x8.fromInt8x16Bits(i), expected(i, SharedArrayBuffer));
}
}
+function testInt16x8FromUint8x16Bits() {
+ function expected(v, Buffer) {
+ var u8 = new Uint8Array(new Buffer(16));
+ var i16 = new Int16Array(u8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) u8[i] = asArr[i];
+ return [i16[0], i16[1], i16[2], i16[3], i16[4], i16[5], i16[6], i16[7]];
+ }
+
+ var vals = [[0, 1, -2, 3, -4, UINT8_MAX, INT8_MIN, INT8_MAX, -6, 7, -8, 9, -10, 11, -12, 13]];
+
+ for (var v of vals) {
+ var i = Uint8x16(...v);
+ assertEqX8(Int16x8.fromUint8x16Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Int16x8.fromUint8x16Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testInt16x8FromUint16x8Bits() {
+ function expected(v, Buffer) {
+ var u16 = new Uint16Array(new Buffer(16));
+ var i16 = new Int16Array(u16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) u16[i] = asArr[i];
+ return [i16[0], i16[1], i16[2], i16[3], i16[4], i16[5], i16[6], i16[7]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8],
+ [0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX]];
+
+ for (var v of vals) {
+ var i = Uint16x8(...v);
+ assertEqX8(Int16x8.fromUint16x8Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Int16x8.fromUint16x8Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
function testInt16x8FromInt32x4Bits() {
function expected(v, Buffer) {
var i32 = new Int32Array(new Buffer(16));
var i16 = new Int16Array(i32.buffer);
var asArr = simdToArray(v);
for (var i = 0; i < 4; i++) i32[i] = asArr[i];
return [i16[0], i16[1], i16[2], i16[3], i16[4], i16[5], i16[6], i16[7]];
}
@@ -428,42 +790,472 @@ function testInt16x8FromInt32x4Bits() {
for (var v of vals) {
var i = Int32x4(...v);
assertEqX8(Int16x8.fromInt32x4Bits(i), expected(i, ArrayBuffer));
if (typeof SharedArrayBuffer != "undefined")
assertEqX8(Int16x8.fromInt32x4Bits(i), expected(i, SharedArrayBuffer));
}
}
+function testInt16x8FromUint32x4Bits() {
+ function expected(v, Buffer) {
+ var u32 = new Uint32Array(new Buffer(16));
+ var i16 = new Int16Array(u32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 4; i++) u32[i] = asArr[i];
+ return [i16[0], i16[1], i16[2], i16[3], i16[4], i16[5], i16[6], i16[7]];
+ }
+
+ var vals = [[1, -2, -3, 4], [INT16_MAX, INT16_MIN, INT32_MAX, INT32_MIN]];
+
+ for (var v of vals) {
+ var i = Uint32x4(...v);
+ assertEqX8(Int16x8.fromUint32x4Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Int16x8.fromUint32x4Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint32x4FromInt8x16Bits() {
+ function expected(v, Buffer) {
+ var i8 = new Int8Array(new Buffer(16));
+ var u32 = new Uint32Array(i8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) i8[i] = asArr[i];
+ return [u32[0], u32[1], u32[2], u32[3]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+ [INT8_MIN, INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, INT8_MAX,
+ INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN]];
+
+ for (var v of vals) {
+ var i = Int8x16(...v);
+ assertEqX4(Uint32x4.fromInt8x16Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Uint32x4.fromInt8x16Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint32x4FromUint8x16Bits() {
+ function expected(v, Buffer) {
+ var u8 = new Uint8Array(new Buffer(16));
+ var u32 = new Uint32Array(u8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) u8[i] = asArr[i];
+ return [u32[0], u32[1], u32[2], u32[3]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+ [0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX,
+ UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0, UINT8_MAX, 0]];
+
+ for (var v of vals) {
+ var i = Uint8x16(...v);
+ assertEqX4(Uint32x4.fromUint8x16Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Uint32x4.fromUint8x16Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint32x4FromInt16x8Bits() {
+ function expected(v, Buffer) {
+ var i16 = new Int16Array(new Buffer(16));
+ var u32 = new Uint32Array(i16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) i16[i] = asArr[i];
+ return [u32[0], u32[1], u32[2], u32[3]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8],
+ [INT16_MIN, INT16_MAX, INT16_MIN, INT16_MAX, INT16_MIN, INT16_MAX, INT16_MIN, INT16_MAX]];
+
+ for (var v of vals) {
+ var i = Int16x8(...v);
+ assertEqX4(Uint32x4.fromInt16x8Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Uint32x4.fromInt16x8Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint32x4FromUint16x8Bits() {
+ function expected(v, Buffer) {
+ var u16 = new Uint16Array(new Buffer(16));
+ var u32 = new Uint32Array(u16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) u16[i] = asArr[i];
+ return [u32[0], u32[1], u32[2], u32[3]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8],
+ [0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX]];
+
+ for (var v of vals) {
+ var i = Uint16x8(...v);
+ assertEqX4(Uint32x4.fromUint16x8Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Uint32x4.fromUint16x8Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint32x4FromInt32x4Bits() {
+ function expected(v, Buffer) {
+ var i32 = new Int32Array(new Buffer(16));
+ var u32 = new Uint32Array(i32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) i32[i] = asArr[i];
+ return [u32[0], u32[1], u32[2], u32[3]];
+ }
+
+ var vals = [[0, 1, -2, 3], [INT8_MIN, UINT32_MAX, INT32_MIN, INT32_MAX]];
+
+ for (var v of vals) {
+ var i = Int32x4(...v);
+ assertEqX4(Uint32x4.fromInt32x4Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX4(Uint32x4.fromInt32x4Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint8x16FromFloat32x4Bits() {
+ function expected(v, Buffer) {
+ var f32 = new Float32Array(new Buffer(16));
+ var u8 = new Uint8Array(f32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 4; i++) f32[i] = asArr[i];
+ return [u8[0], u8[1], u8[2], u8[3], u8[4], u8[5], u8[6], u8[7],
+ u8[8], u8[9], u8[10], u8[11], u8[12], u8[13], u8[14], u8[15]];
+ }
+
+ var vals = [[1, -2, 3, -4], [Infinity, -Infinity, NaN, -0]];
+
+ for (var v of vals) {
+ var f = Float32x4(...v);
+ assertEqX16(Uint8x16.fromFloat32x4Bits(f), expected(f, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Uint8x16.fromFloat32x4Bits(f), expected(f, SharedArrayBuffer));
+ }
+}
+
+function testUint8x16FromFloat64x2Bits() {
+ function expected(v, Buffer) {
+ var f64 = new Float64Array(new Buffer(16));
+ var u8 = new Uint8Array(f64.buffer);
+ f64[0] = Float64x2.extractLane(v, 0);
+ f64[1] = Float64x2.extractLane(v, 1);
+ return [u8[0], u8[1], u8[2], u8[3], u8[4], u8[5], u8[6], u8[7],
+ u8[8], u8[9], u8[10], u8[11], u8[12], u8[13], u8[14], u8[15]];
+ }
+ var vals = [[1, -2], [-3, 4], [Infinity, -Infinity], [NaN, -0]];
+
+ for (var v of vals) {
+ var f = Float64x2(...v);
+ assertEqX16(Uint8x16.fromFloat64x2Bits(f), expected(f, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Uint8x16.fromFloat64x2Bits(f), expected(f, SharedArrayBuffer));
+ }
+}
+
+function testUint8x16FromInt8x16Bits() {
+ function expected(v, Buffer) {
+ var i8 = new Int8Array(new Buffer(16));
+ var u8 = new Uint8Array(i8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) i8[i] = asArr[i];
+ return [u8[0], u8[1], u8[2], u8[3], u8[4], u8[5], u8[6], u8[7],
+ u8[8], u8[9], u8[10], u8[11], u8[12], u8[13], u8[14], u8[15]];
+ }
+
+ var vals = [[0, 1, -2, 3, -4, 5, INT8_MIN, UINT8_MAX, -6, 7, INT8_MAX, 9, -10, 11, -12, 13]];
+
+ for (var v of vals) {
+ var i = Int8x16(...v);
+ assertEqX16(Uint8x16.fromInt8x16Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Uint8x16.fromInt8x16Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint8x16FromInt16x8Bits() {
+ function expected(v, Buffer) {
+ var i16 = new Int16Array(new Buffer(16));
+ var u8 = new Uint8Array(i16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) i16[i] = asArr[i];
+ return [u8[0], u8[1], u8[2], u8[3], u8[4], u8[5], u8[6], u8[7],
+ u8[8], u8[9], u8[10], u8[11], u8[12], u8[13], u8[14], u8[15]];
+ }
+
+ var vals = [[0, 1, -2, 3, INT8_MIN, INT8_MAX, INT16_MIN, INT16_MAX]];
+ for (var v of vals) {
+ var i = Int16x8(...v);
+ assertEqX16(Uint8x16.fromInt16x8Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Uint8x16.fromInt16x8Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint8x16FromUint16x8Bits() {
+ function expected(v, Buffer) {
+ var u16 = new Uint16Array(new Buffer(16));
+ var u8 = new Uint8Array(u16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) u16[i] = asArr[i];
+ return [u8[0], u8[1], u8[2], u8[3], u8[4], u8[5], u8[6], u8[7],
+ u8[8], u8[9], u8[10], u8[11], u8[12], u8[13], u8[14], u8[15]];
+ }
+
+ var vals = [[0, 1, -2, UINT16_MAX, INT8_MIN, INT8_MAX, INT16_MIN, INT16_MAX]];
+ for (var v of vals) {
+ var i = Uint16x8(...v);
+ assertEqX16(Uint8x16.fromUint16x8Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Uint8x16.fromUint16x8Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint8x16FromInt32x4Bits() {
+ function expected(v, Buffer) {
+ var i32 = new Int32Array(new Buffer(16));
+ var u8 = new Uint8Array(i32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 4; i++) i32[i] = asArr[i];
+ return [u8[0], u8[1], u8[2], u8[3], u8[4], u8[5], u8[6], u8[7],
+ u8[8], u8[9], u8[10], u8[11], u8[12], u8[13], u8[14], u8[15]];
+ }
+
+ var vals = [[0, 1, -2, 3], [INT8_MIN, INT8_MAX, INT32_MIN, INT32_MAX]];
+ for (var v of vals) {
+ var i = Int32x4(...v);
+ assertEqX16(Uint8x16.fromInt32x4Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Uint8x16.fromInt32x4Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint8x16FromUint32x4Bits() {
+ function expected(v, Buffer) {
+ var u32 = new Uint32Array(new Buffer(16));
+ var u8 = new Uint8Array(u32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 4; i++) u32[i] = asArr[i];
+ return [u8[0], u8[1], u8[2], u8[3], u8[4], u8[5], u8[6], u8[7],
+ u8[8], u8[9], u8[10], u8[11], u8[12], u8[13], u8[14], u8[15]];
+ }
+
+ var vals = [[0, 1, -2, 3], [INT8_MIN, INT8_MAX, INT32_MIN, INT32_MAX]];
+ for (var v of vals) {
+ var i = Uint32x4(...v);
+ assertEqX16(Uint8x16.fromUint32x4Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX16(Uint8x16.fromUint32x4Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint16x8FromFloat32x4Bits() {
+ function expected(v, Buffer) {
+ var f32 = new Float32Array(new Buffer(16));
+ var u16 = new Uint16Array(f32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 4; i++) f32[i] = asArr[i];
+ return [u16[0], u16[1], u16[2], u16[3], u16[4], u16[5], u16[6], u16[7]];
+ }
+
+ var vals = [[1, -2, 3, -4], [Infinity, -Infinity, NaN, -0]];
+
+ for (var v of vals) {
+ var f = Float32x4(...v);
+ assertEqX8(Uint16x8.fromFloat32x4Bits(f), expected(f, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Uint16x8.fromFloat32x4Bits(f), expected(f, SharedArrayBuffer));
+ }
+}
+
+function testUint16x8FromFloat64x2Bits() {
+ function expected(v, Buffer) {
+ var f64 = new Float64Array(new Buffer(16));
+ var u16 = new Uint16Array(f64.buffer);
+ f64[0] = Float64x2.extractLane(v, 0);
+ f64[1] = Float64x2.extractLane(v, 1);
+ return [u16[0], u16[1], u16[2], u16[3], u16[4], u16[5], u16[6], u16[7]];
+ }
+
+ var vals = [[1, -2], [-3, 4], [Infinity, -Infinity], [NaN, -0]];
+
+ for (var v of vals) {
+ var f = Float64x2(...v);
+ assertEqX8(Uint16x8.fromFloat64x2Bits(f), expected(f, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Uint16x8.fromFloat64x2Bits(f), expected(f, SharedArrayBuffer));
+ }
+}
+
+function testUint16x8FromInt8x16Bits() {
+ function expected(v, Buffer) {
+ var i8 = new Int8Array(new Buffer(16));
+ var u16 = new Uint16Array(i8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) i8[i] = asArr[i];
+ return [u16[0], u16[1], u16[2], u16[3], u16[4], u16[5], u16[6], u16[7]];
+ }
+
+ var vals = [[0, 1, -2, 3, -4, 5, INT8_MIN, INT8_MAX, -6, 7, -8, 9, -10, 11, -12, 13]];
+
+ for (var v of vals) {
+ var i = Int8x16(...v);
+ assertEqX8(Uint16x8.fromInt8x16Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Uint16x8.fromInt8x16Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint16x8FromUint8x16Bits() {
+ function expected(v, Buffer) {
+ var u8 = new Uint8Array(new Buffer(16));
+ var u16 = new Uint16Array(u8.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 16; i++) u8[i] = asArr[i];
+ return [u16[0], u16[1], u16[2], u16[3], u16[4], u16[5], u16[6], u16[7]];
+ }
+
+ var vals = [[0, 1, -2, 3, -4, UINT8_MAX, INT8_MIN, INT8_MAX, -6, 7, -8, 9, -10, 11, -12, 13]];
+
+ for (var v of vals) {
+ var i = Uint8x16(...v);
+ assertEqX8(Uint16x8.fromUint8x16Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Uint16x8.fromUint8x16Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint16x8FromInt16x8Bits() {
+ function expected(v, Buffer) {
+ var i16 = new Int16Array(new Buffer(16));
+ var u16 = new Uint16Array(i16.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 8; i++) i16[i] = asArr[i];
+ return [u16[0], u16[1], u16[2], u16[3], u16[4], u16[5], u16[6], u16[7]];
+ }
+
+ var vals = [[1, 2, 3, 4, 5, 6, 7, 8],
+ [INT16_MIN, UINT16_MAX, INT16_MAX, UINT16_MAX, 0, UINT16_MAX, 0, UINT16_MAX]];
+
+ for (var v of vals) {
+ var i = Int16x8(...v);
+ assertEqX8(Uint16x8.fromInt16x8Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Uint16x8.fromInt16x8Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint16x8FromInt32x4Bits() {
+ function expected(v, Buffer) {
+ var i32 = new Int32Array(new Buffer(16));
+ var u16 = new Uint16Array(i32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 4; i++) i32[i] = asArr[i];
+ return [u16[0], u16[1], u16[2], u16[3], u16[4], u16[5], u16[6], u16[7]];
+ }
+
+ var vals = [[1, -2, -3, 4], [INT16_MAX, INT16_MIN, INT32_MAX, INT32_MIN]];
+
+ for (var v of vals) {
+ var i = Int32x4(...v);
+ assertEqX8(Uint16x8.fromInt32x4Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Uint16x8.fromInt32x4Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
+function testUint16x8FromUint32x4Bits() {
+ function expected(v, Buffer) {
+ var u32 = new Uint32Array(new Buffer(16));
+ var u16 = new Uint16Array(u32.buffer);
+ var asArr = simdToArray(v);
+ for (var i = 0; i < 4; i++) u32[i] = asArr[i];
+ return [u16[0], u16[1], u16[2], u16[3], u16[4], u16[5], u16[6], u16[7]];
+ }
+
+ var vals = [[1, -2, -3, 4], [INT16_MAX, INT16_MIN, INT32_MAX, INT32_MIN]];
+
+ for (var v of vals) {
+ var i = Uint32x4(...v);
+ assertEqX8(Uint16x8.fromUint32x4Bits(i), expected(i, ArrayBuffer));
+ if (typeof SharedArrayBuffer != "undefined")
+ assertEqX8(Uint16x8.fromUint32x4Bits(i), expected(i, SharedArrayBuffer));
+ }
+}
+
function test() {
testFloat32x4FromFloat64x2Bits();
testFloat32x4FromInt8x16Bits();
testFloat32x4FromInt16x8Bits();
testFloat32x4FromInt32x4();
testFloat32x4FromInt32x4Bits();
+ testFloat32x4FromUint8x16Bits();
+ testFloat32x4FromUint16x8Bits();
+ testFloat32x4FromUint32x4();
+ testFloat32x4FromUint32x4Bits();
testFloat64x2FromFloat32x4Bits();
testFloat64x2FromInt8x16Bits();
testFloat64x2FromInt16x8Bits();
testFloat64x2FromInt32x4Bits();
+ testFloat64x2FromUint8x16Bits();
+ testFloat64x2FromUint16x8Bits();
+ testFloat64x2FromUint32x4Bits();
testInt8x16FromFloat32x4Bits();
testInt8x16FromFloat64x2Bits();
testInt8x16FromInt16x8Bits();
testInt8x16FromInt32x4Bits();
+ testInt8x16FromUint8x16Bits();
+ testInt8x16FromUint16x8Bits();
+ testInt8x16FromUint32x4Bits();
testInt16x8FromFloat32x4Bits();
testInt16x8FromFloat64x2Bits();
testInt16x8FromInt8x16Bits();
testInt16x8FromInt32x4Bits();
+ testInt16x8FromUint8x16Bits();
+ testInt16x8FromUint16x8Bits();
+ testInt16x8FromUint32x4Bits();
testInt32x4FromFloat32x4();
testInt32x4FromFloat32x4Bits();
testInt32x4FromFloat64x2Bits();
testInt32x4FromInt8x16Bits();
testInt32x4FromInt16x8Bits();
+ testInt32x4FromUint8x16Bits();
+ testInt32x4FromUint16x8Bits();
+ testInt32x4FromUint32x4Bits();
+
+ testUint8x16FromFloat32x4Bits();
+ testUint8x16FromFloat64x2Bits();
+ testUint8x16FromInt8x16Bits();
+ testUint8x16FromInt16x8Bits();
+ testUint8x16FromInt32x4Bits();
+ testUint8x16FromUint16x8Bits();
+ testUint8x16FromUint32x4Bits();
+
+ testUint16x8FromFloat32x4Bits();
+ testUint16x8FromFloat64x2Bits();
+ testUint16x8FromInt8x16Bits();
+ testUint16x8FromInt16x8Bits();
+ testUint16x8FromInt32x4Bits();
+ testUint16x8FromUint8x16Bits();
+ testUint16x8FromUint32x4Bits();
+
+ testUint32x4FromFloat32x4();
+ testUint32x4FromFloat32x4Bits();
+ testUint32x4FromFloat64x2Bits();
+ testUint32x4FromInt8x16Bits();
+ testUint32x4FromInt16x8Bits();
+ testUint32x4FromInt32x4Bits();
+ testUint32x4FromUint8x16Bits();
+ testUint32x4FromUint16x8Bits();
if (typeof reportCompare === "function") {
reportCompare(true, true);
}
}
test();
--- a/js/src/tests/ecma_7/SIMD/load.js
+++ b/js/src/tests/ecma_7/SIMD/load.js
@@ -29,16 +29,28 @@ function MakeComparator(kind, arr, share
case 'Int16x8':
sizeOfLaneElem = 2;
typedArrayCtor = Int16Array;
break;
case 'Int32x4':
sizeOfLaneElem = 4;
typedArrayCtor = Int32Array;
break;
+ case 'Uint8x16':
+ sizeOfLaneElem = 1;
+ typedArrayCtor = Uint8Array;
+ break;
+ case 'Uint16x8':
+ sizeOfLaneElem = 2;
+ typedArrayCtor = Uint16Array;
+ break;
+ case 'Uint32x4':
+ sizeOfLaneElem = 4;
+ typedArrayCtor = Uint32Array;
+ break;
case 'Float32x4':
sizeOfLaneElem = 4;
typedArrayCtor = Float32Array;
break;
case 'Float64x2':
sizeOfLaneElem = 8;
typedArrayCtor = Float64Array;
break;
@@ -188,45 +200,52 @@ function testSharedArrayBufferCompat() {
new Uint16Array(TA.buffer),
new Int16Array(TA.buffer),
new Uint32Array(TA.buffer),
new Int32Array(TA.buffer),
new Float32Array(TA.buffer),
new Float64Array(TA.buffer)
])
{
- for (var kind of ['Int32x4', 'Float32x4', 'Float64x2']) {
+ for (var kind of ['Int32x4', 'Uint32x4', 'Float32x4', 'Float64x2']) {
var comp = MakeComparator(kind, ta);
comp.load(0);
comp.load1(0);
comp.load2(0);
comp.load3(0);
comp.load(3);
comp.load1(3);
comp.load2(3);
comp.load3(3);
}
assertThrowsInstanceOf(() => SIMD.Int32x4.load(ta, 1024), RangeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.load(ta, 1024), RangeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.load(ta, 1024), RangeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.load(ta, 1024), RangeError);
}
}
testLoad('Float32x4', new Float32Array(SIZE_32_ARRAY));
testLoad('Float64x2', new Float64Array(SIZE_64_ARRAY));
testLoad('Int8x16', new Int8Array(SIZE_8_ARRAY));
testLoad('Int16x8', new Int16Array(SIZE_16_ARRAY));
testLoad('Int32x4', new Int32Array(SIZE_32_ARRAY));
+testLoad('Uint8x16', new Uint8Array(SIZE_8_ARRAY));
+testLoad('Uint16x8', new Uint16Array(SIZE_16_ARRAY));
+testLoad('Uint32x4', new Uint32Array(SIZE_32_ARRAY));
if (typeof SharedArrayBuffer != "undefined") {
testLoad('Float32x4', new Float32Array(new SharedArrayBuffer(SIZE_8_ARRAY)));
testLoad('Float64x2', new Float64Array(new SharedArrayBuffer(SIZE_8_ARRAY)));
testLoad('Int8x16', new Int8Array(new SharedArrayBuffer(SIZE_8_ARRAY)));
testLoad('Int16x8', new Int16Array(new SharedArrayBuffer(SIZE_8_ARRAY)));
testLoad('Int32x4', new Int32Array(new SharedArrayBuffer(SIZE_8_ARRAY)));
+ testLoad('Uint8x16', new Uint8Array(new SharedArrayBuffer(SIZE_8_ARRAY)));
+ testLoad('Uint16x8', new Uint16Array(new SharedArrayBuffer(SIZE_8_ARRAY)));
+ testLoad('Uint32x4', new Uint32Array(new SharedArrayBuffer(SIZE_8_ARRAY)));
}
testSharedArrayBufferCompat();
if (typeof reportCompare === "function")
reportCompare(true, true);
--- a/js/src/tests/ecma_7/SIMD/replaceLane.js
+++ b/js/src/tests/ecma_7/SIMD/replaceLane.js
@@ -1,14 +1,17 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
var Float32x4 = SIMD.Float32x4;
+var Float64x2 = SIMD.Float64x2;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
-var Float64x2 = SIMD.Float64x2;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
var Bool8x16 = SIMD.Bool8x16;
var Bool16x8 = SIMD.Bool16x8;
var Bool32x4 = SIMD.Bool32x4;
var Bool64x2 = SIMD.Bool64x2;
function replaceLaneN(laneIndex, arr, value) {
var copy = arr.slice();
assertEq(laneIndex <= arr.length, true);
@@ -130,16 +133,49 @@ function test() {
var v = Int32x4inputs[1][0];
assertEqX4(Int32x4.replaceLane(v, 0), replaceLane0(simdToArray(v), 0));
assertEqX4(Int32x4.replaceLane(v, 0, good), replaceLane0(simdToArray(v), good | 0));
assertThrowsInstanceOf(() => Int32x4.replaceLane(v, 0, bad), TestError);
assertThrowsInstanceOf(() => Int32x4.replaceLane(v, 4, good), TypeError);
assertThrowsInstanceOf(() => Int32x4.replaceLane(v, 1.1, good), TypeError);
+ var Uint8x16inputs = [[Uint8x16(0, 1, 2, 3, 4, 5, 6, 7, -1, -2, -3, -4, -5, -6, INT8_MIN, UINT8_MAX), 17]];
+ testType('Uint8x16', Uint8x16inputs);
+
+ var v = Uint8x16inputs[0][0];
+ assertEqX16(Uint8x16.replaceLane(v, 0), replaceLane0(simdToArray(v), 0));
+ assertEqX16(Uint8x16.replaceLane(v, 0, good), replaceLane0(simdToArray(v), good | 0));
+ assertThrowsInstanceOf(() => Uint8x16.replaceLane(v, 0, bad), TestError);
+ assertThrowsInstanceOf(() => Uint8x16.replaceLane(v, 16, good), TypeError);
+ assertThrowsInstanceOf(() => Uint8x16.replaceLane(v, 1.1, good), TypeError);
+
+ var Uint16x8inputs = [[Uint16x8(0, 1, 2, 3, -1, -2, INT16_MIN, UINT16_MAX), 9]];
+ testType('Uint16x8', Uint16x8inputs);
+
+ var v = Uint16x8inputs[0][0];
+ assertEqX8(Uint16x8.replaceLane(v, 0), replaceLane0(simdToArray(v), 0));
+ assertEqX8(Uint16x8.replaceLane(v, 0, good), replaceLane0(simdToArray(v), good | 0));
+ assertThrowsInstanceOf(() => Uint16x8.replaceLane(v, 0, bad), TestError);
+ assertThrowsInstanceOf(() => Uint16x8.replaceLane(v, 8, good), TypeError);
+ assertThrowsInstanceOf(() => Uint16x8.replaceLane(v, 1.1, good), TypeError);
+
+ var Uint32x4inputs = [
+ [Uint32x4(1, 2, 3, 4), 5],
+ [Uint32x4(INT32_MIN, UINT32_MAX, INT32_MAX, 4), UINT32_MAX],
+ ];
+ testType('Uint32x4', Uint32x4inputs);
+
+ var v = Uint32x4inputs[1][0];
+ assertEqX4(Uint32x4.replaceLane(v, 0), replaceLane0(simdToArray(v), 0));
+ assertEqX4(Uint32x4.replaceLane(v, 0, good), replaceLane0(simdToArray(v), good | 0));
+ assertThrowsInstanceOf(() => Uint32x4.replaceLane(v, 0, bad), TestError);
+ assertThrowsInstanceOf(() => Uint32x4.replaceLane(v, 4, good), TypeError);
+ assertThrowsInstanceOf(() => Uint32x4.replaceLane(v, 1.1, good), TypeError);
+
var Bool64x2inputs = [
[Bool64x2(true, true), false],
];
testType('Bool64x2', Bool64x2inputs);
var v = Bool64x2inputs[0][0];
assertEqX2(Bool64x2.replaceLane(v, 0), replaceLane0(simdToArray(v), false));
assertEqX2(Bool64x2.replaceLane(v, 0, true), replaceLane0(simdToArray(v), true));
--- a/js/src/tests/ecma_7/SIMD/select-bitselect.js
+++ b/js/src/tests/ecma_7/SIMD/select-bitselect.js
@@ -5,16 +5,19 @@
* https://creativecommons.org/publicdomain/zero/1.0/
*/
var Float32x4 = SIMD.Float32x4;
var Float64x2 = SIMD.Float64x2;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
var Bool8x16 = SIMD.Bool8x16;
var Bool16x8 = SIMD.Bool16x8;
var Bool32x4 = SIMD.Bool32x4;
var Bool64x2 = SIMD.Bool64x2;
function getMask(i, maskLength) {
var args = [];
for (var j = 0; j < maskLength; j++)
@@ -77,16 +80,39 @@ function test() {
inputs = [
[Int32x4(0,4,9,16), Int32x4(1,2,3,4)],
[Int32x4(-1, 2, INT32_MAX, INT32_MIN), Int32x4(INT32_MAX, -4, INT32_MIN, 42)]
];
testSelect(Int32x4, inputs);
inputs = [
+ [Uint8x16(0,4,9,16,25,36,49,64,81,121,-4,-9,-16,-25,-36,-49), Uint8x16(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16)],
+ [Uint8x16(-1, 2, INT8_MAX, INT8_MIN, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
+ Uint8x16(INT8_MAX, -4, INT8_MIN, 42, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)]
+ ];
+
+ testSelect(Uint8x16, inputs);
+
+ inputs = [
+ [Uint16x8(0,4,9,16,25,36,49,64), Uint16x8(1,2,3,4,5,6,7,8)],
+ [Uint16x8(-1, 2, INT16_MAX, INT16_MIN, 5, 6, 7, 8),
+ Uint16x8(INT16_MAX, -4, INT16_MIN, 42, 5, 6, 7, 8)]
+ ];
+
+ testSelect(Uint16x8, inputs);
+
+ inputs = [
+ [Uint32x4(0,4,9,16), Uint32x4(1,2,3,4)],
+ [Uint32x4(-1, 2, INT32_MAX, INT32_MIN), Uint32x4(INT32_MAX, -4, INT32_MIN, 42)]
+ ];
+
+ testSelect(Uint32x4, inputs);
+
+ inputs = [
[Float32x4(0.125,4.25,9.75,16.125), Float32x4(1.5,2.75,3.25,4.5)],
[Float32x4(-1.5,-0,NaN,-Infinity), Float32x4(1,-2,13.37,3.13)],
[Float32x4(1.5,2.75,NaN,Infinity), Float32x4(-NaN,-Infinity,9.75,16.125)]
];
testSelect(Float32x4, inputs);
inputs = [
--- a/js/src/tests/ecma_7/SIMD/shell.js
+++ b/js/src/tests/ecma_7/SIMD/shell.js
@@ -29,16 +29,19 @@ function makeDouble(sign, exp, mantissa)
return f64[0];
}
function GetType(v) {
switch (Object.getPrototypeOf(v)) {
case SIMD.Int8x16.prototype: return SIMD.Int8x16;
case SIMD.Int16x8.prototype: return SIMD.Int16x8;
case SIMD.Int32x4.prototype: return SIMD.Int32x4;
+ case SIMD.Uint8x16.prototype: return SIMD.Uint8x16;
+ case SIMD.Uint16x8.prototype: return SIMD.Uint16x8;
+ case SIMD.Uint32x4.prototype: return SIMD.Uint32x4;
case SIMD.Float32x4.prototype: return SIMD.Float32x4;
case SIMD.Float64x2.prototype: return SIMD.Float64x2;
case SIMD.Bool8x16.prototype: return SIMD.Bool8x16;
case SIMD.Bool16x8.prototype: return SIMD.Bool16x8;
case SIMD.Bool32x4.prototype: return SIMD.Bool32x4;
case SIMD.Bool64x2.prototype: return SIMD.Bool64x2;
}
}
@@ -75,16 +78,26 @@ function assertEqInt32x4(v, arr) {
for (var i = 0; i < 4; i++)
assertEq(SIMD.Int32x4.extractLane(v, i), arr[i]);
} catch (e) {
print("stack trace:", e.stack);
throw e;
}
}
+function assertEqUint32x4(v, arr) {
+ try {
+ for (var i = 0; i < 4; i++)
+ assertEq(SIMD.Uint32x4.extractLane(v, i), arr[i]);
+ } catch (e) {
+ print("stack trace:", e.stack);
+ throw e;
+ }
+}
+
function assertEqFloat32x4(v, arr) {
try {
for (var i = 0; i < 4; i++)
assertEq(SIMD.Float32x4.extractLane(v, i), arr[i]);
} catch (e) {
print("stack trace:", e.stack);
throw e;
}
@@ -98,95 +111,121 @@ function assertEqBool32x4(v, arr) {
print("stack trace:", e.stack);
throw e;
}
}
function assertEqX4(v, arr) {
var Type = GetType(v);
if (Type === SIMD.Int32x4) assertEqInt32x4(v, arr);
+ else if (Type === SIMD.Uint32x4) assertEqUint32x4(v, arr);
else if (Type === SIMD.Float32x4) assertEqFloat32x4(v, arr);
else if (Type === SIMD.Bool32x4) assertEqBool32x4(v, arr);
else throw new TypeError("Unknown SIMD kind.");
}
function assertEqInt16x8(v, arr) {
try {
for (var i = 0; i < 8; i++)
assertEq(SIMD.Int16x8.extractLane(v, i), arr[i]);
} catch (e) {
print("stack trace:", e.stack);
throw e;
}
}
+function assertEqUint16x8(v, arr) {
+ try {
+ for (var i = 0; i < 8; i++)
+ assertEq(SIMD.Uint16x8.extractLane(v, i), arr[i]);
+ } catch (e) {
+ print("stack trace:", e.stack);
+ throw e;
+ }
+}
+
function assertEqBool16x8(v, arr) {
try {
for (var i = 0; i < 8; i++){
assertEq(SIMD.Bool16x8.extractLane(v, i), arr[i]);
}
} catch (e) {
print("stack trace:", e.stack);
throw e;
}
}
function assertEqX8(v, arr) {
var Type = GetType(v);
if (Type === SIMD.Int16x8) assertEqInt16x8(v, arr);
+ else if (Type === SIMD.Uint16x8) assertEqUint16x8(v, arr);
else if (Type === SIMD.Bool16x8) assertEqBool16x8(v, arr);
else throw new TypeError("Unknown x8 vector.");
}
function assertEqInt8x16(v, arr) {
try {
for (var i = 0; i < 16; i++)
assertEq(SIMD.Int8x16.extractLane(v, i), arr[i]);
} catch (e) {
print("stack trace:", e.stack);
throw e;
}
}
+function assertEqUint8x16(v, arr) {
+ try {
+ for (var i = 0; i < 16; i++)
+ assertEq(SIMD.Uint8x16.extractLane(v, i), arr[i]);
+ } catch (e) {
+ print("stack trace:", e.stack);
+ throw e;
+ }
+}
+
function assertEqBool8x16(v, arr) {
try {
for (var i = 0; i < 16; i++)
assertEq(SIMD.Bool8x16.extractLane(v, i), arr[i]);
} catch (e) {
print("stack trace:", e.stack);
throw e;
}
}
function assertEqX16(v, arr) {
var Type = GetType(v);
if (Type === SIMD.Int8x16) assertEqInt8x16(v, arr);
+ else if (Type === SIMD.Uint8x16) assertEqUint8x16(v, arr);
else if (Type === SIMD.Bool8x16) assertEqBool8x16(v, arr);
else throw new TypeError("Unknown x16 vector.");
}
function simdLength(v) {
var pt = Object.getPrototypeOf(v);
- if (pt == SIMD.Int8x16.prototype || pt === SIMD.Bool8x16.prototype)
+ if (pt == SIMD.Int8x16.prototype || pt == SIMD.Uint8x16.prototype ||
+ pt === SIMD.Bool8x16.prototype)
return 16;
- if (pt == SIMD.Int16x8.prototype || pt === SIMD.Bool16x8.prototype)
+ if (pt == SIMD.Int16x8.prototype || pt == SIMD.Uint16x8.prototype ||
+ pt === SIMD.Bool16x8.prototype)
return 8;
- if (pt === SIMD.Int32x4.prototype || pt === SIMD.Float32x4.prototype || pt === SIMD.Bool32x4.prototype)
+ if (pt === SIMD.Int32x4.prototype || pt === SIMD.Uint32x4.prototype ||
+ pt === SIMD.Float32x4.prototype || pt === SIMD.Bool32x4.prototype)
return 4;
if (pt === SIMD.Float64x2.prototype || pt == SIMD.Bool64x2.prototype)
return 2;
throw new TypeError("Unknown SIMD kind.");
}
function simdLengthType(t) {
- if (t == SIMD.Int8x16 || t == SIMD.Bool8x16)
+ if (t == SIMD.Int8x16 || t == SIMD.Uint8x16 || t == SIMD.Bool8x16)
return 16;
- else if (t == SIMD.Int16x8 || t == SIMD.Bool16x8)
+ else if (t == SIMD.Int16x8 || t == SIMD.Uint16x8 || t == SIMD.Bool16x8)
return 8;
- else if (t == SIMD.Int32x4 || t == SIMD.Float32x4 || t == SIMD.Bool32x4)
+ else if (t == SIMD.Int32x4 || t == SIMD.Uint32x4 || t == SIMD.Float32x4 || t == SIMD.Bool32x4)
return 4;
else if (t == SIMD.Float64x2 || t == SIMD.Bool64x2)
return 2;
else
throw new TypeError("Unknown SIMD kind.");
}
function getAssertFuncFromLength(l) {
@@ -202,16 +241,19 @@ function getAssertFuncFromLength(l) {
throw new TypeError("Unknown SIMD kind.");
}
function assertEqVec(v, arr) {
var Type = GetType(v);
if (Type === SIMD.Int8x16) assertEqInt8x16(v, arr);
else if (Type === SIMD.Int16x8) assertEqInt16x8(v, arr);
else if (Type === SIMD.Int32x4) assertEqInt32x4(v, arr);
+ else if (Type === SIMD.Uint8x16) assertEqUint8x16(v, arr);
+ else if (Type === SIMD.Uint16x8) assertEqUint16x8(v, arr);
+ else if (Type === SIMD.Uint32x4) assertEqUint32x4(v, arr);
else if (Type === SIMD.Float32x4) assertEqFloat32x4(v, arr);
else if (Type === SIMD.Float64x2) assertEqFloat64x2(v, arr);
else if (Type === SIMD.Bool8x16) assertEqBool8x16(v, arr);
else if (Type === SIMD.Bool16x8) assertEqBool16x8(v, arr);
else if (Type === SIMD.Bool32x4) assertEqBool32x4(v, arr);
else if (Type === SIMD.Bool64x2) assertEqBool64x2(v, arr);
else throw new TypeError("Unknown SIMD Kind");
}
@@ -248,16 +290,28 @@ function simdToArray(v) {
if (Type === SIMD.Int16x8) {
return indexes(8).map((i) => SIMD.Int16x8.extractLane(v, i));
}
if (Type === SIMD.Int32x4) {
return indexes(4).map((i) => SIMD.Int32x4.extractLane(v, i));
}
+ if (Type === SIMD.Uint8x16) {
+ return indexes(16).map((i) => SIMD.Uint8x16.extractLane(v, i));
+ }
+
+ if (Type === SIMD.Uint16x8) {
+ return indexes(8).map((i) => SIMD.Uint16x8.extractLane(v, i));
+ }
+
+ if (Type === SIMD.Uint32x4) {
+ return indexes(4).map((i) => SIMD.Uint32x4.extractLane(v, i));
+ }
+
if (Type === SIMD.Float32x4) {
return indexes(4).map((i) => SIMD.Float32x4.extractLane(v, i));
}
if (Type === SIMD.Float64x2) {
return indexes(2).map((i) => SIMD.Float64x2.extractLane(v, i));
}
@@ -269,16 +323,20 @@ const INT8_MIN = -Math.pow(2, 7);
assertEq((INT8_MAX + 1) << 24 >> 24, INT8_MIN);
const INT16_MAX = Math.pow(2, 15) - 1;
const INT16_MIN = -Math.pow(2, 15);
assertEq((INT16_MAX + 1) << 16 >> 16, INT16_MIN);
const INT32_MAX = Math.pow(2, 31) - 1;
const INT32_MIN = -Math.pow(2, 31);
assertEq(INT32_MAX + 1 | 0, INT32_MIN);
+const UINT8_MAX = Math.pow(2, 8) - 1;
+const UINT16_MAX = Math.pow(2, 16) - 1;
+const UINT32_MAX = Math.pow(2, 32) - 1;
+
function testUnaryFunc(v, simdFunc, func) {
var varr = simdToArray(v);
var observed = simdToArray(simdFunc(v));
var expected = varr.map(function(v, i) { return func(varr[i]); });
for (var i = 0; i < observed.length; i++)
assertEq(observed[i], expected[i]);
--- a/js/src/tests/ecma_7/SIMD/splat.js
+++ b/js/src/tests/ecma_7/SIMD/splat.js
@@ -1,15 +1,18 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
var Float64x2 = SIMD.Float64x2;
var Float32x4 = SIMD.Float32x4;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
var Bool8x16 = SIMD.Bool8x16;
var Bool16x8 = SIMD.Bool16x8;
var Bool32x4 = SIMD.Bool32x4;
function TestSplatX16(type, inputs, coerceFunc) {
for (var x of inputs) {
assertEqX16(SIMD[type].splat(x), [x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x].map(coerceFunc));
}
@@ -46,16 +49,28 @@ function test() {
TestSplatX8('Int16x8', [0, 1, 2, -1, INT16_MIN, INT16_MAX, INT16_MIN - 1, INT16_MAX + 1], (x) => x << 16 >> 16);
assertEqX8(Int16x8.splat(), [0, 0, 0, 0, 0, 0, 0, 0]);
assertThrowsInstanceOf(() => SIMD.Int16x8.splat(bad), TestError);
TestSplatX4('Int32x4', [0, undefined, 3.5, 42, -1337, INT32_MAX, INT32_MAX + 1, good], (x) => x | 0);
assertEqX4(SIMD.Int32x4.splat(), [0, 0, 0, 0]);
assertThrowsInstanceOf(() => SIMD.Int32x4.splat(bad), TestError);
+ TestSplatX16('Uint8x16', [0, 1, 2, -1, -2, 3, -3, 4, -4, 5, -5, 6, INT8_MIN, INT8_MAX, INT8_MIN - 1, INT8_MAX + 1], (x) => x << 24 >>> 24);
+ assertEqX16(Uint8x16.splat(), [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.splat(bad), TestError);
+
+ TestSplatX8('Uint16x8', [0, 1, 2, -1, INT16_MIN, INT16_MAX, INT16_MIN - 1, INT16_MAX + 1], (x) => x << 16 >>> 16);
+ assertEqX8(Uint16x8.splat(), [0, 0, 0, 0, 0, 0, 0, 0]);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.splat(bad), TestError);
+
+ TestSplatX4('Uint32x4', [0, undefined, 3.5, 42, INT32_MAX, INT32_MIN, UINT32_MAX, UINT32_MAX + 1, good], (x) => x >>> 0);
+ assertEqX4(SIMD.Uint32x4.splat(), [0, 0, 0, 0]);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.splat(bad), TestError);
+
TestSplatX4('Float32x4', [0, undefined, 3.5, 42, -13.37, Infinity, NaN, -0, good], (x) => Math.fround(x));
assertEqX4(SIMD.Float32x4.splat(), [NaN, NaN, NaN, NaN]);
assertThrowsInstanceOf(() => SIMD.Float32x4.splat(bad), TestError);
TestSplatX2('Float64x2', [0, undefined, 3.5, 42, -13.37, Infinity, NaN, -0, good], (x) => +x);
assertEqX2(SIMD.Float64x2.splat(), [NaN, NaN]);
assertThrowsInstanceOf(() => SIMD.Float64x2.splat(bad), TestError);
--- a/js/src/tests/ecma_7/SIMD/store.js
+++ b/js/src/tests/ecma_7/SIMD/store.js
@@ -88,16 +88,58 @@ function testStoreInt32x4(Buffer) {
testStore(I32, 'Int32x4', 2, v);
testStore(I32, 'Int32x4', 12, v);
assertThrowsInstanceOf(() => SIMD.Int32x4.store(I32), TypeError);
assertThrowsInstanceOf(() => SIMD.Int32x4.store(I32, 0), TypeError);
assertThrowsInstanceOf(() => SIMD.Float32x4.store(I32, 0, v), TypeError);
}
+function testStoreUint8x16(Buffer) {
+ var I8 = new Uint8Array(new Buffer(32));
+
+ var v = SIMD.Uint8x16(0, 1, INT8_MAX, INT8_MIN, UINT8_MAX, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+ testStore(I8, 'Uint8x16', 0, v);
+ testStore(I8, 'Uint8x16', 1, v);
+ testStore(I8, 'Uint8x16', 2, v);
+ testStore(I8, 'Uint8x16', 16, v);
+
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.store(I8), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.store(I8, 0), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.store(I8, 0, v), TypeError);
+}
+
+function testStoreUint16x8(Buffer) {
+ var I16 = new Uint16Array(new Buffer(64));
+
+ var v = SIMD.Uint16x8(0, 1, INT16_MAX, INT16_MIN, 4, 5, 6, 7);
+ testStore(I16, 'Uint16x8', 0, v);
+ testStore(I16, 'Uint16x8', 1, v);
+ testStore(I16, 'Uint16x8', 2, v);
+ testStore(I16, 'Uint16x8', 24, v);
+
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.store(I16), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint16x8.store(I16, 0), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint8x16.store(I16, 0, v), TypeError);
+}
+
+function testStoreUint32x4(Buffer) {
+ var I32 = new Uint32Array(new Buffer(64));
+
+ var v = SIMD.Uint32x4(0, 1, Math.pow(2,31) - 1, -Math.pow(2, 31));
+ testStore(I32, 'Uint32x4', 0, v);
+ testStore(I32, 'Uint32x4', 1, v);
+ testStore(I32, 'Uint32x4', 2, v);
+ testStore(I32, 'Uint32x4', 12, v);
+
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.store(I32), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Uint32x4.store(I32, 0), TypeError);
+ assertThrowsInstanceOf(() => SIMD.Float32x4.store(I32, 0, v), TypeError);
+}
+
function testStoreFloat32x4(Buffer) {
var F32 = new Float32Array(new Buffer(64));
var v = SIMD.Float32x4(1,2,3,4);
testStore(F32, 'Float32x4', 0, v);
testStore(F32, 'Float32x4', 1, v);
testStore(F32, 'Float32x4', 2, v);
testStore(F32, 'Float32x4', 12, v);
@@ -143,16 +185,19 @@ function testSharedArrayBufferCompat() {
var I8 = new Int8Array(TA.buffer);
var I16 = new Int16Array(TA.buffer);
var F32 = new Float32Array(TA.buffer);
var F64 = new Float64Array(TA.buffer);
var Int8x16 = SIMD.Int8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
var Int16x8 = SIMD.Int16x8(1, 2, 3, 4, 5, 6, 7, 8);
var Int32x4 = SIMD.Int32x4(1, 2, 3, 4);
+ var Uint8x16 = SIMD.Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+ var Uint16x8 = SIMD.Uint16x8(1, 2, 3, 4, 5, 6, 7, 8);
+ var Uint32x4 = SIMD.Uint32x4(1, 2, 3, 4);
var Float32x4 = SIMD.Float32x4(1, 2, 3, 4);
var Float64x2 = SIMD.Float64x2(1, 2);
for (var ta of [
new Uint8Array(TA.buffer),
new Int8Array(TA.buffer),
new Uint16Array(TA.buffer),
new Int16Array(TA.buffer),
@@ -166,16 +211,25 @@ function testSharedArrayBufferCompat() {
for (var i = 0; i < 16; i++) assertEq(I8[i], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16][i]);
SIMD.Int16x8.store(ta, 0, Int16x8);
for (var i = 0; i < 8; i++) assertEq(I16[i], [1, 2, 3, 4, 5, 6, 7, 8][i]);
SIMD.Int32x4.store(ta, 0, Int32x4);
for (var i = 0; i < 4; i++) assertEq(I32[i], [1, 2, 3, 4][i]);
+ SIMD.Uint8x16.store(ta, 0, Uint8x16);
+ for (var i = 0; i < 16; i++) assertEq(I8[i], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16][i]);
+
+ SIMD.Uint16x8.store(ta, 0, Uint16x8);
+ for (var i = 0; i < 8; i++) assertEq(I16[i], [1, 2, 3, 4, 5, 6, 7, 8][i]);
+
+ SIMD.Uint32x4.store(ta, 0, Uint32x4);
+ for (var i = 0; i < 4; i++) assertEq(I32[i], [1, 2, 3, 4][i]);
+
SIMD.Float32x4.store(ta, 0, Float32x4);
for (var i = 0; i < 4; i++) assertEq(F32[i], [1, 2, 3, 4][i]);
SIMD.Float64x2.store(ta, 0, Float64x2);
for (var i = 0; i < 2; i++) assertEq(F64[i], [1, 2][i]);
assertThrowsInstanceOf(() => SIMD.Int8x16.store(ta, 1024, Int8x16), RangeError);
assertThrowsInstanceOf(() => SIMD.Int16x8.store(ta, 1024, Int16x8), RangeError);
@@ -183,22 +237,28 @@ function testSharedArrayBufferCompat() {
assertThrowsInstanceOf(() => SIMD.Float32x4.store(ta, 1024, Float32x4), RangeError);
assertThrowsInstanceOf(() => SIMD.Float64x2.store(ta, 1024, Float64x2), RangeError);
}
}
testStoreInt8x16(ArrayBuffer);
testStoreInt16x8(ArrayBuffer);
testStoreInt32x4(ArrayBuffer);
+testStoreUint8x16(ArrayBuffer);
+testStoreUint16x8(ArrayBuffer);
+testStoreUint32x4(ArrayBuffer);
testStoreFloat32x4(ArrayBuffer);
testStoreFloat64x2(ArrayBuffer);
if (typeof SharedArrayBuffer != "undefined") {
testStoreInt8x16(SharedArrayBuffer);
testStoreInt16x8(SharedArrayBuffer);
testStoreInt32x4(SharedArrayBuffer);
+ testStoreUint8x16(SharedArrayBuffer);
+ testStoreUint16x8(SharedArrayBuffer);
+ testStoreUint32x4(SharedArrayBuffer);
testStoreFloat32x4(SharedArrayBuffer);
testStoreFloat64x2(SharedArrayBuffer);
testSharedArrayBufferCompat();
}
if (typeof reportCompare === "function")
reportCompare(true, true);
--- a/js/src/tests/ecma_7/SIMD/swizzle-shuffle.js
+++ b/js/src/tests/ecma_7/SIMD/swizzle-shuffle.js
@@ -5,16 +5,19 @@
* https://creativecommons.org/publicdomain/zero/1.0/
*/
var Float32x4 = SIMD.Float32x4;
var Float64x2 = SIMD.Float64x2;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
function swizzle2(arr, x, y) {
return [arr[x], arr[y]];
}
function swizzle4(arr, x, y, z, w) {
return [arr[x], arr[y], arr[z], arr[w]];
}
@@ -27,21 +30,24 @@ function swizzle16(arr, s0, s1, s2, s3,
s8, s9, s10, s11, s12, s13, s14, s15) {
return [arr[s0], arr[s1], arr[s2], arr[s3], arr[s4], arr[s5], arr[s6], arr[s7],
arr[s8], arr[s9], arr[s10], arr[s11], arr[s12], arr[s13], arr[s14], arr[s15]];
}
function getNumberOfLanesFromType(type) {
switch (type) {
case Int8x16:
+ case Uint8x16:
return 16;
case Int16x8:
+ case Uint16x8:
return 8;
case Float32x4:
case Int32x4:
+ case Uint32x4:
return 4;
case Float64x2:
return 2;
}
throw new TypeError("Unknown SIMD type.");
}
function testSwizzleForType(type) {
@@ -178,16 +184,46 @@ function testSwizzleInt32x4() {
assertThrowsInstanceOf(function() {
Float32x4.swizzle(v, 0, 0, 0, 0);
}, TypeError);
testSwizzleForType(Int32x4);
}
+function testSwizzleUint8x16() {
+ var v = Uint16x8(1, 2, 3, 4, 5, 6, 7, 8);
+
+ assertThrowsInstanceOf(function() {
+ Uint8x16.swizzle(v, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ }, TypeError);
+
+ testSwizzleForType(Uint8x16);
+}
+
+function testSwizzleUint16x8() {
+ var v = Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+
+ assertThrowsInstanceOf(function() {
+ Uint16x8.swizzle(v, 0, 0, 0, 0, 0, 0, 0, 0);
+ }, TypeError);
+
+ testSwizzleForType(Uint16x8);
+}
+
+function testSwizzleUint32x4() {
+ var v = Uint32x4(1, 2, 3, 4);
+
+ assertThrowsInstanceOf(function() {
+ Float32x4.swizzle(v, 0, 0, 0, 0);
+ }, TypeError);
+
+ testSwizzleForType(Uint32x4);
+}
+
function testSwizzleFloat32x4() {
var v = Float32x4(1, 2, 3, 4);
assertThrowsInstanceOf(function() {
Int32x4.swizzle(v, 0, 0, 0, 0);
}, TypeError);
testSwizzleForType(Float32x4);
@@ -391,16 +427,46 @@ function testShuffleInt32x4() {
assertThrowsInstanceOf(function() {
Float32x4.shuffle(v, v, 0, 0, 0, 0);
}, TypeError);
testShuffleForType(Int32x4);
}
+function testShuffleUint8x16() {
+ var v = Uint16x8(1, 2, 3, 4, 5, 6, 7, 8);
+
+ assertThrowsInstanceOf(function() {
+ Uint8x16.shuffle(v, v, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ }, TypeError);
+
+ testShuffleForType(Uint8x16);
+}
+
+function testShuffleUint16x8() {
+ var v = Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+
+ assertThrowsInstanceOf(function() {
+ Uint16x8.shuffle(v, v, 0, 0, 0, 0, 0, 0, 0, 0);
+ }, TypeError);
+
+ testShuffleForType(Uint16x8);
+}
+
+function testShuffleUint32x4() {
+ var v = Uint32x4(1, 2, 3, 4);
+
+ assertThrowsInstanceOf(function() {
+ Float32x4.shuffle(v, v, 0, 0, 0, 0);
+ }, TypeError);
+
+ testShuffleForType(Uint32x4);
+}
+
function testShuffleFloat32x4() {
var v = Float32x4(1, 2, 3, 4);
assertThrowsInstanceOf(function() {
Int32x4.shuffle(v, v, 0, 0, 0, 0);
}, TypeError);
testShuffleForType(Float32x4);
@@ -414,18 +480,24 @@ function testShuffleFloat64x2() {
}, TypeError);
testShuffleForType(Float64x2);
}
testSwizzleInt8x16();
testSwizzleInt16x8();
testSwizzleInt32x4();
+testSwizzleUint8x16();
+testSwizzleUint16x8();
+testSwizzleUint32x4();
testSwizzleFloat32x4();
testSwizzleFloat64x2();
testShuffleInt8x16();
testShuffleInt16x8();
testShuffleInt32x4();
+testShuffleUint8x16();
+testShuffleUint16x8();
+testShuffleUint32x4();
testShuffleFloat32x4();
testShuffleFloat64x2();
if (typeof reportCompare === "function")
reportCompare(true, true);
--- a/js/src/tests/ecma_7/SIMD/typedobjects.js
+++ b/js/src/tests/ecma_7/SIMD/typedobjects.js
@@ -1,14 +1,17 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
var Float32x4 = SIMD.Float32x4;
var Float64x2 = SIMD.Float64x2;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
var Bool8x16 = SIMD.Bool8x16;
var Bool16x8 = SIMD.Bool16x8;
var Bool32x4 = SIMD.Bool32x4;
var Bool64x2 = SIMD.Bool64x2;
var {StructType, Handle} = TypedObject;
var {float32, float64, int8, int16, int32, uint8} = TypedObject;
@@ -463,16 +466,299 @@ function testInt32x4Setters() {
array[1] = [15, 16, 17, 18];
}, TypeError, "Setting Int32x4 from an array");
assertThrowsInstanceOf(function() {
array[1] = 22;
}, TypeError, "Setting Int32x4 from a number");
}
+function testUint8x16Alignment() {
+ assertEq(Uint8x16.byteLength, 16);
+ assertEq(Uint8x16.byteAlignment, 16);
+
+ var Compound = new StructType({c: uint8, d: uint8, f: Uint8x16});
+ assertEq(Compound.fieldOffsets.c, 0);
+ assertEq(Compound.fieldOffsets.d, 1);
+ assertEq(Compound.fieldOffsets.f, 16);
+}
+
+function testUint8x16Getters() {
+ // Create a Uint8x16 and check that the getters work:
+ var f = Uint8x16(11, 22, 33, 44, 55, 66, 77, 88, 99, 10, 20, 30, 40, 50, 60, 70);
+ assertEq(Uint8x16.extractLane(f, 0), 11);
+ assertEq(Uint8x16.extractLane(f, 1), 22);
+ assertEq(Uint8x16.extractLane(f, 2), 33);
+ assertEq(Uint8x16.extractLane(f, 3), 44);
+ assertEq(Uint8x16.extractLane(f, 4), 55);
+ assertEq(Uint8x16.extractLane(f, 5), 66);
+ assertEq(Uint8x16.extractLane(f, 6), 77);
+ assertEq(Uint8x16.extractLane(f, 7), 88);
+ assertEq(Uint8x16.extractLane(f, 8), 99);
+ assertEq(Uint8x16.extractLane(f, 9), 10);
+ assertEq(Uint8x16.extractLane(f, 10), 20);
+ assertEq(Uint8x16.extractLane(f, 11), 30);
+ assertEq(Uint8x16.extractLane(f, 12), 40);
+ assertEq(Uint8x16.extractLane(f, 13), 50);
+ assertEq(Uint8x16.extractLane(f, 14), 60);
+ assertEq(Uint8x16.extractLane(f, 15), 70);
+
+ assertThrowsInstanceOf(() => Uint8x16.extractLane(f, 16), TypeError);
+ assertThrowsInstanceOf(() => Uint8x16.extractLane(f, -1), TypeError);
+ assertThrowsInstanceOf(() => Uint8x16.extractLane(f, 0.5), TypeError);
+ assertThrowsInstanceOf(() => Uint8x16.extractLane(f, {}), TypeError);
+ assertThrowsInstanceOf(() => Uint8x16.extractLane(Uint32x4(1,2,3,4), 0), TypeError);
+ assertThrowsInstanceOf(() => Uint8x16.extractLane(1, 0), TypeError);
+ assertThrowsInstanceOf(() => Uint8x16.extractLane(f, f), TypeError);
+}
+
+function testUint8x16Handles() {
+ var Array = Uint8x16.array(3);
+ var array = new Array([Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
+ Uint8x16(17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32),
+ Uint8x16(33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48)]);
+
+ // Test that trying to create handle into the interior of a
+ // Uint8x16 fails.
+ assertThrowsInstanceOf(function() {
+ var h = int8.handle(array, 1, 0);
+ }, TypeError, "Creating a int8 handle to elem via ctor");
+
+ assertThrowsInstanceOf(function() {
+ var h = int8.handle();
+ Handle.move(h, array, 1, 0);
+ }, TypeError, "Creating a int8 handle to elem via move");
+}
+
+function testUint8x16Reify() {
+ var Array = Uint8x16.array(3);
+ var array = new Array([Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
+ Uint8x16(17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32),
+ Uint8x16(33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48)]);
+
+ // Test that reading array[1] produces a *copy* of Uint8x16, not an
+ // alias into the array.
+
+ var f = array[1];
+
+ var sj1 = Uint8x16.extractLane(f, 3);
+
+ assertEq(sj1, 20);
+ assertEq(Uint8x16.extractLane(array[1], 3), 20);
+ array[1] = Uint8x16(49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64);
+ assertEq(Uint8x16.extractLane(f, 3), 20);
+ assertEq(Uint8x16.extractLane(array[1], 3), 52);
+}
+
+function testUint8x16Setters() {
+ var Array = Uint8x16.array(3);
+ var array = new Array([Uint8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
+ Uint8x16(17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32),
+ Uint8x16(33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48)]);
+ assertEq(Uint8x16.extractLane(array[1], 3), 20);
+
+ // Test that we are allowed to write Uint8x16 values into array,
+ // but not other things.
+
+ array[1] = Uint8x16(49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64);
+ assertEq(Uint8x16.extractLane(array[1], 3), 52);
+
+ assertThrowsInstanceOf(function() {
+ array[1] = {s0: 49, s1: 50, s2: 51, s3: 52, s4: 53, s5: 54, s6: 55, s7: 56,
+ s8: 57, s9: 58, s10: 59, s11: 60, s12: 61, s13: 62, s14: 63, s15: 64};
+ }, TypeError, "Setting Uint8x16 from an object");
+
+ assertThrowsInstanceOf(function() {
+ array[1] = [49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64];
+ }, TypeError, "Setting Uint8x16 from an array");
+
+ assertThrowsInstanceOf(function() {
+ array[1] = 52;
+ }, TypeError, "Setting Uint8x16 from a number");
+}
+
+function testUint16x8Alignment() {
+ assertEq(Uint16x8.byteLength, 16);
+ assertEq(Uint16x8.byteAlignment, 16);
+
+ var Compound = new StructType({c: uint8, d: uint8, f: Uint16x8});
+ assertEq(Compound.fieldOffsets.c, 0);
+ assertEq(Compound.fieldOffsets.d, 1);
+ assertEq(Compound.fieldOffsets.f, 16);
+}
+
+function testUint16x8Getters() {
+ // Create a Uint16x8 and check that the getters work:
+ var f = Uint16x8(11, 22, 33, 44, 55, 66, 77, 88);
+ assertEq(Uint16x8.extractLane(f, 0), 11);
+ assertEq(Uint16x8.extractLane(f, 1), 22);
+ assertEq(Uint16x8.extractLane(f, 2), 33);
+ assertEq(Uint16x8.extractLane(f, 3), 44);
+ assertEq(Uint16x8.extractLane(f, 4), 55);
+ assertEq(Uint16x8.extractLane(f, 5), 66);
+ assertEq(Uint16x8.extractLane(f, 6), 77);
+ assertEq(Uint16x8.extractLane(f, 7), 88);
+
+ assertThrowsInstanceOf(() => Uint16x8.extractLane(f, 8), TypeError);
+ assertThrowsInstanceOf(() => Uint16x8.extractLane(f, -1), TypeError);
+ assertThrowsInstanceOf(() => Uint16x8.extractLane(f, 0.5), TypeError);
+ assertThrowsInstanceOf(() => Uint16x8.extractLane(f, {}), TypeError);
+ assertThrowsInstanceOf(() => Uint16x8.extractLane(Uint32x4(1,2,3,4), 0), TypeError);
+ assertThrowsInstanceOf(() => Uint16x8.extractLane(1, 0), TypeError);
+ assertThrowsInstanceOf(() => Uint16x8.extractLane(f, f), TypeError);
+}
+
+function testUint16x8Handles() {
+ var Array = Uint16x8.array(3);
+ var array = new Array([Uint16x8(1, 2, 3, 4, 5, 6, 7, 8),
+ Uint16x8(9, 10, 11, 12, 13, 14, 15, 16),
+ Uint16x8(17, 18, 19, 20, 21, 22, 23, 24)]);
+
+ // Test that trying to create handle into the interior of a
+ // Uint16x8 fails.
+ assertThrowsInstanceOf(function() {
+ var h = int16.handle(array, 1, 0);
+ }, TypeError, "Creating a int16 handle to elem via ctor");
+
+ assertThrowsInstanceOf(function() {
+ var h = int16.handle();
+ Handle.move(h, array, 1, 0);
+ }, TypeError, "Creating a int16 handle to elem via move");
+}
+
+function testUint16x8Reify() {
+ var Array = Uint16x8.array(3);
+ var array = new Array([Uint16x8(1, 2, 3, 4, 5, 6, 7, 8),
+ Uint16x8(9, 10, 11, 12, 13, 14, 15, 16),
+ Uint16x8(17, 18, 19, 20, 21, 22, 23, 24)]);
+
+ // Test that reading array[1] produces a *copy* of Uint16x8, not an
+ // alias into the array.
+
+ var f = array[1];
+ assertEq(Uint16x8.extractLane(f, 3), 12);
+ assertEq(Uint16x8.extractLane(array[1], 3), 12);
+ array[1] = Uint16x8(25, 26, 27, 28, 29, 30, 31, 32);
+ assertEq(Uint16x8.extractLane(f, 3), 12);
+ assertEq(Uint16x8.extractLane(array[1], 3), 28);
+}
+
+function testUint16x8Setters() {
+ var Array = Uint16x8.array(3);
+ var array = new Array([Uint16x8(1, 2, 3, 4, 5, 6, 7, 8),
+ Uint16x8(9, 10, 11, 12, 13, 14, 15, 16),
+ Uint16x8(17, 18, 19, 20, 21, 22, 23, 24)]);
+ assertEq(Uint16x8.extractLane(array[1], 3), 12);
+
+ // Test that we are allowed to write Uint16x8 values into array,
+ // but not other things.
+
+ array[1] = Uint16x8(25, 26, 27, 28, 29, 30, 31, 32);
+ assertEq(Uint16x8.extractLane(array[1], 3), 28);
+
+ assertThrowsInstanceOf(function() {
+ array[1] = {s0: 25, s1: 26, s2: 27, s3: 28, s4: 29, s5: 30, s6: 31, s7: 32};
+ }, TypeError, "Setting Uint16x8 from an object");
+
+ assertThrowsInstanceOf(function() {
+ array[1] = [25, 26, 27, 28, 29, 30, 31, 32];
+ }, TypeError, "Setting Uint16x8 from an array");
+
+ assertThrowsInstanceOf(function() {
+ array[1] = 28;
+ }, TypeError, "Setting Uint16x8 from a number");
+}
+
+function testUint32x4Alignment() {
+ assertEq(Uint32x4.byteLength, 16);
+ assertEq(Uint32x4.byteAlignment, 16);
+
+ var Compound = new StructType({c: uint8, d: uint8, f: Uint32x4});
+ assertEq(Compound.fieldOffsets.c, 0);
+ assertEq(Compound.fieldOffsets.d, 1);
+ assertEq(Compound.fieldOffsets.f, 16);
+}
+
+function testUint32x4Getters() {
+ // Create a Uint32x4 and check that the getters work:
+ var f = Uint32x4(11, 22, 33, 44);
+ assertEq(Uint32x4.extractLane(f, 0), 11);
+ assertEq(Uint32x4.extractLane(f, 1), 22);
+ assertEq(Uint32x4.extractLane(f, 2), 33);
+ assertEq(Uint32x4.extractLane(f, 3), 44);
+
+ assertThrowsInstanceOf(() => Uint32x4.extractLane(f, 4), TypeError);
+ assertThrowsInstanceOf(() => Uint32x4.extractLane(f, -1), TypeError);
+ assertThrowsInstanceOf(() => Uint32x4.extractLane(f, 0.5), TypeError);
+ assertThrowsInstanceOf(() => Uint32x4.extractLane(f, {}), TypeError);
+ assertThrowsInstanceOf(() => Uint32x4.extractLane(Float32x4(1,2,3,4), 0), TypeError);
+ assertThrowsInstanceOf(() => Uint32x4.extractLane(1, 0), TypeError);
+ assertThrowsInstanceOf(() => Uint32x4.extractLane(f, f), TypeError);
+}
+
+function testUint32x4Handles() {
+ var Array = Uint32x4.array(3);
+ var array = new Array([Uint32x4(1, 2, 3, 4),
+ Uint32x4(5, 6, 7, 8),
+ Uint32x4(9, 10, 11, 12)]);
+
+ // Test that trying to create handle into the interior of a
+ // Uint32x4 fails.
+ assertThrowsInstanceOf(function() {
+ var h = int32.handle(array, 1, 0);
+ }, TypeError, "Creating a int32 handle to elem via ctor");
+
+ assertThrowsInstanceOf(function() {
+ var h = int32.handle();
+ Handle.move(h, array, 1, 0);
+ }, TypeError, "Creating a int32 handle to elem via move");
+}
+
+function testUint32x4Reify() {
+ var Array = Uint32x4.array(3);
+ var array = new Array([Uint32x4(1, 2, 3, 4),
+ Uint32x4(5, 6, 7, 8),
+ Uint32x4(9, 10, 11, 12)]);
+
+ // Test that reading array[1] produces a *copy* of Uint32x4, not an
+ // alias into the array.
+
+ var f = array[1];
+ assertEq(Uint32x4.extractLane(f, 3), 8);
+ assertEq(Uint32x4.extractLane(array[1], 3), 8);
+ array[1] = Uint32x4(15, 16, 17, 18);
+ assertEq(Uint32x4.extractLane(f, 3), 8);
+ assertEq(Uint32x4.extractLane(array[1], 3), 18);
+}
+
+function testUint32x4Setters() {
+ var Array = Uint32x4.array(3);
+ var array = new Array([Uint32x4(1, 2, 3, 4),
+ Uint32x4(5, 6, 7, 8),
+ Uint32x4(9, 10, 11, 12)]);
+ assertEq(Uint32x4.extractLane(array[1], 3), 8);
+
+ // Test that we are allowed to write Uint32x4 values into array,
+ // but not other things.
+ array[1] = Uint32x4(15, 16, 17, 18);
+ assertEq(Uint32x4.extractLane(array[1], 3), 18);
+
+ assertThrowsInstanceOf(function() {
+ array[1] = {x: 15, y: 16, z: 17, w: 18};
+ }, TypeError, "Setting Uint32x4 from an object");
+
+ assertThrowsInstanceOf(function() {
+ array[1] = [15, 16, 17, 18];
+ }, TypeError, "Setting Uint32x4 from an array");
+
+ assertThrowsInstanceOf(function() {
+ array[1] = 22;
+ }, TypeError, "Setting Uint32x4 from a number");
+}
+
function testBool8x16Getters() {
// Create a Bool8x16 and check that the getters work:
var f = Bool8x16(true, false, true, false, true, false, true, false, true, true, false, false, true, true, false, false);
assertEq(Bool8x16.extractLane(f, 0), true);
assertEq(Bool8x16.extractLane(f, 1), false);
assertEq(Bool8x16.extractLane(f, 2), true);
assertEq(Bool8x16.extractLane(f, 3), false);
assertEq(Bool8x16.extractLane(f, 4), true);
@@ -744,16 +1030,34 @@ function test() {
testInt16x8Setters();
testInt32x4Alignment();
testInt32x4Getters();
testInt32x4Handles();
testInt32x4Reify();
testInt32x4Setters();
+ testUint8x16Alignment();
+ testUint8x16Getters();
+ testUint8x16Handles();
+ testUint8x16Reify();
+ testUint8x16Setters();
+
+ testUint16x8Alignment();
+ testUint16x8Getters();
+ testUint16x8Handles();
+ testUint16x8Reify();
+ testUint16x8Setters();
+
+ testUint32x4Alignment();
+ testUint32x4Getters();
+ testUint32x4Handles();
+ testUint32x4Reify();
+ testUint32x4Setters();
+
testBool8x16Getters();
testBool8x16Reify();
testBool8x16Setters();
testBool16x8Getters();
testBool16x8Reify();
testBool16x8Setters();
--- a/js/src/tests/ecma_7/SIMD/unary-operations.js
+++ b/js/src/tests/ecma_7/SIMD/unary-operations.js
@@ -1,13 +1,16 @@
// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
var Float32x4 = SIMD.Float32x4;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;
+var Uint8x16 = SIMD.Uint8x16;
+var Uint16x8 = SIMD.Uint16x8;
+var Uint32x4 = SIMD.Uint32x4;
var Bool8x16 = SIMD.Bool8x16;
var Bool16x8 = SIMD.Bool16x8;
var Bool32x4 = SIMD.Bool32x4;
var Bool64x2 = SIMD.Bool64x2;
function testFloat32x4abs() {
function absf(a) {
return Math.abs(Math.fround(a));
@@ -144,16 +147,76 @@ function testInt32x4not() {
[[1, 2, 3, 4], [-2, -3, -4, -5]],
[[INT32_MAX, INT32_MIN, 0, 0], [~INT32_MAX | 0, ~INT32_MIN | 0, ~0 | 0, ~0 | 0]]
];
for (var [v,w] of valsExp) {
assertEqX4(Int32x4.not(Int32x4(...v)), w);
}
}
+function testUint8x16neg() {
+ var vals = [
+ [[ 1, 2, 3, 4, 5, 6, 7, 0, -1, -2, -3, -4, UINT8_MAX, INT8_MAX, 0, 0],
+ [255, 254, 253, 252, 251, 250, 249, 0, 1, 2, 3, 4, 1, INT8_MAX+2, 0, 0]]
+ ];
+ for (var [v,w] of vals) {
+ assertEqX16(Uint8x16.neg(Uint8x16(...v)), w);
+ }
+}
+
+function testUint8x16not() {
+ var vals = [
+ [[1, 2, 3, 4, 5, 6, 7, -1, -2, -3, -4, -5, -6, 0, INT8_MIN, INT8_MAX],
+ [1, 2, 3, 4, 5, 6, 7, -1, -2, -3, -4, -5, -6, 0, INT8_MIN, INT8_MAX].map((x) => ~x << 24 >>> 24)]
+ ];
+ for (var [v,w] of vals) {
+ assertEqX16(Uint8x16.not(Uint8x16(...v)), w);
+ }
+}
+
+function testUint16x8neg() {
+ var vals = [
+ [[1, 2, UINT16_MAX, -1, -2, 0, INT16_MIN, INT16_MAX],
+ [1, 2, UINT16_MAX, -1, -2, 0, INT16_MIN, INT16_MAX].map((x) => -x << 16 >>> 16)]
+ ];
+ for (var [v,w] of vals) {
+ assertEqX8(Uint16x8.neg(Uint16x8(...v)), w);
+ }
+}
+
+function testUint16x8not() {
+ var vals = [
+ [[1, 2, UINT16_MAX, -1, -2, 0, INT16_MIN, INT16_MAX],
+ [1, 2, UINT16_MAX, -1, -2, 0, INT16_MIN, INT16_MAX].map((x) => ~x << 16 >>> 16)]
+ ];
+ for (var [v,w] of vals) {
+ assertEqX8(Uint16x8.not(Uint16x8(...v)), w);
+ }
+}
+
+function testUint32x4neg() {
+ var valsExp = [
+ [[1, 2, 3, 4], [-1 >>> 0, -2 >>> 0, -3 >>> 0, -4 >>> 0]],
+ [[INT32_MAX, INT32_MIN, -0, 0], [-INT32_MAX >>> 0, -INT32_MIN >>> 0, 0, 0]]
+ ];
+ for (var [v,w] of valsExp) {
+ assertEqX4(Uint32x4.neg(Uint32x4(...v)), w);
+ }
+}
+
+function testUint32x4not() {
+ var valsExp = [
+ [[1, 2, 3, 4], [~1 >>> 0, ~2 >>> 0, ~3 >>> 0, ~4 >>> 0]],
+ [[INT32_MAX, INT32_MIN, UINT32_MAX, 0], [~INT32_MAX >>> 0, ~INT32_MIN >>> 0, 0, ~0 >>> 0]]
+ ];
+ for (var [v,w] of valsExp) {
+ assertEqX4(Uint32x4.not(Uint32x4(...v)), w);
+ }
+}
+
function testBool8x16not() {
var valsExp = [
[[true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false],
[false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true]],
[[true, true, false, false, true, true, false, false, true, true, false, false, true, true, false, false],
[false, false, true, true, false, false, true, true, false, false, true, true, false, false, true, true]]
];
for (var [v,w] of valsExp) {
@@ -308,16 +371,25 @@ function test() {
testInt8x16not();
testInt16x8neg();
testInt16x8not();
testInt32x4neg();
testInt32x4not();
+ testUint8x16neg();
+ testUint8x16not();
+
+ testUint16x8neg();
+ testUint16x8not();
+
+ testUint32x4neg();
+ testUint32x4not();
+
testBool8x16not();
testBool8x16allTrue();
testBool8x16anyTrue();
testBool16x8not();
testBool16x8allTrue();
testBool16x8anyTrue();
--- a/js/src/vm/CommonPropertyNames.h
+++ b/js/src/vm/CommonPropertyNames.h
@@ -232,16 +232,19 @@
macro(unescape, unescape, "unescape") \
macro(uneval, uneval, "uneval") \
macro(unicode, unicode, "unicode") \
macro(uninitialized, uninitialized, "uninitialized") \
macro(uint8, uint8, "uint8") \
macro(uint8Clamped, uint8Clamped, "uint8Clamped") \
macro(uint16, uint16, "uint16") \
macro(uint32, uint32, "uint32") \
+ macro(uint8x16, uint8x16, "Uint8x16") \
+ macro(uint16x8, uint16x8, "Uint16x8") \
+ macro(uint32x4, uint32x4, "Uint32x4") \
macro(unsized, unsized, "unsized") \
macro(unwatch, unwatch, "unwatch") \
macro(url, url, "url") \
macro(usage, usage, "usage") \
macro(useGrouping, useGrouping, "useGrouping") \
macro(useAsm, useAsm, "use asm") \
macro(useStrict, useStrict, "use strict") \
macro(value, value, "value") \
--- a/js/src/vm/SelfHosting.cpp
+++ b/js/src/vm/SelfHosting.cpp
@@ -1450,17 +1450,22 @@ static const JSFunctionSpec intrinsic_fu
JS_FN("std_String_toUpperCase", str_toUpperCase, 0,0),
JS_FN("std_WeakMap_has", WeakMap_has, 1,0),
JS_FN("std_WeakMap_get", WeakMap_get, 2,0),
JS_FN("std_WeakMap_set", WeakMap_set, 2,0),
JS_FN("std_WeakMap_delete", WeakMap_delete, 1,0),
JS_FN("std_WeakMap_clear", WeakMap_clear, 0,0),
+ JS_FN("std_SIMD_Int8x16_extractLane", simd_int8x16_extractLane, 2,0),
+ JS_FN("std_SIMD_Int16x8_extractLane", simd_int16x8_extractLane, 2,0),
JS_INLINABLE_FN("std_SIMD_Int32x4_extractLane", simd_int32x4_extractLane, 2,0, SimdInt32x4),
+ JS_FN("std_SIMD_Uint8x16_extractLane", simd_uint8x16_extractLane, 2,0),
+ JS_FN("std_SIMD_Uint16x8_extractLane", simd_uint16x8_extractLane, 2,0),
+ JS_FN("std_SIMD_Uint32x4_extractLane", simd_uint32x4_extractLane, 2,0),
JS_INLINABLE_FN("std_SIMD_Float32x4_extractLane", simd_float32x4_extractLane,2,0, SimdFloat32x4),
JS_FN("std_SIMD_Float64x2_extractLane", simd_float64x2_extractLane, 2,0),
JS_FN("std_SIMD_Bool8x16_extractLane", simd_bool8x16_extractLane, 2,0),
JS_FN("std_SIMD_Bool16x8_extractLane", simd_bool16x8_extractLane, 2,0),
JS_FN("std_SIMD_Bool32x4_extractLane", simd_bool32x4_extractLane, 2,0),
JS_FN("std_SIMD_Bool64x2_extractLane", simd_bool64x2_extractLane, 2,0),
// Helper funtions after this point.
@@ -1597,16 +1602,19 @@ static const JSFunctionSpec intrinsic_fu
JS_FN("TypedObjectTypeDescr", js::TypedObjectTypeDescr, 1, 0),
JS_FN("ClampToUint8", js::ClampToUint8, 1, 0),
JS_FN("GetTypedObjectModule", js::GetTypedObjectModule, 0, 0),
JS_FN("GetFloat32x4TypeDescr", js::GetFloat32x4TypeDescr, 0, 0),
JS_FN("GetFloat64x2TypeDescr", js::GetFloat64x2TypeDescr, 0, 0),
JS_FN("GetInt8x16TypeDescr", js::GetInt8x16TypeDescr, 0, 0),
JS_FN("GetInt16x8TypeDescr", js::GetInt16x8TypeDescr, 0, 0),
JS_FN("GetInt32x4TypeDescr", js::GetInt32x4TypeDescr, 0, 0),
+ JS_FN("GetUint8x16TypeDescr", js::GetUint8x16TypeDescr, 0, 0),
+ JS_FN("GetUint16x8TypeDescr", js::GetUint16x8TypeDescr, 0, 0),
+ JS_FN("GetUint32x4TypeDescr", js::GetUint32x4TypeDescr, 0, 0),
JS_FN("GetBool8x16TypeDescr", js::GetBool8x16TypeDescr, 0, 0),
JS_FN("GetBool16x8TypeDescr", js::GetBool16x8TypeDescr, 0, 0),
JS_FN("GetBool32x4TypeDescr", js::GetBool32x4TypeDescr, 0, 0),
JS_FN("GetBool64x2TypeDescr", js::GetBool64x2TypeDescr, 0, 0),
JS_INLINABLE_FN("ObjectIsTypeDescr" , js::ObjectIsTypeDescr, 1, 0,
IntrinsicObjectIsTypeDescr),
JS_INLINABLE_FN("ObjectIsTypedObject", js::ObjectIsTypedObject, 1, 0,