一个可执行文件的生成

我们先来复习一下一个可执行的程序是如何从源代码转变为一个可以运行的二进制文件的。
在这一部分，我们以简单的hello.c程序来说明：

#include <stdio.h>
int main()
{
    printf("hello, world\n");
    return 0;
}

预处理

首先是预处理部分。
预处理命令：

• gcc -E hello.c -o hello.i
• cpp hello.c > hello.i

经过预处理的程序大致如下：

# 1 "hello.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "hello.c"
# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
/*
.
.
省略大部分内容
.
.
*/
# 868 "/usr/include/stdio.h" 3 4
# 2 "hello.c" 2
# 2 "hello.c"
int main()
{
    printf("hello, world\n");
    return 0;
}

可见经过预编译处理后，得到的文件还是一个可读的文本文件 ，但不包含任何宏定义

编译

编译过程就是将预处理后得到的预处理文件（如 hello.i）进行词法分析、语法分析、语义分析、优化后，生成汇编代码文件
编译命令：

• gcc -S hello.i -o hello.s
• gcc -S hello.c -o hello.s

经过编译的程序如下：

	.file	"hello.c"
	.text
	.section	.rodata
.LC0:
	.string	"hello, world"
	.text
	.globl	main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	leaq	.LC0(%rip), %rdi
	call	puts@PLT
	movl	$0, %eax
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 7.4.0-1ubuntu1~18.04) 7.4.0"
	.section	.note.GNU-stack,"",@progbits

同样的，经过编译后，得到的汇编代码文件还是可读的文本文件，CPU仍然无法理解和执行它

汇编

汇编过程就是将编译后得到的汇编代码文件转换为机器指令序列，生成可重定位目标文件。
汇编指令和机器指令一一对应，前者是后者的符号表示，它们都属于机器级指令，所构成的程序称为机器级代码。
汇编命令：

• gcc -c hello.s -o hello.o
• gcc -c hello.c -o hello.o

汇编结果是一个可重定位目标文件，其中包含的是不可读的二进制代码，我们用工具查看它的大致内容：
objdump hello.o -D

hello.o：     文件格式 elf64-x86-64


Disassembly of section .text:

0000000000000000 <main>:
   0:	55                   	push   %rbp
   1:	48 89 e5             	mov    %rsp,%rbp
   4:	48 8d 3d 00 00 00 00 	lea    0x0(%rip),%rdi        # b <main+0xb>
   b:	e8 00 00 00 00       	callq  10 <main+0x10>
  10:	b8 00 00 00 00       	mov    $0x0,%eax
  15:	5d                   	pop    %rbp
  16:	c3                   	retq   

Disassembly of section .rodata:

0000000000000000 <.rodata>:
   0:	68 65 6c 6c 6f       	pushq  $0x6f6c6c65
   5:	2c 20                	sub    $0x20,%al
   7:	77 6f                	ja     78 <main+0x78>
   9:	72 6c                	jb     77 <main+0x77>
   b:	64                   	fs
	...

Disassembly of section .comment:

0000000000000000 <.comment>:
   0:	00 47 43             	add    %al,0x43(%rdi)
   3:	43 3a 20             	rex.XB cmp (%r8),%spl
   6:	28 55 62             	sub    %dl,0x62(%rbp)
   9:	75 6e                	jne    79 <main+0x79>
   b:	74 75                	je     82 <main+0x82>
   d:	20 37                	and    %dh,(%rdi)
   f:	2e 34 2e             	cs xor $0x2e,%al
  12:	30 2d 31 75 62 75    	xor    %ch,0x75627531(%rip)        # 75627549 <main+0x75627549>
  18:	6e                   	outsb  %ds:(%rsi),(%dx)
  19:	74 75                	je     90 <main+0x90>
  1b:	31 7e 31             	xor    %edi,0x31(%rsi)
  1e:	38 2e                	cmp    %ch,(%rsi)
  20:	30 34 29             	xor    %dh,(%rcx,%rbp,1)
  23:	20 37                	and    %dh,(%rdi)
  25:	2e 34 2e             	cs xor $0x2e,%al
  28:	30 00                	xor    %al,(%rax)

Disassembly of section .eh_frame:

0000000000000000 <.eh_frame>:
   0:	14 00                	adc    $0x0,%al
   2:	00 00                	add    %al,(%rax)
   4:	00 00                	add    %al,(%rax)
   6:	00 00                	add    %al,(%rax)
   8:	01 7a 52             	add    %edi,0x52(%rdx)
   b:	00 01                	add    %al,(%rcx)
   d:	78 10                	js     1f <.eh_frame+0x1f>
   f:	01 1b                	add    %ebx,(%rbx)
  11:	0c 07                	or     $0x7,%al
  13:	08 90 01 00 00 1c    	or     %dl,0x1c000001(%rax)
  19:	00 00                	add    %al,(%rax)
  1b:	00 1c 00             	add    %bl,(%rax,%rax,1)
  1e:	00 00                	add    %al,(%rax)
  20:	00 00                	add    %al,(%rax)
  22:	00 00                	add    %al,(%rax)
  24:	17                   	(bad)  
  25:	00 00                	add    %al,(%rax)
  27:	00 00                	add    %al,(%rax)
  29:	41 0e                	rex.B (bad) 
  2b:	10 86 02 43 0d 06    	adc    %al,0x60d4302(%rsi)
  31:	52                   	push   %rdx
  32:	0c 07                	or     $0x7,%al
  34:	08 00                	or     %al,(%rax)
	...

目标文件

目标文件有三种形式：

• 可重定位目标文件 Relocatable object file (.ofile)
  • 由对应的 .c 文件通过编译器和汇编器生成的二进制代码，包含代码和数据，可以与其他可重定位目标文件合并创建一个可执行或共享的目标文件
• 可执行目标文件 Executable object file (a.outfile)
  • 由链接器生成，可以直接通过加载器加载到内存中充当进程执行的二进制文件，包含代码和数据
• 共享目标文件 Shared object file (.sofile)
  • 一种类型特殊的可重定位目标文件，可以在加载或者运行时被动态的加载进内存并连接的二进制文件。Windows下被称为 Dynamic Link Libraries(DLLs)。

格式 [1]

上面提到的三种对象文件有统一的格式，即 Executable and Linkable Format(ELF)，因为，我们把它们统称为 ELF binaries，具体的文件格式如下

下面分别介绍一下各个部分：

• ELF header
  • 包含 word size, byte ordering, file type (.o, exec, .so), machine type, etc
• Segment header table
  • 包含 page size, virtual addresses memory segments(sections), segment sizes
• .text section
  • 代码部分
• .rodata section
  • 只读数据部分，例如跳转表
• .data section
  • 初始化的全局变量
• .bss section
  • 未初始化的全局变量
• .symtab section
  • 包含 symbol table, procudure 和 static variable names 以及 section names 和 location
• .rel.txt section
  • .text section 的重定位信息
• .rel.data section
  • .data section 的重定位信息
• .debug section
  • 包含 symbolic debugging (gcc -g) 的信息
• Section header table
  • 每个 section 的大小和偏移量

符号解析

下面我们换用一个程序来进行说明：

/* main.c */
int sum(int *a, int n);

int array[2] = {1, 2};

int main() 
{
    int val = sum(array, 2);
    return val;
}

/* sum.c */
int array[2];
int sum(int *a, int n)
{
    int i, s = 0;
    static int sta = 50;
    for (i = 0; i < n; i++) { 
        s += a[i];
    }
    return s;
}        

在进行链接的时候，我们首先得做的一件事情就是符号的解析：
符号指的是我们在代码中声明的变量、函数，所有的符号声明都会被保存在符号表(symbol table)中，而符号表会保存在由汇编器生成的object文件中（也就是.o文件）。
每一个可重定位目标模块都有一个符号表，符号表实际上是一个结构体数组，每一个元素包含名称、大小和符号的位置。
在连接器的上下文中，有三种不同的符号：

• 全局符号 Global symbols
• 由模块内定义，并能够被其他模块引用的符号
• 非静态的C函数与全局变量是全局符号
• 对于main.o来说，array是全局符号
• 外部符号 External symbols
• 由其他模块内定义，并被本模块引用的符号
• 在其他源代码之中定义的非静态的C函数与全局变量是外部符号
• 对于sum.o来说，array是外部符号
• 本地符号 Local symbols
• 在当前模块中定义，只能被当前模块引用的是本地符号
• 带有属性的C函数与全局变量是本地符号
• 对于sum.o来说，sta是外部符号

对于连接器来说，局部的非静态变量不在它的管辖范畴之内，因为局部的非静态变量不是符号，它一般都是保存在栈里面。而静态的变量，如果已经初始化，则会保存在.data节之中，否则保存在.bss节之中。
如果遇到在同一个模块的不同函数里面出现了相同名字的静态变量，则会给同名的本地符号加上一个唯一的编号，用于标识这一个变量。
但是如果遇到了同名的全局符号或是外部符号则怎么做呢？
首先我们得知道，不同的符号是有强弱之分的：

• 函数和已初始化的全局变量是强符号
• main.o里面的array是强符号，因为它已经初始化
• 而未初始化的全局变量是弱符号
• sum.o里面的array是弱符号，因为它未初始化

所以，根据强弱符号的定义，Linux的连接器在处理多重定义的符号时，采用以下三条规则：

• 规则1：不能出现多个同名的强符号，不然就会出现链接错误
• 规则2：如果有同名的强符号和弱符号，选择强符号
• 规则3：如果有多个弱符号，随便选择一个

所以在进行main.o与sum.o的链接时，连接器选择的是main.o中的符号array。
我们来看一个额外的例子：

// 文件 h1.c
#include <stdio.h>

int x = 2018; 
int y = 2019;

void f();

void main()
{
	printf("x = 0x%x ,y = 0x%x\n",x,y);
	f();
	printf("x = 0x%x ,y = 0x%x\n",x,y);
}

// 文件 h2.c
double x;
void f()
{
	x = -1;
}

运行的结果是：

linux> ./h
x = 0x7e2 ,y = 0x7e3
x = 0x0 ,y = 0xbff00000

在h1中x定义为int型数据占用4个字节，而在h2中x定义为double型数据，在x86-64/Linux下，占用8个字节，则h2中的x = -1;不仅修改了x的内容，也修改了y的内容，这一种错误，在编译的时候只会触发一条警告。当程序到达了一定的规模后，这种类型的错误相当难以修正。
所以说，如果可能，尽量避免使用全局变量。

如果一定要用的话，注意下面几点：

• 使用静态变量
• 定义全局变量的时候初始化
• 注意使用extern关键字

重定位

在符号解析完成后，进行重定位工作，主要分为三步：

• 合并相同的节
• 将所有目标模块中的代码段与数据段分别合并为一个单独的代码段和数据段
• 例如，所有.text节合并作为可执行文件中的.text节
• 对定义符号进行重定位（确定地址）
• 确定新节中所有定义符号在虚拟地址空间中的绝对地址
• 例如，为函数确定首地址，进而确定每条指令的地址；为变量确定首地址
• 对引用符号进行重定位（确定地址）
• 将可执行文件中符号引用处的地址修改为重定位后的地址信息
• 修改.text节和.data节中对每个符号的引用（地址）

在完成这三步工作后，链接也就基本完成了。

---

参考资料

• 1.【读薄 CSAPP】肆 链接