1 files changed, 785 insertions, 0 deletions
diff --git a/js/src/tests/ecma_7/SIMD/binary-operations.js b/js/src/tests/ecma_7/SIMD/binary-operations.js
new file mode 100644
index 000000000..04b035309
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/binary-operations.js
@@ -0,0 +1,785 @@
+// |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]],
+    [[NaN, -0, Infinity, -Infinity], [0, -0, -Infinity, -Infinity]]
+  ];
+
+  for (var [v,w] of vals) {
+    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.add, addf);
+  }
+}
+
+function testFloat32x4div() {
+  function divf(a, b) {
+    return Math.fround(Math.fround(a) / Math.fround(b));
+  }
+
+  var vals = [
+    [[1, 2, 3, 4], [10, 20, 30, 40]],
+    [[1.26, 2.03, 3.17, 4.59], [11.025, 17.3768, 29.1957, 46.4049]],
+    [[0, -0, Infinity, -Infinity], [1, 1, -Infinity, Infinity]]
+  ];
+
+  for (var [v,w] of vals) {
+    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.div, divf);
+  }
+}
+
+function testFloat32x4mul() {
+  function mulf(a, b) {
+    return Math.fround(Math.fround(a) * Math.fround(b));
+  }
+
+  var vals = [
+    [[1, 2, 3, 4], [10, 20, 30, 40]],
+    [[1.66, 2.57, 3.73, 4.12], [10.67, 20.68, 30.02, 40.58]],
+    [[NaN, -0, Infinity, -Infinity], [NaN, -0, -Infinity, 0]]
+  ];
+
+  for (var [v,w] of vals) {
+    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.mul, mulf);
+  }
+}
+
+function testFloat32x4sub() {
+  function subf(a, b) {
+    return Math.fround(Math.fround(a) - Math.fround(b));
+  }
+
+  var vals = [
+    [[1, 2, 3, 4], [10, 20, 30, 40]],
+    [[1.34, 2.95, 3.17, 4.29], [10.18, 20.43, 30.63, 40.38]],
+    [[NaN, -0, -Infinity, -Infinity], [NaN, -0, Infinity, -Infinity]]
+  ];
+
+  for (var [v,w] of vals) {
+    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.sub, subf);
+  }
+}
+
+// Helper for saturating arithmetic.
+// See SIMD.js, 5.1.25 Saturate(descriptor, x)
+function saturate(lower, upper, x) {
+    x = x | 0;
+    if (x > upper)
+        return upper;
+    if (x < lower)
+        return lower;
+    return x;
+}
+
+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);
+  }
+}
+
+function testInt8x16and() {
+  function andi(a, b) {
+    return (a & b) << 24 >> 24;
+  }
+
+  for (var [v,w] of i8x16vals) {
+    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.and, andi);
+  }
+}
+
+function testInt8x16mul() {
+  function muli(x, y) {
+    return (x * y) << 24 >> 24;
+  }
+
+  for (var [v,w] of i8x16vals) {
+    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.mul, muli);
+  }
+}
+
+function testInt8x16or() {
+  function ori(a, b) {
+    return (a | b) << 24 >> 24;
+  }
+
+  for (var [v,w] of i8x16vals) {
+    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.or, ori);
+  }
+}
+
+function testInt8x16sub() {
+  function subi(a, b) {
+    return (a - b) << 24 >> 24;
+  }
+
+  for (var [v,w] of i8x16vals) {
+    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.sub, subi);
+  }
+}
+
+function testInt8x16xor() {
+  function xori(a, b) {
+    return (a ^ b) << 24 >> 24;
+  }
+
+  for (var [v,w] of i8x16vals) {
+    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.xor, xori);
+  }
+}
+
+function testInt8x16addSaturate() {
+  function satadd(a, b) {
+    return saturate(INT8_MIN, INT8_MAX, a + b);
+  }
+
+  for (var [v,w] of i8x16vals) {
+    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.addSaturate, satadd);
+  }
+}
+
+function testInt8x16subSaturate() {
+  function satsub(a, b) {
+    return saturate(INT8_MIN, INT8_MAX, a - b);
+  }
+
+  for (var [v,w] of i8x16vals) {
+    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.subSaturate, satsub);
+  }
+}
+
+// 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);
+  }
+}
+
+function testUint8x16addSaturate() {
+  function satadd(a, b) {
+    return saturate(0, UINT8_MAX, a + b);
+  }
+
+  for (var [v,w] of i8x16vals) {
+    testBinaryFunc(Uint8x16(...v), Uint8x16(...w), Uint8x16.addSaturate, satadd);
+  }
+}
+
+function testUint8x16subSaturate() {
+  function satsub(a, b) {
+    return saturate(0, UINT8_MAX, a - b);
+  }
+
+  for (var [v,w] of i8x16vals) {
+    testBinaryFunc(Uint8x16(...v), Uint8x16(...w), Uint8x16.subSaturate, satsub);
+  }
+}
+
+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);
+  }
+}
+
+function testInt16x8and() {
+  function andi(a, b) {
+    return (a & b) << 16 >> 16;
+  }
+
+  for (var [v,w] of i16x8vals) {
+    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.and, andi);
+  }
+}
+
+function testInt16x8mul() {
+  function muli(x, y) {
+    return (x * y) << 16 >> 16;
+  }
+
+  for (var [v,w] of i16x8vals) {
+    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.mul, muli);
+  }
+}
+
+function testInt16x8or() {
+  function ori(a, b) {
+    return (a | b) << 16 >> 16;
+  }
+
+  for (var [v,w] of i16x8vals) {
+    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.or, ori);
+  }
+}
+
+function testInt16x8sub() {
+  function subi(a, b) {
+    return (a - b) << 16 >> 16;
+  }
+
+  for (var [v,w] of i16x8vals) {
+    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.sub, subi);
+  }
+}
+
+function testInt16x8xor() {
+  function xori(a, b) {
+    return (a ^ b) << 16 >> 16;
+  }
+
+  for (var [v,w] of i16x8vals) {
+    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.xor, xori);
+  }
+}
+
+function testInt16x8addSaturate() {
+  function satadd(a, b) {
+    return saturate(INT16_MIN, INT16_MAX, a + b);
+  }
+
+  for (var [v,w] of i16x8vals) {
+    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.addSaturate, satadd);
+  }
+}
+
+function testInt16x8subSaturate() {
+  function satsub(a, b) {
+    return saturate(INT16_MIN, INT16_MAX, a - b);
+  }
+
+  for (var [v,w] of i16x8vals) {
+    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.subSaturate, satsub);
+  }
+}
+
+// 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);
+  }
+}
+
+function testUint16x8addSaturate() {
+  function satadd(a, b) {
+    return saturate(0, UINT16_MAX, a + b);
+  }
+
+  for (var [v,w] of i16x8vals) {
+    testBinaryFunc(Uint16x8(...v), Uint16x8(...w), Uint16x8.addSaturate, satadd);
+  }
+}
+
+function testUint16x8subSaturate() {
+  function satsub(a, b) {
+    return saturate(0, UINT16_MAX, a - b);
+  }
+
+  for (var [v,w] of i16x8vals) {
+    testBinaryFunc(Uint16x8(...v), Uint16x8(...w), Uint16x8.subSaturate, satsub);
+  }
+}
+
+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;
+  }
+
+  for (var [v,w] of i32x4vals) {
+    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.add, addi);
+  }
+}
+
+function testInt32x4and() {
+  function andi(a, b) {
+    return (a & b) | 0;
+  }
+
+  for (var [v,w] of i32x4vals) {
+    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.and, andi);
+  }
+}
+
+function testInt32x4mul() {
+  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(Int32x4(...v), Int32x4(...w), Int32x4.mul, muli);
+  }
+}
+
+function testInt32x4or() {
+  function ori(a, b) {
+    return (a | b) | 0;
+  }
+
+  for (var [v,w] of i32x4vals) {
+    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.or, ori);
+  }
+}
+
+function testInt32x4sub() {
+  function subi(a, b) {
+    return (a - b) | 0;
+  }
+
+  for (var [v,w] of i32x4vals) {
+    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.sub, subi);
+  }
+}
+
+function testInt32x4xor() {
+  function xori(a, b) {
+    return (a ^ b) | 0;
+  }
+
+  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);
+  }
+}
+
+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]]
+];
+
+function testBool8x16and() {
+  function andb(a, b) {
+    return a && b;
+  }
+
+  for (var [v,w] of b8x16vals) {
+    testBinaryFunc(Bool8x16(...v), Bool8x16(...w), Bool8x16.and, andb);
+  }
+}
+
+function testBool8x16or() {
+  function orb(a, b) {
+    return a || b;
+  }
+
+  for (var [v,w] of b8x16vals) {
+    testBinaryFunc(Bool8x16(...v), Bool8x16(...w), Bool8x16.or, orb);
+  }
+}
+
+function testBool8x16xor() {
+  function xorb(a, b) {
+    return a != b;
+  }
+
+  for (var [v,w] of b8x16vals) {
+    testBinaryFunc(Bool8x16(...v), Bool8x16(...w), Bool8x16.xor, xorb);
+  }
+}
+
+var b16x8vals = [
+  [[true, true, true, true, false, false, false, false],
+   [false, true, false, true, false, true, false, true]]
+];
+
+function testBool16x8and() {
+  function andb(a, b) {
+    return a && b;
+  }
+
+  for (var [v,w] of b16x8vals) {
+    testBinaryFunc(Bool16x8(...v), Bool16x8(...w), Bool16x8.and, andb);
+  }
+}
+
+function testBool16x8or() {
+  function orb(a, b) {
+    return a || b;
+  }
+
+  for (var [v,w] of b16x8vals) {
+    testBinaryFunc(Bool16x8(...v), Bool16x8(...w), Bool16x8.or, orb);
+  }
+}
+
+function testBool16x8xor() {
+  function xorb(a, b) {
+    return a != b;
+  }
+
+  for (var [v,w] of b16x8vals) {
+    testBinaryFunc(Bool16x8(...v), Bool16x8(...w), Bool16x8.xor, xorb);
+  }
+}
+
+var b32x4vals = [
+  [[true, true, false, false], [false, true, false, true]]
+];
+
+function testBool32x4and() {
+  function andb(a, b) {
+    return a && b;
+  }
+
+  for (var [v,w] of b32x4vals) {
+    testBinaryFunc(Bool32x4(...v), Bool32x4(...w), Bool32x4.and, andb);
+  }
+}
+
+function testBool32x4or() {
+  function orb(a, b) {
+    return a || b;
+  }
+
+  for (var [v,w] of b32x4vals) {
+    testBinaryFunc(Bool32x4(...v), Bool32x4(...w), Bool32x4.or, orb);
+  }
+}
+
+function testBool32x4xor() {
+  function xorb(a, b) {
+    return a != b;
+  }
+
+  for (var [v,w] of b32x4vals) {
+    testBinaryFunc(Bool32x4(...v), Bool32x4(...w), Bool32x4.xor, xorb);
+  }
+}
+
+var b64x2vals = [
+  [[false, false], [false, true], [true, false], [true, true]]
+];
+
+function testBool64x2and() {
+  function andb(a, b) {
+    return a && b;
+  }
+
+  for (var [v,w] of b64x2vals) {
+    testBinaryFunc(Bool64x2(...v), Bool64x2(...w), Bool64x2.and, andb);
+  }
+}
+
+function testBool64x2or() {
+  function orb(a, b) {
+    return a || b;
+  }
+
+  for (var [v,w] of b64x2vals) {
+    testBinaryFunc(Bool64x2(...v), Bool64x2(...w), Bool64x2.or, orb);
+  }
+}
+
+function testBool64x2xor() {
+  function xorb(a, b) {
+    return a != b;
+  }
+
+  for (var [v,w] of b64x2vals) {
+    testBinaryFunc(Bool64x2(...v), Bool64x2(...w), Bool64x2.xor, xorb);
+  }
+}
+
+function test() {
+  testFloat32x4add();
+  testFloat32x4div();
+  testFloat32x4mul();
+  testFloat32x4sub();
+
+  testInt8x16add();
+  testInt8x16and();
+  testInt8x16mul();
+  testInt8x16or();
+  testInt8x16sub();
+  testInt8x16xor();
+  testInt8x16addSaturate();
+  testInt8x16subSaturate();
+
+  testUint8x16add();
+  testUint8x16and();
+  testUint8x16mul();
+  testUint8x16or();
+  testUint8x16sub();
+  testUint8x16xor();
+  testUint8x16addSaturate();
+  testUint8x16subSaturate();
+
+  testInt16x8add();
+  testInt16x8and();
+  testInt16x8mul();
+  testInt16x8or();
+  testInt16x8sub();
+  testInt16x8xor();
+  testInt16x8addSaturate();
+  testInt16x8subSaturate();
+
+  testUint16x8add();
+  testUint16x8and();
+  testUint16x8mul();
+  testUint16x8or();
+  testUint16x8sub();
+  testUint16x8xor();
+  testUint16x8addSaturate();
+  testUint16x8subSaturate();
+
+  testInt32x4add();
+  testInt32x4and();
+  testInt32x4mul();
+  testInt32x4or();
+  testInt32x4sub();
+  testInt32x4xor();
+
+  testUint32x4add();
+  testUint32x4and();
+  testUint32x4mul();
+  testUint32x4or();
+  testUint32x4sub();
+  testUint32x4xor();
+
+  testBool8x16and();
+  testBool8x16or();
+  testBool8x16xor();
+
+  testBool16x8and();
+  testBool16x8or();
+  testBool16x8xor();
+
+  testBool32x4and();
+  testBool32x4or();
+  testBool32x4xor();
+
+  testBool64x2and();
+  testBool64x2or();
+  testBool64x2xor();
+
+  if (typeof reportCompare === "function") {
+    reportCompare(true, true);
+  }
+}
+
+test();