转Linux平台可以用gdb进行反汇编和调试。

Linux平台可以用gdb进行反汇编和调试。

如果在Linux平台可以用gdb进行反汇编和调试。(转)

2. 最简C代码分析

    为简化问题，来分析一下最简的c代码生成的汇编代码：
    # vi test1.c
     
    int main()
    {
        return 0;
    }  
   
    编译该程序，产生二进制文件：
    # gcc test1.c -o test1
    # file test1  
    test1: ELF 32-bit LSB executable 80386 Version 1, dynamically linked, not stripped

    test1是一个ELF格式32位小端(Little Endian)的可执行文件，动态链接并且符号表没有去除。
    这正是Unix/Linux平台典型的可执行文件格式。
    用mdb反汇编可以观察生成的汇编代码：

    # mdb test1
    Loading modules: [ libc.so.1 ]
    > main::dis                       ; 反汇编main函数，mdb的命令一般格式为  <地址>::dis
    main:          pushl   %ebp       ; ebp寄存器内容压栈，即保存main函数的上级调用函数的栈基地址
    main+1:        movl    %esp,%ebp  ; esp值赋给ebp，设置main函数的栈基址
    main+3:          subl    $8,%esp
    main+6:          andl    $0xf0,%esp
    main+9:          movl    $0,%eax
    main+0xe:        subl    %eax,%esp
    main+0x10:     movl    $0,%eax    ; 设置函数返回值0
    main+0x15:     leave              ; 将ebp值赋给esp，pop先前栈内的上级函数栈的基地址给ebp，恢复原栈基址
    main+0x16:     ret                ; main函数返回，回到上级调用
    >

    注：这里得到的汇编语言语法格式与Intel的手册有很大不同，Unix/Linux采用AT&T汇编格式作为汇编语言的语法格式
         如果想了解AT&T汇编可以参考文章： Linux AT&T 汇编语言开发指南

    问题：谁调用了 main函数？
    
     在C语言的层面来看，main函数是一个程序的起始入口点，而实际上，ELF可执行文件的入口点并不是main而是_start。
     mdb也可以反汇编_start：
      
    > _start::dis                       ;从_start 的地址开始反汇编
    _start:              pushl   $0
    _start+2:            pushl   $0
    _start+4:            movl    %esp,%ebp
    _start+6:            pushl   %edx
    _start+7:            movl    $0x80504b0,%eax
    _start+0xc:          testl   %eax,%eax
    _start+0xe:          je      +0xf            <_start+0x1d>
    _start+0x10:         pushl   $0x80504b0
    _start+0x15:         call    -0x75          
    _start+0x1a:         addl    $4,%esp
    _start+0x1d:         movl    $0x8060710,%eax
    _start+0x22:         testl   %eax,%eax
    _start+0x24:         je      +7              <_start+0x2b>
    _start+0x26:         call    -0x86          
    _start+0x2b:         pushl   $0x80506cd
    _start+0x30:         call    -0x90          
    _start+0x35:         movl    +8(%ebp),%eax
    _start+0x38:         leal    +0x10(%ebp,%eax,4),%edx
    _start+0x3c:         movl    %edx,0x8060804
    _start+0x42:         andl    $0xf0,%esp
    _start+0x45:         subl    $4,%esp
    _start+0x48:         pushl   %edx
    _start+0x49:         leal    +0xc(%ebp),%edx
    _start+0x4c:         pushl   %edx
    _start+0x4d:         pushl   %eax
    _start+0x4e:         call    +0x152          <_init>
    _start+0x53:         call    -0xa3           <__fpstart>
    _start+0x58:        call    +0xfb       

              ;在这里调用了main函数
    _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(Application Binary Interface)来决定的。
    Solaris/Linux操作系统的ABI就是Sytem V ABI。


    概念：SFP (Stack Frame Pointer) 栈框架指针 

    正确理解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是释放当前函数或者过程的栈框架，即相当于以下两条指令：
        movl ebp esp
        popl  ebp

    如果反汇编一个函数，很多时候会在函数进入和返回处，发现有类似如下形式的汇编语句：
       
        pushl   %ebp            ; ebp寄存器内容压栈，即保存main函数的上级调用函数的栈基地址
        movl    %esp,%ebp       ; esp值赋给ebp，设置 main函数的栈基址
        ...........             ; 以上两条指令相当于 enter 0,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 ，则函数栈框架及调用关系如下图所示：

   	+-------------------------+----> 高地址
   	| EIP (上级函数返回地址)    | 
   	+-------------------------+ 
 +-->   | EBP (上级函数的EBP)      | --+ <------当前函数A的EBP (即SFP框架指针) 
 | 	+-------------------------+   +-->偏移量A 
 | 	| Local Variables         |   |
 | 	| ..........              | --+  <------ESP指向函数A新分配的局部变量,局部变量可以通过A的ebp-偏移量A访问 
 | f 	+-------------------------+
 | r 	| Arg n(函数B的第n个参数)   | 
 | a 	+-------------------------+
 | m 	| Arg .(函数B的第.个参数)   |
 | e 	+-------------------------+
 | 	| Arg 1(函数B的第1个参数)   |
 | o 	+-------------------------+
 | f 	| Arg 0(函数B的第0个参数)   | --+ <------ B函数的参数可以由B的ebp+偏移量B访问
 | 	+-------------------------+   +--> 偏移量B
 | A 	| EIP (A函数的返回地址)     |   | 
 | 	+-------------------------+ --+ 
 +--- 	| EBP (A函数的EBP)         |<--+ <------ 当前函数B的EBP (即SFP框架指针) 
   	+-------------------------+   |
   	| Local Variables         |   |
   	| ..........              |   | <------ ESP指向函数B新分配的局部变量
   	+-------------------------+   |
   	| Arg n(函数C的第n个参数)   |   |
   	+-------------------------+   |
   	| Arg .(函数C的第.个参数)   |   |
   	+-------------------------+   +--> frame of B
   	| Arg 1(函数C的第1个参数)   |   |
   	+-------------------------+   |
   	| Arg 0(函数C的第0个参数)   |   |
   	+-------------------------+   |
   	| EIP (B函数的返回地址)     |   |
   	+-------------------------+   |
 +-->   | EBP (B函数的EBP)         | --+ <------ 当前函数C的EBP (即SFP框架指针) 
 |      +-------------------------+
 | 	| Local Variables         |
 | 	| ..........              | <------ ESP指向函数C新分配的局部变量
 | 	+-------------------------+----> 低地址
frame of C
	
		图 1-1 

      
    再分析test1反汇编结果中剩余部分语句的含义：
       
    # mdb test1
    Loading modules: [ libc.so.1 ]
    > main::dis                        ; 反汇编main函数
    main:          pushl   %ebp                           
    main+1:        movl    %esp,%ebp        ; 创建Stack Frame(栈框架)
    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                    ; 撤销Stack Frame(栈框架)
    main+0x16:     ret                      ; main 函数返回
    >

    以下两句似乎是没有意义的，果真是这样吗？
        movl    $0,%eax
        subl     %eax,%esp
      
    用gcc的O2级优化来重新编译test1.c:
    # gcc -O2 test1.c -o test1
    # mdb test1
    > 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
    >
    新的反汇编结果比最初的结果要简洁一些，果然之前被认为无用的语句被优化掉了，进一步验证了之前的猜测。