Merge branch 'golang:master' into master

Author: kevin-valerio

src/bufio/bufio.go

@@ -30,7 +30,7 @@ var (
 
 // Reader implements buffering for an io.Reader object.
 // A new Reader is created by calling [NewReader] or [NewReaderSize];
-// alternatively the zero value of a Reader may be used after calling [Reset]
+// alternatively the zero value of a Reader may be used after calling [Reader.Reset]
 // on it.
 type Reader struct {
 	buf          []byte

src/cmd/compile/internal/ssa/prove.go

@@ -2180,29 +2180,56 @@ func (ft *factsTable) detectSubRelations(v *Value) {
 
 	// Check if we might wrap around. If so, give up.
 	width := uint(v.Type.Size()) * 8
-	if _, ok := safeSub(xLim.min, yLim.max, width); !ok {
-		return // x-y might underflow
-	}
-	if _, ok := safeSub(xLim.max, yLim.min, width); !ok {
-		return // x-y might overflow
+
+	// v >= 1 in the signed domain?
+	var vSignedMinOne bool
+
+	// Signed optimizations
+	if _, ok := safeSub(xLim.min, yLim.max, width); ok {
+		// Large abs negative y can also overflow
+		if _, ok := safeSub(xLim.max, yLim.min, width); ok {
+			// x-y won't overflow
+
+			// Subtracting a positive non-zero number only makes
+			// things smaller. If it's positive or zero, it might
+			// also do nothing (x-0 == v).
+			if yLim.min > 0 {
+				ft.update(v.Block, v, x, signed, lt)
+			} else if yLim.min == 0 {
+				ft.update(v.Block, v, x, signed, lt|eq)
+			}
+
+			// Subtracting a number from a bigger one
+			// can't go below 1. If the numbers might be
+			// equal, then it can't go below 0.
+			//
+			// This requires the overflow checks because
+			// large negative y can cause an overflow.
+			if ft.orderS.Ordered(y, x) {
+				ft.signedMin(v, 1)
+				vSignedMinOne = true
+			} else if ft.orderS.OrderedOrEqual(y, x) {
+				ft.setNonNegative(v)
+			}
+		}
 	}
 
-	// Subtracting a positive non-zero number only makes
-	// things smaller. If it's positive or zero, it might
-	// also do nothing (x-0 == v).
-	if yLim.min > 0 {
-		ft.update(v.Block, v, x, signed, lt)
-	} else if yLim.min == 0 {
-		ft.update(v.Block, v, x, signed, lt|eq)
+	// Unsigned optimizations
+	if _, ok := safeSubU(xLim.umin, yLim.umax, width); ok {
+		if yLim.umin > 0 {
+			ft.update(v.Block, v, x, unsigned, lt)
+		} else {
+			ft.update(v.Block, v, x, unsigned, lt|eq)
+		}
 	}
 
-	// Subtracting a number from a bigger one
-	// can't go below 1. If the numbers might be
-	// equal, then it can't go below 0.
-	if ft.orderS.Ordered(y, x) {
-		ft.signedMin(v, 1)
-	} else if ft.orderS.OrderedOrEqual(y, x) {
-		ft.setNonNegative(v)
+	// Proving v >= 1 in the signed domain automatically
+	// proves it in the unsigned domain, so we can skip it.
+	//
+	// We don't need overflow checks here, since if y < x,
+	// then x-y can never overflow for uint.
+	if !vSignedMinOne && ft.orderU.Ordered(y, x) {
+		ft.unsignedMin(v, 1)
 	}
 }
 

src/cmd/compile/internal/ssagen/intrinsics.go

@@ -2170,7 +2170,7 @@ func findIntrinsic(sym *types.Sym) intrinsicBuilder {
 
 	fn := sym.Name
 	if ssa.IntrinsicsDisable {
-		if pkg == "internal/runtime/sys" && (fn == "GetCallerPC" || fn == "GrtCallerSP" || fn == "GetClosurePtr") ||
+		if pkg == "internal/runtime/sys" && (fn == "GetCallerPC" || fn == "GetCallerSP" || fn == "GetClosurePtr") ||
 			pkg == simdPackage {
 			// These runtime functions don't have definitions, must be intrinsics.
 		} else {

src/cmd/compile/internal/types/type.go

@@ -1683,6 +1683,9 @@ func (t *Type) SetUnderlying(underlying *Type) {
 	if underlying.HasShape() {
 		t.SetHasShape(true)
 	}
+	if underlying.isSIMD {
+		simdify(t, underlying.isSIMDTag)
+	}
 
 	// spec: "The declared type does not inherit any methods bound
 	// to the existing type, but the method set of an interface

src/cmd/compile/internal/walk/range.go

@@ -348,6 +348,8 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		// } else {
 		// hv2, hv1 = decoderune(ha, hv1)
 		fn := typecheck.LookupRuntime("decoderune")
+		// decoderune expects a uint, but hv1 is an int.
+		// This is safe because hv1 is always >= 0.
 		call := mkcall1(fn, fn.Type().ResultsTuple(), &nif.Else, ha, hv1)
 		a := ir.NewAssignListStmt(base.Pos, ir.OAS2, []ir.Node{hv2, hv1}, []ir.Node{call})
 		nif.Else.Append(a)

src/cmd/cover/cover_test.go

@@ -638,3 +638,12 @@ func main() {
 		t.Errorf("unexpected success; want failure due to newline in file path")
 	}
 }
+
+func TestAlignment(t *testing.T) {
+	// Test that cover data structures are aligned appropriately. See issue 58936.
+	testenv.MustHaveGoRun(t)
+	t.Parallel()
+
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "test", "-cover", filepath.Join(testdata, "align.go"), filepath.Join(testdata, "align_test.go"))
+	run(cmd, t)
+}

src/cmd/cover/testdata/align.go

@@ -0,0 +1,11 @@
+// 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 p
+
+var badSlice [8265]byte
+
+func init() {
+	badSlice[0] = 4
+}

src/cmd/cover/testdata/align_test.go

@@ -0,0 +1,10 @@
+// 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 p
+
+import "testing"
+
+func TestFoo(t *testing.T) {
+}

src/cmd/go/testdata/script/cgo_g3.txt

@@ -0,0 +1,18 @@
+[!cgo] skip
+
+# Test that -g3 works with cgo.
+env CGO_CFLAGS=-g3
+go build
+
+-- go.mod --
+module cgog3
+
+go 1.25
+-- m.go --
+package main
+
+import "os/user"
+
+func main() {
+	user.Current()
+}

src/cmd/internal/sys/arch.go

@@ -143,7 +143,7 @@ var ArchLoong64 = &Arch{
 	PtrSize:        8,
 	RegSize:        8,
 	MinLC:          4,
-	Alignment:      8, // Unaligned accesses are not guaranteed to be fast
+	Alignment:      1,
 	CanMergeLoads:  true,
 	CanJumpTable:   true,
 	HasLR:          true,