ff283f7ded
* Limit triggering of tail calls to explicit use of a new inline runtime function %_TailCall. %_TailCall works just like %_Call except for using tail-calling mechanics (currently only in TF). * Remove hack that recognized some specific usages of %_Call and converted them into tail calls. * Support tail calls for all calls where the number of callee stack parameters is less than or equal to the number of caller stack parameters. * Use the gap resolver to swizzle parameters and registers to tail calls. BUG=v8:4076 LOG=n Review URL: https://codereview.chromium.org/1439613003 Cr-Commit-Position: refs/heads/master@{#31987}
109 lines
2.7 KiB
JavaScript
109 lines
2.7 KiB
JavaScript
// 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 --nostress-opt --turbo
|
|
// Flags: --nonative-context-specialization
|
|
|
|
var p0 = new Object();
|
|
var p1 = new Object();
|
|
var p2 = new Object();
|
|
|
|
// Ensure 1 parameter passed straight-through is handled correctly
|
|
var count1 = 100000;
|
|
tailee1 = function() {
|
|
"use strict";
|
|
if (count1-- == 0) {
|
|
return this;
|
|
}
|
|
return %_TailCall(tailee1, this);
|
|
};
|
|
|
|
%OptimizeFunctionOnNextCall(tailee1);
|
|
assertEquals(p0, tailee1.call(p0));
|
|
|
|
// Ensure 2 parameters passed straight-through trigger a tail call are handled
|
|
// correctly and don't cause a stack overflow.
|
|
var count2 = 100000;
|
|
tailee2 = function(px) {
|
|
"use strict";
|
|
assertEquals(p2, px);
|
|
assertEquals(p1, this);
|
|
count2 = ((count2 | 0) - 1) | 0;
|
|
if ((count2 | 0) === 0) {
|
|
return this;
|
|
}
|
|
return %_TailCall(tailee2, this, px);
|
|
};
|
|
|
|
%OptimizeFunctionOnNextCall(tailee2);
|
|
assertEquals(p1, tailee2.call(p1, p2));
|
|
|
|
// Ensure swapped 2 parameters trigger a tail call and do the appropriate
|
|
// parameters swapping
|
|
var count3 = 999999;
|
|
tailee3 = function(px) {
|
|
"use strict";
|
|
if (count3-- == 0) {
|
|
return this;
|
|
}
|
|
return %_TailCall(tailee3, px, this);
|
|
};
|
|
|
|
%OptimizeFunctionOnNextCall(tailee3);
|
|
assertEquals(p2, tailee3.call(p1, p2));
|
|
|
|
// Ensure too many parameters defeats the tail call optimization (currently
|
|
// unsupported).
|
|
var count4 = 1000000;
|
|
tailee4 = function(px) {
|
|
"use strict";
|
|
if (count4-- == 0) {
|
|
return this;
|
|
}
|
|
return %_TailCall(tailee4, this, px, undefined);
|
|
};
|
|
|
|
%OptimizeFunctionOnNextCall(tailee4);
|
|
assertThrows(function() { tailee4.call(p1, p2); });
|
|
|
|
// Ensure that calling the arguments adapter defeats the tail call optimization.
|
|
var count5 = 1000000;
|
|
tailee5 = function(px) {
|
|
"use strict";
|
|
if (count5-- == 0) {
|
|
return this;
|
|
}
|
|
return %_TailCall(tailee5, this);
|
|
};
|
|
|
|
%OptimizeFunctionOnNextCall(tailee5);
|
|
assertThrows(function() { tailee5.call(p1, p2); });
|
|
|
|
// Ensure tail calls with fewer stack parameters properly re-arranges the stack.
|
|
tailee6 = function(px) {
|
|
return px;
|
|
}
|
|
|
|
tailee7 = function(px, py, pz, pa, pb, pc) {
|
|
"use strict";
|
|
return %_TailCall(tailee6, this, pc);
|
|
};
|
|
|
|
%OptimizeFunctionOnNextCall(tailee6);
|
|
%OptimizeFunctionOnNextCall(tailee7);
|
|
assertEquals(110, tailee7.call(null, 15, 16, 17, 18, 0, 110));
|
|
|
|
tailee8 = function(px, py, pz, pa, pb) {
|
|
return pb + pz + px;
|
|
}
|
|
|
|
tailee9 = function(px, py, pz, pa, pb, pc) {
|
|
"use strict";
|
|
return %_TailCall(tailee8, this, pb, py, px, pa, pz);
|
|
};
|
|
|
|
%OptimizeFunctionOnNextCall(tailee8);
|
|
%OptimizeFunctionOnNextCall(tailee9);
|
|
assertEquals(32, tailee9.call(null, 15, 16, 17, 18, 0, 110));
|