зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1201934 - Remove SIMD shiftRight***ByScalar. r=sunfish
These functions have been replaced by the shiftRightByScalar function which behaves differently on signed and unsigned SIMD types. Add some Uint32x4 tests to make up for the reduced test coverage. MozReview-Commit-ID: 6BKSMR07zDa
This commit is contained in:
Jakob Olesen
Родитель
1575a306bd
Коммит
dcd04d21d2
|
|
@ -2365,10 +2365,6 @@ EmitSimdOp(FunctionCompiler& f, ExprType type, SimdOperation op, SimdSign sign,
|
|||
return EmitSimdShift(f, type, MSimdShift::lsh, def);
|
||||
case SimdOperation::Fn_shiftRightByScalar:
|
||||
return EmitSimdShift(f, type, MSimdShift::rshForSign(sign), def);
|
||||
case SimdOperation::Fn_shiftRightArithmeticByScalar:
|
||||
return EmitSimdShift(f, type, MSimdShift::rsh, def);
|
||||
case SimdOperation::Fn_shiftRightLogicalByScalar:
|
||||
return EmitSimdShift(f, type, MSimdShift::ursh, def);
|
||||
#define _CASE(OP) \
|
||||
case SimdOperation::Fn_##OP: \
|
||||
return EmitSimdBinaryComp(f, type, MSimdBinaryComp::OP, sign, def);
|
||||
|
|
|
|||
|
|
@ -250,8 +250,6 @@
|
|||
V(subSaturate, (BinaryFunc<Int8x16, SubSaturate, Int8x16>), 2) \
|
||||
V(shiftLeftByScalar, (BinaryScalar<Int8x16, ShiftLeft>), 2) \
|
||||
V(shiftRightByScalar, (BinaryScalar<Int8x16, ShiftRightArithmetic>), 2) \
|
||||
V(shiftRightArithmeticByScalar, (BinaryScalar<Int8x16, ShiftRightArithmetic>), 2) \
|
||||
V(shiftRightLogicalByScalar, (BinaryScalar<Int8x16, ShiftRightLogical>), 2) \
|
||||
V(xor, (BinaryFunc<Int8x16, Xor, Int8x16>), 2)
|
||||
|
||||
#define INT8X16_TERNARY_FUNCTION_LIST(V) \
|
||||
|
|
@ -301,8 +299,6 @@
|
|||
V(subSaturate, (BinaryFunc<Uint8x16, SubSaturate, Uint8x16>), 2) \
|
||||
V(shiftLeftByScalar, (BinaryScalar<Uint8x16, ShiftLeft>), 2) \
|
||||
V(shiftRightByScalar, (BinaryScalar<Uint8x16, ShiftRightLogical>), 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) \
|
||||
|
|
@ -352,8 +348,6 @@
|
|||
V(subSaturate, (BinaryFunc<Int16x8, SubSaturate, Int16x8>), 2) \
|
||||
V(shiftLeftByScalar, (BinaryScalar<Int16x8, ShiftLeft>), 2) \
|
||||
V(shiftRightByScalar, (BinaryScalar<Int16x8, ShiftRightArithmetic>), 2) \
|
||||
V(shiftRightArithmeticByScalar, (BinaryScalar<Int16x8, ShiftRightArithmetic>), 2) \
|
||||
V(shiftRightLogicalByScalar, (BinaryScalar<Int16x8, ShiftRightLogical>), 2) \
|
||||
V(xor, (BinaryFunc<Int16x8, Xor, Int16x8>), 2)
|
||||
|
||||
#define INT16X8_TERNARY_FUNCTION_LIST(V) \
|
||||
|
|
@ -403,8 +397,6 @@
|
|||
V(subSaturate, (BinaryFunc<Uint16x8, SubSaturate, Uint16x8>), 2) \
|
||||
V(shiftLeftByScalar, (BinaryScalar<Uint16x8, ShiftLeft>), 2) \
|
||||
V(shiftRightByScalar, (BinaryScalar<Uint16x8, ShiftRightLogical>), 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) \
|
||||
|
|
@ -456,8 +448,6 @@
|
|||
V(sub, (BinaryFunc<Int32x4, Sub, Int32x4>), 2) \
|
||||
V(shiftLeftByScalar, (BinaryScalar<Int32x4, ShiftLeft>), 2) \
|
||||
V(shiftRightByScalar, (BinaryScalar<Int32x4, ShiftRightArithmetic>), 2) \
|
||||
V(shiftRightArithmeticByScalar, (BinaryScalar<Int32x4, ShiftRightArithmetic>), 2) \
|
||||
V(shiftRightLogicalByScalar, (BinaryScalar<Int32x4, ShiftRightLogical>), 2) \
|
||||
V(xor, (BinaryFunc<Int32x4, Xor, Int32x4>), 2)
|
||||
|
||||
#define INT32X4_TERNARY_FUNCTION_LIST(V) \
|
||||
|
|
@ -512,8 +502,6 @@
|
|||
V(sub, (BinaryFunc<Uint32x4, Sub, Uint32x4>), 2) \
|
||||
V(shiftLeftByScalar, (BinaryScalar<Uint32x4, ShiftLeft>), 2) \
|
||||
V(shiftRightByScalar, (BinaryScalar<Uint32x4, ShiftRightLogical>), 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) \
|
||||
|
|
@ -586,9 +574,7 @@
|
|||
// Bitwise shifts defined on integer SIMD types.
|
||||
#define FOREACH_SHIFT_SIMD_OP(_) \
|
||||
_(shiftLeftByScalar) \
|
||||
_(shiftRightByScalar) \
|
||||
_(shiftRightArithmeticByScalar) \
|
||||
_(shiftRightLogicalByScalar)
|
||||
_(shiftRightByScalar)
|
||||
|
||||
// Unary arithmetic operators defined on numeric SIMD types.
|
||||
#define FOREACH_NUMERIC_SIMD_UNOP(_) \
|
||||
|
|
|
|||
|
|
@ -10,12 +10,17 @@ function lsh(count) { return curry(binaryLsh, count); }
|
|||
function binaryRsh(count, v) { if (count>>>0 >= 32) count = 31; return (v >> count) | 0; }
|
||||
function rsh(count) { return curry(binaryRsh, count); }
|
||||
|
||||
function binaryUrsh(count, v) { if (count>>>0 >= 32) return 0; return (v >>> count) | 0; }
|
||||
function binaryUlsh(count, v) { if (count>>>0 >= 32) return 0; return (v << count) >>> 0; }
|
||||
function ulsh(count) { return curry(binaryUlsh, count); }
|
||||
|
||||
function binaryUrsh(count, v) { if (count>>>0 >= 32) return 0; return v >>> count; }
|
||||
function ursh(count) { return curry(binaryUrsh, count); }
|
||||
|
||||
function f() {
|
||||
var v = SIMD.Int32x4(1, 2, -3, 4);
|
||||
var u = SIMD.Uint32x4(1, 0x55005500, -3, 0xaa00aa00);
|
||||
var a = [1, 2, -3, 4];
|
||||
var b = [1, 0x55005500, -3, 0xaa00aa00];
|
||||
var zeros = [0,0,0,0];
|
||||
|
||||
var shifts = [-1, 0, 1, 31, 32];
|
||||
|
|
@ -30,20 +35,6 @@ function f() {
|
|||
assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, 31), a.map(lsh(31)));
|
||||
assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, 32), a.map(lsh(32)));
|
||||
|
||||
assertEqX4(SIMD.Int32x4.shiftRightArithmeticByScalar(v, -1), a.map(rsh(31)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightArithmeticByScalar(v, 0), a.map(rsh(0)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightArithmeticByScalar(v, 1), a.map(rsh(1)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightArithmeticByScalar(v, 2), a.map(rsh(2)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightArithmeticByScalar(v, 31), a.map(rsh(31)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightArithmeticByScalar(v, 32), a.map(rsh(31)));
|
||||
|
||||
assertEqX4(SIMD.Int32x4.shiftRightLogicalByScalar(v, -1), a.map(ursh(-1)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightLogicalByScalar(v, 0), a.map(ursh(0)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightLogicalByScalar(v, 1), a.map(ursh(1)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightLogicalByScalar(v, 2), a.map(ursh(2)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightLogicalByScalar(v, 31), a.map(ursh(31)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightLogicalByScalar(v, 32), a.map(ursh(32)));
|
||||
|
||||
assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, -1), a.map(rsh(31)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, 0), a.map(rsh(0)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, 1), a.map(rsh(1)));
|
||||
|
|
@ -51,11 +42,28 @@ function f() {
|
|||
assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, 31), a.map(rsh(31)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, 32), a.map(rsh(31)));
|
||||
|
||||
assertEqX4(SIMD.Uint32x4.shiftLeftByScalar(u, -1), b.map(ulsh(-1)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftLeftByScalar(u, 0), b.map(ulsh(0)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftLeftByScalar(u, 1), b.map(ulsh(1)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftLeftByScalar(u, 2), b.map(ulsh(2)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftLeftByScalar(u, 31), b.map(ulsh(31)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftLeftByScalar(u, 32), b.map(ulsh(32)));
|
||||
|
||||
assertEqX4(SIMD.Uint32x4.shiftRightByScalar(u, -1), b.map(ursh(-1)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftRightByScalar(u, 0), b.map(ursh(0)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftRightByScalar(u, 1), b.map(ursh(1)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftRightByScalar(u, 2), b.map(ursh(2)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftRightByScalar(u, 31), b.map(ursh(31)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftRightByScalar(u, 32), b.map(ursh(32)));
|
||||
|
||||
// Non constant shift counts
|
||||
var c = shifts[i % shifts.length];
|
||||
|
||||
assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, c), a.map(lsh(c)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightArithmeticByScalar(v, c), a.map(rsh(c)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightLogicalByScalar(v, c), a.map(ursh(c)));
|
||||
assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, c), a.map(rsh(c)));
|
||||
|
||||
assertEqX4(SIMD.Uint32x4.shiftLeftByScalar(u, c), b.map(ulsh(c)));
|
||||
assertEqX4(SIMD.Uint32x4.shiftRightByScalar(u, c), b.map(ursh(c)));
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1073,8 +1073,6 @@ assertAsmTypeFail('glob', USE_ASM + F32 + CF32 + NOTF32 + 'function f() {var x=f
|
|||
// Logical ops
|
||||
const LSHI = 'var lsh=i4.shiftLeftByScalar;'
|
||||
const RSHI = 'var rsh=i4.shiftRightByScalar;'
|
||||
const ARSHI = 'var arsh=i4.shiftRightArithmeticByScalar;'
|
||||
const URSHI = 'var ursh=i4.shiftRightLogicalByScalar;'
|
||||
|
||||
assertAsmTypeFail('glob', USE_ASM + I32 + CI32 + F32 + FROUND + LSHI + "function f() {var x=f4(1,2,3,4); return ci4(lsh(x,f32(42)));} return f");
|
||||
assertAsmTypeFail('glob', USE_ASM + I32 + CI32 + F32 + FROUND + LSHI + "function f() {var x=f4(1,2,3,4); return ci4(lsh(x,42));} return f");
|
||||
|
|
@ -1087,62 +1085,44 @@ var vinput = [0, 1, INT32_MIN, INT32_MAX];
|
|||
// TODO: What to do for masks > 31? Should we keep only the five low bits of
|
||||
// the mask (JS) or not (x86)?
|
||||
// See bug 1246800.
|
||||
function Lsh(i) { if (i > 31) return () => 0; return function(x) { return (x << i) | 0 } }
|
||||
function Arsh(i) { if (i > 31) return (x) => (x<0)?-1:0; return function(x) { return (x >> i) | 0 } }
|
||||
function Ursh(i) { if (i > 31) return () => 0; return function(x) { return (x >>> i) | 0 } }
|
||||
function Lsh(i) { if (i > 31) return () => 0; return function(x) { return (x << i) | 0 } }
|
||||
function Rsh(i) { if (i > 31) return (x) => (x<0)?-1:0; return function(x) { return (x >> i) | 0 } }
|
||||
|
||||
var asmLsh = asmLink(asmCompile('glob', USE_ASM + I32 + CI32 + LSHI + 'function f(x, y){x=x|0;y=y|0; var v=' + input + ';return ci4(lsh(v, x+y))} return f;'), this)
|
||||
var asmRsh = asmLink(asmCompile('glob', USE_ASM + I32 + CI32 + RSHI + 'function f(x, y){x=x|0;y=y|0; var v=' + input + ';return ci4(rsh(v, x+y))} return f;'), this)
|
||||
var asmArsh = asmLink(asmCompile('glob', USE_ASM + I32 + CI32 + ARSHI + 'function f(x, y){x=x|0;y=y|0; var v=' + input + ';return ci4(arsh(v, x+y))} return f;'), this)
|
||||
var asmUrsh = asmLink(asmCompile('glob', USE_ASM + I32 + CI32 + URSHI + 'function f(x, y){x=x|0;y=y|0; var v=' + input + ';return ci4(ursh(v, x+y))} return f;'), this)
|
||||
|
||||
for (var i = 1; i < 64; i++) {
|
||||
CheckI4(LSHI, 'var x=' + input + '; x=lsh(x, ' + i + ')', vinput.map(Lsh(i)));
|
||||
CheckI4(RSHI, 'var x=' + input + '; x=rsh(x, ' + i + ')', vinput.map(Arsh(i)));
|
||||
CheckI4(ARSHI, 'var x=' + input + '; x=arsh(x, ' + i + ')', vinput.map(Arsh(i)));
|
||||
CheckI4(URSHI, 'var x=' + input + '; x=ursh(x, ' + i + ')', vinput.map(Ursh(i)));
|
||||
CheckI4(RSHI, 'var x=' + input + '; x=rsh(x, ' + i + ')', vinput.map(Rsh(i)));
|
||||
|
||||
assertEqX4(asmLsh(i, 3), vinput.map(Lsh(i + 3)));
|
||||
assertEqX4(asmRsh(i, 3), vinput.map(Arsh(i + 3)));
|
||||
assertEqX4(asmArsh(i, 3), vinput.map(Arsh(i + 3)));
|
||||
assertEqX4(asmUrsh(i, 3), vinput.map(Ursh(i + 3)));
|
||||
assertEqX4(asmRsh(i, 3), vinput.map(Rsh(i + 3)));
|
||||
}
|
||||
|
||||
// Same thing for Uint32x4.
|
||||
const LSHU = 'var lsh=u4.shiftLeftByScalar;'
|
||||
const RSHU = 'var rsh=u4.shiftRightByScalar;'
|
||||
const ARSHU = 'var arsh=u4.shiftRightArithmeticByScalar;'
|
||||
const URSHU = 'var ursh=u4.shiftRightLogicalByScalar;'
|
||||
|
||||
input = 'u4(0, 1, 0x80008000, ' + INT32_MAX + ')';
|
||||
vinput = [0, 1, 0x80008000, INT32_MAX];
|
||||
|
||||
function uLsh(i) { if (i > 31) return () => 0; return function(x) { return (x << i) >>> 0 } }
|
||||
function uArsh(i) { if (i > 31) return (x) => (((x|0)<0)?-1:0)>>>0; return function(x) { return (x >> i) >>> 0 } }
|
||||
function uUrsh(i) { if (i > 31) return () => 0; return function(x) { return (x >>> i) } }
|
||||
function uLsh(i) { if (i > 31) return () => 0; return function(x) { return (x << i) >>> 0 } }
|
||||
function uRsh(i) { if (i > 31) return () => 0; return function(x) { return (x >>> i) } }
|
||||
|
||||
// Need to bitcast to Int32x4 before returning result.
|
||||
asmLsh = asmLink(asmCompile('glob', USE_ASM + U32 + CU32 + LSHU + I32 + CI32 + I32U32 +
|
||||
'function f(x, y){x=x|0;y=y|0; var v=' + input + ';return ci4(i4u4(lsh(v, x+y)));} return f;'), this)
|
||||
asmRsh = asmLink(asmCompile('glob', USE_ASM + U32 + CU32 + RSHU + I32 + CI32 + I32U32 +
|
||||
'function f(x, y){x=x|0;y=y|0; var v=' + input + ';return ci4(i4u4(rsh(v, x+y)));} return f;'), this)
|
||||
asmArsh = asmLink(asmCompile('glob', USE_ASM + U32 + CU32 + ARSHU + I32 + CI32 + I32U32 +
|
||||
'function f(x, y){x=x|0;y=y|0; var v=' + input + ';return ci4(i4u4(arsh(v, x+y)));} return f;'), this)
|
||||
asmUrsh = asmLink(asmCompile('glob', USE_ASM + U32 + CU32 + URSHU + I32 + CI32 + I32U32 +
|
||||
'function f(x, y){x=x|0;y=y|0; var v=' + input + ';return ci4(i4u4(ursh(v, x+y)));} return f;'), this)
|
||||
|
||||
for (var i = 1; i < 64; i++) {
|
||||
// Constant shifts.
|
||||
CheckU4(LSHU, 'var x=' + input + '; x=lsh(x, ' + i + ')', vinput.map(uLsh(i)));
|
||||
CheckU4(RSHU, 'var x=' + input + '; x=rsh(x, ' + i + ')', vinput.map(uUrsh(i)));
|
||||
CheckU4(ARSHU, 'var x=' + input + '; x=arsh(x, ' + i + ')', vinput.map(uArsh(i)));
|
||||
CheckU4(URSHU, 'var x=' + input + '; x=ursh(x, ' + i + ')', vinput.map(uUrsh(i)));
|
||||
CheckU4(LSHU, 'var x=' + input + '; x=lsh(x, ' + i + ')', vinput.map(uLsh(i)));
|
||||
CheckU4(RSHU, 'var x=' + input + '; x=rsh(x, ' + i + ')', vinput.map(uRsh(i)));
|
||||
|
||||
// Dynamically computed shifts. The asm function returns a Int32x4.
|
||||
assertEqX4(SIMD.Uint32x4.fromInt32x4Bits(asmLsh(i, 3)), vinput.map(uLsh(i + 3)));
|
||||
assertEqX4(SIMD.Uint32x4.fromInt32x4Bits(asmRsh(i, 3)), vinput.map(uUrsh(i + 3)));
|
||||
assertEqX4(SIMD.Uint32x4.fromInt32x4Bits(asmArsh(i, 3)), vinput.map(uArsh(i + 3)));
|
||||
assertEqX4(SIMD.Uint32x4.fromInt32x4Bits(asmUrsh(i, 3)), vinput.map(uUrsh(i + 3)));
|
||||
assertEqX4(SIMD.Uint32x4.fromInt32x4Bits(asmLsh(i, 3)), vinput.map(uLsh(i + 3)));
|
||||
assertEqX4(SIMD.Uint32x4.fromInt32x4Bits(asmRsh(i, 3)), vinput.map(uRsh(i + 3)));
|
||||
}
|
||||
|
||||
// Select
|
||||
|
|
|
|||
|
|
@ -3165,10 +3165,6 @@ IonBuilder::inlineSimd(CallInfo& callInfo, JSFunction* target, SimdType type)
|
|||
return inlineSimdShift(callInfo, native, MSimdShift::lsh, type);
|
||||
case SimdOperation::Fn_shiftRightByScalar:
|
||||
return inlineSimdShift(callInfo, native, MSimdShift::rshForSign(GetSimdSign(type)), type);
|
||||
case SimdOperation::Fn_shiftRightArithmeticByScalar:
|
||||
return inlineSimdShift(callInfo, native, MSimdShift::rsh, type);
|
||||
case SimdOperation::Fn_shiftRightLogicalByScalar:
|
||||
return inlineSimdShift(callInfo, native, MSimdShift::ursh, type);
|
||||
|
||||
// Boolean unary.
|
||||
case SimdOperation::Fn_allTrue:
|
||||
|
|
|
|||
|
|
@ -92,8 +92,6 @@ function test() {
|
|||
for (var bits = -2; bits < 12; bits++) {
|
||||
testBinaryScalarFunc(v, bits, Int8x16.shiftLeftByScalar, lsh8);
|
||||
testBinaryScalarFunc(v, bits, Int8x16.shiftRightByScalar, rsha8);
|
||||
testBinaryScalarFunc(v, bits, Int8x16.shiftRightArithmeticByScalar, rsha8);
|
||||
testBinaryScalarFunc(v, bits, Int8x16.shiftRightLogicalByScalar, rshl8);
|
||||
}
|
||||
// Test that the shift count is coerced to an int32.
|
||||
testBinaryScalarFunc(v, undefined, Int8x16.shiftLeftByScalar, lsh8);
|
||||
|
|
@ -108,8 +106,6 @@ function test() {
|
|||
for (var bits = -2; bits < 20; bits++) {
|
||||
testBinaryScalarFunc(v, bits, Int16x8.shiftLeftByScalar, lsh16);
|
||||
testBinaryScalarFunc(v, bits, Int16x8.shiftRightByScalar, rsha16);
|
||||
testBinaryScalarFunc(v, bits, Int16x8.shiftRightArithmeticByScalar, rsha16);
|
||||
testBinaryScalarFunc(v, bits, Int16x8.shiftRightLogicalByScalar, rshl16);
|
||||
}
|
||||
// Test that the shift count is coerced to an int32.
|
||||
testBinaryScalarFunc(v, undefined, Int16x8.shiftLeftByScalar, lsh16);
|
||||
|
|
@ -124,8 +120,6 @@ function test() {
|
|||
for (var bits = -2; bits < 36; bits++) {
|
||||
testBinaryScalarFunc(v, bits, Int32x4.shiftLeftByScalar, lsh32);
|
||||
testBinaryScalarFunc(v, bits, Int32x4.shiftRightByScalar, rsha32);
|
||||
testBinaryScalarFunc(v, bits, Int32x4.shiftRightArithmeticByScalar, rsha32);
|
||||
testBinaryScalarFunc(v, bits, Int32x4.shiftRightLogicalByScalar, rshl32);
|
||||
}
|
||||
// Test that the shift count is coerced to an int32.
|
||||
testBinaryScalarFunc(v, undefined, Int32x4.shiftLeftByScalar, lsh32);
|
||||
|
|
@ -141,8 +135,6 @@ function test() {
|
|||
for (var bits = -2; bits < 12; bits++) {
|
||||
testBinaryScalarFunc(v, bits, Uint8x16.shiftLeftByScalar, ulsh8);
|
||||
testBinaryScalarFunc(v, bits, Uint8x16.shiftRightByScalar, urshl8);
|
||||
testBinaryScalarFunc(v, bits, Uint8x16.shiftRightArithmeticByScalar, ursha8);
|
||||
testBinaryScalarFunc(v, bits, Uint8x16.shiftRightLogicalByScalar, urshl8);
|
||||
}
|
||||
// Test that the shift count is coerced to an int32.
|
||||
testBinaryScalarFunc(v, undefined, Uint8x16.shiftLeftByScalar, ulsh8);
|
||||
|
|
@ -157,8 +149,6 @@ function test() {
|
|||
for (var bits = -2; bits < 20; bits++) {
|
||||
testBinaryScalarFunc(v, bits, Uint16x8.shiftLeftByScalar, ulsh16);
|
||||
testBinaryScalarFunc(v, bits, Uint16x8.shiftRightByScalar, urshl16);
|
||||
testBinaryScalarFunc(v, bits, Uint16x8.shiftRightArithmeticByScalar, ursha16);
|
||||
testBinaryScalarFunc(v, bits, Uint16x8.shiftRightLogicalByScalar, urshl16);
|
||||
}
|
||||
// Test that the shift count is coerced to an int32.
|
||||
testBinaryScalarFunc(v, undefined, Uint16x8.shiftLeftByScalar, ulsh16);
|
||||
|
|
@ -174,8 +164,6 @@ function test() {
|
|||
for (var bits = -2; bits < 36; bits++) {
|
||||
testBinaryScalarFunc(v, bits, Uint32x4.shiftLeftByScalar, ulsh32);
|
||||
testBinaryScalarFunc(v, bits, Uint32x4.shiftRightByScalar, urshl32);
|
||||
testBinaryScalarFunc(v, bits, Uint32x4.shiftRightArithmeticByScalar, ursha32);
|
||||
testBinaryScalarFunc(v, bits, Uint32x4.shiftRightLogicalByScalar, urshl32);
|
||||
}
|
||||
// Test that the shift count is coerced to an int32.
|
||||
testBinaryScalarFunc(v, undefined, Uint32x4.shiftLeftByScalar, ulsh32);
|
||||
|
|
@ -186,38 +174,26 @@ function test() {
|
|||
var v = SIMD.Int8x16(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
|
||||
assertThrowsInstanceOf(() => SIMD.Int8x16.shiftLeftByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Int8x16.shiftRightByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Int8x16.shiftRightArithmeticByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Int8x16.shiftRightLogicalByScalar(v, bad), TestError);
|
||||
|
||||
var v = SIMD.Int16x8(1,2,3,4,5,6,7,8);
|
||||
assertThrowsInstanceOf(() => SIMD.Int16x8.shiftLeftByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Int16x8.shiftRightByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Int16x8.shiftRightArithmeticByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Int16x8.shiftRightLogicalByScalar(v, bad), TestError);
|
||||
|
||||
var v = SIMD.Int32x4(1,2,3,4);
|
||||
assertThrowsInstanceOf(() => SIMD.Int32x4.shiftLeftByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Int32x4.shiftRightByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Int32x4.shiftRightArithmeticByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Int32x4.shiftRightLogicalByScalar(v, bad), TestError);
|
||||
|
||||
var v = SIMD.Uint8x16(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint8x16.shiftLeftByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint8x16.shiftRightByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint8x16.shiftRightArithmeticByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint8x16.shiftRightLogicalByScalar(v, bad), TestError);
|
||||
|
||||
var v = SIMD.Uint16x8(1,2,3,4,5,6,7,8);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint16x8.shiftLeftByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint16x8.shiftRightByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint16x8.shiftRightArithmeticByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint16x8.shiftRightLogicalByScalar(v, bad), TestError);
|
||||
|
||||
var v = SIMD.Uint32x4(1,2,3,4);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint32x4.shiftLeftByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint32x4.shiftRightByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint32x4.shiftRightArithmeticByScalar(v, bad), TestError);
|
||||
assertThrowsInstanceOf(() => SIMD.Uint32x4.shiftRightLogicalByScalar(v, bad), TestError);
|
||||
|
||||
if (typeof reportCompare === "function")
|
||||
reportCompare(true, true);
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче