Go 编译器SSA 优化tighten pass的详细过程

x = 1
x = x + 1
x = x * 2

v1 = 1
v2 = v1 + 1
v3 = v2 * 2

type Value struct {
    ID     ID           // 全函数唯一编号
    Op     Op           // 操作类型(Add64 / Load / Store / Phi ...)
    Type   *types.Type  // 结果的类型
    AuxInt int64        // 附加的整数信息(如常量值)
    Aux    Aux          // 附加的其他信息(如符号名)
    Args   []*Value     // 操作数(输入),全是别的 Value 的指针
    Block  *Block       // 属于哪个基本块
    Pos    src.XPos     // 源码位置(文件:行:列)
    Uses   int32        // 被引用的次数
    ...
}

func Sum(a, b int) int {
    x := a + b   // 第2行
    y := x * 2   // 第3行
    return y     // 第4行
}

b1:                                    ← 基本块 1
    v1 = InitMem               <mem>          ← 内存链起点(编译器自动插入)
    v2 = SP                    <uintptr>      ← 栈指针(自动插入)
    v3 = SB                    <uintptr>      ← 全局基址(自动插入)
    v4 = Arg    <int> {a}                     ← 参数 a
    v5 = Arg    <int> {b}                     ← 参数 b
    v6 = Add64  <int>  v4 v5                  ← x = a + b
    v7 = Const64 <int>  [2]                   ← 字面量 2
    v8 = Mul64  <int>  v6 v7                  ← y = x * 2
    v9 = Return <int>  v8                     ← return y

//           ↓ 结果类型
v9 = Store <mem> p, val, mem
//               ↑   ↑    ↑ 这是 3 个输入,不是 v9 的类型

func f(a, b int) int {
    if a > b {      // 分支
        return a
    }
    return b
}

        b1 (entry)
        |  a > b ?
       / \
      /   \
   真/     \假
    /       \
  b2        b3
 return a   return b

type Block struct {
    Kind     BlockKind   // 块的"出口形状"
    Values   []*Value    // 块体:块内定义的值
    Controls [2]*Value   // 出口要用的控制值(如 If 的条件)
    Succs    []Edge      // 出边
    Preds    []Edge      // 入边
    Aux/AuxInt ...       // 出口的附属信息(如跳转目标)
}

        b1
       /  \
      b2   b3
       \   /
        b4

      b1            ← 根(入口)
     / | \
   b2  b3 b4        ← b4 的 idom 是 b1(不是 b2/b3)

func f(cond bool) int {
    var x int
    if cond {
        x = 1
    } else {
        x = 2
    }
    return x + 10
}

b1: If cond → b2, b3
b2: v1 = Const64 [1]; goto b4
b3: v2 = Const64 [2]; goto b4
b4: v3 = Phi <int> v1, v2      ← 从 b2 来取 v1,从 b3 来取 v2
    v4 = Add64 v3, (Const64 10)
    Return v4

v.Args[i]   ↔   b.Preds[i]

// regalloc.go:742
func (v *Value) needRegister() bool {
    return !v.Type.IsMemory() && !v.Type.IsVoid() && !v.Type.IsFlags() && !v.Type.IsTuple()
}

// types/type.go:380
type Tuple struct {
    first  *Type
    second *Type
    // Any tuple with a memory type must put that memory type second.
}

v  = AtomicAdd64 <(UInt64,Mem)> &x, 1, mem
s0 = Select0 <UInt64> v      ← 取 first(和)
s1 = Select1 <Mem>    v      ← 取 second(新内存)

func f(c1, c2 bool, p *int) int {
    t := *p + 1        // ← t 在这里就算好了(入口块)
    var r int
    if c1 {            // 第一层菱形
        r = 100
    } else {
        r = 200
    }
    if c2 {            // 第二层菱形
        return t + r   // ← t 直到这里才被用到
    }
    return t * 2       // ← 或者这里
}

      b1 (entry)  t = *p + 1 定义在这里
     /  \
    b2   b3            第一层菱形(与 t 无关)
     \   /
      b4
     /  \
    b5   b6            ★ t 在这里才被使用
     \   /
      b7

// tighten moves Values closer to the Blocks in which they are used.
// This can reduce the amount of register spilling required,
// if it doesn't also create more live values.
// A Value can be moved to any block that
// dominates all blocks in which it is used.

b1:  t = *p + 1
     |
    b2/b3/b4  ← t 一直占着寄存器干等(还要跟这些块里的值抢寄存器!)
     |
    b5/b6:  use t

b1:  (t 搬走了,寄存器释放)
     |
    b2/b3/b4:  t = *p + 1     ← 在这里才算,算完马上用
     |
    b5/b6:  use t

┌─────────────────────────────────────────────────────────┐
│ 阶段 0:前置检查                                          │
│   -N 模式(关闭优化)且函数不巨大 → 直接返回               │
├─────────────────────────────────────────────────────────┤
│ 阶段 1:筛选可搬移的值 → canMove[]                        │
│   逐条"钉死清单"过滤 + narg 寄存器压力闸门               │
├─────────────────────────────────────────────────────────┤
│ 阶段 2:准备工具                                          │
│   memState(内存状态) / makeLCArange(LCA 表)              │
│   idom(支配树) / loopnest(循环信息)                      │
├─────────────────────────────────────────────────────────┤
│ 阶段 3:计算目标位置 → target[]          ← 不动点循环内    │
│   扫 Args(含 Phi 前驱特例)+ 扫 ControlValues,滚动求 LCA  │
├─────────────────────────────────────────────────────────┤
│ 阶段 4:循环保护                          ← 不动点循环内  │
│   target 掉进更深循环 → 沿 idom[header] 往外拽            │
├─────────────────────────────────────────────────────────┤
│ 阶段 5:执行搬移                          ← 不动点循环内  │
│   内存一致性检查 → append 到目标块 → swap-remove 原位置   │
│   有搬动则 changed=true,回到阶段 3 重来                   │
└─────────────────────────────────────────────────────────┘

// tighten.go:34-72
for _, b := range f.Blocks {
    for _, v := range b.Values {
        if v.Op.isLoweredGetClosurePtr() {
                // Must stay in the entry block.
                continue
            }
            switch v.Op {
            case OpPhi, OpArg, OpArgIntReg, OpArgFloatReg, OpSelect0, OpSelect1, OpSelectN:
                // Phis need to stay in their block.
                // Arg must stay in the entry block.
                // Tuple selectors must stay with the tuple generator.
                // SelectN is typically, ultimately, a register.
                continue
            }
            // Count arguments which will need a register.
            narg := 0
            for _, a := range v.Args {
                // SP and SB are special registers and have no effect on
                // the allocation of general-purpose registers.
                if a.needRegister() && a.Op != OpSB && a.Op != OpSP {
                    narg++
                }
            }
            if narg >= 2 && !v.Type.IsFlags() {
                // Don't move values with more than one input, as that may
                // increase register pressure.
                // We make an exception for flags, as we want flag generators
                // moved next to uses (because we only have 1 flag register).
                continue
            }
        canMove[v.ID] = true
    }
}

if v.Op.isLoweredGetClosurePtr() {
    // Must stay in the entry block.
    continue
}

func makeAdder(n int) func(int) int {
    return func(x int) int { return x + n }   // 捕获 n
}

case ssa.OpARM64LoweredGetClosurePtr:
    // Closure pointer is R26 (arm64.REGCTXT).
    ssagen.CheckLoweredGetClosurePtr(v)

入口块:
  clo = GetClosurePtr              ← 定义(= DX 的别名)
  ptr1 = OffPtr clo [8]; v1 = Load ptr1   ← 抢救捕获变量 1
  ptr2 = OffPtr clo [16]; v2 = Load ptr2  ← 抢救捕获变量 2
  ...全部消费完毕...
  (函数主体:clo 再无使用点)

switch v.Op {
case OpPhi, OpArg, OpArgIntReg, OpArgFloatReg, OpSelect0, OpSelect1, OpSelectN:
    // Phis need to stay in their block.
    // Arg must stay in the entry block.
    // Tuple selectors must stay with the tuple generator.
    // SelectN is typically, ultimately, a register.
    continue
}

b1: x = 1        b2: x = 2
    |                |
    └───→ b3 ←──────┘
b3: p = Phi <int> v_x(b1边), v_y(b2边)

b1(entry): v4 = ArgIntReg <int> [R0]   ← 必须最先执行,把 R0 抢救下来
b2:        ...任意使用 R0 的代码...      ← R0 立刻可被重新分配
b5:        use v4

t  = AtomicAdd64 <(UInt64,Mem)> &x, 1, mem   ← 元组生成器
s0 = Select0 <UInt64> t                       ← 取 first
s1 = Select1 <Mem>    t                       ← 取 second

for _, a := range v.Args {
    // SP and SB are special registers and have no effect on
    // the allocation of general-purpose registers.
    if a.needRegister() && a.Op != OpSB && a.Op != OpSP {
        narg++
    }
}
if narg >= 2 && !v.Type.IsFlags() {
    // Don't move values with more than one input, as that may
    // increase register pressure.
    // We make an exception for flags, as we want flag generators
    // moved next to uses (because we only have 1 flag register).
    continue
}

不搬:                          下沉到 b3:
b1: a,b 定义                    b1: a,b 定义
    v = Op a,b  ← 立即消费           |
    |                              b2: ...(a、b 必须一路活着!)
    b2: 中间代码                     |
    |                              b3: v = Op a,b   ← a、b、v 三者同时占寄存器
    b3: use v                        use v

v1 = OpSP
v2 = OpConst64 {8}
v3 = OpOffPtr v1 [8] // 计算地址: SP + 8
v4 = OpLoad <TypeInt64> v3 mem // 从改地址读取64位值

if narg >= 2 && !v.Type.IsFlags() {
//       ↑↑↑↑↑↑↑↑↑ 这个取反就是豁免

不搬(留在 b1):                    下沉(搬到 b3):
b1: v3 = CMPQ x, y                b1: (v3 搬走)
    |                                  |
    b2: v8 = CMPQ z, w  ← 踩掉!        b2: v8 = CMPQ z, w  ← 随便踩,无冲突
    |                                  |
    b3: If v3 → ...  (flags 已毁)      b3: v3 = CMPQ x, y  ← 生成后立刻使用
                                           If v3 → ...

// tighten.go:26-32, 74-84
startMem := f.Cache.allocValueSlice(f.NumBlocks())   // 每块开头的内存状态
endMem   := f.Cache.allocValueSlice(f.NumBlocks())
memState(f, startMem, endMem)
lca := makeLCArange(f)      // LCA 查询表
target := f.Cache.allocBlockSlice(f.NumValues())
idom := f.Idom()            // 支配树父节点
loops := f.loopnest()       // 循环信息

func f(p, q *int) int {
    *p = 1
    *q = 2
    x := *p
    y := *q
    return x + y
}

b1:
    v1  = InitMem <mem>                    ← 链头:内存版本 0
    v7  = Arg <*int> {p}
    v8  = Arg <*int> {q}
    v10 = Const64 <int> [1]
    v13 = Const64 <int> [2]
    v11 = NilCheck <*int> v7 v1            ← 使用 v1!
    v12 = Store <mem> {int} v11 v10 v1     ← 使用 v1,吐出 v12(版本 1)
    v14 = NilCheck <*int> v8 v12           ← 使用 v12
    v15 = Store <mem> {int} v14 v13 v12    ← 使用 v12,吐出 v15(版本 2)
    v16 = NilCheck <*int> v7 v15           ← 使用 v15
    v17 = Load <int> v16 v15               ← 使用 v15(不能使用 v1/v12)
    v18 = NilCheck <*int> v8 v15
    v19 = Load <int> v18 v15               ← 使用 v15
    v20 = Add64 <int> v17 v19
    v21 = MakeResult <int,mem> v20 v15     ← 返回值也带走 v15
    Ret v21

v1 ──→ v12 ──→ v15 ──→ v21
        │       │
        ├───────┴──→ v17(Load x:吃 v15)
                     v19(Load y:吃 v15)
                     v11/v14/v16/v18(NilCheck:各吃对应版本)

// types/type.go:1549
func (t *Type) IsMemory() bool {
    if t == TypeMem || t.kind == TTUPLE && t.extra.(*Tuple).second == TypeMem {
        return true
    }
    if t.kind == TRESULTS {
        if types := t.extra.(*Results).Types; len(types) > 0 && types[len(types)-1] == TypeMem {
            return true
        }
    }
    return false
}

if v.Op == OpPhi {
    if v.Type.IsMemory() { mem = v }          // 证据 1:memory Phi 本身
} else if v.Op == OpInitMem {
    mem = v                                    // 证据 2:InitMem(注释说其实非必需)
} else if a := v.MemoryArg(); a != nil && a.Block != b {
    mem = a                                    // 证据 3:块内指令的 mem 参数来自别的块
}

if mem.Op == OpPhi && mem.Block == top {
    endMem[pb.ID] = mem.Args[i]    // 特例:top 的入口是 memory Phi
} else {
    endMem[pb.ID] = mem            // 一般:前驱的出口 = top 的入口
}
if startMem[pb.ID] == nil {
    startMem[pb.ID] = endMem[pb.ID]  // 前驱自己没有锚点 → 顺带继承
    changed = append(changed, pb)    // 继续向前传播
}

b1: → b2
b2: ← b1, b2     (自循环,体内没有任何带 mem 的指令)

b1: InitMem → v10 = Store v1 …          (出口内存 v10)
      ├→ b2: v20 = Load … v10           (锚点:mem 参数 v10 来自 b1)
      └→ b3: v21 = Store v1 …           (出口 v21)
b4(←b2,b3): v30 = Phi <mem> …           (锚点:memory Phi)

// tighten.go:93-122
// Compute target locations (for moveable values only).
// target location = the least common ancestor of all uses in the dominator tree.
for _, b := range f.Blocks {
    for _, v := range b.Values {
        for i, a := range v.Args {
            if !canMove[a.ID] { continue }
            use := b
            if v.Op == OpPhi {
                use = b.Preds[i].b          // ★ Phi 特例, phi是一个虚拟的SSA,不产生实际的指令,真正是用的地方是在前驱边
            }
            if target[a.ID] == nil {
                target[a.ID] = use
            } else {
                target[a.ID] = lca.find(target[a.ID], use)
            }
        }
    }
    for _, c := range b.ControlValues() {   // ★ 第二个循环
        if !canMove[c.ID] { continue }
        if target[c.ID] == nil {
            target[c.ID] = b
        } else {
            target[c.ID] = lca.find(target[c.ID], b)
        }
    }
}

func f(c1, c2 bool) int {
    t := 42
    if c1 { ... }        // b2, b3
    if c2 {
        return t + 1     // b5 使用点 1
    }
    return t + 2         // b6 使用点 2
}

CFG:                 支配树:
      b1                  b1
     /  \                / | \
    b2   b3             b2 b3 b4
     \   /                  / \
      b4                   b5  b6
     /  \
    b5    b6
     \   /
      b7

for _, c := range b.ControlValues() { ... target[c.ID] = b ... }

func (b *Block) ControlValues() []*Value {
    if b.Controls[0] == nil { return b.Controls[:0] }
    if b.Controls[1] == nil { return b.Controls[:1] }
    return b.Controls[:2]
}

b4: v3 = CMPQ <flags> a, b    ← v3 不在任何指令的 Args 里!
    If v3 → b5, b6            ← v3 是 b4 的控制值

b1:
    x = Load ...
    y = Load ...
    v3 = CMPQ <flags> x, y      ← 生成点,离分支很远
    |
    v
b2:
    v8 = CMPQ <flags> z, w      ← ★ 另一个比较,踩掉唯一的 flag 寄存器!
    If v8 → b3, b4
b3:
    If v3 → b5, b6              ← v3 的使用点(控制值)

b1: x, y 加载
    |
b2: v8 = CMPQ z,w; If v8 → b3, b4    ← 随便踩,不再冲突
b3: v3 = CMPQ x,y                     ← 生成后立刻使用
    If v3 → b5, b6

// tighten.go:124-143
// If the target location is inside a loop,
// move the target location up to just before the loop head.
if !loops.hasIrreducible {
    // Loop info might not be correct for irreducible loops. See issue 75569.
    for _, b := range f.Blocks {
        origloop := loops.b2l[b.ID]
        for _, v := range b.Values {
            t := target[v.ID]
            if t == nil { continue }
            targetloop := loops.b2l[t.ID]
            for targetloop != nil && (origloop == nil || targetloop.depth > origloop.depth) {
                t = idom[targetloop.header.ID]
                target[v.ID] = t
                targetloop = loops.b2l[t.ID]
            }
        }
    }
}

func f(xs [][]int) int {
    sum := 0
    a := len(xs) * 2              // ← 定义在任何循环之外
    for i := range xs {           // 外层循环
        for j := range xs[i] {    // 内层循环
            sum += a + xs[i][j]   // ← a 在最深处被使用
        }
    }
    return sum
}

b1 (entry)   a = len(xs)*2        ← 定义点(不在任何循环)
 |
b2 外层 header ◄──────────────┐
 |                            |
b3 内层 header ◄─────┐        |
 |                   |        |
b4 内层 body  use a ─┘        |    ← a 的唯一使用点
 |                            |
b5 外层 latch ────────────────┘

// tighten.go:145-174
// Move values to target locations.
for _, b := range f.Blocks {
    for i := 0; i < len(b.Values); i++ {
        v := b.Values[i]
        t := target[v.ID]
        if t == nil || t == b {
            // v is not moveable, or is already in correct place.
            continue
        }
        if mem := v.MemoryArg(); mem != nil {
            if startMem[t.ID] != mem {
                // We can't move a value with a memory arg unless the target block
                // has that memory arg as its starting memory.
                continue
            }
        }
        // Move v to the block which dominates its uses.
        t.Values = append(t.Values, v)
        v.Block = t
        last := len(b.Values) - 1
        b.Values[i] = b.Values[last]
        b.Values[last] = nil
        b.Values = b.Values[:last]
        changed = true
        i--
    }
}

if mem := v.MemoryArg(); mem != nil {
    if startMem[t.ID] != mem { continue }
}

b1:
    v1 = InitMem
    v2 = Store <mem> p, 1, v1      ← 内存推进到 v2
    |
b2:  (startMem[b2] = v2)
    v3 = Load <int> q, v2          ← 吃掉 v2

t.Values = append(t.Values, v)   // ① 追加到目标块末尾
v.Block = t                      // ② 更新归属
// ③ 从原块删除(swap-remove)
last := len(b.Values) - 1
b.Values[i] = b.Values[last]
b.Values[last] = nil
b.Values = b.Values[:last]