Merge branch 'master' of github.com:kevin-valerio/go-arithmetic-panik

Author: kevin-valerio

doc/godebug.md

@@ -189,6 +189,11 @@ crypto/x509.CreateCertificate. The setting `x509sha256skid=0` reverts to SHA-1.
 Go 1.25 corrected the semantics of contention reports for runtime-internal locks,
 and so removed the [`runtimecontentionstacks` setting](/pkg/runtime#hdr-Environment_Variables).
 
+Go 1.25 (starting with Go 1.25 RC 2) disabled build information stamping when
+multiple VCS are detected due to concerns around VCS injection attacks. This
+behavior and setting was backported to Go 1.24.5 and Go 1.23.11. This behavior
+can be renabled with the setting `allowmultiplevcs=1`.
+
 ### Go 1.24
 
 Go 1.24 added a new `fips140` setting that controls whether the Go

src/cmd/cgo/internal/testsanitizers/asan_test.go

@@ -8,6 +8,7 @@ package sanitizers_test
 
 import (
 	"bytes"
+	"crypto/fips140"
 	"fmt"
 	"internal/platform"
 	"internal/testenv"
@@ -157,6 +158,10 @@ func mustHaveASAN(t *testing.T) *config {
 		t.Skipf("skipping on %s/%s; -asan option is not supported.", goos, goarch)
 	}
 
+	if fips140.Enabled() {
+		t.Skipf("skipping with FIPS 140 mode; -asan option is not supported.")
+	}
+
 	// The current implementation is only compatible with the ASan library from version
 	// v7 to v9 (See the description in src/runtime/asan/asan.go). Therefore, using the
 	// -asan option must use a compatible version of ASan library, which requires that

src/cmd/compile/doc.go

@@ -253,6 +253,9 @@ The //go:nosplit directive must be followed by a function declaration.
 It specifies that the function must omit its usual stack overflow check.
 This is most commonly used by low-level runtime code invoked
 at times when it is unsafe for the calling goroutine to be preempted.
+Using this directive outside of low-level runtime code is not safe,
+because it permits the nosplit function to overwrite the end of stack,
+leading to memory corruption and arbitrary program failure.
 
 # Linkname Directive
 

src/cmd/compile/internal/base/debug.go

@@ -40,6 +40,7 @@ type DebugFlags struct {
 	InlFuncsWithClosures  int    `help:"allow functions with closures to be inlined" concurrent:"ok"`
 	InlStaticInit         int    `help:"allow static initialization of inlined calls" concurrent:"ok"`
 	Libfuzzer             int    `help:"enable coverage instrumentation for libfuzzer"`
+	LiteralAllocHash      string `help:"hash value for use in debugging literal allocation optimizations" concurrent:"ok"`
 	LoopVar               int    `help:"shared (0, default), 1 (private loop variables), 2, private + log"`
 	LoopVarHash           string `help:"for debugging changes in loop behavior. Overrides experiment and loopvar flag."`
 	LocationLists         int    `help:"print information about DWARF location list creation"`

src/cmd/compile/internal/base/flag.go

@@ -268,6 +268,10 @@ func ParseFlags() {
 	if Debug.PGOHash != "" {
 		PGOHash = NewHashDebug("pgohash", Debug.PGOHash, nil)
 	}
+	if Debug.LiteralAllocHash != "" {
+		LiteralAllocHash = NewHashDebug("literalalloc", Debug.LiteralAllocHash, nil)
+	}
+
 	if Debug.MergeLocalsHash != "" {
 		MergeLocalsHash = NewHashDebug("mergelocals", Debug.MergeLocalsHash, nil)
 	}

src/cmd/compile/internal/base/hashdebug.go

@@ -56,6 +56,7 @@ var hashDebug *HashDebug
 var FmaHash *HashDebug          // for debugging fused-multiply-add floating point changes
 var LoopVarHash *HashDebug      // for debugging shared/private loop variable changes
 var PGOHash *HashDebug          // for debugging PGO optimization decisions
+var LiteralAllocHash *HashDebug // for debugging literal allocation optimizations
 var MergeLocalsHash *HashDebug  // for debugging local stack slot merging changes
 var VariableMakeHash *HashDebug // for debugging variable-sized make optimizations
 

src/cmd/compile/internal/escape/escape.go

@@ -534,10 +534,6 @@ func (b *batch) rewriteWithLiterals(n ir.Node, fn *ir.Func) {
 	if n.Op() != ir.OMAKESLICE && n.Op() != ir.OCONVIFACE {
 		return
 	}
-	if base.Flag.Cfg.CoverageInfo != nil {
-		// Avoid altering coverage results.
-		return
-	}
 
 	// Look up a cached ReassignOracle for the function, lazily computing one if needed.
 	ro := b.reassignOracle(fn)
@@ -571,6 +567,10 @@ func (b *batch) rewriteWithLiterals(n ir.Node, fn *ir.Func) {
 					base.Fatalf("unexpected BasicLit Kind")
 				}
 				if constant.Compare(lit.Val(), token.GEQ, constant.MakeInt64(0)) {
+					if !base.LiteralAllocHash.MatchPos(n.Pos(), nil) {
+						// De-selected by literal alloc optimizations debug hash.
+						return
+					}
 					// Preserve any side effects of the original expression, then replace it.
 					assignTemp(*r, n.PtrInit())
 					*r = lit
@@ -584,6 +584,10 @@ func (b *batch) rewriteWithLiterals(n ir.Node, fn *ir.Func) {
 		if conv.X.Op() != ir.OLITERAL && !conv.X.Type().IsInterface() {
 			v := ro.StaticValue(conv.X)
 			if v != nil && v.Op() == ir.OLITERAL && ir.ValidTypeForConst(conv.X.Type(), v.Val()) {
+				if !base.LiteralAllocHash.MatchPos(n.Pos(), nil) {
+					// De-selected by literal alloc optimizations debug hash.
+					return
+				}
 				if base.Debug.EscapeDebug >= 3 {
 					base.WarnfAt(n.Pos(), "rewriting OCONVIFACE value from %v (%v) to %v (%v)", conv.X, conv.X.Type(), v, v.Type())
 				}

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

@@ -1917,15 +1917,22 @@ func (ft *factsTable) flowLimit(v *Value) bool {
 
 // See if we can get any facts because v is the result of signed mod by a constant.
 // The mod operation has already been rewritten, so we have to try and reconstruct it.
-//   x % d
+//
+//	x % d
+//
 // is rewritten as
-//   x - (x / d) * d
+//
+//	x - (x / d) * d
+//
 // furthermore, the divide itself gets rewritten. If d is a power of 2 (d == 1<<k), we do
-//   (x / d) * d = ((x + adj) >> k) << k
-//               = (x + adj) & (-1<<k)
+//
+//	(x / d) * d = ((x + adj) >> k) << k
+//	            = (x + adj) & (-1<<k)
+//
 // with adj being an adjustment in case x is negative (see below).
 // if d is not a power of 2, we do
-//   x / d = ... TODO ...
+//
+//	x / d = ... TODO ...
 func (ft *factsTable) detectSignedMod(v *Value) bool {
 	if ft.detectSignedModByPowerOfTwo(v) {
 		return true

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

@@ -120,6 +120,11 @@ func TestStmtLines(t *testing.T) {
 				break
 			}
 			must(err)
+			if le.EndSequence {
+				// When EndSequence is true only
+				// le.Address is meaningful, skip.
+				continue
+			}
 			fl := Line{le.File.Name, le.Line}
 			lines[fl] = lines[fl] || le.IsStmt
 		}

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

@@ -246,14 +246,18 @@ func (o *orderState) addrTemp(n ir.Node) ir.Node {
 	if v == nil {
 		v = n
 	}
+	optEnabled := func(n ir.Node) bool {
+		// Do this optimization only when enabled for this node.
+		return base.LiteralAllocHash.MatchPos(n.Pos(), nil)
+	}
 	if (v.Op() == ir.OSTRUCTLIT || v.Op() == ir.OARRAYLIT) && !base.Ctxt.IsFIPS() {
-		if ir.IsZero(v) && 0 < v.Type().Size() && v.Type().Size() <= abi.ZeroValSize {
+		if ir.IsZero(v) && 0 < v.Type().Size() && v.Type().Size() <= abi.ZeroValSize && optEnabled(n) {
 			// This zero value can be represented by the read-only zeroVal.
 			zeroVal := ir.NewLinksymExpr(v.Pos(), ir.Syms.ZeroVal, n.Type())
 			vstat := typecheck.Expr(zeroVal).(*ir.LinksymOffsetExpr)
 			return vstat
 		}
-		if isStaticCompositeLiteral(v) {
+		if isStaticCompositeLiteral(v) && optEnabled(n) {
 			// v can be directly represented in the read-only data section.
 			lit := v.(*ir.CompLitExpr)
 			vstat := readonlystaticname(n.Type())