改造 Go 编译器以高效实现 IPv4 到 IPv6 的映射

# 改造 Go 编译器，高效实现 IPv4 到 IPv6 的映射 来源：https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6 [`netip.Addr`](https://pkg.go.dev/net/netip#Addr) 有一个 [`Unmap()`](https://pkg.go.dev/net/netip#Addr.Unmap) 方法，用于从 [IPv4-mapped IPv6 地址](https://www.rfc-editor.org/rfc/rfc4291#section-2.5.5.2)中取出包裹在内的 IPv4 地址：对于 `::ffff:203.0.113.10` 或 `::ffff:cb00:710a`，它返回 `203.0.113.10`。¹ 反方向却没有 `Map()` 或 `To6()` 方法。实现这样一个方法很简单，但 Go 维护者[拒绝了](https://github.com/golang/go/issues/54365#issuecomment-1570607144)添加它的提议，理由是用户应当自己写 `netip.AddrFrom16(ip.As16())`，然后交给编译器去优化。² 如今，这种写法比原生方法慢八倍。我们怎样才能教会编译器优化这一段代码序列？ - [各种替代方案](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#the-alternatives) - [修改 Go 标准库](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#modifying-the-go-standard-library) - [作为辅助函数](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#as-a-helper) - [使用 unsafe 函数](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#as-an-unsafe-function) - [基准测试](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#benchmarks) - [汇编代码](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#assembly-code) - [改造 Go 编译器](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#hacking-the-go-compiler) - [大锤子](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#the-hammer) - [螺丝刀](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#the-screwdriver) - [理论层面](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#on-paper) - [实际效果](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#in-practice) - [乱序](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#out-of-order) - [恢复有序](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#back-in-order) - [下一步](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#next-steps) ## 各种替代方案 让我们探讨为 `netip.Addr` 实现映射语义的三种方式。我最中意的是把它加进 Go 标准库。Go 维护者则偏好一个小型外部辅助函数，把 `netip.AddrFrom16()` 和 `netip.Addr.As16()` 串联起来，希望编译器最终能够优化它。[`unsafe` 包](https://pkg.go.dev/unsafe)提供了第三条路，其性能与第一种方案相同。 ## 修改 Go 标准库 在内部，`netip.Addr` 把任意 IP 地址存储为一个 128 位的值，外加一个 `z` 字段，用来编码地址族和 zone： ```go type Addr struct { addr uint128 z unique.Handle[addrDetail] } type addrDetail struct { isV6 bool // IPv4 为 false，IPv6 为 true。 zoneV6 string // 仅当 IsV6 为 true 时才 != ""。 } var ( z0 unique.Handle[addrDetail] z4 = unique.Make(addrDetail{}) z6noz = unique.Make(addrDetail{isV6: true}) ) ``` [`AddrFrom4()`](https://pkg.go.dev/net/netip#AddrFrom4) 会把一个 IPv4 地址编码为 IPv4-mapped IPv6 地址，并把 `z` 设为唯一值 `z4`： ```go // AddrFrom4 返回由 addr 中字节给出的 IPv4 地址所对应的地址。 func AddrFrom4(addr [4]byte) Addr { return Addr{ addr: uint128{ 0, 0xffff00000000 | uint64(addr[0])<<24 | uint64(addr[1])<<16 | uint64(addr[2])<<8 | uint64(addr[3])}, z: z4, } } ``` [`Unmap()`](https://pkg.go.dev/net/netip#Addr.Unmap) 则通过把 `z` 字段设为 `z4`，将一个 IPv4-mapped IPv6 地址变成 IPv4 地址： ```go func (ip Addr) Unmap() Addr { if ip.Is4In6() { ip.z = z4 } return ip } ``` 在 Go 标准库内部实现反方向变换非常简单：如果地址是 IPv4 的，我们就把 `z` 字段设为 `z6noz`。 ```go // To6 把 IPv4 地址映射为 IPv4-mapped IPv6 地址。 // 对 IPv6 地址原样返回。 func (ip Addr) To6() Addr { if ip.Is4() { ip.z = z6noz } return ip } ``` ## 作为辅助函数 我们无法从 `net/netip` 包外部访问 `z` 字段。于是我们围绕 `netip.AddrFrom16(ip.As16())` 这一模式构建一个小型辅助函数： ```go // AddrTo6 把 IPv4 地址映射为 IPv4-mapped IPv6 地址。 // 对 IPv6 地址原样返回。 func AddrTo6(ip netip.Addr) netip.Addr { if ip.Is4() { ip = netip.AddrFrom16(ip.As16()) } return ip } ``` ## 使用 unsafe 函数 另一种方案借助 `unsafe` 包，通过一个内存布局相同的代理结构体来修改 `Addr` 结构体。³ ```go // addrProxy 与 netip.Addr 具有相同的内存布局。 type addrProxy struct { addr [2]uint64 // netip.uint128 z unsafe.Pointer // unique.Handle[netip.addrDetail] } var ( anyIPv6 = netip.IPv6Unspecified() netipZ6noz = (*addrProxy)(unsafe.Pointer(&anyIPv6)).z ) // AddrTo6 把 IPv4 地址映射为 IPv4-mapped IPv6 地址。 // 对 IPv6 地址原样返回。 func AddrTo6(ip netip.Addr) netip.Addr { if !ip.Is4() { return ip } (*addrProxy)(unsafe.Pointer(&ip)).z = netipZ6noz return ip } ``` ## 基准测试 在我的计算机上（Go 1.27.1），标准库方案每次操作耗时 0.88 纳秒，而 Go 维护者所青睐的方案耗时 7.14 纳秒。unsafe 方案的性能与前者相当。 ``` goos: linux goarch: amd64 pkg: github.com/vincentbernat/go-netip-addrto6 cpu: AMD Ryzen 5 5600X 6-Core Processor │ sec/op │ │ AddrTo6/safe 7.137n ± 0% │ AddrTo6/unsafe 0.8682n ± 2% │ AddrTo6/builtin 0.8775n ± 2% ``` ## 汇编代码 让我们看看编译器为每种方案生成的汇编代码。⁴ 内置于标准库的那个方案长这样：⁵ ``` // AX = input.addr.hi, BX = input.addr.lo, CX = input.z CMPQ net/netip·z4(SB), CX ; 检查 "z"：是否为 IPv4 地址 JNE end ; 如果不是，就直接结束 MOVQ net/netip·z6noz(SB), CX ; CX = netip.z6noz end: RET ; 返回值 = Addr{hi: AX, lo: BX, z: CX} ``` Go 的[汇编语言](https://go.dev/doc/asm)并非底层机器语言的直接映射：它操作的是从 [Plan 9 汇编器](https://9p.io/sys/doc/asm.html)派生出的一套半抽象指令集。它有四个伪寄存器：FP（函数参数的帧指针）、PC（程序计数器）、SB（全局符号的静态基址指针）和 SP（栈指针）。此外还有架构相关的寄存器，如 `AX`、`CX`、`DX`、`BX`、`SI`、`DI` 以及 `R8` 到 `R15`。存储数据的指令把最后一个参数作为目标操作数。指令可以带有显式的大小后缀：`MOVB` 移动一个字节，`MOVW` 是 16 位，`MOVL` 是 32 位，`MOVQ` 是 64 位。在上面的例子中，第一条指令把 64 位值 `z4` 与 `CX` 寄存器进行比较。 unsafe 方案看起来几乎一模一样： ``` // AX = input.addr.hi, BX = input.addr.lo, CX = input.z CMPQ net/netip·z4(SB), CX ; 检查 "z"：是否为 IPv4 地址 JNE end ; 如果不是，就直接结束 MOVQ netipZ6noz(SB), CX ; CX = netip.z6noz end: RET ; 返回值 = Addr{hi: AX, lo: BX, z: CX} ``` 辅助函数方案的指令多得多。为了理解原因，我们看看 [`As16()`](https://pkg.go.dev/net/netip#Addr.As16) 和 [`AddrFrom16()`](https://pkg.go.dev/net/netip#AddrFrom16) 的代码。它们都很短，短到编译器可以内联它们。 ```go func (ip Addr) As16() (a16 [16]byte) { byteorder.BEPutUint64(a16[:8], ip.addr.hi) byteorder.BEPutUint64(a16[8:], ip.addr.lo) return a16 } func AddrFrom16(addr [16]byte) Addr { return Addr{ addr: uint128{ byteorder.BEUint64(addr[:8]), byteorder.BEUint64(addr[8:]), }, z: z6noz, } } ``` 我们已经可以猜出待优化的模式了：代码把 IP 地址打包进一个数组，复制一遍，然后再拆包出来。如果手动对这段 Go 代码进行内联，我们得到： ```go func AddrTo6(input netip.Addr) netip.Addr { if !input.Is4() { return input } var a16 [16]byte byteorder.BEPutUint64(a16[:8], input.addr.hi) byteorder.BEPutUint64(a16[8:], input.addr.lo) addr := a16 var output netip.Addr output.addr.hi = byteorder.BEUint64(addr[:8]) output.addr.lo = byteorder.BEUint64(addr[8:]) output.z = netip.z6noz return output } ``` 作为人类，我们可以在脑海中直接推导出优化后的形式： ```go func AddrTo6(input netip.Addr) netip.Addr { if !input.Is4() { return input } var output netip.Addr output.addr.hi = input.addr.hi output.addr.lo = input.addr.lo output.z = netip.z6noz return output } ``` 遗憾的是，截至 Go 1.26.8，编译器还不够聪明，做不到同样的事情： ``` // AX = input.addr.hi, BX = input.addr.lo, CX = input.z ; 压入栈（32 字节）： ; 0(SP) addr netip.uint128 ; 16(SP) a16 [16]byte PUSHQ BP MOVQ SP, BP SUBQ $32, SP CMPQ net/netip·z4(SB), CX ; 检查 "z"：是否为 IPv4 地址 JNE end ; 如果不是，就直接结束 ; 打包：byteorder.BEPutUint64(a16[:8], input.addr.hi) ; byteorder.BEPutUint64(a16[8:], input.addr.lo) MOVBEQ AX, net/netip·a16+16(SP) MOVBEQ BX, net/netip·a16+24(SP) ; addr = a16，通过向量寄存器 X0 一次性移动 16 字节 MOVUPS net/netip·a16+16(SP), X0 MOVUPS X0, net/netip·addr(SP) ; CX = netip.z6noz MOVQ net/netip·z6noz(SB), CX ; 拆包：output.addr.hi = byteorder.BEUint64(addr[:8]) ; output.addr.lo = byteorder.BEUint64(addr[8:]) MOVBEQ net/netip·addr(SP), AX MOVBEQ net/netip·addr+8(SP), BX end: ADDQ $32, SP POPQ BP RET ; 返回值 = Addr{hi: AX, lo: BX, z: CX} ``` 编译器在字节重排方面做得不错：`BEPutUint64()` 中的八次字节存储被合并成一条 `MOVBEQ`，它以字节交换的方式存储寄存器。`BEUint64()` 中的八次字节读取则被合并成一条反方向的 `MOVBEQ`。⁶ 还剩下三组指令：一次打包、一次复制、一次拆包。 ## 改造 Go 编译器 Go 编译器包含[若干阶段](https://github.com/golang/go/blob/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/README.md)： **解析（Parsing）** 编译器对源代码进行[分词和解析](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/syntax)，为每个源文件构建一棵语法树。 **类型检查（Type checking）** 编译器[把每个标识符映射到它所指代的对象](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/types2)，折叠常量，并推断每个表达式的类型。 **IR 构造（IR construction）** 编译器把语法树及其类型转换成它自己的[中间表示](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/ir)（IR）。这个过程被称为「noding」（[参见 noder](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/noder)），它经过一种名为 unifiedIR 的序列化格式。 **中端（Middle end）** 编译器对 IR 执行若干优化遍，例如[去虚化](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/devirtualize)（devirtualization）、[函数调用内联](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/inline)（function call inlining）以及[逃逸分析](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/escape)（escape analysis）。 **遍历（Walk）** 这个阶段包含[两个步骤](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/walk)：求值顺序分析（order of evaluation）把复杂语句拆解为更简单的形式，脱糖（desugaring）则把 `switch` 或 channel 等更高级的 Go 构造转换为更原始的指令或对运行时的调用。 **通用 SSA（Generic SSA）** 编译器[把 IR 转换成静态单赋值（SSA）形式](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/ssagen)，这是一种层次更低的中间表示，适合进行与机器无关的优化以及[重写规则](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/ssa)处理。 **机器代码生成（Machine code generation）** 编译器把 SSA 形式重写为[针对具体机器的变体](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/ssa/_gen)，分配寄存器，并应用更多的优化遍。最后，[汇编器](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/internal/obj)把生成的指令转换为机器码。 ## 大锤子 我最初的想法是：在「noding」过程中尽早把 `netip.AddrFrom16(ip.As16())` 的出现替换成 `netip.Addr{addr: ip.addr, z: netip.z6noz}`。在此之前，类型检查阶段会阻止我们访问未导出的结构体字段。 Go 1.27 引入了一个便利的调试选项，可以在编译过程的若干关键点上导出某个函数的 IR： ``` $ GOTOOLCHAIN=go1.27.1 GOAMD64=v3 go build -a -gcflags="-d=astdump=AddrTo6Safe" . Writing text ast output for AddrTo6Safe to AddrTo6Safe.ast Writing html ast output for AddrTo6Safe to AddrTo6Safe.html Writing html syntax output for AddrTo6Safe to AddrTo6Safe.syntax.html ``` 在 HTML 文件中，第一列展示的是 noding 输出的 IR： ``` DCLFUNC addrto6.AddrTo6Safe ABI:ABIInternal FUNC-func(netip.Addr) netip.Addr DCLFUNC-Dcl . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr . NAME-addrto6.~r0 Class:PPARAMOUT Offset:0 OnStack netip.Addr DCLFUNC-body . IF # ipv6_safe.go:11:2 IF-Cond . CALLFUNC bool . CALLFUNC-Fun . METHEXPR addrto6.Is4 FUNC-func(netip.Addr) bool . . TYPE netip.Addr Class:PEXTERN Offset:0 type netip.Addr . CALLFUNC-Args . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr IF-Body . AS # ipv6_safe.go:12:6 . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr . CALLFUNC netip.Addr . CALLFUNC-Fun . NAME-netip.AddrFrom16 Class:PFUNC Offset:0 Used FUNC-func([16]byte) netip.Addr . CALLFUNC-Args . CALLFUNC ARRAY-[16]byte . CALLFUNC-Fun . METHEXPR addrto6.As16 FUNC-func(netip.Addr) [16]byte . . TYPE netip.Addr Class:PEXTERN Offset:0 type netip.Addr . CALLFUNC-Args . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr RETURN # ipv6_safe.go:14:2 RETURN-Results . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr ``` 在 `if` 语句的函数体中，我们可以看到对方法 `netip.Addr.As16()` 和函数 `netip.AddrFrom16()` 的调用。我们的目标是把它们替换成一个结构体字面量： ``` IF-Body . AS # ipv6_safe.go:12:6 . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr . STRUCTLIT netip.Addr . STRUCTLIT-List . STRUCTKEY netip.addr . DOT netip.addr netip.uint128 . . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr . STRUCTKEY netip.z . NAME-netip.z6noz Class:PEXTERN Offset:0 unique.Handle[net/netip.addrDetail] ``` 在 noder 的 [`reader.go`](https://github.com/golang/go/blob/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/noder/reader.go) 中，`expr()` 方法会为一个表达式构建 IR 树。在 `exprCall` 分支的末尾，我们添加对 `rewriteAddrFrom16As16...` 的调用。 ¹ 有一个[脚注](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#sidenote-why)解释了为什么会有这个方法。 ² 有一个[脚注](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#sidenote-equiv)说明了为什么 `AddrFrom16(ip.As16())` 等价于映射操作。 ³ 有一个[脚注](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#sidenote-tests)讨论了这种 unsafe 方案的测试方式。 ⁴ 有一个[脚注](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#sidenote-dis)说明了如何反汇编查看这些代码。 ⁵ 有一个[脚注](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#sidenote-inline)解释了为什么内置方案的代码如此精简。 ⁶ 有一个[脚注](https://vincent.bernat.ch/en/blog/2026-go-netip-addrto6#sidenote-amd64v3)说明了 `GOAMD64=v3` 与 `MOVBEQ` 指令之间的关系。