@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/runtime/rand.go

@@ -10,7 +10,7 @@ import (
 	"internal/byteorder"
 	"internal/chacha8rand"
 	"internal/goarch"
-	"internal/runtime/math"
+	"math/bits"
 	"unsafe"
 	_ "unsafe" // for go:linkname
 )
@@ -117,7 +117,10 @@ func allZero(b []byte) bool {
 	return acc == 0
 }
 
+// Used in internal/runtime/maps
 // bootstrapRand returns a random uint64 from the global random generator.
+//
+//go:linknamestd bootstrapRand
 func bootstrapRand() uint64 {
 	lock(&globalRand.lock)
 	if !globalRand.init {
@@ -192,7 +195,8 @@ func mrandinit(mp *m) {
 	}
 	bootstrapRandReseed() // erase key we just extracted
 	mp.chacha8.Init64(seed)
-	mp.cheaprand = rand()
+	mp.cheaprand = uint32(rand())
+	mp.cheaprand64 = rand()
 }
 
 // randn is like rand() % n but faster.
@@ -227,14 +231,12 @@ func randn(n uint32) uint32 {
 func cheaprand() uint32 {
 	mp := getg().m
 	// Implement wyrand: https://github.com/wangyi-fudan/wyhash
-	// Only the platform that math.Mul64 can be lowered
-	// by the compiler should be in this list.
-	if goarch.IsAmd64|goarch.IsArm64|goarch.IsPpc64|
-		goarch.IsPpc64le|goarch.IsMips64|goarch.IsMips64le|
-		goarch.IsS390x|goarch.IsRiscv64|goarch.IsLoong64 == 1 {
-		mp.cheaprand += 0xa0761d6478bd642f
-		hi, lo := math.Mul64(mp.cheaprand, mp.cheaprand^0xe7037ed1a0b428db)
-		return uint32(hi ^ lo)
+	// Only the platform that supports 64-bit multiplication
+	// natively should be allowed.
+	if bits.UintSize == 64 {
+		mp.cheaprand += 0x53c5ca59
+		hi, lo := bits.Mul32(mp.cheaprand, mp.cheaprand^0x74743c1b)
+		return hi ^ lo
 	}
 
 	// Implement xorshift64+: 2 32-bit xorshift sequences added together.
@@ -242,7 +244,7 @@ func cheaprand() uint32 {
 	// Xorshift paper: https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf
 	// This generator passes the SmallCrush suite, part of TestU01 framework:
 	// http://simul.iro.umontreal.ca/testu01/tu01.html
-	t := (*[2]uint32)(unsafe.Pointer(&mp.cheaprand))
+	t := (*[2]uint32)(unsafe.Pointer(&mp.cheaprand64))
 	s1, s0 := t[0], t[1]
 	s1 ^= s1 << 17
 	s1 = s1 ^ s0 ^ s1>>7 ^ s0>>16
@@ -269,7 +271,33 @@ func cheaprand() uint32 {
 //go:linkname cheaprand64
 //go:nosplit
 func cheaprand64() int64 {
-	return int64(cheaprand())<<31 ^ int64(cheaprand())
+	return int64(cheaprandu64() & ^(uint64(1) << 63))
+}
+
+// cheaprandu64 is a non-cryptographic-quality 64-bit random generator
+// suitable for calling at very high frequency (such as during sampling decisions).
+// it is "cheap" in the sense of both expense and quality.
+//
+// cheaprandu64 must not be exported to other packages:
+// the rule is that other packages using runtime-provided
+// randomness must always use rand.
+//
+//go:nosplit
+func cheaprandu64() uint64 {
+	// Implement wyrand: https://github.com/wangyi-fudan/wyhash
+	// Only the platform that bits.Mul64 can be lowered
+	// by the compiler should be in this list.
+	if goarch.IsAmd64|goarch.IsArm64|goarch.IsPpc64|
+		goarch.IsPpc64le|goarch.IsMips64|goarch.IsMips64le|
+		goarch.IsS390x|goarch.IsRiscv64|goarch.IsLoong64 == 1 {
+		mp := getg().m
+		// Implement wyrand: https://github.com/wangyi-fudan/wyhash
+		mp.cheaprand64 += 0xa0761d6478bd642f
+		hi, lo := bits.Mul64(mp.cheaprand64, mp.cheaprand64^0xe7037ed1a0b428db)
+		return hi ^ lo
+	}
+
+	return uint64(cheaprand())<<32 | uint64(cheaprand())
 }
 
 // cheaprandn is like cheaprand() % n but faster.

package/bin/go/src/runtime/{rt0_linux_ppc64le.s → rt0_linux_ppc64x.s}

@@ -2,15 +2,25 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build (ppc64 || ppc64le) && linux
+
 #include "go_asm.h"
 #include "textflag.h"
 #include "asm_ppc64x.h"
 
-TEXT _rt0_ppc64le_linux(SB),NOSPLIT,$0
+#ifdef GOARCH_ppc64
+#define ENTRYPOINT	_rt0_ppc64_linux
+#define ENTRYPOINT_LIB	_rt0_ppc64_linux_lib
+#else
+#define ENTRYPOINT	_rt0_ppc64le_linux
+#define ENTRYPOINT_LIB	_rt0_ppc64le_linux_lib
+#endif
+
+TEXT ENTRYPOINT(SB),NOSPLIT,$0
 	XOR R0, R0	  // Make sure R0 is zero before _main
 	BR _main<>(SB)
 
-TEXT _rt0_ppc64le_linux_lib(SB),NOSPLIT|NOFRAME,$0
+TEXT ENTRYPOINT_LIB(SB),NOSPLIT|NOFRAME,$0
 	JMP _rt0_ppc64x_lib(SB)
 
 TEXT _main<>(SB),NOSPLIT,$-8

package/bin/go/src/runtime/runtime-gdb.py

@@ -169,6 +169,10 @@ class MapTypePrinter:
 		cnt = 0
 		# Yield keys and elements in group.
 		# group is a value of type *group[K,V]
+		# The group layout depends on GOEXPERIMENT=mapsplitgroup:
+		#   split:       group.keys[i] / group.elems[i]
+		#   interleaved: group.slots[i].key / group.slots[i].elem
+		# Detect which layout by checking for the 'keys' field.
 		def group_slots(group):
 			ctrl = group['ctrl']
 
@@ -179,8 +183,15 @@ class MapTypePrinter:
 					continue
 
 				# Full
-				yield str(cnt), group['slots'][i]['key']
-				yield str(cnt+1), group['slots'][i]['elem']
+				# The group layout depends on GOEXPERIMENT=mapsplitgroup:
+				#   split:       group.keys[i] / group.elems[i]
+				#   interleaved: group.slots[i].key / group.slots[i].elem
+				try:
+					yield str(cnt), group['slots'][i]['key']
+					yield str(cnt+1), group['slots'][i]['elem']
+				except gdb.error:
+					yield str(cnt), group['keys'][i]
+					yield str(cnt+1), group['elems'][i]
 
 		# The linker DWARF generation
 		# (cmd/link/internal/ld.(*dwctxt).synthesizemaptypes) records

package/bin/go/src/runtime/runtime1.go

@@ -5,8 +5,10 @@
 package runtime
 
 import (
+	"internal/abi"
 	"internal/bytealg"
 	"internal/goarch"
+	"internal/godebugs"
 	"internal/runtime/atomic"
 	"internal/strconv"
 	"unsafe"
@@ -286,10 +288,6 @@ func check() {
 	if fixedStack != round2(fixedStack) {
 		throw("FixedStack is not power-of-2")
 	}
-
-	if !checkASM() {
-		throw("assembly checks failed")
-	}
 }
 
 type dbgVar struct {
@@ -351,16 +349,6 @@ var debug struct {
 
 	panicnil atomic.Int32
 
-	// asynctimerchan controls whether timer channels
-	// behave asynchronously (as in Go 1.22 and earlier)
-	// instead of their Go 1.23+ synchronous behavior.
-	// The value can change at any time (in response to os.Setenv("GODEBUG"))
-	// and affects all extant timer channels immediately.
-	// Programs wouldn't normally change over an execution,
-	// but allowing it is convenient for testing and for programs
-	// that do an os.Setenv in main.init or main.main.
-	asynctimerchan atomic.Int32
-
 	// tracebacklabels controls the inclusion of goroutine labels in the
 	// goroutine status header line.
 	tracebacklabels atomic.Int32
@@ -369,7 +357,6 @@ var debug struct {
 var dbgvars = []*dbgVar{
 	{name: "adaptivestackstart", value: &debug.adaptivestackstart},
 	{name: "asyncpreemptoff", value: &debug.asyncpreemptoff},
-	{name: "asynctimerchan", atomic: &debug.asynctimerchan},
 	{name: "cgocheck", value: &debug.cgocheck},
 	{name: "clobberfree", value: &debug.clobberfree},
 	{name: "containermaxprocs", value: &debug.containermaxprocs, def: 1},
@@ -398,7 +385,7 @@ var dbgvars = []*dbgVar{
 	{name: "traceallocfree", atomic: &debug.traceallocfree},
 	{name: "tracecheckstackownership", value: &debug.traceCheckStackOwnership},
 	{name: "tracebackancestors", value: &debug.tracebackancestors},
-	{name: "tracebacklabels", atomic: &debug.tracebacklabels, def: 0},
+	{name: "tracebacklabels", atomic: &debug.tracebacklabels, def: 1},
 	{name: "tracefpunwindoff", value: &debug.tracefpunwindoff},
 	{name: "updatemaxprocs", value: &debug.updatemaxprocs, def: 1},
 }
@@ -484,6 +471,14 @@ func reparsedebugvars(env string) {
 	}
 }
 
+// If an invalid GODEBUG setting is found during startup time,
+// invalidGODEBUG is set to that setting so it can be reported
+// when initialization has progressed sufficiently.
+var invalidGODEBUG struct {
+	key, value string
+	removed    int
+}
+
 // parsegodebug parses the godebug string, updating variables listed in dbgvars.
 // If seen == nil, this is startup time and we process the string left to right
 // overwriting older settings with newer ones.
@@ -522,6 +517,23 @@ func parsegodebug(godebug string, seen map[string]bool) {
 			continue
 		}
 		key, value := field[:i], field[i+1:]
+
+		// Setting a removed GODEBUG is ok unless it's set to an old value.
+		// We only check at startup time per go.dev/issue/76163.
+		if seen == nil {
+			for _, info := range godebugs.Removed {
+				if info.Name == key {
+					if info.Old(value) {
+						invalidGODEBUG.key = key
+						invalidGODEBUG.value = value
+						invalidGODEBUG.removed = info.Removed
+						return // this skips the cgocheck below but we're about to fatal anyway
+					}
+					break
+				}
+			}
+		}
+
 		if seen[key] {
 			continue
 		}
@@ -627,18 +639,48 @@ func releasem(mp *m) {
 // Do not remove or change the type signature.
 // See go.dev/issue/67401.
 //
+// This is obsolete and only remains for external packages.
+// New code should use reflect_compiledTypelinks.
+//
 //go:linkname reflect_typelinks reflect.typelinks
 func reflect_typelinks() ([]unsafe.Pointer, [][]int32) {
 	modules := activeModules()
+
+	typesToOffsets := func(md *moduledata) []int32 {
+		types := moduleTypelinks(md)
+		ret := make([]int32, 0, len(types))
+		for _, typ := range types {
+			ret = append(ret, int32(uintptr(unsafe.Pointer(typ))-md.types))
+		}
+		return ret
+	}
+
 	sections := []unsafe.Pointer{unsafe.Pointer(modules[0].types)}
-	ret := [][]int32{modules[0].typelinks}
+	ret := [][]int32{typesToOffsets(modules[0])}
 	for _, md := range modules[1:] {
 		sections = append(sections, unsafe.Pointer(md.types))
-		ret = append(ret, md.typelinks)
+		ret = append(ret, typesToOffsets(md))
 	}
 	return sections, ret
 }
 
+// reflect_compiledTypelinks returns the typelink types
+// generated by the compiler for all current modules.
+// The normal case is a single module, so this returns one
+// slice for the main module, and a slice of slices, normally nil,
+// for other modules.
+//
+//go:linknamestd reflect_compiledTypelinks reflect.compiledTypelinks
+func reflect_compiledTypelinks() ([]*abi.Type, [][]*abi.Type) {
+	modules := activeModules()
+	firstTypes := moduleTypelinks(modules[0])
+	var rest [][]*abi.Type
+	for _, md := range modules[1:] {
+		rest = append(rest, moduleTypelinks(md))
+	}
+	return firstTypes, rest
+}
+
 // reflect_resolveNameOff resolves a name offset from a base pointer.
 //
 // reflect_resolveNameOff is for package reflect,
@@ -722,6 +764,15 @@ func reflect_addReflectOff(ptr unsafe.Pointer) int32 {
 	return id
 }
 
+// reflect_adjustAIXGCDataForRuntime takes a type.GCData address and returns
+// the new address to use. This is only called on AIX.
+// See getGCMaskOnDemand.
+//
+//go:linknamestd reflect_adjustAIXGCDataForRuntime reflect.adjustAIXGCDataForRuntime
+func reflect_adjustAIXGCDataForRuntime(addr *byte) *byte {
+	return (*byte)(add(unsafe.Pointer(addr), aixStaticDataBase-firstmoduledata.data))
+}
+
 //go:linkname fips_getIndicator crypto/internal/fips140.getIndicator
 func fips_getIndicator() uint8 {
 	return getg().fipsIndicator

package/bin/go/src/runtime/runtime2.go

@@ -301,8 +301,6 @@ func setMNoWB(mp **m, new *m) {
 }
 
 type gobuf struct {
-	// The offsets of sp, pc, and g are known to (hard-coded in) libmach.
-	//
 	// ctxt is unusual with respect to GC: it may be a
 	// heap-allocated funcval, so GC needs to track it, but it
 	// needs to be set and cleared from assembly, where it's
@@ -479,12 +477,12 @@ type g struct {
 	// It is stack.lo+StackGuard on g0 and gsignal stacks.
 	// It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).
 	stack       stack   // offset known to runtime/cgo
-	stackguard0 uintptr // offset known to liblink
-	stackguard1 uintptr // offset known to liblink
+	stackguard0 uintptr // offset known to cmd/internal/obj/*
+	stackguard1 uintptr // offset known to cmd/internal/obj/*
 
-	_panic    *_panic // innermost panic - offset known to liblink
+	_panic    *_panic // innermost panic
 	_defer    *_defer // innermost defer
-	m         *m      // current m; offset known to arm liblink
+	m         *m      // current m
 	sched     gobuf
 	syscallsp uintptr // if status==Gsyscall, syscallsp = sched.sp to use during gc
 	syscallpc uintptr // if status==Gsyscall, syscallpc = sched.pc to use during gc
@@ -622,15 +620,18 @@ type m struct {
 
 	// Fields whose offsets are not known to debuggers.
 
-	procid       uint64            // for debuggers, but offset not hard-coded
-	gsignal      *g                // signal-handling g
-	goSigStack   gsignalStack      // Go-allocated signal handling stack
-	sigmask      sigset            // storage for saved signal mask
-	tls          [tlsSlots]uintptr // thread-local storage (for x86 extern register)
-	mstartfn     func()
-	curg         *g       // current running goroutine
-	caughtsig    guintptr // goroutine running during fatal signal
-	signalSecret uint32   // whether we have secret information in our signal stack
+	procid     uint64            // for debuggers, but offset not hard-coded
+	gsignal    *g                // signal-handling g
+	goSigStack gsignalStack      // Go-allocated signal handling stack
+	sigmask    sigset            // storage for saved signal mask
+	tls        [tlsSlots]uintptr // thread-local storage (for x86 extern register)
+	mstartfn   func()
+	curg       *g       // current running goroutine
+	caughtsig  guintptr // goroutine running during fatal signal
+
+	// Indicates whether we've received a signal while
+	// running in secret mode.
+	signalSecret bool
 
 	// p is the currently attached P for executing Go code, nil if not executing user Go code.
 	//
@@ -715,8 +716,9 @@ type m struct {
 
 	mOS
 
-	chacha8   chacha8rand.State
-	cheaprand uint64
+	chacha8     chacha8rand.State
+	cheaprand   uint32
+	cheaprand64 uint64
 
 	// Up to 10 locks held by this m, maintained by the lock ranking code.
 	locksHeldLen int
@@ -783,7 +785,7 @@ type p struct {
 
 	// oldm is the previous m this p ran on.
 	//
-	// We are not assosciated with this m, so we have no control over its
+	// We are not associated with this m, so we have no control over its
 	// lifecycle. This value is an m.self object which points to the m
 	// until the m exits.
 	//
@@ -1175,16 +1177,17 @@ type _panic struct {
 	link *_panic // link to earlier panic
 
 	// startPC and startSP track where _panic.start was called.
+	// (These are the SP and PC of the gopanic frame itself.)
 	startPC uintptr
 	startSP unsafe.Pointer
 
 	// The current stack frame that we're running deferred calls for.
+	pc uintptr
 	sp unsafe.Pointer
-	lr uintptr
 	fp unsafe.Pointer
 
 	// retpc stores the PC where the panic should jump back to, if the
-	// function last returned by _panic.next() recovers the panic.
+	// function last returned by _panic.nextDefer() recovers the panic.
 	retpc uintptr
 
 	// Extra state for handling open-coded defers.
@@ -1195,8 +1198,6 @@ type _panic struct {
 	repanicked  bool // whether this panic repanicked
 	goexit      bool
 	deferreturn bool
-
-	gopanicFP unsafe.Pointer // frame pointer of the gopanic frame
 }
 
 // savedOpenDeferState tracks the extra state from _panic that's

package/bin/go/src/runtime/secret/secret.go

@@ -24,6 +24,9 @@ import (
 //     that, any panic raised by f will appear as if it originates from
 //     Do itself.
 //
+// Any goroutine spawned while executing f will act as if the entire goroutine
+// is wrapped inside another call to Do.
+//
 // Users should be cautious of allocating inside Do.
 // Erasing heap memory after Do returns may increase garbage collector sweep times and
 // requires additional memory to keep track of allocations until they are to be erased.
@@ -39,7 +42,6 @@ import (
 //   - Currently only supported on linux/amd64 and linux/arm64.  On unsupported
 //     platforms, Do will invoke f directly.
 //   - Protection does not extend to any global variables written by f.
-//   - Protection does not extend to any new goroutines made by f.
 //   - If f calls runtime.Goexit, erasure can be delayed by defers
 //     higher up on the call stack.
 //   - Heap allocations will only be erased if the program drops all
@@ -119,7 +121,10 @@ func doHelper(f func()) (p any) {
 	return
 }
 
-// Enabled reports whether [Do] appears anywhere on the call stack.
+// Enabled reports whether the current goroutine
+// is running in secret mode. This is usually through a call to
+// [Do], but can also occur when a goroutine already running in
+// secret mode launches another goroutine.
 func Enabled() bool {
 	return count() > 0
 }

package/bin/go/src/runtime/secret.go

@@ -71,15 +71,6 @@ func addSecret(p unsafe.Pointer, size uintptr) {
 	addspecial(p, &s.special, false)
 }
 
-// send a no-op signal to an M for the purposes of
-// clobbering the signal stack
-//
-// Use sigpreempt. If we don't have a preemption queued, this just
-// turns into a no-op
-func noopSignal(mp *m) {
-	signalM(mp, sigPreempt)
-}
-
 // secret_getStack returns the memory range of the
 // current goroutine's stack.
 // For testing only.
@@ -93,6 +84,33 @@ func secret_getStack() (uintptr, uintptr) {
 	return gp.stack.lo, gp.stack.hi
 }
 
+// erase any secrets that may have been spilled onto the signal stack during
+// signal handling. Must be called on g0 or inside STW to make sure we don't
+// get rescheduled onto a different M.
+//
+//go:nosplit
+func eraseSecretsSignalStk() {
+	mp := getg().m
+	if mp.signalSecret {
+		mp.signalSecret = false
+		// signal handlers get invoked atomically
+		// so it's fine for us to zero out the stack while a signal
+		// might get delivered. Worst case is we are currently running
+		// in secret mode and the signal spills fresh secret info onto
+		// the stack, but since we haven't returned from the secret.Do
+		// yet, we make no guarantees about that information.
+		//
+		// It might be tempting to only erase the part of the signal
+		// stack that has the context, but when running with forwarded
+		// signals, they might pull arbitrary data out of the context and
+		// store it elsewhere on the stack. We can't stop them from storing
+		// the data in arbitrary places, but we can erase the stack where
+		// they are likely to put it in cases of a register spill.
+		size := mp.gsignal.stack.hi - mp.gsignal.stack.lo
+		memclrNoHeapPointers(unsafe.Pointer(mp.gsignal.stack.lo), size)
+	}
+}
+
 // return a slice of all Ms signal stacks
 // For testing only.
 //

package/bin/go/src/runtime/secret_nosecret.go

@@ -27,4 +27,4 @@ func addSecret(p unsafe.Pointer, size uintptr) {}
 //go:linkname secret_getStack runtime/secret.getStack
 func secret_getStack() (uintptr, uintptr) { return 0, 0 }
 
-func noopSignal(mp *m) {}
+func eraseSecretsSignalStk() {}

package/bin/go/src/runtime/sigaction.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 (linux && !386 && !amd64 && !arm64 && !loong64 && !ppc64le) || (freebsd && !amd64)
+//go:build (linux && !386 && !amd64 && !arm64 && !loong64 && !ppc64 && !ppc64le) || (freebsd && !amd64)
 
 package runtime
 

package/bin/go/src/runtime/signal_unix.go

@@ -491,7 +491,7 @@ func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
 	sighandler(sig, info, ctx, gp)
 
 	if goexperiment.RuntimeSecret && gp.secret > 0 {
-		atomic.Store(&gp.m.signalSecret, 1)
+		gp.m.signalSecret = true
 	}
 
 	setg(gp)
@@ -989,8 +989,10 @@ func dieFromSignal(sig uint32) {
 	osyield()
 	osyield()
 
-	// If we are still somehow running, just exit with the wrong status.
-	exit(2)
+	// If we are still somehow running, this probably means we're PID 1
+	// immune to signals with default-terminate. Use a shell convention
+	// of exit(128+sig) to mimic the "terminated by signal".
+	exit(128 + int32(sig))
 }
 
 // raisebadsignal is called when a signal is received on a non-Go

package/bin/go/src/runtime/softfloat64.go

@@ -91,7 +91,6 @@ func funpack32(f uint32) (sign, mant uint32, exp int, inf, nan bool) {
 }
 
 func fpack64(sign, mant uint64, exp int, trunc uint64) uint64 {
-	mant0, exp0, trunc0 := mant, exp, trunc
 	if mant == 0 {
 		return sign
 	}
@@ -99,6 +98,11 @@ func fpack64(sign, mant uint64, exp int, trunc uint64) uint64 {
 		mant <<= 1
 		exp--
 	}
+	// Save the normalized mantissa; the denormal path below restores it and
+	// re-aligns to the subnormal exponent. Saving before this loop (as the
+	// code originally did) left a heavily-cancelled add/sub mantissa
+	// un-normalized, which that path then shifted the wrong way. See #79964.
+	mant0, exp0, trunc0 := mant, exp, trunc
 	for mant >= 4<<mantbits64 {
 		trunc |= mant & 1
 		mant >>= 1
@@ -142,7 +146,6 @@ func fpack64(sign, mant uint64, exp int, trunc uint64) uint64 {
 }
 
 func fpack32(sign, mant uint32, exp int, trunc uint32) uint32 {
-	mant0, exp0, trunc0 := mant, exp, trunc
 	if mant == 0 {
 		return sign
 	}
@@ -150,6 +153,8 @@ func fpack32(sign, mant uint32, exp int, trunc uint32) uint32 {
 		mant <<= 1
 		exp--
 	}
+	// See fpack64: save the normalized mantissa for the denormal path below.
+	mant0, exp0, trunc0 := mant, exp, trunc
 	for mant >= 4<<mantbits32 {
 		trunc |= mant & 1
 		mant >>= 1

package/bin/go/src/runtime/string.go

@@ -8,6 +8,7 @@ import (
 	"internal/abi"
 	"internal/bytealg"
 	"internal/goarch"
+	"internal/goos"
 	"internal/runtime/math"
 	"internal/runtime/sys"
 	"internal/strconv"
@@ -505,7 +506,9 @@ func findnull(s *byte) int {
 	// It must be the minimum page size for any architecture Go
 	// runs on. It's okay (just a minor performance loss) if the
 	// actual system page size is larger than this value.
-	const pageSize = 4096
+	// For Android, we set the page size to the MTE size, as MTE
+	// might be enforced. See issue 59090.
+	const pageSize = 4096*(1-goos.IsAndroid) + 16*goos.IsAndroid
 
 	offset := 0
 	ptr := unsafe.Pointer(s)

package/bin/go/src/runtime/stubs.go

@@ -203,12 +203,19 @@ func noEscapePtr[T any](p *T) *T {
 // Not all cgocallback frames are actually cgocallback,
 // so not all have these arguments. Mark them uintptr so that the GC
 // does not misinterpret memory when the arguments are not present.
-// cgocallback is not called from Go, only from crosscall2.
+// cgocallback is not called from Go, only from crosscall2 in runtime/cgo.
 // This in turn calls cgocallbackg, which is where we'll find
 // pointer-declared arguments.
 //
 // When fn is nil (frame is saved g), call dropm instead,
 // this is used when the C thread is exiting.
+//
+// cgocallback should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/ebitengine/purego
+//
+//go:linkname cgocallback
 func cgocallback(fn, frame, ctxt uintptr)
 
 func gogo(buf *gobuf)
@@ -260,6 +267,7 @@ func breakpoint()
 // only in a very limited callee of reflectcall, the stackArgs are copied, and
 // regArgs is only used in the reflectcall frame.
 //
+//go:linknamestd reflectcall
 //go:noescape
 func reflectcall(stackArgsType *_type, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
 
@@ -334,6 +342,7 @@ func morestack()
 func morestack_noctxt()
 
 func rt0_go()
+func rt0_lib_go()
 
 // in asm_*.s
 // not called directly; definitions here supply type information for traceback.
@@ -391,9 +400,6 @@ func divRoundUp(n, a uintptr) uintptr {
 	return (n + a - 1) / a
 }
 
-// checkASM reports whether assembly runtime checks have passed.
-func checkASM() bool
-
 func memequal_varlen(a, b unsafe.Pointer) bool
 
 // bool2int returns 0 if x is false or 1 if x is true.
@@ -408,6 +414,10 @@ func bool2int(x bool) int {
 // (e.g., an INT3 on x86). A crash in abort is recognized by the
 // signal handler, which will attempt to tear down the runtime
 // immediately.
+//
+// Also called from runtime test.
+//
+//go:linkname abort
 func abort()
 
 // Called from compiled code; declared for vet; do NOT call from Go.

package/bin/go/src/runtime/stubs_amd64.go

@@ -48,7 +48,11 @@ func asmcgocall_landingpad()
 //
 // Spills/loads arguments in registers to/from an internal/abi.RegArgs
 // respectively. Does not follow the Go ABI.
+//
+//go:linknamestd spillArgs
 func spillArgs()
+
+//go:linknamestd unspillArgs
 func unspillArgs()
 
 // getfp returns the frame pointer register of its caller or 0 if not implemented.