不知道大家平时编程过程中使用动态链接库的情况多不多，如果一个程序引用了无数个动态链接库，那就有可能引入符号冲突的问题，问题如下：

想象中

实际上
# w0 j! z. h( P; X$ c

7 ~. m, c# _; y) {& V

下面，我们尝试解决它。

' x+ `0 Q/ I$ a; I$ Q

最开始介绍下g++基本命令参数：

1. 
   . V( M* W( G* N# ?) F- U# W7 O7 G
2. g++
   
3. -c <file> 编译源文件，但是不进行链接
   
4. -o <file> 指定输出文件的名字
   
5. -s        strip，移除符号信息
   
6. -L <dir>  指令搜索链接库的路径
   ( O; k7 a4 X, N' [
7. -l <lib>  指定要链接的链接库
   ! C! T" {7 E9 J/ e# Q7 A) d/ \4 a
8. -shared   产生动态目标文件

复制代码

先来看一段代码：

1. 
   
2. #include <stdio.h>
   ( M! C, E' d! E/ c5 s, F# N! P, t5 I
3. 
   ' I* O( S! q1 F8 z/ ?0 }
4. void DoThing() { printf("work \n"); }

复制代码

/ Y  z1 c3 }4 D

再定义一个简单的main.cc程序：

1. 
   8 I& P1 e* `# b5 i
2. #include <stdio.h>
   $ S0 \0 N, `" m
3. 
   5 A" I) U1 l8 |
4. void DoThing();
   7 a- y* W1 \# X! U& d9 R
5. 
   ) [) I2 T; f0 b( P+ V; D( p
6. int main() {
   : ?( H% {  i9 Z! z
7.     printf("start \n");
   & N$ i' ]6 _- ^2 W/ w. a( a4 {
8.     DoThing();
   - ?: H* c1 ]3 x+ f6 m
9.     printf("finished \n");
   3 F8 a9 S' Z1 a
10.     return 0;
    + u" A5 L# V. ?1 e" }# Q( n
11. }

复制代码

# e' Z$ [8 ^' Q2 n6 i+ K

编译这两个文件，并分别打包成静态库：

1. 
   
2. g++ -c work.cc -o work.o
   
3. ar rc libwork.a work.o
   8 d& K) p; p$ T/ U/ ]' k
4. g++ -c main.cc -o main.o
   . q4 v/ s" `; u1 q2 A
5. ar rc libmain.a main.o

复制代码

6 L0 s8 Z2 n. T! X: |; k

现在将这两个静态库链接成一个可执行文件，注意链接器如果发现当前库中使用了没有被定义的符号，它只会向后查找，因此最低级别没有其它依赖的库应该放在最右边，如果出现了符号冲突问题，链接器会使用最左边的符号。

如果这样进行链接：

1. 
   
2. g++ -c work.cc -o work.o
   
3. ar rc libwork.a work.o
   ) ?7 `4 H$ M! I# o, p
4. g++ -c main.cc -o main.o
   
5. ar rc libmain.a main.o

复制代码

' `7 @! Z7 Z& J! |- b; a3 C

  G. M" N5 j0 x" S6 h, F

链接失败，因为main库里的DoThing符号没有被定义，链接器向后查找，没有找到对应的符号定义，这里更改下链接库的顺序：

1. 
   
2. g++ -s -L. -o main.exe -lmain -lwork
   + L: ~2 D- Z7 R# d& ~
3. $ ./main.exe
   / V$ G" m  Z/ K3 m$ ?
4. start
   . E; `' ?9 ^( C3 {
5. work
   , S) z8 S: L8 m* n
6. finished

复制代码

% |7 C% T3 Y* n7 y9 h

链接成功。

( G  U) z! q, e6 i

现在写一个简单的容易产生符号冲突的文件conflict.cc：

1. 
   
2. #include <stdio.h>
   
3. 
   , B( r  l; Q* l, y, o
4. void DoThing() { printf("conflict \n"); }

复制代码

编译并打包成静态库：

1. 
   $ O8 }; {6 v9 w+ a  B4 k
2. g++ -c conflict.cc -o conflict.o
   
3. ar rc libconflict.a conflict.o

复制代码

如果按这样的顺序链接成一个可执行程序：

1. 
   
2. $ g++ -s -L. -o main.exe -lmain -lwork -lconflict
   ) A, T) D7 @) s& c/ a8 W
3. $ ./main.exe
   / u  V3 W/ n9 {* V
4. start
   
5. work
   
6. finished

复制代码

如果稍微更改一下链接的顺序：

1. 
   
2. $ g++ -s -L. -o main.exe -lmain -lconflict -lwork
   . H+ z% y6 J; _0 i( l9 ?4 E
3. $ ./main.exe
   $ s- V* S" E* Z( f! R
4. start
   
5. conflict
   
6. finished

复制代码

这里发现顺序的不同导致了程序输出内容不同，究其原因就是那潜在的符号冲突。

现在再试试动态库，先介绍如何使用动态库：

1. 
   
2. $ rm libconflict.a
   
3. $ g++ -shared conflict.o -o libconflict.so
   
4. $ g++ -s -L. -o main.exe -lmain -lconflict
   
5. $ LD_LIBRARY_PATH=. ./main.exe
   
6. start
   1 ?: w* _! J( N* F1 ?' m- ]0 D* H  V. C4 O
7. conflict
   
8. finished

复制代码

! }4 p( ?# ?+ P1 C+ Z  E

: K3 W! W/ d1 g7 }' b

现在再引用一个中间层在动态链接库中调用conflict的文件layer.cc
7 m$ d% i, L1 {3 v, k( _1 N

1. 
   
2. #include <stdio.h>
   % e& E; T( T, O0 n% \3 _) E
3. void DoThing();
   
4. void DoLayer() {
   5 f. ~1 _# t/ i, a! Y" N1 l: B/ k
5.     printf("layer \n");
   
6.     DoThing();
   ! s; {5 B2 |3 ?8 V9 J: }
7. }

复制代码

并把layer和conflict打包成一个动态链接库：

1. 
   
2. $ g++ -c layer.cc -o layer.o
   
3. $ g++ -shared layer.o conflict.o -o libconflict.so
     d# \. r$ N  p2 K& X

复制代码

  O" x( g. f8 w: y. ?. N

然后更新main.c程序，main里面调用layer，layer里调用conflict：

1. 
   + n% H) b* g' c, k( v; T+ r/ ?
2. #include <stdio.h>
   
3. void DoLayer();
   2 a9 G' v0 Y5 k& ]5 S
4. int main() {
   9 O' Q3 O( V6 q4 |& B6 e
5.     printf("start \n");
   
6.     DoLayer();
     r5 p* U. |) r$ g, ]
7.     printf("finished \n");
   ! b- k2 A  ^9 |2 q
8.     return 0;
   6 B9 b0 z% x* }+ s& V% C9 K
9. }
   2 U: K3 n( C' p: u% u' y0 k; r

复制代码

编译链接执行：

1. 
   
2. $ g++ -c main.cc -o main.o
   # i  t" o* i8 r( i
3. $ ar rc libmain.a main.o
   & Y2 D1 y. G5 r9 c1 P2 C$ O3 ^
4. $ g++ -s -L. -o main.exe -lmain -lconflict
   
5. $ LD_LIBRARY_PATH=. ./main.exe
   # o" y( X! i0 |# h8 X
6. start
   
7. layer
   
8. conflict
   9 }. _# q' \# V+ }4 l4 c$ V
9. finished

复制代码

正常输出，没啥问题，现在再把之前的work.cc也塞到main.cc中，观察下冲突：
8 k0 x2 @. `0 C# Q+ |% `: _5 P/ u

1. 
   % }& B' S7 e( S8 v; n
2. #include <stdio.h>
   1 {' H  @9 q/ t/ ?0 }
3. void DoThing();
   
4. void DoLayer();
   
5. int main() {
   : q6 @0 K- ~' X7 O1 ^
6.     printf("start \n");
   
7.     DoThing();
   ' B) z9 m  M/ _) ]0 `1 B
8.     DoLayer();
   
9.     printf("finished \n");
   
10.     return 0;
    
11. }

复制代码

把work.o和main.o打包成一个库，之后和conflict链接成一个可执行程序，运行：

1. 
   . Z9 T; r# y4 q% |" d
2. $ g++ -c main.cc -o main.o
   
3. $ ar rc libmain.a main.o work.o
   / _4 q) W% T% }2 t  ~
4. $ g++ -s -L. -o main.exe -lmain -lconflict
   ' [, ~7 L4 k' j  T! d" G% A
5. $ LD_LIBRARY_PATH=. ./main.exe
   * J' T; ^. L  g$ q
6. start
   
7. work
   
8. layer
   
9. work
   
10. finished

复制代码

$ Y: F: o/ m4 ^+ M& Y# Q3 L

这里输出了两个work，正常情况下第二个work应该输出conflict，怎么解决呢？

可以考虑使用-fvisibility=hidden来隐藏内部的符号，链接库内部使用的符号把它隐藏掉，不让它被导出，外部也不会改变它的调用路径。
5 y# q6 Y1 D2 V1 [% r: m

先使用nm看一下libconflict.so里面的符号：

1. 
   0 D1 K( A+ H3 `. X& M$ O/ \
2. $ nm -CD libconflict.so
   8 f# A  r+ c0 I, D
3.                  w _ITM_deregisterTMCloneTable
   
4.                  w _ITM_registerTMCloneTable
   
5. 000000000000065a T DoLayer()
   
6. 0000000000000672 T DoThing()
   
7. 0000000000201030 B __bss_start
   0 ~3 J' R7 {$ C% @. i9 R" I1 M
8.                  w __cxa_finalize
   - |, i4 m& p, {7 T7 z
9.                  w __gmon_start__
   ! o, c. B9 V$ U- a3 E
10. 0000000000201030 D _edata
    / W2 d5 n  |, T; l, P; ~: n
11. 0000000000201038 B _end
    
12. 0000000000000688 T _fini
    . q, S! x0 W# v$ Y# g: A, G
13. 0000000000000528 T _init
    6 a; u1 X* a- U( |1 j* c6 `- O
14.                  U puts

复制代码

如果把符号隐藏掉：

1. 
   
2. $ g++ -fvisibility=hidden -c layer.cc -o layer.o
   ' I: y1 R- W9 q; w
3. $ g++ -fvisibility=hidden -c conflict.cc -o conflict.o
   ( r! \; l  G) }
4. $ g++ -shared layer.o conflict.o -o libconflict.so
   % [& r. y. e9 ]
5. 再使用nm看一下libconflict.so里面的符号：
   
6. $ nm -CD libconflict.so
   
7.                  w _ITM_deregisterTMCloneTable
   6 _/ i7 b- ]! B. b/ E0 Q
8.                  w _ITM_registerTMCloneTable
   
9. 0000000000201028 B __bss_start
   5 J, p. R2 _. {' k. q
10.                  w __cxa_finalize
    
11.                  w __gmon_start__
    
12. 0000000000201028 D _edata
    
13. 0000000000201030 B _end
    
14. 0000000000000618 T _fini
    - T  |8 a& j& }# u" _" V
15. 00000000000004c0 T _init
    
16.                  U puts

复制代码

" X0 S! c; p& h% l5 B, d

这样的话main函数肯定不能调用DoLayer啦，因为DoLayer符号没有暴露出来：

1. 
   
2. $ g++ -s -L. -o main.exe -lmain -lconflict
   
3. ./libmain.a(main.o): In function `main':
   9 j1 _" Z  p9 @) V* ^
4. main.cc:(.text+0x16): undefined reference to `DoLayer()'
   9 m3 \& b: R0 B$ Y3 b$ [
5. collect2: error: ld returned 1 exit statu

复制代码

0 Z6 ]! C5 D* y7 b4 j2 Y

那怎么暴露出来特定符号呢，直接看代码，改动了layer.cc：

1. 
   
2. #include <stdio.h>
   
3. void DoThing();
   
4. __attribute__ ((visibility ("default"))) void DoLayer() {
   
5.     printf("layer \n");
   
6.     DoThing();
   
7. }

复制代码

再编译链接运行看看结果：

1. 
     ~+ i+ @2 k1 {9 f$ {2 V! s
2. $ g++ -fvisibility=hidden -c layer.cxx -o layer.o
   0 v5 Z- t! P4 S1 p7 E# \
3. $ g++ -shared layer.o conflict.o -o libconflict.so
   
4. $ g++ -s -L. -o main.exe -lmain -lconflict
   6 b( n: V% i" i9 i5 W1 Z
5. $ LD_LIBRARY_PATH=. ./main.exe
   5 e. X1 z% Y! s+ C
6. start
   
7. work
   
8. layer
   
9. conflict
   4 p9 c& c9 L  u  e
10. finished

复制代码

0 ~  f' i9 W' i$ l( Z+ g: A

发现已经是我们期待的结果啦，符号冲突的问题因此被解决。

是不是感觉很麻烦，难道每个要暴露的符号都要加上__attribute__这种修饰吗，这里其实可以写一个export文件，告诉编译器要导出的所有符号有哪些。

1. 
   
2. export.txt
   
3. 
   
4. {
   
5. global: *DoLayer*;
   
6. local: *;
   ! T% H6 }7 t) b' [
7. };
   
8. g++ -Wl,--version-script=export.txt -s -shared layer.o conflict.o -o libconflict.so

复制代码

& ?) X' l: [  _. ~: j  ^

1 ]( t6 h9 m$ r$ J( I

但这种方式只有在gcc中才可以被使用，我在clang中尝试使用但是失败啦，所以为了兼容性不建议使用这种方式，还是消停的使用__attribute__来解决符号冲突问题吧。

7 T" S- ?2 S+ z) p" `

Tips

通过隐藏符号可以减小可执行程序的大小，还可以解决符号冲突问题，但有个缺点，因为隐藏了符号，线上程序运行时如果出现crash，通过堆栈信息我们看不到具体函数调用路径，给定位问题带来了困难。所以，是否需要使用这种办法，还应根据实际情况具体抉择。

: v+ ?3 s7 p7 Y0 f3 @& z+ m2 N