Goose 编译器内幕:从源码到单个 C 文件的 7 阶段编译流水线

原创2026-10-24 18:34:061,983 阅读

Goose 编译器内幕:从源码到单个 C 文件的 7 阶段编译流水线

Goose 是一款内存安全的系统编程语言,其 Goose 编译器最独特的设计是:把整个 .goose 程序编译成单个纯 C 文件,随后既能交给任意 C 编译器构建,也能用编译器内置的 TinyCC 直接在内存中 JIT 运行。本文带你深入 Goose 编译器源码,拆解这条「从源码到 C 文件」的 7 阶段编译流水线:每一阶段由哪些源码文件负责、输入输出是什么、新手能亲眼看到哪些产物,一次讲清楚。

Goose 编译器项目标志:一只极简风格的黑色鹅

🗺️ 7 阶段编译流水线:一张表看懂全局

整条流水线由 src/main.cpp 中的 compile 驱动按序调度,各阶段一览如下(与官方笔记 docs/implementation.md 第 1 节一致):

# 阶段 关键源码 输入 → 输出
1 解析 Parse src/lexer.h、src/parser.h .goose 源文件(自动跟随 import)→ AST 抽象语法树
2 名称解析 Resolve src/resolve.h 按字面书写的类型名 → 具体的 struct/enum/泛型,别名被展开
3 类型检查 Typecheck src/typecheck.h 等 typecheck*.h 带注释的 AST → 每个特化(specialization)一份 FnSpec 与 struct/enum 实例
4 优化 Optimize src/optimize.h 等 optimize_*.h 存活特化 → 被内联、常量折叠、尾递归改写后的函数体
5 边界检查消除 BCE src/bce.h 存活特化 → 标注哪些索引/切片检查永远不会失败
6 代码生成 Codegen src/codegen.h 等 codegen*.h 存活特化与全局变量 → 一个 C 文件(含嵌入的运行时)
7 JIT / 构建 src/jit.h 生成的 C 文本 → TinyCC 内存中直接运行,或交给 C 编译器链接

几个值得注意的驱动细节:

  • 编译在一个 64 MB 栈的专用线程上执行(src/main.cpp 的 RunOnCompilerStack),因为类型检查会递归到与程序编译期调用路径一样深;
  • 每阶段完成时都会打印一行进度,如 parsed ok: ...、typechecked ok: ... optimized -O1、bce: elided N/M index checks、wrote out.c (N bytes),新手可以凭这几行确认程序走到了流水线的哪一步;
  • 优化级别 -O0/-O1/-O2 只影响内联阈值:goose run 默认 -O1,goose build 默认 -O2。

🔤 阶段 1+2:词法扫描、语法解析与名称解析

词法器(src/lexer.h)是一个手写扫描器,用一个巨大的 switch 逐字符识别标识符、整数、浮点、字符串与标点,并用 X-macro 表定义全部 token 集合。解析器(src/parser.h)采用递归下降,一个语法构造对应一个函数。

真正的重活发生在 src/main.cpp 的 ParseProgram:它不只是解析单个文件,而是沿 import 传递加载整个程序——程序自己的包、根文件声明的第三方包、标准库(stdlib/std.goose),每个文件只解析一次。解析完成后还会按导入图的后序遍历排序全局变量,保证「被导入文件的全局先初始化」。

阶段 2 的名称解析(src/resolve.h 的 ResolveTypeNames)把所有解析期占位的类型名就地改写为具体的 struct/enum 类型,别名(alias)在此被彻底展开——从此以后「这是否为整数」只是一个类型种类比较,不再需要查名字。

🔍 阶段 3:类型检查与「每个调用一份特化」

类型检查器(src/typecheck.h,按职责拆分为 typecheck_types.h、typecheck_calls.h 等多个头文件)是全编译器最核心的一环,因为它同时承担三件大事:

  1. 类型检查:每个表达式求出类型,越界访问、不可变写入等非法操作在此被拒绝;
  2. 引用根推断:Goose 没有生命周期注解,编译器为每个引用/切片推断它「扎根于」哪个变量,并保证引用不会比其宿主活得久;
  3. 泛型特化:Goose 的泛型是「编译期实体」——一个函数在每个不同的调用点各生成一份特化(FnSpec),函数体被克隆并按该调用的具体类型重新标注。函数值(闭包)也是编译期概念,xs.filter() { it > 0 } 最终编译成它看起来的循环。

这也是编译栈需要 64 MB 的原因:检查 main 会沿调用链递归展开,直到整个可达函数图都被特化完毕。

⚡ 阶段 4:优化器做了哪些重写

优化器(src/optimize.h 及 optimize_basecase.h、optimize_tre.h、optimize_loops.h、optimize_reassoc.h)在 BCE 之前就地改写已检查的函数体。它的唯一铁律:任何改写都不能改变 release 构建的计算结果,且会把运行时中止的操作(除零、失败转换、越界索引)折叠成值。主要重写包括:

  • 内联:调用被替换为被调者参数绑定加函数体副本,再重新折叠让常量级联。阈值随优化级别变化(-O1 为 8/48,-O2 为 16/96),循环内的调用阈值放宽 4 倍;
  • 常量传播与折叠:字面量初始化、永不写入的局部变量在使用处直接替换为字面量;整数/浮点运算、比较、if 常量条件等在检查位宽下折叠;
  • 尾递归消除(optimize_tre.h):把 while 形态的尾递归改写为受控循环;
  • 基数情形内联(optimize_basecase.h):处理递归的小情形直接展开。

全部内联完成后会再做一次可达性分析——所有调用都被内联掉的特化就此死亡,代码生成会跳过它们。

🛡️ 阶段 5:边界检查消除(BCE)的巧妙之处

Goose 的下标访问默认都带边界检查,但 src/bce.h 会在优化之后、代码生成之前,证明哪些检查永远不会触发并直接删掉。它使用流敏感的「差分约束」域:每个状态记录形如 l <= r + c 的事实,一次查询就是图上一次最短路(Bellman-Ford);变量写入不删除旧事实而是开启新的「代数代」,再为 push/pop 等长度变化建立跨代桥接,因此像 for i in n 这类循环入口快照都能被精确追踪。

这一步只要求可靠(sound):删错的检查会让程序语义改变,所以编译器对拿不准的一律保留。你可以用 --no-bce 跳过该阶段,或加 --bce-lines 查看每一行删掉/保留了多少检查。

📄 阶段 6:代码生成,输出单个 C 文件

代码生成器(src/codegen.h,按类型、帧、构造、语句、调用、渲染等主题拆成 11 个 codegen_*.h)把存活特化渲染成一个自包含的 C 文件,遵循规范附录 C 的 C 表示法。运行时(src/runtime/runtime.h 等 C99 源码)被预先嵌入编译器(src/runtime_inline.h),由驱动按序拼装:编译器特性定义 → 运行时 → 生成的程序。程序名统一带 _g 后缀,与 C 关键字和运行时 gs_ 前缀隔离。

两种输出形态:

  • goose -o hello.c hello.goose:写出程序 C,链接 goose --emit-runtime 生成的一次性运行时目标文件;
  • goose build hello.goose:C 文件写入 GOOSE_HOME 下的构建目录,随后用本机 C 编译器编译链接成可执行文件(可用 --dry-run 只打印命令)。

生成的 C 对任何 C 后端都相同——clang 能向量化并调度边界检查已消除的循环,这正是 Goose 基准成绩优于 C++/Rust 的来源之一(见 bench/results.md)。

🚀 阶段 7:TinyCC JIT,零构建直接运行

最后一阶段由 src/jit.h 完成:TinyCC 以 vendor 形式放在 third_party/tinycc 并编译进 Goose 编译器本身。当你不带 -o 执行 goose hello.goose(等价 goose run)时,生成的 C 文本不落地、直接被 TinyCC 编译进本进程内存并调用其 main——没有构建步骤,没有临时文件。这也是 samples/01_tour.goose 等 31 个示例能「拿来就跑」的原因。注意 JIT 模式暂不支持线程程序,那需要走 goose build。

🧪 动手实验:7 个命令观察编译流水线

拿到任意一个 .goose 文件(可从 samples/ 开始),用这些标志停在流水线的不同位置,亲眼看每个阶段的产物:

goose --tokens hello.goose    # 停在阶段1前:打印 token 流
goose --dump hello.goose     # 停在解析后:AST 反向打印成源码
goose --check hello.goose    # 停在类型检查/优化/BCE后,不生成 C
goose --specs hello.goose    # 打印每个特化优化后的函数体
goose --bce-lines hello.goose # 每行消除/保留了多少边界检查
goose -o hello.c hello.goose # 停在阶段6:输出单个 C 文件
goose hello.goose            # 走完全程:TinyCC 内存中 JIT 运行

📚 源码地图:编译器文件导读

想看懂什么 从这里读起
流水线驱动与命令行 src/main.cpp
语言规范(7 阶段语义的权威定义) docs/goose_spec.md
各实现细节与函数名导航 docs/implementation.md
运行时与数据栈 src/runtime/
编译器自身如何测试 docs/testing.md

总结

Goose 编译器用 7 个阶段完成了一次优雅的「降维」:解析与特化把泛型在编译期全部展开,优化器把内联与折叠做完,BCE 删掉被证明无害的检查,最后代码生成吐出一个普通 C 文件——由此 Goose 继承了 C 的可移植性(任何有 C 编译器的机器都能构建),又保住了自己的内存安全与性能。理解了这张流水线地图,你就拥有了读懂 Goose 编译器全部源码的路线图。

登录后查看全文
goose