diff options
Diffstat (limited to 'deps/v8/test/mjsunit')
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=""">_</a>'); +assertEquals('_'.anchor('\x22\x22'), '<a name="""">_</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; |