@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/internal/strconv/uscale.go

@@ -0,0 +1,290 @@
+// 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.
+
+// Floating point binary↔decimal conversion by fast unrounded scaling.
+// See “Floating-Point Printing and Parsing Can Be Simple And Fast”,
+// https://research.swtch.com/fp
+
+package strconv
+
+import (
+	"math/bits"
+	"unsafe"
+)
+
+// bool2 converts b to an integer: 1 for true, 0 for false.
+func bool2[T ~int | ~uint32 | ~uint64](b bool) T {
+	if b {
+		return 1
+	}
+	return 0
+}
+
+// pack64 takes m, e and returns f = m * 2**e.
+// It assumes the caller has provided a 53-bit mantissa m
+// and an exponent that is in range for the mantissa.
+func pack64(m uint64, e int) (float64, error) {
+	if m&(1<<52) == 0 {
+		return float64frombits(m), nil
+	}
+	if e >= 0x7FF-1075 {
+		return float64frombits(m&(1<<63) | 0x7ff<<52), ErrRange
+	}
+	return float64frombits(m&^(1<<52) | uint64(1075+e)<<52), nil
+}
+
+// pack32 takes m, e and returns f = m * 2**e.
+// It assumes the caller has provided a 24-bit mantissa m
+// and an exponent that is in range for the mantissa.
+func pack32(m uint32, e int) (float32, error) {
+	if m&(1<<23) == 0 {
+		return float32frombits(m), nil
+	}
+	if e >= 0xFF-150 {
+		return float32frombits(m&(1<<31) | 0xff<<23), ErrRange
+	}
+	return float32frombits(m&^(1<<23) | uint32(150+e)<<23), nil
+}
+
+// An unrounded represents an unrounded value.
+type unrounded uint64
+
+func (u unrounded) floor() uint64         { return uint64((u + 0) >> 2) }
+func (u unrounded) roundHalfDown() uint64 { return uint64((u + 1) >> 2) }
+func (u unrounded) round() uint64         { return uint64((u + 1 + (u>>2)&1) >> 2) }
+func (u unrounded) roundHalfUp() uint64   { return uint64((u + 2) >> 2) }
+func (u unrounded) ceil() uint64          { return uint64((u + 3) >> 2) }
+func (u unrounded) nudge(δ int) unrounded { return u + unrounded(δ) }
+
+func (u unrounded) div(d uint64) unrounded {
+	x := uint64(u)
+	return unrounded(x/d) | u&1 | bool2[unrounded](x%d != 0)
+}
+
+func (u unrounded) rsh(s int) unrounded {
+	return u>>s | u&1 | bool2[unrounded](u&((1<<s)-1) != 0)
+}
+
+// log10Pow2(x) returns ⌊log₁₀ 2**x⌋ = ⌊x * log₁₀ 2⌋.
+func log10Pow2(x int) int {
+	// log₁₀ 2 ≈ 0.30102999566 ≈ 78913 / 2^18
+	return (x * 78913) >> 18
+}
+
+// log2Pow10(x) returns ⌊log₂ 10**x⌋ = ⌊x * log₂ 10⌋.
+func log2Pow10(x int) int {
+	// log₂ 10 ≈ 3.32192809489 ≈ 108853 / 2^15
+	return (x * 108853) >> 15
+}
+
+// uint64pow10[x] is 10**x.
+var uint64pow10 = [...]uint64{
+	1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+}
+
+// fixedWidthFloat returns the n-digit decimal form of f = m * 2**e as d * 10**p.
+// n can be at most 18.
+// If fmt == 'f' then n is a conservative estimate of the number of digits,
+// and digits are discarded to match prec.
+func fixedWidthFloat(m uint64, e, n, prec int, fmt byte) (d uint64, p int) {
+	p = n - 1 - log10Pow2(e+63)
+	var pre scaler
+	prescale(&pre, e, p, log2Pow10(p))
+	u := uscale(m, &pre)
+	if u >= unmin(uint64pow10[n]) {
+		u = u.div(10)
+		p--
+	}
+	if fmt == 'f' {
+		for p > prec {
+			u = u.div(10)
+			p--
+		}
+	}
+	return u.round(), -p
+}
+
+// parseFloat64 rounds d * 10**p to the nearest float64 f.
+// d can have at most 19 digits.
+// It returns ErrRange if the result rounds to infinity.
+func parseFloat64(d uint64, p int, sign uint64) (float64, error) {
+	b := bits.Len64(d)
+	lp := log2Pow10(p)
+	e := min(1074, 53-b-lp)
+	var pre scaler
+	prescale(&pre, e-(64-b), p, lp)
+	if pre.s >= 64 {
+		return float64frombits(sign | 0), nil
+	}
+	u := uscale(d<<(64-b), &pre)
+
+	// This block is branch-free code for:
+	//	if u.round() >= 1<<53 {
+	//		u = u.rsh(1)
+	//		e = e - 1
+	//	}
+	s := bool2[int](u >= unmin(1<<53))
+	u = u>>s | u&1
+	e = e - s
+
+	return pack64(sign|u.round(), -e)
+}
+
+// parseFloat32 rounds d * 10**p to the nearest float32 f.
+// d can have at most 19 digits.
+// It returns ErrRange if the result rounds to infinity.
+func parseFloat32(d uint64, p int, sign uint32) (float32, error) {
+	b := bits.Len64(d)
+	lp := log2Pow10(p)
+	e := min(149, 24-b-lp)
+	var pre scaler
+	prescale(&pre, e-(64-b), p, lp)
+	if pre.s >= 64 {
+		return float32frombits(sign | 0), nil
+	}
+	u := uscale(d<<(64-b), &pre)
+
+	// This block is branch-free code for:
+	//	if u.round() >= 1<<24 {
+	//		u = u.rsh(1)
+	//		e = e - 1
+	//	}
+	s := bool2[int](u >= unmin(1<<24))
+	u = u>>s | u&1
+	e = e - s
+
+	return pack32(sign|uint32(u.round()), -e)
+}
+
+// unmin returns the minimum unrounded that rounds to x.
+func unmin(x uint64) unrounded {
+	return unrounded(x<<2 - 2)
+}
+
+// shortFloat computes the shortest formatting of f,
+// using as few digits as possible that will still round trip
+// back to the original float.
+func shortFloat[F float32 | float64](m uint64, e int) (d uint64, p int) {
+	var mantBits, minExp int // parameterized constants
+	switch 8 * unsafe.Sizeof(F(0)) {
+	case 32:
+		mantBits = float32MantBits
+		minExp = float32MinExp
+	case 64:
+		mantBits = float64MantBits
+		minExp = float64MinExp
+	}
+
+	// Note: these cases could be factored a little more,
+	// but in the first two branches, z is a constant,
+	// allowing the compiler to greatly simplify the code.
+	var min, max uint64
+	var odd int
+	z := 63 - mantBits
+	if m == 1<<63 && e > minExp {
+		p = -skewed(e + z)
+		min = m - 1<<(z-2) // min = m - 1/4 * 2**(e+z)
+		max = m + 1<<(z-1) // max = m + 1/2 * 2**(e+z)
+		odd = int(m>>z) & 1
+	} else if e >= minExp {
+		p = -log10Pow2(e + z)
+		min = m - 1<<(z-1) // min = m - 1/2 * 2**(e+z)
+		max = m + 1<<(z-1) // max = m + 1/2 * 2**(e+z)
+		odd = int(m>>z) & 1
+	} else {
+		z = z + (minExp - e)
+		p = -log10Pow2(e + z)
+		min = m - 1<<(z-1) // min = m - 1/2 * 2**(e+z)
+		max = m + 1<<(z-1) // max = m + 1/2 * 2**(e+z)
+		odd = int(m>>z) & 1
+	}
+
+	var pre scaler
+	prescale(&pre, e, p, log2Pow10(p))
+	dmin := uscale(min, &pre).nudge(+odd).ceil()
+	dmax := uscale(max, &pre).nudge(-odd).floor()
+
+	if d = dmax / 10; d*10 >= dmin {
+		return d, -(p - 1)
+	}
+	if d = dmin; d < dmax {
+		d = uscale(m, &pre).round()
+	}
+	return d, -p
+}
+
+// skewed computes the skewed footprint of m * 2**e,
+// which is ⌊log₁₀ 3/4 * 2**e⌋ = ⌊e*(log₁₀ 2)-(log₁₀ 4/3)⌋.
+func skewed(e int) int {
+	return (e*631305 - 261663) >> 21
+}
+
+// A pmHiLo represents hi<<64 - lo.
+type pmHiLo struct {
+	hi uint64
+	lo uint64
+}
+
+// A scaler holds derived scaling constants for a given e, p pair.
+type scaler struct {
+	// Note: using pm pmHiLo here nudges uscale just over the inlining boundary. Don't.
+	pmHi uint64
+	pmLo uint64
+	s    int
+}
+
+// prescale returns the scaling constants for e, p.
+// lp must be log2Pow10(p).
+// The caller is responsible for either avoiding e, p pairs
+// that cause pre.s < 0 or pre.s >= 64, or else handling
+// those cases before passing the result to uscale.
+// In practice, pre.s < 0 would indicate a buggy caller
+// and pre.s >= 64 can only happen for parsing and is
+// picked off at those call sites.
+func prescale(pre *scaler, e, p, lp int) {
+	pre.pmHi = pow10Tab[p-pow10Min].hi
+	pre.pmLo = pow10Tab[p-pow10Min].lo
+	pre.s = -(e + lp + 3)
+}
+
+// uscale returns unround(x * 2**e * 10**p).
+// The caller should pass &pre for prescale(&pre, e, p, log2Pow10(p))
+// and should have left-justified x so its high bit is set.
+// The caller is also responsible for checking that c.s < 64.
+// For formatting, that's always true.
+// For parsing, the caller needs to pick it off early and return a signed 0.
+func uscale(x uint64, c *scaler) unrounded {
+	hi, mid := bits.Mul64(x, c.pmHi)
+	s := c.s & 63 // make shifts cheaper
+	if hi>>s<<s != hi {
+		return unrounded(hi>>s | 1)
+	}
+	mid2, _ := bits.Mul64(x, c.pmLo)
+	hi -= bool2[uint64](mid < mid2)
+	return unrounded(hi>>s | bool2[uint64](mid-mid2 > 1))
+}
+
+// setDigits sets digs to the nd digits described by d, p.
+func setDigits(s []byte, d uint64, p, nd int) (dp, nzd int) {
+	// Note: nd <= len(s) is guaranteed by caller,
+	// but writing it explicitly here lets the compiler know,
+	// so that it can remove the bounds check in the loop.
+	// (The slice s[:nd] not panicking only establishes nd <= cap(s).)
+	if nd <= len(s) {
+		formatBase10(s[:nd], d)
+		dp = nd + p
+		for nd > 0 && s[nd-1] == '0' {
+			nd--
+		}
+	}
+	return dp, nd
+}
+
+// numDigits returns the number of decimal digits in d.
+// It requires d ≥ 1.
+func numDigits(d uint64) int {
+	nd := log10Pow2(bits.Len64(d))
+	return nd + bool2[int](d >= uint64pow10[nd])
+}

package/bin/go/src/internal/stringslite/strings.go

@@ -28,52 +28,15 @@ func IndexByte(s string, c byte) int {
 func Index(s, substr string) int {
 	n := len(substr)
 	switch {
-	case n == 0:
+	case n == 0 || substr == s:
 		return 0
 	case n == 1:
 		return IndexByte(s, substr[0])
-	case n == len(s):
-		if substr == s {
-			return 0
-		}
-		return -1
-	case n > len(s):
+	case n >= len(s):
 		return -1
-	case n <= bytealg.MaxLen:
+	case n <= bytealg.MaxLen && len(s) <= bytealg.MaxBruteForce:
 		// Use brute force when s and substr both are small
-		if len(s) <= bytealg.MaxBruteForce {
-			return bytealg.IndexString(s, substr)
-		}
-		c0 := substr[0]
-		c1 := substr[1]
-		i := 0
-		t := len(s) - n + 1
-		fails := 0
-		for i < t {
-			if s[i] != c0 {
-				// IndexByte is faster than bytealg.IndexString, so use it as long as
-				// we're not getting lots of false positives.
-				o := IndexByte(s[i+1:t], c0)
-				if o < 0 {
-					return -1
-				}
-				i += o + 1
-			}
-			if s[i+1] == c1 && s[i:i+n] == substr {
-				return i
-			}
-			fails++
-			i++
-			// Switch to bytealg.IndexString when IndexByte produces too many false positives.
-			if fails > bytealg.Cutover(i) {
-				r := bytealg.IndexString(s[i:], substr)
-				if r >= 0 {
-					return r + i
-				}
-				return -1
-			}
-		}
-		return -1
+		return bytealg.IndexString(s, substr)
 	}
 	c0 := substr[0]
 	c1 := substr[1]
@@ -82,6 +45,8 @@ func Index(s, substr string) int {
 	fails := 0
 	for i < t {
 		if s[i] != c0 {
+			// IndexByte is faster than bytealg.IndexString, so use it as long as
+			// we're not getting lots of false positives.
 			o := IndexByte(s[i+1:t], c0)
 			if o < 0 {
 				return -1
@@ -93,7 +58,14 @@ func Index(s, substr string) int {
 		}
 		i++
 		fails++
-		if fails >= 4+i>>4 && i < t {
+		if n <= bytealg.MaxLen && fails > bytealg.Cutover(i) {
+			// Switch to bytealg.IndexString when IndexByte produces too many false positives.
+			r := bytealg.IndexString(s[i:], substr)
+			if r >= 0 {
+				return r + i
+			}
+			return -1
+		} else if n > bytealg.MaxLen && fails >= 4+i>>4 && i < t {
 			// See comment in ../bytes/bytes.go.
 			j := bytealg.IndexRabinKarp(s[i:], substr)
 			if j < 0 {

package/bin/go/src/internal/syscall/unix/asm_openbsd.s

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !mips64
-
 #include "textflag.h"
 
 TEXT ·libc_faccessat_trampoline(SB),NOSPLIT,$0-0

package/bin/go/src/internal/syscall/unix/at.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build dragonfly || freebsd || linux || netbsd || (openbsd && mips64)
+//go:build dragonfly || freebsd || linux || netbsd
 
 package unix
 

package/bin/go/src/internal/syscall/unix/at_fstatat.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build dragonfly || (linux && !(loong64 || mips64 || mips64le)) || netbsd || (openbsd && mips64)
+//go:build dragonfly || (linux && !(loong64 || mips64 || mips64le)) || netbsd
 
 package unix
 

package/bin/go/src/internal/syscall/unix/at_libc2.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build darwin || (openbsd && !mips64)
+//go:build darwin || openbsd
 
 package unix
 

package/bin/go/src/internal/syscall/unix/at_openbsd.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !mips64
-
 package unix
 
 import (

package/bin/go/src/internal/syscall/unix/faccessat_bsd.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build dragonfly || freebsd || netbsd || (openbsd && mips64)
+//go:build dragonfly || freebsd || netbsd
 
 package unix
 

package/bin/go/src/internal/syscall/unix/faccessat_openbsd.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !mips64
-
 package unix
 
 import (

package/bin/go/src/internal/syscall/windows/at_windows.go

@@ -371,7 +371,6 @@ func Deleteat(dirfd syscall.Handle, name string, options uint32) error {
 		&IO_STATUS_BLOCK{},
 		unsafe.Pointer(&FILE_DISPOSITION_INFORMATION_EX{
 			Flags: FILE_DISPOSITION_DELETE |
-				FILE_DISPOSITION_FORCE_IMAGE_SECTION_CHECK |
 				FILE_DISPOSITION_POSIX_SEMANTICS |
 				// This differs from DeleteFileW, but matches os.Remove's
 				// behavior on Unix platforms of permitting deletion of
@@ -431,7 +430,7 @@ func deleteatFallback(h syscall.Handle) error {
 		h,
 		FileDispositionInfo,
 		unsafe.Pointer(&FILE_DISPOSITION_INFO{
-			DeleteFile: true,
+			DeleteFile: 1,
 		}),
 		uint32(unsafe.Sizeof(FILE_DISPOSITION_INFO{})),
 	)
@@ -492,7 +491,7 @@ func Renameat(olddirfd syscall.Handle, oldpath string, newdirfd syscall.Handle,
 	//
 	// Try again.
 	renameInfo := FILE_RENAME_INFORMATION{
-		ReplaceIfExists: true,
+		ReplaceIfExists: 1,
 		RootDirectory:   newdirfd,
 	}
 	copy(renameInfo.FileName[:], p16)
@@ -661,6 +660,7 @@ func symlinkat(oldname string, newdirfd syscall.Handle, newname string, flags Sy
 	namebuf := rdbbuf[bufferSize:]
 	copy(namebuf, unsafe.String((*byte)(unsafe.Pointer(&oldnameu16[0])), 2*len(oldnameu16)))
 
+	var bytesReturned uint32
 	err = syscall.DeviceIoControl(
 		h,
 		FSCTL_SET_REPARSE_POINT,
@@ -668,7 +668,7 @@ func symlinkat(oldname string, newdirfd syscall.Handle, newname string, flags Sy
 		uint32(len(rdbbuf)),
 		nil,
 		0,
-		nil,
+		&bytesReturned,
 		nil)
 	if err != nil {
 		// Creating the symlink has failed, so try to remove the file.
@@ -677,7 +677,7 @@ func symlinkat(oldname string, newdirfd syscall.Handle, newname string, flags Sy
 			h,
 			&IO_STATUS_BLOCK{},
 			unsafe.Pointer(&FILE_DISPOSITION_INFORMATION{
-				DeleteFile: true,
+				DeleteFile: 1,
 			}),
 			uint32(unsafe.Sizeof(FILE_DISPOSITION_INFORMATION{})),
 			FileDispositionInformation,

package/bin/go/src/internal/syscall/windows/net_windows.go

@@ -19,6 +19,7 @@ func WSASendtoInet6(s syscall.Handle, bufs *syscall.WSABuf, bufcnt uint32, sent
 
 const (
 	SO_TYPE                                = 0x1008
+	SO_PROTOCOL_INFOW                      = 0x2005
 	SIO_TCP_INITIAL_RTO                    = syscall.IOC_IN | syscall.IOC_VENDOR | 17
 	TCP_INITIAL_RTO_UNSPECIFIED_RTT        = ^uint16(0)
 	TCP_INITIAL_RTO_NO_SYN_RETRANSMISSIONS = ^uint8(1)

package/bin/go/src/internal/syscall/windows/string_windows.go

@@ -22,11 +22,14 @@ func NewNTUnicodeString(s string) (*NTUnicodeString, error) {
 	if err != nil {
 		return nil, err
 	}
-	n := uint16(len(s16) * 2)
+	n := len(s16) * 2
+	if n > (1<<16)-1 {
+		return nil, syscall.EINVAL
+	}
 	// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdmsec/nf-wdmsec-wdmlibrtlinitunicodestringex
 	return &NTUnicodeString{
-		Length:        n - 2, // subtract 2 bytes for the NUL terminator
-		MaximumLength: n,
+		Length:        uint16(n) - 2, // subtract 2 bytes for the NUL terminator
+		MaximumLength: uint16(n),
 		Buffer:        &s16[0],
 	}, nil
 }

package/bin/go/src/internal/syscall/windows/syscall_windows.go

@@ -573,6 +573,8 @@ type FILE_MODE_INFORMATION struct {
 	Mode uint32
 }
 
+//sys	IsProcessorFeaturePresent(ProcessorFeature uint32) (ret bool) = kernel32.IsProcessorFeaturePresent
+
 // NT Native APIs
 //sys   NtCreateFile(handle *syscall.Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, allocationSize *int64, attributes uint32, share uint32, disposition uint32, options uint32, eabuffer unsafe.Pointer, ealength uint32) (ntstatus error) = ntdll.NtCreateFile
 //sys   NtOpenFile(handle *syscall.Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, share uint32, options uint32) (ntstatus error) = ntdll.NtOpenFile

package/bin/go/src/internal/syscall/windows/types_windows.go

@@ -219,12 +219,12 @@ const (
 
 // https://learn.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-file_disposition_info
 type FILE_DISPOSITION_INFO struct {
-	DeleteFile bool
+	DeleteFile byte
 }
 
 // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/ns-ntddk-_file_disposition_information
 type FILE_DISPOSITION_INFORMATION struct {
-	DeleteFile bool
+	DeleteFile byte
 }
 
 // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/ns-ntddk-_file_disposition_information_ex
@@ -250,7 +250,7 @@ const (
 
 // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/ns-ntifs-_file_rename_information
 type FILE_RENAME_INFORMATION struct {
-	ReplaceIfExists bool
+	ReplaceIfExists byte
 	RootDirectory   syscall.Handle
 	FileNameLength  uint32
 	FileName        [syscall.MAX_PATH]uint16
@@ -266,7 +266,7 @@ type FILE_RENAME_INFORMATION_EX struct {
 
 // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ntifs/ns-ntifs-_file_link_information
 type FILE_LINK_INFORMATION struct {
-	ReplaceIfExists bool
+	ReplaceIfExists byte
 	RootDirectory   syscall.Handle
 	FileNameLength  uint32
 	FileName        [syscall.MAX_PATH]uint16
@@ -390,3 +390,88 @@ const (
 	PROCESS_TRUST_LABEL_SECURITY_INFORMATION = 0x00000080
 	BACKUP_SECURITY_INFORMATION              = 0x00010000
 )
+
+// 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_64BIT_LOADSTORE_ATOMIC              = 25
+	PF_ARM_DIVIDE_INSTRUCTION_AVAILABLE        = 24
+	PF_ARM_EXTERNAL_CACHE_AVAILABLE            = 26
+	PF_ARM_FMAC_INSTRUCTIONS_AVAILABLE         = 27
+	PF_ARM_VFP_32_REGISTERS_AVAILABLE          = 18
+	PF_3DNOW_INSTRUCTIONS_AVAILABLE            = 7
+	PF_CHANNELS_ENABLED                        = 16
+	PF_COMPARE_EXCHANGE_DOUBLE                 = 2
+	PF_COMPARE_EXCHANGE128                     = 14
+	PF_COMPARE64_EXCHANGE128                   = 15
+	PF_FASTFAIL_AVAILABLE                      = 23
+	PF_FLOATING_POINT_EMULATED                 = 1
+	PF_FLOATING_POINT_PRECISION_ERRATA         = 0
+	PF_MMX_INSTRUCTIONS_AVAILABLE              = 3
+	PF_NX_ENABLED                              = 12
+	PF_PAE_ENABLED                             = 9
+	PF_RDTSC_INSTRUCTION_AVAILABLE             = 8
+	PF_RDWRFSGSBASE_AVAILABLE                  = 22
+	PF_SECOND_LEVEL_ADDRESS_TRANSLATION        = 20
+	PF_SSE3_INSTRUCTIONS_AVAILABLE             = 13
+	PF_SSSE3_INSTRUCTIONS_AVAILABLE            = 36
+	PF_SSE4_1_INSTRUCTIONS_AVAILABLE           = 37
+	PF_SSE4_2_INSTRUCTIONS_AVAILABLE           = 38
+	PF_AVX_INSTRUCTIONS_AVAILABLE              = 39
+	PF_AVX2_INSTRUCTIONS_AVAILABLE             = 40
+	PF_AVX512F_INSTRUCTIONS_AVAILABLE          = 41
+	PF_VIRT_FIRMWARE_ENABLED                   = 21
+	PF_XMMI_INSTRUCTIONS_AVAILABLE             = 6
+	PF_XMMI64_INSTRUCTIONS_AVAILABLE           = 10
+	PF_XSAVE_ENABLED                           = 17
+	PF_ARM_V8_INSTRUCTIONS_AVAILABLE           = 29
+	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_SVE2_1_INSTRUCTIONS_AVAILABLE       = 48
+	PF_ARM_SVE_AES_INSTRUCTIONS_AVAILABLE      = 49
+	PF_ARM_SVE_PMULL128_INSTRUCTIONS_AVAILABLE = 50
+	PF_ARM_SVE_BITPERM_INSTRUCTIONS_AVAILABLE  = 51
+	PF_ARM_SVE_BF16_INSTRUCTIONS_AVAILABLE     = 52
+	PF_ARM_SVE_EBF16_INSTRUCTIONS_AVAILABLE    = 53
+	PF_ARM_SVE_B16B16_INSTRUCTIONS_AVAILABLE   = 54
+	PF_ARM_SVE_SHA3_INSTRUCTIONS_AVAILABLE     = 55
+	PF_ARM_SVE_SM4_INSTRUCTIONS_AVAILABLE      = 56
+	PF_ARM_SVE_I8MM_INSTRUCTIONS_AVAILABLE     = 57
+	PF_ARM_SVE_F32MM_INSTRUCTIONS_AVAILABLE    = 58
+	PF_ARM_SVE_F64MM_INSTRUCTIONS_AVAILABLE    = 59
+	PF_BMI2_INSTRUCTIONS_AVAILABLE             = 60
+	PF_MOVDIR64B_INSTRUCTION_AVAILABLE         = 61
+	PF_ARM_LSE2_AVAILABLE                      = 62
+	PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE         = 64
+	PF_ARM_SHA512_INSTRUCTIONS_AVAILABLE       = 65
+	PF_ARM_V82_I8MM_INSTRUCTIONS_AVAILABLE     = 66
+	PF_ARM_V82_FP16_INSTRUCTIONS_AVAILABLE     = 67
+	PF_ARM_V86_BF16_INSTRUCTIONS_AVAILABLE     = 68
+	PF_ARM_V86_EBF16_INSTRUCTIONS_AVAILABLE    = 69
+	PF_ARM_SME_INSTRUCTIONS_AVAILABLE          = 70
+	PF_ARM_SME2_INSTRUCTIONS_AVAILABLE         = 71
+	PF_ARM_SME2_1_INSTRUCTIONS_AVAILABLE       = 72
+	PF_ARM_SME2_2_INSTRUCTIONS_AVAILABLE       = 73
+	PF_ARM_SME_AES_INSTRUCTIONS_AVAILABLE      = 74
+	PF_ARM_SME_SBITPERM_INSTRUCTIONS_AVAILABLE = 75
+	PF_ARM_SME_SF8MM4_INSTRUCTIONS_AVAILABLE   = 76
+	PF_ARM_SME_SF8MM8_INSTRUCTIONS_AVAILABLE   = 77
+	PF_ARM_SME_SF8DP2_INSTRUCTIONS_AVAILABLE   = 78
+	PF_ARM_SME_SF8DP4_INSTRUCTIONS_AVAILABLE   = 79
+	PF_ARM_SME_SF8FMA_INSTRUCTIONS_AVAILABLE   = 80
+	PF_ARM_SME_F8F32_INSTRUCTIONS_AVAILABLE    = 81
+	PF_ARM_SME_F8F16_INSTRUCTIONS_AVAILABLE    = 82
+	PF_ARM_SME_F16F16_INSTRUCTIONS_AVAILABLE   = 83
+	PF_ARM_SME_B16B16_INSTRUCTIONS_AVAILABLE   = 84
+	PF_ARM_SME_F64F64_INSTRUCTIONS_AVAILABLE   = 85
+	PF_ARM_SME_I16I64_INSTRUCTIONS_AVAILABLE   = 86
+	PF_ARM_SME_LUTv2_INSTRUCTIONS_AVAILABLE    = 87
+	PF_ARM_SME_FA64_INSTRUCTIONS_AVAILABLE     = 88
+	PF_UMONITOR_INSTRUCTION_AVAILABLE          = 89
+)

package/bin/go/src/internal/syscall/windows/zsyscall_windows.go

@@ -83,6 +83,7 @@ var (
 	procGetTempPath2W                     = modkernel32.NewProc("GetTempPath2W")
 	procGetVolumeInformationByHandleW     = modkernel32.NewProc("GetVolumeInformationByHandleW")
 	procGetVolumeNameForVolumeMountPointW = modkernel32.NewProc("GetVolumeNameForVolumeMountPointW")
+	procIsProcessorFeaturePresent         = modkernel32.NewProc("IsProcessorFeaturePresent")
 	procLockFileEx                        = modkernel32.NewProc("LockFileEx")
 	procModule32FirstW                    = modkernel32.NewProc("Module32FirstW")
 	procModule32NextW                     = modkernel32.NewProc("Module32NextW")
@@ -427,6 +428,12 @@ func GetVolumeNameForVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint
 	return
 }
 
+func IsProcessorFeaturePresent(ProcessorFeature uint32) (ret bool) {
+	r0, _, _ := syscall.SyscallN(procIsProcessorFeaturePresent.Addr(), uintptr(ProcessorFeature))
+	ret = r0 != 0
+	return
+}
+
 func LockFileEx(file syscall.Handle, flags uint32, reserved uint32, bytesLow uint32, bytesHigh uint32, overlapped *syscall.Overlapped) (err error) {
 	r1, _, e1 := syscall.SyscallN(procLockFileEx.Addr(), uintptr(file), uintptr(flags), uintptr(reserved), uintptr(bytesLow), uintptr(bytesHigh), uintptr(unsafe.Pointer(overlapped)))
 	if r1 == 0 {