在前面的文章中程序喵已经介绍过静态链接的原理，这篇文章我们来解密动态链接。
% K$ B# p1 O+ e! ^) w9 K2 c

老规矩，先抛出几个问题：
( Q3 u, j" m. {' T+ {8 L/ `5 C

. d* q) `8 G% C$ S: L

0 q  ?( v0 W% k1 q7 L; G+ [

• 为什么要进行动态链接？
• 如何进行动态链接？
• 什么是地址无关代码技术？
• 什么是延迟绑定技术？
• 如何在程序运行过程中进行显式链接？
  : b- v7 J3 x1 {/ v- t
  
  

( z" M& k  U: T8 P9 Y6 i9 `

为什么要进行动态链接？

因为静态链接有缺点：

• 浪费内存和磁盘空间：如下图，
  
  

Program1和Program2分别包含Program1.o和Program2.o两个模块，他们都需要Lib.o模块。静态链接情况下，两个目标文件都用到Lib.o这个模块，所以它们同时在链接输出的可执行文件Program1和program2中有副本，同时运行时，Lib.o在磁盘和内存中有两份副本，当系统中有大量类似Lib.o的多个程序共享目标文件时，就会浪费很大空间。

• 静态链接对程序的更新部署和发布很不友好：假如一个模块依赖20个模块，当20个模块其中有一个模块需要更新时，需要将所有的模块都找出来重新编译出一个可执行程序才可以更新成功，每次更新任何一个模块，用户就需要重新获得一个非常大的程序，程序如果使用静态链接，那么通过网络来更新程序也会非常不便，一旦程序任何位置有一个小改动，都会导致整个程序重新下载。
  
  . J2 a( C( _- T' g3 g, J

为了解决静态链接的缺点，所以引入了动态链接，动态链接的内存分布如图，

( n! P/ Y5 u/ _: J
- u0 X8 x! i5 ^' \% A( E

多个程序依赖同一个共享目标文件，这个共享目标文件在磁盘和内存中仅有一份，不会产生副本，简单来讲就是不像静态链接一样对那些组成程序的目标文件进行链接，等到程序要运行时才进行链接，把链接这个过程推迟到运行时才执行。动态链接的方式使得开发过程中各个模块更加独立，耦合度更小，便于不同的开发者和开发组织之间独立的进行开发和测试。

如何进行动态链接？

看如下代码：

1. 
   * i' _+ p) n7 `
2. // lib.c
   
3. #include <stdio.h>
   * O6 m) ]9 O/ C$ A
4. 
   2 f6 R% l/ E0 ^# v
5. void func(int i) {
   . S, k# q) @1 f. I' P0 c
6.    printf("func %d \n", i);
   . w% q# b8 I) U. ^
7. }

复制代码

1. 
   
2. // Program.c
   
3. void func(int i);
   ; T3 ]6 b! C4 ^- S
4. 
   3 @2 [; M5 ~- i$ |4 V1 j& i! x
5. int main() {
     b- e! G; `$ T) j
6.    func(1);
   
7.    return 0;
   ; I# o8 b& b. u
8. }
   ) \: q7 k$ O8 d8 |) M" K+ Z

复制代码

编译运行过程如下：

1. <font style="background-color:rgb(255, 255, 255)">
   ) q" N3 S) h$ s1 x( r3 ^
2. $ gcc -fPIC -shared -o lib.so lib.c
   
3. $ gcc -o test Program.c ./lib.so
   2 g* o2 t. H" c7 D1 `
4. $ ./test
   6 |6 z+ A5 k$ _( [, _
5. $ func 1</font><font style="background-color:rgb(255, 255, 255)">
   
6. </font>

复制代码

通过-fPIC和-shared可以生成一个动态链接库，再链接到可执行程序就可以正常运行。

通过readelf命令可以查看动态链接库的segment信息：

1. 
   & ?1 n8 X$ r# D( [4 `
2. ~/test$ readelf -l lib.so
   
3. 
   
4. Elf file type is DYN (Shared object file)
   ' M2 P' g. J9 Q; ^
5. Entry point 0x530
   
6. There are 7 program headers, starting at offset 64
   
7. 
   ) S: Z% o5 z" q% b% f/ v; h
8. Program Headers:
   ) b: r5 z8 ]2 Z. ?
9. Type           Offset             VirtAddr           PhysAddr
   2 p  d8 y2 d4 z
10.                 FileSiz            MemSiz              Flags  Align
    
11. LOAD           0x0000000000000000 0x0000000000000000 0x0000000000000000
    : [/ p/ U, s+ i# |- Y6 E$ s
12.                 0x00000000000006e4 0x00000000000006e4  R E    0x200000
    % c1 T6 |* w: l
13. LOAD           0x0000000000000e10 0x0000000000200e10 0x0000000000200e10
    - ?$ T9 p# n& V, d6 K/ e7 p  i
14.                 0x0000000000000218 0x0000000000000220  RW     0x200000
    ' z& @" O1 v% x" V
15. DYNAMIC        0x0000000000000e20 0x0000000000200e20 0x0000000000200e20
    
16.                 0x00000000000001c0 0x00000000000001c0  RW     0x8
    + i# h, n# t) U1 n( s0 X1 d
17. NOTE           0x00000000000001c8 0x00000000000001c8 0x00000000000001c8
    
18.                 0x0000000000000024 0x0000000000000024  R      0x4
    & W. U) x) W( W# H
19. GNU_EH_FRAME   0x0000000000000644 0x0000000000000644 0x0000000000000644
    
20.                 0x0000000000000024 0x0000000000000024  R      0x4
    
21. GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
    
22.                 0x0000000000000000 0x0000000000000000  RW     0x10
    
23. GNU_RELRO      0x0000000000000e10 0x0000000000200e10 0x0000000000200e10
    
24.                 0x00000000000001f0 0x00000000000001f0  R      0x1
    & B: y3 T, g" F4 j6 v6 r
25. 
    
26. Section to Segment mapping:
    # V8 w1 F% \5 E  I. P
27. Segment Sections...
    
28.   00     .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .plt.got .text .fini .rodata .eh_frame_hdr .eh_frame
    & ]' L( E' b3 ^- T4 j8 F- h
29.   01     .init_array .fini_array .dynamic .got .got.plt .data .bss
    
30.   02     .dynamic
    
31.   03     .note.gnu.build-id
    & @& P3 K  S  J' T* C
32.   04     .eh_frame_hdr
    
33.   05
    . S6 y; q' Y) B5 U
34.   06     .init_array .fini_array .dynamic .got

复制代码

& |/ n2 `# t; ?6 @$ b

5 P. V* W2 C4 D2 w4 Y4 A) Y

可以看见动态链接模块的装载地址从0开始，0是无效地址，它的装载地址会在程序运行时再确定，在编译时是不确定的。

改一下程序：

1. <font style="background-color:rgb(255, 255, 255)">
   
2. // Program.c
   % K# }- R- f9 a4 A- @
3. #include <stdio.h>
   / j1 h' @& O3 _' O  l$ b9 V2 S
4. void func(int i);
   1 {5 n: d- M; X/ E* G4 A
5. 
   
6. int main() {
   4 I: h% Y/ s* n; n6 p
7.    func(1);
   
8.    sleep(-1);
   
9.    return 0;
   8 T3 x6 Z- {$ g+ M# ?' W6 d, S
10. }</font>
    

复制代码

运行读取maps信息：

1. 
   
2. ~/test$ ./test &
   
3. [1] 126
   
4. ~/test$ func 1
   2 d; g- }. r# A3 Q/ V, \0 b6 I
5. cat /proc/126/maps
   
6. 7ff2c59f0000-7ff2c5bd7000 r-xp 00000000 00:00 516391             /lib/x86_64-linux-gnu/libc-2.27.so
   * \5 |) v$ G$ e. `" ?! s! j( S
7. 7ff2c5bd7000-7ff2c5be0000 ---p 001e7000 00:00 516391             /lib/x86_64-linux-gnu/libc-2.27.so
   
8. 7ff2c5be0000-7ff2c5dd7000 ---p 000001f0 00:00 516391             /lib/x86_64-linux-gnu/libc-2.27.so
   " v, P3 `5 r+ O1 T8 Y
9. 7ff2c5dd7000-7ff2c5ddb000 r--p 001e7000 00:00 516391             /lib/x86_64-linux-gnu/libc-2.27.so
   " G6 i* z1 ?9 \; K1 `( f3 A
10. 7ff2c5ddb000-7ff2c5ddd000 rw-p 001eb000 00:00 516391             /lib/x86_64-linux-gnu/libc-2.27.so
    
11. 7ff2c5ddd000-7ff2c5de1000 rw-p 00000000 00:00 0
    
12. 7ff2c5df0000-7ff2c5df1000 r-xp 00000000 00:00 189022             /mnt/d/wzq/wzq/util/test/lib.so
    , V8 X- |4 E& f  W) u' `! A; p
13. 7ff2c5df1000-7ff2c5df2000 ---p 00001000 00:00 189022             /mnt/d/wzq/wzq/util/test/lib.so
    
14. 7ff2c5df2000-7ff2c5ff0000 ---p 00000002 00:00 189022             /mnt/d/wzq/wzq/util/test/lib.so
    7 A3 Z  H! Z( R5 K0 t
15. 7ff2c5ff0000-7ff2c5ff1000 r--p 00000000 00:00 189022             /mnt/d/wzq/wzq/util/test/lib.so
    
16. 7ff2c5ff1000-7ff2c5ff2000 rw-p 00001000 00:00 189022             /mnt/d/wzq/wzq/util/test/lib.so
    ) C/ h$ o8 I  K* D& k6 j* U8 G$ m( T
17. 7ff2c6000000-7ff2c6026000 r-xp 00000000 00:00 516353             /lib/x86_64-linux-gnu/ld-2.27.so
    + c  U1 f: b. f0 S5 p$ S
18. 7ff2c6026000-7ff2c6027000 r-xp 00026000 00:00 516353             /lib/x86_64-linux-gnu/ld-2.27.so
    
19. 7ff2c6227000-7ff2c6228000 r--p 00027000 00:00 516353             /lib/x86_64-linux-gnu/ld-2.27.so
    
20. 7ff2c6228000-7ff2c6229000 rw-p 00028000 00:00 516353             /lib/x86_64-linux-gnu/ld-2.27.so
    
21. 7ff2c6229000-7ff2c622a000 rw-p 00000000 00:00 0
    , q( e7 [6 h, }: O8 D, w
22. 7ff2c62e0000-7ff2c62e3000 rw-p 00000000 00:00 0
    
23. 7ff2c62f0000-7ff2c62f2000 rw-p 00000000 00:00 0
    
24. 7ff2c6400000-7ff2c6401000 r-xp 00000000 00:00 189023             /mnt/d/wzq/wzq/util/test/test
    ! h9 B% l; [/ [0 c% |, W
25. 7ff2c6600000-7ff2c6601000 r--p 00000000 00:00 189023             /mnt/d/wzq/wzq/util/test/test
    
26. 7ff2c6601000-7ff2c6602000 rw-p 00001000 00:00 189023             /mnt/d/wzq/wzq/util/test/test
    
27. 7fffee96f000-7fffee990000 rw-p 00000000 00:00 0                 [heap]
    ( k1 V9 {' _0 x# |2 r7 [$ d
28. 7ffff6417000-7ffff6c17000 rw-p 00000000 00:00 0                 [stack]
    
29. 7ffff729d000-7ffff729e000 r-xp 00000000 00:00 0                 [vdso]
    

复制代码

# s6 F# m1 T; D' O6 X/ p8 B

可以看到，整个进程虚拟地址空间中，多出了几个文件的映射，lib.so和test一样，它们都是被操作系统用同样的方法映射到进程的虚拟地址空间，只是它们占据的虚拟地址和长度不同，从maps里可以看见里面还有libc-2.27.so，这是C语言运行库，还有一个ld-2.27.so，这是Linux下的动态链接器，动态链接器和普通共享对象一样被映射到进程的地址空间，在系统开始运行test前，会先把控制权交给动态链接器，动态链接器完成所有的动态链接工作后会把控制权交给test，然后执行test程序。

当链接器将Program.o链接成可执行文件时，这时候链接器必须确定目标文件中所引用的func函数的性质，如果是一个定义于其它静态目标文件中的函数，那么链接器将会按照静态链接的规则，将Program.o的func函数地址进行重定位，如果func是一个定义在某个动态链接共享对象中的函数，那么链接器将会将这个符号的引用标记为一个动态链接的符号，不对它进行地址重定位，将这个过程留在装载时再进行。

动态链接的方式

动态链接有两种方式：装载时重定位和地址无关代码技术。

装载时重定位：在链接时对所有绝对地址的引用不作重定位，而把这一步推迟到装载时完成，也叫基址重置，每个指令和数据相当于模块装载地址是固定的，系统会分配足够大的空间给装载模块，当装载地址确定后，那指令和数据地址自然也就确定了。然而动态链接模块被装载映射到虚拟空间，指令被重定位后对于每个进程来讲是不同的，没有办法做到同一份指令被多个进程共享，所以指令对不同的进程来说有不同的副本，还是空间浪费，怎么解决这个问题？使用fPIC方法。

地址无关代码：指令部分无法在多个进程之间共享，不能节省内存，所以引入了地址无关代码的技术。我们平时编程过程中可能都见过-fPIC的编译选项，这个就代表使用了地址无关代码技术来实现真正的动态链接。基本思想就是使用GOT（全局偏移表），这是一个指向变量或函数地址的指针数组，当指令要访问变量或者调用函数时，会去GOT中找到相应的地址进行间接跳转访问，每个变量或函数都对应一个地址，链接器在装载模块的时候会查找每个变量和函数的地址，然后填充GOT中的各个项，确保每个指针指向的地址正确。GOT放在数据段，所以它可以在模块装载时被修改，并且每个进程都可以有独立的副本，相互不受影响。

tips

8 ^4 `  O- k9 k2 R% T6 a

-fpic和-fPIC的区别：它们都是地址无关代码技术，-fpic产生的代码相对较小较快，但是在某些平台会有些限制，所以大多数情况下都是用-fPIC来产生地址无关代码。

-fPIC和-fPIE的区别：一个作用于共享对象，一个作用于可执行文件，一个以地址无关方式编译的可执行文件被称作地址无关可执行文件。

-fpie和-fPIE的区别：类似于-fpic和-fPIC的区别

4 L. k) K: A/ v! L( x

延迟绑定技术

在程序刚启动时动态链接器会寻找并装载所需要的共享对象，然后进行符号地址寻址重定位等工作，这些工作会减慢程序的启动速度，如果解决？

使用PLT延迟绑定技术，这里会单独有一个叫.PLT的段，ELF将 GOT拆分成两个表.GOT和.GOT.PLT，其中.GOT用来保存全局变量的引用地址，.GOT.PLT用来保存外部函数的地址，每个外部函数在PLT中都有一个对应项，在初始化时不会绑定，而是在函数第一次被用到时才进行绑定，将函数真实地址与对应表项进行绑定，之后就可以进行间接跳转。

显式运行时链接

支持动态链接的系统往往都支持显式运行时链接，也叫运行时加载，让程序自己在运行时控制加载的模块，在需要时加载需要的模块，在不需要时将其卸载。这种运行时加载方式使得程序的模块组织变得很灵活，可以用来实现一些诸如插件、驱动等功能。

通过这四个API可以进行显式运行时链接：

1. 
   
2. dlopen()：打开动态链接库
   
3. dlsym()：查找符号
   
4. dlerror()：错误处理
   ( |9 N- w' ~* k
5. dlclose()：关闭动态链接库
   ' C. B) g) }3 {* V) {0 n

复制代码

" G- I0 G7 V' Y- k8 o. @* m$ v" Z

参考这段使用代码：
5 R$ i' K2 B% \- R) p, T8 \2 |

1. 
   2 z1 P7 s2 b4 Z+ A4 e
2. #include <stdio.h>
   ' I; p2 n& V; M1 V( t
3. #include <dlfcn.h>
   : h" v. x6 m7 H0 b) b6 J$ N5 @
4. 
   % g6 q/ a0 T0 J; l# V- B' B5 f
5. int main() {
   5 F. ?: B% R; ]8 o
6. 
   ! t: D; Y' l# p& N6 B8 ]2 |0 j
7.    void *handle;
   ; o1 M5 _6 w: @" [2 X; B7 u
8.    void (*f)(int);
   7 A9 @' r8 J; i7 R: w/ X+ ~
9.    char *error;
   1 `7 k8 I2 r! A) X7 `
10. 
    
11.    handle = dlopen("./lib.so", RTLD_NOW);
    1 D) |: g/ I0 J5 K
12.    if (handle == NULL) {
    * w) e' R  k, U$ K
13.        printf("handle null \n");
    8 v4 b% }3 Q+ m0 x
14.        return -1;
    2 n  c) t$ y$ `, ~+ F( u; v! m3 ?! n) A
15.   }
      O8 f* o( Q2 ]3 M  W) u+ c
16.    f = dlsym(handle, "func");
    
17.    do {
    . y8 C# H  e% u/ g
18.        if ((error = dlerror()) != NULL) {
    # i3 T1 f# y- L# T
19.            printf("error\n");
    
20.            break;
    0 e) m- E) C& N+ o6 A8 U4 L) E
21.       }
    8 |/ h8 `7 ]( l' `% B
22.        f(100);
    ' h  D4 Z/ G; v
23.   } while (0);
    
24.    dlclose(handle);
    
25. 
    % b+ s1 u. e/ W9 Q' x# I6 U# a
26.    return 0;
    
27. }
    

复制代码

编译运行：
0 I. C5 P8 T! x; H/ U

1. 
   
2. $ gcc -o test program.c -ldl
   
3. $ ./test
   + d6 C4 R! r+ t8 {) S6 u) m
4. func 100
   # m7 u/ X! E1 {" w7 \7 I

复制代码

2 |( }7 H- A. D. G8 I+ m

总结

6 v9 ~( N/ W& M8 h4 F2 Y, l

为什么要进行动态链接？为了解决静态链接浪费空间和更新困难的缺点。

动态链接的方式？装载时重定位和地址无关代码技术。

地址无关代码技术原理？通过GOT段实现间接跳转。

延迟加载技术原理？对外部函数符号通过PLT段实现延迟绑定及间接跳转。

如果进行显式运行时链接？通过<dlfcn.h>头文件中的四个函数，代码如上。

5 w% G' s( X( r: k7 D$ _

8 a# ]# h, L# r) K" u  O. }
9 W- g5 A6 q' f3 u* P4 J7 Z8 A

非常好的资料，感谢分享非常好的资料，感谢分享非常好的资料，感谢分享非常好的资料，感谢分享非常好的资料，感谢分享非常好的资料，感谢分享非常好的资料，感谢分享非常好的资料，感谢分享非常好的资料，感谢分享非常好的资料，感谢分享非常好的资料，感谢分享