盘古开天辟地！我们写了个C语言源文件，那从源文件到可执行程序这中间又发生了什么？编译，链接这些概念又是什么意思？带着对这些问题的好奇，我查了一些资料。其中，主要参考的是《程序员的自我修养》这本书和一些网上的博客。
在windows下经常只需要单击Run或者Debug就可以运行一个C语言程序，这种便利隐藏了背后的复杂机制，而我想知道这背后到底发生了什么。
本文所使用的系统是ubuntu，但这些概念也适用于windows下。
1. 编译源文件的四个阶段
假如我们写了一个很简单的helloworld.c程序：
#include <stdio.h>
int main(int argc, char *argv[])
{
printf("Hello,World!\n");
return 0;
}
我们都知道运行命令
gcc helloworld.c -o helloworld
便可以对这个文件进行编译，并命名可执行文件为helloworld。然后运行
./helloworld
Hello,World!
便可以执行该文件，但是这背后又经历了什么呢？
注意：
本文并不是一篇严谨的探讨编译过程的文章，只是我对这个问题了解过程的一个梳理。
1.1 预处理(preprocessing)
在预处理阶段，我们可以简单理解就是处理以"#"开始的那些预处理指令，比如说：
#define,#include,#if,#elif,#else,#endif
预处理器会按照这些指令的意义进行处理，将#define定义的宏进行替换展开，将#include包含的文件整体替换进来。
可以运行命令
gcc -E helloworld.c -o helloworld.i
来得到经过预处理后的文件，检查可以发现预处理确实帮我们把#include的文件包含进来了，另外在文件中还包含了一些行号信息，以便之后程序出错提示错误所在的位置。
1.2 编译(compile)
这一步是将上一步得到的*.i进行编译，得到汇编代码，可以运行命令
gcc -S helloworld.i -o helloworld.s
来得到经过汇编后的文件，该文件的其中一部分如下：
main:
...
leaq .LC0(%rip), %rcx
call puts
...
正好对应我们在主程序中调用的函数printf，于是我们知道在这一步是生成了汇编文件。
1.3 汇编(assembly)
这一步是将上一步的汇编代码汇编为具体的机器代码，可以运行命令
gcc -c helloworld.s -o helloworld.o
生成的helloworld.o可以称为目标文件，下面我们对目标文件来检查，帮助理解链接过程。
1.3.1 目标文件的结构
上一步中生成的是目标文件，但这个目标文件还没有经过链接，也就是它其中的一些符号还无法确定，比如说在上面的printf我们就无法确定在哪里去寻找这个函数的具体定义，通过头文件stdio.h我们只是知道了它的定义形式，知道如何去调用它，但是具体执行的时候是需要代码的，那么去哪里找呢？寻找printf并将它的地址写入到我们的程序中就是链接的作用。
我们在系统中经常打交道的文件有
- 可执行文件(Executable File)，比如
Windows下的.exe，或者linux下/bin/bash文件 - 共享目标文件(Shared Object File)，比如
Windows下的.dll，或者linux下.so文件 - 可重定位文件(Relocatable File)，我们上面生成的文件便是这种文件，可重定位指的是程序中的一些位置的符号(函数名，变量名)的地址还未确定，在之后的链接阶段需要重新定位
在Linux下可以使用命令file来查看文件的具体格式，让我们运行
$ file helloworld.o
helloworld.o: ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped
那么具体来说，目标文件到底包含什么呢？首先一定会包含代码，其次是数据(定义的变量)，除此以外，我们还关心的是文件中包含的符号表，它是我们后续执行链接最重要的内容了。
运行命令
$ readelf -S helloworld.o
可以查看我们目标文件的段表，关于段表的详细介绍请查看《程序员的自我修养》这本书。
There are 13 section headers, starting at offset 0x2d8:
节头：
[号] 名称 类型 地址 偏移量
大小 全体大小 旗标 链接 信息 对齐
[ 0] NULL 0000000000000000 00000000
0000000000000000 0000000000000000 0 0 0
[ 1] .text PROGBITS 0000000000000000 00000040
0000000000000022 0000000000000000 AX 0 0 1
[ 2] .rela.text RELA 0000000000000000 00000228
0000000000000030 0000000000000018 I 10 1 8
[ 3] .data PROGBITS 0000000000000000 00000062
0000000000000000 0000000000000000 WA 0 0 1
[ 4] .bss NOBITS 0000000000000000 00000062
0000000000000000 0000000000000000 WA 0 0 1
[ 5] .rodata PROGBITS 0000000000000000 00000062
000000000000000d 0000000000000000 A 0 0 1
[ 6] .comment PROGBITS 0000000000000000 0000006f
000000000000002c 0000000000000001 MS 0 0 1
[ 7] .note.GNU-stack PROGBITS 0000000000000000 0000009b
0000000000000000 0000000000000000 0 0 1
[ 8] .eh_frame PROGBITS 0000000000000000 000000a0
0000000000000038 0000000000000000 A 0 0 8
[ 9] .rela.eh_frame RELA 0000000000000000 00000258
0000000000000018 0000000000000018 I 10 8 8
[10] .symtab SYMTAB 0000000000000000 000000d8
0000000000000120 0000000000000018 11 9 8
[11] .strtab STRTAB 0000000000000000 000001f8
000000000000002e 0000000000000000 0 0 1
[12] .shstrtab STRTAB 0000000000000000 00000270
0000000000000061 0000000000000000 0 0 1
我们关心的是上述段表中的2号段表:.rela.text可重定位表。正如我们之前所说的，在链接阶段要对可重定位文件中的一些符号进行重定位，所以我们必须了解哪些符号需要进行定位，而.rela.text就是用来记录相应的符号。
其中，符号表中会包含几种符号：
- 在本文件中定义的符号，可以被其它目标文件所引用
- 在本文件中引用的符号，但却没有在本文件中定义
- ...
我们先运行命令
$ nm helloworld.o
U _GLOBAL_OFFSET_TABLE_
0000000000000000 T main
U puts
来查看我们的目标文件中的符号表，可以看到我们两个符号main和puts。之所以不是printf可能是编译中进行了改变。
让我们运行另外一个命令来详细查看符号表：
$ readelf -s helloworld.o
Symbol table '.symtab' contains 12 entries:
Num: Value Size Type Bind Vis Ndx Name
......
9: 0000000000000000 34 FUNC GLOBAL DEFAULT 1 main
10: 0000000000000000 0 NOTYPE GLOBAL DEFAULT UND _GLOBAL_OFFSET_TABLE_
11: 0000000000000000 0 NOTYPE GLOBAL DEFAULT UND puts
又看到了我们熟悉的两个符号，由于main是在本文件中定义的所以它的类型是FUNC函数，且Ndx=1可以得知位于代码段，而puts由于未定义，所以Ndx=UND(undefine)，因此通过符号表我们便可以获得哪些符号是在本文件中定义的，哪些符号是需要进行重定位的。
1.4 链接(link)
上面我们知道了符号表的存在，下面我们详细说明下链接的过程。
假设我们有了两个文件，a.c和b.c。例子来自于《程序员的自我修养》。
/* a.c */
extern int shared;
int main(){
int a=100;
swap(&a, &shared);
return 0;
}
/* b.c */
int shared = 1; // default is global variable, can be accessed by external program
void swap(int *a, int *b){
*a ^= *b ^= *a ^= *b; // swap value
}
首先使用gcc编译这两个文件
$ gcc -c a.c b.c
然后我们会得到两个文件a.o，b.o，分别查看这两个文件的符号表
$ readelf -s a.o
Symbol table '.symtab' contains 13 entries:
Num: Value Size Type Bind Vis Ndx Name
......
8: 0000000000000000 81 FUNC GLOBAL DEFAULT 1 main
9: 0000000000000000 0 NOTYPE GLOBAL DEFAULT UND shared
11: 0000000000000000 0 NOTYPE GLOBAL DEFAULT UND swap
$ readelf -s b.o
Symbol table '.symtab' contains 10 entries:
Num: Value Size Type Bind Vis Ndx Name
......
8: 0000000000000000 4 OBJECT GLOBAL DEFAULT 2 shared
9: 0000000000000000 75 FUNC GLOBAL DEFAULT 1 swap
于是，我们可以看出，在a.o中只定义了一个全局符号main，而shared和swap都是未定义，而在b.o中，shared和swap则是定义了的。
我们将采用的链接命令为
$ ld a.o b.o -e main -o ab
- -e 表示
main作为主函数入口 - -o 表示输出文件名
然后查看分配前后地址的分配情况
$ objdump -h a.o
a.o： 文件格式 elf64-x86-64
节：
Idx Name Size VMA LMA File off Algn
0 .text 00000051 0000000000000000 0000000000000000 00000040 2**0
CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
1 .data 00000000 0000000000000000 0000000000000000 00000091 2**0
CONTENTS, ALLOC, LOAD, DATA
......
$ objdump -h b.o
b.o： 文件格式 elf64-x86-64
节：
Idx Name Size VMA LMA File off Algn
0 .text 0000004b 0000000000000000 0000000000000000 00000040 2**0
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 .data 00000004 0000000000000000 0000000000000000 0000008c 2**2
CONTENTS, ALLOC, LOAD, DATA
......
我尝试了好几遍运行命令
$ ld a.o b.o -e main -o ab
但是都提示一个错误
a.o：在函数‘main’中：
a.c:(.text+0x4b)：对‘__stack_chk_fail’未定义的引用
不知道为什么，于是我只好使用命令
$ gcc a.o b.o -o ab
但是生成后的文件和作者的就不太一样了，如下
节：
Idx Name Size VMA LMA File off Algn
......
13 .text 00000222 0000000000000560 0000000000000560 00000560 2**4
......
22 .data 00000014 0000000000201000 0000000000201000 00001000 2**3
CONTENTS, ALLOC, LOAD, DATA
23 .bss 00000004 0000000000201014 0000000000201014 00001014 2**0
ALLOC
24 .comment 0000002b 0000000000000000 0000000000000000 00001014 2**0
CONTENTS, READONLY
但是仍然是可以看出VMA(虚拟内存地址)已经被赋值了，而在之前的a.o和b.o中都是没有赋值的。
到这一步的意思是经过链接，我们将两个目标文件合成到一个文件中了，并且每个函数都有自己的相对地址，这时候我们就可以给每一个符号赋予地址了。
运行命令
$ readelf -s ab
来查看符号表，只列出相关的内容
Symbol table '.symtab' contains 66 entries:
Num: Value Size Type Bind Vis Ndx Name
59: 000000000000066a 81 FUNC GLOBAL DEFAULT 14 main
62: 00000000000006bb 75 FUNC GLOBAL DEFAULT 14 swap
65: 0000000000201010 4 OBJECT GLOBAL DEFAULT 23 shared
我们可以看出相关符号已经被赋予了具体的地址空间，也就是我们完成了链接过程。
在完成上述过程后，我们运行命令来反汇编查看
$ objdump -d ab
000000000000066a <main>:
66a: 55 push %rbp
66b: 48 89 e5 mov %rsp,%rbp
66e: 48 83 ec 10 sub $0x10,%rsp
672: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
679: 00 00
67b: 48 89 45 f8 mov %rax,-0x8(%rbp)
67f: 31 c0 xor %eax,%eax
681: c7 45 f4 64 00 00 00 movl $0x64,-0xc(%rbp)
688: 48 8d 45 f4 lea -0xc(%rbp),%rax
68c: 48 8d 35 7d 09 20 00 lea 0x20097d(%rip),%rsi # 201010 <shared>
693: 48 89 c7 mov %rax,%rdi
696: b8 00 00 00 00 mov $0x0,%eax
69b: e8 1b 00 00 00 callq 6bb <swap> # <swap> 6bb
6a0: b8 00 00 00 00 mov $0x0,%eax
6a5: 48 8b 55 f8 mov -0x8(%rbp),%rdx
6a9: 64 48 33 14 25 28 00 xor %fs:0x28,%rdx
6b0: 00 00
6b2: 74 05 je 6b9 <main+0x4f>
6b4: e8 87 fe ff ff callq 540 <__stack_chk_fail@plt>
6b9: c9 leaveq
6ba: c3 retq
注意到swap以及变量shared的地址已经被正确地赋值给了程序，作为对比我们查看下在链接之前程序的内容
$ objdump -d a.o
a.o： 文件格式 elf64-x86-64
Disassembly of section .text:
0000000000000000 <main>:
0: 55 push %rbp
1: 48 89 e5 mov %rsp,%rbp
4: 48 83 ec 10 sub $0x10,%rsp
8: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax
f: 00 00
11: 48 89 45 f8 mov %rax,-0x8(%rbp)
15: 31 c0 xor %eax,%eax
17: c7 45 f4 64 00 00 00 movl $0x64,-0xc(%rbp)
1e: 48 8d 45 f4 lea -0xc(%rbp),%rax
22: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 29 <main+0x29>
29: 48 89 c7 mov %rax,%rdi
2c: b8 00 00 00 00 mov $0x0,%eax
31: e8 00 00 00 00 callq 36 <main+0x36>
36: b8 00 00 00 00 mov $0x0,%eax
3b: 48 8b 55 f8 mov -0x8(%rbp),%rdx
3f: 64 48 33 14 25 28 00 xor %fs:0x28,%rdx
46: 00 00
48: 74 05 je 4f <main+0x4f>
4a: e8 00 00 00 00 callq 4f <main+0x4f>
4f: c9 leaveq
50: c3 retq
我们要注意的是偏移22和偏移31分别对应着shared和swap的调用，而第二列的十六进制代表这条指令，每个指令的后四个字节为地址，可以看出这些地址都是0，这说明在文件a.o中，由于无法确定具体的地址，此时编译器只是将其赋了一个特殊的地址0x0，然后在最后的链接阶段再完成正确的地址赋值。
我们还可以运行命令
$ objdump -r a.o
a.o： 文件格式 elf64-x86-64
RELOCATION RECORDS FOR [.text]:
OFFSET TYPE VALUE
0000000000000025 R_X86_64_PC32 shared-0x0000000000000004
0000000000000032 R_X86_64_PLT32 swap-0x0000000000000004
000000000000004b R_X86_64_PLT32 __stack_chk_fail-0x0000000000000004
其中的offset描述了要重定位的位置。
2. 总结
事实上，在《程序员的自我修养》这本书中作者对于细节的探讨很深入，要想完全理解掌握实在太难。
我主要想总结下关于链接部分。大概的过程就是：
- 链接器接收到输入文件
- 收集每个输入文件的段表，合成一个全局符号表，这张表里包含所有定义的符号
- 如果是静态链接，将多个输入文件合并，进行地址空间的分配，在这一步完成之后所有符号的具体地址就定了
- 然后再对每一个输入文件中需要重定位的符号重新定位到正确的地址处
