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

peter 等级 119 0 0

本篇文章是深入剖析 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)的下一行指令压栈;
  1. 会导致栈顶往下增长 8 字节
  1. 跳转到 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);
  1. 所以,设置返回值是在 callee 函数里;
  1. 执行 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 原理分享里展开进一步的剖析。


本文转自 https://mp.weixin.qq.com/s/Tl67RsMVkaRIbmKCl0z-Ow,如有侵权,请联系删除。

预览图
收藏
评论区