@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/internal/nettest/packetconn.go

@@ -0,0 +1,250 @@
+// Copyright 2026 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.
+
+package nettest
+
+import (
+	"context"
+	"errors"
+	"internal/gate"
+	"net"
+	"os"
+	"slices"
+	"sync"
+	"time"
+)
+
+// A PacketNet is a group of communicating [PacketConn]s.
+type PacketNet struct {
+	mu    sync.Mutex
+	conns map[netAddr]*PacketConn
+}
+
+type netAddr struct {
+	network string
+	addr    string
+}
+
+// NewPacketNet returns a new PacketNet.
+func NewPacketNet() *PacketNet {
+	return &PacketNet{
+		conns: make(map[netAddr]*PacketConn),
+	}
+}
+
+// NewConn returns a new [PacketConn] listening on the given address.
+// It returns an error if there is an existing listener on this address.
+func (n *PacketNet) NewConn(a net.Addr) (*PacketConn, error) {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	addrKey := netAddr{a.Network(), a.String()}
+	if _, ok := n.conns[addrKey]; ok {
+		return nil, &net.OpError{
+			Op:   "listen",
+			Net:  "udp",
+			Addr: a,
+			Err:  errors.New("address is in use"),
+		}
+	}
+	p := &PacketConn{
+		gate: gate.New(false),
+		addr: a,
+		net:  n,
+	}
+	n.conns[addrKey] = p
+	return p, nil
+}
+
+type PacketConn struct {
+	gate         gate.Gate
+	queue        queue[*packet]
+	closed       bool
+	readErr      error
+	writeErr     error
+	closeErr     error
+	readDeadline connDeadline
+
+	net  *PacketNet
+	addr net.Addr
+}
+
+type packet struct {
+	b   []byte
+	src net.Addr
+}
+
+// ReadFrom reads a packet from the connection, copying the payload into b.
+func (p *PacketConn) ReadFrom(b []byte) (n int, addr net.Addr, err error) {
+	p.gate.WaitAndLock(context.Background())
+	defer p.unlock()
+
+	switch {
+	case p.closed:
+		err = net.ErrClosed
+	case p.readDeadline.expired:
+		err = os.ErrDeadlineExceeded
+	case p.queue.len() == 0 && p.readErr != nil:
+		err = p.readErr
+	}
+	if err != nil {
+		return 0, nil, &net.OpError{
+			Op:   "read",
+			Net:  "udp",
+			Addr: p.addr,
+			Err:  err,
+		}
+	}
+	pkt := p.queue.pop()
+	n = copy(b, pkt.b)
+	return n, pkt.src, nil
+}
+
+// WriteTo writes a packet with payload b to addr.
+// addr must be a [*net.UDPAddr].
+//
+// WriteTo appends the packet to the recipient's receive buffer.
+// If no recipient is listening on addr or if the recipient's
+// receive buffer is full, the packet is silently discarded.
+func (p *PacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
+	p.gate.Lock()
+	switch {
+	case p.closed:
+		err = net.ErrClosed
+	case p.writeErr != nil:
+		err = p.writeErr
+	}
+	p.unlock()
+	if err != nil {
+		return 0, &net.OpError{
+			Op:     "write",
+			Net:    "udp",
+			Source: p.addr,
+			Addr:   addr,
+			Err:    err,
+		}
+	}
+
+	p.net.mu.Lock()
+	dst := p.net.conns[netAddr{addr.Network(), addr.String()}]
+	p.net.mu.Unlock()
+
+	if dst == nil {
+		// There is no PacketConn listening on the destination address,
+		// and the packet falls silently into the void.
+		return len(b), nil
+	}
+
+	dst.lock()
+	if !dst.closed {
+		dst.queue.push(&packet{b: slices.Clone(b), src: p.addr})
+	}
+	dst.unlock()
+	return len(b), nil
+}
+
+// Close closes the connection.
+func (p *PacketConn) Close() error {
+	p.net.mu.Lock()
+	delete(p.net.conns, netAddr{p.addr.Network(), p.addr.String()})
+	p.net.mu.Unlock()
+
+	p.lock()
+	defer p.unlock()
+	err := p.closeErr
+	p.closed = true
+	p.readErr = net.ErrClosed
+	p.writeErr = net.ErrClosed
+	p.closeErr = net.ErrClosed
+	if err != nil {
+		return &net.OpError{
+			Op:   "close",
+			Net:  "udp",
+			Addr: p.addr,
+			Err:  err,
+		}
+	}
+	return err
+}
+
+// LocalAddr returns the (fake) local network address.
+func (p *PacketConn) LocalAddr() net.Addr {
+	p.lock()
+	defer p.unlock()
+	return p.addr
+}
+
+// SetReadDeadline sets the read deadline for the connection.
+// PacketConns have no write deadline.
+func (p *PacketConn) SetDeadline(t time.Time) error {
+	return p.SetReadDeadline(t)
+}
+
+// SetReadDeadline sets the read deadline for the connection.
+func (p *PacketConn) SetReadDeadline(t time.Time) error {
+	p.readDeadline.setDeadline(p, t)
+	return nil
+}
+
+// SetWriteDeadline has no effect.
+// Writes to PacketConns never block.
+func (p *PacketConn) SetWriteDeadline(t time.Time) error {
+	return nil
+}
+
+// SetReadError causes any currently blocked and future ReadFrom calls to return
+// a net.OpError wrapping err. It does not affect the other half of the connection.
+// Reads will return any buffered data before returning the error,
+// including data written after the error is set.
+// A nil error restores the usual behavior.
+func (c *PacketConn) SetReadError(err error) {
+	c.lock()
+	defer c.unlock()
+	c.readErr = err
+}
+
+// SetWriteError causes any currently blocked and future WriteTo calls to return
+// a net.OpError wrapping err. It does not affect the other half of the connection.
+// Writes will not write data while an error is set.
+// A nil error restores the usual behavior.
+func (c *PacketConn) SetWriteError(err error) {
+	c.lock()
+	defer c.unlock()
+	c.writeErr = err
+}
+
+// SetCloseError sets the error returned by Close.
+// Close still closes the connection.
+// A nil error restores the usual behavior.
+func (c *PacketConn) SetCloseError(err error) {
+	c.lock()
+	defer c.unlock()
+	c.closeErr = err
+}
+
+// CanRead reports whether [ReadFrom] can return at least one byte or an error.
+// If [ReadFrom] would block, CanRead returns false.
+func (p *PacketConn) CanRead() bool {
+	p.lock()
+	defer p.unlock()
+	return p.canReadLocked()
+}
+
+func (p *PacketConn) canReadLocked() bool {
+	return p.queue.len() > 0 || p.readDeadline.expired || p.closed || p.readErr != nil
+}
+
+// IsClosed reports whether the connection has been closed.
+func (p *PacketConn) IsClosed() bool {
+	p.lock()
+	defer p.unlock()
+	return p.closed
+}
+
+func (p *PacketConn) lock() {
+	p.gate.Lock()
+}
+
+func (p *PacketConn) unlock() {
+	p.gate.Unlock(p.canReadLocked())
+}

package/bin/go/src/internal/nettest/queue.go

@@ -0,0 +1,33 @@
+// Copyright 2026 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.
+
+package nettest
+
+type queue[T any] struct {
+	headPos int
+	head    []T
+	tail    []T
+}
+
+func (q *queue[T]) len() int {
+	return len(q.head[q.headPos:]) + len(q.tail)
+}
+
+func (q *queue[T]) push(v T) {
+	q.tail = append(q.tail, v)
+}
+
+func (q *queue[T]) pop() T {
+	var zero T
+	if q.headPos >= len(q.head) {
+		if len(q.tail) == 0 {
+			return zero
+		}
+		q.head, q.headPos, q.tail = q.tail, 0, q.head[:0]
+	}
+	v := q.head[q.headPos]
+	q.head[q.headPos] = zero
+	q.headPos++
+	return v
+}

package/bin/go/src/internal/pkgbits/syncmarker_string.go

@@ -84,9 +84,9 @@ const _SyncMarker_name = "EOFBoolInt64Uint64StringValueValRelocsRelocUseRelocPub
 var _SyncMarker_index = [...]uint16{0, 3, 7, 12, 18, 24, 29, 32, 38, 43, 51, 57, 60, 67, 73, 80, 83, 89, 95, 99, 106, 120, 129, 135, 140, 147, 150, 160, 168, 175, 182, 188, 195, 201, 209, 214, 218, 226, 232, 234, 241, 248, 252, 260, 269, 279, 296, 305, 313, 318, 327, 333, 340, 350, 359, 369, 379, 389, 394, 405, 416, 424, 432, 437, 445, 450, 458, 467, 472, 480}
 
 func (i SyncMarker) String() string {
-	i -= 1
-	if i < 0 || i >= SyncMarker(len(_SyncMarker_index)-1) {
-		return "SyncMarker(" + strconv.FormatInt(int64(i+1), 10) + ")"
+	idx := int(i) - 1
+	if i < 1 || idx >= len(_SyncMarker_index)-1 {
+		return "SyncMarker(" + strconv.FormatInt(int64(i), 10) + ")"
 	}
-	return _SyncMarker_name[_SyncMarker_index[i]:_SyncMarker_index[i+1]]
+	return _SyncMarker_name[_SyncMarker_index[idx]:_SyncMarker_index[idx+1]]
 }

package/bin/go/src/internal/pkgbits/version.go

@@ -1,4 +1,4 @@
-// Copyright 2021 The Go Authors. All rights reserved.
+// Copyright 2024 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.
 
@@ -28,6 +28,19 @@ const (
 	// - remove derived info "needed" bool
 	V2
 
+	// V3: introduces a more compact format for composite literal element lists
+	// - negative lengths indicate that (some) elements may have keys
+	// - positive lengths indicate that no element has a key
+	// - a negative struct field index indicates an embedded field
+	V3
+
+	// V4: encodes generic methods as standalone function objects
+	V4
+
+	// V5: encodes the index of methods to preserve relative order
+	// of nongeneric and generic methods (go.dev/issue/81188).
+	V5
+
 	numVersions = iota
 )
 
@@ -61,6 +74,16 @@ const (
 	// whether a type was a derived type.
 	DerivedInfoNeeded
 
+	// Composite literals use a more compact format for element lists.
+	CompactCompLiterals
+
+	// Generic methods may appear as standalone function objects.
+	GenericMethods
+
+	// Method index is encoded to preserve relative order of
+	// nongeneric and generic methods.
+	PreserveMethodOrder
+
 	numFields = iota
 )
 
@@ -68,6 +91,9 @@ const (
 var introduced = [numFields]Version{
 	Flags:               V1,
 	AliasTypeParamNames: V2,
+	CompactCompLiterals: V3,
+	GenericMethods:      V4,
+	PreserveMethodOrder: V5,
 }
 
 // removed is the version a field was removed in or 0 for fields

package/bin/go/src/internal/platform/supported.go

@@ -90,9 +90,9 @@ func MustLinkExternal(goos, goarch string, withCgo bool) bool {
 			// https://go.dev/issue/14449
 			return true
 		case "ppc64":
-			// Big Endian PPC64 cgo internal linking is not implemented for aix or linux.
+			// Big Endian PPC64 cgo internal linking is not implemented for aix.
 			// https://go.dev/issue/8912
-			if goos == "aix" || goos == "linux" {
+			if goos == "aix" {
 				return true
 			}
 		}
@@ -144,9 +144,7 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool {
 			return true
 		case "linux":
 			switch goarch {
-			case "386", "amd64", "arm", "armbe", "arm64", "arm64be", "loong64", "ppc64le", "riscv64", "s390x":
-				// linux/ppc64 not supported because it does
-				// not support external linking mode yet.
+			case "386", "amd64", "arm", "armbe", "arm64", "arm64be", "loong64", "ppc64", "ppc64le", "riscv64", "s390x":
 				return true
 			default:
 				// Other targets do not support -shared,
@@ -164,7 +162,7 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool {
 
 	case "c-shared":
 		switch platform {
-		case "linux/amd64", "linux/arm", "linux/arm64", "linux/loong64", "linux/386", "linux/ppc64le", "linux/riscv64", "linux/s390x",
+		case "linux/amd64", "linux/arm", "linux/arm64", "linux/loong64", "linux/386", "linux/ppc64", "linux/ppc64le", "linux/riscv64", "linux/s390x",
 			"android/amd64", "android/arm", "android/arm64", "android/386",
 			"freebsd/amd64",
 			"darwin/amd64", "darwin/arm64",
@@ -182,7 +180,7 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool {
 
 	case "pie":
 		switch platform {
-		case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/loong64", "linux/ppc64le", "linux/riscv64", "linux/s390x",
+		case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/loong64", "linux/ppc64", "linux/ppc64le", "linux/riscv64", "linux/s390x",
 			"android/amd64", "android/arm", "android/arm64", "android/386",
 			"freebsd/amd64",
 			"darwin/amd64", "darwin/arm64",
@@ -196,14 +194,14 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool {
 
 	case "shared":
 		switch platform {
-		case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x":
+		case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64", "linux/ppc64le", "linux/s390x":
 			return true
 		}
 		return false
 
 	case "plugin":
 		switch platform {
-		case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/loong64", "linux/riscv64", "linux/s390x", "linux/ppc64le",
+		case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/loong64", "linux/riscv64", "linux/s390x", "linux/ppc64", "linux/ppc64le",
 			"android/amd64", "android/386",
 			"darwin/amd64", "darwin/arm64",
 			"freebsd/amd64":
@@ -220,7 +218,7 @@ func InternalLinkPIESupported(goos, goarch string) bool {
 	switch goos + "/" + goarch {
 	case "android/arm64",
 		"darwin/amd64", "darwin/arm64",
-		"linux/amd64", "linux/arm64", "linux/loong64", "linux/ppc64le",
+		"linux/amd64", "linux/arm64", "linux/loong64", "linux/ppc64", "linux/ppc64le", "linux/s390x",
 		"windows/386", "windows/amd64", "windows/arm64":
 		return true
 	}

package/bin/go/src/internal/platform/zosarch.go

@@ -47,7 +47,6 @@ var List = []OSArch{
 	{"openbsd", "amd64"},
 	{"openbsd", "arm"},
 	{"openbsd", "arm64"},
-	{"openbsd", "mips64"},
 	{"openbsd", "ppc64"},
 	{"openbsd", "riscv64"},
 	{"plan9", "386"},
@@ -87,7 +86,7 @@ var distInfo = map[OSArch]osArchInfo{
 	{"linux", "mips64"}:    {CgoSupported: true},
 	{"linux", "mips64le"}:  {CgoSupported: true},
 	{"linux", "mipsle"}:    {CgoSupported: true},
-	{"linux", "ppc64"}:     {},
+	{"linux", "ppc64"}:     {CgoSupported: true},
 	{"linux", "ppc64le"}:   {CgoSupported: true},
 	{"linux", "riscv64"}:   {CgoSupported: true},
 	{"linux", "s390x"}:     {CgoSupported: true},
@@ -100,7 +99,6 @@ var distInfo = map[OSArch]osArchInfo{
 	{"openbsd", "amd64"}:   {CgoSupported: true},
 	{"openbsd", "arm"}:     {CgoSupported: true},
 	{"openbsd", "arm64"}:   {CgoSupported: true},
-	{"openbsd", "mips64"}:  {CgoSupported: true, Broken: true},
 	{"openbsd", "ppc64"}:   {},
 	{"openbsd", "riscv64"}: {CgoSupported: true},
 	{"plan9", "386"}:       {},

package/bin/go/src/internal/poll/fd_mutex.go

@@ -34,11 +34,18 @@ const (
 	mutexWMask   = (1<<20 - 1) << 43
 )
 
+const (
+	readlock  = true
+	writeLock = false
+	waitLock  = true
+	tryLock   = false
+)
+
 const overflowMsg = "too many concurrent operations on a single file or socket (max 1048575)"
 
-// Read operations must do rwlock(true)/rwunlock(true).
+// Read operations must do rwlock(readlock, waitLock)/rwunlock(readlock).
 //
-// Write operations must do rwlock(false)/rwunlock(false).
+// Write operations must do rwlock(writeLock, waitLock)/rwunlock(writeLock).
 //
 // Misc operations must do incref/decref.
 // Misc operations include functions like setsockopt and setDeadline.
@@ -114,7 +121,8 @@ func (mu *fdMutex) decref() bool {
 
 // lock adds a reference to mu and locks mu.
 // It reports whether mu is available for reading or writing.
-func (mu *fdMutex) rwlock(read bool) bool {
+// If wait is false, lock fails immediately if mu is not available.
+func (mu *fdMutex) rwlock(read bool, wait bool) bool {
 	var mutexBit, mutexWait, mutexMask uint64
 	var mutexSema *uint32
 	if read {
@@ -142,6 +150,9 @@ func (mu *fdMutex) rwlock(read bool) bool {
 			}
 		} else {
 			// Wait for lock.
+			if !wait {
+				return false
+			}
 			new = old + mutexWait
 			if new&mutexMask == 0 {
 				panic(overflowMsg)
@@ -218,7 +229,7 @@ func (fd *FD) decref() error {
 // readLock adds a reference to fd and locks fd for reading.
 // It returns an error when fd cannot be used for reading.
 func (fd *FD) readLock() error {
-	if !fd.fdmu.rwlock(true) {
+	if !fd.fdmu.rwlock(readlock, waitLock) {
 		return errClosing(fd.isFile)
 	}
 	return nil
@@ -228,7 +239,7 @@ func (fd *FD) readLock() error {
 // It also closes fd when the state of fd is set to closed and there
 // is no remaining reference.
 func (fd *FD) readUnlock() {
-	if fd.fdmu.rwunlock(true) {
+	if fd.fdmu.rwunlock(readlock) {
 		fd.destroy()
 	}
 }
@@ -236,7 +247,7 @@ func (fd *FD) readUnlock() {
 // writeLock adds a reference to fd and locks fd for writing.
 // It returns an error when fd cannot be used for writing.
 func (fd *FD) writeLock() error {
-	if !fd.fdmu.rwlock(false) {
+	if !fd.fdmu.rwlock(writeLock, waitLock) {
 		return errClosing(fd.isFile)
 	}
 	return nil
@@ -246,7 +257,7 @@ func (fd *FD) writeLock() error {
 // It also closes fd when the state of fd is set to closed and there
 // is no remaining reference.
 func (fd *FD) writeUnlock() {
-	if fd.fdmu.rwunlock(false) {
+	if fd.fdmu.rwunlock(writeLock) {
 		fd.destroy()
 	}
 }
@@ -254,18 +265,46 @@ func (fd *FD) writeUnlock() {
 // readWriteLock adds a reference to fd and locks fd for reading and writing.
 // It returns an error when fd cannot be used for reading and writing.
 func (fd *FD) readWriteLock() error {
-	if !fd.fdmu.rwlock(true) || !fd.fdmu.rwlock(false) {
+	if !fd.fdmu.rwlock(readlock, waitLock) {
+		return errClosing(fd.isFile)
+	}
+	if !fd.fdmu.rwlock(writeLock, waitLock) {
+		if fd.fdmu.rwunlock(readlock) {
+			fd.destroy()
+		}
 		return errClosing(fd.isFile)
 	}
 	return nil
 }
 
+// tryReadWriteLock tries to add a reference to fd and lock fd for reading and writing.
+// It returns (false, nil) when fd is not available for reading and writing but is not closing.
+// It returns (false, errClosing) when fd is closing.
+func (fd *FD) tryReadWriteLock() (bool, error) {
+	if !fd.fdmu.rwlock(readlock, tryLock) {
+		if fd.closing() {
+			return false, errClosing(fd.isFile)
+		}
+		return false, nil
+	}
+	if !fd.fdmu.rwlock(writeLock, tryLock) {
+		if fd.fdmu.rwunlock(readlock) {
+			fd.destroy()
+		}
+		if fd.closing() {
+			return false, errClosing(fd.isFile)
+		}
+		return false, nil
+	}
+	return true, nil
+}
+
 // readWriteUnlock removes a reference from fd and unlocks fd for reading and writing.
 // It also closes fd when the state of fd is set to closed and there
 // is no remaining reference.
 func (fd *FD) readWriteUnlock() {
-	fd.fdmu.rwunlock(true)
-	if fd.fdmu.rwunlock(false) {
+	fd.fdmu.rwunlock(readlock)
+	if fd.fdmu.rwunlock(writeLock) {
 		fd.destroy()
 	}
 }

package/bin/go/src/internal/poll/fd_unix.go

@@ -148,7 +148,12 @@ func (fd *FD) Read(p []byte) (int, error) {
 		// without trying (but after acquiring the readLock).
 		// Otherwise syscall.Read returns 0, nil which looks like
 		// io.EOF.
-		// TODO(bradfitz): make it wait for readability? (Issue 15735)
+		//
+		// Waiting for readability instead was proposed in
+		// go.dev/cl/22031 and abandoned. Blocking would change
+		// the behavior of existing callers, and the netpoller's
+		// edge-triggered notifications alone cannot detect data
+		// that is already buffered. See go.dev/issue/15735.
 		return 0, nil
 	}
 	if err := fd.pd.prepareRead(fd.isFile); err != nil {