Merge remote-tracking branch 'upstream/master'

Author: actions-user

doc/godebug.md

@@ -169,6 +169,9 @@ Go command will follow symlinks to regular files embedding files.
 The default value `embedfollowsymlinks=0` does not allow following
 symlinks. `embedfollowsymlinks=1` will allow following symlinks.
 
+Go 1.25 corrected the semantics of contention reports for runtime-internal locks,
+and so removed the [`runtimecontentionstacks` setting](/pkg/runtime#hdr-Environment_Variable).
+
 ### Go 1.24
 
 Go 1.24 added a new `fips140` setting that controls whether the Go

doc/next/6-stdlib/99-minor/runtime/pprof/66999.md

@@ -0,0 +1,6 @@
+The mutex profile for contention on runtime-internal locks now correctly points
+to the end of the critical section that caused the delay. This matches the
+profile's behavior for contention on `sync.Mutex` values. The
+`runtimecontentionstacks` setting for `GODEBUG`, which allowed opting in to the
+unusual behavior of Go 1.22 through 1.24 for this part of the profile, is now
+gone.

src/cmd/asm/internal/asm/testdata/loong64enc1.s

@@ -964,3 +964,25 @@ lable2:
 	XVSETALLNEH	X1, FCC0	// 20b49c76
 	XVSETALLNEW	X1, FCC0	// 20b89c76
 	XVSETALLNEV	X1, FCC0	// 20bc9c76
+
+	// [X]VFRINT[{RNE/RZ/RP/RM}].{S/D} instructions
+	VFRINTRNEF	V1, V2		// 22749d72
+	VFRINTRNED	V1, V2		// 22789d72
+	VFRINTRZF	V1, V2		// 22649d72
+	VFRINTRZD	V1, V2		// 22689d72
+	VFRINTRPF	V1, V2		// 22549d72
+	VFRINTRPD	V1, V2		// 22589d72
+	VFRINTRMF	V1, V2		// 22449d72
+	VFRINTRMD	V1, V2		// 22489d72
+	VFRINTF		V1, V2		// 22349d72
+	VFRINTD		V1, V2		// 22389d72
+	XVFRINTRNEF	X1, X2		// 22749d76
+	XVFRINTRNED	X1, X2		// 22789d76
+	XVFRINTRZF	X1, X2		// 22649d76
+	XVFRINTRZD	X1, X2		// 22689d76
+	XVFRINTRPF	X1, X2		// 22549d76
+	XVFRINTRPD	X1, X2		// 22589d76
+	XVFRINTRMF	X1, X2		// 22449d76
+	XVFRINTRMD	X1, X2		// 22489d76
+	XVFRINTF	X1, X2		// 22349d76
+	XVFRINTD	X1, X2		// 22389d76

src/cmd/compile/internal/reflectdata/map_swiss.go

@@ -159,6 +159,7 @@ func SwissMapType() *types.Type {
 	//     globalShift uint8
 	//
 	//     writing uint8
+	//     tombstonePossible bool
 	//     // N.B Padding
 	//
 	//     clearSeq uint64
@@ -172,6 +173,7 @@ func SwissMapType() *types.Type {
 		makefield("globalDepth", types.Types[types.TUINT8]),
 		makefield("globalShift", types.Types[types.TUINT8]),
 		makefield("writing", types.Types[types.TUINT8]),
+		makefield("tombstonePossible", types.Types[types.TBOOL]),
 		makefield("clearSeq", types.Types[types.TUINT64]),
 	}
 

src/cmd/compile/internal/test/inl_test.go

@@ -284,6 +284,25 @@ func TestIntendedInlining(t *testing.T) {
 		}
 	}
 
+	if runtime.GOARCH != "wasm" {
+		// mutex implementation for multi-threaded GOARCHes
+		want["runtime"] = append(want["runtime"],
+			// in the fast paths of lock2 and unlock2
+			"key8",
+			"(*mLockProfile).store",
+		)
+		if bits.UintSize == 64 {
+			// these use 64-bit arithmetic, which is hard to inline on 32-bit platforms
+			want["runtime"] = append(want["runtime"],
+				// in the fast paths of lock2 and unlock2
+				"mutexSampleContention",
+
+				// in a slow path of lock2, but within the critical section
+				"(*mLockProfile).end",
+			)
+		}
+	}
+
 	// Functions that must actually be inlined; they must have actual callers.
 	must := map[string]bool{
 		"compress/flate.byLiteral.Len":  true,

src/cmd/dist/test.go

@@ -1678,7 +1678,7 @@ func (t *tester) makeGOROOTUnwritable() (undo func()) {
 func raceDetectorSupported(goos, goarch string) bool {
 	switch goos {
 	case "linux":
-		return goarch == "amd64" || goarch == "ppc64le" || goarch == "arm64" || goarch == "s390x"
+		return goarch == "amd64" || goarch == "ppc64le" || goarch == "arm64" || goarch == "s390x" || goarch == "loong64"
 	case "darwin":
 		return goarch == "amd64" || goarch == "arm64"
 	case "freebsd", "netbsd", "windows":

src/cmd/internal/obj/loong64/a.out.go

@@ -950,6 +950,28 @@ const (
 	AXVFRSQRTF
 	AXVFRSQRTD
 
+	// LSX and LASX floating point conversion instructions
+	AVFRINTRNEF
+	AVFRINTRNED
+	AVFRINTRZF
+	AVFRINTRZD
+	AVFRINTRPF
+	AVFRINTRPD
+	AVFRINTRMF
+	AVFRINTRMD
+	AVFRINTF
+	AVFRINTD
+	AXVFRINTRNEF
+	AXVFRINTRNED
+	AXVFRINTRZF
+	AXVFRINTRZD
+	AXVFRINTRPF
+	AXVFRINTRPD
+	AXVFRINTRMF
+	AXVFRINTRMD
+	AXVFRINTF
+	AXVFRINTD
+
 	// LSX and LASX integer neg instructions
 	AVNEGB
 	AVNEGH

src/cmd/internal/obj/loong64/anames.go

@@ -1722,6 +1722,16 @@ func buildop(ctxt *obj.Link) {
 			opset(AVNEGH, r0)
 			opset(AVNEGW, r0)
 			opset(AVNEGV, r0)
+			opset(AVFRINTRNEF, r0)
+			opset(AVFRINTRNED, r0)
+			opset(AVFRINTRZF, r0)
+			opset(AVFRINTRZD, r0)
+			opset(AVFRINTRPF, r0)
+			opset(AVFRINTRPD, r0)
+			opset(AVFRINTRMF, r0)
+			opset(AVFRINTRMD, r0)
+			opset(AVFRINTF, r0)
+			opset(AVFRINTD, r0)
 
 		case AXVPCNTB:
 			opset(AXVPCNTH, r0)
@@ -1737,6 +1747,16 @@ func buildop(ctxt *obj.Link) {
 			opset(AXVNEGH, r0)
 			opset(AXVNEGW, r0)
 			opset(AXVNEGV, r0)
+			opset(AXVFRINTRNEF, r0)
+			opset(AXVFRINTRNED, r0)
+			opset(AXVFRINTRZF, r0)
+			opset(AXVFRINTRZD, r0)
+			opset(AXVFRINTRPF, r0)
+			opset(AXVFRINTRPD, r0)
+			opset(AXVFRINTRMF, r0)
+			opset(AXVFRINTRMD, r0)
+			opset(AXVFRINTF, r0)
+			opset(AXVFRINTD, r0)
 
 		case AVADDB:
 			opset(AVADDH, r0)
@@ -3583,6 +3603,46 @@ func (c *ctxt0) oprr(a obj.As) uint32 {
 		return 0x1da70e << 10 // xvneg.w
 	case AXVNEGV:
 		return 0x1da70f << 10 // xvneg.d
+	case AVFRINTRNEF:
+		return 0x1ca75d << 10 // vfrintrne.s
+	case AVFRINTRNED:
+		return 0x1ca75e << 10 // vfrintrne.d
+	case AVFRINTRZF:
+		return 0x1ca759 << 10 // vfrintrz.s
+	case AVFRINTRZD:
+		return 0x1ca75a << 10 // vfrintrz.d
+	case AVFRINTRPF:
+		return 0x1ca755 << 10 // vfrintrp.s
+	case AVFRINTRPD:
+		return 0x1ca756 << 10 // vfrintrp.d
+	case AVFRINTRMF:
+		return 0x1ca751 << 10 // vfrintrm.s
+	case AVFRINTRMD:
+		return 0x1ca752 << 10 // vfrintrm.d
+	case AVFRINTF:
+		return 0x1ca74d << 10 // vfrint.s
+	case AVFRINTD:
+		return 0x1ca74e << 10 // vfrint.d
+	case AXVFRINTRNEF:
+		return 0x1da75d << 10 // xvfrintrne.s
+	case AXVFRINTRNED:
+		return 0x1da75e << 10 // xvfrintrne.d
+	case AXVFRINTRZF:
+		return 0x1da759 << 10 // xvfrintrz.s
+	case AXVFRINTRZD:
+		return 0x1da75a << 10 // xvfrintrz.d
+	case AXVFRINTRPF:
+		return 0x1da755 << 10 // xvfrintrp.s
+	case AXVFRINTRPD:
+		return 0x1da756 << 10 // xvfrintrp.d
+	case AXVFRINTRMF:
+		return 0x1da751 << 10 // xvfrintrm.s
+	case AXVFRINTRMD:
+		return 0x1da752 << 10 // xvfrintrm.d
+	case AXVFRINTF:
+		return 0x1da74d << 10 // xvfrint.s
+	case AXVFRINTD:
+		return 0x1da74e << 10 // xvfrint.d
 	case AVSETEQV:
 		return 0x1ca726<<10 | 0x0<<3 // vseteqz.v
 	case AVSETNEV:

src/cmd/internal/obj/loong64/asm.go

@@ -43,15 +43,15 @@ var globalCertCache = new(certCache)
 
 // activeCert is a handle to a certificate held in the cache. Once there are
 // no alive activeCerts for a given certificate, the certificate is removed
-// from the cache by a finalizer.
+// from the cache by a cleanup.
 type activeCert struct {
 	cert *x509.Certificate
 }
 
 // active increments the number of references to the entry, wraps the
-// certificate in the entry in an activeCert, and sets the finalizer.
+// certificate in the entry in an activeCert, and sets the cleanup.
 //
-// Note that there is a race between active and the finalizer set on the
+// Note that there is a race between active and the cleanup set on the
 // returned activeCert, triggered if active is called after the ref count is
 // decremented such that refs may be > 0 when evict is called. We consider this
 // safe, since the caller holding an activeCert for an entry that is no longer
@@ -60,11 +60,11 @@ type activeCert struct {
 func (cc *certCache) active(e *cacheEntry) *activeCert {
 	e.refs.Add(1)
 	a := &activeCert{e.cert}
-	runtime.SetFinalizer(a, func(_ *activeCert) {
-		if e.refs.Add(-1) == 0 {
-			cc.evict(e)
+	runtime.AddCleanup(a, func(ce *cacheEntry) {
+		if ce.refs.Add(-1) == 0 {
+			cc.evict(ce)
 		}
-	})
+	}, e)
 	return a
 }