《Go 语言设计与实现》读书笔记：常用关键字

原书中的代码片段基于 Go 1.15，笔记则根据 Go 1.22 版本的更新进行了相应替换。

fn字段表示defer关键字传入的函数，曾经是*funcval类型，其指向的函数可以拥有任意签名。而在 runtime: use func() for deferred functions 提交之后，该字段就变成了没有参数和返回值的func()类型。这是因为 Go 语言会在类型检查阶段调用 cmd/compile/internal/typecheck.normalizeGoDeferCall 将OGO和ODEFER声明中形如f(x, y)的函数标准化为：

1
2
x1, y1 := x, y          // added to init
func() { f(x1, y1) }()  // result

执行机制

中间代码生成阶段的 cmd/compile/internal/ssagen.stmt 负责处理程序中的defer关键字，该函数会根据情况使用三种不同的执行机制：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
// stmt converts the statement n to SSA and adds it to s.
func (s *state) stmt(n ir.Node) {
    ...
    switch n.Op() {
    ...
    case ir.ODEFER:
        n := n.(*ir.GoDeferStmt)
        ...
        if s.hasOpenDefers {
            s.openDeferRecord(n.Call.(*ir.CallExpr))  // 开放编码
        } else {
            d := callDefer  // 堆中分配
            if n.Esc() == ir.EscNever && n.DeferAt == nil {
                d = callDeferStack  // 栈上分配
            }
            s.call(n.Call.(*ir.CallExpr), d, false, n.DeferAt)
        }
    }
}

早期的 Go 语言会在堆上分配 runtime._defer 结构体，不过实现的性能较差；
1.13 版本的 Go 语言引入栈上分配的defer，减少了 30% 的额外开销，详见：runtime: allocate defer records on the stack；
1.14 版本的 Go 语言引入了基于开放编码的defer，使其额外开销可以忽略不计，详见：runtime: make defers low-cost through inline code and extra funcdata。

堆中分配

1
2
3
4
5
func main() {
  for i := 0; i < unpredictableNumber; i++ {
    defer fmt.Println(i) // Heap-allocated defer
  }
}

编译器无法预测示例代码中循环的迭代次数，runtime._defer 的数量会在运行期间改变，因此该结构体只能在堆中分配。在编译器看来，defer也是函数调用，因此会执行 cmd/compile/internal/ssagen.call 为其生成中间代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool, deferExtra ir.Expr) *ssa.Value {
    ...
    var call *ssa.Value
    ...
        switch {
        case k == callDefer:
            // 运行期间将调用 runtime.deferproc
            sym := ir.Syms.Deferproc
            aux := ssa.StaticAuxCall(sym, s.f.ABIDefault.ABIAnalyzeTypes(ACArgs, ACResults)) 
            call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
        ...
        }
}

Go 语言的编译器不仅将defer转换成了 runtime.deferproc，还通过以下三个步骤为所有调用defer的函数末尾插入 runtime.deferreturn：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// cmd/compile/internal/walk.walkStmt
func walkStmt(n ir.Node) ir.Node {
    ...
    switch n.Op() {
    case ir.ODEFER:
        n := n.(*ir.GoDeferStmt)
        // 设置当前函数的 hasdefer 属性
        ir.CurFunc.SetHasDefer(true)
        ...
        fallthrough
    ...
    }
}

// cmd/compile/internal/ssagen.buildssa
func buildssa(fn *ir.Func, worker int) *ssa.Func {
    ...
    var s state
    // 更新 state 的 hasdefer 字段
    s.hasdefer = fn.HasDefer()
    ...
}

// cmd/compile/internal/ssagen.exit
func (s *state) exit() *ssa.Block {
    if s.hasdefer {  
        ...
            // 在函数返回前插入 runtime.deferreturn
            s.rtcall(ir.Syms.Deferreturn, true, nil)  
    }
    ...
}

上述两个函数是defer运行时机制的入口，分别承担了不同的工作：

runtime.deferproc 负责创建新的延迟调用；
runtime.deferreturn 负责在函数调用结束时执行所有的延迟调用。

创建延迟调用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
func deferproc(fn func()) {
    gp := getg()
    d := newdefer()
    // 将 _defer 追加到链表最前面
    d.link = gp._defer
    gp._defer = d
    d.fn = fn
    d.pc = getcallerpc()
    d.sp = getcallersp()

    return0()
}

runtime.newdefer 的作用是想尽办法获得 runtime._defer 结构体，包含三种方式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
func newdefer() *_defer {
    var d *_defer
    mp := acquirem()
    pp := mp.p.ptr()
    if len(pp.deferpool) == 0 && sched.deferpool != nil {
        lock(&sched.deferlock)
        for len(pp.deferpool) < cap(pp.deferpool)/2 && sched.deferpool != nil {
            // 从调度器的延迟调用缓存池 sched.deferpool 中取出 _defer
            d := sched.deferpool
            sched.deferpool = d.link
            d.link = nil
            // 并追加到当前 Goroutine 的缓存池中
            pp.deferpool = append(pp.deferpool, d)
        }
        unlock(&sched.deferlock)
    }
    if n := len(pp.deferpool); n > 0 {
        // 从 Goroutine 的延迟调用缓存池 pp.deferpool 中取出 _defer
        d = pp.deferpool[n-1]
        pp.deferpool[n-1] = nil
        pp.deferpool = pp.deferpool[:n-1]
    }
    releasem(mp)
    mp, pp = nil, nil

    if d == nil {
        // 在堆上创建一个新的 _defer
        d = new(_defer)
    }
    d.heap = true
    return d
}

无论使用哪种方式，runtime._defer 结构体都会被追加到所在 Goroutine _defer链表的最前面。defer关键字的插入顺序是从后向前的，而执行则是从前向后的，这也解释了为什么后调用的defer会先执行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
func main() {
    for i := 0; i < 3; i++ {
        defer fmt.Println(i)
    }
}

$ go run main.go
2
1
0

另外，runtime.deferproc 在创建延迟调用时会立刻复制函数的参数，因此后者不会等到真正执行时计算：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
func main() {  
    n := 1  
    if n == 1 {  
        defer fmt.Println(n)  
        n += 100  
    }  
    fmt.Println(n)  
}

$ go run main.go
101
1

执行延迟调用

runtime.deferreturn 会在函数返回之前执行 Goroutine _defer链表中注册的所有函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
func deferreturn() {
    var p _panic
    p.deferreturn = true

    p.start(getcallerpc(), unsafe.Pointer(getcallersp()))
    for {
        // 获取下一个要执行的 defer 函数
        fn, ok := p.nextDefer()
        // 若没有更多的 defer 函数要执行，则退出循环
        if !ok {
            break
        }
        // 执行 defer 函数
        fn()
    }
}

栈上分配

当defer在函数体中最多执行一次时，runtime._defer 会在编译期间被分配到栈上：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
// cmd/compile/internal/ssagen.call
func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool, deferExtra ir.Expr) *ssa.Value {
    ...
    var call *ssa.Value
    if k == callDeferStack {
        // 在栈上初始化 defer 结构体
        t := deferstruct()
        // 运行期间将调用 runtime.deferprocStack 
        ACArgs = append(ACArgs, types.Types[types.TUINTPTR])
        aux := ssa.StaticAuxCall(ir.Syms.DeferprocStack, s.f.ABIDefault.ABIAnalyzeTypes(ACArgs, ACResults))
        callArgs = append(callArgs, addr, s.mem())
        call = s.newValue0A(ssa.OpStaticLECall, aux.LateExpansionResultType(), aux)
        call.AddArgs(callArgs...)
        call.AuxInt = int64(types.PtrSize)
    }
    ...
}

runtime.deferprocStack 只需要设置一些未在编译期间初始化的字段，就可以把defer结构体追加到 Goroutine 的延迟调用链表中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
func deferprocStack(d *_defer) {
    gp := getg()
    d.heap = false
    d.rangefunc = false
    d.sp = getcallersp()
    d.pc = getcallerpc()
    // The lines below implement:
    //   d.panic = nil
    //   d.fd = nil
    //   d.link = gp._defer
    //   d.head = nil
    //   gp._defer = d
    *(*uintptr)(unsafe.Pointer(&d.link)) = uintptr(unsafe.Pointer(gp._defer))
    *(*uintptr)(unsafe.Pointer(&d.head)) = 0
    *(*uintptr)(unsafe.Pointer(&gp._defer)) = uintptr(unsafe.Pointer(d))

    return0()
}

除了分配位置不同，栈上分配和堆中分配并没有本质区别，前者可以适用于绝大多数场景。

开放编码

开放编码将defer调用直接内联到函数末尾以及汇编代码中每一个返回语句之前，仅在满足以下条件时启用：

函数的defer数量少于或者等于 8 个；
函数的defer关键字不能在循环中执行；
函数的return语句与defer语句的乘积小于或者等于 15 个。

否则，最终生成的二进制代码将会非常臃肿。除上述几个条件外，也有其他条件会限制开放编码的使用。不过它们都是不太重要的细节，这里不会深究。

启用优化

Go 语言会在编译期间决定是否启用开放编码。在编译器生成中间代码之前，cmd/compile/internal/walk.walkStmt 会修改已经生成的抽象语法树，设置函数体上的OpenCodedDeferDisallowed属性：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
func walkStmt(n ir.Node) ir.Node {
    ...
    case ir.ODEFER:
        ...
        // 函数的 defer 数量大于 8
        if ir.CurFunc.NumDefers > maxOpenDefers || n.DeferAt != nil {
            ir.CurFunc.SetOpenCodedDeferDisallowed(true)
        }
        // defer 在循环中出现
        if n.Esc() != ir.EscNever {
            ir.CurFunc.SetOpenCodedDeferDisallowed(true)
        }
        fallthrough
    ...
}

我们在 SSA 中间代码生成阶段的 cmd/compile/internal/ssagen.buildssa 函数中也能够看到启用开放编码优化的其他条件：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
func buildssa(fn *ir.Func, worker int) *ssa.Func {
    ...
    s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.OpenCodedDeferDisallowed()
    ...
    if s.hasOpenDefers &&
        // return 和 defer 语句数量的乘积大于 15
        s.curfn.NumReturns*s.curfn.NumDefers > 15 {
        s.hasOpenDefers = false
    }
    ...
}

延迟记录

延迟比特和延迟记录是使用开放编码实现defer的两个最重要结构，Go 语言会在编译期间调用 cmd/compile/internal/ssagen.buildssa 在栈上初始化大小为 8 个比特的deferBits变量。

该变量中的每个比特位都表示对应的defer关键字是否需要被执行。如下图所示，倒数第二个比特位被设置成了 1，那么其对应的函数将在函数返回前执行：

20240818172235

编译器还会通过 cmd/compile/internal/ssagen.openDeferRecord 添加代码以评估和存储defer调用的函数，并记录有关defer的信息。传入defer的函数和参数存储在 cmd/compile/internal/ssagen.openDeferInfo 结构体中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
func (s *state) openDeferRecord(n *ir.CallExpr) {
    ...
    opendefer := &openDeferInfo{
        n: n,
    }
    fn := n.Fun
    closureVal := s.expr(fn)
    closure := s.openDeferSave(fn.Type(), closureVal)
    opendefer.closureNode = closure.Aux.(*ir.Name)
    if !(fn.Op() == ir.ONAME && fn.(*ir.Name).Class == ir.PFUNC) {
        opendefer.closure = closure
    }
    index := len(s.openDefers)
    s.openDefers = append(s.openDefers, opendefer)

    bitvalue := s.constInt8(types.Types[types.TUINT8], 1<<uint(index))
    newDeferBits := s.newValue2(ssa.OpOr8, types.Types[types.TUINT8], s.variable(deferBitsVar, types.Types[types.TUINT8]), bitvalue)
    s.vars[deferBitsVar] = newDeferBits
    s.store(types.Types[types.TUINT8], s.deferBitsAddr, newDeferBits)
}

在函数返回前，cmd/compile/internal/ssagen.openDeferExit 将处理所有使用开放编码优化的defer关键字，检查延迟比特的每个位以确定是否执行了相应的defer语句：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
// cmd/compile/internal/ssagen.exit
func (s *state) exit() *ssa.Block {
    if s.hasdefer {  
        if s.hasOpenDefers {
            ... 
            s.openDeferExit()
       } 
    }
    ...
}

上述优化过程可以用伪码表示为：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
deferBits := 0               // 初始化延迟比特

deferBits |= 1<<0            // 延迟比特最后一位设为 1
_f1, _a1 := f1, a1           // 保存函数及参数

if condition {
    deferBits |= 1<<1        // 若条件满足，延迟比特倒数第二位设为 1
    _f2, _a2 := f2, a2       // 保存函数及参数

}

exit:
if deferBits & 1<<1 != 0 {   // 00000011 & 00000010 != 0
    deferBits &^= 1<<1       // 将倒数第二位复原为 0 以进行下一次判断
    _f2(_a2)
}

if deferBits & 1<<0 != 0 {   // 00000001 & 00000001 != 0
    deferBits &^= 1<<0
    _f1(_a1)
}

综上所述，开放编码使用延迟比特和 cmd/compile/internal/ssagen.openDeferInfo 结构体存储defer的相关信息，将其直接在当前函数内展开，并在返回前根据延迟比特位决定是否执行调用。这种方法只使用了少量的位运算指令和内存资源，因此性能最好。

Panic & Recover

panic能够改变程序的控制流。调用panic后会立刻停止执行当前函数的剩余代码，并递归执行当前 Goroutine 中的defer；
recover可以中止panic造成的程序崩溃，不过只能在defer中发挥作用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func badCall() {
    panic("bad end")
}

func test() {
    defer func() {
        if e := recover(); e != nil {
            fmt.Printf("Panicing %s\r\n", e)
        }
    }()
    badCall()
    fmt.Printf("After bad call\r\n") // 无法到达
}

func main() {
    fmt.Printf("Calling test\r\n")
    test()
    fmt.Printf("Test completed\r\n")
}

$ go run main.go
Calling test
Panicing bad end
Test completed

数据结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
type _panic struct {
    argp unsafe.Pointer // 指向发生 panic 时执行 defer 调用的参数的指针
    arg  any            // panic 的参数
    link *_panic        // 指向更早的 runtime._panic

    // 调用 _panic.start 时的程序计数器和栈指针
    startPC uintptr
    startSP unsafe.Pointer

    // 调用 defer 时的栈帧
    sp unsafe.Pointer
    lr uintptr
    fp unsafe.Pointer

    // 存储 panic 应当跳转回去的程序计数器位置
    retpc uintptr

    // 用于处理开放编码优化的 defer
    deferBitsPtr *uint8
    slotsPtr     unsafe.Pointer

    recovered   bool    // 是否已经被 recover 恢复
    goexit      bool    // 保证 rutime.Goexit 不会被 defer 中的
                        // panic 和 recover 取消
    deferreturn bool  
}

runtime._panic 中的link字段与 runtime._defer 类似，因此panic关键字也支持嵌套调用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
func main() {
    defer fmt.Println("in main")
    defer func() {
        defer func() {
            panic("panic again and again")
        }()
        panic("panic again")
    }()

    panic("panic once")
}

$ go run main.go
in main
panic: panic once
    panic: panic again
    panic: panic again and again

goroutine 1 [running]:
...
exit status 2

程序崩溃

编译器会将关键字panic转换成 runtime.gopanic：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func gopanic(e any) {
    ...
    // 初始化 runtime._panic
    var p _panic
    p.arg = e

    runningPanicDefers.Add(1)
    // *_panic.start 设置 _panic 结构体的字段
    // 并将其添加到所在 Goroutine _panic 链表的最前端
    p.start(getcallerpc(), unsafe.Pointer(getcallersp()))
    // 不断从当前 Goroutine _defer 链表中获取并执行 defer 调用
    for {
        fn, ok := p.nextDefer()
        if !ok {
            break
        }
        fn()
    }

    preprintpanics(&p)
    // 终止整个程序
    fatalpanic(&p)  
    *(*int)(nil) = 0
}

该函数最后调用的 runtime.fatalpanic 实现了无法被恢复的程序崩溃：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func fatalpanic(msgs *_panic) {
    pc := getcallerpc()
    sp := getcallersp()
    gp := getg()
    var docrash bool
    systemstack(func() {
        if startpanic_m() && msgs != nil {
            runningPanicDefers.Add(-1)
            // 打印全部 panic 消息以及调用时传入的参数
            printpanics(msgs)
        }
        docrash = dopanic_m(gp, pc, sp)
    })

    if docrash {
        crash()
    }
    // 退出当前程序并返回错误码 2
    systemstack(func() {
        exit(2)
    })

    *(*int)(nil) = 0
}

崩溃恢复

编译器会将关键字recover转换为 runtime.gorecover：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
func gorecover(argp uintptr) any {
    gp := getg()
    p := gp._panic
    if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
        // 修改 runtime._panic 的 recovered 字段
        p.recovered = true
        // 返回 panic 的参数
        return p.arg 
    }
    return nil
}

p != nil：如果当前 Goroutine 没有panic，该函数将返回nil。因此，recover只能在defer调用中生效：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
func main() {
    defer fmt.Println("in main")
    if err := recover(); err != nil {
        fmt.Println(err)
    }

    panic("unknown err")
}

$ go run main.go
in main
panic: unknown err

goroutine 1 [running]:
...
exit status 2

argp == uintptr(p.argp)：runtime.gorecover 的参数argp是当前栈帧的栈指针，而p.argp则是发生panic时执行defer调用的参数的指针。因此，下面两段代码，第一段的panic可以recover，第二段则不会：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
// 第一段
func main() {
    defer func() {
        // argp 为 匿名函数的栈指针
        recover()
    }()
    panic("ooo")

}

// 第二段
func main() {
    // argp 为 main 函数的栈指针
    defer recover()
    panic("ooo")

}

runtime.gorecover 中并不包含恢复程序的逻辑，这项工作是由 runtime.recovery 完成的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
func gopanic(e any) {
    ...
    for {
        fn, ok := p.nextDefer()
        if !ok {
            break
        }
        fn()
    }
    ...
}

func (p *_panic) nextDefer() (func(), bool) {
    gp := getg()
    if !p.deferreturn {
        if gp._panic != p {
            throw("bad panic stack")
        }

        if p.recovered {
            mcall(recovery) // 不会返回
            throw("recovery failed")
        }
    }
    ...
}

func recovery(gp *g) {
    p := gp._panic
    pc, sp, fp := p.retpc, uintptr(p.sp), uintptr(p.fp)
    p0, saveOpenDeferState := p, p.deferBitsPtr != nil && *p.deferBitsPtr != 0
    ...
    gp.sched.sp = sp
    gp.sched.pc = pc
    gp.sched.lr = 0
    ...
    // 将函数的返回值设置为 1
    gp.sched.ret = 1
    // 根据 pc 和 sp 跳回 defer 关键字调用的位置
    gogo(&gp.sched)
}

runtime.deferproc的注释表明，当函数的返回值为 1 时，编译器生成的代码会直接跳转到 runtime.deferreturn 并恢复到正常的执行流程。

Make & New

make：初始化内置的数据结构，如切片、哈希表和管道；
new：根据传入的类型分配一片内存空间并返回指向这片内存空间的指针；

Make

在类型检查阶段，编译器会将代表make关键字的OMAKE节点根据参数类型转换成OMAKESLICE、OMAKEMAP和OMAKECHAN三种不同的节点。这些节点调用不同的运行时函数初始化对应的数据结构。

New

编译器在中间代码生成的遍历和替换阶段调用 cmd/compile/internal/walk.walkExpr1 和 cmd/compile/internal/walk.walkNew 决定变量的分配方式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
    switch n.Op() {
    ...
    case ir.ONEW:
        n := n.(*ir.UnaryExpr)
        return walkNew(n, init)
    ...
    }
}

func walkNew(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {  
    t := n.Type().Elem()  
    // 该类型无法分配到堆上
    if t.NotInHeap() {  
       base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())  
    }  
    // 变量没有逃逸到堆上
    if n.Esc() == ir.EscNone {  
        // 类型的大小超过了编译器允许的隐式栈变量的最大大小
       if t.Size() > ir.MaxImplicitStackVarSize {  
          base.Fatalf("large ONEW with EscNone: %v", n)  
       }  
       // 在栈上分配变量 tmp 并将 &tmp 表达式附加到 init
       return stackTempAddr(init, t)  
    }  
    // 计算类型的大小和对齐方式
    types.CalcSize(t)  
    n.MarkNonNil()  
    return n  
}

如果变量需要被分配到堆上，new关键字后续将由 cmd/compile/internal/ssagen.*state.expr 等函数处理：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
func (s *state) expr(n ir.Node) *ssa.Value {
    return s.exprCheckPtr(n, true)
}

func (s *state) exprCheckPtr(n ir.Node, checkPtrOK bool) *ssa.Value {
    ...
    switch n.Op() {
    ...
    case ir.ONEW:
        n := n.(*ir.UnaryExpr)
        var rtype *ssa.Value
        if x, ok := n.X.(*ir.DynamicType); ok && x.Op() == ir.ODYNAMICTYPE {
            rtype = s.expr(x.RType)
        }
        return s.newObject(n.Type().Elem(), rtype)
    ...
    }
}

func (s *state) newObject(typ *types.Type, rtype *ssa.Value) *ssa.Value {  
    // 若申请的空间为 0，则返回一个表示空指针的 Zerobase
    if typ.Size() == 0 {  
       return s.newValue1A(ssa.OpAddr, types.NewPtr(typ), ir.Syms.Zerobase, s.sb)  
    }  
    if rtype == nil {  
       rtype = s.reflectType(typ)  
    }
    // 将关键字转换为 runtime.Newobject
    return s.rtcall(ir.Syms.Newobject, true, []*types.Type{types.NewPtr(typ)}, rtype)[0]  
}

runtime.newobject 根据传入类型所占空间的大小，调用 runtime.mallocgc 在堆中申请一块内存并返回指向它的指针：

1
2
3
func newobject(typ *_type) unsafe.Pointer {
    return mallocgc(typ.Size_, typ, true)
}

使用var关键字初始化变量的过程与之类似：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
// cmd/compile/internal/ssagen.*state.stmt
func (s *state) stmt(n ir.Node) {
    ...
    switch n.Op() {
    ...
    case ir.ODCL:
        n := n.(*ir.Decl)
        // 若变量逃逸到堆上
        if v := n.X; v.Esc() == ir.EscHeap {
            s.newHeapaddr(v)
        }
    ...
    }
}

// cmd/compile/internal/ssagen.*state.newHeapaddr
func (s *state) newHeapaddr(n *ir.Name) {
    s.setHeapaddr(n.Pos(), n, s.newObject(n.Type(), nil))
}

Future Work

~~在阅读源码时发现了书中未提到的 runtime.deferrangefunc 和 runtime.deferprocat 函数，它们的作用是什么？~~ 两者用于实现 Go 1.22 版本的新特性：Go Wiki: Rangefunc Experiment；

《Go 语言设计与实现》读书笔记：常用关键字

For 和 Range

数组和切片

遍历清空元素

`for range a{}`

`for i := range a {}`

`for i, elem := range a {}`

哈希表

字符串

管道

Defer

数据结构

执行机制

堆中分配

创建延迟调用

执行延迟调用

栈上分配

开放编码

启用优化

延迟记录

Panic & Recover

数据结构

程序崩溃

崩溃恢复

Make & New

Make

New

Future Work