GCC 从入门到实战：编译四阶段 + 常用命令速查

GCC（GNU Compiler Collection）是 Linux 下最常用的 C/C++ 编译器，也是嵌入式开发中不可或缺的工具。

基本格式：gcc [选项] 源文件 -o 输出文件

1. GCC 编译的四个阶段总览

源码(.c) → 预处理(.i) → 编译(.s) → 汇编(.o) → 链接(可执行文件)
             -E          -S          -c         默认

选项字母：-E → -S → -c → -o（ESCo，谐音"逃跑"）
文件后缀：.i → .s → .o → a.out

gcc -Wall -save-temps main.c -o main
# 会生成：main.i  main.s  main.o  main

1.1 预处理（-E）：展开宏、搬入头文件

还没开始翻译，先把"缩写"和"引用"全部展开，整理成一份完整的 C 代码。

预处理器在这一步做三件事：

1. #include → 把头文件内容原封不动搬进来（比如 stdio.h 里 printf 的声明）
2. 宏替换 → 把所有宏"文本替换"掉
3. 删除注释 → 去掉所有 // 和 /* */

// main.c
#include <stdio.h>
#define ADD(a, b) (a) + (b)

int main() {
    int x = ADD(1, 2);
    printf("x=%d\n", x);
    return 0;
}

gcc -E main.c -o main.i   # 预处理

打开 main.i，看到：

• #include <stdio.h> 被替换成了近千行 stdio.h 的源码
• ADD(1, 2) 被替换成了 (1) + (2) —— 纯文本替换，不做计算

// main.i（简化示意）
// ... stdio.h 展开的几千行声明 ...
extern int printf(const char *, ...);

int main() {
    int x = (1) + (2);        // ADD(1,2) 被替换了
    printf("x=%d\n", x);
    return 0;
}

1.2 编译（-S）：C 代码 → 汇编代码

这是「高级语言 → 低级语言」的关键一步，也是最"智能"的一步。

编译器在这一步做了三件事：

1. 语法检查 — 少写分号、括号不匹配，这一步报错
2. 优化 — 比如 (1) + (2) 直接优化成 3，减少运行时计算
3. 翻译 — 把 C 的 if、for、printf 对应成汇编指令（MOV、ADD、CALL）

上一步生成了 main.i，继续往下走：

gcc -S main.i -o main.s   # 从预处理结果编译，更连贯
gcc -S main.c -o main.s   # 直接从源码编译也行，GCC 会自动先预处理

生成的 main.s（文本格式，人类能看懂）：

    .section  .rodata        ; 只读数据段（存放字符串常量）
.LC0:
    .string "x=%d\n"        ; printf 的格式字符串

    .text                    ; 代码段（存放可执行指令）
    .globl  main             ; 声明 main 为全局符号
main:
    pushq   %rbp
    movq    %rsp, %rbp
    subq    $16, %rsp
    movl    $3, -4(%rbp)     ; (1)+(2) 被优化成 3 了
    movl    -4(%rbp), %eax
    movl    %eax, %esi       ; 第2个参数：x 的值
    leaq    .LC0(%rip), %rax
    movq    %rax, %rdi       ; 第1个参数：格式字符串 "x=%d\n"
    movl    $0, %eax
    call    printf@PLT       ; 调用 printf
    movl    $0, %eax         ; return 0
    leave
    ret

1.3 汇编（-c）：汇编代码 → 机器码

这一步很"机械"，没有优化，只是把每条汇编指令一对一直译成二进制数。

gcc -c main.s -o main.o   # 汇编生成机器码文件
gcc -c main.c -o main.o   # 直接从源码汇编生成机器码，GCC 会自动先预处理、编译

汇编器（as）把每条指令对应成 CPU 能直接执行的二进制数，比如：

• MOV → 01010001
• ADD → 00101100

1.4 链接：把所有 .o 拼成可执行文件

你的代码里写了 printf，但你只是"调用"了它，真正的实现在标准库（libc）里。链接就是把你的代码和库的代码拼到一起。

gcc main.o -o main   # 链接生成可执行文件

链接器（ld）在这一步做的事：

1. 合并目标文件 — 多个 .o 文件合并成一个（多文件项目时）
2. 解析符号引用 — 你的代码调用了 printf，链接器去 libc 里找到它的机器码，填上地址
3. 生成可执行文件 — 加上程序入口地址、内存布局等信息，生成最终能运行的文件

2. 常用选项速查

3. 警告与调试

# 建议始终带上 -Wall
gcc -Wall main.c -o main

# 更严格的警告
gcc -Wall -Wextra main.c -o main

# 把警告当错误，有警告就编译失败
gcc -Wall -Werror main.c -o main

# 生成调试信息，配合 gdb 使用
gcc -g main.c -o main
gdb ./main

AddressSanitizer：内存错误检测利器

# 编译时加 -fsanitize=address，能检测数组越界、空指针等
gcc -g -fsanitize=address main.c -o main

// bug.c — 故意越界
int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};
    return arr[10];  // 越界！
}

$ gcc -g -fsanitize=address bug.c -o bug && ./bug
# ERROR: AddressSanitizer: stack-buffer-overflow
#     #0 0x4005e7 in main bug.c:4  ← 直接告诉你第几行出错

4. 优化等级

gcc -O0 main.c -o main   # 调试用
gcc -Os main.c -o main   # 嵌入式用，最小体积
gcc -O2 main.c -o main   # 发布用

5. 头文件搜索路径

搜索顺序：

gcc -I ./include -I ./drivers/inc main.c -o main

-D：命令行定义宏

# 等价于在代码开头写 #define DEBUG 和 #define VERSION 3
gcc -DDEBUG -DVERSION=3 main.c -o main

6. 多文件编译

# 方式1: 一步编译
gcc main.c utils.c -o app

# 方式2: 分步编译（大项目推荐，修改单文件只需重新编译该文件）
gcc -c main.c -o main.o
gcc -c utils.c -o utils.o
gcc main.o utils.o -o app

7. Makefile — 自动化多文件编译

文件多了每次手敲 gcc 太累，Makefile 帮你一个 make 搞定。

基本语法

目标: 依赖
    命令           # 注意: 必须用 Tab 缩进，不能用空格!

示例：编译 main.c + utils.c

CC = gcc
CFLAGS = -Wall -g

app: main.o utils.o
    $(CC) $^ -o $@

%.o: %.c
    $(CC) $(CFLAGS) -c $< -o $@

clean:
    rm -f *.o app

%.o: %.c 是模式规则，意思是"任何 .o 文件都由同名 .c 文件编译而来"，不用再给每个文件单独写规则了。

使用方法

make          # 编译项目（只重新编译修改过的文件）
make clean    # 清理所有编译产物
make -j4      # 4线程并行编译（大项目更快）

常用变量

进阶：区分调试/发布版本

CC = gcc
CFLAGS = -Wall -std=gnu11

ifeq ($(DEBUG), 1)
    CFLAGS += -g -Og -DDEBUG -fsanitize=address
    LDFLAGS += -fsanitize=address
else
    CFLAGS += -O2 -DNDEBUG
endif

app: main.o utils.o
    $(CC) $(LDFLAGS) $^ -o $@

%.o: %.c
    $(CC) $(CFLAGS) -c $< -o $@

clean:
    rm -f *.o app

make DEBUG=1    # 调试版本
make            # 发布版本

为什么用 Makefile？

8. 链接库

# 链接数学库 libm（使用 math.h 中的 sin/cos/sqrt 等）
gcc main.c -o main -lm

# 链接多线程库 libpthread
gcc main.c -o main -lpthread

# 指定头文件搜索路径
gcc -I./include main.c -o main

# 指定库文件搜索路径
gcc -L./lib main.c -o main -lmylib

静态链接 vs 动态链接

# 强制静态链接
gcc -static main.c -o main

# 查看动态库依赖
ldd main

9. C 语言标准

gcc -std=c99 main.c -o main    # C99（for循环内定义变量、// 注释）
gcc -std=c11 main.c -o main    # C11（多线程、泛型宏）
gcc -std=c17 main.c -o main    # C17（bug修复版）
gcc -std=gnu11 main.c -o main  # C11 + GNU 扩展（GCC 默认，支持 typeof 等）

10. 嵌入式开发速查

交叉编译基本用法

# ARM Cortex-M（裸机）
arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -Os main.c -o main.elf

# ARM Linux（开发板应用）
arm-linux-gnueabihf-gcc -Wall -O2 main.c -o main

嵌入式常用选项

体积优化三件套

arm-none-eabi-gcc \
    -Os \                           # 优化体积
    -ffunction-sections -fdata-sections \  # 每个函数/数据单独成段
    -Wl,--gc-sections \             # 链接时裁剪未使用的段
    main.c -T stm32.ld -o firmware.elf

11. GCC 配套工具速查

12. 常见报错与排查

13. 实用场景速查

14. 自测题

看看你掌握了多少，答案都在文章里 👆

15. 思考题

这些问题没有标准答案，动手试试或查资料，能帮你加深理解 🤔

1. 为什么嵌入式中访问硬件寄存器必须用 volatile？
提示：想想编译器的优化阶段会对 while (*reg == 0) {} 做什么。

2. gcc -O2 main.c -o main 和 gcc main.c -O2 -o main 的结果一样吗？GCC 选项的顺序重要吗？
提示：动手试试，对比生成的可执行文件。

3. 为什么大型项目用分步编译（先 -c 再链接）而不是一步编译？
提示：如果项目有 100 个 .c 文件，你只改了其中 1 个，两种方式分别需要编译多少个文件？

4. #include <stdio.h> 和 #include "stdio.h" 都能编译通过，它们的搜索路径有什么不同？为什么推荐系统头文件用 <>？

5. 用 gcc -save-temps main.c -o main 生成所有中间文件后，打开 main.i 看看有多少行。为什么一个只有 10 行的 C 文件，预处理后会变成几千行？

6. 链接器报 undefined reference 和编译器报 implicit declaration of function，虽然都和"函数找不到"有关，但本质原因不同。请解释区别。
提示：一个是找不到声明，一个是找不到定义（机器码）。

参考资料

• GCC 官方文档
• GCC 优化选项
• GCC 警告选项
• Search Path