平台：x86/Debian GNU/Linux gcc

1 C源文件代码对应的指令

计算机是由数字电路组成的运算机器，只能对数字做运算。加载到内存中运行的文件被称之为可执行文件，可执行文件中的二进制对应着C源代码的标识符和数据。由一个C源文件到可执行文件可分为两个阶段：编译和链接。对可执行文件进行反汇编可以看到C代码中的每个语句所对应的机器指令bytes(left)及反汇编代码(right)。如以下C语言程序可用gcc编译器来描述其生成可执行文件的过程：

1. /* Filename:    c_to_elf.c 
2.  * Brife:   To see c source file to be elf file by compiling and link 
3.  * Date:    2014.7.20 - Sunday 
4.  * Author:  One fish 
5.  */  
6. #include <stdio.h>  
7.   
8.   
9. //------Global varible-----------  
10. static int i;  
11.   
12.   
13. //------Functions decaration  
14. int add_ij(int i, int j);  
15.   
16.   
17. //---Main the entry of this application  
18. int main(void)  
19. {  
20.     int j, k = 1;  
21.       
22.     i   = k;  
23.     j   = 2;  
24.     add_ij(i, j);  
25.   
26.     return 0;  
27. }  
28.   
29.   
30. int add_ij(int i, int j)  
31. {  
32.     int k;  
33.   
34.     k   = i + j;  
35.     return k;  
36. }

(1) gcc命令选项

Figure1.gcc 命令选项

图中的各个名字是gcc默认生成的（不用-o选项让生成文件以其它名字生成）。以.s为后缀的为C源文件对应的汇编文件；以.o为后缀的为C源文件对应的目标文件；.out为C源文件对应的可执行文件。

(2) 目标文件

选择由C源文件汇编文件得到目标文件：

gcc  -g  -S c_to_elf.c [生成c_to_elf.s，是c_to_elf.c对应的汇编代码]

gcc  -g  -c c_to_elf.s[生成c_to_elf.o，即为目标文件]

-g选项是使生成的文件能够关联上C源代码。

(3) 反汇编--可执行文件

选择由(2)中生成的目标文件得到可执行文件c_to_elf：gcc -g  c_to_elf.o  -o c_to_elf。目标文件也可以进行反汇编。

用objdump命令可对可执行文件进行反汇编：objdump –dS c_to_elf > exe_disassembly.txt。对c_to_elf的反汇编信息都在exe_disassembly.txt文件中，只看C代码对应指令部分[第一列为指令地址，中间的几列为机器指令，最后的是汇编代码]：

1. 080483dc <main>:  
2. int add_ij(int i, int j);  
3.   
4.   
5. //---Main the entry of this application  
6. int main(void)  
7. {  
8.  80483dc:   55                      push   %ebp  
9.  80483dd:   89 e5                   mov    %esp,%ebp  
10.  80483df:   83 e4 f0                and    $0xfffffff0,%esp  
11.  80483e2:   83 ec 20                sub    $0x20,%esp  
12.     int j, k = 1;  
13.  80483e5:   c7 44 24 1c 01 00 00    movl   $0x1,0x1c(%esp)  
14.  80483ec:   00   
15.       
16.     i   = k;  
17.  80483ed:   8b 44 24 1c             mov    0x1c(%esp),%eax  
18.  80483f1:   a3 84 96 04 08          mov    %eax,0x8049684  
19.     j   = 2;  
20.  80483f6:   c7 44 24 18 02 00 00    movl   $0x2,0x18(%esp)  
21.  80483fd:   00   
22.     add_ij(i, j);  
23.  80483fe:   a1 84 96 04 08          mov    0x8049684,%eax  
24.  8048403:   8b 54 24 18             mov    0x18(%esp),%edx  
25.  8048407:   89 54 24 04             mov    %edx,0x4(%esp)  
26.  804840b:   89 04 24                mov    %eax,(%esp)  
27.  804840e:   e8 07 00 00 00          call   804841a <add_ij>  
28.   
29.     return 0;  
30.  8048413:   b8 00 00 00 00          mov    $0x0,%eax  
31. }  
32.  8048418:   c9                      leave    
33.  8048419:   c3                      ret      
34.   
35. 0804841a <add_ij>:  
36.   
37.   
38. int add_ij(int i, int j)  
39. {  
40.  804841a:   55                      push   %ebp  
41.  804841b:   89 e5                   mov    %esp,%ebp  
42.  804841d:   83 ec 10                sub    $0x10,%esp  
43.     int k;  
44.   
45.     k   = i + j;  
46.  8048420:   8b 45 0c                mov    0xc(%ebp),%eax  
47.  8048423:   8b 55 08                mov    0x8(%ebp),%edx  
48.  8048426:   01 d0                   add    %edx,%eax  
49.  8048428:   89 45 fc                mov    %eax,-0x4(%ebp)  
50.     return k;  
51.  804842b:   8b 45 fc                mov    -0x4(%ebp),%eax  
52. }  
53.  804842e:   c9                      leave    
54.  804842f:   c3                      ret   

(4) 由反汇编分析程序运行时堆栈内存的变化

虽然程序中的内存地址都是虚拟地址，但可根据虚拟内存与物理内存的映射关系用虚拟内存地址来模拟堆栈内存上物理地址的变化。

[1]进入main函数main栈帧的开始

Figure2.程序进入main函数运行

esp寄存器指向栈底，ebp寄存器指向栈顶。进入main函数时假设esp指向栈内存的内容为……。然后栈内存会随着接下来的指令而得到分配。

[2]main函数内的局部变量的栈内存

Figure3.main函数局部变量栈内存

用栈内存地址esp + 0x1c 和 esp + 0x18来存储k和j（这个关系会被记住，当程序中用到k或j时，关联的就是这两个地址或者地址中的内容）。

[3] main函数栈帧的形成

Figure4.main函数栈帧的形成

到main函数的return语句处就标志着main函数栈帧形成。调用子函数给子函数传参数是将参数的值压入（复制了参数）本函数栈中（这个地址会被记住，进入子函数后到这个地址来取值）。全局变量i的地址是0x8049684这个地址是在程序链接时被分配的。

[4] 子函数add_ij()栈帧的分配与回收

Figure5.add_ij子函数栈帧分配及回收

进入子函数add_ij后，为add_ij及其内部的变量分配栈内存形成add_ij的函数栈帧。当退出add_ij函数执行完毕后，add_ij函数栈帧被操作系统回收。依据对ebp和esp的操作，此时会返回到调用子函数add_ij的函数中，去继续执行调用函数的下一个语句。

[5]main函数栈帧的回收

Figure6.main函数栈帧的回收

main()是一个具入口性质的函数（首先被调用），当main函数执行完毕后。它的函数栈帧以相同的方式被回收，ebp与esp会返回到到上一层栈帧（如果有）。

对可执行文件进行的反汇编中可以看出，可执行文件中的有的地址（如全局变量i）已经被分配，可程序还没有运行，无法保证这个地址的可用性。其实这个地址是虚拟地址，可执行程序被加载到内存中运行时，操作系统会检查内存中的页表看这个虚拟地址可以映射到物理地址中的哪一个地址，这个地址才是变量真正的地址。MMU的存在可以解决链接时为程序分配的地址是否可用问题。

2 编译----C源文件到目标文件

编译是指将C代码翻译成汇编或机器指令的过程。

(1) C程序对应的汇编代码

C源文件可被gcc编译为汇编文件。即此笔记前提到的c_to_elf.s文件，摘main和add_ij()函数对应的汇编代码如下：

Figure7.main和add_ij()对应的汇编代码

(2) C程序的目标文件 

笔记前提到的c_to_elf.o为c_to_elf.c对应的目标文件，在linux下用readelf –a  c_to_elf.o  > obj.txt命令将目标文件中的内容读到obj.txt文件中，截取一部分出来瞧瞧：

[1] ELF Header

Figure8.目标文件中的ELF Header

从ELF Header中可以看出，计算机内的数字采用的2’s complement方式，小端方式存储。操作系统为UNIX，文件本身类型为REL，文件中段头（section headers）的文件起始地址为1264，一共有21个段头。

[2] Section headers