在阅读这篇文章之前, 请思考一下对于下面的这些问题, 你有一个准确清晰的认知吗？

1. 什么是函数栈帧？
2. 程序中的局部变量, 是如何创建的？
3. 为什么局部变量不初始化会是随机值？
4. 函数传参, 究竟是如何传参的？
5. 函数的形参和实参存在什么关系？
6. 函数是如何被调用的？
7. 函数被调用之后是如何返回的？

如果没有, 请尝试阅读、分析、理解本篇文章。 读懂本篇文章将会提升你的“自我修养”。

程序运行背后的机制和由来, 可以看作是程序员的一种“自我修养”。 ------ 程序员的自我修养 “链接、装载与库”

栈与栈帧 Link to 栈与栈帧

什么是栈？ Link to 什么是栈？

在操作系统中, 栈是一个动态内存区域。

函数的中的局部变量, 都存放在内存的栈区中。

栈区的使用, 和数据结构中的栈使用规则相似:

压栈、出栈、先进后出。

栈区总是先使用高地址, 再使用低地址, 即栈区的使用是 从高地址向低地址延伸 的。

什么是栈帧？ Link to 什么是栈帧？

从逻辑上讲, 栈帧就是一个函数执行的环境。

栈会保存一个函数被调用所需要的维护信息, 保存这些信息所用的信息空间, 常被称为 函数栈帧。

每一个函数的调用, 都会创建一个独立的栈帧。

维护函数栈帧, 需要用 两个寄存器 来记录函数栈帧的大小, 也可以叫 划定函数活动记录的范围 , 这两个寄存器存放的是地址, 两个地址之间, 就是函数的栈帧大小:

1. 寄存器 ebp: 栈底指针

指向维护栈帧的高地址.

2. 寄存器 esp: 栈顶指针

指向维护的栈帧的低地址, 会随每次压栈自动向低地址延伸.

栈帧是如何创建的? Link to 栈帧是如何创建的?

以下均在Windows平台, VS2013编译环境下演示

不同平台, 不同编译环境下的栈帧操作可能会有差异, 但是逻辑相通。

创建一个最简单的可以观察函数栈帧的程序

（步骤划分越细, 函数栈帧观察越容易）:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>

int Add(int x, int y)
{
	int z = 0;
	z = x + y;

	return z;
}

int main()
{
	int a = 10;
	int b = 20;
	int c = 0;
	c = Add(a, b);

	return 0;
}

在对代码进行调试的时候, 对函数栈帧调用进行查看, 此时调用 mian 函数栈帧:

将光标继续向后走, 走到 21行 之后跳到另外一个界面:

发现, main 函数并不是直接被计算机调用的, 而是由另外一个函数所调用

向上翻阅代码, 能看到 main 函数其实是在 __mainCRTStartup 函数中被调用

而 __mainCRTStartup 函数, 又在 mainCRTStartup 函数中被调用

所以 在调用 main 函数之前, 其实已经调用了两个函数, 也已经创建了两个函数的栈帧。但是这两个函数的栈帧创建的过程并不容易被看到, 所以我们可以观察 main 函数的栈帧的创建来详细了解栈帧的创建。

重新回到, 光标刚指向 main 函数的时候, 转到反汇编:

右边 反汇编窗口的代码 , 其实就是 main 函数中, 从函数栈帧创建, 到 main 函数结束 的整个操作及顺序。

以动画形式演示:

1. main 函数调用之前, mainCRTStartup 和 __mainCRTStartup 函数的栈帧创建(无详细内容):

   

2. 进入 main 函数:

   1. (push ebp) 压栈, 压入内容是 ebp 指向的地址(为保存当前 ebp 内容)``ps: 压栈之后, esp(栈顶指针)自动指向栈顶`
   2. (mov ebp,esp) 将 ebp 指向 esp 的地址( 将 esp 赋予 ebp)

   此时, ebp 和 esp 的实际变化为:

   未执行 :

   

   执行 push ebp :

   

   执行 mov ebp,esp :

   

   

3. 此时, 反汇编中的语句光标指向了

   sub esp,0E4h

   

   即下一句执行指令的就是 sub esp,0E4h

   汇编语言: sub 相减

   sub esp,0E4h 指 esp = esp - 0E4h

   0E4h 是十六进制数, 转换成十进制为 228:

   

   执行sub esp,0E4h 的变化:

   未执行:

   

   执行 sub esp,0E4h:

   

   

   执行之后, esp 和 ebp 之间会 存在一块由其新维护的空间

   而这段空间其实就是为 main 函数预开辟的空间

   查看地址:

   

   即: 从 0x00AFF8A4 到 0x00AFF988 就是为 main 函数与开辟的空间

   也被成为 main 函数的栈帧。

   但是, 这里并不是函数栈帧创建的结束。

4. 继续执行汇编指令, 光标继续移动:

   

   

   保存了寄存器ebx esi edi

5. 指令继续执行:

   1. 执行lea edi,[ebp-0E4h]:

      

      这里的 ebp-0E4h 地址, 经过对比, 就是 预开辟的 main 函数栈帧的栈顶地址(0x00AFF8A4)

      汇编指令 : lea(Load effect address) 加载有效地址 lea edi,[ebp-0E4h] 即为: 加载有效地址 ebp-0E4h 至寄存器edi

   2. 执行 mov ecx,39h 和 mov eax,0CCCCCCCCh

      

      👇👇👇

      

      寄存器 ecx 存入 十六进制 39(十进制 57)

      寄存器 eax 存入0xCCCCCCCC

   3. 执行 rep_stos dword_ptr_es:[edi]:

      

      执行之后, 从 0x00AFF988 - 4 到 0x00AFF8A4 的(每4字节)所有内容都被设置为了 0xCCCCCCCC , 即 开辟的main 栈帧中的所有内容被设置为 0xCCCCCCCC

      汇编指令:

      PLAINTEXT

      Copy to clipboard

      1
      2
      3
      4

      lea         edi,[ebp-0E4h]  
      mov         ecx,39h  
      mov         eax,0CCCCCCCCh  
      rep stos    dword ptr es:[edi]
      

      这一段汇编指令中最后一句

      rep_stos dword_ptr_es:[edi]

      rep : 重复上面指令, 即

      PLAINTEXT

      Copy to clipboard

      1
      2
      3

      lea         edi,[ebp-0E4h]  
      mov         ecx,39h  
      mov         eax,0CCCCCCCCh
      

      寄存器 ecx 中的值, 即为重复的次数

      stos : 将 eax 中的值拷贝到 edi 指向的地址

      指令执行时, 默认 edi 中的地址, 是增大的(向高地址增长)。所以, 会从edi [ebp-0E4h(0x00AFF8A4)] 每4字节的增长, 增长到 0x00AFF988 共 57次(寄存器 ecx 中存入的数据)

   main 函数栈帧中所有内容被 设置为了 0xCCCCCCCC

   那么 在 main 函数中 定义局部变量 而不初始化

   局部变量就会表示随机值

   所以 输出一个未初始化的局部变量, 很可能会出现:

   

到此, main 函数栈帧的预创建全部完成（只是预创建）。 接下来就是, 局部变量的创建、调用函数栈帧的创建、函数传参、函数返回等。

局部变量是如何创建的？调用函数究竟是如何传参的？ Link to 局部变量是如何创建的？调用函数究竟是如何传参的？

以上, 详细分析了 main 函数栈帧在内存中创建的过程。 创建完成之后, 就会按照顺序执行 main 函数中的函数 或 语句。

接下来, 就是局部变量在栈帧中的创建 和 函数被调用时传参的实现:

局部变量在栈帧中的创建 Link to 局部变量在栈帧中的创建

先在反汇编窗口中, 右键选择显示符号名, 可以看到:

关闭字符名则会显示地址:

dword ptr 表示地址内容为双字(4字节)数据

观察汇编代码, 对 局部变量 a、 b、 c 的创建及初始化是从 地址ebp-8 开始的。 代码向下执行:

局部变量的创建相对简单, 一张动图就可以理解。

函数被调用时的传参 及 被调用函数栈帧的创建 Link to 函数被调用时的传参 及 被调用函数栈帧的创建

调用需要使用参数的函数时, 需要传入存在的局部变量, 作为函数的参数。 但是, 被传入函数的参数, 在函数中都被称为 形参, 在被调用函数中 直接改变 并不能真正改变原来的变量, 这是为什么？

真正的原因, 就在这里:

先分析汇编代码:

PLAINTEXT

Copy to clipboard

1
2
3
4

mov        eax,dword ptr [ebp-14h]
push       eax
mov        ecx,dword ptr [ebp-8]
push       ecx

将 ebp-14h 地址处的双字的值（即变量 b 的值）存入 寄存器 eax, 压栈存入 eax , 压入位置是: 0x00AFF894 将 ebp-8 地址处的双字的值（即变量 a 的值）存入 寄存器 ecx, 压栈存入 ecx, 压入位置是: 0x00AFF890

执行之后内存中的变化:

这两个步骤, 其实就是形参的创建, 或者说调用函数时的传参操作 (被调用函数究竟是如何使用形参的内容在下边) 也就是说, 形参的创建其实是在 main 函数的栈帧中创建的。

汇编指令继续向下执行（注意: 执行 call 指令时, (VS环境)按F11 进入函数内部 ）:

call 指令, 在这里的作用是:

1. 将 call 指令的一下条指令的地址(00911F00)压入栈中
2. 然后跳转至 后边的地址(009111E0)的代码处

到此时内存变化:

jmp 指令: 无条件跳转至 后边的地址处 即在此指令中, 跳转至00911A40 处

执行 jmp :

执行 jmp 之后, 进入 Add 函数, 会发现一段熟悉的指令, 和进入 main 函数时的前几行指令相似。 这段指令就是 Add 函数预开辟栈帧的指令（不再分析）, 直接看图:

1. 先压栈, 压入的是 维护 main 函数栈帧时的ebp :

   

2. 连续执行指令, 预创建及处理 Add 函数栈帧:

   

以上是 Add 函数栈帧的创建过程。

被调用函数形参的使用 Link to 被调用函数形参的使用

自定义的 Add 函数, 目的是求两个int 类型整数的和, 返回值也是 int 类型。

观察、对比汇编代码:

1. z , 是在 Add 函数栈帧内创建的局部变量, 对应的地址是 ebp-8, 即从 ebp(此时维护Add栈帧的栈底指针) 向低地址偏移 8 字节, 发现在 Add 栈帧内部。

   

2. x、y 分别对应 : ebp+8 、ebp+0Ch 即从 ebp 向高地址偏移 8 字节 和 12 字节, 很明显不在 Add 函数栈帧内, 究竟在哪？

   

   分析之后发现, Add 函数调用的形参 其实就是之前(即将进入Add函数时), 执行这一段代码时压栈的内容:

   PLAINTEXT

   Copy to clipboard

   1
   2
   3
   4

   mov        eax,dword ptr [ebp-14h]
   push       eax
   mov        ecx,dword ptr [ebp-8]
   push       ecx
   

   将 ebp-14h 地址处的双字的值（即变量 b 的值）存入 寄存器 eax, 压栈存入 eax, 压入位置是: 0x00AFF894 将 ebp-8 地址处的双字的值（即变量 a 的值）存入 寄存器 ecx, 压栈存入 ecx, 压入位置是: 0x00AFF890

3. 所以

   函数的形参其实早在main函数栈帧中就已经创建好并且存储在一个位置, 并不是进入函数才创建的, 函数要使用形参直接在存储的那个地址拿就可以了, 这就是 在函数中改变形参不会影响原变量 的原因

观察过后, 执行相加的语句:

相加操作完成

但是需要将相加的结果作为返回值返回, 并且重新回到main 函数中, 这个函数才算执行结束.

返回操作具体是如何进行的呢？

函数返回 Link to 函数返回

函数返回并没有看上去那么简单:

return z; 语句之后, 其实都是函数返回需要进行的操作。

1. 首先是, return z;

   返回值操作是, mov eax,dword ptr [ebp-8]

   将 ebp-8(z) 处的两字(4字节) 的值存入 寄存器 eax

   返回 z 的操作, 其实就是将 z 的值, 存入了寄存器中。

   当函数使用完后, 局部变量会被销毁, 但是寄存器在CPU中是不会被销毁的。

   所以将 局部变量 z 的值 存放在寄存器中, 就能达到返回 z 的值 的效果

   

2. 再按顺序将:

   在进入 Add 函数后 压栈的 edi, esi, ebx 三个内容退栈

   

3. 然后将 ebp 的值 给 esp, 当 esp 的值变为 ebp 的值的时候, Add 函数栈帧的维护就结束了。Add 函数栈帧的空间就会还给内存

   

4. 再然后就是 pop ebp

   pop ebp 与 一般 pop 其他内容不同, pop ebp 还会将这里需要弹出的 ebp 的值 给 寄存器 ebp

   

   此时, esp 和 ebp 两个维护栈帧的寄存器, 就又去维护 main 函数栈帧了。

   这整个过程的动画

   

5. 最后一步就是 ret 指令

   当 Add 函数使用结束之后, 汇编代码应该继续回到 main 函数中的 call 指令的下一条语句的地方:

   即这里:

   

   那么怎么才能回到这里呢？

   回想一下, 在 esp 和 ebp 重新维护main 函数栈帧的时候, esp 指向的地址, 其实就是之前 call 指令执行时, 压栈压入的call 指令的下一条指令的地址:

   

   ret 指令执行之后, 会直接把这个空间弹出栈, 然后返回到这个空间存放的地址的指令处:

   

   

   这些步骤执行之后, 逻辑成功从 Add 函数中返回到 main 函数中。

   继续执行代码:

   add esp,8:

   

   mov dword ptr [ebp-20h],eax:

   

   

代码走到这里, 函数栈帧的大部分内容都已经讲的很清楚了。本篇文章到这里也就结束了。

结束 Link to 结束

再回过头来看文章开头的问题:

1. 什么是函数栈帧？

2. 程序中的局部变量, 是如何创建的？

3. 为什么局部变量不初始化会是随机值？

4. 函数传参, 究竟是如何传参的？

5. 函数的形参和实参存在什么关系？

6. 函数是如何被调用的？

7. 函数被调用之后是如何返回的？

如果读懂了本篇文章, 对于这些问题应该是有一个清晰明确的理解的。 希望可以帮到大家。

这篇文章, 是提升自我修养篇的第一篇文章。 文章的内容主要来源于 《程序员的自我修养----“链接、装载与库”》 以及 博主自己的调试与总结。

感谢！！！ （画图真的耗时间）