函数调用堆栈

来源：互联网发布：猫池软件编辑：程序博客网时间：2024/06/06 16:59

先总结一下堆栈的具体作用：

1，传递参数（为被调用函数提供参数）

2，保存局部变量

3，保存中间变量

4，在系统中用堆栈保存任务的状态（例如各个寄存器的值）

堆栈有后进先出的特性，所以能帮我们做很多事情。一会我们通过实例分析时你就会有感触。

下面先说一下看下面的具体事例分析时所需要的基础知识：

1.什么是堆栈
编译器一般使用堆栈实现函数调用。堆栈是存储器的一个区域，嵌入式环境有时需要程序员自己定义一个数组作为堆栈。Windows为每个线程自动维护一个堆栈，堆栈的大小可以设置。编译器使用堆栈来堆放每个函数的参数、局部变量等信息。
函数调用经常是嵌套的，在同一时刻，堆栈中会有多个函数的信息，每个函数占用一个连续的区域。一个函数占用的区域被称作帧（frame）。【每个函数都占有一个帧区。就是为了区分开这个函数的框架，一会我们分析具体实例时，我们就会有体会了】

      编译器是从高地址开始使用堆栈。
      在多线程（任务）环境，CPU的堆栈指针指向的存储器区域就是当前使用的堆栈。切换线程的一个重要工作，就是将堆栈指针设为当前线程的堆栈栈顶地址。
      不同CPU，不同编译器的堆栈布局、函数调用方法都可能不同，但堆栈的基本概念是一样的。【我们说的是x86机器的，因为我们比较容易做实验】

1.1堆栈相关寄存器：

esp：堆栈指针（stack pointer），指向系统栈最上面一个栈帧的栈顶
ebp: 基址指针（base pointer），指向系统栈最上面一个栈帧的底部
cs:eip：指令寄存器(extended instruction pointer)，指向下一条等待执行的指令地址
注：ebp在C语言中用作记录当前函数调用基址。

1.2堆栈操作

push：以字节为单位将数据（对于32位系统可以是4个字节）压入栈，从高到低按字节依次将数据存入ESP-1、ESP-2、ESP-3、ESP-4的地址单元。
pop：过程与PUSH相反。
call：用来调用一个函数或过程，此时，下一条指令地址会被压入堆栈，以备返回时能恢复执行下条指令。

leave：当调用函数调用时，一般都有这两条指令：pushl %ebp movl %esp, %ebp 而，leave是这两条指令的反操作。
ret：从一个函数或过程返回，之前call保存的下条指令地址会从栈内弹出到EIP寄存器中，程序转到CALL之前下条指令处执行。
注：
call指令的两个作用
①将下一条指令的地址A保存在栈顶
②设置eip指向被调用程序代码开始处

1.3函数堆栈框架的形成（C语言中）

①执行call XXX之前
cs : eip原来的值指向call下一条指令，该值被保存到栈顶
然后cs : eip的值指向xxx的入口地址
②进入 XXX
第一条指令： pushl %ebp //意为保存调用者的栈帧地址
第二条指令： movl %esp, %ebp //初始化XXX的栈帧地址
然后函数体中的常规操作，可能会压栈、出栈
③退出XXX
movl %ebp,%esp
popl %ebp
ret

2.函数调用约定
      函数调用约定包括传递参数的顺序，谁负责清理参数占用的堆栈等，如下面这个主要的函数约定表显示的：

                     函数调用约定                参数传递顺序谁负责清理参数占用的堆栈
                     __pascal                       从左到右         调用者
                     __stdcall                       从右到左         被调函数
                     __cdecl                         从右到左         调用者

      调用函数的代码和被调函数必须采用相同的函数的调用约定，程序才能正常运行。在Windows上，__cdecl是C/C++程序的缺省函数调用约定。在linux下gcc默认用的规则是__stdcall （一会我们分析的函数就是在linux下用c语言源码和反汇编语言对比分析一下函数调用的具体实现）
      在有的cpu上，编译器会用寄存器传递参数，函数使用的堆栈由被调函数分配和释放。这种调用约定在行为上和__cdecl有一个共同点：实参和形参数目不符不会导致堆栈错误。
      不过，即使用寄存器传递参数，编译器在进入函数时，还是会将寄存器里的参数存入堆栈指定位置。参数和局部变量一样应该在堆栈中有一席之地。参数可以被理解为由调用函数指定初值的局部变量。

这段代码反汇编后，代码是什么呢？

#include <stdio.h>

long test(int a,int b)
{
     a = a + 3;
     b = b + 5;
     return a + b;
}

int main(int argc, char* argv[])
{
    printf("%d",test(10,90));
    return 0;
}

先来看一个概貌

16:   int main(int argc, char* argv[])
17:   {
00401070   push        ebp
00401071   mov         ebp,esp
00401073   sub         esp,40h
00401076   push        ebx
00401077   push        esi
00401078   push        edi
00401079   lea         edi,[ebp-40h]
0040107C   mov         ecx,10h
00401081   mov         eax,0CCCCCCCCh
00401086   rep stos    dword ptr [edi]
18:       printf("%d",test(10,90));
00401088   push        5Ah
0040108A   push        0Ah
0040108C   call        @ILT+0(test) (00401005)
00401091   add         esp,8
00401094   push        eax
00401095   push        offset string "%d" (0042201c)
0040109A   call        printf (004010d0)
0040109F   add         esp,8
19:       return 0;
004010A2   xor         eax,eax
20:   }

下面来解释一下

开始进入Main函数 esp=0x12FF84   ebp=0x12FFC0
完成椭圆形框起来的部分
00401070   push        ebp     ebp的值入栈，保存现场(调用现场，从test函数看，如红线所示，即保存的0x12FF80用于从test函数堆栈返回到main函数)
00401071   mov         ebp,esp     此时ebp＝0x12FF80 此时ebp就是“当前函数堆栈”的基址以便访问堆栈中的信息；还有就是从当前函数栈顶返回到栈底

00401073   sub      esp,40h
函数使用的堆栈，默认64个字节，堆栈上就是16个横条（密集线部分）此时esp=0x12FF40
在上图中，上面密集线是test函数堆栈空间，下面是Main的堆栈空间    (补充，其实这个就叫做 Stack Frame)

00401076   push        ebx
00401077   push        esi
00401078   push        edi    入栈

00401079   lea         edi,[ebp-40h]
0040107C   mov         ecx,10h
00401081   mov         eax,0CCCCCCCCh
00401086   rep stos    dword ptr [edi]
初始化用于该函数的栈空间为0XCCCCCCCC 即从0x12FF40~0x12FF80所有的值均为0xCCCCCCCC

18:       printf("%d",test(10,90));
00401088   push        5Ah    参数入栈从右至左先90 后10
0040108A   push        0Ah

0040108C   call        @ILT+0(test) (00401005)
函数调用，转向eip 00401005
注意，此时仍入栈，入栈的是call test 指令下一条指令的地址00401091   下一条指令是add esp,8

@ILT+0(?test@@YAJHH@Z):
00401005   jmp         test (00401020)
即转向被调函数test

8:    long test(int a,int b)
9:    {
00401020   push        ebp
00401021   mov         ebp,esp           
00401023   sub         esp,40h
00401026   push        ebx
00401027   push        esi
00401028   push        edi
00401029   lea         edi,[ebp-40h]
0040102C   mov         ecx,10h
00401031   mov         eax,0CCCCCCCCh
00401036   rep stos    dword ptr [edi]       //这些和上面一样
10:        a = a + 3;                                    
00401038   mov         eax,dword ptr [ebp+8]     //ebp=0x12FF24 加8 [0x12FF30]即取到了参数10
0040103B   add         eax,3
0040103E   mov         dword ptr [ebp+8],eax
11:        b = b + 5;
00401041   mov         ecx,dword ptr [ebp+0Ch]
00401044   add         ecx,5
00401047   mov         dword ptr [ebp+0Ch],ecx
12:        return a + b;
0040104A   mov         eax,dword ptr [ebp+8]
0040104D   add         eax,dword ptr [ebp+0Ch]  //最后的结果保存在eax, 结果得以返回
13:   }
00401050   pop         edi                 
00401051   pop         esi
00401052   pop         ebx
00401053   mov         esp,ebp     //esp指向0x12FF24, test函数的堆栈空间被放弃，从当前函数栈顶返回到栈底
00401055   pop         ebp           //此时ebp=0x12FF80, 恢复现场  esp=0x12FF28
00401056   ret                          ret负责栈顶0x12FF28之值00401091弹出到指令寄存器中，esp=0x12FF30

因为win32汇编一般用eax返回结果所以如果最终结果不是在eax里面的话还要把它放到eax

注意，从被调函数返回时，是弹出EBP,恢复堆栈到函数调用前的地址，弹出返回地址到EIP以继续执行程序。

从test函数返回，执行
00401091   add         esp,8
清栈，清除两个压栈的参数10 90 调用者main负责
(所谓__cdecl调用由调用者负责恢复栈，调用者负责清理的只是入栈的参数，test函数自己的堆栈空间自己返回时自己已经清除，靠！一直理解错)

00401094   push       eax          入栈，计算结果108入栈，即printf函数的参数之一入栈
00401095   push        offset string "%d" (0042201c)     入栈，参数 "%d" 当然其实是％d的地址
0040109A   call        printf (004010d0)      函数调用 printf("%d",108) 因为printf函数时
0040109F   add         esp,8       清栈，清除参数 ("%d", 108)
19:       return 0;
004010A2   xor         eax,eax     eax清零
20:   }

main函数执行完毕此时esp=0x12FF34   ebp=0x12FF80
004010A4   pop         edi
004010A5   pop         esi
004010A6   pop         ebx
004010A7   add         esp,40h    //为啥不用mov esp, ebp? 是为了下面的比较
004010AA   cmp         ebp,esp   //比较，若不同则调用chkesp抛出异常
004010AC   call        __chkesp (00401150)
004010B1   mov         esp,ebp
004010B3   pop         ebp          //ESP=0X12FF84 EBP=0x12FFC0 尘归尘土归土一切都恢复最初的平静了 :)
004010B4   ret

另
1. 如果函数调用方式是__stdcall 不同之处在于
main函数call 后面没有了 add esp, 8
test函数最后一句是 ret 8   (由test函数清栈, ret 8意思是执行ret后，esp+8)

2. 运行过程中0x12FF28 保存了指令地址 00401091是怎么保存的？
栈每个空间保存4个字节（粒度4字节）例如下一个栈空间0x12FF2C保存参数10
因此
0x12FF28 0x12FF29 0x12FF2A 0x12FF2B
91              10            40           00
little-endian 认为其读的第一个字节为最小的那位上的数

3. char a[] = "abcde"
对局部字符数组变量（栈变量）赋值，是利用寄存器从全局数据内存区把字符串“abcde”拷贝到栈内存中的

4. int szNum[5] = { 1, 2, 3, 4, 5 }; 栈中是如何分布的？
     00401798   mov         dword ptr [ebp-14h],1
     0040179F   mov         dword ptr [ebp-10h],2
     004017A6   mov         dword ptr [ebp-0Ch],3
     004017AD   mov         dword ptr [ebp-8],4
     004017B4   mov         dword ptr [ebp-4],5
可以看出来是从右边开始入栈，所以是 5 4 3 2 1 入栈

int *ptrA = (int*)(&szNum+1);
int *ptrB = (int*)((int)szNum + 1);
std::cout<< ptrA[-1] << *ptrB << std::endl;
结果如何？
28:       int *ptrA = (int*)(&szNum+1);
004017BB   lea         eax,[ebp]
004017BE   mov         dword ptr [ebp-18h],eax
&szNum是指向数组指针；加1是加一个数组宽度；&szNum+1指向移动5个int单位之后的那个地方，就是把EBP的地址赋给指针
ptrA[-1]是回退一个int*宽度，即ebp-4
29:       int *ptrB = (int*)((int)szNum + 1);
004017C1   lea         ecx,[ebp-13h]
004017C4   mov         dword ptr [ebp-1Ch],ecx
如果上面是指针算术，那这里就是地址算术，只是首地址+1个字节的offset，即ebp-13h给指针

实际保存是这样的
01               00           00      00           02           00      00      00
ebp-14h     ebp-13h                      ebp-10h
注意是int*类型的，最后获得的是 00 00 00 02
由于Little-endian, 实际上逻辑数是02000000   转换为十进制数就为33554432
最后输出533554432

0 0