@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/runtime/os_dragonfly.go

@@ -349,3 +349,13 @@ const sigPerThreadSyscall = 1 << 31
 func runPerThreadSyscall() {
 	throw("runPerThreadSyscall only valid on linux")
 }
+
+//go:nowritebarrierrec
+//go:nosplit
+func libpreinit() {}
+
+//go:nowritebarrierrec
+//go:nosplit
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
+	throw("bad newosproc0")
+}

package/bin/go/src/runtime/os_js.go

@@ -40,3 +40,13 @@ func readRandom(r []byte) int {
 func goenvs() {
 	goenvs_unix()
 }
+
+//go:nowritebarrierrec
+//go:nosplit
+func libpreinit() {}
+
+//go:nowritebarrierrec
+//go:nosplit
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
+	throw("bad newosproc0")
+}

package/bin/go/src/runtime/os_linux32.go

@@ -57,11 +57,11 @@ func futex(addr unsafe.Pointer, op int32, val uint32, ts *timespec, addr2 unsafe
 	if use64bitsTimeOn32bits {
 		return futex_time64(addr, op, val, ts, addr2, val3)
 	}
-	// Downgrade ts.
+
 	var ts32 timespec32
 	var pts32 *timespec32
 	if ts != nil {
-		ts32.setNsec(ts.tv_sec*1e9 + int64(ts.tv_nsec))
+		ts32 = ts.mustDowncastToTimespec32()
 		pts32 = &ts32
 	}
 	return futex_time32(addr, op, val, pts32, addr2, val3)
@@ -83,16 +83,29 @@ func timer_settime(timerid int32, flags int32, new, old *itimerspec) int32 {
 	var new32, old32 *itimerspec32
 
 	if new != nil {
-		newts.it_interval.setNsec(new.it_interval.tv_sec*1e9 + int64(new.it_interval.tv_nsec))
-		newts.it_value.setNsec(new.it_value.tv_sec*1e9 + int64(new.it_value.tv_nsec))
+		newts.it_interval = new.it_interval.mustDowncastToTimespec32()
+		newts.it_value = new.it_value.mustDowncastToTimespec32()
 		new32 = &newts
 	}
 
 	if old != nil {
-		oldts.it_interval.setNsec(old.it_interval.tv_sec*1e9 + int64(old.it_interval.tv_nsec))
-		oldts.it_value.setNsec(old.it_value.tv_sec*1e9 + int64(old.it_value.tv_nsec))
+		oldts.it_interval = old.it_interval.mustDowncastToTimespec32()
+		oldts.it_value = old.it_value.mustDowncastToTimespec32()
 		old32 = &oldts
 	}
 
 	return timer_settime32(timerid, flags, new32, old32)
 }
+
+// mustDowncastToTimespec32 converts a 64-bit timespec to a 32-bit
+// timespec and throws if the value cannot be represented in 32 bits.
+//
+//go:nosplit
+func (ts timespec) mustDowncastToTimespec32() (r timespec32) {
+	r.tv_sec = int32(ts.tv_sec)
+	if ts.tv_sec != int64(r.tv_sec) {
+		throw("timespec64 value cannot be represented in timespec32")
+	}
+	r.tv_nsec = ts.tv_nsec
+	return
+}

package/bin/go/src/runtime/os_netbsd.go

@@ -443,3 +443,13 @@ const sigPerThreadSyscall = 1 << 31
 func runPerThreadSyscall() {
 	throw("runPerThreadSyscall only valid on linux")
 }
+
+//go:nowritebarrierrec
+//go:nosplit
+func libpreinit() {}
+
+//go:nowritebarrierrec
+//go:nosplit
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
+	throw("bad newosproc0")
+}

package/bin/go/src/runtime/os_openbsd.go

@@ -339,3 +339,13 @@ const sigPerThreadSyscall = 1 << 31
 func runPerThreadSyscall() {
 	throw("runPerThreadSyscall only valid on linux")
 }
+
+//go:nowritebarrierrec
+//go:nosplit
+func libpreinit() {}
+
+//go:nowritebarrierrec
+//go:nosplit
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
+	throw("bad newosproc0")
+}

package/bin/go/src/runtime/os_plan9.go

@@ -594,3 +594,13 @@ func walltime() (sec int64, nsec int32) {
 	readtime(&t[0], 1, 1)
 	return timesplit(frombe(t[0]))
 }
+
+//go:nowritebarrierrec
+//go:nosplit
+func libpreinit() {}
+
+//go:nowritebarrierrec
+//go:nosplit
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
+	throw("bad newosproc0")
+}

package/bin/go/src/runtime/os_wasip1.go

@@ -266,3 +266,13 @@ func nanotime1() int64 {
 	}
 	return int64(time)
 }
+
+//go:nowritebarrierrec
+//go:nosplit
+func libpreinit() {}
+
+//go:nowritebarrierrec
+//go:nosplit
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
+	throw("bad newosproc0")
+}

package/bin/go/src/runtime/os_windows.go

@@ -39,6 +39,7 @@ const (
 //go:cgo_import_dynamic runtime._GetSystemDirectoryA GetSystemDirectoryA%2 "kernel32.dll"
 //go:cgo_import_dynamic runtime._GetSystemInfo GetSystemInfo%1 "kernel32.dll"
 //go:cgo_import_dynamic runtime._GetThreadContext GetThreadContext%2 "kernel32.dll"
+//go:cgo_import_dynamic runtime._IsProcessorFeaturePresent IsProcessorFeaturePresent%1 "kernel32.dll"
 //go:cgo_import_dynamic runtime._SetThreadContext SetThreadContext%2 "kernel32.dll"
 //go:cgo_import_dynamic runtime._LoadLibraryExW LoadLibraryExW%3 "kernel32.dll"
 //go:cgo_import_dynamic runtime._PostQueuedCompletionStatus PostQueuedCompletionStatus%4 "kernel32.dll"
@@ -96,6 +97,7 @@ var (
 	_GetSystemDirectoryA,
 	_GetSystemInfo,
 	_GetThreadContext,
+	_IsProcessorFeaturePresent,
 	_SetThreadContext,
 	_LoadLibraryExW,
 	_PostQueuedCompletionStatus,
@@ -261,6 +263,12 @@ func windows_QueryPerformanceFrequency() int64 {
 	return frequency
 }
 
+//go:linknamestd cpu_isProcessorFeaturePresent internal/cpu.isProcessorFeaturePresent
+func cpu_isProcessorFeaturePresent(processorFeature uint32) bool {
+	ret := stdcall(_IsProcessorFeaturePresent, uintptr(processorFeature))
+	return ret != 0
+}
+
 func loadOptionalSyscalls() {
 	bcryptPrimitives := windowsLoadSystemLib(bcryptprimitivesdll[:])
 	if bcryptPrimitives == 0 {
@@ -742,18 +750,17 @@ func semacreate(mp *m) {
 	}
 }
 
-// May run with m.p==nil, so write barriers are not allowed. This
-// function is called by newosproc0, so it is also required to
-// operate without stack guards.
+// May run with m.p==nil, so write barriers are not allowed.
 //
 //go:nowritebarrierrec
-//go:nosplit
 func newosproc(mp *m) {
-	// We pass 0 for the stack size to use the default for this binary.
-	thandle := stdcall(_CreateThread, 0, 0,
-		abi.FuncPCABI0(tstart_stdcall), uintptr(unsafe.Pointer(mp)),
-		0, 0)
-
+	// LockOSThread can reach newosproc on a goroutine stack when starting
+	// the template thread. createThread does not switch stacks itself.
+	var thandle uintptr
+	var err uint32
+	systemstack(func() {
+		thandle, err = createThread(0, unsafe.Pointer(abi.FuncPCABI0(tstart_stdcall)), unsafe.Pointer(mp))
+	})
 	if thandle == 0 {
 		if atomic.Load(&exiting) != 0 {
 			// CreateThread may fail if called
@@ -763,7 +770,7 @@ func newosproc(mp *m) {
 			lock(&deadlock)
 			lock(&deadlock)
 		}
-		print("runtime: failed to create new OS thread (have ", mcount(), " already; errno=", getlasterror(), ")\n")
+		print("runtime: failed to create new OS thread (have ", mcount(), " already; errno=", err, ")\n")
 		throw("runtime.newosproc")
 	}
 
@@ -777,8 +784,34 @@ func newosproc(mp *m) {
 //
 //go:nowritebarrierrec
 //go:nosplit
-func newosproc0(stacksize uintptr, fn uintptr) {
-	throw("bad newosproc0")
+func newosproc0(stacksize uintptr, fn unsafe.Pointer) {
+	thandle, err := createThread(stacksize, fn, nil)
+	if thandle == 0 {
+		print("runtime: failed to create new OS thread (errno=", err, ")\n")
+		throw("runtime: failed to create new OS thread\n")
+	}
+	stdcall_no_g(_CloseHandle, thandle)
+}
+
+// createThread calls CreateThread to create a new thread.
+//
+//go:nowritebarrierrec
+//go:nosplit
+func createThread(stackSize uintptr, fn unsafe.Pointer, arg unsafe.Pointer) (handle uintptr, err uint32) {
+	for tries := range 20 {
+		// We pass 0 for the stack size to use the default for this binary.
+		handle = stdcall_no_g(_CreateThread, 0, stackSize, uintptr(fn), uintptr(arg), 0, 0)
+		if handle == 0 {
+			err = getlasterror()
+		}
+		if handle == 0 && err == windows.ERROR_ACCESS_DENIED {
+			// "Insufficient resources". Yield, then back off a bit before retrying.
+			usleep_no_g(uint32(tries) * 1000)
+			continue
+		}
+		break
+	}
+	return handle, err
 }
 
 //go:nosplit

package/bin/go/src/runtime/os_workdir_ios_arm64.go

@@ -0,0 +1,98 @@
+// 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 runtime
+
+import "unsafe"
+
+const (
+	maxPathLen             = 1024
+	_kCFStringEncodingUTF8 = 0x08000100
+)
+
+// initWorkingDir sets the current working directory to the app root on iOS.
+// By default ios/arm64 processes start in "/".
+func initWorkingDir() {
+	bundle := cfBundleGetMainBundle()
+	if bundle == 0 {
+		writeErrStr("runtime/cgo: no main bundle\n")
+		return
+	}
+	if !bundleHasInfoPlist(bundle) {
+		// Not an app bundle; keep the inherited working directory.
+		return
+	}
+	url := cfBundleCopyBundleURL(bundle)
+	if url == 0 {
+		// No app bundle URL found.
+		return
+	}
+
+	var buf [maxPathLen]byte
+	path := &buf[0]
+	ok := cfURLGetFileSystemRepresentation(url, true, path, uintptr(len(buf)))
+	cfRelease(url)
+	if !ok {
+		writeErrStr("runtime/cgo: cannot get bundle URL path\n")
+		return
+	}
+
+	if chdir(path) != 0 {
+		writeErrStr("runtime/cgo: chdir(")
+		writeErrData(path, int32(findnull(path)))
+		writeErrStr(") failed\n")
+	}
+
+	const goExecWrapperWorkingDirectoryKey = "GoExecWrapperWorkingDirectory\x00"
+	key := cfStringCreateWithCString(0, unsafe.StringData(goExecWrapperWorkingDirectoryKey), _kCFStringEncodingUTF8)
+	if key == 0 {
+		writeErrStr("runtime/cgo: cannot create GoExecWrapperWorkingDirectory string\n")
+		return
+	}
+	wd := cfBundleGetValueForInfoDictionaryKey(bundle, key)
+	cfRelease(key)
+	if wd == 0 {
+		return
+	}
+	if !cfStringGetCString(wd, path, uintptr(len(buf)), _kCFStringEncodingUTF8) {
+		writeErrStr("runtime/cgo: cannot get GoExecWrapperWorkingDirectory string\n")
+		return
+	}
+
+	if chdir(path) != 0 {
+		writeErrStr("runtime/cgo: chdir(")
+		writeErrData(path, int32(findnull(path)))
+		writeErrStr(") failed\n")
+	}
+}
+
+// bundleHasInfoPlist reports whether bundle contains an Info.plist. The main
+// bundle of an executable that is not inside an app bundle is the directory
+// holding the executable, which has no Info.plist. It can also happen on
+// Corellium virtual devices.
+func bundleHasInfoPlist(bundle uintptr) bool {
+	const (
+		infoName = "Info\x00"
+		infoType = "plist\x00"
+	)
+	name := cfStringCreateWithCString(0, unsafe.StringData(infoName), _kCFStringEncodingUTF8)
+	if name == 0 {
+		writeErrStr("runtime/cgo: cannot create Info.plist strings\n")
+		return false
+	}
+	typ := cfStringCreateWithCString(0, unsafe.StringData(infoType), _kCFStringEncodingUTF8)
+	if typ == 0 {
+		cfRelease(name)
+		writeErrStr("runtime/cgo: cannot create Info.plist strings\n")
+		return false
+	}
+	url := cfBundleCopyResourceURL(bundle, name, typ, 0)
+	cfRelease(name)
+	cfRelease(typ)
+	if url == 0 {
+		return false
+	}
+	cfRelease(url)
+	return true
+}

package/bin/go/src/runtime/os_workdir_stub.go

@@ -0,0 +1,9 @@
+// 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 && !(ios && arm64)
+
+package runtime
+
+func initWorkingDir() {}

package/bin/go/src/runtime/panic.go

@@ -791,7 +791,7 @@ type PanicNilError struct {
 	_ [0]*PanicNilError
 }
 
-func (*PanicNilError) Error() string { return "panic called with nil argument" }
+func (*PanicNilError) Error() string { return "runtime error: panic called with nil argument" }
 func (*PanicNilError) RuntimeError() {}
 
 var panicnil = &godebugInc{name: "panicnil"}
@@ -847,7 +847,6 @@ func gopanic(e any) {
 
 	var p _panic
 	p.arg = e
-	p.gopanicFP = unsafe.Pointer(sys.GetCallerSP())
 
 	runningPanicDefers.Add(1)
 
@@ -920,7 +919,7 @@ func (p *_panic) start(pc uintptr, sp unsafe.Pointer) {
 	// caller instead, we avoid needing to unwind through an extra
 	// frame. It also somewhat simplifies the terminating condition for
 	// deferreturn.
-	p.lr, p.fp = pc, sp
+	p.pc, p.sp = pc, sp
 	p.nextFrame()
 }
 
@@ -995,7 +994,7 @@ func (p *_panic) nextDefer() (func(), bool) {
 
 // nextFrame finds the next frame that contains deferred calls, if any.
 func (p *_panic) nextFrame() (ok bool) {
-	if p.lr == 0 {
+	if p.pc == 0 {
 		return false
 	}
 
@@ -1007,10 +1006,10 @@ func (p *_panic) nextFrame() (ok bool) {
 		}
 
 		var u unwinder
-		u.initAt(p.lr, uintptr(p.fp), 0, gp, 0)
+		u.initAt(p.pc, uintptr(p.sp), 0, gp, 0)
 		for {
 			if !u.valid() {
-				p.lr = 0
+				p.pc = 0
 				return // ok == false
 			}
 
@@ -1027,10 +1026,25 @@ func (p *_panic) nextFrame() (ok bool) {
 				break // found a frame with open-coded defers
 			}
 
+			if p.link != nil && uintptr(u.frame.sp) == uintptr(p.link.startSP) && uintptr(p.link.sp) > u.frame.sp {
+				// Skip ahead to where the next panic up the stack was last looking
+				// for defers. See issue 77062.
+				//
+				// The startSP condition is to check when we have walked up the stack
+				// to where the next panic up the stack started. If so, the processing
+				// of that panic has run all the defers up to its current scanning
+				// position.
+				//
+				// The final condition is just to make sure that the line below
+				// is actually helpful.
+				u.initAt(p.link.pc, uintptr(p.link.sp), 0, gp, 0)
+				continue
+			}
+
 			u.next()
 		}
 
-		p.lr = u.frame.lr
+		p.pc = u.frame.pc
 		p.sp = unsafe.Pointer(u.frame.sp)
 		p.fp = unsafe.Pointer(u.frame.fp)
 
@@ -1131,7 +1145,7 @@ func gorecover() any {
 				case abi.FuncIDWrapper:
 					continue
 				case abi.FuncID_gopanic:
-					if u.frame.fp == uintptr(p.gopanicFP) && nonWrapperFrames > 0 {
+					if u.frame.sp == uintptr(p.startSP) && nonWrapperFrames > 0 {
 						canRecover = true
 					}
 					break loop
@@ -1702,3 +1716,74 @@ func isAbortPC(pc uintptr) bool {
 	}
 	return f.funcID == abi.FuncID_abort
 }
+
+// For debugging only.
+//
+//go:noinline
+//go:nosplit
+func dumpPanicDeferState(where string, gp *g) {
+	systemstack(func() {
+		println("DUMPPANICDEFERSTATE", where)
+		p := gp._panic
+		d := gp._defer
+		var u unwinder
+		for u.init(gp, 0); u.valid(); u.next() {
+			// Print frame.
+			println("  frame sp=", hex(u.frame.sp), "fp=", hex(u.frame.fp), "pc=", pcName(u.frame.pc), "+", pcOff(u.frame.pc))
+			// Print panic.
+			for p != nil && uintptr(p.sp) == u.frame.sp {
+				println("    panic", p, "sp=", p.sp, "fp=", p.fp, "arg=", p.arg, "recovered=", p.recovered, "pc=", pcName(p.pc), "+", pcOff(p.pc), "retpc=", pcName(p.retpc), "+", pcOff(p.retpc), "startsp=", p.startSP, "startPC=", hex(p.startPC), pcName(p.startPC), "+", pcOff(p.startPC))
+				p = p.link
+			}
+
+			// Print linked defers.
+			for d != nil && d.sp == u.frame.sp {
+				println("    defer(link)", "heap=", d.heap, "rangefunc=", d.rangefunc, fnName(d.fn))
+				d = d.link
+			}
+
+			// Print open-coded defers.
+			// (A function is all linked or all open-coded, so we don't
+			// need to interleave this loop with the one above.)
+			fd := funcdata(u.frame.fn, abi.FUNCDATA_OpenCodedDeferInfo)
+			if fd != nil {
+				deferBitsOffset, fd := readvarintUnsafe(fd)
+				m := *(*uint8)(unsafe.Pointer(u.frame.varp - uintptr(deferBitsOffset)))
+				slotsOffset, fd := readvarintUnsafe(fd)
+				slots := u.frame.varp - uintptr(slotsOffset)
+				for i := 7; i >= 0; i-- {
+					if m>>i&1 == 0 {
+						continue
+					}
+					fn := *(*func())(unsafe.Pointer(slots + uintptr(i)*goarch.PtrSize))
+					println("    defer(open)", fnName(fn))
+				}
+			}
+
+		}
+		if p != nil {
+			println("  REMAINING PANICS!", p)
+		}
+		if d != nil {
+			println("  REMAINING DEFERS!")
+		}
+	})
+}
+
+func pcName(pc uintptr) string {
+	fn := findfunc(pc)
+	if !fn.valid() {
+		return "<unk>"
+	}
+	return funcname(fn)
+}
+func pcOff(pc uintptr) hex {
+	fn := findfunc(pc)
+	if !fn.valid() {
+		return 0
+	}
+	return hex(pc - fn.entry())
+}
+func fnName(fn func()) string {
+	return pcName(**(**uintptr)(unsafe.Pointer(&fn)))
+}

package/bin/go/src/runtime/plugin.go

@@ -66,9 +66,7 @@ func plugin_lastmoduleinit() (path string, syms map[string]any, initTasks []*ini
 	moduledataverify1(md)
 
 	lock(&itabLock)
-	for _, i := range md.itablinks {
-		itabAdd(i)
-	}
+	addModuleItabs(md)
 	unlock(&itabLock)
 
 	// Build a map of symbol names to symbols. Here in the runtime

package/bin/go/src/runtime/pprof/pprof.go

@@ -80,7 +80,6 @@ import (
 	"cmp"
 	"fmt"
 	"internal/abi"
-	"internal/goexperiment"
 	"internal/profilerecord"
 	"io"
 	"runtime"
@@ -257,15 +256,13 @@ func lockProfiles() {
 	if profiles.m == nil {
 		// Initial built-in profiles.
 		profiles.m = map[string]*Profile{
-			"goroutine":    goroutineProfile,
-			"threadcreate": threadcreateProfile,
-			"heap":         heapProfile,
-			"allocs":       allocsProfile,
-			"block":        blockProfile,
-			"mutex":        mutexProfile,
-		}
-		if goexperiment.GoroutineLeakProfile {
-			profiles.m["goroutineleak"] = goroutineLeakProfile
+			"goroutine":     goroutineProfile,
+			"threadcreate":  threadcreateProfile,
+			"heap":          heapProfile,
+			"allocs":        allocsProfile,
+			"block":         blockProfile,
+			"mutex":         mutexProfile,
+			"goroutineleak": goroutineLeakProfile,
 		}
 	}
 }
@@ -674,9 +671,9 @@ func writeHeapInternal(w io.Writer, debug int, defaultSampleType string) error {
 	var total runtime.MemProfileRecord
 	for i := range p {
 		r := &p[i]
-		total.AllocBytes += r.AllocBytes
+		total.AllocBytes += r.AllocObjects * r.ObjectSize
 		total.AllocObjects += r.AllocObjects
-		total.FreeBytes += r.FreeBytes
+		total.FreeBytes += r.FreeObjects * r.ObjectSize
 		total.FreeObjects += r.FreeObjects
 	}
 
@@ -706,7 +703,7 @@ func writeHeapInternal(w io.Writer, debug int, defaultSampleType string) error {
 		r := &p[i]
 		fmt.Fprintf(w, "%d: %d [%d: %d] @",
 			r.InUseObjects(), r.InUseBytes(),
-			r.AllocObjects, r.AllocBytes)
+			r.AllocObjects, r.AllocObjects*r.ObjectSize)
 		for _, pc := range r.Stack {
 			fmt.Fprintf(w, " %#x", pc)
 		}
@@ -1003,7 +1000,7 @@ func writeProfileInternal(w io.Writer, debug int, name string, runtimeProfile fu
 	}
 
 	b := bufio.NewWriter(w)
-	tw := tabwriter.NewWriter(w, 1, 8, 1, '\t', 0)
+	tw := tabwriter.NewWriter(b, 1, 8, 1, '\t', 0)
 	w = tw
 
 	fmt.Fprintf(w, "--- %v:\n", name)

package/bin/go/src/runtime/pprof/protomem.go

@@ -51,16 +51,10 @@ func writeHeapProto(w io.Writer, p []profilerecord.MemProfileRecord, rate int64,
 			hideRuntime = false // try again, and show all frames next time.
 		}
 
-		values[0], values[1] = scaleHeapSample(r.AllocObjects, r.AllocBytes, rate)
-		values[2], values[3] = scaleHeapSample(r.InUseObjects(), r.InUseBytes(), rate)
-		var blockSize int64
-		if r.AllocObjects > 0 {
-			blockSize = r.AllocBytes / r.AllocObjects
-		}
+		values[0], values[1] = scaleHeapSample(r.AllocObjects, r.ObjectSize, rate)
+		values[2], values[3] = scaleHeapSample(r.InUseObjects(), r.ObjectSize, rate)
 		b.pbSample(values, locs, func() {
-			if blockSize != 0 {
-				b.pbLabel(tagSample_Label, "bytes", "", blockSize)
-			}
+			b.pbLabel(tagSample_Label, "bytes", "", r.ObjectSize)
 		})
 	}
 	return b.build()
@@ -75,19 +69,18 @@ func writeHeapProto(w io.Writer, p []profilerecord.MemProfileRecord, rate int64,
 // which samples to collect, based on the desired average collection
 // rate R. The probability of a sample of size S to appear in that
 // profile is 1-exp(-S/R).
-func scaleHeapSample(count, size, rate int64) (int64, int64) {
-	if count == 0 || size == 0 {
+func scaleHeapSample(count, avgSize, rate int64) (int64, int64) {
+	if count == 0 || avgSize == 0 {
 		return 0, 0
 	}
 
 	if rate <= 1 {
 		// if rate==1 all samples were collected so no adjustment is needed.
 		// if rate<1 treat as unknown and skip scaling.
-		return count, size
+		return count, count * avgSize
 	}
 
-	avgSize := float64(size) / float64(count)
-	scale := 1 / (1 - math.Exp(-avgSize/float64(rate)))
+	scale := 1 / (1 - math.Exp(-float64(avgSize)/float64(rate)))
 
-	return int64(float64(count) * scale), int64(float64(size) * scale)
+	return int64(float64(count) * scale), int64(float64(count*avgSize) * scale)
 }

package/bin/go/src/runtime/preempt_loong64.s

@@ -4,8 +4,8 @@
 #include "textflag.h"
 
 TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0
-	MOVV R1, -224(R3)
-	SUBV $224, R3
+	MOVV R1, -232(R3)
+	SUBV $232, R3
 	// Save GPs
 	MOVV R4, 8(R3)
 	MOVV R5, 16(R3)
@@ -50,6 +50,8 @@ TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0
 	MOVV FCC7, R4
 	BSTRINSV $63, R4, $56, R5
 	MOVV R5, 216(R3)
+	MOVV FCSR0, R5
+	MOVV R5, 224(R3)
 	// Save extended register state to p.xRegs.scratch
 	MOVV g_m(g), R4
 	MOVV m_p(R4), R4
@@ -272,6 +274,8 @@ restoreLASX:
 	XVMOVQ 0(R4), X0
 	// Restore GPs
 restoreGPs:
+	MOVV 224(R3), R5
+	MOVV R5, FCSR0
 	MOVV 216(R3), R5
 	BSTRPICKV $7, R5, $0, R4
 	MOVV R4, FCC0
@@ -315,7 +319,7 @@ restoreGPs:
 	MOVV 24(R3), R6
 	MOVV 16(R3), R5
 	MOVV 8(R3), R4
-	MOVV 224(R3), R1
+	MOVV 232(R3), R1
 	MOVV (R3), R30
-	ADDV $232, R3
+	ADDV $240, R3
 	JMP (R30)

package/bin/go/src/runtime/preempt_noxreg.go

@@ -25,3 +25,5 @@ func xRegSave(gp *g) {}
 func xRegRestore(gp *g) {}
 
 func (*xRegPerP) free() {}
+
+func xRegScan(gp *g, gcw *gcWork, state *stackScanState) {}