Source code

Revision control

Copy as Markdown

Other Tools

// |jit-test| --enable-stub-frame-pointers; --fast-warmup; --no-threads
// Exercise every path through the Ion generic call trampoline with stub frame
// pointers enabled.
with ({}) {}
const ITERS = 300;
function assertArrayEq(a, b) {
assertEq(a.length, b.length);
for (var i = 0; i < a.length; i++) {
assertEq(a[i], b[i]);
}
}
function assertThrowsTypeError(f) {
var caught = false;
try {
f();
} catch (e) {
assertEq(e instanceof TypeError, true);
caught = true;
}
assertEq(caught, true);
}
function call1(f) { return f(1); }
function call2(f) { return f(1, 2); }
function construct1(F) { return new F(1); }
function callM0(o) { return o.m(); }
function callM2(o, a, b) { return o.m(a, b); }
function s1(x) { return x; }
function s2(x, y) { return [x, y]; }
function s3(x, y, z) { return [x, y, z]; }
function s10(a, b, c, d, e, f, g, h, i, j) { return [a, b, c, d, e, f, g, h, i, j]; }
var manyParams = [];
for (var i = 0; i < 400; i++) {
manyParams.push("p" + i);
}
var s400 = new Function(...manyParams, "return arguments.length + ':' + p399");
function testScripted() {
for (var i = 0; i < ITERS; i++) {
// No underflow.
assertEq(call1(s1), 1);
// Underflow by one (odd) and two (even) arguments.
assertArrayEq(call1(s2), [1, undefined]);
assertArrayEq(call1(s3), [1, undefined, undefined]);
assertArrayEq(call2(s3), [1, 2, undefined]);
// Underflow by many arguments.
assertArrayEq(call1(s10), [1, undefined, undefined, undefined, undefined,
undefined, undefined, undefined, undefined,
undefined]);
// Underflow by more than JIT_ARGS_LENGTH_MAX: VM call.
assertEq(call1(s400), "1:undefined");
}
}
testScripted();
function C1(x) { this.x = x; this.nt = new.target; }
function C2(x, y) { this.args = [x, y]; this.nt = new.target; }
function C3(x, y, z) { this.args = [x, y, z]; this.nt = new.target; }
class K { constructor(x) { this.x = x; } }
var arrow = x => x;
var method = { m(x) { return x; } }.m;
function testConstruct() {
for (var i = 0; i < ITERS; i++) {
var o = construct1(C1);
assertEq(o.x, 1);
assertEq(o.nt, C1);
// Constructing with underflow must keep new.target in the right slot.
o = construct1(C2);
assertArrayEq(o.args, [1, undefined]);
assertEq(o.nt, C2);
o = construct1(C3);
assertArrayEq(o.args, [1, undefined, undefined]);
assertEq(o.nt, C3);
assertEq(construct1(K).x, 1);
// Native constructors.
assertEq(construct1(Array).length, 1);
assertEq(construct1(Uint8Array)[0], 0);
// Not constructors: VM call, which throws.
assertThrowsTypeError(() => construct1(arrow));
assertThrowsTypeError(() => construct1(method));
// Class constructors can't be called: VM call, which throws.
assertThrowsTypeError(() => call1(K));
}
}
testConstruct();
// Make the super() call site polymorphic, then pass a new.target that isn't a
// JSFunction, so that CreateThis returns null and we take the VM call.
function makeDerived(base) {
return class extends base {
constructor() {
super(1);
}
};
}
var deriveds = [makeDerived(C1), makeDerived(C2), makeDerived(C3),
makeDerived(K)];
var proxyNewTarget = new Proxy(function() {}, {});
function testCreateThisNull() {
for (var i = 0; i < ITERS; i++) {
var D = deriveds[i % deriveds.length];
assertEq(new D() instanceof D, true);
var o = Reflect.construct(D, [], proxyNewTarget);
assertEq(Object.getPrototypeOf(o), proxyNewTarget.prototype);
}
}
testCreateThisNull();
function testNative() {
for (var i = 0; i < ITERS; i++) {
assertEq(call1(Math.abs), 1);
assertEq(call2(Math.max), 2);
assertEq(callM2({m: Math.min}, 3, 4), 3);
}
}
testNative();
var funCall = Function.prototype.call;
var otherGlobal = newGlobal({sameCompartmentAs: this});
var otherFunCall = otherGlobal.Function.prototype.call;
function tgt(x) { return [this, x]; }
tgt.m = funCall;
function tgt0() { "use strict"; return this; }
tgt0.m = funCall;
function tgtOther(x) { return x; }
tgtOther.m = otherFunCall;
Math.max.m = funCall;
var boundTgt = s2.bind(null, 5);
boundTgt.m = funCall;
funCall.m = funCall;
var funCallTgt = { m: funCall };
var zeroArgReceivers = [tgt0, {m: () => 1}, {m: Math.abs.bind(null, 1)}];
String.prototype.m = funCall;
function testFunCall() {
var thisv = {};
for (var i = 0; i < ITERS; i++) {
// fun_call with arguments.
var r = callM2(tgt, thisv, 1);
assertEq(r[0], thisv);
assertEq(r[1], 1);
// fun_call without arguments.
var zeroArgReceiver = zeroArgReceivers[i % zeroArgReceivers.length];
assertEq(callM0(zeroArgReceiver), zeroArgReceiver === tgt0 ? undefined : 1);
// fun_call with a native, bound, or fun_call target.
assertEq(callM2(Math.max, null, 7), 7);
assertArrayEq(callM2(boundTgt, null, 1), [5, 1]);
assertEq(callM2(funCall, tgt0, thisv), thisv);
// Cross-realm fun_call: VM call.
assertEq(callM2(tgtOther, null, 1), 1);
// Non-object `this`: VM call, which throws.
assertThrowsTypeError(() => callM2("str", 1, 2));
// Non-callable object `this`: VM call, which throws.
assertThrowsTypeError(() => callM2(funCallTgt, 1, 2));
}
}
testFunCall();
var bthis = {};
function bf() { return [this, ...arguments]; }
var b0 = bf.bind(bthis);
var b1 = bf.bind(bthis, 10);
var b2 = bf.bind(bthis, 10, 11);
var b3 = bf.bind(bthis, 10, 11, 12);
var b5 = bf.bind(bthis, 10, 11, 12, 13, 14);
var bNested = b1.bind({}, 20).bind({}, 30);
var bNative = Math.max.bind(null, 100);
var bUnderflow = s10.bind(null, 0);
var bFunCall = funCall.bind(s2, null, 7);
var manyBoundArgs = [];
for (var i = 0; i < 400; i++) {
manyBoundArgs.push(i);
}
function argsLength() { return arguments.length; }
var bTooMany = argsLength.bind(null, ...manyBoundArgs);
function testBound() {
for (var i = 0; i < ITERS; i++) {
assertArrayEq(call2(b0), [bthis, 1, 2]);
assertArrayEq(call2(b1), [bthis, 10, 1, 2]);
assertArrayEq(call2(b2), [bthis, 10, 11, 1, 2]);
assertArrayEq(call2(b3), [bthis, 10, 11, 12, 1, 2]);
// More than MaxInlineBoundArgs bound arguments.
assertArrayEq(call2(b5), [bthis, 10, 11, 12, 13, 14, 1, 2]);
assertArrayEq(call2(bNested), [bthis, 10, 20, 30, 1, 2]);
assertEq(call2(bNative), 100);
assertArrayEq(call1(bUnderflow), [0, 1, undefined, undefined, undefined,
undefined, undefined, undefined,
undefined, undefined]);
assertArrayEq(call1(bFunCall), [7, 1]);
// Too many arguments: VM call.
assertEq(call2(bTooMany), 402);
// Constructing a bound function: VM call.
assertEq(construct1(C1.bind(null)).x, 1);
}
}
testBound();
var proxyFun = new Proxy(s1, {});
var ccwFun = newGlobal({newCompartment: true}).evaluate("(function(x) { return x; })");
function testNonFunctionCallables() {
for (var i = 0; i < ITERS; i++) {
assertEq(call1(proxyFun), 1);
assertEq(call1(ccwFun), 1);
assertEq(construct1(proxyFun) instanceof s1, true);
assertThrowsTypeError(() => call1({}));
assertThrowsTypeError(() => construct1({}));
}
}
testNonFunctionCallables();
// Call a bound function with many bound arguments at increasing stack depths.
// Close to the stack limit, the stack check in the trampoline fails and we take
// the VM call. The call site must be in the recursive function itself, so that
// trial inlining doesn't make it monomorphic.
var bManyLength = argsLength.bind(null, ...manyBoundArgs.slice(0, 370));
var depthCallees = [bManyLength, bManyLength, Math.max, argsLength];
function callAtEveryDepth(n) {
var f = depthCallees[n & 3];
try {
f(1, 2);
} catch (e) {}
return callAtEveryDepth(n + 1);
}
try {
callAtEveryDepth(0);
} catch (e) {}
// Megamorphic getter calls go through the trampoline with argc == 0.
function getX(o) { return o.x; }
function testMegamorphicGetter() {
var getters = [
function() { return this.v; },
function(a, b) { return [a, b, this.v]; },
Object.prototype.toString,
function(a) { return [this.v, a]; }.bind({v: "bound"}),
];
var objs = [];
for (var i = 0; i < 40; i++) {
var o = {v: i};
o["p" + i] = i;
Object.defineProperty(o, "x", {get: getters[i % getters.length]});
objs.push(o);
}
for (var i = 0; i < ITERS * 4; i++) {
var o = objs[i % objs.length];
var r = getX(o);
switch (i % getters.length) {
case 0:
assertEq(r, o.v);
break;
case 1:
assertArrayEq(r, [undefined, undefined, o.v]);
break;
case 2:
assertEq(r, "[object Object]");
break;
case 3:
assertArrayEq(r, ["bound", undefined]);
break;
}
}
}
testMegamorphicGetter();