Lec 19 优化（Optimizations）——暴露 IR、类型/值分析、栈缓存与寄存器分配

本讲是 Phase 5 的核心方法论。主线：把高层指令拆开 (expose) 成更细的 IR 操作，让类型分析和值分析（常量传播）有机会删掉冗余的类型检查与常量加载；再用栈缓存 / 寄存器分配把临时值从内存搬到寄存器。贯穿全程的一句话：IR 是把分析推断出的信息编码进表示的统一载体。

TL;DR

• 将粗粒度 VM 指令拆成类型检查、解箱、运算与装箱等细粒度 IR，才能让分析看到可删除或合并的冗余工作。
• 类型分析消除重复动态检查，值分析 / 常量传播把已知值向后传递，死代码消除再删掉失去使用者的操作。
• 栈缓存和寄存器分配把临时值从内存留在机器寄存器中；IR 则是将所有分析结论统一编码为后续可消费事实的载体。

1. 今日目标与核心 takeaways

回顾 L18 那个塌缩成 9 条指令的减法例子。今天讲它怎么被优化出来。

Integer* sub(Frame *f) {
  Value *op2 = f->_stack.pop();  assert_integer(op2);
  int32_t v2 = get_integer(static_cast<Integer*>(op2));
  Value *op1 = f->_stack.pop();  assert_integer(op1);
  int32_t v1 = get_integer(static_cast<Integer*>(op1));
  Integer* res = new_integer(v1 - v2);
  f->_stack.push(res);
}

load_local 0
assert_integer
get_integer
load_const 1
assert_integer
get_integer
sub_int32
return

对上面的指令序列，抽象解释抽象栈的演变（栈格 = 类型而非值）：

去掉对常量的 assert_integer 后：

load_local 0
assert_integer    # y 仍需检查（来自参数，类型未知）
get_integer
load_const 1
get_integer
sub_int32
return

对应的机器码（每条 IR 直译，可见仍有大量 push/pop）：

// load_local 0
push %rdi
// assert_integer
pop %rdi;  call assert_integer;  push %rax
// get_integer
pop %rdi;  call get_integer;     push %rax
// load_const 1
mov 8(%r12), %rdx;  push %rdx
// get_integer
pop %rdi;  call get_integer;     push %rax
// sub
pop %rcx;  pop %rdi;  sub %rcx, %rdi;  call new_integer;  push %rax
// ret
pop %rax

5. 值分析 / 常量传播（Value Analysis / Constant Propagation）

常量 2 的值编译期就知道——何必运行时 load_const 再 get_integer？ 抽象栈跟踪到栈顶是常量 2 时：

• 把 get_integer（针对常量）替换为 get_integer 2（直接压 int32 值 2）；
• 于是 load_const 1 变成死代码（没人再用它压的那个 Integer）→ 删除。

结果：

load_local 0
assert_integer
get_integer
get_integer 2     # 直接压常量 2 的 int32
sub_int32
return

5.1 还能更好：折叠进指令

get_integer 2 紧接 sub_int32，可融合成带常量操作数的指令：

load_local 0
assert_integer
get_integer
sub_int32_const 2    # 弹一个 int32，减常量 2，压回 Integer
return

对应辅助函数与机器码：

Integer* sub_int32_const(Frame *f, int32_t v2) {
  int32_t v1 = static_cast<int32_t>(f->_stack.pop());
  f->_stack.push(new_integer(v1 - v2));
}

// load_local 0
push %rdi
// assert_integer
pop %rdi;  call assert_integer;  push %rax
// get_integer
pop %rdi;  call get_integer;     push %rax
// sub_int32_const 2
pop %rdi;  sub $2, %rdi;  call new_integer;  push %rax
// return
pop %rax

这就是 L18 提到的常量折叠 / 强度削减类优化的具体落地：值分析把常量信息固化进指令，删掉加载与一次取值。

6. 机器与存储层级（为什么要用寄存器）

寄存器比主存快约两个数量级。上面机器码里满是 push/pop（访问内存栈），把这些临时值放进寄存器就是下一步优化。

7. 栈缓存（Stack Caching）

7.1 IR 进化为寄存器形式

把"操作数栈位置"显式写成寄存器/三地址码：抽象栈每个位置映射到一个固定寄存器（如栈底位 → r13）。指令变成 dst = op args：

r13 = load_local 0
r13 = assert_integer r13
r13 = get_integer r13
r13 = sub_int32 r13 2
return r13

生成的机器码用 r13 贯穿，不再 push/pop 临时值（仅入口/出口保存 r13）：

push %r13
mov %rdi, %r13              ; r13 = load_local 0
mov %r13, %rdi; call assert_integer; mov %rax, %r13
mov %r13, %rdi; call get_integer;    mov %rax, %r13
sub $2, %r13; mov %r13, %rdi; call new_integer; mov %rax, %r13
mov %r13, %rax             ; return r13
pop %r13

对比 §5.1 满屏 push/pop 的版本，内存访问大幅减少。但栈缓存把每个栈位死板地绑到固定寄存器，不够灵活——这引出一般寄存器分配。

8. 一般寄存器分配（Register Allocation）

8.1 IR：三地址码 / RTL，引入虚拟寄存器

先用无限虚拟寄存器命名每个值：

t1 = load_local 0
t2 = assert_integer t1
t3 = get_integer t2
t4 = sub_int32 t3 2
return t4

8.2 把它当约束优化问题解

代入后：

rdi = load_local 0
rdi = assert_integer rdi
rdi = get_integer rdi
rax = sub_int32 rdi 2
return rax

机器码（注意 load_local 0 因 y 已在 rdi 而消失，连入口保存 r13 也省了）：

// rdi = load_local 0   (y 已在 rdi，空操作)
call assert_integer;  mov %rax, %rdi
call get_integer;     mov %rax, %rdi
sub $2, %rdi;  call new_integer    ; rax = sub_const rdi 2
// return rax

相比栈缓存版（固定 r13、还要 push/pop r13），这版更短——因为分配器把约束（y 在 rdi、返回值在 rax）一并优化掉了搬运。

8.3 MITScript 直线代码的基本生成算法

::: definition 定义（直线 MITScript 的代码生成算法）

• 访问每条语句；

• 按运算顺序访问语句中每个表达式；

• 为表达式结果分配一个临时值；

• 递归访问嵌套子表达式，每个返回其临时值；

• 把"对各子临时值施加运算"的结果赋给所分配的临时值；

• 若适用，把右侧的临时值赋给语句左侧；

• 保留控制流图 (CFG)。 :::

9. 累积收益（四个阶段对比）

slides 用同一段 y - 2 比较四个版本的指令数/内存访问/分配（具体数字 slides 标注"需更新"，趋势如下）：

趋势清楚：暴露 IR → 类型/值分析删冗余 → 寄存器分配去内存搬运，指令数与内存访问逐级下降。

延伸阅读：Shi, Gregg, Beatty, Ertl, "Virtual Machine Showdown: Stack Versus Registers"（栈式 vs 寄存器式 VM 的对比）。

10. 与 Crafting Interpreters 的对应（参考补充）

• 第 30 章 Optimization：NaN-boxing（拆箱/标签）、哈希表加速——对应本讲拆箱与特化。
• 课程比书走得更远：书是单遍编译不做数据流分析；本讲引入抽象解释式的类型/值分析与三地址码 + 寄存器分配，这是工业 JIT（V8、HotSpot）的标准管线。寄存器分配的算法细节留给 L21–L22，分析框架的形式化留给 L23–L24。

11. 本讲小结

• 优化套路：先把高层指令暴露成细粒度 IR 操作（assert_integer/get_integer/sub_int32），再用分析删冗余。
• 类型分析 = 抽象解释一个"类型栈"，删掉类型已知处的 assert_integer（常量必删）。
• 值分析/常量传播 = 抽象解释一个"值栈"，把常量直接折进指令（get_integer 2→sub_int32_const 2），并删除随之产生的死代码。
• 寄存器比内存快约两个数量级；栈缓存把栈位固定映射到寄存器，一般寄存器分配把它推广为带约束（同时活跃需异寄存器、特定寄存器、总数有限）的 NP 完全优化问题，用虚拟寄存器 + 三地址码表达。
• IR 是统一载体：分析把信息编码进 IR，优化彼此交互、可迭代多轮。
• 下一讲（L20）回到代码生成 II：未优化的直接映射，先把机器摸熟。