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>

diff --git a/src/cmd/compile/internal/loong64/ssa.go b/src/cmd/compile/internal/loong64/ssa.go
index 3959f8a7c11eb99c157e6961d54d7f470653e3d4..134575c85ca658e25acef3d0e097925b53a6db5f 100644 (file)
--- a/src/cmd/compile/internal/loong64/ssa.go
+++ b/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()

diff --git a/src/cmd/compile/internal/ssa/_gen/LOONG64Ops.go b/src/cmd/compile/internal/ssa/_gen/LOONG64Ops.go
index cc6ae8fb8e65de9422ac6d5499df48287e1ed690..bee619f6d93a78abc6da2e064ae14e08dce756a4 100644 (file)
--- a/src/cmd/compile/internal/ssa/_gen/LOONG64Ops.go
+++ b/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

diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index f42d64228fae3a1c2866b856eaf02f314b0be277..4aef2d2aa1e9c57e3a855fe012e57cd6550c77a3 100644 (file)
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/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,

diff --git a/src/cmd/internal/obj/loong64/a.out.go b/src/cmd/internal/obj/loong64/a.out.go
index 8e651cdfef0e21ee6d48325bf0c16692e6de1484..7ab85a2f2378aa232c8998b8ea3f50825fc7f359 100644 (file)
--- a/src/cmd/internal/obj/loong64/a.out.go
+++ b/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

diff --git a/src/cmd/internal/obj/loong64/asm.go b/src/cmd/internal/obj/loong64/asm.go
index 35b33b937684285aa3bdcb38187d34c26c8ffca4..848d77fd0d92aac24230ad7868ea5d684809bd17 100644 (file)
--- a/src/cmd/internal/obj/loong64/asm.go
+++ b/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.ADUFFZERO,
-                       obj.ADUFFCOPY:
+                       obj.APCDATA:
                        break
 
                case ARDTIMELW:
@@ -4040,9 +4036,7 @@ func (c *ctxt0) opirr(a obj.As) uint32 {
 
        case AJMP:
                return 0x14 << 26
-       case AJAL,
-               obj.ADUFFZERO,
-               obj.ADUFFCOPY:
+       case AJAL:
                return 0x15 << 26
 
        case AJIRL:

diff --git a/src/cmd/internal/obj/loong64/obj.go b/src/cmd/internal/obj/loong64/obj.go
index a1eb786da3106786149c80c776dc26a2255588cd..a97217d31657cfcdf6029f6816721aa656e0592e 100644 (file)
--- a/src/cmd/internal/obj/loong64/obj.go
+++ b/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,
-               AJAL,
-               ARET,
-               obj.ADUFFZERO,
-               obj.ADUFFCOPY:
+       case AJMP, AJAL, ARET:
                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,
-                       obj.ADUFFZERO,
-                       obj.ADUFFCOPY:
+               case AJAL:
                        c.cursym.Func().Text.Mark &^= LEAF
                        fallthrough
 

diff --git a/src/runtime/duff_loong64.s b/src/runtime/duff_loong64.s
deleted file mode 100644 (file)
index b05502d..0000000
--- a/src/runtime/duff_loong64.s
+++ /dev/null
@@ -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

diff --git a/src/runtime/mkduff.go b/src/runtime/mkduff.go
index dfff084e80f1a64966fdbbef4a64dd29574d777c..75ff437f262172235d70a561987287f9764c749d 100644 (file)
--- a/src/runtime/mkduff.go
+++ b/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")