【C语言】函数栈帧的创建和销毁

函数栈帧的创建和销毁

前言：

在我们前期学习C语言的时候，我们可能有很多困惑？
比如：

• 局部变量是怎么创建的？
• 为什么局部变量的值是随机值？
• 函数是怎么传参的？传参的顺序是怎么样的？
• 形参和实参是什么关系？
• 函数调用是怎么做的？
• 函数调用结束后怎么返回的？

1. 什么是函数栈帧

通常在我们写C语言代码的时候，会把一个独立的功能抽象为函数，函数即是C语言程序的基本单位。回到我们前言讲到的问题，函数是如何调用，如何传参等等，而这些问题都和函数栈帧有关系。
函数栈帧：在我们进行函数调用的过程中在程序的调用栈所开辟的空间，这些空间里存放：

• 临时变量（局部变量以及编译器自动生产的其他临时变量）
• 函数参数和调用返回值
• 寄存器（用来存放返回值）

2. 理解函数栈帧有什么用

理解函数栈帧的创建和销毁，能帮助我们解决上面前言提到的这些问题。

• 局部变量是怎么创建的？
• 为什么局部变量的值是随机值？
• 函数是怎么传参的？传参的顺序是怎么样的？
• 形参和实参是什么关系？
• 函数调用是怎么做的？
• 函数调用结束后怎么返回的？

3.函数栈帧的创建和销毁详解

3.1 什么是栈？

1. 栈（stack） 是现代计算机程序里最为重要的概念，我们写的每一个程序里所使用的函数里面都需要用到栈。
2. 在经典的计算机科学中，栈被定义为一种特殊的容器，用户可以将数据压入栈中（入栈，push），也可以将已经压入栈中的数据弹出（出栈，pop），
3. 但是栈这个容器必须遵守一条规则：先入栈的数据后出\n栈（First In Last Out， FIFO）。
4. 就像叠成一叠的术，先叠上去的书在最下面，因此要最后才能取出。
5. 在计算机系统中，栈则是一个具有以上属性的动态内存区域。
6. 程序可以将数据压入栈中，也可以将数据从栈顶弹出。压栈操作使得栈增大，而弹出操作使得栈减小。
7. 在经典的操作系统中，栈总是向下增长（由高地址向低地址）的。
8. 在我们常见的i386或者x86-64下，栈顶由成为 esp 的寄存器进行定位的。

3.2 认识相关寄存器和汇编指令

相关寄存器

• eax：通用寄存器，保留临时数据，常用于返回值
• ebx：通用寄存器，保留临时数据
• ebq：栈底寄存器
• esp：栈顶寄存器
• eip：指令寄存器，保持当前指令的下一条指令的地址

相关汇报命令

• mov：数据转移指令
• push：数据入栈，同时esp栈顶寄存器也要发生改变
• add：加法
• sub：减法
• call：函数调用，可以压入返回值，也可以转入目标函数
• jump：通过修改eip，转入目标函数，进行调用
• ret：恢复返回地址，压入eip，类似pop，eip指令

3.3 解析函数栈帧的创建和销毁

a. 预热

首先我们得提前了解一些知识才能有效的帮助理解，函数栈帧的创建和销毁。

1. 每一次调用函数，都要为本次函数调用开辟空间–就是函数栈帧的空间
2. 这块空间的维护是使用了2个寄存器：esp和ebp，esp记录栈顶的地址，ebp记录栈底的地址。
   

b. 函数的调用堆栈

例题代码：

#include 
int Add(int x,int y)
{
	int z = 0;
	z = x + y;
	return z;
}

int main()
{
	int a = 10;
	int b = 20;
	int ret = 0;
	ret = Add(a, b);
	printf("%d\n", ret);

	return 0;
}

首先我们F11进行逐句调试，然后点击调试，选择窗口，选择调用堆栈，调试进入Add函数后就可以观察到函数的调用堆栈，如下图：
函数调用堆栈是反馈函数调用逻辑的，那我们可以清晰的观察到， main 函数调用之前，是由invoke_main 函数来调用main函数。
在 invoke_main 函数之前的函数调用我们就暂时不考虑了。那我们可以确定， invoke_main 函数应该会有自己的栈帧， main 函数和 Add 函数也会维护自己的栈帧，
每个函数栈帧都有自己的 ebp 和 esp 来维护栈帧空间。那接下来我们从main函数的栈帧创建开始讲解：

c. 转到反汇编

F11调试到main函数开始执行，右击鼠标转到反汇编。在我们VS编译器中每次调试都会为程序重新分配内存。

int main()
{
//函数栈帧的创建
00591820  push        ebp  
00591821  mov         ebp,esp  
00591823  sub         esp,0E4h  
00591829  push        ebx  
0059182A  push        esi  
0059182B  push        edi  
0059182C  lea         edi,[ebp-24h]  
0059182F  mov         ecx,9  
00591834  mov         eax,0CCCCCCCCh  
00591839  rep stos    dword ptr es:[edi]  
//main函数中的代码
	int a = 10;
0059183B  mov         dword ptr [a],0Ah  
	int b = 20;
00591842  mov         dword ptr [b],14h  
	int ret = 0;
00591849  mov         dword ptr [ret],0  
	ret = Add(a, b);
00591850  mov         eax,dword ptr [b]  
00591853  push        eax  
00591854  mov         ecx,dword ptr [a]  
00591857  push        ecx  
00591858  call        _Add (05910B4h)  
0059185D  add         esp,8  
00591860  mov         dword ptr [ret],eax  
	printf("%d\n", ret);
00591863  mov         eax,dword ptr [ret]  
00591866  push        eax  
00591867  push        offset string "%d\n" (0597B30h)  
0059186C  call        _printf (05910D2h)  
00591871  add         esp,8  

	return 0;
00591874  xor         eax,eax  
}

d. 函数栈帧的创建

00591820  push        ebp  
//把ebp寄存器中的值进行压栈，此时ebp存放的是invoke_main函数栈帧的ebp，esp-4
00591821  mov         ebp,esp  
//move指令是把esp的值存放到ebp中，相当于产生了main函数的ebp，这个值就是
//invoke_main函数栈帧的esp
00591823  sub         esp,0E4h  
//sub让esp中的地址减去一个16进制Oxe4，产生新的esp，此时esp是main函数栈帧的esp，
//此时结合上一条指令的ebp和当前的esp，ebp和esp之间维护了一个块栈空间，这个就是
//为main函数开辟的栈空间，这一段空间中将储存main函数中的局部变量，临时变量和已经调试的信息等。
00591829  push        ebx  
//将寄存器ebx的值压栈，esp-4
0059182A  push        esi  
//将寄存器esi的值压栈，esp-4
0059182B  push        edi  
//将寄存器edi的值压栈，esp-4
//这三条push指令保存了3个寄存器的值在栈区，这3个在函数随后执行中可能会被修改，
//所以先保存寄存器原来的值，以便在退出函数时恢复。

//初始化main函数的栈帧空间
0059182C  lea         edi,[ebp-24h]  
//把[ebp-24h]  的地址放在edi中
0059182F  mov         ecx,9  
//把9放在eax中
00591834  mov         eax,0CCCCCCCCh  
//把0CCCCCCCCh  放在eax中
00591839  rep stos    dword ptr es:[edi]  
//edi到9这一段的内存里面每一个字节都被初始化为OxCC

	int a = 10;
0059183B  mov         dword ptr [a],0Ah 
//将10存储到[a]的地址处，[a]的位置其实就是a变量 
	int b = 20;
00591842  mov         dword ptr [b],14h  
//将10存储到[b]的地址处，[b]的位置其实就是b变量 
	int ret = 0;
00591849  mov         dword ptr [ret],0  
//将0存储到[ret]的地址处，[ret]的位置其实是ret变量
//以上汇编代码表示的变量a,b,ret的创建和初始化，这就是局部的变量的创建和初始化
//其实是局部变量的创建时在局部变量所在函数的栈帧空间中创建的
//调用Add函数
	ret = Add(a, b);
//调用Add函数时的传参
//其实传参就是把参数push到栈帧空间中
00591850  mov         eax,dword ptr [b] 
 //传递b，将[b]处放的20放在eax寄存器中
00591853  push        eax  
//将eax的值压栈
00591854  mov         ecx,dword ptr [a] 
//传递a，将[a]处放的20放在ecx寄存器中
00591857  push        ecx 
//将ecx的值压栈
00591858  call        _Add (05910B4h)  
//跳转调用函数
0059185D  add         esp,8  
00591860  mov         dword ptr [ret],eax 

函数调用的过程

00591858  call        _Add (05910B4h)  
//跳转调用函数
0059185D  add         esp,8  
00591860  mov         dword ptr [ret],eax 

call 指令是要执行函数调用逻辑的，在执行call指令之前先会把call指令的下一条指令的地址进行压栈操作，
这个操作是为了解决当函数调用结束后要回到call指令的下一条指令的地方，继续往后执行。

接下来我们跳转到Add函数，观察Add函数的反汇编代码。

int Add(int x, int y)
{
00591760  push        ebp  //将main函数栈帧的ebp保存
00591761  mov         ebp,esp  //将main函数的esp给新的ebp，该ebp为Add函数的ebp
00591763  sub         esp,0CCh  //求Add函数的esp
00591769  push        ebx  //将ebx压栈
0059176A  push        esi   //将esi压栈
0059176B  push        edi   //将edi压栈
	int z = 0;
0059176C  mov         dword ptr [z],0  //把0放在[z]
	z = x + y;
00591773  mov         eax,dword ptr [x]  //把[x]的地址移到eax中
00591776  add         eax,dword ptr [y] // 把[y]的地址移到eax中
00591779  mov         dword ptr [z],eax  //将eax的值保存在[z]中
	return z;
0059177C  mov         eax,dword ptr [z]  //把z的值储存在eax寄存器中，把它作为计算结果做函数的返回值
}
0059177F  pop         edi  
00591780  pop         esi  
00591781  pop         ebx  
00591782  mov         esp,ebp  
00591784  pop         ebp  
00591785  ret  

图片中的 a 和 b 其实就是 Add 函数的形参 x , y 。这里的分析很好的说明了函数的传参过程，以及函数\n在进行值传递调用的时候，形参其实是实参的一份拷贝。对形参的修改不会影响实参。

e. 函数栈帧的销毁

当函数调用要结束返回的时候，前面创建的函数栈帧也开始销毁。

0059177F  pop         edi  
在栈顶弹出一个值，存放到edi中，esp+4
00591780  pop         esi  
//在栈顶弹出一个值，存放到esi中，esp+4
00591781  pop         ebx  
 //在栈顶弹出一个值，存放到ebx中，esp+4
00591782  mov         esp,ebp  
//再将Add函数的ebp的值赋值给esp，相当于回收了Add函数的栈帧空间
00591784  pop         ebp  
//弹出栈顶的值存放到ebp，栈顶此时的值恰好就是main函数的ebp，esp+4，
//此时恢复了main函数的栈帧维护，esp指向main函数栈帧的栈顶，ebp指向了main函数栈帧的栈底。
00591785  ret  
//ret指令的执行，首先是从栈顶弹出一个值，此时栈顶的值就是call指令下一条指令的地址，
//此时esp+4，然后直接跳转到call指令下一条指令的地址处，继续往下执行。

如图所示，回到call指令的下一条地址
接着回到main函数，执行add和move

0059185D  add         esp,8  
//esp直接+8，相当于跳过了main函数中压栈的a和b
00591860  mov         dword ptr [ret],eax  
//将eax中值，存档到ebp-0x20的地址处，其实就是存储到main函数中ret变量中，
//而此时eax中就是Add函数中计算的x和y的和，可以看出来，本次函数的返回值是由eax寄存器带回来的。
//程序是在函数调用返回之后，在eax中去读取返回值的。
	printf("%d\n", ret);

4. 解答前言提到的问题

弄清楚整个的函数栈帧的创建和销毁之后，我们再来回过头看到我们这些问题：

• 局部变量是怎么创建的？
  首先为函数开辟好栈帧空间，在这个空间里我们初始化一段空间，再给局部变量栈帧里面分配一点空间。
• 为什么局部变量的值是随机值？
  因为值是我们随机放进栈帧空间里面去的。
• 函数是怎么传参的？传参的顺序是怎么样的？
  当我们要去调用函数之前，通过push把俩个参数从右向左进行压栈放进栈帧空间里，在Add函数栈帧空间里面通过指针的偏移量找回到我们的形参。
• 形参和实参是什么关系？
  形参是我们压栈开辟的空间，和实参值时相同的，空间是独立的，所以形参是实参的一份临时拷贝，改变形参不会影响实参。
• 函数调用是怎么做的？
  在上面d中我们讲的很清楚。
• 函数调用结束后怎么返回的？
  在我们调用之前把call指令的下一条指令的地址（记住）压栈了，把ebp调用函数的上一个函数的ebp栈帧存放进去了，当我们函数调完要返回的时候pop弹出ebp就能找到我们原始上一个函数调用的ebp，然后指针往下走找到esp栈顶回到我们的栈帧空间，当往回走会找到call指令的下一条指令的地址，让我们函数调用完返回，返回值是通过寄存器方式带回来的。