原来编译链接还有这么多套路

本文转载自微信公众号「程序喵大人」，作者程序喵大人 。转载本文请联系程序喵大人公众号。

大家好，我是程序喵。

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

想象中

实际上

下面我们尝试解决它：

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

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

先来看一段代码：

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

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

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

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

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

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

如果这样进行链接：

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

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

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

链接成功。

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

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

编译并打包成静态库：

 
 
 
 
    
  
  
  
  
  1. g++ -c conflict.cc -o conflict.o 
    2. 
  
  
  
  
  2. ar rc libconflict.a conflict.o 
    3.

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

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

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

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

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

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

 
 
 
 
    
  
  
  
  
  1. $ rm libconflict.a 
    2. 
  
  
  
  
  2. $ g++ -shared conflict.o -o libconflict.so 
    3. 
  
  
  
  
  3. $ g++ -s -L. -o main.exe -lmain -lconflict 
    4. 
  
  
  
  
  4. $ LD_LIBRARY_PATH=. ./main.exe 
    5. 
  
  
  
  
  5. start 
    6. 
  
  
  
  
  6. conflict 
    7. 
  
  
  
  
  7. finished 
    8.

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

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

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

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

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

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

编译链接执行：

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

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

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

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

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

这里输出了两个work，正常情况下第二个work应该输出conflict，怎么解决呢?可以考虑使用-fvisibility=hidden来隐藏内部的符号，链接库内部使用的符号把它隐藏掉，不让它被导出，外部也不会改变它的调用路径。

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

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

如果把符号隐藏掉，

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

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

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

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

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

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

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

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

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

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

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

分享文章：原来编译链接还有这么多套路
文章源于：http://www.csdahua.cn/qtweb/news42/433642.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

虚拟主机知识

分类信息网

app软件开发　　 　模板商城网站　　 　全网营销　　 　成都主机租用　　 　VI设计　　 　网站设计制作　　 　B2C电商系统　　 　宜宾网站营销推广　　 　重庆联通机房托管　　 　防护网厂　　 　成都微信开发　　 　zyfdjwx.com　　 　广安做网站　　 　服务器托管　　 　成都app开发公司　　 　响应式网站设计方案　　 　班戈纳美网站　　 　精灵网　　 　成都网站设计公司　　 　企业网站维护