@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/internal/cpu/cpu_arm64_openbsd.go

@@ -25,11 +25,16 @@ func osInit() {
 	if !ok {
 		return
 	}
+	// Get ID_AA64ISAR1 from sysctl.
+	isar1, ok := sysctlUint64([]uint32{_CTL_MACHDEP, _CPU_ID_AA64ISAR1})
+	if !ok {
+		return
+	}
 	// Get ID_AA64PFR0 from sysctl.
 	pfr0, ok := sysctlUint64([]uint32{_CTL_MACHDEP, _CPU_ID_AA64PFR0})
 	if !ok {
 		return
 	}
 
-	parseARM64SystemRegisters(isar0, pfr0)
+	parseARM64SystemRegisters(isar0, isar1, pfr0)
 }

package/bin/go/src/internal/cpu/cpu_arm64_other.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 arm64 && !linux && !freebsd && !android && (!darwin || ios) && !openbsd
+//go:build arm64 && !linux && !freebsd && !android && (!darwin || ios) && !openbsd && !windows
 
 package cpu
 

package/bin/go/src/internal/cpu/cpu_arm64_windows.go

@@ -0,0 +1,26 @@
+// 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 arm64
+
+package cpu
+
+func osInit() {
+	// TODO(brainman): we don't know how to retrieve those bits form user space - leaving them as false for now
+	// https://github.com/golang/go/issues/76791#issuecomment-3877873959
+	ARM64.HasCPUID = false
+	ARM64.HasDIT = false
+	ARM64.IsNeoverse = false
+
+	if isProcessorFeaturePresent(_PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE) {
+		ARM64.HasAES = true
+		ARM64.HasPMULL = true
+		ARM64.HasSHA1 = true
+		ARM64.HasSHA2 = true
+	}
+	ARM64.HasSHA3 = isProcessorFeaturePresent(_PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE)
+	ARM64.HasCRC32 = isProcessorFeaturePresent(_PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE)
+	ARM64.HasSHA512 = isProcessorFeaturePresent(_PF_ARM_SHA512_INSTRUCTIONS_AVAILABLE)
+	ARM64.HasATOMICS = isProcessorFeaturePresent(_PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE)
+}

package/bin/go/src/internal/cpu/cpu_loong64.go

@@ -17,8 +17,13 @@ const (
 	cpucfg1_CRC32 = 1 << 25
 
 	// CPUCFG2 bits
-	cpucfg2_LAM_BH = 1 << 27
-	cpucfg2_LAMCAS = 1 << 28
+	cpucfg2_LAM_BH      = 1 << 27
+	cpucfg2_LAMCAS      = 1 << 28
+	cpucfg2_LLACQ_SCREL = 1 << 29
+	cpucfg2_SCQ         = 1 << 30
+
+	// CPUCFG3 bits
+	cpucfg3_DBAR_HINTS = 1 << 17
 )
 
 // get_cpucfg is implemented in cpu_loong64.s.
@@ -31,6 +36,9 @@ func doinit() {
 		{Name: "crc32", Feature: &Loong64.HasCRC32},
 		{Name: "lamcas", Feature: &Loong64.HasLAMCAS},
 		{Name: "lam_bh", Feature: &Loong64.HasLAM_BH},
+		{Name: "llacq_screl", Feature: &Loong64.HasLLACQ_SCREL},
+		{Name: "scq", Feature: &Loong64.HasSCQ},
+		{Name: "dbar_hints", Feature: &Loong64.HasDBAR_HINTS},
 	}
 
 	// The CPUCFG data on Loong64 only reflects the hardware capabilities,
@@ -42,10 +50,14 @@ func doinit() {
 	// through CPUCFG
 	cfg1 := get_cpucfg(1)
 	cfg2 := get_cpucfg(2)
+	cfg3 := get_cpucfg(3)
 
 	Loong64.HasCRC32 = cfgIsSet(cfg1, cpucfg1_CRC32)
 	Loong64.HasLAMCAS = cfgIsSet(cfg2, cpucfg2_LAMCAS)
 	Loong64.HasLAM_BH = cfgIsSet(cfg2, cpucfg2_LAM_BH)
+	Loong64.HasLLACQ_SCREL = cfgIsSet(cfg2, cpucfg2_LLACQ_SCREL)
+	Loong64.HasSCQ = cfgIsSet(cfg2, cpucfg2_SCQ)
+	Loong64.HasDBAR_HINTS = cfgIsSet(cfg3, cpucfg3_DBAR_HINTS)
 
 	osInit()
 }

package/bin/go/src/internal/cpu/cpu_riscv64.go

@@ -13,6 +13,16 @@ func doinit() {
 		{Name: "fastmisaligned", Feature: &RISCV64.HasFastMisaligned},
 		{Name: "v", Feature: &RISCV64.HasV},
 		{Name: "zbb", Feature: &RISCV64.HasZbb},
+		{Name: "zbc", Feature: &RISCV64.HasZbc},
+		{Name: "zvbb", Feature: &RISCV64.HasZvbb},
+		{Name: "zvbc", Feature: &RISCV64.HasZvbc},
+		{Name: "zvkg", Feature: &RISCV64.HasZvkg},
+		{Name: "zvkned", Feature: &RISCV64.HasZvkned},
+		{Name: "zvknha", Feature: &RISCV64.HasZvknha},
+		{Name: "zvknhb", Feature: &RISCV64.HasZvknhb},
+		{Name: "zvksed", Feature: &RISCV64.HasZvksed},
+		{Name: "zvksh", Feature: &RISCV64.HasZvksh},
+		{Name: "zvkt", Feature: &RISCV64.HasZvkt},
 	}
 	osInit()
 }

package/bin/go/src/internal/cpu/cpu_riscv64_linux.go

@@ -51,6 +51,17 @@ const (
 	riscv_HWPROBE_KEY_IMA_EXT_0   = 0x4
 	riscv_HWPROBE_IMA_V           = 0x4
 	riscv_HWPROBE_EXT_ZBB         = 0x10
+	riscv_HWPROBE_EXT_ZBC         = 0x80
+	riscv_HWPROBE_EXT_ZVBB        = 0x20000
+	riscv_HWPROBE_EXT_ZVBC        = 0x40000
+	riscv_HWPROBE_EXT_ZVKB        = 0x80000
+	riscv_HWPROBE_EXT_ZVKG        = 0x100000
+	riscv_HWPROBE_EXT_ZVKNED      = 0x200000
+	riscv_HWPROBE_EXT_ZVKNHA      = 0x400000
+	riscv_HWPROBE_EXT_ZVKNHB      = 0x800000
+	riscv_HWPROBE_EXT_ZVKSED      = 0x1000000
+	riscv_HWPROBE_EXT_ZVKSH       = 0x2000000
+	riscv_HWPROBE_EXT_ZVKT        = 0x4000000
 	riscv_HWPROBE_KEY_CPUPERF_0   = 0x5
 	riscv_HWPROBE_MISALIGNED_FAST = 0x3
 	riscv_HWPROBE_MISALIGNED_MASK = 0x7
@@ -85,6 +96,16 @@ func osInit() {
 		v := uint(pairs[0].value)
 		RISCV64.HasV = isSet(v, riscv_HWPROBE_IMA_V)
 		RISCV64.HasZbb = isSet(v, riscv_HWPROBE_EXT_ZBB)
+		RISCV64.HasZbc = isSet(v, riscv_HWPROBE_EXT_ZBC)
+		RISCV64.HasZvbb = isSet(v, riscv_HWPROBE_EXT_ZVBB)
+		RISCV64.HasZvbc = isSet(v, riscv_HWPROBE_EXT_ZVBC)
+		RISCV64.HasZvkg = isSet(v, riscv_HWPROBE_EXT_ZVKG)
+		RISCV64.HasZvkned = isSet(v, riscv_HWPROBE_EXT_ZVKNED)
+		RISCV64.HasZvknha = isSet(v, riscv_HWPROBE_EXT_ZVKNHA)
+		RISCV64.HasZvknhb = isSet(v, riscv_HWPROBE_EXT_ZVKNHB)
+		RISCV64.HasZvksed = isSet(v, riscv_HWPROBE_EXT_ZVKSED)
+		RISCV64.HasZvksh = isSet(v, riscv_HWPROBE_EXT_ZVKSH)
+		RISCV64.HasZvkt = isSet(v, riscv_HWPROBE_EXT_ZVKT)
 	}
 	if pairs[1].key != -1 {
 		v := pairs[1].value & riscv_HWPROBE_MISALIGNED_MASK

package/bin/go/src/internal/cpu/cpu_windows.go

@@ -0,0 +1,20 @@
+// 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 cpu
+
+import _ "unsafe" // for linkname
+
+const (
+	_PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE  = 30
+	_PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE   = 31
+	_PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE = 34
+	_PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE       = 64
+	_PF_ARM_SHA512_INSTRUCTIONS_AVAILABLE     = 65
+)
+
+// isProcessorFeaturePresent calls windows IsProcessorFeaturePresent API.
+//
+//go:linknamestd isProcessorFeaturePresent
+func isProcessorFeaturePresent(processorFeature uint32) bool // Implemented in runtime package.

package/bin/go/src/internal/cpu/cpu_x86.go

@@ -57,6 +57,7 @@ const (
 	cpuid_AVX512_VBMI      = 1 << 1
 	cpuid_AVX512_VBMI2     = 1 << 6
 	cpuid_GFNI             = 1 << 8
+	cpuid_VPCLMULQDQ       = 1 << 10 // applies to not just AVX512
 	cpuid_AVX512VPCLMULQDQ = 1 << 10
 	cpuid_AVX512_BITALG    = 1 << 12
 
@@ -174,6 +175,7 @@ func doinit() {
 	X86.HasADX = isSet(ebx7, cpuid_ADX)
 	X86.HasSHA = isSet(ebx7, cpuid_SHA)
 	X86.HasVAES = isSet(ecx7, cpuid_VAES) && X86.HasAVX
+	X86.HasVPCLMULQDQ = isSet(ecx7, cpuid_VPCLMULQDQ)
 
 	X86.HasAVX512F = isSet(ebx7, cpuid_AVX512F) && osSupportsAVX512
 	if X86.HasAVX512F {

package/bin/go/src/internal/filepathlite/path_windows.go

@@ -219,38 +219,51 @@ func volumeNameLen(path string) int {
 		// Path does not have a volume component.
 		return 0
 
-	case pathHasPrefixFold(path, `\\.\UNC`):
-		// We're going to treat the UNC host and share as part of the volume
-		// prefix for historical reasons, but this isn't really principled;
-		// Windows's own GetFullPathName will happily remove the first
-		// component of the path in this space, converting
-		// \\.\unc\a\b\..\c into \\.\unc\a\c.
-		return uncLen(path, len(`\\.\UNC\`))
-
 	case pathHasPrefixFold(path, `\\.`) ||
 		pathHasPrefixFold(path, `\\?`) || pathHasPrefixFold(path, `\??`):
-		// Path starts with \\.\, and is a Local Device path; or
-		// path starts with \\?\ or \??\ and is a Root Local Device path.
+		// Path starts with a device prefix: \\.\ for Local Device paths,
+		// or \\?\ or \??\ for Root Local Device paths.
+		switch {
+		case len(path) == 3:
+			return 3 // exactly \\., \\?, or \??
+		case pathHasPrefixFold(path[4:], `UNC`):
+			// We're going to treat the UNC host and share as part of the volume
+			// prefix for historical reasons, but this isn't really principled;
+			// Windows's own GetFullPathName will happily remove the first
+			// component of the path in this space, converting
+			// \\.\unc\a\b\..\c into \\.\unc\a\c.
+			return validVolumeNameLen(path, uncLen(path, len(`\\.\UNC\`)))
+		}
 		//
-		// We treat the next component after the \\.\ prefix as
+		// We treat the next component after the device prefix as
 		// part of the volume name, which means Clean(`\\?\c:\`)
 		// won't remove the trailing \. (See #64028.)
-		if len(path) == 3 {
-			return 3 // exactly \\.
-		}
 		_, rest, ok := cutPath(path[4:])
 		if !ok {
-			return len(path)
+			return validVolumeNameLen(path, len(path))
 		}
-		return len(path) - len(rest) - 1
+		return validVolumeNameLen(path, len(path)-len(rest)-1)
 
 	case len(path) >= 2 && IsPathSeparator(path[1]):
 		// Path starts with \\, and is a UNC path.
-		return uncLen(path, 2)
+		return validVolumeNameLen(path, uncLen(path, 2))
 	}
 	return 0
 }
 
+// validVolumeNameLen returns n if path[:n] is a valid Windows volume name.
+// If the volume name contains a ".." path component, it returns 0.
+func validVolumeNameLen(path string, n int) int {
+	for p := path[:n]; p != ""; {
+		var part string
+		part, p, _ = cutPath(p)
+		if part == ".." {
+			return 0
+		}
+	}
+	return n
+}
+
 // pathHasPrefixFold tests whether the path s begins with prefix,
 // ignoring case and treating all path separators as equivalent.
 // If s is longer than prefix, then s[len(prefix)] must be a path separator.

package/bin/go/src/internal/fuzz/fuzz.go

@@ -126,10 +126,14 @@ func CoordinateFuzzing(ctx context.Context, opts CoordinateFuzzingOpts) (err err
 			}
 		}
 
-		if err == fuzzCtx.Err() || isInterruptError(err) {
+		if err == ctx.Err() || err == fuzzCtx.Err() || isInterruptError(err) {
 			// Suppress cancellation errors and terminations due to SIGINT.
 			// The messages are not helpful since either the user triggered the error
 			// (with ^C) or another more helpful message will be printed (a crasher).
+			//
+			// Also check ctx.Err() because when ctx's deadline expires, there
+			// is a window where ctx.Err() is set but fuzzCtx (a child) has
+			// not yet been canceled. See go.dev/issue/75804.
 			err = nil
 		}
 		if err != nil && (fuzzErr == nil || fuzzErr == ctx.Err()) {

package/bin/go/src/internal/fuzz/mutator.go

@@ -66,7 +66,7 @@ func (m *mutator) mutate(vals []any, maxBytes int) {
 	case int16:
 		vals[i] = int16(m.mutateInt(int64(v), math.MaxInt16))
 	case int64:
-		vals[i] = m.mutateInt(v, maxInt)
+		vals[i] = m.mutateInt(v, math.MaxInt64)
 	case uint:
 		vals[i] = uint(m.mutateUInt(uint64(v), maxUint))
 	case uint16:
@@ -74,7 +74,7 @@ func (m *mutator) mutate(vals []any, maxBytes int) {
 	case uint32:
 		vals[i] = uint32(m.mutateUInt(uint64(v), math.MaxUint32))
 	case uint64:
-		vals[i] = m.mutateUInt(v, maxUint)
+		vals[i] = m.mutateUInt(v, math.MaxUint64)
 	case float32:
 		vals[i] = float32(m.mutateFloat(float64(v), math.MaxFloat32))
 	case float64:

package/bin/go/src/internal/fuzz/worker.go

@@ -489,7 +489,7 @@ func RunFuzzWorker(ctx context.Context, fn func(CorpusEntry) error) error {
 	srv := &workerServer{
 		workerComm: comm,
 		fuzzFn: func(e CorpusEntry) (time.Duration, error) {
-			timer := time.AfterFunc(10*time.Second, func() {
+			timer := time.AfterFunc(60*time.Second, func() {
 				panic("deadlocked!") // this error message won't be printed
 			})
 			defer timer.Stop()

package/bin/go/src/internal/gate/gate.go

@@ -0,0 +1,76 @@
+// Copyright 2024 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 gate contains an alternative condition variable.
+package gate
+
+import "context"
+
+// A Gate is a monitor (mutex + condition variable) with one bit of state.
+//
+// The condition may be either set or unset.
+// Lock operations may be unconditional, or wait for the condition to be set.
+// Unlock operations record the new state of the condition.
+type Gate struct {
+	// When unlocked, exactly one of set or unset contains a value.
+	// When locked, neither chan contains a value.
+	set   chan struct{}
+	unset chan struct{}
+}
+
+// New returns a new, unlocked gate.
+func New(set bool) Gate {
+	g := Gate{
+		set:   make(chan struct{}, 1),
+		unset: make(chan struct{}, 1),
+	}
+	g.Unlock(set)
+	return g
+}
+
+// Lock acquires the gate unconditionally.
+// It reports whether the condition is set.
+func (g *Gate) Lock() (set bool) {
+	select {
+	case <-g.set:
+		return true
+	case <-g.unset:
+		return false
+	}
+}
+
+// WaitAndLock waits until the condition is set before acquiring the gate.
+// If the context expires, WaitAndLock returns an error and does not acquire the gate.
+func (g *Gate) WaitAndLock(ctx context.Context) error {
+	select {
+	case <-g.set:
+		return nil
+	default:
+	}
+	select {
+	case <-g.set:
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+// LockIfSet acquires the gate if and only if the condition is set.
+func (g *Gate) LockIfSet() (acquired bool) {
+	select {
+	case <-g.set:
+		return true
+	default:
+		return false
+	}
+}
+
+// Unlock sets the condition and releases the gate.
+func (g *Gate) Unlock(set bool) {
+	if set {
+		g.set <- struct{}{}
+	} else {
+		g.unset <- struct{}{}
+	}
+}

package/bin/go/src/internal/godebugs/table.go

@@ -27,7 +27,6 @@ type Info struct {
 // (Otherwise the test in this package will fail.)
 var All = []Info{
 	{Name: "allowmultiplevcs", Package: "cmd/go"},
-	{Name: "asynctimerchan", Package: "time", Changed: 23, Old: "1"},
 	{Name: "containermaxprocs", Package: "runtime", Changed: 25, Old: "0"},
 	{Name: "cryptocustomrand", Package: "crypto", Changed: 26, Old: "1"},
 	{Name: "dataindependenttiming", Package: "crypto/subtle", Opaque: true},
@@ -40,7 +39,6 @@ var All = []Info{
 	{Name: "gocachetest", Package: "cmd/go"},
 	{Name: "gocacheverify", Package: "cmd/go"},
 	{Name: "gotestjsonbuildtext", Package: "cmd/go", Changed: 24, Old: "1"},
-	{Name: "gotypesalias", Package: "go/types", Changed: 23, Old: "0"},
 	{Name: "htmlmetacontenturlescape", Package: "html/template"},
 	{Name: "http2client", Package: "net/http"},
 	{Name: "http2debug", Package: "net/http", Opaque: true},
@@ -63,38 +61,59 @@ var All = []Info{
 	{Name: "randseednop", Package: "math/rand", Changed: 24, Old: "0"},
 	{Name: "rsa1024min", Package: "crypto/rsa", Changed: 24, Old: "0"},
 	{Name: "tarinsecurepath", Package: "archive/tar"},
-	{Name: "tls10server", Package: "crypto/tls", Changed: 22, Old: "1"},
-	{Name: "tls3des", Package: "crypto/tls", Changed: 23, Old: "1"},
 	{Name: "tlsmaxrsasize", Package: "crypto/tls"},
 	{Name: "tlsmlkem", Package: "crypto/tls", Changed: 24, Old: "0", Opaque: true},
-	{Name: "tlsrsakex", Package: "crypto/tls", Changed: 22, Old: "1"},
 	{Name: "tlssecpmlkem", Package: "crypto/tls", Changed: 26, Old: "0", Opaque: true},
 	{Name: "tlssha1", Package: "crypto/tls", Changed: 25, Old: "1"},
-	{Name: "tlsunsafeekm", Package: "crypto/tls", Changed: 22, Old: "1"},
+	// Mark tracebacklabels as Opaque so we don't generate a metric that we can't increment.
+	// IncNonDefault uses a sync.Once, which involves sync.Mutex, and is not safe from a signal handler.
+	// (Tracebacks are generated in signal-handlers.)
+	{Name: "tracebacklabels", Package: "runtime", Changed: 27, Old: "0", Opaque: true},
 	{Name: "updatemaxprocs", Package: "runtime", Changed: 25, Old: "0"},
 	{Name: "urlmaxqueryparams", Package: "net/url", Changed: 24, Old: "0"},
 	{Name: "urlstrictcolons", Package: "net/url", Changed: 26, Old: "0"},
 	{Name: "winreadlinkvolume", Package: "os", Changed: 23, Old: "0"},
 	{Name: "winsymlink", Package: "os", Changed: 23, Old: "0"},
-	{Name: "x509keypairleaf", Package: "crypto/tls", Changed: 23, Old: "0"},
 	{Name: "x509negativeserial", Package: "crypto/x509", Changed: 23, Old: "1"},
 	{Name: "x509rsacrt", Package: "crypto/x509", Changed: 24, Old: "0"},
 	{Name: "x509sha256skid", Package: "crypto/x509", Changed: 25, Old: "0"},
+	{Name: "x509sslcertoverrideplatform", Package: "crypto/x509", Changed: 27, Old: "0"},
 	{Name: "x509usefallbackroots", Package: "crypto/x509"},
 	{Name: "x509usepolicies", Package: "crypto/x509", Changed: 24, Old: "0"},
 	{Name: "zipinsecurepath", Package: "archive/zip"},
 }
 
+// A RemovedInfo describes a GODEBUG setting that has been removed.
+//
+// Per the policy for removing GODEBUG settings (go.dev/issue/76163), using any non-"old"
+// value for the removed setting is permissible. Using an old value, indicating a non-final
+// default value for that setting, leads to a build or vet error.
+// To support multiple "old" values (see asynctimerchan), the Old field is a predicate.
 type RemovedInfo struct {
-	Name    string // name of the removed GODEBUG setting.
-	Removed int    // minor version of Go, when the removal happened
+	Name    string            // name of the removed GODEBUG setting.
+	Removed int               // minor version of Go, when the removal happened
+	Old     func(string) bool // reports whether the GODEBUG value (argument) is an old (invalid) value
 }
 
 // Removed contains all GODEBUGs that we have removed.
+//
+// Every removed GODEBUG must have a corresponding section in doc/godebug.md,
+// since cmd/go links to that document when a removed GODEBUG is used.
 var Removed = []RemovedInfo{
-	{Name: "x509sha1", Removed: 24},
+	{Name: "x509sha1", Removed: 24, Old: one},                                                       // Old: "1"
+	{Name: "tlskyber", Removed: 24, Old: zero},                                                      // Old: "0"
+	{Name: "gotypesalias", Removed: 27, Old: zero},                                                  // Old: "0"
+	{Name: "tlsunsafeekm", Removed: 27, Old: one},                                                   // Old: "1"
+	{Name: "tlsrsakex", Removed: 27, Old: one},                                                      // Old: "1"
+	{Name: "tls3des", Removed: 27, Old: one},                                                        // Old: "1"
+	{Name: "tls10server", Removed: 27, Old: one},                                                    // Old: "1"
+	{Name: "x509keypairleaf", Removed: 27, Old: zero},                                               // Old: "0"
+	{Name: "asynctimerchan", Removed: 27, Old: func(s string) bool { return s == "1" || s == "2" }}, // Old: "1" or "2"
 }
 
+func zero(s string) bool { return s == "0" }
+func one(s string) bool  { return s == "1" }
+
 // Lookup returns the Info with the given name.
 func Lookup(name string) *Info {
 	// binary search, avoiding import of sort.

package/bin/go/src/internal/goexperiment/exp_mapsplitgroup_off.go

@@ -0,0 +1,8 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.mapsplitgroup
+
+package goexperiment
+
+const MapSplitGroup = false
+const MapSplitGroupInt = 0

package/bin/go/src/internal/goexperiment/exp_mapsplitgroup_on.go

@@ -0,0 +1,8 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.mapsplitgroup
+
+package goexperiment
+
+const MapSplitGroup = true
+const MapSplitGroupInt = 1

package/bin/go/src/internal/goexperiment/flags.go

@@ -119,13 +119,15 @@ type Flags struct {
 	// SizeSpecializedMalloc enables malloc implementations that are specialized per size class.
 	SizeSpecializedMalloc bool
 
-	// GoroutineLeakProfile enables the collection of goroutine leak profiles.
-	GoroutineLeakProfile bool
-
 	// SIMD enables the simd package and the compiler's handling
 	// of SIMD intrinsics.
 	SIMD bool
 
 	// RuntimeSecret enables the runtime/secret package.
 	RuntimeSecret bool
+
+	// MapSplitGroup changes the internal representation of map groups
+	// from interleaved key/elem slots (KVKVKVKV) to split key and elem
+	// arrays (KKKKVVVV).
+	MapSplitGroup bool
 }

package/bin/go/src/internal/goversion/goversion.go

@@ -9,4 +9,4 @@ package goversion
 //
 // It should be updated at the start of each development cycle to be
 // the version of the next Go 1.x release. See go.dev/issue/40705.
-const Version = 26
+const Version = 27

package/bin/go/src/internal/lazyregexp/lazyre.go

@@ -43,6 +43,10 @@ func (r *Regexp) FindStringSubmatchIndex(s string) []int {
 	return r.re().FindStringSubmatchIndex(s)
 }
 
+func (r *Regexp) ReplaceAll(src, repl []byte) []byte {
+	return r.re().ReplaceAll(src, repl)
+}
+
 func (r *Regexp) ReplaceAllString(src, repl string) string {
 	return r.re().ReplaceAllString(src, repl)
 }