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>

2 files changed, 14 insertions, 58 deletions

diff --git a/src/net/netip/leaf_alts.go b/src/net/netip/leaf_alts.go
deleted file mode 100644
index d887bed627..0000000000
--- 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 1912561c74..1c06efac1e 100644
--- 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
 }