返回专栏
· 17 分钟阅读

程序加载与链接(Program Loading & Linking)


一、什么是程序加载与链接?

一个程序通常由多个源文件、目标文件和外部库组成。编译器负责将源代码转换为目标代码,而程序加载与链接负责将这些独立的代码和数据组织起来,使其能够在运行环境中正确执行。

需要区分三个概念:

  • 编译(Compilation):将源代码转换为目标代码或中间表示。
  • 链接(Linking):解析符号引用,将多个目标文件和库组合起来,形成可执行文件或可加载模块。
  • 加载(Loading):将可执行文件或模块映射到进程地址空间,完成必要的运行时准备。

典型的程序构建与运行过程:

flowchart TB
    A["源代码文件"] --> B["编译器"]
    B --> C["目标文件"]
    C --> D["链接器"]
    E["静态库或共享库"] --> D
    D --> F["可执行文件"]
    F --> G["操作系统加载器"]
    G --> H["进程地址空间"]
    H --> I["程序开始执行"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,编译、链接和加载并不一定严格发生在三个完全独立的时间阶段。例如,动态链接器可以在程序启动时参与符号解析,运行期间也可以加载新的共享库或模块。

二、程序为什么需要链接?

在实际开发中,一个程序通常不会将所有代码写在同一个源文件中。

例如:

project/
├── main.c
├── math.c
├── math.h
└── logger.c

其中:

  • main.c:程序入口及主要逻辑。
  • math.c:数学计算实现。
  • math.h:数学函数声明。
  • logger.c:日志功能实现。

main.c 可以调用 math.c 中定义的函数,但在单独编译 main.c 时,编译器可能还无法确定 add() 函数最终位于哪个目标文件、具体地址是什么。

例如:

main.c

#include <stdio.h>
#include "math.h"

int main(void) {
    int result = add(10, 20);
    printf("%d\n", result);
    return 0;
}

math.h

#ifndef MATH_H
#define MATH_H

int add(int a, int b);

#endif

math.c

int add(int a, int b) {
    return a + b;
}

分别编译:

gcc -c main.c -o main.o
gcc -c math.c -o math.o

此时会生成两个目标文件:

main.o
math.o

main.o 中存在对 add 的外部符号引用,而 math.o 中存在 add 的符号定义。

链接器需要找到这两个符号之间的对应关系,并修正相关地址引用。

flowchart TB
    A["main.o"] --> B["引用符号 add"]
    C["math.o"] --> D["定义符号 add"]
    B --> E["链接器解析符号"]
    D --> E
    E --> F["建立符号对应关系"]
    F --> G["生成可执行文件"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

执行链接:

gcc main.o math.o -o app

生成可执行文件 app。

程序的模块化开发依赖这种机制。不同模块可以独立编译,最终通过链接器组合起来。

三、目标文件与可执行文件

理解链接过程,需要先了解目标文件的结构。

目标文件通常不是简单的机器码集合,而是包含代码、数据、符号信息、重定位信息等内容的结构化文件。

在 Linux 等 ELF 平台中,常见的目标文件和可执行文件使用 ELF(Executable and Linkable Format)格式。

1. 目标文件的主要组成

组成部分 作用
.text 存放程序指令代码
.data 存放已初始化的全局变量和静态变量
.bss 存放未显式初始化或初始化为零的静态存储期数据
.rodata 存放只读数据,例如字符串常量
.symtab 符号表,记录符号定义及相关信息
.strtab 符号字符串表
.rel.text / .rela.text 记录代码段中的重定位信息
.debug_* 调试信息,是否存在取决于构建配置

不同目标文件格式和平台的具体结构不同。上述名称主要以 ELF 为例。

2. 代码段与数据段

以 C 语言为例:

int global_init = 100;
int global_uninit;

const char *message = "Hello";

int calculate(int a, int b) {
    return a + b;
}

在典型 ELF 目标文件中:

  • calculate() 的机器指令通常位于 .text。
  • global_init 对应的数据通常位于 .data。
  • global_uninit 通常位于 .bss。
  • 字符串字面量通常位于 .rodata。
  • message 本身是一个指针变量,通常位于 .data,它指向的字符串内容通常位于 .rodata。

这里需要注意,.bss 通常不需要在文件中保存每个变量的实际零值字节,而是通过记录所需内存大小等信息,让加载过程为其提供零初始化的内存。

3. ELF 文件的两种视角

ELF 文件具有两种重要的组织视角:

  • Section(节):主要服务于链接、符号解析和调试。
  • Segment(段):主要服务于程序加载和内存映射。

例如,多个节可以组合到一个可加载段中。

视角 主要使用者 关注内容
Section 链接器 代码、数据、符号、重定位
Segment 加载器 内存映射、权限、文件偏移

不能将 Section 和 Segment 当作同一个概念。

四、什么是符号与符号表?

符号(Symbol) 是链接过程中用于标识函数、变量或其他程序实体的名称及相关属性。

例如:

int count = 10;

int add(int a, int b) {
    return a + b;
}

其中:

  • count 是变量符号。
  • add 是函数符号。

编译器会在目标文件中记录符号信息,链接器根据这些信息解析模块之间的引用关系。

1. 符号表(Symbol Table)

符号表通常记录:

  • 符号名称。
  • 符号类型。
  • 符号绑定属性。
  • 所属节。
  • 符号值或地址相关信息。
  • 符号大小。

以 ELF 为例,符号表中的常见信息包括:

字段 含义
st_name 符号名称在字符串表中的偏移
st_value 符号值,具体含义取决于文件类型和符号类别
st_size 符号大小
st_info 符号类型和绑定属性
st_other 符号可见性等信息
st_shndx 符号所属节的索引

2. 常见符号类型

类型 含义
局部符号 主要在当前目标文件内部使用
全局符号 可以被其他目标文件引用
弱符号 在符号解析时具有较低优先级
未定义符号 当前目标文件引用了该符号,但没有在本文件中定义

例如:

extern int global_count;

int get_count(void) {
    return global_count;
}

当前目标文件引用 global_count,但并没有定义它,因此符号表中会记录一个未定义符号。

链接器需要在其他目标文件或库中找到对应定义。

3. 符号解析规则

链接器解析符号时,需要考虑符号绑定属性、可见性、定义状态和链接规则。

常见情况:

  • 强符号通常优先于弱符号。
  • 多个强符号定义可能产生重复定义错误。
  • 只有未定义引用而找不到对应定义时,通常会产生未解析符号错误。
  • 局部符号通常不会参与跨目标文件的全局符号解析。

不同平台和链接器对具体规则的处理可能有所差异。

五、什么是重定位(Relocation)?

重定位是链接过程中非常关键的机制。

编译器在生成目标文件时,通常还不知道某些外部函数或变量最终会被放置在什么地址。

因此,目标文件中可能保留尚未确定的地址引用,并通过重定位信息告诉链接器:

  • 哪个位置需要修改。
  • 需要引用哪个符号。
  • 应采用什么重定位类型。
  • 如何根据最终地址计算写入值。

1. 为什么需要重定位?

例如:

extern int global_value;

int get_value(void) {
    return global_value;
}

编译 get_value() 时,编译器知道要访问 global_value,但如果该变量定义在另一个目标文件中,其最终地址尚未确定。

因此,编译器可能先生成一段包含待修正地址的机器指令,并记录相应的重定位条目。

链接器在确定符号最终位置后,按照目标平台的重定位规则修改指令或数据中的相关字段。

2. 重定位的基本过程

flowchart TB
    A["生成目标文件"] --> B["保留未确定地址的引用"]
    B --> C["记录重定位条目"]
    C --> D["链接器确定符号位置"]
    D --> E["计算重定位值"]
    E --> F["修正代码或数据"]
    F --> G["生成可执行文件或共享库"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

3. 重定位的计算思想

重定位并不是简单地将某个符号地址直接写入指令。

不同 CPU 架构具有不同的指令编码和寻址方式,因此需要使用对应的重定位类型。

常见的计算形式包括:

绝对地址重定位:

R = S + A

PC 相对重定位:

R = S + A - P

其中:

  • R:需要写入的重定位结果。
  • S:目标符号的地址。
  • A:重定位条目中记录的附加值。
  • P:需要进行重定位的位置地址。

这两种公式用于说明常见重定位计算模型,实际 ELF 重定位类型可能具有不同定义和计算规则。

PC 相对寻址通常用于函数调用和跳转等场景,可以减少对绝对地址的依赖。

4. 为什么位置无关代码很重要?

现代操作系统普遍支持地址空间布局随机化(ASLR)。

同一个程序每次运行时,代码和数据可能被映射到不同的虚拟地址。

如果机器码严重依赖固定绝对地址,就需要进行额外的地址修正。

位置无关代码(PIC,Position Independent Code)能够减少对固定装载地址的依赖,特别适合共享库。

在 GCC 中,可以通过以下参数生成位置无关代码:

gcc -fPIC -c math.c -o math.o

-fPIC 是常见的生成位置无关代码选项,具体实现依赖目标平台和编译器。

六、什么是链接器?

链接器(Linker) 是负责将多个目标文件和库组合起来,并解析它们之间符号引用关系的工具。

链接器的主要工作包括:

  1. 输入文件解析。
  2. 符号表收集。
  3. 符号解析。
  4. 节合并与布局。
  5. 地址分配。
  6. 重定位处理。
  7. 输出文件生成。

1. 链接器的基本工作流程

flowchart TB
    A["读取目标文件与库"] --> B["解析文件结构"]
    B --> C["收集符号表"]
    C --> D["解析符号引用"]
    D --> E{"是否存在未解析符号"}
    E -->|"是"| F["继续查找目标文件或库"]
    F --> D
    E -->|"否"| G["合并代码与数据节"]
    G --> H["安排内存布局"]
    H --> I["执行重定位"]
    I --> J["生成输出文件"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style J fill:#E5F4EC,stroke:#A3CBB5,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

2. 静态链接(Static Linking)

静态链接是指在生成最终可执行文件时,将所需的静态库代码复制或合并到输出文件中。

例如:

gcc main.o math.o -o app

如果使用静态库:

gcc main.o -L. -lmath -o app

其中 -lmath 表示链接名为 math 的库,具体选择哪个文件取决于链接器搜索规则和参数。

静态库通常以 .a(Linux 常见)或 .lib(Windows 常见)等形式存在。

静态链接的特点:

  • 库代码通常被纳入最终可执行文件。
  • 程序运行时不需要再通过动态链接器查找这些静态库。
  • 可执行文件通常更大。
  • 库更新后,通常需要重新链接程序才能使用新版本。

需要注意,静态链接并不意味着整个程序完全没有动态依赖。程序仍可能依赖操作系统提供的动态库。

3. 动态链接(Dynamic Linking)

动态链接不会将所有依赖库的代码都复制到可执行文件中,而是保留对共享库的依赖。

例如:

gcc -shared -fPIC math.c -o libmath.so

生成共享库:

libmath.so

再进行动态链接:

gcc main.o -L. -lmath -o app

运行时,系统需要找到并加载对应共享库。

动态链接的特点:

  • 多个进程可以共享同一个共享库的代码映射。
  • 可执行文件通常更小。
  • 库可以独立更新,但必须保持接口和 ABI 兼容。
  • 运行时需要解决共享库依赖和符号地址问题。

4. 静态链接与动态链接对比

对比维度 静态链接 动态链接
库代码 通常合并进可执行文件 运行时加载共享库
文件大小 通常较大 通常较小
运行时依赖 不需要对应静态库文件 需要共享库及其依赖
库更新 通常需要重新链接 可在兼容条件下独立更新
内存共享 不以共享库映射方式共享代码 多进程可共享库的只读代码页
部署复杂度 可能较低 需要管理库版本与依赖

5. 静态链接与动态链接的区别示意

flowchart TB
    A["应用目标文件"] --> B["静态链接器"]
    C["静态库"] --> B
    B --> D["包含库代码的可执行文件"]

    E["应用目标文件"] --> F["动态链接器或链接过程"]
    G["共享库依赖信息"] --> F
    F --> H["可执行文件"]
    H --> I["运行时加载共享库"]
    J["共享库文件"] --> I
    I --> K["完成动态符号绑定"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style J fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style K fill:#F3EDFC,stroke:#C4B2E3,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

七、什么是加载器(Loader)?

加载器(Loader) 是操作系统或运行时中负责将可执行文件装入进程地址空间,并完成程序启动准备的机制。

在 Linux 中,程序执行通常涉及内核加载器和动态链接器。

加载器需要处理:

  • 识别可执行文件格式。
  • 创建进程地址空间。
  • 映射代码段和数据段。
  • 设置内存访问权限。
  • 准备栈和程序参数。
  • 建立必要的运行时环境。
  • 将控制权交给程序入口。