gcc 编译过程

现代编译器常见的编译过程:

源文件－－>预处理－－>编译/优化－－>汇编－－>链接-->可执行文件

对于gcc而言：

第一步 预处理

命令：　gcc -o test.i -E test.c

　或者 cpp -o test.i test.c (这里cpp不是值c plus plus,而是the C Preprocessor)

结果： 生成预处理后的文件test.i(可以打开后与预处理前进行比对，当然长度会吓你一跳)

作用： 读取c源程序，对伪指令和特殊符号进行处理。包括宏，条件编译，包含的头文件，以及一些特殊符号。基本上是一个replace的过程。

第二步 编译及优化

命令: gcc -o test.s -S test.i

　 或者 /路径/cc1 -o test.s test.i

结果： 生成汇编文件test.s(可打开后查看源文件生成的汇编码)

作用： 通过词法和语法分析，确认所有指令符合语法规则(否则报编译错),之后翻译成对应的中间码，在linux中被称为RTL(Register Transfer Language)，通常是平台无关的，这个过程也被称为编译前端。编译后端对RTL树进行裁减，优化，得到在目标机上可执行的汇编代码。gcc采用as 作为其汇编器，所以汇编码是AT&T格式的，而不是Intel格式，所以在用gcc编译嵌入式汇编时，也要采用AT&T格式。

第三步 汇编

命令： gcc -o test.o -c test.s

或者 as -o test.o test.s

结果: 生成目标机器指令文件test.o(可用objdump查看)

作用: 把汇编语言代码翻译成目标机器指令, 用file test.o 可以看到test.o是一个relocatable的ELF文件，通常包含.text .rodata代码段和数据段。可用readelf -r test.o查看需要relocation的部分。

第四步 链接

命令： gcc -o test test.o

或者 ld -o test test.o

结果: 生成可执行文件test (可用objdump查看)

作用: 将在一个文件中引用的符号同在另外一个文件中该符号的定义链接起来，使得所有的这些目标文件链接成为一个能被操作系统加载到内存的执行体。(如果有不到的符号定义，或者重复定义等，会报链接错)。用file test 可以看到test是一个executable的ELF文件。

当然链接的时候还会用到静态链接库，和动态连接库。静态库和动态库都是.o目标文件的集合。

静态库:

命令：ar -v -q test.a test.o

结果: 生成静态链接库test.a

作用: 静态库是在链接过程中将相关代码提取出来加入可执行文件的库(即在链接的时候将函数的代码将从其所在地静态链接库中被拷贝到最终的可执行程序中)，ar只是将一些别的文件集合到一个文件中。可以打包，当然也可以解包。

动态库:

命令: gcc -shared test.so test.o

或者/PATH/collect2 -shared test.so test.o (省略若干参数)

结果: 生成动态连接库test.so

作用: 动态库在链接时只创建一些符号表，而在运行的时候才将有关库的代码装入内存，映射到运行时相应进程的虚地址空间。如果出错，如找不到对应的.so文件，会在执行的时候报动态连接错(可用LD_LIBRARY_PATH指定路径)。用file test.so可以看到test.so是shared object的ELF文件。

当然以上各步可以一步或若干步一起完成，如gcc -o test test.c直接得到可执行文件。

附:

ELF文件格式

ELF文件格式是ABI(Application Binary Interface)的一部分，被Tool Interface Standards committee作为在32位Intel架构下可移植的目标文件格式。其格式比较复杂，这里就不细讲了，只说说其类型。

在specification 1.1中定义了的类型。表示在ELF header中的e_type

Name Value Meaning

==== ===== =======

ET_NONE 0 No file type

ET_REL 1 Relocatable file

ET_EXEC 2 Executable file

ET_DYN 3 Shared object file

ET_CORE 4 Core file

ET_LOPROC 0xff00 Processor-specific

ET_HIPROC 0xffff Processor-specific

主要的有4种

1. Relocatable file 保留了代码和数据，被用来和其他的object file一起创建可执行的文件或者是shared object file. (也就是我们常见的.o文件)

2. Executable file 保留了用来执行的程序，该文件可以被系统exec()加载用以创建程序进程。(也就是我们常说的可执行文件)

3. Shared object file 保留了代码和数据，以在两种情况下被连接，一是link editor如ld,可以用它与其他的Relocateble或者Shared的object file一起创建另一个object file. 二是与Executable file或者其他的Shared object file动态链接成为一个进程映像。(也就是我们常说的动态链接库，或者.so文件)

4. Core file 的内容在规范中没有指明，目前多用来记录core dump信息。

=============================================================================

本文对gcc 编译器如何工作做一个概要描述. 更为详细的信息请参考编译器手册。

当我们进行编译的时候,要使用一系列的工具,我们称之为工具链.其中包括:预处理器CPP,编译器前端gcc/g++,汇编器as,连接器ld.
一个编译过程包括下面几个阶段：
(1)预处理.预处理器CPP将对源文件中的宏进行展开。
(2)编译.gcc将c文件编译成汇编文件。
(3)汇编。as将汇编文件编译成机器码。
(4)连接。ld将目标文件和外部符号进行连接，得到一个可执行二进制文件。

下面以一个很简单的test.c来探讨这个过程。

#define NUMBER (1+2)
int main()
{
int x=NUMBER;
return 0;
}

(1)预处理：gcc会首先调用CPP进行预处理： CPP test.c >test.i
预处理的输出为文件test.i。 我们用cat test.i查看test.i的内容如下：
int main()
{
int x=(1+2);
return 0;
}

我们可以看到，文件中宏定义NUMBER出现的位置被(1+2)替换掉了，其它的内容保持不变。

(2)gcc将c文件编译成汇编文件。
接下来gcc会执行gcc -S test.i得到的输出文件为test.s .

(3)as将汇编文件编译成机器码。
as test.s -o test.o得到输出文件为test.o. test.o中为目标机器上的二进制文件.
用nm查看文件中的符号： nm test.o输出如下：
00000000 b .bss
00000000 d .data
00000000 t .text
U ___main
U __alloca
00000000 T _main

既然已经是二进制目标文件了，能不能执行呢？试一下./test.o,提示cannot execute binary
file.原来___main前面的U表示这个符号的地址还没有定下来，T表示这个符号属于代码段。ld连接的时候会为这些带U的符号确定地址。

(4)连接。
连接需要指定库的位置。通常程序中会有很多的外部符号，因此需要指定的位置就会很多。不过，我们之需要调用gcc即可，ld会自己去找这些库
的位置。
gcc test.o>test就得到了最终的可执行程序了。