net/netip: use internal/byteorder

This also as a side effect fixes #56136 because internal/byteorder
package has a special treatment in the inliner.

Fixes #56136

Change-Id: Ib90eb716f7a67659fb4cea7e99c14cf7e819ef7b
GitHub-Last-Rev: a78d8f6feef78f3f2fc28b2a52cf6374728ce537
GitHub-Pull-Request: golang/go#67317
Reviewed-on: https://go-review.googlesource.com/c/go/+/584995
Auto-Submit: Ian Lance Taylor <iant@google.com>
Reviewed-by: Damien Neil <dneil@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@google.com>

diff --git a/src/net/netip/leaf_alts.go b/src/net/netip/leaf_alts.go
deleted file mode 100644 (file)
index d887bed..0000000
--- a/src/net/netip/leaf_alts.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Stuff that exists in std, but we can't use due to being a dependency
-// of net, for go/build deps_test policy reasons.
-
-package netip
-
-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
-}
-
-func bePutUint64(b []byte, v uint64) {
-       _ = b[7] // early bounds check to guarantee safety of writes below
-       b[0] = byte(v >> 56)
-       b[1] = byte(v >> 48)
-       b[2] = byte(v >> 40)
-       b[3] = byte(v >> 32)
-       b[4] = byte(v >> 24)
-       b[5] = byte(v >> 16)
-       b[6] = byte(v >> 8)
-       b[7] = byte(v)
-}
-
-func bePutUint32(b []byte, v uint32) {
-       _ = b[3] // early bounds check to guarantee safety of writes below
-       b[0] = byte(v >> 24)
-       b[1] = byte(v >> 16)
-       b[2] = byte(v >> 8)
-       b[3] = byte(v)
-}
-
-func leUint16(b []byte) uint16 {
-       _ = b[1] // bounds check hint to compiler; see golang.org/issue/14808
-       return uint16(b[0]) | uint16(b[1])<<8
-}
-
-func lePutUint16(b []byte, v uint16) {
-       _ = b[1] // early bounds check to guarantee safety of writes below
-       b[0] = byte(v)
-       b[1] = byte(v >> 8)
-}

diff --git a/src/net/netip/netip.go b/src/net/netip/netip.go
index 1912561c749aa5d15312ff721dcd9360013d36bd..1c06efac1e3e5852dbaf59694cf5ca9ea78d73fa 100644 (file)
--- a/src/net/netip/netip.go
+++ b/src/net/netip/netip.go
@@ -14,6 +14,7 @@ package netip
 import (
        "cmp"
        "errors"
+       "internal/byteorder"
        "math"
        "strconv"
        "unique"
@@ -102,8 +103,8 @@ func AddrFrom4(addr [4]byte) Addr {
 func AddrFrom16(addr [16]byte) Addr {
        return Addr{
                addr: uint128{
-                       beUint64(addr[:8]),
-                       beUint64(addr[8:]),
+                       byteorder.BeUint64(addr[:8]),
+                       byteorder.BeUint64(addr[8:]),
                },
                z: z6noz,
        }
@@ -676,8 +677,8 @@ func (ip Addr) Prefix(b int) (Prefix, error) {
 // [Addr.Zone] method to get it).
 // The ip zero value returns all zeroes.
 func (ip Addr) As16() (a16 [16]byte) {
-       bePutUint64(a16[:8], ip.addr.hi)
-       bePutUint64(a16[8:], ip.addr.lo)
+       byteorder.BePutUint64(a16[:8], ip.addr.hi)
+       byteorder.BePutUint64(a16[8:], ip.addr.lo)
        return a16
 }
 
@@ -686,7 +687,7 @@ func (ip Addr) As16() (a16 [16]byte) {
 // Note that 0.0.0.0 is not the zero Addr.
 func (ip Addr) As4() (a4 [4]byte) {
        if ip.z == z4 || ip.Is4In6() {
-               bePutUint32(a4[:], uint32(ip.addr.lo))
+               byteorder.BePutUint32(a4[:], uint32(ip.addr.lo))
                return a4
        }
        if ip.z == z0 {
@@ -702,12 +703,12 @@ func (ip Addr) AsSlice() []byte {
                return nil
        case z4:
                var ret [4]byte
-               bePutUint32(ret[:], uint32(ip.addr.lo))
+               byteorder.BePutUint32(ret[:], uint32(ip.addr.lo))
                return ret[:]
        default:
                var ret [16]byte
-               bePutUint64(ret[:8], ip.addr.hi)
-               bePutUint64(ret[8:], ip.addr.lo)
+               byteorder.BePutUint64(ret[:8], ip.addr.hi)
+               byteorder.BePutUint64(ret[8:], ip.addr.lo)
                return ret[:]
        }
 }
@@ -987,12 +988,12 @@ func (ip Addr) marshalBinaryWithTrailingBytes(trailingBytes int) []byte {
                b = make([]byte, trailingBytes)
        case z4:
                b = make([]byte, 4+trailingBytes)
-               bePutUint32(b, uint32(ip.addr.lo))
+               byteorder.BePutUint32(b, uint32(ip.addr.lo))
        default:
                z := ip.Zone()
                b = make([]byte, 16+len(z)+trailingBytes)
-               bePutUint64(b[:8], ip.addr.hi)
-               bePutUint64(b[8:], ip.addr.lo)
+               byteorder.BePutUint64(b[:8], ip.addr.hi)
+               byteorder.BePutUint64(b[8:], ip.addr.lo)
                copy(b[16:], z)
        }
        return b
@@ -1209,7 +1210,7 @@ func (p *AddrPort) UnmarshalText(text []byte) error {
 // containing the port in little-endian.
 func (p AddrPort) MarshalBinary() ([]byte, error) {
        b := p.Addr().marshalBinaryWithTrailingBytes(2)
-       lePutUint16(b[len(b)-2:], p.Port())
+       byteorder.LePutUint16(b[len(b)-2:], p.Port())
        return b, nil
 }
 
@@ -1224,7 +1225,7 @@ func (p *AddrPort) UnmarshalBinary(b []byte) error {
        if err != nil {
                return err
        }
-       *p = AddrPortFrom(addr, leUint16(b[len(b)-2:]))
+       *p = AddrPortFrom(addr, byteorder.LeUint16(b[len(b)-2:]))
        return nil
 }