X86汇编语言学习.docx

   _start+0x5d:

        addl   $0xc,%esp

   _start+0x60:

        pushl  %eax

   _start+0x61:

        call   -0xa1          

   _start+0x66:

        pushl  $0

   _start+0x68:

        movl   $1,%eax

   _start+0x6d:

        lcall  $7,$0

   _start+0x74:

        hlt

   > 

   问题：

为什么用EAX寄存器保存函数返回值？

   实际上IA32并没有规定用哪个寄存器来保存返回值。

但如果反汇编Solaris/Linux的二进制文件，就会发现，都用EAX保存函数返回值。

   这不是偶然现象，是操作系统的ABI（ApplicationBinaryInterface）来决定的。

   Solaris/Linux操作系统的ABI就是SytemVABI。

   概念：

SFP（StackFramePointer）栈框架指针 

   正确理解SFP必须了解：

       IA32的栈的概念

       CPU中32位寄存器ESP/EBP的作用

       PUSH/POP指令是如何影响栈的

       CALL/RET/LEAVE等指令是如何影响栈的

   如我们所知：

   1）IA32的栈是用来存放临时数据，而且是LIFO，即后进先出的。

栈的增长方向是从高地址向低地址增长，按字节为单位编址。

   2）EBP是栈基址的指针，永远指向栈底（高地址），ESP是栈指针，永远指向栈顶（低地址）。

   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指令用来从一个函数或过程返回，之前CALL保存的下条指令地址会从栈内弹出到EIP寄存器中，程序转到CALL之前下条指令处执行

   7）ENTER是建立当前函数的栈框架，即相当于以下两条指令：

       pushl  %ebp

       movl   %esp,%ebp

   8）LEAVE是释放当前函数或者过程的栈框架，即相当于以下两条指令：

       movlebpesp

       popl ebp

   如果反汇编一个函数，很多时候会在函数进入和返回处，发现有类似如下形式的汇编语句：

       pushl  %ebp           ;ebp寄存器内容压栈，即保存main函数的上级调用函数的栈基地址

       movl   %esp,%ebp      ;esp值赋给ebp，设置main函数的栈基址

       ...........            ;以上两条指令相当于enter0,0

       ...........

       leave                  ;将ebp值赋给esp，pop先前栈内的上级函数栈的基地址给ebp，恢复原栈基址

       ret                    ;main函数返回，回到上级调用

   这些语句就是用来创建和释放一个函数或者过程的栈框架的。

   原来编译器会自动在函数入口和出口处插入创建和释放栈框架的语句。

   函数被调用时：

   1）EIP/EBP成为新函数栈的边界

   函数被调用时，返回时的EIP首先被压入堆栈；创建栈框架时，上级函数栈的EBP被压入堆栈，与EIP一道行成新函数栈框架的边界

   2）EBP成为栈框架指针SFP，用来指示新函数栈的边界

   栈框架建立后，EBP指向的栈的内容就是上一级函数栈的EBP，可以想象，通过EBP就可以把层层调用函数的栈都回朔遍历一遍，调试器就是利用这个特性实现backtrace功能的

   3）ESP总是作为栈指针指向栈顶，用来分配栈空间

   栈分配空间给函数局部变量时的语句通常就是给ESP减去一个常数值，例如，分配一个整型数据就是ESP-4

   4）函数的参数传递和局部变量访问可以通过SFP即EBP来实现 

   由于栈框架指针永远指向当前函数的栈基地址，参数和局部变量访问通常为如下形式：

       +8+xx（%ebp）        ;函数入口参数的的访问

       -xx（%ebp）          ;函数局部变量访问

   假如函数A调用函数B，函数B调用函数C，则函数栈框架及调用关系如下图所示：

[b:

771101bbb0]下图有点乱，因此删去部分内容，要看原图可参考我的blog[/b:

771101bbb0]

+----------------------------+---->高地址

|EIP（上级函数返回地址） |    

+----------------------------+  

|EBP（上级函数的EBP）    | 

+----------------------------+

|LocalVariables           |   

|..........                         | 

+-----------------------------+  

|Argn（函数B的第n个参数）|  

+-----------------------------+

|Arg.（函数B的第.个参数）  | 

+-----------------------------+ 

|Arg1（函数B的第1个参数）| 

+-----------------------------+  

|Arg0（函数B的第0个参数）| 

+-----------------------------+ 

 EIP（A函数的返回地址）     |

+-----------------------------+ 

|EBP（A函数的EBP）         |

+-----------------------------+  

|LocalVariables            |  

|..........                          |   

+-----------------------------+ 

|Argn（函数C的第n个参数）|  

+-----------------------------+   

|Arg.（函数C的第.个参数）  |  

+-----------------------------+  

|Arg1（函数C的第1个参数）| 

+-----------------------------+  

|Arg0（函数C的第0个参数）|  

+-----------------------------+   

|EIP（B函数的返回地址）    | 

+-----------------------------+ 

|EBP（B函数的EBP）         | 

+-----------------------------+

|LocalVariables            |

|..........                          | 

+-----------------------------+--->低地址

  图1-1 

   再分析test1反汇编结果中剩余部分语句的含义：

   #mdbtest1

   Loadingmodules:

[libc.so.1]

   >main:

:

dis                       ;反汇编main函数

   main:

         pushl  %ebp                            

   main+1:

       movl   %esp,%ebp       ;创建StackFrame（栈框架）

   main+3:

      subl   $8,%esp      ;通过ESP-8来分配8字节堆栈空间

   main+6:

      andl   $0xf0,%esp   ;使栈地址16字节对齐

   main+9:

      movl   $0,%eax      ;无意义

   main+0xe:

    subl   %eax,%esp    ;无意义

   main+0x10:

    movl   $0,%eax         ;设置main函数返回值

   main+0x15:

    leave                   ;撤销StackFrame（栈框架）

   main+0x16:

    ret                     ;main函数返回

   >

   以下两句似乎是没有意义的，果真是这样吗？

       movl   $0,%eax 

       subl    %eax,%esp

   用gcc的O2级优化来重新编译test1.c:

   #gcc-O2test1.c-otest1

   #mdbtest1

   >main:

:

dis

   main:

        pushl  %ebp

   main+1:

      movl   %esp,%ebp

   main+3:

      subl   $8,%esp

   main+6:

      andl   $0xf0,%esp

   main+9:

      xorl   %eax,%eax     ;设置main返回值，使用xorl异或指令来使eax为0

   main+0xb:

    leave

   main+0xc:

    ret

   > 

   新的反汇编结果比最初的结果要简洁一些，果然之前被认为无用的语句被优化掉了，进一步验证了之前的猜测。

   提示：

编译器产生的某些语句可能在程序实际语义上没有用处，可以用优化选项去掉这些语句。

   问题：

为什么用xorl来设置eax的值？

   注意到优化后的代码中，eax返回值的设置由movl$0,%eax变为xorl%eax,%eax，这是因为IA32指令中，xorl比movl有更高的运行速度。

   概念：

Stackaligned栈对齐

   那么，以下语句到底是和作用呢？

       subl   $8,%esp

      andl   $0xf0,%esp    ;通过andl使低4位为0，保证栈地址16字节对齐

   表面来看，这条语句最直接的后果是使ESP的地址后4位为0，即16字节对齐，那么为什么这么做呢？

   原来，IA32系列CPU的一些指令分别在4、8、16字节对齐时会有更快的运行速度，因此gcc编译器为提高生成代码在IA32上的运行速度，默认对产生的代码进行16字节对齐

       andl$0xf0,%esp的意义很明显，那么subl$8,%esp呢，是必须的吗？

   这里假设在进入main函数之前，栈是16字节对齐的话，那么，进入main函数后，EIP和EBP被压入堆栈后，栈地址最末4位二进制位必定是1000，esp-8则恰好使后4位地址二进制位为0000。

看来，这也是为保证栈16字节对齐的。

   如果查一下gcc的手册，就会发现关于栈对齐的参数设置：

   -mpreferred-stack-boundary=n   ;希望栈按照2的n次的字节边界对齐,n的取值范围是2-12

   默认情况下，n是等于4的，也就是说，默认情况下，gcc是16字节对齐，以适应IA32大多数指令的要求。

   让我们利用-mpreferred-stack-boundary=2来去除栈对齐指令：

   #gcc-mpreferred-stack-boundary=2test1.c-otest1

   >main:

:

dis

   main:

      pushl  %ebp

   main+1:

    movl   %esp,%ebp

   main+3:

    movl   $0,%eax

   main+8:

    leave

   main+9:

    ret

   > 

   可以看到，栈对齐指令没有了，因为，IA32的栈本身就是4字节对齐的，不需要用额外指令进行对齐。

   那么，栈框架指针SFP是不是必须的呢？

   #gcc-mpreferred-stack-boundary=2-fomit-frame-pointertest1.c-otest

   >main:

:

dis

   main:

      movl   $0,%eax

   main+5:

    ret

   > 

   由此可知，-fomit-frame-pointer可以去除SFP。

   问题：

去除SFP后有什么缺点呢？

   1）增加调式难度

       由于SFP在调试器backtrace的指令中被使用到，因此没有SFP该调试指令就无法使用。

   2）降低汇编代码可读性

       函数参数和局部变量的访问，在没有ebp的情况下，都只能通过+xx（esp）的方式访问，而很难区分两种方式，降低了程序的可读性。

   问题：

去除SFP有什么优点呢？

   1）节省栈空间

   2）减少建立和撤销栈框架的指令后，简化了代码

   3）使ebp空闲出来，使之作为通用寄存器使用，增加通用寄存器的数量

   4）以上3点使得程序运行速度更快

   概念：

CallingConvention 调用约定和ABI（ApplicationBinaryInterface）应用程序二进制接口

       函数如何找到它的参数？

       函数如何返回结果？

       函数在哪里存放局部变量？

       那一个硬件寄存器是起始空间？

       那一个硬件寄存器必须预先保留？

   CallingConvention 调用约定对以上问题作出了规定。

CallingConvention也是ABI的一部分。

   因此，遵守相同ABI规范的操作系统，使其相互间实现二进制代码的互操作成为