第 2 章 程序如何真正运行

1
2
3
4
5
6
7
8

/* 证明预处理只是文本替换：出错发生在 .i 阶段，而不是 .s 阶段 */
#define SQUARE(x) ((x) * (x))
int main(void) {
    /* 宏没有类型也没有求值顺序，SQUARE(i++) 展开成 ((i++) * (i++))，i 被加两次 */
    /* 这正是 C++ 引入 inline 函数的核心动机之一：保留类型检查与单次求值 */
    int i = 3;
    return SQUARE(i);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

   源码到运行：每一步的产物在哪一层

  main.c ──[cpp]──▶ main.i ──[cc1]──▶ main.s ──[as]──▶ main.o
                                                  │
   libc.so / crt1.o / crti.o ─────────────────────┤
                                                  ▼
                                          [ld 链接]──▶ a.out  (ELF executable)
                                                          │
                            内核 execve 读 ELF 头 ─────────┤
                                                          ▼
                            ld.so 装载依赖 ──▶ 重定位 ──▶ _start ──▶ __libc_start_main ──▶ main

1
2
3
4
5

readelf -h ./a.out        # ELF 头：类型(EXEC/DYN)、入口地址、程序头偏移
readelf -l ./a.out        # 段视图：哪些节被合并、虚拟地址与权限位
readelf -S ./a.out        # 节视图：每个节的地址、偏移、大小、对齐
readelf -s ./a.out | grep main   # 符号定义与绑定类型（T 代码/D 数据/B bss/U 未定义）
readelf -d ./a.out        # 动态段：NEEDED 依赖库、RPATH/RUNPATH、SONAME

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

  首次调用 printf 的完整指令流（延迟绑定，lazy binding）

  调用方 main                     .plt（只读，可共享）            .got.plt（可写，每进程一份）
  ─────────────────────────       ──────────────────────         ──────────────────────────
  call printf@plt ───────────▶  printf@plt:                     [0] .dynamic 地址
                                    jmp  *GOT[printf] ──┐        [1] link_map 指针
                                                        │        [2] _dl_runtime_resolve
                                                        │        [3] 0x...4006  ◀─ 回填后
                                                        ▼        [4] loader 桩地址（初始值）
                                 GOT[printf] 初始指向 plt+6（不是 printf！）
                                                        │
                                    push $index; jmp .plt[0] ──▶ _dl_runtime_resolve
                                                                   │ 查 .dynsym/.dynstr
                                                                   ▼
                                                            回填 GOT[printf] = 真实地址
                                                            然后跳到真实 printf

  第二次调用 printf：
  call printf@plt ──▶ jmp *GOT[printf] ──▶ 直接进 libc（只多一次间接跳转）

  与之相对：-z now / -Wl,-z,now（full RELRO）在加载时把所有 GOT 一次填好，
  jmp *GOT 第一次就命中真实地址，代价是启动多一次全量符号解析。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/* 拦截 libc 的 malloc：不改一行业务代码就把分配记进日志，是内存排查的常用手段 */
#define _GNU_SOURCE
#include <dlfcn.h>
#include <stddef.h>

/* 用 RTLD_NEXT 取"下一个"同名符号，否则 dlsym("malloc") 会查到我们自己，造成无限递归 */
static void *(*real_malloc)(size_t) = NULL;

void *malloc(size_t size) {
    if (real_malloc == NULL) {
        real_malloc = dlsym(RTLD_NEXT, "malloc");  /* 首次调用才解析，避免 ld.so 重入死锁 */
    }
    /* 这里只允许用 write 这类不分配内存的接口：printf 自身会 malloc 而重入本函数 */
    return real_malloc(size);
}

 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

  x86-64 Linux 进程虚拟地址空间（高地址在上；箭头为增长方向）

  0xFFFFFFFFFFFFFFFF  ┌───────────────────────────────┐
                      │ 内核空间（用户不可访问）        │
  0x00007FFFFFFFFFFF  ├───────────────────────────────┤
                      │ 栈 stack                      │  ← 向下增长
                      │   [环境变量/argv][局部变量]    │
                      │   ↓ rsp 每压栈一次递减 8 字节  │
                      ├───────────────────────────────┤  ◀── 栈与 mmap 之间是巨大的空闲"护栏"
                      │   （大段未映射空洞）           │      任何越界访问都直接 SIGSEGV
                      ├───────────────────────────────┤
                      │ mmap 区（共享库、大块 malloc、  │  ← 向下增长（自高地址向低地址分配）
                      │ 线程栈、mmap 文件映射）         │
                      ├───────────────────────────────┤
                      │   （空洞）                     │
                      ├───────────────────────────────┤
                      │ 堆 heap                       │  ← 向上增长（brk 抬高 program break）
                      │   ↑ 小块 malloc（< 128 KB）     │
                      ├───────────────────────────────┤
                      │ .bss   未初始化全局量          │  读写
                      │ .data  已初始化全局量          │  读写
                      │ .rodata 常量与字面量           │  只读
                      │ .text  机器码                  │  只读+可执行
  0x0000000000400000  └───────────────────────────────┘  （非 PIE 的传统固定基址）
                      │ 低地址：NULL 页（mmap_min_addr 保留，用于拦空指针解引用） │
                    0 └───────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

  单个栈帧的内存布局（地址从高到低排列，x86-64，红区 red zone 为 128 字节）

  高地址
        ┌──────────────────────────────┐
        │ 调用者的栈帧 ...              │
        ├──────────────────────────────┤
        │ 第 7 个及以后的参数           │  调用者负责压入
        ├──────────────────────────────┤
   rbp+8│ 返回地址 return address       │  ← call 指令自动压入，= 下一条指令地址
   rbp+0│ 调用者的 rbp（saved rbp）     │  ← push rbp 压入
        ├──────────────────────────────┤  ◀── rbp 指向这里，帧内一切用 rbp-偏移 寻址
   rbp-8│ 局部变量 / 被调用者保存寄存器 │
   rbp-16│ ...                          │
        │                              │  ← sub rsp, N 一次性预留
        ├──────────────────────────────┤  ◀── rsp
        │ 红区（128 字节，叶子函数可直接 │  信号处理器的栈帧会覆盖红区，
        │ 使用而无需调整 rsp）           │  这是 volatile 变量必须落栈的原因之一
  低地址 └──────────────────────────────┘

  函数序言：push rbp; mov rbp, rsp; sub rsp, N
  函数尾声：leave（= mov rsp, rbp; pop rbp）; ret

1
2
3
4
5
6
7
8

/* 用 union 而非指针强转：union 的成员共享同一块存储，是标准允许的类型双关（type punning） */
#include <stdio.h>
int main(void) {
    union { unsigned int i; unsigned char c[4]; } u;
    u.i = 0x01020304u;   /* 0x01 是最高有效字节，看它落在低地址还是高地址 */
    printf("%s\n", u.c[0] == 0x04 ? "little-endian" : "big-endian");
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <stdio.h>
struct A { char a; int b; char c; };                 /* 1 + 3填充 + 4 + 1 + 3尾部填充 = 12 */
struct B { char c; char a; int b; };                 /* 调整顺序后只需 4 字节填充 = 8 */
struct C { double d; char c; int i; };               /* 8 + 1 + 3填充 + 4 = 16（尾部已对齐） */
struct D { char a; long b; char c; } __attribute__((packed));  /* 强制紧凑 = 10 */
struct E { char a; long b; char c; };                /* 1 + 7填充 + 8 + 1 + 7尾部填充 = 24 */
int main(void) {
    /* 静态断言在编译期拦住"以为 sizeof 等于字段和"的误改，比运行时打印更早暴露问题 */
    _Static_assert(sizeof(struct A) == 12, "A");
    _Static_assert(sizeof(struct B) == 8,  "B");
    _Static_assert(sizeof(struct E) == 24, "E");
    printf("%zu %zu %zu %zu\n", sizeof(struct A), sizeof(struct B),
           sizeof(struct C), sizeof(struct D));
    return 0;
}

1
2
3
4
5
6
7
8

/* 三个控制内联的手段：always_inline 是强制、noinline 是禁制、hot 影响代码布局 */
static inline __attribute__((always_inline)) int add_one(int x) { return x + 1; }

/* 大函数强制内联会挤掉 icache，这里显式禁止，交给编译器按调用点热度决定 */
__attribute__((noinline)) void heavy_path(void) { /* 复杂逻辑 */ }

/* 标记热路径让链接器把该函数排在一起，提升 icache 与 iTLB 命中率 */
__attribute__((hot)) int fast_path(int x) { return add_one(x); }