github.com/comwrg/go/src@v0.0.0-20220319063731-c238d0440370/runtime/mkduff.go (about) 1 // Copyright 2015 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 //go:build ignore 6 // +build ignore 7 8 // runtime·duffzero is a Duff's device for zeroing memory. 9 // The compiler jumps to computed addresses within 10 // the routine to zero chunks of memory. 11 // Do not change duffzero without also 12 // changing the uses in cmd/compile/internal/*/*.go. 13 14 // runtime·duffcopy is a Duff's device for copying memory. 15 // The compiler jumps to computed addresses within 16 // the routine to copy chunks of memory. 17 // Source and destination must not overlap. 18 // Do not change duffcopy without also 19 // changing the uses in cmd/compile/internal/*/*.go. 20 21 // See the zero* and copy* generators below 22 // for architecture-specific comments. 23 24 // mkduff generates duff_*.s. 25 package main 26 27 import ( 28 "bytes" 29 "fmt" 30 "io" 31 "log" 32 "os" 33 ) 34 35 func main() { 36 gen("amd64", notags, zeroAMD64, copyAMD64) 37 gen("386", notags, zero386, copy386) 38 gen("arm", notags, zeroARM, copyARM) 39 gen("arm64", notags, zeroARM64, copyARM64) 40 gen("ppc64x", tagsPPC64x, zeroPPC64x, copyPPC64x) 41 gen("mips64x", tagsMIPS64x, zeroMIPS64x, copyMIPS64x) 42 gen("riscv64", notags, zeroRISCV64, copyRISCV64) 43 } 44 45 func gen(arch string, tags, zero, copy func(io.Writer)) { 46 var buf bytes.Buffer 47 48 fmt.Fprintln(&buf, "// Code generated by mkduff.go; DO NOT EDIT.") 49 fmt.Fprintln(&buf, "// Run go generate from src/runtime to update.") 50 fmt.Fprintln(&buf, "// See mkduff.go for comments.") 51 tags(&buf) 52 fmt.Fprintln(&buf, "#include \"textflag.h\"") 53 fmt.Fprintln(&buf) 54 zero(&buf) 55 fmt.Fprintln(&buf) 56 copy(&buf) 57 58 if err := os.WriteFile("duff_"+arch+".s", buf.Bytes(), 0644); err != nil { 59 log.Fatalln(err) 60 } 61 } 62 63 func notags(w io.Writer) { fmt.Fprintln(w) } 64 65 func zeroAMD64(w io.Writer) { 66 // X15: zero 67 // DI: ptr to memory to be zeroed 68 // DI is updated as a side effect. 69 fmt.Fprintln(w, "TEXT runtime·duffzero<ABIInternal>(SB), NOSPLIT, $0-0") 70 for i := 0; i < 16; i++ { 71 fmt.Fprintln(w, "\tMOVUPS\tX15,(DI)") 72 fmt.Fprintln(w, "\tMOVUPS\tX15,16(DI)") 73 fmt.Fprintln(w, "\tMOVUPS\tX15,32(DI)") 74 fmt.Fprintln(w, "\tMOVUPS\tX15,48(DI)") 75 fmt.Fprintln(w, "\tLEAQ\t64(DI),DI") // We use lea instead of add, to avoid clobbering flags 76 fmt.Fprintln(w) 77 } 78 fmt.Fprintln(w, "\tRET") 79 } 80 81 func copyAMD64(w io.Writer) { 82 // SI: ptr to source memory 83 // DI: ptr to destination memory 84 // SI and DI are updated as a side effect. 85 // 86 // This is equivalent to a sequence of MOVSQ but 87 // for some reason that is 3.5x slower than this code. 88 fmt.Fprintln(w, "TEXT runtime·duffcopy<ABIInternal>(SB), NOSPLIT, $0-0") 89 for i := 0; i < 64; i++ { 90 fmt.Fprintln(w, "\tMOVUPS\t(SI), X0") 91 fmt.Fprintln(w, "\tADDQ\t$16, SI") 92 fmt.Fprintln(w, "\tMOVUPS\tX0, (DI)") 93 fmt.Fprintln(w, "\tADDQ\t$16, DI") 94 fmt.Fprintln(w) 95 } 96 fmt.Fprintln(w, "\tRET") 97 } 98 99 func zero386(w io.Writer) { 100 // AX: zero 101 // DI: ptr to memory to be zeroed 102 // DI is updated as a side effect. 103 fmt.Fprintln(w, "TEXT runtime·duffzero(SB), NOSPLIT, $0-0") 104 for i := 0; i < 128; i++ { 105 fmt.Fprintln(w, "\tSTOSL") 106 } 107 fmt.Fprintln(w, "\tRET") 108 } 109 110 func copy386(w io.Writer) { 111 // SI: ptr to source memory 112 // DI: ptr to destination memory 113 // SI and DI are updated as a side effect. 114 // 115 // This is equivalent to a sequence of MOVSL but 116 // for some reason MOVSL is really slow. 117 fmt.Fprintln(w, "TEXT runtime·duffcopy(SB), NOSPLIT, $0-0") 118 for i := 0; i < 128; i++ { 119 fmt.Fprintln(w, "\tMOVL\t(SI), CX") 120 fmt.Fprintln(w, "\tADDL\t$4, SI") 121 fmt.Fprintln(w, "\tMOVL\tCX, (DI)") 122 fmt.Fprintln(w, "\tADDL\t$4, DI") 123 fmt.Fprintln(w) 124 } 125 fmt.Fprintln(w, "\tRET") 126 } 127 128 func zeroARM(w io.Writer) { 129 // R0: zero 130 // R1: ptr to memory to be zeroed 131 // R1 is updated as a side effect. 132 fmt.Fprintln(w, "TEXT runtime·duffzero(SB), NOSPLIT, $0-0") 133 for i := 0; i < 128; i++ { 134 fmt.Fprintln(w, "\tMOVW.P\tR0, 4(R1)") 135 } 136 fmt.Fprintln(w, "\tRET") 137 } 138 139 func copyARM(w io.Writer) { 140 // R0: scratch space 141 // R1: ptr to source memory 142 // R2: ptr to destination memory 143 // R1 and R2 are updated as a side effect 144 fmt.Fprintln(w, "TEXT runtime·duffcopy(SB), NOSPLIT, $0-0") 145 for i := 0; i < 128; i++ { 146 fmt.Fprintln(w, "\tMOVW.P\t4(R1), R0") 147 fmt.Fprintln(w, "\tMOVW.P\tR0, 4(R2)") 148 fmt.Fprintln(w) 149 } 150 fmt.Fprintln(w, "\tRET") 151 } 152 153 func zeroARM64(w io.Writer) { 154 // ZR: always zero 155 // R20: ptr to memory to be zeroed 156 // On return, R20 points to the last zeroed dword. 157 fmt.Fprintln(w, "TEXT runtime·duffzero(SB), NOSPLIT|NOFRAME, $0-0") 158 for i := 0; i < 63; i++ { 159 fmt.Fprintln(w, "\tSTP.P\t(ZR, ZR), 16(R20)") 160 } 161 fmt.Fprintln(w, "\tSTP\t(ZR, ZR), (R20)") 162 fmt.Fprintln(w, "\tRET") 163 } 164 165 func copyARM64(w io.Writer) { 166 // R20: ptr to source memory 167 // R21: ptr to destination memory 168 // R26, R27 (aka REGTMP): scratch space 169 // R20 and R21 are updated as a side effect 170 fmt.Fprintln(w, "TEXT runtime·duffcopy(SB), NOSPLIT|NOFRAME, $0-0") 171 172 for i := 0; i < 64; i++ { 173 fmt.Fprintln(w, "\tLDP.P\t16(R20), (R26, R27)") 174 fmt.Fprintln(w, "\tSTP.P\t(R26, R27), 16(R21)") 175 fmt.Fprintln(w) 176 } 177 fmt.Fprintln(w, "\tRET") 178 } 179 180 func tagsPPC64x(w io.Writer) { 181 fmt.Fprintln(w) 182 fmt.Fprintln(w, "//go:build ppc64 || ppc64le") 183 fmt.Fprintln(w, "// +build ppc64 ppc64le") 184 fmt.Fprintln(w) 185 } 186 187 func zeroPPC64x(w io.Writer) { 188 // R0: always zero 189 // R3 (aka REGRT1): ptr to memory to be zeroed - 8 190 // On return, R3 points to the last zeroed dword. 191 fmt.Fprintln(w, "TEXT runtime·duffzero(SB), NOSPLIT|NOFRAME, $0-0") 192 for i := 0; i < 128; i++ { 193 fmt.Fprintln(w, "\tMOVDU\tR0, 8(R3)") 194 } 195 fmt.Fprintln(w, "\tRET") 196 } 197 198 func copyPPC64x(w io.Writer) { 199 // duffcopy is not used on PPC64. 200 fmt.Fprintln(w, "TEXT runtime·duffcopy(SB), NOSPLIT|NOFRAME, $0-0") 201 fmt.Fprintln(w, "\tUNDEF") 202 } 203 204 func tagsMIPS64x(w io.Writer) { 205 fmt.Fprintln(w) 206 fmt.Fprintln(w, "//go:build mips64 || mips64le") 207 fmt.Fprintln(w, "// +build mips64 mips64le") 208 fmt.Fprintln(w) 209 } 210 211 func zeroMIPS64x(w io.Writer) { 212 // R0: always zero 213 // R1 (aka REGRT1): ptr to memory to be zeroed - 8 214 // On return, R1 points to the last zeroed dword. 215 fmt.Fprintln(w, "TEXT runtime·duffzero(SB), NOSPLIT|NOFRAME, $0-0") 216 for i := 0; i < 128; i++ { 217 fmt.Fprintln(w, "\tMOVV\tR0, 8(R1)") 218 fmt.Fprintln(w, "\tADDV\t$8, R1") 219 } 220 fmt.Fprintln(w, "\tRET") 221 } 222 223 func copyMIPS64x(w io.Writer) { 224 fmt.Fprintln(w, "TEXT runtime·duffcopy(SB), NOSPLIT|NOFRAME, $0-0") 225 for i := 0; i < 128; i++ { 226 fmt.Fprintln(w, "\tMOVV\t(R1), R23") 227 fmt.Fprintln(w, "\tADDV\t$8, R1") 228 fmt.Fprintln(w, "\tMOVV\tR23, (R2)") 229 fmt.Fprintln(w, "\tADDV\t$8, R2") 230 fmt.Fprintln(w) 231 } 232 fmt.Fprintln(w, "\tRET") 233 } 234 235 func zeroRISCV64(w io.Writer) { 236 // ZERO: always zero 237 // X10: ptr to memory to be zeroed 238 // X10 is updated as a side effect. 239 fmt.Fprintln(w, "TEXT runtime·duffzero(SB), NOSPLIT|NOFRAME, $0-0") 240 for i := 0; i < 128; i++ { 241 fmt.Fprintln(w, "\tMOV\tZERO, (X10)") 242 fmt.Fprintln(w, "\tADD\t$8, X10") 243 } 244 fmt.Fprintln(w, "\tRET") 245 } 246 247 func copyRISCV64(w io.Writer) { 248 // X10: ptr to source memory 249 // X11: ptr to destination memory 250 // X10 and X11 are updated as a side effect 251 fmt.Fprintln(w, "TEXT runtime·duffcopy(SB), NOSPLIT|NOFRAME, $0-0") 252 for i := 0; i < 128; i++ { 253 fmt.Fprintln(w, "\tMOV\t(X10), X31") 254 fmt.Fprintln(w, "\tADD\t$8, X10") 255 fmt.Fprintln(w, "\tMOV\tX31, (X11)") 256 fmt.Fprintln(w, "\tADD\t$8, X11") 257 fmt.Fprintln(w) 258 } 259 fmt.Fprintln(w, "\tRET") 260 }