Clearing up the `hidden classes` concept of V8

Question

I've read some articles about V8's hidden classes. However, I still have a few questions in my head:

If, let's say, there are two objects:

var a = { }
a.x = 5
a.y = 6

var b = { }
b.y = 7
b.x = 8

Do they end up with the same hidden class or separate just because one went 0 + x + y and the other 0 + y + x? As I understood, they get different classes but just wanna make sure I got it.

Then, we have this case:

function Point(x, y) {
    this.x = x
    this.y = y
}
var a = new Point(7, 8)

var b = { }
b.x = 6
b.y = 8

var c = {
    x: 8,
    y: 9
}

var d = {
    y: 9,
    x: 80
}

Do we end up with the same hidden class? I might guess that a, b and c do but d doesn't. Unless there is some sorting done on such object expressions (similarly to array's short declaration being analysed for the type).

Finally, we have this:

function PointA(x, y) {
    this.x = x
    this.y = y
}
var a = new PointA(7, 8)

function PointB(x, y) {
    this.x = x
    this.y = y
}
var b = new PointB(7, 8)

It is sorta similar to the second case. These objects seem the same except that their origin (instanceof...) is different. However, do there objects end up with the same hidden class?

Answer 1

If you download V8 and build the debug version you can pass those objects randomly to a function in an infinite loop and have it print the optimized disassembly and see if they were treated as having the same class.

In first case you are right that they will have different hidden classes.

---

In the second case you are wrong, you will end up with 4 different classes, so none of them share a class.

Firstly, fields that are added to an object outside constructor or object literal, will not be stored directly on the object but in an array external to the object. So that's why b will have different hidden class from everyone.

A unique constructor will construct objects of unique class, so a will have different hidden class from everyone. The object literals have properties in different order which is the same case as in the first case.

However object literals with exactly the same layout will share a hidden class, so if we added object e:

var e = {
    x: 32,
    y: -15
};

Then c would share same hidden class with e.

---

In third case they will have different hidden classes for the same reason as in the second case, unique constructors construct objects of different classes.

---

You might also find this interesting https://codereview.stackexchange.com/a/28360/9258

Answer 2

You can easily check by using V8's debugging shell d8.

// test1.js
var a = { }
a.x = 5
a.y = 6

var b = { }
b.y = 7
b.x = 8

print( %HaveSameMap( a, b ) ); 

Then run

$ d8 --allow-natives-syntax test1.js

You'll get the expected output:

false

For you second example:

//test2.js
function Point(x, y) {
    this.x = x
    this.y = y
}

var a = new Point(7, 8)

var b = { }
b.x = 6
b.y = 8

var c = {
    x: 8,
    y: 9
}

var d = {
    y: 9,
    x: 80
}

print( %HaveSameMap( a, b ) );
print( %HaveSameMap( b, c ) );
print( %HaveSameMap( b, d ) );
print( %HaveSameMap( c, d ) );

All 4 objects have different hidden classes:

$ d8 --allow-natives-syntax test2.js
false
false
false
false

And last but not least:

// test3.js
function PointA(x, y) {
    this.x = x
    this.y = y
}
var a = new PointA(7, 8)

function PointB(x, y) {
    this.x = x
    this.y = y
}
var b = new PointB(7, 8)
var c = new PointB(1,4)

print( %HaveSameMap( a, b ) );
print( %HaveSameMap( b, c ) );

a and b have different hidden classes, but b and cthe same.

$ d8 --allow-natives-syntax test3.js
false
true