程序运行之ELF 符号表

Posted 2020-11-07 一张红枫叶

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

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

[email protected]:/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文件中的符号。下面的结果和上面的表可以进行一一对应。

[email protected]:/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");

}

执行结果如下：

[email protected]:/home/zhf/c_prj# gcc -c test.c test1.c

[email protected]:/home/zhf/c_prj# gcc -o test test.o test1.o

[email protected]:/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!