Merge remote-tracking branch 'upstream/master'

Author: actions-user

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

@@ -133,62 +133,38 @@ func (l limit) String() string {
 }
 
 func (l limit) intersect(l2 limit) limit {
-	if l.min < l2.min {
-		l.min = l2.min
-	}
-	if l.umin < l2.umin {
-		l.umin = l2.umin
-	}
-	if l.max > l2.max {
-		l.max = l2.max
-	}
-	if l.umax > l2.umax {
-		l.umax = l2.umax
-	}
+	l.min = max(l.min, l2.min)
+	l.umin = max(l.umin, l2.umin)
+	l.max = min(l.max, l2.max)
+	l.umax = min(l.umax, l2.umax)
 	return l
 }
 
 func (l limit) signedMin(m int64) limit {
-	if l.min < m {
-		l.min = m
-	}
+	l.min = max(l.min, m)
 	return l
 }
 func (l limit) signedMax(m int64) limit {
-	if l.max > m {
-		l.max = m
-	}
+	l.max = min(l.max, m)
 	return l
 }
-func (l limit) signedMinMax(min, max int64) limit {
-	if l.min < min {
-		l.min = min
-	}
-	if l.max > max {
-		l.max = max
-	}
+func (l limit) signedMinMax(minimum, maximum int64) limit {
+	l.min = max(l.min, minimum)
+	l.max = min(l.max, maximum)
 	return l
 }
 
 func (l limit) unsignedMin(m uint64) limit {
-	if l.umin < m {
-		l.umin = m
-	}
+	l.umin = max(l.umin, m)
 	return l
 }
 func (l limit) unsignedMax(m uint64) limit {
-	if l.umax > m {
-		l.umax = m
-	}
+	l.umax = min(l.umax, m)
 	return l
 }
-func (l limit) unsignedMinMax(min, max uint64) limit {
-	if l.umin < min {
-		l.umin = min
-	}
-	if l.umax > max {
-		l.umax = max
-	}
+func (l limit) unsignedMinMax(minimum, maximum uint64) limit {
+	l.umin = max(l.umin, minimum)
+	l.umax = min(l.umax, maximum)
 	return l
 }
 
@@ -688,7 +664,7 @@ func (ft *factsTable) newLimit(v *Value, newLim limit) bool {
 				d |= unsigned
 			}
 			if !isTrue {
-				r ^= (lt | gt | eq)
+				r ^= lt | gt | eq
 			}
 			// TODO: v.Block is wrong?
 			addRestrictions(v.Block, ft, d, v.Args[0], v.Args[1], r)
@@ -721,7 +697,7 @@ func (ft *factsTable) newLimit(v *Value, newLim limit) bool {
 				// But in the signed domain, we can't express the ||
 				// condition, so check if a0 is non-negative instead,
 				// to be able to learn something.
-				r ^= (lt | gt | eq) // >= (index) or > (slice)
+				r ^= lt | gt | eq // >= (index) or > (slice)
 				if ft.isNonNegative(v.Args[0]) {
 					ft.update(v.Block, v.Args[0], v.Args[1], signed, r)
 				}
@@ -1323,8 +1299,8 @@ func prove(f *Func) {
 		}
 
 		// try to rewrite to a downward counting loop checking against start if the
-		// loop body does not depends on ind or nxt and end is known before the loop.
-		// This reduce pressure on the register allocator because this do not need
+		// loop body does not depend on ind or nxt and end is known before the loop.
+		// This reduces pressure on the register allocator because this does not need
 		// to use end on each iteration anymore. We compare against the start constant instead.
 		// That means this code:
 		//
@@ -1356,7 +1332,7 @@ func prove(f *Func) {
 		//
 		//	exit_loop:
 		//
-		// this is better because it only require to keep ind then nxt alive while looping,
+		// this is better because it only requires to keep ind then nxt alive while looping,
 		// while the original form keeps ind then nxt and end alive
 		start, end := v.min, v.max
 		if v.flags&indVarCountDown != 0 {
@@ -1379,7 +1355,7 @@ func prove(f *Func) {
 
 		if end.Block == ind.Block {
 			// we can't rewrite loops where the condition depends on the loop body
-			// this simple check is forced to work because if this is true a Phi in ind.Block must exists
+			// this simple check is forced to work because if this is true a Phi in ind.Block must exist
 			continue
 		}
 

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

@@ -637,17 +637,12 @@ func (f *Func) computeZeroMap(select1 []*Value) map[ID]ZeroRegion {
 					size += ptrSize - d
 				}
 				// Clip to the 64 words that we track.
-				min := off
-				max := off + size
-				if min < 0 {
-					min = 0
-				}
-				if max > 64*ptrSize {
-					max = 64 * ptrSize
-				}
+				minimum := max(off, 0)
+				maximum := min(off+size, 64*ptrSize)
+
 				// Clear bits for parts that we are writing (and hence
 				// will no longer necessarily be zero).
-				for i := min; i < max; i += ptrSize {
+				for i := minimum; i < maximum; i += ptrSize {
 					bit := i / ptrSize
 					z.mask &^= 1 << uint(bit)
 				}

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

@@ -568,7 +568,7 @@ func walkMakeSlice(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 			// The conv is necessary in case n.Type is named.
 			return walkExpr(typecheck.Expr(typecheck.Conv(s, n.Type())), init)
 		}
-		tryStack = true
+		tryStack = base.Flag.N == 0
 	}
 
 	// The final result is assigned to this variable.

src/internal/poll/copy_file_range_unix.go

@@ -16,10 +16,7 @@ func CopyFileRange(dst, src *FD, remain int64) (written int64, handled bool, err
 	}
 
 	for remain > 0 {
-		max := remain
-		if max > maxCopyFileRangeRound {
-			max = maxCopyFileRangeRound
-		}
+		max := min(remain, maxCopyFileRangeRound)
 		n, e := copyFileRange(dst, src, int(max))
 		if n > 0 {
 			remain -= n

src/math/big/arith.go

@@ -143,7 +143,7 @@ func subVWlarge(z, x []Word, y Word) (c Word) {
 	return
 }
 
-func shlVU_g(z, x []Word, s uint) (c Word) {
+func lshVU_g(z, x []Word, s uint) (c Word) {
 	if s == 0 {
 		copy(z, x)
 		return
@@ -162,7 +162,7 @@ func shlVU_g(z, x []Word, s uint) (c Word) {
 	return
 }
 
-func shrVU_g(z, x []Word, s uint) (c Word) {
+func rshVU_g(z, x []Word, s uint) (c Word) {
 	if s == 0 {
 		copy(z, x)
 		return
@@ -194,10 +194,11 @@ func mulAddVWW_g(z, x []Word, y, r Word) (c Word) {
 	return
 }
 
-func addMulVVW_g(z, x []Word, y Word) (c Word) {
+func addMulVVWW_g(z, x, y []Word, m, a Word) (c Word) {
+	c = a
 	// The comment near the top of this file discusses this for loop condition.
-	for i := 0; i < len(z) && i < len(x); i++ {
-		z1, z0 := mulAddWWW_g(x[i], y, z[i])
+	for i := 0; i < len(z) && i < len(x) && i < len(y); i++ {
+		z1, z0 := mulAddWWW_g(y[i], m, x[i])
 		lo, cc := bits.Add(uint(z0), uint(c), 0)
 		c, z[i] = Word(cc), Word(lo)
 		c += z1

src/math/big/arith_386.s

@@ -105,8 +105,8 @@ E4:	CMPL BX, BP		// i < n
 	RET
 
 
-// func shlVU(z, x []Word, s uint) (c Word)
-TEXT ·shlVU(SB),NOSPLIT,$0
+// func lshVU(z, x []Word, s uint) (c Word)
+TEXT ·lshVU(SB),NOSPLIT,$0
 	MOVL z_len+4(FP), BX	// i = z
 	SUBL $1, BX		// i--
 	JL X8b			// i < 0	(n <= 0)
@@ -140,8 +140,8 @@ X8b:	MOVL $0, c+28(FP)
 	RET
 
 
-// func shrVU(z, x []Word, s uint) (c Word)
-TEXT ·shrVU(SB),NOSPLIT,$0
+// func rshVU(z, x []Word, s uint) (c Word)
+TEXT ·rshVU(SB),NOSPLIT,$0
 	MOVL z_len+4(FP), BP
 	SUBL $1, BP		// n--
 	JL X9b			// n < 0	(n <= 0)
@@ -177,12 +177,12 @@ X9b:	MOVL $0, c+28(FP)
 	RET
 
 
-// func mulAddVWW(z, x []Word, y, r Word) (c Word)
+// func mulAddVWW(z, x []Word, m, a Word) (c Word)
 TEXT ·mulAddVWW(SB),NOSPLIT,$0
 	MOVL z+0(FP), DI
 	MOVL x+12(FP), SI
-	MOVL y+24(FP), BP
-	MOVL r+28(FP), CX	// c = r
+	MOVL m+24(FP), BP
+	MOVL a+28(FP), CX	// c = a
 	MOVL z_len+4(FP), BX
 	LEAL (DI)(BX*4), DI
 	LEAL (SI)(BX*4), SI
@@ -204,31 +204,33 @@ E5:	CMPL BX, $0		// i < 0
 	RET
 
 
-// func addMulVVW(z, x []Word, y Word) (c Word)
-TEXT ·addMulVVW(SB),NOSPLIT,$0
-	MOVL z+0(FP), DI
-	MOVL x+12(FP), SI
-	MOVL y+24(FP), BP
+// func addMulVVWW(z, x, y []Word, m, a Word) (c Word)
+TEXT ·addMulVVWW(SB),NOSPLIT,$0
+	MOVL z+0(FP), BP
+	MOVL x+12(FP), DI
+	MOVL y+24(FP), SI
+	MOVL a+40(FP), CX
 	MOVL z_len+4(FP), BX
 	LEAL (DI)(BX*4), DI
 	LEAL (SI)(BX*4), SI
+	LEAL (BP)(BX*4), BP
 	NEGL BX			// i = -n
-	MOVL $0, CX		// c = 0
 	JMP E6
 
 L6:	MOVL (SI)(BX*4), AX
-	MULL BP
+	MULL m+36(FP)
 	ADDL CX, AX
 	ADCL $0, DX
-	ADDL AX, (DI)(BX*4)
+	ADDL (DI)(BX*4), AX
+	MOVL AX, (BP)(BX*4)
 	ADCL $0, DX
 	MOVL DX, CX
 	ADDL $1, BX		// i++
 
 E6:	CMPL BX, $0		// i < 0
 	JL L6
 
-	MOVL CX, c+28(FP)
+	MOVL CX, c+44(FP)
 	RET