Merge branch 'golang:master' into master

Author: KirtanSoni

doc/go_mem.html

@@ -453,7 +453,7 @@ <h3 id="chan">Channel communication</h3>
 </p>
 
 <p class="rule">
-The <i>k</i>th receive on a channel with capacity <i>C</i> is synchronized before the completion of the <i>k</i>+<i>C</i>th send from that channel completes.
+The <i>k</i>th receive from a channel with capacity <i>C</i> is synchronized before the completion of the <i>k</i>+<i>C</i>th send on that channel.
 </p>
 
 <p>

src/cmd/asm/internal/asm/testdata/loong64enc1.s

@@ -849,3 +849,13 @@ lable2:
 	XVFRECIPD	X2, X1		// 41f89c76
 	XVFRSQRTF	X2, X1		// 41049d76
 	XVFRSQRTD	X2, X1		// 41089d76
+
+	// [X]VNEG{B/H/W/V} instructions
+	VNEGB		V1, V2		// 22309c72
+	VNEGH		V1, V2		// 22349c72
+	VNEGW		V1, V2		// 22389c72
+	VNEGV		V1, V2		// 223c9c72
+	XVNEGB		X2, X1		// 41309c76
+	XVNEGH		X2, X1		// 41349c76
+	XVNEGW		X2, X1		// 41389c76
+	XVNEGV		X2, X1		// 413c9c76

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

@@ -419,7 +419,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		ssa.OpRISCV64FMVSX, ssa.OpRISCV64FMVDX,
 		ssa.OpRISCV64FCVTSW, ssa.OpRISCV64FCVTSL, ssa.OpRISCV64FCVTWS, ssa.OpRISCV64FCVTLS,
 		ssa.OpRISCV64FCVTDW, ssa.OpRISCV64FCVTDL, ssa.OpRISCV64FCVTWD, ssa.OpRISCV64FCVTLD, ssa.OpRISCV64FCVTDS, ssa.OpRISCV64FCVTSD,
-		ssa.OpRISCV64NOT, ssa.OpRISCV64NEG, ssa.OpRISCV64NEGW:
+		ssa.OpRISCV64NOT, ssa.OpRISCV64NEG, ssa.OpRISCV64NEGW, ssa.OpRISCV64CTZ, ssa.OpRISCV64CTZW:
 		p := s.Prog(v.Op.Asm())
 		p.From.Type = obj.TYPE_REG
 		p.From.Reg = v.Args[0].Reg()

src/cmd/compile/internal/ssa/_gen/RISCV64.rules

@@ -218,6 +218,13 @@
 (RotateLeft32 ...) => (ROLW ...)
 (RotateLeft64 ...) => (ROL  ...)
 
+// Count trailing zeros (note that these will only be emitted for rva22u64 and above).
+(Ctz(64|32|16|8)NonZero ...) => (Ctz64 ...)
+(Ctz64 ...) => (CTZ  ...)
+(Ctz32 ...) => (CTZW ...)
+(Ctz16 x) => (CTZW (ORI <typ.UInt32> [1<<16] x))
+(Ctz8  x) => (CTZW (ORI <typ.UInt32> [1<<8]  x))
+
 (Less64  ...) => (SLT  ...)
 (Less32  x y) => (SLT  (SignExt32to64 x) (SignExt32to64 y))
 (Less16  x y) => (SLT  (SignExt16to64 x) (SignExt16to64 y))
@@ -589,6 +596,9 @@
 (MOVHUreg (ANDI [c] x)) && c < 0 => (ANDI [int64(uint16(c))] x)
 (MOVWUreg (ANDI [c] x)) && c < 0 => (AND (MOVDconst [int64(uint32(c))]) x)
 
+// Combine negation and sign extension.
+(MOVWreg (NEG x)) => (NEGW x)
+
 // Avoid sign/zero extension for consts.
 (MOVBreg  (MOVDconst [c])) => (MOVDconst [int64(int8(c))])
 (MOVHreg  (MOVDconst [c])) => (MOVDconst [int64(int16(c))])
@@ -732,6 +742,7 @@
 
 // Double negation.
 (NEG (NEG x)) => x
+(NEG <t> s:(ADDI [val] (NEG x))) && s.Uses == 1 && is32Bit(-val) => (ADDI [-val] x)
 
 // Addition of zero or two constants.
 (ADDI [0] x) => x

src/cmd/compile/internal/ssa/_gen/RISCV64Ops.go

@@ -229,6 +229,8 @@ func init() {
 		{name: "AND", argLength: 2, reg: gp21, asm: "AND", commutative: true},   // arg0 & arg1
 		{name: "ANDN", argLength: 2, reg: gp21, asm: "ANDN"},                    // ^arg0 & arg1
 		{name: "ANDI", argLength: 1, reg: gp11, asm: "ANDI", aux: "Int64"},      // arg0 & auxint
+		{name: "CTZ", argLength: 1, reg: gp11, asm: "CTZ"},                      // count trailing zeros
+		{name: "CTZW", argLength: 1, reg: gp11, asm: "CTZW"},                    // count trailing zeros of least significant word
 		{name: "NOT", argLength: 1, reg: gp11, asm: "NOT"},                      // ^arg0
 		{name: "OR", argLength: 2, reg: gp21, asm: "OR", commutative: true},     // arg0 | arg1
 		{name: "ORN", argLength: 2, reg: gp21, asm: "ORN"},                      // ^arg0 | arg1

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

@@ -900,6 +900,30 @@ func initIntrinsics(cfg *intrinsicBuildConfig) {
 			return s.newValue1(ssa.OpCtz8, types.Types[types.TINT], args[0])
 		},
 		sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.MIPS, sys.Loong64, sys.PPC64, sys.S390X, sys.Wasm)
+
+	if cfg.goriscv64 >= 22 {
+		addF("math/bits", "TrailingZeros64",
+			func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+				return s.newValue1(ssa.OpCtz64, types.Types[types.TINT], args[0])
+			},
+			sys.RISCV64)
+		addF("math/bits", "TrailingZeros32",
+			func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+				return s.newValue1(ssa.OpCtz32, types.Types[types.TINT], args[0])
+			},
+			sys.RISCV64)
+		addF("math/bits", "TrailingZeros16",
+			func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+				return s.newValue1(ssa.OpCtz16, types.Types[types.TINT], args[0])
+			},
+			sys.RISCV64)
+		addF("math/bits", "TrailingZeros8",
+			func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+				return s.newValue1(ssa.OpCtz8, types.Types[types.TINT], args[0])
+			},
+			sys.RISCV64)
+	}
+
 	alias("math/bits", "ReverseBytes64", "internal/runtime/sys", "Bswap64", all...)
 	alias("math/bits", "ReverseBytes32", "internal/runtime/sys", "Bswap32", all...)
 	addF("math/bits", "ReverseBytes16",

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

@@ -1106,6 +1106,9 @@ var wantIntrinsics = map[testIntrinsicKey]struct{}{
 	{"riscv64", "internal/runtime/sys", "GetCallerPC"}:                 struct{}{},
 	{"riscv64", "internal/runtime/sys", "GetCallerSP"}:                 struct{}{},
 	{"riscv64", "internal/runtime/sys", "GetClosurePtr"}:               struct{}{},
+	{"riscv64", "internal/runtime/sys", "TrailingZeros32"}:             struct{}{},
+	{"riscv64", "internal/runtime/sys", "TrailingZeros64"}:             struct{}{},
+	{"riscv64", "internal/runtime/sys", "TrailingZeros8"}:              struct{}{},
 	{"riscv64", "math", "Abs"}:                                         struct{}{},
 	{"riscv64", "math", "Copysign"}:                                    struct{}{},
 	{"riscv64", "math", "FMA"}:                                         struct{}{},
@@ -1122,6 +1125,10 @@ var wantIntrinsics = map[testIntrinsicKey]struct{}{
 	{"riscv64", "math/bits", "RotateLeft8"}:                            struct{}{},
 	{"riscv64", "math/bits", "Sub"}:                                    struct{}{},
 	{"riscv64", "math/bits", "Sub64"}:                                  struct{}{},
+	{"riscv64", "math/bits", "TrailingZeros16"}:                        struct{}{},
+	{"riscv64", "math/bits", "TrailingZeros32"}:                        struct{}{},
+	{"riscv64", "math/bits", "TrailingZeros64"}:                        struct{}{},
+	{"riscv64", "math/bits", "TrailingZeros8"}:                         struct{}{},
 	{"riscv64", "runtime", "KeepAlive"}:                                struct{}{},
 	{"riscv64", "runtime", "publicationBarrier"}:                       struct{}{},
 	{"riscv64", "runtime", "slicebytetostringtmp"}:                     struct{}{},
@@ -1308,7 +1315,8 @@ var wantIntrinsics = map[testIntrinsicKey]struct{}{
 
 func TestIntrinsics(t *testing.T) {
 	cfg := &intrinsicBuildConfig{
-		goppc64: 10,
+		goppc64:   10,
+		goriscv64: 23,
 	}
 	initIntrinsics(cfg)
 

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

@@ -950,6 +950,16 @@ const (
 	AXVFRSQRTF
 	AXVFRSQRTD
 
+	// LSX and LASX integer neg instructions
+	AVNEGB
+	AVNEGH
+	AVNEGW
+	AVNEGV
+	AXVNEGB
+	AXVNEGH
+	AXVNEGW
+	AXVNEGV
+
 	ALAST
 
 	// aliases

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

@@ -1659,6 +1659,10 @@ func buildop(ctxt *obj.Link) {
 			opset(AVFRECIPD, r0)
 			opset(AVFRSQRTF, r0)
 			opset(AVFRSQRTD, r0)
+			opset(AVNEGB, r0)
+			opset(AVNEGH, r0)
+			opset(AVNEGW, r0)
+			opset(AVNEGV, r0)
 
 		case AXVPCNTB:
 			opset(AXVPCNTH, r0)
@@ -1670,6 +1674,10 @@ func buildop(ctxt *obj.Link) {
 			opset(AXVFRECIPD, r0)
 			opset(AXVFRSQRTF, r0)
 			opset(AXVFRSQRTD, r0)
+			opset(AXVNEGB, r0)
+			opset(AXVNEGH, r0)
+			opset(AXVNEGW, r0)
+			opset(AXVNEGV, r0)
 
 		case AVADDB:
 			opset(AVADDH, r0)
@@ -3366,6 +3374,22 @@ func (c *ctxt0) oprr(a obj.As) uint32 {
 		return 0x1da741 << 10 // xvfrsqrt.s
 	case AXVFRSQRTD:
 		return 0x1da742 << 10 // xvfrsqrt.d
+	case AVNEGB:
+		return 0x1ca70c << 10 // vneg.b
+	case AVNEGH:
+		return 0x1ca70d << 10 // vneg.h
+	case AVNEGW:
+		return 0x1ca70e << 10 // vneg.w
+	case AVNEGV:
+		return 0x1ca70f << 10 // vneg.d
+	case AXVNEGB:
+		return 0x1da70c << 10 // xvneg.b
+	case AXVNEGH:
+		return 0x1da70d << 10 // xvneg.h
+	case AXVNEGW:
+		return 0x1da70e << 10 // xvneg.w
+	case AXVNEGV:
+		return 0x1da70f << 10 // xvneg.d
 	}
 
 	c.ctxt.Diag("bad rr opcode %v", a)

src/cmd/internal/obj/loong64/a.out.go

@@ -210,7 +210,7 @@ that would have been produced if {{.}} was a regular string.
 
 # Security Model
 
-https://rawgit.com/mikesamuel/sanitized-jquery-templates/trunk/safetemplate.html#problem_definition defines "safe" as used by this package.
+https://web.archive.org/web/20160501113828/http://js-quasis-libraries-and-repl.googlecode.com/svn/trunk/safetemplate.html#problem_definition defines "safe" as used by this package.
 
 This package assumes that template authors are trusted, that Execute's data
 parameter is not, and seeks to preserve the properties below in the face

src/cmd/internal/obj/loong64/anames.go

@@ -223,7 +223,7 @@ func splitPathInRoot(s string, prefix, suffix []string) (_ []string, err error)
 		suffix = nil
 	}
 
-	parts := append([]string{}, prefix...)
+	parts := slices.Clone(prefix)
 	i, j := 0, 1
 	for {
 		if j < len(s) && !IsPathSeparator(s[j]) {