[dev.simd] all: merge master (9b2d39b) into dev.simd

Conflicts:

- src/internal/buildcfg/exp.go

Merge List:

+ 2025-09-22 9b2d39b75b cmd/compile/internal/ssa: match style and formatting
+ 2025-09-22 e23edf5e55 runtime: don't re-read metrics before check in TestReadMetricsSched
+ 2025-09-22 177cd8d763 log/slog: use a pooled json encoder
+ 2025-09-22 2353c15785 cmd/cgo/internal/test: skip TestMultipleAssign when using UCRT on Windows
+ 2025-09-22 32dfd69282 cmd/dist: disable FIPS 140-3 mode when testing maphash with purego
+ 2025-09-19 7f6ff5ec3e cmd/compile: fix doc word
+ 2025-09-19 9693b94be0 runtime: include stderr when objdump fails
+ 2025-09-19 8616981ce6 log/slog: optimize slog Level.String() to avoid fmt.Sprintf
+ 2025-09-19 b8af744360 testing: fix example for unexported identifier
+ 2025-09-19 51dc5bfe6c Revert "cmd/go: disable cgo by default if CC unset and  DefaultCC doesn't exist"
+ 2025-09-19 ee7bf06cb3 time: improve ParseDuration performance for invalid input
+ 2025-09-19 f9e61a9a32 cmd/compile: duplicate nil check to two branches of write barrier
+ 2025-09-18 3cf1aaf8b9 runtime: use futexes with 64-bit time on Linux
+ 2025-09-18 0ab038af62 cmd/compile/internal/abi: use clear built-in
+ 2025-09-18 00bf24fdca bytes: use clear in test
+ 2025-09-18 f9701d21d2 crypto: use clear built-in
+ 2025-09-18 a58afe44fa net: fix testHookCanceledDial race
+ 2025-09-18 3203a5da29 net/http: avoid connCount underflow race
+ 2025-09-18 8ca209ec39 context: don't return a non-nil from Err before Done is closed
+ 2025-09-18 3032894e04 runtime: make explicit nil check in heapSetTypeSmallHeader
+ 2025-09-17 ef05b66d61 cmd/internal/obj/riscv: add support for Zicond instructions
+ 2025-09-17 78ef487a6f cmd/compile: fix the issue of shift amount exceeding the valid range
+ 2025-09-17 77aac7bb75 runtime: don't enable heap randomization if MSAN or ASAN is enabled
+ 2025-09-17 465b85eb76 runtime: fix CheckScavengedBitsCleared with randomized heap base
+ 2025-09-17 909704b85e encoding/json/v2: fix typo in comment
+ 2025-09-17 3db5979e8c testing: use reflect.TypeAssert and reflect.TypeFor
+ 2025-09-17 6a8dbbecbf path/filepath: fix EvalSymlinks to return ENOTDIR on plan9
+ 2025-09-17 bffe7ad9f1 go/parser: Add TestBothLineAndLeadComment
+ 2025-09-17 02a888e820 go/ast: document that (*ast.File).Comments is sorted by position
+ 2025-09-16 594deca981 cmd/link: simplify PE relocations mapping
+ 2025-09-16 9df1a289ac go/parser: simplify expectSemi
+ 2025-09-16 72ba117bda internal/buildcfg: enable randomizedHeapBase64 by default
+ 2025-09-16 796ea3bc2e os/user: align test file name and build tags
+ 2025-09-16 a69395eab2 runtime/_mkmalloc: add a copy of cloneNode
+ 2025-09-16 cbdad4fc3c cmd/go: check pattern for utf8 validity before call regexp.MustCompile
+ 2025-09-16 c2d85eb999 cmd/go: disable cgo by default if CC unset and  DefaultCC doesn't exist
+ 2025-09-16 ac82fe68aa bytes,strings: remove reference to non-existent SplitFunc
+ 2025-09-16 0b26678db2 cmd/compile: fix mips zerorange implementation
+ 2025-09-16 e2cfc1eb3a cmd/internal/obj/riscv: improve handling of float point moves
+ 2025-09-16 281c632e6e crypto/x509/internal/macos: standardize package name
+ 2025-09-16 61dc7fe30d iter: document that calling yield after terminated range loop causes runtime panic

Change-Id: Ic06019efc855913632003f41eb10c746b3410b0a

22 files changed, 255 insertions, 105 deletions

diff --git a/src/cmd/asm/internal/asm/testdata/riscv64.s b/src/cmd/asm/internal/asm/testdata/riscv64.s
index 4f7e7acd77..07a898465f 100644
--- a/src/cmd/asm/internal/asm/testdata/riscv64.s
+++ b/src/cmd/asm/internal/asm/testdata/riscv64.s
@@ -195,6 +195,12 @@ start:
 	RDTIME		X5				// f32210c0
 	RDINSTRET	X5				// f32220c0
 
+	// 12.3: Integer Conditional Operations (Zicond)
+	CZEROEQZ	X5, X6, X7			// b353530e
+	CZEROEQZ	X5, X7				// b3d3530e
+	CZERONEZ	X5, X6, X7			// b373530e
+	CZERONEZ	X5, X7				// b3f3530e
+
 	// 13.1: Multiplication Operations
 	MUL	X5, X6, X7				// b3035302
 	MULH	X5, X6, X7				// b3135302
@@ -1952,12 +1958,23 @@ start:
 	MOVF	4(X5), F0				// 07a04200
 	MOVF	F0, 4(X5)				// 27a20200
 	MOVF	F0, F1					// d3000020
+	MOVF	X1, F3					// d38100f0
+	MOVF	F3, X1					// d38001e0
+	MOVF	X0, F3					// d30100f0
+	MOVF	$(0.0), F3				// d30100f0
+
+	// Converted to load of symbol (AUIPC + FLW)
+	MOVF	$(709.78271289338397), F3		// 970f000087a10f00
 
 	MOVD	4(X5), F0				// 07b04200
 	MOVD	F0, 4(X5)				// 27b20200
 	MOVD	F0, F1					// d3000022
+	MOVD	F3, X1					// d38001e2
+	MOVD	X1, F3					// d38100f2
+	MOVD	X0, F3					// d30100f2
+	MOVD	$(0.0), F3				// d30100f2
 
-	// Convert to load of symbol (AUIPC + FLD)
+	// Converted to load of symbol (AUIPC + FLD)
 	MOVD	$(709.78271289338397), F3		// 970f000087b10f00
 
 	// TLS load with local-exec (LUI + ADDIW + ADD of TP + load)
diff --git a/src/cmd/cgo/internal/test/test.go b/src/cmd/cgo/internal/test/test.go
index fb4a8250a2..9626407d88 100644
--- a/src/cmd/cgo/internal/test/test.go
+++ b/src/cmd/cgo/internal/test/test.go
@@ -1096,6 +1096,12 @@ func testErrno(t *testing.T) {
 }
 
 func testMultipleAssign(t *testing.T) {
+	if runtime.GOOS == "windows" && usesUCRT(t) {
+		// UCRT's strtol throws an unrecoverable crash when
+		// using an invalid base (that is, not 0 or 2..36).
+		// See go.dev/issue/62887.
+		t.Skip("skipping test on Windows when linking with UCRT")
+	}
 	p := C.CString("234")
 	n, m := C.strtol(p, nil, 345), C.strtol(p, nil, 10)
 	defer C.free(unsafe.Pointer(p))
diff --git a/src/cmd/cgo/internal/test/test_unix.go b/src/cmd/cgo/internal/test/test_unix.go
index 664c4850d3..9f35583125 100644
--- a/src/cmd/cgo/internal/test/test_unix.go
+++ b/src/cmd/cgo/internal/test/test_unix.go
@@ -6,6 +6,13 @@
 
 package cgotest
 
-import "syscall"
+import (
+	"syscall"
+	"testing"
+)
 
 var syscall_dot_SIGCHLD = syscall.SIGCHLD
+
+func usesUCRT(t *testing.T) bool {
+	return false
+}
diff --git a/src/cmd/cgo/internal/test/test_windows.go b/src/cmd/cgo/internal/test/test_windows.go
index 7bfb33a83c..c6f31430cf 100644
--- a/src/cmd/cgo/internal/test/test_windows.go
+++ b/src/cmd/cgo/internal/test/test_windows.go
@@ -4,6 +4,20 @@
 
 package cgotest
 
-import "syscall"
+import (
+	"internal/syscall/windows"
+	"syscall"
+	"testing"
+)
 
 var syscall_dot_SIGCHLD syscall.Signal
+
+// usesUCRT reports whether the test is using the Windows UCRT (Universal C Runtime).
+func usesUCRT(t *testing.T) bool {
+	name, err := syscall.UTF16PtrFromString("ucrtbase.dll")
+	if err != nil {
+		t.Fatal(err)
+	}
+	h, err := windows.GetModuleHandle(name)
+	return err == nil && h != 0
+}
diff --git a/src/cmd/compile/README.md b/src/cmd/compile/README.md
index 79d2336154..1089348030 100644
--- a/src/cmd/compile/README.md
+++ b/src/cmd/compile/README.md
@@ -57,7 +57,7 @@ terms of these, so the next step after type checking is to convert the syntax
 and types2 representations to ir and types. This process is referred to as
 "noding."
 
-Noding using a process called Unified IR, which builds a node representation
+Noding uses a process called Unified IR, which builds a node representation
 using a serialized version of the typechecked code from step 2.
 Unified IR is also involved in import/export of packages and inlining.
 
diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go
index cef7885815..7acab36e8d 100644
--- a/src/cmd/compile/internal/abi/abiutils.go
+++ b/src/cmd/compile/internal/abi/abiutils.go
@@ -664,9 +664,7 @@ func (state *assignState) tryAllocRegs(typ *types.Type) []RegIndex {
 func (pa *ABIParamAssignment) ComputePadding(storage []uint64) []uint64 {
 	nr := len(pa.Registers)
 	padding := storage[:nr]
-	for i := 0; i < nr; i++ {
-		padding[i] = 0
-	}
+	clear(padding)
 	if pa.Type.Kind() != types.TSTRUCT || nr == 0 {
 		return padding
 	}
diff --git a/src/cmd/compile/internal/mips/ggen.go b/src/cmd/compile/internal/mips/ggen.go
index 023f4d958e..394f015589 100644
--- a/src/cmd/compile/internal/mips/ggen.go
+++ b/src/cmd/compile/internal/mips/ggen.go
@@ -5,6 +5,7 @@
 package mips
 
 import (
+	"cmd/compile/internal/base"
 	"cmd/compile/internal/objw"
 	"cmd/compile/internal/types"
 	"cmd/internal/obj"
@@ -17,7 +18,7 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog
 	}
 
 	for cnt != 0 {
-		p = pp.Append(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, off)
+		p = pp.Append(p, mips.AMOVW, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, base.Ctxt.Arch.FixedFrameSize+off)
 		cnt -= int64(types.PtrSize)
 		off += int64(types.PtrSize)
 	}
diff --git a/src/cmd/compile/internal/mips64/ggen.go b/src/cmd/compile/internal/mips64/ggen.go
index 0740d9abe8..740d68e335 100644
--- a/src/cmd/compile/internal/mips64/ggen.go
+++ b/src/cmd/compile/internal/mips64/ggen.go
@@ -17,7 +17,7 @@ func zerorange(pp *objw.Progs, p *obj.Prog, off, cnt int64, _ *uint32) *obj.Prog
 	}
 
 	for cnt != 0 {
-		p = pp.Append(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, off)
+		p = pp.Append(p, mips.AMOVV, obj.TYPE_REG, mips.REGZERO, 0, obj.TYPE_MEM, mips.REGSP, off+8)
 		cnt -= int64(types.PtrSize)
 		off += int64(types.PtrSize)
 	}
diff --git a/src/cmd/compile/internal/ssa/README.md b/src/cmd/compile/internal/ssa/README.md
index 8184f9c002..3626f5bb7b 100644
--- a/src/cmd/compile/internal/ssa/README.md
+++ b/src/cmd/compile/internal/ssa/README.md
@@ -48,8 +48,7 @@ However, certain types don't come from Go and are special; below we will cover
 
 Some operators contain an auxiliary field. The aux fields are usually printed as
 enclosed in `[]` or `{}`, and could be the constant op argument, argument type,
-etc.
-for example:
+etc. For example:
 
 	v13 (?) = Const64 <int> [1]
 
diff --git a/src/cmd/compile/internal/ssa/_gen/LOONG64.rules b/src/cmd/compile/internal/ssa/_gen/LOONG64.rules
index d0a64364d6..0d2384143c 100644
--- a/src/cmd/compile/internal/ssa/_gen/LOONG64.rules
+++ b/src/cmd/compile/internal/ssa/_gen/LOONG64.rules
@@ -717,7 +717,8 @@
 (SRLVconst [rc] (MOVBUreg x)) && rc >= 8 => (MOVVconst [0])
 
 // (x + x) << c -> x << c+1
-((SLLV|SLL)const [c] (ADDV x x)) => ((SLLV|SLL)const [c+1] x)
+((SLLV|SLL)const <t> [c] (ADDV x x)) && c < t.Size() * 8 - 1  => ((SLLV|SLL)const [c+1] x)
+((SLLV|SLL)const <t> [c] (ADDV x x)) && c >= t.Size() * 8 - 1 => (MOVVconst [0])
 
 // mul by constant
 (MULV _ (MOVVconst [0])) => (MOVVconst [0])
diff --git a/src/cmd/compile/internal/ssa/_gen/LOONG64Ops.go b/src/cmd/compile/internal/ssa/_gen/LOONG64Ops.go
index 0d5e0eb76f..a3db4def56 100644
--- a/src/cmd/compile/internal/ssa/_gen/LOONG64Ops.go
+++ b/src/cmd/compile/internal/ssa/_gen/LOONG64Ops.go
@@ -247,7 +247,7 @@ func init() {
 		{name: "SLL", argLength: 2, reg: gp21, asm: "SLL"},                        // arg0 << arg1, shift amount is mod 32
 		{name: "SLLV", argLength: 2, reg: gp21, asm: "SLLV"},                      // arg0 << arg1, shift amount is mod 64
 		{name: "SLLconst", argLength: 1, reg: gp11, asm: "SLL", aux: "Int64"},     // arg0 << auxInt, auxInt should be in the range 0 to 31.
-		{name: "SLLVconst", argLength: 1, reg: gp11, asm: "SLLV", aux: "Int64"},   // arg0 << auxInt
+		{name: "SLLVconst", argLength: 1, reg: gp11, asm: "SLLV", aux: "Int64"},   // arg0 << auxInt, auxInt should be in the range 0 to 63.
 		{name: "SRL", argLength: 2, reg: gp21, asm: "SRL"},                        // arg0 >> arg1, shift amount is mod 32
 		{name: "SRLV", argLength: 2, reg: gp21, asm: "SRLV"},                      // arg0 >> arg1, unsigned, shift amount is mod 64
 		{name: "SRLconst", argLength: 1, reg: gp11, asm: "SRL", aux: "Int64"},     // arg0 >> auxInt, auxInt should be in the range 0 to 31.
diff --git a/src/cmd/compile/internal/ssa/rewriteLOONG64.go b/src/cmd/compile/internal/ssa/rewriteLOONG64.go
index 6a9b723c8c..3990b2833b 100644
--- a/src/cmd/compile/internal/ssa/rewriteLOONG64.go
+++ b/src/cmd/compile/internal/ssa/rewriteLOONG64.go
@@ -6561,15 +6561,17 @@ func rewriteValueLOONG64_OpLOONG64SLLV(v *Value) bool {
 }
 func rewriteValueLOONG64_OpLOONG64SLLVconst(v *Value) bool {
 	v_0 := v.Args[0]
-	// match: (SLLVconst [c] (ADDV x x))
+	// match: (SLLVconst <t> [c] (ADDV x x))
+	// cond: c < t.Size() * 8 - 1
 	// result: (SLLVconst [c+1] x)
 	for {
+		t := v.Type
 		c := auxIntToInt64(v.AuxInt)
 		if v_0.Op != OpLOONG64ADDV {
 			break
 		}
 		x := v_0.Args[1]
-		if x != v_0.Args[0] {
+		if x != v_0.Args[0] || !(c < t.Size()*8-1) {
 			break
 		}
 		v.reset(OpLOONG64SLLVconst)
@@ -6577,6 +6579,23 @@ func rewriteValueLOONG64_OpLOONG64SLLVconst(v *Value) bool {
 		v.AddArg(x)
 		return true
 	}
+	// match: (SLLVconst <t> [c] (ADDV x x))
+	// cond: c >= t.Size() * 8 - 1
+	// result: (MOVVconst [0])
+	for {
+		t := v.Type
+		c := auxIntToInt64(v.AuxInt)
+		if v_0.Op != OpLOONG64ADDV {
+			break
+		}
+		x := v_0.Args[1]
+		if x != v_0.Args[0] || !(c >= t.Size()*8-1) {
+			break
+		}
+		v.reset(OpLOONG64MOVVconst)
+		v.AuxInt = int64ToAuxInt(0)
+		return true
+	}
 	// match: (SLLVconst [c] (MOVVconst [d]))
 	// result: (MOVVconst [d<<uint64(c)])
 	for {
@@ -6593,15 +6612,17 @@ func rewriteValueLOONG64_OpLOONG64SLLVconst(v *Value) bool {
 }
 func rewriteValueLOONG64_OpLOONG64SLLconst(v *Value) bool {
 	v_0 := v.Args[0]
-	// match: (SLLconst [c] (ADDV x x))
+	// match: (SLLconst <t> [c] (ADDV x x))
+	// cond: c < t.Size() * 8 - 1
 	// result: (SLLconst [c+1] x)
 	for {
+		t := v.Type
 		c := auxIntToInt64(v.AuxInt)
 		if v_0.Op != OpLOONG64ADDV {
 			break
 		}
 		x := v_0.Args[1]
-		if x != v_0.Args[0] {
+		if x != v_0.Args[0] || !(c < t.Size()*8-1) {
 			break
 		}
 		v.reset(OpLOONG64SLLconst)
@@ -6609,6 +6630,23 @@ func rewriteValueLOONG64_OpLOONG64SLLconst(v *Value) bool {
 		v.AddArg(x)
 		return true
 	}
+	// match: (SLLconst <t> [c] (ADDV x x))
+	// cond: c >= t.Size() * 8 - 1
+	// result: (MOVVconst [0])
+	for {
+		t := v.Type
+		c := auxIntToInt64(v.AuxInt)
+		if v_0.Op != OpLOONG64ADDV {
+			break
+		}
+		x := v_0.Args[1]
+		if x != v_0.Args[0] || !(c >= t.Size()*8-1) {
+			break
+		}
+		v.reset(OpLOONG64MOVVconst)
+		v.AuxInt = int64ToAuxInt(0)
+		return true
+	}
 	return false
 }
 func rewriteValueLOONG64_OpLOONG64SRA(v *Value) bool {
diff --git a/src/cmd/compile/internal/ssa/writebarrier.go b/src/cmd/compile/internal/ssa/writebarrier.go
index 9ef3667d51..ec6901f13e 100644
--- a/src/cmd/compile/internal/ssa/writebarrier.go
+++ b/src/cmd/compile/internal/ssa/writebarrier.go
@@ -303,6 +303,15 @@ func writebarrier(f *Func) {
 		mem := stores[0].MemoryArg()
 		pos := stores[0].Pos
 
+		// If there is a nil check before the WB store, duplicate it to
+		// the two branches, where the store and the WB load occur. So
+		// they are more likely be removed by late nilcheck removal (which
+		// is block-local).
+		var nilcheck, nilcheckThen, nilcheckEnd *Value
+		if a := stores[0].Args[0]; a.Op == OpNilCheck && a.Args[1] == mem {
+			nilcheck = a
+		}
+
 		// If the source of a MoveWB is volatile (will be clobbered by a
 		// function call), we need to copy it to a temporary location, as
 		// marshaling the args of wbMove might clobber the value we're
@@ -377,6 +386,10 @@ func writebarrier(f *Func) {
 		// For each write barrier store, append write barrier code to bThen.
 		memThen := mem
 
+		if nilcheck != nil {
+			nilcheckThen = bThen.NewValue2(nilcheck.Pos, OpNilCheck, nilcheck.Type, nilcheck.Args[0], memThen)
+		}
+
 		// Note: we can issue the write barrier code in any order. In particular,
 		// it doesn't matter if they are in a different order *even if* they end
 		// up referring to overlapping memory regions. For instance if an OpStore
@@ -447,6 +460,9 @@ func writebarrier(f *Func) {
 				// take care of the vast majority of these. We could
 				// patch this up in the signal handler, or use XCHG to
 				// combine the read and the write.
+				if ptr == nilcheck {
+					ptr = nilcheckThen
+				}
 				oldVal := bThen.NewValue2(pos, OpLoad, types.Types[types.TUINTPTR], ptr, memThen)
 				// Save old value to write buffer.
 				addEntry(pos, oldVal)
@@ -459,9 +475,12 @@ func writebarrier(f *Func) {
 		// Now do the rare cases, Zeros and Moves.
 		for _, w := range stores {
 			pos := w.Pos
+			dst := w.Args[0]
+			if dst == nilcheck {
+				dst = nilcheckThen
+			}
 			switch w.Op {
 			case OpZeroWB:
-				dst := w.Args[0]
 				typ := reflectdata.TypeLinksym(w.Aux.(*types.Type))
 				// zeroWB(&typ, dst)
 				taddr := b.NewValue1A(pos, OpAddr, b.Func.Config.Types.Uintptr, typ, sb)
@@ -469,7 +488,6 @@ func writebarrier(f *Func) {
 				f.fe.Func().SetWBPos(pos)
 				nWBops--
 			case OpMoveWB:
-				dst := w.Args[0]
 				src := w.Args[1]
 				if isVolatile(src) {
 					for _, c := range volatiles {
@@ -491,24 +509,29 @@ func writebarrier(f *Func) {
 		// merge memory
 		mem = bEnd.NewValue2(pos, OpPhi, types.TypeMem, mem, memThen)
 
+		if nilcheck != nil {
+			nilcheckEnd = bEnd.NewValue2(nilcheck.Pos, OpNilCheck, nilcheck.Type, nilcheck.Args[0], mem)
+		}
+
 		// Do raw stores after merge point.
 		for _, w := range stores {
 			pos := w.Pos
+			dst := w.Args[0]
+			if dst == nilcheck {
+				dst = nilcheckEnd
+			}
 			switch w.Op {
 			case OpStoreWB:
-				ptr := w.Args[0]
 				val := w.Args[1]
 				if buildcfg.Experiment.CgoCheck2 {
 					// Issue cgo checking code.
-					mem = wbcall(pos, bEnd, cgoCheckPtrWrite, sp, mem, ptr, val)
+					mem = wbcall(pos, bEnd, cgoCheckPtrWrite, sp, mem, dst, val)
 				}
-				mem = bEnd.NewValue3A(pos, OpStore, types.TypeMem, w.Aux, ptr, val, mem)
+				mem = bEnd.NewValue3A(pos, OpStore, types.TypeMem, w.Aux, dst, val, mem)
 			case OpZeroWB:
-				dst := w.Args[0]
 				mem = bEnd.NewValue2I(pos, OpZero, types.TypeMem, w.AuxInt, dst, mem)
 				mem.Aux = w.Aux
 			case OpMoveWB:
-				dst := w.Args[0]
 				src := w.Args[1]
 				if isVolatile(src) {
 					for _, c := range volatiles {
@@ -529,9 +552,8 @@ func writebarrier(f *Func) {
 			case OpVarDef, OpVarLive:
 				mem = bEnd.NewValue1A(pos, w.Op, types.TypeMem, w.Aux, mem)
 			case OpStore:
-				ptr := w.Args[0]
 				val := w.Args[1]
-				mem = bEnd.NewValue3A(pos, OpStore, types.TypeMem, w.Aux, ptr, val, mem)
+				mem = bEnd.NewValue3A(pos, OpStore, types.TypeMem, w.Aux, dst, val, mem)
 			}
 		}
 
@@ -557,6 +579,9 @@ func writebarrier(f *Func) {
 				f.freeValue(w)
 			}
 		}
+		if nilcheck != nil && nilcheck.Uses == 0 {
+			nilcheck.reset(OpInvalid)
+		}
 
 		// put values after the store sequence into the end block
 		bEnd.Values = append(bEnd.Values, after...)
diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 1200303334..b9673564ec 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -705,6 +705,7 @@ func (t *tester) registerTests() {
 				timeout: 300 * time.Second,
 				tags:    []string{"purego"},
 				pkg:     "hash/maphash",
+				env:     []string{"GODEBUG=fips140=off"}, // FIPS 140-3 mode is incompatible with purego
 			})
 	}
 
diff --git a/src/cmd/go/internal/modget/query.go b/src/cmd/go/internal/modget/query.go
index f95b503d8f..05872d52ec 100644
--- a/src/cmd/go/internal/modget/query.go
+++ b/src/cmd/go/internal/modget/query.go
@@ -10,6 +10,7 @@ import (
 	"regexp"
 	"strings"
 	"sync"
+	"unicode/utf8"
 
 	"cmd/go/internal/base"
 	"cmd/go/internal/gover"
@@ -285,6 +286,11 @@ func reportError(q *query, err error) {
 	// TODO(bcmills): Use errors.As to unpack these errors instead of parsing
 	// strings with regular expressions.
 
+	if !utf8.ValidString(q.pattern) || !utf8.ValidString(q.version) {
+		base.Errorf("go: %s", errStr)
+		return
+	}
+
 	patternRE := regexp.MustCompile("(?m)(?:[ \t(\"`]|^)" + regexp.QuoteMeta(q.pattern) + "(?:[ @:;)\"`]|$)")
 	if patternRE.MatchString(errStr) {
 		if q.rawVersion == "" {
diff --git a/src/cmd/go/testdata/script/get_panic_issue75251.txt b/src/cmd/go/testdata/script/get_panic_issue75251.txt
new file mode 100644
index 0000000000..2cc3f3a9c4
--- /dev/null
+++ b/src/cmd/go/testdata/script/get_panic_issue75251.txt
@@ -0,0 +1,16 @@
+# Issue #75251: Don't panic if the package path or the package version
+# contains invalid UTF-8 characters.
+
+go mod init m
+
+! go get golang.org/x/net/http/httpgutsÿv0.43.0 # contains 0xff byte
+! stderr panic
+stderr 'malformed module path'
+
+! go get golang.org/x/net/http/httpgutsÿ@v0.43.0 # contains 0xff byte
+! stderr panic
+stderr 'malformed module path'
+
+! go get golang.org/x/net/http/httpguts@ÿv0.43.0 # contains 0xff byte
+! stderr panic
+stderr 'disallowed version string'
diff --git a/src/cmd/internal/obj/riscv/anames.go b/src/cmd/internal/obj/riscv/anames.go
index 88ac746573..a8807fc7a8 100644
--- a/src/cmd/internal/obj/riscv/anames.go
+++ b/src/cmd/internal/obj/riscv/anames.go
@@ -61,6 +61,8 @@ var Anames = []string{
 	"CSRRWI",
 	"CSRRSI",
 	"CSRRCI",
+	"CZEROEQZ",
+	"CZERONEZ",
 	"MUL",
 	"MULH",
 	"MULHU",
diff --git a/src/cmd/internal/obj/riscv/cpu.go b/src/cmd/internal/obj/riscv/cpu.go
index e265e04482..305ef061e3 100644
--- a/src/cmd/internal/obj/riscv/cpu.go
+++ b/src/cmd/internal/obj/riscv/cpu.go
@@ -409,6 +409,10 @@ const (
 	ACSRRSI
 	ACSRRCI
 
+	// 12.3: Integer Conditional Operations (Zicond)
+	ACZEROEQZ
+	ACZERONEZ
+
 	// 13.1: Multiplication Operations
 	AMUL
 	AMULH
diff --git a/src/cmd/internal/obj/riscv/inst.go b/src/cmd/internal/obj/riscv/inst.go
index a6a03dc565..a5b3acdb18 100644
--- a/src/cmd/internal/obj/riscv/inst.go
+++ b/src/cmd/internal/obj/riscv/inst.go
@@ -1,4 +1,4 @@
-// Code generated by ./parse.py -go rv64_a rv64_c rv64_d rv64_f rv64_i rv64_m rv64_q rv64_zba rv64_zbb rv64_zbs rv_a rv_c rv_c_d rv_d rv_f rv_i rv_m rv_q rv_s rv_system rv_v rv_zba rv_zbb rv_zbs rv_zicsr; DO NOT EDIT.
+// Code generated by ./parse.py -go rv64_a rv64_c rv64_d rv64_f rv64_i rv64_m rv64_q rv64_zba rv64_zbb rv64_zbs rv_a rv_c rv_c_d rv_d rv_f rv_i rv_m rv_q rv_s rv_system rv_v rv_zba rv_zbb rv_zbs rv_zicond rv_zicsr; DO NOT EDIT.
 package riscv
 
 import "cmd/internal/obj"
@@ -194,6 +194,10 @@ func encode(a obj.As) *inst {
 		return &inst{0x13, 0x1, 0x0, 0x1, 1537, 0x30}
 	case ACTZW:
 		return &inst{0x1b, 0x1, 0x0, 0x1, 1537, 0x30}
+	case ACZEROEQZ:
+		return &inst{0x33, 0x5, 0x0, 0x0, 224, 0x7}
+	case ACZERONEZ:
+		return &inst{0x33, 0x7, 0x0, 0x0, 224, 0x7}
 	case ADIV:
 		return &inst{0x33, 0x4, 0x0, 0x0, 32, 0x1}
 	case ADIVU:
diff --git a/src/cmd/internal/obj/riscv/obj.go b/src/cmd/internal/obj/riscv/obj.go
index 1538d03179..9d595f301c 100644
--- a/src/cmd/internal/obj/riscv/obj.go
+++ b/src/cmd/internal/obj/riscv/obj.go
@@ -29,6 +29,7 @@ import (
 	"internal/abi"
 	"internal/buildcfg"
 	"log"
+	"math"
 	"math/bits"
 	"strings"
 )
@@ -145,9 +146,29 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 			p.From.Offset = 0
 		}
 
+	case AMOVF:
+		if p.From.Type == obj.TYPE_FCONST && p.From.Name == obj.NAME_NONE && p.From.Reg == obj.REG_NONE {
+			f64 := p.From.Val.(float64)
+			f32 := float32(f64)
+			if math.Float32bits(f32) == 0 {
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REG_ZERO
+				break
+			}
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Float32Sym(f32)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+
 	case AMOVD:
 		if p.From.Type == obj.TYPE_FCONST && p.From.Name == obj.NAME_NONE && p.From.Reg == obj.REG_NONE {
 			f64 := p.From.Val.(float64)
+			if math.Float64bits(f64) == 0 {
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REG_ZERO
+				break
+			}
 			p.From.Type = obj.TYPE_MEM
 			p.From.Sym = ctxt.Float64Sym(f64)
 			p.From.Name = obj.NAME_EXTERN
@@ -1927,6 +1948,10 @@ var instructions = [ALAST & obj.AMask]instructionData{
 	ACSRRW & obj.AMask:  {enc: iIIEncoding, immForm: ACSRRWI},
 	ACSRRWI & obj.AMask: {enc: iIIEncoding},
 
+	// 12.3: "Zicond" Extension for Integer Conditional Operations
+	ACZERONEZ & obj.AMask: {enc: rIIIEncoding, ternary: true},
+	ACZEROEQZ & obj.AMask: {enc: rIIIEncoding, ternary: true},
+
 	// 13.1: Multiplication Operations
 	AMUL & obj.AMask:    {enc: rIIIEncoding, ternary: true},
 	AMULH & obj.AMask:   {enc: rIIIEncoding, ternary: true},
@@ -3254,16 +3279,37 @@ func instructionsForMOV(p *obj.Prog) []*instruction {
 	case p.From.Type == obj.TYPE_REG && p.To.Type == obj.TYPE_REG:
 		// Handle register to register moves.
 		switch p.As {
-		case AMOV: // MOV Ra, Rb -> ADDI $0, Ra, Rb
+		case AMOV:
+			// MOV Ra, Rb -> ADDI $0, Ra, Rb
 			ins.as, ins.rs1, ins.rs2, ins.imm = AADDI, uint32(p.From.Reg), obj.REG_NONE, 0
-		case AMOVW: // MOVW Ra, Rb -> ADDIW $0, Ra, Rb
+		case AMOVW:
+			// MOVW Ra, Rb -> ADDIW $0, Ra, Rb
 			ins.as, ins.rs1, ins.rs2, ins.imm = AADDIW, uint32(p.From.Reg), obj.REG_NONE, 0
-		case AMOVBU: // MOVBU Ra, Rb -> ANDI $255, Ra, Rb
+		case AMOVBU:
+			// MOVBU Ra, Rb -> ANDI $255, Ra, Rb
 			ins.as, ins.rs1, ins.rs2, ins.imm = AANDI, uint32(p.From.Reg), obj.REG_NONE, 255
-		case AMOVF: // MOVF Ra, Rb -> FSGNJS Ra, Ra, Rb
-			ins.as, ins.rs1 = AFSGNJS, uint32(p.From.Reg)
-		case AMOVD: // MOVD Ra, Rb -> FSGNJD Ra, Ra, Rb
-			ins.as, ins.rs1 = AFSGNJD, uint32(p.From.Reg)
+		case AMOVF:
+			// MOVF Ra, Rb -> FSGNJS Ra, Ra, Rb
+			//          or -> FMVWX  Ra, Rb
+			//          or -> FMVXW  Ra, Rb
+			if ins.rs2 >= REG_X0 && ins.rs2 <= REG_X31 && ins.rd >= REG_F0 && ins.rd <= REG_F31 {
+				ins.as = AFMVWX
+			} else if ins.rs2 >= REG_F0 && ins.rs2 <= REG_F31 && ins.rd >= REG_X0 && ins.rd <= REG_X31 {
+				ins.as = AFMVXW
+			} else {
+				ins.as, ins.rs1 = AFSGNJS, uint32(p.From.Reg)
+			}
+		case AMOVD:
+			// MOVD Ra, Rb -> FSGNJD Ra, Ra, Rb
+			//          or -> FMVDX  Ra, Rb
+			//          or -> FMVXD  Ra, Rb
+			if ins.rs2 >= REG_X0 && ins.rs2 <= REG_X31 && ins.rd >= REG_F0 && ins.rd <= REG_F31 {
+				ins.as = AFMVDX
+			} else if ins.rs2 >= REG_F0 && ins.rs2 <= REG_F31 && ins.rd >= REG_X0 && ins.rd <= REG_X31 {
+				ins.as = AFMVXD
+			} else {
+				ins.as, ins.rs1 = AFSGNJD, uint32(p.From.Reg)
+			}
 		case AMOVB, AMOVH:
 			if buildcfg.GORISCV64 >= 22 {
 				// Use SEXTB or SEXTH to extend.
diff --git a/src/cmd/internal/pkgpattern/pkgpattern.go b/src/cmd/internal/pkgpattern/pkgpattern.go
index 1496eebb3e..5bbe8a52fb 100644
--- a/src/cmd/internal/pkgpattern/pkgpattern.go
+++ b/src/cmd/internal/pkgpattern/pkgpattern.go
@@ -7,6 +7,7 @@ package pkgpattern
 import (
 	"regexp"
 	"strings"
+	"unicode/utf8"
 )
 
 // Note: most of this code was originally part of the cmd/go/internal/search
@@ -71,7 +72,7 @@ func matchPatternInternal(pattern string, vendorExclude bool) func(name string)
 
 	const vendorChar = "\x00"
 
-	if vendorExclude && strings.Contains(pattern, vendorChar) {
+	if vendorExclude && strings.Contains(pattern, vendorChar) || !utf8.ValidString(pattern) {
 		return func(name string) bool { return false }
 	}
 
diff --git a/src/cmd/link/internal/loadpe/ldpe.go b/src/cmd/link/internal/loadpe/ldpe.go
index b895ac4149..d3a050135c 100644
--- a/src/cmd/link/internal/loadpe/ldpe.go
+++ b/src/cmd/link/internal/loadpe/ldpe.go
@@ -17,6 +17,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"strconv"
 	"strings"
 )
 
@@ -348,11 +349,11 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 				return nil, fmt.Errorf("relocation number %d symbol index idx=%d cannot be large then number of symbols %d", j, r.SymbolTableIndex, len(f.COFFSymbols))
 			}
 			pesym := &f.COFFSymbols[r.SymbolTableIndex]
-			_, gosym, err := state.readpesym(pesym)
+			_, rSym, err := state.readpesym(pesym)
 			if err != nil {
 				return nil, err
 			}
-			if gosym == 0 {
+			if rSym == 0 {
 				name, err := pesym.FullName(f.StringTable)
 				if err != nil {
 					name = string(pesym.Name[:])
@@ -360,90 +361,53 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, input *bio.Read
 				return nil, fmt.Errorf("reloc of invalid sym %s idx=%d type=%d", name, r.SymbolTableIndex, pesym.Type)
 			}
 
-			rSym := gosym
 			rSize := uint8(4)
 			rOff := int32(r.VirtualAddress)
-			var rAdd int64
 			var rType objabi.RelocType
 			switch arch.Family {
 			default:
 				return nil, fmt.Errorf("%s: unsupported arch %v", pn, arch.Family)
-			case sys.I386, sys.AMD64:
+			case sys.I386:
 				switch r.Type {
-				default:
-					return nil, fmt.Errorf("%s: %v: unknown relocation type %v", pn, state.sectsyms[rsect], r.Type)
-
-				case IMAGE_REL_I386_REL32, IMAGE_REL_AMD64_REL32,
-					IMAGE_REL_AMD64_ADDR32, // R_X86_64_PC32
-					IMAGE_REL_AMD64_ADDR32NB:
-					if r.Type == IMAGE_REL_AMD64_ADDR32NB {
-						rType = objabi.R_PEIMAGEOFF
-					} else {
-						rType = objabi.R_PCREL
-					}
-
-					rAdd = int64(int32(binary.LittleEndian.Uint32(state.sectdata[rsect][rOff:])))
-
-				case IMAGE_REL_I386_DIR32NB, IMAGE_REL_I386_DIR32:
-					if r.Type == IMAGE_REL_I386_DIR32NB {
-						rType = objabi.R_PEIMAGEOFF
-					} else {
-						rType = objabi.R_ADDR
-					}
-
-					// load addend from image
-					rAdd = int64(int32(binary.LittleEndian.Uint32(state.sectdata[rsect][rOff:])))
-
-				case IMAGE_REL_AMD64_ADDR64: // R_X86_64_64
-					rSize = 8
-
+				case IMAGE_REL_I386_REL32:
+					rType = objabi.R_PCREL
+				case IMAGE_REL_I386_DIR32:
 					rType = objabi.R_ADDR
-
-					// load addend from image
-					rAdd = int64(binary.LittleEndian.Uint64(state.sectdata[rsect][rOff:]))
+				case IMAGE_REL_I386_DIR32NB:
+					rType = objabi.R_PEIMAGEOFF
 				}
-
-			case sys.ARM:
+			case sys.AMD64:
 				switch r.Type {
-				default:
-					return nil, fmt.Errorf("%s: %v: unknown ARM relocation type %v", pn, state.sectsyms[rsect], r.Type)
-
-				case IMAGE_REL_ARM_SECREL:
+				case IMAGE_REL_AMD64_REL32:
 					rType = objabi.R_PCREL
-
-					rAdd = int64(int32(binary.LittleEndian.Uint32(state.sectdata[rsect][rOff:])))
-
-				case IMAGE_REL_ARM_ADDR32, IMAGE_REL_ARM_ADDR32NB:
-					if r.Type == IMAGE_REL_ARM_ADDR32NB {
-						rType = objabi.R_PEIMAGEOFF
-					} else {
-						rType = objabi.R_ADDR
-					}
-
-					rAdd = int64(int32(binary.LittleEndian.Uint32(state.sectdata[rsect][rOff:])))
-
-				case IMAGE_REL_ARM_BRANCH24:
-					rType = objabi.R_CALLARM
-
-					rAdd = int64(int32(binary.LittleEndian.Uint32(state.sectdata[rsect][rOff:])))
+				case IMAGE_REL_AMD64_ADDR32:
+					rType = objabi.R_ADDR
+				case IMAGE_REL_AMD64_ADDR64:
+					rType = objabi.R_ADDR
+					rSize = 8
+				case IMAGE_REL_AMD64_ADDR32NB:
+					rType = objabi.R_PEIMAGEOFF
 				}
-
 			case sys.ARM64:
 				switch r.Type {
-				default:
-					return nil, fmt.Errorf("%s: %v: unknown ARM64 relocation type %v", pn, state.sectsyms[rsect], r.Type)
-
-				case IMAGE_REL_ARM64_ADDR32, IMAGE_REL_ARM64_ADDR32NB:
-					if r.Type == IMAGE_REL_ARM64_ADDR32NB {
-						rType = objabi.R_PEIMAGEOFF
-					} else {
-						rType = objabi.R_ADDR
-					}
-
-					rAdd = int64(int32(binary.LittleEndian.Uint32(state.sectdata[rsect][rOff:])))
+				case IMAGE_REL_ARM64_ADDR32:
+					rType = objabi.R_ADDR
+				case IMAGE_REL_ARM64_ADDR32NB:
+					rType = objabi.R_PEIMAGEOFF
 				}
 			}
-
+			if rType == 0 {
+				return nil, fmt.Errorf("%s: %v: unknown relocation type %v", pn, state.sectsyms[rsect], r.Type)
+			}
+			var rAdd int64
+			switch rSize {
+			default:
+				panic("unexpected relocation size " + strconv.Itoa(int(rSize)))
+			case 4:
+				rAdd = int64(int32(binary.LittleEndian.Uint32(state.sectdata[rsect][rOff:])))
+			case 8:
+				rAdd = int64(binary.LittleEndian.Uint64(state.sectdata[rsect][rOff:]))
+			}
 			// ld -r could generate multiple section symbols for the
 			// same section but with different values, we have to take
 			// that into account, or in the case of split resources,