从源码到可执行文件，编译器到底做了什么

最新推荐文章于 2026-09-02 10:30:19 发布

原创最新推荐文章于 2026-09-02 10:30:19 发布 · 366 阅读

7 ·

本内容遵循CC 4.0 BY-SA版权协议

作者Kruptos，联系方式：843812@qq.com。内容为作者原创，版权归作者所有，转载或分享，请注明出处和作者。未经作者授权，不得用于商业用途。

GEO检测

收录于

操作系统

编译原理

从源码到可执行文件，编译器到底做了什么？

敲下 gcc main.c，几秒钟后一个可执行文件出现了。这中间发生了什么？对很多开发者来说，编译是一个黑盒。今天把盒子拆开：一条编译命令背后，源码经历了预处理、编译、汇编、链接四个界限分明的阶段，每一阶段都有专门的理论支撑。理解全景，你才能定位"编译错误"和"链接错误"到底差在哪。

一、先分清楚：编译 vs 解释

把高级语言变成机器能执行的行为，有两条路径：

编译：先把完整源码翻译成机器码，生成独立产物，再由系统加载执行（C/C++）
解释：不预先生成目标代码，边读源码边执行（早期 BASIC、脚本语言）

但今天的边界已经模糊：Java 编译成字节码再让虚拟机执行，Python 也会把源码编译成字节码。更准确的说法是：任何语言实现都包含某种形式的翻译，区别只在翻译的时机和粒度。

二、四阶段模型：一次编译的完整旅程

传统 C 工具链把"源码→可执行文件"拆成四段：

main.c --预处理--> 纯净翻译单元 --编译--> main.s(汇编) --汇编--> main.o(目标文件) --链接--> a.out(可执行)
   [cpp]              [cc1]              [as]              [ld]

预处理：展开宏、处理条件编译、包含头文件 → 产出纯净的翻译单元
编译：词法分析→语法分析→语义分析→中间表示→优化→代码生成 → 产出汇编代码
汇编：把人类可读的汇编翻译成机器码 → 产出可重定位的目标文件（.o）
链接：把多个目标文件和库合并 → 产出可执行文件或共享库

每阶段处理的信息抽象层次不同，算法和数据结构也不同——这就是它们被拆开的原因，也让每个工具可以独立演进、单独替换。

三、用 gcc -v 把黑盒变白盒

加 -v 参数，gcc 会把每一步摊开给你看：

/usr/lib/gcc/.../cc1 -quiet main.c -o /tmp/ccXXXX.s   ← 真正的编译
as -v --64 -o /tmp/ccXXXX.o /tmp/ccXXXX.s            ← 汇编
collect2 -o a.out /tmp/ccXXXX.o crt1.o ... -lc        ← 链接

你会发现：gcc 本身只是个"司机"，它按顺序调用 cc1（编译）、as（汇编）、ld/collect2（链接）。所谓一次编译命令，其实是精心编排的接力赛。学会看这段日志，链接报错时你能立刻判断问题出在哪一棒。

四、代码演示：亲手跑一遍迷你四阶段

import re

# 阶段 1：预处理（展开宏）
def preprocess(src, macros):
    for k, v in macros.items():
        src = src.replace(k, v)
    return src

# 阶段 2：词法分析（拆 token）
def tokenize(src):
    spec = [("NUM", r"\d+"), ("ID", r"[a-zA-Z_]\w*"), ("OP", r"[+\-*/=]"),
            ("LPAREN", r"\("), ("RPAREN", r"\)"), ("SKIP", r"\s+")]
    rx = re.compile("|".join(f"(?P<{n}>{p})" for n, p in spec))
    return [(m.lastgroup, m.group()) for m in rx.finditer(src) if m.lastgroup != "SKIP"]

# 阶段 3：汇编（伪汇编生成）
def pseudo_asm(tokens):
    out = []
    for kind, val in tokens:
        if kind == "NUM": out.append(f"  li t0, {val}")
        elif kind == "ID": out.append(f"  # 变量 {val}")
        elif kind == "OP" and val == "+": out.append("  add t0, t0, t1")
    return out

# 阶段 4：链接（符号解析）
def link(objs):
    syms = {}
    for o in objs:
        syms.update({s: o["name"] for s in o["defined"]})
    return syms, [s for s in objs[0]["undefined"] if s not in syms]

src = "int main() { int x = 40; x = x + 2; }"
p = preprocess(src, {"int": "", "{": ";", "}": ";"})
toks = tokenize(p)
print("词法分析:", [(k, v) for k, v in toks][:8])
print("伪汇编:")
for line in pseudo_asm(toks)[:6]:
    print(line)
syms, und = link([{"name": "main.o", "defined": ["main"], "undefined": ["printf"]},
                  {"name": "libc.a", "defined": ["printf"], "undefined": []}])
print(f"链接: 解析符号 {syms}, 未解析 {und}")

运行输出：

词法分析: [('ID', 'main'), ('LPAREN', '('), ('RPAREN', ')'), ('ID', 'x'), ('OP', '='), ('NUM', '40'), ('ID', 'x'), ('OP', '=')]
伪汇编:
  # 变量 main
  # 变量 x
  li t0, 40
  # 变量 x
  # 变量 x
  add t0, t0, t1
链接: 解析符号 {'main': 'main.o', 'printf': 'libc.a'}, 未解析 []

虽然简化了，但四阶段的灵魂都在：文本处理→拆 token→生成指令→解析符号。当你亲手走过一遍，再看 GCC/LLVM 的文档，那些术语不再是天书。