runtime, cmd/compile, cmd/internal/obj: remove duff support for loong64

Change-Id: I44d6452933c8010f7dfbf821a32053f9d1cf151e
Reviewed-on: https://go-review.googlesource.com/c/go/+/700096
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: sophie zhao <zhaoxiaolin@loongson.cn>
Reviewed-by: abner chenc <chenguoqi@loongson.cn>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Keith Randall <khr@google.com>
Auto-Submit: Michael Pratt <mpratt@google.com>

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

@@ -552,13 +552,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 		p.To.Type = obj.TYPE_REG
 		p.To.Reg = v.Reg()
 
-	case ssa.OpLOONG64DUFFZERO:
-		// runtime.duffzero expects start address in R20
-		p := s.Prog(obj.ADUFFZERO)
-		p.To.Type = obj.TYPE_MEM
-		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = ir.Syms.Duffzero
-		p.To.Offset = v.AuxInt
 	case ssa.OpLOONG64LoweredZero:
 		ptrReg := v.Args[0].Reg()
 		n := v.AuxInt
@@ -652,12 +645,6 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
 			zero8(s, ptrReg, off+n-8)
 		}
 
-	case ssa.OpLOONG64DUFFCOPY:
-		p := s.Prog(obj.ADUFFCOPY)
-		p.To.Type = obj.TYPE_MEM
-		p.To.Name = obj.NAME_EXTERN
-		p.To.Sym = ir.Syms.Duffcopy
-		p.To.Offset = v.AuxInt
 	case ssa.OpLOONG64LoweredMove:
 		dstReg := v.Args[0].Reg()
 		srcReg := v.Args[1].Reg()

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

@@ -360,24 +360,6 @@ func init() {
 		{name: "CALLclosure", argLength: -1, reg: regInfo{inputs: []regMask{gpsp, buildReg("R29"), 0}, clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true}, // call function via closure.  arg0=codeptr, arg1=closure, last arg=mem, auxint=argsize, returns mem
 		{name: "CALLinter", argLength: -1, reg: regInfo{inputs: []regMask{gp}, clobbers: callerSave}, aux: "CallOff", clobberFlags: true, call: true},                         // call fn by pointer.  arg0=codeptr, last arg=mem, auxint=argsize, returns mem
 
-		// duffzero
-		// arg0 = address of memory to zero
-		// arg1 = mem
-		// auxint = offset into duffzero code to start executing
-		// returns mem
-		// R20 aka loong64.REGRT1 changed as side effect
-		{
-			name:      "DUFFZERO",
-			aux:       "Int64",
-			argLength: 2,
-			reg: regInfo{
-				inputs:   []regMask{buildReg("R20")},
-				clobbers: buildReg("R20 R1"),
-			},
-			typ:            "Mem",
-			faultOnNilArg0: true,
-		},
-
 		// medium zeroing
 		// arg0 = address of memory to zero
 		// arg1 = mem
@@ -393,25 +375,6 @@ func init() {
 			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)
-		// arg2 = mem
-		// auxint = offset into duffcopy code to start executing
-		// returns mem
-		{
-			name:      "DUFFCOPY",
-			aux:       "Int64",
-			argLength: 3,
-			reg: regInfo{
-				inputs:   []regMask{buildReg("R21"), buildReg("R20")},
-				clobbers: buildReg("R20 R21 R1"),
-			},
-			typ:            "Mem",
-			faultOnNilArg0: true,
-			faultOnNilArg1: true,
-		},
-
 		// large zeroing
 		// arg0 = address of memory to zero
 		// arg1 = mem

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

@@ -1924,9 +1924,7 @@ const (
 	OpLOONG64CALLtail
 	OpLOONG64CALLclosure
 	OpLOONG64CALLinter
-	OpLOONG64DUFFZERO
 	OpLOONG64LoweredZero
-	OpLOONG64DUFFCOPY
 	OpLOONG64LoweredZeroLoop
 	OpLOONG64LoweredMove
 	OpLOONG64LoweredMoveLoop
@@ -25934,18 +25932,6 @@ var opcodeTable = [...]opInfo{
 			clobbers: 4611686018427387896, // R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19 R20 R21 g R23 R24 R25 R26 R27 R28 R29 R31 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31
 		},
 	},
-	{
-		name:           "DUFFZERO",
-		auxType:        auxInt64,
-		argLen:         2,
-		faultOnNilArg0: true,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{0, 524288}, // R20
-			},
-			clobbers: 524290, // R1 R20
-		},
-	},
 	{
 		name:           "LoweredZero",
 		auxType:        auxInt64,
@@ -25957,20 +25943,6 @@ var opcodeTable = [...]opInfo{
 			},
 		},
 	},
-	{
-		name:           "DUFFCOPY",
-		auxType:        auxInt64,
-		argLen:         3,
-		faultOnNilArg0: true,
-		faultOnNilArg1: true,
-		reg: regInfo{
-			inputs: []inputInfo{
-				{0, 1048576}, // R21
-				{1, 524288},  // R20
-			},
-			clobbers: 1572866, // R1 R20 R21
-		},
-	},
 	{
 		name:           "LoweredZeroLoop",
 		auxType:        auxInt64,

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

@@ -225,8 +225,6 @@ const (
 	REGZERO = REG_R0 // set to zero
 	REGLINK = REG_R1
 	REGSP   = REG_R3
-	REGRT1  = REG_R20 // reserved for runtime, duffzero and duffcopy
-	REGRT2  = REG_R21 // reserved for runtime, duffcopy
 	REGCTXT = REG_R29 // context for closures
 	REGG    = REG_R22 // G in loong64
 	REGTMP  = REG_R30 // used by the assembler

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

@@ -440,8 +440,6 @@ var optab = []Optab{
 	{obj.ANOP, C_DCON, C_NONE, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0},  // nop variants, see #40689
 	{obj.ANOP, C_REG, C_NONE, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0},
 	{obj.ANOP, C_FREG, C_NONE, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0},
-	{obj.ADUFFZERO, C_NONE, C_NONE, C_NONE, C_BRAN, C_NONE, 11, 4, 0, 0}, // same as AJMP
-	{obj.ADUFFCOPY, C_NONE, C_NONE, C_NONE, C_BRAN, C_NONE, 11, 4, 0, 0}, // same as AJMP
 }
 
 var atomicInst = map[obj.As]uint32{
@@ -1526,9 +1524,7 @@ func buildop(ctxt *obj.Link) {
 			obj.ATEXT,
 			obj.AFUNCDATA,
 			obj.APCALIGN,
-			obj.APCDATA,
+			obj.APCDATA:
-			obj.ADUFFZERO,
-			obj.ADUFFCOPY:
 			break
 
 		case ARDTIMELW:
@@ -4040,9 +4036,7 @@ func (c *ctxt0) opirr(a obj.As) uint32 {
 
 	case AJMP:
 		return 0x14 << 26
-	case AJAL,
+	case AJAL:
-		obj.ADUFFZERO,
-		obj.ADUFFCOPY:
 		return 0x15 << 26
 
 	case AJIRL:

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

@@ -17,11 +17,7 @@ import (
 func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 	// Rewrite JMP/JAL to symbol as TYPE_BRANCH.
 	switch p.As {
-	case AJMP,
+	case AJMP, AJAL, ARET:
-		AJAL,
-		ARET,
-		obj.ADUFFZERO,
-		obj.ADUFFCOPY:
 		if p.To.Sym != nil {
 			p.To.Type = obj.TYPE_BRANCH
 		}
@@ -93,40 +89,6 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
 }
 
 func rewriteToUseGot(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
-	//     ADUFFxxx $offset
-	// becomes
-	//     MOVV runtime.duffxxx@GOT, REGTMP
-	//     ADD $offset, REGTMP
-	//     JAL REGTMP
-	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
-		var sym *obj.LSym
-		if p.As == obj.ADUFFZERO {
-			sym = ctxt.LookupABI("runtime.duffzero", obj.ABIInternal)
-		} else {
-			sym = ctxt.LookupABI("runtime.duffcopy", obj.ABIInternal)
-		}
-		offset := p.To.Offset
-		p.As = AMOVV
-		p.From.Type = obj.TYPE_MEM
-		p.From.Sym = sym
-		p.From.Name = obj.NAME_GOTREF
-		p.To.Type = obj.TYPE_REG
-		p.To.Reg = REGTMP
-		p.To.Name = obj.NAME_NONE
-		p.To.Offset = 0
-		p.To.Sym = nil
-		p1 := obj.Appendp(p, newprog)
-		p1.As = AADDV
-		p1.From.Type = obj.TYPE_CONST
-		p1.From.Offset = offset
-		p1.To.Type = obj.TYPE_REG
-		p1.To.Reg = REGTMP
-		p2 := obj.Appendp(p1, newprog)
-		p2.As = AJAL
-		p2.To.Type = obj.TYPE_MEM
-		p2.To.Reg = REGTMP
-	}
-
 	// We only care about global data: NAME_EXTERN means a global
 	// symbol in the Go sense, and p.Sym.Local is true for a few
 	// internally defined symbols.
@@ -256,9 +218,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
 				}
 			}
 
-		case AJAL,
+		case AJAL:
-			obj.ADUFFZERO,
-			obj.ADUFFCOPY:
 			c.cursym.Func().Text.Mark &^= LEAF
 			fallthrough
 

src/runtime/duff_loong64.s

@@ -1,907 +0,0 @@
-// Code generated by mkduff.go; DO NOT EDIT.
-// Run go generate from src/runtime to update.
-// See mkduff.go for comments.
-
-#include "textflag.h"
-
-TEXT runtime·duffzero<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-0
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	MOVV	R0, (R20)
-	ADDV	$8, R20
-	RET
-
-TEXT runtime·duffcopy<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-0
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	MOVV	(R20), R30
-	ADDV	$8, R20
-	MOVV	R30, (R21)
-	ADDV	$8, R21
-
-	RET

src/runtime/mkduff.go

@@ -34,7 +34,6 @@ import (
 func main() {
 	gen("386", notags, zero386, copy386)
 	gen("arm", notags, zeroARM, copyARM)
-	gen("loong64", notags, zeroLOONG64, copyLOONG64)
 	gen("ppc64x", tagsPPC64x, zeroPPC64x, copyPPC64x)
 	gen("mips64x", tagsMIPS64x, zeroMIPS64x, copyMIPS64x)
 	gen("riscv64", notags, zeroRISCV64, copyRISCV64)
@@ -175,30 +174,6 @@ func copyARM64(w io.Writer) {
 	fmt.Fprintln(w, "\tRET")
 }
 
-func zeroLOONG64(w io.Writer) {
-	// R0: always zero
-	// R20: ptr to memory to be zeroed
-	// On return, R20 points to the last zeroed dword.
-	fmt.Fprintln(w, "TEXT runtime·duffzero<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-0")
-	for i := 0; i < 128; i++ {
-		fmt.Fprintln(w, "\tMOVV\tR0, (R20)")
-		fmt.Fprintln(w, "\tADDV\t$8, R20")
-	}
-	fmt.Fprintln(w, "\tRET")
-}
-
-func copyLOONG64(w io.Writer) {
-	fmt.Fprintln(w, "TEXT runtime·duffcopy<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-0")
-	for i := 0; i < 128; i++ {
-		fmt.Fprintln(w, "\tMOVV\t(R20), R30")
-		fmt.Fprintln(w, "\tADDV\t$8, R20")
-		fmt.Fprintln(w, "\tMOVV\tR30, (R21)")
-		fmt.Fprintln(w, "\tADDV\t$8, R21")
-		fmt.Fprintln(w)
-	}
-	fmt.Fprintln(w, "\tRET")
-}
-
 func tagsPPC64x(w io.Writer) {
 	fmt.Fprintln(w)
 	fmt.Fprintln(w, "//go:build ppc64 || ppc64le")