X86汇编语言学习

1、 . X86汇编语言学习手记X86汇编语言学习手记(1)1. 编译环境    OS: Solaris 9 X86    Compiler: gcc 3.3.2    Linker: Solaris Link Editors 5.x    Debug Tool: mdb    Editor: vi    注：关于编译环境的安装和设置，可以参考文章：Solaris 上的开发环境安装与设置。        mdb是Sola

2、ris提供的kernel debug工具，这里用它做反汇编和汇编语言调试工具。        如果在Linux平台可以用gdb进行反汇编和调试。 2. 最简C代码分析     为简化问题，来分析一下最简的c代码生成的汇编代码：     # vi test1.c            int main()         

3、;    return 0;                  编译该程序，产生二进制文件：     # gcc test1.c -o test1     # file test1       test1: ELF 32-bit LSB executable 80386 Version 1, dynamically linked

4、, not stripped      test1是一个ELF格式32位小端(Little Endian)的可执行文件，动态并且符号表没有去除。     这正是Unix/Linux平台典型的可执行文件格式。     用mdb反汇编可以观察生成的汇编代码：     # mdb test1     Loading modules: libc.so.1     > main:dis  &

5、#160;                    ; 反汇编main函数，mdb的命令一般格式为  <地址>:dis     main:          pushl   %ebp     

6、0; ; ebp寄存器容压栈，即保存main函数的上级调用函数的栈基地址     main+1:        movl    %esp,%ebp  ; esp值赋给ebp，设置main函数的栈基址     main+3:          subl    $8,%esp    

7、 main+6:          andl    $0xf0,%esp     main+9:          movl    $0,%eax     main+0xe:        subl  

8、0; %eax,%esp     main+0x10:     movl    $0,%eax    ; 设置函数返回值0     main+0x15:     leave              ; 将ebp值赋给esp，pop先前栈的上级函数栈的基地址给ebp，恢

9、复原栈基址     main+0x16:     ret                ; main函数返回，回到上级调用     >      注：这里得到的汇编语言语法格式与Intel的手册有很大不同，Unix/Linux采用AT&T汇编格式作为汇编语言的语法格式   &

10、#160;      如果想了解AT&T汇编可以参考文章：Linux AT&T 汇编语言开发指南      问题：谁调用了 main函数？            在C语言的层面来看，main函数是一个程序的起始入口点，而实际上，ELF可执行文件的入口点并不是main而是_start。      mdb也可以反汇编_start：    

11、;         > _start:dis                       ;从_start 的地址开始反汇编     _start:          

12、60;   pushl   $0     _start+2:            pushl   $0     _start+4:            movl    %esp,%ebp    

13、_start+6:            pushl   %edx     _start+7:            movl    $0x80504b0,%eax     _start+0xc:      &

14、#160;   testl   %eax,%eax     _start+0xe:          je      +0xf            <_start+0x1d>     _start+0x10:  &#

15、160;      pushl   $0x80504b0     _start+0x15:         call    -0x75           <atexit>     _start+0x1a:   

16、60;     addl    $4,%esp     _start+0x1d:         movl    $0x8060710,%eax     _start+0x22:         testl   %eax,%eax   &#

17、160; _start+0x24:         je      +7              <_start+0x2b>     _start+0x26:         call  

18、0; -0x86           <atexit>     _start+0x2b:         pushl   $0x80506cd     _start+0x30:         call    -0x9

19、0           <atexit>     _start+0x35:         movl    +8(%ebp),%eax     _start+0x38:         leal    +0x

20、10(%ebp,%eax,4),%edx     _start+0x3c:         movl    %edx,0x8060804     _start+0x42:         andl    $0xf0,%esp     _start+0x45:  

21、0;      subl    $4,%esp     _start+0x48:         pushl   %edx     _start+0x49:         leal    +0xc(%ebp),%edx   &#

22、160; _start+0x4c:         pushl   %edx     _start+0x4d:         pushl   %eax     _start+0x4e:         call    +0x15

23、2          <_init>     _start+0x53:         call    -0xa3           <_fpstart>     _start+0x58:  &

24、#160;     call    +0xfb        <main>              ;在这里调用了main函数     _start+0x5d:         addl 

25、0;  $0xc,%esp     _start+0x60:         pushl   %eax     _start+0x61:         call    -0xa1           <exit&

26、gt;     _start+0x66:         pushl   $0     _start+0x68:         movl    $1,%eax     _start+0x6d:         lcal

27、l   $7,$0     _start+0x74:         hlt     >      问题：为什么用EAX寄存器保存函数返回值？     实际上IA32并没有规定用哪个寄存器来保存返回值。但如果反汇编Solaris/Linux的二进制文件，就会发现，都用EAX保存函数返回值。     这不是偶然现象，是操作系统的ABI

28、(Application Binary Interface)来决定的。     Solaris/Linux操作系统的ABI就是Sytem V ABI。     概念：SFP (Stack Frame Pointer) 栈框架指针      正确理解SFP必须了解：         IA32 的栈的概念         CPU 中32位寄存器ESP/EBP的作

29、用         PUSH/POP 指令是如何影响栈的         CALL/RET/LEAVE 等指令是如何影响栈的     如我们所知：     1)IA32的栈是用来存放临时数据，而且是LIFO，即后进先出的。栈的增长方向是从高地址向低地址增长，按字节为单位编址。     2) EBP是栈基址的指针，永远指向栈底（高地址），ESP是栈指针，永远指向栈顶（低

30、地址）。     3) PUSH一个long型数据时，以字节为单位将数据压入栈，从高到低按字节依次将数据存入ESP-1、ESP-2、ESP-3、ESP-4的地址单元。     4) POP一个long型数据，过程与PUSH相反，依次将ESP-4、ESP-3、ESP-2、ESP-1从栈弹出，放入一个32位寄存器。     5) CALL指令用来调用一个函数或过程，此时，下一条指令地址会被压入堆栈，以备返回时能恢复执行下条指令。     6) RET指令用来从一个函数或过程返回，

31、之前CALL保存的下条指令地址会从栈弹出到EIP寄存器中，程序转到CALL之前下条指令处执行     7) ENTER是建立当前函数的栈框架，即相当于以下两条指令：         pushl   %ebp         movl    %esp,%ebp     8) LEAVE是释放当前函数或者过程的栈框架，即相当于以下两条指令：  

32、;       movl ebp esp         popl  ebp     如果反汇编一个函数，很多时候会在函数进入和返回处，发现有类似如下形式的汇编语句：                   pushl   %ebp  

33、;          ; ebp寄存器容压栈，即保存main函数的上级调用函数的栈基地址         movl    %esp,%ebp       ; esp值赋给ebp，设置 main函数的栈基址         .    

34、0;        ; 以上两条指令相当于 enter 0,0         .         leave                   ; 将ebp值赋给esp，pop先前栈的上级函数栈的基地址给e

35、bp，恢复原栈基址         ret                     ; main函数返回，回到上级调用     这些语句就是用来创建和释放一个函数或者过程的栈框架的。     原来编译器会自动在函数入口和出口处插入创建和释放栈框架的语句。  &

36、#160;  函数被调用时：     1) EIP/EBP成为新函数栈的边界     函数被调用时，返回时的EIP首先被压入堆栈；创建栈框架时，上级函数栈的EBP被压入堆栈，与EIP一道行成新函数栈框架的边界     2) EBP成为栈框架指针SFP，用来指示新函数栈的边界     栈框架建立后，EBP指向的栈的容就是上一级函数栈的EBP，可以想象，通过EBP就可以把层层调用函数的栈都回朔遍历一遍，调试器就是利用这个特性实现 backtrace功能的  &

37、#160;  3) ESP总是作为栈指针指向栈顶，用来分配栈空间     栈分配空间给函数局部变量时的语句通常就是给ESP减去一个常数值，例如，分配一个整型数据就是 ESP-4     4) 函数的参数传递和局部变量访问可以通过SFP即EBP来实现      由于栈框架指针永远指向当前函数的栈基地址，参数和局部变量访问通常为如下形式：         +8+xx(%ebp)   

38、0;     ; 函数入口参数的的访问         -xx(%ebp)           ; 函数局部变量访问                  假如函数A调用函数B，函数B调用函数C ，则函数栈框架与调用关系如下图所示： b:771

39、101bbb0下图有点乱，因此删去部分容，要看原图可参考我的blog/b:771101bbb0 +-+-> 高地址 | EIP (上级函数返回地址)  |     +-+   | EBP (上级函数的EBP)     |  +-+ | Local Variables            |    | .  &#

40、160;                       |  +-+   | Arg n(函数B的第n个参数) |   +-+ | Arg .(函数B的第.个参数)   |  +-+  | Arg 1(函数B的第1个参数) |  +-+   | Arg 0(函数

41、B的第0个参数) |  +-+   EIP (A函数的返回地址)      | +-+  | EBP (A函数的EBP)          | +-+   | Local Variables             |   | .  

42、60;                        |    +-+  | Arg n(函数C的第n个参数) |   +-+    | Arg .(函数C的第.个参数)   |   +-+   | Arg 1(函数C的

43、第1个参数) |  +-+   | Arg 0(函数C的第0个参数) |   +-+    | EIP (B函数的返回地址)     |  +-+  | EBP (B函数的EBP)          |  +-+ | Local Variables         &#

44、160;   | | .                           |  +-+-> 低地址    图 1-1              再分析test1反汇编结果

45、中剩余部分语句的含义：              # mdb test1     Loading modules: libc.so.1     > main:dis                     

46、0;  ; 反汇编main函数     main:          pushl   %ebp                              

47、60;  main+1:        movl    %esp,%ebp        ; 创建Stack Frame(栈框架)     main+3:       subl    $8,%esp       ; 通过ESP-8来分配8字

48、节堆栈空间     main+6:       andl    $0xf0,%esp    ; 使栈地址16字节对齐     main+9:       movl    $0,%eax       ; 无意义     main+0xe:&#

49、160;    subl    %eax,%esp     ; 无意义     main+0x10:     movl    $0,%eax          ; 设置main函数返回值     main+0x15:     leave&#

50、160;                   ; 撤销Stack Frame(栈框架)     main+0x16:     ret                  &

51、#160;   ; main 函数返回     >     以下两句似乎是没有意义的，果真是这样吗？         movl    $0,%eax          subl     %eax,%esp         &

52、#160;   用gcc的O2级优化来重新编译test1.c:     # gcc -O2 test1.c -o test1     # mdb test1     > main:dis     main:         pushl   %ebp     main+1:    &#

53、160;  movl    %esp,%ebp     main+3:       subl    $8,%esp     main+6:       andl    $0xf0,%esp     main+9:       xo

54、rl    %eax,%eax      ; 设置main返回值，使用xorl异或指令来使eax为0     main+0xb:     leave     main+0xc:     ret     >      新的反汇编结果比最初的结果要简洁一些，果然之前被认为无用的语句被优化掉了，进一步验证了之

55、前的猜测。     提示：编译器产生的某些语句可能在程序实际语义上没有用处，可以用优化选项去掉这些语句。     问题：为什么用xorl来设置eax的值？     注意到优化后的代码中，eax返回值的设置由 movl $0,%eax 变为 xorl %eax,%eax ，这是因为IA32指令中，xorl比movl有更高的运行速度。     概念：Stack aligned 栈对齐     那么，以下语句到底是和作用呢？   &

56、#160;     subl    $8,%esp        andl    $0xf0,%esp     ; 通过andl使低4位为0，保证栈地址16字节对齐             表面来看，这条语句最直接的后果是使ESP的地址后4位为0，即16字节对齐，那么为什么这么做呢？  &

57、#160;  原来，IA32 系列CPU的一些指令分别在4、8、16字节对齐时会有更快的运行速度，因此gcc编译器为提高生成代码在IA32上的运行速度，默认对产生的代码进行16字节对齐         andl $0xf0,%esp 的意义很明显，那么 subl $8,%esp 呢，是必须的吗？     这里假设在进入main函数之前，栈是16字节对齐的话，那么，进入main函数后，EIP和EBP被压入堆栈后，栈地址最末4位二进制位必定是 1000，esp -8则恰好使后4位地址二进制

58、位为0000。看来，这也是为保证栈16字节对齐的。     如果查一下gcc的手册，就会发现关于栈对齐的参数设置：     -mpreferred-stack-boundary=n    ; 希望栈按照2的n次的字节边界对齐, n的取值围是2-12     默认情况下，n是等于4的，也就是说，默认情况下，gcc是16字节对齐，以适应IA32大多数指令的要求。     让我们利用-mpreferred-stack-boundary=2来去除栈对齐指

59、令：            # gcc -mpreferred-stack-boundary=2 test1.c -o test1             > main:dis     main:       pushl   %ebp     main+1:

60、60;    movl    %esp,%ebp     main+3:     movl    $0,%eax     main+8:     leave     main+9:     ret     >      可以

61、看到，栈对齐指令没有了，因为，IA32的栈本身就是4字节对齐的，不需要用额外指令进行对齐。     那么，栈框架指针SFP是不是必须的呢？     # gcc -mpreferred-stack-boundary=2 -fomit-frame-pointer test1.c -o test     > main:dis     main:       movl    $0,%eax

62、     main+5:     ret     >      由此可知，-fomit-frame-pointer 可以去除SFP。             问题：去除SFP后有什么缺点呢？             1)增加调式难度  

63、0;      由于SFP在调试器backtrace的指令中被使用到，因此没有SFP该调试指令就无法使用。     2)降低汇编代码可读性         函数参数和局部变量的访问，在没有ebp的情况下，都只能通过+xx(esp)的方式访问，而很难区分两种方式，降低了程序的可读性。             问题：去除SFP有什么优点呢？  

64、;           1)节省栈空间     2)减少建立和撤销栈框架的指令后，简化了代码     3)使ebp空闲出来，使之作为通用寄存器使用，增加通用寄存器的数量     4)以上3点使得程序运行速度更快     概念：Calling Convention  调用约定和 ABI (Application Binary Interface) 应用程序二进制接口  

65、                 函数如何找到它的参数？         函数如何返回结果？         函数在哪里存放局部变量？         那一个硬件寄存器是起始空间？      

66、;   那一个硬件寄存器必须预先保留？     Calling Convention  调用约定对以上问题作出了规定。Calling Convention也是ABI的一部分。     因此，遵守一样ABI规的操作系统，使其相互间实现二进制代码的互操作成为了可能。     例如：由于Solaris、Linux都遵守System V的ABI，Solaris 10就提供了直接运行Linux二进制程序的功能。     详见文章：关注： Solaris 1

67、0的10大新变化                3. 小结     本文通过最简的C程序，引入以下概念：         SFP 栈框架指针         Stack aligned 栈对齐         Calli

68、ng Convention  调用约定 和 ABI (Application Binary Interface) 应用程序二进制接口     今后，将通过进一步的实验，来深入了解这些概念。通过掌握这些概念，使在汇编级调试程序产生的core dump、掌握C语言高级调试技巧成为了可能。X86汇编语言学习手记(2)这是作者在学习X86汇编过程中的学习笔记，难免有错误和疏漏之处，欢迎指正。作者将随时修改错误并将新的版本发布在自己的Blog站点上。严格说来，本篇文档更侧重于C语言和C编译器方面的知识，如果涉与到基本的汇编语言的容，可以参考相关文档。 自X86 汇

69、编语言学习手记(1)在作者的Blog上发布以来，得到了很多网友的肯定和鼓励，并且还有热心网友指出了其中的错误，b:bea66ddae0作者已经将文档中已发现的错误修正后更新在Blog上。/b:bea66ddae0     上一篇文章通过分析一个最简的C程序，引出了以下概念：         Stack Frame 栈框架 和 SFP 栈框架指针         Stack aligned 栈对齐   

70、60;     Calling Convention  调用约定 和 ABI (Application Binary Interface) 应用程序二进制接口     本章中，将通过进一步的实验，来深入了解这些概念。如果还不了解这些概念，可以参考 X86汇编语言学习手记(1)。          1. 局部变量的栈分配     上篇文章已经分析过一个最简的C程序，     下面

71、我们分析一下C编译器如何处理局部变量的分配，为此先给出如下程序：     #vi test2.c      int main()             int i;         int j=2;         i=3;      &

72、#160;  i=+i;         return i+j;         编译该程序，产生二进制文件，并利用mdb来观察程序运行中的stack的状态：     #gcc test2.c -o test2     #mdb test2     Loading modules: libc.so.1     > main:dis

73、    main:           pushl   %ebp     main+1:         movl    %esp,%ebp          ; main至main+1，创建Stack Frame &#

74、160;   main+3:         subl    $8,%esp            ; 为局部变量i,j分配栈空间，并保证栈16字节对齐     main+6:         andl    $0xf0

75、,%esp     main+9:         movl    $0,%eax     main+0xe:       subl    %eax,%esp          ; main+6至main+0xe，再次保证栈16字节对齐 

76、    main+0x10:      movl    $2,-8(%ebp)        ; 初始化局部变量j的值为2     main+0x17:      movl    $3,-4(%ebp)        ; 给局部变量i赋值为

77、3     main+0x1e:      leal    -4(%ebp),%eax      ; 将局部变量i的地址装入到EAX寄存器中     main+0x21:      incl    (%eax)          

78、   ; i+     main+0x23:      movl    -8(%ebp),%eax      ; 将j的值装入EAX     main+0x26:      addl    -4(%ebp),%eax      ; i+j并将结果存入EAX，作

79、为返回值     main+0x29:      leave                    ; 撤销Stack Frame      main+0x2a:      ret     

80、                 ; main函数返回     >      > main+0x10:b         ; 在地址 main+0x10处设置断点     > main+0x1e:b   

81、0;     ; 在main+0x1e设置断点     > main+0x29:b         ; 在main+0x1e设置断点     > main+0x2a:b         ; 在main+0x1e设置断点           

82、;   下面的mdb的4个命令在一行输入，中间用分号间隔开，命令的含义在注释中给出：     > :r;<esp,10/nap;<ebp=X;<eax=X    ; 运行程序(:r 命令)     mdb: stop at main+0x10               ; 以ESP寄存器为起始地址，指定格式输出16字节的栈

83、容(<esp,10/nap 命令)     mdb: target stopped at:                ; 在最后输出EBP和EAX寄存器的值(<ebp=X 命令 和<eax=X 命令)     main+0x10:      movl    $2,-8(%ebp)

84、0;   ; 程序运行后在main +0x10处指令执行前中断，此时栈分配后还未初始化     0x8047db0:           0x8047db0:      0xddbebca0             ; 这是变量j，4字节，未初始化，此处为栈顶，ESP的值就是0x8047d

85、b0        0x8047db4:      0xddbe137f             ; 这是变量i， 4字节，未初始化     0x8047db8:      0x8047dd8        &

86、#160;     ; 这是_start的SFP(_start的EBP),4字节，由main 的SFP指向它     0x8047dbc:      _start+0x5d            ; 这是_start调用main之前压栈的下条指令地址，main返回后将恢复给EIP     0x8047dc0:  

87、60;   1                    0x8047dc4:      0x8047de4            0x8047dc8:      0x8047dec  

88、;          0x8047dcc:      _start+0x35          0x8047dd0:      _fini                0x8047dd4: 

89、;     ld.so.1atexit_fini     0x8047dd8:      0                      ; _start的SFP指向的容为0，证明_start是程序的入口     0x8047ddc:

90、0;     0                    0x8047de0:      1                    0x8047de4:

91、      0x8047eb4            0x8047de8:      0                    0x8047dec:      0x804

92、7eba                            8047db8              ; 这是main当前EBP寄存器的值，即main的SFP     

93、;                0                  ; EAX的值，当前为0     > :c;<esp,10/nap;<ebp=X;<eax=X    ; 继续运行程序(:c

94、 命令)，其余3命令同上，打印16字节栈和EBP,EAX容     mdb: stop at main+0x1e     mdb: target stopped at:     main+0x1e:      leal    -4(%ebp),%eax  ; 程序运行到断点main+0x1e处停止，此时局部变量i,j赋值已完成     0x8047db0:  

95、0;        0x8047db0:      2                      ; 这是变量j，4字节，值为2，此处为栈顶，ESP的值就是0x8047db0     0x8047db4:    

96、;  3                      ; 这是变量i，4字节，值为3      0x8047db8:      0x8047dd8            &

97、#160; ; 这是_start的SFP，4字节     0x8047dbc:      _start+0x5d            ; 这是返回_start后的EIP     0x8047dc0:      1         

98、0;          0x8047dc4:      0x8047de4            0x8047dc8:      0x8047dec            0x8047dcc:  &#

99、160;   _start+0x35          0x8047dd0:      _fini                0x8047dd4:      ld.so.1atexit_fini     0x8047dd8:&

100、#160;     0                    0x8047ddc:      0                    0x8047d

101、e0:      1                    0x8047de4:      0x8047eb4            0x8047de8:      0&

102、#160;                   0x8047dec:      0x8047eba                        &#

103、160;   8047db8              ; 这是main当前EBP寄存器的值，即main的SFP                     0        

104、0;         ; EAX的值，当前为0     > :c;<esp,10/nap;<ebp=X;<eax=X    ; 继续运行程序，打印16字节栈和EBP,EAX容     mdb: stop at main+0x29     mdb: target stopped at:     main+0x29:  

105、0;   leave                  ; 运行到断点main+0x29处停止，计算已经完成，即将撤销Stack Frame     0x8047db0:           0x8047db0:      2 &

106、#160;                    ; 这是变量j，4字节，值为2，此处为栈顶，ESP的值就是0x8047db0            0x8047db4:      4      &#

107、160;               ; 这是i+以后的变量i，4字节，值为3     0x8047db8:      0x8047dd8              ; 这是_start的SFP，4字节     0x80

108、47dbc:      _start+0x5d            ; 这是返回_start后的EIP     0x8047dc0:      1                  

109、60; 0x8047dc4:      0x8047de4            0x8047dc8:      0x8047dec            0x8047dcc:      _start+0x35   &#

110、160;      0x8047dd0:      _fini                0x8047dd4:      ld.so.1atexit_fini     0x8047dd8:      0   

111、;                 0x8047ddc:      0                    0x8047de0:      1  &

112、#160;                 0x8047de4:      0x8047eb4            0x8047de8:      0        &

113、#160;           0x8047dec:      0x8047eba                            8047db8    

114、          ; 这是main当前EBP寄存器的值，即main的SFP                             6        

115、0;         ; EAX的值，即函数的返回值，当前为6                    > :c;<esp,10/nap;<ebp=X;<eax=X    ; 继续运行程序，打印16字节栈和EBP,EAX容     mdb: stop at

116、main+0x2a     mdb: target stopped at:     main+0x2a:      ret                  ; 运行到断点main+0x2a处停止，Stack Frame已被撤销，main即将返回     0x8047dbc: &

117、#160;         0x8047dbc:      _start+0x5d            ; Stack Frame已经被撤销，栈顶是返回_start后的EIP，main的栈已被释放     0x8047dc0:      1    

118、                0x8047dc4:      0x8047de4            0x8047dc8:      0x8047dec         

119、60;  0x8047dcc:      _start+0x35          0x8047dd0:      _fini                0x8047dd4:      ld.so.1atexit_f

120、ini     0x8047dd8:      0                    0x8047ddc:      0              

121、;      0x8047de0:      1                    0x8047de4:      0x8047eb4            0x8047de8

122、:      0                    0x8047dec:      0x8047eba            0x8047df0:      0x80

123、47ed6            0x8047df4:      0x8047edd            0x8047df8:      0x8047ee4            

124、0;               8047dd8            ; _start的SFP,之前存储在地址0x8047db8处，main的Stack Frame撤销时恢复              

125、60;             6                 ; EAX的值，即函数的返回值，当前为6                  

126、60; > :s;<esp,10/nap;<ebp=X;<eax=X   ; 单步执行下条指令(:s 命令)，打印16字节栈和EBP,EAX容     mdb: target stopped at:     _start+0x5d:    addl    $0xc,%esp     ; 此时main已经返回，_start+0x5d曾经存储在地址0x8047dbc处   &#

127、160; 0x8047dc0:           0x8047dc0:      1                      ; main已经返回，_start +0x5d已经被弹出     0x8047dc4:&#

128、160;     0x8047de4            0x8047dc8:      0x8047dec            0x8047dcc:      _start+0x35       

129、;   0x8047dd0:      _fini                0x8047dd4:      ld.so.1atexit_fini     0x8047dd8:      0     

130、60;                ; _start的SFP指向的容为0，证明_start是程序的入口                    0x8047ddc:      0   

131、60;                0x8047de0:      1                    0x8047de4:      0x8047eb4 

132、60;          0x8047de8:      0                    0x8047dec:      0x8047eba        &#

133、160;   0x8047df0:      0x8047ed6            0x8047df4:      0x8047edd            0x8047df8:      0x8047ee4 

134、60;          0x8047dfc:      0x8047ef3                            8047dd8     &#

135、160;      ; _start的SFP,之前存储在地址0x8047db8处，main的Stack Frame撤销时恢复                       6                 ; EAX的值为6，还是main函数的返回值                     >      通过m