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

想象中

实际上

下面，我们尝试解决它。

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

1. 
   
2. g++
   
3. -c <file> 编译源文件，但是不进行链接
   
4. -o <file> 指定输出文件的名字
   
5. -s        strip，移除符号信息
   
6. -L <dir>  指令搜索链接库的路径
   
7. -l <lib>  指定要链接的链接库
   
8. -shared   产生动态目标文件

复制代码

先来看一段代码：

1. 
   
2. #include <stdio.h>
   
3. 
   
4. void DoThing() { printf("work \n"); }

复制代码

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

1. 
   
2. #include <stdio.h>
   
3. 
   
4. void DoThing();
   
5. 
   
6. int main() {
   
7.     printf("start \n");
   
8.     DoThing();
   
9.     printf("finished \n");
   
10.     return 0;
    
11. }

复制代码

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

1. 
   
2. g++ -c work.cc -o work.o
   
3. ar rc libwork.a work.o
   
4. g++ -c main.cc -o main.o
   
5. ar rc libmain.a main.o

复制代码

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

如果这样进行链接：

1. 
   
2. g++ -c work.cc -o work.o
   
3. ar rc libwork.a work.o
   
4. g++ -c main.cc -o main.o
   
5. ar rc libmain.a main.o

复制代码

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

1. 
   
2. g++ -s -L. -o main.exe -lmain -lwork
   
3. $ ./main.exe
   
4. start
   
5. work
   
6. finished

复制代码

链接成功。

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

1. 
   
2. #include <stdio.h>
   
3. 
   
4. void DoThing() { printf("conflict \n"); }

复制代码

编译并打包成静态库：

1. 
   
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
   
3. $ ./main.exe
   
4. start
   
5. work
   
6. finished

复制代码

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

1. 
   
2. $ g++ -s -L. -o main.exe -lmain -lconflict -lwork
   
3. $ ./main.exe
   
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
   
7. conflict
   
8. finished

复制代码

现在再引用一个中间层在动态链接库中调用conflict的文件layer.cc

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

复制代码

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

1. 
   
2. $ g++ -c layer.cc -o layer.o
   
3. $ g++ -shared layer.o conflict.o -o libconflict.so
   

复制代码

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

1. 
   
2. #include <stdio.h>
   
3. void DoLayer();
   
4. int main() {
   
5.     printf("start \n");
   
6.     DoLayer();
   
7.     printf("finished \n");
   
8.     return 0;
   
9. }
   

复制代码

编译链接执行：

1. 
   
2. $ g++ -c main.cc -o main.o
   
3. $ ar rc libmain.a main.o
   
4. $ g++ -s -L. -o main.exe -lmain -lconflict
   
5. $ LD_LIBRARY_PATH=. ./main.exe
   
6. start
   
7. layer
   
8. conflict
   
9. finished

复制代码

正常输出，没啥问题，现在再把之前的work.cc也塞到main.cc中，观察下冲突：

1. 
   
2. #include <stdio.h>
   
3. void DoThing();
   
4. void DoLayer();
   
5. int main() {
   
6.     printf("start \n");
   
7.     DoThing();
   
8.     DoLayer();
   
9.     printf("finished \n");
   
10.     return 0;
    
11. }

复制代码

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

1. 
   
2. $ g++ -c main.cc -o main.o
   
3. $ ar rc libmain.a main.o work.o
   
4. $ g++ -s -L. -o main.exe -lmain -lconflict
   
5. $ LD_LIBRARY_PATH=. ./main.exe
   
6. start
   
7. work
   
8. layer
   
9. work
   
10. finished

复制代码

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

可以考虑使用-fvisibility=hidden来隐藏内部的符号，链接库内部使用的符号把它隐藏掉，不让它被导出，外部也不会改变它的调用路径。

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

1. 
   
2. $ nm -CD libconflict.so
   
3.                  w _ITM_deregisterTMCloneTable
   
4.                  w _ITM_registerTMCloneTable
   
5. 000000000000065a T DoLayer()
   
6. 0000000000000672 T DoThing()
   
7. 0000000000201030 B __bss_start
   
8.                  w __cxa_finalize
   
9.                  w __gmon_start__
   
10. 0000000000201030 D _edata
    
11. 0000000000201038 B _end
    
12. 0000000000000688 T _fini
    
13. 0000000000000528 T _init
    
14.                  U puts

复制代码

如果把符号隐藏掉：

1. 
   
2. $ g++ -fvisibility=hidden -c layer.cc -o layer.o
   
3. $ g++ -fvisibility=hidden -c conflict.cc -o conflict.o
   
4. $ g++ -shared layer.o conflict.o -o libconflict.so
   
5. 再使用nm看一下libconflict.so里面的符号：
   
6. $ nm -CD libconflict.so
   
7.                  w _ITM_deregisterTMCloneTable
   
8.                  w _ITM_registerTMCloneTable
   
9. 0000000000201028 B __bss_start
   
10.                  w __cxa_finalize
    
11.                  w __gmon_start__
    
12. 0000000000201028 D _edata
    
13. 0000000000201030 B _end
    
14. 0000000000000618 T _fini
    
15. 00000000000004c0 T _init
    
16.                  U puts

复制代码

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

1. 
   
2. $ g++ -s -L. -o main.exe -lmain -lconflict
   
3. ./libmain.a(main.o): In function `main':
   
4. main.cc:(.text+0x16): undefined reference to `DoLayer()'
   
5. collect2: error: ld returned 1 exit statu

复制代码

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

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

复制代码

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

1. 
   
2. $ g++ -fvisibility=hidden -c layer.cxx -o layer.o
   
3. $ g++ -shared layer.o conflict.o -o libconflict.so
   
4. $ g++ -s -L. -o main.exe -lmain -lconflict
   
5. $ LD_LIBRARY_PATH=. ./main.exe
   
6. start
   
7. work
   
8. layer
   
9. conflict
   
10. finished

复制代码

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

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

1. 
   
2. export.txt
   
3. 
   
4. {
   
5. global: *DoLayer*;
   
6. local: *;
   
7. };
   
8. g++ -Wl,--version-script=export.txt -s -shared layer.o conflict.o -o libconflict.so

复制代码

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

Tips

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