C语言函数调用分析

首先push %ebp，是将调用函数的栈帧基地址压入栈中，也就是保存调用函数的栈帧EBP。将其指向的地址压入堆栈中。mov %esp,%ebp则是将ESP和EBP指向同一个地址，作为被调用函数的栈帧基地址。sub $0x18,%esp则是修改ESP的值，与EBP构成当前被调用函数的栈帧空间。

从图中可以每个函数的栈空间都是相互独立的，但是每一个栈空间的基本结构都是相同的。都是该函数的EBP指针，然后是局部变量空间，然后是往下一个函数的传递参数空间，返回的EBP地址。这样就能实现不同函数的调用，然后传递参数是采用基于EBP指针的相对位置实现的，并没有绝对地址。

由此可以知道栈空间的分布是根据调用情况分析的，当调用过多时就会导致溢出错误，因此并不是一味的迭代和递归。

关于函数调用的返回都是采用EAX寄存器实现的，但是当返回的是结构体以及联合体时返回就不能采用EAX实现了，基本的实现方法也是基于堆栈的。

1. #include
2. 
   
3. typedef struct{
   
4. doubled;
   
5. float f;
   
6. inti;
   
7. char c;
   
8. }return_value;
   
9. 
   
10. 
    
11. return_value my_test_of_return()
    
12. {
    
13. return_value rv;
    
14. 
    
15. rv.d=12.56;
    
16. rv.f=3.1;
    
17. rv.i=10;
    
18. rv.c=a;
    
19. 
    
20. return rv;
    
21. }
    
22. 
    
23. intmain()
    
24. {
    
25. return_value local=my_test_of_return();
26. 
    
27. return 0;
    
28. }

编译以及反汇编以后得到如下的结果：

[gong@Gong-Computer deeplearn]$ gcc -g structpass.c -o structpass
[gong@Gong-Computer deeplearn]$ objdump -S -d structpass > structpass_s

1. ...
3. 08048394 :
5. char c;
7. }return_value;
10. return_value my_test_of_return()
12. {
14. 8048394: 55 push %ebp
16. 8048395: 89 e5 mov %esp,%ebp
18. 8048397: 83 ec 20 sub $0x20,%esp
20. 804839a: 8b 45 08 mov 0x8(%ebp),%eax
22. return_value rv;
26. rv.d = 12.56;
28. 804839d: dd 05 d8 84 04 08 fldl 0x80484d8
30. 80483a3: dd 5d e8 fstpl -0x18(%ebp)
32. rv.f = 3.1;
34. 80483a6: ba 66 66 46 40 mov $0x40466666,%edx
36. 80483ab: 89 55 f0 mov %edx,-0x10(%ebp)
38. rv.i = 10;
40. 80483ae: c7 45 f4 0a 00 00 00 movl $0xa,-0xc(%ebp)
42. rv.c = a;
44. 80483b5: c6 45 f8 61 movb $0x61,-0x8(%ebp)
48. return rv;
50. 80483b9: 8b 55 e8 mov -0x18(%ebp),%edx
52. 80483bc: 89 10 mov %edx,(%eax)
54. 80483be: 8b 55 ec mov -0x14(%ebp),%edx
56. 80483c1: 89 50 04 mov %edx,0x4(%eax)
58. 80483c4: 8b 55 f0 mov -0x10(%ebp),%edx
60. 80483c7: 89 50 08 mov %edx,0x8(%eax)
62. 80483ca: 8b 55 f4 mov -0xc(%ebp),%edx
64. 80483cd: 89 50 0c mov %edx,0xc(%eax)
66. 80483d0: 8b 55 f8 mov -0x8(%ebp),%edx
68. 80483d3: 89 50 10 mov %edx,0x10(%eax)
70. }
72. 80483d6: c9 leave
74. 80483d7: c2 04 00 ret $0x4
78. 080483da
    :
82. int main()
84. {
86. 80483da: 8d 4c 24 04 lea 0x4(%esp),%ecx
88. 80483de: 83 e4 f8 and $0xfffffff8,%esp
90. 80483e1: ff 71 fc pushl -0x4(%ecx)
92. 80483e4: 55 push %ebp
94. 80483e5: 89 e5 mov %esp,%ebp
96. 80483e7: 51 push %ecx
98. 80483e8: 83 ec 2c sub $0x2c,%esp
100. return_value local = my_test_of_return();
102. 80483eb: 8d 45 e0 lea -0x20(%ebp),%eax
104. 80483ee: 89 04 24 mov %eax,(%esp)
106. 80483f1: e8 9e ff ff ffcall8048394
108. 80483f6: 83 ec 04 sub $0x4,%esp
112. return 0;
114. 80483f9: b8 00 00 00 00 mov $0x0,%eax
116. }
118. 80483fe: 8b 4d fc mov -0x4(%ebp),%ecx
120. 8048401: c9 leave
122. 8048402: 8d 61 fc lea -0x4(%ecx),%esp
124. ...

从上面的结果可以知道可以知道，返回的过程并不是一次通过EAX返回的，而是通过堆栈一个一个的传递出来，实现结果的返回。因此这也是我们需要注意的地方。

同样对于结构体的传递方式也是采用堆栈的方式进行传递，基本的参看下面的分析。参数也是依据堆栈中的位置进行控制的。

代码：

1. #include
2. 
   
3. typedef struct{
   
4. doubled;
   
5. float f;
   
6. inti;
   
7. char c;
   
8. }return_value;
   
9. 
   
10. return_value my_test_pass(return_value pass)
    
11. {
    
12. return_value rv;
    
13. rv.d=pass.d;
    
14. rv.f=pass.f;
    
15. rv.i=pass.i;
    
16. rv.c=pass.c;
    
17. 
    
18. return rv;
    
19. }
    
20. return_value my_test_of_return()
    
21. {
    
22. return_value rv;
    
23. 
    
24. rv.d=12.56;
    
25. rv.f=3.1;
    
26. rv.i=10;
    
27. rv.c=a;
    
28. 
    
29. return rv;
    
30. }
    
31. 
    
32. intmain()
    
33. {
    
34. return_value local=my_test_of_return();
    
35. return_value local1=my_test_pass(local);
36. 
    
37. return 0;
    
38. }

编译和反汇编过程：

[gong@Gong-Computer deeplearn]$ gcc -g structpass.c -o structpass
[gong@Gong-Computer deeplearn]$ objdump -S -d structpass > structpass_s

1. ...
2. int main()
4. {
6. 804841d: 8d 4c 24 04 lea 0x4(%esp),%ecx
8. 8048421: 83 e4 f8 and $0xfffffff8,%esp
10. 8048424: ff 71 fc pushl -0x4(%ecx)
12. 8048427: 55 push %ebp
14. 8048428: 89 e5 mov %esp,%ebp
16. 804842a: 51 push %ecx
18. 804842b: 83 ec