@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/strconv/isprint.go

@@ -6,7 +6,7 @@
 
 package strconv
 
-// (424+133+112)*2 + (508)*4 = 3370 bytes
+// (412+132+120)*2 + (566)*4 = 3592 bytes
 
 var isPrint16 = []uint16{
 	0x0020, 0x007e,
@@ -24,8 +24,8 @@ var isPrint16 = []uint16{
 	0x07fd, 0x082d,
 	0x0830, 0x085b,
 	0x085e, 0x086a,
-	0x0870, 0x088e,
-	0x0898, 0x098c,
+	0x0870, 0x088f,
+	0x0897, 0x098c,
 	0x098f, 0x0990,
 	0x0993, 0x09b2,
 	0x09b6, 0x09b9,
@@ -71,14 +71,13 @@ var isPrint16 = []uint16{
 	0x0be6, 0x0bfa,
 	0x0c00, 0x0c39,
 	0x0c3c, 0x0c4d,
-	0x0c55, 0x0c5a,
-	0x0c5d, 0x0c5d,
+	0x0c55, 0x0c5d,
 	0x0c60, 0x0c63,
 	0x0c66, 0x0c6f,
 	0x0c77, 0x0cb9,
 	0x0cbc, 0x0ccd,
 	0x0cd5, 0x0cd6,
-	0x0cdd, 0x0ce3,
+	0x0cdc, 0x0ce3,
 	0x0ce6, 0x0cf3,
 	0x0d00, 0x0d4f,
 	0x0d54, 0x0d63,
@@ -135,12 +134,12 @@ var isPrint16 = []uint16{
 	0x1a7f, 0x1a89,
 	0x1a90, 0x1a99,
 	0x1aa0, 0x1aad,
-	0x1ab0, 0x1ace,
-	0x1b00, 0x1b4c,
-	0x1b50, 0x1bf3,
+	0x1ab0, 0x1add,
+	0x1ae0, 0x1aeb,
+	0x1b00, 0x1bf3,
 	0x1bfc, 0x1c37,
 	0x1c3b, 0x1c49,
-	0x1c4d, 0x1c88,
+	0x1c4d, 0x1c8a,
 	0x1c90, 0x1cba,
 	0x1cbd, 0x1cc7,
 	0x1cd0, 0x1cfa,
@@ -156,10 +155,10 @@ var isPrint16 = []uint16{
 	0x2030, 0x205e,
 	0x2070, 0x2071,
 	0x2074, 0x209c,
-	0x20a0, 0x20c0,
+	0x20a0, 0x20c1,
 	0x20d0, 0x20f0,
 	0x2100, 0x218b,
-	0x2190, 0x2426,
+	0x2190, 0x2429,
 	0x2440, 0x244a,
 	0x2460, 0x2b73,
 	0x2b76, 0x2cf3,
@@ -171,17 +170,15 @@ var isPrint16 = []uint16{
 	0x2da0, 0x2e5d,
 	0x2e80, 0x2ef3,
 	0x2f00, 0x2fd5,
-	0x2ff0, 0x2ffb,
-	0x3001, 0x3096,
+	0x2ff0, 0x3096,
 	0x3099, 0x30ff,
-	0x3105, 0x31e3,
-	0x31f0, 0xa48c,
+	0x3105, 0x31e5,
+	0x31ef, 0xa48c,
 	0xa490, 0xa4c6,
 	0xa4d0, 0xa62b,
 	0xa640, 0xa6f7,
-	0xa700, 0xa7ca,
-	0xa7d0, 0xa7d9,
-	0xa7f2, 0xa82c,
+	0xa700, 0xa7dc,
+	0xa7f1, 0xa82c,
 	0xa830, 0xa839,
 	0xa840, 0xa877,
 	0xa880, 0xa8c5,
@@ -207,10 +204,7 @@ var isPrint16 = []uint16{
 	0xfa70, 0xfad9,
 	0xfb00, 0xfb06,
 	0xfb13, 0xfb17,
-	0xfb1d, 0xfbc2,
-	0xfbd3, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdcf, 0xfdcf,
+	0xfb1d, 0xfdcf,
 	0xfdf0, 0xfe19,
 	0xfe20, 0xfe6b,
 	0xfe70, 0xfefc,
@@ -271,6 +265,7 @@ var isNotPrint16 = []uint16{
 	0x0c45,
 	0x0c49,
 	0x0c57,
+	0x0c5b,
 	0x0c8d,
 	0x0c91,
 	0x0ca9,
@@ -317,7 +312,7 @@ var isNotPrint16 = []uint16{
 	0x180e,
 	0x191f,
 	0x1a5f,
-	0x1b7f,
+	0x1b4d,
 	0x1f58,
 	0x1f5a,
 	0x1f5c,
@@ -327,7 +322,6 @@ var isNotPrint16 = []uint16{
 	0x1fdc,
 	0x1ff5,
 	0x208f,
-	0x2b96,
 	0x2d26,
 	0x2da7,
 	0x2daf,
@@ -338,12 +332,11 @@ var isNotPrint16 = []uint16{
 	0x2dd7,
 	0x2ddf,
 	0x2e9a,
+	0x3000,
 	0x3040,
 	0x3130,
 	0x318f,
 	0x321f,
-	0xa7d2,
-	0xa7d4,
 	0xa9ce,
 	0xa9ff,
 	0xab27,
@@ -383,6 +376,7 @@ var isPrint32 = []uint32{
 	0x010500, 0x010527,
 	0x010530, 0x010563,
 	0x01056f, 0x0105bc,
+	0x0105c0, 0x0105f3,
 	0x010600, 0x010736,
 	0x010740, 0x010755,
 	0x010760, 0x010767,
@@ -395,7 +389,7 @@ var isPrint32 = []uint32{
 	0x0108e0, 0x0108f5,
 	0x0108fb, 0x01091b,
 	0x01091f, 0x010939,
-	0x01093f, 0x01093f,
+	0x01093f, 0x010959,
 	0x010980, 0x0109b7,
 	0x0109bc, 0x0109cf,
 	0x0109d2, 0x010a06,
@@ -417,9 +411,14 @@ var isPrint32 = []uint32{
 	0x010cc0, 0x010cf2,
 	0x010cfa, 0x010d27,
 	0x010d30, 0x010d39,
+	0x010d40, 0x010d65,
+	0x010d69, 0x010d85,
+	0x010d8e, 0x010d8f,
 	0x010e60, 0x010ead,
 	0x010eb0, 0x010eb1,
-	0x010efd, 0x010f27,
+	0x010ec2, 0x010ec7,
+	0x010ed0, 0x010ed8,
+	0x010efa, 0x010f27,
 	0x010f30, 0x010f59,
 	0x010f70, 0x010f89,
 	0x010fb0, 0x010fcb,
@@ -446,6 +445,10 @@ var isPrint32 = []uint32{
 	0x01135d, 0x011363,
 	0x011366, 0x01136c,
 	0x011370, 0x011374,
+	0x011380, 0x01138b,
+	0x01138e, 0x0113c2,
+	0x0113c5, 0x0113d8,
+	0x0113e1, 0x0113e2,
 	0x011400, 0x011461,
 	0x011480, 0x0114c7,
 	0x0114d0, 0x0114d9,
@@ -456,6 +459,7 @@ var isPrint32 = []uint32{
 	0x011660, 0x01166c,
 	0x011680, 0x0116b9,
 	0x0116c0, 0x0116c9,
+	0x0116d0, 0x0116e3,
 	0x011700, 0x01171a,
 	0x01171d, 0x01172b,
 	0x011730, 0x011746,
@@ -473,6 +477,9 @@ var isPrint32 = []uint32{
 	0x011a50, 0x011aa2,
 	0x011ab0, 0x011af8,
 	0x011b00, 0x011b09,
+	0x011b60, 0x011b67,
+	0x011bc0, 0x011be1,
+	0x011bf0, 0x011bf9,
 	0x011c00, 0x011c45,
 	0x011c50, 0x011c6c,
 	0x011c70, 0x011c8f,
@@ -482,9 +489,11 @@ var isPrint32 = []uint32{
 	0x011d50, 0x011d59,
 	0x011d60, 0x011d98,
 	0x011da0, 0x011da9,
+	0x011db0, 0x011ddb,
+	0x011de0, 0x011de9,
 	0x011ee0, 0x011ef8,
 	0x011f00, 0x011f3a,
-	0x011f3e, 0x011f59,
+	0x011f3e, 0x011f5a,
 	0x011fb0, 0x011fb0,
 	0x011fc0, 0x011ff1,
 	0x011fff, 0x012399,
@@ -493,7 +502,9 @@ var isPrint32 = []uint32{
 	0x012f90, 0x012ff2,
 	0x013000, 0x01342f,
 	0x013440, 0x013455,
+	0x013460, 0x0143fa,
 	0x014400, 0x014646,
+	0x016100, 0x016139,
 	0x016800, 0x016a38,
 	0x016a40, 0x016a69,
 	0x016a6e, 0x016ac9,
@@ -502,15 +513,18 @@ var isPrint32 = []uint32{
 	0x016b00, 0x016b45,
 	0x016b50, 0x016b77,
 	0x016b7d, 0x016b8f,
+	0x016d40, 0x016d79,
 	0x016e40, 0x016e9a,
+	0x016ea0, 0x016eb8,
+	0x016ebb, 0x016ed3,
 	0x016f00, 0x016f4a,
 	0x016f4f, 0x016f87,
 	0x016f8f, 0x016f9f,
 	0x016fe0, 0x016fe4,
-	0x016ff0, 0x016ff1,
-	0x017000, 0x0187f7,
-	0x018800, 0x018cd5,
-	0x018d00, 0x018d08,
+	0x016ff0, 0x016ff6,
+	0x017000, 0x018cd5,
+	0x018cff, 0x018d1e,
+	0x018d80, 0x018df2,
 	0x01aff0, 0x01b122,
 	0x01b132, 0x01b132,
 	0x01b150, 0x01b152,
@@ -522,6 +536,10 @@ var isPrint32 = []uint32{
 	0x01bc80, 0x01bc88,
 	0x01bc90, 0x01bc99,
 	0x01bc9c, 0x01bc9f,
+	0x01cc00, 0x01ccfc,
+	0x01cd00, 0x01ceb3,
+	0x01ceba, 0x01ced0,
+	0x01cee0, 0x01cef0,
 	0x01cf00, 0x01cf2d,
 	0x01cf30, 0x01cf46,
 	0x01cf50, 0x01cfc3,
@@ -557,6 +575,10 @@ var isPrint32 = []uint32{
 	0x01e2c0, 0x01e2f9,
 	0x01e2ff, 0x01e2ff,
 	0x01e4d0, 0x01e4f9,
+	0x01e5d0, 0x01e5fa,
+	0x01e5ff, 0x01e5ff,
+	0x01e6c0, 0x01e6f5,
+	0x01e6fe, 0x01e6ff,
 	0x01e7e0, 0x01e8c4,
 	0x01e8c7, 0x01e8d6,
 	0x01e900, 0x01e94b,
@@ -582,11 +604,10 @@ var isPrint32 = []uint32{
 	0x01f240, 0x01f248,
 	0x01f250, 0x01f251,
 	0x01f260, 0x01f265,
-	0x01f300, 0x01f6d7,
+	0x01f300, 0x01f6d8,
 	0x01f6dc, 0x01f6ec,
 	0x01f6f0, 0x01f6fc,
-	0x01f700, 0x01f776,
-	0x01f77b, 0x01f7d9,
+	0x01f700, 0x01f7d9,
 	0x01f7e0, 0x01f7eb,
 	0x01f7f0, 0x01f7f0,
 	0x01f800, 0x01f80b,
@@ -594,25 +615,26 @@ var isPrint32 = []uint32{
 	0x01f850, 0x01f859,
 	0x01f860, 0x01f887,
 	0x01f890, 0x01f8ad,
-	0x01f8b0, 0x01f8b1,
-	0x01f900, 0x01fa53,
+	0x01f8b0, 0x01f8bb,
+	0x01f8c0, 0x01f8c1,
+	0x01f8d0, 0x01f8d8,
+	0x01f900, 0x01fa57,
 	0x01fa60, 0x01fa6d,
 	0x01fa70, 0x01fa7c,
-	0x01fa80, 0x01fa88,
-	0x01fa90, 0x01fac5,
-	0x01face, 0x01fadb,
-	0x01fae0, 0x01fae8,
-	0x01faf0, 0x01faf8,
-	0x01fb00, 0x01fbca,
-	0x01fbf0, 0x01fbf9,
+	0x01fa80, 0x01fa8a,
+	0x01fa8e, 0x01fac8,
+	0x01facd, 0x01fadc,
+	0x01fadf, 0x01faea,
+	0x01faef, 0x01faf8,
+	0x01fb00, 0x01fbfa,
 	0x020000, 0x02a6df,
-	0x02a700, 0x02b739,
-	0x02b740, 0x02b81d,
-	0x02b820, 0x02cea1,
+	0x02a700, 0x02b81d,
+	0x02b820, 0x02cead,
 	0x02ceb0, 0x02ebe0,
+	0x02ebf0, 0x02ee5d,
 	0x02f800, 0x02fa1d,
 	0x030000, 0x03134a,
-	0x031350, 0x0323af,
+	0x031350, 0x033479,
 	0x0e0100, 0x0e01ef,
 }
 
@@ -654,6 +676,13 @@ var isNotPrint32 = []uint16{ // add 0x10000 to each entry
 	0x1331,
 	0x1334,
 	0x133a,
+	0x138a,
+	0x138f,
+	0x13b6,
+	0x13c1,
+	0x13c6,
+	0x13cb,
+	0x13d6,
 	0x145c,
 	0x1914,
 	0x1917,
@@ -695,6 +724,7 @@ var isNotPrint32 = []uint16{ // add 0x10000 to each entry
 	0xe007,
 	0xe022,
 	0xe025,
+	0xe6df,
 	0xe7e7,
 	0xe7ec,
 	0xe7ef,
@@ -727,7 +757,7 @@ var isNotPrint32 = []uint16{ // add 0x10000 to each entry
 	0xeeaa,
 	0xf0c0,
 	0xf0d0,
-	0xfabe,
+	0xfac7,
 	0xfb93,
 }
 

package/bin/go/src/strings/builder.go

@@ -99,7 +99,7 @@ func (b *Builder) WriteByte(c byte) error {
 }
 
 // WriteRune appends the UTF-8 encoding of Unicode code point r to b's buffer.
-// It returns the length of r and a nil error.
+// It returns the number of bytes written and a nil error.
 func (b *Builder) WriteRune(r rune) (int, error) {
 	b.copyCheck()
 	n := len(b.buf)

package/bin/go/src/strings/strings.go

@@ -74,6 +74,7 @@ func ContainsRune(s string, r rune) bool {
 }
 
 // ContainsFunc reports whether any Unicode code points r within s satisfy f(r).
+// It stops as soon as a call to f returns true.
 func ContainsFunc(s string, f func(rune) bool) bool {
 	return IndexFunc(s, f) >= 0
 }
@@ -94,25 +95,7 @@ func LastIndex(s, substr string) int {
 	case n > len(s):
 		return -1
 	}
-	// Rabin-Karp search from the end of the string
-	hashss, pow := bytealg.HashStrRev(substr)
-	last := len(s) - n
-	var h uint32
-	for i := len(s) - 1; i >= last; i-- {
-		h = h*bytealg.PrimeRK + uint32(s[i])
-	}
-	if h == hashss && s[last:] == substr {
-		return last
-	}
-	for i := last - 1; i >= 0; i-- {
-		h *= bytealg.PrimeRK
-		h += uint32(s[i])
-		h -= pow * uint32(s[i+n])
-		if h == hashss && s[i:i+n] == substr {
-			return i
-		}
-	}
-	return -1
+	return bytealg.LastIndexRabinKarp(s, substr)
 }
 
 // IndexByte returns the index of the first instance of c in s, or -1 if c is not present in s.
@@ -211,7 +194,7 @@ func IndexAny(s, chars string) int {
 		}
 		return IndexRune(s, r)
 	}
-	if len(s) > 8 {
+	if shouldUseASCIISet(len(s)) {
 		if as, isASCII := makeASCIISet(chars); isASCII {
 			for i := 0; i < len(s); i++ {
 				if as.contains(s[i]) {
@@ -247,7 +230,7 @@ func LastIndexAny(s, chars string) int {
 		}
 		return -1
 	}
-	if len(s) > 8 {
+	if shouldUseASCIISet(len(s)) {
 		if as, isASCII := makeASCIISet(chars); isASCII {
 			for i := len(s) - 1; i >= 0; i-- {
 				if as.contains(s[i]) {
@@ -299,9 +282,7 @@ func genSplit(s, sep string, sepSave, n int) []string {
 		n = Count(s, sep) + 1
 	}
 
-	if n > len(s)+1 {
-		n = len(s) + 1
-	}
+	n = min(n, len(s)+1)
 	a := make([]string, n)
 	n--
 	i := 0
@@ -949,15 +930,22 @@ func lastIndexFunc(s string, f func(rune) bool, truth bool) int {
 	return -1
 }
 
-// asciiSet is a 32-byte value, where each bit represents the presence of a
-// given ASCII character in the set. The 128-bits of the lower 16 bytes,
-// starting with the least-significant bit of the lowest word to the
-// most-significant bit of the highest word, map to the full range of all
-// 128 ASCII characters. The 128-bits of the upper 16 bytes will be zeroed,
-// ensuring that any non-ASCII character will be reported as not in the set.
-// This allocates a total of 32 bytes even though the upper half
-// is unused to avoid bounds checks in asciiSet.contains.
-type asciiSet [8]uint32
+// asciiSet is a 256-byte lookup table for fast ASCII character membership testing.
+// Each element corresponds to an ASCII character value, with true indicating the
+// character is in the set. Using bool instead of byte allows the compiler to
+// eliminate the comparison instruction, as bool values are guaranteed to be 0 or 1.
+//
+// The full 256-element table is used rather than a 128-element table to avoid
+// additional operations in the lookup path. Alternative approaches were tested:
+//   - [128]bool with explicit bounds check (if c >= 128): introduces branches
+//     that cause pipeline stalls, resulting in ~70% slower performance
+//   - [128]bool with masking (c&0x7f): eliminates bounds checks but the AND
+//     operation still costs ~10% performance compared to direct indexing
+//
+// The 256-element array allows direct indexing with no bounds checks, no branches,
+// and no masking operations, providing optimal performance. The additional 128 bytes
+// of memory is a worthwhile tradeoff for the simpler, faster code.
+type asciiSet [256]bool
 
 // makeASCIISet creates a set of ASCII characters and reports whether all
 // characters in chars are ASCII.
@@ -967,14 +955,24 @@ func makeASCIISet(chars string) (as asciiSet, ok bool) {
 		if c >= utf8.RuneSelf {
 			return as, false
 		}
-		as[c/32] |= 1 << (c % 32)
+		as[c] = true
 	}
 	return as, true
 }
 
 // contains reports whether c is inside the set.
 func (as *asciiSet) contains(c byte) bool {
-	return (as[c/32] & (1 << (c % 32))) != 0
+	return as[c]
+}
+
+// shouldUseASCIISet returns whether to use the lookup table optimization.
+// The threshold of 8 bytes balances initialization cost against per-byte
+// search cost, performing well across all charset sizes.
+//
+// More complex heuristics (e.g., different thresholds per charset size)
+// add branching overhead that eats away any theoretical improvements.
+func shouldUseASCIISet(bufLen int) bool {
+	return bufLen > 8
 }
 
 // Trim returns a slice of the string s with all leading and
@@ -1289,3 +1287,14 @@ func CutPrefix(s, prefix string) (after string, found bool) {
 func CutSuffix(s, suffix string) (before string, found bool) {
 	return stringslite.CutSuffix(s, suffix)
 }
+
+// CutLast slices s around the last instance of sep,
+// returning the text before and after sep.
+// The found result reports whether sep appears in s.
+// If sep does not appear in s, CutLast returns s, "", false.
+func CutLast(s, sep string) (before, after string, found bool) {
+	if i := LastIndex(s, sep); i >= 0 {
+		return s[:i], s[i+len(sep):], true
+	}
+	return s, "", false
+}

package/bin/go/src/sync/atomic/doc.go

@@ -45,6 +45,10 @@
 // This definition provides the same semantics as
 // C++'s sequentially consistent atomics and Java's volatile variables.
 //
+// Only a few integer sizes are supported: on many architectures,
+// atomic operations on non-word-sized integers are inefficient or
+// infeasible. For example, a [Bool] may be larger than a built-in bool.
+//
 // [the Go memory model]: https://go.dev/ref/mem
 package atomic
 
@@ -80,6 +84,7 @@ func SwapUint32(addr *uint32, new uint32) (old uint32)
 // Consider using the more ergonomic and less error-prone [Uintptr.Swap] instead.
 //
 //go:noescape
+//go:linknamestd SwapUintptr
 func SwapUintptr(addr *uintptr, new uintptr) (old uintptr)
 
 // SwapPointer atomically stores new into *addr and returns the previous *addr value.
@@ -102,6 +107,7 @@ func CompareAndSwapUint32(addr *uint32, old, new uint32) (swapped bool)
 // Consider using the more ergonomic and less error-prone [Uintptr.CompareAndSwap] instead.
 //
 //go:noescape
+//go:linknamestd CompareAndSwapUintptr
 func CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool)
 
 // CompareAndSwapPointer executes the compare-and-swap operation for a unsafe.Pointer value.
@@ -208,6 +214,7 @@ func StoreUint32(addr *uint32, val uint32)
 // Consider using the more ergonomic and less error-prone [Uintptr.Store] instead.
 //
 //go:noescape
+//go:linknamestd StoreUintptr
 func StoreUintptr(addr *uintptr, val uintptr)
 
 // StorePointer atomically stores val into *addr.

package/bin/go/src/sync/cond.go

@@ -86,8 +86,10 @@ func (c *Cond) Signal() {
 
 // Broadcast wakes all goroutines waiting on c.
 //
-// It is allowed but not required for the caller to hold c.L
-// during the call.
+// It is allowed but not required for the caller to hold c.L during the call.
+// The time it takes to run Broadcast is proportional to the number of waiting goroutines;
+// be aware that holding the lock across a call to Broadcast
+// will extend the amount of time that the lock is held.
 func (c *Cond) Broadcast() {
 	c.checker.check()
 	runtime_notifyListNotifyAll(&c.notify)

package/bin/go/src/sync/pool.go

@@ -6,6 +6,7 @@ package sync
 
 import (
 	"internal/race"
+	rtatomic "internal/runtime/atomic"
 	"runtime"
 	"sync/atomic"
 	"unsafe"
@@ -159,8 +160,8 @@ func (p *Pool) Get() any {
 
 func (p *Pool) getSlow(pid int) any {
 	// See the comment in pin regarding ordering of the loads.
-	size := runtime_LoadAcquintptr(&p.localSize) // load-acquire
-	locals := p.local                            // load-consume
+	size := rtatomic.LoadAcquintptr(&p.localSize) // load-acquire
+	locals := p.local                             // load-consume
 	// Try to steal one element from other procs.
 	for i := 0; i < int(size); i++ {
 		l := indexLocal(locals, (pid+i+1)%int(size))
@@ -212,8 +213,8 @@ func (p *Pool) pin() (*poolLocal, int) {
 	// Since we've disabled preemption, GC cannot happen in between.
 	// Thus here we must observe local at least as large localSize.
 	// We can observe a newer/larger local, it is fine (we must observe its zero-initialized-ness).
-	s := runtime_LoadAcquintptr(&p.localSize) // load-acquire
-	l := p.local                              // load-consume
+	s := rtatomic.LoadAcquintptr(&p.localSize) // load-acquire
+	l := p.local                               // load-consume
 	if uintptr(pid) < s {
 		return indexLocal(l, pid), pid
 	}
@@ -240,7 +241,7 @@ func (p *Pool) pinSlow() (*poolLocal, int) {
 	size := runtime.GOMAXPROCS(0)
 	local := make([]poolLocal, size)
 	atomic.StorePointer(&p.local, unsafe.Pointer(&local[0])) // store-release
-	runtime_StoreReluintptr(&p.localSize, uintptr(size))     // store-release
+	rtatomic.StoreReluintptr(&p.localSize, uintptr(size))    // store-release
 	return &local[pid], pid
 }
 
@@ -306,13 +307,3 @@ func indexLocal(l unsafe.Pointer, i int) *poolLocal {
 func runtime_registerPoolCleanup(cleanup func())
 func runtime_procPin() int
 func runtime_procUnpin()
-
-// The below are implemented in internal/runtime/atomic and the
-// compiler also knows to intrinsify the symbol we linkname into this
-// package.
-
-//go:linkname runtime_LoadAcquintptr internal/runtime/atomic.LoadAcquintptr
-func runtime_LoadAcquintptr(ptr *uintptr) uintptr
-
-//go:linkname runtime_StoreReluintptr internal/runtime/atomic.StoreReluintptr
-func runtime_StoreReluintptr(ptr *uintptr, val uintptr)

package/bin/go/src/sync/runtime2_lockrank.go

@@ -13,8 +13,7 @@ import "unsafe"
 type notifyList struct {
 	wait   uint32
 	notify uint32
-	rank   int     // rank field of the mutex
-	pad    int     // pad field of the mutex
+	rank   int64   // rank field of the mutex
 	lock   uintptr // key field of the mutex
 
 	head unsafe.Pointer

package/bin/go/src/syscall/exec_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 || netbsd || (openbsd && mips64)
+//go:build dragonfly || netbsd
 
 package syscall
 
@@ -187,7 +187,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 	// Pass 1: look for fd[i] < i and move those up above len(fd)
 	// so that pass 2 won't stomp on an fd it needs later.
 	if pipe < nextfd {
-		if runtime.GOOS == "netbsd" || (runtime.GOOS == "openbsd" && runtime.GOARCH == "mips64") {
+		if runtime.GOOS == "netbsd" {
 			_, _, err1 = RawSyscall(_SYS_DUP3, uintptr(pipe), uintptr(nextfd), O_CLOEXEC)
 		} else if runtime.GOOS == "dragonfly" {
 			_, _, err1 = RawSyscall(SYS_FCNTL, uintptr(pipe), _F_DUP2FD_CLOEXEC, uintptr(nextfd))
@@ -209,7 +209,7 @@ func forkAndExecInChild(argv0 *byte, argv, envv []*byte, chroot, dir *byte, attr
 			if nextfd == pipe { // don't stomp on pipe
 				nextfd++
 			}
-			if runtime.GOOS == "netbsd" || (runtime.GOOS == "openbsd" && runtime.GOARCH == "mips64") {
+			if runtime.GOOS == "netbsd" {
 				_, _, err1 = RawSyscall(_SYS_DUP3, uintptr(fd[i]), uintptr(nextfd), O_CLOEXEC)
 			} else if runtime.GOOS == "dragonfly" {
 				_, _, err1 = RawSyscall(SYS_FCNTL, uintptr(fd[i]), _F_DUP2FD_CLOEXEC, uintptr(nextfd))

package/bin/go/src/syscall/exec_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 syscall
 

package/bin/go/src/syscall/exec_linux.go

@@ -521,8 +521,13 @@ func forkAndExecInChild1(argv0 *byte, argv, envv []*byte, chroot, dir *byte, att
 		for _, c = range sys.AmbientCaps {
 			// Add the c capability to the permitted and inheritable capability mask,
 			// otherwise we will not be able to add it to the ambient capability mask.
-			caps.data[capToIndex(c)].permitted |= capToMask(c)
-			caps.data[capToIndex(c)].inheritable |= capToMask(c)
+			idx := int(capToIndex(c))
+			if idx >= len(caps.data) {
+				err1 = EINVAL
+				goto childerror
+			}
+			caps.data[idx].permitted |= capToMask(c)
+			caps.data[idx].inheritable |= capToMask(c)
 		}
 
 		if _, _, err1 = RawSyscall(SYS_CAPSET, uintptr(unsafe.Pointer(&caps.hdr)), uintptr(unsafe.Pointer(&caps.data[0])), 0); err1 != 0 {

package/bin/go/src/syscall/fs_js.go

@@ -421,9 +421,11 @@ func Read(fd int, b []byte) (int, error) {
 	if err != nil {
 		return 0, err
 	}
-	js.CopyBytesToGo(b, buf)
-
 	n2 := n.Int()
+	if n2 > 0 {
+		js.CopyBytesToGo(b[:n2], buf)
+	}
+
 	f.pos += int64(n2)
 	return n2, err
 }
@@ -465,8 +467,11 @@ func Pread(fd int, b []byte, offset int64) (int, error) {
 	if err != nil {
 		return 0, err
 	}
-	js.CopyBytesToGo(b, buf)
-	return n.Int(), nil
+	n2 := n.Int()
+	if n2 > 0 {
+		js.CopyBytesToGo(b[:n2], buf)
+	}
+	return n2, nil
 }
 
 func Pwrite(fd int, b []byte, offset int64) (int, error) {