深入剖析 defer 原理篇 —— 函数调用的原理？

大纲

• 地址空间
• 函数栈帧
• 栈帧的划定
• 函数调用
• 函数返回
• 举个例子
• 总结

本篇文章是深入剖析 golang 的 defer 的基础知识准备，如果要完全理解 defer ，避免踩坑，这个章节的基础知识必不可少。我们先复习一个最基础的知识 —— 函数调用。这个对理解 defer 在函数里的行为必不可少。那么，当你看到一个函数调用的语句你能回忆起多少知识点呢？

地址空间

下图是一个典型的操作系统的地址空间示意图：

最重要的几点：

1. 内核栈在高地址，用户栈在低地址。如果是 32 位操作系统，那么最经典的就是，用户栈区域为 [0, 3G]，内核栈区域为 [3G, 4G]；
2. 栈空间分配是从高地址往下分配的（所以我们经常看到栈分配空间，是通过减 rsp 的值来实现就是这个道理）；
3. 堆空间分配是从低地址往上分配的；

函数栈帧

函数调用执行的时候，需要分配空间存储数据，比如函数的参数，函数内局部变量，寄存器的值(用于上下文切换)。这些数据都需要保存在一个地方，这个地方就是栈空间上。因为这些数据的声明周期是和函数一体的，函数执行的时候存在，函数执行完立马就可以销毁。和堆空间不同，堆上用来分配声明周期由程序员控制的对象。栈的使用规划负责人是编译器，堆空间的使用规划负责人是程序员（在有垃圾回收的语言里，堆空间的使用由语言层面支持）。

当函数调用的时候，对应产生一个栈帧（stack frame），函数结束的时候，释放栈帧。栈帧主要用来保存：

1. 函数参数
2. 局部变量
3. 返回值
4. 寄存器的值（上下文切换）

函数在执行过程中使用一块栈内存来保存上述这些值。当发生函数调用时，因为 caller 还没执行完，caller 的栈帧中保存的数据还有用，所以 callee 函数执行的时候不能覆盖 caller 的栈帧，这种情况需要分配一个 callee 的栈帧。

栈空间的使用方式由编译器管理，在编译期间就确定。栈的大小就会随函数调用层级的增加而向低地址增加，随函数的返回而缩小，调用层级越深，消耗的栈空间就越大。所以，在递归函数的场景，经常见到有些递归太深的函数会报错，被操作系统直接拒绝，就是因为考虑到这个栈空间使用的合理性，我们对栈的深度有限制。

栈帧的划定

有两个寄存器的值来划定一个函数栈帧：

1. rsp ：栈寄存器，指向当前栈顶位置；
2. rbp ：栈帧寄存器，指向函数栈帧的起始位置；

所以，我们可以认为在一个函数执行的时候，rsp, rbp 这两个寄存器指向的区域就是当前函数的一个栈帧。在 golang 的一个函数的代码里，开头会先保存 rbp 寄存器的值，保存到栈上，函数执行完之后，需要返回 caller 函数之前，需要恢复 rbp 寄存器。

举个例子：

func C(c int) (r int) {
 c1 := c + 3
 return c1
}

汇编出来的指令如下，用 dlv 调试看下：

  15: func C(c int) (r int) {
    16:     c1 := c + 3
=>  17:     return c1
    18: }

(dlv) disassemble
TEXT main.C(SB)
    // 分配栈空间
    test_call.go:15     0x1056fe0   4883ec10        sub rsp, 0x10
    // 保存上一个函数的栈基地址
    test_call.go:15     0x1056fe4   48896c2408      mov qword ptr [rsp+0x8], rbp
    // rbp 指向当前的栈基
    test_call.go:15     0x1056fe9   488d6c2408      lea rbp, ptr [rsp+0x8]
    test_call.go:15     0x1056fee   48c744242000000000  mov qword ptr [rsp+0x20], 0x0
    // 执行 a + 3
    test_call.go:16     0x1056ff7   488b442418      mov rax, qword ptr [rsp+0x18]
    test_call.go:16     0x1056ffc   4883c003        add rax, 0x3
    // 保存到 c1 变量
    test_call.go:16     0x1057000   48890424        mov qword ptr [rsp], rax
    // 保存到返回值到栈变量
=>  test_call.go:17     0x1057004   4889442420      mov qword ptr [rsp+0x20], rax
    // 恢复 rbp 值（指向上一个函数的栈基）
    test_call.go:17     0x1057009   488b6c2408      mov rbp, qword ptr [rsp+0x8]
    // 回收栈空间
    <autogenerated>:1   0x105700e   4883c410        add rsp, 0x10
    // 返回调用函数
    <autogenerated>:1   0x1057012   c3          ret

dlv 调试到这个 C 函数的时候，rsp 和 rbp 寄存器的值分别是 0x000000c00002e6f8，0x000000c00002e700，相隔 8 个字节，所以可以说这个函数的栈帧就只有 8 个字节，不过有上面有 16 个字节要注意，就是 caller 函数 rbp 的保存值和 caller 下一行要执行的指令地址。另外要提一点的是，rbp 这个寄存器其实就函数执行的功能上来说，并不需要，rbp 基本上就是给用来调试的，标明一个个栈帧，这样 gdb 或者 dlv 执行 bt 命令的时候，就能看到堆栈了。

函数调用

函数调用在 golang 里面非常简单，比如 b1 := C(b) 就是一个函数调用，执行函数 C ，传入的实参是变量 b ，返回值存入局部变量 b1，对应的汇编指令是 call 。这个语句经过编译器的翻译，如下：

// 传入参数
test_call.go:10  0x1056faf 4889442428  mov qword ptr [rsp+0x28], rax
test_call.go:11  0x1056fb4 48890424  mov qword ptr [rsp], rax
// 跳转到函数 C 执行指令
test_call.go:11  0x1056fb8 e823000000  call $main.C

这里我们注意到，一个简单的 b1 := C(b) 会翻译成多条汇编语句，通过汇编语句我们看到一行函数调用主要做两件事情：

1. 设置函数参数；
2. 执行 call 指令；

函数调用最重要的就是 call 指令。call 指令是一条基础的汇编指令，做两件事情：

1. 把当前所在函数（caller）的下一行指令压栈；

2. 会导致栈顶往下增长 8 字节

3. 跳转到 C 函数指令执行（pc 的值切换成 C 的入口指令）

什么意思？举个例子，假如 b1 := C(b) 下一行的命令是 a :=1 ，如下：

b1 := C(b)
a := 1

调用 call $main.C 的时候，就先把 a := 1 这行语句对应的代码地址保存到栈上，然后 pc 寄存器加载函数 C 的入口指令。

进入函数里面，第一件做的事情就是保存 rbp 的值，后面从函数中退出的时候，用于恢复上下文。

函数返回

golang 语言层面函数返回对应了 return 关键字，这个有必要深入理解下。函数 C 的语句如下：

func C(c int) (r int) {
 c1 := c + 3
 return c1
}

和函数调用一样，函数返回（return）的调用也是多个步骤的。看起来就调用了一行 return c1，但其实这一行语句包含了多行指令：

1. 设置返回值（函数调用是 b1 := C(b) ，这里说的设置返回值也就是设置 b1）； a . 所以，设置返回值是在 callee 函数里；

2 . 执行 ret 指令

函数返回最重要的就是 ret 指令了，这个指令和 call 是配套的，动作是相反的，汇编指令 ret 主要做两件事情：

1. 从当前栈顶处取出 [$rsp] 的值，恢复到 pc 寄存器，跳转到这个地址准备执行命令;
2. 弹栈，栈顶往上缩减 8 字节

回想上面说的函数调用时候 call 时候的压栈，ret 取出来的地址就是 a :=1 指令，这样就刚好对上了，函数 C 调用完回到原函数继续执行下一行命令。

举个例子

了解完基础知识，我们以下面的例子，分析一下这个函数栈，复习一下：

package main

func A(a int) int {
 a = a + 1
 a1 := B(a)
 return a1
}

func B(b int) int {
 b = b + 2
 b1 := C(b)
 return b1
}

func C(c int) (r int) {
 c1 := c + 3
 return c1
}

func main() {
 a := A(7)
 _ = a
}

函数栈帧如下：

这个地方的栈帧区域标注都是以 rsp，rpb 寄存器界定的，所以每个栈帧中间有 16 个字节的间隔，分别是函数压栈的地址，还有 rbp 的保存值。

总结

1. go 的一行函数调用语句其实非原子操作，对应多行汇编指令，包括 1）参数设置，2） call 指令执行；
2. 其中 call 汇编指令的内容也有两个：返回地址压栈（会导致 rsp 值往下增长，rsp-0x8），callee 函数地址加载到 pc 寄存器；
3. go 的一行函数返回 return语句其实也非原子操作，对应多行汇编指令，包括 1）返回值设置 和 2）ret 指令执行；
4. 其中 ret 汇编指令的内容是两个，指令pc 寄存器恢复为 rsp 栈顶保存的地址，rsp 往上缩减，rsp+0x8；
5. 参数设置在 caller 函数里，返回值设置在 callee 函数里；
6. rsp, rbp 两个寄存器是栈帧的最重要的两个寄存器，这两个值划定了栈帧；
7. rbp 寄存器的常见的作用栈基寄存器，但其实再深入了解下你会知道 rbp 在当今体系里其实可以作为通用寄存器了。而最常见的用来用栈基寄存器还是为了调试，比较方便的划定栈帧；

思考

为什么深入理解 defer 需要先深入理解函数调用呢？

因为，这个关系到 defer 最本质的语义：defer 是在函数调用返回的时候执行的。那么这个执行时机到底是什么样子的？是先设置返回值，还是先执行 defer 函数呢？

比如下面的例子：

func f1 () (r int) {
 t := 1
 defer func() {
  t = t +5
 }()
 return t
}

func f2() (r int) {
 defer func(r int) {
  r = r + 5
 }(r)
 return 1
}

func f3() (r int) {
 defer func () {
  r = r + 5
 } ()
 return 1
}

这三个函数的返回值分别是多少？可以思考下。

答案：f1() -> 1，f2() -> 1，f3() -> 6 。

你全对了吗？如果心有疑问，我们在下一次的 defer 原理分享里展开进一步的剖析。

本文由哈喽比特于3年以前收录，如有侵权请联系我们。
文章来源：https://mp.weixin.qq.com/s/2iyrDewtM_V2Xs8WULQnTw