Bidouiller le compilateur Go pour convertir efficacement les IPv4 en IPv6

Vincent Bernat

netip.​Addr ex­pose une mé­thode Unmap() qui ren­voie l’adresse IPv4 conte­nue dans une adresse IPv6 re­pré­sen­tant une IPv4 (IPv4-map­ped IPv6 ad­dress). À par­tir de ::ffff:​203.0.113.10 ou de ::ffff:​cb00:710a, elle ren­voie 203.0.113.101. Il n’existe pas de mé­thode Map() ou To6() pour l’opé­ra­tion in­verse. Une telle mé­thode est tri­viale à écrire, mais les main­te­neurs de Go l’ont re­fu­sée au mo­tif que les uti­li­sa­teurs de­vraient écrire netip.​AddrFrom16(ip.​As16()) et lais­ser le com­pi­la­teur l’op­ti­mi­ser2. Au­jourd’hui, cette construc­tion est huit fois plus lente qu’une mé­thode na­tive. Com­ment ap­prendre au com­pi­la­teur à l’op­timiser ?

Les solutions possibles#

Exa­mi­nons trois fa­çons d’im­plé­men­ter cette conver­sion pour netip.​Addr. Ma pré­fé­rée consiste à l’ajou­ter à la bi­blio­thèque stan­dard de Go. Les main­te­neurs de Go pré­fèrent une pe­tite fonc­tion uti­li­taire ex­terne en­chaî­nant netip.​AddrFrom16() et netip.​Addr.​As16(), en es­pé­rant que le com­pi­la­teur réus­sisse à l’op­ti­mi­ser. Le pa­quet unsafe ouvre une troi­sième voie, avec des per­for­mances iden­tiques à la pre­mière solution.

Modifier la bibliothèque standard de Go#

En in­terne, netip.​Addr stocke les adresses IP sous forme d’une va­leur de 128 bits ac­com­pa­gnée d’un champ sup­plé­men­taire z qui en­code la fa­mille et la zone :

type Addr struct {
    addr uint128
    z unique.Handle[addrDetail]
}

type addrDetail struct {
    isV6   bool   // false pour IPv4, true pour IPv6.
    zoneV6 string // != "" seulement si IsV6 est vrai.
}

var (
    z0    unique.Handle[addrDetail]
    z4    = unique.Make(addrDetail{})
    z6noz = unique.Make(addrDetail{isV6: true})
)

AddrFrom4() en­code une adresse IPv4 sous la forme d’une adresse IPv6 re­pré­sen­tant une IPv4 et as­signe le sin­gle­ton z4 au champ z :

// AddrFrom4 returns the address of the IPv4 address given by the bytes in addr.
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() trans­forme une adresse IPv6 re­pré­sen­tant une IPv4 en adresse IPv4 en as­si­gnant le sin­gle­ton z4 au champ :

func (ip Addr) Unmap() Addr {
    if ip.Is4In6() {
        ip.z = z4
    }
    return ip
}

Ajou­ter l’opé­ra­tion in­verse dans la bi­blio­thèque stan­dard de Go est tri­vial : il suf­fit d’as­si­gner au champ z le sin­gle­ton z6noz quand l’adresse est une IPv4.

// To6 maps an IPv4 address to an IPv4-mapped IPv6 address. It returns an
// IPv6 address unmodified.
func (ip Addr) To6() Addr {
    if ip.Is4() {
        ip.z = z6noz
    }
    return ip
}

Mise à jour (10.2026)

Plu­tôt que de mo­di­fier Go, nous pou­vons mo­di­fier n’im­porte quel pa­quet, y com­pris ceux de la bi­blio­thèque stan­dard, avec l’op­tion -overlay de go build. Dans notre cas, elle per­met d’ajou­ter To6() à net/​netip. Son usage reste tou­te­fois contrai­gnant3 : l’op­tion at­tend un fi­chier JSON as­so­ciant des che­mins ab­so­lus dans GOROOT à des fi­chiers de rem­pla­ce­ment et il faut la spé­ci­fier à chaque com­mande go.

Avec une fonction utilitaire#

Le champ z n’est pas ac­ces­sible en de­hors du pa­quet net/​netip. À la place, nous écri­vons une fonc­tion uti­li­taire au­tour de la construc­tion netip.​AddrFrom16(ip.​As16()) :

// AddrTo6 maps an IPv4 address to an IPv4-mapped IPv6 address. It returns an
// IPv6 address unmodified.
func AddrTo6(ip netip.Addr) netip.Addr {
    if ip.Is4() {
        ip = netip.AddrFrom16(ip.As16())
    }
    return ip
}

Avec le paquet unsafe#

Une autre so­lu­tion uti­lise le pa­quet unsafe pour mo­di­fier la struc­ture Addr par l’in­ter­mé­diaire d’une struc­ture avec le même schéma mémoire4 :

// addrProxy a le même schéma mémoire que 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 maps an IPv4 address to an IPv4-mapped IPv6 address. It returns an
// IPv6 address unmodified.
func AddrTo6(ip netip.Addr) netip.Addr {
    if !ip.Is4() {
        return ip
    }
    (*addrProxy)(unsafe.Pointer(&ip)).z = netipZ6noz
    return ip
}

Performances#

Sur mon or­di­na­teur, avec Go 1.27.1, la so­lu­tion in­té­grée à la bi­blio­thèque stan­dard coûte 0,88 ns par opé­ra­tion, alors que celle pri­vi­lé­giée par les main­te­neurs de Go coûte 7,14 ns. La so­lu­tion uti­li­sant unsafe égale les per­for­mances de la première.

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%

Code assembleur#

Re­gar­dons le code as­sem­bleur que le com­pi­la­teur gé­nère pour chaque so­lu­tion5. La so­lu­tion in­té­grée à la bi­blio­thèque stan­dard res­semble à ceci6 :

// AX = input.addr.hi, BX = input.addr.lo, CX = input.z
 CMPQ  net/netip·z4(SB), CX     ; vérifier avec "z" s'il s'agit d'une adresse IPv4
 JNE   end                      ; sinon, s'arrêter ici
 MOVQ  net/netip·z6noz(SB), CX  ; CX = netip.z6noz
end:
 RET
// valeur de retour = Addr{hi: AX, lo: BX, z: CX}

Le lan­gage as­sem­bleur de Go n’est pas une re­pré­sen­ta­tion di­recte du lan­gage ma­chine sous-ja­cent : il re­pose sur un jeu d’ins­truc­tions semi-abs­trait dé­rivé de l’as­sem­bleur de Plan 9. Il dis­pose de quatre pseudo-re­gistres : FP (frame poin­ter ou poin­teur de cadre pour les ar­gu­ments des fonc­tions), PC (pro­gram coun­ter ou comp­teur or­di­nal), SB (sta­tic base ou poin­teur de base pour les sym­boles glo­baux) et SP (stack poin­ter ou poin­teur de la pile). Il pos­sède aussi des re­gistres propres à l’ar­chi­tec­ture, comme AX, CX, DX, BX, SI, DI et R8 à R15. Les ins­truc­tions qui stockent une don­née uti­lisent leur der­nier ar­gu­ment comme des­ti­na­tion. Les ins­truc­tions peuvent por­ter un suf­fixe de taille ex­pli­cite : MOVB dé­place un oc­tet, MOVW 16 bits, MOVL 32 bits et MOVQ 64 bits. Dans l’exemple ci-des­sus, la pre­mière ins­truc­tion com­pare la va­leur de 64 bits z4 avec le re­gistre CX.

La so­lu­tion uti­li­sant unsafe est presque identique :

// AX = input.addr.hi, BX = input.addr.lo, CX = input.z
 CMPQ  net/netip·z4(SB), CX  ; vérifier avec "z" s'il s'agit d'une adresse IPv4
 JNE   end                   ; sinon, s'arrêter ici
 MOVQ  netipZ6noz(SB), CX    ; CX = netip.z6noz
end:
 RET
// valeur de retour = Addr{hi: AX, lo: BX, z: CX}

La so­lu­tion uti­li­taire com­porte beau­coup plus d’ins­truc­tions. Pour com­prendre pour­quoi, exa­mi­nons le code de As16() et de AddrFrom16(). Elles sont as­sez courtes pour que le com­pi­la­teur rem­place leur ap­pel par leur code.

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,
    }
}

On de­vine déjà la construc­tion qui sera à op­ti­mi­ser : le code stocke l’adresse IP dans un ta­bleau, le co­pie, puis l’en ex­trait. Si nous dé­ve­lop­pons le code Go à la main, nous obtenons :

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
}

En tant qu’hu­mains, nous pou­vons men­ta­le­ment ob­te­nir la forme op­timisée :

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
}

Mal­heu­reu­se­ment, avec Go 1.26.8, le com­pi­la­teur n’est pas as­sez ma­lin pour en faire autant :

// AX = input.addr.hi, BX = input.addr.lo, CX = input.z
; Réserver de la place sur la pile (32 octets) :
;    0(SP) addr netip.uint128
;   16(SP) a16 [16]byte
 PUSHQ   BP
 MOVQ    SP, BP
 SUBQ    $32, SP

 CMPQ    net/netip·z4(SB), CX  ; vérifier avec "z" s'il s'agit d'une adresse IPv4
 JNE     end                   ; sinon, s'arrêter ici

; Empaquetage : 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, 16 octets d'un coup via le registre vectoriel X0
 MOVUPS  net/netip·a16+16(SP), X0
 MOVUPS  X0, net/netip·addr(SP)

; CX = netip.z6noz
 MOVQ    net/netip·z6noz(SB), CX
; Dépaquetage : 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
// valeur de retour = Addr{hi: AX, lo: BX, z: CX}

Le com­pi­la­teur s’en sort ho­no­ra­ble­ment avec la ma­ni­pu­la­tion des oc­tets : les huit écri­tures d’un oc­tet pro­ve­nant de BEPutUint64() sont rem­pla­cées par un unique MOVBEQ, qui co­pie un re­gistre en in­ver­sant l’ordre de ses oc­tets, et les huit lec­tures d’un oc­tet de BEUint64() de­viennent aussi un unique MOVBEQ dans l’autre sens7. Il reste trois groupes d’ins­truc­tions : un em­pa­que­tage, une co­pie et un dé­pa­quetage.

Bidouiller le compilateur#

Le com­pi­la­teur Go com­porte plu­sieurs phases :

Ana­lyse syn­taxique
Le com­pi­la­teur dé­coupe le code source en lexèmes et l’ana­lyse. Il construit un arbre syn­taxique pour chaque fi­chier source.
Vé­ri­fi­ca­tion des types
Le com­pi­la­teur as­so­cie chaque iden­ti­fiant à l’ob­jet qu’il dé­signe, cal­cule les ex­pres­sions constantes et in­fère le type de chaque ex­pression.
Construc­tion de l’IR
Le com­pi­la­teur conver­tit l’arbre syn­taxique et ses types dans une re­pré­sen­ta­tion in­ter­mé­diaire (IR). Ce pro­ces­sus, ap­pelé « no­ding », passe par un for­mat de sé­ria­li­sa­tion nommé unified IR.
Middle end
Le com­pi­la­teur ef­fec­tue plu­sieurs passes d’op­ti­mi­sa­tion sur l’IR, comme la dé­vir­tua­li­sa­tion, le rem­pla­ce­ment des ap­pels de fonc­tion par leurs conte­nus et l’ana­lyse d’échappement.
Walk
Cette phase com­porte deux étapes : une dé­com­po­si­tion des ins­truc­tions com­plexes en ins­truc­tions plus simples et la trans­for­ma­tion des construc­tions Go de haut ni­veau, comme switch ou les ca­naux, en ins­truc­tions plus pri­mi­tives ou en ap­pels à des fonctions.
SSA gé­né­rique
Le com­pi­la­teur conver­tit l’IR en forme SSA (Sta­tic Single As­si­gn­ment), une re­pré­sen­ta­tion in­ter­mé­diaire de plus bas ni­veau adap­tée aux op­ti­mi­sa­tions et règles de ré­écri­ture in­dé­pen­dantes de l’ar­chi­tecture.
Gé­né­ra­tion du code ma­chine
Le com­pi­la­teur ré­écrit la forme SSA en va­riantes propres à l’ar­chi­tec­ture, al­loue les re­gistres et ap­plique d’autres passes d’op­ti­mi­sa­tion. Pour fi­nir, l’as­sem­bleur trans­forme les ins­truc­tions gé­né­rées en code machine.

Le marteau#

Ma pre­mière idée est de rem­pla­cer les oc­cur­rences de netip.​AddrFrom16(ip.​As16()) par netip.​Addr{addr: ip.​addr, z: netip.​z6noz} le plus tôt pos­sible, c’est-à-dire pen­dant le no­ding. Avant cela, la phase de vé­ri­fi­ca­tion des types nous in­ter­dit d’ac­cé­der aux champs non ex­por­tés d’une structure.

Go 1.27 a in­tro­duit une op­tion de dé­bo­gage pra­tique pour af­fi­cher l’IR d’une fonc­tion à plu­sieurs mo­ments clés de la com­pilation :

$ 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

Dans le fi­chier HTML, la pre­mière co­lonne montre l’IR telle qu’elle sort du noding :

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

Dans le corps de l’ins­truc­tion if, nous re­pé­rons l’ap­pel à la mé­thode netip.​Addr.​As16() et ce­lui à la fonc­tion netip.​AddrFrom16(). Notre ob­jec­tif est de les rem­pla­cer par la construc­tion lit­té­rale d’une structure :

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]

Dans le fi­chier reader.go du no­der, la mé­thode expr() construit l’arbre IR d’une ex­pres­sion. À la fin de la branche exprCall, nous ajou­tons l’ap­pel à une fonc­tion rewriteAddrFrom16As16(). Elle prend en pa­ra­mètre le nœud cou­rant et ren­voie la struc­ture construite en cas de suc­cès ou nil si la ré­écri­ture n’est pas pos­sible. D’abord, nous vé­ri­fions que nous avons le mo­tif at­tendu : un ap­pel à la fonc­tion netip.​AddrFrom16() avec, pour unique ar­gu­ment, un ap­pel à la mé­thode netip.​Addr.As16() :

func rewriteAddrFrom16As16(n ir.Node) ir.Node {
    call, ok := n.(*ir.CallExpr)
    if !ok || call.Op() != ir.OCALLFUNC ||
        len(call.Args) != 1 || len(call.Init()) != 0 ||
        !isNetipFunc(call.Fun, "AddrFrom16") {
        return nil
    }
    inner, ok := call.Args[0].(*ir.CallExpr)
    if !ok || inner.Op() != ir.OCALLFUNC ||
        len(inner.Args) != 1 || len(inner.Init()) != 0 ||
        !isNetipFunc(inner.Fun, "Addr.As16") {
        return nil
    }
    x := inner.Args[0]
    // [...]
}

En­suite, nous ré­cu­pé­rons netip.z6noz :

z6noz, err := lookupVar(ir.StaticCalleeName(call.Fun).Sym().Pkg, "z6noz")
if err != nil {
    return nil
}

Et nous construi­sons lit­té­ra­le­ment la structure :

typ := call.Type()
pos := call.Pos()
var list []ir.Node
for i, f := range typ.Fields() {
    var value ir.Node
    switch f.Sym.Name {
    case "addr":
        value = typecheck.DotField(pos, x, i)
    case "z":
        value = z6noz
    default:
        return nil
    }
    list = append(list, ir.NewStructKeyExpr(pos, f, value))
}
lit := ir.NewCompLitExpr(pos, ir.OSTRUCTLIT, typ, list)
lit.SetTypecheck(1)
return lit

Je­tez un œil à la mo­di­fi­ca­tion com­plète8. Nous pou­vons la tes­ter avec les com­mandes suivantes :

$ cd src
$ ./make.bash
Building Go cmd/dist using /usr/lib/go-1.27. (go1.27.1 linux/amd64)
Building Go toolchain1 and bootstrap cmd/go (go_bootstrap) using /usr/lib/go-1.27.
Building Go toolchain2 using go_bootstrap and Go toolchain1.
Building Go toolchain3 and commands using go_bootstrap and Go toolchain2.
Checking command staleness for linux/amd64.
---
Installed Go for linux/amd64 in /home/bernat/code/free/go
Installed commands in /home/bernat/code/free/go/bin
*** You need to add /home/bernat/code/free/go/bin to your PATH.
$ export PATH=$PWD/../bin:$PATH
$ go version
go version go1.28-devel_9834516e20 Sat Sep 12 08:23:11 2026 -0700 linux/amd64
$ go test net/netip/...
ok      net/netip   0.224s
$ cd ../../go-netip-addrto6
$ go test .
ok      github.com/vincentbernat/go-netip-addrto6   0.062s

Le code gé­néré pour la fonc­tion uti­li­taire est dé­sor­mais le plus court possible !

// AX = input.addr.hi, BX = input.addr.lo, CX = input.z
 CMPQ    net/netip·z4(SB), CX     ; vérifier avec "z" s'il s'agit d'une adresse IPv4
 JNE     end                      ; sinon, s'arrêter ici
 MOVQ    net/netip·z6noz(SB), CX  ; CX = netip.z6noz
end:
 RET
// valeur de retour = Addr{hi: AX, lo: BX, z: CX}

Il est peu pro­bable que les main­te­neurs de Go ac­ceptent cette amé­lio­ra­tion. Elle dé­pend de la struc­ture in­terne de net/​netip.​Addr. C’est une bi­douille peu élé­gante dans le no­der, dont le rôle est de tra­duire fi­dè­le­ment l’AST vé­ri­fié en IR. Et elle est plus dif­fi­cile à main­te­nir que l’ajout de la mé­thode To6().

Le tournevis#

Le bon en­droit pour une telle op­ti­mi­sa­tion est la phase SSA gé­né­rique. L’une des der­nières passes in­dé­pen­dantes de l’ar­chi­tec­ture est memcombine. Avec l’op­tion de dé­bo­gage adé­quate, le com­pi­la­teur af­fiche la forme SSA après cette passe9 :

$ GOTOOLCHAIN=go1.26.8 GOAMD64=v3 \
> go build -a -gcflags='-d=ssa/memcombine/dump=AddrTo6Safe' .
$ head -5 AddrTo6Safe_01__memcombine.dump
AddrTo6Safe func(netip.Addr) netip.Addr
  b2:
    (?) v1 = InitMem <mem>
    (?) v2 = SP <uintptr>
    (?) v3 = SB <uintptr>

Le ré­sul­tat de la passe memcombine suit la même struc­ture que le code as­sem­bleur de AddrTo6Safe() exa­miné plus haut : deux écri­tures, une co­pie et deux lec­tures que nous ai­me­rions éliminer.

; […]
  v502 = ArgIntReg <uint64> {ip+0} [0]              ; input.addr.hi
  v490 = ArgIntReg <uint64> {ip+8} [1]              ; input.addr.lo
  v466 = ArgIntReg <*netip.addrDetail> {ip+16} [2]  ; input.z
; […]
  v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1     ; &a16
  v173 = OffPtr <*byte> [8] v22                     ; &a16[8]
  v442 = Bswap64 <uint64> v490                      ; bswap(input.addr.lo)
  v542 = Bswap64 <uint64> v502                      ; bswap(input.addr.hi)
  v161 = Store <mem> {uint64} v22 v542 v23          ; a16[:8] = bswap(hi)
  v282 = Store <mem> {uint64} v173 v442 v161        ; a16[8:] = bswap(lo)

  v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
  v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16

  v415 = OffPtr <*byte> [8] v285                    ; &addr[8]
  v416 = Load <uint64> v285 v286                    ; addr[:8]
  v299 = Bswap64 <uint64> v416                      ; output.addr.hi
  v174 = Load <uint64> v415 v286                    ; addr[8:]
  v39  = Bswap64 <uint64> v174                      ; output.addr.lo
; […]

Chaque ligne com­porte un iden­ti­fiant de va­leur (v442), une opé­ra­tion avec son type (Bswap64 <uint64>) et ses ar­gu­ments (v490)10. Les va­leurs sont les briques de base de la forme SSA et ne sont dé­fi­nies qu’une seule fois. Les pa­ra­mètres en­tiers sont en­tou­rés par des cro­chets ([8]) et les ar­gu­ments auxi­liaires sont in­di­qués par des ac­co­lades ({netip.​addr}). Les opé­ra­tions qui écrivent en mé­moire pro­duisent un nou­vel état de la mé­moire. Chaque opé­ra­tion mé­moire re­prend l’état cou­rant en der­nier ar­gu­ment, ce qui per­met de les main­te­nir dans l’ordre.

Sur le papier#

Concen­trons-nous sur output.​addr.lo, alias v39 :

  v490 = ArgIntReg <uint64> {ip+8} [1]              ; input.addr.lo
  v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1     ; &a16
  v173 = OffPtr <*byte> [8] v22                     ; &a16[8]
  v442 = Bswap64 <uint64> v490                      ; bswap(input.addr.lo)
  v282 = Store <mem> {uint64} v173 v442 v161        ; a16[8:] = bswap(lo)
  v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
  v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16
  v415 = OffPtr <*byte> [8] v285                    ; &addr[8]
  v174 = Load <uint64> v415 v286                    ; addr[8:]
  v39  = Bswap64 <uint64> v174                      ; output.addr.lo

Pour sim­pli­fier ce code, nous pour­rions ap­pli­quer trois règles de ré­écriture :

  1. La pre­mière ajoute un rac­courci pour une lec­ture à tra­vers une co­pie : (Load (OffPtr [o] p) (Move p src mem)) => (Load (OffPtr [o] src) mem). Elle s’ap­plique à v174 avec ses ar­gu­ments v415 et v286 et crée une nou­velle va­leur v600 :

      v490 = ArgIntReg <uint64> {ip+8} [1]              ; input.addr.lo
      v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1     ; &a16
      v173 = OffPtr <*byte> [8] v22                     ; &a16[8]
      v442 = Bswap64 <uint64> v490                      ; bswap(input.addr.lo)
      v282 = Store <mem> {uint64} v173 v442 v161        ; a16[8:] = bswap(lo)
      v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
      v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16
      v415 = OffPtr <*byte> [8] v285                    ; &addr[8]
      v600 = OffPtr <*byte> [8] v22                     ; &a16[8]
      v174 = Load <uint64> v600 v282                    ; a16[8:]
      v39  = Bswap64 <uint64> v174                      ; output.addr.lo
    
  2. La deuxième sim­pli­fie une lec­ture qui suit une écri­ture : (Load p (Store p x _)) => x. La lec­ture est trans­mise : la va­leur écrite la rem­place et il ne reste plus au­cun ac­cès mé­moire. Elle s’ap­plique à v174. Elle re­marque que v600 et v173 dé­si­gnent la même adresse et rem­place v174 par une co­pie de v442 :

      v490 = ArgIntReg <uint64> {ip+8} [1]              ; input.addr.lo
      v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1     ; &a16
      v173 = OffPtr <*byte> [8] v22                     ; &a16[8]
      v442 = Bswap64 <uint64> v490                      ; bswap(input.addr.lo)
      v282 = Store <mem> {uint64} v173 v442 v161        ; a16[8:] = bswap(lo)
      v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
      v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16
      v415 = OffPtr <*byte> [8] v285                    ; &addr[8]
      v600 = OffPtr <*byte> [8] v22                     ; &a16[8]
      v174 = Copy <uint64> v442                         ; bswap(input.addr.lo)
      v39  = Bswap64 <uint64> v174                      ; output.addr.lo
    
  3. La der­nière étape an­nule les deux in­ver­sions d’oc­tets : (Bswap64 (Bswap64 x)) => x. v39 de­vient une co­pie de v490 :

      v490 = ArgIntReg <uint64> {ip+8} [1]              ; input.addr.lo
      v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1     ; &a16
      v173 = OffPtr <*byte> [8] v22                     ; &a16[8]
      v442 = Bswap64 <uint64> v490                      ; bswap(input.addr.lo)
      v282 = Store <mem> {uint64} v173 v442 v161        ; a16[8:] = bswap(lo)
      v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
      v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16
      v415 = OffPtr <*byte> [8] v285                    ; &addr[8]
      v600 = OffPtr <*byte> [8] v22                     ; &a16[8]
      v174 = Copy <uint64> v442                         ; bswap(input.addr.lo)
      v39  = Copy <uint64> v490                         ; output.addr.lo = input.addr.lo
    

Si nous igno­rons les va­leurs in­utiles pour cal­cu­ler v39, il ne reste que cette forme SSA :

  v490 = ArgIntReg <uint64> {ip+8} [1]  ; input.addr.lo
  v39  = Copy <uint64> v490             ; output.addr.lo = input.addr.lo

Pas­sons à output.​addr.hi, alias v299 :

  v502 = ArgIntReg <uint64> {ip+0} [0]              ; input.addr.hi
  v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1     ; &a16
  v173 = OffPtr <*byte> [8] v22                     ; &a16[8]
  v542 = Bswap64 <uint64> v502                      ; bswap(input.addr.hi)
  v161 = Store <mem> {uint64} v22 v542 v23          ; a16[:8] = bswap(hi)
  v282 = Store <mem> {uint64} v173 v442 v161        ; a16[8:] = bswap(lo)
  v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
  v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16
  v416 = Load <uint64> v285 v286                    ; addr[:8]
  v299 = Bswap64 <uint64> v416                      ; output.addr.hi

Pour l’éli­mi­ner, nous ap­pli­quons là aussi trois règles de ré­écriture :

  1. La pre­mière rac­cour­cit une lec­ture à tra­vers une co­pie, mais sans ap­pli­quer un dé­ca­lage : (Load p (Move p src mem)) => (Load src mem). Elle ré­écrit v416 pour uti­li­ser les ar­gu­ments de v286 :

      v502 = ArgIntReg <uint64> {ip+0} [0]              ; input.addr.hi
      v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1     ; &a16
      v173 = OffPtr <*byte> [8] v22                     ; &a16[8]
      v542 = Bswap64 <uint64> v502                      ; bswap(input.addr.hi)
      v161 = Store <mem> {uint64} v22 v542 v23          ; a16[:8] = bswap(hi)
      v282 = Store <mem> {uint64} v173 v442 v161        ; a16[8:] = bswap(lo)
      v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
      v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16
      v416 = Load <uint64> v22 v282                     ; a16[:8]
      v299 = Bswap64 <uint64> v416                      ; output.addr.hi
    
  2. La deuxième règle trans­met une va­leur écrite une étape plus tôt, en igno­rant une écri­ture à une autre adresse quand il n’y a pas de che­vau­che­ment : (Load p (Store q _ (Store p x _))) => x. Elle s’ap­plique à v416 : x est v542, p est v22 (&a16), q est v173 (&a16[8]), et p et q ne se che­vauchent pas si on les consi­dère comme des uint64.

      v502 = ArgIntReg <uint64> {ip+0} [0]              ; input.addr.hi
      v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1     ; &a16
      v173 = OffPtr <*byte> [8] v22                     ; &a16[8]
      v542 = Bswap64 <uint64> v502                      ; bswap(input.addr.hi)
      v161 = Store <mem> {uint64} v22 v542 v23          ; a16[:8] = bswap(hi)
      v282 = Store <mem> {uint64} v173 v442 v161        ; a16[8:] = bswap(lo)
      v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
      v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16
      v416 = Copy <uint64> v542                         ; bswap(input.addr.hi)
      v299 = Bswap64 <uint64> v416                      ; output.addr.hi
    
  3. La troi­sième règle an­nule deux in­ver­sions d’oc­tets : (Bswap64 (Bswap64 x)) => x. v299 de­vient une co­pie de v502 :

      v502 = ArgIntReg <uint64> {ip+0} [0]              ; input.addr.hi
      v22 = LocalAddr <*[16]byte> {netip.a16} v2 v1     ; &a16
      v173 = OffPtr <*byte> [8] v22                     ; &a16[8]
      v542 = Bswap64 <uint64> v502                      ; bswap(input.addr.hi)
      v161 = Store <mem> {uint64} v22 v542 v23          ; a16[:8] = bswap(hi)
      v282 = Store <mem> {uint64} v173 v442 v161        ; a16[8:] = bswap(lo)
      v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
      v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16
      v416 = Copy <uint64> v542                         ; bswap(input.addr.hi)
      v299 = Copy <uint64> v502                         ; output.addr.hi = input.addr.hi
    

Si nous re­ti­rons les va­leurs in­utiles pour cal­cu­ler v299, nous ob­te­nons la forme SSA suivante :

  v502 = ArgIntReg <uint64> {ip+0} [0] ; input.addr.hi
  v299 = Copy <uint64> v502            ; output.addr.hi = input.addr.hi

En pratique#

La plu­part de ces règles existent déjà dans generic.​rules. Elles uti­lisent des condi­tions pour va­li­der leur contexte : ssa.​IsSamePtr() pour une même adresse, ssa.​Disjoint() pour des adresses qui ne se che­vauchent pas. La règle qui trans­met une va­leur écrite à une lec­ture existe déjà, avec trois va­riantes qui re­gardent à tra­vers plu­sieurs autres écri­tures. Voici les deux dont nous avons besoin :

(Load <t1> p1 (Store {t2} p2 x _))
    && ssa.IsSamePtr(p1, p2)
    && copyCompatibleType(t1, x.Type)
    && t1.Size() == t2.Size()
    => x
(Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 x _)))
    && ssa.IsSamePtr(p1, p3)
    && copyCompatibleType(t1, x.Type)
    && t1.Size() == t3.Size()
    && ssa.Disjoint(p3, t3, p2, t2)
    => x

Go 1.27 a ajouté la règle de lec­ture à tra­vers une co­pie dans CL 748200 pour cor­ri­ger le ti­cket #77720 :

(Load <t1> op1:(OffPtr [o1] p1) move:(Move [n] p2 src mem))
    && o1 >= 0 && o1+t1.Size() <= n && ssa.IsSamePtr(p1, p2)
    && !ssa.IsVolatile(src)
    => @move.Block (Load <t1> (OffPtr <op1.Type> [o1] src) mem)

Il lui manque une va­riante sans ap­pli­ca­tion d’un décalage :

(Load <t1> p1 move:(Move [n] p2 src mem))
    && p1.Op != ssaop.OpOffPtr
    && t1.Size() <= n && ssa.IsSamePtr(p1, p2)
    && !ssa.IsVolatile(src)
    => @move.Block (Load <t1> (OffPtr <p1.Type> [0] src) mem)

Il n’existe pas de règle gé­né­rique pour an­nu­ler deux in­ver­sions d’oc­tets, mais la passe de tra­duc­tion vers AMD64 com­porte cette règle :

(BSWAP(Q|L) (BSWAP(Q|L) p)) => p

Après bas­cule sur la branche de dé­ve­lop­pe­ment de Go et ajout de la règle man­quante, le code as­sem­bleur gé­néré est pire qu’avec Go 1.26.8, même si notre règle sup­plé­men­taire amé­liore lé­gè­re­ment la si­tua­tion à la fin :

// AX = input.addr.hi, BX = input.addr.lo, CX = input.z
; Réserver de la place sur la pile (16 octets) :
;    0(SP) a16 [16]byte
 PUSHQ   BP
 MOVQ    SP, BP
 SUBQ    $16, SP

 CMPQ    net/netip·z4(SB), CX       ; vérifier avec "z" s'il s'agit d'une adresse IPv4
 JNE     end                        ; sinon, s'arrêter ici

; Les quatre octets transmis : la moitié basse de input.addr.lo est découpée
; puis reconstituée dans les registres
 MOVQ    BX, DX                     ; DX = input.addr.lo
 SHRQ    $24, BX                    ; BX = input.addr.lo >> 24
 MOVQ    DX, SI                     ; SI = input.addr.lo
 SHRQ    $16, DX                    ; DX = input.addr.lo >> 16
 MOVQ    SI, DI                     ; DI = input.addr.lo, gardé pour l'empaquetage
 SHRQ    $8, SI                     ; SI = input.addr.lo >> 8
 MOVBLZX DIB, R8                    ; R8 = byte(input.addr.lo)
 MOVBLZX SIB, SI                    ; SI = byte(input.addr.lo >> 8)
 SHLQ    $8, SI
 ORQ     R8, SI                     ; SI = deux octets de poids faible de input.addr.lo
 MOVBLZX DL, DX                     ; DX = byte(input.addr.lo >> 16)
 SHLQ    $16, DX
 ORQ     SI, DX
 MOVBLZX BL, BX                     ; BX = byte(input.addr.lo >> 24)
 SHLQ    $24, BX
 ORQ     DX, BX                     ; BX = input.addr.lo & 0xffffffff

; Empaquetage : byteorder.BEPutUint64(a16[:8], input.addr.hi)
;               byteorder.BEPutUint64(a16[8:], input.addr.lo)
 MOVBEQ  AX, net/netip·a16(SP)
 MOVBEQ  DI, net/netip·a16+8(SP)

; Les quatre autres octets de input.addr.lo, lus un par un dans a16
 MOVBLZX net/netip·a16+11(SP), DX   ; a16[11]
 SHLQ    $32, DX
 ORQ     DX, BX
 MOVBLZX net/netip·a16+10(SP), DX   ; a16[10]
 SHLQ    $40, DX
 ORQ     DX, BX
 MOVBLZX net/netip·a16+9(SP), DX    ; a16[9]
 SHLQ    $48, DX
 ORQ     DX, BX
 MOVBLZX net/netip·a16+8(SP), DX    ; a16[8]
 SHLQ    $56, DX

; output.z = netip.z6noz
 MOVQ    net/netip·z6noz(SB), CX
; output.addr.hi = byteorder.BEUint64(a16[:8])
 MOVBEQ  net/netip·a16(SP), AX
; output.addr.lo assemblé à partir des étapes précédentes
 ORQ     DX, BX

end:
 LEAVEQ
 RET
// valeur de retour = Addr{hi: AX, lo: BX, z: CX}

C’est la règle de lec­ture à tra­vers une co­pie, ajou­tée dans Go 1.27, qui a in­tro­duit cette ré­gression.

Mise à jour (11.2026)

La branche de dé­ve­lop­pe­ment de Go in­tègre dé­sor­mais la même règle via CL 841105 pour cor­ri­ger le ti­cket #81839. Le code gé­néré est iden­tique à ce­lui ci-dessus.

Dans le désordre#

Ne bais­sons pas les bras ! En réa­lité, les règles de ré­écri­ture s’exé­cutent avant memcombine, no­tam­ment dans la passe late opt. À ce stade, le com­pi­la­teur a rem­placé les ap­pels de BEPutUint64() et de BEUint64() par seize écri­tures et seize lec­tures d’un oc­tet, confor­mé­ment à leur code source :

func BEUint64(b []byte) uint64 {
    _ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
    return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
        uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
}

Sui­vons deux oc­tets de output.​addr.lo : addr[15] et addr[11]. Voici une forme SSA sim­pli­fiée avant la passe late opt :

  v273 = Trunc64to8 <byte> v490                     ; byte(input.addr.lo)
  v226 = Trunc64to8 <byte> v225                     ; byte(input.addr.lo >> 32)
; […]
  v235 = Store <mem> {byte} v233 v226 v223          ; a16[11] = byte(lo >> 32)
  v247 = Store <mem> {byte} v245 v238 v235          ; a16[12] = …
  v259 = Store <mem> {byte} v257 v250 v247          ; a16[13] = …
  v271 = Store <mem> {byte} v269 v262 v259          ; a16[14] = …
  v282 = Store <mem> {byte} v280 v273 v271          ; a16[15] = byte(lo)
  v285 = LocalAddr <*[16]byte> {netip.addr} v2 v282 ; &addr
  v286 = Move <mem> {[16]byte} [16] v285 v22 v282   ; addr = a16
; […]
  v433 = OffPtr <*byte> [15] v285                   ; &addr[15]
  v435 = Load <byte> v433 v286                      ; addr[15]
  v479 = OffPtr <*byte> [11] v285                   ; &addr[11]
  v481 = Load <byte> v479 v286                      ; addr[11]

La pre­mière règle lit à tra­vers la co­pie : (Load (OffPtr [o] p) (Move p src mem)) => (Load (OffPtr [o] src) mem). Elle s’ap­plique aux deux lec­tures, qui lisent dé­sor­mais a16 avec l’état de la mé­moire pré­cé­dant la copie :

  v600 = OffPtr <*byte> [15] v22 ; &a16[15]
  v435 = Load <byte> v600 v282   ; a16[15]
  v601 = OffPtr <*byte> [11] v22 ; &a16[11]
  v481 = Load <byte> v601 v282   ; a16[11]

La deuxième règle rac­cour­cit une lec­ture qui suit une écri­ture : (Load p (Store p x _)) => x. Elle s’ap­plique à v435, puisque v282 écrit a16[15]. Elle ne s’ap­plique pas à v481 : v235 écrit a16[11] quatre écri­tures plus tôt dans la chaîne, alors que les va­riantes de cette règle ne re­montent au maxi­mum qu’à trois écritures.

  v435 = Copy <byte> v273        ; byte(input.addr.lo)
  v601 = OffPtr <*byte> [11] v22 ; &a16[11]
  v481 = Load <byte> v601 v282   ; a16[11]

Il en va de même pour les autres oc­tets : la règle trans­met les quatre der­niers oc­tets écrits, de a16[12] à a16[15]. Les douze autres lec­tures conti­nuent de lire a16 au lieu de addr.

BEUint64() de­vient une chaîne de Or64, cha­cun pla­çant un oc­tet à sa place. memcombine est une passe écrite en Go, et non un en­semble de règles de ré­écri­ture. Elle part du der­nier Or64 de la chaîne et col­lecte jusqu’à huit termes. Si chaque terme est la lec­ture d’un oc­tet, éten­due à 64 bits et dé­ca­lée, et si les huit lec­tures portent sur des adresses consé­cu­tives à par­tir du même poin­teur avec le même état de la mé­moire, elle rem­place toute la chaîne par une unique lec­ture de 64 bits et une in­ver­sion d’oc­tets. Si­non, elle ré­es­saie avec quatre termes, puis deux ainsi qu’à par­tir de chaque Or64 in­ter­mé­diaire. Voici la boucle qui vé­ri­fie chaque terme dans une ver­sion sim­pli­fiée de combineLoads() :

for i := int64(0); i < n; i++ {
    v := a[i]
    shift := int64(0)
    if v.Op == shiftOp {
        v, shift = peelShift(v)
    }
    if v.Op != extOp {
        return false
    }
    load := v.Args[0]
    if load.Op != ssaop.OpLoad {
        return false
    }
    if load.Args[1] != mem {
        return false
    }
    p, off := splitPtr(load.Args[0])
    if p != base {
        return false
    }
    r[i] = LoadRecord{load: load, offset: off, shift: shift}
}

Pour output.​addr.hi, les huit lec­tures portent sur a16 avec le même état de la mé­moire, v282 :

  v13  = Load <byte> v22 v282               ; a16[0]
  v530 = Load <byte> v14 v282               ; a16[1]
  v488 = Load <byte> v504 v282              ; a16[2]
  v405 = Load <byte> v537 v282              ; a16[3]
  v385 = Load <byte> v397 v282              ; a16[4]
  v361 = Load <byte> v373 v282              ; a16[5]
  v196 = Load <byte> v63 v282               ; a16[6]
  v432 = Load <byte> v315 v282              ; a16[7]
  v319 = ZeroExt8to64 <uint64> v432         ; uint64(a16[7])
  v329 = ZeroExt8to64 <uint64> v196         ; uint64(a16[6])
  v330 = Lsh64x64 <uint64> [true] v329 v138 ; uint64(a16[6]) << 8
  v331 = Or64 <uint64> v319 v330            ; a16[7] | a16[6] << 8
; […] idem pour a16[5] à a16[1]
  v401 = ZeroExt8to64 <uint64> v13          ; uint64(a16[0])
  v402 = Lsh64x64 <uint64> [true] v401 v55  ; uint64(a16[0]) << 56
  v403 = Or64 <uint64> v402 v391            ; | a16[0] << 56 = output.addr.hi

memcombine les fu­sionne en une seule lec­ture et une in­version :

  v286 = Load <uint64> v22 v282   ; a16[:8]
  v285 = Bswap64 <uint64> v286    ; output.addr.hi

Pour output.​addr.lo, voici la chaîne que voit memcombine après late opt :

  v436 = ZeroExt8to64 <uint64> v273 ; addr[15], transmis
  v448 = Or64 <uint64> v436 v447    ; | addr[14] << 8, transmis
  v460 = Or64 <uint64> v459 v448    ; | addr[13] << 16, transmis
  v472 = Or64 <uint64> v471 v460    ; | addr[12] << 24, transmis
  v484 = Or64 <uint64> v483 v472    ; | a16[11] << 32, lu
  v496 = Or64 <uint64> v495 v484    ; | a16[10] << 40, lu
  v508 = Or64 <uint64> v507 v496    ; | a16[9] << 48, lu
  v520 = Or64 <uint64> v519 v508    ; | a16[8] << 56, lu

À par­tir de v520, quatre des huit termes sont des oc­tets trans­mis et non des lec­tures en mé­moire : memcombine ne peut pas les com­bi­ner. Elle ne fu­sionne pas non plus les quatre lec­tures res­tantes, car elles re­posent sur les oc­tets transmis.

Remise en ordre#

En ré­sumé, les règles de ré­écri­ture s’exé­cutent trop tôt pour être ef­fi­caces. Il existe un contour­ne­ment ra­pide : exé­cu­ter une pre­mière passe memcombine avant late opt. Après cette mo­di­fi­ca­tion, le code gé­néré pour la fonc­tion uti­li­taire re­de­vient le plus court possible :

// AX = input.addr.hi, BX = input.addr.lo, CX = input.z
 CMPQ    net/netip·z4(SB), CX     ; vérifier avec "z" s'il s'agit d'une adresse IPv4
 JNE     end                      ; sinon, s'arrêter ici
 MOVQ    net/netip·z6noz(SB), CX  ; CX = netip.z6noz
end:
 RET
// valeur de retour = Addr{hi: AX, lo: BX, z: CX}

Et les me­sures de per­for­mance le confirment ! ✌️

goos: linux
goarch: amd64
pkg: github.com/vincentbernat/go-netip-addrto6
cpu: AMD Ryzen 5 5600X 6-Core Processor
                   │   Go 1.26.8    │             Our branch              │
                   │     sec/op     │    sec/op     vs base               │
AddrTo6/safe          6.5470n ±  0%   0.8944n ± 4%  -86.34% (p=0.002 n=6)
AddrTo6/unsafe        0.9071n ±  3%   0.8682n ± 1%   -4.28% (p=0.002 n=6)
AddrTo6/builtin       0.8871n ±  2%   0.8785n ± 1%        ~ (p=0.310 n=6)

Prochaine étape#

Je pense que les main­te­neurs de Go re­jet­te­ront cette mo­di­fi­ca­tion à cause de la passe memcombine sup­plé­men­taire. À la place, je compte pu­blier cet ar­ticle et re­lan­cer le su­jet à la suite du ti­cket #54365. Soit la com­plexité du pro­blème et la ré­gres­sion de Go 1.27 convainquent les main­te­neurs qu’il est plus simple et ef­fi­cace d’ajou­ter une mé­thode To6(), soit ils me conseillent sur la marche à suivre. Dans tous les cas, creu­ser ce su­jet m’a beau­coup ap­pris sur le com­pi­la­teur Go ! ⚙️

Mise à jour (10.2026)

J’ai ou­vert le ti­cket #81994 pour pro­po­ser la mé­thode Addr.​To6(). Met­tez un 👍 si vous vou­lez la voir dans Go !