r/javascript • • Jun 20 '16

Javascript developers, be warned about this crazy JIT bug in V8!

Last week I've spent a full day to fix very strange behavior in a single page application for my customer that only happens on Chrome 51 (maybe 52, but not in Canary 53).

After a while our SPA started behaving incorrectly...

It turned out to be a nasty bug in the V8 JIT engine.

Try the following in Chrome's developer console:

function foo() {
  return typeof null === "undefined";
}

for(var i=0; i<10000; ++i) console.log(foo())

This should of course always print false, but in Chrome 51, it prints true after about about 100 iterations (it varies...)

I want to warn other web-developers for this bug, to avoid many $$$ being wasted (or becoming insane ;-))

 

EDIT: The following - more realistic case that we had in third-party library code - will also fail, but after about 10 thousand iterations:

function isUndefined(thing){
    return typeof thing === "undefined";
}

for(var i=0; i<100000; i++) console.log(isUndefined(null));

 

EDIT: The bug also manifests itself with the more common pattern

typeof x !== "undefined"

UPDATE: I just tried this with the latest stable Chrome (52.0.2743.82), and it now works correctly :)

482 Upvotes

117 comments sorted by

View all comments

2

u/AlGoreBestGore Jun 20 '16

While this is trippy, when would you need to check if null's type is undefined?

0

u/[deleted] Jun 20 '16

[deleted]

-4

u/hkrdrm Jun 20 '16

still wouldn't it be more proper to check

if(some_variable === null)

13

u/StoneCypher Jun 20 '16

no. null is a placeholder here.

what he's saying is "if you compare things to typeof undefined, every hundred or so iterations it'll fail. look, it even happens with null."

3

u/bits_and_bytes Jun 20 '16 edited Jun 20 '16

I've tried a few different permutations and I can only get it to reliably happen with null (or a var set to null). So I think /u/hkrdrm and /u/AlGoreBestGore are right to be asking their questions. typeof null is "object" which is why you get the false returns for the first 100+ tries when comparing it to "undefined". But I've tried comparing other "object"s with "undefined" and I don't have the same problem. For example:

var thing = {};
function foo() {
   return typeof thing === "undefined";
}

for(var i=0; i<10000; ++i) console.log(foo())

This works just fine. But if thing = null, then it all blows up.

EDIT: I've found that the bug doesn't show up if null is in a var either:

var thing = null;
function foo() {
  return typeof thing === "undefined";
}

for(var i=0; i<10000; ++i) console.log(foo())

This works correctly as well. It only seems to happen if you directly reference 'null' in the typeof comparison, and only if it's in a declared function. After the function starts returning true, it will always return true until it's re-initialized. A very strange bug indeed.

2

u/iamallamaa Jun 20 '16

I found that if the variable is defined within the function as null that it does still has the error.

function foo(){
    var thing=null;
    return typeof thing === "undefined";
}
for(var i=0; i<10000; i++) console.log(foo());

265 false 9735 true

And when null is passed as an argument, it doesn't.

function foo(thing){
    return typeof thing === "undefined";
}
for(var i=0; i<10000; i++) console.log(foo(null));

10000 false

1

u/ziriax Jun 21 '16

Try 100 thousand times... It will still fail at some point

function foo(thing){
    return typeof thing === "undefined";
}
for(var i=0; i<100000; i++) console.log(foo(null));

12291 false 87709 true

Also, once this function is JIT optimized, it can keep failing if doesn't get de-optimized