一、什么是库
我们平时写代码时总要include一些库,这些库是什么呢?
库是写好的、现有的、成熟的、可以复用的代码。我们平时写的程序都要用到很多基础的库的功能,如果没有库,这些功能就需要我们自己实现一遍再用。有了库,极大地节省了我们写代码的时间。
库本质上来说就一种可执行代码的二进制形式,可以被操作系统载入内存执行。
库有两种:
静态库 .a(linux) .lib(windows)
动态库 .so(linux) .dll(windows)
注意,虽然作用和头文件很像,但是库和头文件是两种不同的文件
二、静态库
2.1 概念
静态库是在链接阶段,静态链接器解析文件中的未定义符号,从静态库中提取包含对应符号的 .o 模块,并与用户代码合并、完成地址重定位。
2.2 静态库生成
首先,我们需要将源码编译成.o文件
gcc -c add.c -o add.o
gcc -c sub.c -o sub.o

接下来打包静态库:
ar rcs libmath.a add.o sub.o

这里出现的libmath.o就是静态库了
这里要注意,库文件的命名是有一定规范的,我们需要在库文件名前加上lib
lib[库文件名].a
这里,我们只有两个文件要打包成库。那如果我们有100个文件要打包呢?这时候,如果还手动使用命令就太麻烦了。所以我们可以写一个Makefile来方便我们进行打包:
# 1. 找到所有 .c,并推导出对应的 .o 列表
OBJS = $(patsubst %.cc, %.o, $(wildcard *.cc))
# 2. 目标依赖于这些 .o 文件
libmath.a: $(OBJS)
ar -rcs $@ $^
# 3. 模式规则:.cc 编译为 .o(注意命令行前必须是 Tab 缩进)
%.o: %.cc
g++ -c $< -o $@
.PHONY: clean
clean:
rm -f *.o libmath.a
2.3 静态库使用
下面我们进行静态库的使用。
在此之前,我们需要先再创建一下add.h和sub.h,并在里面声明两个函数
我们新建一个文件来进行演示:
//Main.cc
#include<iostream>
#include"add.h"
#include"sub.h"
using namespace std;
int main()
{
int a,b;
cout<<"Enter two numbers: ";
cin>>a>>b;
cout<<"Sum of two numbers is: "<<add(a,b)<<endl;
cout<<"Difference of two numbers is: "<<sub(a,b)<<endl;
return 0;
}
接下来,为了不受原本存在的.cc文件影响,我们可以直接把原来的文件删了
下面是两种使用静态库的方法:
方式一:标准参数法(推荐,工业界通用)
使用-L指定库的路径和-l指定库名称:
g++ main.cc -L. -lmath -o main
-L.:告诉链接器在当前目录(.)查找库文件。
-lmath:指定库名称。链接器会自动补全前缀lib和后缀.a,最终寻找并加载libmath.a。


如果头文件在单独的子目录(如 include/),需要配合 -I 指定头文件路径:
g++ main.cc -I./include -L./lib -lmath -o main
方式二:直接指定库路径(简易快速)
直接将 .a 文件当作普通目标文件传给编译器:
g++ main.cc ./libmath.a -o main
这种方式不需要写 -L 和 -l,适合单次本地调试测试。

三、动态库
3.1 概念
动态库是程序运行时才去进行链接的代码。编译链接时,仅在可执行文件中记录依赖库的名称与符号信息。
程序运行前,由系统的动态链接器将其从硬盘加载到内存中
动态库可以被多个进程共享。这样,内存中只需要存储一份代码,所有程序就都可以使用这个库了,节省了内存空间。
3.2 动态库生成
动态库生成必须使用两个关键参数:
-fPIC(Position Independent Code):生成位置无关代码。动态库的代码段在各个进程的虚拟地址空间中加载的基地址并不固定,必须通过相对偏移和全局偏移表(GOT)寻址。
-shared:指示链接器生成共享目标文件(.so),而非普通可执行程序gcc在链接时,会强制寻找程序的入口,但是动态库显然没有main函数。为了解决这个问题,要加上这个参数。加上-shared就是明确告知链接器:“这是一个供别人调用的共享库(.so),不是独立执行程序,不用找main函数”。
下面,我们再次使用前面的add和sub进行动态库的创建:
# 步骤 1:编译源文件为位置无关的目标文件
g++ -fPIC -c add.cc -o add.o
g++ -fPIC -c sub.cc -o sub.o# 步骤 2:打包生成动态共享库
g++ -shared -o libmymath.so add.o sub.o# 亦可一步合并完成:
# g++ -fPIC -shared -o libmymath.so add.cc sub.cc
下面时Makefile写法:
TARGET = libmymath.so
OBJS = $(patsubst %.cc, %.o, $(wildcard *.cc))# 生成动态库
$(TARGET): $(OBJS)
g++ -shared -o $@ $^# 必须带 -fPIC
%.o: %.cc
g++ -fPIC -c $< -o $@.PHONY: clean
clean:
rm -f *.o $(TARGET)
3.3 动态库的使用
首先要编译链接主程序,在编译链接时,要指明此程序依赖的动态库
假设主程序为
main.cc:g++ main.cc -L. -lmymath -o main
-L.:指示编译器在当前目录下查找库文件。
-lmymath:链接libmymath.so(链接器会自动去除lib前缀与.so后缀)。

但是这时,如果我们直接运行main程序,会直接报错:

这是因为动态链接器找不到动态库
动态链接器默认只会在系统标准目录中查找动态库,而我们的动态库不在这里面
下面有四种解决方案:
临时方案:设置环境变量
LD_LIBRARY_PATH(适合开发调试)export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH ./main该变量仅在当前终端会话生效,关闭终端后失效。
工程方案:编译时指定 RPATH(推荐,路径写入二进制文件) 在编译时通过
-Wl,-rpath让链接器将库的运行时搜索路径直接硬编码进 ELF 文件的RUNPATH头部:# $ORIGIN 代表可执行程序所在的当前目录 g++ main.cc -L. -lmymath -Wl,-rpath='$$ORIGIN' -o main ./main无论程序被拷贝到哪里,只要库文件放在它旁边,程序即可直接运行。
系统方案:修改系统动态链接配置文件
# 1. 在配置目录中添加自定义路径配置文件 sudo echo "/path/to/your/library" > /etc/ld.so.conf.d/mymath.conf # 2. 刷新动态链接器缓存 ld.so.cache sudo ldconfig全局方案:安装到系统标准库目录
sudo cp libmymath.so /usr/lib64/ sudo ldconfig

3.4 使用外部库
我们可以下载一个外部库来玩一玩:
// 安装// Centos$ sudo yum install -y ncurses-devel// ubuntu$ sudo apt install -y libncurses-dev
#include <ncurses.h>
int main() {
// 1. 初始化终端环境
initscr(); // 初始化 ncurses 屏幕
cbreak(); // 禁用行缓冲,按键立即读取无需按回车
noecho(); // 禁止用户输入的字符直接回显在屏幕上
keypad(stdscr, TRUE); // 开启功能键支持(支持 F1~F12、方向键等)
curs_set(0); // 隐藏终端光标(0: 不可见, 1: 正常, 2: 极明显)
// 2. 初始化颜色支持
if (has_colors()) {
start_color();
// 初始化颜色对:ID, 前景色, 背景色
init_pair(1, COLOR_CYAN, COLOR_BLACK);
init_pair(2, COLOR_YELLOW, COLOR_BLUE);
}
// 3. 获取终端当前的行列数
int max_y = 0, max_x = 0;
getmaxyx(stdscr, max_y, max_x);
// 初始位置(屏幕中心)
int y = max_y / 2;
int x = max_x / 2;
int ch;
while (true) {
// 清屏
clear();
// 打印标题(带颜色属性)
attron(COLOR_PAIR(2) | A_BOLD);
mvprintw(1, 2, " [ncurses Demo] Use WASD or Arrow Keys to move, 'q' to quit ");
attroff(COLOR_PAIR(2) | A_BOLD);
// 打印当前坐标状态
mvprintw(3, 2, "Current Position: (Y: %d, X: %d) | Screen Size: (%d x %d)", y, x, max_y, max_x);
// 绘制移动的玩家角色 '@'
attron(COLOR_PAIR(1) | A_BOLD);
mvaddch(y, x, '@');
attroff(COLOR_PAIR(1) | A_BOLD);
// 刷新缓冲区,真正将内容渲染到终端屏幕
refresh();
// 等待并读取按键输入
ch = getch();
if (ch == 'q' || ch == 'Q') {
break;
}
// 处理移动逻辑(支持方向键和 WASD)
switch (ch) {
case KEY_UP:
case 'w':
case 'W':
if (y > 4) y--;
break;
case KEY_DOWN:
case 's':
case 'S':
if (y < max_y - 2) y++;
break;
case KEY_LEFT:
case 'a':
case 'A':
if (x > 2) x--;
break;
case KEY_RIGHT:
case 'd':
case 'D':
if (x < max_x - 3) x++;
break;
default:
break;
}
}
// 4. 退出前必须清理 ncurses 环境并恢复终端正常状态
endwin();
return 0;
}
g++ Main.cc -o Main -lncurses

五、ELF文件
5.1 ELF文件的组成
要理解编译链接的细节,我们不得不了解一下ELF文件。
下面四种文件都是ELF文件:
1. 可重定位文件(目标文件):包含适合与其他目标文件链接来创建可执行文件或者共享目标文件的代码和数据
2. 可执行文件:就是可以运行的程序
3. 共享目标文件:就是动态库文件(.so)
4. 核心转储文件:在进程崩溃瞬间记录虚拟内存镜像状态、CPU寄存器快照和线程调用栈,供 GDB(
gdb ./main core)事后复盘排查崩溃点。
而一个ELF由下面四个部分组成:
1. ELF头(ELF header):位于文件的开头位置,记录文件的元数据与结构导航信息,用来定位文件的其他部分。
2. 程序表头(Program header table):记录每个segment(段)的类型、访问权限和偏移量、长度等属性
3. 节(Sections):ELF文件的基本组成单位,不同类型的节存储特定类型的数据。
节名称 作用说明 读写属性 .text编译生成的 CPU 机器指令(代码段)。 只读、可执行( R-X).rodata只读常量数据(如字符串字面量、 const全局变量)。只读( R--).data已显式初始化的全局变量和静态变量。 可读、可写( RW-).bss未初始化(或初始化为 0)的全局/静态变量。在文件中不占实际磁盘空间,仅记录所需大小,运行时内核用全 0 物理页填充。 可读、可写( RW-).symtab符号表。记录函数名、全局变量名及其在代码段/数据段中的偏移。 链接使用(可被 strip剥离).strtab字符串表。存储符号名、节名称等以 \0结尾的原始文本字符串。只读数据 .dynsym动态符号表。只包含动态链接(如调用动态库)所需的导出/导入符号。运行时必须保留。 运行时需要 .dynstr动态字符串表。存储动态符号对应的名称。 运行时需要 .plt/.got过程链接表与全局偏移表。实现动态库函数的延迟绑定与位置无关寻址(PIC)。 .got.plt运行时可写4.节头表(Section Header Table):记录所有节的目录信息,相当于文件的目录索引。包含每个节的名称、类型和字节偏移量、字节大小、内存对齐要求。
5.2 ELF从形成到加载轮廓
5.2.1 ELF形成可执行
编译时,编译器会把源代码文件编译成ELF格式的.o文件
链接时,因为.o文件和动静态库文件都是ELF格式的,他们的格式都相同,所以可以直接合并成一个ELF文件。这样,就形成了可执行文件。

5.2.2 ELF可执⾏⽂件加载
一个ELF文件会有多种不同的Section,但是一个Section可能只占了几百字节,这样,一个section就要独占一个4KB的页面,会有很大的空间浪费。所以,在加载到内存中时,链接器和内核会将有相同权限的Section合并成一个segment。而合并原则是在形成ELF时就已经确定的,被记录在ELF的程序表头中,我们可以用readelf 命令来查看section:

那么 ,程序表头和节头表有什么作用呢?
我们要从两个视角来看,他们分别服务于ELF文件的两个阶段:运行加载期和编译链接期
| 对比维度 | 程序头表 (Program Header Table) | 节头表 (Section Header Table) |
| 主要服务对象 | 操作系统内核(execve)与动态链接器(ld-linux.so) | 静态链接器(ld)、调试器(gdb)、反编译工具(objdump) |
| 生效生命周期 | 运行态 / 加载期(Runtime) | 开发态 / 编译链接期(Link time / Debug time) |
| 基本管理单元 | Segment(段) | Section(节) |
| 解决的核心问题 | 这个二进制文件应该如何被映射到进程的虚拟内存中?哪些区域只读?哪些区域可执行? | 这个文件包含哪些代码块、符号表、重定位项?它们应该如何拼接与缝合? |
| 存在必要性 | 可执行文件与共享库必须存在;目标文件(.o)中通常没有(因为 .o 不需要单独加载运行)。 | 目标文件必须存在;在剥离调试信息(strip)的可执行文件中甚至可以被完全抹去,程序仍能正常运行。 |
程序头表在程序运行加载时高速操作系统该如何加载程序,指明每个段(segment)在该文件中的偏移量和大小,该映射到虚拟内存的哪个地址和内存占用大小等,告诉内核在哪里找动态链接器
节头表在编译链接时,记录每个section的信息,告诉链接器该如何进行ELF文件的合并
六、理解链接与加载
6.1 静态链接
我们先创建两个文件来进行演示:
//code.cc
#include<stdio.h>
void run()
{
printf("running...\n");
}
//hello.cc
#include <stdio.h>
void run();
int main()
{
printf("hello world!\n");
run();
return 0;
}
我们编译这两个文件成.o文件:
g++ -c *.cc
用objdump命令查看编译出的.o文件:


可以看到这两个.o文件中的call这里,这里就是函数跳转的位置。但是我们发现,这两个地址都是0
。因为现在这两个文件都还不认识他们外面的函数,只有在链接时,这两个地址才会被修正:

可以看到,链接后形成的main.exe文件的call已经有了地址。所以,链接过程中会涉及到对.o外部符号进行地址重定位

6.2 ELF加载与进程地址空间
6.2.1 虚拟地址/逻辑地址
一个ELF程序被加载到内存之前就有了地址,这时因为当代计算机采用了“平坦模式”进行工作。
平坦模式就是把所有段的基地址强制归零,把整个虚拟内存拉成了一个无断层、连续线性的地址空间:
虚拟地址=段基址+偏移量=绝对数值
为了让相对寻址成立,ELF文件内必须预先规划好虚拟地址,如果不提前给段指定基地址,就无法得知段与段之间跨越了多少个字节

对于每个进程来说虚拟地址空间都是独立的,程序运行时,先通过ELF文件中预先设置好的虚拟地址形成内存中的地址
再程序运行时,内核会先随机选一个合法且未使用的虚拟基地址,然后根据ELF中的偏移量来设置程序在内存中每个segment的起始地址
6.3 动态链接
6.3.1 过程
动态链接是将程序对共享库的加载与符号绑定推迟到运行时。默认情况下,函数调用采用延迟绑定(Lazy Binding)机制,即在第一次调用时才现场解析目标函数的绝对虚拟地址。
在编译链接时,可执行文件的segment会为动态库预留空白占位槽位(GOT槽位)。运行时,操作系统会把主程序和动态链接器映射进内存,之后动态连接器会读取主程序的依赖的动态库,读取后发起mmap系统调用,请求内核把这个程序用到的动态库的代码段和数据段通过页表映射到进程的虚拟地址空间的共享区中
而在现代Linux操作系统中,并不会在程序运行一开始就把所有动态库映射到地址空间,而是在程序正式开始运行前,先在虚拟内存中先为这个动态库分配一段空间但不立即分配物理内存和建立硬件页表项,当程序运行时遇到了动态库中的函数,硬件 MMU 才会发现页表中没有对应的物理页框,立即触发 缺页异常,内核接管异常,此时才现场从物理内存划出一个 4KB 页,把磁盘上该函数所在的 4KB 机器指令读进物理 RAM,然后将映射写入页表,进行映射。
而进程间是如何共享库的呢?
如果一个进程运行时,触发缺页中断要寻找动态库时,发现内存中已经存在了依赖的动态库,那么就会通过文件系统的 Page Cache(页面缓存)进行映射,将映射写入页表
而当新的进程需要对动态库的数据进行更改时,内核会在物理内存中新建一个4kb的物理页,拷贝出一份相同的数据给新进程,并把新进程页表里的该项改为可读写并指向新的物理页,这样就可以让各进程独享自己的私有变量和GOT表
GOT表:在可读写的数据段中开辟一个“地址中转站”,让只读的代码段能通过固定相对偏移间接找到那些在编译期无法确定绝对地址的外部变量和外部函数
动态链接器:◦ 动态链接器(如ld-linux.so)负责在程序运⾏时加载动态库。◦ 当程序启动时,动态链接器会解析程序中的动态库依赖,并加载这些库到内存中。环境变量和配置⽂件:◦ Linux系统通过环境变量(如LD_LIBRARY_PATH)和配置⽂件(如/etc/ld.so.conf及其⼦配置⽂件)来指定动态库的搜索路径。◦ 这些路径会被动态链接器在加载动态库时搜索。缓存⽂件:◦ 为了提⾼动态库的加载效率,Linux系统会维护⼀个名为/etc/ld.so.cache的缓存⽂件。◦ 该⽂件包含了系统中所有已知动态库的路径和相关信息,动态链接器在加载动态库时会⾸先搜索这个缓存⽂件。
6.3.2 main函数的执行
这个_start函数会执行一系列初始化操作:
execve 切换到用户态时,栈顶(%rsp 指向的位置)已经由内核预先铺设好了命令行与环境变量数据
高地址
...
环境变量字符串 ("PATH=/bin", ...)
参数字符串 ("./main", "arg1", ...)
辅助向量 (Auxiliary Vector, auxv)
环境变量指针数组 (NULL 结尾)
命令行参数指针数组 (NULL 结尾)
argc (参数个数)
低地址 <-- %rsp (当前栈顶)
_start会直接从栈顶弹出这些核心数据
3.栈对齐
86-64 ABI 规范严格要求:在执行任何 call 指令前,栈指针 %rsp 必须对齐到 16 字节边界
内核初始化栈时并不保证 16 字节对齐,_start 通过与操作清空低 4 位来完成强制对齐
4.传参并跳转到__libc_start_main
真正执行main函数之前,还需要做大量初始化工作,__libc_start_main函数就时用来做这些工作的:
_start 会根据 x86-64 的函数调用约定(参数寄存器为 %rdi, %rsi, %rdx, %rcx, %r8, %r9),把准备好的数据与函数指针填入对应寄存器:
| 寄存器 / 栈位置 | 传递的参数 | 作用说明 |
%rdi (第 1 参数) | main | 用户编写的 main 函数真实入口指针 |
%rsi (第 2 参数) | argc | 命令行参数个数 |
%rdx (第 3 参数) | argv | 命令行参数数组指针 |
%rcx (第 4 参数) | __libc_csu_init | 初始化函数指针(负责调用全局对象的构造函数) |
%r8 (第 5 参数) | __libc_csu_fini | 析构清理函数指针(负责调用全局对象的析构函数) |
%r9 (第 6 参数) | stack_end | 传入旧栈顶指针,用于辅助初始化或栈溢出保护 |
| 栈顶 (第 7 参数) | 动态链接器清理函数 | 动态链接器传来的 rtld_fini 析构回调 |
填好这些参数后,_start执行 call __libc_start_main ,跳转到这个函数开始进行初始化,初始化完成后调用main函数
5.兜底保护:hlt
__libc_start_main会在调用完main函数后捕获mian函数的返回值并调用exit_group系统调用终止进程
但如果发生了严重错误导致 __libc_start_main 意外返回,_start 会紧接着执行一条兜底指令:
hlt
使 CPU 暂停执行,防止指令指针坠入未知内存区域乱跑。
整体调用链路总结

6.3.3 库函数的调用
前面我们知道,不管是静态库还是动态库的函数,都被我们映射到了进程地址空间中,那么,程序运行时到底是怎么调用函数的呢?
进程代码区中的call命令其实并不是直接写入了目标函数的地址,而是写入了函数的got地址+表中偏移地址,比如我们调用printf("Hello World\n");这条命令,要经过下面六个步骤:
1.汇编指令执行call printf@plt ,cpu指令指针跳转到代码段的printf@plt处
2.查GOT表
printf@plt 的第一条指令是间接跳转:jmp *printf@got.plt(%rip)
此时 GOT 表项里存的是什么? 因为从未被调用过,动态链接器在初始化时预填的并不是真实函数地址,而是紧接着该 jmp 指令的下一条指令地址(printf@plt + 6)
因此,CPU 执行跳转后,实际上又“跌回”到了 printf@plt 的后续指令中
3.准备符号标识:
PLT 后续指令执行 pushq $reloc_index,把 printf 在重定位表(.rela.plt)中的偏移索引压入栈中
接着执行一条跳转指令,跳到所有外部函数共用的公共入口 PLT[0]
4.调用动态链接器:
PLT[0] 将当前模块的标识指针(link_map,存放在 GOT[1])压栈
然后调用 GOT[2] 中存放的动态链接器解析入口函数:_dl_runtime_resolve()
5.动态解析与覆写缓存:
_dl_runtime_resolve() 接收到两个参数:当前模块信息与符号编号
动态链接器顺着当前进程的动态库链表,在 libc.so 的动态符号表(.dynsym)中利用哈希表快速匹配查找 "printf" 的相对偏移
结合 libc.so 映射在虚拟内存共享区中的加载基地址(l_addr),计算出 printf 在当前平坦虚拟内存中的真实绝对地址
关键动作:动态链接器直接将该 64 位绝对虚拟地址,写回到主程序私有数据段的printf@got.plt 槽位中
6.转入真实函数执行:
动态链接器将执行流直接交给 0x7ffff7a25000,开始执行 glibc 中的 printf 机器指令
简单地说就是:
一开始进程的代码区中跳转指令指向的是只读代码段自带的 PLT 跳板;首次执行时,PLT跳板里的GOT槽位存的是后继跌入动态链接器的指令的地址,动态链接器根据元数据符号表找到真实函数后,把真实绝对地址填入数据区中该函数专属的 GOT 槽位,后续调用直接解引用该槽位跳转,代码区本身从始至终不发生任何修改
这样,以后再次执行printf函数时,got.plt已经是正确的地址了,这里就会直接跳转到printf函数处进行执行,而不会执行下一条指令,执行完printf函数后,不会继续执行printf@plt + 6,而是执行main函数中的下一条命令,因为printf函数执行完毕后会执行ret指令,这个指令是弹出栈顶的8字节,赋给cpu指针RIP,而现在栈顶的是call命令压入栈顶的下一条main函数中的命令
还有值得说明的一点:
不仅可执行程序要调用库,库也会调用其他的库,所以库之间也是有依赖关系的
库也有自己的.plt和 .got.plt,即使他们都调用了printf,主程序的printf@got.plt和库的printf@got.plt也是两个相互独立的数据槽位
当执行流进入
libA.so的foo()函数,跑到了call printf@plt;调用的其实是
libA.so自己只读代码段里的printf@plt;首次执行时,读取
libA.so私有数据段里的printf@got.plt,跌回libA.so自己的 PLT 跳板,触发_dl_runtime_resolve;动态链接器把解析出的绝对地址写入
libA.so专属的 GOT 槽位;
printf内部执行完ret,弹栈回到libA.so内部紧随其后的下一条指令。
本文深入解析Linux下静态库(.a)和动态库(.so)的生成、使用及底层机制,涵盖静态链接与动态链接过程、ELF文件结构(头、段、节、节头表、程序头表)、地址重定位(静态/动态)、GOT/PLT机制、动态链接器工作流程,以及进程加载时虚拟地址空间布局与共享库内存映射原理。


14万+

被折叠的 条评论
为什么被折叠?



