编译链接是如何得到可执行文件的呢?

盘古开天辟地!我们写了个C语言源文件,那从源文件到可执行程序这中间又发生了什么?编译,链接这些概念又是什么意思?带着对这些问题的好奇,我查了一些资料。其中,主要参考的是《程序员的自我修养》这本书和一些网上的博客。

windows下经常只需要单击Run或者Debug就可以运行一个C语言程序,这种便利隐藏了背后的复杂机制,而我想知道这背后到底发生了什么。

本文所使用的系统是ubuntu,但这些概念也适用于windows下。

1. 编译源文件的四个阶段

假如我们写了一个很简单的helloworld.c程序:

#include 

int main(int argc, char *argv[])
{
    printf("Hello,World!\n");
    return 0;
}

我们都知道运行命令

gcc helloworld.c -o helloworld

便可以对这个文件进行编译,并命名可执行文件为helloworld。然后运行

./helloworld
Hello,World!

便可以执行该文件,但是这背后又经历了什么呢?

注意:

本文并不是一篇严谨的探讨编译过程的文章,只是我对这个问题了解过程的一个梳理。

1.1 预处理(preprocessing)

在预处理阶段,我们可以简单理解就是处理以"#"开始的那些预处理指令,比如说:

#define,#include,#if,#elif,#else,#endif

预处理器会按照这些指令的意义进行处理,将#define定义的宏进行替换展开,将#include包含的文件整体替换进来。

可以运行命令

gcc -E helloworld.c -o helloworld.i

来得到经过预处理后的文件,检查可以发现预处理确实帮我们把#include的文件包含进来了,另外在文件中还包含了一些行号信息,以便之后程序出错提示错误所在的位置。

1.2 编译(compile)

这一步是将上一步得到的*.i进行编译,得到汇编代码,可以运行命令

gcc -S helloworld.i -o helloworld.s

来得到经过汇编后的文件,该文件的其中一部分如下:

main:
    ...
    leaq    .LC0(%rip), %rcx
    call    puts
    ...

正好对应我们在主程序中调用的函数printf,于是我们知道在这一步是生成了汇编文件。

1.3 汇编(assembly)

这一步是将上一步的汇编代码汇编为具体的机器代码,可以运行命令

gcc -c helloworld.s -o helloworld.o

生成的helloworld.o可以称为目标文件,下面我们对目标文件来检查,帮助理解链接过程。

1.3.1 目标文件的结构

上一步中生成的是目标文件,但这个目标文件还没有经过链接,也就是它其中的一些符号还无法确定,比如说在上面的printf我们就无法确定在哪里去寻找这个函数的具体定义,通过头文件stdio.h我们只是知道了它的定义形式,知道如何去调用它,但是具体执行的时候是需要代码的,那么去哪里找呢?寻找printf并将它的地址写入到我们的程序中就是链接的作用。

我们在系统中经常打交道的文件有

  1. 可执行文件(Executable File),比如Windows下的.exe,或者linux/bin/bash文件
  2. 共享目标文件(Shared Object File),比如Windows下的.dll,或者linux.so文件
  3. 可重定位文件(Relocatable File),我们上面生成的文件便是这种文件,可重定位指的是程序中的一些位置的符号(函数名,变量名)的地址还未确定,在之后的链接阶段需要重新定位

Linux下可以使用命令file来查看文件的具体格式,让我们运行

$ file helloworld.o
helloworld.o: ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped

那么具体来说,目标文件到底包含什么呢?首先一定会包含代码,其次是数据(定义的变量),除此以外,我们还关心的是文件中包含的符号表,它是我们后续执行链接最重要的内容了。

运行命令

$ readelf -S helloworld.o

可以查看我们目标文件的段表,关于段表的详细介绍请查看《程序员的自我修养》这本书。

There are 13 section headers, starting at offset 0x2d8:

节头:
  [号] 名称              类型             地址              偏移量
       大小              全体大小          旗标   链接   信息   对齐
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .text             PROGBITS         0000000000000000  00000040
       0000000000000022  0000000000000000  AX       0     0     1
  [ 2] .rela.text        RELA             0000000000000000  00000228
       0000000000000030  0000000000000018   I      10     1     8
  [ 3] .data             PROGBITS         0000000000000000  00000062
       0000000000000000  0000000000000000  WA       0     0     1
  [ 4] .bss              NOBITS           0000000000000000  00000062
       0000000000000000  0000000000000000  WA       0     0     1
  [ 5] .rodata           PROGBITS         0000000000000000  00000062
       000000000000000d  0000000000000000   A       0     0     1
  [ 6] .comment          PROGBITS         0000000000000000  0000006f
       000000000000002c  0000000000000001  MS       0     0     1
  [ 7] .note.GNU-stack   PROGBITS         0000000000000000  0000009b
       0000000000000000  0000000000000000           0     0     1
  [ 8] .eh_frame         PROGBITS         0000000000000000  000000a0
       0000000000000038  0000000000000000   A       0     0     8
  [ 9] .rela.eh_frame    RELA             0000000000000000  00000258
       0000000000000018  0000000000000018   I      10     8     8
  [10] .symtab           SYMTAB           0000000000000000  000000d8
       0000000000000120  0000000000000018          11     9     8
  [11] .strtab           STRTAB           0000000000000000  000001f8
       000000000000002e  0000000000000000           0     0     1
  [12] .shstrtab         STRTAB           0000000000000000  00000270
       0000000000000061  0000000000000000           0     0     1

我们关心的是上述段表中的2号段表:.rela.text可重定位表。正如我们之前所说的,在链接阶段要对可重定位文件中的一些符号进行重定位,所以我们必须了解哪些符号需要进行定位,而.rela.text就是用来记录相应的符号。

其中,符号表中会包含几种符号:

  1. 在本文件中定义的符号,可以被其它目标文件所引用
  2. 在本文件中引用的符号,但却没有在本文件中定义
  3. ...

我们先运行命令

$ nm helloworld.o
                 U _GLOBAL_OFFSET_TABLE_
0000000000000000 T main
                 U puts

来查看我们的目标文件中的符号表,可以看到我们两个符号mainputs之所以不是printf可能是编译中进行了改变。

让我们运行另外一个命令来详细查看符号表:

$ readelf -s helloworld.o
Symbol table '.symtab' contains 12 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     ......
     9: 0000000000000000    34 FUNC    GLOBAL DEFAULT    1 main
    10: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _GLOBAL_OFFSET_TABLE_
    11: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND puts

又看到了我们熟悉的两个符号,由于main是在本文件中定义的所以它的类型是FUNC函数,且Ndx=1可以得知位于代码段,而puts由于未定义,所以Ndx=UND(undefine),因此通过符号表我们便可以获得哪些符号是在本文件中定义的,哪些符号是需要进行重定位的。

上面我们知道了符号表的存在,下面我们详细说明下链接的过程。

假设我们有了两个文件,a.cb.c。例子来自于《程序员的自我修养》。

/* a.c */
extern int shared;
int main(){
    int a=100;
    swap(&a, &shared);
    return 0;
}

/* b.c */
int shared = 1; // default is global variable, can be accessed by external program

void swap(int *a, int *b){
    *a ^= *b ^= *a ^= *b; // swap value
}

首先使用gcc编译这两个文件

$ gcc -c a.c b.c

然后我们会得到两个文件a.ob.o,分别查看这两个文件的符号表

$ readelf -s a.o
Symbol table '.symtab' contains 13 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     ......
     8: 0000000000000000    81 FUNC    GLOBAL DEFAULT    1 main
     9: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND shared
    11: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND swap
    
$ readelf -s b.o
Symbol table '.symtab' contains 10 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     ......
     8: 0000000000000000     4 OBJECT  GLOBAL DEFAULT    2 shared
     9: 0000000000000000    75 FUNC    GLOBAL DEFAULT    1 swap

于是,我们可以看出,在a.o中只定义了一个全局符号main,而sharedswap都是未定义,而在b.o中,sharedswap则是定义了的。

我们将采用的链接命令为

$ ld a.o b.o -e main -o ab
  • -e 表示main作为主函数入口
  • -o 表示输出文件名

然后查看分配前后地址的分配情况

$ objdump -h a.o
a.o:     文件格式 elf64-x86-64

节:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         00000051  0000000000000000  0000000000000000  00000040  2**0
                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
  1 .data         00000000  0000000000000000  0000000000000000  00000091  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  ......

$ objdump -h b.o
b.o:     文件格式 elf64-x86-64
节:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         0000004b  0000000000000000  0000000000000000  00000040  2**0
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000004  0000000000000000  0000000000000000  0000008c  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  ......

我尝试了好几遍运行命令

$ ld a.o b.o -e main -o ab

但是都提示一个错误

a.o:在函数‘main’中:
a.c:(.text+0x4b):对‘__stack_chk_fail’未定义的引用

不知道为什么,于是我只好使用命令

$ gcc a.o b.o -o ab

但是生成后的文件和作者的就不太一样了,如下

 节:
 Idx Name          Size      VMA               LMA               File off  Algn
 ......
 13 .text         00000222  0000000000000560  0000000000000560  00000560  2**4
 ......
 22 .data         00000014  0000000000201000  0000000000201000  00001000  2**3
                  CONTENTS, ALLOC, LOAD, DATA
 23 .bss          00000004  0000000000201014  0000000000201014  00001014  2**0
                  ALLOC
 24 .comment      0000002b  0000000000000000  0000000000000000  00001014  2**0
                  CONTENTS, READONLY

但是仍然是可以看出VMA(虚拟内存地址)已经被赋值了,而在之前的a.ob.o中都是没有赋值的。

到这一步的意思是经过链接,我们将两个目标文件合成到一个文件中了,并且每个函数都有自己的相对地址,这时候我们就可以给每一个符号赋予地址了。

运行命令

$ readelf -s ab

来查看符号表,只列出相关的内容

Symbol table '.symtab' contains 66 entries:
    Num:    Value          Size Type    Bind   Vis      Ndx Name
    59: 000000000000066a    81 FUNC    GLOBAL DEFAULT   14 main

    62: 00000000000006bb    75 FUNC    GLOBAL DEFAULT   14 swap

    65: 0000000000201010     4 OBJECT  GLOBAL DEFAULT   23 shared

我们可以看出相关符号已经被赋予了具体的地址空间,也就是我们完成了链接过程。

在完成上述过程后,我们运行命令来反汇编查看

$ objdump -d ab
 000000000000066a 
: 66a: 55 push %rbp 66b: 48 89 e5 mov %rsp,%rbp 66e: 48 83 ec 10 sub $0x10,%rsp 672: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax 679: 00 00 67b: 48 89 45 f8 mov %rax,-0x8(%rbp) 67f: 31 c0 xor %eax,%eax 681: c7 45 f4 64 00 00 00 movl $0x64,-0xc(%rbp) 688: 48 8d 45 f4 lea -0xc(%rbp),%rax 68c: 48 8d 35 7d 09 20 00 lea 0x20097d(%rip),%rsi # 201010 693: 48 89 c7 mov %rax,%rdi 696: b8 00 00 00 00 mov $0x0,%eax 69b: e8 1b 00 00 00 callq 6bb # 6bb 6a0: b8 00 00 00 00 mov $0x0,%eax 6a5: 48 8b 55 f8 mov -0x8(%rbp),%rdx 6a9: 64 48 33 14 25 28 00 xor %fs:0x28,%rdx 6b0: 00 00 6b2: 74 05 je 6b9 6b4: e8 87 fe ff ff callq 540 <__stack_chk_fail@plt> 6b9: c9 leaveq 6ba: c3 retq

注意到swap以及变量shared的地址已经被正确地赋值给了程序,作为对比我们查看下在链接之前程序的内容

$ objdump -d a.o
a.o:     文件格式 elf64-x86-64
Disassembly of section .text:
0000000000000000 
: 0: 55 push %rbp 1: 48 89 e5 mov %rsp,%rbp 4: 48 83 ec 10 sub $0x10,%rsp 8: 64 48 8b 04 25 28 00 mov %fs:0x28,%rax f: 00 00 11: 48 89 45 f8 mov %rax,-0x8(%rbp) 15: 31 c0 xor %eax,%eax 17: c7 45 f4 64 00 00 00 movl $0x64,-0xc(%rbp) 1e: 48 8d 45 f4 lea -0xc(%rbp),%rax 22: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 29 29: 48 89 c7 mov %rax,%rdi 2c: b8 00 00 00 00 mov $0x0,%eax 31: e8 00 00 00 00 callq 36 36: b8 00 00 00 00 mov $0x0,%eax 3b: 48 8b 55 f8 mov -0x8(%rbp),%rdx 3f: 64 48 33 14 25 28 00 xor %fs:0x28,%rdx 46: 00 00 48: 74 05 je 4f 4a: e8 00 00 00 00 callq 4f 4f: c9 leaveq 50: c3 retq

我们要注意的是偏移22和偏移31分别对应着sharedswap的调用,而第二列的十六进制代表这条指令,每个指令的后四个字节为地址,可以看出这些地址都是0,这说明在文件a.o中,由于无法确定具体的地址,此时编译器只是将其赋了一个特殊的地址0x0,然后在最后的链接阶段再完成正确的地址赋值。

我们还可以运行命令

$ objdump -r a.o
a.o:     文件格式 elf64-x86-64

RELOCATION RECORDS FOR [.text]:
OFFSET           TYPE              VALUE 
0000000000000025 R_X86_64_PC32     shared-0x0000000000000004
0000000000000032 R_X86_64_PLT32    swap-0x0000000000000004
000000000000004b R_X86_64_PLT32    __stack_chk_fail-0x0000000000000004

其中的offset描述了要重定位的位置。

2. 总结

事实上,在《程序员的自我修养》这本书中作者对于细节的探讨很深入,要想完全理解掌握实在太难。

我主要想总结下关于链接部分。大概的过程就是:

  1. 链接器接收到输入文件
  2. 收集每个输入文件的段表,合成一个全局符号表,这张表里包含所有定义的符号
  3. 如果是静态链接,将多个输入文件合并,进行地址空间的分配,在这一步完成之后所有符号的具体地址就定了
  4. 然后再对每一个输入文件中需要重定位的符号重新定位到正确的地址处

你可能感兴趣的