一个可执行文件依赖哪些库,ldd 列得出来;它自己导出了哪些符号,nm 列得出来。这两张表就是"库"在二进制层面的全部内容:一批已经编译好的机器码,加上一份名字清单。库分两种存法——编译时整块搬进可执行文件,或者运行时再挂进进程地址空间。

静态库是一包放好的 .o

静态库(libx.a)就是一串目标文件用 ar 归档成一个文件,本质上没有新格式。ar -rc libmystdio.a my_stdio.o my_string.o 里的 r 是 replace、c 是 create:库不存在就新建,存在就把同名成员换掉,其余保留。

ar -rc libmystdio.a my_stdio.o my_string.o
ar -tv libmystdio.a          # t 列表,v 显示详细信息
rw-rw-r-- 1000/1000   2848 Oct 29 14:35 2024 my_stdio.o
rw-rw-r-- 1000/1000   1272 Oct 29 14:35 2024 my_string.o

一段能用的 Makefile 大致长这样:

libmystdio.a: my_stdio.o my_string.o
	@ar -rc $@ $^
	@echo "build $^ to $@ done"
 
%.o: %.c
	@gcc -c $<
 
.PHONY: clean output
clean:
	@rm -rf *.a *.o stdc*
 
output:
	@mkdir -p stdc/include stdc/lib
	@cp -f *.h stdc/include
	@cp -f *.a stdc/lib
	@tar -czf stdc.tgz stdc

使用时有三种摆放方式,对应三个编译选项:

# 头文件和库都装进了系统路径
gcc main.c -lmystdio
 
# 头文件和库就在当前目录
gcc main.c -I. -L. -lmystdio
 
# 头文件和库各有自己的目录
gcc main.c -I头文件目录 -L库文件目录 -lmystdio
  • -I 加头文件的搜索目录,编译器找 #include 时用;
  • -L 加库文件的搜索目录,链接器找 -l 指定的库时用;
  • -l 写库的名字,但要去掉 lib 前缀和 .a/.so 后缀:libc.so 的库名是 c。

-L 只在链接这一刻有效,它不会写进二进制。程序运行时找不找得到库,是另一套规则。

静态库最直接的性质:链接完成后,库里的代码已经在可执行文件里了,把 libmystdio.a 删掉,程序照样跑。

课件在"场景 2"里写的是 gcc main.c -L. -lmymath,而前面造的库叫 libmystdio.a。这个名字对不上,照抄会得到 cannot find -lmymath。-l 后面跟的是库名,-L 后面跟的是目录,两者不能串。

动态库给出去的是符号表

动态库(libx.so)在运行时才被链接。可执行文件里不放库函数的机器码,只留一张"我用到哪些外部符号"的表,加上调用它们的入口。程序启动前,动态链接器把这些库从磁盘映射进进程地址空间,这个过程叫动态链接(dynamic linking)。

生成动态库要两个选项:

gcc -fPIC -c my_stdio.c my_string.c
gcc -shared -o libmystdio.so my_stdio.o my_string.o

-shared 表示产出共享库格式,-fPIC 表示按位置无关代码(position independent code)编译——库可能被映射到任意地址,编译时不能写死绝对地址。

用起来和静态库一样:

gcc main.c -I. -L. -lmystdio
ldd a.out
linux-vdso.so.1 =>  (0x00007ffecb5be000)
libmystdio.so => not found
libc.so.6 => /lib64/libc.so.6 (0x00007f8e2a5dc000)
/lib64/ld-linux-x86-64.so.2 (0x00007f8e2a9d2000)

编译通过了,ldd 却说 not found。这条消息来自动态链接器,它不认识 -L。

同一个目录下同时有 libmystdio.so 和 libmystdio.a 时,GNU ld 优先选 .so,找不到才退回 .a。想强制静态链接,加 -static;只是想让某个库静态,可以写 -Wl,-Bstatic -lfoo -Wl,-Bdynamic。

用外部库同理,比如 ncurses:

sudo apt install -y libncurses-dev      # CentOS: yum install -y ncurses-devel
gcc progress.c -o progress -lncurses

运行时找不到 .so,改的是谁的搜索路径

动态链接器(ld-linux-x86-64.so.2)按固定顺序找库,-L 不在其中。让程序找到库的做法有四种:

  1. 把 .so 拷到系统库目录,如 /usr/lib、/usr/local/lib、/lib64;
  2. 在系统库目录里给这个库建同名软链接;
  3. 设环境变量 LD_LIBRARY_PATH,只对当前 shell 及其子进程有效;
  4. 把目录写进 /etc/ld.so.conf.d/*.conf,再执行 ldconfig 刷新缓存。
echo "/opt/app/lib" > /etc/ld.so.conf.d/app.conf
ldconfig                  # 重建 /etc/ld.so.cache

第四种是系统级方案。ldconfig 会把配置里所有目录下的库扫描一遍,写进 /etc/ld.so.cache;动态链接器优先查这个缓存,比逐个目录扫快得多。改完配置不跑 ldconfig,新的路径不会生效。

前三种方案各有代价:拷贝会留下版本分裂,软链接要在系统目录里动手,环境变量只对从这个 shell 启动的进程有效,而且它会同时影响所有依赖库的查找,容易把别的程序带偏。生产环境通常用第四种,或者链接时直接写 -Wl,-rpath。

readelf -d 能看出二进制里到底写了什么路径:

readelf -d a.out | grep -E 'RPATH|RUNPATH|NEEDED'

NEEDED 是它记下的依赖库名,RPATH/RUNPATH 是编译时写进去的搜索目录。这两项存在时,LD_LIBRARY_PATH 的优先级会被打乱——RPATH 排在它前面,RUNPATH 排在它后面。

.o 里那条 call 后面为什么是 0

把一个多文件工程拆开编译,能看到链接器到底在修什么:

gcc -c hello.c code.c
objdump -d hello.o
0000000000000000 <main>:
   0:  f3 0f 1e fa          endbr64
   4:  55                   push   %rbp
   5:  48 89 e5             mov    %rsp,%rbp
   8:  48 8d 3d 00 00 00 00 lea    0x0(%rip),%rdi
   f:  e8 00 00 00 00       callq  14 <main+0x14>

callq 后面是四个 0。不是因为被调用的函数在地址 0,而是编译 hello.c 时编译器根本不知道 run 和 printf 在哪:run 在另一个 .o 里,printf 在 libc 里。编译器只能先填 0,并把"这里需要修正"记进重定位表。

符号表把这件事说得很清楚:

readelf -s hello.o
10: 0000000000000000    37 FUNC   GLOBAL DEFAULT    1 main
12: 0000000000000000     0 NOTYPE GLOBAL DEFAULT  UND puts
13: 0000000000000000     0 NOTYPE GLOBAL DEFAULT  UND run

Ndx 一列是 UND(undefined),意思是"本文件里没有这个符号的定义"。run 在 code.o 里,puts 在 libc.so 里。链接器的工作就是把每个 UND 在其他目标文件的符号表里找一遍,找到定义就把地址填回去。

hello.o 和 code.o 都有 .text 节,链接之后它们被并进同一个 .text:

四个 .o 各自的 ELF 结构,.text 与 .data 被横向对齐后合并进 main 的 .text 和 .data,其余 section 按原样搬过去

合并完成后统一编址,main.exe 里的 callq 就变成了具体地址:

0000000000001160 <main>:
 1160: f3 0f 1e fa          endbr64
 1164: 55                   push   %rbp
 1165: 48 89 e5             mov    %rsp,%rbp
 1168: 48 8d 3d a0 0e 00 00 lea    0xea0(%rip),%rdi
 116f: e8 dc fe ff ff       callq  1050 <puts@plt>
 1174: b8 00 00 00 00       mov    $0x0,%eax
 1179: e8 cb ff ff ff       callq  1149 <run>

e8 是相对调用,后面四字节是目标地址与本指令下一条之间的差值,1149 就是 run 在合并后的 .text 里的位置。readelf -s main.exe 里 run 的 Ndx 从 UND 变成了具体节号——链接完成的标志就是这个。

静态库走的是同一条路:ar 里的成员是 .o,链接器按需取出被引用到的那些,和其他 .o 一起合并。所以静态链接本质上是"把一批 .o 拼起来,再统一修正地址",也叫静态重定位。

链接顺序在这里会咬人。GNU ld 从左到右扫描命令行,处理到某个库时只解决"当前已经出现但还没定义的符号"。若 libfoo 依赖 libbar,写成 -lbar -lfoo 就找不到 libbar 里的定义,因为轮到 libbar 时还没有任何未定义符号指向它。正确顺序是依赖者在前、被依赖者在后:-lfoo -lbar。循环依赖可以套 -Wl,--start-group -lfoo -lbar -Wl,--end-group,让链接器反复扫描。

ELF 的链接视图与执行视图

file 先给个结论:

file hello.o
# hello.o: ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped
file a.out
# a.out: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2

ELF 涵盖四类文件:可重定位文件(.o)、可执行文件、共享目标文件(.so)、内核转储(core dump)。结构上分四部分:

  • ELF 头:文件特性,以及在文件中的程序头表、节头表偏移,作用是定位其他部分;
  • 程序头表(Program header table):列出所有有效段(segment)的偏移、虚拟地址、长度、权限;
  • 节头表(Section header table):描述每个节(section);
  • 节:基本组成单位,.text 存机器指令,.data 存已初始化的全局变量和静态变量。

常用的节还有几类:.rodata 存只读数据(字符串字面量就在这),只能落在只读段里;.bss 只为未初始化的全局和静态变量占位,不占文件空间,readelf -S 里它的类型是 NOBITS;.symtab 是符号表,名字与地址的对应;.got/.got.plt 是给动态链接用的跳转地址表。

两个视图对应两张表:

"链接视图"和"执行视图":左边一列是节,按功能划分给链接器看;右边一列是段,按权限合并给加载器看;中间的箭头是节到段的映射关系

readelf -S 看节,readelf -l 看段。readelf -l 末尾有一段 Section to Segment mapping,直接写出哪个段包含哪些节:

段权限包含的节
LOAD(第一个)R E.interp .note.* .gnu.hash .dynsym .dynstr .text .plt .rodata .eh_frame
LOAD(第二个)RW.init_array .fini_array .dynamic .got .got.plt .data .bss

合并的原则是属性相同:可读可执行的一组,可读可写的一组,只读的一组。理由有两个。一是减少页内碎片——页是最小分配单位,如果 .text 4097 字节、.init 512 字节各自独立占页,要 3 页;合并后只需 2 页。二是权限控制——同一个段只有一种权限,代码段只读可执行,数据段可读写,这样页表项的权限位才有意义。

这里有一处课件要改。课件用 readelf -h a.out 看到 Type: DYN (Shared object file),注释成"文件类型:动态共享库(.so)"。这个输出本身没错,但结论错了:a.out 是可执行文件,DYN 只说明它以 PIE(position independent executable)形式生成——现代发行版的 gcc 默认开 -pie,可执行文件也按"可重定位"的方式编址,加载时整体加一个随机基址。区分办法是 file 的输出:pie executable 与 shared object 是两回事;另外 PIE 的入口地址是文件内偏移(比如 0x1060),而老式 EXEC 类型的入口是虚拟地址(比如 0x400640)。想回到老样子编译,加 -no-pie。

从 _start 到 main,以及地址在编译时就已经定好

一个 ELF 文件还没被加载时就已经有地址了。objdump -S 左边那一列就是虚拟地址,起始按 0 算,各段依次排开。这是"平坦模式"的要求:编译器和操作系统必须约定同一套编址,加载时才能把每个段直接摊到进程地址空间里。

反汇编左侧的 1149、1160 就是已经编好的虚拟地址,callq 1050 <puts@plt> 里的 1050 也是;这些数字在文件里就写死了

程序的入口不写在这个约定里,写在 ELF 头的 Entry point 字段。readelf -h 能看到它,readelf -l 里的 INTERP 段则指出由谁来做加载后的收尾:

[Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]

启动顺序大致是:

  1. 内核读 ELF 头,按程序头表里的 LOAD 段把文件内容映射到各段的虚拟地址;
  2. 跳到 Entry point,那里是 _start,由 C 运行时库或链接器提供;
  3. _start 搭好初始栈,做完数据段初始化,再调用 __libc_start_main;
  4. __libc_start_main 里完成动态链接器的收尾工作、初始化线程库和信号处理,最后调用 main;
  5. main 返回后,__libc_start_main 处理返回值并调用 exit。

_start 不做这些细节,它只是把 main 的地址交给 __libc_start_main——objdump -d 里能看到 lea 0xd8(%rip),%rdi # 1160 <main> 这一行。

那程序运行起来之后,内存里那些区域是谁划的?进程刚创建时 mm_struct、vm_area_struct 的数据来自 ELF 的各个 segment:每个 segment 带自己的起始地址和长度,正好填进 VMA 的 [vm_start, vm_end],再用具体地址填页表。

task_struct 的 mm 指针指向 mm_struct,mm_struct 的 mmap 挂着一串 vm_area_struct,每段对应进程地址空间里的一块:栈、文件映射与匿名映射区、堆、BSS、数据段、代码段,每段都标了 READ/WRITE/EXEC 权限

所以虚拟地址机制要编译器配合,不只靠操作系统:编译器负责把段摆到约定的地址上,操作系统负责把这些地址映射到物理页。

库被映射进来之后,如何调用:GOT 与 PLT

动态库也是一个文件,要访问同样要先打开、再映射。差别在映射地址:库的加载地址每次运行都可能不同(ASLR),所以可执行文件里那条 call 不能写死库函数的绝对地址。

代码段是只读的,改不了;能改的只有可写段。于是每个模块在自己可写的数据区里留了一张表,每项存一个外部函数或全局变量的地址,这张表叫全局偏移表(Global Offset Table,GOT)。加载时动态链接器把真实地址填进 GOT,调用时先查表再跳。

左边是进程地址空间:代码区里的 call 指令不知道库函数在哪;中间经过 struct file、dentry、inode 找到磁盘上的 libc.so,把库的代码和数据映射进共享区;右下 .got 表在库加载后被改写成"库起始地址 + 函数偏移",调用变成查表跳转

.got 是独立的一个节,readelf -S 能看到它带 WA 标志(可写、需分配)。课件说它"在 .data 中预留一片区域",更准确的说法是:.got/.got.plt 单独成节,加载时与 .data 一起并进同一个可写 segment,readelf -l 的映射表里 RW 那个 LOAD 段包含 .got、.got.plt、.data 三项。

三个结论合起来就是 PIC 的定义:

  • 代码段只读,所以不能改代码,只能改 GOT;因此同一份代码可以被所有进程共享;
  • 每个进程的每个动态库都有自己的 GOT,GOT 本身不共享;
  • 在单个 .so 内部,GOT 与 .text 的相对位置固定,所以代码可以用 RIP 相对寻址找到自己的 GOT。

这正是编译时加 -fPIC 的原因:PIC = 相对编址 + GOT。

GOT 不是一次性填完的。链接时若把所有函数都立刻重定位,启动会很慢,而多数函数整个运行期可能一次都不调用。常用的优化是延迟绑定,也就是过程链接表(Procedure Linkage Table,PLT)。objdump -d 里每个外部函数都有一个 foo@plt 桩:

0000000000001050 <puts@plt>:
 1050: f3 0f 1e fa          endbr64
 1054: f2 ff 25 75 2f 00 00 bnd jmpq *0x2f75(%rip)   # 3fd0 <puts@GLIBC_2.2.5>

第一次跳到 puts@plt 时,GOT 里那一项还指向"查符号"的桩代码,它找到真正地址后回填 GOT;之后再调用就走直达路径。gcc 默认给 -z lazy,改成 -Wl,-z,now 可以要求启动时全部绑定。

库之间也会互相依赖。两个 .so 都在调用对方的函数,各自都有自己的 .got,加载时按依赖顺序映射、逐个填表——这就是"解析依赖关系"的实际含义。

命名、链接顺序与三个查看命令

三条容易踩的规则放在一起。

库名规则:文件叫 libxxx.so 或 libxxx.a,-l 写 xxx。libc.so → -lc,libmystdio.so → -lmystdio。文件名写成 mystdio.so,-lmystdio 找不到。

链接顺序:命令行从左到右生效,被依赖的库放后面;循环依赖用 --start-group。

三个排查命令:

file  a.out            # 类型:可重定位 / 可执行 / PIE / 共享库
ldd   a.out            # 运行时依赖的每个库,以及解析到的实际路径
nm -D libfoo.so        # 导出(T)与未定义(U)的符号
nm    a.out            # 静态链接的程序,符号还能在这里看到定义

ldd 报 not found 是运行时搜索问题,查搜索路径;nm 报某个符号是 U 而在任何库里都找不到 T 版本,那是链接问题,去查 -l 和链接顺序。file 与 readelf -h 给出的是文件类型,用它区分静态链接、动态链接和 PIE,比看大小可靠——静态链接的程序通常大一圈,但那不是判据。