From dcd04d21d2d15826dc84a0f0449264f9b3e183e5 Mon Sep 17 00:00:00 2001 From: Jakob Olesen Date: Thu, 18 Feb 2016 15:37:10 -0800 Subject: [PATCH] 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 --- js/src/asmjs/WasmIonCompile.cpp | 4 --- js/src/builtin/SIMD.h | 16 +-------- js/src/jit-test/tests/SIMD/shift.js | 42 ++++++++++++++---------- js/src/jit-test/tests/asm.js/testSIMD.js | 40 ++++++---------------- js/src/jit/MCallOptimize.cpp | 4 --- js/src/tests/ecma_7/SIMD/shifts.js | 24 -------------- 6 files changed, 36 insertions(+), 94 deletions(-) diff --git a/js/src/asmjs/WasmIonCompile.cpp b/js/src/asmjs/WasmIonCompile.cpp index b3d6c7d3aeae..2fe95541b5b1 100644 --- a/js/src/asmjs/WasmIonCompile.cpp +++ b/js/src/asmjs/WasmIonCompile.cpp @@ -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); diff --git a/js/src/builtin/SIMD.h b/js/src/builtin/SIMD.h index 79aa30ea283a..eab6c6e8f780 100644 --- a/js/src/builtin/SIMD.h +++ b/js/src/builtin/SIMD.h @@ -250,8 +250,6 @@ V(subSaturate, (BinaryFunc), 2) \ V(shiftLeftByScalar, (BinaryScalar), 2) \ V(shiftRightByScalar, (BinaryScalar), 2) \ - V(shiftRightArithmeticByScalar, (BinaryScalar), 2) \ - V(shiftRightLogicalByScalar, (BinaryScalar), 2) \ V(xor, (BinaryFunc), 2) #define INT8X16_TERNARY_FUNCTION_LIST(V) \ @@ -301,8 +299,6 @@ V(subSaturate, (BinaryFunc), 2) \ V(shiftLeftByScalar, (BinaryScalar), 2) \ V(shiftRightByScalar, (BinaryScalar), 2) \ - V(shiftRightArithmeticByScalar, (BinaryScalar), 2) \ - V(shiftRightLogicalByScalar, (BinaryScalar), 2) \ V(xor, (BinaryFunc), 2) #define UINT8X16_TERNARY_FUNCTION_LIST(V) \ @@ -352,8 +348,6 @@ V(subSaturate, (BinaryFunc), 2) \ V(shiftLeftByScalar, (BinaryScalar), 2) \ V(shiftRightByScalar, (BinaryScalar), 2) \ - V(shiftRightArithmeticByScalar, (BinaryScalar), 2) \ - V(shiftRightLogicalByScalar, (BinaryScalar), 2) \ V(xor, (BinaryFunc), 2) #define INT16X8_TERNARY_FUNCTION_LIST(V) \ @@ -403,8 +397,6 @@ V(subSaturate, (BinaryFunc), 2) \ V(shiftLeftByScalar, (BinaryScalar), 2) \ V(shiftRightByScalar, (BinaryScalar), 2) \ - V(shiftRightArithmeticByScalar, (BinaryScalar), 2) \ - V(shiftRightLogicalByScalar, (BinaryScalar), 2) \ V(xor, (BinaryFunc), 2) #define UINT16X8_TERNARY_FUNCTION_LIST(V) \ @@ -456,8 +448,6 @@ V(sub, (BinaryFunc), 2) \ V(shiftLeftByScalar, (BinaryScalar), 2) \ V(shiftRightByScalar, (BinaryScalar), 2) \ - V(shiftRightArithmeticByScalar, (BinaryScalar), 2) \ - V(shiftRightLogicalByScalar, (BinaryScalar), 2) \ V(xor, (BinaryFunc), 2) #define INT32X4_TERNARY_FUNCTION_LIST(V) \ @@ -512,8 +502,6 @@ V(sub, (BinaryFunc), 2) \ V(shiftLeftByScalar, (BinaryScalar), 2) \ V(shiftRightByScalar, (BinaryScalar), 2) \ - V(shiftRightArithmeticByScalar, (BinaryScalar), 2) \ - V(shiftRightLogicalByScalar, (BinaryScalar), 2) \ V(xor, (BinaryFunc), 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(_) \ diff --git a/js/src/jit-test/tests/SIMD/shift.js b/js/src/jit-test/tests/SIMD/shift.js index 14fddedea2d8..9975d0f871b3 100644 --- a/js/src/jit-test/tests/SIMD/shift.js +++ b/js/src/jit-test/tests/SIMD/shift.js @@ -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; } diff --git a/js/src/jit-test/tests/asm.js/testSIMD.js b/js/src/jit-test/tests/asm.js/testSIMD.js index c2f69eb4c291..6eefcacc99e1 100644 --- a/js/src/jit-test/tests/asm.js/testSIMD.js +++ b/js/src/jit-test/tests/asm.js/testSIMD.js @@ -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 diff --git a/js/src/jit/MCallOptimize.cpp b/js/src/jit/MCallOptimize.cpp index ad3db61b006f..c68fc3256b02 100644 --- a/js/src/jit/MCallOptimize.cpp +++ b/js/src/jit/MCallOptimize.cpp @@ -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: diff --git a/js/src/tests/ecma_7/SIMD/shifts.js b/js/src/tests/ecma_7/SIMD/shifts.js index f9e58adbc2d4..7f5e5db99642 100644 --- a/js/src/tests/ecma_7/SIMD/shifts.js +++ b/js/src/tests/ecma_7/SIMD/shifts.js @@ -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);