cmd/compile: use generated loops instead of DUFFZERO on loong64

Change-Id: Id43ee4353d4bac96627f8b0f54545cdd3d2a1d1b
Reviewed-on: https://go-review.googlesource.com/c/go/+/699695
Reviewed-by: Cherry Mui <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Carlos Amedee <[email protected]>
Reviewed-by: abner chenc <[email protected]>

Author: limeidan

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

@@ -560,28 +560,97 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Sym = ir.Syms.Duffzero
 		p.To.Offset = v.AuxInt
 	case ssa.OpLOONG64LoweredZero:
-		// MOVx	R0, (Rarg0)
-		// ADDV	$sz, Rarg0
-		// BGEU	Rarg1, Rarg0, -2(PC)
-		mov, sz := largestMove(v.AuxInt)
-		p := s.Prog(mov)
-		p.From.Type = obj.TYPE_REG
-		p.From.Reg = loong64.REGZERO
-		p.To.Type = obj.TYPE_MEM
-		p.To.Reg = v.Args[0].Reg()
+		ptrReg := v.Args[0].Reg()
+		n := v.AuxInt
+		if n < 16 {
+			v.Fatalf("Zero too small %d", n)
+		}
 
-		p2 := s.Prog(loong64.AADDVU)
-		p2.From.Type = obj.TYPE_CONST
-		p2.From.Offset = sz
-		p2.To.Type = obj.TYPE_REG
-		p2.To.Reg = v.Args[0].Reg()
+		// Generate Zeroing instructions.
+		var off int64
+		for n >= 8 {
+			// MOVV     ZR, off(ptrReg)
+			zero8(s, ptrReg, off)
+			off += 8
+			n -= 8
+		}
+		if n != 0 {
+			// MOVV     ZR, off+n-8(ptrReg)
+			zero8(s, ptrReg, off+n-8)
+		}
+	case ssa.OpLOONG64LoweredZeroLoop:
+		ptrReg := v.Args[0].Reg()
+		countReg := v.RegTmp()
+		var off int64
+		n := v.AuxInt
+		loopSize := int64(64)
+		if n < 3*loopSize {
+			// - a loop count of 0 won't work.
+			// - a loop count of 1 is useless.
+			// - a loop count of 2 is a code size ~tie
+			//     4 instructions to implement the loop
+			//     8 instructions in the loop body
+			//   vs
+			//     16 instuctions in the straightline code
+			//   Might as well use straightline code.
+			v.Fatalf("ZeroLoop size tool small %d", n)
+		}
 
-		p3 := s.Prog(loong64.ABGEU)
-		p3.From.Type = obj.TYPE_REG
-		p3.From.Reg = v.Args[1].Reg()
-		p3.Reg = v.Args[0].Reg()
-		p3.To.Type = obj.TYPE_BRANCH
-		p3.To.SetTarget(p)
+		// Put iteration count in a register.
+		//   MOVV     $n/loopSize, countReg
+		p := s.Prog(loong64.AMOVV)
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = n / loopSize
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = countReg
+		cntInit := p
+
+		// Zero loopSize bytes starting at ptrReg.
+		for range loopSize / 8 {
+			// MOVV     ZR, off(ptrReg)
+			zero8(s, ptrReg, off)
+			off += 8
+		}
+
+		// Increment ptrReg by loopSize.
+		//   ADDV     $loopSize, ptrReg
+		p = s.Prog(loong64.AADDV)
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = loopSize
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = ptrReg
+
+		// Decrement loop count.
+		//   SUBV     $1, countReg
+		p = s.Prog(loong64.ASUBV)
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = 1
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = countReg
+
+		// Jump to loop header if we're not done yet.
+		//   BNE     countReg, loop header
+		p = s.Prog(loong64.ABNE)
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = countReg
+		p.To.Type = obj.TYPE_BRANCH
+		p.To.SetTarget(cntInit.Link)
+
+		// Multiples of the loop size are now done.
+		n %= loopSize
+
+		off = 0
+		// Write any fractional portion.
+		for n >= 8 {
+			// MOVV     ZR, off(ptrReg)
+			zero8(s, ptrReg, off)
+			off += 8
+			n -= 8
+		}
+
+		if n != 0 {
+			zero8(s, ptrReg, off+n-8)
+		}
 
 	case ssa.OpLOONG64DUFFCOPY:
 		p := s.Prog(obj.ADUFFCOPY)
@@ -1155,3 +1224,14 @@ func spillArgReg(pp *objw.Progs, p *obj.Prog, f *ssa.Func, t *types.Type, reg in
 	p.Pos = p.Pos.WithNotStmt()
 	return p
 }
+
+// zero8 zeroes 8 bytes at reg+off.
+func zero8(s *ssagen.State, reg int16, off int64) {
+	// MOVV     ZR, off(reg)
+	p := s.Prog(loong64.AMOVV)
+	p.From.Type = obj.TYPE_REG
+	p.From.Reg = loong64.REGZERO
+	p.To.Type = obj.TYPE_MEM
+	p.To.Reg = reg
+	p.To.Offset = off
+}

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

@@ -373,24 +373,8 @@
         (MOVVstore [8] ptr (MOVVconst [0])
                 (MOVVstore ptr (MOVVconst [0]) mem))
 
-// strip off fractional word zeroing
-(Zero [s] ptr mem) && s%8 != 0 && s > 16 =>
-    (Zero [s%8]
-        (OffPtr <ptr.Type> ptr [s-s%8])
-        (Zero [s-s%8] ptr mem))
-
-// medium zeroing uses a duff device
-(Zero [s] ptr mem)
-    && s%8 == 0 && s > 16 && s <= 8*128 =>
-    (DUFFZERO [8 * (128 - s/8)] ptr mem)
-
-// large zeroing uses a loop
-(Zero [s] ptr mem)
-    && s%8 == 0 && s > 8*128 =>
-    (LoweredZero
-        ptr
-        (ADDVconst <ptr.Type> ptr [s-8])
-        mem)
+(Zero [s] ptr mem) && s > 16 && s < 192 => (LoweredZero [s] ptr mem)
+(Zero [s] ptr mem) && s >= 192 => (LoweredZeroLoop [s] ptr mem)
 
 // moves
 (Move [0] _ _ mem) => mem

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

@@ -376,6 +376,21 @@ func init() {
 			faultOnNilArg0: true,
 		},
 
+		// medium zeroing
+		// arg0 = address of memory to zero
+		// arg1 = mem
+		// auxint = number of bytes to zero
+		// returns mem
+		{
+			name:      "LoweredZero",
+			aux:       "Int64",
+			argLength: 2,
+			reg: regInfo{
+				inputs: []regMask{gp},
+			},
+			faultOnNilArg0: true,
+		},
+
 		// duffcopy
 		// arg0 = address of dst memory (in R21, changed as side effect)
 		// arg1 = address of src memory (in R20, changed as side effect)
@@ -395,25 +410,21 @@ func init() {
 			faultOnNilArg1: true,
 		},
 
-		// large or unaligned zeroing
-		// arg0 = address of memory to zero (in R20, changed as side effect)
-		// arg1 = address of the last element to zero
-		// arg2 = mem
-		// auxint = alignment
+		// large zeroing
+		// arg0 = address of memory to zero
+		// arg1 = mem
+		// auxint = number of bytes to zero
 		// returns mem
-		//	MOVx	R0, (R20)
-		//	ADDV	$sz, R20
-		//	BGEU	Rarg1, R20, -2(PC)
 		{
-			name:      "LoweredZero",
+			name:      "LoweredZeroLoop",
 			aux:       "Int64",
-			argLength: 3,
+			argLength: 2,
 			reg: regInfo{
-				inputs:   []regMask{buildReg("R20"), gp},
-				clobbers: buildReg("R20"),
+				inputs:       []regMask{gp},
+				clobbersArg0: true,
 			},
-			typ:            "Mem",
 			faultOnNilArg0: true,
+			needIntTemp:    true,
 		},
 
 		// large or unaligned move