1
// ELF Header 结构（64 位）
2
typedef struct {
3
    unsigned char e_ident[16];  // 魔数 + 类 + 字节序 + 版本
4
    uint16_t e_type;            // 文件类型：REL/EXEC/DYN/CORE
5
    uint16_t e_machine;         // 架构：EM_X86_64=62, EM_AARCH64=183
6
    uint32_t e_version;         // 版本
7
    uint64_t e_entry;           // 入口点虚拟地址
8
    uint64_t e_phoff;           // Program Header Table 偏移
9
    uint64_t e_shoff;           // Section Header Table 偏移
10
    uint32_t e_flags;           // 架构特定标志
11
    uint16_t e_ehsize;          // ELF Header 大小
12
    uint16_t e_phentsize;       // Program Header 条目大小
13
    uint16_t e_phnum;           // Program Header 条目数
14
    uint16_t e_shentsize;       // Section Header 条目大小
15
    uint16_t e_shnum;           // Section Header 条目数
16
    uint16_t e_shstrndx;        // 段名字符串表索引
17
} Elf64_Ehdr;

1
# 创建测试文件
2
cat > hello.c << 'EOF'
3
#include <stdio.h>
4
int global_var = 42;
5
int main() { printf("%d\n", global_var); return 0; }
6
EOF
7

8
gcc -c hello.c -o hello.o     # 编译为目标文件
9
gcc hello.o -o hello           # 链接为可执行文件
10

11
# 查看 ELF Header
12
readelf -h hello.o
13
readelf -h hello
14

15
# 查看段表
16
readelf -S hello.o
17

18
# 查看符号表
19
readelf -s hello.o
20

21
# 查看重定位表
22
readelf -r hello.o
23

24
# 查看段内容
25
readelf -x .text hello.o
26
readelf -x .data hello.o

1
// ELF 符号表条目
2
typedef struct {
3
    uint32_t st_name;    // 符号名（字符串表索引）
4
    uint8_t  st_info;    // 类型 + 绑定
5
    uint8_t  st_other;   // 可见性
6
    uint16_t st_shndx;   // 所在段索引
7
    uint64_t st_value;   // 符号值（地址或偏移）
8
    uint64_t st_size;    // 符号大小
9
} Elf64_Sym;
10

11
// 符号类型
12
// STT_NOTYPE  = 0  未指定
13
// STT_OBJECT  = 1  数据对象（变量）
14
// STT_FUNC    = 2  函数
15
// STT_SECTION = 3  段
16

17
// 符号绑定
18
// STB_LOCAL   = 0  局部符号（文件内可见）
19
// STB_GLOBAL  = 1  全局符号（跨文件可见）
20
// STB_WEAK    = 2  弱符号（可被覆盖）

1
// 重定位条目
2
typedef struct {
3
    uint64_t r_offset;    // 需要修正的位置（段内偏移）
4
    uint32_t r_info;      // 符号索引 + 重定位类型
5
    int64_t  r_addend;    // 附加常量
6
} Elf64_Rela;
7

8
// 常见重定位类型（x86-64）
9
// R_X86_64_64     = 1   绝对地址 64 位
10
// R_X86_64_PC32   = 2   PC 相对 32 位
11
// R_X86_64_PLT32  = 4   PLT 相对（函数调用）
12
// R_X86_64_GOTPCREL = 9 GOT 相对（全局变量）

1
class Relocator:
2
    """简化的重定位处理器"""
3

4
    def relocate(self, section, relocations, symbol_table, base_addr):
5
        """处理重定位"""
6
        data = bytearray(section.data)
7

8
        for rel in relocations:
9
            # 查找符号定义
10
            sym = symbol_table[rel.symbol_index]
11
            sym_addr = base_addr + sym.value
12

13
            # 根据重定位类型修正
14
            offset = rel.offset
15
            if rel.type == 'R_X86_64_64':
16
                # 绝对地址
17
                struct.pack_into('<Q', data, offset, sym_addr + rel.addend)
18
            elif rel.type == 'R_X86_64_PC32':
19
                # PC 相对地址
20
                pc = base_addr + section.offset + offset
21
                value = sym_addr + rel.addend - pc
22
                struct.pack_into('<i', data, offset, value)
23
            elif rel.type == 'R_X86_64_PLT32':
24
                # PLT 相对（动态链接）
25
                plt_addr = self._get_plt_entry(sym)
26
                pc = base_addr + section.offset + offset
27
                value = plt_addr + rel.addend - pc
28
                struct.pack_into('<i', data, offset, value)
29

30
        return bytes(data)

1
; PLT 条目（函数调用跳转到这里）
2
printf@PLT:
3
    jmp *GOT[printf]        ; 第一次：跳转到解析器
4
    push reloc_index        ; 压入重定位索引
5
    jmp resolver            ; 跳转到动态链接器
6

7
; 解析后，GOT[printf] 被更新为实际地址
8
; 后续调用直接跳转到 printf 的实际地址

1
# 错误：链接顺序很重要！
2
gcc main.o -lm -lfoo  # 如果 foo 依赖 math，可能失败
3

4
# 正确：依赖库放在后面
5
gcc main.o -lfoo -lm  # foo 在前，math 在后
6

7
# 原因：链接器从左到右处理，只记住当前未解析的符号
8
# 如果 -lm 在 -lfoo 前面，链接器处理 -lm 时还没有看到对 math 的引用

1
cat > link_test.c << 'EOF'
2
int add(int a, int b) { return a + b; }
3
int main() { return add(3, 4); }
4
EOF
5

6
gcc -c link_test.c -o link_test.o
7

8
# 查看段
9
readelf -S link_test.o
10

11
# 查看符号
12
nm link_test.o
13

14
# 查看反汇编
15
objdump -d link_test.o
16

17
# 查看重定位
18
readelf -r link_test.o

1
# 详细链接输出
2
gcc -Wl,--verbose link_test.o -o link_test 2>&1 | head -100
3

4
# 查看可执行文件的段
5
readelf -l link_test
6

7
# 查看动态依赖
8
ldd link_test
9

10
# 静态链接对比
11
gcc -static link_test.o -o link_test_static
12
ls -l link_test link_test_static

1
# 查看默认链接脚本
2
ld --verbose | grep -A 100 "SECTIONS"
3

4
# 自定义链接脚本（简化）
5
cat > custom.ld << 'EOF'
6
ENTRY(main)
7
SECTIONS {
8
    . = 0x400000;
9
    .text : { *(.text) }
10
    .data : { *(.data) }
11
    .bss  : { *(.bss) }
12
}
13
EOF
14

15
gcc -T custom.ld -nostdlib link_test.o -o link_test_custom

1
// Section Header 条目（64 位）
2
typedef struct {
3
    uint32_t sh_name;       // 段名（字符串表索引）
4
    uint32_t sh_type;       // 段类型
5
    uint64_t sh_flags;      // 段标志
6
    uint64_t sh_addr;       // 虚拟地址（加载后）
7
    uint64_t sh_offset;     // 文件内偏移
8
    uint64_t sh_size;       // 段大小
9
    uint32_t sh_link;       // 关联段索引
10
    uint32_t sh_info;       // 附加信息
11
    uint64_t sh_addralign;  // 对齐要求
12
    uint64_t sh_entsize;    // 条目大小（如果段是表）
13
} Elf64_Shdr;

1
; 优化前：通过 GOT 间接访问
2
movq global@GOTPCREL(%rip), %rax   ; 加载 GOT 条目地址
3
movq (%rax), %rax                    ; 通过 GOT 间接访问
4

5
; 链接器优化后：直接访问（同模块内）
6
leaq global(%rip), %rax              ; 直接 LEA，省去一次内存访问
7
movq (%rax), %rax
8

9
; 更激进优化：如果只读
10
movq global(%rip), %rax              ; 直接 MOV，完全省去 GOT

1
// GOT 的概念结构
2
struct GOT {
3
    // GOT[0]: .dynamic 段的地址（动态链接器使用）
4
    // GOT[1]: link_map 的地址（动态链接器使用）
5
    // GOT[2]: _dl_runtime_resolve 的地址（解析器）
6
    // GOT[3+]: 全局变量/函数的地址
7
    void *dynamic_ptr;
8
    void *link_map_ptr;
9
    void *resolver_ptr;
10
    void *global_var_1;    // 全局变量地址
11
    void *printf_addr;     // printf 函数地址
12
    void *malloc_addr;     // malloc 函数地址
13
    // ...
14
};