deps: update V8 to 6.3.292.46

PR-URL: https://github.com/nodejs/node/pull/16271
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Myles Borins <myles.borins@gmail.com>

122 files changed, 10379 insertions, 406 deletions

diff --git a/deps/v8/test/mjsunit/array-constructor-feedback.js b/deps/v8/test/mjsunit/array-constructor-feedback.js
index c1f386d983..fb4ad5a19a 100644
--- a/deps/v8/test/mjsunit/array-constructor-feedback.js
+++ b/deps/v8/test/mjsunit/array-constructor-feedback.js
@@ -106,14 +106,9 @@ function assertKind(expected, obj, name_opt) {
   a = bar(10);
   assertKind(elements_kind.fast, a);
   assertOptimized(bar);
-  bar(100000);
+  bar(10000);
   assertOptimized(bar);
 
-  // If the argument isn't a smi, things should still work.
-  a = bar("oops");
-  assertOptimized(bar);
-  assertKind(elements_kind.fast, a);
-
   function barn(one, two, three) {
     return new Array(one, two, three);
   }
diff --git a/deps/v8/test/mjsunit/array-reduce.js b/deps/v8/test/mjsunit/array-reduce.js
index f34d3ef6ff..4a4494a72c 100644
--- a/deps/v8/test/mjsunit/array-reduce.js
+++ b/deps/v8/test/mjsunit/array-reduce.js
@@ -537,3 +537,23 @@ var arr = [];
 Object.defineProperty(arr, "0", { get: function() { delete this[0] },
   configurable: true});
 assertEquals(undefined, arr.reduceRight(function(val) { return val }));
+
+
+(function ReduceRightMaxIndex() {
+  const kMaxIndex = 0xffffffff-1;
+  let array = [];
+  array[kMaxIndex-2] = 'value-2';
+  array[kMaxIndex-1] = 'value-1';
+  // Use the maximum array index possible.
+  array[kMaxIndex] = 'value';
+  // Add the next index which is a normal property and thus will not show up.
+  array[kMaxIndex+1] = 'normal property';
+  assertThrowsEquals( () => {
+      array.reduceRight((sum, value) => {
+        assertEquals('initial', sum);
+        assertEquals('value', value);
+        // Throw at this point as we would very slowly loop down from kMaxIndex.
+        throw 'do not continue';
+      }, 'initial')
+  }, 'do not continue');
+})();
diff --git a/deps/v8/test/mjsunit/asm/math-max.js b/deps/v8/test/mjsunit/asm/math-max.js
new file mode 100644
index 0000000000..d5dc0d1617
--- /dev/null
+++ b/deps/v8/test/mjsunit/asm/math-max.js
@@ -0,0 +1,78 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+function Module(stdlib) {
+  "use asm";
+
+  var max = stdlib.Math.max;
+  var fround = stdlib.Math.fround;
+
+  // f: double, double -> double
+  function f(a, b) {
+    a = +a; b = +b;
+    return +max(a, b);
+  }
+
+  // g: signed, signed -> signed
+  function g(a, b) {
+    a = a | 0; b = b | 0;
+    return max(a >> 0, b >> 0) | 0;
+  }
+
+  // h: float, float -> float
+  function h(a, b) {
+    a = fround(a); b = fround(b);
+    return fround(max(a, b));
+  }
+
+  return { f: f, g: g, h: h };
+}
+
+var m = Module({ Math: Math });
+var f = m.f;
+var g = m.g;
+var h = m.h;
+
+assertTrue(isNaN(f(0, NaN)));
+assertFalse(isFinite(f(0, Infinity)));
+assertTrue(isFinite(f(0, -Infinity)));
+
+assertTrue(Object.is(+0, f(-0, +0)));
+assertTrue(Object.is(+0, f(+0, -0)));
+
+assertEquals(0.1,  f( 0,    0.1));
+assertEquals(0.5,  f( 0.1,  0.5));
+assertEquals(0.5,  f( 0.5, -0.1));
+assertEquals(-0.1, f(-0.1, -0.5));
+assertEquals(1,    f(-0.5,  1));
+assertEquals(1.1,  f( 1,    1.1));
+assertEquals(1.1,  f( 1.1, -1));
+assertEquals(-1,   f(-1,   -1.1));
+assertEquals(0,    f(-1.1,  0));
+
+assertEquals( 1, g( 0,  1));
+assertEquals( 5, g( 1,  5));
+assertEquals( 5, g( 5, -1));
+assertEquals(-1, g(-1, -5));
+assertEquals( 1, g(-5,  1));
+assertEquals( 1, g( 1, -1));
+assertEquals( 0, g(-1,  0));
+
+assertEquals(Math.fround(0.1),  h( 0,    0.1));
+assertEquals(Math.fround(0.5),  h( 0.1,  0.5));
+assertEquals(Math.fround(0.5),  h( 0.5, -0.1));
+assertEquals(Math.fround(-0.1), h(-0.1, -0.5));
+assertEquals(Math.fround(1),    h(-0.5,  1));
+assertEquals(Math.fround(1.1),  h( 1,    1.1));
+assertEquals(Math.fround(1.1),  h( 1.1, -1));
+assertEquals(Math.fround(-1),   h(-1,   -1.1));
+assertEquals(Math.fround(0),    h(-1.1,  0));
+
+assertEquals(1, g(0, Number.MIN_SAFE_INTEGER));
+assertEquals(0, g(0, Number.MAX_SAFE_INTEGER));
+
+assertEquals(Number.MAX_VALUE, f(Number.MIN_VALUE, Number.MAX_VALUE));
+assertEquals(Number.MAX_VALUE, f(Number.MAX_VALUE, Number.MIN_VALUE));
+assertEquals(Number.POSITIVE_INFINITY, f(Number.POSITIVE_INFINITY, 0));
+assertEquals(0, f(Number.NEGATIVE_INFINITY, 0));
diff --git a/deps/v8/test/mjsunit/asm/math-min.js b/deps/v8/test/mjsunit/asm/math-min.js
new file mode 100644
index 0000000000..5923d267d0
--- /dev/null
+++ b/deps/v8/test/mjsunit/asm/math-min.js
@@ -0,0 +1,78 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+function Module(stdlib) {
+  "use asm";
+
+  var min = stdlib.Math.min;
+  var fround = stdlib.Math.fround;
+
+  // f: double, double -> double
+  function f(a, b) {
+    a = +a; b = +b;
+    return +min(a, b);
+  }
+
+  // g: signed, signed -> signed
+  function g(a, b) {
+    a = a | 0; b = b | 0;
+    return min(a >> 0, b >> 0) | 0;
+  }
+
+  // h: float, float -> float
+  function h(a, b) {
+    a = fround(a); b = fround(b);
+    return fround(min(a, b));
+  }
+
+  return { f: f, g: g, h: h };
+}
+
+var m = Module({ Math: Math });
+var f = m.f;
+var g = m.g;
+var h = m.h;
+
+assertTrue(isNaN(f(0, NaN)));
+assertTrue(isFinite(f(0, Infinity)));
+assertFalse(isFinite(f(0, -Infinity)));
+
+assertTrue(Object.is(-0, f(-0, +0)));
+assertTrue(Object.is(-0, f(+0, -0)));
+
+assertEquals(0,    f( 0,    0.1));
+assertEquals(0.1,  f( 0.1,  0.5));
+assertEquals(-0.1, f( 0.5, -0.1));
+assertEquals(-0.5, f(-0.1, -0.5));
+assertEquals(-0.5, f(-0.5,  1));
+assertEquals(1,    f( 1,    1.1));
+assertEquals(-1,   f( 1.1, -1));
+assertEquals(-1.1, f(-1,   -1.1));
+assertEquals(-1.1, f(-1.1,  0));
+
+assertEquals( 0, g( 0,  1));
+assertEquals( 1, g( 1,  5));
+assertEquals(-1, g( 5, -1));
+assertEquals(-5, g(-1, -5));
+assertEquals(-5, g(-5,  1));
+assertEquals(-1, g( 1, -1));
+assertEquals(-1, g(-1,  0));
+
+assertEquals(Math.fround(0),    h( 0,    0.1));
+assertEquals(Math.fround(0.1),  h( 0.1,  0.5));
+assertEquals(Math.fround(-0.1), h( 0.5, -0.1));
+assertEquals(Math.fround(-0.5), h(-0.1, -0.5));
+assertEquals(Math.fround(-0.5), h(-0.5,  1));
+assertEquals(Math.fround(1),    h( 1,    1.1));
+assertEquals(Math.fround(-1),   h( 1.1, -1));
+assertEquals(Math.fround(-1.1), h(-1,   -1.1));
+assertEquals(Math.fround(-1.1), h(-1.1,  0));
+
+assertEquals(0, g(0, Number.MIN_SAFE_INTEGER));
+assertEquals(-1, g(0, Number.MAX_SAFE_INTEGER));
+
+assertEquals(Number.MIN_VALUE, f(Number.MIN_VALUE, Number.MAX_VALUE));
+assertEquals(Number.MIN_VALUE, f(Number.MAX_VALUE, Number.MIN_VALUE));
+assertEquals(0, f(Number.POSITIVE_INFINITY, 0));
+assertEquals(Number.NEGATIVE_INFINITY, f(Number.NEGATIVE_INFINITY, 0));
diff --git a/deps/v8/test/mjsunit/asm/noexpose-wasm.js b/deps/v8/test/mjsunit/asm/noexpose-wasm.js
new file mode 100644
index 0000000000..7336ab2727
--- /dev/null
+++ b/deps/v8/test/mjsunit/asm/noexpose-wasm.js
@@ -0,0 +1,37 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --noexpose-wasm --validate-asm
+
+assertThrows(() => { let x = WebAssembly.Module; });
+
+function Module(stdlib, foreign, heap) {
+  "use asm";
+  function f1(i) {
+    i = i|0;
+    return (i | 0) / 3 | 0;
+  }
+  function f2(i) {
+    i = i|0;
+    return (i | 0) / 13 | 0;
+  }
+  function f3(i) {
+    i = i|0;
+    return (i | 0) / 1024 | 0;
+  }
+  function f4(i) {
+    i = i|0;
+    return (i | 0) / 3733331 | 0;
+  }
+  return { f1: f1, f2: f2, f3: f3, f4: f4 };
+}
+
+var m = Module(this, {}, new ArrayBuffer(1024));
+
+for (var i = -2147483648; i < 2147483648; i += 3999777) {
+  assertEquals(i / 3 | 0, m.f1(i));
+  assertEquals(i / 13 | 0, m.f2(i));
+  assertEquals(i / 1024 | 0, m.f3(i));
+  assertEquals(i / 3733331 | 0, m.f4(i));
+}
diff --git a/deps/v8/test/mjsunit/code-coverage-precise.js b/deps/v8/test/mjsunit/code-coverage-precise.js
index 3d5d5bac9e..c5569cf010 100644
--- a/deps/v8/test/mjsunit/code-coverage-precise.js
+++ b/deps/v8/test/mjsunit/code-coverage-precise.js
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 // Flags: --allow-natives-syntax --no-always-opt
+// Flags: --no-stress-incremental-marking
 // Files: test/mjsunit/code-coverage-utils.js
 
 // Test precise code coverage.
diff --git a/deps/v8/test/mjsunit/compiler/array-push-1.js b/deps/v8/test/mjsunit/compiler/array-push-1.js
new file mode 100644
index 0000000000..58afd6ffe6
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/array-push-1.js
@@ -0,0 +1,239 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --opt
+
+// Test multiple arguments push for PACKED_SMI_ELEMENTS.
+(function() {
+  function push0(a) {
+    return a.push();
+  }
+
+  assertEquals(0, push0([]));
+  assertEquals(1, push0([1]));
+  %OptimizeFunctionOnNextCall(push0);
+  assertEquals(2, push0([1, 2]));
+
+  function push1(a) {
+    return a.push(1);
+  }
+
+  assertEquals(1, push1([]));
+  assertEquals(2, push1([1]));
+  %OptimizeFunctionOnNextCall(push1);
+  assertEquals(3, push1([1, 2]));
+
+  function push2(a) {
+    return a.push(1, 2);
+  }
+
+  assertEquals(2, push2([]));
+  assertEquals(3, push2([1]));
+  %OptimizeFunctionOnNextCall(push2);
+  assertEquals(4, push2([1, 2]));
+
+  function push3(a) {
+    return a.push(1, 2, 3);
+  }
+
+  assertEquals(3, push3([]));
+  assertEquals(4, push3([1]));
+  %OptimizeFunctionOnNextCall(push3);
+  assertEquals(5, push3([1, 2]));
+})();
+
+// Test multiple arguments push for HOLEY_SMI_ELEMENTS.
+(function() {
+  function push0(a) {
+    return a.push();
+  }
+
+  assertEquals(1, push0(new Array(1)));
+  assertEquals(2, push0(new Array(2)));
+  %OptimizeFunctionOnNextCall(push0);
+  assertEquals(3, push0(new Array(3)));
+
+  function push1(a) {
+    return a.push(1);
+  }
+
+  assertEquals(2, push1(new Array(1)));
+  assertEquals(3, push1(new Array(2)));
+  %OptimizeFunctionOnNextCall(push1);
+  assertEquals(4, push1(new Array(3)));
+
+  function push2(a) {
+    return a.push(1, 2);
+  }
+
+  assertEquals(3, push2(new Array(1)));
+  assertEquals(4, push2(new Array(2)));
+  %OptimizeFunctionOnNextCall(push2);
+  assertEquals(5, push2(new Array(3)));
+
+  function push3(a) {
+    return a.push(1, 2, 3);
+  }
+
+  assertEquals(4, push3(new Array(1)));
+  assertEquals(5, push3(new Array(2)));
+  %OptimizeFunctionOnNextCall(push3);
+  assertEquals(6, push3(new Array(3)));
+})();
+
+// Test multiple arguments push for PACKED_DOUBLE_ELEMENTS.
+(function() {
+  function push0(a) {
+    return a.push();
+  }
+
+  assertEquals(1, push0([1.1]));
+  assertEquals(2, push0([1.1, 2.2]));
+  %OptimizeFunctionOnNextCall(push0);
+  assertEquals(3, push0([1.1, 2.2, 3.3]));
+
+  function push1(a) {
+    return a.push(1.1);
+  }
+
+  assertEquals(2, push1([1.1]));
+  assertEquals(3, push1([1.1, 2.2]));
+  %OptimizeFunctionOnNextCall(push1);
+  assertEquals(4, push1([1.1, 2.2, 3.3]));
+
+  function push2(a) {
+    return a.push(1.1, 2.2);
+  }
+
+  assertEquals(3, push2([1.1]));
+  assertEquals(4, push2([1.1, 2.2]));
+  %OptimizeFunctionOnNextCall(push2);
+  assertEquals(5, push2([1.1, 2.2, 3.3]));
+
+  function push3(a) {
+    return a.push(1.1, 2.2, 3.3);
+  }
+
+  assertEquals(4, push3([1.1]));
+  assertEquals(5, push3([1.1, 2.2]));
+  %OptimizeFunctionOnNextCall(push3);
+  assertEquals(6, push3([1.1, 2.2, 3.3]));
+})();
+
+// Test multiple arguments push for HOLEY_DOUBLE_ELEMENTS.
+(function() {
+  function push0(a) {
+    return a.push();
+  }
+
+  assertEquals(2, push0([, 1.1]));
+  assertEquals(3, push0([, 1.1, 2.2]));
+  %OptimizeFunctionOnNextCall(push0);
+  assertEquals(4, push0([, 1.1, 2.2, 3.3]));
+
+  function push1(a) {
+    return a.push(1.1);
+  }
+
+  assertEquals(3, push1([, 1.1]));
+  assertEquals(4, push1([, 1.1, 2.2]));
+  %OptimizeFunctionOnNextCall(push1);
+  assertEquals(5, push1([, 1.1, 2.2, 3.3]));
+
+  function push2(a) {
+    return a.push(1.1, 2.2);
+  }
+
+  assertEquals(4, push2([, 1.1]));
+  assertEquals(5, push2([, 1.1, 2.2]));
+  %OptimizeFunctionOnNextCall(push2);
+  assertEquals(6, push2([, 1.1, 2.2, 3.3]));
+
+  function push3(a) {
+    return a.push(1.1, 2.2, 3.3);
+  }
+
+  assertEquals(5, push3([, 1.1]));
+  assertEquals(6, push3([, 1.1, 2.2]));
+  %OptimizeFunctionOnNextCall(push3);
+  assertEquals(7, push3([, 1.1, 2.2, 3.3]));
+})();
+
+// Test multiple arguments push for PACKED_ELEMENTS.
+(function() {
+  function push0(a) {
+    return a.push();
+  }
+
+  assertEquals(1, push0(['1']));
+  assertEquals(2, push0(['1', '2']));
+  %OptimizeFunctionOnNextCall(push0);
+  assertEquals(3, push0(['1', '2', '3']));
+
+  function push1(a) {
+    return a.push('1');
+  }
+
+  assertEquals(2, push1(['1']));
+  assertEquals(3, push1(['1', '2']));
+  %OptimizeFunctionOnNextCall(push1);
+  assertEquals(4, push1(['1', '2', '3']));
+
+  function push2(a) {
+    return a.push('1', '2');
+  }
+
+  assertEquals(3, push2(['1']));
+  assertEquals(4, push2(['1', '2']));
+  %OptimizeFunctionOnNextCall(push2);
+  assertEquals(5, push2(['1', '2', '3']));
+
+  function push3(a) {
+    return a.push('1', '2', '3');
+  }
+
+  assertEquals(4, push3(['1']));
+  assertEquals(5, push3(['1', '2']));
+  %OptimizeFunctionOnNextCall(push3);
+  assertEquals(6, push3(['1', '2', '3']));
+})();
+
+// Test multiple arguments push for HOLEY_ELEMENTS.
+(function() {
+  function push0(a) {
+    return a.push();
+  }
+
+  assertEquals(2, push0([, '1']));
+  assertEquals(3, push0([, '1', '2']));
+  %OptimizeFunctionOnNextCall(push0);
+  assertEquals(4, push0([, '1', '2', '3']));
+
+  function push1(a) {
+    return a.push('1');
+  }
+
+  assertEquals(3, push1([, '1']));
+  assertEquals(4, push1([, '1', '2']));
+  %OptimizeFunctionOnNextCall(push1);
+  assertEquals(5, push1([, '1', '2', '3']));
+
+  function push2(a) {
+    return a.push('1', '2');
+  }
+
+  assertEquals(4, push2([, '1']));
+  assertEquals(5, push2([, '1', '2']));
+  %OptimizeFunctionOnNextCall(push2);
+  assertEquals(6, push2([, '1', '2', '3']));
+
+  function push3(a) {
+    return a.push('1', '2', '3');
+  }
+
+  assertEquals(5, push3([, '1']));
+  assertEquals(6, push3([, '1', '2']));
+  %OptimizeFunctionOnNextCall(push3);
+  assertEquals(7, push3([, '1', '2', '3']));
+})();
diff --git a/deps/v8/test/mjsunit/compiler/array-push-2.js b/deps/v8/test/mjsunit/compiler/array-push-2.js
new file mode 100644
index 0000000000..cb18d71d63
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/array-push-2.js
@@ -0,0 +1,65 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --opt
+
+// Test elements transition from SMI to DOUBLE.
+(function() {
+  const a = [];
+  const foo = (x, y) => a.push(x, y);
+  foo(1, 2);
+  foo(3, 4);
+  %OptimizeFunctionOnNextCall(foo);
+  foo(5, 6.6);
+  assertEquals([1, 2, 3, 4, 5, 6.6], a);
+})();
+(function() {
+  const a = [];
+  const foo = (x, y) => a.push(x, y);
+  foo(1, 2);
+  foo(3, 4);
+  %OptimizeFunctionOnNextCall(foo);
+  foo(5.5, 6.6);
+  assertEquals([1, 2, 3, 4, 5.5, 6.6], a);
+})();
+
+// Test elements transition from SMI to OBJECT.
+(function() {
+  const a = [];
+  const foo = (x, y) => a.push(x, y);
+  foo(1, 2);
+  foo(3, 4);
+  %OptimizeFunctionOnNextCall(foo);
+  foo(5, '6');
+  assertEquals([1, 2, 3, 4, 5, '6'], a);
+})();
+(function() {
+  const a = [];
+  const foo = (x, y) => a.push(x, y);
+  foo(1, 2);
+  foo(3, 4);
+  %OptimizeFunctionOnNextCall(foo);
+  foo('5', '6');
+  assertEquals([1, 2, 3, 4, '5', '6'], a);
+})();
+
+// Test elements transition from DOUBLE to OBJECT.
+(function() {
+  const a = [0.5];
+  const foo = (x, y) => a.push(x, y);
+  foo(1, 2);
+  foo(3, 4);
+  %OptimizeFunctionOnNextCall(foo);
+  foo(5, '6');
+  assertEquals([0.5, 1, 2, 3, 4, 5, '6'], a);
+})();
+(function() {
+  const a = [0.5];
+  const foo = (x, y) => a.push(x, y);
+  foo(1, 2);
+  foo(3, 4);
+  %OptimizeFunctionOnNextCall(foo);
+  foo('5', '6');
+  assertEquals([0.5, 1, 2, 3, 4, '5', '6'], a);
+})();
diff --git a/deps/v8/test/mjsunit/compiler/array-push-3.js b/deps/v8/test/mjsunit/compiler/array-push-3.js
new file mode 100644
index 0000000000..f648eb9ed9
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/array-push-3.js
@@ -0,0 +1,51 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --opt
+
+// Test side effects on arguments evaluation.
+(function() {
+  const a = [];
+  const bar = x => { a.push(x); return x; };
+  const foo = x => a.push(bar(x), bar(x));
+  foo(1);
+  foo(2);
+  %OptimizeFunctionOnNextCall(foo);
+  foo(3);
+  assertEquals([1,1,1,1, 2,2,2,2, 3,3,3,3], a);
+})();
+
+// Test invalidation on arguments evaluation.
+(function() {
+  let y = 1;
+  const a = [];
+  const bar = x => { a.push(y); return x; }
+  const foo = x => a.push(bar(x), bar(x));
+  foo(1);
+  y = 2;
+  foo(2);
+  %OptimizeFunctionOnNextCall(foo);
+  y = 3;
+  foo(3);
+  assertOptimized(foo);
+  y = 4.4;
+  foo(4);
+  assertEquals([1,1,1,1, 2,2,2,2, 3,3,3,3, 4.4,4.4,4,4], a);
+})();
+(function() {
+  let y = 1;
+  const a = [0.5];
+  const bar = x => { a.push(y); return x; }
+  const foo = x => a.push(bar(x), bar(x));
+  foo(1);
+  y = 2;
+  foo(2);
+  %OptimizeFunctionOnNextCall(foo);
+  y = 3;
+  foo(3);
+  assertOptimized(foo);
+  y = '4';
+  foo(4);
+  assertEquals([0.5, 1,1,1,1, 2,2,2,2, 3,3,3,3, '4','4',4,4], a);
+})();
diff --git a/deps/v8/test/mjsunit/compiler/array-subclass.js b/deps/v8/test/mjsunit/compiler/array-subclass.js
new file mode 100644
index 0000000000..d20b669661
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/array-subclass.js
@@ -0,0 +1,396 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+// Test Array subclass default constructor with no parameters.
+(function() {
+  const A = class A extends Array { };
+
+  function foo() { return new A; }
+
+  assertInstanceof(foo(), A);
+  assertEquals(0, foo().length);
+  assertInstanceof(foo(), A);
+  assertEquals(0, foo().length);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(0, foo().length);
+})();
+
+// Test Array subclass default constructor with small constant length.
+(function() {
+  const A = class A extends Array { };
+  const L = 4;
+
+  function foo() { return new A(L); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+})();
+
+// Test Array subclass default constructor with large constant length.
+(function() {
+  const A = class A extends Array { };
+  const L = 1024 * 1024;
+
+  function foo() { return new A(L); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+})();
+
+// Test Array subclass default constructor with known boolean.
+(function() {
+  const A = class A extends Array { };
+
+  function foo() { return new A(true); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals(true, foo()[0]);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals(true, foo()[0]);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals(true, foo()[0]);
+})();
+
+// Test Array subclass default constructor with known string.
+(function() {
+  const A = class A extends Array { };
+
+  function foo() { return new A(""); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals("", foo()[0]);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals("", foo()[0]);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals("", foo()[0]);
+})();
+
+// Test Array subclass default constructor with known object.
+(function() {
+  const A = class A extends Array { };
+  const O = {foo: "foo"};
+
+  function foo() { return new A(O); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertSame(O, foo()[0]);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertSame(O, foo()[0]);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertSame(O, foo()[0]);
+})();
+
+// Test Array subclass default constructor with known small integers.
+(function() {
+  const A = class A extends Array { };
+
+  function foo() { return new A(1, 2, 3); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(3, foo().length);
+  assertEquals(1, foo()[0]);
+  assertEquals(2, foo()[1]);
+  assertEquals(3, foo()[2]);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(3, foo().length);
+  assertEquals(1, foo()[0]);
+  assertEquals(2, foo()[1]);
+  assertEquals(3, foo()[2]);
+})();
+
+// Test Array subclass default constructor with known numbers.
+(function() {
+  const A = class A extends Array { };
+
+  function foo() { return new A(1.1, 2.2, 3.3); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(3, foo().length);
+  assertEquals(1.1, foo()[0]);
+  assertEquals(2.2, foo()[1]);
+  assertEquals(3.3, foo()[2]);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(3, foo().length);
+  assertEquals(1.1, foo()[0]);
+  assertEquals(2.2, foo()[1]);
+  assertEquals(3.3, foo()[2]);
+})();
+
+// Test Array subclass default constructor with known strings.
+(function() {
+  const A = class A extends Array { };
+
+  function foo() { return new A("a", "b", "c", "d"); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(4, foo().length);
+  assertEquals("a", foo()[0]);
+  assertEquals("b", foo()[1]);
+  assertEquals("c", foo()[2]);
+  assertEquals("d", foo()[3]);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(4, foo().length);
+  assertEquals("a", foo()[0]);
+  assertEquals("b", foo()[1]);
+  assertEquals("c", foo()[2]);
+  assertEquals("d", foo()[3]);
+})();
+
+// Test Array subclass constructor with no parameters.
+(function() {
+  const A = class A extends Array {
+    constructor() {
+      super();
+      this.bar = 1;
+    }
+  };
+
+  function foo() { return new A; }
+
+  assertInstanceof(foo(), A);
+  assertEquals(0, foo().length);
+  assertEquals(1, foo().bar);
+  assertInstanceof(foo(), A);
+  assertEquals(0, foo().length);
+  assertEquals(1, foo().bar);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(0, foo().length);
+  assertEquals(1, foo().bar);
+})();
+
+// Test Array subclass constructor with small constant length.
+(function() {
+  const A = class A extends Array {
+    constructor(n) {
+      super(n);
+      this.bar = 1;
+    }
+  };
+  const L = 4;
+
+  function foo() { return new A(L); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  assertEquals(1, foo().bar);
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  assertEquals(1, foo().bar);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  assertEquals(1, foo().bar);
+})();
+
+// Test Array subclass constructor with large constant length.
+(function() {
+  const A = class A extends Array {
+    constructor(n) {
+      super(n);
+      this.bar = 1;
+    }
+  };
+  const L = 1024 * 1024;
+
+  function foo() { return new A(L); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  assertEquals(1, foo().bar);
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  assertEquals(1, foo().bar);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(L, foo().length);
+  assertEquals(1, foo().bar);
+})();
+
+// Test Array subclass constructor with known boolean.
+(function() {
+  const A = class A extends Array {
+    constructor(n) {
+      super(n);
+      this.bar = 1;
+    }
+  };
+
+  function foo() { return new A(true); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals(true, foo()[0]);
+  assertEquals(1, foo().bar);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals(true, foo()[0]);
+  assertEquals(1, foo().bar);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals(true, foo()[0]);
+  assertEquals(1, foo().bar);
+})();
+
+// Test Array subclass constructor with known string.
+(function() {
+  const A = class A extends Array {
+    constructor(n) {
+      super(n);
+      this.bar = 1;
+    }
+  };
+
+  function foo() { return new A(""); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals("", foo()[0]);
+  assertEquals(1, foo().bar);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals("", foo()[0]);
+  assertEquals(1, foo().bar);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertEquals("", foo()[0]);
+  assertEquals(1, foo().bar);
+})();
+
+// Test Array subclass constructor with known object.
+(function() {
+  const A = class A extends Array {
+    constructor(n) {
+      super(n);
+      this.bar = 1;
+    }
+  };
+  const O = {foo: "foo"};
+
+  function foo() { return new A(O); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertSame(O, foo()[0]);
+  assertEquals(1, foo().bar);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertSame(O, foo()[0]);
+  assertEquals(1, foo().bar);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(1, foo().length);
+  assertSame(O, foo()[0]);
+  assertEquals(1, foo().bar);
+})();
+
+// Test Array subclass constructor with known small integers.
+(function() {
+  const A = class A extends Array {
+    constructor(x, y, z) {
+      super(x, y, z);
+      this.bar = 1;
+    }
+  };
+
+  function foo() { return new A(1, 2, 3); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(3, foo().length);
+  assertEquals(1, foo()[0]);
+  assertEquals(2, foo()[1]);
+  assertEquals(3, foo()[2]);
+  assertEquals(1, foo().bar);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(3, foo().length);
+  assertEquals(1, foo()[0]);
+  assertEquals(2, foo()[1]);
+  assertEquals(3, foo()[2]);
+  assertEquals(1, foo().bar);
+})();
+
+// Test Array subclass constructor with known numbers.
+(function() {
+  const A = class A extends Array {
+    constructor(x, y, z) {
+      super(x, y, z);
+      this.bar = 1;
+    }
+  };
+
+  function foo() { return new A(1.1, 2.2, 3.3); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(3, foo().length);
+  assertEquals(1.1, foo()[0]);
+  assertEquals(2.2, foo()[1]);
+  assertEquals(3.3, foo()[2]);
+  assertEquals(1, foo().bar);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(3, foo().length);
+  assertEquals(1.1, foo()[0]);
+  assertEquals(2.2, foo()[1]);
+  assertEquals(3.3, foo()[2]);
+  assertEquals(1, foo().bar);
+})();
+
+// Test Array subclass constructor with known strings.
+(function() {
+  const A = class A extends Array {
+    constructor(a, b, c, d) {
+      super(a, b, c, d);
+      this.bar = 1;
+    }
+  };
+
+  function foo() { return new A("a", "b", "c", "d"); }
+
+  assertInstanceof(foo(), A);
+  assertEquals(4, foo().length);
+  assertEquals("a", foo()[0]);
+  assertEquals("b", foo()[1]);
+  assertEquals("c", foo()[2]);
+  assertEquals("d", foo()[3]);
+  assertEquals(1, foo().bar);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertEquals(4, foo().length);
+  assertEquals("a", foo()[0]);
+  assertEquals("b", foo()[1]);
+  assertEquals("c", foo()[2]);
+  assertEquals("d", foo()[3]);
+  assertEquals(1, foo().bar);
+})();
diff --git a/deps/v8/test/mjsunit/compiler/constant-fold-cow-array.js b/deps/v8/test/mjsunit/compiler/constant-fold-cow-array.js
new file mode 100644
index 0000000000..1ab022611c
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/constant-fold-cow-array.js
@@ -0,0 +1,35 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --no-always-opt --opt
+
+// Check that we properly deoptimize TurboFan'ed code when we constant-fold
+// elements from a COW array and we change the length of the array.
+(function() {
+  const a = [1, 2, 3];
+  const foo = () => a[0];
+  assertEquals(1, foo());
+  assertEquals(1, foo());
+  %OptimizeFunctionOnNextCall(foo);
+  assertEquals(1, foo());
+  assertOptimized(foo);
+  a.length = 1;
+  assertEquals(1, foo());
+  assertUnoptimized(foo);
+})();
+
+// Check that we properly deoptimize TurboFan'ed code when we constant-fold
+// elements from a COW array and we change the element of the array.
+(function() {
+  const a = [1, 2, 3];
+  const foo = () => a[0];
+  assertEquals(1, foo());
+  assertEquals(1, foo());
+  %OptimizeFunctionOnNextCall(foo);
+  assertEquals(1, foo());
+  assertOptimized(foo);
+  a[0] = 42;
+  assertEquals(42, foo());
+  assertUnoptimized(foo);
+})();
diff --git a/deps/v8/test/mjsunit/compiler/constant-fold-tostring.js b/deps/v8/test/mjsunit/compiler/constant-fold-tostring.js
new file mode 100644
index 0000000000..e9c6d916ce
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/constant-fold-tostring.js
@@ -0,0 +1,26 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --no-always-opt --opt
+
+// Check that constant-folding of ToString operations works properly for NaN.
+(function() {
+  const foo = () => `${NaN}`;
+  assertEquals("NaN", foo());
+  assertEquals("NaN", foo());
+  %OptimizeFunctionOnNextCall(foo);
+  assertEquals("NaN", foo());
+})();
+
+// Check that constant-folding of ToString operations works properly for 0/-0.
+(function() {
+  const foo = x => `${x ? 0 : -0}`;
+  assertEquals("0", foo(true));
+  assertEquals("0", foo(false));
+  assertEquals("0", foo(true));
+  assertEquals("0", foo(false));
+  %OptimizeFunctionOnNextCall(foo);
+  assertEquals("0", foo(true));
+  assertEquals("0", foo(false));
+})();
diff --git a/deps/v8/test/mjsunit/compiler/constructor-inlining.js b/deps/v8/test/mjsunit/compiler/constructor-inlining.js
index d43545ada0..4ad426ff61 100644
--- a/deps/v8/test/mjsunit/compiler/constructor-inlining.js
+++ b/deps/v8/test/mjsunit/compiler/constructor-inlining.js
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --allow-natives-syntax --harmony-restrict-constructor-return
+// Flags: --harmony-restrict-constructor-return --allow-natives-syntax --stress-inline
 
 if (this.FLAG_harmony_restrict_constructor_return === undefined)
   this.FLAG_harmony_restrict_constructor_return = true;
@@ -54,9 +54,6 @@ function Constr(use, x){
   }
 }
 
-%SetForceInlineFlag(Base);
-%SetForceInlineFlag(Derived);
-%SetForceInlineFlag(Constr);
 
 var a = {};
 var b = {};
diff --git a/deps/v8/test/mjsunit/compiler/dead-string-char-code-at.js b/deps/v8/test/mjsunit/compiler/dead-string-char-code-at.js
deleted file mode 100644
index 9f01541c90..0000000000
--- a/deps/v8/test/mjsunit/compiler/dead-string-char-code-at.js
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2013 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Flags: --allow-natives-syntax
-
-var S1 = "string1";
-var S2 = "@@string2";
-
-function dead1(a, b) {
-    var x = %_StringCharCodeAt(a, 4);
-    return a; // x is dead code
-}
-
-function dead2(a, b) {
-    var x = %_StringCharCodeAt(a, 3);
-    var y = %_StringCharCodeAt(b, 1);
-    return a; // x and y are both dead
-}
-
-function dead3(a, b) {
-    a = a ? "11" : "12";
-    b = b ? "13" : "14";
-    var x = %_StringCharCodeAt(a, 2);
-    var y = %_StringCharCodeAt(b, 0);
-    return a; // x and y are both dead
-}
-
-function test() {
-  var S3 = S1 + S2;
-
-  assertEquals(S1, dead1(S1, S2));
-  assertEquals(S1, dead2(S1, S2));
-  assertEquals("11", dead3(S1, S2));
-
-  assertEquals(S2, dead1(S2, 677));
-  assertEquals(S2, dead2(S2, S3));
-  assertEquals("11", dead3(S2, S3));
-
-  assertEquals(S3, dead1(S3, 399));
-  assertEquals(S3, dead2(S3, "false"));
-  assertEquals("12", dead3(0, 32));
-
-  assertEquals(S3, dead1(S3, 0));
-  assertEquals(S3, dead2(S3, S1));
-  assertEquals("11", dead3(S3, 0));
-
-  assertEquals("true", dead1("true", 0));
-  assertEquals("true", dead2("true", S3));
-  assertEquals("11", dead3("true", 0));
-}
-
-test();
-test();
-%OptimizeFunctionOnNextCall(dead1);
-%OptimizeFunctionOnNextCall(dead2);
-%OptimizeFunctionOnNextCall(dead3);
-test();
diff --git a/deps/v8/test/mjsunit/compiler/dead-string-char-code-at2.js b/deps/v8/test/mjsunit/compiler/dead-string-char-code-at2.js
deleted file mode 100644
index 9f01541c90..0000000000
--- a/deps/v8/test/mjsunit/compiler/dead-string-char-code-at2.js
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2013 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Flags: --allow-natives-syntax
-
-var S1 = "string1";
-var S2 = "@@string2";
-
-function dead1(a, b) {
-    var x = %_StringCharCodeAt(a, 4);
-    return a; // x is dead code
-}
-
-function dead2(a, b) {
-    var x = %_StringCharCodeAt(a, 3);
-    var y = %_StringCharCodeAt(b, 1);
-    return a; // x and y are both dead
-}
-
-function dead3(a, b) {
-    a = a ? "11" : "12";
-    b = b ? "13" : "14";
-    var x = %_StringCharCodeAt(a, 2);
-    var y = %_StringCharCodeAt(b, 0);
-    return a; // x and y are both dead
-}
-
-function test() {
-  var S3 = S1 + S2;
-
-  assertEquals(S1, dead1(S1, S2));
-  assertEquals(S1, dead2(S1, S2));
-  assertEquals("11", dead3(S1, S2));
-
-  assertEquals(S2, dead1(S2, 677));
-  assertEquals(S2, dead2(S2, S3));
-  assertEquals("11", dead3(S2, S3));
-
-  assertEquals(S3, dead1(S3, 399));
-  assertEquals(S3, dead2(S3, "false"));
-  assertEquals("12", dead3(0, 32));
-
-  assertEquals(S3, dead1(S3, 0));
-  assertEquals(S3, dead2(S3, S1));
-  assertEquals("11", dead3(S3, 0));
-
-  assertEquals("true", dead1("true", 0));
-  assertEquals("true", dead2("true", S3));
-  assertEquals("11", dead3("true", 0));
-}
-
-test();
-test();
-%OptimizeFunctionOnNextCall(dead1);
-%OptimizeFunctionOnNextCall(dead2);
-%OptimizeFunctionOnNextCall(dead3);
-test();
diff --git a/deps/v8/test/mjsunit/compiler/deopt-closure.js b/deps/v8/test/mjsunit/compiler/deopt-closure.js
new file mode 100644
index 0000000000..2ce531faf0
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/deopt-closure.js
@@ -0,0 +1,47 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function TestMaterializeTargetOfInterpretedFrame() {
+  function f(x) {
+    function g() {
+      %_DeoptimizeNow();
+      return x + 1;
+    }
+    return g();
+  }
+  assertEquals(24, f(23));
+  assertEquals(43, f(42));
+  %OptimizeFunctionOnNextCall(f);
+  assertEquals(66, f(65));
+})();
+
+(function TestMaterializeTargetOfArgumentsAdaptorFrame() {
+  function f(x) {
+    function g(a, b, c) {
+      %_DeoptimizeNow();
+      return x + 1;
+    }
+    return g();
+  }
+  assertEquals(24, f(23));
+  assertEquals(43, f(42));
+  %OptimizeFunctionOnNextCall(f);
+  assertEquals(66, f(65));
+})();
+
+(function TestMaterializeTargetOfConstructStubFrame() {
+  function f(x) {
+    function g() {
+      %_DeoptimizeNow();
+      this.val = x + 1;
+    }
+    return new g();
+  }
+  assertEquals({ val: 24 }, f(23));
+  assertEquals({ val: 43 }, f(42));
+  %OptimizeFunctionOnNextCall(f);
+  assertEquals({ val: 66 }, f(65));
+})();
diff --git a/deps/v8/test/mjsunit/compiler/deopt-simple-try-catch.js b/deps/v8/test/mjsunit/compiler/deopt-simple-try-catch.js
new file mode 100644
index 0000000000..b0e382e38c
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/deopt-simple-try-catch.js
@@ -0,0 +1,28 @@
+
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file
+
+// Flags: --allow-natives-syntax
+
+// Small program to test deoptimization with exception handling.
+
+function g() {
+  %DeoptimizeFunction(f);
+  throw 42;
+}
+%NeverOptimizeFunction(g);
+
+function f() {
+  var a = 1;
+  try {
+    g();
+  } catch (e) {
+    return e + a;
+  }
+}
+
+assertEquals(f(), 43);
+assertEquals(f(), 43);
+%OptimizeFunctionOnNextCall(f);
+assertEquals(f(), 43);
diff --git a/deps/v8/test/mjsunit/compiler/for-in-1.js b/deps/v8/test/mjsunit/compiler/for-in-1.js
new file mode 100644
index 0000000000..80add89609
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/for-in-1.js
@@ -0,0 +1,20 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --opt
+
+// Ensure that we properly check for elements on the receiver.
+function foo(o) {
+  var s = "";
+  for (var i in o) s += i;
+  return s;
+}
+
+var a = [];
+assertEquals("", foo(a));
+assertEquals("", foo(a));
+%OptimizeFunctionOnNextCall(foo);
+assertEquals("", foo(a));
+a[0] = 1;
+assertEquals("0", foo(a));
diff --git a/deps/v8/test/mjsunit/compiler/for-in-2.js b/deps/v8/test/mjsunit/compiler/for-in-2.js
new file mode 100644
index 0000000000..a586aff94e
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/for-in-2.js
@@ -0,0 +1,20 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --opt
+
+// Ensure that we properly check for elements on the prototypes.
+function foo(o) {
+  var s = "";
+  for (var i in o) s += i;
+  return s;
+}
+
+var a = [];
+assertEquals("", foo(a));
+assertEquals("", foo(a));
+%OptimizeFunctionOnNextCall(foo);
+assertEquals("", foo(a));
+Array.prototype[0] = 1;
+assertEquals("0", foo(a));
diff --git a/deps/v8/test/mjsunit/compiler/for-in-3.js b/deps/v8/test/mjsunit/compiler/for-in-3.js
new file mode 100644
index 0000000000..80f3fa50c9
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/for-in-3.js
@@ -0,0 +1,20 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --opt
+
+// Ensure that we properly check for elements on the prototypes.
+function foo(o) {
+  var s = "";
+  for (var i in o) s += i;
+  return s;
+}
+
+var o = {};
+assertEquals("", foo(o));
+assertEquals("", foo(o));
+%OptimizeFunctionOnNextCall(foo);
+assertEquals("", foo(o));
+Object.prototype[0] = 1;
+assertEquals("0", foo(o));
diff --git a/deps/v8/test/mjsunit/compiler/for-in-4.js b/deps/v8/test/mjsunit/compiler/for-in-4.js
new file mode 100644
index 0000000000..d15c3484dd
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/for-in-4.js
@@ -0,0 +1,20 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --opt
+
+// Ensure that we properly check for properties on the prototypes.
+function foo(o) {
+  var s = "";
+  for (var i in o) s += i;
+  return s;
+}
+
+var a = [];
+assertEquals("", foo(a));
+assertEquals("", foo(a));
+%OptimizeFunctionOnNextCall(foo);
+assertEquals("", foo(a));
+Array.prototype.x = 4;
+assertEquals("x", foo(a));
diff --git a/deps/v8/test/mjsunit/compiler/for-in-5.js b/deps/v8/test/mjsunit/compiler/for-in-5.js
new file mode 100644
index 0000000000..8f469ab1b3
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/for-in-5.js
@@ -0,0 +1,19 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --opt
+
+// Ensure that we properly check for properties on the prototypes.
+function foo(o) {
+  var s = "";
+  for (var i in o) s += i;
+  return s;
+}
+var o = {a:1, b:2, c:3};
+assertEquals("abc", foo(o));
+assertEquals("abc", foo(o));
+%OptimizeFunctionOnNextCall(foo);
+assertEquals("abc", foo(o));
+Object.prototype.d = 4;
+assertEquals("abcd", foo(o));
diff --git a/deps/v8/test/mjsunit/compiler/function-caller.js b/deps/v8/test/mjsunit/compiler/function-caller.js
new file mode 100644
index 0000000000..1192e680cb
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/function-caller.js
@@ -0,0 +1,25 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function TestInlineAllocatedCaller() {
+  function g() {
+    var caller = g.caller;
+    caller.foo = 23;
+    assertEquals(23, caller.foo);
+    assertEquals(23, g.caller.foo);
+    assertSame(caller, g.caller);
+  }
+  %NeverOptimizeFunction(g);
+
+  function f() {
+    (function caller() { g() })();
+  }
+
+  f();
+  f();
+  %OptimizeFunctionOnNextCall(f);
+  f();
+})();
diff --git a/deps/v8/test/mjsunit/compiler/object-constructor.js b/deps/v8/test/mjsunit/compiler/object-constructor.js
new file mode 100644
index 0000000000..162416fd57
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/object-constructor.js
@@ -0,0 +1,51 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+// Common pattern in Webpack 3 generated bundles, see
+// https://github.com/webpack/webpack/issues/5600 for details.
+(function ObjectConstructorWithKnownFunction() {
+  "use strict";
+  class A {
+    bar() { return this; }
+  };
+  function foo(a) {
+    return Object(a.bar)();
+  }
+  assertEquals(undefined, foo(new A));
+  assertEquals(undefined, foo(new A));
+  %OptimizeFunctionOnNextCall(foo);
+  assertEquals(undefined, foo(new A));
+})();
+
+(function ObjectConstructorWithString() {
+  "use strict";
+  function foo() {
+    return Object("a");
+  }
+  assertEquals('object', typeof foo());
+  assertEquals('object', typeof foo());
+  %OptimizeFunctionOnNextCall(foo);
+  assertEquals('object', typeof foo());
+})();
+
+// Object constructor subclassing via Class Factories, see
+// https://twitter.com/FremyCompany/status/905977048006402048
+// for the hint.
+(function ObjectConstructorSubClassing() {
+  "use strict";
+  const Factory = Base => class A extends Base {};
+  const A = Factory(Object);
+  function foo() {
+    return new A(1, 2, 3);
+  }
+  assertInstanceof(foo(), A);
+  assertInstanceof(foo(), Object);
+  assertInstanceof(foo(), A);
+  assertInstanceof(foo(), Object);
+  %OptimizeFunctionOnNextCall(foo);
+  assertInstanceof(foo(), A);
+  assertInstanceof(foo(), Object);
+})();
diff --git a/deps/v8/test/mjsunit/compiler/object-is.js b/deps/v8/test/mjsunit/compiler/object-is.js
new file mode 100644
index 0000000000..9537d78e3b
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/object-is.js
@@ -0,0 +1,143 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function() {
+  function foo(o) { return Object.is(o, -0); }
+  assertTrue(foo(-0));
+  assertFalse(foo(0));
+  assertFalse(foo(NaN));
+  assertFalse(foo(''));
+  assertFalse(foo([]));
+  assertFalse(foo({}));
+  %OptimizeFunctionOnNextCall(foo);
+  assertTrue(foo(-0));
+  assertFalse(foo(0));
+  assertFalse(foo(NaN));
+  assertFalse(foo(''));
+  assertFalse(foo([]));
+  assertFalse(foo({}));
+})();
+
+(function() {
+  function foo(o) { return Object.is(-0, o); }
+  assertTrue(foo(-0));
+  assertFalse(foo(0));
+  assertFalse(foo(NaN));
+  assertFalse(foo(''));
+  assertFalse(foo([]));
+  assertFalse(foo({}));
+  %OptimizeFunctionOnNextCall(foo);
+  assertTrue(foo(-0));
+  assertFalse(foo(0));
+  assertFalse(foo(NaN));
+  assertFalse(foo(''));
+  assertFalse(foo([]));
+  assertFalse(foo({}));
+})();
+
+(function() {
+  function foo(o) { return Object.is(+o, -0); }
+  assertTrue(foo(-0));
+  assertFalse(foo(0));
+  assertFalse(foo(NaN));
+  %OptimizeFunctionOnNextCall(foo);
+  assertTrue(foo(-0));
+  assertFalse(foo(0));
+  assertFalse(foo(NaN));
+})();
+
+(function() {
+  function foo(o) { return Object.is(-0, +o); }
+  assertTrue(foo(-0));
+  assertFalse(foo(0));
+  assertFalse(foo(NaN));
+  %OptimizeFunctionOnNextCall(foo);
+  assertTrue(foo(-0));
+  assertFalse(foo(0));
+  assertFalse(foo(NaN));
+})();
+
+(function() {
+  function foo(o) { return Object.is(o, NaN); }
+  assertFalse(foo(-0));
+  assertFalse(foo(0));
+  assertTrue(foo(NaN));
+  assertFalse(foo(''));
+  assertFalse(foo([]));
+  assertFalse(foo({}));
+  %OptimizeFunctionOnNextCall(foo);
+  assertFalse(foo(-0));
+  assertFalse(foo(0));
+  assertTrue(foo(NaN));
+  assertFalse(foo(''));
+  assertFalse(foo([]));
+  assertFalse(foo({}));
+})();
+
+(function() {
+  function foo(o) { return Object.is(NaN, o); }
+  assertFalse(foo(-0));
+  assertFalse(foo(0));
+  assertTrue(foo(NaN));
+  assertFalse(foo(''));
+  assertFalse(foo([]));
+  assertFalse(foo({}));
+  %OptimizeFunctionOnNextCall(foo);
+  assertFalse(foo(-0));
+  assertFalse(foo(0));
+  assertTrue(foo(NaN));
+  assertFalse(foo(''));
+  assertFalse(foo([]));
+  assertFalse(foo({}));
+})();
+
+(function() {
+  function foo(o) { return Object.is(+o, NaN); }
+  assertFalse(foo(-0));
+  assertFalse(foo(0));
+  assertTrue(foo(NaN));
+  %OptimizeFunctionOnNextCall(foo);
+  assertFalse(foo(-0));
+  assertFalse(foo(0));
+  assertTrue(foo(NaN));
+})();
+
+(function() {
+  function foo(o) { return Object.is(NaN, +o); }
+  assertFalse(foo(-0));
+  assertFalse(foo(0));
+  assertTrue(foo(NaN));
+  %OptimizeFunctionOnNextCall(foo);
+  assertFalse(foo(-0));
+  assertFalse(foo(0));
+  assertTrue(foo(NaN));
+})();
+
+(function() {
+  function foo(o) { return Object.is(`${o}`, "foo"); }
+  assertFalse(foo("bar"));
+  assertTrue(foo("foo"));
+  %OptimizeFunctionOnNextCall(foo);
+  assertFalse(foo("bar"));
+  assertTrue(foo("foo"));
+})();
+
+(function() {
+  function foo(o) { return Object.is(o, o); }
+  assertTrue(foo(-0));
+  assertTrue(foo(0));
+  assertTrue(foo(NaN));
+  assertTrue(foo(''));
+  assertTrue(foo([]));
+  assertTrue(foo({}));
+  %OptimizeFunctionOnNextCall(foo);
+  assertTrue(foo(-0));
+  assertTrue(foo(0));
+  assertTrue(foo(NaN));
+  assertTrue(foo(''));
+  assertTrue(foo([]));
+  assertTrue(foo({}));
+})();
diff --git a/deps/v8/test/mjsunit/compiler/polymorphic-symbols.js b/deps/v8/test/mjsunit/compiler/polymorphic-symbols.js
new file mode 100644
index 0000000000..e954d50fa8
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/polymorphic-symbols.js
@@ -0,0 +1,48 @@
+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function() {
+  const symbol = Symbol('symbol');
+  const OBJS = [
+    {[symbol]: 0, a: 1},
+    {[symbol]: 1, b: 2},
+    {[symbol]: 2, c: 3},
+    {[symbol]: 3, d: 4}
+  ];
+  function foo(o) { return o[symbol]; }
+  for (let i = 0; i < OBJS.length; ++i) {
+    assertEquals(i, foo(OBJS[i]));
+    assertEquals(i, foo(OBJS[i]));
+  }
+  %OptimizeFunctionOnNextCall(foo);
+  for (let i = 0; i < OBJS.length; ++i) {
+    assertEquals(i, foo(OBJS[i]));
+    assertEquals(i, foo(OBJS[i]));
+  }
+})();
+
+(function() {
+  const symbol = Symbol('symbol');
+  const OBJS = [
+    {[symbol]: 0, a: 1},
+    {[symbol]: 1, b: 2},
+    {[symbol]: 2, c: 3},
+    {[symbol]: 3, d: 4}
+  ];
+  function foo(o) { o[symbol] = o; }
+  for (let i = 0; i < OBJS.length; ++i) {
+    foo(OBJS[i]);
+    foo(OBJS[i]);
+  }
+  %OptimizeFunctionOnNextCall(foo);
+  for (let i = 0; i < OBJS.length; ++i) {
+    foo(OBJS[i]);
+    foo(OBJS[i]);
+  }
+  for (const o of OBJS) {
+    assertEquals(o, o[symbol]);
+  }
+})();
diff --git a/deps/v8/test/mjsunit/compiler/regress-700883.js b/deps/v8/test/mjsunit/compiler/regress-700883.js
index 0b148b5e08..41440f3a3f 100644
--- a/deps/v8/test/mjsunit/compiler/regress-700883.js
+++ b/deps/v8/test/mjsunit/compiler/regress-700883.js
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --allow-natives-syntax
+// Flags: --allow-natives-syntax --stress-inline
 
 function add(x) {
  return x + x;
@@ -10,7 +10,6 @@ function add(x) {
 
 add(0);
 add(1);
-%SetForceInlineFlag(add);
 
 var min = Math.min;
 function foo(x) {
@@ -19,5 +18,6 @@ function foo(x) {
  return min(y, x);
 }
 
+foo();
 %OptimizeFunctionOnNextCall(foo);
 foo();
diff --git a/deps/v8/test/mjsunit/compiler/regress-758096.js b/deps/v8/test/mjsunit/compiler/regress-758096.js
new file mode 100644
index 0000000000..1ed32c0263
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/regress-758096.js
@@ -0,0 +1,54 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function() {
+  var x = 1;
+  x.__proto__.f = function() { return 1; }
+
+  function g() {}
+  g.prototype.f =  function() { return 3; };
+  var y = new g();
+
+  function f(obj) {
+    return obj.f();
+  }
+
+  f(x);
+  f(y);
+  f(x);
+  f(y);
+  %OptimizeFunctionOnNextCall(f);
+  assertEquals(1, f(x));
+  assertEquals(3, f(y));
+})();
+
+(function() {
+  function f() { return 1; }
+  function g() { return 2; }
+
+  var global;
+
+  function h(s) {
+    var fg;
+    var a = 0;
+    if (s) {
+      global = 0;
+      a = 1;
+      fg = f;
+    } else {
+      global = 1
+      fg = g;
+    }
+    return fg() + a;
+  }
+
+  h(0);
+  h(0);
+  h(1);
+  h(1);
+  %OptimizeFunctionOnNextCall(h);
+  assertEquals(2, h(0));
+})();
diff --git a/deps/v8/test/mjsunit/compiler/regress-761892.js b/deps/v8/test/mjsunit/compiler/regress-761892.js
new file mode 100644
index 0000000000..5423c59c04
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/regress-761892.js
@@ -0,0 +1,15 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+function f(x) {
+  var x0 = (0 != Math.min(1, 1)) && 1;
+  1.1!=(x||x0)
+}
+
+f(1.1);
+f(1.1);
+%OptimizeFunctionOnNextCall(f);
+f(1);
diff --git a/deps/v8/test/mjsunit/compiler/regress-762057.js b/deps/v8/test/mjsunit/compiler/regress-762057.js
new file mode 100644
index 0000000000..4b5cab6ef5
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/regress-762057.js
@@ -0,0 +1,20 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+function* foo() {
+  yield;
+  new Set();
+  for (let x of []) {
+    for (let y of []) {
+      yield;
+    }
+  }
+}
+
+let gaga = foo();
+gaga.next();
+%OptimizeFunctionOnNextCall(foo);
+gaga.next();
diff --git a/deps/v8/test/mjsunit/compiler/regress-780658.js b/deps/v8/test/mjsunit/compiler/regress-780658.js
new file mode 100644
index 0000000000..57fdbbabed
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/regress-780658.js
@@ -0,0 +1,29 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --turbo-escape
+
+function get1(l, b) {
+    return l[1];
+}
+
+function with_double(x) {
+    var o = {a: [x,x,x]};
+    o.a.some_property = 1;
+    return get1(o.a);
+}
+
+function with_tagged(x) {
+    var l = [{}, x,x];
+    return get1(l);
+}
+
+with_double(.5);
+with_tagged({});
+with_double(.6);
+with_tagged(null);
+with_double(.5);
+with_tagged({});
+%OptimizeFunctionOnNextCall(with_double);
+with_double(.7);
diff --git a/deps/v8/test/mjsunit/compiler/stress-deopt-count-1.js b/deps/v8/test/mjsunit/compiler/stress-deopt-count-1.js
new file mode 100644
index 0000000000..834a873e75
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/stress-deopt-count-1.js
@@ -0,0 +1,20 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --deopt-every-n-times=0 --opt --no-always-opt
+
+// Check that --deopt-every-n-times 0 doesn't deopt
+
+function f(x) {
+  return x + 1;
+}
+
+f(0);
+%OptimizeFunctionOnNextCall(f);
+
+f(1);
+assertOptimized(f, undefined, undefined, false);
+
+f(1);
+assertOptimized(f, undefined, undefined, false);
diff --git a/deps/v8/test/mjsunit/compiler/stress-deopt-count-2.js b/deps/v8/test/mjsunit/compiler/stress-deopt-count-2.js
new file mode 100644
index 0000000000..641a9e8180
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/stress-deopt-count-2.js
@@ -0,0 +1,48 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --opt --no-always-opt --deopt-every-n-times=6
+
+// Check that stress deopt count resets correctly
+
+// Function with two deopt points
+function f(x) {
+  return x + 1;
+}
+
+f(1);
+%OptimizeFunctionOnNextCall(f);
+
+// stress_deopt_count == 6
+
+f(1);
+assertOptimized(f, undefined, undefined, false);
+
+// stress_deopt_count == 4
+
+f(1);
+assertOptimized(f, undefined, undefined, false);
+
+// stress_deopt_count == 2
+
+f(1);
+// deopt & counter reset
+assertUnoptimized(f, undefined, undefined, false);
+
+// stress_deopt_count == 6
+
+%OptimizeFunctionOnNextCall(f);
+f(1);
+assertOptimized(f, undefined, undefined, false);
+
+// stress_deopt_count == 4
+
+f(1);
+assertOptimized(f, undefined, undefined, false);
+
+// stress_deopt_count == 2
+
+f(1);
+// deopt & counter reset
+assertUnoptimized(f, undefined, undefined, false);
diff --git a/deps/v8/test/mjsunit/compiler/typedarray-prototype-tostringtag.js b/deps/v8/test/mjsunit/compiler/typedarray-prototype-tostringtag.js
new file mode 100644
index 0000000000..de4b302017
--- /dev/null
+++ b/deps/v8/test/mjsunit/compiler/typedarray-prototype-tostringtag.js
@@ -0,0 +1,84 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+const Classes = [
+  Uint8Array,
+  Int8Array,
+  Uint16Array,
+  Int16Array,
+  Uint32Array,
+  Int32Array,
+  Uint8ClampedArray,
+  Float32Array,
+  Float64Array
+];
+const TypedArrayPrototype_toStringTag =
+    Object.getOwnPropertyDescriptor(
+        Object.getPrototypeOf(Uint8Array.prototype),
+        Symbol.toStringTag).get;
+
+(function() {
+  function foo(o) {
+    return TypedArrayPrototype_toStringTag.call(o);
+  }
+  assertEquals(undefined, foo(1));
+  assertEquals(undefined, foo({}));
+  assertEquals(undefined, foo([]));
+  Classes.forEach(C => assertEquals(C.name, foo(new C(1))));
+  %OptimizeFunctionOnNextCall(foo);
+  assertEquals(undefined, foo(1));
+  assertEquals(undefined, foo({}));
+  assertEquals(undefined, foo([]));
+  Classes.forEach(C => assertEquals(C.name, foo(new C(1))));
+})();
+
+(function() {
+  const ReflectApply = Reflect.apply;
+  const uncurryThis = func => (thisArg, ...args) =>
+      ReflectApply(func, thisArg, args);
+  const TypedArrayProto_toStringTag =
+      uncurryThis(TypedArrayPrototype_toStringTag);
+
+  function isTypedArray(value) {
+    return TypedArrayProto_toStringTag(value) !== undefined;
+  }
+
+  assertFalse(isTypedArray(1));
+  assertFalse(isTypedArray({}));
+  assertFalse(isTypedArray([]));
+  assertFalse(isTypedArray('Lorem ipsum'));
+  Classes.forEach(C => assertTrue(isTypedArray(new C(1))));
+  %OptimizeFunctionOnNextCall(isTypedArray);
+  assertFalse(isTypedArray(1));
+  assertFalse(isTypedArray({}));
+  assertFalse(isTypedArray([]));
+  assertFalse(isTypedArray('Lorem ipsum'));
+  Classes.forEach(C => assertTrue(isTypedArray(new C(1))));
+})();
+
+(function() {
+  const ReflectApply = Reflect.apply;
+  const uncurryThis = func => (thisArg, ...args) =>
+      ReflectApply(func, thisArg, args);
+  const TypedArrayProto_toStringTag =
+      uncurryThis(TypedArrayPrototype_toStringTag);
+
+  function isUint8Array(value) {
+    return TypedArrayProto_toStringTag(value) === 'Uint8Array';
+  }
+
+  assertFalse(isUint8Array(1));
+  assertFalse(isUint8Array({}));
+  assertFalse(isUint8Array([]));
+  assertFalse(isUint8Array('Lorem ipsum'));
+  Classes.forEach(C => assertEquals(C === Uint8Array, isUint8Array(new C(1))));
+  %OptimizeFunctionOnNextCall(isUint8Array);
+  assertFalse(isUint8Array(1));
+  assertFalse(isUint8Array({}));
+  assertFalse(isUint8Array([]));
+  assertFalse(isUint8Array('Lorem ipsum'));
+  Classes.forEach(C => assertEquals(C === Uint8Array, isUint8Array(new C(1))));
+})();
diff --git a/deps/v8/test/mjsunit/es6/new-target.js b/deps/v8/test/mjsunit/es6/new-target.js
index 14446fc40f..c77c153cc0 100644
--- a/deps/v8/test/mjsunit/es6/new-target.js
+++ b/deps/v8/test/mjsunit/es6/new-target.js
@@ -472,3 +472,12 @@ function get_new_target() { return new.target; }
   tagNewTargetProp.Prop = C;
   assertEquals(new tagNewTargetProp, ["tagNewTargetProp"]);
 })();
+
+(function testDeleteSloppy() {
+  assertTrue(delete new.target);
+})();
+
+(function testDeleteStrict() {
+  "use strict";
+  assertTrue(delete new.target);
+})();
diff --git a/deps/v8/test/mjsunit/es6/proxies-get.js b/deps/v8/test/mjsunit/es6/proxies-get.js
index 4f7b2d0be4..f52ae1aa7e 100644
--- a/deps/v8/test/mjsunit/es6/proxies-get.js
+++ b/deps/v8/test/mjsunit/es6/proxies-get.js
@@ -193,7 +193,6 @@
     'Error from proxy getOwnPropertyDescriptor trap');
 })();
 
-
 (function testGetPropertyDetailsBailout2() {
   var obj = {};
   Object.defineProperty(obj, 'prop', {
@@ -211,3 +210,13 @@
     " property on the proxy target but the proxy did not return its actual" +
     " value (expected '53' but got '42')");
 })();
+
+(function test32BitIndex() {
+  var index = (1 << 31) + 1;
+  var obj = {};
+  obj[index] = 42;
+  var p = new Proxy(obj, {});
+  for (var i = 0; i < 3; ++i) {
+    assertEquals(42, p[index]);
+  }
+})();
diff --git a/deps/v8/test/mjsunit/es6/proxies-set.js b/deps/v8/test/mjsunit/es6/proxies-set.js
index 19f39f9a65..d56cec52f9 100644
--- a/deps/v8/test/mjsunit/es6/proxies-set.js
+++ b/deps/v8/test/mjsunit/es6/proxies-set.js
@@ -308,3 +308,101 @@ TestTrapReceiverArgument(strictReflectSet);
     }
   }
 })();
+
+
+function TestTargetProxy(mySet) {
+  var q = new Proxy({}, {});
+  var proxy = new Proxy(q, {
+    set: function(t, k, v) {
+      return Reflect.set(t, k, v);
+    }
+  });
+
+  for (var p of properties) {
+    assertTrueIf(mySet.returnsBool, mySet(proxy, p, 42));
+    assertSame(42, q[p]);
+  }
+};
+
+TestTargetProxy(sloppyDefaultSet);
+TestTargetProxy(sloppyReflectSet);
+TestTargetProxy(strictDefaultSet);
+TestTargetProxy(strictReflectSet);
+
+
+(function TestAccessorNoSet() {
+  var target = {
+  };
+  Object.defineProperty(target, 'prop', {
+    get: function() {
+      return 42;
+    },
+    configurable: false
+  })
+  var handler = {
+    set: function() { return true; }
+  }
+  var proxy = new Proxy(target, handler);
+  assertThrows(function() { proxy.prop = 0; }, TypeError);
+})();
+
+(function TestProxyInPrototype() {
+  var handler = {
+    set: function(t, k, v) {
+      Reflect.set(t, k, v);
+    }
+  };
+  var obj = {};
+  var proxy = new Proxy(obj, handler);
+  var o = Object.create(proxy);
+
+  for (var i = 0; i < 3; ++i) {
+    o.prop = 42 + i;
+    assertEquals(42 + i, obj.prop);
+  }
+})();
+
+(function TestProxyInPrototypeNoTrap() {
+  var handler = {
+  };
+  var obj = {};
+  var proxy = new Proxy(obj, handler);
+  var o = Object.create(proxy);
+
+  for (var i = 0; i < 3; ++i) {
+    o.prop = 42 + i;
+    assertEquals(42 + i, o.prop);
+    assertEquals(undefined, obj.prop);
+  }
+})();
+
+// Note: this case is currently handled by runtime.
+(function TestDifferentHolder() {
+  var obj = {
+    '1337': 100
+  };
+  var handler = {
+    set(target, name, value, receiver) {
+      if (name != '1337') return Reflect.set(target, name, value, receiver);
+
+      assertSame(target, obj);
+      assertSame(receiver, p);
+      return target[name] = value;
+    }
+  };
+  var p = new Proxy(obj, handler);
+  for (var i = 0; i < 3; ++i) {
+    assertEquals(42, p[1337] = 42);
+  }
+})();
+
+(function test32BitIndex() {
+  var index = (1 << 31) + 1;
+  var obj = {};
+  obj[index] = 42;
+  var p = new Proxy(obj, {});
+  for (var i = 0; i < 3; ++i) {
+    p[index] = 100;
+    assertEquals(100, obj[index]);
+  }
+})();
diff --git a/deps/v8/test/mjsunit/es6/proxies.js b/deps/v8/test/mjsunit/es6/proxies.js
index 3b9a4c5119..75a80a15bd 100644
--- a/deps/v8/test/mjsunit/es6/proxies.js
+++ b/deps/v8/test/mjsunit/es6/proxies.js
@@ -50,6 +50,19 @@ function TestWithFunctionProxy(test, x, y, z) {
 }
 
 // ---------------------------------------------------------------------------
+// Test Proxy constructor properties
+
+(function TestProxyProperties() {
+  assertEquals(2, Proxy.length);
+  assertEquals(Function.__proto__, Proxy.__proto__);
+  assertEquals(null, Proxy.prototype);
+  assertEquals(undefined, Object.getOwnPropertyDescriptor(Proxy, "arguments"));
+  assertThrows(() => Proxy.arguments, TypeError);
+  assertEquals(undefined, Object.getOwnPropertyDescriptor(Proxy, "caller"));
+  assertThrows(() => Proxy.caller, TypeError);
+})();
+
+// ---------------------------------------------------------------------------
 // Getting property descriptors (Object.getOwnPropertyDescriptor).
 
 var key
diff --git a/deps/v8/test/mjsunit/es6/regress/regress-777182.js b/deps/v8/test/mjsunit/es6/regress/regress-777182.js
new file mode 100644
index 0000000000..6d6eb55c82
--- /dev/null
+++ b/deps/v8/test/mjsunit/es6/regress/regress-777182.js
@@ -0,0 +1,9 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --enable-slow-asserts
+
+var __v_65159 = [1.3];
+__v_65159.length = 0;
+new Int8Array(10).set(__v_65159);
diff --git a/deps/v8/test/mjsunit/es6/string-html.js b/deps/v8/test/mjsunit/es6/string-html.js
index 690830ba84..1eaa7b1eb1 100644
--- a/deps/v8/test/mjsunit/es6/string-html.js
+++ b/deps/v8/test/mjsunit/es6/string-html.js
@@ -8,7 +8,8 @@
 assertEquals('_'.anchor('b'), '<a name="b">_</a>');
 assertEquals('<'.anchor('<'), '<a name="<"><</a>');
 assertEquals('_'.anchor(0x2A), '<a name="42">_</a>');
-assertEquals('_'.anchor('\x22'), '<a name="&quot;">_</a>');
+assertEquals('_'.anchor('\x22\x22'), '<a name="&quot;&quot;">_</a>');
+assertEquals('_'.anchor(), '<a name="undefined">_</a>');
 assertEquals(String.prototype.anchor.call(0x2A, 0x2A), '<a name="42">42</a>');
 assertThrows(function() {
   String.prototype.anchor.call(undefined);
diff --git a/deps/v8/test/mjsunit/es6/string-repeat.js b/deps/v8/test/mjsunit/es6/string-repeat.js
index d61aec066c..3649c5b09b 100644
--- a/deps/v8/test/mjsunit/es6/string-repeat.js
+++ b/deps/v8/test/mjsunit/es6/string-repeat.js
@@ -60,14 +60,19 @@ assertEquals("", "abc".repeat(0));
 assertEquals("abcabc", "abc".repeat(2.0));
 
 assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "a".repeat(37));
+assertEquals("", "a".repeat(NaN));
 assertThrows('"a".repeat(-1)', RangeError);
 assertThrows('"a".repeat(Number.POSITIVE_INFINITY)', RangeError);
+assertThrows('"a".repeat(Number.NEGATIVE_INFINITY)', RangeError);
 assertThrows('"a".repeat(Math.pow(2, 30))', RangeError);
 assertThrows('"a".repeat(Math.pow(2, 40))', RangeError);
+assertThrows('"a".repeat(-Math.pow(2, 40))', RangeError);
 
 // Handling empty strings
 assertThrows('"".repeat(-1)', RangeError);
 assertThrows('"".repeat(Number.POSITIVE_INFINITY)', RangeError);
+assertThrows('"".repeat(Number.NEGATIVE_INFINITY)', RangeError);
+assertThrows('"a".repeat(-Math.pow(2, 40))', RangeError);
 assertEquals("", "".repeat(Math.pow(2, 30)));
 assertEquals("", "".repeat(Math.pow(2, 40)));
 
diff --git a/deps/v8/test/mjsunit/es6/typedarray-set-bytelength-not-smi.js b/deps/v8/test/mjsunit/es6/typedarray-set-bytelength-not-smi.js
new file mode 100644
index 0000000000..1f842878dc
--- /dev/null
+++ b/deps/v8/test/mjsunit/es6/typedarray-set-bytelength-not-smi.js
@@ -0,0 +1,21 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --mock-arraybuffer-allocator
+
+(function TestBufferByteLengthNonSmi() {
+  const source_buffer_length = %_MaxSmi() + 1;
+  const source_buffer = new ArrayBuffer(source_buffer_length);
+  const source = new Uint16Array(source_buffer);
+  assertEquals(source_buffer_length, source_buffer.byteLength);
+  assertEquals(source_buffer_length / 2, source.length);
+
+  const target_buffer_length = %_MaxSmi() - 1;
+  const target_buffer = new ArrayBuffer(target_buffer_length);
+  const target = new Uint16Array(target_buffer);
+  assertEquals(target_buffer_length, target_buffer.byteLength);
+  assertEquals(target_buffer_length / 2, target.length);
+
+  assertThrows(() => target.set(source), RangeError);
+})();
diff --git a/deps/v8/test/mjsunit/es6/typedarray.js b/deps/v8/test/mjsunit/es6/typedarray.js
index 2f4c1b639d..5f4d3f0747 100644
--- a/deps/v8/test/mjsunit/es6/typedarray.js
+++ b/deps/v8/test/mjsunit/es6/typedarray.js
@@ -25,6 +25,8 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// Flags: --allow-natives-syntax
+
 // ArrayBuffer
 
 function TestByteLength(param, expectedByteLength) {
@@ -609,6 +611,103 @@ function TestTypedArraySet() {
   a101[0] = 42;
   b101.set(a101);
   assertArrayPrefix([42], b101);
+
+  // Detached array buffer when accessing a source element
+  var a111 = new Int8Array(100);
+  var evilarr = new Array(100);
+  var detached = false;
+  evilarr[1] = {
+    [Symbol.toPrimitive]() {
+      %ArrayBufferNeuter(a111.buffer);
+      detached = true;
+      return 1;
+    }
+  };
+  assertThrows(() => a111.set(evilarr), TypeError);
+  assertEquals(true, detached);
+
+  // Detached array buffer when converting offset.
+  {
+    for (const klass of typedArrayConstructors) {
+      const xs = new klass(10);
+      let detached = false;
+      const offset = {
+        [Symbol.toPrimitive]() {
+          %ArrayBufferNeuter(xs.buffer);
+          detached = true;
+          return 0;
+        }
+      };
+      assertThrows(() => xs.set(xs, offset), TypeError);
+      assertEquals(true, detached);
+    }
+  }
+
+  // Detached JSTypedArray source argument.
+  {
+    for (const klass of typedArrayConstructors) {
+      const a = new klass(2);
+      for (let i = 0; i < a.length; i++) a[i] = i;
+      %ArrayBufferNeuter(a.buffer);
+
+      const b = new klass(2);
+      assertThrows(() => b.set(a), TypeError);
+    }
+  }
+
+  // Various offset edge cases.
+  {
+    for (const klass of typedArrayConstructors) {
+      const xs = new klass(10);
+      assertThrows(() => xs.set(xs, -1), RangeError);
+      assertThrows(() => xs.set(xs, -1 * 2**64), RangeError);
+      xs.set(xs, -0.0);
+      xs.set(xs, 0.0);
+      xs.set(xs, 0.5);
+      assertThrows(() => xs.set(xs, 2**64), RangeError);
+    }
+  }
+
+  // Exhaustively test elements kind combinations with JSArray source arg.
+  {
+    const kSize = 3;
+    const targets = typedArrayConstructors.map(klass => new klass(kSize));
+    const sources = [ [0,1,2]        // PACKED_SMI
+                    , [0,,2]         // HOLEY_SMI
+                    , [0.1,0.2,0.3]  // PACKED_DOUBLE
+                    , [0.1,,0.3]     // HOLEY_DOUBLE
+                    , [{},{},{}]     // PACKED
+                    , [{},,{}]       // HOLEY
+                    , []             // DICTIONARY (patched later)
+                    ];
+
+    // Migrate to DICTIONARY_ELEMENTS.
+    Object.defineProperty(sources[6], 0, {});
+
+    assertTrue(%HasSmiElements(sources[0]));
+    assertTrue(%HasFastElements(sources[0]) && !%HasHoleyElements(sources[0]));
+    assertTrue(%HasSmiElements(sources[1]));
+    assertTrue(%HasFastElements(sources[1]) && %HasHoleyElements(sources[1]));
+    assertTrue(%HasDoubleElements(sources[2]));
+    assertTrue(%HasFastElements(sources[2]) && !%HasHoleyElements(sources[2]));
+    assertTrue(%HasDoubleElements(sources[3]));
+    assertTrue(%HasFastElements(sources[3]) && %HasHoleyElements(sources[3]));
+    assertTrue(%HasObjectElements(sources[4]));
+    assertTrue(%HasFastElements(sources[4]) && !%HasHoleyElements(sources[4]));
+    assertTrue(%HasObjectElements(sources[4]));
+    assertTrue(%HasFastElements(sources[4]) && !%HasHoleyElements(sources[4]));
+    assertTrue(%HasObjectElements(sources[5]));
+    assertTrue(%HasFastElements(sources[5]) && %HasHoleyElements(sources[5]));
+    assertTrue(%HasDictionaryElements(sources[6]));
+
+    for (const target of targets) {
+      for (const source of sources) {
+        target.set(source);
+        %HeapObjectVerify(target);
+        %HeapObjectVerify(source);
+      }
+    }
+  }
 }
 
 TestTypedArraySet();
@@ -885,3 +984,12 @@ for(i = 0; i < typedArrayConstructors.length; i++) {
                  e.message);
   }
 })();
+
+// Regression test 761654
+assertThrows(function LargeSourceArray() {
+  let v0 = {};
+  v0.length =  2 ** 32; // too large for uint32
+  let a = new Int8Array();
+
+  a.set(v0);
+});
diff --git a/deps/v8/test/mjsunit/function-bind.js b/deps/v8/test/mjsunit/function-bind.js
index 826986943b..7d37da57d2 100644
--- a/deps/v8/test/mjsunit/function-bind.js
+++ b/deps/v8/test/mjsunit/function-bind.js
@@ -41,21 +41,25 @@ var f = foo.bind(foo);
 assertEquals([foo, 3, 1], f(1, 2, 3));
 assertEquals(3, f.length);
 assertEquals("function () { [native code] }", f.toString());
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1);
 assertEquals([foo, 3, 1], f(2, 3));
 assertEquals(2, f.length);
 assertEquals("function () { [native code] }", f.toString());
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1, 2);
 assertEquals([foo, 3, 1], f(3));
 assertEquals(1, f.length);
 assertEquals("function () { [native code] }", f.toString());
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1, 2, 3);
 assertEquals([foo, 3, 1], f());
 assertEquals(0, f.length);
 assertEquals("function () { [native code] }", f.toString());
+%HeapObjectVerify(f);
 
 // Test that length works correctly even if more than the actual number
 // of arguments are given when binding.
@@ -63,6 +67,7 @@ f = foo.bind(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9);
 assertEquals([foo, 9, 1], f());
 assertEquals(0, f.length);
 assertEquals("function () { [native code] }", f.toString());
+%HeapObjectVerify(f);
 
 // Use a different bound object.
 var obj = {x: 42, y: 43};
@@ -78,11 +83,13 @@ assertEquals(3, f_bound_this(1))
 f = f_bound_this.bind(obj);
 assertEquals(2, f(1));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 f = f_bound_this.bind(obj, 2);
 assertEquals(3, f());
 assertEquals(0, f.length);
 assertEquals('[object Function]', Object.prototype.toString.call(f));
+%HeapObjectVerify(f);
 
 // Test chained binds.
 
@@ -90,65 +97,80 @@ assertEquals('[object Function]', Object.prototype.toString.call(f));
 // the same effect.
 f = foo.bind(foo);
 assertEquals([foo, 3, 1], f(1, 2, 3));
+%HeapObjectVerify(f);
 
 var not_foo = {};
 f = foo.bind(foo).bind(not_foo).bind(not_foo).bind(not_foo);
 assertEquals([foo, 3, 1], f(1, 2, 3));
 assertEquals(3, f.length);
+%HeapObjectVerify(f);
 
 // Giving bound parameters should work at any place in the chain.
 f = foo.bind(foo, 1).bind(not_foo).bind(not_foo).bind(not_foo);
 assertEquals([foo, 3, 1], f(2, 3));
 assertEquals(2, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo).bind(not_foo, 1).bind(not_foo).bind(not_foo);
 assertEquals([foo, 3, 1], f(2, 3));
 assertEquals(2, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo).bind(not_foo).bind(not_foo,1 ).bind(not_foo);
 assertEquals([foo, 3, 1], f(2, 3));
 assertEquals(2, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo).bind(not_foo).bind(not_foo).bind(not_foo, 1);
 assertEquals([foo, 3, 1], f(2, 3));
 assertEquals(2, f.length);
+%HeapObjectVerify(f);
 
 // Several parameters can be given, and given in different bind invocations.
 f = foo.bind(foo, 1, 2).bind(not_foo).bind(not_foo).bind(not_foo);
 assertEquals([foo, 3, 1], f(3));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo).bind(not_foo, 1, 2).bind(not_foo).bind(not_foo);
 assertEquals([foo, 3, 1], f(1));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo).bind(not_foo, 1, 2).bind(not_foo).bind(not_foo);
 assertEquals([foo, 3, 1], f(3));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo).bind(not_foo).bind(not_foo, 1, 2).bind(not_foo);
 assertEquals([foo, 3, 1], f(1));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo).bind(not_foo).bind(not_foo).bind(not_foo, 1, 2);
 assertEquals([foo, 3, 1], f(3));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1).bind(not_foo, 2).bind(not_foo).bind(not_foo);
 assertEquals([foo, 3, 1], f(3));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1).bind(not_foo).bind(not_foo, 2).bind(not_foo);
 assertEquals([foo, 3, 1], f(3));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1).bind(not_foo).bind(not_foo).bind(not_foo, 2);
 assertEquals([foo, 3, 1], f(3));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 f = foo.bind(foo).bind(not_foo, 1).bind(not_foo).bind(not_foo, 2);
 assertEquals([foo, 3, 1], f(3));
 assertEquals(1, f.length);
+%HeapObjectVerify(f);
 
 // The wrong number of arguments can be given to bound functions too.
 f = foo.bind(foo);
@@ -158,6 +180,7 @@ assertEquals([foo, 1, 1], f(1));
 assertEquals([foo, 2, 1], f(1, 2));
 assertEquals([foo, 3, 1], f(1, 2, 3));
 assertEquals([foo, 4, 1], f(1, 2, 3, 4));
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1);
 assertEquals(2, f.length);
@@ -165,21 +188,25 @@ assertEquals([foo, 1, 1], f());
 assertEquals([foo, 2, 1], f(2));
 assertEquals([foo, 3, 1], f(2, 3));
 assertEquals([foo, 4, 1], f(2, 3, 4));
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1, 2);
 assertEquals(1, f.length);
 assertEquals([foo, 2, 1], f());
 assertEquals([foo, 3, 1], f(3));
 assertEquals([foo, 4, 1], f(3, 4));
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1, 2, 3);
 assertEquals(0, f.length);
 assertEquals([foo, 3, 1], f());
 assertEquals([foo, 4, 1], f(4));
+%HeapObjectVerify(f);
 
 f = foo.bind(foo, 1, 2, 3, 4);
 assertEquals(0, f.length);
 assertEquals([foo, 4, 1], f());
+%HeapObjectVerify(f);
 
 // Test constructor calls.
 
@@ -194,24 +221,32 @@ var obj2 = new f(1,2,3);
 assertEquals(1, obj2.x);
 assertEquals(2, obj2.y);
 assertEquals(3, obj2.z);
+%HeapObjectVerify(f);
+%HeapObjectVerify(obj2);
 
 f = bar.bind(bar, 1);
 obj2 = new f(2,3);
 assertEquals(1, obj2.x);
 assertEquals(2, obj2.y);
 assertEquals(3, obj2.z);
+%HeapObjectVerify(f);
+%HeapObjectVerify(obj2);
 
 f = bar.bind(bar, 1, 2);
 obj2 = new f(3);
 assertEquals(1, obj2.x);
 assertEquals(2, obj2.y);
 assertEquals(3, obj2.z);
+%HeapObjectVerify(f);
+%HeapObjectVerify(obj2);
 
 f = bar.bind(bar, 1, 2, 3);
 obj2 = new f();
 assertEquals(1, obj2.x);
 assertEquals(2, obj2.y);
 assertEquals(3, obj2.z);
+%HeapObjectVerify(f);
+%HeapObjectVerify(obj2);
 
 
 // Test bind chains when used as a constructor.
@@ -220,6 +255,8 @@ obj2 = new f();
 assertEquals(1, obj2.x);
 assertEquals(2, obj2.y);
 assertEquals(3, obj2.z);
+%HeapObjectVerify(f);
+%HeapObjectVerify(obj2);
 
 // Test obj2 is instanceof both bar and f.
 assertTrue(obj2 instanceof bar);
@@ -235,22 +272,29 @@ assertTrue(obj3 instanceof f);
 assertFalse(obj3 instanceof foo);
 assertFalse(obj3 instanceof Function);
 assertFalse(obj3 instanceof String);
+%HeapObjectVerify(f);
+%HeapObjectVerify(obj3);
 
 // thisArg is converted to object.
 f = foo.bind(undefined);
 assertEquals([this, 0, undefined], f());
+%HeapObjectVerify(f);
 
 f = foo.bind(null);
 assertEquals([this, 0, undefined], f());
+%HeapObjectVerify(f);
 
 f = foo.bind(42);
 assertEquals([Object(42), 0, undefined], f());
+%HeapObjectVerify(f);
 
 f = foo.bind("foo");
 assertEquals([Object("foo"), 0, undefined], f());
+%HeapObjectVerify(f);
 
 f = foo.bind(true);
 assertEquals([Object(true), 0, undefined], f());
+%HeapObjectVerify(f);
 
 // Strict functions don't convert thisArg.
 function soo(x, y, z) {
@@ -260,18 +304,23 @@ function soo(x, y, z) {
 
 var s = soo.bind(undefined);
 assertEquals([undefined, 0, undefined], s());
+%HeapObjectVerify(s);
 
 s = soo.bind(null);
 assertEquals([null, 0, undefined], s());
+%HeapObjectVerify(s);
 
 s = soo.bind(42);
 assertEquals([42, 0, undefined], s());
+%HeapObjectVerify(s);
 
 s = soo.bind("foo");
 assertEquals(["foo", 0, undefined], s());
+%HeapObjectVerify(s);
 
 s = soo.bind(true);
 assertEquals([true, 0, undefined], s());
+%HeapObjectVerify(s);
 
 // Test that .arguments and .caller are poisoned according to the ES5 spec.
 
@@ -316,11 +365,14 @@ assertThrows(function() { f.arguments = 42; }, TypeError);
   Object.setPrototypeOf(fun, proto);
   var bound = fun.bind({});
   assertEquals(proto, Object.getPrototypeOf(bound));
+  %HeapObjectVerify(bound);
 
   var bound2 = fun.bind({});
   assertTrue(%HaveSameMap(new bound, new bound2));
+  %HeapObjectVerify(bound2);
 
   Object.setPrototypeOf(fun, null);
   bound = Function.prototype.bind.call(fun, {});
   assertEquals(null, Object.getPrototypeOf(bound));
+  %HeapObjectVerify(bound);
 })();
diff --git a/deps/v8/test/mjsunit/harmony/array-sort-comparefn.js b/deps/v8/test/mjsunit/harmony/array-sort-comparefn.js
new file mode 100644
index 0000000000..1ae470a351
--- /dev/null
+++ b/deps/v8/test/mjsunit/harmony/array-sort-comparefn.js
@@ -0,0 +1,38 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Array.prototype.sort + TypedArray.prototype.sort: comparefn must be either a
+// function or undefined.
+// https://github.com/tc39/ecma262/pull/785
+
+const types = [
+  Array,
+  Int8Array, Uint8Array,
+  Int16Array, Uint16Array,
+  Int32Array, Uint32Array,
+  Uint8ClampedArray,
+  Float32Array, Float64Array,
+];
+
+for (const type of types) {
+  const array = new type();
+  array[0] = 1;
+  array[1] = 2;
+  array[2] = 3;
+
+  array.sort();
+  array.sort(undefined);
+  array.sort(() => {});
+
+  assertThrows(() => { array.sort(null);     }, TypeError);
+  assertThrows(() => { array.sort(true);     }, TypeError);
+  assertThrows(() => { array.sort(false);    }, TypeError);
+  assertThrows(() => { array.sort('');       }, TypeError);
+  assertThrows(() => { array.sort(0);        }, TypeError);
+  assertThrows(() => { array.sort(42);       }, TypeError);
+  assertThrows(() => { array.sort([]);       }, TypeError);
+  assertThrows(() => { array.sort(/./);      }, TypeError);
+  assertThrows(() => { array.sort({});       }, TypeError);
+  assertThrows(() => { array.sort(Symbol()); }, TypeError);
+}
diff --git a/deps/v8/test/mjsunit/harmony/bigint.js b/deps/v8/test/mjsunit/harmony/bigint.js
new file mode 100644
index 0000000000..4406f12b11
--- /dev/null
+++ b/deps/v8/test/mjsunit/harmony/bigint.js
@@ -0,0 +1,355 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --harmony-bigint --no-opt
+
+'use strict'
+
+const zero = BigInt(0);
+const another_zero = BigInt(0);
+const one = BigInt(1);
+const another_one = BigInt(1);
+const two = BigInt(2);
+const three = BigInt(3);
+const six = BigInt(6);
+
+// BigInt
+{
+  assertSame(BigInt, BigInt.prototype.constructor)
+}
+
+// typeof
+{
+  assertEquals(typeof zero, "bigint");
+  assertEquals(typeof one, "bigint");
+}
+{
+  // TODO(neis): Enable once --no-opt can be removed.
+  //
+  // function Typeof(x) { return typeof x }
+  // assertEquals(Typeof(zero), "bigint");
+  // assertEquals(Typeof(zero), "bigint");
+  // %OptimizeFunctionOnNextCall(Typeof);
+  // assertEquals(Typeof(zero), "bigint");
+}
+
+// ToString
+{
+  assertEquals(String(zero), "0");
+  assertEquals(String(one), "1");
+}
+
+// .toString(radix)
+{
+  // Single-digit BigInts: random-generated inputs close to kMaxInt.
+  // Expectations computed with the following Python program:
+  //   def Format(x, base):
+  //     s = ""
+  //     while x > 0:
+  //       s = "0123456789abcdefghijklmnopqrstuvwxyz"[x % base] + s
+  //       x = x / base
+  //     return s
+  assertEquals("10100110000100101000011100101", BigInt(0x14c250e5).toString(2));
+  assertEquals("-110110100010011111001011111", BigInt(-0x6d13e5f).toString(2));
+  assertEquals("1001222020000100000", BigInt(0x18c72873).toString(3));
+  assertEquals("-1212101122110102020", BigInt(-0x2b19aebe).toString(3));
+  assertEquals("120303133110120", BigInt(0x18cdf518).toString(4));
+  assertEquals("-113203101020122", BigInt(-0x178d121a).toString(4));
+  assertEquals("1323302233400", BigInt(0x18de6256).toString(5));
+  assertEquals("-2301033210212", BigInt(-0x25f7f454).toString(5));
+  assertEquals("131050115130", BigInt(0x211f0d5e).toString(6));
+  assertEquals("-104353333321", BigInt(-0x186bbe91).toString(6));
+  assertEquals("25466260221", BigInt(0x2f69f47e).toString(7));
+  assertEquals("-31051540346", BigInt(-0x352c7efa).toString(7));
+  assertEquals("5004630525", BigInt(0x28133155).toString(8));
+  assertEquals("-7633240703", BigInt(-0x3e6d41c3).toString(8));
+  assertEquals("705082365", BigInt(0x121f4264).toString(9));
+  assertEquals("-780654431", BigInt(-0x1443b36e).toString(9));
+  assertEquals("297019028", BigInt(0x11b42694).toString(10));
+  assertEquals("-721151126", BigInt(-0x2afbe496).toString(10));
+  assertEquals("312914074", BigInt(0x27ca6879).toString(11));
+  assertEquals("-198025592", BigInt(-0x1813d3a7).toString(11));
+  assertEquals("191370997", BigInt(0x2d14f083).toString(12));
+  assertEquals("-1b8aab4a2", BigInt(-0x32b52efa).toString(12));
+  assertEquals("7818062c", BigInt(0x1c84a48c).toString(13));
+  assertEquals("-7529695b", BigInt(-0x1badffee).toString(13));
+  assertEquals("6bc929c4", BigInt(0x2b0a91d0).toString(14));
+  assertEquals("-63042008", BigInt(-0x270dff78).toString(14));
+  assertEquals("5e8b8dec", BigInt(0x3cd27d7f).toString(15));
+  assertEquals("-4005433d", BigInt(-0x28c0821a).toString(15));
+  assertEquals("10b35ca3", BigInt(0x10b35ca3).toString(16));
+  assertEquals("-23d4d9d6", BigInt(-0x23d4d9d6).toString(16));
+  assertEquals("28c3d5e3", BigInt(0x3d75d48c).toString(17));
+  assertEquals("-10c06328", BigInt(-0x1979b7f0).toString(17));
+  assertEquals("eb8d349", BigInt(0x1dacf0a5).toString(18));
+  assertEquals("-1217015h", BigInt(-0x28b3c23f).toString(18));
+  assertEquals("1018520b", BigInt(0x357da01a).toString(19));
+  assertEquals("-9c64e33", BigInt(-0x1b0e9571).toString(19));
+  assertEquals("d7bf9ab", BigInt(0x3309daa3).toString(20));
+  assertEquals("-58h0h9h", BigInt(-0x14c30c55).toString(20));
+  assertEquals("64igi9h", BigInt(0x1fdd329c).toString(21));
+  assertEquals("-45cbc4a", BigInt(-0x15cf9682).toString(21));
+  assertEquals("7bi7d1h", BigInt(0x32f0dfe3).toString(22));
+  assertEquals("-61j743l", BigInt(-0x291ff61f).toString(22));
+  assertEquals("5g5gg25", BigInt(0x325a10bd).toString(23));
+  assertEquals("-3359flb", BigInt(-0x1bb653c9).toString(23));
+  assertEquals("392f5ec", BigInt(0x267ed69c).toString(24));
+  assertEquals("-2ab3icb", BigInt(-0x1bbf7bab).toString(24));
+  assertEquals("3jb2afo", BigInt(0x36f93c24).toString(25));
+  assertEquals("-30bcheh", BigInt(-0x2bec76fa).toString(25));
+  assertEquals("3845agk", BigInt(0x3d04bf64).toString(26));
+  assertEquals("-1gpjl3g", BigInt(-0x1e720b1a).toString(26));
+  assertEquals("20bpaf0", BigInt(0x2e8ff627).toString(27));
+  assertEquals("-292i3c2", BigInt(-0x35f751fe).toString(27));
+  assertEquals("266113k", BigInt(0x3fd26738).toString(28));
+  assertEquals("-1eh16bo", BigInt(-0x2bb5726c).toString(28));
+  assertEquals("19gj7qa", BigInt(0x2f28e8d8).toString(29));
+  assertEquals("-13a0apf", BigInt(-0x278b4588).toString(29));
+  assertEquals("iasrb8", BigInt(0x1a99b3be).toString(30));
+  assertEquals("-frlhoc", BigInt(-0x17106f48).toString(30));
+  assertEquals("bfe4p2", BigInt(0x139f1ea3).toString(31));
+  assertEquals("-ioal1a", BigInt(-0x200e49fa).toString(31));
+  assertEquals("m0v0kf", BigInt(0x2c0f828f).toString(32));
+  assertEquals("-g4bab5", BigInt(-0x2045a965).toString(32));
+  assertEquals("9i1kit", BigInt(0x16450a9f).toString(33));
+  assertEquals("-fqb0e7", BigInt(-0x24d9e889).toString(33));
+  assertEquals("gb9r6m", BigInt(0x2c3acf46).toString(34));
+  assertEquals("-jcaemv", BigInt(-0x346f72b3).toString(34));
+  assertEquals("cw4mbk", BigInt(0x2870cdcb).toString(35));
+  assertEquals("-hw4eki", BigInt(-0x3817c29b).toString(35));
+  assertEquals("alzwgj", BigInt(0x263e2c13).toString(36));
+  assertEquals("-bo4ukz", BigInt(-0x2a0f97d3).toString(36));
+
+  // Multi-digit BigInts.
+  // Test parseInt/toString round trip on a list of randomly generated
+  // string representations of numbers in various bases.
+  var positive = [0, 0,  // Skip base 0 and 1.
+    "1100110001100010110011110110010010001011100111100101111000111101100001000",
+    "1001200022210010220101120212021002011002201122200002211102120120021011020",
+    "1111113020012203332320220022231110130001001320122012131311333110012023232",
+    "4214313040222110434114402342013144321401424143322013320403411012033300312",
+    "5025302003542512450341430541203424555035430434034243510233043041501130015",
+    "6231052230016515343200525230300322104013130605414211331345043144525012021",
+    "1146340505617030644211355340006353546230356336306352536433054143503442135",
+    "7262360724624787621528668212168232276348417717770383567066203032200270570",
+    "7573792356581293501680046955899735043496925151216904903504319328753434194",
+    "4a627927557579898720a42647639128174a8689889766a219342133671449069a2235011",
+    "1a574a5848289924996342a32893380690322330393633b587ba5a15b7b82080222400464",
+    "5163304c74c387b7a443c92466688595b671a3329b42083b1499b0c10a74a9298a06c3a5a",
+    "4b63c834356a03c80946133284a709cbbc2a75022757207dc31c14abd4c160dc122327c17",
+    "d8d59cbb4ca2860de7c002eee4ab3c215b90069200d20dbdc0111cb1e1bab97e8c7609670",
+    "22d4b69398a7f848e6ae36798811cd1a63d90f340d8607f3ce5566c97c18468787eb2b9fd",
+    "1176gf69afd32cc105fa70c705927a384dbdb1g8d952f28028g31ebdc9e32a89f16e825ee",
+    "5d64b74f4d70632h4ee07h7c1e2da9125c42g2727f4b6d95e5cec6ga49566hh731ab5f544",
+    "7ff8cg7f05dd72916a09a4761ii7b0ibcg68ba39b10436f14efg76ge817317badcbi4gffc",
+    "6d7c4hci6cd72e4ja26j354i12i71gb0cbj12gi145j91h02hde3b72c65geb7ff9bi9d0c2b",
+    "c96997f50abe425d13a53kk4af631kg7db208ka5j5bfg8ca5f9c0bjf69j5kgg4jb5h7hi86",
+    "3g5fd800d9ib9j0i8all5jgb23dh9483ab6le5ad9g4kja8a0b3j5jbjfge7k5fffg2kbheee",
+    "9j1119d1cd61kmdm7kma105cki313f678fc3h25f4664281bbmg3fk97kfbh7d48j89j178ch",
+    "d2933cdc9jfe4hl3794kb3e13dg2lihad968ib9jg19dgf1fi482b27ji0d10c6kfkdge5764",
+    "bf6o0njkm1ij5in5nh7h94584bd80el02b07el5ojk9k9g0gn906do70gbbnckl048c0kdmao",
+    "8gb7jnge9p9cdgigo394oa33gfaenc3gnb53eceg4b8511gkkm88b0dod85e5bggpc861d7d5",
+    "qbbnqhkpleb4o8ndaddpc34h5b2iljn3jgnjdn5k57bi3n9i09hjle9hqgqdpgbnk499mak56",
+    "akg7e2976arn8i2m53gif0dp59bmfd7mk9erlg2qm3fc76da9glf397eh4ooij9il0nfl9gac",
+    "mehpbfrj5ah2ef3p2hl637gjp1pm5grqn4037pm1qfgfpr9cfljfc145hljehjjb48bb1n6en",
+    "rg6ik3agnb3p6t2rtja9h4il76i8fkqlt6gplap3fq6pfr7bbcfcp5ffncf3nm4kamap39hse",
+    "bk8rp9r9r8pltdqpb7euc6s9rcm33969pcq6uk3mtfoktt86di8589oacbam5tn29b9b6dq3j",
+    "npth8juld44rss3e57iigjg65po3d1h02heo4r103jmg3ocv89buqtgiov35k39rdf8j9t4ca",
+    "vrmqlwrrrd0uml1womae49jpa9tadh44fw7mucgk06l0uk4uqwuo37t6kwn7wwrm3a6oq081s",
+    "n5cft6gvufqd8iksquu2amghokk17gbtpguidc290af634p7k7rhmfu7bf1s62ej4megoa1j4",
+    "3v3gcrmlfc2tl0tefgkiogj41f6y2tmj9w5bxke8y03xqf49ox8gh9wbrhycrkluicqajtnur",
+    "z2m7b0sy2tzergtkqts5yj0dkrlfkxls81ijgxgfequizpntcwggv2d4rdzcncd0kj9mrmnrb",
+  ];
+  var negative = [0, 0,  // Skip base 0 and 1.
+    "-100010011110111010111111110001100100111010101000001011010010101100101000",
+    "-110012122000122102021210112200001000122011010120101201001122000002022102",
+    "-203210320111001002200122200001312300221100221321010300023323201113122333",
+    "-133042441230110320040323303341320302144241224443231311022240124413104131",
+    "-311325230504055004330150145105331121322231155401110315251422505233103112",
+    "-643153641664240231336166403516403454646560261062114326443664602606315326",
+    "-200057252627665476551635525303641543165622340301637556323453513664337277",
+    "-826688166214270516331644053744613530235020517172322840763172114078364165",
+    "-743042397390679269240157150971957535458122650450558451124173993544604852",
+    "-73528688500003573942a56a504a2996a1384129563098512a63196697975038692aaa63",
+    "-616576a2948a9029316290168b71137b027851639a0283150b125b664b74b767a3597805",
+    "-b875467540719b371b7a36047a7886872a5399c4c630c37149bc3182917a7a7c124475bb",
+    "-3860411b61d35977721bc81bd715c386c9b70a752940913d265505d8c7c5dd2624b591d7",
+    "-bad5dd79b083ee0da9a6296664e72c246d827762357116ae7076a22bb369acbc3a201d03",
+    "-f9b37352aff265124303942a463917a252ff1a2ff4a33777f490b4c103bdcd1a655dbe2c",
+    "-805fg8c74125214g383a8d8g573c49fa7c4035fbc6db61g5gb5g6beb8f90dae4a9a5g7cc",
+    "-70aae113459d3h5084b1gg209g3695d20e78d01gcbb71bh1bd4gdge31haf5hc02dghf14e",
+    "-c55a57haf47b7ih2gh6ea93098ig02b42icga6ead254e0aeeic7g53h5fd6637ge03b2e20",
+    "-e32f7204624ie596j731g72136cejc25ebbgb0140i4997fcdf477f021d86ci4e10db543a",
+    "-i7f32c817i3cac1c24c7786k6ig185f47cj1471ki6bb7agiae838027gjge9g59if9f88g6",
+    "-i30aha2030a9605c270h92e1ca3i02j996hl918gh52fbhb7i16ik1i919ieak3cj384kb61",
+    "-58jmem8e59li67aellid2083dabh4kh51ci1jg7c6a3k4l1hdgfkdha0fglfm4805kida5b9",
+    "-cl9iecjg9ak087cad4151lll44296heae2349g70fbjj37998m2ddn6427fgcl2aknhgn1a1",
+    "-alfjfhho4gf8bi4j2bi3743mhg2aache4c6jcinkmf5ddm7kf9gg350hlja16ealbdlk201j",
+    "-bhh1146ho3o2m3b839c565hbgjnhjh96oofbmdl7gn8h4f94kli94hkk180o79pc4d2l0721",
+    "-p00gknh7e05k6a3apg6i9lb46f4a9qeeiq1778ak8il5dcponk5gl2fiednb4pmo1agmoqph",
+    "-4j8lo4d4p508fnd2hkfb76e8ri81k6hq0op3pr14ca0cn96pccplk7rbahc9cdkdce1q16dn",
+    "-ednlo3ogf2i8annrel9rm323bpf00meed3oi47n0qrdgnd2n3il4bnsc9s2jd7loh44im8ra",
+    "-bjjg6fsbpcc2tc1o09m9r6fd6eoq5480har62a5offn9thcfahbno9kf9magl2akl0jgncj9",
+    "-sonuhat2h60glpbpej9jjado2s5l86122d26tudoc1d6aic2oitu793gk0mlac3dk1dufp1q",
+    "-i9pbvm53ubh8jqifuarauch8cbgk9cjsl6rlioka1phs1lskg1oosll23hjoli2subgr1rto",
+    "-w1ncn5t60b5dv669ekwnvk8n2g7djrsl8cdkwun8o3m5divc3jhnkp2381rhj70gc71a6wff",
+    "-buiq8v33p5ex44ps4s45enj6lrluivm19lcowkvntu72u0xguw13bxgxxe7mdlwt1a4qksae",
+    "-woiycfmea6i12r2yai49mf4lbd7w2jdoebiogfhnh1i4rwgox57obci8qbsfpb4w07nu19m5",
+    "-tbttuip1r6ioca6g6dw354o4m78qep9yh03nojx47yq29fqime6zstwllb74501qct8eskxn",
+  ];
+  for (var base = 2; base <= 36; base++) {
+    var input = positive[base];
+    assertEquals(input, BigInt.parseInt(input, base).toString(base));
+    input = negative[base];
+    assertEquals(input, BigInt.parseInt(input, base).toString(base));
+  }
+}
+
+// .parseInt
+{
+  assertEquals("hellobigint", BigInt.parseInt("hellobigint", 32).toString(32));
+  assertEquals("abc", BigInt.parseInt("101010111100", 2).toString(16));
+  // Detect "0x" prefix.
+  assertEquals("f00dcafe", BigInt.parseInt("0xf00dcafe").toString(16));
+  // Default base is 10, trailing junk is skipped.
+  assertEquals("abc", BigInt.parseInt("2748junk").toString(16));
+  // Objects are converted to string.
+  let obj = {toString: () => "0x12345"};
+  assertEquals("12345", BigInt.parseInt(obj).toString(16));
+  // Empty and invalid strings throw.
+  assertThrows("BigInt.parseInt('')", SyntaxError);
+  assertThrows("BigInt.parseInt('nope', 2)", SyntaxError);
+}
+
+// .valueOf
+{
+  assertEquals(Object(zero).valueOf(), another_zero);
+  assertThrows(() => { return BigInt.prototype.valueOf.call("string"); },
+               TypeError);
+  // TODO(jkummerow): Add tests for (new BigInt(...)).valueOf() when we
+  // can construct BigInt wrappers.
+}
+
+// ToBoolean
+{
+  assertTrue(!zero);
+  assertFalse(!!zero);
+  assertTrue(!!!zero);
+
+  assertFalse(!one);
+  assertTrue(!!one);
+  assertFalse(!!!one);
+}
+
+// Strict equality
+{
+  assertTrue(zero === zero);
+  assertFalse(zero !== zero);
+
+  assertTrue(zero === another_zero);
+  assertFalse(zero !== another_zero);
+
+  assertFalse(zero === one);
+  assertTrue(zero !== one);
+  assertTrue(one !== zero);
+  assertFalse(one === zero);
+
+  assertFalse(zero === 0);
+  assertTrue(zero !== 0);
+  assertFalse(0 === zero);
+  assertTrue(0 !== zero);
+}
+
+// SameValue
+{
+  const obj = Object.defineProperty({}, 'foo',
+      {value: zero, writable: false, configurable: false});
+
+  assertTrue(Reflect.defineProperty(obj, 'foo', {value: zero}));
+  assertTrue(Reflect.defineProperty(obj, 'foo', {value: another_zero}));
+  assertFalse(Reflect.defineProperty(obj, 'foo', {value: one}));
+}
+
+// SameValueZero
+{
+  assertTrue([zero].includes(zero));
+  assertTrue([zero].includes(another_zero));
+
+  assertFalse([zero].includes(+0));
+  assertFalse([zero].includes(-0));
+
+  assertFalse([+0].includes(zero));
+  assertFalse([-0].includes(zero));
+
+  assertTrue([one].includes(one));
+  assertTrue([one].includes(another_one));
+
+  assertFalse([one].includes(1));
+  assertFalse([1].includes(one));
+}{
+  assertTrue(new Set([zero]).has(zero));
+  assertTrue(new Set([zero]).has(another_zero));
+
+  assertFalse(new Set([zero]).has(+0));
+  assertFalse(new Set([zero]).has(-0));
+
+  assertFalse(new Set([+0]).has(zero));
+  assertFalse(new Set([-0]).has(zero));
+
+  assertTrue(new Set([one]).has(one));
+  assertTrue(new Set([one]).has(another_one));
+}{
+  assertTrue(new Map([[zero, 42]]).has(zero));
+  assertTrue(new Map([[zero, 42]]).has(another_zero));
+
+  assertFalse(new Map([[zero, 42]]).has(+0));
+  assertFalse(new Map([[zero, 42]]).has(-0));
+
+  assertFalse(new Map([[+0, 42]]).has(zero));
+  assertFalse(new Map([[-0, 42]]).has(zero));
+
+  assertTrue(new Map([[one, 42]]).has(one));
+  assertTrue(new Map([[one, 42]]).has(another_one));
+}
+
+// Binary ops.
+{
+  assertTrue(one + two === three);
+  assertEquals("hello1", "hello" + one);
+  assertEquals("2hello", two + "hello");
+  assertThrows("one + 2", TypeError);
+  assertThrows("2 + one", TypeError);
+  assertThrows("one + 0.5", TypeError);
+  assertThrows("0.5 + one", TypeError);
+  assertThrows("one + null", TypeError);
+  assertThrows("null + one", TypeError);
+
+  assertTrue(three - two === one);
+  assertThrows("two - 1", TypeError);
+  assertThrows("2 - one", TypeError);
+  assertThrows("two - 0.5", TypeError);
+  assertThrows("2.5 - one", TypeError);
+
+  assertTrue(two * three === six);
+  assertThrows("two * 1", TypeError);
+  assertThrows("1 * two", TypeError);
+  assertThrows("two * 1.5", TypeError);
+  assertThrows("1.5 * two", TypeError);
+
+  assertTrue(six / three === two);
+  assertThrows("six / 3", TypeError);
+  assertThrows("3 / three", TypeError);
+  assertThrows("six / 0.5", TypeError);
+  assertThrows("0.5 / six", TypeError);
+  assertThrows("zero / zero", RangeError);
+  assertThrows("zero / 0", TypeError);
+
+  assertTrue(three % two === one);
+  assertThrows("three % 2", TypeError);
+  assertThrows("3 % two", TypeError);
+  assertThrows("three % 2.5", TypeError);
+  assertThrows("3.5 % two", TypeError);
+  assertThrows("three % zero", RangeError);
+  assertThrows("three % 0", TypeError);
+}
diff --git a/deps/v8/test/mjsunit/harmony/modules-import-large.js b/deps/v8/test/mjsunit/harmony/modules-import-large.js
new file mode 100644
index 0000000000..250a41bd82
--- /dev/null
+++ b/deps/v8/test/mjsunit/harmony/modules-import-large.js
@@ -0,0 +1,1120 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// MODULE
+
+// Flags: --allow-natives-syntax
+
+import * as m1 from "modules-skip-large1.js";
+import * as m2 from "modules-skip-large2.js";
+
+assertFalse(%HasFastProperties(m1));
+assertFalse(%HasFastProperties(m2));
+assertFalse(%HaveSameMap(m1, m2));
+
+function verify(m) {
+  assertEquals(m.a0, 0);
+  assertEquals(m.a1, 1);
+  assertEquals(m.a2, 2);
+  assertEquals(m.a3, 3);
+  assertEquals(m.a4, 4);
+  assertEquals(m.a5, 5);
+  assertEquals(m.a6, 6);
+  assertEquals(m.a7, 7);
+  assertEquals(m.a8, 8);
+  assertEquals(m.a9, 9);
+  assertEquals(m.a10, 10);
+  assertEquals(m.a11, 11);
+  assertEquals(m.a12, 12);
+  assertEquals(m.a13, 13);
+  assertEquals(m.a14, 14);
+  assertEquals(m.a15, 15);
+  assertEquals(m.a16, 16);
+  assertEquals(m.a17, 17);
+  assertEquals(m.a18, 18);
+  assertEquals(m.a19, 19);
+  assertEquals(m.a20, 20);
+  assertEquals(m.a21, 21);
+  assertEquals(m.a22, 22);
+  assertEquals(m.a23, 23);
+  assertEquals(m.a24, 24);
+  assertEquals(m.a25, 25);
+  assertEquals(m.a26, 26);
+  assertEquals(m.a27, 27);
+  assertEquals(m.a28, 28);
+  assertEquals(m.a29, 29);
+  assertEquals(m.a30, 30);
+  assertEquals(m.a31, 31);
+  assertEquals(m.a32, 32);
+  assertEquals(m.a33, 33);
+  assertEquals(m.a34, 34);
+  assertEquals(m.a35, 35);
+  assertEquals(m.a36, 36);
+  assertEquals(m.a37, 37);
+  assertEquals(m.a38, 38);
+  assertEquals(m.a39, 39);
+  assertEquals(m.a40, 40);
+  assertEquals(m.a41, 41);
+  assertEquals(m.a42, 42);
+  assertEquals(m.a43, 43);
+  assertEquals(m.a44, 44);
+  assertEquals(m.a45, 45);
+  assertEquals(m.a46, 46);
+  assertEquals(m.a47, 47);
+  assertEquals(m.a48, 48);
+  assertEquals(m.a49, 49);
+  assertEquals(m.a50, 50);
+  assertEquals(m.a51, 51);
+  assertEquals(m.a52, 52);
+  assertEquals(m.a53, 53);
+  assertEquals(m.a54, 54);
+  assertEquals(m.a55, 55);
+  assertEquals(m.a56, 56);
+  assertEquals(m.a57, 57);
+  assertEquals(m.a58, 58);
+  assertEquals(m.a59, 59);
+  assertEquals(m.a60, 60);
+  assertEquals(m.a61, 61);
+  assertEquals(m.a62, 62);
+  assertEquals(m.a63, 63);
+  assertEquals(m.a64, 64);
+  assertEquals(m.a65, 65);
+  assertEquals(m.a66, 66);
+  assertEquals(m.a67, 67);
+  assertEquals(m.a68, 68);
+  assertEquals(m.a69, 69);
+  assertEquals(m.a70, 70);
+  assertEquals(m.a71, 71);
+  assertEquals(m.a72, 72);
+  assertEquals(m.a73, 73);
+  assertEquals(m.a74, 74);
+  assertEquals(m.a75, 75);
+  assertEquals(m.a76, 76);
+  assertEquals(m.a77, 77);
+  assertEquals(m.a78, 78);
+  assertEquals(m.a79, 79);
+  assertEquals(m.a80, 80);
+  assertEquals(m.a81, 81);
+  assertEquals(m.a82, 82);
+  assertEquals(m.a83, 83);
+  assertEquals(m.a84, 84);
+  assertEquals(m.a85, 85);
+  assertEquals(m.a86, 86);
+  assertEquals(m.a87, 87);
+  assertEquals(m.a88, 88);
+  assertEquals(m.a89, 89);
+  assertEquals(m.a90, 90);
+  assertEquals(m.a91, 91);
+  assertEquals(m.a92, 92);
+  assertEquals(m.a93, 93);
+  assertEquals(m.a94, 94);
+  assertEquals(m.a95, 95);
+  assertEquals(m.a96, 96);
+  assertEquals(m.a97, 97);
+  assertEquals(m.a98, 98);
+  assertEquals(m.a99, 99);
+  assertEquals(m.a100, 100);
+  assertEquals(m.a101, 101);
+  assertEquals(m.a102, 102);
+  assertEquals(m.a103, 103);
+  assertEquals(m.a104, 104);
+  assertEquals(m.a105, 105);
+  assertEquals(m.a106, 106);
+  assertEquals(m.a107, 107);
+  assertEquals(m.a108, 108);
+  assertEquals(m.a109, 109);
+  assertEquals(m.a110, 110);
+  assertEquals(m.a111, 111);
+  assertEquals(m.a112, 112);
+  assertEquals(m.a113, 113);
+  assertEquals(m.a114, 114);
+  assertEquals(m.a115, 115);
+  assertEquals(m.a116, 116);
+  assertEquals(m.a117, 117);
+  assertEquals(m.a118, 118);
+  assertEquals(m.a119, 119);
+  assertEquals(m.a120, 120);
+  assertEquals(m.a121, 121);
+  assertEquals(m.a122, 122);
+  assertEquals(m.a123, 123);
+  assertEquals(m.a124, 124);
+  assertEquals(m.a125, 125);
+  assertEquals(m.a126, 126);
+  assertEquals(m.a127, 127);
+  assertEquals(m.a128, 128);
+  assertEquals(m.a129, 129);
+  assertEquals(m.a130, 130);
+  assertEquals(m.a131, 131);
+  assertEquals(m.a132, 132);
+  assertEquals(m.a133, 133);
+  assertEquals(m.a134, 134);
+  assertEquals(m.a135, 135);
+  assertEquals(m.a136, 136);
+  assertEquals(m.a137, 137);
+  assertEquals(m.a138, 138);
+  assertEquals(m.a139, 139);
+  assertEquals(m.a140, 140);
+  assertEquals(m.a141, 141);
+  assertEquals(m.a142, 142);
+  assertEquals(m.a143, 143);
+  assertEquals(m.a144, 144);
+  assertEquals(m.a145, 145);
+  assertEquals(m.a146, 146);
+  assertEquals(m.a147, 147);
+  assertEquals(m.a148, 148);
+  assertEquals(m.a149, 149);
+  assertEquals(m.a150, 150);
+  assertEquals(m.a151, 151);
+  assertEquals(m.a152, 152);
+  assertEquals(m.a153, 153);
+  assertEquals(m.a154, 154);
+  assertEquals(m.a155, 155);
+  assertEquals(m.a156, 156);
+  assertEquals(m.a157, 157);
+  assertEquals(m.a158, 158);
+  assertEquals(m.a159, 159);
+  assertEquals(m.a160, 160);
+  assertEquals(m.a161, 161);
+  assertEquals(m.a162, 162);
+  assertEquals(m.a163, 163);
+  assertEquals(m.a164, 164);
+  assertEquals(m.a165, 165);
+  assertEquals(m.a166, 166);
+  assertEquals(m.a167, 167);
+  assertEquals(m.a168, 168);
+  assertEquals(m.a169, 169);
+  assertEquals(m.a170, 170);
+  assertEquals(m.a171, 171);
+  assertEquals(m.a172, 172);
+  assertEquals(m.a173, 173);
+  assertEquals(m.a174, 174);
+  assertEquals(m.a175, 175);
+  assertEquals(m.a176, 176);
+  assertEquals(m.a177, 177);
+  assertEquals(m.a178, 178);
+  assertEquals(m.a179, 179);
+  assertEquals(m.a180, 180);
+  assertEquals(m.a181, 181);
+  assertEquals(m.a182, 182);
+  assertEquals(m.a183, 183);
+  assertEquals(m.a184, 184);
+  assertEquals(m.a185, 185);
+  assertEquals(m.a186, 186);
+  assertEquals(m.a187, 187);
+  assertEquals(m.a188, 188);
+  assertEquals(m.a189, 189);
+  assertEquals(m.a190, 190);
+  assertEquals(m.a191, 191);
+  assertEquals(m.a192, 192);
+  assertEquals(m.a193, 193);
+  assertEquals(m.a194, 194);
+  assertEquals(m.a195, 195);
+  assertEquals(m.a196, 196);
+  assertEquals(m.a197, 197);
+  assertEquals(m.a198, 198);
+  assertEquals(m.a199, 199);
+  assertEquals(m.a200, 200);
+  assertEquals(m.a201, 201);
+  assertEquals(m.a202, 202);
+  assertEquals(m.a203, 203);
+  assertEquals(m.a204, 204);
+  assertEquals(m.a205, 205);
+  assertEquals(m.a206, 206);
+  assertEquals(m.a207, 207);
+  assertEquals(m.a208, 208);
+  assertEquals(m.a209, 209);
+  assertEquals(m.a210, 210);
+  assertEquals(m.a211, 211);
+  assertEquals(m.a212, 212);
+  assertEquals(m.a213, 213);
+  assertEquals(m.a214, 214);
+  assertEquals(m.a215, 215);
+  assertEquals(m.a216, 216);
+  assertEquals(m.a217, 217);
+  assertEquals(m.a218, 218);
+  assertEquals(m.a219, 219);
+  assertEquals(m.a220, 220);
+  assertEquals(m.a221, 221);
+  assertEquals(m.a222, 222);
+  assertEquals(m.a223, 223);
+  assertEquals(m.a224, 224);
+  assertEquals(m.a225, 225);
+  assertEquals(m.a226, 226);
+  assertEquals(m.a227, 227);
+  assertEquals(m.a228, 228);
+  assertEquals(m.a229, 229);
+  assertEquals(m.a230, 230);
+  assertEquals(m.a231, 231);
+  assertEquals(m.a232, 232);
+  assertEquals(m.a233, 233);
+  assertEquals(m.a234, 234);
+  assertEquals(m.a235, 235);
+  assertEquals(m.a236, 236);
+  assertEquals(m.a237, 237);
+  assertEquals(m.a238, 238);
+  assertEquals(m.a239, 239);
+  assertEquals(m.a240, 240);
+  assertEquals(m.a241, 241);
+  assertEquals(m.a242, 242);
+  assertEquals(m.a243, 243);
+  assertEquals(m.a244, 244);
+  assertEquals(m.a245, 245);
+  assertEquals(m.a246, 246);
+  assertEquals(m.a247, 247);
+  assertEquals(m.a248, 248);
+  assertEquals(m.a249, 249);
+  assertEquals(m.a250, 250);
+  assertEquals(m.a251, 251);
+  assertEquals(m.a252, 252);
+  assertEquals(m.a253, 253);
+  assertEquals(m.a254, 254);
+  assertEquals(m.a255, 255);
+  assertEquals(m.a256, 256);
+  assertEquals(m.a257, 257);
+  assertEquals(m.a258, 258);
+  assertEquals(m.a259, 259);
+  assertEquals(m.a260, 260);
+  assertEquals(m.a261, 261);
+  assertEquals(m.a262, 262);
+  assertEquals(m.a263, 263);
+  assertEquals(m.a264, 264);
+  assertEquals(m.a265, 265);
+  assertEquals(m.a266, 266);
+  assertEquals(m.a267, 267);
+  assertEquals(m.a268, 268);
+  assertEquals(m.a269, 269);
+  assertEquals(m.a270, 270);
+  assertEquals(m.a271, 271);
+  assertEquals(m.a272, 272);
+  assertEquals(m.a273, 273);
+  assertEquals(m.a274, 274);
+  assertEquals(m.a275, 275);
+  assertEquals(m.a276, 276);
+  assertEquals(m.a277, 277);
+  assertEquals(m.a278, 278);
+  assertEquals(m.a279, 279);
+  assertEquals(m.a280, 280);
+  assertEquals(m.a281, 281);
+  assertEquals(m.a282, 282);
+  assertEquals(m.a283, 283);
+  assertEquals(m.a284, 284);
+  assertEquals(m.a285, 285);
+  assertEquals(m.a286, 286);
+  assertEquals(m.a287, 287);
+  assertEquals(m.a288, 288);
+  assertEquals(m.a289, 289);
+  assertEquals(m.a290, 290);
+  assertEquals(m.a291, 291);
+  assertEquals(m.a292, 292);
+  assertEquals(m.a293, 293);
+  assertEquals(m.a294, 294);
+  assertEquals(m.a295, 295);
+  assertEquals(m.a296, 296);
+  assertEquals(m.a297, 297);
+  assertEquals(m.a298, 298);
+  assertEquals(m.a299, 299);
+  assertEquals(m.a300, 300);
+  assertEquals(m.a301, 301);
+  assertEquals(m.a302, 302);
+  assertEquals(m.a303, 303);
+  assertEquals(m.a304, 304);
+  assertEquals(m.a305, 305);
+  assertEquals(m.a306, 306);
+  assertEquals(m.a307, 307);
+  assertEquals(m.a308, 308);
+  assertEquals(m.a309, 309);
+  assertEquals(m.a310, 310);
+  assertEquals(m.a311, 311);
+  assertEquals(m.a312, 312);
+  assertEquals(m.a313, 313);
+  assertEquals(m.a314, 314);
+  assertEquals(m.a315, 315);
+  assertEquals(m.a316, 316);
+  assertEquals(m.a317, 317);
+  assertEquals(m.a318, 318);
+  assertEquals(m.a319, 319);
+  assertEquals(m.a320, 320);
+  assertEquals(m.a321, 321);
+  assertEquals(m.a322, 322);
+  assertEquals(m.a323, 323);
+  assertEquals(m.a324, 324);
+  assertEquals(m.a325, 325);
+  assertEquals(m.a326, 326);
+  assertEquals(m.a327, 327);
+  assertEquals(m.a328, 328);
+  assertEquals(m.a329, 329);
+  assertEquals(m.a330, 330);
+  assertEquals(m.a331, 331);
+  assertEquals(m.a332, 332);
+  assertEquals(m.a333, 333);
+  assertEquals(m.a334, 334);
+  assertEquals(m.a335, 335);
+  assertEquals(m.a336, 336);
+  assertEquals(m.a337, 337);
+  assertEquals(m.a338, 338);
+  assertEquals(m.a339, 339);
+  assertEquals(m.a340, 340);
+  assertEquals(m.a341, 341);
+  assertEquals(m.a342, 342);
+  assertEquals(m.a343, 343);
+  assertEquals(m.a344, 344);
+  assertEquals(m.a345, 345);
+  assertEquals(m.a346, 346);
+  assertEquals(m.a347, 347);
+  assertEquals(m.a348, 348);
+  assertEquals(m.a349, 349);
+  assertEquals(m.a350, 350);
+  assertEquals(m.a351, 351);
+  assertEquals(m.a352, 352);
+  assertEquals(m.a353, 353);
+  assertEquals(m.a354, 354);
+  assertEquals(m.a355, 355);
+  assertEquals(m.a356, 356);
+  assertEquals(m.a357, 357);
+  assertEquals(m.a358, 358);
+  assertEquals(m.a359, 359);
+  assertEquals(m.a360, 360);
+  assertEquals(m.a361, 361);
+  assertEquals(m.a362, 362);
+  assertEquals(m.a363, 363);
+  assertEquals(m.a364, 364);
+  assertEquals(m.a365, 365);
+  assertEquals(m.a366, 366);
+  assertEquals(m.a367, 367);
+  assertEquals(m.a368, 368);
+  assertEquals(m.a369, 369);
+  assertEquals(m.a370, 370);
+  assertEquals(m.a371, 371);
+  assertEquals(m.a372, 372);
+  assertEquals(m.a373, 373);
+  assertEquals(m.a374, 374);
+  assertEquals(m.a375, 375);
+  assertEquals(m.a376, 376);
+  assertEquals(m.a377, 377);
+  assertEquals(m.a378, 378);
+  assertEquals(m.a379, 379);
+  assertEquals(m.a380, 380);
+  assertEquals(m.a381, 381);
+  assertEquals(m.a382, 382);
+  assertEquals(m.a383, 383);
+  assertEquals(m.a384, 384);
+  assertEquals(m.a385, 385);
+  assertEquals(m.a386, 386);
+  assertEquals(m.a387, 387);
+  assertEquals(m.a388, 388);
+  assertEquals(m.a389, 389);
+  assertEquals(m.a390, 390);
+  assertEquals(m.a391, 391);
+  assertEquals(m.a392, 392);
+  assertEquals(m.a393, 393);
+  assertEquals(m.a394, 394);
+  assertEquals(m.a395, 395);
+  assertEquals(m.a396, 396);
+  assertEquals(m.a397, 397);
+  assertEquals(m.a398, 398);
+  assertEquals(m.a399, 399);
+  assertEquals(m.a400, 400);
+  assertEquals(m.a401, 401);
+  assertEquals(m.a402, 402);
+  assertEquals(m.a403, 403);
+  assertEquals(m.a404, 404);
+  assertEquals(m.a405, 405);
+  assertEquals(m.a406, 406);
+  assertEquals(m.a407, 407);
+  assertEquals(m.a408, 408);
+  assertEquals(m.a409, 409);
+  assertEquals(m.a410, 410);
+  assertEquals(m.a411, 411);
+  assertEquals(m.a412, 412);
+  assertEquals(m.a413, 413);
+  assertEquals(m.a414, 414);
+  assertEquals(m.a415, 415);
+  assertEquals(m.a416, 416);
+  assertEquals(m.a417, 417);
+  assertEquals(m.a418, 418);
+  assertEquals(m.a419, 419);
+  assertEquals(m.a420, 420);
+  assertEquals(m.a421, 421);
+  assertEquals(m.a422, 422);
+  assertEquals(m.a423, 423);
+  assertEquals(m.a424, 424);
+  assertEquals(m.a425, 425);
+  assertEquals(m.a426, 426);
+  assertEquals(m.a427, 427);
+  assertEquals(m.a428, 428);
+  assertEquals(m.a429, 429);
+  assertEquals(m.a430, 430);
+  assertEquals(m.a431, 431);
+  assertEquals(m.a432, 432);
+  assertEquals(m.a433, 433);
+  assertEquals(m.a434, 434);
+  assertEquals(m.a435, 435);
+  assertEquals(m.a436, 436);
+  assertEquals(m.a437, 437);
+  assertEquals(m.a438, 438);
+  assertEquals(m.a439, 439);
+  assertEquals(m.a440, 440);
+  assertEquals(m.a441, 441);
+  assertEquals(m.a442, 442);
+  assertEquals(m.a443, 443);
+  assertEquals(m.a444, 444);
+  assertEquals(m.a445, 445);
+  assertEquals(m.a446, 446);
+  assertEquals(m.a447, 447);
+  assertEquals(m.a448, 448);
+  assertEquals(m.a449, 449);
+  assertEquals(m.a450, 450);
+  assertEquals(m.a451, 451);
+  assertEquals(m.a452, 452);
+  assertEquals(m.a453, 453);
+  assertEquals(m.a454, 454);
+  assertEquals(m.a455, 455);
+  assertEquals(m.a456, 456);
+  assertEquals(m.a457, 457);
+  assertEquals(m.a458, 458);
+  assertEquals(m.a459, 459);
+  assertEquals(m.a460, 460);
+  assertEquals(m.a461, 461);
+  assertEquals(m.a462, 462);
+  assertEquals(m.a463, 463);
+  assertEquals(m.a464, 464);
+  assertEquals(m.a465, 465);
+  assertEquals(m.a466, 466);
+  assertEquals(m.a467, 467);
+  assertEquals(m.a468, 468);
+  assertEquals(m.a469, 469);
+  assertEquals(m.a470, 470);
+  assertEquals(m.a471, 471);
+  assertEquals(m.a472, 472);
+  assertEquals(m.a473, 473);
+  assertEquals(m.a474, 474);
+  assertEquals(m.a475, 475);
+  assertEquals(m.a476, 476);
+  assertEquals(m.a477, 477);
+  assertEquals(m.a478, 478);
+  assertEquals(m.a479, 479);
+  assertEquals(m.a480, 480);
+  assertEquals(m.a481, 481);
+  assertEquals(m.a482, 482);
+  assertEquals(m.a483, 483);
+  assertEquals(m.a484, 484);
+  assertEquals(m.a485, 485);
+  assertEquals(m.a486, 486);
+  assertEquals(m.a487, 487);
+  assertEquals(m.a488, 488);
+  assertEquals(m.a489, 489);
+  assertEquals(m.a490, 490);
+  assertEquals(m.a491, 491);
+  assertEquals(m.a492, 492);
+  assertEquals(m.a493, 493);
+  assertEquals(m.a494, 494);
+  assertEquals(m.a495, 495);
+  assertEquals(m.a496, 496);
+  assertEquals(m.a497, 497);
+  assertEquals(m.a498, 498);
+  assertEquals(m.a499, 499);
+  assertEquals(m.a500, 500);
+  assertEquals(m.a501, 501);
+  assertEquals(m.a502, 502);
+  assertEquals(m.a503, 503);
+  assertEquals(m.a504, 504);
+  assertEquals(m.a505, 505);
+  assertEquals(m.a506, 506);
+  assertEquals(m.a507, 507);
+  assertEquals(m.a508, 508);
+  assertEquals(m.a509, 509);
+  assertEquals(m.a510, 510);
+  assertEquals(m.a511, 511);
+  assertEquals(m.a512, 512);
+  assertEquals(m.a513, 513);
+  assertEquals(m.a514, 514);
+  assertEquals(m.a515, 515);
+  assertEquals(m.a516, 516);
+  assertEquals(m.a517, 517);
+  assertEquals(m.a518, 518);
+  assertEquals(m.a519, 519);
+  assertEquals(m.a520, 520);
+  assertEquals(m.a521, 521);
+  assertEquals(m.a522, 522);
+  assertEquals(m.a523, 523);
+  assertEquals(m.a524, 524);
+  assertEquals(m.a525, 525);
+  assertEquals(m.a526, 526);
+  assertEquals(m.a527, 527);
+  assertEquals(m.a528, 528);
+  assertEquals(m.a529, 529);
+  assertEquals(m.a530, 530);
+  assertEquals(m.a531, 531);
+  assertEquals(m.a532, 532);
+  assertEquals(m.a533, 533);
+  assertEquals(m.a534, 534);
+  assertEquals(m.a535, 535);
+  assertEquals(m.a536, 536);
+  assertEquals(m.a537, 537);
+  assertEquals(m.a538, 538);
+  assertEquals(m.a539, 539);
+  assertEquals(m.a540, 540);
+  assertEquals(m.a541, 541);
+  assertEquals(m.a542, 542);
+  assertEquals(m.a543, 543);
+  assertEquals(m.a544, 544);
+  assertEquals(m.a545, 545);
+  assertEquals(m.a546, 546);
+  assertEquals(m.a547, 547);
+  assertEquals(m.a548, 548);
+  assertEquals(m.a549, 549);
+  assertEquals(m.a550, 550);
+  assertEquals(m.a551, 551);
+  assertEquals(m.a552, 552);
+  assertEquals(m.a553, 553);
+  assertEquals(m.a554, 554);
+  assertEquals(m.a555, 555);
+  assertEquals(m.a556, 556);
+  assertEquals(m.a557, 557);
+  assertEquals(m.a558, 558);
+  assertEquals(m.a559, 559);
+  assertEquals(m.a560, 560);
+  assertEquals(m.a561, 561);
+  assertEquals(m.a562, 562);
+  assertEquals(m.a563, 563);
+  assertEquals(m.a564, 564);
+  assertEquals(m.a565, 565);
+  assertEquals(m.a566, 566);
+  assertEquals(m.a567, 567);
+  assertEquals(m.a568, 568);
+  assertEquals(m.a569, 569);
+  assertEquals(m.a570, 570);
+  assertEquals(m.a571, 571);
+  assertEquals(m.a572, 572);
+  assertEquals(m.a573, 573);
+  assertEquals(m.a574, 574);
+  assertEquals(m.a575, 575);
+  assertEquals(m.a576, 576);
+  assertEquals(m.a577, 577);
+  assertEquals(m.a578, 578);
+  assertEquals(m.a579, 579);
+  assertEquals(m.a580, 580);
+  assertEquals(m.a581, 581);
+  assertEquals(m.a582, 582);
+  assertEquals(m.a583, 583);
+  assertEquals(m.a584, 584);
+  assertEquals(m.a585, 585);
+  assertEquals(m.a586, 586);
+  assertEquals(m.a587, 587);
+  assertEquals(m.a588, 588);
+  assertEquals(m.a589, 589);
+  assertEquals(m.a590, 590);
+  assertEquals(m.a591, 591);
+  assertEquals(m.a592, 592);
+  assertEquals(m.a593, 593);
+  assertEquals(m.a594, 594);
+  assertEquals(m.a595, 595);
+  assertEquals(m.a596, 596);
+  assertEquals(m.a597, 597);
+  assertEquals(m.a598, 598);
+  assertEquals(m.a599, 599);
+  assertEquals(m.a600, 600);
+  assertEquals(m.a601, 601);
+  assertEquals(m.a602, 602);
+  assertEquals(m.a603, 603);
+  assertEquals(m.a604, 604);
+  assertEquals(m.a605, 605);
+  assertEquals(m.a606, 606);
+  assertEquals(m.a607, 607);
+  assertEquals(m.a608, 608);
+  assertEquals(m.a609, 609);
+  assertEquals(m.a610, 610);
+  assertEquals(m.a611, 611);
+  assertEquals(m.a612, 612);
+  assertEquals(m.a613, 613);
+  assertEquals(m.a614, 614);
+  assertEquals(m.a615, 615);
+  assertEquals(m.a616, 616);
+  assertEquals(m.a617, 617);
+  assertEquals(m.a618, 618);
+  assertEquals(m.a619, 619);
+  assertEquals(m.a620, 620);
+  assertEquals(m.a621, 621);
+  assertEquals(m.a622, 622);
+  assertEquals(m.a623, 623);
+  assertEquals(m.a624, 624);
+  assertEquals(m.a625, 625);
+  assertEquals(m.a626, 626);
+  assertEquals(m.a627, 627);
+  assertEquals(m.a628, 628);
+  assertEquals(m.a629, 629);
+  assertEquals(m.a630, 630);
+  assertEquals(m.a631, 631);
+  assertEquals(m.a632, 632);
+  assertEquals(m.a633, 633);
+  assertEquals(m.a634, 634);
+  assertEquals(m.a635, 635);
+  assertEquals(m.a636, 636);
+  assertEquals(m.a637, 637);
+  assertEquals(m.a638, 638);
+  assertEquals(m.a639, 639);
+  assertEquals(m.a640, 640);
+  assertEquals(m.a641, 641);
+  assertEquals(m.a642, 642);
+  assertEquals(m.a643, 643);
+  assertEquals(m.a644, 644);
+  assertEquals(m.a645, 645);
+  assertEquals(m.a646, 646);
+  assertEquals(m.a647, 647);
+  assertEquals(m.a648, 648);
+  assertEquals(m.a649, 649);
+  assertEquals(m.a650, 650);
+  assertEquals(m.a651, 651);
+  assertEquals(m.a652, 652);
+  assertEquals(m.a653, 653);
+  assertEquals(m.a654, 654);
+  assertEquals(m.a655, 655);
+  assertEquals(m.a656, 656);
+  assertEquals(m.a657, 657);
+  assertEquals(m.a658, 658);
+  assertEquals(m.a659, 659);
+  assertEquals(m.a660, 660);
+  assertEquals(m.a661, 661);
+  assertEquals(m.a662, 662);
+  assertEquals(m.a663, 663);
+  assertEquals(m.a664, 664);
+  assertEquals(m.a665, 665);
+  assertEquals(m.a666, 666);
+  assertEquals(m.a667, 667);
+  assertEquals(m.a668, 668);
+  assertEquals(m.a669, 669);
+  assertEquals(m.a670, 670);
+  assertEquals(m.a671, 671);
+  assertEquals(m.a672, 672);
+  assertEquals(m.a673, 673);
+  assertEquals(m.a674, 674);
+  assertEquals(m.a675, 675);
+  assertEquals(m.a676, 676);
+  assertEquals(m.a677, 677);
+  assertEquals(m.a678, 678);
+  assertEquals(m.a679, 679);
+  assertEquals(m.a680, 680);
+  assertEquals(m.a681, 681);
+  assertEquals(m.a682, 682);
+  assertEquals(m.a683, 683);
+  assertEquals(m.a684, 684);
+  assertEquals(m.a685, 685);
+  assertEquals(m.a686, 686);
+  assertEquals(m.a687, 687);
+  assertEquals(m.a688, 688);
+  assertEquals(m.a689, 689);
+  assertEquals(m.a690, 690);
+  assertEquals(m.a691, 691);
+  assertEquals(m.a692, 692);
+  assertEquals(m.a693, 693);
+  assertEquals(m.a694, 694);
+  assertEquals(m.a695, 695);
+  assertEquals(m.a696, 696);
+  assertEquals(m.a697, 697);
+  assertEquals(m.a698, 698);
+  assertEquals(m.a699, 699);
+  assertEquals(m.a700, 700);
+  assertEquals(m.a701, 701);
+  assertEquals(m.a702, 702);
+  assertEquals(m.a703, 703);
+  assertEquals(m.a704, 704);
+  assertEquals(m.a705, 705);
+  assertEquals(m.a706, 706);
+  assertEquals(m.a707, 707);
+  assertEquals(m.a708, 708);
+  assertEquals(m.a709, 709);
+  assertEquals(m.a710, 710);
+  assertEquals(m.a711, 711);
+  assertEquals(m.a712, 712);
+  assertEquals(m.a713, 713);
+  assertEquals(m.a714, 714);
+  assertEquals(m.a715, 715);
+  assertEquals(m.a716, 716);
+  assertEquals(m.a717, 717);
+  assertEquals(m.a718, 718);
+  assertEquals(m.a719, 719);
+  assertEquals(m.a720, 720);
+  assertEquals(m.a721, 721);
+  assertEquals(m.a722, 722);
+  assertEquals(m.a723, 723);
+  assertEquals(m.a724, 724);
+  assertEquals(m.a725, 725);
+  assertEquals(m.a726, 726);
+  assertEquals(m.a727, 727);
+  assertEquals(m.a728, 728);
+  assertEquals(m.a729, 729);
+  assertEquals(m.a730, 730);
+  assertEquals(m.a731, 731);
+  assertEquals(m.a732, 732);
+  assertEquals(m.a733, 733);
+  assertEquals(m.a734, 734);
+  assertEquals(m.a735, 735);
+  assertEquals(m.a736, 736);
+  assertEquals(m.a737, 737);
+  assertEquals(m.a738, 738);
+  assertEquals(m.a739, 739);
+  assertEquals(m.a740, 740);
+  assertEquals(m.a741, 741);
+  assertEquals(m.a742, 742);
+  assertEquals(m.a743, 743);
+  assertEquals(m.a744, 744);
+  assertEquals(m.a745, 745);
+  assertEquals(m.a746, 746);
+  assertEquals(m.a747, 747);
+  assertEquals(m.a748, 748);
+  assertEquals(m.a749, 749);
+  assertEquals(m.a750, 750);
+  assertEquals(m.a751, 751);
+  assertEquals(m.a752, 752);
+  assertEquals(m.a753, 753);
+  assertEquals(m.a754, 754);
+  assertEquals(m.a755, 755);
+  assertEquals(m.a756, 756);
+  assertEquals(m.a757, 757);
+  assertEquals(m.a758, 758);
+  assertEquals(m.a759, 759);
+  assertEquals(m.a760, 760);
+  assertEquals(m.a761, 761);
+  assertEquals(m.a762, 762);
+  assertEquals(m.a763, 763);
+  assertEquals(m.a764, 764);
+  assertEquals(m.a765, 765);
+  assertEquals(m.a766, 766);
+  assertEquals(m.a767, 767);
+  assertEquals(m.a768, 768);
+  assertEquals(m.a769, 769);
+  assertEquals(m.a770, 770);
+  assertEquals(m.a771, 771);
+  assertEquals(m.a772, 772);
+  assertEquals(m.a773, 773);
+  assertEquals(m.a774, 774);
+  assertEquals(m.a775, 775);
+  assertEquals(m.a776, 776);
+  assertEquals(m.a777, 777);
+  assertEquals(m.a778, 778);
+  assertEquals(m.a779, 779);
+  assertEquals(m.a780, 780);
+  assertEquals(m.a781, 781);
+  assertEquals(m.a782, 782);
+  assertEquals(m.a783, 783);
+  assertEquals(m.a784, 784);
+  assertEquals(m.a785, 785);
+  assertEquals(m.a786, 786);
+  assertEquals(m.a787, 787);
+  assertEquals(m.a788, 788);
+  assertEquals(m.a789, 789);
+  assertEquals(m.a790, 790);
+  assertEquals(m.a791, 791);
+  assertEquals(m.a792, 792);
+  assertEquals(m.a793, 793);
+  assertEquals(m.a794, 794);
+  assertEquals(m.a795, 795);
+  assertEquals(m.a796, 796);
+  assertEquals(m.a797, 797);
+  assertEquals(m.a798, 798);
+  assertEquals(m.a799, 799);
+  assertEquals(m.a800, 800);
+  assertEquals(m.a801, 801);
+  assertEquals(m.a802, 802);
+  assertEquals(m.a803, 803);
+  assertEquals(m.a804, 804);
+  assertEquals(m.a805, 805);
+  assertEquals(m.a806, 806);
+  assertEquals(m.a807, 807);
+  assertEquals(m.a808, 808);
+  assertEquals(m.a809, 809);
+  assertEquals(m.a810, 810);
+  assertEquals(m.a811, 811);
+  assertEquals(m.a812, 812);
+  assertEquals(m.a813, 813);
+  assertEquals(m.a814, 814);
+  assertEquals(m.a815, 815);
+  assertEquals(m.a816, 816);
+  assertEquals(m.a817, 817);
+  assertEquals(m.a818, 818);
+  assertEquals(m.a819, 819);
+  assertEquals(m.a820, 820);
+  assertEquals(m.a821, 821);
+  assertEquals(m.a822, 822);
+  assertEquals(m.a823, 823);
+  assertEquals(m.a824, 824);
+  assertEquals(m.a825, 825);
+  assertEquals(m.a826, 826);
+  assertEquals(m.a827, 827);
+  assertEquals(m.a828, 828);
+  assertEquals(m.a829, 829);
+  assertEquals(m.a830, 830);
+  assertEquals(m.a831, 831);
+  assertEquals(m.a832, 832);
+  assertEquals(m.a833, 833);
+  assertEquals(m.a834, 834);
+  assertEquals(m.a835, 835);
+  assertEquals(m.a836, 836);
+  assertEquals(m.a837, 837);
+  assertEquals(m.a838, 838);
+  assertEquals(m.a839, 839);
+  assertEquals(m.a840, 840);
+  assertEquals(m.a841, 841);
+  assertEquals(m.a842, 842);
+  assertEquals(m.a843, 843);
+  assertEquals(m.a844, 844);
+  assertEquals(m.a845, 845);
+  assertEquals(m.a846, 846);
+  assertEquals(m.a847, 847);
+  assertEquals(m.a848, 848);
+  assertEquals(m.a849, 849);
+  assertEquals(m.a850, 850);
+  assertEquals(m.a851, 851);
+  assertEquals(m.a852, 852);
+  assertEquals(m.a853, 853);
+  assertEquals(m.a854, 854);
+  assertEquals(m.a855, 855);
+  assertEquals(m.a856, 856);
+  assertEquals(m.a857, 857);
+  assertEquals(m.a858, 858);
+  assertEquals(m.a859, 859);
+  assertEquals(m.a860, 860);
+  assertEquals(m.a861, 861);
+  assertEquals(m.a862, 862);
+  assertEquals(m.a863, 863);
+  assertEquals(m.a864, 864);
+  assertEquals(m.a865, 865);
+  assertEquals(m.a866, 866);
+  assertEquals(m.a867, 867);
+  assertEquals(m.a868, 868);
+  assertEquals(m.a869, 869);
+  assertEquals(m.a870, 870);
+  assertEquals(m.a871, 871);
+  assertEquals(m.a872, 872);
+  assertEquals(m.a873, 873);
+  assertEquals(m.a874, 874);
+  assertEquals(m.a875, 875);
+  assertEquals(m.a876, 876);
+  assertEquals(m.a877, 877);
+  assertEquals(m.a878, 878);
+  assertEquals(m.a879, 879);
+  assertEquals(m.a880, 880);
+  assertEquals(m.a881, 881);
+  assertEquals(m.a882, 882);
+  assertEquals(m.a883, 883);
+  assertEquals(m.a884, 884);
+  assertEquals(m.a885, 885);
+  assertEquals(m.a886, 886);
+  assertEquals(m.a887, 887);
+  assertEquals(m.a888, 888);
+  assertEquals(m.a889, 889);
+  assertEquals(m.a890, 890);
+  assertEquals(m.a891, 891);
+  assertEquals(m.a892, 892);
+  assertEquals(m.a893, 893);
+  assertEquals(m.a894, 894);
+  assertEquals(m.a895, 895);
+  assertEquals(m.a896, 896);
+  assertEquals(m.a897, 897);
+  assertEquals(m.a898, 898);
+  assertEquals(m.a899, 899);
+  assertEquals(m.a900, 900);
+  assertEquals(m.a901, 901);
+  assertEquals(m.a902, 902);
+  assertEquals(m.a903, 903);
+  assertEquals(m.a904, 904);
+  assertEquals(m.a905, 905);
+  assertEquals(m.a906, 906);
+  assertEquals(m.a907, 907);
+  assertEquals(m.a908, 908);
+  assertEquals(m.a909, 909);
+  assertEquals(m.a910, 910);
+  assertEquals(m.a911, 911);
+  assertEquals(m.a912, 912);
+  assertEquals(m.a913, 913);
+  assertEquals(m.a914, 914);
+  assertEquals(m.a915, 915);
+  assertEquals(m.a916, 916);
+  assertEquals(m.a917, 917);
+  assertEquals(m.a918, 918);
+  assertEquals(m.a919, 919);
+  assertEquals(m.a920, 920);
+  assertEquals(m.a921, 921);
+  assertEquals(m.a922, 922);
+  assertEquals(m.a923, 923);
+  assertEquals(m.a924, 924);
+  assertEquals(m.a925, 925);
+  assertEquals(m.a926, 926);
+  assertEquals(m.a927, 927);
+  assertEquals(m.a928, 928);
+  assertEquals(m.a929, 929);
+  assertEquals(m.a930, 930);
+  assertEquals(m.a931, 931);
+  assertEquals(m.a932, 932);
+  assertEquals(m.a933, 933);
+  assertEquals(m.a934, 934);
+  assertEquals(m.a935, 935);
+  assertEquals(m.a936, 936);
+  assertEquals(m.a937, 937);
+  assertEquals(m.a938, 938);
+  assertEquals(m.a939, 939);
+  assertEquals(m.a940, 940);
+  assertEquals(m.a941, 941);
+  assertEquals(m.a942, 942);
+  assertEquals(m.a943, 943);
+  assertEquals(m.a944, 944);
+  assertEquals(m.a945, 945);
+  assertEquals(m.a946, 946);
+  assertEquals(m.a947, 947);
+  assertEquals(m.a948, 948);
+  assertEquals(m.a949, 949);
+  assertEquals(m.a950, 950);
+  assertEquals(m.a951, 951);
+  assertEquals(m.a952, 952);
+  assertEquals(m.a953, 953);
+  assertEquals(m.a954, 954);
+  assertEquals(m.a955, 955);
+  assertEquals(m.a956, 956);
+  assertEquals(m.a957, 957);
+  assertEquals(m.a958, 958);
+  assertEquals(m.a959, 959);
+  assertEquals(m.a960, 960);
+  assertEquals(m.a961, 961);
+  assertEquals(m.a962, 962);
+  assertEquals(m.a963, 963);
+  assertEquals(m.a964, 964);
+  assertEquals(m.a965, 965);
+  assertEquals(m.a966, 966);
+  assertEquals(m.a967, 967);
+  assertEquals(m.a968, 968);
+  assertEquals(m.a969, 969);
+  assertEquals(m.a970, 970);
+  assertEquals(m.a971, 971);
+  assertEquals(m.a972, 972);
+  assertEquals(m.a973, 973);
+  assertEquals(m.a974, 974);
+  assertEquals(m.a975, 975);
+  assertEquals(m.a976, 976);
+  assertEquals(m.a977, 977);
+  assertEquals(m.a978, 978);
+  assertEquals(m.a979, 979);
+  assertEquals(m.a980, 980);
+  assertEquals(m.a981, 981);
+  assertEquals(m.a982, 982);
+  assertEquals(m.a983, 983);
+  assertEquals(m.a984, 984);
+  assertEquals(m.a985, 985);
+  assertEquals(m.a986, 986);
+  assertEquals(m.a987, 987);
+  assertEquals(m.a988, 988);
+  assertEquals(m.a989, 989);
+  assertEquals(m.a990, 990);
+  assertEquals(m.a991, 991);
+  assertEquals(m.a992, 992);
+  assertEquals(m.a993, 993);
+  assertEquals(m.a994, 994);
+  assertEquals(m.a995, 995);
+  assertEquals(m.a996, 996);
+  assertEquals(m.a997, 997);
+  assertEquals(m.a998, 998);
+  assertEquals(m.a999, 999);
+  assertEquals(m.a1000, 1000);
+  assertEquals(m.a1001, 1001);
+  assertEquals(m.a1002, 1002);
+  assertEquals(m.a1003, 1003);
+  assertEquals(m.a1004, 1004);
+  assertEquals(m.a1005, 1005);
+  assertEquals(m.a1006, 1006);
+  assertEquals(m.a1007, 1007);
+  assertEquals(m.a1008, 1008);
+  assertEquals(m.a1009, 1009);
+  assertEquals(m.a1010, 1010);
+  assertEquals(m.a1011, 1011);
+  assertEquals(m.a1012, 1012);
+  assertEquals(m.a1013, 1013);
+  assertEquals(m.a1014, 1014);
+  assertEquals(m.a1015, 1015);
+  assertEquals(m.a1016, 1016);
+  assertEquals(m.a1017, 1017);
+  assertEquals(m.a1018, 1018);
+  assertEquals(m.a1019, 1019);
+  assertEquals(m.a1020, 1020);
+  assertEquals(m.a1021, 1021);
+  assertEquals(m.a1022, 1022);
+  assertEquals(m.a1023, 1023);
+  assertEquals(m.a1024, 1024);
+  assertEquals(m.a1025, 1025);
+  assertEquals(m.a1026, 1026);
+  assertEquals(m.a1027, 1027);
+  assertEquals(m.a1028, 1028);
+  assertEquals(m.a1029, 1029);
+  assertEquals(m.a1030, 1030);
+  assertEquals(m.a1031, 1031);
+  assertEquals(m.a1032, 1032);
+  assertEquals(m.a1033, 1033);
+  assertEquals(m.a1034, 1034);
+  assertEquals(m.a1035, 1035);
+  assertEquals(m.a1036, 1036);
+  assertEquals(m.a1037, 1037);
+  assertEquals(m.a1038, 1038);
+  assertEquals(m.a1039, 1039);
+  assertEquals(m.a1040, 1040);
+  assertEquals(m.a1041, 1041);
+  assertEquals(m.a1042, 1042);
+  assertEquals(m.a1043, 1043);
+  assertEquals(m.a1044, 1044);
+  assertEquals(m.a1045, 1045);
+  assertEquals(m.a1046, 1046);
+  assertEquals(m.a1047, 1047);
+  assertEquals(m.a1048, 1048);
+  assertEquals(m.a1049, 1049);
+  assertEquals(m.a1050, 1050);
+  assertEquals(m.a1051, 1051);
+  assertEquals(m.a1052, 1052);
+  assertEquals(m.a1053, 1053);
+  assertEquals(m.a1054, 1054);
+  assertEquals(m.a1055, 1055);
+  assertEquals(m.a1056, 1056);
+  assertEquals(m.a1057, 1057);
+  assertEquals(m.a1058, 1058);
+  assertEquals(m.a1059, 1059);
+  assertEquals(m.a1060, 1060);
+  assertEquals(m.a1061, 1061);
+  assertEquals(m.a1062, 1062);
+  assertEquals(m.a1063, 1063);
+  assertEquals(m.a1064, 1064);
+  assertEquals(m.a1065, 1065);
+  assertEquals(m.a1066, 1066);
+  assertEquals(m.a1067, 1067);
+  assertEquals(m.a1068, 1068);
+  assertEquals(m.a1069, 1069);
+  assertEquals(m.a1070, 1070);
+  assertEquals(m.a1071, 1071);
+  assertEquals(m.a1072, 1072);
+  assertEquals(m.a1073, 1073);
+  assertEquals(m.a1074, 1074);
+  assertEquals(m.a1075, 1075);
+  assertEquals(m.a1076, 1076);
+  assertEquals(m.a1077, 1077);
+  assertEquals(m.a1078, 1078);
+  assertEquals(m.a1079, 1079);
+  assertEquals(m.a1080, 1080);
+  assertEquals(m.a1081, 1081);
+  assertEquals(m.a1082, 1082);
+  assertEquals(m.a1083, 1083);
+  assertEquals(m.a1084, 1084);
+  assertEquals(m.a1085, 1085);
+  assertEquals(m.a1086, 1086);
+  assertEquals(m.a1087, 1087);
+  assertEquals(m.a1088, 1088);
+  assertEquals(m.a1089, 1089);
+  assertEquals(m.a1090, 1090);
+  assertEquals(m.a1091, 1091);
+  assertEquals(m.a1092, 1092);
+  assertEquals(m.a1093, 1093);
+  assertEquals(m.a1094, 1094);
+  assertEquals(m.a1095, 1095);
+  assertEquals(m.a1096, 1096);
+  assertEquals(m.a1097, 1097);
+  assertEquals(m.a1098, 1098);
+  assertEquals(m.a1099, 1099);
+}
+verify(m1);  // Uninitialized.
+verify(m1);  // Premonomorphic.
+verify(m2);  // Monomorphic.
diff --git a/deps/v8/test/mjsunit/harmony/modules-skip-large1.js b/deps/v8/test/mjsunit/harmony/modules-skip-large1.js
new file mode 100644
index 0000000000..e643df32a9
--- /dev/null
+++ b/deps/v8/test/mjsunit/harmony/modules-skip-large1.js
@@ -0,0 +1,2204 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export let a0 = 0;
+export let a1 = 1;
+export let a2 = 2;
+export let a3 = 3;
+export let a4 = 4;
+export let a5 = 5;
+export let a6 = 6;
+export let a7 = 7;
+export let a8 = 8;
+export let a9 = 9;
+export let a10 = 10;
+export let a11 = 11;
+export let a12 = 12;
+export let a13 = 13;
+export let a14 = 14;
+export let a15 = 15;
+export let a16 = 16;
+export let a17 = 17;
+export let a18 = 18;
+export let a19 = 19;
+export let a20 = 20;
+export let a21 = 21;
+export let a22 = 22;
+export let a23 = 23;
+export let a24 = 24;
+export let a25 = 25;
+export let a26 = 26;
+export let a27 = 27;
+export let a28 = 28;
+export let a29 = 29;
+export let a30 = 30;
+export let a31 = 31;
+export let a32 = 32;
+export let a33 = 33;
+export let a34 = 34;
+export let a35 = 35;
+export let a36 = 36;
+export let a37 = 37;
+export let a38 = 38;
+export let a39 = 39;
+export let a40 = 40;
+export let a41 = 41;
+export let a42 = 42;
+export let a43 = 43;
+export let a44 = 44;
+export let a45 = 45;
+export let a46 = 46;
+export let a47 = 47;
+export let a48 = 48;
+export let a49 = 49;
+export let a50 = 50;
+export let a51 = 51;
+export let a52 = 52;
+export let a53 = 53;
+export let a54 = 54;
+export let a55 = 55;
+export let a56 = 56;
+export let a57 = 57;
+export let a58 = 58;
+export let a59 = 59;
+export let a60 = 60;
+export let a61 = 61;
+export let a62 = 62;
+export let a63 = 63;
+export let a64 = 64;
+export let a65 = 65;
+export let a66 = 66;
+export let a67 = 67;
+export let a68 = 68;
+export let a69 = 69;
+export let a70 = 70;
+export let a71 = 71;
+export let a72 = 72;
+export let a73 = 73;
+export let a74 = 74;
+export let a75 = 75;
+export let a76 = 76;
+export let a77 = 77;
+export let a78 = 78;
+export let a79 = 79;
+export let a80 = 80;
+export let a81 = 81;
+export let a82 = 82;
+export let a83 = 83;
+export let a84 = 84;
+export let a85 = 85;
+export let a86 = 86;
+export let a87 = 87;
+export let a88 = 88;
+export let a89 = 89;
+export let a90 = 90;
+export let a91 = 91;
+export let a92 = 92;
+export let a93 = 93;
+export let a94 = 94;
+export let a95 = 95;
+export let a96 = 96;
+export let a97 = 97;
+export let a98 = 98;
+export let a99 = 99;
+export let a100 = 100;
+export let a101 = 101;
+export let a102 = 102;
+export let a103 = 103;
+export let a104 = 104;
+export let a105 = 105;
+export let a106 = 106;
+export let a107 = 107;
+export let a108 = 108;
+export let a109 = 109;
+export let a110 = 110;
+export let a111 = 111;
+export let a112 = 112;
+export let a113 = 113;
+export let a114 = 114;
+export let a115 = 115;
+export let a116 = 116;
+export let a117 = 117;
+export let a118 = 118;
+export let a119 = 119;
+export let a120 = 120;
+export let a121 = 121;
+export let a122 = 122;
+export let a123 = 123;
+export let a124 = 124;
+export let a125 = 125;
+export let a126 = 126;
+export let a127 = 127;
+export let a128 = 128;
+export let a129 = 129;
+export let a130 = 130;
+export let a131 = 131;
+export let a132 = 132;
+export let a133 = 133;
+export let a134 = 134;
+export let a135 = 135;
+export let a136 = 136;
+export let a137 = 137;
+export let a138 = 138;
+export let a139 = 139;
+export let a140 = 140;
+export let a141 = 141;
+export let a142 = 142;
+export let a143 = 143;
+export let a144 = 144;
+export let a145 = 145;
+export let a146 = 146;
+export let a147 = 147;
+export let a148 = 148;
+export let a149 = 149;
+export let a150 = 150;
+export let a151 = 151;
+export let a152 = 152;
+export let a153 = 153;
+export let a154 = 154;
+export let a155 = 155;
+export let a156 = 156;
+export let a157 = 157;
+export let a158 = 158;
+export let a159 = 159;
+export let a160 = 160;
+export let a161 = 161;
+export let a162 = 162;
+export let a163 = 163;
+export let a164 = 164;
+export let a165 = 165;
+export let a166 = 166;
+export let a167 = 167;
+export let a168 = 168;
+export let a169 = 169;
+export let a170 = 170;
+export let a171 = 171;
+export let a172 = 172;
+export let a173 = 173;
+export let a174 = 174;
+export let a175 = 175;
+export let a176 = 176;
+export let a177 = 177;
+export let a178 = 178;
+export let a179 = 179;
+export let a180 = 180;
+export let a181 = 181;
+export let a182 = 182;
+export let a183 = 183;
+export let a184 = 184;
+export let a185 = 185;
+export let a186 = 186;
+export let a187 = 187;
+export let a188 = 188;
+export let a189 = 189;
+export let a190 = 190;
+export let a191 = 191;
+export let a192 = 192;
+export let a193 = 193;
+export let a194 = 194;
+export let a195 = 195;
+export let a196 = 196;
+export let a197 = 197;
+export let a198 = 198;
+export let a199 = 199;
+export let a200 = 200;
+export let a201 = 201;
+export let a202 = 202;
+export let a203 = 203;
+export let a204 = 204;
+export let a205 = 205;
+export let a206 = 206;
+export let a207 = 207;
+export let a208 = 208;
+export let a209 = 209;
+export let a210 = 210;
+export let a211 = 211;
+export let a212 = 212;
+export let a213 = 213;
+export let a214 = 214;
+export let a215 = 215;
+export let a216 = 216;
+export let a217 = 217;
+export let a218 = 218;
+export let a219 = 219;
+export let a220 = 220;
+export let a221 = 221;
+export let a222 = 222;
+export let a223 = 223;
+export let a224 = 224;
+export let a225 = 225;
+export let a226 = 226;
+export let a227 = 227;
+export let a228 = 228;
+export let a229 = 229;
+export let a230 = 230;
+export let a231 = 231;
+export let a232 = 232;
+export let a233 = 233;
+export let a234 = 234;
+export let a235 = 235;
+export let a236 = 236;
+export let a237 = 237;
+export let a238 = 238;
+export let a239 = 239;
+export let a240 = 240;
+export let a241 = 241;
+export let a242 = 242;
+export let a243 = 243;
+export let a244 = 244;
+export let a245 = 245;
+export let a246 = 246;
+export let a247 = 247;
+export let a248 = 248;
+export let a249 = 249;
+export let a250 = 250;
+export let a251 = 251;
+export let a252 = 252;
+export let a253 = 253;
+export let a254 = 254;
+export let a255 = 255;
+export let a256 = 256;
+export let a257 = 257;
+export let a258 = 258;
+export let a259 = 259;
+export let a260 = 260;
+export let a261 = 261;
+export let a262 = 262;
+export let a263 = 263;
+export let a264 = 264;
+export let a265 = 265;
+export let a266 = 266;
+export let a267 = 267;
+export let a268 = 268;
+export let a269 = 269;
+export let a270 = 270;
+export let a271 = 271;
+export let a272 = 272;
+export let a273 = 273;
+export let a274 = 274;
+export let a275 = 275;
+export let a276 = 276;
+export let a277 = 277;
+export let a278 = 278;
+export let a279 = 279;
+export let a280 = 280;
+export let a281 = 281;
+export let a282 = 282;
+export let a283 = 283;
+export let a284 = 284;
+export let a285 = 285;
+export let a286 = 286;
+export let a287 = 287;
+export let a288 = 288;
+export let a289 = 289;
+export let a290 = 290;
+export let a291 = 291;
+export let a292 = 292;
+export let a293 = 293;
+export let a294 = 294;
+export let a295 = 295;
+export let a296 = 296;
+export let a297 = 297;
+export let a298 = 298;
+export let a299 = 299;
+export let a300 = 300;
+export let a301 = 301;
+export let a302 = 302;
+export let a303 = 303;
+export let a304 = 304;
+export let a305 = 305;
+export let a306 = 306;
+export let a307 = 307;
+export let a308 = 308;
+export let a309 = 309;
+export let a310 = 310;
+export let a311 = 311;
+export let a312 = 312;
+export let a313 = 313;
+export let a314 = 314;
+export let a315 = 315;
+export let a316 = 316;
+export let a317 = 317;
+export let a318 = 318;
+export let a319 = 319;
+export let a320 = 320;
+export let a321 = 321;
+export let a322 = 322;
+export let a323 = 323;
+export let a324 = 324;
+export let a325 = 325;
+export let a326 = 326;
+export let a327 = 327;
+export let a328 = 328;
+export let a329 = 329;
+export let a330 = 330;
+export let a331 = 331;
+export let a332 = 332;
+export let a333 = 333;
+export let a334 = 334;
+export let a335 = 335;
+export let a336 = 336;
+export let a337 = 337;
+export let a338 = 338;
+export let a339 = 339;
+export let a340 = 340;
+export let a341 = 341;
+export let a342 = 342;
+export let a343 = 343;
+export let a344 = 344;
+export let a345 = 345;
+export let a346 = 346;
+export let a347 = 347;
+export let a348 = 348;
+export let a349 = 349;
+export let a350 = 350;
+export let a351 = 351;
+export let a352 = 352;
+export let a353 = 353;
+export let a354 = 354;
+export let a355 = 355;
+export let a356 = 356;
+export let a357 = 357;
+export let a358 = 358;
+export let a359 = 359;
+export let a360 = 360;
+export let a361 = 361;
+export let a362 = 362;
+export let a363 = 363;
+export let a364 = 364;
+export let a365 = 365;
+export let a366 = 366;
+export let a367 = 367;
+export let a368 = 368;
+export let a369 = 369;
+export let a370 = 370;
+export let a371 = 371;
+export let a372 = 372;
+export let a373 = 373;
+export let a374 = 374;
+export let a375 = 375;
+export let a376 = 376;
+export let a377 = 377;
+export let a378 = 378;
+export let a379 = 379;
+export let a380 = 380;
+export let a381 = 381;
+export let a382 = 382;
+export let a383 = 383;
+export let a384 = 384;
+export let a385 = 385;
+export let a386 = 386;
+export let a387 = 387;
+export let a388 = 388;
+export let a389 = 389;
+export let a390 = 390;
+export let a391 = 391;
+export let a392 = 392;
+export let a393 = 393;
+export let a394 = 394;
+export let a395 = 395;
+export let a396 = 396;
+export let a397 = 397;
+export let a398 = 398;
+export let a399 = 399;
+export let a400 = 400;
+export let a401 = 401;
+export let a402 = 402;
+export let a403 = 403;
+export let a404 = 404;
+export let a405 = 405;
+export let a406 = 406;
+export let a407 = 407;
+export let a408 = 408;
+export let a409 = 409;
+export let a410 = 410;
+export let a411 = 411;
+export let a412 = 412;
+export let a413 = 413;
+export let a414 = 414;
+export let a415 = 415;
+export let a416 = 416;
+export let a417 = 417;
+export let a418 = 418;
+export let a419 = 419;
+export let a420 = 420;
+export let a421 = 421;
+export let a422 = 422;
+export let a423 = 423;
+export let a424 = 424;
+export let a425 = 425;
+export let a426 = 426;
+export let a427 = 427;
+export let a428 = 428;
+export let a429 = 429;
+export let a430 = 430;
+export let a431 = 431;
+export let a432 = 432;
+export let a433 = 433;
+export let a434 = 434;
+export let a435 = 435;
+export let a436 = 436;
+export let a437 = 437;
+export let a438 = 438;
+export let a439 = 439;
+export let a440 = 440;
+export let a441 = 441;
+export let a442 = 442;
+export let a443 = 443;
+export let a444 = 444;
+export let a445 = 445;
+export let a446 = 446;
+export let a447 = 447;
+export let a448 = 448;
+export let a449 = 449;
+export let a450 = 450;
+export let a451 = 451;
+export let a452 = 452;
+export let a453 = 453;
+export let a454 = 454;
+export let a455 = 455;
+export let a456 = 456;
+export let a457 = 457;
+export let a458 = 458;
+export let a459 = 459;
+export let a460 = 460;
+export let a461 = 461;
+export let a462 = 462;
+export let a463 = 463;
+export let a464 = 464;
+export let a465 = 465;
+export let a466 = 466;
+export let a467 = 467;
+export let a468 = 468;
+export let a469 = 469;
+export let a470 = 470;
+export let a471 = 471;
+export let a472 = 472;
+export let a473 = 473;
+export let a474 = 474;
+export let a475 = 475;
+export let a476 = 476;
+export let a477 = 477;
+export let a478 = 478;
+export let a479 = 479;
+export let a480 = 480;
+export let a481 = 481;
+export let a482 = 482;
+export let a483 = 483;
+export let a484 = 484;
+export let a485 = 485;
+export let a486 = 486;
+export let a487 = 487;
+export let a488 = 488;
+export let a489 = 489;
+export let a490 = 490;
+export let a491 = 491;
+export let a492 = 492;
+export let a493 = 493;
+export let a494 = 494;
+export let a495 = 495;
+export let a496 = 496;
+export let a497 = 497;
+export let a498 = 498;
+export let a499 = 499;
+export let a500 = 500;
+export let a501 = 501;
+export let a502 = 502;
+export let a503 = 503;
+export let a504 = 504;
+export let a505 = 505;
+export let a506 = 506;
+export let a507 = 507;
+export let a508 = 508;
+export let a509 = 509;
+export let a510 = 510;
+export let a511 = 511;
+export let a512 = 512;
+export let a513 = 513;
+export let a514 = 514;
+export let a515 = 515;
+export let a516 = 516;
+export let a517 = 517;
+export let a518 = 518;
+export let a519 = 519;
+export let a520 = 520;
+export let a521 = 521;
+export let a522 = 522;
+export let a523 = 523;
+export let a524 = 524;
+export let a525 = 525;
+export let a526 = 526;
+export let a527 = 527;
+export let a528 = 528;
+export let a529 = 529;
+export let a530 = 530;
+export let a531 = 531;
+export let a532 = 532;
+export let a533 = 533;
+export let a534 = 534;
+export let a535 = 535;
+export let a536 = 536;
+export let a537 = 537;
+export let a538 = 538;
+export let a539 = 539;
+export let a540 = 540;
+export let a541 = 541;
+export let a542 = 542;
+export let a543 = 543;
+export let a544 = 544;
+export let a545 = 545;
+export let a546 = 546;
+export let a547 = 547;
+export let a548 = 548;
+export let a549 = 549;
+export let a550 = 550;
+export let a551 = 551;
+export let a552 = 552;
+export let a553 = 553;
+export let a554 = 554;
+export let a555 = 555;
+export let a556 = 556;
+export let a557 = 557;
+export let a558 = 558;
+export let a559 = 559;
+export let a560 = 560;
+export let a561 = 561;
+export let a562 = 562;
+export let a563 = 563;
+export let a564 = 564;
+export let a565 = 565;
+export let a566 = 566;
+export let a567 = 567;
+export let a568 = 568;
+export let a569 = 569;
+export let a570 = 570;
+export let a571 = 571;
+export let a572 = 572;
+export let a573 = 573;
+export let a574 = 574;
+export let a575 = 575;
+export let a576 = 576;
+export let a577 = 577;
+export let a578 = 578;
+export let a579 = 579;
+export let a580 = 580;
+export let a581 = 581;
+export let a582 = 582;
+export let a583 = 583;
+export let a584 = 584;
+export let a585 = 585;
+export let a586 = 586;
+export let a587 = 587;
+export let a588 = 588;
+export let a589 = 589;
+export let a590 = 590;
+export let a591 = 591;
+export let a592 = 592;
+export let a593 = 593;
+export let a594 = 594;
+export let a595 = 595;
+export let a596 = 596;
+export let a597 = 597;
+export let a598 = 598;
+export let a599 = 599;
+export let a600 = 600;
+export let a601 = 601;
+export let a602 = 602;
+export let a603 = 603;
+export let a604 = 604;
+export let a605 = 605;
+export let a606 = 606;
+export let a607 = 607;
+export let a608 = 608;
+export let a609 = 609;
+export let a610 = 610;
+export let a611 = 611;
+export let a612 = 612;
+export let a613 = 613;
+export let a614 = 614;
+export let a615 = 615;
+export let a616 = 616;
+export let a617 = 617;
+export let a618 = 618;
+export let a619 = 619;
+export let a620 = 620;
+export let a621 = 621;
+export let a622 = 622;
+export let a623 = 623;
+export let a624 = 624;
+export let a625 = 625;
+export let a626 = 626;
+export let a627 = 627;
+export let a628 = 628;
+export let a629 = 629;
+export let a630 = 630;
+export let a631 = 631;
+export let a632 = 632;
+export let a633 = 633;
+export let a634 = 634;
+export let a635 = 635;
+export let a636 = 636;
+export let a637 = 637;
+export let a638 = 638;
+export let a639 = 639;
+export let a640 = 640;
+export let a641 = 641;
+export let a642 = 642;
+export let a643 = 643;
+export let a644 = 644;
+export let a645 = 645;
+export let a646 = 646;
+export let a647 = 647;
+export let a648 = 648;
+export let a649 = 649;
+export let a650 = 650;
+export let a651 = 651;
+export let a652 = 652;
+export let a653 = 653;
+export let a654 = 654;
+export let a655 = 655;
+export let a656 = 656;
+export let a657 = 657;
+export let a658 = 658;
+export let a659 = 659;
+export let a660 = 660;
+export let a661 = 661;
+export let a662 = 662;
+export let a663 = 663;
+export let a664 = 664;
+export let a665 = 665;
+export let a666 = 666;
+export let a667 = 667;
+export let a668 = 668;
+export let a669 = 669;
+export let a670 = 670;
+export let a671 = 671;
+export let a672 = 672;
+export let a673 = 673;
+export let a674 = 674;
+export let a675 = 675;
+export let a676 = 676;
+export let a677 = 677;
+export let a678 = 678;
+export let a679 = 679;
+export let a680 = 680;
+export let a681 = 681;
+export let a682 = 682;
+export let a683 = 683;
+export let a684 = 684;
+export let a685 = 685;
+export let a686 = 686;
+export let a687 = 687;
+export let a688 = 688;
+export let a689 = 689;
+export let a690 = 690;
+export let a691 = 691;
+export let a692 = 692;
+export let a693 = 693;
+export let a694 = 694;
+export let a695 = 695;
+export let a696 = 696;
+export let a697 = 697;
+export let a698 = 698;
+export let a699 = 699;
+export let a700 = 700;
+export let a701 = 701;
+export let a702 = 702;
+export let a703 = 703;
+export let a704 = 704;
+export let a705 = 705;
+export let a706 = 706;
+export let a707 = 707;
+export let a708 = 708;
+export let a709 = 709;
+export let a710 = 710;
+export let a711 = 711;
+export let a712 = 712;
+export let a713 = 713;
+export let a714 = 714;
+export let a715 = 715;
+export let a716 = 716;
+export let a717 = 717;
+export let a718 = 718;
+export let a719 = 719;
+export let a720 = 720;
+export let a721 = 721;
+export let a722 = 722;
+export let a723 = 723;
+export let a724 = 724;
+export let a725 = 725;
+export let a726 = 726;
+export let a727 = 727;
+export let a728 = 728;
+export let a729 = 729;
+export let a730 = 730;
+export let a731 = 731;
+export let a732 = 732;
+export let a733 = 733;
+export let a734 = 734;
+export let a735 = 735;
+export let a736 = 736;
+export let a737 = 737;
+export let a738 = 738;
+export let a739 = 739;
+export let a740 = 740;
+export let a741 = 741;
+export let a742 = 742;
+export let a743 = 743;
+export let a744 = 744;
+export let a745 = 745;
+export let a746 = 746;
+export let a747 = 747;
+export let a748 = 748;
+export let a749 = 749;
+export let a750 = 750;
+export let a751 = 751;
+export let a752 = 752;
+export let a753 = 753;
+export let a754 = 754;
+export let a755 = 755;
+export let a756 = 756;
+export let a757 = 757;
+export let a758 = 758;
+export let a759 = 759;
+export let a760 = 760;
+export let a761 = 761;
+export let a762 = 762;
+export let a763 = 763;
+export let a764 = 764;
+export let a765 = 765;
+export let a766 = 766;
+export let a767 = 767;
+export let a768 = 768;
+export let a769 = 769;
+export let a770 = 770;
+export let a771 = 771;
+export let a772 = 772;
+export let a773 = 773;
+export let a774 = 774;
+export let a775 = 775;
+export let a776 = 776;
+export let a777 = 777;
+export let a778 = 778;
+export let a779 = 779;
+export let a780 = 780;
+export let a781 = 781;
+export let a782 = 782;
+export let a783 = 783;
+export let a784 = 784;
+export let a785 = 785;
+export let a786 = 786;
+export let a787 = 787;
+export let a788 = 788;
+export let a789 = 789;
+export let a790 = 790;
+export let a791 = 791;
+export let a792 = 792;
+export let a793 = 793;
+export let a794 = 794;
+export let a795 = 795;
+export let a796 = 796;
+export let a797 = 797;
+export let a798 = 798;
+export let a799 = 799;
+export let a800 = 800;
+export let a801 = 801;
+export let a802 = 802;
+export let a803 = 803;
+export let a804 = 804;
+export let a805 = 805;
+export let a806 = 806;
+export let a807 = 807;
+export let a808 = 808;
+export let a809 = 809;
+export let a810 = 810;
+export let a811 = 811;
+export let a812 = 812;
+export let a813 = 813;
+export let a814 = 814;
+export let a815 = 815;
+export let a816 = 816;
+export let a817 = 817;
+export let a818 = 818;
+export let a819 = 819;
+export let a820 = 820;
+export let a821 = 821;
+export let a822 = 822;
+export let a823 = 823;
+export let a824 = 824;
+export let a825 = 825;
+export let a826 = 826;
+export let a827 = 827;
+export let a828 = 828;
+export let a829 = 829;
+export let a830 = 830;
+export let a831 = 831;
+export let a832 = 832;
+export let a833 = 833;
+export let a834 = 834;
+export let a835 = 835;
+export let a836 = 836;
+export let a837 = 837;
+export let a838 = 838;
+export let a839 = 839;
+export let a840 = 840;
+export let a841 = 841;
+export let a842 = 842;
+export let a843 = 843;
+export let a844 = 844;
+export let a845 = 845;
+export let a846 = 846;
+export let a847 = 847;
+export let a848 = 848;
+export let a849 = 849;
+export let a850 = 850;
+export let a851 = 851;
+export let a852 = 852;
+export let a853 = 853;
+export let a854 = 854;
+export let a855 = 855;
+export let a856 = 856;
+export let a857 = 857;
+export let a858 = 858;
+export let a859 = 859;
+export let a860 = 860;
+export let a861 = 861;
+export let a862 = 862;
+export let a863 = 863;
+export let a864 = 864;
+export let a865 = 865;
+export let a866 = 866;
+export let a867 = 867;
+export let a868 = 868;
+export let a869 = 869;
+export let a870 = 870;
+export let a871 = 871;
+export let a872 = 872;
+export let a873 = 873;
+export let a874 = 874;
+export let a875 = 875;
+export let a876 = 876;
+export let a877 = 877;
+export let a878 = 878;
+export let a879 = 879;
+export let a880 = 880;
+export let a881 = 881;
+export let a882 = 882;
+export let a883 = 883;
+export let a884 = 884;
+export let a885 = 885;
+export let a886 = 886;
+export let a887 = 887;
+export let a888 = 888;
+export let a889 = 889;
+export let a890 = 890;
+export let a891 = 891;
+export let a892 = 892;
+export let a893 = 893;
+export let a894 = 894;
+export let a895 = 895;
+export let a896 = 896;
+export let a897 = 897;
+export let a898 = 898;
+export let a899 = 899;
+export let a900 = 900;
+export let a901 = 901;
+export let a902 = 902;
+export let a903 = 903;
+export let a904 = 904;
+export let a905 = 905;
+export let a906 = 906;
+export let a907 = 907;
+export let a908 = 908;
+export let a909 = 909;
+export let a910 = 910;
+export let a911 = 911;
+export let a912 = 912;
+export let a913 = 913;
+export let a914 = 914;
+export let a915 = 915;
+export let a916 = 916;
+export let a917 = 917;
+export let a918 = 918;
+export let a919 = 919;
+export let a920 = 920;
+export let a921 = 921;
+export let a922 = 922;
+export let a923 = 923;
+export let a924 = 924;
+export let a925 = 925;
+export let a926 = 926;
+export let a927 = 927;
+export let a928 = 928;
+export let a929 = 929;
+export let a930 = 930;
+export let a931 = 931;
+export let a932 = 932;
+export let a933 = 933;
+export let a934 = 934;
+export let a935 = 935;
+export let a936 = 936;
+export let a937 = 937;
+export let a938 = 938;
+export let a939 = 939;
+export let a940 = 940;
+export let a941 = 941;
+export let a942 = 942;
+export let a943 = 943;
+export let a944 = 944;
+export let a945 = 945;
+export let a946 = 946;
+export let a947 = 947;
+export let a948 = 948;
+export let a949 = 949;
+export let a950 = 950;
+export let a951 = 951;
+export let a952 = 952;
+export let a953 = 953;
+export let a954 = 954;
+export let a955 = 955;
+export let a956 = 956;
+export let a957 = 957;
+export let a958 = 958;
+export let a959 = 959;
+export let a960 = 960;
+export let a961 = 961;
+export let a962 = 962;
+export let a963 = 963;
+export let a964 = 964;
+export let a965 = 965;
+export let a966 = 966;
+export let a967 = 967;
+export let a968 = 968;
+export let a969 = 969;
+export let a970 = 970;
+export let a971 = 971;
+export let a972 = 972;
+export let a973 = 973;
+export let a974 = 974;
+export let a975 = 975;
+export let a976 = 976;
+export let a977 = 977;
+export let a978 = 978;
+export let a979 = 979;
+export let a980 = 980;
+export let a981 = 981;
+export let a982 = 982;
+export let a983 = 983;
+export let a984 = 984;
+export let a985 = 985;
+export let a986 = 986;
+export let a987 = 987;
+export let a988 = 988;
+export let a989 = 989;
+export let a990 = 990;
+export let a991 = 991;
+export let a992 = 992;
+export let a993 = 993;
+export let a994 = 994;
+export let a995 = 995;
+export let a996 = 996;
+export let a997 = 997;
+export let a998 = 998;
+export let a999 = 999;
+export let a1000 = 1000;
+export let a1001 = 1001;
+export let a1002 = 1002;
+export let a1003 = 1003;
+export let a1004 = 1004;
+export let a1005 = 1005;
+export let a1006 = 1006;
+export let a1007 = 1007;
+export let a1008 = 1008;
+export let a1009 = 1009;
+export let a1010 = 1010;
+export let a1011 = 1011;
+export let a1012 = 1012;
+export let a1013 = 1013;
+export let a1014 = 1014;
+export let a1015 = 1015;
+export let a1016 = 1016;
+export let a1017 = 1017;
+export let a1018 = 1018;
+export let a1019 = 1019;
+export let a1020 = 1020;
+export let a1021 = 1021;
+export let a1022 = 1022;
+export let a1023 = 1023;
+export let a1024 = 1024;
+export let a1025 = 1025;
+export let a1026 = 1026;
+export let a1027 = 1027;
+export let a1028 = 1028;
+export let a1029 = 1029;
+export let a1030 = 1030;
+export let a1031 = 1031;
+export let a1032 = 1032;
+export let a1033 = 1033;
+export let a1034 = 1034;
+export let a1035 = 1035;
+export let a1036 = 1036;
+export let a1037 = 1037;
+export let a1038 = 1038;
+export let a1039 = 1039;
+export let a1040 = 1040;
+export let a1041 = 1041;
+export let a1042 = 1042;
+export let a1043 = 1043;
+export let a1044 = 1044;
+export let a1045 = 1045;
+export let a1046 = 1046;
+export let a1047 = 1047;
+export let a1048 = 1048;
+export let a1049 = 1049;
+export let a1050 = 1050;
+export let a1051 = 1051;
+export let a1052 = 1052;
+export let a1053 = 1053;
+export let a1054 = 1054;
+export let a1055 = 1055;
+export let a1056 = 1056;
+export let a1057 = 1057;
+export let a1058 = 1058;
+export let a1059 = 1059;
+export let a1060 = 1060;
+export let a1061 = 1061;
+export let a1062 = 1062;
+export let a1063 = 1063;
+export let a1064 = 1064;
+export let a1065 = 1065;
+export let a1066 = 1066;
+export let a1067 = 1067;
+export let a1068 = 1068;
+export let a1069 = 1069;
+export let a1070 = 1070;
+export let a1071 = 1071;
+export let a1072 = 1072;
+export let a1073 = 1073;
+export let a1074 = 1074;
+export let a1075 = 1075;
+export let a1076 = 1076;
+export let a1077 = 1077;
+export let a1078 = 1078;
+export let a1079 = 1079;
+export let a1080 = 1080;
+export let a1081 = 1081;
+export let a1082 = 1082;
+export let a1083 = 1083;
+export let a1084 = 1084;
+export let a1085 = 1085;
+export let a1086 = 1086;
+export let a1087 = 1087;
+export let a1088 = 1088;
+export let a1089 = 1089;
+export let a1090 = 1090;
+export let a1091 = 1091;
+export let a1092 = 1092;
+export let a1093 = 1093;
+export let a1094 = 1094;
+export let a1095 = 1095;
+export let a1096 = 1096;
+export let a1097 = 1097;
+export let a1098 = 1098;
+export let a1099 = 1099;
+export let a1100 = 1100;
+export let a1101 = 1101;
+export let a1102 = 1102;
+export let a1103 = 1103;
+export let a1104 = 1104;
+export let a1105 = 1105;
+export let a1106 = 1106;
+export let a1107 = 1107;
+export let a1108 = 1108;
+export let a1109 = 1109;
+export let a1110 = 1110;
+export let a1111 = 1111;
+export let a1112 = 1112;
+export let a1113 = 1113;
+export let a1114 = 1114;
+export let a1115 = 1115;
+export let a1116 = 1116;
+export let a1117 = 1117;
+export let a1118 = 1118;
+export let a1119 = 1119;
+export let a1120 = 1120;
+export let a1121 = 1121;
+export let a1122 = 1122;
+export let a1123 = 1123;
+export let a1124 = 1124;
+export let a1125 = 1125;
+export let a1126 = 1126;
+export let a1127 = 1127;
+export let a1128 = 1128;
+export let a1129 = 1129;
+export let a1130 = 1130;
+export let a1131 = 1131;
+export let a1132 = 1132;
+export let a1133 = 1133;
+export let a1134 = 1134;
+export let a1135 = 1135;
+export let a1136 = 1136;
+export let a1137 = 1137;
+export let a1138 = 1138;
+export let a1139 = 1139;
+export let a1140 = 1140;
+export let a1141 = 1141;
+export let a1142 = 1142;
+export let a1143 = 1143;
+export let a1144 = 1144;
+export let a1145 = 1145;
+export let a1146 = 1146;
+export let a1147 = 1147;
+export let a1148 = 1148;
+export let a1149 = 1149;
+export let a1150 = 1150;
+export let a1151 = 1151;
+export let a1152 = 1152;
+export let a1153 = 1153;
+export let a1154 = 1154;
+export let a1155 = 1155;
+export let a1156 = 1156;
+export let a1157 = 1157;
+export let a1158 = 1158;
+export let a1159 = 1159;
+export let a1160 = 1160;
+export let a1161 = 1161;
+export let a1162 = 1162;
+export let a1163 = 1163;
+export let a1164 = 1164;
+export let a1165 = 1165;
+export let a1166 = 1166;
+export let a1167 = 1167;
+export let a1168 = 1168;
+export let a1169 = 1169;
+export let a1170 = 1170;
+export let a1171 = 1171;
+export let a1172 = 1172;
+export let a1173 = 1173;
+export let a1174 = 1174;
+export let a1175 = 1175;
+export let a1176 = 1176;
+export let a1177 = 1177;
+export let a1178 = 1178;
+export let a1179 = 1179;
+export let a1180 = 1180;
+export let a1181 = 1181;
+export let a1182 = 1182;
+export let a1183 = 1183;
+export let a1184 = 1184;
+export let a1185 = 1185;
+export let a1186 = 1186;
+export let a1187 = 1187;
+export let a1188 = 1188;
+export let a1189 = 1189;
+export let a1190 = 1190;
+export let a1191 = 1191;
+export let a1192 = 1192;
+export let a1193 = 1193;
+export let a1194 = 1194;
+export let a1195 = 1195;
+export let a1196 = 1196;
+export let a1197 = 1197;
+export let a1198 = 1198;
+export let a1199 = 1199;
+export let a1200 = 1200;
+export let a1201 = 1201;
+export let a1202 = 1202;
+export let a1203 = 1203;
+export let a1204 = 1204;
+export let a1205 = 1205;
+export let a1206 = 1206;
+export let a1207 = 1207;
+export let a1208 = 1208;
+export let a1209 = 1209;
+export let a1210 = 1210;
+export let a1211 = 1211;
+export let a1212 = 1212;
+export let a1213 = 1213;
+export let a1214 = 1214;
+export let a1215 = 1215;
+export let a1216 = 1216;
+export let a1217 = 1217;
+export let a1218 = 1218;
+export let a1219 = 1219;
+export let a1220 = 1220;
+export let a1221 = 1221;
+export let a1222 = 1222;
+export let a1223 = 1223;
+export let a1224 = 1224;
+export let a1225 = 1225;
+export let a1226 = 1226;
+export let a1227 = 1227;
+export let a1228 = 1228;
+export let a1229 = 1229;
+export let a1230 = 1230;
+export let a1231 = 1231;
+export let a1232 = 1232;
+export let a1233 = 1233;
+export let a1234 = 1234;
+export let a1235 = 1235;
+export let a1236 = 1236;
+export let a1237 = 1237;
+export let a1238 = 1238;
+export let a1239 = 1239;
+export let a1240 = 1240;
+export let a1241 = 1241;
+export let a1242 = 1242;
+export let a1243 = 1243;
+export let a1244 = 1244;
+export let a1245 = 1245;
+export let a1246 = 1246;
+export let a1247 = 1247;
+export let a1248 = 1248;
+export let a1249 = 1249;
+export let a1250 = 1250;
+export let a1251 = 1251;
+export let a1252 = 1252;
+export let a1253 = 1253;
+export let a1254 = 1254;
+export let a1255 = 1255;
+export let a1256 = 1256;
+export let a1257 = 1257;
+export let a1258 = 1258;
+export let a1259 = 1259;
+export let a1260 = 1260;
+export let a1261 = 1261;
+export let a1262 = 1262;
+export let a1263 = 1263;
+export let a1264 = 1264;
+export let a1265 = 1265;
+export let a1266 = 1266;
+export let a1267 = 1267;
+export let a1268 = 1268;
+export let a1269 = 1269;
+export let a1270 = 1270;
+export let a1271 = 1271;
+export let a1272 = 1272;
+export let a1273 = 1273;
+export let a1274 = 1274;
+export let a1275 = 1275;
+export let a1276 = 1276;
+export let a1277 = 1277;
+export let a1278 = 1278;
+export let a1279 = 1279;
+export let a1280 = 1280;
+export let a1281 = 1281;
+export let a1282 = 1282;
+export let a1283 = 1283;
+export let a1284 = 1284;
+export let a1285 = 1285;
+export let a1286 = 1286;
+export let a1287 = 1287;
+export let a1288 = 1288;
+export let a1289 = 1289;
+export let a1290 = 1290;
+export let a1291 = 1291;
+export let a1292 = 1292;
+export let a1293 = 1293;
+export let a1294 = 1294;
+export let a1295 = 1295;
+export let a1296 = 1296;
+export let a1297 = 1297;
+export let a1298 = 1298;
+export let a1299 = 1299;
+export let a1300 = 1300;
+export let a1301 = 1301;
+export let a1302 = 1302;
+export let a1303 = 1303;
+export let a1304 = 1304;
+export let a1305 = 1305;
+export let a1306 = 1306;
+export let a1307 = 1307;
+export let a1308 = 1308;
+export let a1309 = 1309;
+export let a1310 = 1310;
+export let a1311 = 1311;
+export let a1312 = 1312;
+export let a1313 = 1313;
+export let a1314 = 1314;
+export let a1315 = 1315;
+export let a1316 = 1316;
+export let a1317 = 1317;
+export let a1318 = 1318;
+export let a1319 = 1319;
+export let a1320 = 1320;
+export let a1321 = 1321;
+export let a1322 = 1322;
+export let a1323 = 1323;
+export let a1324 = 1324;
+export let a1325 = 1325;
+export let a1326 = 1326;
+export let a1327 = 1327;
+export let a1328 = 1328;
+export let a1329 = 1329;
+export let a1330 = 1330;
+export let a1331 = 1331;
+export let a1332 = 1332;
+export let a1333 = 1333;
+export let a1334 = 1334;
+export let a1335 = 1335;
+export let a1336 = 1336;
+export let a1337 = 1337;
+export let a1338 = 1338;
+export let a1339 = 1339;
+export let a1340 = 1340;
+export let a1341 = 1341;
+export let a1342 = 1342;
+export let a1343 = 1343;
+export let a1344 = 1344;
+export let a1345 = 1345;
+export let a1346 = 1346;
+export let a1347 = 1347;
+export let a1348 = 1348;
+export let a1349 = 1349;
+export let a1350 = 1350;
+export let a1351 = 1351;
+export let a1352 = 1352;
+export let a1353 = 1353;
+export let a1354 = 1354;
+export let a1355 = 1355;
+export let a1356 = 1356;
+export let a1357 = 1357;
+export let a1358 = 1358;
+export let a1359 = 1359;
+export let a1360 = 1360;
+export let a1361 = 1361;
+export let a1362 = 1362;
+export let a1363 = 1363;
+export let a1364 = 1364;
+export let a1365 = 1365;
+export let a1366 = 1366;
+export let a1367 = 1367;
+export let a1368 = 1368;
+export let a1369 = 1369;
+export let a1370 = 1370;
+export let a1371 = 1371;
+export let a1372 = 1372;
+export let a1373 = 1373;
+export let a1374 = 1374;
+export let a1375 = 1375;
+export let a1376 = 1376;
+export let a1377 = 1377;
+export let a1378 = 1378;
+export let a1379 = 1379;
+export let a1380 = 1380;
+export let a1381 = 1381;
+export let a1382 = 1382;
+export let a1383 = 1383;
+export let a1384 = 1384;
+export let a1385 = 1385;
+export let a1386 = 1386;
+export let a1387 = 1387;
+export let a1388 = 1388;
+export let a1389 = 1389;
+export let a1390 = 1390;
+export let a1391 = 1391;
+export let a1392 = 1392;
+export let a1393 = 1393;
+export let a1394 = 1394;
+export let a1395 = 1395;
+export let a1396 = 1396;
+export let a1397 = 1397;
+export let a1398 = 1398;
+export let a1399 = 1399;
+export let a1400 = 1400;
+export let a1401 = 1401;
+export let a1402 = 1402;
+export let a1403 = 1403;
+export let a1404 = 1404;
+export let a1405 = 1405;
+export let a1406 = 1406;
+export let a1407 = 1407;
+export let a1408 = 1408;
+export let a1409 = 1409;
+export let a1410 = 1410;
+export let a1411 = 1411;
+export let a1412 = 1412;
+export let a1413 = 1413;
+export let a1414 = 1414;
+export let a1415 = 1415;
+export let a1416 = 1416;
+export let a1417 = 1417;
+export let a1418 = 1418;
+export let a1419 = 1419;
+export let a1420 = 1420;
+export let a1421 = 1421;
+export let a1422 = 1422;
+export let a1423 = 1423;
+export let a1424 = 1424;
+export let a1425 = 1425;
+export let a1426 = 1426;
+export let a1427 = 1427;
+export let a1428 = 1428;
+export let a1429 = 1429;
+export let a1430 = 1430;
+export let a1431 = 1431;
+export let a1432 = 1432;
+export let a1433 = 1433;
+export let a1434 = 1434;
+export let a1435 = 1435;
+export let a1436 = 1436;
+export let a1437 = 1437;
+export let a1438 = 1438;
+export let a1439 = 1439;
+export let a1440 = 1440;
+export let a1441 = 1441;
+export let a1442 = 1442;
+export let a1443 = 1443;
+export let a1444 = 1444;
+export let a1445 = 1445;
+export let a1446 = 1446;
+export let a1447 = 1447;
+export let a1448 = 1448;
+export let a1449 = 1449;
+export let a1450 = 1450;
+export let a1451 = 1451;
+export let a1452 = 1452;
+export let a1453 = 1453;
+export let a1454 = 1454;
+export let a1455 = 1455;
+export let a1456 = 1456;
+export let a1457 = 1457;
+export let a1458 = 1458;
+export let a1459 = 1459;
+export let a1460 = 1460;
+export let a1461 = 1461;
+export let a1462 = 1462;
+export let a1463 = 1463;
+export let a1464 = 1464;
+export let a1465 = 1465;
+export let a1466 = 1466;
+export let a1467 = 1467;
+export let a1468 = 1468;
+export let a1469 = 1469;
+export let a1470 = 1470;
+export let a1471 = 1471;
+export let a1472 = 1472;
+export let a1473 = 1473;
+export let a1474 = 1474;
+export let a1475 = 1475;
+export let a1476 = 1476;
+export let a1477 = 1477;
+export let a1478 = 1478;
+export let a1479 = 1479;
+export let a1480 = 1480;
+export let a1481 = 1481;
+export let a1482 = 1482;
+export let a1483 = 1483;
+export let a1484 = 1484;
+export let a1485 = 1485;
+export let a1486 = 1486;
+export let a1487 = 1487;
+export let a1488 = 1488;
+export let a1489 = 1489;
+export let a1490 = 1490;
+export let a1491 = 1491;
+export let a1492 = 1492;
+export let a1493 = 1493;
+export let a1494 = 1494;
+export let a1495 = 1495;
+export let a1496 = 1496;
+export let a1497 = 1497;
+export let a1498 = 1498;
+export let a1499 = 1499;
+export let a1500 = 1500;
+export let a1501 = 1501;
+export let a1502 = 1502;
+export let a1503 = 1503;
+export let a1504 = 1504;
+export let a1505 = 1505;
+export let a1506 = 1506;
+export let a1507 = 1507;
+export let a1508 = 1508;
+export let a1509 = 1509;
+export let a1510 = 1510;
+export let a1511 = 1511;
+export let a1512 = 1512;
+export let a1513 = 1513;
+export let a1514 = 1514;
+export let a1515 = 1515;
+export let a1516 = 1516;
+export let a1517 = 1517;
+export let a1518 = 1518;
+export let a1519 = 1519;
+export let a1520 = 1520;
+export let a1521 = 1521;
+export let a1522 = 1522;
+export let a1523 = 1523;
+export let a1524 = 1524;
+export let a1525 = 1525;
+export let a1526 = 1526;
+export let a1527 = 1527;
+export let a1528 = 1528;
+export let a1529 = 1529;
+export let a1530 = 1530;
+export let a1531 = 1531;
+export let a1532 = 1532;
+export let a1533 = 1533;
+export let a1534 = 1534;
+export let a1535 = 1535;
+export let a1536 = 1536;
+export let a1537 = 1537;
+export let a1538 = 1538;
+export let a1539 = 1539;
+export let a1540 = 1540;
+export let a1541 = 1541;
+export let a1542 = 1542;
+export let a1543 = 1543;
+export let a1544 = 1544;
+export let a1545 = 1545;
+export let a1546 = 1546;
+export let a1547 = 1547;
+export let a1548 = 1548;
+export let a1549 = 1549;
+export let a1550 = 1550;
+export let a1551 = 1551;
+export let a1552 = 1552;
+export let a1553 = 1553;
+export let a1554 = 1554;
+export let a1555 = 1555;
+export let a1556 = 1556;
+export let a1557 = 1557;
+export let a1558 = 1558;
+export let a1559 = 1559;
+export let a1560 = 1560;
+export let a1561 = 1561;
+export let a1562 = 1562;
+export let a1563 = 1563;
+export let a1564 = 1564;
+export let a1565 = 1565;
+export let a1566 = 1566;
+export let a1567 = 1567;
+export let a1568 = 1568;
+export let a1569 = 1569;
+export let a1570 = 1570;
+export let a1571 = 1571;
+export let a1572 = 1572;
+export let a1573 = 1573;
+export let a1574 = 1574;
+export let a1575 = 1575;
+export let a1576 = 1576;
+export let a1577 = 1577;
+export let a1578 = 1578;
+export let a1579 = 1579;
+export let a1580 = 1580;
+export let a1581 = 1581;
+export let a1582 = 1582;
+export let a1583 = 1583;
+export let a1584 = 1584;
+export let a1585 = 1585;
+export let a1586 = 1586;
+export let a1587 = 1587;
+export let a1588 = 1588;
+export let a1589 = 1589;
+export let a1590 = 1590;
+export let a1591 = 1591;
+export let a1592 = 1592;
+export let a1593 = 1593;
+export let a1594 = 1594;
+export let a1595 = 1595;
+export let a1596 = 1596;
+export let a1597 = 1597;
+export let a1598 = 1598;
+export let a1599 = 1599;
+export let a1600 = 1600;
+export let a1601 = 1601;
+export let a1602 = 1602;
+export let a1603 = 1603;
+export let a1604 = 1604;
+export let a1605 = 1605;
+export let a1606 = 1606;
+export let a1607 = 1607;
+export let a1608 = 1608;
+export let a1609 = 1609;
+export let a1610 = 1610;
+export let a1611 = 1611;
+export let a1612 = 1612;
+export let a1613 = 1613;
+export let a1614 = 1614;
+export let a1615 = 1615;
+export let a1616 = 1616;
+export let a1617 = 1617;
+export let a1618 = 1618;
+export let a1619 = 1619;
+export let a1620 = 1620;
+export let a1621 = 1621;
+export let a1622 = 1622;
+export let a1623 = 1623;
+export let a1624 = 1624;
+export let a1625 = 1625;
+export let a1626 = 1626;
+export let a1627 = 1627;
+export let a1628 = 1628;
+export let a1629 = 1629;
+export let a1630 = 1630;
+export let a1631 = 1631;
+export let a1632 = 1632;
+export let a1633 = 1633;
+export let a1634 = 1634;
+export let a1635 = 1635;
+export let a1636 = 1636;
+export let a1637 = 1637;
+export let a1638 = 1638;
+export let a1639 = 1639;
+export let a1640 = 1640;
+export let a1641 = 1641;
+export let a1642 = 1642;
+export let a1643 = 1643;
+export let a1644 = 1644;
+export let a1645 = 1645;
+export let a1646 = 1646;
+export let a1647 = 1647;
+export let a1648 = 1648;
+export let a1649 = 1649;
+export let a1650 = 1650;
+export let a1651 = 1651;
+export let a1652 = 1652;
+export let a1653 = 1653;
+export let a1654 = 1654;
+export let a1655 = 1655;
+export let a1656 = 1656;
+export let a1657 = 1657;
+export let a1658 = 1658;
+export let a1659 = 1659;
+export let a1660 = 1660;
+export let a1661 = 1661;
+export let a1662 = 1662;
+export let a1663 = 1663;
+export let a1664 = 1664;
+export let a1665 = 1665;
+export let a1666 = 1666;
+export let a1667 = 1667;
+export let a1668 = 1668;
+export let a1669 = 1669;
+export let a1670 = 1670;
+export let a1671 = 1671;
+export let a1672 = 1672;
+export let a1673 = 1673;
+export let a1674 = 1674;
+export let a1675 = 1675;
+export let a1676 = 1676;
+export let a1677 = 1677;
+export let a1678 = 1678;
+export let a1679 = 1679;
+export let a1680 = 1680;
+export let a1681 = 1681;
+export let a1682 = 1682;
+export let a1683 = 1683;
+export let a1684 = 1684;
+export let a1685 = 1685;
+export let a1686 = 1686;
+export let a1687 = 1687;
+export let a1688 = 1688;
+export let a1689 = 1689;
+export let a1690 = 1690;
+export let a1691 = 1691;
+export let a1692 = 1692;
+export let a1693 = 1693;
+export let a1694 = 1694;
+export let a1695 = 1695;
+export let a1696 = 1696;
+export let a1697 = 1697;
+export let a1698 = 1698;
+export let a1699 = 1699;
+export let a1700 = 1700;
+export let a1701 = 1701;
+export let a1702 = 1702;
+export let a1703 = 1703;
+export let a1704 = 1704;
+export let a1705 = 1705;
+export let a1706 = 1706;
+export let a1707 = 1707;
+export let a1708 = 1708;
+export let a1709 = 1709;
+export let a1710 = 1710;
+export let a1711 = 1711;
+export let a1712 = 1712;
+export let a1713 = 1713;
+export let a1714 = 1714;
+export let a1715 = 1715;
+export let a1716 = 1716;
+export let a1717 = 1717;
+export let a1718 = 1718;
+export let a1719 = 1719;
+export let a1720 = 1720;
+export let a1721 = 1721;
+export let a1722 = 1722;
+export let a1723 = 1723;
+export let a1724 = 1724;
+export let a1725 = 1725;
+export let a1726 = 1726;
+export let a1727 = 1727;
+export let a1728 = 1728;
+export let a1729 = 1729;
+export let a1730 = 1730;
+export let a1731 = 1731;
+export let a1732 = 1732;
+export let a1733 = 1733;
+export let a1734 = 1734;
+export let a1735 = 1735;
+export let a1736 = 1736;
+export let a1737 = 1737;
+export let a1738 = 1738;
+export let a1739 = 1739;
+export let a1740 = 1740;
+export let a1741 = 1741;
+export let a1742 = 1742;
+export let a1743 = 1743;
+export let a1744 = 1744;
+export let a1745 = 1745;
+export let a1746 = 1746;
+export let a1747 = 1747;
+export let a1748 = 1748;
+export let a1749 = 1749;
+export let a1750 = 1750;
+export let a1751 = 1751;
+export let a1752 = 1752;
+export let a1753 = 1753;
+export let a1754 = 1754;
+export let a1755 = 1755;
+export let a1756 = 1756;
+export let a1757 = 1757;
+export let a1758 = 1758;
+export let a1759 = 1759;
+export let a1760 = 1760;
+export let a1761 = 1761;
+export let a1762 = 1762;
+export let a1763 = 1763;
+export let a1764 = 1764;
+export let a1765 = 1765;
+export let a1766 = 1766;
+export let a1767 = 1767;
+export let a1768 = 1768;
+export let a1769 = 1769;
+export let a1770 = 1770;
+export let a1771 = 1771;
+export let a1772 = 1772;
+export let a1773 = 1773;
+export let a1774 = 1774;
+export let a1775 = 1775;
+export let a1776 = 1776;
+export let a1777 = 1777;
+export let a1778 = 1778;
+export let a1779 = 1779;
+export let a1780 = 1780;
+export let a1781 = 1781;
+export let a1782 = 1782;
+export let a1783 = 1783;
+export let a1784 = 1784;
+export let a1785 = 1785;
+export let a1786 = 1786;
+export let a1787 = 1787;
+export let a1788 = 1788;
+export let a1789 = 1789;
+export let a1790 = 1790;
+export let a1791 = 1791;
+export let a1792 = 1792;
+export let a1793 = 1793;
+export let a1794 = 1794;
+export let a1795 = 1795;
+export let a1796 = 1796;
+export let a1797 = 1797;
+export let a1798 = 1798;
+export let a1799 = 1799;
+export let a1800 = 1800;
+export let a1801 = 1801;
+export let a1802 = 1802;
+export let a1803 = 1803;
+export let a1804 = 1804;
+export let a1805 = 1805;
+export let a1806 = 1806;
+export let a1807 = 1807;
+export let a1808 = 1808;
+export let a1809 = 1809;
+export let a1810 = 1810;
+export let a1811 = 1811;
+export let a1812 = 1812;
+export let a1813 = 1813;
+export let a1814 = 1814;
+export let a1815 = 1815;
+export let a1816 = 1816;
+export let a1817 = 1817;
+export let a1818 = 1818;
+export let a1819 = 1819;
+export let a1820 = 1820;
+export let a1821 = 1821;
+export let a1822 = 1822;
+export let a1823 = 1823;
+export let a1824 = 1824;
+export let a1825 = 1825;
+export let a1826 = 1826;
+export let a1827 = 1827;
+export let a1828 = 1828;
+export let a1829 = 1829;
+export let a1830 = 1830;
+export let a1831 = 1831;
+export let a1832 = 1832;
+export let a1833 = 1833;
+export let a1834 = 1834;
+export let a1835 = 1835;
+export let a1836 = 1836;
+export let a1837 = 1837;
+export let a1838 = 1838;
+export let a1839 = 1839;
+export let a1840 = 1840;
+export let a1841 = 1841;
+export let a1842 = 1842;
+export let a1843 = 1843;
+export let a1844 = 1844;
+export let a1845 = 1845;
+export let a1846 = 1846;
+export let a1847 = 1847;
+export let a1848 = 1848;
+export let a1849 = 1849;
+export let a1850 = 1850;
+export let a1851 = 1851;
+export let a1852 = 1852;
+export let a1853 = 1853;
+export let a1854 = 1854;
+export let a1855 = 1855;
+export let a1856 = 1856;
+export let a1857 = 1857;
+export let a1858 = 1858;
+export let a1859 = 1859;
+export let a1860 = 1860;
+export let a1861 = 1861;
+export let a1862 = 1862;
+export let a1863 = 1863;
+export let a1864 = 1864;
+export let a1865 = 1865;
+export let a1866 = 1866;
+export let a1867 = 1867;
+export let a1868 = 1868;
+export let a1869 = 1869;
+export let a1870 = 1870;
+export let a1871 = 1871;
+export let a1872 = 1872;
+export let a1873 = 1873;
+export let a1874 = 1874;
+export let a1875 = 1875;
+export let a1876 = 1876;
+export let a1877 = 1877;
+export let a1878 = 1878;
+export let a1879 = 1879;
+export let a1880 = 1880;
+export let a1881 = 1881;
+export let a1882 = 1882;
+export let a1883 = 1883;
+export let a1884 = 1884;
+export let a1885 = 1885;
+export let a1886 = 1886;
+export let a1887 = 1887;
+export let a1888 = 1888;
+export let a1889 = 1889;
+export let a1890 = 1890;
+export let a1891 = 1891;
+export let a1892 = 1892;
+export let a1893 = 1893;
+export let a1894 = 1894;
+export let a1895 = 1895;
+export let a1896 = 1896;
+export let a1897 = 1897;
+export let a1898 = 1898;
+export let a1899 = 1899;
+export let a1900 = 1900;
+export let a1901 = 1901;
+export let a1902 = 1902;
+export let a1903 = 1903;
+export let a1904 = 1904;
+export let a1905 = 1905;
+export let a1906 = 1906;
+export let a1907 = 1907;
+export let a1908 = 1908;
+export let a1909 = 1909;
+export let a1910 = 1910;
+export let a1911 = 1911;
+export let a1912 = 1912;
+export let a1913 = 1913;
+export let a1914 = 1914;
+export let a1915 = 1915;
+export let a1916 = 1916;
+export let a1917 = 1917;
+export let a1918 = 1918;
+export let a1919 = 1919;
+export let a1920 = 1920;
+export let a1921 = 1921;
+export let a1922 = 1922;
+export let a1923 = 1923;
+export let a1924 = 1924;
+export let a1925 = 1925;
+export let a1926 = 1926;
+export let a1927 = 1927;
+export let a1928 = 1928;
+export let a1929 = 1929;
+export let a1930 = 1930;
+export let a1931 = 1931;
+export let a1932 = 1932;
+export let a1933 = 1933;
+export let a1934 = 1934;
+export let a1935 = 1935;
+export let a1936 = 1936;
+export let a1937 = 1937;
+export let a1938 = 1938;
+export let a1939 = 1939;
+export let a1940 = 1940;
+export let a1941 = 1941;
+export let a1942 = 1942;
+export let a1943 = 1943;
+export let a1944 = 1944;
+export let a1945 = 1945;
+export let a1946 = 1946;
+export let a1947 = 1947;
+export let a1948 = 1948;
+export let a1949 = 1949;
+export let a1950 = 1950;
+export let a1951 = 1951;
+export let a1952 = 1952;
+export let a1953 = 1953;
+export let a1954 = 1954;
+export let a1955 = 1955;
+export let a1956 = 1956;
+export let a1957 = 1957;
+export let a1958 = 1958;
+export let a1959 = 1959;
+export let a1960 = 1960;
+export let a1961 = 1961;
+export let a1962 = 1962;
+export let a1963 = 1963;
+export let a1964 = 1964;
+export let a1965 = 1965;
+export let a1966 = 1966;
+export let a1967 = 1967;
+export let a1968 = 1968;
+export let a1969 = 1969;
+export let a1970 = 1970;
+export let a1971 = 1971;
+export let a1972 = 1972;
+export let a1973 = 1973;
+export let a1974 = 1974;
+export let a1975 = 1975;
+export let a1976 = 1976;
+export let a1977 = 1977;
+export let a1978 = 1978;
+export let a1979 = 1979;
+export let a1980 = 1980;
+export let a1981 = 1981;
+export let a1982 = 1982;
+export let a1983 = 1983;
+export let a1984 = 1984;
+export let a1985 = 1985;
+export let a1986 = 1986;
+export let a1987 = 1987;
+export let a1988 = 1988;
+export let a1989 = 1989;
+export let a1990 = 1990;
+export let a1991 = 1991;
+export let a1992 = 1992;
+export let a1993 = 1993;
+export let a1994 = 1994;
+export let a1995 = 1995;
+export let a1996 = 1996;
+export let a1997 = 1997;
+export let a1998 = 1998;
+export let a1999 = 1999;
+export let a2000 = 2000;
+export let a2001 = 2001;
+export let a2002 = 2002;
+export let a2003 = 2003;
+export let a2004 = 2004;
+export let a2005 = 2005;
+export let a2006 = 2006;
+export let a2007 = 2007;
+export let a2008 = 2008;
+export let a2009 = 2009;
+export let a2010 = 2010;
+export let a2011 = 2011;
+export let a2012 = 2012;
+export let a2013 = 2013;
+export let a2014 = 2014;
+export let a2015 = 2015;
+export let a2016 = 2016;
+export let a2017 = 2017;
+export let a2018 = 2018;
+export let a2019 = 2019;
+export let a2020 = 2020;
+export let a2021 = 2021;
+export let a2022 = 2022;
+export let a2023 = 2023;
+export let a2024 = 2024;
+export let a2025 = 2025;
+export let a2026 = 2026;
+export let a2027 = 2027;
+export let a2028 = 2028;
+export let a2029 = 2029;
+export let a2030 = 2030;
+export let a2031 = 2031;
+export let a2032 = 2032;
+export let a2033 = 2033;
+export let a2034 = 2034;
+export let a2035 = 2035;
+export let a2036 = 2036;
+export let a2037 = 2037;
+export let a2038 = 2038;
+export let a2039 = 2039;
+export let a2040 = 2040;
+export let a2041 = 2041;
+export let a2042 = 2042;
+export let a2043 = 2043;
+export let a2044 = 2044;
+export let a2045 = 2045;
+export let a2046 = 2046;
+export let a2047 = 2047;
+export let a2048 = 2048;
+export let a2049 = 2049;
+export let a2050 = 2050;
+export let a2051 = 2051;
+export let a2052 = 2052;
+export let a2053 = 2053;
+export let a2054 = 2054;
+export let a2055 = 2055;
+export let a2056 = 2056;
+export let a2057 = 2057;
+export let a2058 = 2058;
+export let a2059 = 2059;
+export let a2060 = 2060;
+export let a2061 = 2061;
+export let a2062 = 2062;
+export let a2063 = 2063;
+export let a2064 = 2064;
+export let a2065 = 2065;
+export let a2066 = 2066;
+export let a2067 = 2067;
+export let a2068 = 2068;
+export let a2069 = 2069;
+export let a2070 = 2070;
+export let a2071 = 2071;
+export let a2072 = 2072;
+export let a2073 = 2073;
+export let a2074 = 2074;
+export let a2075 = 2075;
+export let a2076 = 2076;
+export let a2077 = 2077;
+export let a2078 = 2078;
+export let a2079 = 2079;
+export let a2080 = 2080;
+export let a2081 = 2081;
+export let a2082 = 2082;
+export let a2083 = 2083;
+export let a2084 = 2084;
+export let a2085 = 2085;
+export let a2086 = 2086;
+export let a2087 = 2087;
+export let a2088 = 2088;
+export let a2089 = 2089;
+export let a2090 = 2090;
+export let a2091 = 2091;
+export let a2092 = 2092;
+export let a2093 = 2093;
+export let a2094 = 2094;
+export let a2095 = 2095;
+export let a2096 = 2096;
+export let a2097 = 2097;
+export let a2098 = 2098;
+export let a2099 = 2099;
+export let a2100 = 2100;
+export let a2101 = 2101;
+export let a2102 = 2102;
+export let a2103 = 2103;
+export let a2104 = 2104;
+export let a2105 = 2105;
+export let a2106 = 2106;
+export let a2107 = 2107;
+export let a2108 = 2108;
+export let a2109 = 2109;
+export let a2110 = 2110;
+export let a2111 = 2111;
+export let a2112 = 2112;
+export let a2113 = 2113;
+export let a2114 = 2114;
+export let a2115 = 2115;
+export let a2116 = 2116;
+export let a2117 = 2117;
+export let a2118 = 2118;
+export let a2119 = 2119;
+export let a2120 = 2120;
+export let a2121 = 2121;
+export let a2122 = 2122;
+export let a2123 = 2123;
+export let a2124 = 2124;
+export let a2125 = 2125;
+export let a2126 = 2126;
+export let a2127 = 2127;
+export let a2128 = 2128;
+export let a2129 = 2129;
+export let a2130 = 2130;
+export let a2131 = 2131;
+export let a2132 = 2132;
+export let a2133 = 2133;
+export let a2134 = 2134;
+export let a2135 = 2135;
+export let a2136 = 2136;
+export let a2137 = 2137;
+export let a2138 = 2138;
+export let a2139 = 2139;
+export let a2140 = 2140;
+export let a2141 = 2141;
+export let a2142 = 2142;
+export let a2143 = 2143;
+export let a2144 = 2144;
+export let a2145 = 2145;
+export let a2146 = 2146;
+export let a2147 = 2147;
+export let a2148 = 2148;
+export let a2149 = 2149;
+export let a2150 = 2150;
+export let a2151 = 2151;
+export let a2152 = 2152;
+export let a2153 = 2153;
+export let a2154 = 2154;
+export let a2155 = 2155;
+export let a2156 = 2156;
+export let a2157 = 2157;
+export let a2158 = 2158;
+export let a2159 = 2159;
+export let a2160 = 2160;
+export let a2161 = 2161;
+export let a2162 = 2162;
+export let a2163 = 2163;
+export let a2164 = 2164;
+export let a2165 = 2165;
+export let a2166 = 2166;
+export let a2167 = 2167;
+export let a2168 = 2168;
+export let a2169 = 2169;
+export let a2170 = 2170;
+export let a2171 = 2171;
+export let a2172 = 2172;
+export let a2173 = 2173;
+export let a2174 = 2174;
+export let a2175 = 2175;
+export let a2176 = 2176;
+export let a2177 = 2177;
+export let a2178 = 2178;
+export let a2179 = 2179;
+export let a2180 = 2180;
+export let a2181 = 2181;
+export let a2182 = 2182;
+export let a2183 = 2183;
+export let a2184 = 2184;
+export let a2185 = 2185;
+export let a2186 = 2186;
+export let a2187 = 2187;
+export let a2188 = 2188;
+export let a2189 = 2189;
+export let a2190 = 2190;
+export let a2191 = 2191;
+export let a2192 = 2192;
+export let a2193 = 2193;
+export let a2194 = 2194;
+export let a2195 = 2195;
+export let a2196 = 2196;
+export let a2197 = 2197;
+export let a2198 = 2198;
+export let a2199 = 2199;
diff --git a/deps/v8/test/mjsunit/harmony/modules-skip-large2.js b/deps/v8/test/mjsunit/harmony/modules-skip-large2.js
new file mode 100644
index 0000000000..2c03557197
--- /dev/null
+++ b/deps/v8/test/mjsunit/harmony/modules-skip-large2.js
@@ -0,0 +1,1104 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export let a0 = 0;
+export let a1 = 1;
+export let a2 = 2;
+export let a3 = 3;
+export let a4 = 4;
+export let a5 = 5;
+export let a6 = 6;
+export let a7 = 7;
+export let a8 = 8;
+export let a9 = 9;
+export let a10 = 10;
+export let a11 = 11;
+export let a12 = 12;
+export let a13 = 13;
+export let a14 = 14;
+export let a15 = 15;
+export let a16 = 16;
+export let a17 = 17;
+export let a18 = 18;
+export let a19 = 19;
+export let a20 = 20;
+export let a21 = 21;
+export let a22 = 22;
+export let a23 = 23;
+export let a24 = 24;
+export let a25 = 25;
+export let a26 = 26;
+export let a27 = 27;
+export let a28 = 28;
+export let a29 = 29;
+export let a30 = 30;
+export let a31 = 31;
+export let a32 = 32;
+export let a33 = 33;
+export let a34 = 34;
+export let a35 = 35;
+export let a36 = 36;
+export let a37 = 37;
+export let a38 = 38;
+export let a39 = 39;
+export let a40 = 40;
+export let a41 = 41;
+export let a42 = 42;
+export let a43 = 43;
+export let a44 = 44;
+export let a45 = 45;
+export let a46 = 46;
+export let a47 = 47;
+export let a48 = 48;
+export let a49 = 49;
+export let a50 = 50;
+export let a51 = 51;
+export let a52 = 52;
+export let a53 = 53;
+export let a54 = 54;
+export let a55 = 55;
+export let a56 = 56;
+export let a57 = 57;
+export let a58 = 58;
+export let a59 = 59;
+export let a60 = 60;
+export let a61 = 61;
+export let a62 = 62;
+export let a63 = 63;
+export let a64 = 64;
+export let a65 = 65;
+export let a66 = 66;
+export let a67 = 67;
+export let a68 = 68;
+export let a69 = 69;
+export let a70 = 70;
+export let a71 = 71;
+export let a72 = 72;
+export let a73 = 73;
+export let a74 = 74;
+export let a75 = 75;
+export let a76 = 76;
+export let a77 = 77;
+export let a78 = 78;
+export let a79 = 79;
+export let a80 = 80;
+export let a81 = 81;
+export let a82 = 82;
+export let a83 = 83;
+export let a84 = 84;
+export let a85 = 85;
+export let a86 = 86;
+export let a87 = 87;
+export let a88 = 88;
+export let a89 = 89;
+export let a90 = 90;
+export let a91 = 91;
+export let a92 = 92;
+export let a93 = 93;
+export let a94 = 94;
+export let a95 = 95;
+export let a96 = 96;
+export let a97 = 97;
+export let a98 = 98;
+export let a99 = 99;
+export let a100 = 100;
+export let a101 = 101;
+export let a102 = 102;
+export let a103 = 103;
+export let a104 = 104;
+export let a105 = 105;
+export let a106 = 106;
+export let a107 = 107;
+export let a108 = 108;
+export let a109 = 109;
+export let a110 = 110;
+export let a111 = 111;
+export let a112 = 112;
+export let a113 = 113;
+export let a114 = 114;
+export let a115 = 115;
+export let a116 = 116;
+export let a117 = 117;
+export let a118 = 118;
+export let a119 = 119;
+export let a120 = 120;
+export let a121 = 121;
+export let a122 = 122;
+export let a123 = 123;
+export let a124 = 124;
+export let a125 = 125;
+export let a126 = 126;
+export let a127 = 127;
+export let a128 = 128;
+export let a129 = 129;
+export let a130 = 130;
+export let a131 = 131;
+export let a132 = 132;
+export let a133 = 133;
+export let a134 = 134;
+export let a135 = 135;
+export let a136 = 136;
+export let a137 = 137;
+export let a138 = 138;
+export let a139 = 139;
+export let a140 = 140;
+export let a141 = 141;
+export let a142 = 142;
+export let a143 = 143;
+export let a144 = 144;
+export let a145 = 145;
+export let a146 = 146;
+export let a147 = 147;
+export let a148 = 148;
+export let a149 = 149;
+export let a150 = 150;
+export let a151 = 151;
+export let a152 = 152;
+export let a153 = 153;
+export let a154 = 154;
+export let a155 = 155;
+export let a156 = 156;
+export let a157 = 157;
+export let a158 = 158;
+export let a159 = 159;
+export let a160 = 160;
+export let a161 = 161;
+export let a162 = 162;
+export let a163 = 163;
+export let a164 = 164;
+export let a165 = 165;
+export let a166 = 166;
+export let a167 = 167;
+export let a168 = 168;
+export let a169 = 169;
+export let a170 = 170;
+export let a171 = 171;
+export let a172 = 172;
+export let a173 = 173;
+export let a174 = 174;
+export let a175 = 175;
+export let a176 = 176;
+export let a177 = 177;
+export let a178 = 178;
+export let a179 = 179;
+export let a180 = 180;
+export let a181 = 181;
+export let a182 = 182;
+export let a183 = 183;
+export let a184 = 184;
+export let a185 = 185;
+export let a186 = 186;
+export let a187 = 187;
+export let a188 = 188;
+export let a189 = 189;
+export let a190 = 190;
+export let a191 = 191;
+export let a192 = 192;
+export let a193 = 193;
+export let a194 = 194;
+export let a195 = 195;
+export let a196 = 196;
+export let a197 = 197;
+export let a198 = 198;
+export let a199 = 199;
+export let a200 = 200;
+export let a201 = 201;
+export let a202 = 202;
+export let a203 = 203;
+export let a204 = 204;
+export let a205 = 205;
+export let a206 = 206;
+export let a207 = 207;
+export let a208 = 208;
+export let a209 = 209;
+export let a210 = 210;
+export let a211 = 211;
+export let a212 = 212;
+export let a213 = 213;
+export let a214 = 214;
+export let a215 = 215;
+export let a216 = 216;
+export let a217 = 217;
+export let a218 = 218;
+export let a219 = 219;
+export let a220 = 220;
+export let a221 = 221;
+export let a222 = 222;
+export let a223 = 223;
+export let a224 = 224;
+export let a225 = 225;
+export let a226 = 226;
+export let a227 = 227;
+export let a228 = 228;
+export let a229 = 229;
+export let a230 = 230;
+export let a231 = 231;
+export let a232 = 232;
+export let a233 = 233;
+export let a234 = 234;
+export let a235 = 235;
+export let a236 = 236;
+export let a237 = 237;
+export let a238 = 238;
+export let a239 = 239;
+export let a240 = 240;
+export let a241 = 241;
+export let a242 = 242;
+export let a243 = 243;
+export let a244 = 244;
+export let a245 = 245;
+export let a246 = 246;
+export let a247 = 247;
+export let a248 = 248;
+export let a249 = 249;
+export let a250 = 250;
+export let a251 = 251;
+export let a252 = 252;
+export let a253 = 253;
+export let a254 = 254;
+export let a255 = 255;
+export let a256 = 256;
+export let a257 = 257;
+export let a258 = 258;
+export let a259 = 259;
+export let a260 = 260;
+export let a261 = 261;
+export let a262 = 262;
+export let a263 = 263;
+export let a264 = 264;
+export let a265 = 265;
+export let a266 = 266;
+export let a267 = 267;
+export let a268 = 268;
+export let a269 = 269;
+export let a270 = 270;
+export let a271 = 271;
+export let a272 = 272;
+export let a273 = 273;
+export let a274 = 274;
+export let a275 = 275;
+export let a276 = 276;
+export let a277 = 277;
+export let a278 = 278;
+export let a279 = 279;
+export let a280 = 280;
+export let a281 = 281;
+export let a282 = 282;
+export let a283 = 283;
+export let a284 = 284;
+export let a285 = 285;
+export let a286 = 286;
+export let a287 = 287;
+export let a288 = 288;
+export let a289 = 289;
+export let a290 = 290;
+export let a291 = 291;
+export let a292 = 292;
+export let a293 = 293;
+export let a294 = 294;
+export let a295 = 295;
+export let a296 = 296;
+export let a297 = 297;
+export let a298 = 298;
+export let a299 = 299;
+export let a300 = 300;
+export let a301 = 301;
+export let a302 = 302;
+export let a303 = 303;
+export let a304 = 304;
+export let a305 = 305;
+export let a306 = 306;
+export let a307 = 307;
+export let a308 = 308;
+export let a309 = 309;
+export let a310 = 310;
+export let a311 = 311;
+export let a312 = 312;
+export let a313 = 313;
+export let a314 = 314;
+export let a315 = 315;
+export let a316 = 316;
+export let a317 = 317;
+export let a318 = 318;
+export let a319 = 319;
+export let a320 = 320;
+export let a321 = 321;
+export let a322 = 322;
+export let a323 = 323;
+export let a324 = 324;
+export let a325 = 325;
+export let a326 = 326;
+export let a327 = 327;
+export let a328 = 328;
+export let a329 = 329;
+export let a330 = 330;
+export let a331 = 331;
+export let a332 = 332;
+export let a333 = 333;
+export let a334 = 334;
+export let a335 = 335;
+export let a336 = 336;
+export let a337 = 337;
+export let a338 = 338;
+export let a339 = 339;
+export let a340 = 340;
+export let a341 = 341;
+export let a342 = 342;
+export let a343 = 343;
+export let a344 = 344;
+export let a345 = 345;
+export let a346 = 346;
+export let a347 = 347;
+export let a348 = 348;
+export let a349 = 349;
+export let a350 = 350;
+export let a351 = 351;
+export let a352 = 352;
+export let a353 = 353;
+export let a354 = 354;
+export let a355 = 355;
+export let a356 = 356;
+export let a357 = 357;
+export let a358 = 358;
+export let a359 = 359;
+export let a360 = 360;
+export let a361 = 361;
+export let a362 = 362;
+export let a363 = 363;
+export let a364 = 364;
+export let a365 = 365;
+export let a366 = 366;
+export let a367 = 367;
+export let a368 = 368;
+export let a369 = 369;
+export let a370 = 370;
+export let a371 = 371;
+export let a372 = 372;
+export let a373 = 373;
+export let a374 = 374;
+export let a375 = 375;
+export let a376 = 376;
+export let a377 = 377;
+export let a378 = 378;
+export let a379 = 379;
+export let a380 = 380;
+export let a381 = 381;
+export let a382 = 382;
+export let a383 = 383;
+export let a384 = 384;
+export let a385 = 385;
+export let a386 = 386;
+export let a387 = 387;
+export let a388 = 388;
+export let a389 = 389;
+export let a390 = 390;
+export let a391 = 391;
+export let a392 = 392;
+export let a393 = 393;
+export let a394 = 394;
+export let a395 = 395;
+export let a396 = 396;
+export let a397 = 397;
+export let a398 = 398;
+export let a399 = 399;
+export let a400 = 400;
+export let a401 = 401;
+export let a402 = 402;
+export let a403 = 403;
+export let a404 = 404;
+export let a405 = 405;
+export let a406 = 406;
+export let a407 = 407;
+export let a408 = 408;
+export let a409 = 409;
+export let a410 = 410;
+export let a411 = 411;
+export let a412 = 412;
+export let a413 = 413;
+export let a414 = 414;
+export let a415 = 415;
+export let a416 = 416;
+export let a417 = 417;
+export let a418 = 418;
+export let a419 = 419;
+export let a420 = 420;
+export let a421 = 421;
+export let a422 = 422;
+export let a423 = 423;
+export let a424 = 424;
+export let a425 = 425;
+export let a426 = 426;
+export let a427 = 427;
+export let a428 = 428;
+export let a429 = 429;
+export let a430 = 430;
+export let a431 = 431;
+export let a432 = 432;
+export let a433 = 433;
+export let a434 = 434;
+export let a435 = 435;
+export let a436 = 436;
+export let a437 = 437;
+export let a438 = 438;
+export let a439 = 439;
+export let a440 = 440;
+export let a441 = 441;
+export let a442 = 442;
+export let a443 = 443;
+export let a444 = 444;
+export let a445 = 445;
+export let a446 = 446;
+export let a447 = 447;
+export let a448 = 448;
+export let a449 = 449;
+export let a450 = 450;
+export let a451 = 451;
+export let a452 = 452;
+export let a453 = 453;
+export let a454 = 454;
+export let a455 = 455;
+export let a456 = 456;
+export let a457 = 457;
+export let a458 = 458;
+export let a459 = 459;
+export let a460 = 460;
+export let a461 = 461;
+export let a462 = 462;
+export let a463 = 463;
+export let a464 = 464;
+export let a465 = 465;
+export let a466 = 466;
+export let a467 = 467;
+export let a468 = 468;
+export let a469 = 469;
+export let a470 = 470;
+export let a471 = 471;
+export let a472 = 472;
+export let a473 = 473;
+export let a474 = 474;
+export let a475 = 475;
+export let a476 = 476;
+export let a477 = 477;
+export let a478 = 478;
+export let a479 = 479;
+export let a480 = 480;
+export let a481 = 481;
+export let a482 = 482;
+export let a483 = 483;
+export let a484 = 484;
+export let a485 = 485;
+export let a486 = 486;
+export let a487 = 487;
+export let a488 = 488;
+export let a489 = 489;
+export let a490 = 490;
+export let a491 = 491;
+export let a492 = 492;
+export let a493 = 493;
+export let a494 = 494;
+export let a495 = 495;
+export let a496 = 496;
+export let a497 = 497;
+export let a498 = 498;
+export let a499 = 499;
+export let a500 = 500;
+export let a501 = 501;
+export let a502 = 502;
+export let a503 = 503;
+export let a504 = 504;
+export let a505 = 505;
+export let a506 = 506;
+export let a507 = 507;
+export let a508 = 508;
+export let a509 = 509;
+export let a510 = 510;
+export let a511 = 511;
+export let a512 = 512;
+export let a513 = 513;
+export let a514 = 514;
+export let a515 = 515;
+export let a516 = 516;
+export let a517 = 517;
+export let a518 = 518;
+export let a519 = 519;
+export let a520 = 520;
+export let a521 = 521;
+export let a522 = 522;
+export let a523 = 523;
+export let a524 = 524;
+export let a525 = 525;
+export let a526 = 526;
+export let a527 = 527;
+export let a528 = 528;
+export let a529 = 529;
+export let a530 = 530;
+export let a531 = 531;
+export let a532 = 532;
+export let a533 = 533;
+export let a534 = 534;
+export let a535 = 535;
+export let a536 = 536;
+export let a537 = 537;
+export let a538 = 538;
+export let a539 = 539;
+export let a540 = 540;
+export let a541 = 541;
+export let a542 = 542;
+export let a543 = 543;
+export let a544 = 544;
+export let a545 = 545;
+export let a546 = 546;
+export let a547 = 547;
+export let a548 = 548;
+export let a549 = 549;
+export let a550 = 550;
+export let a551 = 551;
+export let a552 = 552;
+export let a553 = 553;
+export let a554 = 554;
+export let a555 = 555;
+export let a556 = 556;
+export let a557 = 557;
+export let a558 = 558;
+export let a559 = 559;
+export let a560 = 560;
+export let a561 = 561;
+export let a562 = 562;
+export let a563 = 563;
+export let a564 = 564;
+export let a565 = 565;
+export let a566 = 566;
+export let a567 = 567;
+export let a568 = 568;
+export let a569 = 569;
+export let a570 = 570;
+export let a571 = 571;
+export let a572 = 572;
+export let a573 = 573;
+export let a574 = 574;
+export let a575 = 575;
+export let a576 = 576;
+export let a577 = 577;
+export let a578 = 578;
+export let a579 = 579;
+export let a580 = 580;
+export let a581 = 581;
+export let a582 = 582;
+export let a583 = 583;
+export let a584 = 584;
+export let a585 = 585;
+export let a586 = 586;
+export let a587 = 587;
+export let a588 = 588;
+export let a589 = 589;
+export let a590 = 590;
+export let a591 = 591;
+export let a592 = 592;
+export let a593 = 593;
+export let a594 = 594;
+export let a595 = 595;
+export let a596 = 596;
+export let a597 = 597;
+export let a598 = 598;
+export let a599 = 599;
+export let a600 = 600;
+export let a601 = 601;
+export let a602 = 602;
+export let a603 = 603;
+export let a604 = 604;
+export let a605 = 605;
+export let a606 = 606;
+export let a607 = 607;
+export let a608 = 608;
+export let a609 = 609;
+export let a610 = 610;
+export let a611 = 611;
+export let a612 = 612;
+export let a613 = 613;
+export let a614 = 614;
+export let a615 = 615;
+export let a616 = 616;
+export let a617 = 617;
+export let a618 = 618;
+export let a619 = 619;
+export let a620 = 620;
+export let a621 = 621;
+export let a622 = 622;
+export let a623 = 623;
+export let a624 = 624;
+export let a625 = 625;
+export let a626 = 626;
+export let a627 = 627;
+export let a628 = 628;
+export let a629 = 629;
+export let a630 = 630;
+export let a631 = 631;
+export let a632 = 632;
+export let a633 = 633;
+export let a634 = 634;
+export let a635 = 635;
+export let a636 = 636;
+export let a637 = 637;
+export let a638 = 638;
+export let a639 = 639;
+export let a640 = 640;
+export let a641 = 641;
+export let a642 = 642;
+export let a643 = 643;
+export let a644 = 644;
+export let a645 = 645;
+export let a646 = 646;
+export let a647 = 647;
+export let a648 = 648;
+export let a649 = 649;
+export let a650 = 650;
+export let a651 = 651;
+export let a652 = 652;
+export let a653 = 653;
+export let a654 = 654;
+export let a655 = 655;
+export let a656 = 656;
+export let a657 = 657;
+export let a658 = 658;
+export let a659 = 659;
+export let a660 = 660;
+export let a661 = 661;
+export let a662 = 662;
+export let a663 = 663;
+export let a664 = 664;
+export let a665 = 665;
+export let a666 = 666;
+export let a667 = 667;
+export let a668 = 668;
+export let a669 = 669;
+export let a670 = 670;
+export let a671 = 671;
+export let a672 = 672;
+export let a673 = 673;
+export let a674 = 674;
+export let a675 = 675;
+export let a676 = 676;
+export let a677 = 677;
+export let a678 = 678;
+export let a679 = 679;
+export let a680 = 680;
+export let a681 = 681;
+export let a682 = 682;
+export let a683 = 683;
+export let a684 = 684;
+export let a685 = 685;
+export let a686 = 686;
+export let a687 = 687;
+export let a688 = 688;
+export let a689 = 689;
+export let a690 = 690;
+export let a691 = 691;
+export let a692 = 692;
+export let a693 = 693;
+export let a694 = 694;
+export let a695 = 695;
+export let a696 = 696;
+export let a697 = 697;
+export let a698 = 698;
+export let a699 = 699;
+export let a700 = 700;
+export let a701 = 701;
+export let a702 = 702;
+export let a703 = 703;
+export let a704 = 704;
+export let a705 = 705;
+export let a706 = 706;
+export let a707 = 707;
+export let a708 = 708;
+export let a709 = 709;
+export let a710 = 710;
+export let a711 = 711;
+export let a712 = 712;
+export let a713 = 713;
+export let a714 = 714;
+export let a715 = 715;
+export let a716 = 716;
+export let a717 = 717;
+export let a718 = 718;
+export let a719 = 719;
+export let a720 = 720;
+export let a721 = 721;
+export let a722 = 722;
+export let a723 = 723;
+export let a724 = 724;
+export let a725 = 725;
+export let a726 = 726;
+export let a727 = 727;
+export let a728 = 728;
+export let a729 = 729;
+export let a730 = 730;
+export let a731 = 731;
+export let a732 = 732;
+export let a733 = 733;
+export let a734 = 734;
+export let a735 = 735;
+export let a736 = 736;
+export let a737 = 737;
+export let a738 = 738;
+export let a739 = 739;
+export let a740 = 740;
+export let a741 = 741;
+export let a742 = 742;
+export let a743 = 743;
+export let a744 = 744;
+export let a745 = 745;
+export let a746 = 746;
+export let a747 = 747;
+export let a748 = 748;
+export let a749 = 749;
+export let a750 = 750;
+export let a751 = 751;
+export let a752 = 752;
+export let a753 = 753;
+export let a754 = 754;
+export let a755 = 755;
+export let a756 = 756;
+export let a757 = 757;
+export let a758 = 758;
+export let a759 = 759;
+export let a760 = 760;
+export let a761 = 761;
+export let a762 = 762;
+export let a763 = 763;
+export let a764 = 764;
+export let a765 = 765;
+export let a766 = 766;
+export let a767 = 767;
+export let a768 = 768;
+export let a769 = 769;
+export let a770 = 770;
+export let a771 = 771;
+export let a772 = 772;
+export let a773 = 773;
+export let a774 = 774;
+export let a775 = 775;
+export let a776 = 776;
+export let a777 = 777;
+export let a778 = 778;
+export let a779 = 779;
+export let a780 = 780;
+export let a781 = 781;
+export let a782 = 782;
+export let a783 = 783;
+export let a784 = 784;
+export let a785 = 785;
+export let a786 = 786;
+export let a787 = 787;
+export let a788 = 788;
+export let a789 = 789;
+export let a790 = 790;
+export let a791 = 791;
+export let a792 = 792;
+export let a793 = 793;
+export let a794 = 794;
+export let a795 = 795;
+export let a796 = 796;
+export let a797 = 797;
+export let a798 = 798;
+export let a799 = 799;
+export let a800 = 800;
+export let a801 = 801;
+export let a802 = 802;
+export let a803 = 803;
+export let a804 = 804;
+export let a805 = 805;
+export let a806 = 806;
+export let a807 = 807;
+export let a808 = 808;
+export let a809 = 809;
+export let a810 = 810;
+export let a811 = 811;
+export let a812 = 812;
+export let a813 = 813;
+export let a814 = 814;
+export let a815 = 815;
+export let a816 = 816;
+export let a817 = 817;
+export let a818 = 818;
+export let a819 = 819;
+export let a820 = 820;
+export let a821 = 821;
+export let a822 = 822;
+export let a823 = 823;
+export let a824 = 824;
+export let a825 = 825;
+export let a826 = 826;
+export let a827 = 827;
+export let a828 = 828;
+export let a829 = 829;
+export let a830 = 830;
+export let a831 = 831;
+export let a832 = 832;
+export let a833 = 833;
+export let a834 = 834;
+export let a835 = 835;
+export let a836 = 836;
+export let a837 = 837;
+export let a838 = 838;
+export let a839 = 839;
+export let a840 = 840;
+export let a841 = 841;
+export let a842 = 842;
+export let a843 = 843;
+export let a844 = 844;
+export let a845 = 845;
+export let a846 = 846;
+export let a847 = 847;
+export let a848 = 848;
+export let a849 = 849;
+export let a850 = 850;
+export let a851 = 851;
+export let a852 = 852;
+export let a853 = 853;
+export let a854 = 854;
+export let a855 = 855;
+export let a856 = 856;
+export let a857 = 857;
+export let a858 = 858;
+export let a859 = 859;
+export let a860 = 860;
+export let a861 = 861;
+export let a862 = 862;
+export let a863 = 863;
+export let a864 = 864;
+export let a865 = 865;
+export let a866 = 866;
+export let a867 = 867;
+export let a868 = 868;
+export let a869 = 869;
+export let a870 = 870;
+export let a871 = 871;
+export let a872 = 872;
+export let a873 = 873;
+export let a874 = 874;
+export let a875 = 875;
+export let a876 = 876;
+export let a877 = 877;
+export let a878 = 878;
+export let a879 = 879;
+export let a880 = 880;
+export let a881 = 881;
+export let a882 = 882;
+export let a883 = 883;
+export let a884 = 884;
+export let a885 = 885;
+export let a886 = 886;
+export let a887 = 887;
+export let a888 = 888;
+export let a889 = 889;
+export let a890 = 890;
+export let a891 = 891;
+export let a892 = 892;
+export let a893 = 893;
+export let a894 = 894;
+export let a895 = 895;
+export let a896 = 896;
+export let a897 = 897;
+export let a898 = 898;
+export let a899 = 899;
+export let a900 = 900;
+export let a901 = 901;
+export let a902 = 902;
+export let a903 = 903;
+export let a904 = 904;
+export let a905 = 905;
+export let a906 = 906;
+export let a907 = 907;
+export let a908 = 908;
+export let a909 = 909;
+export let a910 = 910;
+export let a911 = 911;
+export let a912 = 912;
+export let a913 = 913;
+export let a914 = 914;
+export let a915 = 915;
+export let a916 = 916;
+export let a917 = 917;
+export let a918 = 918;
+export let a919 = 919;
+export let a920 = 920;
+export let a921 = 921;
+export let a922 = 922;
+export let a923 = 923;
+export let a924 = 924;
+export let a925 = 925;
+export let a926 = 926;
+export let a927 = 927;
+export let a928 = 928;
+export let a929 = 929;
+export let a930 = 930;
+export let a931 = 931;
+export let a932 = 932;
+export let a933 = 933;
+export let a934 = 934;
+export let a935 = 935;
+export let a936 = 936;
+export let a937 = 937;
+export let a938 = 938;
+export let a939 = 939;
+export let a940 = 940;
+export let a941 = 941;
+export let a942 = 942;
+export let a943 = 943;
+export let a944 = 944;
+export let a945 = 945;
+export let a946 = 946;
+export let a947 = 947;
+export let a948 = 948;
+export let a949 = 949;
+export let a950 = 950;
+export let a951 = 951;
+export let a952 = 952;
+export let a953 = 953;
+export let a954 = 954;
+export let a955 = 955;
+export let a956 = 956;
+export let a957 = 957;
+export let a958 = 958;
+export let a959 = 959;
+export let a960 = 960;
+export let a961 = 961;
+export let a962 = 962;
+export let a963 = 963;
+export let a964 = 964;
+export let a965 = 965;
+export let a966 = 966;
+export let a967 = 967;
+export let a968 = 968;
+export let a969 = 969;
+export let a970 = 970;
+export let a971 = 971;
+export let a972 = 972;
+export let a973 = 973;
+export let a974 = 974;
+export let a975 = 975;
+export let a976 = 976;
+export let a977 = 977;
+export let a978 = 978;
+export let a979 = 979;
+export let a980 = 980;
+export let a981 = 981;
+export let a982 = 982;
+export let a983 = 983;
+export let a984 = 984;
+export let a985 = 985;
+export let a986 = 986;
+export let a987 = 987;
+export let a988 = 988;
+export let a989 = 989;
+export let a990 = 990;
+export let a991 = 991;
+export let a992 = 992;
+export let a993 = 993;
+export let a994 = 994;
+export let a995 = 995;
+export let a996 = 996;
+export let a997 = 997;
+export let a998 = 998;
+export let a999 = 999;
+export let a1000 = 1000;
+export let a1001 = 1001;
+export let a1002 = 1002;
+export let a1003 = 1003;
+export let a1004 = 1004;
+export let a1005 = 1005;
+export let a1006 = 1006;
+export let a1007 = 1007;
+export let a1008 = 1008;
+export let a1009 = 1009;
+export let a1010 = 1010;
+export let a1011 = 1011;
+export let a1012 = 1012;
+export let a1013 = 1013;
+export let a1014 = 1014;
+export let a1015 = 1015;
+export let a1016 = 1016;
+export let a1017 = 1017;
+export let a1018 = 1018;
+export let a1019 = 1019;
+export let a1020 = 1020;
+export let a1021 = 1021;
+export let a1022 = 1022;
+export let a1023 = 1023;
+export let a1024 = 1024;
+export let a1025 = 1025;
+export let a1026 = 1026;
+export let a1027 = 1027;
+export let a1028 = 1028;
+export let a1029 = 1029;
+export let a1030 = 1030;
+export let a1031 = 1031;
+export let a1032 = 1032;
+export let a1033 = 1033;
+export let a1034 = 1034;
+export let a1035 = 1035;
+export let a1036 = 1036;
+export let a1037 = 1037;
+export let a1038 = 1038;
+export let a1039 = 1039;
+export let a1040 = 1040;
+export let a1041 = 1041;
+export let a1042 = 1042;
+export let a1043 = 1043;
+export let a1044 = 1044;
+export let a1045 = 1045;
+export let a1046 = 1046;
+export let a1047 = 1047;
+export let a1048 = 1048;
+export let a1049 = 1049;
+export let a1050 = 1050;
+export let a1051 = 1051;
+export let a1052 = 1052;
+export let a1053 = 1053;
+export let a1054 = 1054;
+export let a1055 = 1055;
+export let a1056 = 1056;
+export let a1057 = 1057;
+export let a1058 = 1058;
+export let a1059 = 1059;
+export let a1060 = 1060;
+export let a1061 = 1061;
+export let a1062 = 1062;
+export let a1063 = 1063;
+export let a1064 = 1064;
+export let a1065 = 1065;
+export let a1066 = 1066;
+export let a1067 = 1067;
+export let a1068 = 1068;
+export let a1069 = 1069;
+export let a1070 = 1070;
+export let a1071 = 1071;
+export let a1072 = 1072;
+export let a1073 = 1073;
+export let a1074 = 1074;
+export let a1075 = 1075;
+export let a1076 = 1076;
+export let a1077 = 1077;
+export let a1078 = 1078;
+export let a1079 = 1079;
+export let a1080 = 1080;
+export let a1081 = 1081;
+export let a1082 = 1082;
+export let a1083 = 1083;
+export let a1084 = 1084;
+export let a1085 = 1085;
+export let a1086 = 1086;
+export let a1087 = 1087;
+export let a1088 = 1088;
+export let a1089 = 1089;
+export let a1090 = 1090;
+export let a1091 = 1091;
+export let a1092 = 1092;
+export let a1093 = 1093;
+export let a1094 = 1094;
+export let a1095 = 1095;
+export let a1096 = 1096;
+export let a1097 = 1097;
+export let a1098 = 1098;
+export let a1099 = 1099;
diff --git a/deps/v8/test/mjsunit/harmony/promise-prototype-finally.js b/deps/v8/test/mjsunit/harmony/promise-prototype-finally.js
index d80065f10d..3668ab5538 100644
--- a/deps/v8/test/mjsunit/harmony/promise-prototype-finally.js
+++ b/deps/v8/test/mjsunit/harmony/promise-prototype-finally.js
@@ -524,3 +524,84 @@ assertTrue(descriptor.configurable);
 assertFalse(descriptor.enumerable);
 assertEquals("finally", Promise.prototype.finally.name);
 assertEquals(1, Promise.prototype.finally.length);
+
+var count = 0;
+class FooPromise extends Promise {
+  constructor(resolve, reject) {
+    count++;
+    return super(resolve, reject);
+  }
+}
+
+testAsync(assert => {
+  assert.plan(1);
+  count = 0;
+
+  new FooPromise(r => r()).finally(() => {}).then(() => {
+    assert.equals(6, count);
+  });
+}, "finally/speciesconstructor");
+
+testAsync(assert => {
+  assert.plan(1);
+  count = 0;
+
+  FooPromise.resolve().finally(() => {}).then(() => {
+    assert.equals(6, count);
+  })
+}, "resolve/finally/speciesconstructor");
+
+testAsync(assert => {
+  assert.plan(1);
+  count = 0;
+
+  FooPromise.reject().finally(() => {}).catch(() => {
+    assert.equals(6, count);
+  })
+}, "reject/finally/speciesconstructor");
+
+testAsync(assert => {
+  assert.plan(2);
+
+  class MyPromise extends Promise {
+    static get [Symbol.species]() { return Promise; }
+  }
+
+  var p = Promise
+      .resolve()
+      .finally(() => MyPromise.resolve());
+
+  assert.equals(true, p instanceof Promise);
+  assert.equals(false, p instanceof MyPromise);
+}, "finally/Symbol.Species");
+
+testAsync(assert => {
+  assert.plan(3);
+  let resolve;
+  let value = 0;
+
+  let p = new Promise(r => { resolve = r });
+
+  Promise.resolve()
+    .finally(() => {
+      return p;
+    })
+    .then(() => {
+      value = 1;
+    });
+
+  // This makes sure we take the fast path in PromiseResolve that just
+  // returns the promise it receives as value. If we had to create
+  // another wrapper promise, that would cause an additional tick in
+  // the microtask queue.
+  Promise.resolve()
+    // onFinally has run.
+    .then(() => { resolve(); })
+    // thenFinally has run.
+    .then(() => assert.equals(0, value))
+    // promise returned by .finally has been resolved.
+    .then(() => assert.equals(0, value))
+    // onFulfilled callback of .then() has run.
+    .then(() => assert.equals(1, value));
+
+}, "PromiseResolve-ordering");
diff --git a/deps/v8/test/mjsunit/harmony/regexp-named-captures.js b/deps/v8/test/mjsunit/harmony/regexp-named-captures.js
index be90427cfa..3ce947d1e5 100644
--- a/deps/v8/test/mjsunit/harmony/regexp-named-captures.js
+++ b/deps/v8/test/mjsunit/harmony/regexp-named-captures.js
@@ -360,6 +360,7 @@ function toSlowMode(re) {
   assertEquals("bacd", "abcd".replace(re, "$2$1"));
   assertEquals("cd", "abcd".replace(re, "$3"));
   assertEquals("$<sndcd", "abcd".replace(re, "$<snd"));
+  assertEquals("$<sndacd", "abcd".replace(re, "$<snd$1"));
   assertEquals("$<42a>cd", "abcd".replace(re, "$<42$1>"));
   assertEquals("$<fth>cd", "abcd".replace(re, "$<fth>"));
   assertEquals("$<a>cd", "abcd".replace(re, "$<$1>"));
@@ -371,10 +372,11 @@ function toSlowMode(re) {
   assertEquals("badc", "abcd".replace(re, "$<snd>$<fst>"));
   assertEquals("badc", "abcd".replace(re, "$2$1"));
   assertEquals("", "abcd".replace(re, "$<thd>"));
-  assertThrows(() => "abcd".replace(re, "$<snd"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<42$1>"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<fth>"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<$1>"), SyntaxError);
+  assertEquals("$<snd$<snd", "abcd".replace(re, "$<snd"));
+  assertEquals("$<snda$<sndc", "abcd".replace(re, "$<snd$1"));
+  assertEquals("", "abcd".replace(re, "$<42$1>"));
+  assertEquals("", "abcd".replace(re, "$<fth>"));
+  assertEquals("", "abcd".replace(re, "$<$1>"));
 }
 
 // @@replace with a string replacement argument (non-global, named captures).
@@ -383,10 +385,11 @@ function toSlowMode(re) {
   assertEquals("bacd", "abcd".replace(re, "$<snd>$<fst>"));
   assertEquals("bacd", "abcd".replace(re, "$2$1"));
   assertEquals("cd", "abcd".replace(re, "$<thd>"));
-  assertThrows(() => "abcd".replace(re, "$<snd"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<42$1>"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<fth>"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<$1>"), SyntaxError);
+  assertEquals("$<sndcd", "abcd".replace(re, "$<snd"));
+  assertEquals("$<sndacd", "abcd".replace(re, "$<snd$1"));
+  assertEquals("cd", "abcd".replace(re, "$<42$1>"));
+  assertEquals("cd", "abcd".replace(re, "$<fth>"));
+  assertEquals("cd", "abcd".replace(re, "$<$1>"));
 }
 
 // @@replace with a string replacement argument (slow, global, named captures).
@@ -395,10 +398,11 @@ function toSlowMode(re) {
   assertEquals("badc", "abcd".replace(re, "$<snd>$<fst>"));
   assertEquals("badc", "abcd".replace(re, "$2$1"));
   assertEquals("", "abcd".replace(re, "$<thd>"));
-  assertThrows(() => "abcd".replace(re, "$<snd"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<42$1>"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<fth>"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<$1>"), SyntaxError);
+  assertEquals("$<snd$<snd", "abcd".replace(re, "$<snd"));
+  assertEquals("$<snda$<sndc", "abcd".replace(re, "$<snd$1"));
+  assertEquals("", "abcd".replace(re, "$<42$1>"));
+  assertEquals("", "abcd".replace(re, "$<fth>"));
+  assertEquals("", "abcd".replace(re, "$<$1>"));
 }
 
 // @@replace with a string replacement argument (slow, non-global,
@@ -408,8 +412,9 @@ function toSlowMode(re) {
   assertEquals("bacd", "abcd".replace(re, "$<snd>$<fst>"));
   assertEquals("bacd", "abcd".replace(re, "$2$1"));
   assertEquals("cd", "abcd".replace(re, "$<thd>"));
-  assertThrows(() => "abcd".replace(re, "$<snd"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<42$1>"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<fth>"), SyntaxError);
-  assertThrows(() => "abcd".replace(re, "$<$1>"), SyntaxError);
+  assertEquals("$<sndcd", "abcd".replace(re, "$<snd"));
+  assertEquals("$<sndacd", "abcd".replace(re, "$<snd$1"));
+  assertEquals("cd", "abcd".replace(re, "$<42$1>"));
+  assertEquals("cd", "abcd".replace(re, "$<fth>"));
+  assertEquals("cd", "abcd".replace(re, "$<$1>"));
 }
diff --git a/deps/v8/test/mjsunit/harmony/regress/regress-771470.js b/deps/v8/test/mjsunit/harmony/regress/regress-771470.js
new file mode 100644
index 0000000000..9776fb0bad
--- /dev/null
+++ b/deps/v8/test/mjsunit/harmony/regress/regress-771470.js
@@ -0,0 +1,8 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --enable-slow-asserts
+
+async function* gen() { };
+gen.prototype = 1;
diff --git a/deps/v8/test/mjsunit/harmony/regress/regress-772649.js b/deps/v8/test/mjsunit/harmony/regress/regress-772649.js
new file mode 100644
index 0000000000..d080410226
--- /dev/null
+++ b/deps/v8/test/mjsunit/harmony/regress/regress-772649.js
@@ -0,0 +1,11 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --harmony-async-iteration
+
+async function* gen([[notIterable]] = [null]) {}
+assertThrows(() => gen(), TypeError);
+assertThrows(() => gen(), TypeError);
+%OptimizeFunctionOnNextCall(gen);
+assertThrows(() => gen(), TypeError);
diff --git a/deps/v8/test/mjsunit/messages.js b/deps/v8/test/mjsunit/messages.js
index a57e1fcf1c..934a731e8f 100644
--- a/deps/v8/test/mjsunit/messages.js
+++ b/deps/v8/test/mjsunit/messages.js
@@ -70,12 +70,24 @@ test(function() {
 
 // kCalledOnNullOrUndefined
 test(function() {
+  String.prototype.includes.call(null);
+}, "String.prototype.includes called on null or undefined", TypeError);
+
+test(function() {
   Array.prototype.shift.call(null);
 }, "Array.prototype.shift called on null or undefined", TypeError);
 
 test(function() {
-  String.prototype.includes.call(null);
-}, "String.prototype.includes called on null or undefined", TypeError);
+  String.prototype.trim.call(null);
+}, "String.prototype.trim called on null or undefined", TypeError);
+
+test(function() {
+  String.prototype.trimLeft.call(null);
+}, "String.prototype.trimLeft called on null or undefined", TypeError);
+
+test(function() {
+  String.prototype.trimRight.call(null);
+}, "String.prototype.trimRight called on null or undefined", TypeError);
 
 // kCannotFreezeArrayBufferView
 test(function() {
@@ -428,6 +440,11 @@ test(function() {
   new Uint16Array(-1);
 }, "Invalid typed array length: -1", RangeError);
 
+// kThrowInvalidStringLength
+test(function() {
+  "a".repeat(1 << 30);
+}, "Invalid string length", RangeError);
+
 // kNormalizationForm
 test(function() {
   "".normalize("ABC");
diff --git a/deps/v8/test/mjsunit/mjsunit.js b/deps/v8/test/mjsunit/mjsunit.js
index 77f8b7605b..d3db2e2e94 100644
--- a/deps/v8/test/mjsunit/mjsunit.js
+++ b/deps/v8/test/mjsunit/mjsunit.js
@@ -550,7 +550,7 @@ var failWithMessage;
             try {
               success(result);
             } catch (e) {
-              failWithMessage(e);
+              failWithMessage(String(e));
             }
           },
           result => {
@@ -582,7 +582,8 @@ var failWithMessage;
     return OptimizationStatusImpl(fun, sync_opt);
   }
 
-  assertUnoptimized = function assertUnoptimized(fun, sync_opt, name_opt) {
+  assertUnoptimized = function assertUnoptimized(fun, sync_opt, name_opt,
+      skip_if_maybe_deopted = true) {
     if (sync_opt === undefined) sync_opt = "";
     var opt_status = OptimizationStatus(fun, sync_opt);
     // Tests that use assertUnoptimized() do not make sense if --always-opt
@@ -590,7 +591,8 @@ var failWithMessage;
     assertFalse((opt_status & V8OptimizationStatus.kAlwaysOptimize) !== 0,
                 "test does not make sense with --always-opt");
     assertTrue((opt_status & V8OptimizationStatus.kIsFunction) !== 0, name_opt);
-    if ((opt_status & V8OptimizationStatus.kMaybeDeopted) !== 0) {
+    if (skip_if_maybe_deopted &&
+        (opt_status & V8OptimizationStatus.kMaybeDeopted) !== 0) {
       // When --deopt-every-n-times flag is specified it's no longer guaranteed
       // that particular function is still deoptimized, so keep running the test
       // to stress test the deoptimizer.
@@ -599,7 +601,8 @@ var failWithMessage;
     assertFalse((opt_status & V8OptimizationStatus.kOptimized) !== 0, name_opt);
   }
 
-  assertOptimized = function assertOptimized(fun, sync_opt, name_opt) {
+  assertOptimized = function assertOptimized(fun, sync_opt, name_opt,
+      skip_if_maybe_deopted = true) {
     if (sync_opt === undefined) sync_opt = "";
     var opt_status = OptimizationStatus(fun, sync_opt);
     // Tests that use assertOptimized() do not make sense if --no-opt
@@ -607,7 +610,8 @@ var failWithMessage;
     assertFalse((opt_status & V8OptimizationStatus.kNeverOptimize) !== 0,
                 "test does not make sense with --no-opt");
     assertTrue((opt_status & V8OptimizationStatus.kIsFunction) !== 0, name_opt);
-    if ((opt_status & V8OptimizationStatus.kMaybeDeopted) !== 0) {
+    if (skip_if_maybe_deopted &&
+        (opt_status & V8OptimizationStatus.kMaybeDeopted) !== 0) {
       // When --deopt-every-n-times flag is specified it's no longer guaranteed
       // that particular function is still optimized, so keep running the test
       // to stress test the deoptimizer.
diff --git a/deps/v8/test/mjsunit/mjsunit.status b/deps/v8/test/mjsunit/mjsunit.status
index 4f49fdd595..b1b6f6aeb1 100644
--- a/deps/v8/test/mjsunit/mjsunit.status
+++ b/deps/v8/test/mjsunit/mjsunit.status
@@ -328,6 +328,7 @@
   'unicodelctest-no-optimization': [PASS, SLOW],
   'unicodelctest': [PASS, SLOW],
   'unicode-test': [PASS, SLOW],
+  'wasm/atomics': [PASS, SLOW],
   'whitespaces': [PASS, SLOW],
 }],  # 'arch == arm64'
 
@@ -656,4 +657,10 @@
     'mjsunit-assertion-error' : [SKIP],
 }], # no_harness
 
+##############################################################################
+['arch != x64 or deopt_fuzzer', {
+    # Skip stress-deopt-count tests since it's in x64 only
+    'compiler/stress-deopt-count-*': [SKIP],
+}], # arch != x64 or deopt_fuzzer
+
 ]
diff --git a/deps/v8/test/mjsunit/optimized-foreach-polymorph.js b/deps/v8/test/mjsunit/optimized-foreach-polymorph.js
new file mode 100644
index 0000000000..ed4958354f
--- /dev/null
+++ b/deps/v8/test/mjsunit/optimized-foreach-polymorph.js
@@ -0,0 +1,111 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --expose-gc --turbo-inline-array-builtins
+
+var a = [0, 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,0,0];
+var b = [{}, {}];
+var c = [,,,,,2,3,4];
+var d = [0.5,3,4];
+var e = [,,,,0.5,3,4];
+
+// Make sure that calls to forEach handle a certain degree of polymorphism (no
+// hole check)
+(function() {
+  var result = 0;
+  var polymorph1 = function(arg) {
+    var sum = function(v,i,o) {
+      result += i;
+    }
+    arg.forEach(sum);
+  }
+  polymorph1(a);
+  polymorph1(a);
+  polymorph1(b);
+  polymorph1(a);
+  polymorph1(a);
+  %OptimizeFunctionOnNextCall(polymorph1);
+  polymorph1(a);
+  polymorph1(b);
+  assertEquals(1757, result);
+})();
+
+// Make sure that calls to forEach handle a certain degree of polymorphism.
+(function() {
+  var result = 0;
+  var polymorph1 = function(arg) {
+    var sum = function(v,i,o) {
+      result += i;
+    }
+    arg.forEach(sum);
+  }
+  polymorph1(a);
+  polymorph1(a);
+  polymorph1(b);
+  polymorph1(a);
+  polymorph1(c);
+  polymorph1(a);
+  %OptimizeFunctionOnNextCall(polymorph1);
+  polymorph1(a);
+  polymorph1(b);
+  assertEquals(1775, result);
+})();
+
+// Make sure that calls to forEach with mixed object/double arrays don't inline
+// forEach.
+(function() {
+  var result = 0;
+  var polymorph1 = function(arg) {
+    var sum = function(v,i,o) {
+      result += i;
+    }
+    arg.forEach(sum);
+  }
+  polymorph1(a);
+  polymorph1(a);
+  polymorph1(b);
+  polymorph1(a);
+  polymorph1(d);
+  polymorph1(a);
+  %OptimizeFunctionOnNextCall(polymorph1);
+  polymorph1(a);
+  polymorph1(b);
+  assertEquals(1760, result);
+})();
+
+// Make sure that calls to forEach with double arrays get the right result
+(function() {
+  var result = 0;
+  var polymorph1 = function(arg) {
+    var sum = function(v,i,o) {
+      result += v;
+    }
+    arg.forEach(sum);
+  }
+  polymorph1(d);
+  polymorph1(d);
+  polymorph1(d);
+  %OptimizeFunctionOnNextCall(polymorph1);
+  polymorph1(d);
+  polymorph1(d);
+  assertEquals(37.5, result);
+})();
+
+// Make sure that calls to forEach with mixed double arrays get the right result
+(function() {
+  var result = 0;
+  var polymorph1 = function(arg) {
+    var sum = function(v,i,o) {
+      result += v;
+    }
+    arg.forEach(sum);
+  }
+  polymorph1(d);
+  polymorph1(e);
+  polymorph1(d);
+  %OptimizeFunctionOnNextCall(polymorph1);
+  polymorph1(d);
+  polymorph1(e);
+  assertEquals(37.5, result);
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-2435.js b/deps/v8/test/mjsunit/regress/regress-2435.js
new file mode 100644
index 0000000000..05a4027339
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-2435.js
@@ -0,0 +1,25 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+function arrayLikeToString(a) {
+  return String.fromCharCode.apply(this, a);
+}
+
+const klasses = [
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array
+];
+const string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+
+for (const klass of klasses) {
+  const array = klass.from(string, s => s.charCodeAt(0));
+  assertEquals(string, arrayLikeToString(array));
+}
diff --git a/deps/v8/test/mjsunit/regress/regress-6838-1.js b/deps/v8/test/mjsunit/regress/regress-6838-1.js
new file mode 100644
index 0000000000..bab6a194d3
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-6838-1.js
@@ -0,0 +1,33 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function TestMathMaxOnLargeInt() {
+  function Module(stdlib) {
+    "use asm";
+    var max = stdlib.Math.max;
+    function f() {
+      return max(42,0xffffffff);
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(0xffffffff, f());
+  assertFalse(%IsAsmWasmCode(Module));
+})();
+
+(function TestMathMinOnLargeInt() {
+  function Module(stdlib) {
+    "use asm";
+    var min = stdlib.Math.min;
+    function f() {
+      return min(42,0xffffffff);
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(42, f());
+  assertFalse(%IsAsmWasmCode(Module));
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-6838-2.js b/deps/v8/test/mjsunit/regress/regress-6838-2.js
new file mode 100644
index 0000000000..31b94b43c2
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-6838-2.js
@@ -0,0 +1,101 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function TestMathCeilReturningFloatish() {
+  function Module(stdlib) {
+    "use asm";
+    var ceil = stdlib.Math.ceil;
+    var fround = stdlib.Math.fround;
+    function f(a) {
+      a = fround(a);
+      return ceil(a);
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(3, f(2.2));
+  assertFalse(%IsAsmWasmCode(Module));
+})();
+
+(function TestMathFloorReturningFloatish() {
+  function Module(stdlib) {
+    "use asm";
+    var floor = stdlib.Math.floor;
+    var fround = stdlib.Math.fround;
+    function f(a) {
+      a = fround(a);
+      return floor(a);
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(2, f(2.2));
+  assertFalse(%IsAsmWasmCode(Module));
+})();
+
+(function TestMathSqrtReturningFloatish() {
+  function Module(stdlib) {
+    "use asm";
+    var sqrt = stdlib.Math.sqrt;
+    var fround = stdlib.Math.fround;
+    function f(a) {
+      a = fround(a);
+      return sqrt(a);
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(Math.sqrt(Math.fround(2.2)), f(2.2));
+  assertFalse(%IsAsmWasmCode(Module));
+})();
+
+(function TestMathAbsReturningFloatish() {
+  function Module(stdlib) {
+    "use asm";
+    var abs = stdlib.Math.abs;
+    var fround = stdlib.Math.fround;
+    function f(a) {
+      a = fround(a);
+      return abs(a);
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(Math.fround(2.2), f(-2.2));
+  assertFalse(%IsAsmWasmCode(Module));
+})();
+
+(function TestMathMinReturningFloat() {
+  function Module(stdlib) {
+    "use asm";
+    var min = stdlib.Math.min;
+    var fround = stdlib.Math.fround;
+    function f(a) {
+      a = fround(a);
+      return min(a, a);
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(Math.fround(2.2), f(2.2));
+  assertTrue(%IsAsmWasmCode(Module));
+})();
+
+(function TestMathMaxReturningFloat() {
+  function Module(stdlib) {
+    "use asm";
+    var max = stdlib.Math.max;
+    var fround = stdlib.Math.fround;
+    function f(a) {
+      a = fround(a);
+      return max(a, a);
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(Math.fround(2.2), f(2.2));
+  assertTrue(%IsAsmWasmCode(Module));
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-6838-3.js b/deps/v8/test/mjsunit/regress/regress-6838-3.js
new file mode 100644
index 0000000000..639ffa5da7
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-6838-3.js
@@ -0,0 +1,39 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function TestMathAbsReturningUnsigned() {
+  function Module(stdlib) {
+    "use asm";
+    var abs=stdlib.Math.abs;
+    function f(a, b) {
+      a = a | 0;
+      b = b | 0;
+      return (abs(a >> 0) == (b >>> 0)) | 0;
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(0, f(1, 2));
+  assertEquals(1, f(23, 23));
+  assertEquals(1, f(-42, 42));
+  assertEquals(1, f(-0x7fffffff, 0x7fffffff));
+  assertEquals(1, f(-0x80000000, 0x80000000));
+  assertTrue(%IsAsmWasmCode(Module));
+})();
+
+(function TestMathAbsOverflowSignedValue() {
+  function Module(stdlib) {
+    "use asm";
+    var abs=stdlib.Math.abs;
+    function f() {
+      return (abs(-0x80000000) > 0) | 0;
+    }
+    return f;
+  }
+  var f = Module(this);
+  assertEquals(1, f());
+  assertTrue(%IsAsmWasmCode(Module));
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-6907.js b/deps/v8/test/mjsunit/regress/regress-6907.js
new file mode 100644
index 0000000000..0749365fed
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-6907.js
@@ -0,0 +1,21 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function TestDematerializedContextInBuiltin() {
+  var f = function() {
+    var b = [1,2,3];
+    var callback = function(v,i,o) {
+      %_DeoptimizeNow();
+    };
+    try { throw 0 } catch(e) {
+      return b.forEach(callback);
+    }
+  }
+  f();
+  f();
+  %OptimizeFunctionOnNextCall(f);
+  f();
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-719380.js b/deps/v8/test/mjsunit/regress/regress-719380.js
index 18d541a5fe..4d41609c51 100644
--- a/deps/v8/test/mjsunit/regress/regress-719380.js
+++ b/deps/v8/test/mjsunit/regress/regress-719380.js
@@ -3,5 +3,5 @@
 // found in the LICENSE file.
 
 TypeError.prototype.__defineGetter__("name", () => { throw 42; });
-console.log({ toString: () => { throw new TypeError() }});
+try { console.log({ toString: () => { throw new TypeError() }}); } catch (e) {}
 try { new WebAssembly.Table({}); } catch (e) {}
diff --git a/deps/v8/test/mjsunit/regress/regress-760268.js b/deps/v8/test/mjsunit/regress/regress-760268.js
new file mode 100644
index 0000000000..6884ae1dca
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-760268.js
@@ -0,0 +1,11 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+var obj = this;
+var handler = {
+  has: function() { return false; }
+}
+var proxy = new Proxy(obj, handler);
+Object.defineProperty(obj, "nonconf", {});
+assertThrows("'nonconf' in proxy");
diff --git a/deps/v8/test/mjsunit/regress/regress-760790.js b/deps/v8/test/mjsunit/regress/regress-760790.js
new file mode 100644
index 0000000000..75770bad18
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-760790.js
@@ -0,0 +1,11 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+function g() {
+  var a = Array(0);
+  a[0]++;
+}
+g();
+g();
+g();
diff --git a/deps/v8/test/mjsunit/regress/regress-761639.js b/deps/v8/test/mjsunit/regress/regress-761639.js
new file mode 100644
index 0000000000..a5fa69f6d8
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-761639.js
@@ -0,0 +1,10 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Regression test for hitting a DCHECK in StoreProxy.
+
+
+for (var i = 0; i < 10; i++) {
+  __proto__ = new Proxy({}, { getPrototypeOf() { } });
+}
diff --git a/deps/v8/test/mjsunit/regress/regress-772190.js b/deps/v8/test/mjsunit/regress/regress-772190.js
new file mode 100644
index 0000000000..008ed63b4d
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-772190.js
@@ -0,0 +1,10 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --always-opt
+
+assertThrows(function() {
+  __v_13383[4];
+  let __v_13383 = {};
+});
diff --git a/deps/v8/test/mjsunit/regress/regress-774475.js b/deps/v8/test/mjsunit/regress/regress-774475.js
new file mode 100644
index 0000000000..b11ea6c231
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-774475.js
@@ -0,0 +1,938 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+var o = function f3() {
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+  x = 1;
+}
diff --git a/deps/v8/test/mjsunit/regress/regress-781218.js b/deps/v8/test/mjsunit/regress/regress-781218.js
new file mode 100644
index 0000000000..ae00cc5c08
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-781218.js
@@ -0,0 +1,43 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+var m = new Map();
+
+function C() { }
+
+// Make sure slack tracking kicks in and shrinks the default size to prevent
+// any further in-object properties.
+%CompleteInobjectSlackTracking(new C());
+
+function f(o) {
+  o.x = true;
+}
+
+// Warm up {f}.
+f(new C());
+f(new C());
+
+
+var o = new C();
+%HeapObjectVerify(o);
+
+m.set(o, 1);  // This creates hash code on o.
+
+// Add an out-of-object property.
+o.x = true;
+%HeapObjectVerify(o);
+// Delete the property (so we have no out-of-object properties).
+delete o.x;
+%HeapObjectVerify(o);
+
+
+// Ensure that growing the properties backing store in optimized code preserves
+// the hash.
+%OptimizeFunctionOnNextCall(f);
+f(o);
+
+%HeapObjectVerify(o);
+assertEquals(1, m.get(o));
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-537444.js b/deps/v8/test/mjsunit/regress/regress-crbug-537444.js
index 6f56fd148d..d6fe6b89a3 100644
--- a/deps/v8/test/mjsunit/regress/regress-crbug-537444.js
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-537444.js
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --allow-natives-syntax
+// Flags: --allow-natives-syntax --stress-inline
 
 "use strict";
 
@@ -19,8 +19,6 @@ function h(x) {
   return z + 1;
 }
 
-%SetForceInlineFlag(g);
-%SetForceInlineFlag(f);
 
 h(1);
 h(1);
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-593697-2.js b/deps/v8/test/mjsunit/regress/regress-crbug-593697-2.js
index c8af4a4e08..c26fdfdf67 100644
--- a/deps/v8/test/mjsunit/regress/regress-crbug-593697-2.js
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-593697-2.js
@@ -2,12 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --allow-natives-syntax
+// Flags: --allow-natives-syntax --stress-inline
 
 "use strict";
 
-%SetForceInlineFlag(Math.cos);
-
 var f5 = (function f6(stdlib) {
   "use asm";
   var cos = stdlib.Math.cos;
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-598998.js b/deps/v8/test/mjsunit/regress/regress-crbug-598998.js
index bbabf1e31d..a2a02623f5 100644
--- a/deps/v8/test/mjsunit/regress/regress-crbug-598998.js
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-598998.js
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --allow-natives-syntax
+// Flags: --allow-natives-syntax --stress-inline
 
 "use strict";
 
@@ -22,8 +22,6 @@ function h(x) {
   g(x, 1);
 }
 
-%SetForceInlineFlag(g);
-%SetForceInlineFlag(f);
 %NeverOptimizeFunction(deopt_function);
 
 h(1);
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-608278.js b/deps/v8/test/mjsunit/regress/regress-crbug-608278.js
index 251ecad86c..c8d2fcc745 100644
--- a/deps/v8/test/mjsunit/regress/regress-crbug-608278.js
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-608278.js
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --allow-natives-syntax
+// Flags: --allow-natives-syntax --stress-inline
 
 "use strict";
 
@@ -21,7 +21,6 @@ function h() {
 function g(v) {
   return h();
 }
-%SetForceInlineFlag(g);
 
 
 function f1() {
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-647217.js b/deps/v8/test/mjsunit/regress/regress-crbug-647217.js
index e3968a19d6..ab45c9afa9 100644
--- a/deps/v8/test/mjsunit/regress/regress-crbug-647217.js
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-647217.js
@@ -2,11 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --allow-natives-syntax --stack-size=100
+// Flags: --allow-natives-syntax --stack-size=100 --stress-inline
 
 var source = "return 1" + new Array(2048).join(' + a') + "";
 eval("function g(a) {" + source + "}");
-%SetForceInlineFlag(g);
 
 function f(a) { return g(a) }
 %OptimizeFunctionOnNextCall(f);
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-714696.js b/deps/v8/test/mjsunit/regress/regress-crbug-714696.js
index 16b09604e9..ad5925478d 100644
--- a/deps/v8/test/mjsunit/regress/regress-crbug-714696.js
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-714696.js
@@ -5,6 +5,6 @@
 if (this.Intl) {
   new Intl.v8BreakIterator();
   new Intl.DateTimeFormat();
-  console.log({ toString: function() { throw 1; }});
+  try { console.log({ toString: function() { throw 1; }}); } catch (e) {}
   new Intl.v8BreakIterator();
 }
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-722871.js b/deps/v8/test/mjsunit/regress/regress-crbug-722871.js
new file mode 100644
index 0000000000..c5b7958f49
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-722871.js
@@ -0,0 +1,113 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+let sab = new SharedArrayBuffer(10 * 4);
+let memory = new Int32Array(sab);
+let workers = [];
+let runningWorkers = 0;
+
+function startWorker(script) {
+  let worker = new Worker(script);
+  worker.done = false;
+  worker.idx = workers.length;
+  workers.push(worker);
+  worker.postMessage(memory);
+  ++runningWorkers;
+};
+
+let shared = `
+  function wait(memory, index, waitCondition, wakeCondition) {
+    while (memory[index] == waitCondition) {
+      var result = Atomics.wait(memory, index, waitCondition);
+      switch (result) {
+        case 'not-equal':
+        case 'ok':
+          break;
+        default:
+          postMessage('Error: bad result from wait: ' + result);
+          break;
+      }
+      var value = memory[index];
+      if (value != wakeCondition) {
+        postMessage(
+            'Error: wait returned not-equal but the memory has a bad value: ' +
+            value);
+      }
+    }
+    var value = memory[index];
+    if (value != wakeCondition) {
+      postMessage(
+          'Error: done waiting but the memory has a bad value: ' + value);
+    }
+  }
+
+  function wake(memory, index) {
+    var result = Atomics.wake(memory, index, 1);
+    if (result != 0 && result != 1) {
+      postMessage('Error: bad result from wake: ' + result);
+    }
+  }
+`;
+
+let worker1 = startWorker(shared + `
+  onmessage = function(msg) {
+    let memory = msg;
+    const didStartIdx = 0;
+    const shouldGoIdx = 1;
+    const didEndIdx = 2;
+
+    postMessage("started");
+    postMessage("memory: " + memory);
+    wait(memory, didStartIdx, 0, 1);
+    memory[shouldGoIdx] = 1;
+    wake(memory, shouldGoIdx);
+    wait(memory, didEndIdx, 0, 1);
+    postMessage("memory: " + memory);
+    postMessage("done");
+  };
+`);
+
+let worker2 = startWorker(shared + `
+  onmessage = function(msg) {
+    let memory = msg;
+    const didStartIdx = 0;
+    const shouldGoIdx = 1;
+    const didEndIdx = 2;
+
+    postMessage("started");
+    postMessage("memory: " + memory);
+    Atomics.store(memory, didStartIdx, 1);
+    wake(memory, didStartIdx);
+    wait(memory, shouldGoIdx, 0, 1);
+    Atomics.store(memory, didEndIdx, 1);
+    wake(memory, didEndIdx, 1);
+    postMessage("memory: " + memory);
+    postMessage("done");
+  };
+`);
+
+let running = true;
+while (running) {
+  for (let worker of workers) {
+    if (worker.done) continue;
+
+    let msg = worker.getMessage();
+    if (msg) {
+      switch (msg) {
+        case "done":
+          if (worker.done === false) {
+            print("worker #" + worker.idx + " done.");
+            worker.done = true;
+            if (--runningWorkers === 0) {
+              running = false;
+            }
+          }
+          break;
+
+        default:
+          print("msg from worker #" + worker.idx + ": " + msg);
+          break;
+      }
+    }
+  }
+}
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-764219.js b/deps/v8/test/mjsunit/regress/regress-crbug-764219.js
new file mode 100644
index 0000000000..2a92d66d2e
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-764219.js
@@ -0,0 +1,35 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+(function() {
+  function f(o) {
+    o.x = 42;
+  };
+
+  f({});
+  f(this);
+  f(this);
+})();
+
+(function() {
+  function f(o) {
+    o.y = 153;
+  };
+
+  Object.setPrototypeOf(this, new Proxy({}, {}));
+  f({});
+  f(this);
+  f(this);
+})();
+
+(function() {
+  function f(o) {
+    o.z = 153;
+  };
+
+  Object.setPrototypeOf(this, new Proxy({get z(){}}, {}));
+  f({});
+  f(this);
+  f(this);
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-768080.js b/deps/v8/test/mjsunit/regress/regress-crbug-768080.js
new file mode 100644
index 0000000000..cfd1fc1f35
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-768080.js
@@ -0,0 +1,64 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function TestReflectConstructBogusNewTarget1() {
+  class C {}
+  function g() {
+    Reflect.construct(C, arguments, 23);
+  }
+  function f() {
+    return new g();
+  }
+  new C();  // Warm-up!
+  assertThrows(f, TypeError);
+  assertThrows(f, TypeError);
+  %OptimizeFunctionOnNextCall(f);
+  assertThrows(f, TypeError);
+})();
+
+(function TestReflectConstructBogusNewTarget2() {
+  class C {}
+  // Note that {unescape} is an example of a non-constructable function. If that
+  // ever changes and this test needs to be adapted, make sure to choose another
+  // non-constructable {JSFunction} object instead.
+  function g() {
+    Reflect.construct(C, arguments, unescape);
+  }
+  function f() {
+    return new g();
+  }
+  new C();  // Warm-up!
+  assertThrows(f, TypeError);
+  assertThrows(f, TypeError);
+  %OptimizeFunctionOnNextCall(f);
+  assertThrows(f, TypeError);
+})();
+
+(function TestReflectConstructBogusTarget() {
+  function g() {
+    Reflect.construct(23, arguments);
+  }
+  function f() {
+    return new g();
+  }
+  assertThrows(f, TypeError);
+  assertThrows(f, TypeError);
+  %OptimizeFunctionOnNextCall(f);
+  assertThrows(f, TypeError);
+})();
+
+(function TestReflectApplyBogusTarget() {
+  function g() {
+    Reflect.apply(23, this, arguments);
+  }
+  function f() {
+    return g();
+  }
+  assertThrows(f, TypeError);
+  assertThrows(f, TypeError);
+  %OptimizeFunctionOnNextCall(f);
+  assertThrows(f, TypeError);
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-768367.js b/deps/v8/test/mjsunit/regress/regress-crbug-768367.js
new file mode 100644
index 0000000000..d1041f32ce
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-768367.js
@@ -0,0 +1,14 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+const o = {};
+
+function foo() { return o[4294967295]; }
+
+assertEquals(undefined, foo());
+assertEquals(undefined, foo());
+%OptimizeFunctionOnNextCall(foo);
+assertEquals(undefined, foo());
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-769852.js b/deps/v8/test/mjsunit/regress/regress-crbug-769852.js
new file mode 100644
index 0000000000..120ea0109e
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-769852.js
@@ -0,0 +1,14 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+function f(o) {
+  function g() {}
+  Object.keys(o).forEach(suite => g());
+}
+assertDoesNotThrow(() => f({}));
+assertDoesNotThrow(() => f({ x:0 }));
+%OptimizeFunctionOnNextCall(f);
+assertDoesNotThrow(() => f({ x:0 }));
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-770543.js b/deps/v8/test/mjsunit/regress/regress-crbug-770543.js
new file mode 100644
index 0000000000..5397a499c3
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-770543.js
@@ -0,0 +1,31 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+(function FunctionCallerFromInlinedBuiltin() {
+  function f() {
+    function g() {
+      Object.getOwnPropertyDescriptor(g, "caller");
+    };
+    [0].forEach(g);
+  }
+  f();
+  f();
+  %OptimizeFunctionOnNextCall(f);
+  f();
+})();
+
+(function FunctionArgumentsFromInlinedBuiltin() {
+  function g() {
+    g.arguments;
+  }
+  function f() {
+    [0].forEach(g);
+  }
+  f();
+  f();
+  %OptimizeFunctionOnNextCall(f);
+  f();
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-770581.js b/deps/v8/test/mjsunit/regress/regress-crbug-770581.js
new file mode 100644
index 0000000000..64edec97cd
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-770581.js
@@ -0,0 +1,22 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+function f(callback) {
+  [Object].forEach(callback);
+}
+
+function message_of_f() {
+  try {
+    f("a teapot");
+  } catch(e) {
+    return String(e);
+  }
+}
+
+assertEquals("TypeError: a teapot is not a function", message_of_f());
+assertEquals("TypeError: a teapot is not a function", message_of_f());
+%OptimizeFunctionOnNextCall(f);
+assertEquals("TypeError: a teapot is not a function", message_of_f());
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-771971.js b/deps/v8/test/mjsunit/regress/regress-crbug-771971.js
new file mode 100644
index 0000000000..cb40db5aa3
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-771971.js
@@ -0,0 +1,12 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+function f() { Object.is(); }
+
+f();
+f();
+%OptimizeFunctionOnNextCall(f);
+f();
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-772056.js b/deps/v8/test/mjsunit/regress/regress-crbug-772056.js
new file mode 100644
index 0000000000..380bae356d
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-772056.js
@@ -0,0 +1,17 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --expose-wasm
+
+load("test/mjsunit/wasm/wasm-constants.js");
+load("test/mjsunit/wasm/wasm-module-builder.js");
+
+var builder = new WasmModuleBuilder();
+builder.addImportedTable("x", "table", 1, 10000000);
+let module = new WebAssembly.Module(builder.toBuffer());
+let table = new WebAssembly.Table({element: "anyfunc",
+  initial: 1, maximum:1000000});
+let instance = new WebAssembly.Instance(module, {x: {table:table}});
+
+assertThrows(() => table.grow(Infinity), RangeError);
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-772610.js b/deps/v8/test/mjsunit/regress/regress-crbug-772610.js
new file mode 100644
index 0000000000..d68ebbf2be
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-772610.js
@@ -0,0 +1,18 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --verify-heap --expose-gc
+
+function f() {
+  var o = [{
+    [Symbol.toPrimitive]() {}
+  }];
+  %_DeoptimizeNow();
+  return o.length;
+}
+assertEquals(1, f());
+assertEquals(1, f());
+%OptimizeFunctionOnNextCall(f);
+assertEquals(1, f());
+gc();
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-772672.js b/deps/v8/test/mjsunit/regress/regress-crbug-772672.js
new file mode 100644
index 0000000000..86e738344a
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-772672.js
@@ -0,0 +1,11 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+function foo() { return new Array(120 * 1024); }
+
+foo()[0] = 0.1;
+%OptimizeFunctionOnNextCall(foo);
+foo();
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-772689.js b/deps/v8/test/mjsunit/regress/regress-crbug-772689.js
new file mode 100644
index 0000000000..32e220daa7
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-772689.js
@@ -0,0 +1,23 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+const A = class A extends Array {
+  constructor() {
+    super();
+    this.y = 1;
+  }
+}
+
+function foo(x) {
+  var a = new A();
+  if (x) return a.y;
+}
+
+assertEquals(undefined, foo(false));
+assertEquals(undefined, foo(false));
+%OptimizeFunctionOnNextCall(foo);
+assertEquals(undefined, foo(false));
+assertEquals(1, foo(true));
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-772720.js b/deps/v8/test/mjsunit/regress/regress-crbug-772720.js
new file mode 100644
index 0000000000..3e359f6c16
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-772720.js
@@ -0,0 +1,15 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+var global;
+function f() {
+  var local = 'abcdefghijklmnopqrst';
+  local += 'abcdefghijkl' + (0 + global);
+  global += 'abcdefghijkl';
+}
+f();
+%OptimizeFunctionOnNextCall(f);
+f();
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-772897.js b/deps/v8/test/mjsunit/regress/regress-crbug-772897.js
new file mode 100644
index 0000000000..c2e4b25fb0
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-772897.js
@@ -0,0 +1,20 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+function store(obj, name) {
+  return obj[name] = 0;
+}
+
+function f(obj) {
+  var key = {
+    toString() { throw new Error("boom"); }
+  };
+  store(obj, key);
+}
+
+(function() {
+  var proxy = new Proxy({}, {});
+  store(proxy, 0)
+  assertThrows(() => f(proxy), Error);
+})();
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-774994.js b/deps/v8/test/mjsunit/regress/regress-crbug-774994.js
new file mode 100644
index 0000000000..5810417f79
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-774994.js
@@ -0,0 +1,34 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Flags: --preparser-scope-analysis
+
+function f() {
+  new class extends Object {
+    constructor() {
+      eval("super(); super.__f_10();");
+    }
+  }
+}
+assertThrows(f, TypeError);
+
+function g() {
+  let obj = {
+    m() {
+      eval("super.foo()");
+    }
+  }
+  obj.m();
+}
+assertThrows(g, TypeError);
+
+function h() {
+  let obj = {
+    get m() {
+      eval("super.foo()");
+    }
+  }
+  obj.m;
+}
+assertThrows(h, TypeError);
diff --git a/deps/v8/test/mjsunit/regress/regress-crbug-783132.js b/deps/v8/test/mjsunit/regress/regress-crbug-783132.js
new file mode 100644
index 0000000000..600a6bf5b6
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-crbug-783132.js
@@ -0,0 +1,15 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --verify-heap
+
+function f(o, v) {
+  try {
+    f(o, v + 1);
+  } catch (e) {
+  }
+  o[v] = 43.35 + v * 5.3;
+}
+
+f(Array.prototype, 0);
diff --git a/deps/v8/test/mjsunit/regress/regress-v8-6940.js b/deps/v8/test/mjsunit/regress/regress-v8-6940.js
new file mode 100644
index 0000000000..c5bb6a950a
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/regress-v8-6940.js
@@ -0,0 +1,9 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+assertTrue(/[ŸŶ]/i.test('ÿ'));
+assertTrue(/[ŸY]/i.test('ÿ'));
+
+assertTrue(/[YÝŸŶỲ]/i.test('ÿ'));
+assertTrue(/[YÝŸŶỲ]/iu.test('ÿ'));
diff --git a/deps/v8/test/mjsunit/regress/wasm/regress-775710.js b/deps/v8/test/mjsunit/regress/wasm/regress-775710.js
new file mode 100644
index 0000000000..5e6fb8c50b
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/wasm/regress-775710.js
@@ -0,0 +1,20 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --validate-asm --allow-natives-syntax
+
+const kMaxLocals = 50000;
+const fn_template = '"use asm";\nfunction f() { LOCALS }\nreturn f;';
+for (var num_locals = kMaxLocals; num_locals < kMaxLocals + 2; ++num_locals) {
+  const fn_code = fn_template.replace(
+      'LOCALS',
+      Array(num_locals)
+          .fill()
+          .map((_, idx) => 'var l' + idx + ' = 0;')
+          .join('\n'));
+  const asm_fn = new Function(fn_code);
+  const f = asm_fn();
+  f();
+  assertEquals(num_locals <= kMaxLocals, %IsAsmWasmCode(asm_fn));
+}
diff --git a/deps/v8/test/mjsunit/regress/wasm/regression-648079.js b/deps/v8/test/mjsunit/regress/wasm/regression-648079.js
index 2fa6b4db7a..acc6146ef5 100644
--- a/deps/v8/test/mjsunit/regress/wasm/regression-648079.js
+++ b/deps/v8/test/mjsunit/regress/wasm/regression-648079.js
@@ -8,7 +8,6 @@ load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
 
 // Non-standard opcodes.
-let kWasmS128 = 0x7b;
 let kSig_s_v = makeSig([], [kWasmS128]);
 let kExprS128LoadMem = 0xc0;
 
diff --git a/deps/v8/test/mjsunit/regress/wasm/regression-702460.js b/deps/v8/test/mjsunit/regress/wasm/regression-702460.js
index 2d63440255..73c01e13a0 100644
--- a/deps/v8/test/mjsunit/regress/wasm/regression-702460.js
+++ b/deps/v8/test/mjsunit/regress/wasm/regression-702460.js
@@ -6,7 +6,6 @@ load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
 
 // Non-standard opcodes.
-let kWasmS128 = 0x7b;
 let kSig_s_v = makeSig([], [kWasmS128]);
 let kExprS128LoadMem = 0xc0;
 
diff --git a/deps/v8/test/mjsunit/regress/wasm/regression-763697.js b/deps/v8/test/mjsunit/regress/wasm/regression-763697.js
new file mode 100644
index 0000000000..faf74e1cff
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/wasm/regression-763697.js
@@ -0,0 +1,15 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --expose-wasm --no-experimental-wasm-simd
+
+load('test/mjsunit/wasm/wasm-constants.js');
+load('test/mjsunit/wasm/wasm-module-builder.js');
+
+let builder = new WasmModuleBuilder();
+    builder.addFunction("main", kSig_i_i)
+      .addBody([kExprGetLocal, 0])
+      .addLocals({s128_count: 1});
+
+  assertFalse(WebAssembly.validate(builder.toBuffer()));
diff --git a/deps/v8/test/mjsunit/regress/wasm/regression-769846.js b/deps/v8/test/mjsunit/regress/wasm/regression-769846.js
new file mode 100644
index 0000000000..297da84f5f
--- /dev/null
+++ b/deps/v8/test/mjsunit/regress/wasm/regression-769846.js
@@ -0,0 +1,15 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+function Module() {
+  "use asm";
+  function div_(__v_6) {
+    __v_6 = __v_6 | 0;
+  }
+  return { f: div_}
+};
+var __f_0 = Module().f;
+__v_8 = [0];
+__v_8.__defineGetter__(0, function() { return __f_0(__v_8); });
+__v_8[0];
diff --git a/deps/v8/test/mjsunit/skipping-inner-functions-bailout.js b/deps/v8/test/mjsunit/skipping-inner-functions-bailout.js
index f09f1d9bb7..f2b6c5bc41 100644
--- a/deps/v8/test/mjsunit/skipping-inner-functions-bailout.js
+++ b/deps/v8/test/mjsunit/skipping-inner-functions-bailout.js
@@ -76,3 +76,9 @@ function TestMultiBailout3() {
   function not_skippable_either() {}
 }
 TestMultiBailout3();
+
+// Regression test for
+// https://bugs.chromium.org/p/chromium/issues/detail?id=761980. The conditions
+// triggering a bailout occur in a context where we're not generating data
+// anyway (inside an arrow function). (This needs to be at top level.)
+x => { (y=eval()) => {} }
diff --git a/deps/v8/test/mjsunit/skipping-inner-functions.js b/deps/v8/test/mjsunit/skipping-inner-functions.js
index 51c9fd5534..e228b258c4 100644
--- a/deps/v8/test/mjsunit/skipping-inner-functions.js
+++ b/deps/v8/test/mjsunit/skipping-inner-functions.js
@@ -295,3 +295,73 @@ function TestSkippableFunctionInForOfHeaderAndBody() {
 }
 
 TestSkippableFunctionInForOfHeaderAndBody();
+
+(function TestSkippableGeneratorInSloppyBlock() {
+  var result = 0;
+
+  function lazy(ctxt_alloc_param) {
+    var ctxt_alloc_var = 10;
+    {
+      function *skip_me() {
+        result = ctxt_alloc_param + ctxt_alloc_var;
+        yield 3;
+      }
+      return skip_me;
+    }
+  }
+  // Test that parameters and variables of the outer function get context
+  // allocated even if we skip the inner function.
+  assertEquals(3, lazy(9)().next().value);
+  assertEquals(19, result);
+})();
+
+(function TestRestoringDataToAsyncArrowFunctionWithNonSimpleParams_1() {
+  // Regression test for
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=765532
+  function lazy() {
+    // The arrow function is not skippable, but we need to traverse its scopes
+    // and restore data to them.
+    async(a=0) => { const d = 0; }
+    function skippable() {}
+  }
+  lazy();
+})();
+
+(function TestRestoringDataToAsyncArrowFunctionWithNonSimpleParams_2() {
+  // Regression test for
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=765532
+  function lazy() {
+    // The arrow function is not skippable, but we need to traverse its scopes
+    // and restore data to them.
+    async(...a) => { const d = 0; }
+    function skippable() {}
+  }
+  lazy();
+})();
+
+(function TestSloppyBlockFunctionShadowingCatchVariable() {
+  // Regression test for
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=771474
+  function lazy() {
+    try {
+    } catch (my_var) {
+      if (false) {
+        function my_var() { }
+      }
+    }
+  }
+  lazy();
+})();
+
+
+(function TestLazinessDecisionWithDefaultConstructors() {
+  // Regression test for
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=773576
+
+  // The problem was that Parser and PreParser treated default constructors
+  // differently, and that threw off the "next / previous function is likely
+  // called" logic.
+
+  function lazy(p = (function() {}, class {}, function() {}, class { method1() { } })) { }
+  lazy();
+})();
diff --git a/deps/v8/test/mjsunit/string-charcodeat.js b/deps/v8/test/mjsunit/string-charcodeat.js
index 335c4b317f..6031096e0b 100644
--- a/deps/v8/test/mjsunit/string-charcodeat.js
+++ b/deps/v8/test/mjsunit/string-charcodeat.js
@@ -239,6 +239,3 @@ for (var i = 0; i < 5; i++) {
 }
 %OptimizeFunctionOnNextCall(directlyOnPrototype);
 directlyOnPrototype();
-
-assertTrue(isNaN(%_StringCharCodeAt("ABC", -1)));
-assertTrue(isNaN(%_StringCharCodeAt("ABC", 4)));
diff --git a/deps/v8/test/mjsunit/third_party/regexp-pcre/regexp-pcre.js b/deps/v8/test/mjsunit/third_party/regexp-pcre/regexp-pcre.js
index 68b8f0525b..8b603e45d1 100644
--- a/deps/v8/test/mjsunit/third_party/regexp-pcre/regexp-pcre.js
+++ b/deps/v8/test/mjsunit/third_party/regexp-pcre/regexp-pcre.js
@@ -899,7 +899,7 @@ res[819] = /:/;
 res[820] = /([\da-f:]+)$/i;
 res[821] = /^.*\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
 res[822] = /^(\d+)\s+IN\s+SOA\s+(\S+)\s+(\S+)\s*\(\s*$/;
-res[823] = /^[a-zA-Z\d][a-zA-Z\d\-]*(\.[a-zA-Z\d][a-zA-z\d\-]*)*\.$/;
+res[823] = /^[a-zA-Z\d][a-zA-Z\d\-]*(\.[a-zA-Z\d][a-zA-Z\d\-]*)*\.$/;
 res[824] = /^\*\.[a-z]([a-z\-\d]*[a-z\d]+)?(\.[a-z]([a-z\-\d]*[a-z\d]+)?)*$/;
 res[825] = /^(?=ab(de))(abd)(e)/;
 res[826] = /^(?!(ab)de|x)(abd)(f)/;
diff --git a/deps/v8/test/mjsunit/type-profile/collect-type-profile.js b/deps/v8/test/mjsunit/type-profile/collect-type-profile.js
deleted file mode 100644
index d21d11d9d2..0000000000
--- a/deps/v8/test/mjsunit/type-profile/collect-type-profile.js
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright 2017 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Flags: --type-profile --allow-natives-syntax
-
-function check_collect_types(name, expected) {
-  const type_profile = %TypeProfile(name);
-  if (type_profile !== undefined) {
-    const result = JSON.stringify(type_profile);
-    print(result);
-    assertEquals(expected, result, name + " failed");
-
-  }
-}
-
-function testFunction(param, flag) {
-  // We want to test 2 different return positions in one function.
-  if (flag) {
-    var first_var = param;
-    return first_var;
-  }
-  var second_var = param;
-  return second_var;
-}
-
-class MyClass {
-  constructor() {}
-}
-
-var expected = `{}`;
-check_collect_types(testFunction, expected);
-
-testFunction({});
-testFunction(123, true);
-testFunction('hello');
-testFunction(123);
-
-expected = `{\"495\":[\"Object\",\"number\",\"string\",\"number\"],\"502\":[\"undefined\",\"boolean\",\"undefined\",\"undefined\"],\"691\":[\"Object\",\"number\",\"string\",\"number\"]}`;
-check_collect_types(testFunction, expected);
-
-testFunction(undefined);
-testFunction('hello', true);
-testFunction({x: 12}, true);
-testFunction({x: 12});
-testFunction(new MyClass());
-
-expected = `{\"495\":[\"Object\",\"number\",\"string\",\"number\",\"undefined\",\"string\",\"Object\",\"Object\",\"MyClass\"],\"502\":[\"undefined\",\"boolean\",\"undefined\",\"undefined\",\"undefined\",\"boolean\",\"boolean\",\"undefined\",\"undefined\"],\"691\":[\"Object\",\"number\",\"string\",\"number\",\"undefined\",\"string\",\"Object\",\"Object\",\"MyClass\"]}`;
-check_collect_types(testFunction, expected);
-
-
-function testReturnOfNonVariable() {
-  return 32;
-}
-testReturnOfNonVariable();
-expected = `{\"1724\":[\"number\"]}`;
-check_collect_types(testReturnOfNonVariable, expected);
-
-// Return statement is reached but its expression is never really returned.
-function try_finally() {
-  try {
-    return 23;
-  } finally {
-    return "nope, string is better"
-  }
-}
-try_finally();
-expected = `{\"2026\":[\"string\"]}`;
-check_collect_types(try_finally, expected);
-
-// Fall-off return.
-function fall_off() {
-  //nothing
-}
-fall_off();
-expected = `{\"2180\":[\"undefined\"]}`;
-check_collect_types(fall_off, expected);
-
-// Do not collect types when the function is never run.
-function never_called() {}
-expected = `{}`;
-check_collect_types(never_called, expected);
-
-
-function several_params(a, b, c, d) {
-  //nothing
-}
-several_params(2, 'foo', {}, new MyClass());
-expected = `{\"2448\":[\"number\"],\"2451\":[\"string\"],\"2454\":[\"Object\"],\"2457\":[\"MyClass\"],\"2474\":[\"undefined\"]}`;
-check_collect_types(several_params, expected);
diff --git a/deps/v8/test/mjsunit/unbox-double-arrays.js b/deps/v8/test/mjsunit/unbox-double-arrays.js
index 2bebddb449..d6fc0938f9 100644
--- a/deps/v8/test/mjsunit/unbox-double-arrays.js
+++ b/deps/v8/test/mjsunit/unbox-double-arrays.js
@@ -50,11 +50,6 @@ function force_to_fast_double_array(a) {
   assertTrue(%HasDoubleElements(a));
 }
 
-function make_object_like_array(size) {
-  obj = new Object();
-  obj.length = size;
-  return obj;
-}
 
 function testOneArrayType(allocator) {
   var large_array = new allocator(large_array_size);
@@ -349,11 +344,18 @@ function testOneArrayType(allocator) {
   assertTrue(%HasDoubleElements(large_array));
 }
 
+class ArraySubclass extends Array {
+  constructor(...args) {
+    super(...args);
+    this.marker = 42;
+  }
+}
+
 // Force gc here to start with a clean heap if we repeat this test multiple
 // times.
 gc();
-testOneArrayType(make_object_like_array);
 testOneArrayType(Array);
+testOneArrayType(ArraySubclass);
 
 var large_array = new Array(large_array_size);
 force_to_fast_double_array(large_array);
diff --git a/deps/v8/test/mjsunit/value-of.js b/deps/v8/test/mjsunit/value-of.js
index 1a242c0ec4..88dad0a9b9 100644
--- a/deps/v8/test/mjsunit/value-of.js
+++ b/deps/v8/test/mjsunit/value-of.js
@@ -25,8 +25,18 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-function MyException() { }
+let valueOf = Object.prototype.valueOf;
+
+assertEquals('object', typeof valueOf.call(true));
+assertEquals('object', typeof valueOf.call(false));
+assertEquals('object', typeof valueOf.call(1.23));
+assertEquals('object', typeof valueOf.call(0));
+assertEquals('object', typeof valueOf.call('a'));
+assertEquals('object', typeof valueOf.call(Symbol.isConcatSpreadable));
+assertThrows(() => valueOf.call(undefined), TypeError);
+assertThrows(() => valueOf.call(null), TypeError);
 
+function MyException() { }
 var o = new Object();
 o.valueOf = function() { throw new MyException(); }
 
diff --git a/deps/v8/test/mjsunit/wasm/asm-with-wasm-off.js b/deps/v8/test/mjsunit/wasm/asm-with-wasm-off.js
index bf3bbe712f..2fec37d6e8 100644
--- a/deps/v8/test/mjsunit/wasm/asm-with-wasm-off.js
+++ b/deps/v8/test/mjsunit/wasm/asm-with-wasm-off.js
@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --validate-asm --allow-natives-syntax
+// Flags: --noexpose-wasm --validate-asm --allow-natives-syntax
 
-// NOTE: This is in it's own file because it calls %DisallowCodegenFromStrings,
+// NOTE: This is in its own file because it calls %DisallowCodegenFromStrings,
 // which messes with the isolate's state.
 (function testAsmWithWasmOff() {
-  %DisallowCodegenFromStrings();
+  %DisallowCodegenFromStrings(true);
   function Module() {
     'use asm';
     function foo() {
diff --git a/deps/v8/test/mjsunit/wasm/atomics.js b/deps/v8/test/mjsunit/wasm/atomics.js
index 089accb45b..a8940af1d1 100644
--- a/deps/v8/test/mjsunit/wasm/atomics.js
+++ b/deps/v8/test/mjsunit/wasm/atomics.js
@@ -21,43 +21,77 @@ function Exchange(a, b) { return b; }
 let maxSize = 10;
 let memory = new WebAssembly.Memory({initial: 1, maximum: maxSize, shared: true});
 
-function GetAtomicBinOpFunction(wasmExpression) {
+function GetAtomicBinOpFunction(wasmExpression, alignment, offset) {
   let builder = new WasmModuleBuilder();
-  builder.addImportedMemory("m", "imported_mem");
+  builder.addImportedMemory("m", "imported_mem", 0, maxSize, "shared");
   builder.addFunction("main", kSig_i_ii)
     .addBody([
       kExprGetLocal, 0,
       kExprGetLocal, 1,
       kAtomicPrefix,
-      wasmExpression])
+      wasmExpression, alignment, offset])
     .exportAs("main");
 
   // Instantiate module, get function exports
   let module = new WebAssembly.Module(builder.toBuffer());
-  let instance = (new WebAssembly.Instance(module,
-        {m: {imported_mem: memory}}));
+  let instance = new WebAssembly.Instance(module,
+        {m: {imported_mem: memory}});
   return instance.exports.main;
 }
 
-function GetAtomicCmpExchangeFunction(wasmExpression) {
+function GetAtomicCmpExchangeFunction(wasmExpression, alignment, offset) {
   let builder = new WasmModuleBuilder();
-  builder.addImportedMemory("m", "imported_mem");
+  builder.addImportedMemory("m", "imported_mem", 0, maxSize, "shared");
   builder.addFunction("main", kSig_i_iii)
     .addBody([
       kExprGetLocal, 0,
       kExprGetLocal, 1,
       kExprGetLocal, 2,
       kAtomicPrefix,
-      wasmExpression])
+      wasmExpression, alignment, offset])
     .exportAs("main");
 
   // Instantiate module, get function exports
   let module = new WebAssembly.Module(builder.toBuffer());
-  let instance = (new WebAssembly.Instance(module,
-        {m: {imported_mem: memory}}));
+  let instance = new WebAssembly.Instance(module,
+        {m: {imported_mem: memory}});
   return instance.exports.main;
 }
 
+function GetAtomicLoadFunction(wasmExpression, alignment, offset) {
+  let builder = new WasmModuleBuilder();
+  builder.addImportedMemory("m", "imported_mem", 0, maxSize, "shared");
+  builder.addFunction("main", kSig_i_i)
+    .addBody([
+      kExprGetLocal, 0,
+      kAtomicPrefix,
+      wasmExpression, alignment, offset])
+    .exportAs("main");
+
+  // Instantiate module, get function exports
+  let module = new WebAssembly.Module(builder.toBuffer());
+  let instance = new WebAssembly.Instance(module,
+        {m: {imported_mem: memory}});
+  return instance.exports.main;
+}
+
+function GetAtomicStoreFunction(wasmExpression, alignment, offset) {
+  let builder = new WasmModuleBuilder();
+  builder.addImportedMemory("m", "imported_mem", 0, maxSize, "shared");
+  builder.addFunction("main", kSig_v_ii)
+    .addBody([
+      kExprGetLocal, 0,
+      kExprGetLocal, 1,
+      kAtomicPrefix,
+      wasmExpression, alignment, offset])
+    .exportAs("main");
+
+  // Instantiate module, get function exports
+  let module = new WebAssembly.Module(builder.toBuffer());
+  let instance = new WebAssembly.Instance(module,
+        {m: {imported_mem: memory}});
+  return instance.exports.main;
+}
 
 function VerifyBoundsCheck(func, memtype_size) {
   const kPageSize = 65536;
@@ -108,109 +142,109 @@ function Test8Op(operation, func) {
 
 (function TestAtomicAdd() {
   print("TestAtomicAdd");
-  let wasmAdd = GetAtomicBinOpFunction(kExprI32AtomicAdd);
+  let wasmAdd = GetAtomicBinOpFunction(kExprI32AtomicAdd, 2, 0);
   Test32Op(Add, wasmAdd);
 })();
 
 (function TestAtomicAdd16U() {
   print("TestAtomicAdd16U");
-  let wasmAdd = GetAtomicBinOpFunction(kExprI32AtomicAdd16U);
+  let wasmAdd = GetAtomicBinOpFunction(kExprI32AtomicAdd16U, 1, 0);
   Test16Op(Add, wasmAdd);
 })();
 
 (function TestAtomicAdd8U() {
   print("TestAtomicAdd8U");
-  let wasmAdd = GetAtomicBinOpFunction(kExprI32AtomicAdd8U);
+  let wasmAdd = GetAtomicBinOpFunction(kExprI32AtomicAdd8U, 0, 0);
   Test8Op(Add, wasmAdd);
 })();
 
 (function TestAtomicSub() {
   print("TestAtomicSub");
-  let wasmSub = GetAtomicBinOpFunction(kExprI32AtomicSub);
+  let wasmSub = GetAtomicBinOpFunction(kExprI32AtomicSub, 2, 0);
   Test32Op(Sub, wasmSub);
 })();
 
 (function TestAtomicSub16U() {
   print("TestAtomicSub16U");
-  let wasmSub = GetAtomicBinOpFunction(kExprI32AtomicSub16U);
+  let wasmSub = GetAtomicBinOpFunction(kExprI32AtomicSub16U, 1, 0);
   Test16Op(Sub, wasmSub);
 })();
 
 (function TestAtomicSub8U() {
   print("TestAtomicSub8U");
-  let wasmSub = GetAtomicBinOpFunction(kExprI32AtomicSub8U);
+  let wasmSub = GetAtomicBinOpFunction(kExprI32AtomicSub8U, 0, 0);
   Test8Op(Sub, wasmSub);
 })();
 
 (function TestAtomicAnd() {
   print("TestAtomicAnd");
-  let wasmAnd = GetAtomicBinOpFunction(kExprI32AtomicAnd);
+  let wasmAnd = GetAtomicBinOpFunction(kExprI32AtomicAnd, 2, 0);
   Test32Op(And, wasmAnd);
 })();
 
 (function TestAtomicAnd16U() {
   print("TestAtomicAnd16U");
-  let wasmAnd = GetAtomicBinOpFunction(kExprI32AtomicAnd16U);
+  let wasmAnd = GetAtomicBinOpFunction(kExprI32AtomicAnd16U, 1, 0);
   Test16Op(And, wasmAnd);
 })();
 
 (function TestAtomicAnd8U() {
   print("TestAtomicAnd8U");
-  let wasmAnd = GetAtomicBinOpFunction(kExprI32AtomicAnd8U);
+  let wasmAnd = GetAtomicBinOpFunction(kExprI32AtomicAnd8U, 0, 0);
   Test8Op(And, wasmAnd);
 })();
 
 (function TestAtomicOr() {
   print("TestAtomicOr");
-  let wasmOr = GetAtomicBinOpFunction(kExprI32AtomicOr);
+  let wasmOr = GetAtomicBinOpFunction(kExprI32AtomicOr, 2, 0);
   Test32Op(Or, wasmOr);
 })();
 
 (function TestAtomicOr16U() {
   print("TestAtomicOr16U");
-  let wasmOr = GetAtomicBinOpFunction(kExprI32AtomicOr16U);
+  let wasmOr = GetAtomicBinOpFunction(kExprI32AtomicOr16U, 1, 0);
   Test16Op(Or, wasmOr);
 })();
 
 (function TestAtomicOr8U() {
   print("TestAtomicOr8U");
-  let wasmOr = GetAtomicBinOpFunction(kExprI32AtomicOr8U);
+  let wasmOr = GetAtomicBinOpFunction(kExprI32AtomicOr8U, 0, 0);
   Test8Op(Or, wasmOr);
 })();
 
 (function TestAtomicXor() {
   print("TestAtomicXor");
-  let wasmXor = GetAtomicBinOpFunction(kExprI32AtomicXor);
+  let wasmXor = GetAtomicBinOpFunction(kExprI32AtomicXor, 2, 0);
   Test32Op(Xor, wasmXor);
 })();
 
 (function TestAtomicXor16U() {
   print("TestAtomicXor16U");
-  let wasmXor = GetAtomicBinOpFunction(kExprI32AtomicXor16U);
+  let wasmXor = GetAtomicBinOpFunction(kExprI32AtomicXor16U, 1, 0);
   Test16Op(Xor, wasmXor);
 })();
 
 (function TestAtomicXor8U() {
   print("TestAtomicXor8U");
-  let wasmXor = GetAtomicBinOpFunction(kExprI32AtomicXor8U);
+  let wasmXor = GetAtomicBinOpFunction(kExprI32AtomicXor8U, 0, 0);
   Test8Op(Xor, wasmXor);
 })();
 
 (function TestAtomicExchange() {
   print("TestAtomicExchange");
-  let wasmExchange = GetAtomicBinOpFunction(kExprI32AtomicExchange);
+  let wasmExchange = GetAtomicBinOpFunction(kExprI32AtomicExchange, 2, 0);
   Test32Op(Exchange, wasmExchange);
 })();
 
 (function TestAtomicExchange16U() {
   print("TestAtomicExchange16U");
-  let wasmExchange = GetAtomicBinOpFunction(kExprI32AtomicExchange16U);
+  let wasmExchange = GetAtomicBinOpFunction(kExprI32AtomicExchange16U, 1, 0);
   Test16Op(Exchange, wasmExchange);
 })();
 
 (function TestAtomicExchange8U() {
   print("TestAtomicExchange8U");
-  let wasmExchange = GetAtomicBinOpFunction(kExprI32AtomicExchange8U);
+  let wasmExchange = GetAtomicBinOpFunction(kExprI32AtomicExchange8U, 0, 0);
   Test8Op(Exchange, wasmExchange);
 })();
 
@@ -232,7 +266,7 @@ function TestCmpExchange(func, buffer, params, size) {
 (function TestAtomicCompareExchange() {
   print("TestAtomicCompareExchange");
   let wasmCmpExchange =
-      GetAtomicCmpExchangeFunction(kExprI32AtomicCompareExchange);
+      GetAtomicCmpExchangeFunction(kExprI32AtomicCompareExchange, 2, 0);
   let i32 = new Uint32Array(memory.buffer);
   let params = [0x00000001, 0x00000555, 0x00099999, 0xffffffff];
   TestCmpExchange(wasmCmpExchange, i32, params, kMemtypeSize32);
@@ -241,7 +275,7 @@ function TestCmpExchange(func, buffer, params, size) {
 (function TestAtomicCompareExchange16U() {
   print("TestAtomicCompareExchange16U");
   let wasmCmpExchange =
-      GetAtomicCmpExchangeFunction(kExprI32AtomicCompareExchange16U);
+      GetAtomicCmpExchangeFunction(kExprI32AtomicCompareExchange16U, 1, 0);
   let i16 = new Uint16Array(memory.buffer);
   let params = [0x0001, 0x0555, 0x9999];
   TestCmpExchange(wasmCmpExchange, i16, params, kMemtypeSize16);
@@ -250,8 +284,130 @@ function TestCmpExchange(func, buffer, params, size) {
 (function TestAtomicCompareExchange8U() {
   print("TestAtomicCompareExchange8U");
   let wasmCmpExchange =
-      GetAtomicCmpExchangeFunction(kExprI32AtomicCompareExchange8U);
+      GetAtomicCmpExchangeFunction(kExprI32AtomicCompareExchange8U, 0, 0);
   let i8 = new Uint8Array(memory.buffer);
   let params = [0x01, 0x0d, 0xf9];
   TestCmpExchange(wasmCmpExchange, i8, params, kMemtypeSize8);
 })();
+
+function TestLoad(func, buffer, value, size) {
+  for (let i = 0; i < buffer.length; i++) {
+    buffer[i] = value;
+    assertEquals(value, func(i * size) >>> 0);
+  }
+  VerifyBoundsCheck(func, size);
+}
+
+(function TestAtomicLoad() {
+  print("TestAtomicLoad");
+  let wasmLoad = GetAtomicLoadFunction(kExprI32AtomicLoad, 2, 0);
+  let i32 = new Uint32Array(memory.buffer);
+  let value = 0xacedaced;
+  TestLoad(wasmLoad, i32, value, kMemtypeSize32);
+})();
+
+(function TestAtomicLoad16U() {
+  print("TestAtomicLoad16U");
+  let wasmLoad = GetAtomicLoadFunction(kExprI32AtomicLoad16U, 1, 0);
+  let i16 = new Uint16Array(memory.buffer);
+  let value = 0xaced;
+  TestLoad(wasmLoad, i16, value, kMemtypeSize16);
+})();
+
+(function TestAtomicLoad8U() {
+  print("TestAtomicLoad8U");
+  let wasmLoad = GetAtomicLoadFunction(kExprI32AtomicLoad8U, 0, 0);
+  let i8 = new Uint8Array(memory.buffer);
+  let value = 0xac;
+  TestLoad(wasmLoad, i8, value, kMemtypeSize8);
+})();
+
+function TestStore(func, buffer, value, size) {
+  for (let i = 0; i < buffer.length; i++) {
+    func(i * size, value)
+    assertEquals(value, buffer[i]);
+  }
+  VerifyBoundsCheck(func, size);
+}
+
+(function TestAtomicStore() {
+  print("TestAtomicStore");
+  let wasmStore = GetAtomicStoreFunction(kExprI32AtomicStore, 2, 0);
+  let i32 = new Uint32Array(memory.buffer);
+  let value = 0xacedaced;
+  TestStore(wasmStore, i32, value, kMemtypeSize32);
+})();
+
+(function TestAtomicStore16U() {
+  print("TestAtomicStore16U");
+  let wasmStore = GetAtomicStoreFunction(kExprI32AtomicStore16U, 1, 0);
+  let i16 = new Uint16Array(memory.buffer);
+  let value = 0xaced;
+  TestStore(wasmStore, i16, value, kMemtypeSize16);
+})();
+
+(function TestAtomicStore8U() {
+  print("TestAtomicStore8U");
+  let wasmStore = GetAtomicStoreFunction(kExprI32AtomicStore8U, 0, 0);
+  let i8 = new Uint8Array(memory.buffer);
+  let value = 0xac;
+  TestCmpExchange(wasmStore, i8, value, kMemtypeSize8);
+})();
+
+(function TestAtomicLoadStoreOffset() {
+  print("TestAtomicLoadStoreOffset");
+  var builder = new WasmModuleBuilder();
+  let memory = new WebAssembly.Memory({
+    initial: 16, maximum: 128, shared: true});
+  builder.addImportedMemory("m", "imported_mem", 16, 128, "shared");
+  builder.addFunction("loadStore", kSig_i_v)
+    .addBody([
+      kExprI32Const, 16,
+      kExprI32Const, 20,
+      kAtomicPrefix,
+      kExprI32AtomicStore, 0, 0xFC, 0xFF, 0x3a,
+      kExprI32Const, 16,
+      kAtomicPrefix,
+      kExprI32AtomicLoad, 0, 0xFC, 0xFF, 0x3a])
+    .exportAs("loadStore");
+  builder.addFunction("storeOob", kSig_v_v)
+    .addBody([
+      kExprI32Const, 16,
+      kExprI32Const, 20,
+      kAtomicPrefix,
+      kExprI32AtomicStore, 0, 0xFC, 0xFF, 0xFF, 0x3a])
+    .exportAs("storeOob");
+  let module = new WebAssembly.Module(builder.toBuffer());
+  let instance = (new WebAssembly.Instance(module,
+        {m: {imported_mem: memory}}));
+  let buf = memory.buffer;
+  assertEquals(20, instance.exports.loadStore());
+  assertTraps(kTrapMemOutOfBounds, instance.exports.storeOob);
+})();
+
+(function TestAtomicOpinLoop() {
+  print("TestAtomicOpinLoop");
+  var builder = new WasmModuleBuilder();
+  let memory = new WebAssembly.Memory({
+    initial: 16, maximum: 128, shared: true});
+  builder.addImportedMemory("m", "imported_mem", 16, 128, "shared");
+  builder.addFunction("main", kSig_i_v)
+    .addBody([
+      kExprLoop, kWasmStmt,
+        kExprI32Const, 16,
+        kExprI32Const, 20,
+        kAtomicPrefix,
+        kExprI32AtomicStore, 2, 0,
+        kExprI32Const, 16,
+        kAtomicPrefix,
+        kExprI32AtomicLoad, 2, 0,
+        kExprReturn,
+      kExprEnd,
+      kExprI32Const, 0
+    ])
+    .exportFunc();
+  let module = new WebAssembly.Module(builder.toBuffer());
+  let instance = (new WebAssembly.Instance(module,
+        {m: {imported_mem: memory}}));
+  assertEquals(20, instance.exports.main());
+})();
diff --git a/deps/v8/test/mjsunit/wasm/disable-trap-handler.js b/deps/v8/test/mjsunit/wasm/disable-trap-handler.js
new file mode 100644
index 0000000000..3389ba8cad
--- /dev/null
+++ b/deps/v8/test/mjsunit/wasm/disable-trap-handler.js
@@ -0,0 +1,9 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax --no-wasm-trap-handler
+
+// This test makes sure that --no-wasm-trap-handler has the correct effect.
+
+assertFalse(%IsWasmTrapHandlerEnabled());
diff --git a/deps/v8/test/mjsunit/wasm/disallow-codegen.js b/deps/v8/test/mjsunit/wasm/disallow-codegen.js
new file mode 100644
index 0000000000..3374a9efd7
--- /dev/null
+++ b/deps/v8/test/mjsunit/wasm/disallow-codegen.js
@@ -0,0 +1,104 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --expose-wasm --allow-natives-syntax
+
+load("test/mjsunit/wasm/wasm-constants.js");
+load("test/mjsunit/wasm/wasm-module-builder.js");
+
+let kReturnValue = 19;
+
+let buffer = (function CreateBuffer() {
+  let builder = new WasmModuleBuilder();
+  builder.addMemory(1, 1, true);
+  builder.addFunction('main', kSig_i_v)
+      .addBody([kExprI32Const, kReturnValue])
+      .exportFunc();
+
+  return builder.toBuffer();
+})();
+
+%DisallowCodegenFromStrings(true);
+
+async function SyncTestOk() {
+  print('sync module compile (ok)...');
+  %DisallowCodegenFromStrings(false);
+  let module = new WebAssembly.Module(buffer);
+  assertInstanceof(module, WebAssembly.Module);
+}
+
+async function SyncTestFail() {
+  print('sync module compile (fail)...');
+  %DisallowCodegenFromStrings(true);
+  try {
+    let module = new WebAssembly.Module(buffer);
+    assertUnreachable();
+  } catch (e) {
+    print("  " + e);
+    assertInstanceof(e, WebAssembly.CompileError);
+  }
+}
+
+async function AsyncTestOk() {
+  print('async module compile (ok)...');
+  %DisallowCodegenFromStrings(false);
+  let promise = WebAssembly.compile(buffer);
+  assertPromiseResult(
+    promise, module => assertInstanceof(module, WebAssembly.Module));
+}
+
+async function AsyncTestFail() {
+  print('async module compile (fail)...');
+  %DisallowCodegenFromStrings(true);
+  try {
+    let m = await WebAssembly.compile(buffer);
+    assertUnreachable();
+  } catch (e) {
+    print("  " + e);
+    assertInstanceof(e, WebAssembly.CompileError);
+  }
+}
+
+async function StreamingTestOk() {
+  print('streaming module compile (ok)...');
+  // TODO(titzer): compileStreaming must be supplied by embedder.
+  // (and it takes a response, not a buffer)
+  %DisallowCodegenFromStrings(false);
+  if ("Function" != typeof WebAssembly.compileStreaming) {
+    print("  no embedder for streaming compilation");
+    return;
+  }
+  let promise = WebAssembly.compileStreaming(buffer);
+  assertPromiseResult(
+    promise, module => assertInstanceof(module, WebAssembly.Module));
+}
+
+async function StreamingTestFail() {
+  print('streaming module compile (fail)...');
+  %DisallowCodegenFromStrings(true);
+  // TODO(titzer): compileStreaming must be supplied by embedder.
+  // (and it takes a response, not a buffer)
+  if ("Function" != typeof WebAssembly.compileStreaming) {
+    print("  no embedder for streaming compilation");
+    return;
+  }
+  try {
+    let m = await WebAssembly.compileStreaming(buffer);
+    assertUnreachable();
+  } catch (e) {
+    print("  " + e);
+    assertInstanceof(e, WebAssembly.CompileError);
+  }
+}
+
+async function RunAll() {
+  await SyncTestOk();
+  await SyncTestFail();
+  await AsyncTestOk();
+  await AsyncTestFail();
+  await StreamingTestOk();
+  await StreamingTestFail();
+}
+
+assertPromiseResult(RunAll());
diff --git a/deps/v8/test/mjsunit/wasm/exceptions.js b/deps/v8/test/mjsunit/wasm/exceptions.js
index 8fcfd15ff4..74d8e7dfb5 100644
--- a/deps/v8/test/mjsunit/wasm/exceptions.js
+++ b/deps/v8/test/mjsunit/wasm/exceptions.js
@@ -19,7 +19,7 @@ var test_throw = (function () {
         kExprI32Const, 0,
         kExprI32Ne,
         kExprIf, kWasmStmt,
-        kExprThrow, 0,
+          kExprThrow, 0,
         kExprEnd,
         kExprI32Const, 1
       ]).exportFunc();
@@ -36,8 +36,8 @@ assertEquals("function", typeof test_throw.exports.throw_if_param_not_zero);
 
 // Test expected behavior of throws
 assertEquals(1, test_throw.exports.throw_if_param_not_zero(0));
-assertWasmThrows([], function() { test_throw.exports.throw_if_param_not_zero(10) });
-assertWasmThrows([], function() { test_throw.exports.throw_if_param_not_zero(-1) });
+assertWasmThrows(0, [], function() { test_throw.exports.throw_if_param_not_zero(10) });
+assertWasmThrows(0, [], function() { test_throw.exports.throw_if_param_not_zero(-1) });
 
 // Now that we know throwing works, we test catching the exceptions we raise.
 var test_catch = (function () {
@@ -72,32 +72,315 @@ assertEquals("function", typeof test_catch.exports.simple_throw_catch_to_0_1);
 assertEquals(0, test_catch.exports.simple_throw_catch_to_0_1(0));
 assertEquals(1, test_catch.exports.simple_throw_catch_to_0_1(1));
 
+// Test that we can distinguish which exception was thrown.
+var test_catch_2 = (function () {
+  var builder = new WasmModuleBuilder();
+
+  builder.addException(kSig_v_v);
+  builder.addException(kSig_v_v);
+  builder.addException(kSig_v_v);
+  builder.addFunction("catch_different_exceptions", kSig_i_i)
+      .addBody([
+        kExprTry, kWasmI32,
+          kExprTry, kWasmI32,
+            kExprGetLocal, 0,
+            kExprI32Eqz,
+            kExprIf, kWasmStmt,
+              kExprThrow, 0,
+            kExprElse,
+              kExprGetLocal, 0,
+              kExprI32Const, 1,
+              kExprI32Eq,
+              kExprIf, kWasmStmt,
+                kExprThrow, 1,
+              kExprElse,
+                kExprThrow, 2,
+              kExprEnd,
+            kExprEnd,
+            kExprI32Const, 2,
+          kExprCatch, 0,
+            kExprI32Const, 3,
+          kExprEnd,
+        kExprCatch, 1,
+          kExprI32Const, 4,
+        kExprEnd
+      ]).exportFunc();
+  return builder.instantiate();
+})();
+
+assertFalse(test_catch_2 === undefined);
+assertFalse(test_catch_2 === null);
+assertFalse(test_catch_2 === 0);
+assertEquals("object", typeof test_catch_2.exports);
+assertEquals("function", typeof test_catch_2.exports.catch_different_exceptions);
+
+assertEquals(3, test_catch_2.exports.catch_different_exceptions(0));
+assertEquals(4, test_catch_2.exports.catch_different_exceptions(1));
+assertWasmThrows(2, [], function() { test_catch_2.exports.catch_different_exceptions(2) });
+
+// Test throwing an exception with multiple values.
+var test_throw_1_2 = (function() {
+  var builder = new WasmModuleBuilder();
+  builder.addException(kSig_v_ii);
+  builder.addFunction("throw_1_2", kSig_v_v)
+      .addBody([
+        kExprI32Const, 1,
+        kExprI32Const, 2,
+        kExprThrow, 0,
+      ]).exportFunc();
+
+  return builder.instantiate();
+})();
+
+assertFalse(test_throw_1_2 === undefined);
+assertFalse(test_throw_1_2 === null);
+assertFalse(test_throw_1_2 === 0);
+assertEquals("object", typeof test_throw_1_2.exports);
+assertEquals("function", typeof test_throw_1_2.exports.throw_1_2);
+
+assertWasmThrows(0, [0, 1, 0, 2], function() { test_throw_1_2.exports.throw_1_2(); });
+
+// Test throwing/catching the i32 parameter value.
+var test_throw_catch_param_i = (function () {
+  var builder = new WasmModuleBuilder();
+  builder.addException(kSig_v_i);
+  builder.addFunction("throw_catch_param", kSig_i_i)
+      .addBody([
+        kExprTry, kWasmI32,
+          kExprGetLocal, 0,
+          kExprThrow, 0,
+          kExprI32Const, 2,
+        kExprCatch, 0,
+          kExprReturn,
+        kExprEnd,
+      ]).exportFunc();
+
+  return builder.instantiate();
+})();
+
+assertFalse(test_throw_catch_param_i === undefined);
+assertFalse(test_throw_catch_param_i === null);
+assertFalse(test_throw_catch_param_i === 0);
+assertEquals("object", typeof test_throw_catch_param_i.exports);
+assertEquals("function",
+             typeof test_throw_catch_param_i.exports.throw_catch_param);
+
+assertEquals(0, test_throw_catch_param_i.exports.throw_catch_param(0));
+assertEquals(1, test_throw_catch_param_i.exports.throw_catch_param(1));
+assertEquals(10, test_throw_catch_param_i.exports.throw_catch_param(10));
+
+// Test the encoding of a thrown exception with an integer exception.
+
+var test_throw_param_i = (function () {
+  var builder = new WasmModuleBuilder();
+  builder.addException(kSig_v_i);
+  builder.addFunction("throw_param", kSig_v_i)
+      .addBody([
+        kExprGetLocal, 0,
+        kExprThrow, 0,
+      ]).exportFunc();
+
+  return builder.instantiate();
+})();
+
+assertFalse(test_throw_param_i === undefined);
+assertFalse(test_throw_param_i === null);
+assertFalse(test_throw_param_i === 0);
+assertEquals("object", typeof test_throw_param_i.exports);
+assertEquals("function",
+             typeof test_throw_param_i.exports.throw_param);
+
+assertWasmThrows(0, [0, 5], function() { test_throw_param_i.exports.throw_param(5); });
+assertWasmThrows(0, [6, 31026],
+                 function() { test_throw_param_i.exports.throw_param(424242); });
+
+// Test throwing/catching the f32 parameter value.
+var test_throw_catch_param_f = (function () {
+  var builder = new WasmModuleBuilder();
+  builder.addException(kSig_v_f);
+  builder.addFunction("throw_catch_param", kSig_f_f)
+      .addBody([
+        kExprTry, kWasmF32,
+          kExprGetLocal, 0,
+          kExprThrow, 0,
+          kExprF32Const, 0, 0, 0, 0,
+        kExprCatch, 0,
+          kExprReturn,
+        kExprEnd,
+      ]).exportFunc();
+
+  return builder.instantiate();
+})();
+
+assertFalse(test_throw_catch_param_f === undefined);
+assertFalse(test_throw_catch_param_f === null);
+assertFalse(test_throw_catch_param_f === 0);
+assertEquals("object", typeof test_throw_catch_param_f.exports);
+assertEquals("function",
+             typeof test_throw_catch_param_f.exports.throw_catch_param);
+
+assertEquals(5.0, test_throw_catch_param_f.exports.throw_catch_param(5.0));
+assertEquals(10.5, test_throw_catch_param_f.exports.throw_catch_param(10.5));
+
+// Test the encoding of a thrown exception with a float value.
+
+var test_throw_param_f = (function () {
+  var builder = new WasmModuleBuilder();
+  builder.addException(kSig_v_f);
+  builder.addFunction("throw_param", kSig_v_f)
+      .addBody([
+        kExprGetLocal, 0,
+        kExprThrow, 0,
+      ]).exportFunc();
+
+  return builder.instantiate();
+})();
+
+assertFalse(test_throw_param_f === undefined);
+assertFalse(test_throw_param_f === null);
+assertFalse(test_throw_param_f === 0);
+assertEquals("object", typeof test_throw_param_f.exports);
+assertEquals("function",
+             typeof test_throw_param_f.exports.throw_param);
+
+assertWasmThrows(0, [16544, 0],
+                 function() { test_throw_param_f.exports.throw_param(5.0); });
+assertWasmThrows(0, [16680, 0],
+                 function() { test_throw_param_f.exports.throw_param(10.5); });
+
+// Test throwing/catching an I64 value
+var test_throw_catch_param_l = (function () {
+  var builder = new WasmModuleBuilder();
+  builder.addException(kSig_v_l);
+  builder.addFunction("throw_catch_param", kSig_i_i)
+      .addBody([
+        kExprGetLocal, 0,
+        kExprI64UConvertI32,
+        kExprSetLocal, 1,
+        kExprTry, kWasmI32,
+          kExprGetLocal, 1,
+          kExprThrow, 0,
+          kExprI32Const, 2,
+        kExprCatch, 0,
+          kExprGetLocal, 1,
+          kExprI64Eq,
+          kExprIf, kWasmI32,
+            kExprI32Const, 1,
+          kExprElse,
+            kExprI32Const, 0,
+          kExprEnd,
+          // TODO(kschimpf): Why is this return necessary?
+          kExprReturn,
+        kExprEnd,
+      ]).addLocals({i64_count: 1}).exportFunc();
+
+  return builder.instantiate();
+})();
+
+assertFalse(test_throw_catch_param_l === undefined);
+assertFalse(test_throw_catch_param_l === null);
+assertFalse(test_throw_catch_param_l === 0);
+assertEquals("object", typeof test_throw_catch_param_l.exports);
+assertEquals("function",
+             typeof test_throw_catch_param_l.exports.throw_catch_param);
+
+assertEquals(1, test_throw_catch_param_l.exports.throw_catch_param(5));
+assertEquals(1, test_throw_catch_param_l.exports.throw_catch_param(0));
+assertEquals(1, test_throw_catch_param_l.exports.throw_catch_param(-1));
+
+// Test the encoding of a thrown exception with an I64 value.
+
+var test_throw_param_l = (function () {
+  var builder = new WasmModuleBuilder();
+  builder.addException(kSig_v_l);
+  builder.addFunction("throw_param", kSig_v_ii)
+      .addBody([
+        kExprGetLocal, 0,
+        kExprI64UConvertI32,
+        kExprI64Const, 32,
+        kExprI64Shl,
+        kExprGetLocal, 1,
+        kExprI64UConvertI32,
+        kExprI64Ior,
+        kExprThrow, 0
+      ]).exportFunc();
+
+  return builder.instantiate();
+})();
+
+assertFalse(test_throw_param_l === undefined);
+assertFalse(test_throw_param_l === null);
+assertFalse(test_throw_param_l === 0);
+assertEquals("object", typeof test_throw_param_l.exports);
+assertEquals("function",
+             typeof test_throw_param_l.exports.throw_param);
+
+assertWasmThrows(0, [0, 10, 0, 5],
+                 function() { test_throw_param_l.exports.throw_param(10, 5); });
+assertWasmThrows(0, [65535, 65535, 0, 13],
+                 function() { test_throw_param_l.exports.throw_param(-1, 13); });
+
+// Test throwing/catching the F64 parameter value
+var test_throw_catch_param_d = (function () {
+  var builder = new WasmModuleBuilder();
+  builder.addException(kSig_v_d);
+  builder.addFunction("throw_catch_param", kSig_d_d)
+      .addBody([
+        kExprTry, kWasmF64,
+          kExprGetLocal, 0,
+          kExprThrow, 0,
+          kExprF64Const, 0, 0, 0, 0, 0, 0, 0, 0,
+        kExprCatch, 0,
+          kExprReturn,
+        kExprEnd,
+      ]).exportFunc();
+
+  return builder.instantiate();
+})();
+
+assertFalse(test_throw_catch_param_d === undefined);
+assertFalse(test_throw_catch_param_d === null);
+assertFalse(test_throw_catch_param_d === 0);
+assertEquals("object", typeof test_throw_catch_param_d.exports);
+assertEquals("function",
+             typeof test_throw_catch_param_d.exports.throw_catch_param);
+
+assertEquals(5.0, test_throw_catch_param_d.exports.throw_catch_param(5.0));
+assertEquals(10.5, test_throw_catch_param_d.exports.throw_catch_param(10.5));
+
+// Test the encoding of a thrown exception with an f64 value.
+
+var test_throw_param_d = (function () {
+  var builder = new WasmModuleBuilder();
+  builder.addException(kSig_v_d);
+  builder.addFunction("throw_param", kSig_v_f)
+      .addBody([
+        kExprGetLocal, 0,
+        kExprF64ConvertF32,
+        kExprThrow, 0
+      ]).exportFunc();
+
+  return builder.instantiate();
+})();
+
+assertFalse(test_throw_param_d === undefined);
+assertFalse(test_throw_param_d === null);
+assertFalse(test_throw_param_d === 0);
+assertEquals("object", typeof test_throw_param_d.exports);
+assertEquals("function",
+             typeof test_throw_param_d.exports.throw_param);
+
+assertWasmThrows(0, [16404, 0, 0, 0],
+                 function() { test_throw_param_d.exports.throw_param(5.0); });
+assertWasmThrows(0, [16739, 4816, 0, 0],
+                 function() { test_throw_param_d.exports.throw_param(10000000.5); });
+
 /* TODO(kschimpf) Convert these tests to work for the proposed exceptions.
 
 // The following methods do not attempt to catch the exception they raise.
 var test_throw = (function () {
   var builder = new WasmModuleBuilder();
 
-  builder.addFunction("throw_param_if_not_zero", kSig_i_i)
-    .addBody([
-      kExprGetLocal, 0,
-      kExprI32Const, 0,
-      kExprI32Ne,
-      kExprIf, kWasmStmt,
-      kExprGetLocal, 0,
-      kExprThrow,
-      kExprEnd,
-      kExprI32Const, 1
-    ])
-    .exportFunc()
-
-  builder.addFunction("throw_20", kSig_v_v)
-    .addBody([
-      kExprI32Const, 20,
-      kExprThrow,
-    ])
-    .exportFunc()
-
   builder.addFunction("throw_expr_with_params", kSig_v_ddi)
     .addBody([
       // p2 * (p0 + min(p0, p1))|0 - 20
@@ -123,14 +406,9 @@ assertFalse(test_throw === undefined);
 assertFalse(test_throw === null);
 assertFalse(test_throw === 0);
 assertEquals("object", typeof test_throw.exports);
-assertEquals("function", typeof test_throw.exports.throw_param_if_not_zero);
-assertEquals("function", typeof test_throw.exports.throw_20);
 assertEquals("function", typeof test_throw.exports.throw_expr_with_params);
 
 assertEquals(1, test_throw.exports.throw_param_if_not_zero(0));
-assertWasmThrows(10, function() { test_throw.exports.throw_param_if_not_zero(10) });
-assertWasmThrows(-1, function() { test_throw.exports.throw_param_if_not_zero(-1) });
-assertWasmThrows(20, test_throw.exports.throw_20);
 assertWasmThrows(
     -8, function() { test_throw.exports.throw_expr_with_params(1.5, 2.5, 4); });
 assertWasmThrows(
diff --git a/deps/v8/test/mjsunit/wasm/expose-wasm.js b/deps/v8/test/mjsunit/wasm/expose-wasm.js
new file mode 100644
index 0000000000..836c619025
--- /dev/null
+++ b/deps/v8/test/mjsunit/wasm/expose-wasm.js
@@ -0,0 +1,7 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --noexpose-wasm
+
+assertThrows(() => { let x = WebAssembly.compile; });
diff --git a/deps/v8/test/mjsunit/wasm/js-api.js b/deps/v8/test/mjsunit/wasm/js-api.js
index 352f7caefa..952c6296cd 100644
--- a/deps/v8/test/mjsunit/wasm/js-api.js
+++ b/deps/v8/test/mjsunit/wasm/js-api.js
@@ -16,7 +16,7 @@ function unexpectedFail(error) {
 }
 
 function assertEq(val, expected) {
-  assertEquals(expected, val);
+  assertSame(expected, val);
 }
 function assertArrayBuffer(val, expected) {
   assertTrue(val instanceof ArrayBuffer);
@@ -512,13 +512,40 @@ assertTrue(buf !== mem.buffer);
 assertEq(buf.byteLength, 0);
 buf = mem.buffer;
 assertEq(buf.byteLength, kPageSize);
-assertEq(mem.grow(1), 1);
+assertEq(mem.grow(1, 23), 1);
+assertTrue(buf !== mem.buffer);
+assertEq(buf.byteLength, 0);
+buf = mem.buffer;
+assertEq(buf.byteLength, 2 * kPageSize);
+assertEq(mem.grow(), 2);
 assertTrue(buf !== mem.buffer);
 assertEq(buf.byteLength, 0);
 buf = mem.buffer;
 assertEq(buf.byteLength, 2 * kPageSize);
 assertErrorMessage(() => mem.grow(1), Error, /failed to grow memory/);
+assertErrorMessage(() => mem.grow(Infinity), Error, /failed to grow memory/);
+assertErrorMessage(() => mem.grow(-Infinity), Error, /failed to grow memory/);
 assertEq(buf, mem.buffer);
+let throwOnValueOf = {
+  valueOf: function() {
+    throw Error('throwOnValueOf')
+  }
+};
+assertErrorMessage(() => mem.grow(throwOnValueOf), Error, /throwOnValueOf/);
+assertEq(buf, mem.buffer);
+let zero_wrapper = {
+  valueOf: function() {
+    ++this.call_counter;
+    return 0;
+  },
+  call_counter: 0
+};
+assertEq(mem.grow(zero_wrapper), 2);
+assertEq(zero_wrapper.call_counter, 1);
+assertTrue(buf !== mem.buffer);
+assertEq(buf.byteLength, 0);
+buf = mem.buffer;
+assertEq(buf.byteLength, 2 * kPageSize);
 
 let empty_mem = new Memory({initial: 0, maximum: 5});
 let empty_buf = empty_mem.buffer;
@@ -571,8 +598,9 @@ assertTrue(new Table({initial: 1, element: 'anyfunc'}) instanceof Table);
 assertTrue(new Table({initial: 1.5, element: 'anyfunc'}) instanceof Table);
 assertTrue(
     new Table({initial: 1, maximum: 1.5, element: 'anyfunc'}) instanceof Table);
-// TODO:maximum assertTrue(new Table({initial:1, maximum:Math.pow(2,32)-1,
-// element:"anyfunc"}) instanceof Table);
+assertTrue(
+    new Table({initial: 1, maximum: Math.pow(2, 32) - 1, element: 'anyfunc'})
+        instanceof Table);
 
 // 'WebAssembly.Table.prototype' data property
 let tableProtoDesc = Object.getOwnPropertyDescriptor(Table, 'prototype');
@@ -623,15 +651,17 @@ assertErrorMessage(
     () => get.call(), TypeError, /called on incompatible undefined/);
 assertErrorMessage(
     () => get.call({}), TypeError, /called on incompatible Object/);
+assertEq(get.call(tbl1), null);
 assertEq(get.call(tbl1, 0), null);
+assertEq(get.call(tbl1, 0, Infinity), null);
 assertEq(get.call(tbl1, 1), null);
 assertEq(get.call(tbl1, 1.5), null);
 assertErrorMessage(() => get.call(tbl1, 2), RangeError, /bad Table get index/);
 assertErrorMessage(
     () => get.call(tbl1, 2.5), RangeError, /bad Table get index/);
 assertErrorMessage(() => get.call(tbl1, -1), RangeError, /bad Table get index/);
-// TODO assertErrorMessage(() => get.call(tbl1, Math.pow(2,33)), RangeError,
-// /bad Table get index/);
+assertErrorMessage(
+    () => get.call(tbl1, Math.pow(2, 33)), RangeError, /bad Table get index/);
 assertErrorMessage(
     () => get.call(tbl1, {valueOf() { throw new Error('hi') }}), Error, 'hi');
 
@@ -651,15 +681,26 @@ assertErrorMessage(
 assertErrorMessage(
     () => set.call(tbl1, 0), TypeError, /requires more than 1 argument/);
 assertErrorMessage(
+    () => set.call(tbl1, undefined), TypeError,
+    /requires more than 1 argument/);
+assertErrorMessage(
     () => set.call(tbl1, 2, null), RangeError, /bad Table set index/);
 assertErrorMessage(
     () => set.call(tbl1, -1, null), RangeError, /bad Table set index/);
-// TODO assertErrorMessage(() => set.call(tbl1, Math.pow(2,33), null),
-// RangeError, /bad Table set index/);
+assertErrorMessage(
+    () => set.call(tbl1, Math.pow(2, 33), null), RangeError,
+    /bad Table set index/);
+assertErrorMessage(
+    () => set.call(tbl1, Infinity, null), RangeError, /bad Table set index/);
+assertErrorMessage(
+    () => set.call(tbl1, -Infinity, null), RangeError, /bad Table set index/);
 assertErrorMessage(
     () => set.call(tbl1, 0, undefined), TypeError,
     /can only assign WebAssembly exported functions to Table/);
 assertErrorMessage(
+    () => set.call(tbl1, undefined, undefined), TypeError,
+    /can only assign WebAssembly exported functions to Table/);
+assertErrorMessage(
     () => set.call(tbl1, 0, {}), TypeError,
     /can only assign WebAssembly exported functions to Table/);
 assertErrorMessage(() => set.call(tbl1, 0, function() {
@@ -672,6 +713,7 @@ assertErrorMessage(
     'hai');
 assertEq(set.call(tbl1, 0, null), undefined);
 assertEq(set.call(tbl1, 1, null), undefined);
+assertEq(set.call(tbl1, undefined, null), undefined);
 
 // 'WebAssembly.Table.prototype.grow' data property
 let tblGrowDesc = Object.getOwnPropertyDescriptor(tableProto, 'grow');
@@ -693,11 +735,21 @@ assertErrorMessage(
     /bad Table grow delta/);
 var tbl = new Table({element: 'anyfunc', initial: 1, maximum: 2});
 assertEq(tbl.length, 1);
+assertErrorMessage(
+    () => tbl.grow(Infinity), RangeError, /failed to grow table/);
+assertErrorMessage(
+    () => tbl.grow(-Infinity), RangeError, /failed to grow table/);
 assertEq(tbl.grow(0), 1);
 assertEq(tbl.length, 1);
-assertEq(tbl.grow(1), 1);
+assertEq(tbl.grow(1, 4), 1);
+assertEq(tbl.length, 2);
+assertEq(tbl.grow(), 2);
 assertEq(tbl.length, 2);
 assertErrorMessage(() => tbl.grow(1), Error, /failed to grow table/);
+assertErrorMessage(
+    () => tbl.grow(Infinity), RangeError, /failed to grow table/);
+assertErrorMessage(
+    () => tbl.grow(-Infinity), RangeError, /failed to grow table/);
 
 // 'WebAssembly.validate' function
 assertErrorMessage(() => WebAssembly.validate(), TypeError);
@@ -841,3 +893,17 @@ assertInstantiateSuccess(importingModuleBinary, {'': {f: () => {}}});
 assertInstantiateSuccess(importingModuleBinary.buffer, {'': {f: () => {}}});
 assertInstantiateSuccess(
     memoryImportingModuleBinary, {'': {'my_memory': scratch_memory}});
+
+(function TestSubclassing() {
+  class M extends WebAssembly.Module { }
+  assertThrows(() => new M());
+
+  class I extends WebAssembly.Instance { }
+  assertThrows(() => new I());
+
+  class T extends WebAssembly.Table { }
+  assertThrows(() => new T());
+
+  class Y extends WebAssembly.Memory { }
+  assertThrows(() => new Y());
+})();
diff --git a/deps/v8/test/mjsunit/wasm/memory-external-call.js b/deps/v8/test/mjsunit/wasm/memory-external-call.js
new file mode 100644
index 0000000000..0095ba1e7d
--- /dev/null
+++ b/deps/v8/test/mjsunit/wasm/memory-external-call.js
@@ -0,0 +1,149 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --expose-wasm
+
+load('test/mjsunit/wasm/wasm-constants.js');
+load('test/mjsunit/wasm/wasm-module-builder.js');
+
+let initialMemoryPages = 1;
+let maximumMemoryPages = 5;
+let other_fn_idx = 0;
+
+// This builder can be used to generate a module with memory + load/store
+// functions and/or an additional imported function.
+function generateBuilder(add_memory, import_sig) {
+  let builder = new WasmModuleBuilder();
+  if (import_sig) {
+    // Add the import if we expect a module builder with imported functions.
+    let idx = builder.addImport('import_module', 'other_module_fn', import_sig);
+    // The imported function should always have index 0. With this assertion we
+    // verify that we can use other_fn_idx to refer to this function.
+    assertEquals(idx, other_fn_idx)
+  }
+  if (add_memory) {
+    // Add the memory if we expect a module builder with memory and load/store.
+    builder.addMemory(initialMemoryPages, maximumMemoryPages, true);
+    builder.addFunction('load', kSig_i_i)
+        .addBody([kExprGetLocal, 0, kExprI32LoadMem, 0, 0])
+        .exportFunc();
+    builder.addFunction('store', kSig_i_ii)
+        .addBody([
+          kExprGetLocal, 0, kExprGetLocal, 1, kExprI32StoreMem, 0, 0,
+          kExprGetLocal, 1
+        ])
+        .exportFunc();
+  }
+  return builder;
+}
+
+// This test verifies that when a Wasm module without memory invokes a function
+// imported from another module that has memory, the second module reads its own
+// memory and returns the expected value.
+(function TestExternalCallBetweenTwoWasmModulesWithoutAndWithMemory() {
+  print('TestExternalCallBetweenTwoWasmModulesWithoutAndWithMemory');
+
+  let first_module = generateBuilder(add_memory = false, import_sig = kSig_i_i);
+  // Function to invoke the imported function and add 1 to the result.
+  first_module.addFunction('plus_one', kSig_i_i)
+      .addBody([
+        kExprGetLocal, 0,                   // -
+        kExprCallFunction, other_fn_idx,    // call the imported function
+        kExprI32Const, 1,                   // -
+        kExprI32Add,                        // add 1 to the result
+        kExprReturn                         // -
+      ])
+      .exportFunc();
+  let second_module =
+      generateBuilder(add_memory = true, import_sig = undefined);
+
+  let index = kPageSize - 4;
+  let second_value = 2222;
+  // Instantiate the instances.
+  let second_instance = second_module.instantiate();
+  let first_instance = first_module.instantiate(
+      {import_module: {other_module_fn: second_instance.exports.load}});
+  // Write the values in the second instance.
+  second_instance.exports.store(index, second_value);
+  assertEquals(second_value, second_instance.exports.load(index));
+  // Verify that the value is correct when passing from the imported function.
+  assertEquals(second_value + 1, first_instance.exports.plus_one(index));
+})();
+
+// This test verifies that when a Wasm module with memory invokes a function
+// imported from another module that also has memory, the second module reads
+// its own memory and returns the expected value.
+(function TestExternalCallBetweenTwoWasmModulesWithMemory() {
+  print('TestExternalCallBetweenTwoWasmModulesWithMemory');
+
+  let first_module = generateBuilder(add_memory = true, import_sig = kSig_i_i);
+  // Function to invoke the imported function and add 1 to the result.
+  first_module.addFunction('plus_one', kSig_i_i)
+      .addBody([
+        kExprGetLocal, 0,                   // -
+        kExprCallFunction, other_fn_idx,    // call the imported function
+        kExprI32Const, 1,                   // -
+        kExprI32Add,                        // add 1 to the result
+        kExprReturn                         // -
+      ])
+      .exportFunc();
+  let second_module =
+      generateBuilder(add_memory = true, import_sig = undefined);
+
+  let index = kPageSize - 4;
+  let first_value = 1111;
+  let second_value = 2222;
+  // Instantiate the instances.
+  let second_instance = second_module.instantiate();
+  let first_instance = first_module.instantiate(
+      {import_module: {other_module_fn: second_instance.exports.load}});
+  // Write the values in the two instances.
+  first_instance.exports.store(index, first_value);
+  second_instance.exports.store(index, second_value);
+  // Verify that the values were stored to memory.
+  assertEquals(first_value, first_instance.exports.load(index));
+  assertEquals(second_value, second_instance.exports.load(index));
+  // Verify that the value is correct when passing from the imported function.
+  assertEquals(second_value + 1, first_instance.exports.plus_one(index));
+})();
+
+// This test verifies that the correct memory is accessed after returning
+// from a function imported from another module that also has memory.
+(function TestCorrectMemoryAccessedAfterReturningFromExternalCall() {
+  print('TestCorrectMemoryAccessedAfterReturningFromExternalCall');
+
+  let first_module = generateBuilder(add_memory = true, import_sig = kSig_i_ii);
+  // Function to invoke the imported function and add 1 to the result.
+  first_module.addFunction('sandwich', kSig_i_iii)
+      .addBody([
+        kExprGetLocal, 0,                   // param0 (index)
+        kExprGetLocal, 1,                   // param1 (first_value)
+        kExprI32StoreMem, 0, 0,             // store value in first_instance
+        kExprGetLocal, 0,                   // param0 (index)
+        kExprGetLocal, 2,                   // param2 (second_value)
+        kExprCallFunction, other_fn_idx,    // call the imported function
+        kExprDrop,                          // drop the return value
+        kExprGetLocal, 0,                   // param0 (index)
+        kExprI32LoadMem, 0, 0,              // load from first_instance
+        kExprReturn                         // -
+      ])
+      .exportFunc();
+  let second_module =
+      generateBuilder(add_memory = true, import_sig = undefined);
+
+  let index = kPageSize - 4;
+  let first_value = 1111;
+  let second_value = 2222;
+  // Instantiate the instances.
+  let second_instance = second_module.instantiate();
+  let first_instance = first_module.instantiate(
+      {import_module: {other_module_fn: second_instance.exports.store}});
+  // Call the sandwich function and check that it returns the correct value.
+  assertEquals(
+      first_value,
+      first_instance.exports.sandwich(index, first_value, second_value));
+  // Verify that the values are correct in both memories.
+  assertEquals(first_value, first_instance.exports.load(index));
+  assertEquals(second_value, second_instance.exports.load(index));
+})();
diff --git a/deps/v8/test/mjsunit/wasm/module-memory.js b/deps/v8/test/mjsunit/wasm/module-memory.js
index fdab182665..f5b5981436 100644
--- a/deps/v8/test/mjsunit/wasm/module-memory.js
+++ b/deps/v8/test/mjsunit/wasm/module-memory.js
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --expose-wasm --expose-gc --stress-compaction
+// Flags: --expose-wasm --expose-gc --stress-compaction --allow-natives-syntax
 
 load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
@@ -162,8 +162,12 @@ function testOOBThrows() {
 
 
   for (offset = 65534; offset < 66536; offset++) {
+    const trap_count = %GetWasmRecoveredTrapCount();
     assertTraps(kTrapMemOutOfBounds, read);
     assertTraps(kTrapMemOutOfBounds, write);
+    if (%IsWasmTrapHandlerEnabled()) {
+      assertEquals(trap_count + 2, %GetWasmRecoveredTrapCount());
+    }
   }
 }
 
diff --git a/deps/v8/test/mjsunit/wasm/shared-memory.js b/deps/v8/test/mjsunit/wasm/shared-memory.js
index 98ebd57e79..fa51a8307f 100644
--- a/deps/v8/test/mjsunit/wasm/shared-memory.js
+++ b/deps/v8/test/mjsunit/wasm/shared-memory.js
@@ -4,6 +4,9 @@
 
 // Flags: --experimental-wasm-threads
 
+load("test/mjsunit/wasm/wasm-constants.js");
+load("test/mjsunit/wasm/wasm-module-builder.js");
+
 function assertMemoryIsValid(memory) {
   assertSame(WebAssembly.Memory.prototype, memory.__proto__);
   assertSame(WebAssembly.Memory, memory.constructor);
@@ -50,3 +53,51 @@ function assertMemoryIsValid(memory) {
   assertThrows(() => new WebAssembly.Memory({initial: 0, shared: true}),
       TypeError);
 })();
+
+(function TestCompileWithUndefinedShared() {
+  print("TestCompileWithUndefinedShared");
+  let memory = new WebAssembly.Memory({
+    initial: 0, maximum: 10, shared: true});
+  let builder = new WasmModuleBuilder();
+  builder.addImportedMemory("m", "imported_mem", 0, undefined, "shared");
+  assertThrows(() => new WebAssembly.Module(builder.toBuffer()),
+       WebAssembly.CompileError);
+})();
+
+(function TestCompileAtomicOpUndefinedShared() {
+  print("TestCompileAtomicOpUndefinedShared");
+  let memory = new WebAssembly.Memory({
+    initial: 0, maximum: 10, shared: true});
+  let builder = new WasmModuleBuilder();
+  builder.addFunction("main", kSig_i_ii)
+    .addBody([
+      kExprGetLocal, 0,
+      kExprGetLocal, 1,
+      kAtomicPrefix,
+      kExprI32AtomicAdd]);
+  builder.addImportedMemory("m", "imported_mem");
+  assertThrows(() => new WebAssembly.Module(builder.toBuffer()),
+       WebAssembly.CompileError);
+})();
+
+(function TestInstantiateWithUndefinedShared() {
+  print("TestInstantiateWithUndefinedShared");
+  let memory = new WebAssembly.Memory({
+    initial: 0, maximum: 10, shared: true});
+  let builder = new WasmModuleBuilder();
+  builder.addImportedMemory("m", "imported_mem");
+  let module = new WebAssembly.Module(builder.toBuffer());
+  assertThrows(() => new WebAssembly.Instance(module,
+         {m: {imported_mem: memory}}), WebAssembly.LinkError);
+})();
+
+(function TestInstantiateWithImportNotSharedDefined() {
+  print("TestInstantiateWithImportNotSharedDefined");
+  let memory = new WebAssembly.Memory({
+    initial: 0, maximum: 10, shared: false});
+  let builder = new WasmModuleBuilder();
+  builder.addImportedMemory("m", "imported_mem", 0, 10, "shared");
+  let module = new WebAssembly.Module(builder.toBuffer());
+  assertThrows(() => new WebAssembly.Instance(module,
+         {m: {imported_mem: memory}}), WebAssembly.LinkError);
+})();
diff --git a/deps/v8/test/mjsunit/wasm/stack.js b/deps/v8/test/mjsunit/wasm/stack.js
index 57e57d6467..f49dca3585 100644
--- a/deps/v8/test/mjsunit/wasm/stack.js
+++ b/deps/v8/test/mjsunit/wasm/stack.js
@@ -128,7 +128,6 @@ Error.prepareStackTrace = function(error, frames) {
   }
 })();
 
-
 (function testStackOverflow() {
   print("testStackOverflow");
   var builder = new WasmModuleBuilder();
@@ -139,7 +138,7 @@ Error.prepareStackTrace = function(error, frames) {
       kExprI32Const, 0,
       kExprCallIndirect, sig_index, kTableZero
     ])
-    .exportFunc()
+    .exportFunc();
   builder.appendToTable([0]);
 
   try {
@@ -157,3 +156,29 @@ Error.prepareStackTrace = function(error, frames) {
     ]);
   }
 })();
+
+(function testBigOffset() {
+  print('testBigOffset');
+  var builder = new WasmModuleBuilder();
+
+  let body = [kExprI32Const, 0, kExprI32Add];
+  while (body.length <= 65536) body = body.concat(body);
+  body.unshift(kExprI32Const, 0);
+  body.push(kExprUnreachable);
+  let unreachable_pos = body.length - 1;
+
+  builder.addFunction('main', kSig_v_v).addBody(body).exportFunc();
+
+  try {
+    builder.instantiate().exports.main();
+    fail('expected wasm exception');
+  } catch (e) {
+    assertEquals('unreachable', e.message, 'trap reason');
+    verifyStack(e.stack, [
+      // isWasm, function, line, pos, file
+      [true, 'main', 0, unreachable_pos + 1, null],  // -
+      [false, 'testBigOffset', 173, 0, 'stack.js'],  //-
+      [false, null, 184, 0, 'stack.js']
+    ]);
+  }
+})();
diff --git a/deps/v8/test/mjsunit/wasm/streaming-compile.js b/deps/v8/test/mjsunit/wasm/streaming-compile.js
new file mode 100644
index 0000000000..5f2ca6b9fa
--- /dev/null
+++ b/deps/v8/test/mjsunit/wasm/streaming-compile.js
@@ -0,0 +1,7 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --wasm-test-streaming -async-compilation --expose-wasm --allow-natives-syntax
+
+load("test/mjsunit/wasm/async-compile.js");
diff --git a/deps/v8/test/mjsunit/wasm/streaming-error-position.js b/deps/v8/test/mjsunit/wasm/streaming-error-position.js
new file mode 100644
index 0000000000..c2b86c03fa
--- /dev/null
+++ b/deps/v8/test/mjsunit/wasm/streaming-error-position.js
@@ -0,0 +1,374 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --wasm-test-streaming --wasm-async-compilation --expose-wasm --allow-natives-syntax
+
+'use strict';
+
+load('test/mjsunit/wasm/wasm-constants.js');
+load('test/mjsunit/wasm/wasm-module-builder.js');
+
+function module(bytes) {
+  let buffer = bytes;
+  if (typeof buffer === 'string') {
+    buffer = new ArrayBuffer(bytes.length);
+    let view = new Uint8Array(buffer);
+    for (let i = 0; i < bytes.length; ++i) {
+      view[i] = bytes.charCodeAt(i);
+    }
+  }
+  return new WebAssembly.Module(buffer);
+}
+
+function toBuffer(binary) {
+  let buffer = new ArrayBuffer(binary.length);
+  let view = new Uint8Array(buffer);
+  for (let i = 0; i < binary.length; i++) {
+    let val = binary[i];
+    if ((typeof val) == 'string') val = val.charCodeAt(0);
+    view[i] = val | 0;
+  }
+  return buffer;
+}
+
+function testErrorPosition(bytes, pos, test_name) {
+  assertPromiseResult(
+      WebAssembly.compile(toBuffer(bytes)), assertUnreachable, e => {
+        print(test_name);
+        assertInstanceof(e, WebAssembly.CompileError);
+        let regex = new RegExp('@\\+' + pos);
+        print(e.message);
+        assertMatches(regex, e.message, 'Error Position');
+      });
+}
+
+(function testInvalidMagic() {
+  let bytes = new Binary;
+  bytes.push(
+      kWasmH0, kWasmH1 + 1, kWasmH2, kWasmH3, kWasmV0, kWasmV1, kWasmV2,
+      kWasmV3);
+  // Error at pos==0 because that's where the magic word is.
+  testErrorPosition(bytes, 0, 'testInvalidMagic');
+})();
+
+(function testInvalidVersion() {
+  let bytes = new Binary;
+  bytes.push(
+      kWasmH0, kWasmH1, kWasmH2, kWasmH3, kWasmV0, kWasmV1 + 1, kWasmV2,
+      kWasmV3);
+  // Error at pos==4 because that's where the version word is.
+  testErrorPosition(bytes, 4, 'testInvalidVersion');
+})();
+
+(function testSectionLengthInvalidVarint() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.emit_u8(kTypeSectionCode);
+  bytes.push(0x80, 0x80, 0x80, 0x80, 0x80, 0x00);
+  let pos = bytes.length - 1 - 1;
+  testErrorPosition(bytes, pos, 'testSectionLengthInvalidVarint');
+})();
+
+(function testSectionLengthTooBig() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.emit_u8(kTypeSectionCode);
+  bytes.emit_u32v(0xffffff23);
+  let pos = bytes.length - 1;
+  testErrorPosition(bytes, pos, 'testSectionLengthTooBig');
+})();
+
+(function testFunctionsCountInvalidVarint() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,  // section id
+      1,                 // section length
+      0                  // number of types
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      1,                     // section length
+      0                      // number of functions
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      20,                // section length (arbitrary value > 6)
+  );
+  // Functions count
+  bytes.push(0x80, 0x80, 0x80, 0x80, 0x80, 0x00);
+
+  let pos = bytes.length - 1 - 1;
+  testErrorPosition(bytes, pos, 'testFunctionsCountInvalidVarint');
+})();
+
+(function testFunctionsCountTooBig() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,  // section id
+      1,                 // section length
+      0                  // number of types
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      1,                     // section length
+      0                      // number of functions
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      20,                // section length (arbitrary value > 6)
+  );
+  // Functions count
+  bytes.emit_u32v(0xffffff23);
+
+  let pos = bytes.length - 1;
+  testErrorPosition(bytes, pos, 'testFunctionsCountTooBig');
+})();
+
+(function testFunctionsCountDoesNotMatch() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,  // section id
+      1,                 // section length
+      0                  // number of types
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      1,                     // section length
+      0                      // number of functions
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      20,                // section length (arbitrary value > 6)
+  );
+  // Functions count (different than the count in the functions section.
+  bytes.emit_u32v(5);
+
+  let pos = bytes.length - 1;
+  testErrorPosition(bytes, pos, 'testFunctionsCountDoesNotMatch');
+})();
+
+(function testBodySizeInvalidVarint() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,       // section id
+      4,                      // section length
+      1,                      // number of types
+      kWasmFunctionTypeForm,  // type
+      0,                      // number of parameter
+      0                       // number of returns
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      2,                     // section length
+      1,                     // number of functions
+      0                      // signature index
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      20,                // section length (arbitrary value > 6)
+      1                  // functions count
+  );
+  // Invalid function body size.
+  bytes.push(0x80, 0x80, 0x80, 0x80, 0x80, 0x00);
+
+  let pos = bytes.length - 1 - 1;
+  testErrorPosition(bytes, pos, 'testBodySizeInvalidVarint');
+})();
+
+(function testBodySizeTooBig() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,       // section id
+      4,                      // section length
+      1,                      // number of types
+      kWasmFunctionTypeForm,  // type
+      0,                      // number of parameter
+      0                       // number of returns
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      2,                     // section length
+      1,                     // number of functions
+      0                      // signature index
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      20,                // section length (arbitrary value > 6)
+      1                  // functions count
+  );
+  // Invalid function body size.
+  bytes.emit_u32v(0xffffff23);
+
+  let pos = bytes.length - 1;
+  testErrorPosition(bytes, pos, 'testBodySizeTooBig');
+})();
+
+(function testBodySizeDoesNotFit() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,       // section id
+      4,                      // section length
+      1,                      // number of types
+      kWasmFunctionTypeForm,  // type
+      0,                      // number of parameter
+      0                       // number of returns
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      2,                     // section length
+      1,                     // number of functions
+      0                      // signature index
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      20,                // section length (arbitrary value > 6)
+      1                  // functions count
+  );
+  // Invalid function body size (does not fit into the code section).
+  bytes.emit_u32v(20);
+
+  let pos = bytes.length - 1;
+  testErrorPosition(bytes, pos, 'testBodySizeDoesNotFit');
+})();
+
+(function testBodySizeIsZero() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,       // section id
+      4,                      // section length
+      1,                      // number of types
+      kWasmFunctionTypeForm,  // type
+      0,                      // number of parameter
+      0                       // number of returns
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      2,                     // section length
+      1,                     // number of functions
+      0                      // signature index
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      20,                // section length (arbitrary value > 6)
+      1                  // functions count
+  );
+  // Invalid function body size (body size of 0 is invalid).
+  bytes.emit_u32v(0);
+
+  let pos = bytes.length - 1;
+  testErrorPosition(bytes, pos, 'testBodySizeIsZero');
+})();
+
+(function testStaleCodeSectionBytes() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,       // section id
+      4,                      // section length
+      1,                      // number of types
+      kWasmFunctionTypeForm,  // type
+      0,                      // number of parameter
+      0                       // number of returns
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      2,                     // section length
+      1,                     // number of functions
+      0                      // signature index
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      20,                // section length (too big)
+      1,                 // functions count
+      2,                 // body size
+      0,                 // locals count
+      kExprEnd           // body
+  );
+
+  let pos = bytes.length - 1;
+  testErrorPosition(bytes, pos, 'testStaleCodeSectionBytes');
+})();
+
+(function testInvalidCode() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,       // section id
+      4,                      // section length
+      1,                      // number of types
+      kWasmFunctionTypeForm,  // type
+      0,                      // number of parameter
+      0                       // number of returns
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      2,                     // section length
+      1,                     // number of functions
+      0                      // signature index
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      6,                 // section length (too big)
+      1,                 // functions count
+      4,                 // body size
+      0,                 // locals count
+      kExprGetLocal, 0,  // Access a non-existing local
+      kExprEnd           // --
+  );
+
+  // Find error at the index of kExprGetLocal.
+  let pos = bytes.length - 1 - 1;
+  testErrorPosition(bytes, pos, 'testInvalidCode');
+})();
+
+(function testCodeSectionSizeZero() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,       // section id
+      4,                      // section length
+      1,                      // number of types
+      kWasmFunctionTypeForm,  // type
+      0,                      // number of parameter
+      0                       // number of returns
+  );
+  bytes.push(
+      kFunctionSectionCode,  // section id
+      2,                     // section length
+      1,                     // number of functions
+      0                      // signature index
+  );
+  bytes.push(
+      kCodeSectionCode,  // section id
+      0,                 // section length (too big)
+  );
+
+  // Find error at the index of kExprGetLocal.
+  let pos = bytes.length - 1;
+  testErrorPosition(bytes, pos, 'testCodeSectionSizeZero');
+})();
+
+(function testInvalidSection() {
+  let bytes = new Binary;
+  bytes.emit_header();
+  bytes.push(
+      kTypeSectionCode,       // section id
+      5,                      // section length
+      1,                      // number of types
+      kWasmFunctionTypeForm,  // type
+      1,                      // number of parameter
+      0x7b,                   // invalid type
+      0                       // number of returns
+  );
+
+  let pos = bytes.length - 1 - 1;
+  testErrorPosition(bytes, pos, 'testInvalidSection');
+})();
diff --git a/deps/v8/test/mjsunit/wasm/streaming-trap-location.js b/deps/v8/test/mjsunit/wasm/streaming-trap-location.js
new file mode 100644
index 0000000000..1607ca76f2
--- /dev/null
+++ b/deps/v8/test/mjsunit/wasm/streaming-trap-location.js
@@ -0,0 +1,7 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --wasm-test-streaming --wasm-async-compilation --expose-wasm
+
+load("test/mjsunit/wasm/trap-location.js");
diff --git a/deps/v8/test/mjsunit/wasm/trap-location.js b/deps/v8/test/mjsunit/wasm/trap-location.js
index 390ad74d8d..0c646c92cd 100644
--- a/deps/v8/test/mjsunit/wasm/trap-location.js
+++ b/deps/v8/test/mjsunit/wasm/trap-location.js
@@ -14,12 +14,16 @@ Error.prepareStackTrace = function(error, frames) {
 
 function testTrapLocations(instance, expected_stack_length) {
   function testWasmTrap(value, reason, position) {
+    let function_name = arguments.callee.name;
     try {
       instance.exports.main(value);
       fail('expected wasm exception');
     } catch (e) {
       assertEquals(kTrapMsgs[reason], e.message, 'trap reason');
-      assertEquals(expected_stack_length, e.stack.length, 'number of frames');
+      // Check that the trapping function is the one which was called from this
+      // function.
+      assertTrue(
+          e.stack[1].toString().startsWith(function_name), 'stack depth');
       assertEquals(0, e.stack[0].getLineNumber(), 'wasmFunctionIndex');
       assertEquals(position, e.stack[0].getPosition(), 'position');
     }
diff --git a/deps/v8/test/mjsunit/wasm/unreachable-validation.js b/deps/v8/test/mjsunit/wasm/unreachable-validation.js
index 113bcc3102..5b98b1713b 100644
--- a/deps/v8/test/mjsunit/wasm/unreachable-validation.js
+++ b/deps/v8/test/mjsunit/wasm/unreachable-validation.js
@@ -128,3 +128,5 @@ run(I, "U (block (iblock 0 0 brt01) drop)", [unr, ...block, ...iblock, ...zero,
 run(V, "(iblock (iblock U 0 brt01)) drop", [...iblock, ...iblock, unr, ...zero, ...brt01, end, end, drop]);
 run(I, "(block (fblock U 0 brt01) drop)", [...iblock, ...fblock, unr, ...zero, ...brt01, end, drop, end]);
 run(I, "(iblock (fblock U 0 brt01) drop 0) drop", [...iblock, ...fblock, unr, ...zero, ...brt01, end, drop, ...zero, end, drop]);
+
+run(I, "(iblock (block (U brif 1))", [...iblock, ...block, unr, kExprBrIf, 0, end, end, kExprDrop]);
diff --git a/deps/v8/test/mjsunit/wasm/wasm-constants.js b/deps/v8/test/mjsunit/wasm/wasm-constants.js
index c556b109a1..cc5f1e9c4a 100644
--- a/deps/v8/test/mjsunit/wasm/wasm-constants.js
+++ b/deps/v8/test/mjsunit/wasm/wasm-constants.js
@@ -92,6 +92,7 @@ let kWasmI32 = 0x7f;
 let kWasmI64 = 0x7e;
 let kWasmF32 = 0x7d;
 let kWasmF64 = 0x7c;
+let kWasmS128  = 0x7b;
 
 let kExternalFunction = 0;
 let kExternalTable = 1;
@@ -123,6 +124,10 @@ let kSig_v_d = makeSig([kWasmF64], []);
 let kSig_v_dd = makeSig([kWasmF64, kWasmF64], []);
 let kSig_v_ddi = makeSig([kWasmF64, kWasmF64, kWasmI32], []);
 
+let kSig_v_f = makeSig([kWasmF32], []);
+let kSig_f_f = makeSig([kWasmF32], [kWasmF32]);
+let kSig_d_d = makeSig([kWasmF64], [kWasmF64]);
+
 function makeSig(params, results) {
   return {params: params, results: results};
 }
@@ -327,6 +332,12 @@ let kExprF64ReinterpretI64 = 0xbf;
 // Prefix opcodes
 let kAtomicPrefix = 0xfe;
 
+let kExprI32AtomicLoad = 0x10;
+let kExprI32AtomicLoad8U = 0x12;
+let kExprI32AtomicLoad16U = 0x13;
+let kExprI32AtomicStore = 0x17;
+let kExprI32AtomicStore8U = 0x19;
+let kExprI32AtomicStore16U = 0x1a;
 let kExprI32AtomicAdd = 0x1e;
 let kExprI32AtomicAdd8U = 0x20;
 let kExprI32AtomicAdd16U = 0x21;
@@ -387,7 +398,7 @@ function assertTraps(trap, code) {
   throw new MjsUnitAssertionError('Did not trap, expected: ' + kTrapMsgs[trap]);
 }
 
-function assertWasmThrows(values, code) {
+function assertWasmThrows(runtime_id, values, code) {
   try {
     if (typeof code === 'function') {
       code();
@@ -396,15 +407,18 @@ function assertWasmThrows(values, code) {
     }
   } catch (e) {
     assertTrue(e instanceof WebAssembly.RuntimeError);
-    assertNotEquals(e['WasmExceptionTag'], undefined);
-    assertTrue(Number.isInteger(e['WasmExceptionTag']));
-    // TODO(kschimpf): Extract values from the exception.
-    let e_values = [];
-    assertEquals(values, e_values);
+    var e_runtime_id = e['WasmExceptionRuntimeId'];
+    assertEquals(e_runtime_id, runtime_id);
+    assertTrue(Number.isInteger(e_runtime_id));
+    var e_values = e['WasmExceptionValues'];
+    assertEquals(values.length, e_values.length);
+    for (i = 0; i < values.length; ++i) {
+      assertEquals(values[i], e_values[i]);
+    }
     // Success.
     return;
   }
-  throw new MjsUnitAssertionError('Did not throw, expected: ' + values);
+  throw new MjsUnitAssertionError('Did not throw expected: ' + runtime_id + values);
 }
 
 function wasmI32Const(val) {
diff --git a/deps/v8/test/mjsunit/wasm/wasm-module-builder.js b/deps/v8/test/mjsunit/wasm/wasm-module-builder.js
index 78e3d6bde8..d21067b36e 100644
--- a/deps/v8/test/mjsunit/wasm/wasm-module-builder.js
+++ b/deps/v8/test/mjsunit/wasm/wasm-module-builder.js
@@ -171,8 +171,8 @@ class WasmModuleBuilder {
     return this;
   }
 
-  addMemory(min, max, exp) {
-    this.memory = {min: min, max: max, exp: exp};
+  addMemory(min, max, exp, shared) {
+    this.memory = {min: min, max: max, exp: exp, shared: shared};
     return this;
   }
 
@@ -240,9 +240,9 @@ class WasmModuleBuilder {
     return this.num_imported_globals++;
   }
 
-  addImportedMemory(module = "", name, initial = 0, maximum) {
+  addImportedMemory(module = "", name, initial = 0, maximum, shared) {
     let o = {module: module, name: name, kind: kExternalMemory,
-             initial: initial, maximum: maximum};
+             initial: initial, maximum: maximum, shared: shared};
     this.imports.push(o);
     return this;
   }
@@ -348,7 +348,12 @@ class WasmModuleBuilder {
             section.emit_u8(imp.mutable);
           } else if (imp.kind == kExternalMemory) {
             var has_max = (typeof imp.maximum) != "undefined";
-            section.emit_u8(has_max ? 1 : 0); // flags
+            var is_shared = (typeof imp.shared) != "undefined";
+            if (is_shared) {
+              section.emit_u8(has_max ? 3 : 2); // flags
+            } else {
+              section.emit_u8(has_max ? 1 : 0); // flags
+            }
             section.emit_u32v(imp.initial); // initial
             if (has_max) section.emit_u32v(imp.maximum); // maximum
           } else if (imp.kind == kExternalTable) {
@@ -395,9 +400,16 @@ class WasmModuleBuilder {
       binary.emit_section(kMemorySectionCode, section => {
         section.emit_u8(1);  // one memory entry
         const has_max = wasm.memory.max !== undefined;
-        section.emit_u32v(has_max ? kResizableMaximumFlag : 0);
+        const is_shared = wasm.memory.shared !== undefined;
+        // Emit flags (bit 0: reszeable max, bit 1: shared memory)
+        if (is_shared) {
+          section.emit_u8(has_max ? 3 : 2);
+        } else {
+          section.emit_u8(has_max ? 1 : 0);
+        }
         section.emit_u32v(wasm.memory.min);
         if (has_max) section.emit_u32v(wasm.memory.max);
+        if (wasm.memory.shared) section.emit_u8(1);
       });
     }
 
@@ -511,7 +523,7 @@ class WasmModuleBuilder {
         for (let type of wasm.exceptions) {
           section.emit_u32v(type.params.length);
           for (let param of type.params) {
-            section.enit_u8(param);
+            section.emit_u8(param);
           }
         }
       });
@@ -541,6 +553,9 @@ class WasmModuleBuilder {
             if (l.f64_count > 0) {
               local_decls.push({count: l.f64_count, type: kWasmF64});
             }
+            if (l.s128_count > 0) {
+              local_decls.push({count: l.s128_count, type: kWasmS128});
+            }
           }
 
           let header = new Binary;