有关于全局符号介入与多个动态库存在相同的符号相互覆盖的问题

mazinkaiser1991

小弟最近在看《程序员的自我修养》，书中提到了全局符号介入问题，根据书中的代码进行了实验，实验代码如下：
a1.c

1. #include <stdio.h>
   
2. void a()
   
3. {
   
4.         printf("a1.c\n");
   
5. }

复制代码

a2.c

1. #include <stdio.h>
   
2. void a()
   
3. {
   
4.         printf("a2.c\n");
   
5. }

复制代码

b1.c

1. void a();
   
2. 
   
3. void b1()
   
4. {
   
5.         a();
   
6. }

复制代码

b2.c

1. void a();
   
2. 
   
3. void b2()
   
4. {
   
5.         a();
   
6. }

复制代码

编译命令如下：

1. gcc -fPIC -shared a1.c -o a1.so
   
2. gcc -fPIC -shared a2.c -o a2.so
   
3. gcc -fPIC -shared b1.c a1.so -o b1.so
   
4. gcc -fPIC -shared b2.c a2.so -o b2.so

复制代码

最后是main.c

1. #include <stdio.h>
   
2. 
   
3. void b1();
   
4. void b2();
   
5. 
   
6. int main()
   
7. {
   
8.         b1();
   
9.         b2();
   
10.         return 0;
    
11. }

复制代码

编译命令如下：

1. gcc main.c b1.so b2.so -o main -Xlinker -rpath ./

复制代码

最后程序运行结果如下：

1. ./main
   
2. a1.c
   
3. a1.c

复制代码

根据书中给出的解释是：当一个符号需要被加入全局符号表时，如果相同的符号名已经存在，则后加入的符号被忽略。到现在为止一切正常。
接下来问题就来了，偶然在网上看到了一段代码，并测试之。
foo.c

1. #include <stdio.h>
   
2. 
   
3. struct {
   
4.     int a;
   
5.     int b;
   
6. } b = { 3, 3 };
   
7. 
   
8. int main();
   
9. 
   
10. void foo()
    
11. {
    
12.     b.a = 4;
    
13.     b.b = 4;
    
14.     printf("foo:\t(&b)=0x%08x\n\tsizeof(b)=%d\n\tb.a=%d\n\tb.b=%d\n\tmain:0x%08x\n",
    
15.         &b, sizeof b, b.a, b.b, main);
    
16. }

复制代码

t1.c

1. #include <stdio.h>
   
2. 
   
3. int b = 1;
   
4. int c = 1;
   
5. 
   
6. int main()
   
7. {
   
8.     int count = 5;
   
9.     while (count-- > 0) {
   
10.         t2();
    
11.         foo();
    
12.         printf("t1:\t(&b)=0x%08x\n\t(&c)=0x%08x\n\tsizeof(b)=%d\n\tb=%d\n\tc=%d\n",
    
13.             &b, &c, sizeof b, b, c);
    
14.         sleep(1);
    
15.     }
    
16.     return 0;
    
17. }

复制代码

t2.c

1. #include <stdio.h>
   
2. 
   
3. int b;
   
4. int c;
   
5. 
   
6. int t2()
   
7. {
   
8.     printf("t2:\t(&b)=0x%08x\n\t(&c)=0x%08x\n\tsizeof(b)=%d\n\tb=%d\n\tc=%d\n",
   
9.         &b, &c, sizeof b, b, c);
   
10.     return 0;
    
11. }

复制代码

makefile如下：

1. export LD_LIBRARY_PATH:=.
   
2. 
   
3. test: t1.o t2.o
   
4.         gcc -shared -fPIC -o libfoo.so foo.c
   
5.         gcc -o test t1.o t2.o -L. -lfoo
   
6. 
   
7. t1.o: t1.c
   
8. t2.o: t2.c
   
9. 
   
10. .PHONY:clean
    
11. clean:
    
12.         rm -f *.o *.so test*

复制代码

首先只对程序源码静态分析就可以发现：强符号b被定义了两次，不过编译时并没有报重定义错误，这是我的第一个问题？接下来看运行。

1. t2:        (&b)=0x00601050
   
2.         (&c)=0x00601054
   
3.         sizeof(b)=4
   
4.         b=1
   
5.         c=1
   
6. foo:        (&b)=0x00601050
   
7.         sizeof(b)=8
   
8.         b.a=4
   
9.         b.b=4
   
10.         main:0x00400766
    
11. t1:        (&b)=0x00601050
    
12.         (&c)=0x00601054
    
13.         sizeof(b)=4
    
14.         b=4
    
15.         c=4
    
16. t2:        (&b)=0x00601050
    
17.         (&c)=0x00601054
    
18.         sizeof(b)=4
    
19.         b=4
    
20.         c=4
    
21. foo:        (&b)=0x00601050
    
22.         sizeof(b)=8
    
23.         b.a=4
    
24.         b.b=4
    
25.         main:0x00400766
    
26. t1:        (&b)=0x00601050
    
27.         (&c)=0x00601054
    
28.         sizeof(b)=4
    
29.         b=4
    
30.         c=4
    
31. t2:        (&b)=0x00601050
    
32.         (&c)=0x00601054
    
33.         sizeof(b)=4
    
34.         b=4
    
35.         c=4
    
36. foo:        (&b)=0x00601050
    
37.         sizeof(b)=8
    
38.         b.a=4
    
39.         b.b=4
    
40.         main:0x00400766
    
41. t1:        (&b)=0x00601050
    
42.         (&c)=0x00601054
    
43.         sizeof(b)=4
    
44.         b=4
    
45.         c=4
    
46. t2:        (&b)=0x00601050
    
47.         (&c)=0x00601054
    
48.         sizeof(b)=4
    
49.         b=4
    
50.         c=4
    
51. foo:        (&b)=0x00601050
    
52.         sizeof(b)=8
    
53.         b.a=4
    
54.         b.b=4
    
55.         main:0x00400766
    
56. t1:        (&b)=0x00601050
    
57.         (&c)=0x00601054
    
58.         sizeof(b)=4
    
59.         b=4
    
60.         c=4
    
61. t2:        (&b)=0x00601050
    
62.         (&c)=0x00601054
    
63.         sizeof(b)=4
    
64.         b=4
    
65.         c=4
    
66. foo:        (&b)=0x00601050
    
67.         sizeof(b)=8
    
68.         b.a=4
    
69.         b.b=4
    
70.         main:0x00400766
    
71. t1:        (&b)=0x00601050
    
72.         (&c)=0x00601054
    
73.         sizeof(b)=4
    
74.         b=4
    
75.         c=4
    

复制代码

通过程序可以清晰的发现，一开始b、c的值都还是1，但调用动态链接库中的foo函数后，b、c的内存地址没有改变，但值却改变了。
通过readelf -r 命令可以发现，test中并不存在b、c符号，证明上述符号在形成可执行文件时已完成重定位，但通过赋值情况来看，好像是运行加入的libfoo.so中的b将t1.c中的b覆盖了。
说了这么多，可能大家都乱了，现在把我的问题给大家总结以下
在第一个例子中：后加入的全局符号被忽略。
在第二个例子中：后加入的全局符号又覆盖前面被加入符号。
这两个例子从我直观上看是前后矛盾的，所以哪位大神可以给我分析，小弟万分感谢。