| // Copyright 2019 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| // |
| // System calls and other sys.stuff for arm64, OpenBSD |
| // /usr/src/sys/kern/syscalls.master for syscall numbers. |
| // |
| |
| #include "go_asm.h" |
| #include "go_tls.h" |
| #include "textflag.h" |
| |
| #define CLOCK_REALTIME $0 |
| #define CLOCK_MONOTONIC $3 |
| |
| // With OpenBSD 6.7 onwards, an arm64 syscall returns two instructions |
| // after the SVC instruction, to allow for a speculative execution |
| // barrier to be placed after the SVC without impacting performance. |
| // For now use hardware no-ops as this works with both older and newer |
| // kernels. After OpenBSD 6.8 is released this should be changed to |
| // speculation barriers. |
| #define INVOKE_SYSCALL \ |
| SVC; \ |
| NOOP; \ |
| NOOP |
| |
| // Exit the entire program (like C exit) |
| TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0 |
| MOVW code+0(FP), R0 // arg 1 - status |
| MOVD $1, R8 // sys_exit |
| INVOKE_SYSCALL |
| BCC 3(PC) |
| MOVD $0, R0 // crash on syscall failure |
| MOVD R0, (R0) |
| RET |
| |
| // func exitThread(wait *uint32) |
| TEXT runtime·exitThread(SB),NOSPLIT,$0 |
| MOVD wait+0(FP), R0 // arg 1 - notdead |
| MOVD $302, R8 // sys___threxit |
| INVOKE_SYSCALL |
| MOVD $0, R0 // crash on syscall failure |
| MOVD R0, (R0) |
| JMP 0(PC) |
| |
| TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0 |
| MOVD name+0(FP), R0 // arg 1 - path |
| MOVW mode+8(FP), R1 // arg 2 - mode |
| MOVW perm+12(FP), R2 // arg 3 - perm |
| MOVD $5, R8 // sys_open |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| MOVW $-1, R0 |
| MOVW R0, ret+16(FP) |
| RET |
| |
| TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0 |
| MOVW fd+0(FP), R0 // arg 1 - fd |
| MOVD $6, R8 // sys_close |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| MOVW $-1, R0 |
| MOVW R0, ret+8(FP) |
| RET |
| |
| TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0 |
| MOVW fd+0(FP), R0 // arg 1 - fd |
| MOVD p+8(FP), R1 // arg 2 - buf |
| MOVW n+16(FP), R2 // arg 3 - nbyte |
| MOVD $3, R8 // sys_read |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| NEG R0, R0 |
| MOVW R0, ret+24(FP) |
| RET |
| |
| // func pipe() (r, w int32, errno int32) |
| TEXT runtime·pipe(SB),NOSPLIT|NOFRAME,$0-12 |
| MOVD $r+0(FP), R0 |
| MOVW $0, R1 |
| MOVD $101, R8 // sys_pipe2 |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| NEG R0, R0 |
| MOVW R0, errno+8(FP) |
| RET |
| |
| // func pipe2(flags int32) (r, w int32, errno int32) |
| TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20 |
| MOVD $r+8(FP), R0 |
| MOVW flags+0(FP), R1 |
| MOVD $101, R8 // sys_pipe2 |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| NEG R0, R0 |
| MOVW R0, errno+16(FP) |
| RET |
| |
| TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0 |
| MOVD fd+0(FP), R0 // arg 1 - fd |
| MOVD p+8(FP), R1 // arg 2 - buf |
| MOVW n+16(FP), R2 // arg 3 - nbyte |
| MOVD $4, R8 // sys_write |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| NEG R0, R0 |
| MOVW R0, ret+24(FP) |
| RET |
| |
| TEXT runtime·usleep(SB),NOSPLIT,$24-4 |
| MOVWU usec+0(FP), R3 |
| MOVD R3, R5 |
| MOVW $1000000, R4 |
| UDIV R4, R3 |
| MOVD R3, 8(RSP) // tv_sec |
| MUL R3, R4 |
| SUB R4, R5 |
| MOVW $1000, R4 |
| MUL R4, R5 |
| MOVD R5, 16(RSP) // tv_nsec |
| |
| ADD $8, RSP, R0 // arg 1 - rqtp |
| MOVD $0, R1 // arg 2 - rmtp |
| MOVD $91, R8 // sys_nanosleep |
| INVOKE_SYSCALL |
| RET |
| |
| TEXT runtime·getthrid(SB),NOSPLIT,$0-4 |
| MOVD $299, R8 // sys_getthrid |
| INVOKE_SYSCALL |
| MOVW R0, ret+0(FP) |
| RET |
| |
| TEXT runtime·thrkill(SB),NOSPLIT,$0-16 |
| MOVW tid+0(FP), R0 // arg 1 - tid |
| MOVD sig+8(FP), R1 // arg 2 - signum |
| MOVW $0, R2 // arg 3 - tcb |
| MOVD $119, R8 // sys_thrkill |
| INVOKE_SYSCALL |
| RET |
| |
| TEXT runtime·raiseproc(SB),NOSPLIT,$0 |
| MOVD $20, R8 // sys_getpid |
| INVOKE_SYSCALL |
| // arg 1 - pid, already in R0 |
| MOVW sig+0(FP), R1 // arg 2 - signum |
| MOVD $122, R8 // sys_kill |
| INVOKE_SYSCALL |
| RET |
| |
| TEXT runtime·mmap(SB),NOSPLIT,$0 |
| MOVD addr+0(FP), R0 // arg 1 - addr |
| MOVD n+8(FP), R1 // arg 2 - len |
| MOVW prot+16(FP), R2 // arg 3 - prot |
| MOVW flags+20(FP), R3 // arg 4 - flags |
| MOVW fd+24(FP), R4 // arg 5 - fd |
| MOVW $0, R5 // arg 6 - pad |
| MOVW off+28(FP), R6 // arg 7 - offset |
| MOVD $197, R8 // sys_mmap |
| INVOKE_SYSCALL |
| MOVD $0, R1 |
| BCC 3(PC) |
| MOVD R0, R1 // if error, move to R1 |
| MOVD $0, R0 |
| MOVD R0, p+32(FP) |
| MOVD R1, err+40(FP) |
| RET |
| |
| TEXT runtime·munmap(SB),NOSPLIT,$0 |
| MOVD addr+0(FP), R0 // arg 1 - addr |
| MOVD n+8(FP), R1 // arg 2 - len |
| MOVD $73, R8 // sys_munmap |
| INVOKE_SYSCALL |
| BCC 3(PC) |
| MOVD $0, R0 // crash on syscall failure |
| MOVD R0, (R0) |
| RET |
| |
| TEXT runtime·madvise(SB),NOSPLIT,$0 |
| MOVD addr+0(FP), R0 // arg 1 - addr |
| MOVD n+8(FP), R1 // arg 2 - len |
| MOVW flags+16(FP), R2 // arg 2 - flags |
| MOVD $75, R8 // sys_madvise |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| MOVW $-1, R0 |
| MOVW R0, ret+24(FP) |
| RET |
| |
| TEXT runtime·setitimer(SB),NOSPLIT,$0 |
| MOVW mode+0(FP), R0 // arg 1 - mode |
| MOVD new+8(FP), R1 // arg 2 - new value |
| MOVD old+16(FP), R2 // arg 3 - old value |
| MOVD $69, R8 // sys_setitimer |
| INVOKE_SYSCALL |
| RET |
| |
| // func walltime1() (sec int64, nsec int32) |
| TEXT runtime·walltime1(SB), NOSPLIT, $32 |
| MOVW CLOCK_REALTIME, R0 // arg 1 - clock_id |
| MOVD $8(RSP), R1 // arg 2 - tp |
| MOVD $87, R8 // sys_clock_gettime |
| INVOKE_SYSCALL |
| |
| MOVD 8(RSP), R0 // sec |
| MOVD 16(RSP), R1 // nsec |
| MOVD R0, sec+0(FP) |
| MOVW R1, nsec+8(FP) |
| |
| RET |
| |
| // int64 nanotime1(void) so really |
| // void nanotime1(int64 *nsec) |
| TEXT runtime·nanotime1(SB),NOSPLIT,$32 |
| MOVW CLOCK_MONOTONIC, R0 // arg 1 - clock_id |
| MOVD $8(RSP), R1 // arg 2 - tp |
| MOVD $87, R8 // sys_clock_gettime |
| INVOKE_SYSCALL |
| |
| MOVW 8(RSP), R3 // sec |
| MOVW 16(RSP), R5 // nsec |
| |
| MOVD $1000000000, R4 |
| MUL R4, R3 |
| ADD R5, R3 |
| MOVD R3, ret+0(FP) |
| RET |
| |
| TEXT runtime·sigaction(SB),NOSPLIT,$0 |
| MOVW sig+0(FP), R0 // arg 1 - signum |
| MOVD new+8(FP), R1 // arg 2 - new sigaction |
| MOVD old+16(FP), R2 // arg 3 - old sigaction |
| MOVD $46, R8 // sys_sigaction |
| INVOKE_SYSCALL |
| BCC 3(PC) |
| MOVD $3, R0 // crash on syscall failure |
| MOVD R0, (R0) |
| RET |
| |
| TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$0 |
| MOVW how+0(FP), R0 // arg 1 - mode |
| MOVW new+4(FP), R1 // arg 2 - new |
| MOVD $48, R8 // sys_sigprocmask |
| INVOKE_SYSCALL |
| BCC 3(PC) |
| MOVD $3, R8 // crash on syscall failure |
| MOVD R8, (R8) |
| MOVW R0, ret+8(FP) |
| RET |
| |
| TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 |
| MOVW sig+8(FP), R0 |
| MOVD info+16(FP), R1 |
| MOVD ctx+24(FP), R2 |
| MOVD fn+0(FP), R11 |
| BL (R11) // Alignment for ELF ABI? |
| RET |
| |
| TEXT runtime·sigtramp(SB),NOSPLIT,$192 |
| // Save callee-save registers in the case of signal forwarding. |
| // Please refer to https://golang.org/issue/31827 . |
| MOVD R19, 8*4(RSP) |
| MOVD R20, 8*5(RSP) |
| MOVD R21, 8*6(RSP) |
| MOVD R22, 8*7(RSP) |
| MOVD R23, 8*8(RSP) |
| MOVD R24, 8*9(RSP) |
| MOVD R25, 8*10(RSP) |
| MOVD R26, 8*11(RSP) |
| MOVD R27, 8*12(RSP) |
| MOVD g, 8*13(RSP) |
| MOVD R29, 8*14(RSP) |
| FMOVD F8, 8*15(RSP) |
| FMOVD F9, 8*16(RSP) |
| FMOVD F10, 8*17(RSP) |
| FMOVD F11, 8*18(RSP) |
| FMOVD F12, 8*19(RSP) |
| FMOVD F13, 8*20(RSP) |
| FMOVD F14, 8*21(RSP) |
| FMOVD F15, 8*22(RSP) |
| |
| // If called from an external code context, g will not be set. |
| // Save R0, since runtime·load_g will clobber it. |
| MOVW R0, 8(RSP) // signum |
| MOVB runtime·iscgo(SB), R0 |
| CMP $0, R0 |
| BEQ 2(PC) |
| BL runtime·load_g(SB) |
| |
| MOVD R1, 16(RSP) |
| MOVD R2, 24(RSP) |
| BL runtime·sigtrampgo(SB) |
| |
| // Restore callee-save registers. |
| MOVD 8*4(RSP), R19 |
| MOVD 8*5(RSP), R20 |
| MOVD 8*6(RSP), R21 |
| MOVD 8*7(RSP), R22 |
| MOVD 8*8(RSP), R23 |
| MOVD 8*9(RSP), R24 |
| MOVD 8*10(RSP), R25 |
| MOVD 8*11(RSP), R26 |
| MOVD 8*12(RSP), R27 |
| MOVD 8*13(RSP), g |
| MOVD 8*14(RSP), R29 |
| FMOVD 8*15(RSP), F8 |
| FMOVD 8*16(RSP), F9 |
| FMOVD 8*17(RSP), F10 |
| FMOVD 8*18(RSP), F11 |
| FMOVD 8*19(RSP), F12 |
| FMOVD 8*20(RSP), F13 |
| FMOVD 8*21(RSP), F14 |
| FMOVD 8*22(RSP), F15 |
| |
| RET |
| |
| // int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void)); |
| TEXT runtime·tfork(SB),NOSPLIT,$0 |
| |
| // Copy mp, gp and fn off parent stack for use by child. |
| MOVD mm+16(FP), R4 |
| MOVD gg+24(FP), R5 |
| MOVD fn+32(FP), R6 |
| |
| MOVD param+0(FP), R0 // arg 1 - param |
| MOVD psize+8(FP), R1 // arg 2 - psize |
| MOVD $8, R8 // sys___tfork |
| INVOKE_SYSCALL |
| |
| // Return if syscall failed. |
| BCC 4(PC) |
| NEG R0, R0 |
| MOVW R0, ret+40(FP) |
| RET |
| |
| // In parent, return. |
| CMP $0, R0 |
| BEQ 3(PC) |
| MOVW R0, ret+40(FP) |
| RET |
| |
| // Initialise m, g. |
| MOVD R5, g |
| MOVD R4, g_m(g) |
| |
| // Call fn. |
| BL (R6) |
| |
| // fn should never return. |
| MOVD $2, R8 // crash if reached |
| MOVD R8, (R8) |
| RET |
| |
| TEXT runtime·sigaltstack(SB),NOSPLIT,$0 |
| MOVD new+0(FP), R0 // arg 1 - new sigaltstack |
| MOVD old+8(FP), R1 // arg 2 - old sigaltstack |
| MOVD $288, R8 // sys_sigaltstack |
| INVOKE_SYSCALL |
| BCC 3(PC) |
| MOVD $0, R8 // crash on syscall failure |
| MOVD R8, (R8) |
| RET |
| |
| TEXT runtime·osyield(SB),NOSPLIT,$0 |
| MOVD $298, R8 // sys_sched_yield |
| INVOKE_SYSCALL |
| RET |
| |
| TEXT runtime·thrsleep(SB),NOSPLIT,$0 |
| MOVD ident+0(FP), R0 // arg 1 - ident |
| MOVW clock_id+8(FP), R1 // arg 2 - clock_id |
| MOVD tsp+16(FP), R2 // arg 3 - tsp |
| MOVD lock+24(FP), R3 // arg 4 - lock |
| MOVD abort+32(FP), R4 // arg 5 - abort |
| MOVD $94, R8 // sys___thrsleep |
| INVOKE_SYSCALL |
| MOVW R0, ret+40(FP) |
| RET |
| |
| TEXT runtime·thrwakeup(SB),NOSPLIT,$0 |
| MOVD ident+0(FP), R0 // arg 1 - ident |
| MOVW n+8(FP), R1 // arg 2 - n |
| MOVD $301, R8 // sys___thrwakeup |
| INVOKE_SYSCALL |
| MOVW R0, ret+16(FP) |
| RET |
| |
| TEXT runtime·sysctl(SB),NOSPLIT,$0 |
| MOVD mib+0(FP), R0 // arg 1 - mib |
| MOVW miblen+8(FP), R1 // arg 2 - miblen |
| MOVD out+16(FP), R2 // arg 3 - out |
| MOVD size+24(FP), R3 // arg 4 - size |
| MOVD dst+32(FP), R4 // arg 5 - dest |
| MOVD ndst+40(FP), R5 // arg 6 - newlen |
| MOVD $202, R8 // sys___sysctl |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| NEG R0, R0 |
| MOVW R0, ret+48(FP) |
| RET |
| |
| // int32 runtime·kqueue(void); |
| TEXT runtime·kqueue(SB),NOSPLIT,$0 |
| MOVD $269, R8 // sys_kqueue |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| NEG R0, R0 |
| MOVW R0, ret+0(FP) |
| RET |
| |
| // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); |
| TEXT runtime·kevent(SB),NOSPLIT,$0 |
| MOVW kq+0(FP), R0 // arg 1 - kq |
| MOVD ch+8(FP), R1 // arg 2 - changelist |
| MOVW nch+16(FP), R2 // arg 3 - nchanges |
| MOVD ev+24(FP), R3 // arg 4 - eventlist |
| MOVW nev+32(FP), R4 // arg 5 - nevents |
| MOVD ts+40(FP), R5 // arg 6 - timeout |
| MOVD $72, R8 // sys_kevent |
| INVOKE_SYSCALL |
| BCC 2(PC) |
| NEG R0, R0 |
| MOVW R0, ret+48(FP) |
| RET |
| |
| // func closeonexec(fd int32) |
| TEXT runtime·closeonexec(SB),NOSPLIT,$0 |
| MOVW fd+0(FP), R0 // arg 1 - fd |
| MOVD $2, R1 // arg 2 - cmd (F_SETFD) |
| MOVD $1, R2 // arg 3 - arg (FD_CLOEXEC) |
| MOVD $92, R8 // sys_fcntl |
| INVOKE_SYSCALL |
| RET |
| |
| // func runtime·setNonblock(int32 fd) |
| TEXT runtime·setNonblock(SB),NOSPLIT|NOFRAME,$0-4 |
| MOVW fd+0(FP), R0 // arg 1 - fd |
| MOVD $3, R1 // arg 2 - cmd (F_GETFL) |
| MOVD $0, R2 // arg 3 |
| MOVD $92, R8 // sys_fcntl |
| INVOKE_SYSCALL |
| MOVD $4, R2 // O_NONBLOCK |
| ORR R0, R2 // arg 3 - flags |
| MOVW fd+0(FP), R0 // arg 1 - fd |
| MOVD $4, R1 // arg 2 - cmd (F_SETFL) |
| MOVD $92, R8 // sys_fcntl |
| INVOKE_SYSCALL |
| RET |
