c++函数的返回值存在哪?反汇编代码分析

这几天一直在给同学讲数据结构和算法的题,讲题的过程中突然想到这函数的返回值究竟是存放在哪的,为什么可以通过函数的调用来直接给变量赋值。仔细想想这么多年居然没有深究过这个问题,太不应该,于是今天花了些时间来好好研究了一下这个问题。也跟了一些thread,某些前辈的观点是“不应该动不动就提到寄存器,栈,堆这些较底层的概念。完全可以这样理解:返回值保存在一段临时区域,到下一条语句时,返回值被销毁,所以,如果要继续使用返回值,必须将返回值赋予其他变量。”这确实不假,但是我觉得这位前辈应该是在透彻理解了内在的机理之后才这么说的,我觉得作为学习过程还是应该深究一下。

另有一位前辈说“不大于32位的(返回值)在eax中,64位的在edx + eax中。再大就传指针了。”

那么就拿反汇编代码开刀,验证一下。

(一)  基础知识

在看反汇编代码之前,应该有几点要明确一下:

1.每个进程对应一个Call Stack(调用栈),而CallStack 又由许多Stack Frame(栈帧)组成,对应每个未完成的函数调用,由系统分配。(VC调试中默认是会显示调用栈窗口的,越往栈顶的就是越最近调用的函数,黑色显示的就是还未返回的函数调用)

2.eax, ebx, ecx, edx, esi, edi, ebp, esp等都是X86 汇编语言中CPU上的32位通用寄存器的名称,他们各自的作用如下:

EAX 是累加器(accumulator), 它是很多加法乘法指令的缺省寄存器。

EBX 是基地址(base)寄存器,在内存寻址时存放基地址。

ECX 是计数器(counter),是重复(REP)前缀指令和LOOP指令的内定计数器。

EDX 则一般被用来放整数除法产生的余数。

ESI/EDI分别是源/目标索引寄存器(source/destinationindex),在很多字符串操作指令中,DS:ESI指向源串,而ES:EDI指向目标串。

EBP是基址指针(BASE POINTER),按照习惯,通常用于界定StackFrame(栈帧)。

ESP 是堆栈指针,被形象地称为栈顶指针,堆栈的顶部是地址小的区域,压入堆栈的数据越多,ESP也就越来越小。在32位平台上,每压入一个数据,ESP就减少4字节。

3.windows平台下的Call Stack,从上(高地址)往下(低地址)生长。

(二)代码分析

首先我实验的平台是32位版vs2010,程序为Debug版本。

先试试32位整型的int,C++的实验代码如下:

  1. #include “stdafx.h”
  2. int minus(int a ,int b)
  3. {
  4.          int j=2;
  5.          return a-b;
  6. }
  7. int _tmain(int argc, _TCHAR* argv[])
  8. {
  9.          int i=1;
  10.          int c=minus(3,1);
  11.          return 0;
  12. }

 

在return 0处设置断点,或者直接用system(“pause”)也行。

调试运行,可以看到反汇编代码如下:

  1. int minus(int a ,int b)
  2. {
  3. /*step8 再次将EPB压栈,并将ESP的值放入EPB中,此时ESP指向位置5,EPB也指向位置5,这个位置也正是minus()栈帧的底部,同时又是Main()栈帧的顶部*/
  4. 01091380 push        ebp
  5. 01091381 mov         ebp,esp
  6. /*step9 作用同step2。此时EPB位置不变,ESP指向位置6*/
  7. 01091383 sub         esp,0CCh
  8. /*step10 作用同step3。此时EPB位置不变,ESP指向位置7*/
  9. 01091389 push        ebx
  10. 0109138A push        esi
  11. 0109138B push        edi
  12. /*step11 作用同step4。ESP和EPB位置不变*/
  13. 0109138C lea         edi,[ebp-0CCh]
  14. 01091392 mov         ecx,33h
  15. 01091397 mov         eax,0CCCCCCCCh
  16. 0109139C rep stos    dword ptres:[edi]
  17.          int j=2;
  18. /*step12 作用同step5。ESP和EPB位置不变*/
  19. 0109139E mov         dword ptr [j],2
  20.          return a-b;
  21. /*step13 将参数a的值放入EAX。然后将参数b的值也传入,在EAX中进行减法,结果存放在EXA中。ESP和EPB位置不变*/
  22. 010913A5 mov         eax,dword ptr [a]
  23. 010913A8 sub         eax,dword ptr [b]
  24. }
  25. /*step14 返回过程。将三个寄存器的值弹出,恢复到调用前的状态。并将EBP的值赋给ESP,此时EBP与ESP都指向位置5,也就是释放了从位置6到位置5的预留空间。最后弹出EBP的值,使其恢复到调用minus()前的状态,ret语句进行返回,返回到先前压入栈中的返回地址所指向的地址处。此时EPB指向位置0,ESP指向位置3*/
  26. 010913AB pop         edi
  27. 010913AC pop         esi
  28. 010913AD pop         ebx
  29. 010913AE mov         esp,ebp
  30. 010913B0 pop         ebp
  31. 010913B1 ret
  32. int _tmain(int argc, _TCHAR* argv[])
  33. {
  34. /*step1 运行时库的启动函数mainCRTStartup()调用Main(),正式进入主函数,将EPB压栈,再将ESP的值放入EPB中,此时ESP指向位置0,EPB也指向位置0,这个位置也正是的Main()栈帧的底部,同时又是mainCRTStartup()栈帧的顶部*/
  35. 010913C0 push        ebp
  36. 010913C1 mov         ebp,esp
  37. /*step2 将ESP下移0CCh个字节,也就是位置0到位置1之间的空间,这段空间将预留用来存储局部变量,此时ESP指向位置1,EPB指向位置0*/
  38. 010913C3 sub         esp,0D8h
  39. /*step3 将三个寄存器的值压栈,此时ESP指向位置2,EPB指向位置0*/
  40. 010913C9 push        ebx
  41. 010913CA push        esi
  42. 010913CB push        edi
  43. /*step4 首先将位置1的地址放入目标索引寄存器EDI中,stos dwordptr es:[edi]的意思是从累加器EAX传送4个字节(双字),到由EDI作为指针的目的串中,同时修改EDI以指向串中的下一个单元,前面加上rep代表重复执行,执行次数就是ECX寄存器中的值,而36h*4正好等于0D8h,所以以下4句的作用就是将刚刚预留的位置0到位置1之间的空间全部赋值为0CCCCCCCCh ,这其实就是int 3断点,以防止意外访问。ESP和EPB位置不变*/
  44. 010913CC lea         edi,[ebp-0D8h]
  45. 010913D2 mov         ecx,36h
  46. 010913D7 mov         eax,0CCCCCCCCh
  47. 010913DC rep stos    dword ptres:[edi]
  48.          int i=1;
  49. /*step5 将1传到局部变量i所在地址中,也就是刚刚预留的那块空间中,i应当是EBP-偏移量的形式。ESP和EPB位置不变*/
  50. 010913DE mov         dword ptr [i],1
  51.          int c=minus(3,1);
  52. /*step6 在调用minus()前,按从右到左的顺序将实参压栈。EPB位置不变,ESP指向位置3*/
  53. 010913E5 push        1
  54. 010913E7 push        3
  55. /*step7 调用minus(),并将下一条语句的地址010913EE压栈,作为返回地址。EPB位置不变,ESP指向位置4*/
  56. 010913E9 call        minus (10911C7h)
  57. /*step15 从minus返回。将ESP+8,代表释放前面压入栈中的两个市场(2个4字节),并将EAX中的值(也就是返回值)赋给局部变量c,这里也就证明了当返回值是32位int类型的时候,返回值确实是暂存在EAX中的。EPB指向位置0,ESP指向位置2*/
  58. 010913EE add         esp,8
  59. 010913F1 mov         dword ptr [c],eax
  60.          return 0;
  61. /*step16 准备返回0给main函数。先对EAX自身做异或运算,EAX变成0,此时返回值才是真正的不存在了。然后将三个寄存器的值弹出,恢复到mainCRTStartup()调用main()前的状态,接着释放位置1到位置0之间的预留空间。EPB和ESP都指向位置0。再接着通过比较EBP与ESP的值,检查ESP是否正常。不相等则调用ILT+305指向的异常处理函数,使ESP等于EBP。正常的话就直接弹出EBP,结束main()函数,返回mainCRTStartup()函数中继续剩下的操作。*/
  62. 010913F4 xor         eax,eax
  63. }
  64. 010913F6 pop         edi
  65. 010913F7 pop         esi
  66. 010913F8 pop         ebx
  67. 010913F9 add         esp,0D8h
  68. 010913FF cmp         ebp,esp
  69. 01091401 call       @ILT+305(__RTC_CheckEsp) (1091136h)
  70. 01091406 mov         esp,ebp
  71. 01091408 pop         ebp
  72. 01091409 ret

示意图如图:

 

再试试64位整型的long long,C++的实验代码如下(VC6编译器可能不支持long long):

  1. #include “stdafx.h”
  2. long long minus(long long a , long long b)
  3. {
  4.          int j=2;
  5.          return a-b;
  6. }
  7. int _tmain(int argc, _TCHAR* argv[])
  8. {
  9.          int i=1;
  10.          long long c=minus(3,1);
  11.          return 0;
  12. }

 

反汇编代码如下:

  1. long long minus(long long a ,long long b)
  2. {
  3. 01351380 push        ebp
  4. 01351381 mov         ebp,esp
  5. 01351383 sub         esp,0CCh
  6. 01351389 push        ebx
  7. 0135138A push        esi
  8. 0135138B push        edi
  9. 0135138C lea         edi,[ebp-0CCh]
  10. 01351392 mov         ecx,33h
  11. 01351397 mov         eax,0CCCCCCCCh
  12. 0135139C rep stos    dword ptres:[edi]
  13.          int j=2;
  14. 0135139E mov         dword ptr [j],2
  15.          return a-b;
  16. <span style=“color:#FF0000;”>013513A5 mov         eax,dword ptr [a]
  17. 013513A8 sub         eax,dword ptr [b]
  18. 013513AB mov         edx,dword ptr[ebp+0Ch]
  19. 013513AE sbb         edx,dword ptr[ebp+14h] </span>
  20. }
  21. 013513B1 pop         edi
  22. 013513B2 pop         esi
  23. 013513B3 pop         ebx
  24. 013513B4 mov         esp,ebp
  25. 013513B6 pop         ebp
  26. 013513B7 ret
  27. int _tmain(int argc, _TCHAR* argv[])
  28. {
  29. 013513C0 push        ebp
  30. 013513C1 mov         ebp,esp
  31. 013513C3 sub         esp,0DCh
  32. 013513C9 push        ebx
  33. 013513CA push        esi
  34. 013513CB push        edi
  35. 013513CC lea         edi,[ebp-0DCh]
  36. 013513D2 mov         ecx,37h
  37. 013513D7 mov         eax,0CCCCCCCCh
  38. 013513DC rep stos    dword ptres:[edi]
  39.          int i=1;
  40. 013513DE mov         dword ptr [i],1
  41.          long long c=minus(3,1);
  42. 013513E5 push        0
  43. 013513E7 push        1
  44. 013513E9 push        0
  45. 013513EB push        3
  46. 013513ED call        minus (13511C2h)
  47. 013513F2 add         esp,10h
  48. <span style=“color:#FF0000;”>013513F5 mov         dword ptr [c],eax
  49. 013513F8 mov        dword ptr [ebp-14h],edx </span>
  50.          return 0;
  51. 013513FB xor         eax,eax
  52. }
  53. 013513FD pop         edi
  54. 013513FE pop         esi
  55. 013513FF pop         ebx
  56. 01351400 add         esp,0DCh
  57. 01351406 cmp         ebp,esp
  58. 01351408 call       @ILT+305(__RTC_CheckEsp) (1351136h)
  59. 0135140D mov         esp,ebp
  60. 0135140F pop         ebp
  61. 01351410 ret

可以发现在进行减法运算和传递返回值时确实发生了变化,说明返回值为64位整型时,会使用EAX和EDX来分别传递返回值的低32位和高32位。

浮点数的情况就不重复贴代码了,直接看反汇编代码:

  1. float c=minus(3,1);
  2. 010E13F5 push        ecx
  3. //压入实参1到浮点寄存器st(0),注意这个操作不会影响ESP的值
  4. 010E13F6 fld1
  5. //将1送入到ESP指向的空间中,也就是ECX中?并且1从st(0)出栈
  6. 010E13F8 fstp        dword ptr [esp]
  7. 010E13FB push        ecx
  8. //另一个实参3
  9. 010E13FC fld         dword ptr[__real@40400000 (10E573Ch)]
  10. 010E1402 fstp        dword ptr [esp]
  11. 010E1405 call        minus (10E117Ch)
  12. 010E140A add         esp,8
  13. //返回值赋给c,然后出栈
  14. 010E140D fstp        dword ptr [c]

 

可以看出浮点类型的返回值是暂存在浮点寄存器st(0)中的。