《目标文件》

Posted on

编译器编译源码生成的文件就叫目标文件，那目标文件里面到底长什么样？

目标文件从结构上将，就是编译后的可执行文件格式，只是没有经过链接的过程。这两种文件和操作系统、编译器密切相关

可执行文件格式涵盖了程序的编译、链接、装载和执行的各个方面，了解它的结构并深入剖析对理解系统、机理大有好处

可执行文件主要有Windows的PE和Linux的ELF，目标文件如前所说，是未进行链接的中间文件（如Windows的.obj和Linux的.o）。我们可以将其看做同一个类型的文件

除此之外，动态链接库（DLL，如Windows的.dll和Linux的.so）和静态链接库（Windows的.lib和Linux的.a）都按照可执行文件格式存储

但如果要细分这些类型文件，则

  • 可执行文件：如Windows的.exe
  • 共享目标文件：如Windows的.dll和Linux的.so，一种链接器可以将其和其他可重定位文件和共享目标文件链接产生新的目标文件；第二种动态链接器将其与可执行文件结合，成为进程镜像的一部分
  • 可重定位文件：如Windows的.obj和Linux的.o，可以被链接成可执行文件或共享目标文件
  • 核心转储文件：当进程意外终止，系统将进程的地址空间的内容和一些终止信息转储到该文件

目标文件

一般按照信息的不同属性，以节（Section）或段（Segment）的形式存储。这里有个问题，在BIOS代码中，段和节是由区别的，而且是包含的关系，这怎么理解？？？

1
2
3
4
5
6
7
8
9
10
void
readseg(uint32_t pa, uint32_t count, uint32_t offset)
{
        ...

        while (pa < end_pa) {
                readsect((uint8_t*) pa, offset);
                ...
        }
}

一般机器指令放在代码段（.code或.text），全局变量和局部静态变量放在数据段中（.data）

数据和指令分开放置的好处：

  • 数据和指令在装载后，会被映射到两个虚拟内存区域，这两个区域可以设置不同的读写权限，防止指令被修改
  • 指令和数据分离有利于提高程序的局部性，进而提高缓存的命中率
  • 指令共享，当系统运行多个该程序的副本时，内存中只需要保存一份该程序的指令，这将节省大量空间

用例子说话

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int printf(const char * format,...);

int global_init_var = 84;
int global_uninit_var;

void func1(int i)
{
        printf("%d\n",i);
}

int main()
{
        static int static_var = 85;
        static int static_var2;

        int a = 1;
        int b;

        func1(static_var + static_var2 + a + b);

        return a;
}

使用命令objdump -h simplesection.o来查看ELF文件各个段的信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
simplesection.o:     file format elf64-x86-64

Sections:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         00000057  0000000000000000  0000000000000000  00000040  2**0
                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
  1 .data         00000008  0000000000000000  0000000000000000  00000098  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          00000004  0000000000000000  0000000000000000  000000a0  2**2
                  ALLOC
  3 .rodata       00000004  0000000000000000  0000000000000000  000000a0  2**0
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  4 .comment      0000002b  0000000000000000  0000000000000000  000000a4  2**0
                  CONTENTS, READONLY
  5 .note.GNU-stack 00000000  0000000000000000  0000000000000000  000000cf  2**0
                  CONTENTS, READONLY
  6 .eh_frame     00000058  0000000000000000  0000000000000000  000000d0  2**3
                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, DATA

Size很好理解；File off指示了段的偏移量，即段所在位置；CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE则表示段的属性，只有标记了CONTENTS才是在文件中实际存在的

使用参数-s可以段的内容以十六进制展现出来，-d可以将所有包含指令的段反汇编

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
simplesection.o:     file format elf64-x86-64

Contents of section .text:
 0000 554889e5 4883ec10 897dfc8b 45fc89c6  UH..H....}..E...
 0010 488d3d00 000000b8 00000000 e8000000  H.=.............
 0020 0090c9c3 554889e5 4883ec10 c745f801  ....UH..H....E..
 0030 0000008b 15000000 008b0500 00000001  ................
 0040 c28b45f8 01c28b45 fc01d089 c7e80000  ..E....E........
 0050 00008b45 f8c9c3                      ...E...         
Contents of section .data:
 0000 54000000 55000000                    T...U...        
Contents of section .rodata:
 0000 25640a00                             %d..            
Contents of section .comment:
 0000 00474343 3a202855 62756e74 7520372e  .GCC: (Ubuntu 7.
 0010 332e302d 32377562 756e7475 317e3138  3.0-27ubuntu1~18
 0020 2e303429 20372e33 2e3000             .04) 7.3.0.     
Contents of section .eh_frame:
 0000 14000000 00000000 017a5200 01781001  .........zR..x..
 0010 1b0c0708 90010000 1c000000 1c000000  ................
 0020 00000000 24000000 00410e10 8602430d  ....$....A....C.
 0030 065f0c07 08000000 1c000000 3c000000  ._..........<...
 0040 00000000 33000000 00410e10 8602430d  ....3....A....C.
 0050 066e0c07 08000000                    .n......        

Disassembly of section .text:

0000000000000000 <func1>:
   0:	55                   	push   %rbp
   1:	48 89 e5             	mov    %rsp,%rbp
   4:	48 83 ec 10          	sub    $0x10,%rsp
   8:	89 7d fc             	mov    %edi,-0x4(%rbp)
   b:	8b 45 fc             	mov    -0x4(%rbp),%eax
   e:	89 c6                	mov    %eax,%esi
  10:	48 8d 3d 00 00 00 00 	lea    0x0(%rip),%rdi        # 17 <func1+0x17>
  17:	b8 00 00 00 00       	mov    $0x0,%eax
  1c:	e8 00 00 00 00       	callq  21 <func1+0x21>
  21:	90                   	nop
  22:	c9                   	leaveq 
  23:	c3                   	retq   

0000000000000024 <main>:
  24:	55                   	push   %rbp
  25:	48 89 e5             	mov    %rsp,%rbp
  28:	48 83 ec 10          	sub    $0x10,%rsp
  2c:	c7 45 f8 01 00 00 00 	movl   $0x1,-0x8(%rbp)
  33:	8b 15 00 00 00 00    	mov    0x0(%rip),%edx        # 39 <main+0x15>
  39:	8b 05 00 00 00 00    	mov    0x0(%rip),%eax        # 3f <main+0x1b>
  3f:	01 c2                	add    %eax,%edx
  41:	8b 45 f8             	mov    -0x8(%rbp),%eax
  44:	01 c2                	add    %eax,%edx
  46:	8b 45 fc             	mov    -0x4(%rbp),%eax
  49:	01 d0                	add    %edx,%eax
  4b:	89 c7                	mov    %eax,%edi
  4d:	e8 00 00 00 00       	callq  52 <main+0x2e>
  52:	8b 45 f8             	mov    -0x8(%rbp),%eax
  55:	c9                   	leaveq 
  56:	c3                   	retq

接下来一段段分析

代码段

1
2
3
4
5
6
7
Contents of section .text:
 0000 554889e5 4883ec10 897dfc8b 45fc89c6  UH..H....}..E...
 0010 488d3d00 000000b8 00000000 e8000000  H.=.............
 0020 0090c9c3 554889e5 4883ec10 c745f801  ....UH..H....E..
 0030 0000008b 15000000 008b0500 00000001  ................
 0040 c28b45f8 01c28b45 fc01d089 c7e80000  ..E....E........
 0050 00008b45 f8c9c3                      ...E...

最左边是偏移量，因此总共0x57个字节，和上述信息吻合

然后去对照下面的汇编指令，发现一模一样！！！

数据段

.data保存的是初始化的全局静态变量和局部静态变量，也就是static_var global_init_var两个变量

.rodata保存的是只读数据（read only，如const修饰的变量和字符串变量），对应源代码中的%d\n。单独设立该段的好处：在语义上支持了const，OS在加载的时候可以将该段映射到可读的，保证安全性？？

54000000 55000000也可以看出机器的大端的

BSS段

.bss存放未初始化的全局变量和局部静态变量，但有些编译器会将此类变量放在.bss段中，有些则不存放，只是预留一个未定义的全局变量符号

其他段

这些段和其他一些功能有关，先不介绍

我们也可以自定义段，让变量或者代码能放到指定的段中，以实现特定的功能，如为了满足某些硬件的内存和I/O的地址布局，或Linux内核用来完成一些初始化和用户空间复制时出现页错误？？？

GCC提供__attribute__((section("name")))属性来将变量和函数放到name段中

ELF文件

ELF文件的开始是一个File Header，它描述了文件的属性，如文件是否可执行、是静态链接还是动态链接、入口地址、目标硬件、目标OS等信息，除此之外，还有一个Section Table，描述接下来各个段的信息，如各个段在文件的偏移量、段的属性

学习ELF最好的方法就是直接看源码定义，在/usr/include/elf.h，头文件定义分为32位和64位，我们以32位为准

文件头

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* The ELF file header.  This appears at the start of every ELF file.  */

#define EI_NIDENT (16)

typedef struct
{
  unsigned char e_ident[EI_NIDENT];     /* Magic number and other info */
  Elf32_Half    e_type;                 /* Object file type */
  Elf32_Half    e_machine;              /* Architecture */
  Elf32_Word    e_version;              /* Object file version */
  Elf32_Addr    e_entry;                /* Entry point virtual address */
  Elf32_Off     e_phoff;                /* Program header table file offset */
  Elf32_Off     e_shoff;                /* Section header table file offset */
  Elf32_Word    e_flags;                /* Processor-specific flags */
  Elf32_Half    e_ehsize;               /* ELF header size in bytes */
  Elf32_Half    e_phentsize;            /* Program header table entry size */
  Elf32_Half    e_phnum;                /* Program header table entry count */
  Elf32_Half    e_shentsize;            /* Section header table entry size */
  Elf32_Half    e_shnum;                /* Section header table entry count */
  Elf32_Half    e_shstrndx;             /* Section header string table index */
} Elf32_Ehdr;

虽然下图是64位可执行文件的文件头，但是依旧可以寻找一一对应关系

关于魔数还有个小故事，这些故事归结起来就是马屁股和航天飞机，也就是经济学中的路径依赖，映射到互联网就是培养用户习惯，在我们的生活中，处处都是路径依赖，因为事务总不能脱离历史发展，那么有办法摆脱路径依赖，或者有办法找到好的路径吗？

段表

段表描述了ELF文件的每个段的信息，如段名、长度、偏移、读写权利等，编译器、链接器和装载器都是依靠段表来定位和访问每个段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* Section header.  */

typedef struct
{
  Elf32_Word    sh_name;                /* Section name (string tbl index) */
  Elf32_Word    sh_type;                /* Section type */
  Elf32_Word    sh_flags;               /* Section flags */
  Elf32_Addr    sh_addr;                /* Section virtual addr at execution */
  Elf32_Off     sh_offset;              /* Section file offset */
  Elf32_Word    sh_size;                /* Section size in bytes */
  Elf32_Word    sh_link;                /* Link to another section */
  Elf32_Word    sh_info;                /* Additional section information */
  Elf32_Word    sh_addralign;           /* Section alignment */
  Elf32_Word    sh_entsize;             /* Entry size if section holds table */
} Elf32_Shdr;

段的名字只在链接和编译期间有意义，对操作系统没有意义

重定位表

重定位表也是ELF的一个段，对于需要重定位的代码段或数据段，都会有一个相应的重定位表

字符串表

往往把长度不定的字符串集中起来存放，然后使用字符串在表中的偏移来引用字符串

链接的接口：符号

链接的本质就是不同目标文件得到结合，这些目标文件之间必须要固定的规则，才能像积木一样结合在一起

在链接中，将函数和变量统称为符号，符号是链接中的粘合剂，整个链接都是基于符号完成的

每个目标文件都有一个符号表，这个表记录了目标文件中的所有符号，每个符号对应的值，称为符号值，对于变量和函数，符号值就是地址。符号也有分类：

  • 定义在目标文件的全局符号，可以被其他目标文件引用
  • 定义在其他目标文件的全局符号
  • 段名，由编译器产生
  • 局部符号
  • 行号信息

我们只关心全局符号，其他符号对于链接过程都是无关紧要的，readelf objdump nm都能查看符号表

符号表就是一个elf32_sym结构的数组，每个元素对应一个符号

1
2
3
4
5
6
7
8
9
10
11
/* Symbol table entry.  */

typedef struct
{
  Elf32_Word    st_name;                /* Symbol name (string tbl index) */
  Elf32_Addr    st_value;               /* Symbol value */
  Elf32_Word    st_size;                /* Symbol size */
  unsigned char st_info;                /* Symbol type and binding */
  unsigned char st_other;               /* Symbol visibility */
  Elf32_Section st_shndx;               /* Section index */
} Elf32_Sym;

每个元素都会有相关的宏定义，代表不同的含义，具体参考elf.h

特殊符号:在使用ld作为链接器来生成可执行文件时，会定义很多特殊符号，这些符号被定义在ld链接器的链接脚本中。链接器会在程序最终链接成可执行文件的时候将其解析成正确的值，如_executable_start表示程序起始地址 _etext表示代码段结束地址等

编译器默认函数和初始化的全局变量为强符号，未初始化的全局变量为弱符号，也可以通过GCC的__attribute__((weak))定义任何一个强符号为弱符号，且对于强弱符号有以下规则

  • 强符号不能重复定义
  • 优先选择强符号定义
  • 都是弱符号定义时，选择占用空间最大的那个

目标文件会引用定义在其他目标文件中的符号，并在最终链接成可执行文件，如果没有找到该符号定义，就会报错的符号引用称为强引用，反之则为弱引用，可通过__attribute__((weakref))声明对一个外部引用为弱引用