文章目录
一、静态链接
- ⽆论是⾃⼰的
.o,还是静态库中的.o,本质都是把.o⽂件进⾏链接的过程 - 所以:研究静态链接,本质就是研究
.o是如何链接的
反汇编查看编译后的.o⽬标⽂件
objdump -d code.o
objdump -d hello.o
我们可以看到这⾥的call指令,它们分别对应之前调⽤的printf和run函数,但是你会发现他们的跳转地址都被设成了0。那这是为什么呢?
其实就是在编译 hello.c 的时候,编译器是完全不知道 printf 和 run 函数的存在的,⽐如他们位于内存的哪个区块,代码⻓什么样都是不知道的。因此,编辑器只能将这两个函数的跳转地址先暂时设为0。也就是说.o文件彼此之间不认识对方。
这个地址会在哪个时候被修正?链接的时候!为了让链接器将来在链接时能够正确定位到这些被修正的地址,在代码块(.data)中还存在⼀个重定位表,这张表将来在链接的时候,就会根据表⾥记录的地址将其修正。
整个过程
// code.c
#include<stdio.h>
void run()
{
printf("running...\n");
}
// hello.c
#include<stdio.h>
void run();
int main()
{
printf("hello world!\n");
run();
return 0;
}
过程一:
读取code.o符合表
readelf -s code.o
这里的puts就是printf的实现,UND指puts方法在当前文件(code.o)中未定义。
读取hello.o符合表
readelf -s hello.o
这里的UND run就是指我们的run方法在当前文件(hello.o)中未定义,因为在code.o中。
过程二:
将两个.o文件链接成可执行程序main.exe
gcc *.o -o main.exe
此时读取hello.o符号表
readelf -s main.exe
我们可以看到两个.o进⾏合并之后,在最终的可执⾏程序中,就找到了run。这里的FUNC表示run符号类型是函数,14表示run函数被合并后的section下标。
再读取可执⾏程序最终的所有的section
readelf -S main.exe
事实上hello.o和code.o的.text已经被合并了,是main.exe的第14个section。
那么怎么证明上⾯的说法?
只要观察hello.o或者code.o call后⾯的00 00 00 00有没有被修改成为具体的最终函数地址即可。
过程三:
反汇编查看main.exe
objdump -d main.exe
我们可以看到两个.o的代码段合并到了⼀起,并进⾏了统⼀的编址。
事实上在链接的时候,会修改.o中没有确定的函数地址,在合并完成之后,进⾏相关call地址,完成代码调⽤。
综上:
静态链接就是把库中的.o进⾏合并。
所以链接其实就是将编译之后的所有.o⽂件连同⽤到的⼀些静态库运⾏时库组合,拼装成⼀个独⽴的可执⾏⽂件。其中就包括我们之前提到的地址修正,当所有模块组合在⼀起之后,链接器会根据我们的.o⽂件或者静态库中的重定位表找到那些需要被重定位的函数全局变量,从⽽修正它们的地址。这其实就是静态链接的过程。

所以,链接过程中会涉及到对.o中外部符号进⾏地址重定位。
二、ELF加载与进程地址空间
1、虚拟地址/逻辑地址
- ⼀个ELF程序,在没有被加载到内存的时候,有没有地址呢?
⼀个ELF程序,在没有被加载到内存的时候,本来就有地址,当代计算机⼯作的时候,都采⽤"平坦模式"进⾏⼯作。所以也要求ELF对⾃⼰的代码和数据进⾏统⼀编址。
下⾯是 objdump -S 反汇编之后的代码。

最左侧的就是ELF的虚拟地址,其实,严格意义上应该叫做逻辑地址(起始地址+偏移量),但是我们认为起始地址是0。也就是说,其实虚拟地址在我们的程序还没有加载到内存的时候,就已经把可执⾏程序进⾏统⼀编址了。
- 进程mm_struct、vm_area_struct在进程刚刚创建的时候,初始化数据从哪⾥来的?
从ELF各个segment来,每个segment有⾃⼰的起始地址和⾃⼰的⻓度,⽤来初始化内核结构中的[start,end]等范围数据,另外在⽤详细地址,填充⻚表。
所以:虚拟地址机制,不光光OS要⽀持,编译器也要⽀持。
2、再谈进程虚拟地址空间
ELF在被编译好之后,会把⾃⼰未来程序的⼊⼝地址记录在ELF header的Entry字段中。
读取 ELF 格式文件(main.exe)
readelf -h main.exe

三、动态链接与动态库加载
1、单个进程如何看到库
库函数调用:
- 被进程看到:动态库映射到进程的地址空间
- 被进程调用:在进程的地址空间中进行跳转

2、多个进程如何共享库

注意:动态库中的代码不会重复出现了!
3、动态链接
1)概要
动态链接其实远⽐静态链接要常⽤得多。⽐如我们查看下 main.exe 这个可执⾏程序依赖的动态库,会发现它就⽤到了⼀个c动态链接库:
这⾥的 libc.so 是C语⾔的运⾏时库,⾥⾯提供了常⽤的标准输⼊输出⽂件字符串处理等等这些功能。
那为什么编译器默认不使⽤静态链接呢?静态链接会将编译产⽣的所有⽬标⽂件,连同⽤到的各种库,合并形成⼀个独⽴的可执⾏⽂件,它不需要额外的依赖就可以运⾏。
但静态链接最⼤的问题在于⽣成的⽂件体积⼤,并且相当耗费内存资源。随着软件复杂度的提升,我们的操作系统也越来越臃肿,不同的软件就有可能都包含了相同的功能和代码,显然会浪费⼤量的硬盘空间。
这个时候,动态链接的优势就体现出来了,我们可以将需要共享的代码单独提取出来,保存成⼀个独⽴的动态链接库,等到程序运⾏的时候再将它们加载到内存,这样不但可以节省空间,并且因为同⼀个模块在内存中只需要保留⼀份副本,所以可以被不同的进程所共享。
动态链接到底是如何⼯作的??
动态链接实际上将链接的整个过程推迟到了程序加载的时候。⽐如我们去运⾏⼀个程序,操作系统会⾸先将程序的数据代码连同它⽤到的⼀系列动态库先加载到内存,其中每个动态库的加载地址都是不固定的,操作系统会根据当前地址空间的使⽤情况为它们动态分配⼀段内存。
当动态库被加载到内存以后,⼀旦它的内存地址被确定,我们就可以去修正动态库中的那些函数跳转地址了。
2)可执⾏程序被编译器动了⼿脚
在C/C++程序中,当程序开始执⾏时,它⾸先并不会直接跳转到 main 函数。实际上,程序的⼊⼝点是 _start ,这是⼀个由C运⾏时库(通常是glibc)或链接器(如ld)提供的特殊函数。
在 _start 函数中,会执⾏⼀系列初始化操作,这些操作包括:
-
设置堆栈:为程序创建⼀个初始的堆栈环境。
-
初始化数据段:将程序的数据段(如全局变量和静态变量)从初始化数据段复制到相应的内存位置,并清零未初始化的数据段。
-
动态链接:这是关键的⼀步,
_start函数会调⽤动态链接器的代码来解析和加载程序所依赖的动态库(shared libraries)。动态链接器会处理所有的符号解析和重定位,确保程序中的函数调⽤和变量访问能够正确地映射到动态库中的实际地址。 -
调⽤
_ _libc_start_main:⼀旦动态链接完成,_start函数会调⽤_ _libc_start_main(这是glibc提供的⼀个函数)。_ _libc_start_main函数负责执⾏⼀些额外的初始化⼯作,⽐如设置信号处理函数、初始化线程库(如果使⽤了线程)等。 -
调⽤
main函数:最后,_ _libc_start_main函数会调⽤程序的main函数,此时程序的执⾏控制权才正式交给⽤户编写的代码。 -
处理
main函数的返回值:当main函数返回时,_ _libc_start_main会负责处理这个返回值,并最终调⽤_exit函数来终⽌程序。
上述过程描述了C/C++程序在 main 函数之前执⾏的⼀系列操作,但这些操作对于⼤多数程序员来说是透明的。程序员通常只需要关注 main 函数中的代码,⽽不需要关⼼底层的初始化过程。然⽽,了解这些底层细节有助于更好地理解程序的执⾏流程和调试问题。
动态链接器:
- 动态链接器(如ld-linux.so)负责在程序运⾏时加载动态库。
- 当程序启动时,动态链接器会解析程序中的动态库依赖,并加载这些库到内存中。
环境变量和配置⽂件:
- Linux系统通过环境变量(如LD_LIBRARY_PATH)和配置⽂件(如/etc/ld.so.conf及其⼦配置⽂件)来指定动态库的搜索路径。
- 这些路径会被动态链接器在加载动态库时搜索。
缓存⽂件:
- 为了提⾼动态库的加载效率,Linux系统会维护⼀个名为/etc/ld.so.cache的缓存⽂件。
- 该⽂件包含了系统中所有已知动态库的路径和相关信息,动态链接器在加载动态库时会⾸先搜索这个缓存⽂件。
3)动态库中的相对地址
动态库为了随时进⾏加载,为了⽀持并映射到任意进程的任意位置,对动态库中的⽅法,统⼀编址,采⽤相对编址的⽅案进⾏编制的(其实可执⾏程序也⼀样,都要遵守平坦模式,只不过exe是直接加载的)。

#Cetnos下查看任意一个库的反汇编
objdump -S /lib64/libc-2.17.so | less
4)程序怎么和库具体映射起来的
- 动态库也是⼀个⽂件,要访问也是要被先加载,要加载也是要被打开的。
- 让我们的进程找到动态库的本质:也是⽂件操作,不过我们访问库函数,通过虚拟地址进⾏跳转访问的,所以需要把动态库映射到进程的地址空间中。

5)程序怎么进⾏库函数调⽤
- 库已经被我们映射到了当前进程的地址空间中
- 库的虚拟起始地址我们也已经知道了
- 库中每⼀个⽅法的偏移量地址我们也知道
- 所以访问库中任意⽅法,只需要知道库的起始虚拟地址+⽅法偏移量即可定位库中的⽅法
- ⽽且:整个调⽤过程,是从代码区跳转到共享区,调⽤完毕在返回到代码区,整个过程完全在进程地址空间中进⾏的。

6)全局偏移量表GOT(global offset table)
-
我们的程序运⾏之前,先把所有库加载并映射,所有库的起始虚拟地址都应该提前知道。
-
然后对我们加载到内存中的程序的库函数调⽤进⾏地址修改,在内存中⼆次完成地址设置(这个叫做加载地址重定位)。
-
等等,修改的是代码区?不是说代码区在进程中是只读的吗?怎么修改?能修改吗?
所以:动态链接采⽤的做法是在 .data (可执⾏程序或者库⾃⼰)中专⻔预留⼀⽚区域⽤来存放函数的跳转地址,它也被叫做全局偏移表GOT,表中每⼀项都是本运⾏模块要引⽤的⼀个全局变量或函数的地址。
- 因为
.data区域是可读写的,所以可以⽀持动态进⾏修改
readelf -S a.out
...
[24] .got PROGBITS 0000000000003fb8 00002fb8
0000000000000048 0000000000000008 WA 0 0 8
...
$ readelf -l a.out # .got在加载的时候,会和.data合并成为⼀个segment,然后加载在⼀起 ...
05 .init_array .fini_array .dynamic .got .data .bss
...

-
由于代码段只读,我们不能直接修改代码段。但有了GOT表,代码便可以被所有进程共享。但在不同进程的地址空间中,各动态库的绝对地址、相对位置都不同。反映到GOT表上,就是每个进程的每个动态库都有独⽴的GOT表,所以进程间不能共享GOT表。
-
在单个
.so下,由于GOT表与.text的相对位置是固定的,我们完全可以利⽤CPU的相对寻址来找到GOT表。 -
在调⽤函数的时候会⾸先查表,然后根据表中的地址来进⾏跳转,这些地址在动态库加载的时候会被修改为真正的地址。
-
这种⽅式实现的动态链接就被叫做 PIC 地址⽆关代码 。换句话说,我们的动态库不需要做任何修改,被加载到任意内存地址都能够正常运⾏,并且能够被所有进程共享,这也是为什么之前我们给编译器指定-fPIC参数的原因,PIC=相对编址+GOT。

7)库间依赖
-
不仅仅有可执⾏程序调⽤库。
-
库也会调⽤其他库!!库之间是有依赖的,如何做到库和库之间互相调⽤也是与地址⽆关的呢??
-
库中也有.GOT,和可执⾏程序⼀样!这也就是为什么⼤家为什么都是ELF的格式!

由于GOT表中的映射地址会在运⾏时去修改,我们可以通过gdb调试去观察GOT表的地址变化。
- 由于动态链接在程序加载的时候需要对⼤量函数进⾏重定位,这⼀步显然是⾮常耗时的。为了进⼀步降低开销,我们的操作系统还做了⼀些其他的优化,⽐如延迟绑定,或者也叫PLT(过程连接表(Procedure Linkage Table))。与其在程序⼀开始就对所有函数进⾏重定位,不如将这个过程推迟到函数第⼀次被调⽤的时候,因为绝⼤多数动态库中的函数可能在程序运⾏期间⼀次都不会被使⽤到。
思路是:GOT中的跳转地址默认会指向⼀段辅助代码,它也被叫做桩代码/stup。在我们第⼀次调⽤函数的时候,这段代码会负责查询真正函数的跳转地址,并且去更新GOT表。于是我们再次调⽤函数的时候,就会直接跳转到动态库中真正的函数实现。
总⽽⾔之,动态链接实际上将链接的整个过程,⽐如符号查询、地址的重定位从编译时推迟到了程序的运⾏时,它虽然牺牲了⼀定的性能和程序加载时间,但绝对是物有所值的。因为动态链接能够更有效的利⽤磁盘空间和内存资源,以极⼤⽅便了代码的更新和维护,更关键的是,它实现了⼆进制级别的代码复⽤。
解析依赖关系的时候,就是加载并完善互相之间的GOT表的过程。
四、总结
-
静态链接的出现,提⾼了程序的模块化⽔平。对于⼀个⼤的项⽬,不同的⼈可以独⽴地测试和开发⾃⼰的模块。通过静态链接,⽣成最终的可执⾏⽂件。
-
我们知道静态链接会将编译产⽣的所有⽬标⽂件,和⽤到的各种库合并成⼀个独⽴的可执⾏⽂件,其中我们会去修正模块间函数的跳转地址,也被叫做编译重定位(也叫做静态重定位)。
-
⽽动态链接实际上将链接的整个过程推迟到了程序加载的时候。⽐如我们去运⾏⼀个程序,操作系统会⾸先将程序的数据代码连同它⽤到的⼀系列动态库先加载到内存,其中每个动态库的加载地址都是不固定的,但是⽆论加载到什么地⽅,都要映射到进程对应的地址空间,然后通过.GOT⽅式进⾏调⽤(运⾏重定位,也叫做动态地址重定位)。
142



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



