@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/vendor/golang.org/x/net/quic/udp_msg.go

@@ -0,0 +1,245 @@
+// Copyright 2023 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.
+
+//go:build !quicbasicnet && (darwin || linux)
+
+package quic
+
+import (
+	"encoding/binary"
+	"net"
+	"net/netip"
+	"sync"
+	"syscall"
+	"unsafe"
+)
+
+// Network interface for platforms using sendmsg/recvmsg with cmsgs.
+
+type netUDPConn struct {
+	c         *net.UDPConn
+	localAddr netip.AddrPort
+}
+
+func newNetUDPConn(uc *net.UDPConn) (*netUDPConn, error) {
+	a, _ := uc.LocalAddr().(*net.UDPAddr)
+	localAddr := a.AddrPort()
+	if localAddr.Addr().IsUnspecified() {
+		// If the conn is not bound to a specified (non-wildcard) address,
+		// then set localAddr.Addr to an invalid netip.Addr.
+		// This better conveys that this is not an address we should be using,
+		// and is a bit more efficient to test against.
+		localAddr = netip.AddrPortFrom(netip.Addr{}, localAddr.Port())
+	}
+
+	sc, err := uc.SyscallConn()
+	if err != nil {
+		return nil, err
+	}
+	sc.Control(func(fd uintptr) {
+		// Ask for ECN info and (when we aren't bound to a fixed local address)
+		// destination info.
+		//
+		// If any of these calls fail, we won't get the requested information.
+		// That's fine, we'll gracefully handle the lack.
+		syscall.SetsockoptInt(int(fd), syscall.IPPROTO_IP, ip_recvtos, 1)
+		syscall.SetsockoptInt(int(fd), syscall.IPPROTO_IPV6, syscall.IPV6_RECVTCLASS, 1)
+		if !localAddr.IsValid() {
+			syscall.SetsockoptInt(int(fd), syscall.IPPROTO_IP, syscall.IP_PKTINFO, 1)
+			syscall.SetsockoptInt(int(fd), syscall.IPPROTO_IPV6, ipv6_recvpktinfo, 1)
+		}
+	})
+
+	return &netUDPConn{
+		c:         uc,
+		localAddr: localAddr,
+	}, nil
+}
+
+func (c *netUDPConn) Close() error { return c.c.Close() }
+
+func (c *netUDPConn) LocalAddr() netip.AddrPort {
+	a, _ := c.c.LocalAddr().(*net.UDPAddr)
+	return a.AddrPort()
+}
+
+func (c *netUDPConn) Read(f func(*datagram)) {
+	// We shouldn't ever see all of these messages at the same time,
+	// but the total is small so just allocate enough space for everything we use.
+	const (
+		inPktinfoSize  = 12 // int + in_addr + in_addr
+		in6PktinfoSize = 20 // in6_addr + int
+		ipTOSSize      = 4
+		ipv6TclassSize = 4
+	)
+	control := make([]byte, 0+
+		syscall.CmsgSpace(inPktinfoSize)+
+		syscall.CmsgSpace(in6PktinfoSize)+
+		syscall.CmsgSpace(ipTOSSize)+
+		syscall.CmsgSpace(ipv6TclassSize))
+
+	for {
+		d := newDatagram()
+		n, controlLen, _, peerAddr, err := c.c.ReadMsgUDPAddrPort(d.b, control)
+		if err != nil {
+			return
+		}
+		if n == 0 {
+			continue
+		}
+		d.localAddr = c.localAddr
+		d.peerAddr = unmapAddrPort(peerAddr)
+		d.b = d.b[:n]
+		parseControl(d, control[:controlLen])
+		f(d)
+	}
+}
+
+var cmsgPool = sync.Pool{
+	New: func() any {
+		return new([]byte)
+	},
+}
+
+func (c *netUDPConn) Write(dgram datagram) error {
+	controlp := cmsgPool.Get().(*[]byte)
+	control := *controlp
+	defer func() {
+		*controlp = control[:0]
+		cmsgPool.Put(controlp)
+	}()
+
+	localIP := dgram.localAddr.Addr()
+	if localIP.IsValid() {
+		if localIP.Is4() {
+			control = appendCmsgIPSourceAddrV4(control, localIP)
+		} else {
+			control = appendCmsgIPSourceAddrV6(control, localIP)
+		}
+	}
+	if dgram.ecn != ecnNotECT {
+		if dgram.peerAddr.Addr().Is4() {
+			control = appendCmsgECNv4(control, dgram.ecn)
+		} else {
+			control = appendCmsgECNv6(control, dgram.ecn)
+		}
+	}
+
+	_, _, err := c.c.WriteMsgUDPAddrPort(dgram.b, control, dgram.peerAddr)
+	return err
+}
+
+func parseControl(d *datagram, control []byte) {
+	msgs, err := syscall.ParseSocketControlMessage(control)
+	if err != nil {
+		return
+	}
+	for _, m := range msgs {
+		switch m.Header.Level {
+		case syscall.IPPROTO_IP:
+			switch m.Header.Type {
+			case syscall.IP_TOS, ip_recvtos:
+				// (Linux sets the type to IP_TOS, Darwin to IP_RECVTOS,
+				// just check for both.)
+				if ecn, ok := parseIPTOS(m.Data); ok {
+					d.ecn = ecn
+				}
+			case syscall.IP_PKTINFO:
+				if a, ok := parseInPktinfo(m.Data); ok {
+					d.localAddr = netip.AddrPortFrom(a, d.localAddr.Port())
+				}
+			}
+		case syscall.IPPROTO_IPV6:
+			switch m.Header.Type {
+			case syscall.IPV6_TCLASS:
+				// 32-bit integer containing the traffic class field.
+				// The low two bits are the ECN field.
+				if ecn, ok := parseIPv6TCLASS(m.Data); ok {
+					d.ecn = ecn
+				}
+			case ipv6_pktinfo:
+				if a, ok := parseIn6Pktinfo(m.Data); ok {
+					d.localAddr = netip.AddrPortFrom(a, d.localAddr.Port())
+				}
+			}
+		}
+	}
+}
+
+// IPV6_TCLASS is specified by RFC 3542 as an int.
+
+func parseIPv6TCLASS(b []byte) (ecnBits, bool) {
+	if len(b) != 4 {
+		return 0, false
+	}
+	return ecnBits(binary.NativeEndian.Uint32(b) & ecnMask), true
+}
+
+func appendCmsgECNv6(b []byte, ecn ecnBits) []byte {
+	b, data := appendCmsg(b, syscall.IPPROTO_IPV6, syscall.IPV6_TCLASS, 4)
+	binary.NativeEndian.PutUint32(data, uint32(ecn))
+	return b
+}
+
+// struct in_pktinfo {
+//   unsigned int   ipi_ifindex;  /* send/recv interface index */
+//   struct in_addr ipi_spec_dst; /* Local address */
+//   struct in_addr ipi_addr;     /* IP Header dst address */
+// };
+
+// parseInPktinfo returns the destination address from an IP_PKTINFO.
+func parseInPktinfo(b []byte) (dst netip.Addr, ok bool) {
+	if len(b) != 12 {
+		return netip.Addr{}, false
+	}
+	return netip.AddrFrom4([4]byte(b[8:][:4])), true
+}
+
+// appendCmsgIPSourceAddrV4 appends an IP_PKTINFO setting the source address
+// for an outbound datagram.
+func appendCmsgIPSourceAddrV4(b []byte, src netip.Addr) []byte {
+	// struct in_pktinfo {
+	//   unsigned int   ipi_ifindex;  /* send/recv interface index */
+	//   struct in_addr ipi_spec_dst; /* Local address */
+	//   struct in_addr ipi_addr;     /* IP Header dst address */
+	// };
+	b, data := appendCmsg(b, syscall.IPPROTO_IP, syscall.IP_PKTINFO, 12)
+	ip := src.As4()
+	copy(data[4:], ip[:])
+	return b
+}
+
+// struct in6_pktinfo {
+//   struct in6_addr  ipi6_addr;    /* src/dst IPv6 address */
+//   unsigned int     ipi6_ifindex; /* send/recv interface index */
+// };
+
+// parseIn6Pktinfo returns the destination address from an IPV6_PKTINFO.
+func parseIn6Pktinfo(b []byte) (netip.Addr, bool) {
+	if len(b) != 20 {
+		return netip.Addr{}, false
+	}
+	return netip.AddrFrom16([16]byte(b[:16])).Unmap(), true
+}
+
+// appendCmsgIPSourceAddrV6 appends an IPV6_PKTINFO setting the source address
+// for an outbound datagram.
+func appendCmsgIPSourceAddrV6(b []byte, src netip.Addr) []byte {
+	b, data := appendCmsg(b, syscall.IPPROTO_IPV6, ipv6_pktinfo, 20)
+	ip := src.As16()
+	copy(data[0:], ip[:])
+	return b
+}
+
+// appendCmsg appends a cmsg with the given level, type, and size to b.
+// It returns the new buffer, and the data section of the cmsg.
+func appendCmsg(b []byte, level, typ int32, size int) (_, data []byte) {
+	off := len(b)
+	b = append(b, make([]byte, syscall.CmsgSpace(size))...)
+	h := (*syscall.Cmsghdr)(unsafe.Pointer(&b[off]))
+	h.Level = level
+	h.Type = typ
+	h.SetLen(syscall.CmsgLen(size))
+	return b, b[off+syscall.CmsgSpace(0):][:size]
+}

package/bin/go/src/vendor/golang.org/x/net/quic/udp_other.go

@@ -0,0 +1,62 @@
+// Copyright 2023 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.
+
+//go:build quicbasicnet || !(darwin || linux)
+
+package quic
+
+import (
+	"net"
+	"net/netip"
+)
+
+// Lowest common denominator network interface: Basic net.UDPConn, no cmsgs.
+// We will not be able to send or receive ECN bits,
+// and we will not know what our local address is.
+//
+// The quicbasicnet build tag allows selecting this interface on any platform.
+
+// See udp.go.
+const (
+	udpECNSupport              = false
+	udpInvalidLocalAddrIsError = false
+)
+
+type netUDPConn struct {
+	c *net.UDPConn
+}
+
+func newNetUDPConn(uc *net.UDPConn) (*netUDPConn, error) {
+	return &netUDPConn{
+		c: uc,
+	}, nil
+}
+
+func (c *netUDPConn) Close() error { return c.c.Close() }
+
+func (c *netUDPConn) LocalAddr() netip.AddrPort {
+	a, _ := c.c.LocalAddr().(*net.UDPAddr)
+	return a.AddrPort()
+}
+
+func (c *netUDPConn) Read(f func(*datagram)) {
+	for {
+		dgram := newDatagram()
+		n, peerAddr, err := c.c.ReadFromUDPAddrPort(dgram.b)
+		if err != nil {
+			return
+		}
+		if n == 0 {
+			continue
+		}
+		dgram.peerAddr = unmapAddrPort(peerAddr)
+		dgram.b = dgram.b[:n]
+		f(dgram)
+	}
+}
+
+func (c *netUDPConn) Write(dgram datagram) error {
+	_, err := c.c.WriteToUDPAddrPort(dgram.b, dgram.peerAddr)
+	return err
+}

package/bin/go/src/vendor/golang.org/x/net/quic/udp_packetconn.go

@@ -0,0 +1,67 @@
+// 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.
+
+package quic
+
+import (
+	"net"
+	"net/netip"
+)
+
+// netPacketConn is a packetConn implementation wrapping a net.PacketConn.
+//
+// This is mostly useful for tests, since PacketConn doesn't provide access to
+// important features such as identifying the local address packets were received on.
+type netPacketConn struct {
+	c         net.PacketConn
+	localAddr netip.AddrPort
+}
+
+func newNetPacketConn(pc net.PacketConn) (*netPacketConn, error) {
+	addr, err := addrPortFromAddr(pc.LocalAddr())
+	if err != nil {
+		return nil, err
+	}
+	return &netPacketConn{
+		c:         pc,
+		localAddr: addr,
+	}, nil
+}
+
+func (c *netPacketConn) Close() error {
+	return c.c.Close()
+}
+
+func (c *netPacketConn) LocalAddr() netip.AddrPort {
+	return c.localAddr
+}
+
+func (c *netPacketConn) Read(f func(*datagram)) {
+	for {
+		dgram := newDatagram()
+		n, peerAddr, err := c.c.ReadFrom(dgram.b)
+		if err != nil {
+			return
+		}
+		dgram.peerAddr, err = addrPortFromAddr(peerAddr)
+		if err != nil {
+			continue
+		}
+		dgram.b = dgram.b[:n]
+		f(dgram)
+	}
+}
+
+func (c *netPacketConn) Write(dgram datagram) error {
+	_, err := c.c.WriteTo(dgram.b, net.UDPAddrFromAddrPort(dgram.peerAddr))
+	return err
+}
+
+func addrPortFromAddr(addr net.Addr) (netip.AddrPort, error) {
+	switch a := addr.(type) {
+	case *net.UDPAddr:
+		return a.AddrPort(), nil
+	}
+	return netip.ParseAddrPort(addr.String())
+}

package/bin/go/src/vendor/golang.org/x/sys/cpu/asm_darwin_arm64_gc.s

@@ -0,0 +1,12 @@
+// 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.
+
+//go:build darwin && arm64 && gc
+
+#include "textflag.h"
+
+TEXT libc_sysctlbyname_trampoline<>(SB),NOSPLIT,$0-0
+	JMP	libc_sysctlbyname(SB)
+GLOBL	·libc_sysctlbyname_trampoline_addr(SB), RODATA, $8
+DATA	·libc_sysctlbyname_trampoline_addr(SB)/8, $libc_sysctlbyname_trampoline<>(SB)

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu.go

@@ -152,13 +152,17 @@ var ARM struct {
 // The booleans in Loong64 contain the correspondingly named cpu feature bit.
 // The struct is padded to avoid false sharing.
 var Loong64 struct {
-	_         CacheLinePad
-	HasLSX    bool // support 128-bit vector extension
-	HasLASX   bool // support 256-bit vector extension
-	HasCRC32  bool // support CRC instruction
-	HasLAM_BH bool // support AM{SWAP/ADD}[_DB].{B/H} instruction
-	HasLAMCAS bool // support AMCAS[_DB].{B/H/W/D} instruction
-	_         CacheLinePad
+	_              CacheLinePad
+	HasLSX         bool // support 128-bit vector extension
+	HasLASX        bool // support 256-bit vector extension
+	HasCRC32       bool // support CRC instruction
+	HasLAMCAS      bool // support AMCAS[_DB].{B/H/W/D}
+	HasLAM_BH      bool // support AM{SWAP/ADD}[_DB].{B/H} instruction
+	HasLLACQ_SCREL bool // support LLACQ.{W/D}, SCREL.{W/D} instruction
+	HasSCQ         bool // support SC.Q instruction
+	HasDBAR_HINTS  bool // supports finer-grained DBAR hints
+
+	_ CacheLinePad
 }
 
 // MIPS64X contains the supported CPU features of the current mips64/mips64le
@@ -232,6 +236,7 @@ var RISCV64 struct {
 	HasZba            bool // Address generation instructions extension
 	HasZbb            bool // Basic bit-manipulation extension
 	HasZbs            bool // Single-bit instructions extension
+	HasZbc            bool // Carryless multiplication extension
 	HasZvbb           bool // Vector Basic Bit-manipulation
 	HasZvbc           bool // Vector Carryless Multiplication
 	HasZvkb           bool // Vector Cryptography Bit-manipulation

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu_arm64.go

@@ -44,14 +44,11 @@ func initOptions() {
 }
 
 func archInit() {
-	switch runtime.GOOS {
-	case "freebsd":
+	if runtime.GOOS == "freebsd" {
 		readARM64Registers()
-	case "linux", "netbsd", "openbsd":
+	} else {
+		// Most platforms don't seem to allow directly reading these registers.
 		doinit()
-	default:
-		// Many platforms don't seem to allow reading these registers.
-		setMinimalFeatures()
 	}
 }
 

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu_darwin_arm64.go

@@ -0,0 +1,67 @@
+// 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.
+
+//go:build darwin && arm64 && gc
+
+package cpu
+
+func doinit() {
+	setMinimalFeatures()
+
+	// The feature flags are explained in [Instruction Set Detection].
+	// There are some differences between MacOS versions:
+	//
+	// MacOS 11 and 12 do not have "hw.optional" sysctl values for some of the features.
+	//
+	// MacOS 13 changed some of the naming conventions to align with ARM Architecture Reference Manual.
+	// For example "hw.optional.armv8_2_sha512" became "hw.optional.arm.FEAT_SHA512".
+	// It currently checks both to stay compatible with MacOS 11 and 12.
+	// The old names also work with MacOS 13, however it's not clear whether
+	// they will continue working with future OS releases.
+	//
+	// Once MacOS 12 is no longer supported the old names can be removed.
+	//
+	// [Instruction Set Detection]: https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics
+
+	// Encryption, hashing and checksum capabilities
+
+	// For the following flags there are no MacOS 11 sysctl flags.
+	ARM64.HasAES = true || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_AES\x00"))
+	ARM64.HasPMULL = true || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_PMULL\x00"))
+	ARM64.HasSHA1 = true || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_SHA1\x00"))
+	ARM64.HasSHA2 = true || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_SHA256\x00"))
+
+	ARM64.HasSHA3 = darwinSysctlEnabled([]byte("hw.optional.armv8_2_sha3\x00")) || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_SHA3\x00"))
+	ARM64.HasSHA512 = darwinSysctlEnabled([]byte("hw.optional.armv8_2_sha512\x00")) || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_SHA512\x00"))
+
+	ARM64.HasCRC32 = darwinSysctlEnabled([]byte("hw.optional.armv8_crc32\x00"))
+
+	// Atomic and memory ordering
+	ARM64.HasATOMICS = darwinSysctlEnabled([]byte("hw.optional.armv8_1_atomics\x00")) || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_LSE\x00"))
+	ARM64.HasLRCPC = darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_LRCPC\x00"))
+
+	// SIMD and floating point capabilities
+	ARM64.HasFPHP = darwinSysctlEnabled([]byte("hw.optional.neon_fp16\x00")) || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_FP16\x00"))
+	ARM64.HasASIMDHP = darwinSysctlEnabled([]byte("hw.optional.neon_hpfp\x00")) || darwinSysctlEnabled([]byte("hw.optional.AdvSIMD_HPFPCvt\x00"))
+	ARM64.HasASIMDRDM = darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_RDM\x00"))
+	ARM64.HasASIMDDP = darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_DotProd\x00"))
+	ARM64.HasASIMDFHM = darwinSysctlEnabled([]byte("hw.optional.armv8_2_fhm\x00")) || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_FHM\x00"))
+	ARM64.HasI8MM = darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_I8MM\x00"))
+
+	ARM64.HasJSCVT = darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_JSCVT\x00"))
+	ARM64.HasFCMA = darwinSysctlEnabled([]byte("hw.optional.armv8_3_compnum\x00")) || darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_FCMA\x00"))
+
+	// Miscellaneous
+	ARM64.HasDCPOP = darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_DPB\x00"))
+	ARM64.HasEVTSTRM = darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_ECV\x00"))
+	ARM64.HasDIT = darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_DIT\x00"))
+
+	// Not supported, but added for completeness
+	ARM64.HasCPUID = false
+
+	ARM64.HasSM3 = false  // darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_SM3\x00"))
+	ARM64.HasSM4 = false  // darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_SM4\x00"))
+	ARM64.HasSVE = false  // darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_SVE\x00"))
+	ARM64.HasSVE2 = false // darwinSysctlEnabled([]byte("hw.optional.arm.FEAT_SVE2\x00"))
+}

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu_darwin_arm64_other.go

@@ -0,0 +1,31 @@
+// 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.
+
+//go:build darwin && arm64 && !gc
+
+package cpu
+
+import "runtime"
+
+func doinit() {
+	setMinimalFeatures()
+
+	ARM64.HasASIMD = true
+	ARM64.HasFP = true
+
+	// Go already assumes these to be available because they were on the M1
+	// and these are supported on all Apple arm64 chips.
+	ARM64.HasAES = true
+	ARM64.HasPMULL = true
+	ARM64.HasSHA1 = true
+	ARM64.HasSHA2 = true
+
+	if runtime.GOOS != "ios" {
+		// Apple A7 processors do not support these, however
+		// M-series SoCs are at least armv8.4-a
+		ARM64.HasCRC32 = true   // armv8.1
+		ARM64.HasATOMICS = true // armv8.2
+		ARM64.HasJSCVT = true   // armv8.3, if HasFP
+	}
+}

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu_gccgo_arm64.go

@@ -9,3 +9,4 @@ package cpu
 func getisar0() uint64 { return 0 }
 func getisar1() uint64 { return 0 }
 func getpfr0() uint64  { return 0 }
+func getzfr0() uint64  { return 0 }

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu_linux_riscv64.go

@@ -58,6 +58,7 @@ const (
 	riscv_HWPROBE_EXT_ZBA         = 0x8
 	riscv_HWPROBE_EXT_ZBB         = 0x10
 	riscv_HWPROBE_EXT_ZBS         = 0x20
+	riscv_HWPROBE_EXT_ZBC         = 0x80
 	riscv_HWPROBE_EXT_ZVBB        = 0x20000
 	riscv_HWPROBE_EXT_ZVBC        = 0x40000
 	riscv_HWPROBE_EXT_ZVKB        = 0x80000
@@ -108,6 +109,7 @@ func doinit() {
 			RISCV64.HasZba = isSet(v, riscv_HWPROBE_EXT_ZBA)
 			RISCV64.HasZbb = isSet(v, riscv_HWPROBE_EXT_ZBB)
 			RISCV64.HasZbs = isSet(v, riscv_HWPROBE_EXT_ZBS)
+			RISCV64.HasZbc = isSet(v, riscv_HWPROBE_EXT_ZBC)
 			RISCV64.HasZvbb = isSet(v, riscv_HWPROBE_EXT_ZVBB)
 			RISCV64.HasZvbc = isSet(v, riscv_HWPROBE_EXT_ZVBC)
 			RISCV64.HasZvkb = isSet(v, riscv_HWPROBE_EXT_ZVKB)

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu_loong64.go

@@ -15,8 +15,13 @@ const (
 	cpucfg1_CRC32 = 1 << 25
 
 	// CPUCFG2 bits
-	cpucfg2_LAM_BH = 1 << 27
-	cpucfg2_LAMCAS = 1 << 28
+	cpucfg2_LAM_BH      = 1 << 27
+	cpucfg2_LAMCAS      = 1 << 28
+	cpucfg2_LLACQ_SCREL = 1 << 29
+	cpucfg2_SCQ         = 1 << 30
+
+	// CPUCFG3 bits
+	cpucfg3_DBAR_HINTS = 1 << 17
 )
 
 func initOptions() {
@@ -26,6 +31,9 @@ func initOptions() {
 		{Name: "crc32", Feature: &Loong64.HasCRC32},
 		{Name: "lam_bh", Feature: &Loong64.HasLAM_BH},
 		{Name: "lamcas", Feature: &Loong64.HasLAMCAS},
+		{Name: "llacq_screl", Feature: &Loong64.HasLLACQ_SCREL},
+		{Name: "scq", Feature: &Loong64.HasSCQ},
+		{Name: "dbar_hints", Feature: &Loong64.HasDBAR_HINTS},
 	}
 
 	// The CPUCFG data on Loong64 only reflects the hardware capabilities,
@@ -37,10 +45,14 @@ func initOptions() {
 	// through CPUCFG
 	cfg1 := get_cpucfg(1)
 	cfg2 := get_cpucfg(2)
+	cfg3 := get_cpucfg(3)
 
 	Loong64.HasCRC32 = cfgIsSet(cfg1, cpucfg1_CRC32)
 	Loong64.HasLAMCAS = cfgIsSet(cfg2, cpucfg2_LAMCAS)
 	Loong64.HasLAM_BH = cfgIsSet(cfg2, cpucfg2_LAM_BH)
+	Loong64.HasLLACQ_SCREL = cfgIsSet(cfg2, cpucfg2_LLACQ_SCREL)
+	Loong64.HasSCQ = cfgIsSet(cfg2, cpucfg2_SCQ)
+	Loong64.HasDBAR_HINTS = cfgIsSet(cfg3, cpucfg3_DBAR_HINTS)
 }
 
 func get_cpucfg(reg uint32) uint32

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu_other_arm64.go

@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !linux && !netbsd && !openbsd && arm64
+//go:build !darwin && !linux && !netbsd && !openbsd && !windows && arm64
 
 package cpu
 
-func doinit() {}
+func doinit() {
+	setMinimalFeatures()
+}

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu_riscv64.go

@@ -16,6 +16,7 @@ func initOptions() {
 		{Name: "zba", Feature: &RISCV64.HasZba},
 		{Name: "zbb", Feature: &RISCV64.HasZbb},
 		{Name: "zbs", Feature: &RISCV64.HasZbs},
+		{Name: "zbc", Feature: &RISCV64.HasZbc},
 		// RISC-V Cryptography Extensions
 		{Name: "zvbb", Feature: &RISCV64.HasZvbb},
 		{Name: "zvbc", Feature: &RISCV64.HasZvbc},

package/bin/go/src/vendor/golang.org/x/sys/cpu/cpu_windows.go

@@ -0,0 +1,26 @@
+// 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 cpu
+
+//go:generate go run golang.org/x/sys/windows/mkwinsyscall -systemdll=false -output zcpu_windows.go cpu_windows.go
+
+//sys	isProcessorFeaturePresent(ProcessorFeature uint32) (ret bool) = kernel32.IsProcessorFeaturePresent
+
+// The processor features to be tested for IsProcessorFeaturePresent, see
+// https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-isprocessorfeaturepresent
+const (
+	_PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE  = 30
+	_PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE   = 31
+	_PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE = 34
+	_PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE     = 43
+
+	_PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE = 44
+	_PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE = 45
+	_PF_ARM_SVE_INSTRUCTIONS_AVAILABLE       = 46
+	_PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE      = 47
+
+	_PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE   = 64
+	_PF_ARM_SHA512_INSTRUCTIONS_AVAILABLE = 65
+)