qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-14 23:20:27 -07:00
Code Releases Activity

net/netip: use internal/byteorder

Browse Source 
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: a78d8f6fee
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>
This commit is contained in:
Mateusz Poliwczak 2024-05-11 05:31:15 +00:00 committed by Damien Neil
parent f933f78d17
commit f43d9c40f3
2 changed files with 14 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
src/net/netip/leaf_alts.go
View File

@ -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)
}

27
src/net/netip/netip.go
View File

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