Merge remote-tracking branch 'upstream/master'

Author: actions-user

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

@@ -75,6 +75,8 @@ type location struct {
 	captured   bool // has a closure captured this variable?
 	reassigned bool // has this variable been reassigned?
 	addrtaken  bool // has this variable's address been taken?
+	param      bool // is this variable a parameter (ONAME of class ir.PPARAM)?
+	paramOut   bool // is this variable an out parameter (ONAME of class ir.PPARAMOUT)?
 }
 
 type locAttr uint8
@@ -281,6 +283,11 @@ func (e *escape) newLoc(n ir.Node, persists bool) *location {
 		curfn:     e.curfn,
 		loopDepth: e.loopDepth,
 	}
+	if loc.isName(ir.PPARAM) {
+		loc.param = true
+	} else if loc.isName(ir.PPARAMOUT) {
+		loc.paramOut = true
+	}
 	if persists {
 		loc.attrs |= attrPersists
 	}

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

@@ -126,7 +126,7 @@ func (b *batch) walkOne(root *location, walkgen uint32, enqueue func(*location))
 		// corresponding result parameter, then record
 		// that value flow for tagging the function
 		// later.
-		if l.isName(ir.PPARAM) {
+		if l.param {
 			if b.outlives(root, l) {
 				if !l.hasAttr(attrEscapes) && (logopt.Enabled() || base.Flag.LowerM >= 2) {
 					if base.Flag.LowerM >= 2 {
@@ -270,7 +270,7 @@ func (b *batch) outlives(l, other *location) bool {
 	// We don't know what callers do with returned values, so
 	// pessimistically we need to assume they flow to the heap and
 	// outlive everything too.
-	if l.isName(ir.PPARAMOUT) {
+	if l.paramOut {
 		// Exception: Closures can return locations allocated outside of
 		// them without forcing them to the heap, if we can statically
 		// identify all call sites. For example:

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

@@ -217,12 +217,12 @@ func nilcheckelim2(f *Func) {
 					f.Warnl(v.Pos, "removed nil check")
 				}
 				// For bug 33724, policy is that we might choose to bump an existing position
-				// off the faulting load/store in favor of the one from the nil check.
+				// off the faulting load in favor of the one from the nil check.
 
 				// Iteration order means that first nilcheck in the chain wins, others
 				// are bumped into the ordinary statement preservation algorithm.
 				u := b.Values[unnecessary.get(v.Args[0].ID)]
-				if !u.Pos.SameFileAndLine(v.Pos) {
+				if !u.Type.IsMemory() && !u.Pos.SameFileAndLine(v.Pos) {
 					if u.Pos.IsStmt() == src.PosIsStmt {
 						pendingLines.add(u.Pos)
 					}

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

@@ -3469,19 +3469,28 @@ func (s *state) exprCheckPtr(n ir.Node, checkPtrOK bool) *ssa.Value {
 
 	case ir.OLEN, ir.OCAP:
 		n := n.(*ir.UnaryExpr)
+		// Note: all constant cases are handled by the frontend. If len or cap
+		// makes it here, we want the side effects of the argument. See issue 72844.
+		a := s.expr(n.X)
+		t := n.X.Type()
 		switch {
-		case n.X.Type().IsSlice():
+		case t.IsSlice():
 			op := ssa.OpSliceLen
 			if n.Op() == ir.OCAP {
 				op = ssa.OpSliceCap
 			}
-			return s.newValue1(op, types.Types[types.TINT], s.expr(n.X))
-		case n.X.Type().IsString(): // string; not reachable for OCAP
-			return s.newValue1(ssa.OpStringLen, types.Types[types.TINT], s.expr(n.X))
-		case n.X.Type().IsMap(), n.X.Type().IsChan():
-			return s.referenceTypeBuiltin(n, s.expr(n.X))
-		default: // array
-			return s.constInt(types.Types[types.TINT], n.X.Type().NumElem())
+			return s.newValue1(op, types.Types[types.TINT], a)
+		case t.IsString(): // string; not reachable for OCAP
+			return s.newValue1(ssa.OpStringLen, types.Types[types.TINT], a)
+		case t.IsMap(), t.IsChan():
+			return s.referenceTypeBuiltin(n, a)
+		case t.IsArray():
+			return s.constInt(types.Types[types.TINT], t.NumElem())
+		case t.IsPtr() && t.Elem().IsArray():
+			return s.constInt(types.Types[types.TINT], t.Elem().NumElem())
+		default:
+			s.Fatalf("bad type in len/cap: %v", t)
+			return nil
 		}
 
 	case ir.OSPTR:

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

@@ -8,6 +8,7 @@ package types2
 
 import (
 	"cmd/compile/internal/syntax"
+	"go/constant"
 	"internal/buildcfg"
 	. "internal/types/errors"
 )
@@ -23,8 +24,32 @@ import (
 func (check *Checker) rangeStmt(inner stmtContext, rangeStmt *syntax.ForStmt, noNewVarPos poser, sKey, sValue, sExtra, rangeVar syntax.Expr, isDef bool) {
 	// check expression to iterate over
 	var x operand
+
+	// From the spec:
+	//   The range expression x is evaluated before beginning the loop,
+	//   with one exception: if at most one iteration variable is present
+	//   and x or len(x) is constant, the range expression is not evaluated.
+	// So we have to be careful not to evaluate the arg in the
+	// described situation.
+
+	check.hasCallOrRecv = false
 	check.expr(nil, &x, rangeVar)
 
+	if isTypes2 && x.mode != invalid && sValue == nil && !check.hasCallOrRecv {
+		if t, ok := arrayPtrDeref(under(x.typ)).(*Array); ok {
+			// Override type of rangeVar to be a constant
+			// (and thus side-effects will not be computed
+			// by the backend).
+			check.record(&operand{
+				mode: constant_,
+				expr: rangeVar,
+				typ:  Typ[Int],
+				val:  constant.MakeInt64(t.len),
+				id:   x.id,
+			})
+		}
+	}
+
 	// determine key/value types
 	var key, val Type
 	if x.mode != invalid {

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

@@ -278,12 +278,13 @@ func walkLenCap(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
 	// replace len(*[10]int) with 10.
 	// delayed until now to preserve side effects.
 	t := n.X.Type()
-
 	if t.IsPtr() {
 		t = t.Elem()
 	}
 	if t.IsArray() {
-		safeExpr(n.X, init)
+		// evaluate any side effects in n.X. See issue 72844.
+		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.BlankNode, n.X))
+
 		con := ir.NewConstExpr(constant.MakeInt64(t.NumElem()), n)
 		con.SetTypecheck(1)
 		return con

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

@@ -5,6 +5,7 @@
 package walk
 
 import (
+	"go/constant"
 	"internal/buildcfg"
 	"unicode/utf8"
 
@@ -80,6 +81,10 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		base.Fatalf("walkRange")
 
 	case types.IsInt[k]:
+		if nn := arrayRangeClear(nrange, v1, v2, a); nn != nil {
+			base.Pos = lno
+			return nn
+		}
 		hv1 := typecheck.TempAt(base.Pos, ir.CurFunc, t)
 		hn := typecheck.TempAt(base.Pos, ir.CurFunc, t)
 
@@ -519,21 +524,41 @@ func arrayRangeClear(loop *ir.RangeStmt, v1, v2, a ir.Node) ir.Node {
 	}
 	lhs := stmt.X.(*ir.IndexExpr)
 	x := lhs.X
-	if a.Type().IsPtr() && a.Type().Elem().IsArray() {
-		if s, ok := x.(*ir.StarExpr); ok && s.Op() == ir.ODEREF {
-			x = s.X
+
+	// Get constant number of iterations for int and array cases.
+	n := int64(-1)
+	if ir.IsConst(a, constant.Int) {
+		n = ir.Int64Val(a)
+	} else if a.Type().IsArray() {
+		n = a.Type().NumElem()
+	} else if a.Type().IsPtr() && a.Type().Elem().IsArray() {
+		n = a.Type().Elem().NumElem()
+	}
+
+	if n >= 0 {
+		// Int/Array case.
+		if !x.Type().IsArray() {
+			return nil
+		}
+		if x.Type().NumElem() != n {
+			return nil
+		}
+	} else {
+		// Slice case.
+		if !ir.SameSafeExpr(x, a) {
+			return nil
 		}
 	}
 
-	if !ir.SameSafeExpr(x, a) || !ir.SameSafeExpr(lhs.Index, v1) {
+	if !ir.SameSafeExpr(lhs.Index, v1) {
 		return nil
 	}
 
 	if !ir.IsZero(stmt.Y) {
 		return nil
 	}
 
-	return arrayClear(stmt.Pos(), a, loop)
+	return arrayClear(stmt.Pos(), x, loop)
 }
 
 // arrayClear constructs a call to runtime.memclr for fast zeroing of slices and arrays.

src/crypto/internal/fips140/sha512/sha512block_riscv64.s

@@ -138,9 +138,8 @@
 #define SHA512ROUND(index, a, b, c, d, e, f, g, h) \
 	SHA512T1(index, e, f, g, h); \
 	SHA512T2(a, b, c); \
-	MOV	X6, h; \
 	ADD	X5, d; \
-	ADD	X5, h
+	ADD	X6, X5, h
 
 #define SHA512ROUND0(index, a, b, c, d, e, f, g, h) \
 	MSGSCHEDULE0(index); \

src/go/types/range.go

@@ -12,6 +12,7 @@ package codegen
 type T struct {
 	a *[10]int
 	b [10]int
+	s []int
 }
 
 func (t *T) f() {
@@ -38,4 +39,15 @@ func (t *T) f() {
 	for i := range *t.a {
 		(*t.a)[i] = 0
 	}
+
+	// amd64:-".*runtime.memclrNoHeapPointers"
+	// amd64:"DUFFZERO"
+	for i := range t.b {
+		t.b[i] = 0
+	}
+
+	// amd64:".*runtime.memclrNoHeapPointers"
+	for i := range t.s {
+		t.s[i] = 0
+	}
 }