github.com/mtsmfm/go/src@v0.0.0-20221020090648-44bdcb9f8fde/runtime/sys_freebsd_arm64.s (about) 1 // Copyright 2019 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 // 6 // System calls and other sys.stuff for arm64, FreeBSD 7 // /usr/src/sys/kern/syscalls.master for syscall numbers. 8 // 9 10 #include "go_asm.h" 11 #include "go_tls.h" 12 #include "textflag.h" 13 #include "cgo/abi_arm64.h" 14 15 #define CLOCK_REALTIME 0 16 #define CLOCK_MONOTONIC 4 17 #define FD_CLOEXEC 1 18 #define F_SETFD 2 19 #define F_GETFL 3 20 #define F_SETFL 4 21 #define O_NONBLOCK 4 22 23 #define SYS_exit 1 24 #define SYS_read 3 25 #define SYS_write 4 26 #define SYS_open 5 27 #define SYS_close 6 28 #define SYS_getpid 20 29 #define SYS_kill 37 30 #define SYS_sigaltstack 53 31 #define SYS_munmap 73 32 #define SYS_madvise 75 33 #define SYS_setitimer 83 34 #define SYS_fcntl 92 35 #define SYS___sysctl 202 36 #define SYS_nanosleep 240 37 #define SYS_clock_gettime 232 38 #define SYS_sched_yield 331 39 #define SYS_sigprocmask 340 40 #define SYS_kqueue 362 41 #define SYS_sigaction 416 42 #define SYS_thr_exit 431 43 #define SYS_thr_self 432 44 #define SYS_thr_kill 433 45 #define SYS__umtx_op 454 46 #define SYS_thr_new 455 47 #define SYS_mmap 477 48 #define SYS_cpuset_getaffinity 487 49 #define SYS_pipe2 542 50 #define SYS_kevent 560 51 52 TEXT emptyfunc<>(SB),0,$0-0 53 RET 54 55 // func sys_umtx_op(addr *uint32, mode int32, val uint32, uaddr1 uintptr, ut *umtx_time) int32 56 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0 57 MOVD addr+0(FP), R0 58 MOVW mode+8(FP), R1 59 MOVW val+12(FP), R2 60 MOVD uaddr1+16(FP), R3 61 MOVD ut+24(FP), R4 62 MOVD $SYS__umtx_op, R8 63 SVC 64 BCC ok 65 NEG R0, R0 66 ok: 67 MOVW R0, ret+32(FP) 68 RET 69 70 // func thr_new(param *thrparam, size int32) int32 71 TEXT runtime·thr_new(SB),NOSPLIT,$0 72 MOVD param+0(FP), R0 73 MOVW size+8(FP), R1 74 MOVD $SYS_thr_new, R8 75 SVC 76 BCC ok 77 NEG R0, R0 78 ok: 79 MOVW R0, ret+16(FP) 80 RET 81 82 // func thr_start() 83 TEXT runtime·thr_start(SB),NOSPLIT,$0 84 // set up g 85 MOVD m_g0(R0), g 86 MOVD R0, g_m(g) 87 BL emptyfunc<>(SB) // fault if stack check is wrong 88 BL runtime·mstart(SB) 89 90 MOVD $2, R8 // crash (not reached) 91 MOVD R8, (R8) 92 RET 93 94 // func exit(code int32) 95 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4 96 MOVW code+0(FP), R0 97 MOVD $SYS_exit, R8 98 SVC 99 MOVD $0, R0 100 MOVD R0, (R0) 101 102 // func exitThread(wait *atomic.Uint32) 103 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8 104 MOVD wait+0(FP), R0 105 // We're done using the stack. 106 MOVW $0, R1 107 STLRW R1, (R0) 108 MOVW $0, R0 109 MOVD $SYS_thr_exit, R8 110 SVC 111 JMP 0(PC) 112 113 // func open(name *byte, mode, perm int32) int32 114 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20 115 MOVD name+0(FP), R0 116 MOVW mode+8(FP), R1 117 MOVW perm+12(FP), R2 118 MOVD $SYS_open, R8 119 SVC 120 BCC ok 121 MOVW $-1, R0 122 ok: 123 MOVW R0, ret+16(FP) 124 RET 125 126 // func closefd(fd int32) int32 127 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12 128 MOVW fd+0(FP), R0 129 MOVD $SYS_close, R8 130 SVC 131 BCC ok 132 MOVW $-1, R0 133 ok: 134 MOVW R0, ret+8(FP) 135 RET 136 137 // func pipe2(flags int32) (r, w int32, errno int32) 138 TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20 139 MOVD $r+8(FP), R0 140 MOVW flags+0(FP), R1 141 MOVD $SYS_pipe2, R8 142 SVC 143 BCC ok 144 NEG R0, R0 145 ok: 146 MOVW R0, errno+16(FP) 147 RET 148 149 // func write1(fd uintptr, p unsafe.Pointer, n int32) int32 150 TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28 151 MOVD fd+0(FP), R0 152 MOVD p+8(FP), R1 153 MOVW n+16(FP), R2 154 MOVD $SYS_write, R8 155 SVC 156 BCC ok 157 NEG R0, R0 // caller expects negative errno 158 ok: 159 MOVW R0, ret+24(FP) 160 RET 161 162 // func read(fd int32, p unsafe.Pointer, n int32) int32 163 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28 164 MOVW fd+0(FP), R0 165 MOVD p+8(FP), R1 166 MOVW n+16(FP), R2 167 MOVD $SYS_read, R8 168 SVC 169 BCC ok 170 NEG R0, R0 // caller expects negative errno 171 ok: 172 MOVW R0, ret+24(FP) 173 RET 174 175 // func usleep(usec uint32) 176 TEXT runtime·usleep(SB),NOSPLIT,$24-4 177 MOVWU usec+0(FP), R3 178 MOVD R3, R5 179 MOVW $1000000, R4 180 UDIV R4, R3 181 MOVD R3, 8(RSP) 182 MUL R3, R4 183 SUB R4, R5 184 MOVW $1000, R4 185 MUL R4, R5 186 MOVD R5, 16(RSP) 187 188 // nanosleep(&ts, 0) 189 ADD $8, RSP, R0 190 MOVD $0, R1 191 MOVD $SYS_nanosleep, R8 192 SVC 193 RET 194 195 // func thr_self() thread 196 TEXT runtime·thr_self(SB),NOSPLIT,$8-8 197 MOVD $ptr-8(SP), R0 // arg 1 &8(SP) 198 MOVD $SYS_thr_self, R8 199 SVC 200 MOVD ptr-8(SP), R0 201 MOVD R0, ret+0(FP) 202 RET 203 204 // func thr_kill(t thread, sig int) 205 TEXT runtime·thr_kill(SB),NOSPLIT,$0-16 206 MOVD tid+0(FP), R0 // arg 1 pid 207 MOVD sig+8(FP), R1 // arg 2 sig 208 MOVD $SYS_thr_kill, R8 209 SVC 210 RET 211 212 // func raiseproc(sig uint32) 213 TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0 214 MOVD $SYS_getpid, R8 215 SVC 216 MOVW sig+0(FP), R1 217 MOVD $SYS_kill, R8 218 SVC 219 RET 220 221 // func setitimer(mode int32, new, old *itimerval) 222 TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24 223 MOVW mode+0(FP), R0 224 MOVD new+8(FP), R1 225 MOVD old+16(FP), R2 226 MOVD $SYS_setitimer, R8 227 SVC 228 RET 229 230 // func fallback_walltime() (sec int64, nsec int32) 231 TEXT runtime·fallback_walltime(SB),NOSPLIT,$24-12 232 MOVW $CLOCK_REALTIME, R0 233 MOVD $8(RSP), R1 234 MOVD $SYS_clock_gettime, R8 235 SVC 236 MOVD 8(RSP), R0 // sec 237 MOVW 16(RSP), R1 // nsec 238 MOVD R0, sec+0(FP) 239 MOVW R1, nsec+8(FP) 240 RET 241 242 // func fallback_nanotime() int64 243 TEXT runtime·fallback_nanotime(SB),NOSPLIT,$24-8 244 MOVD $CLOCK_MONOTONIC, R0 245 MOVD $8(RSP), R1 246 MOVD $SYS_clock_gettime, R8 247 SVC 248 MOVD 8(RSP), R0 // sec 249 MOVW 16(RSP), R2 // nsec 250 251 // sec is in R0, nsec in R2 252 // return nsec in R2 253 MOVD $1000000000, R3 254 MUL R3, R0 255 ADD R2, R0 256 257 MOVD R0, ret+0(FP) 258 RET 259 260 // func asmSigaction(sig uintptr, new, old *sigactiont) int32 261 TEXT runtime·asmSigaction(SB),NOSPLIT|NOFRAME,$0 262 MOVD sig+0(FP), R0 // arg 1 sig 263 MOVD new+8(FP), R1 // arg 2 act 264 MOVD old+16(FP), R2 // arg 3 oact 265 MOVD $SYS_sigaction, R8 266 SVC 267 BCC ok 268 MOVW $-1, R0 269 ok: 270 MOVW R0, ret+24(FP) 271 RET 272 273 // func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer) 274 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 275 MOVW sig+8(FP), R0 276 MOVD info+16(FP), R1 277 MOVD ctx+24(FP), R2 278 MOVD fn+0(FP), R11 279 BL (R11) 280 RET 281 282 // func sigtramp() 283 TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$176 284 // Save callee-save registers in the case of signal forwarding. 285 // Please refer to https://golang.org/issue/31827 . 286 SAVE_R19_TO_R28(8*4) 287 SAVE_F8_TO_F15(8*14) 288 289 // this might be called in external code context, 290 // where g is not set. 291 // first save R0, because runtime·load_g will clobber it 292 MOVW R0, 8(RSP) 293 MOVBU runtime·iscgo(SB), R0 294 CMP $0, R0 295 BEQ 2(PC) 296 BL runtime·load_g(SB) 297 298 #ifdef GOEXPERIMENT_regabiargs 299 // Restore signum to R0. 300 MOVW 8(RSP), R0 301 // R1 and R2 already contain info and ctx, respectively. 302 #else 303 MOVD R1, 16(RSP) 304 MOVD R2, 24(RSP) 305 #endif 306 MOVD $runtime·sigtrampgo<ABIInternal>(SB), R3 307 BL (R3) 308 309 // Restore callee-save registers. 310 RESTORE_R19_TO_R28(8*4) 311 RESTORE_F8_TO_F15(8*14) 312 313 RET 314 315 // func mmap(addr uintptr, n uintptr, prot int, flags int, fd int, off int64) (ret uintptr, err error) 316 TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0 317 MOVD addr+0(FP), R0 318 MOVD n+8(FP), R1 319 MOVW prot+16(FP), R2 320 MOVW flags+20(FP), R3 321 MOVW fd+24(FP), R4 322 MOVW off+28(FP), R5 323 MOVD $SYS_mmap, R8 324 SVC 325 BCS fail 326 MOVD R0, p+32(FP) 327 MOVD $0, err+40(FP) 328 RET 329 fail: 330 MOVD $0, p+32(FP) 331 MOVD R0, err+40(FP) 332 RET 333 334 // func munmap(addr uintptr, n uintptr) (err error) 335 TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0 336 MOVD addr+0(FP), R0 337 MOVD n+8(FP), R1 338 MOVD $SYS_munmap, R8 339 SVC 340 BCS fail 341 RET 342 fail: 343 MOVD $0, R0 344 MOVD R0, (R0) // crash 345 346 // func madvise(addr unsafe.Pointer, n uintptr, flags int32) int32 347 TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0 348 MOVD addr+0(FP), R0 349 MOVD n+8(FP), R1 350 MOVW flags+16(FP), R2 351 MOVD $SYS_madvise, R8 352 SVC 353 BCC ok 354 MOVW $-1, R0 355 ok: 356 MOVW R0, ret+24(FP) 357 RET 358 359 // func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32 360 TEXT runtime·sysctl(SB),NOSPLIT,$0 361 MOVD mib+0(FP), R0 362 MOVD miblen+8(FP), R1 363 MOVD out+16(FP), R2 364 MOVD size+24(FP), R3 365 MOVD dst+32(FP), R4 366 MOVD ndst+40(FP), R5 367 MOVD $SYS___sysctl, R8 368 SVC 369 BCC ok 370 NEG R0, R0 371 ok: 372 MOVW R0, ret+48(FP) 373 RET 374 375 // func sigaltstack(new, old *stackt) 376 TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0 377 MOVD new+0(FP), R0 378 MOVD old+8(FP), R1 379 MOVD $SYS_sigaltstack, R8 380 SVC 381 BCS fail 382 RET 383 fail: 384 MOVD $0, R0 385 MOVD R0, (R0) // crash 386 387 // func osyield() 388 TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0 389 MOVD $SYS_sched_yield, R8 390 SVC 391 RET 392 393 // func sigprocmask(how int32, new, old *sigset) 394 TEXT runtime·sigprocmask(SB),NOSPLIT|NOFRAME,$0-24 395 MOVW how+0(FP), R0 396 MOVD new+8(FP), R1 397 MOVD old+16(FP), R2 398 MOVD $SYS_sigprocmask, R8 399 SVC 400 BCS fail 401 RET 402 fail: 403 MOVD $0, R0 404 MOVD R0, (R0) // crash 405 406 // func cpuset_getaffinity(level int, which int, id int64, size int, mask *byte) int32 407 TEXT runtime·cpuset_getaffinity(SB),NOSPLIT|NOFRAME,$0-44 408 MOVD level+0(FP), R0 409 MOVD which+8(FP), R1 410 MOVD id+16(FP), R2 411 MOVD size+24(FP), R3 412 MOVD mask+32(FP), R4 413 MOVD $SYS_cpuset_getaffinity, R8 414 SVC 415 BCC ok 416 MOVW $-1, R0 417 ok: 418 MOVW R0, ret+40(FP) 419 RET 420 421 // func kqueue() int32 422 TEXT runtime·kqueue(SB),NOSPLIT|NOFRAME,$0 423 MOVD $SYS_kqueue, R8 424 SVC 425 BCC ok 426 MOVW $-1, R0 427 ok: 428 MOVW R0, ret+0(FP) 429 RET 430 431 // func kevent(kq int, ch unsafe.Pointer, nch int, ev unsafe.Pointer, nev int, ts *Timespec) (n int, err error) 432 TEXT runtime·kevent(SB),NOSPLIT,$0 433 MOVW kq+0(FP), R0 434 MOVD ch+8(FP), R1 435 MOVW nch+16(FP), R2 436 MOVD ev+24(FP), R3 437 MOVW nev+32(FP), R4 438 MOVD ts+40(FP), R5 439 MOVD $SYS_kevent, R8 440 SVC 441 BCC ok 442 NEG R0, R0 443 ok: 444 MOVW R0, ret+48(FP) 445 RET 446 447 // func closeonexec(fd int32) 448 TEXT runtime·closeonexec(SB),NOSPLIT|NOFRAME,$0 449 MOVW fd+0(FP), R0 450 MOVD $F_SETFD, R1 451 MOVD $FD_CLOEXEC, R2 452 MOVD $SYS_fcntl, R8 453 SVC 454 RET 455 456 // func getCntxct(physical bool) uint32 457 TEXT runtime·getCntxct(SB),NOSPLIT,$0 458 MOVB physical+0(FP), R0 459 CMP $0, R0 460 BEQ 3(PC) 461 462 // get CNTPCT (Physical Count Register) into R0 463 MRS CNTPCT_EL0, R0 464 B 2(PC) 465 466 // get CNTVCT (Virtual Count Register) into R0 467 MRS CNTVCT_EL0, R0 468 469 MOVW R0, ret+8(FP) 470 RET