程序运行之ELF 符号表

当一个工程中有多个文件的时候，链接的本质就是要把多个不同的目标文件相互粘到一起。就想玩具积木一样整合成一个整体。为了使不同的目标文件之间能够相互粘合，这些目标文件之间必须要有固定的规则才行。比如目标文件B用到了目标文件A中的函数”foo”，那么我们就称目标文件A定义了函数foo,目标文件B引用了函数foo。每个函数和变量都有自己独特的名字，避免链接过程中不同变量和函数之间的混淆。在链接过程中，我们将函数和变量统称为符号。函数或者变量名就是符号名

每一个目标文件都会有一个相应的符号表，这个表里面记录了目标文件中所用到的所有符号。每个定义的符号有一个对应的值，叫做符号值，对于变量和函数来说， 符号值就是它们的地址。我们可以通过nm命令来查看目标文件中的符号结果。

root@zhf-maple:/home/zhf/c_prj# nm main.o

0000000000000000 T func1

0000000000000004 C global_init_var

U _GLOBAL_OFFSET_TABLE_

0000000000000000 D global_var

0000000000000024 T main

U printf

0000000000000000 b static_var2.2257

0000000000000004 d static_var.2256

符号表条目有如下结构(from elf.h):

typedef struct {

ELF32_Word st_name;

ELF32_Addr st_value;

ELF32_Word st_size;

unsigned char st_info;

unsigned char st_other;

Elf32_Half sth_shndx;

} Elf32_Sym;

ELF符号表域说明:

域	描述
st_name	符号串表索引. 串表用于保存符号名.
st_value	符号值: 符号的section索引为SHN_COMMON:符号对齐要求. 重定位文件:离section起始位置的偏移. 执行文件:符号的地址.
st_size	对象大小.
st_info >> 4	高4位定义符号的绑定[binding ]: STB_LOCAL (0) symbol is local to the file STB_GLOBAL (1) symbol is visible to all object files STB_WEAK (2) symbol is global with lower precedence
st_info & 15	低4位定义符号的类型: STT_NOTYPE (0)    无类型 STT_OBJECT (1)    数据对象(变量) STT_FUNC (2)      函数 STT_SECTION (3)   section名 STT_FILE (4)      文件名
st_other	未使用.
st_shndx	定义符号sectiond的索引.特殊的section数包括: SHN_UNDEF (0x0000)   未定义section SHN_ABS (0xfff1)     绝对, 不可重定位符号 SHN_COMMON (0xfff2) 不分配, 外部变量

符号所在的段

宏定义名	值	说明
SHN_ABS	0xfff1	该符号包含了一个绝对值，比如表示文件名的符号
SHN_COMMON	0xfff2	表示该符号是一个"COMMON块"的符号 一般来说，未初始化的全局符号定义就是这种类型的。
SHN_UNDEF	0	该符号在本目标文件中被引用到，但是定义在其他目标文件中

我们还是通过readelf命令来查看下main.o文件中的符号。下面的结果和上面的表可以进行一一对应。

root@zhf-maple:/home/zhf/c_prj# readelf -s main.o

Symbol table '.symtab' contains 17 entries:

Num:    Value          Size Type    Bind   Vis      Ndx Name

0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND

1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS main.c

2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1

3: 0000000000000000     0 SECTION LOCAL  DEFAULT    3

4: 0000000000000000     0 SECTION LOCAL  DEFAULT    4

5: 0000000000000000     0 SECTION LOCAL  DEFAULT    5

6: 0000000000000004     4 OBJECT  LOCAL  DEFAULT    3 static_var.2256

7: 0000000000000000     4 OBJECT  LOCAL  DEFAULT    4 static_var2.2257

8: 0000000000000000     0 SECTION LOCAL  DEFAULT    7

9: 0000000000000000     0 SECTION LOCAL  DEFAULT    8

10: 0000000000000000     0 SECTION LOCAL  DEFAULT    6

11: 0000000000000000     4 OBJECT  GLOBAL DEFAULT    3 global_var

12: 0000000000000004     4 OBJECT  GLOBAL DEFAULT  COM global_init_var

13: 0000000000000000    36 FUNC    GLOBAL DEFAULT    1 func1

14: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _GLOBAL_OFFSET_TABLE_

15: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND printf

16: 0000000000000024    40 FUNC    GLOBAL DEFAULT    1 main

弱符号与强符号

我们经常在编程中碰到一种情况叫符号重复定义。多个目标文件中含有相同名字全局符号的定义，那么这些目标文件链接的时候将会出现符号重复定义的错误。比如我们在目标文件A和目标文件B都定义了一个全局整形变量global，并将它们都初始化，那么链接器将A和B进行链接时会报错：

1 b.o:(.data+0x0): multiple definition of `global'

2 a.o:(.data+0x0): first defined here

这种符号的定义可以被称为强符号（Strong Symbol）。有些符号的定义可以被称为弱符号（Weak Symbol）。对于C语言来说，编译器默认函数和初始化了的全局变量为强符号，未初始化的全局变量为弱符号(C++并没有将未初始化的全局符号视为弱符号)。我们也可以通过GCC的"__attribute__((weak))"来定义任何一个强符号为弱符号。注意，强符号和弱符号都是针对定义来说的，不是针对符号的引用。比如我们有下面这段程序：

extern int ext;

int weak1;

int strong = 1;

int __attribute__((weak)) weak2 = 2;

int main()

{

return 0;

}

上面这段程序中，"weak"和"weak2"是弱符号，"strong"和"main"是强符号，而"ext"既非强符号也非弱符号，因为它是一个外部变量的引用。链接器会按照如下的规则处理被多次定义的全局符号：

规则1：不允许强符号被多次定义。

规则2：如果一个符号在某个目标文件中是强符号，在其他文件中都是弱符号，那么选择强符号。

规则3：如果一个符号在所有的目标文件中都是弱符号，那么选择其中占用空间最大的一个。

我们来看一个实际的例子：在下面的代码中f()没有被定义，因此会报错

int main()

{

f();

return 0;

}

g++  -o bin/Debug/linux_c obj/Debug/chapter8.o obj/Debug/main.o

obj/Debug/main.o：在函数‘main’中：

/home/zhf/codeblocks_prj/linux_c/main.c:15：对‘f’未定义的引用

如果将代码改成如下：

void __attribute__((weak)) f();

int main()

{

if (f){

f();

}

return 0;

}

居然编译通过了，甚至成功执行！让我们看看为什么？

首先声明了一个符号f()，属性为weak，但并不定义它，这样，链接器会将此未定义的weak symbol赋值为0，也就是说f()并没有真正被调用，试试看，去掉if条件，肯定core dump！

我们甚至可以定义强符号来override弱符号：

test.c中代码如下

#include<stdlib.h>

#include<stdio.h>

void __attribute__((weak)) f(){

printf("original f()\n");

}

int main(int argc,char *argv[]){

f();

return 0;

}

test1.c中的代码如下：

#include <stdio.h>

void f(void){

printf("override f()\n");

}

执行结果如下：

root@zhf-maple:/home/zhf/c_prj# gcc -c test.c test1.c

root@zhf-maple:/home/zhf/c_prj# gcc -o test test.o test1.o

root@zhf-maple:/home/zhf/c_prj# ./test

override f()

在Linux程序的设计中，如果一个程序被设计成可以支持单线程或多线程的模式，就可以通过弱引用的方法来判断当前的程序是链接到了单线程的Glibc库还是多线程的Glibc库（是否在编译时有-lpthread选项），从而执行单线程版本的程序或多线程版本的程序。我们可以在程序中定义一个pthread_create函数的弱引用，然后程序在运行时动态判断是否链接到pthread库从而决定执行多线程版本还是单线程版本：

#include <stdio.h>

#include <pthread.h>

int pthread_create( pthread_t*, const pthread_attr_t*,

void* (*)(void*), void*) __attribute__ ((weak));

int main()

{

if(pthread_create)

{

printf("This is multi-thread version!\n");

// run the multi-thread version

// main_multi_thread()

}

else

{

printf("This is single-thread version!\n");

// run the single-thread version

// main_single_thread()

}

}

执行结果如下：

$ gcc pthread.c -o pt

$ ./pt

This is single-thread version!

$ gcc pthread.c -lpthread -o pt

$ ./pt

This is multi-thread version!