Linux系统——库的原理与制作之ELF文件的形成与加载的过程(下)

作者:进击的荆棘日期:2026/10/14

● 💁‍♂️个人主页:进击的荆棘

👇作者其它专栏:

《数据结构与算法》《算法》《C++起始之路》《Linux》


目录

1.什么是库

2.静态库

3.动态库

4.使用外部库

5.目标文件

6.ELF文件

7.ELF从形成到加载轮廓

8.理解链接与加载

附录:操作大全


8.理解链接与加载

8.1静态链接

1#读取可执行程序最终的所有的section清单
2[sjx@VM-0-6-centos test]$ readelf -S main.exe
3There are 30 section headers, starting at offset 0x1960:
4
5Section Headers:
6  [Nr] Name              Type             Address           Offset
7       Size              EntSize          Flags  Link  Info  Align
8  [ 0]                   NULL             0000000000000000  00000000
9       0000000000000000  0000000000000000           0     0     0
10  [ 1] .interp           PROGBITS         0000000000400238  00000238
11       000000000000001c  0000000000000000   A       0     0     1
12  [ 2] .note.ABI-tag     NOTE             0000000000400254  00000254
13       0000000000000020  0000000000000000   A       0     0     4
14  [ 3] .note.gnu.build-i NOTE             0000000000400274  00000274
15       0000000000000024  0000000000000000   A       0     0     4
16  [ 4] .gnu.hash         GNU_HASH         0000000000400298  00000298
17       000000000000001c  0000000000000000   A       5     0     8
18  [ 5] .dynsym           DYNSYM           00000000004002b8  000002b8
19       0000000000000060  0000000000000018   A       6     1     8
20  [ 6] .dynstr           STRTAB           0000000000400318  00000318
21       000000000000003d  0000000000000000   A       0     0     1
22  [ 7] .gnu.version      VERSYM           0000000000400356  00000356
23       0000000000000008  0000000000000002   A       5     0     2
24  [ 8] .gnu.version_r    VERNEED          0000000000400360  00000360
25       0000000000000020  0000000000000000   A       6     1     8
26  [ 9] .rela.dyn         RELA             0000000000400380  00000380
27       0000000000000018  0000000000000018   A       5     0     8
28  [10] .rela.plt         RELA             0000000000400398  00000398
29       0000000000000048  0000000000000018  AI       5    23     8
30  [11] .init             PROGBITS         00000000004003e0  000003e0
31       000000000000001a  0000000000000000  AX       0     0     4
32  [12] .plt              PROGBITS         0000000000400400  00000400
33       0000000000000040  0000000000000010  AX       0     0     16
34  [13] .text             PROGBITS         0000000000400440  00000440
35       0000000000000192  0000000000000000  AX       0     0     16
36  [14] .fini             PROGBITS         00000000004005d4  000005d4
37       0000000000000009  0000000000000000  AX       0     0     4
38  [15] .rodata           PROGBITS         00000000004005e0  000005e0
39       000000000000002b  0000000000000000   A       0     0     8
40  [16] .eh_frame_hdr     PROGBITS         000000000040060c  0000060c
41       000000000000003c  0000000000000000   A       0     0     4
42  [17] .eh_frame         PROGBITS         0000000000400648  00000648
43       0000000000000114  0000000000000000   A       0     0     8
44  [18] .init_array       INIT_ARRAY       0000000000600e10  00000e10
45       0000000000000008  0000000000000008  WA       0     0     8
46  [19] .fini_array       FINI_ARRAY       0000000000600e18  00000e18
47       0000000000000008  0000000000000008  WA       0     0     8
48  [20] .jcr              PROGBITS         0000000000600e20  00000e20
49       0000000000000008  0000000000000000  WA       0     0     8
50  [21] .dynamic          DYNAMIC          0000000000600e28  00000e28
51       00000000000001d0  0000000000000010  WA       6     0     8
52  [22] .got              PROGBITS         0000000000600ff8  00000ff8
53       0000000000000008  0000000000000008  WA       0     0     8
54  [23] .got.plt          PROGBITS         0000000000601000  00001000
55       0000000000000030  0000000000000008  WA       0     0     8
56  [24] .data             PROGBITS         0000000000601030  00001030
57       0000000000000004  0000000000000000  WA       0     0     1
58  [25] .bss              NOBITS           0000000000601034  00001034
59       0000000000000004  0000000000000000  WA       0     0     1
60  [26] .comment          PROGBITS         0000000000000000  00001034
61       000000000000002d  0000000000000001  MS       0     0     1
62  [27] .symtab           SYMTAB           0000000000000000  00001068
63       0000000000000618  0000000000000018          28    47     8
64  [28] .strtab           STRTAB           0000000000000000  00001680
65       00000000000001d5  0000000000000000           0     0     1
66  [29] .shstrtab         STRTAB           0000000000000000  00001855
67       0000000000000108  0000000000000000           0     0     1
68Key to Flags:
69  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
70  L (link order), O (extra OS processing required), G (group), T (TLS),
71  C (compressed), x (unknown), o (OS specific), E (exclude),
72  l (large), p (processor specific)
73#main.o和code.o的.text被合并了,是main.exe的第13个section
74
75#如何证明上面的说法?
76#关于main.o或code.o call后面的00 00 00 00 有没有被修改成为具体的最终函数地址?
77[sjx@VM-0-6-centos test]$ objdump -d main.exe    #反汇编main.exe只查看代码段信息,包含源代码
78
79main.exe:     file format elf64-x86-64
80
81
82Disassembly of section .init:
83
8400000000004003e0 <_init>:
85  4003e0:	48 83 ec 08          	sub    $0x8,%rsp
86  4003e4:	48 8b 05 0d 0c 20 00 	mov    0x200c0d(%rip),%rax        # 600ff8 <__gmon_start__>
87  4003eb:	48 85 c0             	test   %rax,%rax
88  4003ee:	74 05                	je     4003f5 <_init+0x15>
89  4003f0:	e8 3b 00 00 00       	callq  400430 <__gmon_start__@plt>
90  4003f5:	48 83 c4 08          	add    $0x8,%rsp
91  4003f9:	c3                   	retq   
92
93Disassembly of section .plt:
94
950000000000400400 <.plt>:
96  400400:	ff 35 02 0c 20 00    	pushq  0x200c02(%rip)        # 601008 <_GLOBAL_OFFSET_TABLE_+0x8>
97  400406:	ff 25 04 0c 20 00    	jmpq   *0x200c04(%rip)        # 601010 <_GLOBAL_OFFSET_TABLE_+0x10>
98  40040c:	0f 1f 40 00          	nopl   0x0(%rax)
99
1000000000000400410 <puts@plt>:
101  400410:	ff 25 02 0c 20 00    	jmpq   *0x200c02(%rip)        # 601018 <puts@GLIBC_2.2.5>
102  400416:	68 00 00 00 00       	pushq  $0x0
103  40041b:	e9 e0 ff ff ff       	jmpq   400400 <.plt>
104
1050000000000400420 <__libc_start_main@plt>:
106  400420:	ff 25 fa 0b 20 00    	jmpq   *0x200bfa(%rip)        # 601020 <__libc_start_main@GLIBC_2.2.5>
107  400426:	68 01 00 00 00       	pushq  $0x1
108  40042b:	e9 d0 ff ff ff       	jmpq   400400 <.plt>
109
1100000000000400430 <__gmon_start__@plt>:
111  400430:	ff 25 f2 0b 20 00    	jmpq   *0x200bf2(%rip)        # 601028 <__gmon_start__>
112  400436:	68 02 00 00 00       	pushq  $0x2
113  40043b:	e9 c0 ff ff ff       	jmpq   400400 <.plt>
114
115Disassembly of section .text:
116
1170000000000400440 <_start>:
118  400440:	31 ed                	xor    %ebp,%ebp
119  400442:	49 89 d1             	mov    %rdx,%r9
120  400445:	5e                   	pop    %rsi
121  400446:	48 89 e2             	mov    %rsp,%rdx
122  400449:	48 83 e4 f0          	and    $0xfffffffffffffff0,%rsp
123  40044d:	50                   	push   %rax
124  40044e:	54                   	push   %rsp
125  40044f:	49 c7 c0 d0 05 40 00 	mov    $0x4005d0,%r8
126  400456:	48 c7 c1 60 05 40 00 	mov    $0x400560,%rcx
127  40045d:	48 c7 c7 3d 05 40 00 	mov    $0x40053d,%rdi
128  400464:	e8 b7 ff ff ff       	callq  400420 <__libc_start_main@plt>
129  400469:	f4                   	hlt    
130  40046a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
131
1320000000000400470 <deregister_tm_clones>:
133  400470:	b8 3f 10 60 00       	mov    $0x60103f,%eax
134  400475:	55                   	push   %rbp
135  400476:	48 2d 38 10 60 00    	sub    $0x601038,%rax
136  40047c:	48 83 f8 0e          	cmp    $0xe,%rax
137  400480:	48 89 e5             	mov    %rsp,%rbp
138  400483:	77 02                	ja     400487 <deregister_tm_clones+0x17>
139  400485:	5d                   	pop    %rbp
140  400486:	c3                   	retq   
141  400487:	b8 00 00 00 00       	mov    $0x0,%eax
142  40048c:	48 85 c0             	test   %rax,%rax
143  40048f:	74 f4                	je     400485 <deregister_tm_clones+0x15>
144  400491:	5d                   	pop    %rbp
145  400492:	bf 38 10 60 00       	mov    $0x601038,%edi
146  400497:	ff e0                	jmpq   *%rax
147  400499:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
148
14900000000004004a0 <register_tm_clones>:
150  4004a0:	b8 38 10 60 00       	mov    $0x601038,%eax
151  4004a5:	55                   	push   %rbp
152  4004a6:	48 2d 38 10 60 00    	sub    $0x601038,%rax
153  4004ac:	48 c1 f8 03          	sar    $0x3,%rax
154  4004b0:	48 89 e5             	mov    %rsp,%rbp
155  4004b3:	48 89 c2             	mov    %rax,%rdx
156  4004b6:	48 c1 ea 3f          	shr    $0x3f,%rdx
157  4004ba:	48 01 d0             	add    %rdx,%rax
158  4004bd:	48 d1 f8             	sar    %rax
159  4004c0:	75 02                	jne    4004c4 <register_tm_clones+0x24>
160  4004c2:	5d                   	pop    %rbp
161  4004c3:	c3                   	retq   
162  4004c4:	ba 00 00 00 00       	mov    $0x0,%edx
163  4004c9:	48 85 d2             	test   %rdx,%rdx
164  4004cc:	74 f4                	je     4004c2 <register_tm_clones+0x22>
165  4004ce:	5d                   	pop    %rbp
166  4004cf:	48 89 c6             	mov    %rax,%rsi
167  4004d2:	bf 38 10 60 00       	mov    $0x601038,%edi
168  4004d7:	ff e2                	jmpq   *%rdx
169  4004d9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
170
17100000000004004e0 <__do_global_dtors_aux>:
172  4004e0:	80 3d 4d 0b 20 00 00 	cmpb   $0x0,0x200b4d(%rip)        # 601034 <_edata>
173  4004e7:	75 11                	jne    4004fa <__do_global_dtors_aux+0x1a>
174  4004e9:	55                   	push   %rbp
175  4004ea:	48 89 e5             	mov    %rsp,%rbp
176  4004ed:	e8 7e ff ff ff       	callq  400470 <deregister_tm_clones>
177  4004f2:	5d                   	pop    %rbp
178  4004f3:	c6 05 3a 0b 20 00 01 	movb   $0x1,0x200b3a(%rip)        # 601034 <_edata>
179  4004fa:	f3 c3                	repz retq 
180  4004fc:	0f 1f 40 00          	nopl   0x0(%rax)
181
1820000000000400500 <frame_dummy>:
183  400500:	48 83 3d 18 09 20 00 	cmpq   $0x0,0x200918(%rip)        # 600e20 <__JCR_END__>
184  400507:	00 
185  400508:	74 1e                	je     400528 <frame_dummy+0x28>
186  40050a:	b8 00 00 00 00       	mov    $0x0,%eax
187  40050f:	48 85 c0             	test   %rax,%rax
188  400512:	74 14                	je     400528 <frame_dummy+0x28>
189  400514:	55                   	push   %rbp
190  400515:	bf 20 0e 60 00       	mov    $0x600e20,%edi
191  40051a:	48 89 e5             	mov    %rsp,%rbp
192  40051d:	ff d0                	callq  *%rax
193  40051f:	5d                   	pop    %rbp
194  400520:	e9 7b ff ff ff       	jmpq   4004a0 <register_tm_clones>
195  400525:	0f 1f 00             	nopl   (%rax)
196  400528:	e9 73 ff ff ff       	jmpq   4004a0 <register_tm_clones>
197
198000000000040052d <test>:
199  40052d:	55                   	push   %rbp
200  40052e:	48 89 e5             	mov    %rsp,%rbp
201  400531:	bf f0 05 40 00       	mov    $0x4005f0,%edi
202  400536:	e8 d5 fe ff ff       	callq  400410 <puts@plt>
203  40053b:	5d                   	pop    %rbp
204  40053c:	c3                   	retq   
205
206000000000040053d <main>:
207  40053d:	55                   	push   %rbp
208  40053e:	48 89 e5             	mov    %rsp,%rbp
209  400541:	b8 00 00 00 00       	mov    $0x0,%eax
210  400546:	e8 e2 ff ff ff       	callq  40052d <test>
211  40054b:	bf ff 05 40 00       	mov    $0x4005ff,%edi
212  400550:	e8 bb fe ff ff       	callq  400410 <puts@plt>
213  400555:	5d                   	pop    %rbp
214  400556:	c3                   	retq   
215  400557:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
216  40055e:	00 00 
217
2180000000000400560 <__libc_csu_init>:
219  400560:	41 57                	push   %r15
220  400562:	41 89 ff             	mov    %edi,%r15d
221  400565:	41 56                	push   %r14
222  400567:	49 89 f6             	mov    %rsi,%r14
223  40056a:	41 55                	push   %r13
224  40056c:	49 89 d5             	mov    %rdx,%r13
225  40056f:	41 54                	push   %r12
226  400571:	4c 8d 25 98 08 20 00 	lea    0x200898(%rip),%r12        # 600e10 <__frame_dummy_init_array_entry>
227  400578:	55                   	push   %rbp
228  400579:	48 8d 2d 98 08 20 00 	lea    0x200898(%rip),%rbp        # 600e18 <__init_array_end>
229  400580:	53                   	push   %rbx
230  400581:	4c 29 e5             	sub    %r12,%rbp
231  400584:	31 db                	xor    %ebx,%ebx
232  400586:	48 c1 fd 03          	sar    $0x3,%rbp
233  40058a:	48 83 ec 08          	sub    $0x8,%rsp
234  40058e:	e8 4d fe ff ff       	callq  4003e0 <_init>
235  400593:	48 85 ed             	test   %rbp,%rbp
236  400596:	74 1e                	je     4005b6 <__libc_csu_init+0x56>
237  400598:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
238  40059f:	00 
239  4005a0:	4c 89 ea             	mov    %r13,%rdx
240  4005a3:	4c 89 f6             	mov    %r14,%rsi
241  4005a6:	44 89 ff             	mov    %r15d,%edi
242  4005a9:	41 ff 14 dc          	callq  *(%r12,%rbx,8)
243  4005ad:	48 83 c3 01          	add    $0x1,%rbx
244  4005b1:	48 39 eb             	cmp    %rbp,%rbx
245  4005b4:	75 ea                	jne    4005a0 <__libc_csu_init+0x40>
246  4005b6:	48 83 c4 08          	add    $0x8,%rsp
247  4005ba:	5b                   	pop    %rbx
248  4005bb:	5d                   	pop    %rbp
249  4005bc:	41 5c                	pop    %r12
250  4005be:	41 5d                	pop    %r13
251  4005c0:	41 5e                	pop    %r14
252  4005c2:	41 5f                	pop    %r15
253  4005c4:	c3                   	retq   
254  4005c5:	90                   	nop
255  4005c6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
256  4005cd:	00 00 00 
257
25800000000004005d0 <__libc_csu_fini>:
259  4005d0:	f3 c3                	repz retq 
260
261Disassembly of section .fini:
262
26300000000004005d4 <_fini>:
264  4005d4:	48 83 ec 08          	sub    $0x8,%rsp
265  4005d8:	48 83 c4 08          	add    $0x8,%rsp
266  4005dc:	c3                   	retq  
267
268最终:
2691.两个.o的代码段合并到了一起,并进行了统一的编址
2702.链接的时候,会修改.o中没有确定的函数地址,在合并完成之后,进行相关call地址,完成代码调用

静态链接就是把库中的.o进行合并,和上述过程一致

所以链接其实就是将编译之后的所有目标文件连同用到的一些静态库运行时库结合,拼装成一个独立的可执行文件。其中就包括之前提到的地址修正,当所有模块组合在一起之后,链接器会根据我们的.o文件或静态库中的重定位表找到那些需要被重定位的函数全局变量,从而修正它们的地址。这就是静态链接的过程

​

所以,链接过程中会对.o中外部符号进行地址重定位

8.2ELF加载与进程地址空间

8.2.1虚拟地址/逻辑地址

问题:

●一个ELF程序,在没有被加载到内存的时候,有无地址?

●进程mm_struct、vm_area_struct在进程刚刚创建的时候,初始化数据从哪来?

答案:

●一个ELF程序,在没有被加载到内存的时候,本来就有地址(虚拟内存地址,不是物理地址),当代计算机工作的时候,都采用“平坦模式”进行工作。所有页要求ELF对自己的代码和数据进行统一编址,下面是objdump -d反汇编之后的代码

​

最左侧的就是ELF的虚拟地址,严格意义上叫做逻辑地址(其实地址+偏移量),但是我们认为其实地址是0,所以虚拟地址在程序还没有加载到内存的时候,就已经把可执行程序进行统一编址了

●进程mm_struct、vm_area_struct在进程刚刚创建的时候,初始化数据从哪来?从ELF各个segment来,每个segment有自己的起始地址和自己的长度,用来初始化内核结构中的[start,end]等范围数据,另外在用详细地址,填充页表

所以:虚拟地址机制,不光光OS要支持,编译器也要支持

8.2.2重新理解进程虚拟地址空间

ELF在被编译好之后,会把自己未来程序的入口地址记录在ELF header的Entry字段中:

1[sjx@VM-0-6-centos test]$ readelf -h main.exe
2ELF Header:
3  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
4  Class:                             ELF64
5  Data:                              2's complement, little endian
6  Version:                           1 (current)
7  OS/ABI:                            UNIX - System V
8  ABI Version:                       0
9  Type:                              EXEC (Executable file)
10  Machine:                           Advanced Micro Devices X86-64
11  Version:                           0x1
12  Entry point address:               0x400440
13  Start of program headers:          64 (bytes into file)
14  Start of section headers:          6496 (bytes into file)
15  Flags:                             0x0
16  Size of this header:               64 (bytes)
17  Size of program headers:           56 (bytes)
18  Number of program headers:         9
19  Size of section headers:           64 (bytes)
20  Number of section headers:         30
21  Section header string table index: 29
22

8.3动态链接与动态库加载

8.3.1进程如何看到动态库

8.3.2进程间是如何看到共享库的

8.3.3动态链接

8.3.3.1概要

动态链接远比静态链接要常用的多。下面这个main.exe可执行程序依赖的动态库就用到了一个C动态链接库:

1[sjx@VM-0-6-centos ~]$ ldd main.exe
2	linux-vdso.so.1 =>  (0x00007ffc08db8000)
3	libc.so.6 => /lib64/libc.so.6 (0x00007fd39c648000)
4	/lib64/ld-linux-x86-64.so.2 (0x00007fd39ca16000)
5# ldd命令用于打印程序或库文件所依赖的共享库列表

libc.so是C的运行时库,里面提供了常用的标准输入输出文件字符串处理等功能

为什么编译器默认不适用静态链接?静态链接会将编译产生的所有目标文件,连同用到的各种库,合并形成一个独立的可执行文件,不需要额外的依赖就可以运行。照理说应该更加方便?

**静态链接最大的问题在于生成的文件体积大,且相当耗费内存资源。**随着软件复杂度的提升,操作系统也越来越臃肿,不同的软件就有可能都包含了相同的功能和代码,显然会浪费大量的硬盘空间。

此时,动态链接就显现了它的优势,我们可以将需要共享的代码单独提取出来,保存成一个独立的动态链接库,等到程序运行时再将它们加载到内存,这样就可以节省空间,因为同一个模块再内存中只需要保留一份副本,可以被不同的进程所共享。

动态链接如何工作?

**动态链接实际上将链接的整个过程推迟到了程序加载的时候。**当我们去运行一个程序,操作系统会首先将程序的数据代码连同它用到的一系列动态库先加载到内存,其中每个动态库的加载地址都是不固定的,操作系统会根据当前地址空间的使用情况为它们动态分配一段内存。

当动态库被加载到内存以后,一旦它的内存地址被确定,就可以去修正动态库中的那些函数跳转地址了

8.3.3.2我们的可执行程序被编译器动了手脚
1[sjx@VM-0-6-centos ~]$ ldd /usr/bin/ls
2	linux-vdso.so.1 =>  (0x00007ffc6dd50000)
3	libselinux.so.1 => /lib64/libselinux.so.1 (0x00007f6b67cf5000)
4	libcap.so.2 => /lib64/libcap.so.2 (0x00007f6b67af0000)
5	libacl.so.1 => /lib64/libacl.so.1 (0x00007f6b678e7000)
6	libc.so.6 => /lib64/libc.so.6 (0x00007f6b67519000)
7	libpcre.so.1 => /lib64/libpcre.so.1 (0x00007f6b672b7000)
8	libdl.so.2 => /lib64/libdl.so.2 (0x00007f6b670b3000)
9	/lib64/ld-linux-x86-64.so.2 (0x00007f6b67f1c000)
10	libattr.so.1 => /lib64/libattr.so.1 (0x00007f6b66eae000)
11	libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f6b66c92000)
12[sjx@VM-0-6-centos ~]$ ldd main.exe
13	linux-vdso.so.1 =>  (0x00007ffe1df2f000)
14	libc.so.6 => /lib64/libc.so.6 (0x00007f2df9fc2000)
15	/lib64/ld-linux-x86-64.so.2 (0x00007f2dfa390000)
16

在C/C++程序中,当程序开始执行时,它首先并不会直接跳转到main函数。实际上,程序的入口点是_start,这是一个由C运行时库(通常是glibc)或链接器(如ld)提供的特殊函数。

在_start函数中,会执行一系列初始化操作,包括:

1.设置堆栈:为程序创建一个初始的堆栈环境

2.初始化数据段:将程序的数据段(如全局变量和静态变量)从初始化数据段复制到相应的内存位置,并清零未初始化的数据段

3.动态链接:关键一步,_start函数会调用动态链接器的代码来解析和加载程序所依赖的动态库(shared libraries)。动态链接器会处理所有的符号解析和重定位,确保程序中的函数调用和变量访问能够正确地映射到动态库中的实际地址

动态链接器:

●动态链接器(如ld-linux.so)负责在重新运行时加载动态库

●当程序启动时,,动态链接器会解析程序中的动态库依赖,并加载这些库到内存中

环境变量和配置文件:

●Linux系统通过环境变量(如LD_LIBRARY_PATH)和配置文件(如/etc/ld.so.conf及其子配置文件)来指定动态库的搜索路径

●这些路径会被动态链接器在加载动态库时搜索

缓存文件:

●为提高动态库的加载效率,Linux系统会维护一个名为/etc/ld.so.cache的缓存文件

●该文件包含了系统中所有已知动态库的路径和相关信息,动态链接器在加载动态库时会首先搜索这个缓存文件

4.调用__libc_start_main:一旦动态链接完成,_start函数会调用__libc_start_main(这是glibc提供的一个函数)。__libc_start_main函数负责执行一些额外的初始化工作,如设置信号处理函数、初始化线程库(若使用了线程)等

5.调用main函数:最好__libc_start_main函数会调用main函数,此时程序的执行控制权才正式交给用户编写的代码

6.处理main函数的返回值:当main函数返回时,__libc_start_main会负责处理这个返回只,并最终调用_exit函数终止程序

上述过程描述了C/C++程序在main函数之前执行的一系列操作,但这些操作对大多数程序员来说是透明的。程序员通常只需要关注main函数中的代码,而不需要关心底层的初始化过程。然而,了解底层细节有助于更好的理解程序的执行流程和调试问题

8.3.3.3动态库中的相对地址

动态库为了随时进行加载,为了支持并映射到任意进程的任意位置,对动态库中的方法,统一编址,采用相对编址的方案进行编址(其实可执行程序也一样,都要遵守平坦模式,只不过exe是直接加载的)

# ubuntu下查看任意⼀个库的反汇编

objdump -S /lib/x86_64-linux-gnu/libc-2.31.so | less

# Cetnos下查看任意⼀个库的反汇编

$ objdump -S /lib64/libc-2.17.so | less

8.3.3.4我们的程序是如何与库具体映射起来的

注:

●动态库也是一个文件,要访问也是要被先加载,要加载也是要被打开的

●让我们的进程找到动态库的本质:也是文件操作,不过我们访问库函数,通过虚拟地址进行跳转访问,所有需要把动态库映射到进程的地址空间中

8.3.3.5我们的程序如何进行库函数调用

注:

●库已经被映射到了当前进程的地址空间中

●库的虚拟起始地址我们也已经知道了

●库中每一个方法的偏移量也知道了

●所以:访问库中任意方法,只需要知道库的起始虚拟地址+方法偏移量即可定位库中的方法

●而且:整个调用过程,是从代码区跳转到共享区,调用完毕再返回到代码区,整个过程完全在进程地址空间中进行

8.3.3.6全局偏移量表GOT(global offset table)

注:

●由于我们的程序运行之前,先把所有库加载并映射,所以库的起始虚拟地址都应该提前知道

●然后对我们加载到内存中的程序的库函数调用进行地址修改,在内存中二次完成地址设置(加载地址重定位)

●注意到,修改的是代码区,不是说代码区在进程中是只读的吗?能修改吗?如何修改?

所以:动态链接采用的做法是在.data(可执行程序或库自己)中专门预留一片区域用来存放函数的跳转地址,被叫做全局偏移表GOT,表中每一项都是本运行模块要引用的一个全局变量或函数的地址

●因为.data区域是可读写,所以可以支持动态进行修改

1$ readelf -S a.out
2...
3[24] .got PROGBITS 0000000000003fb8 00002fb8
40000000000000048 0000000000000008 WA 0 0 8
5...
6$ readelf -l a.out # .got在加载的时候,会和.data合并成为⼀个segment,然后加载在⼀起
7...
805 .init_array .fini_array .dynamic .got .data .bss
9...
10

1.由于代码段只读,不能直接修改代码段。但有了GOT表,代码便可以被所有进程共享。但在不同进程的地址空间中,各动态库的绝对地址、相对位置都不同。反映到GOT表上,就是每个进程的每个动态位都有独立的GOT表,所以进程间不能共享GOT表

2.在单个.so下,由于GOT表与.text的相对位置是固定的,完全可以利用CPU的相对寻址来找到GOT表

3.在调用函数的时候会首先查表,然后根据表中的地址来进行跳转,这些地址在动态库加载的时候会被修改为真正的地址

4.这种方式实现的动态链接就被叫做PIC地址无关码。即动态库不需要做任何修改,被加载到任意内存地址都能够正常运行,并且能够被所有进程共享,这就是为什么之前需要指定编译器-fPIC参数的原因,PIC=相对编址+GOT

8.3.3.7库间依赖

注:

●不仅仅有可执行程序调用库

●库也会调用其他库。库之间是有依赖的,如何做到库和库之间相互调用也是与地址无关的?

●库中也有.GOT和可执行一样。这就是为什么都是ELF的格式

由于GOT表中的映射地址会在运行时区修改,可以通过gdb调试去观察GOT表的地址变化。

详细内容可以了解使用gdb调试GOT

●由于动态链接在程序加载的时候需要对大量函数进行重定位,这显然是非常耗时的。为进一步降低开销,操作系统做出一些优化,如:延迟绑定,也叫PLT(过程连接表(PRocedure Linkage Table))。与其在程序已开始就对所有函数进行重定位,不如将这个过程推迟到函数第一次被调用的时候,因为绝大多数动态库中的函数可能在程序运行期间一次都不会被使用到

GOT中的跳转地址默认会指向一段辅助代码,它也被叫做桩代码/stup。在我们第一次调用函数的时候,这段代码会负责查询真正函数的跳转地址,并且去更新GOT表。于是我们再次调用函数的时候,就会直接跳转到动态库中真正的函数实现

动态链接实际上将链接的整个过程,如符号查询、地址的重定位从编译时推迟到了程序的运行时,虽然牺牲了一定的性能和程序加载时间,但是值得。因为动态链接能够更有效的利用磁盘空间和内存资源,极大方便了代码的更新和维护,更关键的是,它实现了二进制级别的代码复用。

解析依赖关系的时候,就是加载并完善互相之间的GOT表的过程

8.3.4总结

●静态链接的出现,提高了程序的模块化水平。对于一个大的项目,不同的人可以独立地测试和开发自己的模块。通过静态链接,生成最终的可执行文件。

●静态链接会将编译产生的所有目标文件和用到的各种库合并成一个独立的可执行文件,其中我们会去修正模块间函数的跳转地址,也被叫做编译重定位(静态重定位)

●动态链接实际上将链接的整个过程推迟到了程序加载的时候。如我们运行一个程序,操作系统会首先将程序的数据代码连同它用到的一系列动态库先加载到内存,其中每个动态库的加载地址都是不固定的,但是无论加载到什么地方,都要映射到进程对应的地址空间,然后通过.GOT方式进行调用(运行重定位,也叫动态地址重定位)


参考文档


《Linux系统——库的原理与制作之ELF文件的形成与加载的过程(下)》 是转载文章,点击查看原文。


相关推荐


【AI开发之Rust】第 18 课:SQLite 持久化与本地缓存 —— 给 store 填上真实现
悟空聊AI2026/10/5

18.1 这节课解决什么问题 第 17 课的 HistoryStore 还是内存假实现——App 一重启历史全丢。本课把它换成 SQLite 本地数据库,回答三件事: ① rusqlite:怎么连、怎么建表、怎么读写(参数化查询防注入) ② 表结构 & 迁移:schema 版本升级不丢数据 ③ 把 sqlite 实现塞回 core:服务层测试一行不改(17 课接口红利的兑现) 同时处理 SQLite 在真实 App 里最常见的"最后 20%":忙锁(database is locked)、连接


风险审计岗位数据分析能力要求:Excel、SQL、Power BI怎么准备
cspttty2026/9/29

一、风险审计岗位的核心加分项,不是会背准则,而是能发现业务风险 (一)前程无忧2026校园招聘白皮书显示,专业服务类岗位看重专业知识、问题解决能力、沟通能力、独立思考能力和执行力。 风险审计岗位不是单纯查账,而是围绕采购、销售、费用、合同、权限、库存、资金等流程,判断哪里可能失控、违规或低效。对2027届学生来说,简历上最有说服力的不是写熟悉审计,而是能写清楚自己做过什么风险识别动作。 1. 具体日常工作任务可以这样理解 月初从ERP或财务系统导出上月费用报销明细,用Excel透视表


GitLab+Jenkins CI-CD自动化部署实战
蓝胖的四次元口袋2026/9/21

作者:没有四次元口袋的蓝胖 日期:2026-09-15 标签:CI/CD, GitLab, Jenkins, DevOps 写在前面 这是一篇 CI/CD 自动化部署实战记录。从 GitLab 代码托管、分支规范制定,到 Jenkins 自动化构建部署,完整记录了团队从零搭建 CI/CD 流水线的全过程。 一、项目背景 团队之前的部署流程:每次代码提交后,需要 手动登录服务器 → mvn clean package → 上传 jar/war 包 → 重启 Tomcat,流程繁琐且容易出错。


uni-app 安卓自有证书完全指南
90后晨仔2026/9/13

本文参考 DCloud 官方文档《Android平台签名证书(.keystore)生成指南》(ask.dcloud.net.cn/article/357… Oracle 官方 keytool 文档与 Android 签名机制原理整理而成。 一、核心前提:Android 只需要一套自有证书 在 Android 平台,签名的规则非常明确:同一个包名(Package Name)的应用,必须使用同一个证书签名,才能覆盖安装和更新。如果包名相同但签名不同,Android 系统会在安装时报错,用户必须先卸


ArcGIS JS 基础教程(30):体元系列 - VoxelSlice 体元切片
非科班Java出身GISer2026/9/5

ArcGIS JS 基础教程(30):体元系列 - VoxelSlice 体元切片 零、写在前面一、功能介绍二、功能实现2.1 创建并添加切片2.2 切片的三个核心属性2.3 管理集合(增删改) 三、功能应用四、核心代码五、在线示例六、关键 API 说明七、系列导航 零、写在前面 📌 本系列教程完整目录:ArcGIS JS 系列基础教程(100个项目常用热门功能) 💡 在线示例:完整可运行的 HTML 示例,无需任何环境配置,可直接在浏览器中打开体验 🗂️ 专


0823Keepalived + LVS(DR) + MariaDB主主 小白完整实战教程
Void 出逃2026/8/28

文章目录 Keepalived + LVS(DR) + MariaDB主主 小白完整实战教程一、业务背景与架构选型数据库业务四大刚性需求传统架构痛点本套方案组件分工项目预期收益 二、MariaDB主从/主主复制原理核心日志与线程完整同步流程 三、实验环境规划四、基础环境初始化(所有机器)1. 修改主机名、网卡IP2. router路由器开启IP转发 五、部署MariaDB,配置主主双向复制db1配置db2配置第一步:db2作为从库,同步db1(db1→db2)第二步:db1作


【系列:TDengine 工业物联网实战:从零搭起可运行系统 · 第 7 篇】
jufeng13072026/8/20

第 4 篇我们搭好了写入管线,背压、攒批、并发 worker 都就位了。可管线再高效,也得有数据往里喂。今天回到源头:数据从哪来?两条路——模拟器直接造,采集器从三源收,最终都汇入同一条 pipeline。这篇就讲四件事:物理模型、确定性 seed、归一化漏斗、坏数据去向。读完你能回答:模拟器的物理模型为什么这么设计?三源各适合什么场景?坏数据去哪了? 两条路径,一个入口 先看全局。整个系统的数据入口分成两条路,但最终汇聚到同一个 WritePipeline——就是第 4 篇讲背压、攒批、并发


uni-app 生命周期深度解析(iOS / Android / 鸿蒙 / Vue3 四端对照)
90后晨仔2026/8/7

📌 本文定位: 面向同时具备 iOS、Android、鸿蒙原生开发经验,正在转向 uni-app 的资深工程师。所有技术点均基于 uni-app 官方文档 及 Vue3 官方文档整理。 一、先搞懂一个 JS 语法问题:为什么说"与 data/methods 平级的叫生命周期"? 很多原生工程师初学 uni-app 时会对这句话感到困惑。我们从 JavaScript 语言层面彻底讲清楚。 1.1 Options API 的本质是一个"配置对象" 在 Vue2/Vue3 的 Options A


GPT 5.6 的真正变革:从"最强模型"到"最合适模型",AI 工程范式正在重置
浮生望2026/7/29

摘要: GPT 5.6以Sol、Terra、Luna三层架构重新定义AI使用方式。跑分不再决定竞争力,真正的差距在于把什么任务分给什么模型,用更少Token和更少返工完成更高质量交付。AI正从顾问变成协作者。 每次新模型发布,人们都在问同一个问题,但那个问题已经过时了 GPT 5.6 发布后,讨论一如既往地集中在几个老问题上:跑分涨了多少?代码能力有没有超过 Claude?谁又成了"最强模型"? 这些问题很重要,但如果你只盯着它们,就错过了 GPT 5.6 真正改变游戏规则的地方。 Open


影像创作领域的GitHub!深度体验了这个国产AI,我卸了3个AI视频工具!
程序员X小鹿2026/7/21

大家好,我是X小鹿,今天分享一个不一样的 AI 视频工具。 以前做一条 AI 短片,从剧本创作、脚本编写、到角色定妆、场景道具生成、再到分镜生成、视频生成,以及最后的剪辑成片,每一步都需要用到单独的工具。 生成一条短片,需要在多个工具间来回切换。 后来也陆续出现了一些 AI 视频工具,把上面的很多流程都集成在了一个平台上,用起来确实比之前方便了不少。 最近用了 AI 视频创作平台 updream ,发现它虽然也是将很多功能集成在了一起,但和之前接触的一些 AI 视频工具又不太一样。 体验下来,

首页编辑器站点地图

本站内容在 CC BY-SA 4.0 协议下发布

Copyright © 2026 聚合阅读