@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/internal/abi/type.go

@@ -5,6 +5,7 @@
 package abi
 
 import (
+	"internal/goarch"
 	"unsafe"
 )
 
@@ -412,6 +413,22 @@ func (t *Type) MapType() *MapType {
 	return (*MapType)(unsafe.Pointer(t))
 }
 
+// PointerType returns t cast to a *PtrType, or nil if its tag does not match.
+func (t *Type) PointerType() *PtrType {
+	if t.Kind() != Pointer {
+		return nil
+	}
+	return (*PtrType)(unsafe.Pointer(t))
+}
+
+// SliceType returns t cast to a *SliceType, or nil if its tag does not match.
+func (t *Type) SliceType() *SliceType {
+	if t.Kind() != Slice {
+		return nil
+	}
+	return (*SliceType)(unsafe.Pointer(t))
+}
+
 // ArrayType returns t cast to a *ArrayType, or nil if its tag does not match.
 func (t *Type) ArrayType() *ArrayType {
 	if t.Kind() != Array {
@@ -420,6 +437,14 @@ func (t *Type) ArrayType() *ArrayType {
 	return (*ArrayType)(unsafe.Pointer(t))
 }
 
+// ChanType returns t cast to a *ChanType, or nil if its tag does not match.
+func (t *Type) ChanType() *ChanType {
+	if t.Kind() != Chan {
+		return nil
+	}
+	return (*ChanType)(unsafe.Pointer(t))
+}
+
 // FuncType returns t cast to a *FuncType, or nil if its tag does not match.
 func (t *Type) FuncType() *FuncType {
 	if t.Kind() != Func {
@@ -712,6 +737,105 @@ func NewName(n, tag string, exported, embedded bool) Name {
 	return Name{Bytes: &b[0]}
 }
 
+// DescriptorSize returns the contiguous size taken in memory by the
+// type descriptor. This is the size of the Type struct,
+// plus other fields used by some type kinds, plus the UncommonType
+// struct if present, plus other optional information.
+// This is just the size of the bytes that appear contiguously in memory.
+// It does not include the size of things like type strings
+// and field names that appear elsewhere.
+//
+// This code must match the data structures build by
+// cmd/compile/internal/reflectdata/reflect.go:writeType.
+func (t *Type) DescriptorSize() int {
+	var baseSize, addSize int
+	switch t.Kind_ {
+	case Array:
+		baseSize, addSize = t.ArrayType().descriptorSizes()
+	case Chan:
+		baseSize, addSize = t.ChanType().descriptorSizes()
+	case Func:
+		baseSize, addSize = t.FuncType().descriptorSizes()
+	case Interface:
+		baseSize, addSize = t.InterfaceType().descriptorSizes()
+	case Map:
+		baseSize, addSize = t.MapType().descriptorSizes()
+	case Pointer:
+		baseSize, addSize = t.PointerType().descriptorSizes()
+	case Slice:
+		baseSize, addSize = t.SliceType().descriptorSizes()
+	case Struct:
+		baseSize, addSize = t.StructType().descriptorSizes()
+	case Bool,
+		Int, Int8, Int16, Int32, Int64,
+		Uint, Uint8, Uint16, Uint32, Uint64, Uintptr,
+		Float32, Float64, Complex64, Complex128,
+		String, UnsafePointer:
+
+		baseSize = int(unsafe.Sizeof(*t))
+		addSize = 0
+
+	default:
+		panic("DescriptorSize: invalid type descriptor")
+	}
+
+	// For clarity, we add the sizes together in the order
+	// they appear in memory.
+
+	ret := baseSize
+
+	mcount := 0
+	ut := t.Uncommon()
+	if ut != nil {
+		ret += int(unsafe.Sizeof(*ut))
+		mcount = int(ut.Mcount)
+	}
+
+	ret += addSize
+
+	ret += mcount * int(unsafe.Sizeof(Method{}))
+
+	return ret
+}
+
+func (at *ArrayType) descriptorSizes() (base, add int) {
+	return int(unsafe.Sizeof(*at)), 0
+}
+
+func (ct *ChanType) descriptorSizes() (base, add int) {
+	return int(unsafe.Sizeof(*ct)), 0
+}
+
+func (ft *FuncType) descriptorSizes() (base, add int) {
+	base = int(unsafe.Sizeof(*ft))
+	add = (ft.NumIn() + ft.NumOut()) * goarch.PtrSize
+	return base, add
+}
+
+func (it *InterfaceType) descriptorSizes() (base, add int) {
+	base = int(unsafe.Sizeof(*it))
+	add = len(it.Methods) * int(unsafe.Sizeof(Imethod{}))
+	return base, add
+}
+
+func (mt *MapType) descriptorSizes() (base, add int) {
+	return int(unsafe.Sizeof(*mt)), 0
+}
+
+func (pt *PtrType) descriptorSizes() (base, add int) {
+	return int(unsafe.Sizeof(*pt)), 0
+}
+
+func (st *SliceType) descriptorSizes() (base, add int) {
+	return int(unsafe.Sizeof(*st)), 0
+}
+
+func (st *StructType) descriptorSizes() (base, add int) {
+	base = int(unsafe.Sizeof(*st))
+	add = len(st.Fields) * int(unsafe.Sizeof(StructField{}))
+	return base, add
+}
+
 const (
 	TraceArgsLimit    = 10 // print no more than 10 args/components
 	TraceArgsMaxDepth = 5  // no more than 5 layers of nesting
@@ -747,31 +871,16 @@ const (
 
 // MaxPtrmaskBytes is the maximum length of a GC ptrmask bitmap,
 // which holds 1-bit entries describing where pointers are in a given type.
-// Above this length, the GC information is recorded as a GC program,
-// which can express repetition compactly. In either form, the
-// information is used by the runtime to initialize the heap bitmap,
-// and for large types (like 128 or more words), they are roughly the
-// same speed. GC programs are never much larger and often more
-// compact. (If large arrays are involved, they can be arbitrarily
-// more compact.)
-//
-// The cutoff must be large enough that any allocation large enough to
-// use a GC program is large enough that it does not share heap bitmap
-// bytes with any other objects, allowing the GC program execution to
-// assume an aligned start and not use atomic operations. In the current
-// runtime, this means all malloc size classes larger than the cutoff must
-// be multiples of four words. On 32-bit systems that's 16 bytes, and
-// all size classes >= 16 bytes are 16-byte aligned, so no real constraint.
-// On 64-bit systems, that's 32 bytes, and 32-byte alignment is guaranteed
-// for size classes >= 256 bytes. On a 64-bit system, 256 bytes allocated
-// is 32 pointers, the bits for which fit in 4 bytes. So MaxPtrmaskBytes
-// must be >= 4.
-//
-// We used to use 16 because the GC programs do have some constant overhead
-// to get started, and processing 128 pointers seems to be enough to
-// amortize that overhead well.
+// Above this length, the runtime computes the GC ptrmask bitmap as needed.
+// The information is used by the runtime to initialize the heap bitmap.
 //
-// To make sure that the runtime's chansend can call typeBitsBulkBarrier,
-// we raised the limit to 2048, so that even 32-bit systems are guaranteed to
-// use bitmaps for objects up to 64 kB in size.
-const MaxPtrmaskBytes = 2048
+// There is a bit of overhead to computing the GC ptrmask bitmap
+// the first time. On the other hand building GC ptrmask bitmaps
+// for all types at compile time takes space in the binary for
+// large types that have a lot of pointers, such as large array types.
+// Using 16 means that types that keep their pointers in the first
+// 512 (on 32-bit) or 1024 (on 64-bit) bytes are computed at compile time,
+// and types with more pointers are computed at run time.
+// This tradeoff sounds reasonable, and 16 was the cutoff back when
+// we used GC programs, but this has not been benchmarked.
+const MaxPtrmaskBytes = 16

package/bin/go/src/internal/buildcfg/exp.go

@@ -62,11 +62,9 @@ func ParseGOEXPERIMENT(goos, goarch, goexp string) (*ExperimentFlags, error) {
 	// always on.
 	var regabiSupported, regabiAlwaysOn bool
 	switch goarch {
-	case "amd64", "arm64", "loong64", "ppc64le", "ppc64", "riscv64":
+	case "amd64", "arm64", "loong64", "ppc64le", "ppc64", "riscv64", "s390x":
 		regabiAlwaysOn = true
 		regabiSupported = true
-	case "s390x":
-		regabiSupported = true
 	}
 
 	// Older versions (anything before V16) of dsymutil don't handle
@@ -81,11 +79,13 @@ func ParseGOEXPERIMENT(goos, goarch, goexp string) (*ExperimentFlags, error) {
 	dwarf5Supported := (goos != "darwin" && goos != "ios" && goos != "aix")
 
 	baseline := goexperiment.Flags{
-		RegabiWrappers:       regabiSupported,
-		RegabiArgs:           regabiSupported,
-		Dwarf5:               dwarf5Supported,
-		RandomizedHeapBase64: true,
-		GreenTeaGC:           true,
+		RegabiWrappers:        regabiSupported,
+		RegabiArgs:            regabiSupported,
+		Dwarf5:                dwarf5Supported,
+		RandomizedHeapBase64:  true,
+		GreenTeaGC:            true,
+		JSONv2:                true,
+		SizeSpecializedMalloc: true,
 	}
 	flags := &ExperimentFlags{
 		Flags:    baseline,

package/bin/go/src/internal/buildcfg/zbootstrap.go

@@ -15,7 +15,7 @@ const DefaultGORISCV64 = `rva20u64`
 const defaultGOEXPERIMENT = ``
 const defaultGO_EXTLINK_ENABLED = ``
 const defaultGO_LDSO = ``
-const version = `go1.26.9`
+const version = `go1.27.3`
 const defaultGOOS = runtime.GOOS
 const defaultGOARCH = runtime.GOARCH
 const DefaultGOFIPS140 = `off`

package/bin/go/src/internal/bytealg/bytealg.go

@@ -29,17 +29,17 @@ const (
 // If MaxLen is not 0, make sure MaxLen >= 4.
 var MaxLen int
 
-// PrimeRK is the prime base used in Rabin-Karp algorithm.
-const PrimeRK = 16777619
+// primeRK is the prime base used in Rabin-Karp algorithm.
+const primeRK = 16777619
 
-// HashStr returns the hash and the appropriate multiplicative
+// hashStr returns the hash and the appropriate multiplicative
 // factor for use in Rabin-Karp algorithm.
-func HashStr[T string | []byte](sep T) (uint32, uint32) {
+func hashStr[T string | []byte](sep T) (uint32, uint32) {
 	hash := uint32(0)
 	for i := 0; i < len(sep); i++ {
-		hash = hash*PrimeRK + uint32(sep[i])
+		hash = hash*primeRK + uint32(sep[i])
 	}
-	var pow, sq uint32 = 1, PrimeRK
+	var pow, sq uint32 = 1, primeRK
 	for i := len(sep); i > 0; i >>= 1 {
 		if i&1 != 0 {
 			pow *= sq
@@ -49,14 +49,14 @@ func HashStr[T string | []byte](sep T) (uint32, uint32) {
 	return hash, pow
 }
 
-// HashStrRev returns the hash of the reverse of sep and the
+// hashStrRev returns the hash of the reverse of sep and the
 // appropriate multiplicative factor for use in Rabin-Karp algorithm.
-func HashStrRev[T string | []byte](sep T) (uint32, uint32) {
+func hashStrRev[T string | []byte](sep T) (uint32, uint32) {
 	hash := uint32(0)
 	for i := len(sep) - 1; i >= 0; i-- {
-		hash = hash*PrimeRK + uint32(sep[i])
+		hash = hash*primeRK + uint32(sep[i])
 	}
-	var pow, sq uint32 = 1, PrimeRK
+	var pow, sq uint32 = 1, primeRK
 	for i := len(sep); i > 0; i >>= 1 {
 		if i&1 != 0 {
 			pow *= sq
@@ -70,17 +70,17 @@ func HashStrRev[T string | []byte](sep T) (uint32, uint32) {
 // first occurrence of sep in s, or -1 if not present.
 func IndexRabinKarp[T string | []byte](s, sep T) int {
 	// Rabin-Karp search
-	hashss, pow := HashStr(sep)
+	hashss, pow := hashStr(sep)
 	n := len(sep)
 	var h uint32
 	for i := 0; i < n; i++ {
-		h = h*PrimeRK + uint32(s[i])
+		h = h*primeRK + uint32(s[i])
 	}
 	if h == hashss && string(s[:n]) == string(sep) {
 		return 0
 	}
 	for i := n; i < len(s); {
-		h *= PrimeRK
+		h *= primeRK
 		h += uint32(s[i])
 		h -= pow * uint32(s[i-n])
 		i++
@@ -95,18 +95,18 @@ func IndexRabinKarp[T string | []byte](s, sep T) int {
 // occurrence of sep in s, or -1 if not present.
 func LastIndexRabinKarp[T string | []byte](s, sep T) int {
 	// Rabin-Karp search from the end of the string
-	hashss, pow := HashStrRev(sep)
+	hashss, pow := hashStrRev(sep)
 	n := len(sep)
 	last := len(s) - n
 	var h uint32
 	for i := len(s) - 1; i >= last; i-- {
-		h = h*PrimeRK + uint32(s[i])
+		h = h*primeRK + uint32(s[i])
 	}
 	if h == hashss && string(s[last:]) == string(sep) {
 		return last
 	}
 	for i := last - 1; i >= 0; i-- {
-		h *= PrimeRK
+		h *= primeRK
 		h += uint32(s[i])
 		h -= pow * uint32(s[i+n])
 		if h == hashss && string(s[i:i+n]) == string(sep) {

package/bin/go/src/internal/bytealg/compare_s390x.s

@@ -6,13 +6,6 @@
 #include "textflag.h"
 
 TEXT ·Compare<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-56
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	a_base+0(FP), R2
-	MOVD	a_len+8(FP), R3
-	MOVD	b_base+24(FP), R4
-	MOVD	b_len+32(FP), R5
-	LA	ret+48(FP), R6
-#else
 	// R2 = a_base
 	// R3 = a_len
 	// R4 = a_cap (unused)
@@ -21,17 +14,9 @@ TEXT ·Compare<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-56
 	// R7 = b_cap (unused)
 	MOVD	R5, R4
 	MOVD	R6, R5
-#endif
 	BR	cmpbody<>(SB)
 
 TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-40
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	a_base+0(FP), R2
-	MOVD	a_len+8(FP), R3
-	MOVD	b_base+16(FP), R4
-	MOVD	b_len+24(FP), R5
-	LA	ret+32(FP), R6
-#endif
 	// R2 = a_base
 	// R3 = a_len
 	// R4 = b_base
@@ -75,21 +60,12 @@ cmplengths:
 	BLT	lt
 gt:
 	MOVD	$1, R2
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	R2, 0(R6)
-#endif
 	RET
 lt:
 	MOVD	$-1, R2
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	R2, 0(R6)
-#endif
 	RET
 eq:
 	MOVD	$0, R2
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	R2, 0(R6)
-#endif
 	RET
 
 TEXT cmpbodyclc<>(SB),NOSPLIT|NOFRAME,$0-0

package/bin/go/src/internal/bytealg/equal_s390x.s

@@ -7,22 +7,10 @@
 
 // memequal(a, b unsafe.Pointer, size uintptr) bool
 TEXT runtime·memequal<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-25
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	a+0(FP), R2
-	MOVD	b+8(FP), R3
-	MOVD	size+16(FP), R4
-	LA	ret+24(FP), R5
-#endif
 	BR	memeqbody<>(SB)
 
 // memequal_varlen(a, b unsafe.Pointer) bool
 TEXT runtime·memequal_varlen<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-17
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	a+0(FP), R2
-	MOVD	b+8(FP), R3
-	LA	ret+16(FP), R5
-#endif
-
 	MOVD	8(R12), R4    // compiler stores size at offset 8 in the closure
 	BR	memeqbody<>(SB)
 
@@ -52,15 +40,9 @@ tail:
 	BEQ	equal
 notequal:
 	MOVD	$0, R2
-#ifndef GOEXPERIMENT_regabiargs
-	MOVB	R2, 0(R5)
-#endif
 	RET
 equal:
 	MOVD	$1, R2
-#ifndef GOEXPERIMENT_regabiargs
-	MOVB	R2, 0(R5)
-#endif
 	RET
 tiny:
 	MOVD	$0, R1

package/bin/go/src/internal/bytealg/indexbyte_arm64.s

@@ -34,6 +34,10 @@ TEXT ·IndexByteString<ABIInternal>(SB),NOSPLIT,$0-32
 	// identify exactly which byte has matched.
 
 	CBZ	R1, fail
+#ifdef GOOS_android
+	ADD	R0, R1, R20   // R20 = end of data
+	BIC	$0xf, R0, R21 // R21 = earliest we can read
+#endif
 	MOVD	R0, R11
 	// Magic constant 0x40100401 allows us to identify
 	// which lane matches the requested byte.
@@ -51,7 +55,20 @@ TEXT ·IndexByteString<ABIInternal>(SB),NOSPLIT,$0-32
 	// Input string is not 32-byte aligned. We calculate the
 	// syndrome value for the aligned 32 bytes block containing
 	// the first bytes and mask off the irrelevant part.
+#ifdef GOOS_android
+	// Android requires us to not read outside an aligned 16-byte
+	// region because MTE might be enforced.
+	CMP	R21, R3
+	BLO	2(PC)
+	VLD1	(R3), [V1.B16]
+	ADD	$0x10, R3
+	CMP	R3, R20
+	BLS	2(PC)
+	VLD1	(R3), [V2.B16]
+	ADD	$0x10, R3
+#else
 	VLD1.P	(R3), [V1.B16, V2.B16]
+#endif
 	SUB	$0x20, R9, R4
 	ADDS	R4, R1, R1
 	VCMEQ	V0.B16, V1.B16, V3.B16
@@ -71,7 +88,18 @@ TEXT ·IndexByteString<ABIInternal>(SB),NOSPLIT,$0-32
 	CBNZ	R6, tail
 
 loop:
+#ifdef GOOS_android
+	CMP	R21, R3
+	BLO	2(PC)
+	VLD1	(R3), [V1.B16]
+	ADD	$0x10, R3
+	CMP	R3, R20
+	BLS	2(PC)
+	VLD1	(R3), [V2.B16]
+	ADD	$0x10, R3
+#else
 	VLD1.P	(R3), [V1.B16, V2.B16]
+#endif
 	SUBS	$0x20, R1, R1
 	VCMEQ	V0.B16, V1.B16, V3.B16
 	VCMEQ	V0.B16, V2.B16, V4.B16

package/bin/go/src/internal/bytealg/indexbyte_s390x.s

@@ -7,26 +7,12 @@
 
 
 TEXT ·IndexByte<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-40
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD    b_base+0(FP), R2// b_base => R2
-	MOVD    b_len+8(FP), R3 // b_len => R3
-	MOVBZ   c+24(FP), R4    // c => R4
-	MOVD    $ret+32(FP), R5 // &ret => R5
-#else
 	MOVD    R5, R4
 	AND	$0xff, R4
-#endif
 	BR      indexbytebody<>(SB)
 
 TEXT ·IndexByteString<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-32
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD    s_base+0(FP), R2 // s_base => R2
-	MOVD    s_len+8(FP), R3 // s_len => R3
-	MOVBZ   c+16(FP), R4    // c => R4
-	MOVD    $ret+24(FP), R5 // &ret => R5
-#else
 	AND	$0xff, R4
-#endif
 	BR      indexbytebody<>(SB)
 
 // input:
@@ -51,17 +37,10 @@ residual:
 found:
         SUB     R6, R2
         SUB     $1, R2
-#ifndef GOEXPERIMENT_regabiargs
-        MOVD    R2, 0(R5)
-#endif
         RET
 
 notfound:
-#ifndef GOEXPERIMENT_regabiargs
-        MOVD    $-1, 0(R5)
-#else
         MOVD    $-1, R2
-#endif
         RET
 
 large:
@@ -77,19 +56,11 @@ srstloop:
 foundr0:
         XOR     R0, R0          // reset R0
         SUB     R6, R8          // remove base
-#ifndef GOEXPERIMENT_regabiargs
-        MOVD    R8, 0(R5)
-#else
         MOVD    R8, R2
-#endif
         RET
 notfoundr0:
         XOR     R0, R0          // reset R0
-#ifndef GOEXPERIMENT_regabiargs
-        MOVD    $-1, 0(R5)
-#else
         MOVD    $-1, R2
-#endif
         RET
 
 vectorimpl:
@@ -118,11 +89,7 @@ vectorloop:
         SUB     $16, R2
         SUB     R6, R2
         ADD     R2, R7
-#ifndef GOEXPERIMENT_regabiargs
-        MOVD    R7, 0(R5)
-#else
         MOVD    R7, R2
-#endif
         RET
 
 notaligned:

package/bin/go/src/internal/coverage/encodemeta/encode.go

@@ -110,7 +110,7 @@ func (b *CoverageMetaDataBuilder) emitFunc(w io.WriteSeeker, off int64, f funcDe
 }
 
 func (b *CoverageMetaDataBuilder) reportWriteError(err error) {
-	if b.werr != nil {
+	if b.werr == nil {
 		b.werr = err
 	}
 }

package/bin/go/src/internal/cpu/cpu.go

@@ -57,6 +57,7 @@ var X86 struct {
 	HasSSE41            bool
 	HasSSE42            bool
 	HasVAES             bool
+	HasVPCLMULQDQ       bool
 	_                   CacheLinePad
 }
 
@@ -84,6 +85,7 @@ var ARM64 struct {
 	HasATOMICS bool
 	HasCPUID   bool
 	HasDIT     bool
+	HasSB      bool
 	IsNeoverse bool
 	_          CacheLinePad
 }
@@ -91,13 +93,16 @@ var ARM64 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
-	HasLAMCAS bool // support AMCAS[_DB].{B/H/W/D}
-	HasLAM_BH bool // support AM{SWAP/ADD}[_DB].{B/H} 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
 }
 
 var MIPS64X struct {
@@ -156,6 +161,16 @@ var RISCV64 struct {
 	HasFastMisaligned bool // Fast misaligned accesses
 	HasV              bool // Vector extension compatible with RVV 1.0
 	HasZbb            bool // Basic bit-manipulation extension
+	HasZbc            bool // Carryless multiplication extension
+	HasZvbb           bool // Vector Basic Bit-manipulation
+	HasZvbc           bool // Vector Carryless Multiplication
+	HasZvkg           bool // Vector GCM/GMAC
+	HasZvkned         bool // NIST Suite: Vector AES Block Cipher
+	HasZvknha         bool // NIST Suite: Vector SHA-2 Secure Hash
+	HasZvknhb         bool // NIST Suite: Vector SHA-2 Secure Hash
+	HasZvksed         bool // ShangMi Suite: SM4 Block Cipher
+	HasZvksh          bool // ShangMi Suite: SM3 Secure Hash
+	HasZvkt           bool // Vector Data-Independent Execution Latency
 	_                 CacheLinePad
 }
 

package/bin/go/src/internal/cpu/cpu_arm64.go

@@ -29,6 +29,8 @@ func doinit() {
 
 func getisar0() uint64
 
+func getisar1() uint64
+
 func getpfr0() uint64
 
 func getMIDR() uint64
@@ -37,7 +39,7 @@ func extractBits(data uint64, start, end uint) uint {
 	return (uint)(data>>start) & ((1 << (end - start + 1)) - 1)
 }
 
-func parseARM64SystemRegisters(isar0, pfr0 uint64) {
+func parseARM64SystemRegisters(isar0, isa1, pfr0 uint64) {
 	// ID_AA64ISAR0_EL1
 	// https://developer.arm.com/documentation/ddi0601/2025-03/AArch64-Registers/ID-AA64ISAR0-EL1--AArch64-Instruction-Set-Attribute-Register-0
 	switch extractBits(isar0, 4, 7) {
@@ -76,6 +78,11 @@ func parseARM64SystemRegisters(isar0, pfr0 uint64) {
 		ARM64.HasSHA3 = true
 	}
 
+	switch extractBits(isa1, 36, 39) {
+	case 1:
+		ARM64.HasSB = true
+	}
+
 	switch extractBits(pfr0, 48, 51) {
 	case 1:
 		ARM64.HasDIT = true

package/bin/go/src/internal/cpu/cpu_arm64.s

@@ -11,6 +11,13 @@ TEXT ·getisar0(SB),NOSPLIT,$0
 	MOVD	R0, ret+0(FP)
 	RET
 
+// func getisar1() uint64
+TEXT ·getisar1(SB),NOSPLIT,$0-8
+	// get Instruction Set Attributes 1 into R0
+	MRS	ID_AA64ISAR1_EL1, R0
+	MOVD	R0, ret+0(FP)
+	RET
+
 // func getpfr0() uint64
 TEXT ·getpfr0(SB),NOSPLIT,$0-8
 	// get Processor Feature Register 0 into R0

package/bin/go/src/internal/cpu/cpu_arm64_darwin.go

@@ -18,6 +18,8 @@ func osInit() {
 
 	ARM64.HasDIT = sysctlEnabled([]byte("hw.optional.arm.FEAT_DIT\x00"))
 
+	ARM64.HasSB = sysctlEnabled([]byte("hw.optional.arm.FEAT_SB\x00"))
+
 	// There are no hw.optional sysctl values for the below features on macOS 11
 	// to detect their supported state dynamically (although they are available
 	// in the hw.optional.arm tree on macOS 12). Assume the CPU features that

package/bin/go/src/internal/cpu/cpu_arm64_freebsd.go

@@ -9,7 +9,8 @@ package cpu
 func osInit() {
 	// Retrieve info from system register ID_AA64ISAR0_EL1.
 	isar0 := getisar0()
+	isar1 := getisar1()
 	prf0 := getpfr0()
 
-	parseARM64SystemRegisters(isar0, prf0)
+	parseARM64SystemRegisters(isar0, isar1, prf0)
 }

package/bin/go/src/internal/cpu/cpu_arm64_hwcap.go

@@ -34,6 +34,7 @@ const (
 	hwcap_SHA3    = 1 << 17
 	hwcap_SHA512  = 1 << 21
 	hwcap_DIT     = 1 << 24
+	hwcap_SB      = 1 << 29
 )
 
 func hwcapInit(os string) {
@@ -50,6 +51,7 @@ func hwcapInit(os string) {
 	ARM64.HasCPUID = isSet(HWCap, hwcap_CPUID)
 	ARM64.HasSHA512 = isSet(HWCap, hwcap_SHA512)
 	ARM64.HasDIT = isSet(HWCap, hwcap_DIT)
+	ARM64.HasSB = isSet(HWCap, hwcap_SB)
 
 	// The Samsung S9+ kernel reports support for atomics, but not all cores
 	// actually support them, resulting in SIGILL. See issue #28431.