1
// JavaScript 源码
2
function add(a, b) {
3
    return a + b;
4
}

1
// Ignition 字节码（简化）
2
LdaNamedProperty a0, [0]    // 加载参数 a
3
Add a1, [1]                  // 加上参数 b
4
Return                       // 返回结果

1
# 使用 Node.js 查看字节码
2
node --print-bytecode -e "function add(a, b) { return a + b; } add(1, 2);"

1
// 两个看似不同的对象，实际有相同的隐藏类
2
let p1 = { x: 1, y: 2 };
3
let p2 = { x: 3, y: 4 };
4
// p1 和 p2 共享同一个隐藏类 Point { x, y }

1
// 好：所有对象共享同一隐藏类
2
function Point(x, y) {
3
    this.x = x;  // 先添加 x
4
    this.y = y;  // 再添加 y
5
}
6

7
// 坏：不同添加顺序导致不同隐藏类
8
function BadPoint(x, y) {
9
    if (x > 0) {
10
        this.x = x;
11
        this.y = y;
12
    } else {
13
        this.y = y;  // 顺序不同！
14
        this.x = x;
15
    }
16
}

1
function getX(obj) {
2
    return obj.x;  // 这个属性访问有内联缓存
3
}
4

5
// 第一次调用：缓存为空，慢路径查找
6
getX({ x: 1 });  // IC 记录：隐藏类 = Point, 偏移 = 0
7

8
// 后续调用：缓存命中，直接用偏移访问
9
getX({ x: 2 });  // IC 命中：直接读取 offset 0

1
# Sea of Nodes 示例
2
# JavaScript: a + b
3

4
# 节点图
5
nodes = [
6
    Node(id=1, op='JSAdd', inputs=[2, 3]),    # a + b
7
    Node(id=2, op='LoadContext', inputs=[4]),   # 加载 a
8
    Node(id=3, op='LoadContext', inputs=[5]),   # 加载 b
9
    Node(id=4, op='Parameter', inputs=[]),      # 参数 a
10
    Node(id=5, op='Parameter', inputs=[]),      # 参数 b
11
]

1
function add(a, b) {
2
    return a + b;
3
}
4

5
// 如果类型反馈显示 a 和 b 总是 Smi（小整数）
6
// TurboFan 可以投机优化为：
7
// 1. 检查 a 和 b 是否为 Smi（守卫条件）
8
// 2. 如果是，直接做整数加法（快速路径）
9
// 3. 如果不是，去优化回 Ignition（慢速路径）

1
# 查看去优化
2
node --trace-deopt -e "
3
function add(a, b) { return a + b; }
4
for (let i = 0; i < 10000; i++) add(1, 2);  // 训练：总是 Smi
5
add('hello', 'world');  // 触发去优化！
6
"

1
// JavaScript 源码
2
function factorial(n) {
3
    let result = 1;
4
    while (n > 1) {
5
        result = result * n;
6
        n = n - 1;
7
    }
8
    return result;
9
}

1
// Ignition 字节码（简化）
2
LdaSmi [1]              // 累加器 = 1
3
Star r0                 // r0 = result = 1
4
LdaNamedProperty r1, [n] // 累加器 = n
5
Star r2                 // r2 = n
6
Loop:
7
LdaSmi [1]              // 累加器 = 1
8
CompareOp r2, gt        // r2 > 1 ?
9
JumpIfFalse EndLoop     // 如果 false 跳出
10
LdaNamedProperty r0, [result]  // 累加器 = result
11
Mul r2, [ic_slot]       // 累加器 = result * n
12
Star r0                 // r0 = result
13
LdaNamedProperty r2, [n] // 累加器 = n
14
SubSmi [1], [ic_slot]   // 累加器 = n - 1
15
Star r2                 // r2 = n
16
Jump Loop
17
EndLoop:
18
Lda r0                  // 累加器 = result
19
Return                  // 返回累加器

1
// 短链：好（单态 IC）
2
function Point(x, y) {
3
    this.x = x;  // Map0 -> Map1 (添加 x)
4
    this.y = y;  // Map1 -> Map2 (添加 y)
5
}
6
// 所有 Point 对象共享 Map2，IC 单态命中
7

8
// 长链：差（超多态 IC）
9
function DynamicObj() {}
10
const obj = new DynamicObj();
11
obj.a = 1;  // Map0 -> Map1
12
obj.b = 2;  // Map1 -> Map2
13
obj.c = 3;  // Map2 -> Map3
14
// ... 每次添加属性都创建新 Map
15
// 访问 obj.a 需要搜索转换链

1
# 查看优化/去优化
2
node --trace-opt --trace-deopt script.js
3

4
# 查看内联缓存
5
node --trace-ic script.js
6

7
# 查看字节码
8
node --print-bytecode script.js
9

10
# 查看 TurboFan 生成的代码
11
node --print-opt-code script.js

1
// 测试隐藏类对性能的影响
2
function testMonomorphic() {
3
    const objects = [];
4
    for (let i = 0; i < 100000; i++) {
5
        objects.push({ x: i, y: i * 2 });
6
    }
7
    let sum = 0;
8
    for (const obj of objects) {
9
        sum += obj.x + obj.y;
10
    }
11
    return sum;
12
}
13

14
function testPolymorphic() {
15
    const objects = [];
16
    for (let i = 0; i < 100000; i++) {
17
        if (i % 2 === 0) {
18
            objects.push({ x: i, y: i * 2 });
19
        } else {
20
            objects.push({ y: i * 2, x: i });  // 不同顺序！
21
        }
22
    }
23
    let sum = 0;
24
    for (const obj of objects) {
25
        sum += obj.x + obj.y;
26
    }
27
    return sum;
28
}
29

30
console.time('monomorphic');
31
testMonomorphic();
32
console.timeEnd('monomorphic');
33

34
console.time('polymorphic');
35
testPolymorphic();
36
console.timeEnd('polymorphic');

1
// 触发去优化
2
function add(a, b) { return a + b; }
3

4
// 训练为 Smi 加法
5
for (let i = 0; i < 10000; i++) add(1, 2);
6

7
// 触发去优化：传入字符串
8
add("hello", "world");