C语言栈帧

C语言中，函数调用是通过栈帧（stack frame）来实现的。栈帧可以被用来传递参数、保存返回信息、存储局部变量等等。栈帧的一般结构如下图：

栈帧结构的两端由两个寄存器来指定。寄存器ebp指向当前的栈帧的底部（高地址），通常叫做帧指针；寄存器esp指向当前的栈帧的顶部（低址地），通常叫做栈指针。在函数执行过程中，栈指针esp会随着数据的入栈和出栈而移动，因此函数中对大部分数据的访问都基于帧指针ebp进行。

栈帧是由高地址向低地址延伸的，例如：

入栈操作：push $eax

等价于：esp = exp - 4; $eax -> [esp]

出栈操作：pop $eax

等价于：[esp] -> $eax; esp = esp - 4;

 

下面通过源码加以解释：

add.c

[cpp]  view plain copy print ?

1. int add(int m, int n)  
2. {  
3.     int a;  
4.     int b;  
5.     int c;  
6.   
7.     a = m;  
8.     b = n;  
9.     c = a + b;  
10.     return c;  
11. }  
12.   
13. int main()  
14. {  
15.     int m = 4;  
16.     int n = 5;  
17.     int c;  
18.   
19.     c = add(m, n);  
20.   
21.     return 0;  
22. }  

 

编译：

[cpp]  view plain copy print ?

1. gcc -S -Wall add.c  

对应的汇编代码add.s

[plain]  view plain copy print ?

1.     .file   "add.c"  
2.     .text  
3. .globl add  
4.     .type   add, @function  
5. add:  
6.     pushl   %ebp                   #将当前（即main函数）的帧指针ebp入栈。由于新函数需要有自己的栈帧，因此需要将上面函数（main函数）的帧指针ebp（栈底）保存起来；而栈指针esp（即栈顶）不想要保存，因为两 个栈帧是相邻的，所以上一个栈帧的栈顶将会是下一个栈帧的栈底。  
7.     movl    %esp, %ebp             #main函数的栈指针esp即为add函数的帧指针ebp  
8.     subl    $16, %esp                 #add函数的栈指针减少16，为局部变量分配空间  
9.     movl    8(%ebp), %eax          #取得m的值，放入ebp-12，即a的位置  
10.     movl    %eax, -12(%ebp)  
11.     movl    12(%ebp), %eax         #取得n的值，放入ebp-8，即b的位置  
12.     movl    %eax, -8(%ebp)  
13.     movl    -8(%ebp), %edx         #将n的值放入edx  
14.     movl    -12(%ebp), %eax        #将m的值放入eax  
15.     addl    %edx, %eax             #计算n+m，结果放入eax  
16.     movl    %eax, -4(%ebp)         #将eax的结果放入ebp-4,即c的位置  
17.     movl    -4(%ebp), %eax         #将最后的结果放入eax  
18.     leave  
19.     ret  
20.     .size   add, .-add  
21. .globl main  
22.     .type   main, @function  
23. main:  
24.     leal    4(%esp), %ecx  
25.     andl    $-16, %esp  
26.     pushl   -4(%ecx)  
27.     pushl   %ebp  
28.     movl    %esp, %ebp  
29.     pushl   %ecx  
30.     subl    $24, %esp  
31.     movl    $4, -16(%ebp)                 #保存m的值  
32.     movl    $5, -12(%ebp)                 #保存n的值  
33.     movl    -12(%ebp), %eax  
34.     movl    %eax, 4(%esp)                 #将n的值放入esp+4  
35.     movl    -16(%ebp), %eax  
36.     movl    %eax, (%esp)                  #将m的值放入esp  
37.     call    add                           #调用add函数  
38.     movl    %eax, -8(%ebp)                #从eax取得返回值，放入ebp-8  
39.     movl    $0, %eax  
40.     addl    $24, %esp  
41.     popl    %ecx  
42.     popl    %ebp  
43.     leal    -4(%ecx), %esp  
44.     ret  
45.     .size   main, .-main  
46.     .ident  "GCC: (GNU) 4.3.0 20080428 (Red Hat 4.3.0-8)"  
47.     .section    .note.GNU-stack,"",@progbits  

[plain]  view plain copy print ?

1. <span style="font-size:14px;"></span>   

[plain]  view plain copy print ?

1. <span style="font-size:14px;"></span>   

[plain]  view plain copy print ?

1. <span style="font-size:14px;">这样编译出来的汇编代码是没有经过优化的，如果编译时选择了优化选项，即</span>  

[cpp]  view plain copy print ?

1. gcc -S -Wall -O2 add.c  

 

则产生出来的汇编代码如下：

 

[cpp]  view plain copy print ?

1.     .file   "add.c"  
2.     .text  
3.     .p2align 4,,15  
4. .globl add  
5.     .type   add, @function  
6. add:  
7.     pushl   %ebp  
8.     movl    %esp, %ebp  
9.     movl    12(%ebp), %eax  
10.     addl    8(%ebp), %eax  
11.     popl    %ebp  
12.     ret  
13.     .size   add, .-add  
14.     .p2align 4,,15  
15. .globl main  
16.     .type   main, @function  
17. main:  
18.     leal    4(%esp), %ecx  
19.     andl    $-16, %esp  
20.     pushl   -4(%ecx)  
21.     xorl    %eax, %eax  
22.     pushl   %ebp  
23.     movl    %esp, %ebp  
24.     pushl   %ecx  
25.     popl    %ecx  
26.     popl    %ebp  
27.     leal    -4(%ecx), %esp  
28.     ret  
29.     .size   main, .-main  
30.     .ident  "GCC: (GNU) 4.3.0 20080428 (Red Hat 4.3.0-8)"  
31.     .section    .note.GNU-stack,"",@progbits  

从这里也可以看出优化到底做了哪些工作，以及优化前后的效率比较。