微波EDA网,见证研发工程师的成长!
首页 > 硬件设计 > 嵌入式设计 > C语言函数调用分析

C语言函数调用分析

时间:12-01 来源:互联网 点击:

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

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

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

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

  1. #include

  2. typedef struct{
  3. doubled;
  4. float f;
  5. inti;
  6. char c;
  7. }return_value;


  8. return_value my_test_of_return()
  9. {
  10. return_value rv;

  11. rv.d=12.56;
  12. rv.f=3.1;
  13. rv.i=10;
  14. rv.c=a;

  15. return rv;
  16. }

  17. intmain()
  18. {
  19. return_value local=my_test_of_return();

  20. return 0;
  21. }

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

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

  1. ...
  2. 08048394 :
  3. char c;
  4. }return_value;
  5. return_value my_test_of_return()
  6. {
  7. 8048394: 55 push %ebp
  8. 8048395: 89 e5 mov %esp,%ebp
  9. 8048397: 83 ec 20 sub $0x20,%esp
  10. 804839a: 8b 45 08 mov 0x8(%ebp),%eax
  11. return_value rv;
  12. rv.d = 12.56;
  13. 804839d: dd 05 d8 84 04 08 fldl 0x80484d8
  14. 80483a3: dd 5d e8 fstpl -0x18(%ebp)
  15. rv.f = 3.1;
  16. 80483a6: ba 66 66 46 40 mov $0x40466666,%edx
  17. 80483ab: 89 55 f0 mov %edx,-0x10(%ebp)
  18. rv.i = 10;
  19. 80483ae: c7 45 f4 0a 00 00 00 movl $0xa,-0xc(%ebp)
  20. rv.c = a;
  21. 80483b5: c6 45 f8 61 movb $0x61,-0x8(%ebp)
  22. return rv;
  23. 80483b9: 8b 55 e8 mov -0x18(%ebp),%edx
  24. 80483bc: 89 10 mov %edx,(%eax)
  25. 80483be: 8b 55 ec mov -0x14(%ebp),%edx
  26. 80483c1: 89 50 04 mov %edx,0x4(%eax)
  27. 80483c4: 8b 55 f0 mov -0x10(%ebp),%edx
  28. 80483c7: 89 50 08 mov %edx,0x8(%eax)
  29. 80483ca: 8b 55 f4 mov -0xc(%ebp),%edx
  30. 80483cd: 89 50 0c mov %edx,0xc(%eax)
  31. 80483d0: 8b 55 f8 mov -0x8(%ebp),%edx
  32. 80483d3: 89 50 10 mov %edx,0x10(%eax)
  33. }
  34. 80483d6: c9 leave
  35. 80483d7: c2 04 00 ret $0x4
  36. 080483da
    :
  37. int main()
  38. {
  39. 80483da: 8d 4c 24 04 lea 0x4(%esp),%ecx
  40. 80483de: 83 e4 f8 and $0xfffffff8,%esp
  41. 80483e1: ff 71 fc pushl -0x4(%ecx)
  42. 80483e4: 55 push %ebp
  43. 80483e5: 89 e5 mov %esp,%ebp
  44. 80483e7: 51 push %ecx
  45. 80483e8: 83 ec 2c sub $0x2c,%esp
  46. return_value local = my_test_of_return();
  47. 80483eb: 8d 45 e0 lea -0x20(%ebp),%eax
  48. 80483ee: 89 04 24 mov %eax,(%esp)
  49. 80483f1: e8 9e ff ff ffcall8048394
  50. 80483f6: 83 ec 04 sub $0x4,%esp
  51. return 0;
  52. 80483f9: b8 00 00 00 00 mov $0x0,%eax
  53. }
  54. 80483fe: 8b 4d fc mov -0x4(%ebp),%ecx
  55. 8048401: c9 leave
  56. 8048402: 8d 61 fc lea -0x4(%ecx),%esp
  57. ...

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

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

代码:

  1. #include

  2. typedef struct{
  3. doubled;
  4. float f;
  5. inti;
  6. char c;
  7. }return_value;

  8. return_value my_test_pass(return_value pass)
  9. {
  10. return_value rv;
  11. rv.d=pass.d;
  12. rv.f=pass.f;
  13. rv.i=pass.i;
  14. rv.c=pass.c;

  15. return rv;
  16. }
  17. return_value my_test_of_return()
  18. {
  19. return_value rv;

  20. rv.d=12.56;
  21. rv.f=3.1;
  22. rv.i=10;
  23. rv.c=a;

  24. return rv;
  25. }

  26. intmain()
  27. {
  28. return_value local=my_test_of_return();
  29. return_value local1=my_test_pass(local);

  30. return 0;
  31. }

编译和反汇编过程:

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

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

Copyright © 2017-2020 微波EDA网 版权所有

网站地图

Top