test/mjsunit/es6/tail-call-megatest.js - Issue 1709583002: [turbofan] Fixing ES6 tail calls in Turbofan.

Unified Diff: test/mjsunit/es6/tail-call-megatest.js

Issue 1709583002: [turbofan] Fixing ES6 tail calls in Turbofan. (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master

Patch Set: Created 4 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: test/mjsunit/es6/tail-call-megatest.js

diff --git a/test/mjsunit/es6/tail-call-megatest.js b/test/mjsunit/es6/tail-call-megatest.js

new file mode 100644

index 0000000000000000000000000000000000000000..3cfa26ade26255e2ba98fbb9467fc5e42a2e2251

--- /dev/null

+++ b/test/mjsunit/es6/tail-call-megatest.js

@@ -0,0 +1,1024 @@

+// 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-tailcalls --no-turbo-inlining

+//

+// This is an auto-generated file. Do not modify.

+// See test/mjsunit/es6/tail-call-mega-generator.js for details.

+//

+"use strict";

+Error.prepareStackTrace = (error,stack) => {

+ error.strace = stack;

+ return error.message + "\n at " + stack.join("\n at ");

+function CheckStackTrace(expected) {

+ var e = new Error();

+ e.stack; // prepare stack trace

+ var stack = e.strace;

+ assertEquals("CheckStackTrace", stack[0].getFunctionName());

+ for (var i = 0; i < expected.length; i++) {

+ assertEquals(expected[i].name, stack[i + 1].getFunctionName());

+ }

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+function CheckArguments(expected, args) {

+ args = Array.prototype.slice.call(args);

+ assertEquals(expected, args);

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+(function() {

+ function f(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ function g(a) {

+ // Let it be inlined.

+ CheckArguments([10], arguments);

+ return f();

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ %SetForceInlineFlag(g);

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function f(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ function g(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ CheckArguments([10], arguments);

+ return f();

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function f(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([1], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([1], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ function g(a) {

+ // Let it be inlined.

+ CheckArguments([10], arguments);

+ return f(1);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ %SetForceInlineFlag(g);

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function f(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([1], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([1], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ function g(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ CheckArguments([10], arguments);

+ return f(1);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function f(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ function g(a) {

+ // Let it be inlined.

+ CheckArguments([10], arguments);

+ return f(1, 2);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ %SetForceInlineFlag(g);

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function f(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ function g(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ CheckArguments([10], arguments);

+ return f(1, 2);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(153, this.a);

+ CheckArguments([], arguments);

+ CheckStackTrace([ff, test]);

+ %DeoptimizeNow();

+ CheckArguments([], arguments);

+ CheckStackTrace([ff, test]);

+ return 42;

+ }

+ var f = ff.bind({a: 153});

+ function g(a) {

+ // Let it be inlined.

+ CheckArguments([10], arguments);

+ return f();

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ %SetForceInlineFlag(g);

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(153, this.a);

+ CheckArguments([], arguments);

+ CheckStackTrace([ff, test]);

+ %DeoptimizeNow();

+ CheckArguments([], arguments);

+ CheckStackTrace([ff, test]);

+ return 42;

+ }

+ var f = ff.bind({a: 153});

+ function g(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ CheckArguments([10], arguments);

+ return f();

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(153, this.a);

+ CheckArguments([1], arguments);

+ CheckStackTrace([ff, test]);

+ %DeoptimizeNow();

+ CheckArguments([1], arguments);

+ CheckStackTrace([ff, test]);

+ return 42;

+ }

+ var f = ff.bind({a: 153});

+ function g(a) {

+ // Let it be inlined.

+ CheckArguments([10], arguments);

+ return f(1);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ %SetForceInlineFlag(g);

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(153, this.a);

+ CheckArguments([1], arguments);

+ CheckStackTrace([ff, test]);

+ %DeoptimizeNow();

+ CheckArguments([1], arguments);

+ CheckStackTrace([ff, test]);

+ return 42;

+ }

+ var f = ff.bind({a: 153});

+ function g(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ CheckArguments([10], arguments);

+ return f(1);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(153, this.a);

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([ff, test]);

+ %DeoptimizeNow();

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([ff, test]);

+ return 42;

+ }

+ var f = ff.bind({a: 153});

+ function g(a) {

+ // Let it be inlined.

+ CheckArguments([10], arguments);

+ return f(1, 2);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ %SetForceInlineFlag(g);

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(153, this.a);

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([ff, test]);

+ %DeoptimizeNow();

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([ff, test]);

+ return 42;

+ }

+ var f = ff.bind({a: 153});

+ function g(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ CheckArguments([10], arguments);

+ return f(1, 2);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ var f = new Proxy(ff, {});

+ function g(a) {

+ // Let it be inlined.

+ CheckArguments([10], arguments);

+ return f();

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ %SetForceInlineFlag(g);

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ var f = new Proxy(ff, {});

+ function g(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ CheckArguments([10], arguments);

+ return f();

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([1], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([1], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ var f = new Proxy(ff, {});

+ function g(a) {

+ // Let it be inlined.

+ CheckArguments([10], arguments);

+ return f(1);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ %SetForceInlineFlag(g);

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([1], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([1], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ var f = new Proxy(ff, {});

+ function g(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ CheckArguments([10], arguments);

+ return f(1);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ var f = new Proxy(ff, {});

+ function g(a) {

+ // Let it be inlined.

+ CheckArguments([10], arguments);

+ return f(1, 2);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ %SetForceInlineFlag(g);

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+(function() {

+ function ff(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ assertEquals(undefined, this);

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([f, test]);

+ %DeoptimizeNow();

+ CheckArguments([1, 2], arguments);

+ CheckStackTrace([f, test]);

+ return 42;

+ }

+ var f = new Proxy(ff, {});

+ function g(a) {

+ // Don't inline. Don't inline. Don't inline. Don't inline.

+ CheckArguments([10], arguments);

+ return f(1, 2);

+ }

+ function test() {

+ assertEquals(42, g(10));

+ }

+ ;

+ test();

+ %OptimizeFunctionOnNextCall(test);

+ try { %OptimizeFunctionOnNextCall(f); } catch(e) {}

+ try { %OptimizeFunctionOnNextCall(ff); } catch(e) {}

+ %OptimizeFunctionOnNextCall(g);

+ test();

+})();

+// The end.

« no previous file with comments | « test/mjsunit/es6/tail-call.js ('k') | test/mjsunit/es6/tail-call-megatest-generator.js » ('j') | test/mjsunit/es6/tail-call-megatest-generator.js » ('J')