Add m-esr52 at 52.6.0

34 files changed, 1769 insertions, 0 deletions

diff --git a/js/src/jit-test/tests/SIMD/binary-arith.js b/js/src/jit-test/tests/SIMD/binary-arith.js
new file mode 100644
index 000000000..74211d46d
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/binary-arith.js
@@ -0,0 +1,30 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function f() {
+    var i1 = SIMD.Int32x4(1, 2, 3, 4);
+    var i2 = SIMD.Int32x4(4, 3, 2, 1);
+
+    var f1 = SIMD.Float32x4(1, 2, 3, 4);
+    var f2 = SIMD.Float32x4(4, 3, 2, 1);
+
+    var i8_1 = SIMD.Int8x16(1, 2, 3, 4, 20, 30, 40, 50, 100, 115, 120, 125);
+    var i8_2 = SIMD.Int8x16(4, 3, 2, 1,  8,  7,  6,  5,  12,  11,  10,   9);
+
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Float32x4.add(f1, f2), binaryX((x, y) => x + y, f1, f2));
+        assertEqX4(SIMD.Float32x4.sub(f1, f2), binaryX((x, y) => x - y, f1, f2));
+        assertEqX4(SIMD.Float32x4.mul(f1, f2), binaryX((x, y) => x * y, f1, f2));
+
+        assertEqX4(SIMD.Int32x4.add(i1, i2), binaryX((x, y) => x + y, i1, i2));
+        assertEqX4(SIMD.Int32x4.sub(i1, i2), binaryX((x, y) => x - y, i1, i2));
+        assertEqX4(SIMD.Int32x4.mul(i1, i2), binaryX((x, y) => x * y, i1, i2));
+
+        assertEqX4(SIMD.Int8x16.add(i8_1, i8_2), binaryX((x, y) => (x + y) << 24 >> 24, i8_1, i8_2));
+        assertEqX4(SIMD.Int8x16.sub(i8_1, i8_2), binaryX((x, y) => (x - y) << 24 >> 24, i8_1, i8_2));
+        assertEqX4(SIMD.Int8x16.mul(i8_1, i8_2), binaryX((x, y) => (x * y) << 24 >> 24, i8_1, i8_2));
+    }
+}
+
+f();
diff --git a/js/src/jit-test/tests/SIMD/bool32x4-arith.js b/js/src/jit-test/tests/SIMD/bool32x4-arith.js
new file mode 100644
index 000000000..bafceefa9
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bool32x4-arith.js
@@ -0,0 +1,15 @@
+load(libdir + "simd.js");
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function f() {
+    var b1 = SIMD.Bool32x4(true, false, true, false);
+    var b2 = SIMD.Bool32x4(true, true, true, true);
+    do {
+        assertEqX4(SIMD.Bool32x4.and(b1, b2), booleanBinaryX4((x, y) => x && y, b1, b2));
+        assertEqX4(SIMD.Bool32x4.or(b1, b2),  booleanBinaryX4((x, y) => x || y, b1, b2));
+        assertEqX4(SIMD.Bool32x4.xor(b1, b2), booleanBinaryX4((x, y) => x != y, b1, b2));
+    } while (!inIon());
+}
+
+f();
diff --git a/js/src/jit-test/tests/SIMD/bool32x4-const.js b/js/src/jit-test/tests/SIMD/bool32x4-const.js
new file mode 100644
index 000000000..54bada215
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bool32x4-const.js
@@ -0,0 +1,65 @@
+load(libdir + "simd.js");
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+// Test constant folding into the Bool32x4 constructor.
+// Verify that we get the truthiness right, c.f. the ECMA ToBoolean() function.
+function f1() {
+    var B = SIMD.Bool32x4;
+    var S = SIMD.Bool32x4.splat;
+    return [
+        B(false, false, false, true),
+        B(true),
+        B(undefined, null, "", "x"),
+        B({}, 0, 1, -0.0),
+        B(NaN, -NaN, Symbol(), objectEmulatingUndefined()),
+
+        S(false),
+        S(true),
+        S(undefined),
+        S(null),
+
+        S(""),
+        S("x"),
+        S(0),
+        S(1),
+
+        S({}),
+        S(-0.0),
+        S(NaN),
+        S(Symbol()),
+
+        S(objectEmulatingUndefined())
+    ];
+}
+
+function f() {
+    for (var i = 0; i < 100; i++) {
+        var a = f1()
+        assertEqX4(a[0], [false, false, false, true]);
+        assertEqX4(a[1], [true,  false, false, false]);
+        assertEqX4(a[2], [false, false, false, true]);
+        assertEqX4(a[3], [true,  false, true,  false]);
+        assertEqX4(a[4], [false, false, true,  false]);
+
+        // Splats.
+        assertEqX4(a[5], [false, false, false, false]);
+        assertEqX4(a[6], [true, true, true, true]);
+        assertEqX4(a[7], [false, false, false, false]);
+        assertEqX4(a[8], [false, false, false, false]);
+
+        assertEqX4(a[9], [false, false, false, false]);
+        assertEqX4(a[10], [true, true, true, true]);
+        assertEqX4(a[11], [false, false, false, false]);
+        assertEqX4(a[12], [true, true, true, true]);
+
+        assertEqX4(a[13], [true, true, true, true]);
+        assertEqX4(a[14], [false, false, false, false]);
+        assertEqX4(a[15], [false, false, false, false]);
+        assertEqX4(a[16], [true, true, true, true]);
+
+        assertEqX4(a[17], [false, false, false, false]);
+    }
+}
+
+f();
diff --git a/js/src/jit-test/tests/SIMD/bug1109911.js b/js/src/jit-test/tests/SIMD/bug1109911.js
new file mode 100644
index 000000000..23a5c5721
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug1109911.js
@@ -0,0 +1,11 @@
+if (typeof TypedObject === "undefined" || typeof SIMD === 'undefined')
+  quit();
+
+var Int32x4 = SIMD.Int32x4;
+var a = Int32x4((4294967295), 200, 300, 400);
+addCase( new Array(Math.pow(2,12)) );
+for ( var arg = "", i = 0; i < Math.pow(2,12); i++ ) {}
+addCase( a );
+function addCase(object) {
+  object.length
+}
diff --git a/js/src/jit-test/tests/SIMD/bug1121299.js b/js/src/jit-test/tests/SIMD/bug1121299.js
new file mode 100644
index 000000000..17ca46e2e
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug1121299.js
@@ -0,0 +1,31 @@
+if (!this.hasOwnProperty("SIMD"))
+  quit();
+
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 30);
+
+function test_1(i) {
+  if (i >= 40)
+    return;
+  var a = SIMD.Float32x4(1.1, 2.2, 3.3, 4.6);
+  SIMD.Int32x4.fromFloat32x4(a);
+  test_1(i + 1);
+}
+test_1(0);
+
+
+var Float32x4 = SIMD.Float32x4;
+function test_2() {
+    var Array = Float32x4.array(3);
+    var array = new Array([
+        Float32x4(1, 2, 3, 4),
+        Float32x4(5, 6, 7, 8),
+        Float32x4(9, 10, 11, 12)
+    ]);
+    if (typeof reportCompare === "function")
+        reportCompare(true, true);
+}
+test_2();
+evaluate("test_2(); test_2();", {
+    isRunOnce: true,
+});
diff --git a/js/src/jit-test/tests/SIMD/bug1123631.js b/js/src/jit-test/tests/SIMD/bug1123631.js
new file mode 100644
index 000000000..28c0e0aa1
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug1123631.js
@@ -0,0 +1,9 @@
+if (!this.hasOwnProperty("SIMD"))
+  quit();
+
+var Float64x2 = SIMD.Float64x2;
+function test() {
+  var a = Float64x2(1, 2);
+}
+test();
+test();
diff --git a/js/src/jit-test/tests/SIMD/bug1130845.js b/js/src/jit-test/tests/SIMD/bug1130845.js
new file mode 100644
index 000000000..2baf3865d
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug1130845.js
@@ -0,0 +1,15 @@
+if (!this.hasOwnProperty("SIMD"))
+  quit();
+
+var Int32x4 = SIMD.Int32x4;
+function test() {
+  var a = Int32x4();
+  var b = Int32x4(10, 20, 30, 40);
+  var c = SIMD.Int32x4.and(a, b);
+  assertEq(Int32x4.extractLane(c, 0), 0);
+  return 0;
+}
+test();
+var u = [], v = [];
+for (var j=0; j<u.length; ++j)
+    v[test()] = t;
diff --git a/js/src/jit-test/tests/SIMD/bug1241872.js b/js/src/jit-test/tests/SIMD/bug1241872.js
new file mode 100644
index 000000000..c36ebcc6b
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug1241872.js
@@ -0,0 +1,10 @@
+if (typeof SIMD !== 'object')
+    quit(0);
+
+function test() {
+    return SIMD.Float32x4().toSource();
+}
+
+var r = '';
+for (var i = 0; i < 10000; i++)
+    r = test();
diff --git a/js/src/jit-test/tests/SIMD/bug1248503.js b/js/src/jit-test/tests/SIMD/bug1248503.js
new file mode 100644
index 000000000..e121cea1d
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug1248503.js
@@ -0,0 +1,16 @@
+if (typeof SIMD !== 'object')
+    quit(0);
+
+function assertEqVec(v, w) {
+    [0].forEach(i => v, w);
+    function assertEqX4(...opts) {}
+}
+gczeal(1);
+function f() {
+    SIMD.Float32x4();
+    var i1 = SIMD.Int32x4();
+    for (j = 0; j < 100000; ++j, eval.eval)
+        assertEqVec(SIMD.Int32x4.check(i1), i1);
+}
+f();
+
diff --git a/js/src/jit-test/tests/SIMD/bug1273483.js b/js/src/jit-test/tests/SIMD/bug1273483.js
new file mode 100644
index 000000000..3c9386b4f
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug1273483.js
@@ -0,0 +1,9 @@
+if (typeof SIMD === 'undefined')
+    quit();
+
+Int8x16 = SIMD.Int8x16;
+var Int32x4 = SIMD.Int32x4;
+function testSwizzleForType(type) type();
+testSwizzleForType(Int8x16);
+function testSwizzleInt32x4() testSwizzleForType(Int32x4);
+testSwizzleInt32x4();
diff --git a/js/src/jit-test/tests/SIMD/bug1296640-gc-args.js b/js/src/jit-test/tests/SIMD/bug1296640-gc-args.js
new file mode 100644
index 000000000..4dbe95410
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug1296640-gc-args.js
@@ -0,0 +1,9 @@
+if (typeof gczeal === 'undefined' || typeof SIMD === 'undefined') {
+    quit();
+}
+
+gczeal(9, 2);
+var Int8x16 = SIMD.Int8x16;
+var v = Int8x16();
+var good = { valueOf: () => 21 };
+Int8x16.shiftLeftByScalar(v, good);
diff --git a/js/src/jit-test/tests/SIMD/bug1303780-gc-args.js b/js/src/jit-test/tests/SIMD/bug1303780-gc-args.js
new file mode 100644
index 000000000..a894d532e
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug1303780-gc-args.js
@@ -0,0 +1,12 @@
+if (typeof gczeal === 'undefined' || typeof SIMD === 'undefined') {
+    quit();
+}
+
+gczeal(14,2);
+var Float32x4 = SIMD.Float32x4;
+function test() {
+    var v = Float32x4(1,2,3,4);
+    var good = {valueOf: () => 42};
+    Float32x4.replaceLane(v, 0, good);
+}
+test();
diff --git a/js/src/jit-test/tests/SIMD/bug953108.js b/js/src/jit-test/tests/SIMD/bug953108.js
new file mode 100644
index 000000000..a8ae80e17
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/bug953108.js
@@ -0,0 +1,10 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+if (!this.hasOwnProperty("TypedObject") || !this.hasOwnProperty("SIMD"))
+  quit();
+
+var Float32x4 = SIMD.Float32x4;
+Float32x4.array(1);
diff --git a/js/src/jit-test/tests/SIMD/check.js b/js/src/jit-test/tests/SIMD/check.js
new file mode 100644
index 000000000..bef0b6c68
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/check.js
@@ -0,0 +1,25 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function f() {
+    var f1 = SIMD.Float32x4(1, 2, 3, 4);
+    var i1 = SIMD.Int32x4(1, 2, -3, 4);
+    var b1 = SIMD.Bool32x4(true, true, false, true);
+    var i = 0;
+    try {
+        for (; i < 150; i++) {
+            if (i > 148)
+                i1 = f1;
+            assertEqVec(SIMD.Int32x4.check(i1), i1);
+            assertEqVec(SIMD.Float32x4.check(f1), f1);
+            assertEqVec(SIMD.Bool32x4.check(b1), b1);
+        }
+    } catch (ex) {
+        assertEq(i, 149);
+        assertEq(ex instanceof TypeError, true);
+    }
+}
+
+f();
+
diff --git a/js/src/jit-test/tests/SIMD/compare.js b/js/src/jit-test/tests/SIMD/compare.js
new file mode 100644
index 000000000..21dca20cd
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/compare.js
@@ -0,0 +1,39 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function f() {
+    var f1 = SIMD.Float32x4(1, 2, 3, 4);
+    var f2 = SIMD.Float32x4(NaN, Infinity, 3.14, -0);
+
+    var i1 = SIMD.Int32x4(1, 2, -3, 4);
+    var i2 = SIMD.Int32x4(1, -2, 3, 0);
+
+    var u1 = SIMD.Uint32x4(1, 2, -3, 4);
+    var u2 = SIMD.Uint32x4(1, -2, 3, 0x80000000);
+
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Int32x4.lessThan(i1, i2),             [false, false, true, false]);
+        assertEqX4(SIMD.Int32x4.lessThanOrEqual(i1, i2),      [true, false, true, false]);
+        assertEqX4(SIMD.Int32x4.equal(i1, i2),                [true, false, false, false]);
+        assertEqX4(SIMD.Int32x4.notEqual(i1, i2),             [false, true, true, true]);
+        assertEqX4(SIMD.Int32x4.greaterThan(i1, i2),          [false, true, false, true]);
+        assertEqX4(SIMD.Int32x4.greaterThanOrEqual(i1, i2),   [true, true, false, true]);
+
+        assertEqX4(SIMD.Uint32x4.lessThan(u1, u2),             [false, true, false, true]);
+        assertEqX4(SIMD.Uint32x4.lessThanOrEqual(u1, u2),      [true,  true, false, true]);
+        assertEqX4(SIMD.Uint32x4.equal(u1, u2),                [true, false, false, false]);
+        assertEqX4(SIMD.Uint32x4.notEqual(u1, u2),             [false, true, true, true]);
+        assertEqX4(SIMD.Uint32x4.greaterThan(u1, u2),          [false, false, true, false]);
+        assertEqX4(SIMD.Uint32x4.greaterThanOrEqual(u1, u2),   [true, false, true, false]);
+
+        assertEqX4(SIMD.Float32x4.lessThan(f1, f2),             [false, true, true, false]);
+        assertEqX4(SIMD.Float32x4.lessThanOrEqual(f1, f2),      [false, true, true, false]);
+        assertEqX4(SIMD.Float32x4.equal(f1, f2),                [false, false, false, false]);
+        assertEqX4(SIMD.Float32x4.notEqual(f1, f2),             [true, true, true, true]);
+        assertEqX4(SIMD.Float32x4.greaterThan(f1, f2),          [false, false, false, true]);
+        assertEqX4(SIMD.Float32x4.greaterThanOrEqual(f1, f2),   [false, false, false, true]);
+    }
+}
+
+f();
diff --git a/js/src/jit-test/tests/SIMD/complex-4.js b/js/src/jit-test/tests/SIMD/complex-4.js
new file mode 100644
index 000000000..ca5e8b0f6
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/complex-4.js
@@ -0,0 +1,70 @@
+load(libdir + 'simd.js');
+
+if (typeof SIMD === "undefined")
+    quit();
+
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 90);
+var max = 100; // Make have the warm-up counter high enough to
+               // consider inlining functions.
+
+var f4 = SIMD.Int32x4; // :TODO: Support Float32x4 arith.
+var f4add = f4.add;
+var f4sub = f4.sub;
+var f4mul = f4.mul;
+
+function c4mul(z1, z2) {
+  var { re: re1, im: im1 } = z1;
+  var { re: re2, im: im2 } = z2;
+  var rere = f4mul(re1, re2);
+  var reim = f4mul(re1, im2);
+  var imre = f4mul(im1, re2);
+  var imim = f4mul(im1, im2);
+  return { re: f4sub(rere, imim), im: f4add(reim, imre) };
+}
+
+function c4inv(z) {
+  var { re: re, im: im } = z;
+  var minus = f4(-1, -1, -1, -1);
+  return { re: re, im: f4mul(im, minus) };
+}
+
+function c4inv_inplace(z) {
+  var res = c4inv(z);
+  z.re = res.re;
+  z.im = res.im;
+}
+
+function c4norm(z) {
+  var { re: re, im: im } = c4mul(z, c4inv(z));
+  return re;
+}
+
+function c4scale(z, s) {
+  var { re: re, im: im } = z;
+  var f4s = f4(s, s, s, s);
+  return { re: f4mul(re, f4s), im: f4mul(im, f4s) };
+}
+
+var rotate90 = { re: f4(0, 0, 0, 0), im: f4(1, 1, 1, 1) };
+var cardinals = { re: f4(1, 0, -1, 0), im: f4(0, 1, 0, -1) };
+
+function test(dots) {
+  for (var j = 0; j < 4; j++) {
+    dots = c4mul(rotate90, dots);
+    if (j % 2 == 0) // Magic !
+      c4inv_inplace(dots);
+    dots = c4scale(dots, 2);
+  }
+  return dots;
+}
+
+assertEqX4(c4norm(cardinals), simdToArray(f4.splat(1)));
+var cardinals16 = c4scale(cardinals, 16);
+
+for (var i = 0; i < max; i++) {
+  var res = test(cardinals);
+  assertEqX4(c4norm(res), simdToArray(f4.splat(16 * 16)));
+  assertEqX4(res.re, simdToArray(cardinals16.re));
+  assertEqX4(res.im, simdToArray(cardinals16.im));
+}
diff --git a/js/src/jit-test/tests/SIMD/convert.js b/js/src/jit-test/tests/SIMD/convert.js
new file mode 100644
index 000000000..b27a041e7
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/convert.js
@@ -0,0 +1,68 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 30);
+
+var cast = (function() {
+    var i32 = new Int32Array(1);
+    var f32 = new Float32Array(i32.buffer);
+    return {
+        fromInt32Bits(x) {
+            i32[0] = x;
+            return f32[0];
+        },
+
+        fromFloat32Bits(x) {
+            f32[0] = x;
+            return i32[0];
+        }
+    }
+})();
+
+function f() {
+    // No bailout here.
+    var f4 = SIMD.Float32x4(1, 2, 3, 4);
+    var i4 = SIMD.Int32x4(1, 2, 3, 4);
+    var BitOrZero = (x) => x | 0;
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Float32x4.fromInt32x4(i4), unaryX4(BitOrZero, f4, Math.fround));
+        assertEqX4(SIMD.Float32x4.fromInt32x4Bits(i4), unaryX4(cast.fromInt32Bits, f4, Math.fround));
+        assertEqX4(SIMD.Int32x4.fromFloat32x4(f4), unaryX4(Math.fround, i4, BitOrZero));
+        assertEqX4(SIMD.Int32x4.fromFloat32x4Bits(f4), unaryX4(cast.fromFloat32Bits, i4, BitOrZero));
+    }
+}
+
+function uglyDuckling(val) {
+    // We bail out when i == 149 because the conversion will return
+    // 0x80000000 and the input actually wasn't in bounds.
+    val = Math.fround(val);
+    for (var i = 0; i < 150; i++) {
+        var caught = false;
+        try {
+            var v = SIMD.Float32x4(i < 149 ? 0 : val, 0, 0, 0)
+            SIMD.Int32x4.fromFloat32x4(v);
+        } catch(e) {
+            assertEq(e instanceof RangeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+}
+
+function dontBail() {
+    // On x86, the conversion will return 0x80000000, which will imply that we
+    // check the input values. However, we shouldn't bail out in this case.
+    for (var i = 0; i < 150; i++) {
+        var v = SIMD.Float32x4(i < 149 ? 0 : -Math.pow(2, 31), 0, 0, 0)
+        SIMD.Int32x4.fromFloat32x4(v);
+    }
+}
+
+f();
+
+dontBail();
+dontBail();
+
+uglyDuckling(Math.pow(2, 31));
+uglyDuckling(NaN);
+uglyDuckling(-Math.pow(2, 32));
diff --git a/js/src/jit-test/tests/SIMD/float32x4-binary-arith.js b/js/src/jit-test/tests/SIMD/float32x4-binary-arith.js
new file mode 100644
index 000000000..63e9215d9
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/float32x4-binary-arith.js
@@ -0,0 +1,33 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function maxNum(x, y) {
+    if (x != x)
+        return y;
+    if (y != y)
+        return x;
+    return Math.max(x, y);
+}
+
+function minNum(x, y) {
+    if (x != x)
+        return y;
+    if (y != y)
+        return x;
+    return Math.min(x, y);
+}
+
+function f() {
+    var f1 = SIMD.Float32x4(1, 2, 3, 4);
+    var f2 = SIMD.Float32x4(4, 3, 2, 1);
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Float32x4.div(f1, f2), binaryX((x, y) => x / y, f1, f2));
+        assertEqX4(SIMD.Float32x4.min(f1, f2), binaryX(Math.min, f1, f2));
+        assertEqX4(SIMD.Float32x4.max(f1, f2), binaryX(Math.max, f1, f2));
+        assertEqX4(SIMD.Float32x4.minNum(f1, f2), binaryX(minNum, f1, f2));
+        assertEqX4(SIMD.Float32x4.maxNum(f1, f2), binaryX(maxNum, f1, f2));
+    }
+}
+
+f();
diff --git a/js/src/jit-test/tests/SIMD/getters.js b/js/src/jit-test/tests/SIMD/getters.js
new file mode 100644
index 000000000..5a895bbe2
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/getters.js
@@ -0,0 +1,48 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function f() {
+    var i4 = SIMD.Int32x4(1, -2, 3, -4);
+    var u4 = SIMD.Uint32x4(1, -2, 3, 0x88000000);
+    var b4 = SIMD.Bool32x4(true, true, false, true);
+
+
+    var bt4 = SIMD.Bool32x4(true, true, true, true);
+    var bf4 = SIMD.Bool32x4(false, false, false, false);
+
+    var v = Math.fround(13.37);
+    var f4 = SIMD.Float32x4(13.37, NaN, Infinity, -0);
+
+    for (var i = 0; i < 150; i++) {
+        assertEq(SIMD.Int32x4.extractLane(i4, 0), 1);
+        assertEq(SIMD.Int32x4.extractLane(i4, 1), -2);
+        assertEq(SIMD.Int32x4.extractLane(i4, 2), 3);
+        assertEq(SIMD.Int32x4.extractLane(i4, 3), -4);
+
+        assertEq(SIMD.Uint32x4.extractLane(u4, 0), 1);
+        assertEq(SIMD.Uint32x4.extractLane(u4, 1), -2 >>> 0);
+        assertEq(SIMD.Uint32x4.extractLane(u4, 2), 3);
+        assertEq(SIMD.Uint32x4.extractLane(u4, 3), 0x88000000);
+
+        assertEq(SIMD.Float32x4.extractLane(f4, 0), v);
+        assertEq(SIMD.Float32x4.extractLane(f4, 1), NaN);
+        assertEq(SIMD.Float32x4.extractLane(f4, 2), Infinity);
+        assertEq(SIMD.Float32x4.extractLane(f4, 3), -0);
+
+        assertEq(SIMD.Bool32x4.extractLane(b4, 0), true);
+        assertEq(SIMD.Bool32x4.extractLane(b4, 1), true);
+        assertEq(SIMD.Bool32x4.extractLane(b4, 2), false);
+        assertEq(SIMD.Bool32x4.extractLane(b4, 3), true);
+
+        assertEq(SIMD.Bool32x4.anyTrue(b4), true);
+        assertEq(SIMD.Bool32x4.allTrue(b4), false);
+
+        assertEq(SIMD.Bool32x4.anyTrue(bt4), true);
+        assertEq(SIMD.Bool32x4.allTrue(bt4), true);
+        assertEq(SIMD.Bool32x4.anyTrue(bf4), false);
+        assertEq(SIMD.Bool32x4.allTrue(bf4), false);
+    }
+}
+
+f();
diff --git a/js/src/jit-test/tests/SIMD/inline-missing-arguments.js b/js/src/jit-test/tests/SIMD/inline-missing-arguments.js
new file mode 100644
index 000000000..5ef91d072
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/inline-missing-arguments.js
@@ -0,0 +1,81 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function test(i) {
+    assertEqX4(SIMD.Int32x4(),              [0, 0, 0, 0]);
+    assertEqX4(SIMD.Int32x4(i),             [i, 0, 0, 0]);
+    assertEqX4(SIMD.Int32x4(i, 1),          [i, 1, 0, 0]);
+    assertEqX4(SIMD.Int32x4(i, 1, 2),       [i, 1, 2, 0]);
+    assertEqX4(SIMD.Int32x4(i, 1, 2, 3),    [i, 1, 2, 3]);
+    assertEqX4(SIMD.Int32x4(i, 1, 2, 3, 4), [i, 1, 2, 3]);
+
+    assertEqVecArr(SIMD.Int16x8(),              [0, 0, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int16x8(i),             [i, 0, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int16x8(i, 1),          [i, 1, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int16x8(i, 1, 2),       [i, 1, 2, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int16x8(i, 1, 2, 3),    [i, 1, 2, 3, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int16x8(i, 1, 2, 3, 4), [i, 1, 2, 3, 4, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int16x8(i, 1, 2, 3, 4, 5, 6),
+                               [i, 1, 2, 3, 4, 5, 6, 0]);
+    j = i & 32
+    assertEqVecArr(SIMD.Int8x16(),              [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int8x16(j),             [j, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int8x16(j, 1),          [j, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int8x16(j, 1, 2),       [j, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int8x16(j, 1, 2, 3),    [j, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int8x16(j, 1, 2, 3, 4), [j, 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int8x16(j, 1, 2, 3, 4, 5, 6),
+                               [j, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    assertEqVecArr(SIMD.Int8x16(j, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12),
+                               [j, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0, 0, 0]);
+
+    assertEqX4(SIMD.Float32x4(),                [NaN, NaN, NaN, NaN]);
+    assertEqX4(SIMD.Float32x4(i),               [i,   NaN, NaN, NaN]);
+    assertEqX4(SIMD.Float32x4(i, 1),            [i,   1,   NaN, NaN]);
+    assertEqX4(SIMD.Float32x4(i, 1, 2),         [i,   1,   2,   NaN]);
+    assertEqX4(SIMD.Float32x4(i, 1, 2, 3),      [i,   1,   2,   3  ]);
+    assertEqX4(SIMD.Float32x4(i, 1, 2, 3, 4),   [i,   1,   2,   3  ]);
+
+    var b = i % 2 > 0 ;
+    assertEqX4(SIMD.Bool32x4(),                           [false, false, false, false]);
+    assertEqX4(SIMD.Bool32x4(b),                          [b,     false, false, false]);
+    assertEqX4(SIMD.Bool32x4(b, true),                    [b,     true,  false, false]);
+    assertEqX4(SIMD.Bool32x4(b, false, true),             [b,     false, true,  false]);
+    assertEqX4(SIMD.Bool32x4(b, false, true, true),       [b,     false, true,  true ]);
+    assertEqX4(SIMD.Bool32x4(b, false, true, true, true), [b,     false, true,  true ]);
+
+    assertEqVecArr(SIMD.Bool16x8(),
+                                [false, false, false, false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool16x8(b),
+                                [b,     false, false, false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool16x8(b,     true),
+                                [b,     true,  false, false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool16x8(b,     false, true),
+                                [b,     false, true,  false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool16x8(b,     false, true,  true),
+                                [b,     false, true,  true,  false, false, false, false]);
+    assertEqVecArr(SIMD.Bool16x8(b,     false, true,  true,  true),
+                                [b,     false, true,  true,  true,  false, false, false]);
+    assertEqVecArr(SIMD.Bool16x8(b,     false, true,  true,  true,  true),
+                                [b,     false, true,  true,  true,  true,  false, false]);
+
+    assertEqVecArr(SIMD.Bool8x16(),
+                                [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool8x16(b),
+                                [b,     false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool8x16(b,     true),
+                                [b,     true,  false, false, false, false, false, false, false, false, false, false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool8x16(b,     false, true),
+                                [b,     false, true,  false, false, false, false, false, false, false, false, false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool8x16(b,     false, true,  true),
+                                [b,     false, true,  true,  false, false, false, false, false, false, false, false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool8x16(b,     false, true,  true,  true),
+                                [b,     false, true,  true,  true,  false, false, false, false, false, false, false, false, false, false, false]);
+    assertEqVecArr(SIMD.Bool8x16(b,     false, true,  true,  true,  true,  false, true,  true,  true),
+                                [b,     false, true,  true,  true,  true,  false, true,  true,  true,  false, false, false, false, false, false]);
+}
+
+for(var i=0; i<300; i++) {
+    test(i);
+}
diff --git a/js/src/jit-test/tests/SIMD/load.js b/js/src/jit-test/tests/SIMD/load.js
new file mode 100644
index 000000000..5cdb8cce6
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/load.js
@@ -0,0 +1,123 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 40);
+
+function f() {
+    var f32 = new Float32Array(16);
+    for (var i = 0; i < 16; i++)
+        f32[i] = i + 1;
+
+    var f64 = new Float64Array(f32.buffer);
+    var i32 = new Int32Array(f32.buffer);
+    var u32 = new Uint32Array(f32.buffer);
+    var i16 = new Int16Array(f32.buffer);
+    var u16 = new Uint16Array(f32.buffer);
+    var i8  = new Int8Array(f32.buffer);
+    var u8  = new Uint8Array(f32.buffer);
+
+    function testLoad() {
+        assertEqX4(SIMD.Float32x4.load(f64, 0),      [1,2,3,4]);
+        assertEqX4(SIMD.Float32x4.load(f32, 1),      [2,3,4,5]);
+        assertEqX4(SIMD.Float32x4.load(i32, 2),      [3,4,5,6]);
+        assertEqX4(SIMD.Float32x4.load(i16, 3 << 1), [4,5,6,7]);
+        assertEqX4(SIMD.Float32x4.load(u16, 4 << 1), [5,6,7,8]);
+        assertEqX4(SIMD.Float32x4.load(i8 , 5 << 2), [6,7,8,9]);
+        assertEqX4(SIMD.Float32x4.load(u8 , 6 << 2), [7,8,9,10]);
+
+        assertEqX4(SIMD.Float32x4.load(f64, (16 >> 1) - (4 >> 1)), [13,14,15,16]);
+        assertEqX4(SIMD.Float32x4.load(f32, 16 - 4),               [13,14,15,16]);
+        assertEqX4(SIMD.Float32x4.load(i32, 16 - 4),               [13,14,15,16]);
+        assertEqX4(SIMD.Float32x4.load(i16, (16 << 1) - (4 << 1)), [13,14,15,16]);
+        assertEqX4(SIMD.Float32x4.load(u16, (16 << 1) - (4 << 1)), [13,14,15,16]);
+        assertEqX4(SIMD.Float32x4.load(i8,  (16 << 2) - (4 << 2)), [13,14,15,16]);
+        assertEqX4(SIMD.Float32x4.load(u8,  (16 << 2) - (4 << 2)), [13,14,15,16]);
+    }
+
+    function testLoad1() {
+        assertEqX4(SIMD.Float32x4.load1(f64, 0),      [1,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(f32, 1),      [2,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(i32, 2),      [3,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(i16, 3 << 1), [4,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(u16, 4 << 1), [5,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(i8 , 5 << 2), [6,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(u8 , 6 << 2), [7,0,0,0]);
+
+        assertEqX4(SIMD.Float32x4.load1(f64, (16 >> 1) - (4 >> 1)), [13,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(f32, 16 - 4),               [13,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(i32, 16 - 4),               [13,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(i16, (16 << 1) - (4 << 1)), [13,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(u16, (16 << 1) - (4 << 1)), [13,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(i8,  (16 << 2) - (4 << 2)), [13,0,0,0]);
+        assertEqX4(SIMD.Float32x4.load1(u8,  (16 << 2) - (4 << 2)), [13,0,0,0]);
+    }
+
+    function testLoad2() {
+        assertEqX4(SIMD.Float32x4.load2(f64, 0),      [1,2,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(f32, 1),      [2,3,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(i32, 2),      [3,4,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(i16, 3 << 1), [4,5,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(u16, 4 << 1), [5,6,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(i8 , 5 << 2), [6,7,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(u8 , 6 << 2), [7,8,0,0]);
+
+        assertEqX4(SIMD.Float32x4.load2(f64, (16 >> 1) - (4 >> 1)), [13,14,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(f32, 16 - 4),               [13,14,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(i32, 16 - 4),               [13,14,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(i16, (16 << 1) - (4 << 1)), [13,14,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(u16, (16 << 1) - (4 << 1)), [13,14,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(i8,  (16 << 2) - (4 << 2)), [13,14,0,0]);
+        assertEqX4(SIMD.Float32x4.load2(u8,  (16 << 2) - (4 << 2)), [13,14,0,0]);
+    }
+
+    function testLoad3() {
+        assertEqX4(SIMD.Float32x4.load3(f64, 0),      [1,2,3,0]);
+        assertEqX4(SIMD.Float32x4.load3(f32, 1),      [2,3,4,0]);
+        assertEqX4(SIMD.Float32x4.load3(i32, 2),      [3,4,5,0]);
+        assertEqX4(SIMD.Float32x4.load3(i16, 3 << 1), [4,5,6,0]);
+        assertEqX4(SIMD.Float32x4.load3(u16, 4 << 1), [5,6,7,0]);
+        assertEqX4(SIMD.Float32x4.load3(i8 , 5 << 2), [6,7,8,0]);
+        assertEqX4(SIMD.Float32x4.load3(u8 , 6 << 2), [7,8,9,0]);
+
+        assertEqX4(SIMD.Float32x4.load3(f64, (16 >> 1) - (4 >> 1)), [13,14,15,0]);
+        assertEqX4(SIMD.Float32x4.load3(f32, 16 - 4),               [13,14,15,0]);
+        assertEqX4(SIMD.Float32x4.load3(i32, 16 - 4),               [13,14,15,0]);
+        assertEqX4(SIMD.Float32x4.load3(i16, (16 << 1) - (4 << 1)), [13,14,15,0]);
+        assertEqX4(SIMD.Float32x4.load3(u16, (16 << 1) - (4 << 1)), [13,14,15,0]);
+        assertEqX4(SIMD.Float32x4.load3(i8,  (16 << 2) - (4 << 2)), [13,14,15,0]);
+        assertEqX4(SIMD.Float32x4.load3(u8,  (16 << 2) - (4 << 2)), [13,14,15,0]);
+    }
+
+    for (var i = 0; i < 150; i++) {
+        testLoad();
+        testLoad1();
+        testLoad2();
+        testLoad3();
+    }
+}
+
+f();
+
+function testBailout(uglyDuckling) {
+    var f32 = new Float32Array(16);
+    for (var i = 0; i < 16; i++)
+        f32[i] = i + 1;
+
+    var i8  = new Int8Array(f32.buffer);
+
+    for (var i = 0; i < 150; i++) {
+        var caught = false;
+        try {
+            SIMD.Float32x4.load(i8, (i < 149) ? 0 : uglyDuckling);
+        } catch (e) {
+            print(e);
+            assertEq(e instanceof RangeError, true);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+}
+
+print('Testing range checks...');
+testBailout(-1);
+testBailout(-15);
+testBailout(12 * 4 + 1);
diff --git a/js/src/jit-test/tests/SIMD/nursery-overflow.js b/js/src/jit-test/tests/SIMD/nursery-overflow.js
new file mode 100644
index 000000000..5aecff908
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/nursery-overflow.js
@@ -0,0 +1,29 @@
+load(libdir + 'simd.js');
+
+if (typeof SIMD === "undefined")
+    quit();
+
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 30);
+
+var i4 = SIMD.Int32x4;
+var i4sub = SIMD.Int32x4.sub;
+
+function simdbox(i) {
+  return i4(i, i, i, i);
+}
+
+function test() {
+  var arr = [];
+
+  // overflow the nursery with live SIMD objects.
+  for (var i = 0; i < 100000; i++) {
+    arr.push(simdbox(i));
+  }
+
+  return arr;
+}
+
+var arr = test();
+for (var i = 0; i < arr.length; i++)
+  assertEqX4(arr[i], [i, i, i, i]);
diff --git a/js/src/jit-test/tests/SIMD/recover.js b/js/src/jit-test/tests/SIMD/recover.js
new file mode 100644
index 000000000..a8fb0002e
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/recover.js
@@ -0,0 +1,70 @@
+load(libdir + 'simd.js');
+
+if (!this.hasOwnProperty("SIMD"))
+  quit();
+
+// This test case ensure that if we are able to optimize SIMD, then we can use
+// recover instructions to get rid of the allocations. So, there is no value
+// (and the test case would fail) if we are not able to inline SIMD
+// constructors.
+if (!isSimdAvailable())
+  quit();
+
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 20);
+
+// This function is used to cause an invalidation after having removed a branch
+// after DCE.  This is made to check if we correctly recover an array
+// allocation.
+var uceFault = function (i) {
+    if (i > 98)
+        uceFault = function (i) { return true; };
+    return false;
+};
+
+// Check that we can correctly recover a boxed value.
+var uceFault_simdBox_i4 = eval(uneval(uceFault).replace('uceFault', 'uceFault_simdBox_i4'));
+function simdBox_i4(i) {
+    var a = SIMD.Int32x4(i, i, i, i);
+    if (uceFault_simdBox_i4(i) || uceFault_simdBox_i4(i))
+        assertEqX4(a, [i, i, i, i]);
+    assertRecoveredOnBailout(a, true);
+    return 0;
+}
+
+var uceFault_simdBox_u4 = eval(uneval(uceFault).replace('uceFault', 'uceFault_simdBox_u4'));
+function simdBox_u4(i) {
+    var a = SIMD.Uint32x4(i, 98 - i, i + 0x7ffffff0, i + 0xffffff00);
+    if (uceFault_simdBox_u4(i) || uceFault_simdBox_u4(i))
+        assertEqX4(a, [i, 98 - i, i + 0x7ffffff0, i + 0xffffff00].map(x => x >>> 0));
+    assertRecoveredOnBailout(a, true);
+    return 0;
+}
+
+var uceFault_simdBox_f4 = eval(uneval(uceFault).replace('uceFault', 'uceFault_simdBox_f4'));
+function simdBox_f4(i) {
+    var a = SIMD.Float32x4(i, i + 0.1, i + 0.2, i + 0.3);
+    if (uceFault_simdBox_f4(i) || uceFault_simdBox_f4(i))
+        assertEqX4(a, [i, i + 0.1, i + 0.2, i + 0.3].map(Math.fround));
+    assertRecoveredOnBailout(a, true);
+    return 0;
+}
+
+var uceFault_simdBox_b4 = eval(uneval(uceFault).replace('uceFault', 'uceFault_simdBox_b4'));
+function simdBox_b4(i) {
+    var val1 = i%2 === 0,
+        val2 = !val1;
+
+    var a = SIMD.Bool32x4(val1, val2, val1, val2);
+    if (uceFault_simdBox_b4(i) || uceFault_simdBox_b4(i))
+        assertEqX4(a, [val1, val2, val1, val2]);
+    assertRecoveredOnBailout(a, true);
+    return 0;
+}
+
+for (var i = 0; i < 100; i++) {
+    simdBox_i4(i);
+    simdBox_u4(i);
+    simdBox_f4(i);
+    simdBox_b4(i);
+}
diff --git a/js/src/jit-test/tests/SIMD/replacelane.js b/js/src/jit-test/tests/SIMD/replacelane.js
new file mode 100644
index 000000000..c6b37ad5a
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/replacelane.js
@@ -0,0 +1,181 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function f() {
+    var f4 = SIMD.Float32x4(1, 2, 3, 4);
+    var i4 = SIMD.Int32x4(1, 2, 3, 4);
+    var b4 = SIMD.Bool32x4(true, false, true, false);
+
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Int32x4.replaceLane(i4, 0, 42), [42, 2, 3, 4]);
+        assertEqX4(SIMD.Int32x4.replaceLane(i4, 1, 42), [1, 42, 3, 4]);
+        assertEqX4(SIMD.Int32x4.replaceLane(i4, 2, 42), [1, 2, 42, 4]);
+        assertEqX4(SIMD.Int32x4.replaceLane(i4, 3, 42), [1, 2, 3, 42]);
+
+        assertEqX4(SIMD.Float32x4.replaceLane(f4, 0, 42), [42, 2, 3, 4]);
+        assertEqX4(SIMD.Float32x4.replaceLane(f4, 1, 42), [1, 42, 3, 4]);
+        assertEqX4(SIMD.Float32x4.replaceLane(f4, 2, 42), [1, 2, 42, 4]);
+        assertEqX4(SIMD.Float32x4.replaceLane(f4, 3, 42), [1, 2, 3, 42]);
+
+        assertEqX4(SIMD.Bool32x4.replaceLane(b4, 0, false), [false, false, true, false]);
+        assertEqX4(SIMD.Bool32x4.replaceLane(b4, 1, true), [true, true, true, false]);
+        assertEqX4(SIMD.Bool32x4.replaceLane(b4, 2, false), [true, false, false, false]);
+        assertEqX4(SIMD.Bool32x4.replaceLane(b4, 3, true), [true, false, true, true]);
+    }
+}
+
+f();
+
+function e() {
+    var f4 = SIMD.Float32x4(1, 2, 3, 4);
+    var i4 = SIMD.Int32x4(1, 2, 3, 4);
+    var b4 = SIMD.Bool32x4(true, false, true, false);
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Int32x4.replaceLane(i < 149 ? i4 : f4, 0, 42);
+        } catch(e) {
+            assertEq(e instanceof TypeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Int32x4.replaceLane(i < 149 ? i4 : b4, 0, 42);
+        } catch(e) {
+            assertEq(e instanceof TypeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Int32x4.replaceLane(i4, i < 149 ? 0 : 4, 42);
+        } catch(e) {
+            assertEq(e instanceof RangeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Int32x4.replaceLane(i4, i < 149 ? 0 : 1.1, 42);
+        } catch(e) {
+            assertEq(e instanceof RangeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Float32x4.replaceLane(i < 149 ? f4 : i4, 0, 42);
+        } catch(e) {
+            assertEq(e instanceof TypeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Float32x4.replaceLane(i < 149 ? f4 : b4, 0, 42);
+        } catch(e) {
+            assertEq(e instanceof TypeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Float32x4.replaceLane(f4, i < 149 ? 0 : 4, 42);
+        } catch(e) {
+            assertEq(e instanceof RangeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Float32x4.replaceLane(f4, i < 149 ? 0 : 1.1, 42);
+        } catch(e) {
+            assertEq(e instanceof RangeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Bool32x4.replaceLane(i < 149 ? b4 : i4, 0, true);
+        } catch(e) {
+            assertEq(e instanceof TypeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Bool32x4.replaceLane(i < 149 ? b4 : f4, 0, true);
+        } catch(e) {
+            assertEq(e instanceof TypeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Bool32x4.replaceLane(b4, i < 149 ? 0 : 4, true);
+        } catch(e) {
+            assertEq(e instanceof RangeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+    for (let i = 0; i < 150; i++) {
+        let caught = false;
+        try {
+            let x = SIMD.Bool32x4.replaceLane(b4, i < 149 ? 0 : 1.1, true);
+        } catch(e) {
+            assertEq(e instanceof RangeError, true);
+            assertEq(i, 149);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+
+}
+
+e();
diff --git a/js/src/jit-test/tests/SIMD/saturate.js b/js/src/jit-test/tests/SIMD/saturate.js
new file mode 100644
index 000000000..a98cf7ad7
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/saturate.js
@@ -0,0 +1,37 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+const INT8_MIN = -128;
+const INT8_MAX = 127;
+const UINT8_MAX = 255;
+
+function sat8(x) {
+    if (x < INT8_MIN) return INT8_MIN;
+    if (x > INT8_MAX) return INT8_MAX;
+    return x;
+}
+
+function usat8(x) {
+    if (x < 0) return 0;
+    if (x > UINT8_MAX) return UINT8_MAX;
+    return x;
+}
+
+function f() {
+    var i1 = SIMD.Int8x16(1, 100, 3, 4);
+    var i2 = SIMD.Int8x16(4, 30, 2, 1);
+
+    var u1 = SIMD.Uint8x16(1, 2, 3, 4);
+    var u2 = SIMD.Uint8x16(4, 3, 2, 1);
+
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Int8x16.addSaturate(i1, i2), binaryX((x, y) => sat8(x + y), i1, i2));
+        assertEqX4(SIMD.Int8x16.subSaturate(i1, i2), binaryX((x, y) => sat8(x - y), i1, i2));
+
+        assertEqX4(SIMD.Uint8x16.addSaturate(u1, u2), binaryX((x, y) => usat8(x + y), u1, u2));
+        assertEqX4(SIMD.Uint8x16.subSaturate(u1, u2), binaryX((x, y) => usat8(x - y), u1, u2));
+    }
+}
+
+f();
diff --git a/js/src/jit-test/tests/SIMD/select.js b/js/src/jit-test/tests/SIMD/select.js
new file mode 100644
index 000000000..3f0d783da
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/select.js
@@ -0,0 +1,35 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function select(type, mask, ifTrue, ifFalse) {
+    var arr = [];
+    for (var i = 0; i < 4; i++) {
+        var selector = SIMD.Bool32x4.extractLane(mask, i);
+        arr.push(type.extractLane(selector ? ifTrue : ifFalse, i));
+    }
+    return arr;
+}
+
+function f() {
+    var f1 = SIMD.Float32x4(1, 2, 3, 4);
+    var f2 = SIMD.Float32x4(NaN, Infinity, 3.14, -0);
+
+    var i1 = SIMD.Int32x4(2, 3, 5, 8);
+    var i2 = SIMD.Int32x4(13, 37, 24, 42);
+
+    var TTFT = SIMD.Bool32x4(true, true, false, true);
+    var TFTF = SIMD.Bool32x4(true, false, true, false);
+
+    var mask = SIMD.Int32x4(0xdeadbeef, 0xbaadf00d, 0x00ff1ce, 0xdeadc0de);
+
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Float32x4.select(TTFT, f1, f2), select(SIMD.Float32x4, TTFT, f1, f2));
+        assertEqX4(SIMD.Float32x4.select(TFTF, f1, f2), select(SIMD.Float32x4, TFTF, f1, f2));
+
+        assertEqX4(SIMD.Int32x4.select(TFTF, i1, i2), select(SIMD.Int32x4, TFTF, i1, i2));
+        assertEqX4(SIMD.Int32x4.select(TTFT, i1, i2), select(SIMD.Int32x4, TTFT, i1, i2));
+    }
+}
+
+f();
diff --git a/js/src/jit-test/tests/SIMD/shift.js b/js/src/jit-test/tests/SIMD/shift.js
new file mode 100644
index 000000000..8448e52ec
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/shift.js
@@ -0,0 +1,75 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function curry(f, arg) { return f.bind(null, arg); }
+
+function binaryLsh(count, v) { count &= 31; return (v << count) | 0; }
+function lsh(count) { return curry(binaryLsh, count); }
+
+function binaryRsh(count, v) { count &= 31; return (v >> count) | 0; }
+function rsh(count) { return curry(binaryRsh, count); }
+
+function binaryUlsh(count, v) { count &= 31; return (v << count) >>> 0; }
+function ulsh(count) { return curry(binaryUlsh, count); }
+
+function binaryUrsh(count, v) { count &= 31; 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 shifts = [-2, -1, 0, 1, 31, 32, 33];
+
+    var r;
+    for (var i = 0; i < 150; i++) {
+        // Constant shift counts
+        assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, -1), a.map(lsh(-1)));
+        assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, 0),  a.map(lsh(0)));
+        assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, 1),  a.map(lsh(1)));
+        assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, 2),  a.map(lsh(2)));
+        assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, 31), a.map(lsh(31)));
+        assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, 32), a.map(lsh(32)));
+        assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, 33), a.map(lsh(33)));
+
+        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)));
+        assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, 2),  a.map(rsh(2)));
+        assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, 31), a.map(rsh(31)));
+        assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, 32), a.map(rsh(32)));
+        assertEqX4(SIMD.Int32x4.shiftRightByScalar(v, 33), a.map(rsh(33)));
+
+        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.shiftLeftByScalar(u, 33), b.map(ulsh(33)));
+
+        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)));
+        assertEqX4(SIMD.Uint32x4.shiftRightByScalar(u, 33), b.map(ursh(33)));
+
+        // Non constant shift counts
+        var c = shifts[i % shifts.length];
+
+        assertEqX4(SIMD.Int32x4.shiftLeftByScalar(v, c), a.map(lsh(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;
+}
+
+f();
+
diff --git a/js/src/jit-test/tests/SIMD/shuffle.js b/js/src/jit-test/tests/SIMD/shuffle.js
new file mode 100644
index 000000000..505f01131
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/shuffle.js
@@ -0,0 +1,86 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function f() {
+    var i1 = SIMD.Int32x4(1, 2, 3, 4);
+    var i2 = SIMD.Int32x4(5, 6, 7, 8);
+
+    var leet = Math.fround(13.37);
+    var f1 = SIMD.Float32x4(-.5, -0, Infinity, leet);
+    var f2 = SIMD.Float32x4(42, .5, 23, -10);
+
+    // computes all rotations of a given array
+    function *gen(arr) {
+        var previous = arr.slice().splice(0, 4);
+        var i = 4;
+        for (var j = 0; j < 8; j++) {
+            yield previous.slice();
+            previous = previous.splice(1, previous.length - 1);
+            previous.push(arr[i]);
+            i = (i + 1) % arr.length;
+        }
+    }
+
+    var compI = [];
+    var baseI = [];
+    for (var i = 0; i < 8; i++)
+        baseI.push(SIMD.Int32x4.extractLane(i < 4 ? i1 : i2, i % 4));
+    for (var k of gen(baseI))
+        compI.push(k);
+
+    var compF = [];
+    var baseF = [];
+    for (var i = 0; i < 8; i++)
+        baseF.push(SIMD.Float32x4.extractLane(i < 4 ? f1 : f2, i % 4));
+    for (var k of gen(baseF))
+        compF.push(k);
+
+    for (var i = 0; i < 150; i++) {
+        // Variable lanes
+        var r = SIMD.Float32x4.shuffle(f1, f2, i % 8, (i + 1) % 8, (i + 2) % 8, (i + 3) % 8);
+        assertEqX4(r, compF[i % 8]);
+
+        // Constant lanes
+        assertEqX4(SIMD.Float32x4.shuffle(f1, f2, 3, 2, 4, 5), [leet, Infinity, 42, .5]);
+
+        // Variable lanes
+        var r = SIMD.Int32x4.shuffle(i1, i2, i % 8, (i + 1) % 8, (i + 2) % 8, (i + 3) % 8);
+        assertEqX4(r, compI[i % 8]);
+
+        // Constant lanes
+        assertEqX4(SIMD.Int32x4.shuffle(i1, i2, 3, 2, 4, 5), [4, 3, 5, 6]);
+    }
+}
+
+function testBailouts(expectException, uglyDuckling) {
+    var i1 = SIMD.Int32x4(1, 2, 3, 4);
+    var i2 = SIMD.Int32x4(5, 6, 7, 8);
+
+    for (var i = 0; i < 150; i++) {
+        // Test bailouts
+        var value = i == 149 ? uglyDuckling : 0;
+        var caught = false;
+        try {
+            assertEqX4(SIMD.Int32x4.shuffle(i1, i2, value, 2, 4, 5), [1, 3, 5, 6]);
+        } catch(e) {
+            print(e);
+            caught = true;
+            assertEq(i, 149);
+            assertEq(e instanceof TypeError || e instanceof RangeError, true);
+        }
+        if (i == 149)
+            assertEq(caught, expectException);
+    }
+}
+
+f();
+testBailouts(true, -1);
+testBailouts(true, 8);
+testBailouts(true, 2.5);
+testBailouts(true, undefined);
+testBailouts(true, {});
+testBailouts(true, 'one');
+testBailouts(false, false);
+testBailouts(false, null);
+testBailouts(false, " 0.0 ");
diff --git a/js/src/jit-test/tests/SIMD/splat.js b/js/src/jit-test/tests/SIMD/splat.js
new file mode 100644
index 000000000..38eda3085
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/splat.js
@@ -0,0 +1,15 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function f() {
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Int32x4.splat(42),   [42, 42, 42, 42]);
+        assertEqX4(SIMD.Float32x4.splat(42), [42, 42, 42, 42]);
+        assertEqX4(SIMD.Bool32x4.splat(true), [true, true, true, true]);
+        assertEqX4(SIMD.Bool32x4.splat(false), [false, false, false, false]);
+    }
+}
+
+f();
+
diff --git a/js/src/jit-test/tests/SIMD/store.js b/js/src/jit-test/tests/SIMD/store.js
new file mode 100644
index 000000000..8cfa35427
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/store.js
@@ -0,0 +1,143 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 40);
+
+function f() {
+    var f32 = new Float32Array(16);
+    for (var i = 0; i < 16; i++)
+        f32[i] = i + 1;
+
+    var f64 = new Float64Array(f32.buffer);
+    var i32 = new Int32Array(f32.buffer);
+    var u32 = new Uint32Array(f32.buffer);
+    var i16 = new Int16Array(f32.buffer);
+    var u16 = new Uint16Array(f32.buffer);
+    var i8  = new Int8Array(f32.buffer);
+    var u8  = new Uint8Array(f32.buffer);
+
+    var f4 = SIMD.Float32x4(42, 43, 44, 45);
+
+    function check(n) {
+        assertEq(f32[0], 42);
+        assertEq(f32[1], n > 1 ? 43 : 2);
+        assertEq(f32[2], n > 2 ? 44 : 3);
+        assertEq(f32[3], n > 3 ? 45 : 4);
+
+        f32[0] = 1;
+        f32[1] = 2;
+        f32[2] = 3;
+        f32[3] = 4;
+    }
+
+    function testStore() {
+        SIMD.Float32x4.store(f64, 0, f4);
+        check(4);
+        SIMD.Float32x4.store(f32, 0, f4);
+        check(4);
+        SIMD.Float32x4.store(i32, 0, f4);
+        check(4);
+        SIMD.Float32x4.store(u32, 0, f4);
+        check(4);
+        SIMD.Float32x4.store(i16, 0, f4);
+        check(4);
+        SIMD.Float32x4.store(u16, 0, f4);
+        check(4);
+        SIMD.Float32x4.store(i8, 0, f4);
+        check(4);
+        SIMD.Float32x4.store(u8, 0, f4);
+        check(4);
+    }
+
+    function testStore1() {
+        SIMD.Float32x4.store1(f64, 0, f4);
+        check(1);
+        SIMD.Float32x4.store1(f32, 0, f4);
+        check(1);
+        SIMD.Float32x4.store1(i32, 0, f4);
+        check(1);
+        SIMD.Float32x4.store1(u32, 0, f4);
+        check(1);
+        SIMD.Float32x4.store1(i16, 0, f4);
+        check(1);
+        SIMD.Float32x4.store1(u16, 0, f4);
+        check(1);
+        SIMD.Float32x4.store1(i8, 0, f4);
+        check(1);
+        SIMD.Float32x4.store1(u8, 0, f4);
+        check(1);
+    }
+
+    function testStore2() {
+        SIMD.Float32x4.store2(f64, 0, f4);
+        check(2);
+        SIMD.Float32x4.store2(f32, 0, f4);
+        check(2);
+        SIMD.Float32x4.store2(i32, 0, f4);
+        check(2);
+        SIMD.Float32x4.store2(u32, 0, f4);
+        check(2);
+        SIMD.Float32x4.store2(i16, 0, f4);
+        check(2);
+        SIMD.Float32x4.store2(u16, 0, f4);
+        check(2);
+        SIMD.Float32x4.store2(i8, 0, f4);
+        check(2);
+        SIMD.Float32x4.store2(u8, 0, f4);
+        check(2);
+    }
+
+    function testStore3() {
+        SIMD.Float32x4.store3(f64, 0, f4);
+        check(3);
+        SIMD.Float32x4.store3(f32, 0, f4);
+        check(3);
+        SIMD.Float32x4.store3(i32, 0, f4);
+        check(3);
+        SIMD.Float32x4.store3(u32, 0, f4);
+        check(3);
+        SIMD.Float32x4.store3(i16, 0, f4);
+        check(3);
+        SIMD.Float32x4.store3(u16, 0, f4);
+        check(3);
+        SIMD.Float32x4.store3(i8, 0, f4);
+        check(3);
+        SIMD.Float32x4.store3(u8, 0, f4);
+        check(3);
+    }
+
+    for (var i = 0; i < 150; i++) {
+        testStore();
+        testStore1();
+        testStore2();
+        testStore3();
+    }
+}
+
+f();
+
+function testBailout(uglyDuckling) {
+    var f32 = new Float32Array(16);
+    for (var i = 0; i < 16; i++)
+        f32[i] = i + 1;
+
+    var i8  = new Int8Array(f32.buffer);
+
+    var f4 = SIMD.Float32x4(42, 43, 44, 45);
+
+    for (var i = 0; i < 150; i++) {
+        var caught = false;
+        try {
+            SIMD.Float32x4.store(i8, (i < 149) ? 0 : (16 << 2) - (4 << 2) + 1, f4);
+        } catch (e) {
+            print(e);
+            assertEq(e instanceof RangeError, true);
+            caught = true;
+        }
+        assertEq(i < 149 || caught, true);
+    }
+}
+
+print('Testing range checks...');
+testBailout(-1);
+testBailout(-15);
+testBailout(12 * 4 + 1);
diff --git a/js/src/jit-test/tests/SIMD/swizzle.js b/js/src/jit-test/tests/SIMD/swizzle.js
new file mode 100644
index 000000000..2fd56620b
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/swizzle.js
@@ -0,0 +1,104 @@
+if (!this.hasOwnProperty("SIMD"))
+  quit();
+
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+function f() {
+    var i4 = SIMD.Int32x4(1, 2, 3, 4);
+
+    var leet = Math.fround(13.37);
+    var f4 = SIMD.Float32x4(-.5, -0, Infinity, leet);
+
+    var compI = [
+        [1,2,3,4],
+        [2,3,4,1],
+        [3,4,1,2],
+        [4,1,2,3]
+    ];
+
+    var compF = [
+        [-.5, -0, Infinity, leet],
+        [-0, Infinity, leet, -.5],
+        [Infinity, leet, -.5, -0],
+        [leet, -.5, -0, Infinity]
+    ];
+
+    for (var i = 0; i < 150; i++) {
+        // Variable lanes
+        var r = SIMD.Float32x4.swizzle(f4, i % 4, (i + 1) % 4, (i + 2) % 4, (i + 3) % 4);
+        assertEqX4(r, compF[i % 4]);
+
+        // Constant lanes
+        assertEqX4(SIMD.Float32x4.swizzle(f4, 3, 2, 1, 0), [leet, Infinity, -0, -.5]);
+
+        // Variable lanes
+        var r = SIMD.Int32x4.swizzle(i4, i % 4, (i + 1) % 4, (i + 2) % 4, (i + 3) % 4);
+        assertEqX4(r, compI[i % 4]);
+
+        // Constant lanes
+        assertEqX4(SIMD.Int32x4.swizzle(i4, 3, 2, 1, 0), [4, 3, 2, 1]);
+    }
+}
+
+function testBailouts(expectException, uglyDuckling) {
+    var i4 = SIMD.Int32x4(1, 2, 3, 4);
+    for (var i = 0; i < 150; i++) {
+        // Test bailouts
+        var value = i == 149 ? uglyDuckling : 0;
+        var caught = false;
+        try {
+            assertEqX4(SIMD.Int32x4.swizzle(i4, value, 3, 2, 0), [1, 4, 3, 1]);
+        } catch(e) {
+            print(e);
+            caught = true;
+            assertEq(i, 149);
+            assertEq(e instanceof TypeError || e instanceof RangeError, true);
+        }
+        if (i == 149)
+            assertEq(caught, expectException);
+    }
+}
+
+function testInt32x4SwizzleBailout() {
+    // Test out-of-bounds non-constant indices. This is expected to throw.
+    var i4 = SIMD.Int32x4(1, 2, 3, 4);
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Int32x4.swizzle(i4, i, 3, 2, 0), [i + 1, 4, 3, 1]);
+    }
+}
+
+f();
+testBailouts(true, -1);
+testBailouts(true, 4);
+testBailouts(true, 2.5);
+testBailouts(true, undefined);
+testBailouts(true, {});
+testBailouts(true, 'one');
+testBailouts(false, false);
+testBailouts(false, null);
+testBailouts(false, " 0.0 ");
+
+try {
+    testInt32x4SwizzleBailout();
+    throw 'not caught';
+} catch(e) {
+    assertEq(e instanceof RangeError, true);
+}
+
+(function() {
+    var zappa = 0;
+
+    function testBailouts() {
+        var i4 = SIMD.Int32x4(1, 2, 3, 4);
+        for (var i = 0; i < 300; i++) {
+            var value = i == 299 ? 2.5 : 1;
+            SIMD.Int32x4.swizzle(i4, value, 3, 2, 0);
+            zappa = i;
+        }
+    }
+
+    try { testBailouts(); } catch (e) {}
+    assertEq(zappa, 298);
+})();
diff --git a/js/src/jit-test/tests/SIMD/uconvert.js b/js/src/jit-test/tests/SIMD/uconvert.js
new file mode 100644
index 000000000..a45fd7af9
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/uconvert.js
@@ -0,0 +1,86 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 30);
+
+// Testing Uint32 <-> Float32 conversions.
+// These conversions deserve special attention because SSE doesn't provide
+// simple conversion instructions.
+
+// Convert an Uint32Array to a Float32Array using scalar conversions.
+function cvt_utof_scalar(u32s, f32s) {
+    assertEq(u32s.length, f32s.length);
+    for (var i = 0; i < u32s.length; i++) {
+        f32s[i] = u32s[i];
+    }
+}
+
+// Convert an Uint32Array to a Float32Array using simd conversions.
+function cvt_utof_simd(u32s, f32s) {
+    assertEq(u32s.length, f32s.length);
+    for (var i = 0; i < u32s.length; i += 4) {
+        SIMD.Float32x4.store(f32s, i, SIMD.Float32x4.fromUint32x4(SIMD.Uint32x4.load(u32s, i)));
+    }
+}
+
+// Convert a Float32Array to an Uint32Array using scalar conversions.
+function cvt_ftou_scalar(f32s, u32s) {
+    assertEq(f32s.length, u32s.length);
+    for (var i = 0; i < f32s.length; i++) {
+        u32s[i] = f32s[i];
+    }
+}
+
+// Convert a Float32Array to an Uint32Array using simd conversions.
+function cvt_ftou_simd(f32s, u32s) {
+    assertEq(f32s.length, u32s.length);
+    for (var i = 0; i < f32s.length; i += 4) {
+        SIMD.Uint32x4.store(u32s, i, SIMD.Uint32x4.fromFloat32x4(SIMD.Float32x4.load(f32s, i)));
+    }
+}
+
+function check(a, b) {
+    assertEq(a.length, b.length);
+    for (var i = 0; i < a.length; i++) {
+        assertEq(a[i], b[i]);
+    }
+}
+
+// Uint32x4 --> Float32x4 tests.
+var src = new Uint32Array(8000);
+var dst1 = new Float32Array(8000);
+var dst2 = new Float32Array(8000);
+
+for (var i = 0; i < 2000; i++) {
+    src[i] = i;
+    src[i + 2000] = 0x7fffffff - i;
+    src[i + 4000] = 0x80000000 + i;
+    src[i + 6000] = 0xffffffff - i;
+}
+
+for (var n = 0; n < 10; n++) {
+    cvt_utof_scalar(src, dst1);
+    cvt_utof_simd(src, dst2);
+    check(dst1, dst2);
+}
+
+// Float32x4 --> Uint32x4 tests.
+var fsrc = dst1;
+var fdst1 = new Uint32Array(8000);
+var fdst2 = new Uint32Array(8000);
+
+// The 0xffffffff entries in fsrc round to 0x1.0p32f which throws.
+// Go as high as 0x0.ffffffp32f.
+for (var i = 0; i < 2000; i++) {
+    fsrc[i + 6000] = 0xffffff7f - i;
+}
+
+// Truncation towards 0.
+fsrc[1990] = -0.9
+fsrc[1991] = 0.9
+fsrc[1992] = 1.9
+
+for (var n = 0; n < 10; n++) {
+    cvt_ftou_scalar(fsrc, fdst1);
+    cvt_ftou_simd(fsrc, fdst2);
+    check(fdst1, fdst2);
+}
diff --git a/js/src/jit-test/tests/SIMD/unary.js b/js/src/jit-test/tests/SIMD/unary.js
new file mode 100644
index 000000000..34ec3fb10
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/unary.js
@@ -0,0 +1,35 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("ion.warmup.trigger", 50);
+
+var notf = (function() {
+    var i32 = new Int32Array(1);
+    var f32 = new Float32Array(i32.buffer);
+    return function(x) {
+        f32[0] = x;
+        i32[0] = ~i32[0];
+        return f32[0];
+    }
+})();
+
+function f() {
+    var f4 = SIMD.Float32x4(1, 2, 3, 4);
+    var i4 = SIMD.Int32x4(1, 2, 3, 4);
+    var b4 = SIMD.Bool32x4(true, false, true, false);
+    var BitOrZero = (x) => x | 0;
+    for (var i = 0; i < 150; i++) {
+        assertEqX4(SIMD.Float32x4.neg(f4), unaryX4((x) => -x, f4, Math.fround));
+        assertEqX4(SIMD.Float32x4.abs(f4), unaryX4(Math.abs, f4, Math.fround));
+        assertEqX4(SIMD.Float32x4.sqrt(f4), unaryX4(Math.sqrt, f4, Math.fround));
+
+        assertEqX4(SIMD.Float32x4.reciprocalApproximation(f4), unaryX4((x) => 1 / x, f4, Math.fround), assertNear);
+        assertEqX4(SIMD.Float32x4.reciprocalSqrtApproximation(f4), unaryX4((x) => 1 / Math.sqrt(x), f4, Math.fround), assertNear);
+
+        assertEqX4(SIMD.Int32x4.not(i4), unaryX4((x) => ~x, i4, BitOrZero));
+        assertEqX4(SIMD.Int32x4.neg(i4), unaryX4((x) => -x, i4, BitOrZero));
+
+        assertEqX4(SIMD.Bool32x4.not(b4), unaryX4((x) => !x, b4, (x) => x ));
+    }
+}
+
+f();
diff --git a/js/src/jit-test/tests/SIMD/unbox.js b/js/src/jit-test/tests/SIMD/unbox.js
new file mode 100644
index 000000000..2fffddd06
--- /dev/null
+++ b/js/src/jit-test/tests/SIMD/unbox.js
@@ -0,0 +1,144 @@
+load(libdir + 'simd.js');
+
+setJitCompilerOption("baseline.warmup.trigger", 10);
+setJitCompilerOption("ion.warmup.trigger", 30);
+
+var max = 40, pivot = 35;
+
+var i32x4 = SIMD.Int32x4;
+var f32x4 = SIMD.Float32x4;
+var i32x4Add = SIMD.Int32x4.add;
+
+var FakeSIMDType = function (o) { this.x = o.x; this.y = o.y; this.z = o.z; this.w = o.w; };
+if (this.hasOwnProperty("TypedObject")) {
+  var TO = TypedObject;
+  FakeSIMDType = new TO.StructType({ x: TO.int32, y: TO.int32, z: TO.int32, w: TO.int32 });
+}
+
+function simdunbox_bail_undef(i, lhs, rhs) {
+  return i32x4Add(lhs, rhs);
+}
+
+function simdunbox_bail_object(i, lhs, rhs) {
+  return i32x4Add(lhs, rhs);
+}
+
+function simdunbox_bail_typeobj(i, lhs, rhs) {
+  return i32x4Add(lhs, rhs);
+}
+
+function simdunbox_bail_badsimd(i, lhs, rhs) {
+  return i32x4Add(lhs, rhs);
+}
+
+var arr_undef = [ i32x4(0, 1, 1, 2), i32x4(1, 1, 2, 3) ];
+var fail_undef = 0;
+var arr_object = [ i32x4(0, 1, 1, 2), i32x4(1, 1, 2, 3) ];
+var fail_object = 0;
+var arr_typeobj = [ i32x4(0, 1, 1, 2), i32x4(1, 1, 2, 3) ];
+var fail_typeobj = 0;
+var arr_badsimd = [ i32x4(0, 1, 1, 2), i32x4(1, 1, 2, 3) ];
+var fail_badsimd = 0;
+for (var i = 0; i < max; i++) {
+  try {
+    arr_undef[i + 2] = simdunbox_bail_undef(i, arr_undef[i], arr_undef[i + 1]);
+  } catch (x) {
+    arr_undef[i + 2] = arr_undef[i - 1];
+    fail_undef++;
+  }
+
+  try {
+    arr_object[i + 2] = simdunbox_bail_object(i, arr_object[i], arr_object[i + 1]);
+  } catch (x) {
+    arr_object[i + 2] = arr_object[i - 1];
+    fail_object++;
+  }
+
+  try {
+    arr_typeobj[i + 2] = simdunbox_bail_typeobj(i, arr_typeobj[i], arr_typeobj[i + 1]);
+  } catch (x) {
+    arr_typeobj[i + 2] = arr_typeobj[i - 1];
+    fail_typeobj++;
+  }
+
+  try {
+    arr_badsimd[i + 2] = simdunbox_bail_badsimd(i, arr_badsimd[i], arr_badsimd[i + 1]);
+  } catch (x) {
+    arr_badsimd[i + 2] = arr_badsimd[i - 1];
+    fail_badsimd++;
+  }
+
+  if (i + 2 == pivot) {
+    arr_undef[pivot] = undefined;
+    arr_object[pivot] = { x: 0, y: 1, z: 2, w: 3 };
+    arr_typeobj[pivot] = new FakeSIMDType({ x: 0, y: 1, z: 2, w: 3 });
+    arr_badsimd[pivot] = f32x4(0, 1, 2, 3);
+  }
+}
+
+assertEq(fail_undef, 2);
+assertEq(fail_object, 2);
+assertEq(fail_typeobj, 2);
+assertEq(fail_badsimd, 2);
+
+// Assert that all SIMD values are correct.
+function assertEqX4(real, expected, assertFunc) {
+    if (typeof assertFunc === 'undefined')
+        assertFunc = assertEq;
+
+    assertFunc(real.x, expected[0]);
+    assertFunc(real.y, expected[1]);
+    assertFunc(real.z, expected[2]);
+    assertFunc(real.w, expected[3]);
+}
+
+var fib = [0, 1];
+for (i = 0; i < max + 5; i++)
+  fib[i+2] = (fib[i] + fib[i+1]) | 0;
+
+for (i = 0; i < max; i++) {
+  if (i == pivot)
+    continue;
+  var ref = fib.slice(i < pivot ? i : i - 3);
+  assertEqX4(arr_undef[i], ref);
+  assertEqX4(arr_object[i], ref);
+  assertEqX4(arr_typeobj[i], ref);
+  assertEqX4(arr_badsimd[i], ref);
+}
+
+// Check that unbox operations aren't removed
+(function() {
+
+    function add(i, v, w) {
+        if (i % 2 == 0) {
+            SIMD.Int32x4.add(v, w);
+        } else {
+            SIMD.Float32x4.add(v, w);
+        }
+    }
+
+    var i = 0;
+    var caught = false;
+    var f4 = SIMD.Float32x4(1,2,3,4);
+    var i4 = SIMD.Int32x4(1,2,3,4);
+    try {
+        for (; i < 200; i++) {
+            if (i % 2 == 0) {
+                add(i, i4, i4);
+            } else if (i == 199) {
+                add(i, i4, f4);
+            } else {
+                add(i, f4, f4);
+            }
+        }
+    } catch(e) {
+        print(e);
+        assertEq(e instanceof TypeError, true);
+        assertEq(i, 199);
+        caught = true;
+    }
+
+    assertEq(i < 199 || caught, true);
+
+})();
+