netip.Addr features an Unmap()\nmethod returning the unwrapped IPv4 contained in an IPv4-mapped IPv6\naddress: from ::ffff:203.0.113.10 or ::ffff:cb00:710a, it returns\n203.0.113.10.<sup>1</sup> There is no Map() or To6() method for the reverse\ndirection. Such a method is trivial to implement, but Go maintainers have\nrejected it on the grounds that users should write\nnetip.AddrFrom16(ip.As16()) and let the compiler optimize it.<sup>2</sup> Today,\nthis pattern is eight times slower than a native method. How can we teach the\ncompiler to optimize this sequence?
Let’s explore three ways to implement the map semantics for netip.Addr. My\nfavorite is to add it to the Go standard library. Go maintainers prefer a small\nexternal helper chaining netip.AddrFrom16() and netip.Addr.As16(), hoping\nthe compiler eventually optimizes it. The unsafe package\nopens a third path, with the same performance as the first solution.
Internally, netip.Addr stores any IP address as a\n128-bit value with an extra field z to encode the family and the zone:
type Addr struct {\n addr uint128\n z unique.Handle[addrDetail]\n}\ntype addrDetail struct {\n isV6 bool // IPv4 is false, IPv6 is true.\n zoneV6 string // != "" only if IsV6 is true.\n}\nvar (\n z0 unique.Handle[addrDetail]\n z4 = unique.Make(addrDetail{})\n z6noz = unique.Make(addrDetail{isV6: true})\n)AddrFrom4() encodes an IPv4 address as an\nIPv4-mapped IPv6 address and sets z to the unique value z4:
// AddrFrom4 returns the address of the IPv4 address given by the bytes in addr.\nfunc AddrFrom4(addr [4]byte) Addr {\n return Addr{\n addr: uint128{\n 0,\n 0xffff00000000 |\n uint64(addr[0])<<24 | uint64(addr[1])<<16 |\n uint64(addr[2])<<8 | uint64(addr[3])},\n z: z4,\n }\n}Unmap() turns an IPv4-mapped IPv6 address into an\nIPv4 address by setting the z field to z4:
func (ip Addr) Unmap() Addr {\n if ip.Is4In6() {\n ip.z = z4\n }\n return ip\n}Implementing the reverse direction inside the Go standard library is trivial: we\nset the z field to z6noz if the address is IPv4.
// To6 maps an IPv4 address to an IPv4-mapped IPv6 address. It returns an\n// IPv6 address unmodified.\nfunc (ip Addr) To6() Addr {\n if ip.Is4() {\n ip.z = z6noz\n }\n return ip\n}We can’t access the z field from outside the net/netip package. Instead, we\nbuild a small helper around the netip.AddrFrom16(ip.As16()) pattern:
// AddrTo6 maps an IPv4 address to an IPv4-mapped IPv6 address. It returns an\n// IPv6 address unmodified.\nfunc AddrTo6(ip netip.Addr) netip.Addr {\n if ip.Is4() {\n ip = netip.AddrFrom16(ip.As16())\n }\n return ip\n}Another solution uses the unsafe package to alter the Addr struct through\na proxy with the same memory layout:3
// addrProxy has the same memory layout as netip.Addr.\ntype addrProxy struct {\n addr [2]uint64 // netip.uint128\n z unsafe.Pointer // unique.Handle[netip.addrDetail]\n}\nvar (\n anyIPv6 = netip.IPv6Unspecified()\n netipZ6noz = (*addrProxy)(unsafe.Pointer(&anyIPv6)).z\n)\n// AddrTo6 maps an IPv4 address to an IPv4-mapped IPv6 address. It returns an\n// IPv6 address unmodified.\nfunc AddrTo6(ip netip.Addr) netip.Addr {\n if !ip.Is4() {\n return ip\n }\n (*addrProxy)(unsafe.Pointer(&ip)).z = netipZ6noz\n return ip\n}On my computer, with Go 1.27.1, the standard library solution costs 0.88 ns per operation, while the solution favored by Go maintainers costs 7.14 ns. The unsafe solution matches the performance of the first one.
\ngoos: linux\ngoarch: amd64\npkg: github.com/vincentbernat/go-netip-addrto6\ncpu: AMD Ryzen 5 5600X 6-Core Processor\n │ sec/op │\nAddrTo6/safe 7.137n ± 0%\nAddrTo6/unsafe 0.8682n ± 2%\nAddrTo6/builtin 0.8775n ± 2%Let’s check the assembly code the compiler generates for each solution.<sup>4</sup>\nThe one built into the standard library looks like this:5
\n// AX = input.addr.hi, BX = input.addr.lo, CX = input.z\n CMPQ net/netip·z4(SB), CX ; check "z" if this is an IPv4 address\n JNE end ; if not, stop here\n MOVQ net/netip·z6noz(SB), CX ; CX = netip.z6noz\nend:\n RET\n// return value = Addr{hi: AX, lo: BX, z: CX}Go’s assembly language is not a direct representation of the underlying\nmachine language: it operates on a semi-abstract instruction set derived from\nPlan 9’s assembler. It has four pseudo-registers: FP (frame pointer\nfor function arguments), PC (program counter), SB (static base pointer for\nglobal symbols), and SP (stack pointer). It also has architecture-specific\nregisters like AX, CX, DX, BX, SI, DI, and R8 to R15.\nInstructions storing data use their last argument as the destination.\nInstructions can carry an explicit size suffix: MOVB moves a byte, MOVW 16\nbits, MOVL 32 bits, and MOVQ 64 bits. In the example above, the first\ninstruction compares the 64-bit value z4 with the CX register.
The unsafe solution looks almost the same:
\n// AX = input.addr.hi, BX = input.addr.lo, CX = input.z\n CMPQ net/netip·z4(SB), CX ; check "z" if this is an IPv4 address\n JNE end ; if not, stop here\n MOVQ netipZ6noz(SB), CX ; CX = netip.z6noz\nend:\n RET\n// return value = Addr{hi: AX, lo: BX, z: CX}The helper solution has far more instructions. To understand why, let’s look at\nthe code for As16() and\nAddrFrom16(). They are short enough for the compiler\nto inline them.
func (ip Addr) As16() (a16 [16]byte) {\n byteorder.BEPutUint64(a16[:8], ip.addr.hi)\n byteorder.BEPutUint64(a16[8:], ip.addr.lo)\n return a16\n}\nfunc AddrFrom16(addr [16]byte) Addr {\n return Addr{\n addr: uint128{\n byteorder.BEUint64(addr[:8]),\n byteorder.BEUint64(addr[8:]),\n },\n z: z6noz,\n }\n}We can already guess the pattern to optimize: the code packs the IP address into an array, copies it, then unpacks it. If we inline the Go code by hand, we get:
\nfunc AddrTo6(input netip.Addr) netip.Addr {\n if !input.Is4() {\n return input\n }\n var a16 [16]byte\n byteorder.BEPutUint64(a16[:8], input.addr.hi)\n byteorder.BEPutUint64(a16[8:], input.addr.lo)\n addr := a16\n var output netip.Addr\n output.addr.hi = byteorder.BEUint64(addr[:8])\n output.addr.lo = byteorder.BEUint64(addr[8:])\n output.z = netip.z6noz\n return output\n}As humans, we can mentally derive the optimized form:
\nfunc AddrTo6(input netip.Addr) netip.Addr {\n if !input.Is4() {\n return input\n }\n var output netip.Addr\n output.addr.hi = input.addr.hi\n output.addr.lo = input.addr.lo\n output.z = netip.z6noz\n return output\n}Unfortunately, as of Go 1.26.8, the compiler is not smart enough to do the same:
\n// AX = input.addr.hi, BX = input.addr.lo, CX = input.z\n; Push the stack (32 bytes):\n; 0(SP) addr netip.uint128\n; 16(SP) a16 [16]byte\n PUSHQ BP\n MOVQ SP, BP\n SUBQ $32, SP\n CMPQ net/netip·z4(SB), CX ; check "z" if this is an IPv4 address\n JNE end ; if not, stop here\n; Pack: byteorder.BEPutUint64(a16[:8], input.addr.hi)\n; byteorder.BEPutUint64(a16[8:], input.addr.lo)\n MOVBEQ AX, net/netip·a16+16(SP)\n MOVBEQ BX, net/netip·a16+24(SP)\n; addr = a16, 16 bytes at once through the vector register X0\n MOVUPS net/netip·a16+16(SP), X0\n MOVUPS X0, net/netip·addr(SP)\n; CX = netip.z6noz\n MOVQ net/netip·z6noz(SB), CX\n; Unpack: output.addr.hi = byteorder.BEUint64(addr[:8])\n; output.addr.lo = byteorder.BEUint64(addr[8:])\n MOVBEQ net/netip·addr(SP), AX\n MOVBEQ net/netip·addr+8(SP), BX\nend:\n ADDQ $32, SP\n POPQ BP\n RET\n// return value = Addr{hi: AX, lo: BX, z: CX}The compiler does a decent job on the byte shuffling: the eight byte stores of\nBEPutUint64() become a single MOVBEQ, which stores a register byte-swapped.\nThe eight byte loads of BEUint64() become a single MOVBEQ the other way\nround.<sup>6</sup> Three groups of instructions remain: a pack, a copy, and an\nunpack.
The Go compiler has several phases:
\nThe compiler tokenizes and parses the source code . It builds a syntax tree
for each source file.
The compiler maps each identifier to the object it denotes , folds
constants, and infers the type of every expression.
The compiler converts the syntax tree and its types into its own [intermediate
representation](https://github.com/golang/go/tree/1e963f82914ddfb47820034c5c85205a362ed73f/src/cmd/compile/internal/ir) (IR). This process, called “noding ,” goes through\na serialization format named unified IR.
The compiler performs several optimization passes on the IR,
such as devirtualization ,function call inlining ,\nandescape analysis .
This phase runs two steps : order of evaluation decomposes complex
statements into simpler ones, and desugaring transforms higher-level Go\nconstructs, likeswitch or channels, into more primitive instructions or\ncalls to the runtime.
The compiler converts the IR into Static Single Assignment (SSA)
form, a lower-level intermediate representation suited formachine-independent optimizations and rewrite rules .
The compiler rewrites the SSA form into machine-specific variants ,
allocates registers, and applies more optimization passes. At the end,the\nassembler turns the generated instructions into machine code.
My first idea is to replace occurrences of netip.AddrFrom16(ip.As16()) with\nnetip.Addr{addr: ip.addr, z: netip.z6noz} as early as possible, during the\n“noding” process. Before that, the type checking phase prevents\nus from accessing unexported struct fields.
Go 1.27 introduced a convenient debug option to dump the IR of a function at interesting points during compilation:
\n$ GOTOOLCHAIN=go1.27.1 GOAMD64=v3 go build -a -gcflags="-d=astdump=AddrTo6Safe" .\nWriting text ast output for AddrTo6Safe to AddrTo6Safe.ast\nWriting html ast output for AddrTo6Safe to AddrTo6Safe.html\nWriting html syntax output for AddrTo6Safe to AddrTo6Safe.syntax.htmlIn the HTML file, the first column shows the IR as it comes out of noding:
\nDCLFUNC addrto6.AddrTo6Safe ABI:ABIInternal FUNC-func(netip.Addr) netip.Addr\nDCLFUNC-Dcl\n. NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr\n. NAME-addrto6.~r0 Class:PPARAMOUT Offset:0 OnStack netip.Addr\nDCLFUNC-body\n. IF # ipv6_safe.go:11:2\n. IF-Cond\n. . CALLFUNC bool\n. . CALLFUNC-Fun\n. . . METHEXPR addrto6.Is4 FUNC-func(netip.Addr) bool\n. . . . TYPE netip.Addr Class:PEXTERN Offset:0 type netip.Addr\n. . CALLFUNC-Args\n. . . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr\n. IF-Body\n. . AS # ipv6_safe.go:12:6\n. . . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr\n. . . CALLFUNC netip.Addr\n. . . CALLFUNC-Fun\n. . . . NAME-netip.AddrFrom16 Class:PFUNC Offset:0 Used FUNC-func([16]byte) netip.Addr\n. . . CALLFUNC-Args\n. . . . CALLFUNC ARRAY-[16]byte\n. . . . CALLFUNC-Fun\n. . . . . METHEXPR addrto6.As16 FUNC-func(netip.Addr) [16]byte\n. . . . . . TYPE netip.Addr Class:PEXTERN Offset:0 type netip.Addr\n. . . . CALLFUNC-Args\n. . . . . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr\n. RETURN # ipv6_safe.go:14:2\n. RETURN-Results\n. . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.AddrIn the body of the if statement, we spot the calls to the method\nnetip.Addr.As16() and to the function netip.AddrFrom16(). Our goal is to\npatch them with a struct literal:
IF-Body\n. AS # ipv6_safe.go:12:6\n. . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr\n. . STRUCTLIT netip.Addr\n. . STRUCTLIT-List\n. . . STRUCTKEY netip.addr\n. . . . DOT netip.addr netip.uint128\n. . . . . NAME-addrto6.ip Class:PPARAM Offset:0 OnStack Used netip.Addr\n. . . STRUCTKEY netip.z\n. . . . NAME-netip.z6noz Class:PEXTERN Offset:0 unique.Handle[net/netip.addrDetail]In noder’s reader.go, the expr() method builds the IR tree for\nan expression. At the end of the exprCall case, we add a call to a\nrewriteAddrFrom16As16() function. It takes the current node and returns the\nstruct literal on success, or nil if the rewrite is not possible. First, we\ncheck that we have the expected pattern: a call to the netip.AddrFrom16()\nfunction with a call to the netip.Addr.As16() method as its only argument:
func rewriteAddrFrom16As16(n ir.Node) ir.Node {\n call, ok := n.(*ir.CallExpr)\n if !ok || call.Op() != ir.OCALLFUNC ||\n len(call.Args) != 1 || len(call.Init()) != 0 ||\n !isNetipFunc(call.Fun, "AddrFrom16") {\n return nil\n }\n inner, ok := call.Args[0].(*ir.CallExpr)\n if !ok || inner.Op() != ir.OCALLFUNC ||\n len(inner.Args) != 1 || len(inner.Init()) != 0 ||\n !isNetipFunc(inner.Fun, "Addr.As16") {\n return nil\n }\n x := inner.Args[0]\n // [...]\n}Then, we fetch netip.z6noz:
z6noz, err := lookupVar(ir.StaticCalleeName(call.Fun).Sym().Pkg, "z6noz")\nif err != nil {\n return nil\n}And we build the struct literal:
\ntyp := call.Type()\npos := call.Pos()\nvar list []ir.Node\nfor i, f := range typ.Fields() {\n var value ir.Node\n switch f.Sym.Name {\n case "addr":\n value = typecheck.DotField(pos, x, i)\n case "z":\n value = z6noz\n default:\n return nil\n }\n list = append(list, ir.NewStructKeyExpr(pos, f, value))\n}\nlit := ir.NewCompLitExpr(pos, ir.OSTRUCTLIT, typ, list)\nlit.SetTypecheck(1)\nreturn litHave a look at the complete patch.<sup>7</sup> We can test it\nwith the following commands:
\n$ cd src\n$ ./make.bash\nBuilding Go cmd/dist using /usr/lib/go-1.27. (go1.27.1 linux/amd64)\nBuilding Go toolchain1 and bootstrap cmd/go (go_bootstrap) using /usr/lib/go-1.27.\nBuilding Go toolchain2 using go_bootstrap and Go toolchain1.\nBuilding Go toolchain3 and commands using go_bootstrap and Go toolchain2.\nChecking command staleness for linux/amd64.\n---\nInstalled Go for linux/amd64 in /home/bernat/code/free/go\nInstalled commands in /home/bernat/code/free/go/bin\n*** You need to add /home/bernat/code/free/go/bin to your PATH.\n$ export PATH=$PWD/../bin:$PATH\n$ go version\ngo version go1.28-devel_9834516e20 Sat Sep 12 08:23:11 2026 -0700 linux/amd64\n$ go test net/netip/...\nok net/netip 0.224s\n$ cd ../../go-netip-addrto6\n$ go test .\nok github.com/vincentbernat/go-netip-addrto6 0.062sThe generated code for the helper is now the shortest possible version!
\n// AX = input.addr.hi, BX = input.addr.lo, CX = input.z\n CMPQ net/netip·z4(SB), CX ; check "z" if this is an IPv4 address\n JNE end ; if not, stop here\n MOVQ net/netip·z6noz(SB), CX ; CX = netip.z6noz\nend:\n RET\n// return value = Addr{hi: AX, lo: BX, z: CX}Go maintainers are unlikely to accept this change. It relies on the internal\nstructure of net/netip.Addr. It’s an ugly hack in the noder, whose job is to\nfaithfully translate the type-checked AST into the IR. And it’s harder to\nmaintain than adding a To6() method.
The right place for such an optimization is the generic SSA phase. One of\nthe last machine-independent passes is memcombine. With the appropriate debug\nflag, the compiler dumps the SSA form after this pass:8
$ GOTOOLCHAIN=go1.26.8 GOAMD64=v3 \\\n> go build -a -gcflags='-d=ssa/memcombine/dump=AddrTo6Safe' .\n$ head -5 AddrTo6Safe_01__memcombine.dump\nAddrTo6Safe func(netip.Addr) netip.Addr\n b2:\n (?) v1 = InitMem <mem>\n (?) v2 = SP <uintptr>\n (?) v3 = SB <uintptr>The result of the memcombine pass follows the same structure as the assembly\ncode for AddrTo6Safe() we looked at earlier: two stores,\none move, and two loads we would like to optimize away.
; […]\n v502 = ArgIntReg <uint64> {ip+0} [0] ; input.addr.hi\n v490 = ArgIntReg <uint64> {ip+8} [1] ; input.addr.lo\n v466 = ArgIntReg <*netip.addrDetail> {ip+16} [2] ; input.z\n; […]\n v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1 ; &a16\n v173 = OffPtr <*byte> [8] v22 ; &a16[8]\n v442 = Bswap64 <uint64> v490 ; bswap(input.addr.lo)\n v542 = Bswap64 <uint64> v502 ; bswap(input.addr.hi)\n v161 = Store <mem> {uint64} v22 v542 v23 ; a16[:8] = bswap(hi)\n v282 = Store <mem> {uint64} v173 v442 v161 ; a16[8:] = bswap(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n v415 = OffPtr <*byte> [8] v285 ; &addr[8]\n v416 = Load <uint64> v285 v286 ; addr[:8]\n v299 = Bswap64 <uint64> v416 ; output.addr.hi\n v174 = Load <uint64> v415 v286 ; addr[8:]\n v39 = Bswap64 <uint64> v174 ; output.addr.lo\n; […]Each line features a value identifier (v442), an operation with its type\n(Bswap64 <uint64>), and its arguments (v490).<sup>9</sup> Values are the basic\nbuilding blocks of SSA and are defined exactly once. Square brackets enclose\ninteger parameters ([8]) and curly braces contain auxiliary arguments\n({netip.addr}). Operations writing to memory produce a new memory state. Every\nmemory operation takes the current state as its last argument, which keeps them\nin order.
Let’s focus on output.addr.lo, aka v39:
v490 = ArgIntReg <uint64> {ip+8} [1] ; input.addr.lo\n v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1 ; &a16\n v173 = OffPtr <*byte> [8] v22 ; &a16[8]\n v442 = Bswap64 <uint64> v490 ; bswap(input.addr.lo)\n v282 = Store <mem> {uint64} v173 v442 v161 ; a16[8:] = bswap(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n v415 = OffPtr <*byte> [8] v285 ; &addr[8]\n v174 = Load <uint64> v415 v286 ; addr[8:]\n v39 = Bswap64 <uint64> v174 ; output.addr.loTo simplify this code, we could apply three rewriting rules:
\nThe first one adds a shortcut when loading through a move :```\n(Load (OffPtr\n [o] p) (Move p src mem)) => (Load (OffPtr [o] src) mem)
\n. This matches`v174` with its arguments`v415` and`v286` and creates a new value`v600` :```\n v490 = ArgIntReg <uint64> {ip+8} [1] ; input.addr.lo\n v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1 ; &a16\n v173 = OffPtr <*byte> [8] v22 ; &a16[8]\n v442 = Bswap64 <uint64> v490 ; bswap(input.addr.lo)\n v282 = Store <mem> {uint64} v173 v442 v161 ; a16[8:] = bswap(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n v415 = OffPtr <*byte> [8] v285 ; &addr[8]\n v600 = OffPtr <*byte> [8] v22 ; &a16[8]\n v174 = Load <uint64> v600 v282 ; a16[8:]\n v39 = Bswap64 <uint64> v174 ; output.addr.loThe second one simplifies a load following a store :```\n(Load p (Store p x\n _)) => x
\n. The load is*forwarded* : the stored value replaces it and no memory\n access remains. It matches`v174` . It notices that`v600` and`v173` are the\n same address and replaces`v174` with a copy of`v442` :```\n v490 = ArgIntReg <uint64> {ip+8} [1] ; input.addr.lo\n v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1 ; &a16\n v173 = OffPtr <*byte> [8] v22 ; &a16[8]\n v442 = Bswap64 <uint64> v490 ; bswap(input.addr.lo)\n v282 = Store <mem> {uint64} v173 v442 v161 ; a16[8:] = bswap(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n v415 = OffPtr <*byte> [8] v285 ; &addr[8]\n v600 = OffPtr <*byte> [8] v22 ; &a16[8]\n v174 = Copy <uint64> v442 ; bswap(input.addr.lo)\n v39 = Bswap64 <uint64> v174 ; output.addr.loThe last step cancels the two byte swaps :(Bswap64 (Bswap64 x)) => x .v39 becomes a copy ofv490 :```\n v490 = ArgIntReg <uint64> {ip+8} [1] ; input.addr.lo\n v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1 ; &a16\n v173 = OffPtr <*byte> [8] v22 ; &a16[8]\n v442 = Bswap64 <uint64> v490 ; bswap(input.addr.lo)\n v282 = Store <mem> {uint64} v173 v442 v161 ; a16[8:] = bswap(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n v415 = OffPtr <*byte> [8] v285 ; &addr[8]\n v600 = OffPtr <*byte> [8] v22 ; &a16[8]\n v174 = Copy <uint64> v442 ; bswap(input.addr.lo)\n v39 = Copy <uint64> v490 ; output.addr.lo = input.addr.lo
\nIf we ignore the values not needed to compute `v39`, only this SSA form remains:\nv490 = ArgIntReg <uint64> {ip+8} [1] ; input.addr.lo\n v39 = Copy <uint64> v490 ; output.addr.lo = input.addr.lo
\nLet’s switch to `output.addr.hi`, aka `v299`:\nv502 = ArgIntReg <uint64> {ip+0} [0] ; input.addr.hi\n v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1 ; &a16\n v173 = OffPtr <*byte> [8] v22 ; &a16[8]\n v542 = Bswap64 <uint64> v502 ; bswap(input.addr.hi)\n v161 = Store <mem> {uint64} v22 v542 v23 ; a16[:8] = bswap(hi)\n v282 = Store <mem> {uint64} v173 v442 v161 ; a16[8:] = bswap(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n v416 = Load <uint64> v285 v286 ; addr[:8]\n v299 = Bswap64 <uint64> v416 ; output.addr.hi
\nTo optimize it away, we also apply three rewriting rules:\n\n1. \nThe first one also adds a shortcut when **loading through a move** , but\n without an offset:`(Load p (Move p src mem)) => (Load src mem)` . This rewrites`v416` to use arguments from`v286` :```\n v502 = ArgIntReg <uint64> {ip+0} [0] ; input.addr.hi\n v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1 ; &a16\n v173 = OffPtr <*byte> [8] v22 ; &a16[8]\n v542 = Bswap64 <uint64> v502 ; bswap(input.addr.hi)\n v161 = Store <mem> {uint64} v22 v542 v23 ; a16[:8] = bswap(hi)\n v282 = Store <mem> {uint64} v173 v442 v161 ; a16[8:] = bswap(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n v416 = Load <uint64> v22 v282 ; a16[:8]\n v299 = Bswap64 <uint64> v416 ; output.addr.hiThe second rule forwards a value stored one step earlier , skipping over a\n store to another address:(Load p (Store q _ (Store p x _))) => x . This\n matchesv416 :x isv542 ,p isv22 (&a16 ),q isv173 (&a16[8] ), andp andq do not overlap foruint64 .```\n v502 = ArgIntReg <uint64> {ip+0} [0] ; input.addr.hi\n v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1 ; &a16\n v173 = OffPtr <*byte> [8] v22 ; &a16[8]\n v542 = Bswap64 <uint64> v502 ; bswap(input.addr.hi)\n v161 = Store <mem> {uint64} v22 v542 v23 ; a16[:8] = bswap(hi)\n v282 = Store <mem> {uint64} v173 v442 v161 ; a16[8:] = bswap(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n v416 = Copy <uint64> v542 ; bswap(input.addr.hi)\n v299 = Bswap64 <uint64> v416 ; output.addr.hi
3. \nThe third rule **cancels two byte swaps** :`(Bswap64 (Bswap64 x)) => x` .`v299` becomes a copy of`v502` :```\n v502 = ArgIntReg <uint64> {ip+0} [0] ; input.addr.hi\n v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1 ; &a16\n v173 = OffPtr <*byte> [8] v22 ; &a16[8]\n v542 = Bswap64 <uint64> v502 ; bswap(input.addr.hi)\n v161 = Store <mem> {uint64} v22 v542 v23 ; a16[:8] = bswap(hi)\n v282 = Store <mem> {uint64} v173 v442 v161 ; a16[8:] = bswap(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n v416 = Copy <uint64> v542 ; bswap(input.addr.hi)\n v299 = Copy <uint64> v502 ; output.addr.hi = input.addr.hiIf we remove the values not used to compute v299, we get this SSA form:
v502 = ArgIntReg <uint64> {ip+0} [0] ; input.addr.hi\n v299 = Copy <uint64> v502 ; output.addr.hi = input.addr.hiMost of these rules already exist in generic.rules. They use\nconditions to validate their context: ssa.IsSamePtr() for the same address,\nssa.Disjoint() for addresses that do not overlap. The rule forwarding a stored\nvalue to a load already exists with three variants looking through several other\nstores. Here are the two we need:
(Load <t1> p1 (Store {t2} p2 x _))\n && ssa.IsSamePtr(p1, p2)\n && copyCompatibleType(t1, x.Type)\n && t1.Size() == t2.Size()\n => x\n(Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 x _)))\n && ssa.IsSamePtr(p1, p3)\n && copyCompatibleType(t1, x.Type)\n && t1.Size() == t3.Size()\n && ssa.Disjoint(p3, t3, p2, t2)\n => xGo 1.27 added the rule loading through a move with CL 748200 to fix\nissue #77720:
\n(Load <t1> op1:(OffPtr [o1] p1) move:(Move [n] p2 src mem))\n && o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p2)\n && !ssa.IsVolatile(src)\n => @move.Block (Load <t1> (OffPtr <op1.Type> [o1] src) mem)It lacks a variant without an offset:
\n(Load <t1> p1 move:(Move [n] p2 src mem))\n && p1.Op != ssaop.OpOffPtr\n && t1.Size() <= n && ssa.IsSamePtr(p1, p2)\n && !ssa.IsVolatile(src)\n => @move.Block (Load <t1> (OffPtr <p1.Type> [0] src) mem)There is no generic rule to cancel two byte swaps, but the AMD64 lowering\npass includes this rule:
\n(BSWAP(Q|L) (BSWAP(Q|L) p)) => pAfter switching to Go’s development branch and adding the missing\nrule, the generated assembly code is worse than with Go 1.26.8,\neven though our additional rule slightly improves the situation at the end:
\n// AX = input.addr.hi, BX = input.addr.lo, CX = input.z\n; Push the stack (16 bytes):\n; 0(SP) a16 [16]byte\n PUSHQ BP\n MOVQ SP, BP\n SUBQ $16, SP\n CMPQ net/netip·z4(SB), CX ; check "z" if this is an IPv4 address\n JNE end ; if not, stop here\n; The four forwarded bytes: the low half of input.addr.lo is taken apart and\n; put back together in registers\n MOVQ BX, DX ; DX = input.addr.lo\n SHRQ $24, BX ; BX = input.addr.lo >> 24\n MOVQ DX, SI ; SI = input.addr.lo\n SHRQ $16, DX ; DX = input.addr.lo >> 16\n MOVQ SI, DI ; DI = input.addr.lo, kept for the pack\n SHRQ $8, SI ; SI = input.addr.lo >> 8\n MOVBLZX DIB, R8 ; R8 = byte(input.addr.lo)\n MOVBLZX SIB, SI ; SI = byte(input.addr.lo >> 8)\n SHLQ $8, SI\n ORQ R8, SI ; SI = two low bytes of input.addr.lo\n MOVBLZX DL, DX ; DX = byte(input.addr.lo >> 16)\n SHLQ $16, DX\n ORQ SI, DX\n MOVBLZX BL, BX ; BX = byte(input.addr.lo >> 24)\n SHLQ $24, BX\n ORQ DX, BX ; BX = input.addr.lo & 0xffffffff\n; Pack: byteorder.BEPutUint64(a16[:8], input.addr.hi)\n; byteorder.BEPutUint64(a16[8:], input.addr.lo)\n MOVBEQ AX, net/netip·a16(SP)\n MOVBEQ DI, net/netip·a16+8(SP)\n; The four other bytes of input.addr.lo, read one by one from a16\n MOVBLZX net/netip·a16+11(SP), DX ; a16[11]\n SHLQ $32, DX\n ORQ DX, BX\n MOVBLZX net/netip·a16+10(SP), DX ; a16[10]\n SHLQ $40, DX\n ORQ DX, BX\n MOVBLZX net/netip·a16+9(SP), DX ; a16[9]\n SHLQ $48, DX\n ORQ DX, BX\n MOVBLZX net/netip·a16+8(SP), DX ; a16[8]\n SHLQ $56, DX\n; output.z = netip.z6noz\n MOVQ net/netip·z6noz(SB), CX\n; output.addr.hi = byteorder.BEUint64(a16[:8])\n MOVBEQ net/netip·a16(SP), AX\n; output.addr.lo assembled from the previous steps\n ORQ DX, BX\nend:\n LEAVEQ\n RET\n// return value = Addr{hi: AX, lo: BX, z: CX}The rule loading through a move, added in Go 1.27, introduced this regression.
\nLet’s not give up now! In reality, the rewriting rules run before memcombine,\nnotably in the late opt pass. At this point, the inlined versions of\nBEPutUint64() and BEUint64() still expand to sixteen byte stores and sixteen\nbyte loads, matching their source code:
func BEUint64(b []byte) uint64 {\n _ = b[7] // bounds check hint to compiler; see golang.org/issue/14808\n return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |\n uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56\n}Let’s follow two bytes of output.addr.lo: addr[15] and addr[11]. Here is\na simplified SSA form before late opt:
v273 = Trunc64to8 <byte> v490 ; byte(input.addr.lo)\n v226 = Trunc64to8 <byte> v225 ; byte(input.addr.lo >> 32)\n; […]\n v235 = Store <mem> {byte} v233 v226 v223 ; a16[11] = byte(lo >> 32)\n v247 = Store <mem> {byte} v245 v238 v235 ; a16[12] = …\n v259 = Store <mem> {byte} v257 v250 v247 ; a16[13] = …\n v271 = Store <mem> {byte} v269 v262 v259 ; a16[14] = …\n v282 = Store <mem> {byte} v280 v273 v271 ; a16[15] = byte(lo)\n v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr\n v286 = Move <mem> {[16]byte} [16] v285 v22 v282 ; addr = a16\n; […]\n v433 = OffPtr <*byte> [15] v285 ; &addr[15]\n v435 = Load <byte> v433 v286 ; addr[15]\n v479 = OffPtr <*byte> [11] v285 ; &addr[11]\n v481 = Load <byte> v479 v286 ; addr[11]The first rule loads through the move: ```\n(Load (OffPtr [o] p) (Move p src mem))\n=> (Load (OffPtr [o] src) mem)
\n. It matches both loads, which now read `a16`\nwith the memory state before the copy:\nv600 = OffPtr <*byte> [15] v22 ; &a16[15]\n v435 = Load <byte> v600 v282 ; a16[15]\n v601 = OffPtr <*byte> [11] v22 ; &a16[11]\n v481 = Load <byte> v601 v282 ; a16[11]
\nThe second rule shortcuts a load following a store: ```\n(Load p (Store p x _)) =>\nx. It matches v435, as v282 stores a16[15]. It does not match v481:\nv235 stores a16[11] four stores earlier in the chain, while the variants of\nthis rule look through three stores at most.
v435 = Copy <byte> v273 ; byte(input.addr.lo)\n v601 = OffPtr <*byte> [11] v22 ; &a16[11]\n v481 = Load <byte> v601 v282 ; a16[11]The same happens to the other bytes: the rule forwards the four bytes stored\nlast, a16[12] to a16[15]. The twelve other loads now read a16 instead of\naddr.
BEUint64() becomes a chain of Or64, each one adding a byte shifted into\nplace. memcombine is a pass written in Go, not a set of rewrite\nrules. It starts from the last Or64 of the chain and collects up to eight\nterms. If each term is a byte load, extended to 64 bits and shifted, and if the\neight loads read consecutive addresses from the same pointer with the same\nmemory state, it replaces the whole chain with a single 64-bit load and a byte\nswap. Otherwise, it tries again with four, then two terms, and from each\nintermediate Or64. Here is the loop checking each term in a simplified version\nof combineLoads():
for i := int64(0); i < n; i++ {\n v := a[i]\n shift := int64(0)\n if v.Op == shiftOp {\n v, shift = peelShift(v)\n }\n if v.Op != extOp {\n return false\n }\n load := v.Args[0]\n if load.Op != ssaop.OpLoad {\n return false\n }\n if load.Args[1] != mem {\n return false\n }\n p, off := splitPtr(load.Args[0])\n if p != base {\n return false\n }\n r[i] = LoadRecord{load: load, offset: off, shift: shift}\n}For output.addr.hi, the eight loads read a16 with the same memory state\nv282:
v13 = Load <byte> v22 v282 ; a16[0]\n v530 = Load <byte> v14 v282 ; a16[1]\n v488 = Load <byte> v504 v282 ; a16[2]\n v405 = Load <byte> v537 v282 ; a16[3]\n v385 = Load <byte> v397 v282 ; a16[4]\n v361 = Load <byte> v373 v282 ; a16[5]\n v196 = Load <byte> v63 v282 ; a16[6]\n v432 = Load <byte> v315 v282 ; a16[7]\n v319 = ZeroExt8to64 <uint64> v432 ; uint64(a16[7])\n v329 = ZeroExt8to64 <uint64> v196 ; uint64(a16[6])\n v330 = Lsh64x64 <uint64> [true] v329 v138 ; uint64(a16[6]) << 8\n v331 = Or64 <uint64> v319 v330 ; a16[7] | a16[6] << 8\n; […] same for a16[5] to a16[1]\n v401 = ZeroExt8to64 <uint64> v13 ; uint64(a16[0])\n v402 = Lsh64x64 <uint64> [true] v401 v55 ; uint64(a16[0]) << 56\n v403 = Or64 <uint64> v402 v391 ; | a16[0] << 56 = output.addr.himemcombine merges them into one load and a swap:
v286 = Load <uint64> v22 v282 ; a16[:8]\n v285 = Bswap64 <uint64> v286 ; output.addr.hiFor output.addr.lo, here is the chain memcombine sees after late opt:
v436 = ZeroExt8to64 <uint64> v273 ; addr[15], forwarded\n v448 = Or64 <uint64> v436 v447 ; | addr[14] << 8, forwarded\n v460 = Or64 <uint64> v459 v448 ; | addr[13] << 16, forwarded\n v472 = Or64 <uint64> v471 v460 ; | addr[12] << 24, forwarded\n v484 = Or64 <uint64> v483 v472 ; | a16[11] << 32, loaded\n v496 = Or64 <uint64> v495 v484 ; | a16[10] << 40, loaded\n v508 = Or64 <uint64> v507 v496 ; | a16[9] << 48, loaded\n v520 = Or64 <uint64> v519 v508 ; | a16[8] << 56, loadedFrom v520, four of the eight terms are forwarded bytes, not loads from memory,\nand memcombine can’t combine them. It doesn’t merge the four remaining loads\neither, as they sit on top of the forwarded bytes.
In summary, the rewriting rules run too early to be effective. A quick\nworkaround exists: run an earlier round of memcombine before late opt. After\nthis change, the generated code for the helper is back to the\nshortest possible version:
// AX = input.addr.hi, BX = input.addr.lo, CX = input.z\n CMPQ net/netip·z4(SB), CX ; check "z" if this is an IPv4 address\n JNE end ; if not, stop here\n MOVQ net/netip·z6noz(SB), CX ; CX = netip.z6noz\nend:\n RET\n// return value = Addr{hi: AX, lo: BX, z: CX}And the benchmark confirms it! ✌️
\ngoos: linux\ngoarch: amd64\npkg: github.com/vincentbernat/go-netip-addrto6\ncpu: AMD Ryzen 5 5600X 6-Core Processor\n │ Go 1.26.8 │ Our branch │\n │ sec/op │ sec/op vs base │\nAddrTo6/safe 6.5470n ± 0% 0.8944n ± 4% -86.34% (p=0.002 n=6)\nAddrTo6/unsafe 0.9071n ± 3% 0.8682n ± 1% -4.28% (p=0.002 n=6)\nAddrTo6/builtin 0.8871n ± 2% 0.8785n ± 1% ~ (p=0.310 n=6)I think Go maintainers would reject this change because of the additional\nmemcombine pass. Instead, I plan to publish this blog post and bring up the\nsubject again as a follow-up to issue #54365. Either the sheer complexity and\nthe Go 1.27 regression convince the maintainers that adding a To6() method is\nsimpler and more efficient, or they advise me on how to move forward. Either\nway, digging into this subject taught me a lot about the Go compiler! ⚙️
Update (2026-10)
\nI opened issue #81994 to propose Addr.To6(). Give it a 👍 if you want it in Go!