blob: 02e0b17167845992163c71686a25d7a961e91fa6 [file] [log] [blame]
// This program attempts to relatively rare OSR exits due to mispredictions
// on the value of a local variable, where the basic block in which the local
// is assigned the offending value is different than the basic block in which
// the misspeculation occurs. The occurrence of the value that causes
// speculation failure is rare enough that the old JIT's value profiler is
// unlikely to catch it, but common enough that recompilation will be
// triggered.
//
// If the local was defined and used in the same basic block, then OSR exit
// would update the value profile associated with the assignment, and
// everything would be fine. But in this case OSR exit will see that the value
// comes from a GetLocal. If our mechanisms for updating the type predictions
// of local variables whose live ranges span basic blocks work, then it will
// only take one recompile for the optimizing compiler to converge to an
// optimal version of this code, where the variable is known to be one of two
// types and we optimize for both.
//
// TL;DR: This tests that OSR exit updates type predictions on local variables.
function foo(o,p) {
var x;
// Assign to the value on one of two basic blocks.
if (p)
x = o.f;
else
x = o.g;
var y = !x;
var z = o.h;
var w = 0;
for (var i = 0; i < 10000; ++i)
w += z[i%10];
return w + (y?1:0);
}
var array = [1,2,3,4,5,6,7,8,9,10];
var result = 0;
for (var i = 0; i < 300; ++i) {
var v = i;
if (i <= 100 || (i%4))
v = {f:{h:v}, g:{h:v+1}, h:array};
else
v = {f:(i%3)==0, g:((i+1)%3)==0, h:array};
result += foo(v,(i%2)==0);
}
if (result != 16500033)
throw "Bad result: " + result;