diff --git a/js/src/tests/ecma_7/SIMD/float32x4clamp.js b/js/src/tests/ecma_7/SIMD/clamp.js
similarity index 65%
rename from js/src/tests/ecma_7/SIMD/float32x4clamp.js
rename to js/src/tests/ecma_7/SIMD/clamp.js
index fc2e2de830d8..330003c2fd35 100644
--- a/js/src/tests/ecma_7/SIMD/float32x4clamp.js
+++ b/js/src/tests/ecma_7/SIMD/clamp.js
@@ -1,14 +1,14 @@
 // |reftest| skip-if(!this.hasOwnProperty("SIMD"))
 var BUGNUMBER = 946042;
 var float32x4 = SIMD.float32x4;
-var int32x4 = SIMD.int32x4;
+var float64x2 = SIMD.float64x2;
 
-var summary = 'float32x4 clamp';
+var summary = 'float32x4/float64x2 clamp';
 
 function test() {
   print(BUGNUMBER + ": " + summary);
 
-  // FIXME -- Bug 1068028: Amend to check for correctness of NaN border cases once the semantics are defined.
+  // FIXME -- Bug 1068028: Amend to check for correctness of NaN/-0 border cases once the semantics are defined.
 
   var a = float32x4(-20, 10, 30, 0.5);
   var lower = float32x4(2, 1, 50, 0);
@@ -37,6 +37,24 @@ function test() {
   assertEq(i.z, 10);
   assertEq(i.w, -10);
 
+  var j = float64x2(-20, 10);
+  var k = float64x2(2.125, 3);
+  var lower3 = float64x2(2, 1);
+  var upper3 = float64x2(2.5, 5);
+  var l = float64x2.clamp(j, lower3, upper3);
+  assertEq(l.x, 2);
+  assertEq(l.y, 5);
+  var m = float64x2.clamp(k, lower3, upper3);
+  assertEq(m.x, 2.125);
+  assertEq(m.y, 3);
+
+  var n = float64x2(-5, 5);
+  var lower4 = float64x2(-Infinity, 0);
+  var upper4 = float64x2(+Infinity, +Infinity);
+  var p = float64x2.clamp(n, lower4, upper4);
+  assertEq(p.x, -5);
+  assertEq(p.y, 5);
+
   if (typeof reportCompare === "function")
     reportCompare(true, true);
 }
diff --git a/js/src/tests/ecma_7/SIMD/comparisons.js b/js/src/tests/ecma_7/SIMD/comparisons.js
index c97b5ec301ad..19369867de10 100644
--- a/js/src/tests/ecma_7/SIMD/comparisons.js
+++ b/js/src/tests/ecma_7/SIMD/comparisons.js
@@ -6,6 +6,7 @@
  */
 
 var float32x4 = SIMD.float32x4;
+var float64x2 = SIMD.float64x2;
 var int32x4 = SIMD.int32x4;
 
 var fround = Math.fround;
@@ -15,41 +16,60 @@ function boolToSimdLogical(b) {
 }
 
 function testEqualFloat32x4(v, w) {
-    testBinaryFunc(v, w, float32x4.equal, (x, y) => boolToSimdLogical(fround(x) == fround(y)));
+    testBinaryCompare(v, w, float32x4.equal, (x, y) => boolToSimdLogical(fround(x) == fround(y)));
 }
 function testNotEqualFloat32x4(v, w) {
-    testBinaryFunc(v, w, float32x4.notEqual, (x, y) => boolToSimdLogical(fround(x) != fround(y)));
+    testBinaryCompare(v, w, float32x4.notEqual, (x, y) => boolToSimdLogical(fround(x) != fround(y)));
 }
 function testLessThanFloat32x4(v, w) {
-    testBinaryFunc(v, w, float32x4.lessThan, (x, y) => boolToSimdLogical(fround(x) < fround(y)));
+    testBinaryCompare(v, w, float32x4.lessThan, (x, y) => boolToSimdLogical(fround(x) < fround(y)));
 }
 function testLessThanOrEqualFloat32x4(v, w) {
-    testBinaryFunc(v, w, float32x4.lessThanOrEqual, (x, y) => boolToSimdLogical(fround(x) <= fround(y)));
+    testBinaryCompare(v, w, float32x4.lessThanOrEqual, (x, y) => boolToSimdLogical(fround(x) <= fround(y)));
 }
 function testGreaterThanFloat32x4(v, w) {
-    testBinaryFunc(v, w, float32x4.greaterThan, (x, y) => boolToSimdLogical(fround(x) > fround(y)));
+    testBinaryCompare(v, w, float32x4.greaterThan, (x, y) => boolToSimdLogical(fround(x) > fround(y)));
 }
 function testGreaterThanOrEqualFloat32x4(v, w) {
-    testBinaryFunc(v, w, float32x4.greaterThanOrEqual, (x, y) => boolToSimdLogical(fround(x) >= fround(y)));
+    testBinaryCompare(v, w, float32x4.greaterThanOrEqual, (x, y) => boolToSimdLogical(fround(x) >= fround(y)));
+}
+
+function testEqualFloat64x2(v, w) {
+    testBinaryCompare(v, w, float64x2.equal, (x, y) => boolToSimdLogical(x == y));
+}
+function testNotEqualFloat64x2(v, w) {
+    testBinaryCompare(v, w, float64x2.notEqual, (x, y) => boolToSimdLogical(x != y));
+}
+function testLessThanFloat64x2(v, w) {
+    testBinaryCompare(v, w, float64x2.lessThan, (x, y) => boolToSimdLogical(x < y));
+}
+function testLessThanOrEqualFloat64x2(v, w) {
+    testBinaryCompare(v, w, float64x2.lessThanOrEqual, (x, y) => boolToSimdLogical(x <= y));
+}
+function testGreaterThanFloat64x2(v, w) {
+    testBinaryCompare(v, w, float64x2.greaterThan, (x, y) => boolToSimdLogical(x > y));
+}
+function testGreaterThanOrEqualFloat64x2(v, w) {
+    testBinaryCompare(v, w, float64x2.greaterThanOrEqual, (x, y) => boolToSimdLogical(x >= y));
 }
 
 function testEqualInt32x4(v, w) {
-    testBinaryFunc(v, w, int32x4.equal, (x, y) => boolToSimdLogical(x == y));
+    testBinaryCompare(v, w, int32x4.equal, (x, y) => boolToSimdLogical(x == y));
 }
 function testNotEqualInt32x4(v, w) {
-    testBinaryFunc(v, w, int32x4.notEqual, (x, y) => boolToSimdLogical(x != y));
+    testBinaryCompare(v, w, int32x4.notEqual, (x, y) => boolToSimdLogical(x != y));
 }
 function testLessThanInt32x4(v, w) {
-    testBinaryFunc(v, w, int32x4.lessThan, (x, y) => boolToSimdLogical(x < y));
+    testBinaryCompare(v, w, int32x4.lessThan, (x, y) => boolToSimdLogical(x < y));
 }
 function testLessThanOrEqualInt32x4(v, w) {
-    testBinaryFunc(v, w, int32x4.lessThanOrEqual, (x, y) => boolToSimdLogical(x <= y));
+    testBinaryCompare(v, w, int32x4.lessThanOrEqual, (x, y) => boolToSimdLogical(x <= y));
 }
 function testGreaterThanInt32x4(v, w) {
-    testBinaryFunc(v, w, int32x4.greaterThan, (x, y) => boolToSimdLogical(x > y));
+    testBinaryCompare(v, w, int32x4.greaterThan, (x, y) => boolToSimdLogical(x > y));
 }
 function testGreaterThanOrEqualInt32x4(v, w) {
-    testBinaryFunc(v, w, int32x4.greaterThanOrEqual, (x, y) => boolToSimdLogical(x >= y));
+    testBinaryCompare(v, w, int32x4.greaterThanOrEqual, (x, y) => boolToSimdLogical(x >= y));
 }
 
 function test() {
@@ -75,6 +95,32 @@ function test() {
       }
   }
 
+  var float64x2val = [
+      float64x2(1, 20),
+      float64x2(10, 2),
+      float64x2(9.999, 2.1234),
+      float64x2(10, 2.1233),
+      float64x2(30.4443, 4),
+      float64x2(30.4444, 4.0001),
+      float64x2(NaN, -Infinity),
+      float64x2(+Infinity, NaN),
+      float64x2(+Infinity, -0),
+      float64x2(-0, -Infinity),
+      float64x2(13.37, 42.42),
+      float64x2(NaN, 0)
+  ];
+
+  for (v of float64x2val) {
+      for (w of float64x2val) {
+          testEqualFloat64x2(v, w);
+          testNotEqualFloat64x2(v, w);
+          testLessThanFloat64x2(v, w);
+          testLessThanOrEqualFloat64x2(v, w);
+          testGreaterThanFloat64x2(v, w);
+          testGreaterThanOrEqualFloat64x2(v, w);
+      }
+  }
+
   var int32x4val = [
       int32x4(1, 2, 3, 4),
       int32x4(-1, -2, -3, -4),
diff --git a/js/src/tests/ecma_7/SIMD/float32x4-minmax.js b/js/src/tests/ecma_7/SIMD/float32x4-minmax.js
deleted file mode 100644
index dfc998e52048..000000000000
--- a/js/src/tests/ecma_7/SIMD/float32x4-minmax.js
+++ /dev/null
@@ -1,54 +0,0 @@
-// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
-var BUGNUMBER = 946042;
-
-var float32x4 = SIMD.float32x4;
-
-function testMaxFloat32(v, w) {
-    return testBinaryFunc(v, w, float32x4.max, (x, y) => Math.fround(Math.max(x, y)));
-}
-function testMinFloat32(v, w) {
-    return testBinaryFunc(v, w, float32x4.min, (x, y) => Math.fround(Math.min(x, y)));
-}
-
-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 testMaxNumFloat32(v, w) {
-    return testBinaryFunc(v, w, float32x4.maxNum, maxNum);
-}
-function testMinNumFloat32(v, w) {
-    return testBinaryFunc(v, w, float32x4.minNum, minNum);
-}
-
-function test() {
-  print(BUGNUMBER + ": " + summary);
-
-  for ([v, w] of [[float32x4(1, 20, 30, 4), float32x4(10, 2, 3, 40)],
-                  [float32x4(9.999, 2.1234, 30.4443, 4), float32x4(10, 2.1233, 30.4444, 4.0001)],
-                  [float32x4(NaN, -Infinity, +Infinity, -0), float32x4(13.37, 42.42, NaN, 0)]])
-  {
-      testMinFloat32(v, w);
-      testMaxFloat32(v, w);
-      testMinNumFloat32(v, w);
-      testMaxNumFloat32(v, w);
-  }
-
-  if (typeof reportCompare === "function")
-    reportCompare(true, true);
-}
-
-test();
-
diff --git a/js/src/tests/ecma_7/SIMD/float32x4fromfloat64x2.js b/js/src/tests/ecma_7/SIMD/float32x4fromfloat64x2.js
new file mode 100644
index 000000000000..a4b2ef94f599
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float32x4fromfloat64x2.js
@@ -0,0 +1,60 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float32x4 = SIMD.float32x4;
+var float64x2 = SIMD.float64x2;
+
+var summary = 'float32x4 fromFloat64x2';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = float64x2(1, 2);
+  var c = float32x4.fromFloat64x2(a);
+  assertEq(c.x, 1);
+  assertEq(c.y, 2);
+  assertEq(c.z, 0);
+  assertEq(c.w, 0);
+
+  var d = float64x2(-0, NaN);
+  var f = float32x4.fromFloat64x2(d);
+  assertEq(f.x, -0);
+  assertEq(f.y, NaN);
+  assertEq(f.z, 0);
+  assertEq(f.w, 0);
+
+  var g = float64x2(Infinity, -Infinity);
+  var i = float32x4.fromFloat64x2(g);
+  assertEq(i.x, Infinity);
+  assertEq(i.y, -Infinity);
+  assertEq(i.z, 0);
+  assertEq(i.w, 0);
+
+  var j = Math.pow(2, 25) - 1;
+  var k = -Math.pow(2, 25);
+  var l = float64x2(j, k);
+  var m = float32x4.fromFloat64x2(l);
+  assertEq(m.x, Math.fround(j));
+  assertEq(m.y, Math.fround(k));
+  assertEq(m.z, 0);
+  assertEq(m.w, 0);
+
+  var o = Math.pow(2, 1000);
+  var p = Math.pow(2, -1000);
+  var q = float64x2(o, p);
+  var r = float32x4.fromFloat64x2(q);
+  assertEq(r.x, Math.fround(o));
+  assertEq(r.y, Math.fround(p));
+  assertEq(r.z, 0);
+  assertEq(r.w, 0);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/float32x4fromfloat64x2bits.js b/js/src/tests/ecma_7/SIMD/float32x4fromfloat64x2bits.js
new file mode 100644
index 000000000000..d3bb892f48ea
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float32x4fromfloat64x2bits.js
@@ -0,0 +1,43 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float32x4 = SIMD.float32x4;
+var float64x2 = SIMD.float64x2;
+var int32x4 = SIMD.int32x4;
+
+var summary = 'float32x4 fromFloat64x2Bits';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = float64x2(2.000000473111868, 512.0001225471497);
+  var b = float32x4.fromFloat64x2Bits(a);
+  assertEq(b.x, 1.0);
+  assertEq(b.y, 2.0);
+  assertEq(b.z, 3.0);
+  assertEq(b.w, 4.0);
+
+  var c = float64x2(-0, NaN);
+  var d = float32x4.fromFloat64x2Bits(c);
+  assertEq(d.x, 0);
+  assertEq(d.y, -0);
+  assertEq(d.z, 0);
+  assertEq(d.w, NaN);
+
+  var e = float64x2(Infinity, -Infinity);
+  var f = float32x4.fromFloat64x2Bits(e);
+  assertEq(f.x, 0);
+  assertEq(f.y, NaN);
+  assertEq(f.z, 0);
+  assertEq(f.w, NaN);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/float64x2-arithmetic.js b/js/src/tests/ecma_7/SIMD/float64x2-arithmetic.js
new file mode 100644
index 000000000000..775265073e35
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2-arithmetic.js
@@ -0,0 +1,77 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+
+var summary = 'float64x2 arithmetic';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function add(a, b) { return a + b; }
+function sub(a, b) { return a - b; }
+function mul(a, b) { return a * b; }
+function div(a, b) { return a / b; }
+function neg(a) { return -a; }
+function reciprocal(a) { return 1 / a; }
+function reciprocalSqrt(a) { return 1 / Math.sqrt(a); }
+
+function testAdd(v, w) {
+    return testBinaryFunc(v, w, float64x2.add, add);
+}
+function testSub(v, w) {
+    return testBinaryFunc(v, w, float64x2.sub, sub);
+}
+function testMul(v, w) {
+    return testBinaryFunc(v, w, float64x2.mul, mul);
+}
+function testDiv(v, w) {
+    return testBinaryFunc(v, w, float64x2.div, div);
+}
+function testAbs(v) {
+    return testUnaryFunc(v, float64x2.abs, Math.abs);
+}
+function testNeg(v) {
+    return testUnaryFunc(v, float64x2.neg, neg);
+}
+function testReciprocal(v) {
+    return testUnaryFunc(v, float64x2.reciprocal, reciprocal);
+}
+function testReciprocalSqrt(v) {
+    return testUnaryFunc(v, float64x2.reciprocalSqrt, reciprocalSqrt);
+}
+function testSqrt(v) {
+    return testUnaryFunc(v, float64x2.sqrt, Math.sqrt);
+}
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var v, w;
+  for ([v, w] of [[float64x2(1, 2), float64x2(3, 4)],
+                  [float64x2(1.894, 2.8909), float64x2(100.764, 200.987)],
+                  [float64x2(-1, -2), float64x2(-14.54, 57)],
+                  [float64x2(+Infinity, -Infinity), float64x2(NaN, -0)]])
+  {
+      testAdd(v, w);
+      testSub(v, w);
+      testMul(v, w);
+      testDiv(v, w);
+      testAbs(v);
+      testNeg(v);
+      testReciprocal(v);
+      testSqrt(v);
+  }
+  for (v of [float64x2(1, 0.25), float64x2(3, 0.5),
+             float64x2(-0, NaN), float64x2(+Infinity, -Infinity)])
+  {
+      testReciprocalSqrt(v);
+  }
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/float64x2alignment.js b/js/src/tests/ecma_7/SIMD/float64x2alignment.js
new file mode 100644
index 000000000000..bf30466d24c8
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2alignment.js
@@ -0,0 +1,30 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+
+var summary = 'float64x2 alignment';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+var StructType = TypedObject.StructType;
+var uint8 = TypedObject.uint8;
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  assertEq(float64x2.byteLength, 16);
+  assertEq(float64x2.byteAlignment, 16);
+
+  var Compound = new StructType({c: uint8, d: uint8, f: float64x2});
+  assertEq(Compound.fieldOffsets["c"], 0);
+  assertEq(Compound.fieldOffsets["d"], 1);
+  assertEq(Compound.fieldOffsets["f"], 16);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
diff --git a/js/src/tests/ecma_7/SIMD/float64x2fromfloat32x4.js b/js/src/tests/ecma_7/SIMD/float64x2fromfloat32x4.js
new file mode 100644
index 000000000000..b746f1efa7bf
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2fromfloat32x4.js
@@ -0,0 +1,41 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float32x4 = SIMD.float32x4;
+var float64x2 = SIMD.float64x2;
+
+var summary = 'float64x2 fromFloat32x4';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = float32x4(100, 200, 300, 400);
+  var c = float64x2.fromFloat32x4(a);
+  assertEq(c.x, 100);
+  assertEq(c.y, 200);
+
+  var d = float32x4(NaN, -0, NaN, -0);
+  var f = float64x2.fromFloat32x4(d);
+  assertEq(f.x, NaN);
+  assertEq(f.y, -0);
+
+  var g = float32x4(Infinity, -Infinity, Infinity, -Infinity);
+  var i = float64x2.fromFloat32x4(g);
+  assertEq(i.x, Infinity);
+  assertEq(i.y, -Infinity);
+
+  var j = float32x4(13.37, 12.853, 49.97, 53.124);
+  var l = float64x2.fromFloat32x4(j);
+  assertEq(l.x, Math.fround(13.37));
+  assertEq(l.y, Math.fround(12.853));
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/float64x2fromfloat32x4bits.js b/js/src/tests/ecma_7/SIMD/float64x2fromfloat32x4bits.js
new file mode 100644
index 000000000000..6a36df124e5e
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2fromfloat32x4bits.js
@@ -0,0 +1,32 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float32x4 = SIMD.float32x4;
+var float64x2 = SIMD.float64x2;
+var int32x4 = SIMD.int32x4;
+
+var summary = 'float64x2 fromFloat32x4Bits';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = float32x4(0, 1.875, 0, 2);
+  var c = float64x2.fromFloat32x4Bits(a);
+  assertEq(c.x, 1.0);
+  assertEq(c.y, 2.0);
+
+  var d = float32x4(NaN, -0, Infinity, -Infinity);
+  var f = float64x2.fromFloat32x4Bits(d);
+  assertEq(f.x, -1.058925634e-314);
+  assertEq(f.y, -1.404448428688076e+306);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/float64x2fromint32x4.js b/js/src/tests/ecma_7/SIMD/float64x2fromint32x4.js
new file mode 100644
index 000000000000..629d3ec8af8c
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2fromint32x4.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+var int32x4 = SIMD.int32x4;
+
+var summary = 'float64x2 fromInt32x4';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = int32x4(1, 2, 3, 4);
+  var c = float64x2.fromInt32x4(a);
+  assertEq(c.x, 1);
+  assertEq(c.y, 2);
+
+  var d = int32x4(INT32_MAX, INT32_MIN, 0, 0);
+  var f = float64x2.fromInt32x4(d);
+  assertEq(f.x, INT32_MAX);
+  assertEq(f.y, INT32_MIN);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/float64x2fromint32x4bits.js b/js/src/tests/ecma_7/SIMD/float64x2fromint32x4bits.js
new file mode 100644
index 000000000000..e4525ac059db
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2fromint32x4bits.js
@@ -0,0 +1,31 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+var int32x4 = SIMD.int32x4;
+
+var summary = 'float64x2 fromInt32x4Bits';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = int32x4(0x00000000, 0x3ff00000, 0x0000000, 0x40000000);
+  var c = float64x2.fromInt32x4Bits(a);
+  assertEq(c.x, 1.0);
+  assertEq(c.y, 2.0);
+
+  var d = int32x4(0xabcdef12, 0x3ff00000, 0x21fedcba, 0x40000000);
+  var f = float64x2.fromInt32x4Bits(d);
+  assertEq(f.x, 1.0000006400213732);
+  assertEq(f.y, 2.0000002532866263);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/float64x2getters.js b/js/src/tests/ecma_7/SIMD/float64x2getters.js
new file mode 100644
index 000000000000..888182e224ac
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2getters.js
@@ -0,0 +1,47 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+var int32x4 = SIMD.int32x4;
+
+var summary = 'float64x2 getters';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  // Create a float64x2 and check that the getters work:
+  var f = float64x2(11, 22);
+  assertEq(f.x, 11);
+  assertEq(f.y, 22);
+
+  // Test that the getters work when called reflectively:
+  var g = f.__lookupGetter__("x");
+  assertEq(g.call(f), 11);
+
+  // Test that getters cannot be applied to various incorrect things:
+  assertThrowsInstanceOf(function() {
+    g.call({})
+  }, TypeError, "Getter applicable to random objects");
+  assertThrowsInstanceOf(function() {
+    g.call(0xDEADBEEF)
+  }, TypeError, "Getter applicable to integers");
+  assertThrowsInstanceOf(function() {
+    var T = new TypedObject.StructType({x: TypedObject.float64,
+                                        y: TypedObject.float64});
+    var v = new T({x: 11, y: 22});
+    g.call(v)
+  }, TypeError, "Getter applicable to structs");
+  assertThrowsInstanceOf(function() {
+    var t = new int32x4(1, 2, 3, 4);
+    g.call(t)
+  }, TypeError, "Getter applicable to int32x4");
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
diff --git a/js/src/tests/ecma_7/SIMD/float64x2handle.js b/js/src/tests/ecma_7/SIMD/float64x2handle.js
new file mode 100644
index 000000000000..98ee67c6fdeb
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2handle.js
@@ -0,0 +1,51 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+var int32x4 = SIMD.int32x4;
+
+var summary = 'float64x2 handles';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+var ArrayType = TypedObject.ArrayType;
+
+var float64 = TypedObject.float64;
+var Handle = TypedObject.Handle;
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var Array = float64x2.array(3);
+  var array = new Array([float64x2(1, 2),
+                         float64x2(3, 4),
+                         float64x2(5, 6)]);
+
+  // Test that trying to create handle into the interior of a
+  // float64x2 fails.
+
+  assertThrowsInstanceOf(function() {
+    var h = float64.handle(array, 1, "w");
+  }, TypeError, "Creating a float64 handle to prop via ctor");
+
+  assertThrowsInstanceOf(function() {
+    var h = float64.handle();
+    Handle.move(h, array, 1, "w");
+  }, TypeError, "Creating a float64 handle to prop via move");
+
+  assertThrowsInstanceOf(function() {
+    var h = float64.handle(array, 1, 0);
+  }, TypeError, "Creating a float64 handle to elem via ctor");
+
+  assertThrowsInstanceOf(function() {
+    var h = float64.handle();
+    Handle.move(h, array, 1, 0);
+  }, TypeError, "Creating a float64 handle to elem via move");
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
diff --git a/js/src/tests/ecma_7/SIMD/float64x2reify.js b/js/src/tests/ecma_7/SIMD/float64x2reify.js
new file mode 100644
index 000000000000..ac7097787adc
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2reify.js
@@ -0,0 +1,36 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+
+var summary = 'float64x2 reify';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+var ArrayType = TypedObject.ArrayType;
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var Array = float64x2.array(3);
+  var array = new Array([float64x2(1, 2),
+                         float64x2(3, 4),
+                         float64x2(5, 6)]);
+
+  // Test that reading array[1] produces a *copy* of float64x2, not an
+  // alias into the array.
+
+  var f = array[1];
+  assertEq(f.y, 4);
+  assertEq(array[1].y, 4);
+  array[1] = float64x2(7, 8);
+  assertEq(f.y, 4);
+  assertEq(array[1].y, 8);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
diff --git a/js/src/tests/ecma_7/SIMD/float64x2select.js b/js/src/tests/ecma_7/SIMD/float64x2select.js
new file mode 100644
index 000000000000..cfd7599ea4b8
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2select.js
@@ -0,0 +1,34 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+var int32x4 = SIMD.int32x4;
+
+var summary = 'float64x2 select';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = int32x4.bool(true, true, false, false);
+  var b = SIMD.float64x2(1, 2);
+  var c = SIMD.float64x2(3, 4);
+  var d = SIMD.float64x2.select(a, b, c);
+  assertEq(d.x, 1);
+  assertEq(d.y, 4);
+
+  var e = SIMD.float64x2(NaN, -0);
+  var f = SIMD.float64x2(+Infinity, -Infinity);
+  var g = SIMD.float64x2.select(a, e, f);
+  assertEq(g.x, NaN);
+  assertEq(g.y, -Infinity);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/float64x2setter.js b/js/src/tests/ecma_7/SIMD/float64x2setter.js
new file mode 100644
index 000000000000..e59b951c8802
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2setter.js
@@ -0,0 +1,45 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+
+var summary = 'float64x2 setter';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+var ArrayType = TypedObject.ArrayType;
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var Array = float64x2.array(3);
+  var array = new Array([float64x2(1, 2),
+                         float64x2(3, 4),
+                         float64x2(5, 6)]);
+  assertEq(array[1].y, 4);
+
+  // Test that we are allowed to write float64x2 values into array,
+  // but not other things.
+
+  array[1] = float64x2(7, 8);
+  assertEq(array[1].y, 8);
+
+  assertThrowsInstanceOf(function() {
+    array[1] = {x: 7, y: 8 };
+  }, TypeError, "Setting float64x2 from an object");
+
+  assertThrowsInstanceOf(function() {
+    array[1] = [ 7, 8 ];
+  }, TypeError, "Setting float64x2 from an array");
+
+  assertThrowsInstanceOf(function() {
+    array[1] = 9;
+  }, TypeError, "Setting float64x2 from a number");
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
diff --git a/js/src/tests/ecma_7/SIMD/float64x2with.js b/js/src/tests/ecma_7/SIMD/float64x2with.js
new file mode 100644
index 000000000000..e188d6a4d427
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/float64x2with.js
@@ -0,0 +1,36 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+
+var summary = 'float64x2 with';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = float64x2(1, 2);
+  var x = float64x2.withX(a, 5);
+  var y = float64x2.withY(a, 5);
+  assertEq(x.x, 5);
+  assertEq(x.y, 2);
+  assertEq(y.x, 1);
+  assertEq(y.y, 5);
+
+  var b = float64x2(NaN, -0);
+  var x1 = float64x2.withX(b, Infinity);
+  var y1 = float64x2.withY(b, -Infinity);
+  assertEq(x1.x, Infinity);
+  assertEq(x1.y, -0);
+  assertEq(y1.x, NaN);
+  assertEq(y1.y, -Infinity);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/int32x4fromfloat64x2.js b/js/src/tests/ecma_7/SIMD/int32x4fromfloat64x2.js
new file mode 100644
index 000000000000..84ab8def2b6d
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/int32x4fromfloat64x2.js
@@ -0,0 +1,51 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+var int32x4 = SIMD.int32x4;
+
+var summary = 'int32x4 fromFloat64x2';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = float64x2(1, 2.2);
+  var c = int32x4.fromFloat64x2(a);
+  assertEq(c.x, 1);
+  assertEq(c.y, 2);
+  assertEq(c.z, 0);
+  assertEq(c.w, 0);
+
+  var d = float64x2(NaN, -0);
+  var f = int32x4.fromFloat64x2(d);
+  assertEq(f.x, 0);
+  assertEq(f.y, 0);
+  assertEq(f.z, 0);
+  assertEq(f.w, 0);
+
+  var g = float64x2(Infinity, -Infinity);
+  var i = int32x4.fromFloat64x2(g);
+  assertEq(i.x, 0);
+  assertEq(i.y, 0);
+  assertEq(i.z, 0);
+  assertEq(i.w, 0);
+
+  var j = Math.pow(2, 31);
+  var k = -Math.pow(2, 31) - 1;
+  var m = float64x2(j, k);
+  var l = int32x4.fromFloat64x2(m);
+  assertEq(l.x, INT32_MIN);
+  assertEq(l.y, INT32_MAX);
+  assertEq(l.z, 0);
+  assertEq(l.w, 0);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/int32x4fromfloat64x2bits.js b/js/src/tests/ecma_7/SIMD/int32x4fromfloat64x2bits.js
new file mode 100644
index 000000000000..52939cecfbf9
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/int32x4fromfloat64x2bits.js
@@ -0,0 +1,49 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+var BUGNUMBER = 1031203;
+var float64x2 = SIMD.float64x2;
+var int32x4 = SIMD.int32x4;
+
+var summary = 'int32x4 fromFloat64x2Bits';
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+  print(BUGNUMBER + ": " + summary);
+
+  var a = float64x2(1.0, 2.0);
+  var c = int32x4.fromFloat64x2Bits(a);
+  assertEq(c.x, 0x00000000);
+  assertEq(c.y, 0x3FF00000);
+  assertEq(c.z, 0x00000000);
+  assertEq(c.w, 0x40000000);
+
+  var d = float64x2(+Infinity, -Infinity);
+  var f = int32x4.fromFloat64x2Bits(d);
+  assertEq(f.x, 0x00000000);
+  assertEq(f.y, 0x7ff00000);
+  assertEq(f.z, 0x00000000);
+  assertEq(f.w, -0x100000);
+
+  var g = float64x2(-0, NaN);
+  var i = int32x4.fromFloat64x2Bits(g);
+  assertEq(i.x, 0x00000000);
+  assertEq(i.y, -0x80000000);
+  assertEq(i.z, 0x00000000);
+  assertEq(i.w, 0x7ff80000);
+
+  var j = float64x2(1.0000006400213732, 2.0000002532866263);
+  var l = int32x4.fromFloat64x2Bits(j);
+  assertEq(l.x, -0x543210ee);
+  assertEq(l.y, 0x3ff00000);
+  assertEq(l.z, 0x21fedcba);
+  assertEq(l.w, 0x40000000);
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/load.js b/js/src/tests/ecma_7/SIMD/load.js
index a3f83bb18cc5..706bc4b4212d 100644
--- a/js/src/tests/ecma_7/SIMD/load.js
+++ b/js/src/tests/ecma_7/SIMD/load.js
@@ -5,11 +5,11 @@
  * https://creativecommons.org/publicdomain/zero/1.0/
  */
 
-// Our float32array will have 16 elements
-const SIZE_ARRAY = 16;
+// Our array for int32x4 and float32x4 will have 16 elements
+const SIZE_32_ARRAY = 16;
+const SIZE_64_ARRAY = 8;
 
-// 1 float32 == 4 bytes
-const SIZE_BYTES = SIZE_ARRAY * 4;
+const SIZE_BYTES = SIZE_32_ARRAY * 4;
 
 function MakeComparator(kind, arr) {
     var bpe = arr.BYTES_PER_ELEMENT;
@@ -28,10 +28,14 @@ function MakeComparator(kind, arr) {
         sizeOfLaneElem = 4;
         typedArrayCtor = Float32Array;
         break;
+      case 'float64x2':
+        sizeOfLaneElem = 8;
+        typedArrayCtor = Float64Array;
+        break;
       default:
         assertEq(true, false, "unknown SIMD kind");
     }
-
+    var lanes = 16 / sizeOfLaneElem;
     // Reads (numElemToRead * sizeOfLaneElem) bytes in arr, and reinterprets
     // these bytes as a typed array equivalent to the typed SIMD vector.
     var slice = function(start, numElemToRead) {
@@ -49,31 +53,38 @@ function MakeComparator(kind, arr) {
         return new typedArrayCtor(new Uint8Array(asArray).buffer);
     }
 
+    var assertFunc = (lanes == 2) ? assertEqX2 : assertEqX4;
+    var type = SIMD[kind];
     return {
         loadX: function(index) {
-            var v = SIMD[kind].loadX(arr, index);
-            assertEqX4(v, slice(index, 1));
+            var v = type.loadX(arr, index);
+            assertFunc(v, slice(index, 1));
         },
 
         loadXY: function(index) {
-            var v = SIMD[kind].loadXY(arr, index);
-            assertEqX4(v, slice(index, 2));
+            if (lanes < 4)
+                return;
+            var v = type.loadXY(arr, index);
+            assertFunc(v, slice(index, 2));
         },
 
-        loadXYZ: function(index) {
-            var v = SIMD[kind].loadXYZ(arr, index);
-            assertEqX4(v, slice(index, 3));
+       loadXYZ: function(index) {
+           if (lanes < 4)
+               return;
+           var v = type.loadXYZ(arr, index);
+           assertFunc(v, slice(index, 3));
         },
 
         load: function(index) {
-            var v = SIMD[kind].load(arr, index);
-            assertEqX4(v, slice(index, 4));
+           var v = type.load(arr, index);
+           assertFunc(v, slice(index, 4));
         }
     }
 }
 
 function testLoad(kind, TA) {
-    for (var i = SIZE_ARRAY; i--;)
+    var lanes = TA.length / 4;
+    for (var i = TA.length; i--;)
         TA[i] = i;
 
     for (var ta of [
@@ -97,7 +108,7 @@ function testLoad(kind, TA) {
         var C = MakeComparator(kind, ta);
         var bpe = ta.BYTES_PER_ELEMENT;
 
-        var lastValidArgLoadX   = (SIZE_BYTES - 4)  / bpe | 0;
+        var lastValidArgLoadX   = (SIZE_BYTES - (lanes == 4 ? 4 : 8))  / bpe | 0;
         var lastValidArgLoadXY  = (SIZE_BYTES - 8)  / bpe | 0;
         var lastValidArgLoadXYZ = (SIZE_BYTES - 12) / bpe | 0;
         var lastValidArgLoad    = (SIZE_BYTES - 16) / bpe | 0;
@@ -121,25 +132,30 @@ function testLoad(kind, TA) {
         C.loadXY(2);
         C.loadXY(3);
         C.loadXY(lastValidArgLoadXY);
-        assertThrowsInstanceOf(() => SIMD[kind].loadXY(ta, lastValidArgLoadXY + 1), RangeError);
 
         C.loadXYZ(0);
         C.loadXYZ(1);
         C.loadXYZ(2);
         C.loadXYZ(3);
         C.loadXYZ(lastValidArgLoadXYZ);
-        assertThrowsInstanceOf(() => SIMD[kind].loadXYZ(ta, lastValidArgLoadXYZ + 1), RangeError);
+
+        if (lanes >= 4) {
+            assertThrowsInstanceOf(() => SIMD[kind].loadXY(ta, lastValidArgLoadXY + 1), RangeError);
+            assertThrowsInstanceOf(() => SIMD[kind].loadXYZ(ta, lastValidArgLoadXYZ + 1), RangeError);
+        }
     }
 
-    // Test ToInt32 behavior
-    var v = SIMD[kind].load(TA, 12.5);
-    assertEqX4(v, [12, 13, 14, 15]);
+    if (lanes == 4) {
+        // Test ToInt32 behavior
+        var v = SIMD[kind].load(TA, 12.5);
+        assertEqX4(v, [12, 13, 14, 15]);
 
-    var obj = {
-        valueOf: function() { return 12 }
+        var obj = {
+            valueOf: function() { return 12 }
+        }
+        var v = SIMD[kind].load(TA, obj);
+        assertEqX4(v, [12, 13, 14, 15]);
     }
-    var v = SIMD[kind].load(TA, obj);
-    assertEqX4(v, [12, 13, 14, 15]);
 
     var obj = {
         valueOf: function() { throw new TypeError("i ain't a number"); }
@@ -147,8 +163,9 @@ function testLoad(kind, TA) {
     assertThrowsInstanceOf(() => SIMD[kind].load(TA, obj), TypeError);
 }
 
-testLoad('float32x4', new Float32Array(SIZE_ARRAY));
-testLoad('int32x4', new Int32Array(SIZE_ARRAY));
+testLoad('float32x4', new Float32Array(SIZE_32_ARRAY));
+testLoad('float64x2', new Float64Array(SIZE_64_ARRAY));
+testLoad('int32x4', new Int32Array(SIZE_32_ARRAY));
 
 if (typeof reportCompare === "function")
     reportCompare(true, true);
diff --git a/js/src/tests/ecma_7/SIMD/minmax.js b/js/src/tests/ecma_7/SIMD/minmax.js
new file mode 100644
index 000000000000..c21dcccf2315
--- /dev/null
+++ b/js/src/tests/ecma_7/SIMD/minmax.js
@@ -0,0 +1,85 @@
+// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
+
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * https://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+var float32x4 = SIMD.float32x4;
+var float64x2 = SIMD.float64x2;
+
+function testMaxFloat32(v, w) {
+    return testBinaryFunc(v, w, float32x4.max, (x, y) => Math.fround(Math.max(x, y)), 4);
+}
+function testMinFloat32(v, w) {
+    return testBinaryFunc(v, w, float32x4.min, (x, y) => Math.fround(Math.min(x, y)), 4);
+}
+
+function testMaxFloat64(v, w) {
+    return testBinaryFunc(v, w, float64x2.max, (x, y) => Math.max(x, y), 2);
+}
+function testMinFloat64(v, w) {
+    return testBinaryFunc(v, w, float64x2.min, (x, y) => Math.min(x, y), 2);
+}
+
+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 testMaxNumFloat32(v, w) {
+    return testBinaryFunc(v, w, float32x4.maxNum, maxNum, 4);
+}
+function testMinNumFloat32(v, w) {
+    return testBinaryFunc(v, w, float32x4.minNum, minNum, 4);
+}
+
+function testMaxNumFloat64(v, w) {
+    return testBinaryFunc(v, w, float64x2.maxNum, maxNum, 2);
+}
+function testMinNumFloat64(v, w) {
+    return testBinaryFunc(v, w, float64x2.minNum, minNum, 2);
+}
+
+function test() {
+  var v, w;
+  for ([v, w] of [[float32x4(1, 20, 30, 4), float32x4(10, 2, 3, 40)],
+                  [float32x4(9.999, 2.1234, 30.4443, 4), float32x4(10, 2.1233, 30.4444, 4.0001)],
+                  [float32x4(NaN, -Infinity, +Infinity, -0), float32x4(13.37, 42.42, NaN, 0)]])
+  {
+      testMinFloat32(v, w);
+      testMaxFloat32(v, w);
+      testMinNumFloat32(v, w);
+      testMaxNumFloat32(v, w);
+  }
+
+  for ([v, w] of [[float64x2(1, 20), float64x2(10, 2)],
+                  [float64x2(30, 4), float64x2(3, 40)],
+                  [float64x2(9.999, 2.1234), float64x2(10, 2.1233)],
+                  [float64x2(30.4443, 4), float64x2(30.4444, 4.0001)],
+                  [float64x2(NaN, -Infinity), float64x2(13.37, 42.42)],
+                  [float64x2(+Infinity, -0), float64x2(NaN, 0)]])
+  {
+      testMinFloat64(v, w);
+      testMaxFloat64(v, w);
+      testMinNumFloat64(v, w);
+      testMaxNumFloat64(v, w);
+  }
+
+  if (typeof reportCompare === "function")
+    reportCompare(true, true);
+}
+
+test();
+
diff --git a/js/src/tests/ecma_7/SIMD/shell.js b/js/src/tests/ecma_7/SIMD/shell.js
index 8b78e1ef7ec3..55ab7ff387a3 100644
--- a/js/src/tests/ecma_7/SIMD/shell.js
+++ b/js/src/tests/ecma_7/SIMD/shell.js
@@ -1,3 +1,13 @@
+function assertEqX2(v, arr) {
+    try {
+        assertEq(v.x, arr[0]);
+        assertEq(v.y, arr[1]);
+    } catch (e) {
+        print("stack trace:", e.stack);
+        throw e;
+    }
+}
+
 function assertEqX4(v, arr) {
     try {
         assertEq(v.x, arr[0]);
@@ -10,14 +20,51 @@ function assertEqX4(v, arr) {
     }
 }
 
+function simdLength(v) {
+    var pt = Object.getPrototypeOf(v);
+    if (pt === SIMD.int32x4.prototype || pt === SIMD.float32x4.prototype) {
+        return 4;
+    } else if (pt === SIMD.float64x2.prototype) {
+        return 2;
+    } else {
+        throw new TypeError("Unknown SIMD kind.");
+    }
+}
+
+function assertEqVec(v, arr) {
+    var lanes = simdLength(v);
+    if (lanes == 4)
+        assertEqX4(v, arr);
+    else if (lanes == 2)
+        assertEqX2(v, arr);
+    else
+        throw new TypeError("Unknown SIMD kind.");
+}
+
 function simdToArray(v) {
-    return [v.x, v.y, v.z, v.w];
+    var lanes = simdLength(v);
+    if (lanes == 4)
+        return [v.x, v.y, v.z, v.w];
+    else if (lanes == 2)
+        return [v.x, v.y];
+    else
+        throw new TypeError("Unknown SIMD kind.");
 }
 
 const INT32_MAX = Math.pow(2, 31) - 1;
 const INT32_MIN = -Math.pow(2, 31);
 assertEq(INT32_MAX + 1 | 0, INT32_MIN);
 
+function testUnaryFunc(v, simdFunc, func) {
+    var varr = simdToArray(v);
+
+    var observed = simdToArray(simdFunc(v));
+    var expected = varr.map(function(v, i) { return func(varr[i]); });
+
+    for (var i = 0; i < observed.length; i++)
+        assertEq(observed[i], expected[i]);
+}
+
 function testBinaryFunc(v, w, simdFunc, func) {
     var varr = simdToArray(v);
     var warr = simdToArray(w);
@@ -29,6 +76,19 @@ function testBinaryFunc(v, w, simdFunc, func) {
         assertEq(observed[i], expected[i]);
 }
 
+function testBinaryCompare(v, w, simdFunc, func) {
+    var varr = simdToArray(v);
+    var warr = simdToArray(w);
+
+    var inLanes = simdLength(v);
+    var observed = simdToArray(simdFunc(v, w));
+    assertEq(observed.length, 4);
+    for (var i = 0; i < 4; i++) {
+        var j = ((i * inLanes) / 4) | 0;
+        assertEq(observed[i], func(varr[j], warr[j]));
+    }
+}
+
 function testBinaryScalarFunc(v, scalar, simdFunc, func) {
     var varr = simdToArray(v);
 
diff --git a/js/src/tests/ecma_7/SIMD/store.js b/js/src/tests/ecma_7/SIMD/store.js
index 99e4e6cb5f01..839cf8df5712 100644
--- a/js/src/tests/ecma_7/SIMD/store.js
+++ b/js/src/tests/ecma_7/SIMD/store.js
@@ -31,17 +31,19 @@ function testStore(ta, kind, i, v) {
     SIMD[kind].storeX(ta, i, v);
     assertChanged(ta, i, [v.x]);
 
-    reset(ta);
-    SIMD[kind].storeXY(ta, i, v);
-    assertChanged(ta, i, [v.x, v.y]);
-
-    reset(ta);
-    SIMD[kind].storeXYZ(ta, i, v);
-    assertChanged(ta, i, [v.x, v.y, v.z]);
-
     reset(ta);
     SIMD[kind].store(ta, i, v);
-    assertChanged(ta, i, [v.x, v.y, v.z, v.w]);
+    assertChanged(ta, i, simdToArray(v));
+
+    if (simdLength(v) > 2) {
+        reset(ta);
+        SIMD[kind].storeXY(ta, i, v);
+        assertChanged(ta, i, [v.x, v.y]);
+
+        reset(ta);
+        SIMD[kind].storeXYZ(ta, i, v);
+        assertChanged(ta, i, [v.x, v.y, v.z]);
+    }
 }
 
 function testStoreInt32x4() {
@@ -78,8 +80,32 @@ function testStoreFloat32x4() {
     assertThrowsInstanceOf(() => SIMD.int32x4.store(F32, 0, v), TypeError);
 }
 
+function testStoreFloat64x2() {
+    var F64 = new Float64Array(16);
+
+    var v = SIMD.float64x2(1, 2);
+    testStore(F64, 'float64x2', 0, v);
+    testStore(F64, 'float64x2', 1, v);
+    testStore(F64, 'float64x2', 14, v);
+
+    var v = SIMD.float64x2(NaN, -0);
+    testStore(F64, 'float64x2', 0, v);
+    testStore(F64, 'float64x2', 1, v);
+    testStore(F64, 'float64x2', 14, v);
+
+    var v = SIMD.float64x2(-Infinity, +Infinity);
+    testStore(F64, 'float64x2', 0, v);
+    testStore(F64, 'float64x2', 1, v);
+    testStore(F64, 'float64x2', 14, v);
+
+    assertThrowsInstanceOf(() => SIMD.float64x2.store(F64), TypeError);
+    assertThrowsInstanceOf(() => SIMD.float64x2.store(F64, 0), TypeError);
+    assertThrowsInstanceOf(() => SIMD.float32x4.store(F64, 0, v), TypeError);
+}
+
 testStoreInt32x4();
 testStoreFloat32x4();
+testStoreFloat64x2();
 
 if (typeof reportCompare === "function")
     reportCompare(true, true);
diff --git a/js/src/tests/ecma_7/SIMD/swizzle-shuffle.js b/js/src/tests/ecma_7/SIMD/swizzle-shuffle.js
index 2e2d86fa4025..77c1c890332c 100644
--- a/js/src/tests/ecma_7/SIMD/swizzle-shuffle.js
+++ b/js/src/tests/ecma_7/SIMD/swizzle-shuffle.js
@@ -6,28 +6,62 @@
  */
 
 var float32x4 = SIMD.float32x4;
+var float64x2 = SIMD.float64x2;
 var int32x4 = SIMD.int32x4;
 
-function swizzle(arr, x, y, z, w) {
+function swizzle2(arr, x, y) {
+    return [arr[x], arr[y]];
+}
+
+function swizzle4(arr, x, y, z, w) {
     return [arr[x], arr[y], arr[z], arr[w]];
 }
 
+function getNumberOfLanesFromType(type) {
+    switch (type) {
+      case float32x4:
+      case int32x4:
+        return 4;
+      case float64x2:
+        return 2;
+    }
+    throw new TypeError("Unknown SIMD type.");
+}
+
 function testSwizzleForType(type) {
-    var v = type(1,2,3,4);
+    var lanes = getNumberOfLanesFromType(type);
+    var v = lanes == 4 ? type(1, 2, 3, 4) : type(1, 2);
 
     assertThrowsInstanceOf(() => type.swizzle()               , TypeError);
     assertThrowsInstanceOf(() => type.swizzle(v, 0)           , TypeError);
-    assertThrowsInstanceOf(() => type.swizzle(v, 0, 1)        , TypeError);
     assertThrowsInstanceOf(() => type.swizzle(v, 0, 1, 2)     , TypeError);
     assertThrowsInstanceOf(() => type.swizzle(v, 0, 1, 2, 4)  , TypeError);
     assertThrowsInstanceOf(() => type.swizzle(v, 0, 1, 2, -1) , TypeError);
     assertThrowsInstanceOf(() => type.swizzle(0, 1, 2, 3, v)  , TypeError);
 
+    if (lanes == 2) {
+        assertThrowsInstanceOf(() => type.swizzle(v, 0, -1)   , TypeError);
+        assertThrowsInstanceOf(() => type.swizzle(v, 0, 2)    , TypeError);
+    } else {
+        assertEq(lanes, 4);
+        assertThrowsInstanceOf(() => type.swizzle(v, 0, 1), TypeError);
+    }
+
     // Test all possible swizzles.
-    var x, y, z, w;
-    for (var i = 0; i < Math.pow(4, 4); i++) {
-        [x, y, z, w] = [i & 3, (i >> 2) & 3, (i >> 4) & 3, (i >> 6) & 3];
-        assertEqX4(type.swizzle(v, x, y, z, w), swizzle(simdToArray(v), x, y, z, w));
+    if (lanes == 4) {
+        var x, y, z, w;
+        for (var i = 0; i < Math.pow(4, 4); i++) {
+            [x, y, z, w] = [i & 3, (i >> 2) & 3, (i >> 4) & 3, (i >> 6) & 3];
+            assertEqVec(type.swizzle(v, x, y, z, w), swizzle4(simdToArray(v), x, y, z, w));
+        }
+    } else {
+        assertEq(lanes, 2);
+        var x, y;
+        for (var i = 0; i < Math.pow(2, 2); i++) {
+          x = i % 2;
+          y = i > 1 ? 1 : 0;
+          assertEqVec(type.swizzle(v, x, y), swizzle2(simdToArray(v), x, y));
+        }
     }
 
     // Test that the lane inputs are converted into an int32.
@@ -36,7 +70,12 @@ function testSwizzleForType(type) {
         x: 0,
         valueOf: function() { return this.x++ }
     };
-    assertEqX4(type.swizzle(v, obj, obj, obj, obj), swizzle(simdToArray(v), 0, 1, 2, 3));
+    if (lanes == 4) {
+        assertEqVec(type.swizzle(v, obj, obj, obj, obj), swizzle4(simdToArray(v), 0, 1, 2, 3));
+    } else {
+        assertEq(lanes, 2);
+        assertEqVec(type.swizzle(v, obj, obj), swizzle2(simdToArray(v), 0, 1));
+    }
 
     // Object for which ToInt32 will fail.
     obj = {
@@ -65,7 +104,21 @@ function testSwizzleFloat32x4() {
     testSwizzleForType(float32x4);
 }
 
-function shuffle(lhsa, rhsa, x, y, z, w) {
+function testSwizzleFloat64x2() {
+    var v = float64x2(1, 2);
+
+    assertThrowsInstanceOf(function() {
+        float32x4.swizzle(v, 0, 0, 0, 0);
+    }, TypeError);
+
+   testSwizzleForType(float64x2);
+}
+
+function shuffle2(lhsa, rhsa, x, y) {
+    return [(x < 2 ? lhsa : rhsa)[x % 2],
+            (y < 2 ? lhsa : rhsa)[y % 2]];
+}
+function shuffle4(lhsa, rhsa, x, y, z, w) {
     return [(x < 4 ? lhsa : rhsa)[x % 4],
             (y < 4 ? lhsa : rhsa)[y % 4],
             (z < 4 ? lhsa : rhsa)[z % 4],
@@ -73,24 +126,50 @@ function shuffle(lhsa, rhsa, x, y, z, w) {
 }
 
 function testShuffleForType(type) {
-    var lhs = type(1,2,3,4);
-    var rhs = type(5,6,7,8);
+    var lanes = getNumberOfLanesFromType(type);
+    var lhs, rhs;
+    if (lanes == 4) {
+        lhs = type(1, 2, 3, 4);
+        rhs = type(5, 6, 7, 8);
+    } else {
+        assertEq(lanes, 2);
+        lhs = type(1, 2);
+        rhs = type(3, 4);
+    }
 
     assertThrowsInstanceOf(() => type.shuffle(lhs)                   , TypeError);
     assertThrowsInstanceOf(() => type.shuffle(lhs, rhs)              , TypeError);
     assertThrowsInstanceOf(() => type.shuffle(lhs, rhs, 0)           , TypeError);
-    assertThrowsInstanceOf(() => type.shuffle(lhs, rhs, 0, 1)        , TypeError);
     assertThrowsInstanceOf(() => type.shuffle(lhs, rhs, 0, 1, 2)     , TypeError);
     assertThrowsInstanceOf(() => type.shuffle(lhs, rhs, 0, 1, 2, -1) , TypeError);
     assertThrowsInstanceOf(() => type.shuffle(lhs, rhs, 0, 1, 2, 8)  , TypeError);
     assertThrowsInstanceOf(() => type.shuffle(lhs, 0, 1, 2, 7, rhs)  , TypeError);
 
+    if (lanes == 2) {
+        assertThrowsInstanceOf(() => type.shuffle(lhs, rhs, 0, 4)    , TypeError);
+        assertThrowsInstanceOf(() => type.shuffle(lhs, rhs, 0, -1)   , TypeError);
+    } else {
+        assertEq(lanes, 4);
+        assertThrowsInstanceOf(() => type.shuffle(lhs, rhs, 0, 1) , TypeError);
+    }
+
     // Test all possible shuffles.
     var x, y, z, w;
-    for (var i = 0; i < Math.pow(8, 4); i++) {
-        [x, y, z, w] = [i & 7, (i >> 3) & 7, (i >> 6) & 7, (i >> 9) & 7];
-        assertEqX4(type.shuffle(lhs, rhs, x, y, z, w),
-                   shuffle(simdToArray(lhs), simdToArray(rhs), x, y, z, w));
+    if (lanes == 4) {
+        var x, y, z, w;
+        for (var i = 0; i < Math.pow(8, 4); i++) {
+            [x, y, z, w] = [i & 7, (i >> 3) & 7, (i >> 6) & 7, (i >> 9) & 7];
+            assertEqVec(type.shuffle(lhs, rhs, x, y, z, w),
+                        shuffle4(simdToArray(lhs), simdToArray(rhs), x, y, z, w));
+        }
+    } else {
+        assertEq(lanes, 2);
+        var x, y;
+        for (var i = 0; i < Math.pow(4, 2); i++) {
+            [x, y] = [i & 3, (i >> 3) & 3];
+            assertEqVec(type.shuffle(lhs, rhs, x, y),
+                        shuffle2(simdToArray(lhs), simdToArray(rhs), x, y));
+        }
     }
 
     // Test that the lane inputs are converted into an int32.
@@ -99,8 +178,14 @@ function testShuffleForType(type) {
         x: 0,
         valueOf: function() { return this.x++ }
     };
-    assertEqX4(type.shuffle(lhs, rhs, obj, obj, obj, obj),
-               shuffle(simdToArray(lhs),simdToArray(rhs), 0, 1, 2, 3));
+    if (lanes == 4) {
+        assertEqVec(type.shuffle(lhs, rhs, obj, obj, obj, obj),
+                    shuffle4(simdToArray(lhs),simdToArray(rhs), 0, 1, 2, 3));
+    } else {
+        assertEq(lanes, 2);
+        assertEqVec(type.shuffle(lhs, rhs, obj, obj),
+                    shuffle2(simdToArray(lhs),simdToArray(rhs), 0, 1));
+    }
 
     // Object for which ToInt32 will fail.
     obj = {
@@ -129,10 +214,22 @@ function testShuffleFloat32x4() {
     testShuffleForType(float32x4);
 }
 
+function testShuffleFloat64x2() {
+    var v = float64x2(1, 2);
+
+    assertThrowsInstanceOf(function() {
+        float32x4.shuffle(v, v, 0, 0, 0, 0);
+    }, TypeError);
+
+    testShuffleForType(float64x2);
+}
+
 testSwizzleInt32x4();
 testSwizzleFloat32x4();
+testSwizzleFloat64x2();
 testShuffleInt32x4();
 testShuffleFloat32x4();
+testShuffleFloat64x2();
 
 if (typeof reportCompare === "function")
     reportCompare(true, true);