@ttsc/win32-arm64 0.33.1 → 0.34.0

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

@@ -205,7 +205,6 @@ TEXT runtime·mincore<ABIInternal>(SB),NOSPLIT,$0
 // func walltime() (sec int64, nsec int32)
 TEXT runtime·walltime<ABIInternal>(SB),NOSPLIT,$24
 	MOVV	R3, R23	// R23 is unchanged by C code
-	MOVV	R3, R25
 
 	MOVV	g_m(g), R24	// R24 = m
 
@@ -222,16 +221,14 @@ TEXT runtime·walltime<ABIInternal>(SB),NOSPLIT,$24
 	MOVV	R11, m_vdsoSP(R24)
 
 	MOVV	m_curg(R24), R4
-	MOVV	g, R5
-	BNE	R4, R5, noswitch
+	BNE	R4, g, noswitch
 
 	MOVV	m_g0(R24), R4
-	MOVV	(g_sched+gobuf_sp)(R4), R25	// Set SP to g0 stack
+	MOVV	(g_sched+gobuf_sp)(R4), R3	// Set SP to g0 stack
 
 noswitch:
-	SUBV	$16, R25
-	AND	$~15, R25	// Align for C code
-	MOVV	R25, R3
+	SUBV	$16, R3
+	AND	$~15, R3	// Align for C code
 
 	MOVW	$CLOCK_REALTIME, R4
 	MOVV	$0(R3), R5
@@ -283,7 +280,6 @@ fallback:
 // func nanotime1() int64
 TEXT runtime·nanotime1<ABIInternal>(SB),NOSPLIT,$24
 	MOVV	R3, R23	// R23 is unchanged by C code
-	MOVV	R3, R25
 
 	MOVV	g_m(g), R24	// R24 = m
 
@@ -300,16 +296,14 @@ TEXT runtime·nanotime1<ABIInternal>(SB),NOSPLIT,$24
 	MOVV	R11, m_vdsoSP(R24)
 
 	MOVV	m_curg(R24), R4
-	MOVV	g, R5
-	BNE	R4, R5, noswitch
+	BNE	R4, g, noswitch
 
 	MOVV	m_g0(R24), R4
-	MOVV	(g_sched+gobuf_sp)(R4), R25	// Set SP to g0 stack
+	MOVV	(g_sched+gobuf_sp)(R4), R3	// Set SP to g0 stack
 
 noswitch:
-	SUBV	$16, R25
-	AND	$~15, R25	// Align for C code
-	MOVV	R25, R3
+	SUBV	$16, R3
+	AND	$~15, R3	// Align for C code
 
 	MOVW	$CLOCK_MONOTONIC, R4
 	MOVV	$0(R3), R5

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

@@ -417,7 +417,6 @@ TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36
 	MOVW	R3, ret+32(FP)
 	RET
 
-#ifdef GOARCH_ppc64le
 // Call the function stored in _cgo_sigaction using the GCC calling convention.
 TEXT runtime·callCgoSigaction(SB),NOSPLIT,$0
 	MOVD    sig+0(FP), R3
@@ -435,7 +434,6 @@ TEXT runtime·callCgoSigaction(SB),NOSPLIT,$0
 	MOVD    24(R1), R2              // Restore R2
 	MOVW    R3, ret+24(FP)          // Return result
 	RET
-#endif
 
 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 	MOVW	sig+8(FP), R3
@@ -447,13 +445,6 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 	MOVD	24(R1), R2
 	RET
 
-#ifdef GO_PPC64X_HAS_FUNCDESC
-DEFINE_PPC64X_FUNCDESC(runtime·sigtramp, sigtramp<>)
-// cgo isn't supported on ppc64, but we need to supply a cgoSigTramp function.
-DEFINE_PPC64X_FUNCDESC(runtime·cgoSigtramp, sigtramp<>)
-TEXT sigtramp<>(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
-#else
-// ppc64le doesn't need function descriptors
 // Save callee-save registers in the case of signal forwarding.
 // Same as on ARM64 https://golang.org/issue/31827 .
 //
@@ -461,7 +452,6 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME|TOPFRAME,$0
 // a function pointer) as R2 may not be preserved when calling this
 // function. In those cases, the caller preserves their R2.
 TEXT runtime·sigtramp(SB),NOSPLIT|NOFRAME,$0
-#endif
 	// This is called with ELF calling conventions. Convert to Go.
 	// Allocate space for argument storage to call runtime.sigtrampgo.
 	STACK_AND_SAVE_HOST_TO_GO_ABI(32)
@@ -488,7 +478,6 @@ TEXT runtime·sigtramp(SB),NOSPLIT|NOFRAME,$0
 	UNSTACK_AND_RESTORE_GO_TO_HOST_ABI(32)
 	RET
 
-#ifdef GOARCH_ppc64le
 TEXT runtime·cgoSigtramp(SB),NOSPLIT|NOFRAME,$0
 	// The stack unwinder, presumably written in C, may not be able to
 	// handle Go frame correctly. So, this function is NOFRAME, and we
@@ -583,7 +572,6 @@ sigtrampnog:
 	MOVD	R12, CTR
 	MOVD	R10, LR // restore LR
 	JMP	(CTR)
-#endif
 
 // Used by cgoSigtramp to inspect without clobbering R30/R31 via runtime.load_g.
 GLOBL runtime·tls_g+0(SB), TLSBSS+DUPOK, $8

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

@@ -60,9 +60,9 @@ TEXT runtime·exit<ABIInternal>(SB),NOSPLIT,$0
 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8
 	MOV	wait+0(FP), A0
 	// We're done using the stack.
-	FENCE
+	FENCE	RW, W
 	MOVW	ZERO, (A0)
-	FENCE
+	FENCE	RW, RW
 	MOV	$0, A0	// exit code
 	MOV	$SYS_exit, A7
 	ECALL

package/bin/go/src/runtime/sys_openbsd.go

@@ -85,7 +85,7 @@ func sched_yield_trampoline()
 
 //go:nosplit
 func osyield_no_g() {
-	asmcgocall_no_g(unsafe.Pointer(abi.FuncPCABI0(sched_yield_trampoline)), unsafe.Pointer(nil))
+	asmcgocall(unsafe.Pointer(abi.FuncPCABI0(sched_yield_trampoline)), unsafe.Pointer(nil))
 }
 
 // This is exported via linkname to assembly in runtime/cgo.

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

@@ -89,8 +89,8 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
 	MOVW	sig+8(FP), X10
 	MOV	info+16(FP), X11
 	MOV	ctx+24(FP), X12
-	MOV	fn+0(FP), X5
-	JALR	X1, X5
+	MOV	fn+0(FP), X6
+	JALR	X1, X6
 	RET
 
 TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$224
@@ -127,8 +127,8 @@ TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$224
 	MOVW	X10, 8(X2)
 	MOV	X11, 16(X2)
 	MOV	X12, 24(X2)
-	MOV	$runtime·sigtrampgo(SB), X5
-	JALR	X1, X5
+	MOV	$runtime·sigtrampgo(SB), X6
+	JALR	X1, X6
 
 	// Restore callee-save registers.
 	MOV	(4*8)(X2), X8
@@ -458,13 +458,13 @@ TEXT runtime·issetugid_trampoline(SB),NOSPLIT,$0
 TEXT runtime·syscall(SB),NOSPLIT,$8
 	MOV	X10, X9			// pointer to args
 
-	MOV	(0*8)(X9), X5		// fn
+	MOV	(0*8)(X9), X6		// fn
 	MOV	(1*8)(X9), X10		// a1
 	MOV	(2*8)(X9), X11		// a2
 	MOV	(3*8)(X9), X12		// a3
 	MOV	$0, X13			// vararg
 
-	JALR	X1, X5
+	JALR	X1, X6
 
 	MOV	X10, (4*8)(X9)		// r1
 	MOV	X11, (5*8)(X9)		// r2
@@ -502,13 +502,13 @@ ok:
 TEXT runtime·syscallX(SB),NOSPLIT,$8
 	MOV	X10, X9			// pointer to args
 
-	MOV	(0*8)(X9), X5		// fn
+	MOV	(0*8)(X9), X6		// fn
 	MOV	(1*8)(X9), X10		// a1
 	MOV	(2*8)(X9), X11		// a2
 	MOV	(3*8)(X9), X12		// a3
 	MOV	$0, X13			// vararg
 
-	JALR	X1, X5
+	JALR	X1, X6
 
 	MOV	X10, (4*8)(X9)		// r1
 	MOV	X11, (5*8)(X9)		// r2
@@ -548,7 +548,7 @@ ok:
 TEXT runtime·syscall6(SB),NOSPLIT,$8
 	MOV	X10, X9			// pointer to args
 
-	MOV	(0*8)(X9), X5		// fn
+	MOV	(0*8)(X9), X6		// fn
 	MOV	(1*8)(X9), X10		// a1
 	MOV	(2*8)(X9), X11		// a2
 	MOV	(3*8)(X9), X12		// a3
@@ -557,7 +557,7 @@ TEXT runtime·syscall6(SB),NOSPLIT,$8
 	MOV	(6*8)(X9), X15		// a6
 	MOV	$0, X16			// vararg
 
-	JALR	X1, X5
+	JALR	X1, X6
 
 	MOV	X10, (7*8)(X9)		// r1
 	MOV	X11, (8*8)(X9)		// r2
@@ -598,7 +598,7 @@ ok:
 TEXT runtime·syscall6X(SB),NOSPLIT,$8
 	MOV	X10, X9			// pointer to args
 
-	MOV	(0*8)(X9), X5		// fn
+	MOV	(0*8)(X9), X6		// fn
 	MOV	(1*8)(X9), X10		// a1
 	MOV	(2*8)(X9), X11		// a2
 	MOV	(3*8)(X9), X12		// a3
@@ -607,7 +607,7 @@ TEXT runtime·syscall6X(SB),NOSPLIT,$8
 	MOV	(6*8)(X9), X15		// a6
 	MOV	$0, X16			// vararg
 
-	JALR	X1, X5
+	JALR	X1, X6
 
 	MOV	X10, (7*8)(X9)		// r1
 	MOV	X11, (8*8)(X9)		// r2
@@ -652,7 +652,7 @@ TEXT runtime·syscall10(SB),NOSPLIT,$0
 
 	ADD	$-16, X2
 
-	MOV	(0*8)(X9), X5		// fn
+	MOV	(0*8)(X9), X6		// fn
 	MOV	(1*8)(X9), X10		// a1
 	MOV	(2*8)(X9), X11		// a2
 	MOV	(3*8)(X9), X12		// a3
@@ -662,7 +662,7 @@ TEXT runtime·syscall10(SB),NOSPLIT,$0
 	MOV	(7*8)(X9), X16		// a7
 	MOV	(8*8)(X9), X17		// a8
 
-	JALR	X1, X5
+	JALR	X1, X6
 
 	MOV	X10, (11*8)(X9)		// r1
 	MOV	X11, (12*8)(X9)		// r2
@@ -712,7 +712,7 @@ TEXT runtime·syscall10X(SB),NOSPLIT,$0
 
 	ADD	$-16, X2
 
-	MOV	(0*8)(X9), X5		// fn
+	MOV	(0*8)(X9), X6		// fn
 	MOV	(1*8)(X9), X10		// a1
 	MOV	(2*8)(X9), X11		// a2
 	MOV	(3*8)(X9), X12		// a3
@@ -722,7 +722,7 @@ TEXT runtime·syscall10X(SB),NOSPLIT,$0
 	MOV	(7*8)(X9), X16		// a7
 	MOV	(8*8)(X9), X17		// a8
 
-	JALR	X1, X5
+	JALR	X1, X6
 
 	MOV	X10, (11*8)(X9)		// r1
 	MOV	X11, (12*8)(X9)		// r2

package/bin/go/src/runtime/syscall_windows.go

@@ -7,7 +7,6 @@ package runtime
 import (
 	"internal/abi"
 	"internal/goarch"
-	"internal/runtime/syscall/windows"
 	"unsafe"
 )
 
@@ -415,9 +414,6 @@ func syscall_syscalln(fn, n uintptr, args ...uintptr) (r1, r2, err uintptr) {
 	if n > uintptr(len(args)) {
 		panic("syscall: n > len(args)") // should not be reachable from user code
 	}
-	if n > windows.MaxArgs {
-		panic("runtime: SyscallN has too many arguments")
-	}
 
 	// The cgocall parameters are stored in m instead of in
 	// the stack because the stack can move during fn if it
@@ -428,10 +424,10 @@ func syscall_syscalln(fn, n uintptr, args ...uintptr) (r1, r2, err uintptr) {
 	if c.N != 0 {
 		c.Args = uintptr(noescape(unsafe.Pointer(&args[0])))
 	}
-	cgocall(asmstdcallAddr, unsafe.Pointer(c))
+	errno := cgocall(asmstdcallAddr, unsafe.Pointer(c))
 	// cgocall may reschedule us on to a different M,
 	// but it copies the return values into the new M's
 	// so we can read them from there.
 	c = &getg().m.winsyscall
-	return c.R1, c.R2, c.Err
+	return c.R1, c.R2, uintptr(uint32(errno))
 }

package/bin/go/src/runtime/time.go

@@ -29,6 +29,12 @@ func time_runtimeNow() (sec int64, nsec int32, mono int64) {
 	return time_now()
 }
 
+//go:linkname crypto_internal_fips140deps_time_monoTime crypto/internal/fips140deps/time.monoTime
+func crypto_internal_fips140deps_time_monoTime() (mono int64) {
+	_, _, mono = time_now()
+	return mono
+}
+
 //go:linkname time_runtimeNano time.runtimeNano
 func time_runtimeNano() int64 {
 	gp := getg()
@@ -99,7 +105,6 @@ type timer struct {
 	ts *timers
 
 	// sendLock protects sends on the timer's channel.
-	// Not used for async (pre-Go 1.23) behavior when debug.asynctimerchan.Load() != 0.
 	sendLock mutex
 
 	// isSending is used to handle races between running a
@@ -466,45 +471,17 @@ func (ts *timers) addHeap(t *timer) {
 	}
 }
 
-// maybeRunAsync checks whether t needs to be triggered and runs it if so.
-// The caller is responsible for locking the timer and for checking that we
-// are running timers in async mode. If the timer needs to be run,
-// maybeRunAsync will unlock and re-lock it.
-// The timer is always locked on return.
-func (t *timer) maybeRunAsync() {
-	assertLockHeld(&t.mu)
-	if t.state&timerHeaped == 0 && t.isChan && t.when > 0 {
-		// If timer should have triggered already (but nothing looked at it yet),
-		// trigger now, so that a receive after the stop sees the "old" value
-		// that should be there.
-		// (It is possible to have t.blocked > 0 if there is a racing receive
-		// in blockTimerChan, but timerHeaped not being set means
-		// it hasn't run t.maybeAdd yet; in that case, running the
-		// timer ourselves now is fine.)
-		if now := nanotime(); t.when <= now {
-			systemstack(func() {
-				t.unlockAndRun(now, nil) // resets t.when
-			})
-			t.lock()
-		}
-	}
-}
-
 // stop stops the timer t. It may be on some other P, so we can't
 // actually remove it from the timers heap. We can only mark it as stopped.
 // It will be removed in due course by the P whose heap it is on.
 // Reports whether the timer was stopped before it was run.
 func (t *timer) stop() bool {
-	async := debug.asynctimerchan.Load() != 0
-	if !async && t.isChan {
+	if t.isChan {
 		lock(&t.sendLock)
 	}
 
 	t.lock()
 	t.trace("stop")
-	if async {
-		t.maybeRunAsync()
-	}
 	if t.state&timerHeaped != 0 {
 		t.state |= timerModified
 		if t.state&timerZombie == 0 {
@@ -515,7 +492,7 @@ func (t *timer) stop() bool {
 	pending := t.when > 0
 	t.when = 0
 
-	if !async && t.isChan {
+	if t.isChan {
 		// Stop any future sends with stale values.
 		// See timer.unlockAndRun.
 		t.seq++
@@ -530,7 +507,7 @@ func (t *timer) stop() bool {
 		}
 	}
 	t.unlock()
-	if !async && t.isChan {
+	if t.isChan {
 		unlock(&t.sendLock)
 		if timerchandrain(t.hchan()) {
 			pending = true
@@ -576,16 +553,12 @@ func (t *timer) modify(when, period int64, f func(arg any, seq uintptr, delay in
 	if period < 0 {
 		throw("timer period must be non-negative")
 	}
-	async := debug.asynctimerchan.Load() != 0
 
-	if !async && t.isChan {
+	if t.isChan {
 		lock(&t.sendLock)
 	}
 
 	t.lock()
-	if async {
-		t.maybeRunAsync()
-	}
 	t.trace("modify")
 	oldPeriod := t.period
 	t.period = period
@@ -636,7 +609,7 @@ func (t *timer) modify(when, period int64, f func(arg any, seq uintptr, delay in
 		}
 		if t.state&timerHeaped == 0 && when <= bubble.now {
 			systemstack(func() {
-				if !async && t.isChan {
+				if t.isChan {
 					unlock(&t.sendLock)
 				}
 				t.unlockAndRun(bubble.now, bubble)
@@ -645,7 +618,7 @@ func (t *timer) modify(when, period int64, f func(arg any, seq uintptr, delay in
 		}
 	}
 
-	if !async && t.isChan {
+	if t.isChan {
 		// Stop any future sends with stale values.
 		// See timer.unlockAndRun.
 		t.seq++
@@ -660,7 +633,7 @@ func (t *timer) modify(when, period int64, f func(arg any, seq uintptr, delay in
 		}
 	}
 	t.unlock()
-	if !async && t.isChan {
+	if t.isChan {
 		if timerchandrain(t.hchan()) {
 			pending = true
 		}
@@ -1126,13 +1099,7 @@ func (t *timer) unlockAndRun(now int64, bubble *synctestBubble) {
 		// Note that we are running on a system stack,
 		// so there is no chance of getg().m being reassigned
 		// out from under us while this function executes.
-		gp := getg()
-		var tsLocal *timers
-		if bubble == nil {
-			tsLocal = &gp.m.p.ptr().timers
-		} else {
-			tsLocal = &bubble.timers
-		}
+		tsLocal := &getg().m.p.ptr().timers
 		if tsLocal.raceCtx == 0 {
 			tsLocal.raceCtx = racegostart(abi.FuncPCABIInternal((*timers).run) + sys.PCQuantum)
 		}
@@ -1168,8 +1135,7 @@ func (t *timer) unlockAndRun(now int64, bubble *synctestBubble) {
 		t.updateHeap()
 	}
 
-	async := debug.asynctimerchan.Load() != 0
-	if !async && t.isChan && t.period == 0 {
+	if t.isChan && t.period == 0 {
 		// Tell Stop/Reset that we are sending a value.
 		if t.isSending.Add(1) < 0 {
 			throw("too many concurrent timer firings")
@@ -1184,11 +1150,7 @@ func (t *timer) unlockAndRun(now int64, bubble *synctestBubble) {
 		if gp.racectx != 0 {
 			throw("unexpected racectx")
 		}
-		if bubble == nil {
-			gp.racectx = gp.m.p.ptr().timers.raceCtx
-		} else {
-			gp.racectx = bubble.timers.raceCtx
-		}
+		gp.racectx = gp.m.p.ptr().timers.raceCtx
 	}
 
 	if ts != nil {
@@ -1205,7 +1167,7 @@ func (t *timer) unlockAndRun(now int64, bubble *synctestBubble) {
 		bubble.changegstatus(gp, _Gdead, _Grunning)
 	}
 
-	if !async && t.isChan {
+	if t.isChan {
 		// For a timer channel, we want to make sure that no stale sends
 		// happen after a t.stop or t.modify, but we cannot hold t.mu
 		// during the actual send (which f does) due to lock ordering.
@@ -1242,7 +1204,7 @@ func (t *timer) unlockAndRun(now int64, bubble *synctestBubble) {
 
 	f(arg, seq, delay)
 
-	if !async && t.isChan {
+	if t.isChan {
 		unlock(&t.sendLock)
 	}
 
@@ -1267,7 +1229,7 @@ func (t *timer) unlockAndRun(now int64, bubble *synctestBubble) {
 	}
 }
 
-// verifyTimerHeap verifies that the timers is in a valid state.
+// verify verifies that the timer heap is in a valid state.
 // This is only for debugging, and is only called if verifyTimers is true.
 // The caller must have locked ts.
 func (ts *timers) verify() {

package/bin/go/src/runtime/trace/subscribe.go

@@ -199,6 +199,3 @@ func (t *traceMultiplexer) startLocked() error {
 	t.enabled.Store(true)
 	return nil
 }
-
-//go:linkname runtime_readTrace
-func runtime_readTrace() (buf []byte)

package/bin/go/src/runtime/traceback.go

@@ -460,7 +460,7 @@ func (u *unwinder) next() {
 		// get everything, so crash loudly.
 		fail := u.flags&(unwindPrintErrors|unwindSilentErrors) == 0
 		doPrint := u.flags&unwindSilentErrors == 0
-		if doPrint && gp.m.incgo && f.funcID == abi.FuncID_sigpanic {
+		if doPrint && gp.m != nil && gp.m.incgo && f.funcID == abi.FuncID_sigpanic {
 			// We can inject sigpanic
 			// calls directly into C code,
 			// in which case we'll see a C
@@ -742,28 +742,82 @@ printloop:
 }
 
 // funcNamePiecesForPrint returns the function name for printing to the user.
-// It returns three pieces so it doesn't need an allocation for string
+// It returns five pieces so it doesn't need an allocation for string
 // concatenation.
-func funcNamePiecesForPrint(name string) (string, string, string) {
+func funcNamePiecesForPrint(name string) (string, string, string, string, string) {
 	// Replace the shape name in generic function with "...".
 	i := bytealg.IndexByteString(name, '[')
 	if i < 0 {
-		return name, "", ""
+		return name, "", "", "", ""
 	}
 	j := len(name) - 1
 	for name[j] != ']' {
 		j--
 	}
 	if j <= i {
-		return name, "", ""
+		return name, "", "", "", ""
+	}
+
+	interior := name[i+1 : j] // '[' interior ']'
+	// This is an early-out to skip the more-detailed parsing that
+	// follows -- if there's no '[' in the interior, that implies
+	// (assuming balanced brackets) no ']' in the interior, and thus
+	// this will be the answer. If brackets are not balanced
+	// (malformed input, which was already a risk), this will
+	// eat/hide the unbalanced "]".
+	if bytealg.IndexByteString(interior, '[') < 0 {
+		return name[:i], "[...]", name[j+1:], "", ""
+	}
+	// Generic method of generic type.
+	// know interior contains at least "...[..."
+	// expect interior contains "...]___[...".
+	// don't know whether "..." contains balanced brackets or not.
+	// or the compiler might have a bug in its naming-things department.
+	// hope to return name[:i], "[...]", ___, "[...]", name[j+1:]
+	depth := 1 // beginning after first "[", looking for balancing "]"
+	rbr, lbr := -1, -1
+	for k, c := range interior {
+		if c == '[' {
+			depth++
+			if depth != 1 {
+				continue
+			}
+			// rbr != -1 because rbr is only assigned if depth == 0
+			lbr = k
+			break // success, depth == 1, rbr >= 0, lbr > rbr
+		}
+		if c == ']' {
+			depth--
+			if depth < 0 {
+				break // malformed "...]...]"
+			}
+			if depth != 0 {
+				continue
+			}
+			// cannot execute this twice; depth == 0 -> { ']' -> malformed, '[' -> success }
+			rbr = k
+		}
+	}
+	if depth == 1 {
+		if rbr >= 0 && lbr > rbr {
+			return name[:i], "[...]", interior[rbr+1 : lbr], "[...]", name[j+1:]
+		}
+		if rbr == -1 && lbr == -1 {
+			// the bracket seen in the interior must have been balanced in a "[]" pattern, not "]["
+			// return the single-brackets (not a generic method of a generic type) result
+			return name[:i], "[...]", name[j+1:], "", ""
+		}
 	}
-	return name[:i], "[...]", name[j+1:]
+
+	// malformed, return the whole name
+	return name, "", "", "", ""
+
 }
 
 // funcNameForPrint returns the function name for printing to the user.
 func funcNameForPrint(name string) string {
-	a, b, c := funcNamePiecesForPrint(name)
-	return a + b + c
+	a, b, c, d, e := funcNamePiecesForPrint(name)
+	return a + b + c + d + e
 }
 
 // printFuncName prints a function name. name is the function name in
@@ -773,8 +827,8 @@ func printFuncName(name string) {
 		print("panic")
 		return
 	}
-	a, b, c := funcNamePiecesForPrint(name)
-	print(a, b, c)
+	a, b, c, d, e := funcNamePiecesForPrint(name)
+	print(a, b, c, d, e)
 }
 
 func printcreatedby(gp *g) {
@@ -1276,12 +1330,23 @@ func goroutineheader(gp *g) {
 	if bubble := gp.bubble; bubble != nil {
 		print(", synctest bubble ", bubble.id)
 	}
+	print("]")
 	if gp.labels != nil && debug.tracebacklabels.Load() == 1 {
 		labels := (*label.Set)(gp.labels).List
 		if len(labels) > 0 {
-			print(" labels:{")
+			print(" {")
 			for i, kv := range labels {
-				print(quoted(kv.Key), ": ", quoted(kv.Value))
+				// Try to be nice and only quote the keys/values if one of them has characters that need quoting or escaping.
+				printq := func(s string) {
+					if tracebackStringNeedsQuoting(s) {
+						print(quoted(s))
+					} else {
+						print(s)
+					}
+				}
+				printq(kv.Key)
+				print(": ")
+				printq(kv.Value)
 				if i < len(labels)-1 {
 					print(", ")
 				}
@@ -1289,7 +1354,19 @@ func goroutineheader(gp *g) {
 			print("}")
 		}
 	}
-	print("]:\n")
+	print(":\n")
+}
+
+func tracebackStringNeedsQuoting(s string) bool {
+	for _, r := range s {
+		if !('a' <= r && r <= 'z' ||
+			'A' <= r && r <= 'Z' ||
+			'0' <= r && r <= '9' ||
+			r == '.' || r == '/' || r == '_') {
+			return true
+		}
+	}
+	return false
 }
 
 func tracebackothers(me *g) {

package/bin/go/src/runtime/traceregion.go

@@ -92,8 +92,8 @@ func (a *traceRegionAlloc) alloc(n uintptr) *notInHeap {
 		block.off.Store(n)
 		x = (*notInHeap)(unsafe.Pointer(&block.data[0]))
 
-		// Publish the new block.
-		a.current.Store(unsafe.Pointer(block))
+		// Publish the new block. No write barrier as the memory is off heap.
+		a.current.StoreNoWB(unsafe.Pointer(block))
 		unlock(&a.lock)
 	})
 	return x
@@ -112,7 +112,7 @@ func (a *traceRegionAlloc) drop() {
 	}
 	if current := a.current.Load(); current != nil {
 		sysFree(current, unsafe.Sizeof(traceRegionAllocBlock{}), &memstats.other_sys)
-		a.current.Store(nil)
+		a.current.StoreNoWB(nil)
 	}
 	a.dropping.Store(false)
 }

package/bin/go/src/runtime/tracestring.go

@@ -25,6 +25,11 @@ type traceStringTable struct {
 
 // put adds a string to the table, emits it, and returns a unique ID for it.
 func (t *traceStringTable) put(gen uintptr, s string) uint64 {
+	// Truncate the string now to avoid wasting space in the
+	// traceMap and to stay within traceRegionAlloc's block size limit.
+	if len(s) > tracev2.MaxEventTrailerDataSize {
+		s = s[:tracev2.MaxEventTrailerDataSize]
+	}
 	// Put the string in the table.
 	ss := stringStructOf(&s)
 	id, added := t.tab.put(ss.str, uintptr(ss.len))