@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/runtime/preempt_xreg.go

@@ -10,8 +10,8 @@
 // While asynchronous preemption stores general-purpose (GP) registers on the
 // preempted goroutine's own stack, extended register state can be used to save
 // non-GP state off the stack. In particular, this is meant for large vector
-// register files. Currently, we assume this contains only scalar data, though
-// we could change this constraint by conservatively scanning this memory.
+// register files. This memory is conservatively scanned to enable using
+// non-GP registers for operations that may involve pointers.
 //
 // For an architecture to support extended register state, it must provide a Go
 // definition of an xRegState type for storing the state, and its asyncPreempt
@@ -20,6 +20,7 @@
 package runtime
 
 import (
+	"internal/abi"
 	"internal/runtime/sys"
 	"unsafe"
 )
@@ -135,3 +136,29 @@ func (xRegs *xRegPerP) free() {
 		unlock(&xRegAlloc.lock)
 	}
 }
+
+// xRegScan conservatively scans the extended register state.
+//
+// This is supposed to be called only by scanstack when it handles async preemption.
+func xRegScan(gp *g, gcw *gcWork, state *stackScanState) {
+	// Regular async preemption always provides the extended register state.
+	if gp.xRegs.state == nil {
+		var u unwinder
+		for u.init(gp, 0); u.valid(); u.next() {
+			if u.frame.fn.valid() && u.frame.fn.funcID == abi.FuncID_debugCallV2 {
+				return
+			}
+		}
+		println("runtime: gp=", gp, ", goid=", gp.goid)
+		throw("gp.xRegs.state == nil on a scanstack attempt during async preemption")
+	}
+	b := uintptr(unsafe.Pointer(&gp.xRegs.state.regs))
+	n := uintptr(unsafe.Sizeof(gp.xRegs.state.regs))
+	if debugScanConservative {
+		print("begin scan xRegs of goroutine ", gp.goid, " at [", hex(b), ",", hex(b+n), ")\n")
+	}
+	scanConservative(b, n, nil, gcw, state)
+	if debugScanConservative {
+		print("end scan xRegs of goroutine ", gp.goid, "\n")
+	}
+}

package/bin/go/src/runtime/print.go

@@ -212,7 +212,7 @@ func printhex(v uint64) {
 func printquoted(s string) {
 	printlock()
 	gwrite([]byte(`"`))
-	for _, r := range s {
+	for i, r := range s {
 		switch r {
 		case '\n':
 			gwrite([]byte(`\n`))
@@ -227,6 +227,14 @@ func printquoted(s string) {
 		case '\\', '"':
 			gwrite([]byte{byte('\\'), byte(r)})
 			continue
+		case runeError:
+			// Distinguish errors from a valid encoding of U+FFFD.
+			if _, j := decoderune(s, uint(i)); j == uint(i+1) {
+				gwrite(bytes(`\x`))
+				printhexopts(false, 2, uint64(s[i]))
+				continue
+			}
+			// Fall through to quoting.
 		}
 		// For now, only allow basic printable ascii through unescaped
 		if r >= ' ' && r <= '~' {

package/bin/go/src/runtime/proc.go

@@ -12,6 +12,7 @@ import (
 	"internal/goos"
 	"internal/runtime/atomic"
 	"internal/runtime/exithook"
+	"internal/runtime/maps"
 	"internal/runtime/sys"
 	"internal/strconv"
 	"internal/stringslite"
@@ -127,11 +128,14 @@ var (
 // done to start up the runtime. It is built by the linker.
 var runtime_inittasks []*initTask
 
-// main_init_done is a signal used by cgocallbackg that initialization
-// has been completed. It is made before _cgo_notify_runtime_init_done,
-// so all cgo calls can rely on it existing. When main_init is complete,
-// it is closed, meaning cgocallbackg can reliably receive from it.
-var main_init_done chan bool
+// mainInitDone is a signal used by cgocallbackg that initialization
+// has been completed. If this is false, wait on mainInitDoneChan.
+var mainInitDone atomic.Bool
+
+// mainInitDoneChan is closed after initialization has been completed.
+// It is made before _cgo_notify_runtime_init_done, so all cgo
+// calls can rely on it existing.
+var mainInitDoneChan chan bool
 
 //go:linkname main_main main.main
 func main_main()
@@ -213,16 +217,23 @@ func main() {
 	gcenable()
 	defaultGOMAXPROCSUpdateEnable() // don't STW before runtime initialized.
 
-	main_init_done = make(chan bool)
+	// If we encountered a removed GODEBUG during startup we can panic now.
+	if k := invalidGODEBUG.key; k != "" {
+		v := invalidGODEBUG.value
+		r := strconv.Itoa(invalidGODEBUG.removed)
+		fatal(`removed GODEBUG "` + k + `" set to old value "` + v + `" in environment (https://go.dev/doc/godebug#go-1` + r + `)`)
+	}
+
+	mainInitDoneChan = make(chan bool)
 	if iscgo {
 		if _cgo_pthread_key_created == nil {
 			throw("_cgo_pthread_key_created missing")
 		}
 
-		if _cgo_thread_start == nil {
-			throw("_cgo_thread_start missing")
-		}
 		if GOOS != "windows" {
+			if _cgo_thread_start == nil {
+				throw("_cgo_thread_start missing")
+			}
 			if _cgo_setenv == nil {
 				throw("_cgo_setenv missing")
 			}
@@ -265,7 +276,8 @@ func main() {
 	// of collecting statistics in malloc and newproc
 	inittrace.active = false
 
-	close(main_init_done)
+	mainInitDone.Store(true)
+	close(mainInitDoneChan)
 
 	needUnlock = false
 	unlockOSThread()
@@ -778,6 +790,7 @@ func cpuinit(env string) {
 	case "loong64":
 		loong64HasLAMCAS = cpu.Loong64.HasLAMCAS
 		loong64HasLAM_BH = cpu.Loong64.HasLAM_BH
+		loong64HasDBAR_HINTS = cpu.Loong64.HasDBAR_HINTS
 		loong64HasLSX = cpu.Loong64.HasLSX
 
 	case "riscv64":
@@ -873,10 +886,10 @@ func schedinit() {
 	ticks.init() // run as early as possible
 	moduledataverify()
 	stackinit()
-	randinit() // must run before mallocinit, alginit, mcommoninit
+	randinit() // must run before mallocinit, AlgInit, mcommoninit
 	mallocinit()
-	cpuinit(godebug) // must run before alginit
-	alginit()        // maps, hash, rand must not be used before this call
+	cpuinit(godebug) // must run before AlgInit
+	maps.AlgInit()   // maps, hash, rand must not be used before this call
 	mcommoninit(gp.m, -1)
 	modulesinit()   // provides activeModules
 	typelinksinit() // uses maps, activeModules
@@ -1964,6 +1977,11 @@ func mstartm0() {
 //go:nosplit
 func mPark() {
 	gp := getg()
+	// This M might stay parked through an entire GC cycle.
+	// Erase any leftovers on the signal stack.
+	if goexperiment.RuntimeSecret {
+		eraseSecretsSignalStk()
+	}
 	notesleep(&gp.m.park)
 	noteclear(&gp.m.park)
 }
@@ -2904,11 +2922,8 @@ func newm(fn func(), pp *p, id int64) {
 }
 
 func newm1(mp *m) {
-	if iscgo {
+	if iscgo && _cgo_thread_start != nil {
 		var ts cgothreadstart
-		if _cgo_thread_start == nil {
-			throw("_cgo_thread_start missing")
-		}
 		ts.g.set(mp.g0)
 		ts.tls = (*uint64)(unsafe.Pointer(&mp.tls[0]))
 		ts.fn = unsafe.Pointer(abi.FuncPCABI0(mstart))
@@ -4631,6 +4646,30 @@ func reentersyscall(pc, sp, bp uintptr) {
 	// but can have inconsistent g->sched, do not let GC observe it.
 	gp.m.locks++
 
+	// This M may have a signal stack that is dirtied with secret information
+	// (see package "runtime/secret"). Since it's about to go into a syscall for
+	// an arbitrary amount of time and the G that put the secret info there
+	// might have returned from secret.Do, we have to zero it out now, lest we
+	// break the guarantee that secrets are purged by the next GC after a return
+	// to secret.Do.
+	//
+	// It might be tempting to think that we only need to zero out this if we're
+	// not running in secret mode anymore, but that leaves an ABA problem. The G
+	// that put the secrets onto our signal stack may not be the one that is
+	// currently executing.
+	//
+	// Logically, we should erase this when we lose our P, not when we enter the
+	// syscall. This would avoid a zeroing in the case where the call returns
+	// almost immediately. Since we use this path for cgo calls as well, these
+	// fast "syscalls" are quite common. However, since we only erase the signal
+	// stack if we were delivered a signal in secret mode and considering the
+	// cross-thread synchronization cost for the P, it hardly seems worth it.
+	//
+	// TODO(dmo): can we encode the goid into mp.signalSecret and avoid the ABA problem?
+	if goexperiment.RuntimeSecret {
+		eraseSecretsSignalStk()
+	}
+
 	// Entersyscall must not call any function that might split/grow the stack.
 	// (See details in comment above.)
 	// Catch calls that might, by replacing the stack guard with something that
@@ -5410,6 +5449,18 @@ func newproc1(fn *funcval, callergp *g, callerpc uintptr, parked bool, waitreaso
 	// dit bubble
 	newg.ditWanted = callergp.ditWanted
 
+	if goexperiment.RuntimeSecret && callergp.secret > 0 {
+		// while it might seem weird to have a non-zero gp.secret value
+		// with no calls to secret.Do on the stack, this case is handled
+		// just fine by the cleanup logic in goexit0
+		// TODO: secret mode is invisible to the user if they don't ask about it via secret.Enabled
+		// and can have severe performance penalties (at time of writing, wrapping the entire
+		// tls handshake resulted in a 30% slowdown of the benchmarks).
+		// Whether a goroutine is running in secret mode should be more visible,
+		// maybe with a stack frame or some sort of bubble inspecting mechanism
+		newg.secret = 1
+	}
+
 	// Set up race context.
 	if raceenabled {
 		newg.racectx = racegostart(callerpc)

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

@@ -7,6 +7,7 @@
 #include "go_asm.h"
 #include "funcdata.h"
 #include "textflag.h"
+#include "cgo/abi_riscv64.h"
 
 // The following thunks allow calling the gcc-compiled race runtime directly
 // from Go code without going all the way through cgo.
@@ -27,7 +28,7 @@
 // Called from instrumented code.
 TEXT	runtime·raceread<ABIInternal>(SB), NOSPLIT, $0-8
 	// void __tsan_read(ThreadState *thr, void *addr, void *pc);
-	MOV	$__tsan_read(SB), X5
+	MOV	$__tsan_read(SB), X23
 	MOV	X10, X11
 	MOV	X1, X12
 	JMP	racecalladdr<>(SB)
@@ -40,7 +41,7 @@ TEXT	runtime·RaceRead(SB), NOSPLIT, $0-8
 // func runtime·racereadpc(void *addr, void *callpc, void *pc)
 TEXT	runtime·racereadpc(SB), NOSPLIT, $0-24
 	// void __tsan_read_pc(ThreadState *thr, void *addr, void *callpc, void *pc);
-	MOV	$__tsan_read_pc(SB), X5
+	MOV	$__tsan_read_pc(SB), X23
 	MOV	addr+0(FP), X11
 	MOV	callpc+8(FP), X12
 	MOV	pc+16(FP), X13
@@ -50,7 +51,7 @@ TEXT	runtime·racereadpc(SB), NOSPLIT, $0-24
 // Called from instrumented code.
 TEXT	runtime·racewrite<ABIInternal>(SB), NOSPLIT, $0-8
 	// void __tsan_write(ThreadState *thr, void *addr, void *pc);
-	MOV	$__tsan_write(SB), X5
+	MOV	$__tsan_write(SB), X23
 	MOV	X10, X11
 	MOV	X1, X12
 	JMP	racecalladdr<>(SB)
@@ -63,7 +64,7 @@ TEXT	runtime·RaceWrite(SB), NOSPLIT, $0-8
 // func runtime·racewritepc(void *addr, void *callpc, void *pc)
 TEXT	runtime·racewritepc(SB), NOSPLIT, $0-24
 	// void __tsan_write_pc(ThreadState *thr, void *addr, void *callpc, void *pc);
-	MOV	$__tsan_write_pc(SB), X5
+	MOV	$__tsan_write_pc(SB), X23
 	MOV	addr+0(FP), X11
 	MOV	callpc+8(FP), X12
 	MOV	pc+16(FP), X13
@@ -73,7 +74,7 @@ TEXT	runtime·racewritepc(SB), NOSPLIT, $0-24
 // Called from instrumented code.
 TEXT	runtime·racereadrange<ABIInternal>(SB), NOSPLIT, $0-16
 	// void __tsan_read_range(ThreadState *thr, void *addr, uintptr size, void *pc);
-	MOV	$__tsan_read_range(SB), X5
+	MOV	$__tsan_read_range(SB), X23
 	MOV	X11, X12
 	MOV	X10, X11
 	MOV	X1, X13
@@ -87,7 +88,7 @@ TEXT	runtime·RaceReadRange(SB), NOSPLIT, $0-16
 // func runtime·racereadrangepc1(void *addr, uintptr sz, void *pc)
 TEXT	runtime·racereadrangepc1(SB), NOSPLIT, $0-24
 	// void __tsan_read_range(ThreadState *thr, void *addr, uintptr size, void *pc);
-	MOV	$__tsan_read_range(SB), X5
+	MOV	$__tsan_read_range(SB), X23
 	MOV	addr+0(FP), X11
 	MOV	size+8(FP), X12
 	MOV	pc+16(FP), X13
@@ -101,7 +102,7 @@ TEXT	runtime·racereadrangepc1(SB), NOSPLIT, $0-24
 // Called from instrumented code.
 TEXT	runtime·racewriterange<ABIInternal>(SB), NOSPLIT, $0-16
 	// void __tsan_write_range(ThreadState *thr, void *addr, uintptr size, void *pc);
-	MOV	$__tsan_write_range(SB), X5
+	MOV	$__tsan_write_range(SB), X23
 	MOV	X11, X12
 	MOV	X10, X11
 	MOV	X1, X13
@@ -115,7 +116,7 @@ TEXT	runtime·RaceWriteRange(SB), NOSPLIT, $0-16
 // func runtime·racewriterangepc1(void *addr, uintptr sz, void *pc)
 TEXT	runtime·racewriterangepc1(SB), NOSPLIT, $0-24
 	// void __tsan_write_range(ThreadState *thr, void *addr, uintptr size, void *pc);
-	MOV	$__tsan_write_range(SB), X5
+	MOV	$__tsan_write_range(SB), X23
 	MOV	addr+0(FP), X11
 	MOV	size+8(FP), X12
 	MOV	pc+16(FP), X13
@@ -145,7 +146,7 @@ ret:
 // func runtime·racefuncenter(pc uintptr)
 // Called from instrumented code.
 TEXT	runtime·racefuncenter<ABIInternal>(SB), NOSPLIT, $0-8
-	MOV	$__tsan_func_enter(SB), X5
+	MOV	$__tsan_func_enter(SB), X23
 	MOV	X10, X11
 	MOV	g_racectx(g), X10
 	JMP	racecall<>(SB)
@@ -154,7 +155,7 @@ TEXT	runtime·racefuncenter<ABIInternal>(SB), NOSPLIT, $0-8
 // X1 = caller's return address
 TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 	// void __tsan_func_enter(ThreadState *thr, void *pc);
-	MOV	$__tsan_func_enter(SB), X5
+	MOV	$__tsan_func_enter(SB), X23
 	MOV	g_racectx(g), X10
 	MOV	X1, X11
 	JMP	racecall<>(SB)
@@ -163,7 +164,7 @@ TEXT	racefuncenter<>(SB), NOSPLIT, $0-0
 // Called from instrumented code.
 TEXT	runtime·racefuncexit<ABIInternal>(SB), NOSPLIT, $0-0
 	// void __tsan_func_exit(ThreadState *thr);
-	MOV	$__tsan_func_exit(SB), X5
+	MOV	$__tsan_func_exit(SB), X23
 	MOV	g_racectx(g), X10
 	JMP	racecall<>(SB)
 
@@ -173,13 +174,13 @@ TEXT	runtime·racefuncexit<ABIInternal>(SB), NOSPLIT, $0-0
 
 TEXT	sync∕atomic·LoadInt32(SB), NOSPLIT, $0-12
 	GO_ARGS
-	MOV	$__tsan_go_atomic32_load(SB), X5
+	MOV	$__tsan_go_atomic32_load(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
 TEXT	sync∕atomic·LoadInt64(SB), NOSPLIT, $0-16
 	GO_ARGS
-	MOV	$__tsan_go_atomic64_load(SB), X5
+	MOV	$__tsan_go_atomic64_load(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
@@ -203,13 +204,13 @@ TEXT	sync∕atomic·LoadPointer(SB), NOSPLIT, $0-16
 
 TEXT	sync∕atomic·StoreInt32(SB), NOSPLIT, $0-12
 	GO_ARGS
-	MOV	$__tsan_go_atomic32_store(SB), X5
+	MOV	$__tsan_go_atomic32_store(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
 TEXT	sync∕atomic·StoreInt64(SB), NOSPLIT, $0-16
 	GO_ARGS
-	MOV	$__tsan_go_atomic64_store(SB), X5
+	MOV	$__tsan_go_atomic64_store(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
@@ -229,13 +230,13 @@ TEXT	sync∕atomic·StoreUintptr(SB), NOSPLIT, $0-16
 
 TEXT	sync∕atomic·SwapInt32(SB), NOSPLIT, $0-20
 	GO_ARGS
-	MOV	$__tsan_go_atomic32_exchange(SB), X5
+	MOV	$__tsan_go_atomic32_exchange(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
 TEXT	sync∕atomic·SwapInt64(SB), NOSPLIT, $0-24
 	GO_ARGS
-	MOV	$__tsan_go_atomic64_exchange(SB), X5
+	MOV	$__tsan_go_atomic64_exchange(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
@@ -255,7 +256,7 @@ TEXT	sync∕atomic·SwapUintptr(SB), NOSPLIT, $0-24
 
 TEXT	sync∕atomic·AddInt32(SB), NOSPLIT, $0-20
 	GO_ARGS
-	MOV	$__tsan_go_atomic32_fetch_add(SB), X5
+	MOV	$__tsan_go_atomic32_fetch_add(SB), X23
 	CALL	racecallatomic<>(SB)
 	// TSan performed fetch_add, but Go needs add_fetch.
 	MOVW	add+8(FP), X5
@@ -266,7 +267,7 @@ TEXT	sync∕atomic·AddInt32(SB), NOSPLIT, $0-20
 
 TEXT	sync∕atomic·AddInt64(SB), NOSPLIT, $0-24
 	GO_ARGS
-	MOV	$__tsan_go_atomic64_fetch_add(SB), X5
+	MOV	$__tsan_go_atomic64_fetch_add(SB), X23
 	CALL	racecallatomic<>(SB)
 	// TSan performed fetch_add, but Go needs add_fetch.
 	MOV	add+8(FP), X5
@@ -290,13 +291,13 @@ TEXT	sync∕atomic·AddUintptr(SB), NOSPLIT, $0-24
 // And
 TEXT	sync∕atomic·AndInt32(SB), NOSPLIT, $0-20
 	GO_ARGS
-	MOV	$__tsan_go_atomic32_fetch_and(SB), X5
+	MOV	$__tsan_go_atomic32_fetch_and(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
 TEXT	sync∕atomic·AndInt64(SB), NOSPLIT, $0-24
 	GO_ARGS
-	MOV	$__tsan_go_atomic64_fetch_and(SB), X5
+	MOV	$__tsan_go_atomic64_fetch_and(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
@@ -315,13 +316,13 @@ TEXT	sync∕atomic·AndUintptr(SB), NOSPLIT, $0-24
 // Or
 TEXT	sync∕atomic·OrInt32(SB), NOSPLIT, $0-20
 	GO_ARGS
-	MOV	$__tsan_go_atomic32_fetch_or(SB), X5
+	MOV	$__tsan_go_atomic32_fetch_or(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
 TEXT	sync∕atomic·OrInt64(SB), NOSPLIT, $0-24
 	GO_ARGS
-	MOV	$__tsan_go_atomic64_fetch_or(SB), X5
+	MOV	$__tsan_go_atomic64_fetch_or(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
@@ -341,13 +342,13 @@ TEXT	sync∕atomic·OrUintptr(SB), NOSPLIT, $0-24
 
 TEXT	sync∕atomic·CompareAndSwapInt32(SB), NOSPLIT, $0-17
 	GO_ARGS
-	MOV	$__tsan_go_atomic32_compare_exchange(SB), X5
+	MOV	$__tsan_go_atomic32_compare_exchange(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
 TEXT	sync∕atomic·CompareAndSwapInt64(SB), NOSPLIT, $0-25
 	GO_ARGS
-	MOV	$__tsan_go_atomic64_compare_exchange(SB), X5
+	MOV	$__tsan_go_atomic64_compare_exchange(SB), X23
 	CALL	racecallatomic<>(SB)
 	RET
 
@@ -364,7 +365,7 @@ TEXT	sync∕atomic·CompareAndSwapUintptr(SB), NOSPLIT, $0-25
 	JMP	sync∕atomic·CompareAndSwapInt64(SB)
 
 // Generic atomic operation implementation.
-// X5 = addr of target function
+// X23 = addr of target function
 TEXT	racecallatomic<>(SB), NOSPLIT, $0
 	// Set up these registers
 	// X10 = *ThreadState
@@ -398,11 +399,11 @@ racecallatomic_ignore:
 	// Call __tsan_go_ignore_sync_begin to ignore synchronization during the atomic op.
 	// An attempt to synchronize on the address would cause crash.
 	MOV	X1, X20			// save PC
-	MOV	X5, X21			// save target function
-	MOV	$__tsan_go_ignore_sync_begin(SB), X5
+	MOV	X23, X21			// save target function
+	MOV	$__tsan_go_ignore_sync_begin(SB), X23
 	MOV	g_racectx(g), X10	// goroutine context
 	CALL	racecall<>(SB)
-	MOV	X21, X5			// restore the target function
+	MOV	X21, X23			// restore the target function
 	// Call the atomic function.
 	MOV	g_racectx(g), X10	// goroutine context
 	MOV	8(X2), X11		// caller pc
@@ -410,7 +411,7 @@ racecallatomic_ignore:
 	ADD	$24, X2, X13		// arguments
 	CALL	racecall<>(SB)
 	// Call __tsan_go_ignore_sync_end.
-	MOV	$__tsan_go_ignore_sync_end(SB), X5
+	MOV	$__tsan_go_ignore_sync_end(SB), X23
 	MOV	g_racectx(g), X10	// goroutine context
 	CALL	racecall<>(SB)
 	RET
@@ -420,14 +421,14 @@ racecallatomic_ignore:
 // The arguments are never heap-object-preserving pointers, so we pretend there
 // are no arguments.
 TEXT	runtime·racecall(SB), NOSPLIT, $0-0
-	MOV	fn+0(FP), X5
+	MOV	fn+0(FP), X23
 	MOV	arg0+8(FP), X10
 	MOV	arg1+16(FP), X11
 	MOV	arg2+24(FP), X12
 	MOV	arg3+32(FP), X13
 	JMP	racecall<>(SB)
 
-// Switches SP to g0 stack and calls X5. Arguments are already set.
+// Switches SP to g0 stack and calls X23. Arguments are already set.
 TEXT	racecall<>(SB), NOSPLIT|NOFRAME, $0-0
 	MOV	X1, X18				// Save RA in callee save register
 	MOV	X2, X19				// Save SP in callee save register
@@ -443,7 +444,7 @@ TEXT	racecall<>(SB), NOSPLIT|NOFRAME, $0-0
 
 	MOV	(g_sched+gobuf_sp)(X7), X2	// Switch to g0 stack
 call:
-	JALR	RA, (X5)			// Call C function
+	JALR	RA, (X23)			// Call C function
 	MOV	X19, X2				// Restore SP
 	JMP	(X18)				// Return to Go.
 
@@ -458,7 +459,7 @@ TEXT	runtime·racecallbackthunk(SB), NOSPLIT|NOFRAME, $0
 	// can be executed on g0. Second, it is called frequently, so will
 	// benefit from this fast path.
 	BNEZ	X10, rest
-	MOV	X1, X5
+	MOV	X1, X23
 	MOV	g, X6
 	CALL	runtime·load_g(SB)
 	MOV	g_m(g), X7
@@ -466,37 +467,15 @@ TEXT	runtime·racecallbackthunk(SB), NOSPLIT|NOFRAME, $0
 	MOV	p_raceprocctx(X7), X7
 	MOV	X7, (X11)
 	MOV	X6, g
-	JMP	(X5)
+	JMP	(X23)
 rest:
 	// Save callee-save registers (X8, X9, X18..X27, F8, F9, F18..F27),
 	// since Go code will not respect this.
 	// 8(X2) and 16(X2) are for args passed to racecallback
 	SUB	$(27*8), X2
 	MOV	X1, (0*8)(X2)
-	MOV	X8, (3*8)(X2)
-	MOV	X9, (4*8)(X2)
-	MOV	X18, (5*8)(X2)
-	MOV	X19, (6*8)(X2)
-	MOV	X20, (7*8)(X2)
-	MOV	X21, (8*8)(X2)
-	MOV	X22, (9*8)(X2)
-	MOV	X23, (10*8)(X2)
-	MOV	X24, (11*8)(X2)
-	MOV	X25, (12*8)(X2)
-	MOV	X26, (13*8)(X2)
-	MOV	g, (14*8)(X2)
-	MOVD	F8, (15*8)(X2)
-	MOVD	F9, (16*8)(X2)
-	MOVD	F18, (17*8)(X2)
-	MOVD	F19, (18*8)(X2)
-	MOVD	F20, (19*8)(X2)
-	MOVD	F21, (20*8)(X2)
-	MOVD	F22, (21*8)(X2)
-	MOVD	F23, (22*8)(X2)
-	MOVD	F24, (23*8)(X2)
-	MOVD	F25, (24*8)(X2)
-	MOVD	F26, (25*8)(X2)
-	MOVD	F27, (26*8)(X2)
+	SAVE_GPR((3*8))
+	SAVE_FPR((15*8))
 
 	// Set g = g0.
 	CALL	runtime·load_g(SB)
@@ -515,30 +494,8 @@ rest:
 ret:
 	// Restore callee-save registers.
 	MOV	(0*8)(X2), X1
-	MOV	(3*8)(X2), X8
-	MOV	(4*8)(X2), X9
-	MOV	(5*8)(X2), X18
-	MOV	(6*8)(X2), X19
-	MOV	(7*8)(X2), X20
-	MOV	(8*8)(X2), X21
-	MOV	(9*8)(X2), X22
-	MOV	(10*8)(X2), X23
-	MOV	(11*8)(X2), X24
-	MOV	(12*8)(X2), X25
-	MOV	(13*8)(X2), X26
-	MOV	(14*8)(X2), g
-	MOVD	(15*8)(X2), F8
-	MOVD	(16*8)(X2), F9
-	MOVD	(17*8)(X2), F18
-	MOVD	(18*8)(X2), F19
-	MOVD	(19*8)(X2), F20
-	MOVD	(20*8)(X2), F21
-	MOVD	(21*8)(X2), F22
-	MOVD	(22*8)(X2), F23
-	MOVD	(23*8)(X2), F24
-	MOVD	(24*8)(X2), F25
-	MOVD	(25*8)(X2), F26
-	MOVD	(26*8)(X2), F27
+	RESTORE_GPR((3*8))
+	RESTORE_FPR((15*8))
 
 	ADD	$(27*8), X2
 	JMP	(X1)

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

@@ -28,11 +28,7 @@
 TEXT	runtime·raceread<ABIInternal>(SB), NOSPLIT, $0-8
 	// void __tsan_read(ThreadState *thr, void *addr, void *pc);
 	MOVD	$__tsan_read(SB), R1
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	addr+0(FP), R3
-#else
 	MOVD	R2, R3
-#endif
 	MOVD	R14, R4
 	JMP	racecalladdr<>(SB)
 
@@ -53,11 +49,7 @@ TEXT	runtime·racereadpc(SB), NOSPLIT, $0-24
 TEXT	runtime·racewrite<ABIInternal>(SB), NOSPLIT, $0-8
 	// void __tsan_write(ThreadState *thr, void *addr, void *pc);
 	MOVD	$__tsan_write(SB), R1
-#ifndef GOEXPERIMENT_regabiargs
-	MOVD	addr+0(FP), R3
-#else
 	MOVD	R2, R3
-#endif
 	MOVD	R14, R4
 	JMP	racecalladdr<>(SB)
 
@@ -78,12 +70,8 @@ TEXT	runtime·racewritepc(SB), NOSPLIT, $0-24
 TEXT	runtime·racereadrange<ABIInternal>(SB), NOSPLIT, $0-16
 	// void __tsan_read_range(ThreadState *thr, void *addr, uintptr size, void *pc);
 	MOVD	$__tsan_read_range(SB), R1
-#ifndef GOEXPERIMENT_regabiargs
-	LMG	addr+0(FP), R3, R4
-#else
 	MOVD	R3, R4
 	MOVD	R2, R3
-#endif
 	MOVD	R14, R5
 	JMP	racecalladdr<>(SB)
 
@@ -107,12 +95,8 @@ TEXT	runtime·racereadrangepc1(SB), NOSPLIT, $0-24
 TEXT	runtime·racewriterange<ABIInternal>(SB), NOSPLIT, $0-16
 	// void __tsan_write_range(ThreadState *thr, void *addr, uintptr size, void *pc);
 	MOVD	$__tsan_write_range(SB), R1
-#ifndef GOEXPERIMENT_regabiargs
-	LMG	addr+0(FP), R3, R4
-#else
 	MOVD	R3, R4
 	MOVD	R2, R3
-#endif
 	MOVD	R14, R5
 	JMP	racecalladdr<>(SB)