github.com/lzhfromustc/gofuzz@v0.0.0-20211116160056-151b3108bbd1/runtime/sys_openbsd_arm.s (about) 1 // Copyright 2009 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 // System calls and other sys.stuff for ARM, OpenBSD 6 // /usr/src/sys/kern/syscalls.master for syscall numbers. 7 // 8 9 #include "go_asm.h" 10 #include "go_tls.h" 11 #include "textflag.h" 12 13 #define CLOCK_REALTIME $0 14 #define CLOCK_MONOTONIC $3 15 16 // With OpenBSD 6.7 onwards, an armv7 syscall returns two instructions 17 // after the SWI instruction, to allow for a speculative execution 18 // barrier to be placed after the SWI without impacting performance. 19 // For now use hardware no-ops as this works with both older and newer 20 // kernels. After OpenBSD 6.8 is released this should be changed to 21 // speculation barriers. 22 #define NOOP MOVW R0, R0 23 #define INVOKE_SYSCALL \ 24 SWI $0; \ 25 NOOP; \ 26 NOOP 27 28 // Exit the entire program (like C exit) 29 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0 30 MOVW code+0(FP), R0 // arg 1 - status 31 MOVW $1, R12 // sys_exit 32 INVOKE_SYSCALL 33 MOVW.CS $0, R8 // crash on syscall failure 34 MOVW.CS R8, (R8) 35 RET 36 37 // func exitThread(wait *uint32) 38 TEXT runtime·exitThread(SB),NOSPLIT,$0-4 39 MOVW wait+0(FP), R0 // arg 1 - notdead 40 MOVW $302, R12 // sys___threxit 41 INVOKE_SYSCALL 42 MOVW.CS $1, R8 // crash on syscall failure 43 MOVW.CS R8, (R8) 44 JMP 0(PC) 45 46 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0 47 MOVW name+0(FP), R0 // arg 1 - path 48 MOVW mode+4(FP), R1 // arg 2 - mode 49 MOVW perm+8(FP), R2 // arg 3 - perm 50 MOVW $5, R12 // sys_open 51 INVOKE_SYSCALL 52 MOVW.CS $-1, R0 53 MOVW R0, ret+12(FP) 54 RET 55 56 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0 57 MOVW fd+0(FP), R0 // arg 1 - fd 58 MOVW $6, R12 // sys_close 59 INVOKE_SYSCALL 60 MOVW.CS $-1, R0 61 MOVW R0, ret+4(FP) 62 RET 63 64 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0 65 MOVW fd+0(FP), R0 // arg 1 - fd 66 MOVW p+4(FP), R1 // arg 2 - buf 67 MOVW n+8(FP), R2 // arg 3 - nbyte 68 MOVW $3, R12 // sys_read 69 INVOKE_SYSCALL 70 RSB.CS $0, R0 // caller expects negative errno 71 MOVW R0, ret+12(FP) 72 RET 73 74 // func pipe() (r, w int32, errno int32) 75 TEXT runtime·pipe(SB),NOSPLIT,$0-12 76 MOVW $r+0(FP), R0 77 MOVW $263, R12 78 INVOKE_SYSCALL 79 MOVW R0, errno+8(FP) 80 RET 81 82 // func pipe2(flags int32) (r, w int32, errno int32) 83 TEXT runtime·pipe2(SB),NOSPLIT,$0-16 84 MOVW $r+4(FP), R0 85 MOVW flags+0(FP), R1 86 MOVW $101, R12 87 INVOKE_SYSCALL 88 MOVW R0, errno+12(FP) 89 RET 90 91 TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0 92 MOVW fd+0(FP), R0 // arg 1 - fd 93 MOVW p+4(FP), R1 // arg 2 - buf 94 MOVW n+8(FP), R2 // arg 3 - nbyte 95 MOVW $4, R12 // sys_write 96 INVOKE_SYSCALL 97 RSB.CS $0, R0 // caller expects negative errno 98 MOVW R0, ret+12(FP) 99 RET 100 101 TEXT runtime·usleep(SB),NOSPLIT,$16 102 MOVW usec+0(FP), R0 103 CALL runtime·usplitR0(SB) 104 MOVW R0, 4(R13) // tv_sec - l32 105 MOVW $0, R0 106 MOVW R0, 8(R13) // tv_sec - h32 107 MOVW $1000, R2 108 MUL R1, R2 109 MOVW R2, 12(R13) // tv_nsec 110 111 MOVW $4(R13), R0 // arg 1 - rqtp 112 MOVW $0, R1 // arg 2 - rmtp 113 MOVW $91, R12 // sys_nanosleep 114 INVOKE_SYSCALL 115 RET 116 117 TEXT runtime·getthrid(SB),NOSPLIT,$0-4 118 MOVW $299, R12 // sys_getthrid 119 INVOKE_SYSCALL 120 MOVW R0, ret+0(FP) 121 RET 122 123 TEXT runtime·thrkill(SB),NOSPLIT,$0-8 124 MOVW tid+0(FP), R0 // arg 1 - tid 125 MOVW sig+4(FP), R1 // arg 2 - signum 126 MOVW $0, R2 // arg 3 - tcb 127 MOVW $119, R12 // sys_thrkill 128 INVOKE_SYSCALL 129 RET 130 131 TEXT runtime·raiseproc(SB),NOSPLIT,$12 132 MOVW $20, R12 // sys_getpid 133 INVOKE_SYSCALL 134 // arg 1 - pid, already in R0 135 MOVW sig+0(FP), R1 // arg 2 - signum 136 MOVW $122, R12 // sys_kill 137 INVOKE_SYSCALL 138 RET 139 140 TEXT runtime·mmap(SB),NOSPLIT,$16 141 MOVW addr+0(FP), R0 // arg 1 - addr 142 MOVW n+4(FP), R1 // arg 2 - len 143 MOVW prot+8(FP), R2 // arg 3 - prot 144 MOVW flags+12(FP), R3 // arg 4 - flags 145 MOVW fd+16(FP), R4 // arg 5 - fd (on stack) 146 MOVW R4, 4(R13) 147 MOVW $0, R5 // arg 6 - pad (on stack) 148 MOVW R5, 8(R13) 149 MOVW off+20(FP), R6 // arg 7 - offset (on stack) 150 MOVW R6, 12(R13) // lower 32 bits (from Go runtime) 151 MOVW $0, R7 152 MOVW R7, 16(R13) // high 32 bits 153 ADD $4, R13 154 MOVW $197, R12 // sys_mmap 155 INVOKE_SYSCALL 156 SUB $4, R13 157 MOVW $0, R1 158 MOVW.CS R0, R1 // if error, move to R1 159 MOVW.CS $0, R0 160 MOVW R0, p+24(FP) 161 MOVW R1, err+28(FP) 162 RET 163 164 TEXT runtime·munmap(SB),NOSPLIT,$0 165 MOVW addr+0(FP), R0 // arg 1 - addr 166 MOVW n+4(FP), R1 // arg 2 - len 167 MOVW $73, R12 // sys_munmap 168 INVOKE_SYSCALL 169 MOVW.CS $0, R8 // crash on syscall failure 170 MOVW.CS R8, (R8) 171 RET 172 173 TEXT runtime·madvise(SB),NOSPLIT,$0 174 MOVW addr+0(FP), R0 // arg 1 - addr 175 MOVW n+4(FP), R1 // arg 2 - len 176 MOVW flags+8(FP), R2 // arg 2 - flags 177 MOVW $75, R12 // sys_madvise 178 INVOKE_SYSCALL 179 MOVW.CS $-1, R0 180 MOVW R0, ret+12(FP) 181 RET 182 183 TEXT runtime·setitimer(SB),NOSPLIT,$0 184 MOVW mode+0(FP), R0 // arg 1 - mode 185 MOVW new+4(FP), R1 // arg 2 - new value 186 MOVW old+8(FP), R2 // arg 3 - old value 187 MOVW $69, R12 // sys_setitimer 188 INVOKE_SYSCALL 189 RET 190 191 // func walltime1() (sec int64, nsec int32) 192 TEXT runtime·walltime1(SB), NOSPLIT, $32 193 MOVW CLOCK_REALTIME, R0 // arg 1 - clock_id 194 MOVW $8(R13), R1 // arg 2 - tp 195 MOVW $87, R12 // sys_clock_gettime 196 INVOKE_SYSCALL 197 198 MOVW 8(R13), R0 // sec - l32 199 MOVW 12(R13), R1 // sec - h32 200 MOVW 16(R13), R2 // nsec 201 202 MOVW R0, sec_lo+0(FP) 203 MOVW R1, sec_hi+4(FP) 204 MOVW R2, nsec+8(FP) 205 206 RET 207 208 // int64 nanotime1(void) so really 209 // void nanotime1(int64 *nsec) 210 TEXT runtime·nanotime1(SB),NOSPLIT,$32 211 MOVW CLOCK_MONOTONIC, R0 // arg 1 - clock_id 212 MOVW $8(R13), R1 // arg 2 - tp 213 MOVW $87, R12 // sys_clock_gettime 214 INVOKE_SYSCALL 215 216 MOVW 8(R13), R0 // sec - l32 217 MOVW 12(R13), R4 // sec - h32 218 MOVW 16(R13), R2 // nsec 219 220 MOVW $1000000000, R3 221 MULLU R0, R3, (R1, R0) 222 MUL R3, R4 223 ADD.S R2, R0 224 ADC R4, R1 225 226 MOVW R0, ret_lo+0(FP) 227 MOVW R1, ret_hi+4(FP) 228 RET 229 230 TEXT runtime·sigaction(SB),NOSPLIT,$0 231 MOVW sig+0(FP), R0 // arg 1 - signum 232 MOVW new+4(FP), R1 // arg 2 - new sigaction 233 MOVW old+8(FP), R2 // arg 3 - old sigaction 234 MOVW $46, R12 // sys_sigaction 235 INVOKE_SYSCALL 236 MOVW.CS $3, R8 // crash on syscall failure 237 MOVW.CS R8, (R8) 238 RET 239 240 TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$0 241 MOVW how+0(FP), R0 // arg 1 - mode 242 MOVW new+4(FP), R1 // arg 2 - new 243 MOVW $48, R12 // sys_sigprocmask 244 INVOKE_SYSCALL 245 MOVW.CS $3, R8 // crash on syscall failure 246 MOVW.CS R8, (R8) 247 MOVW R0, ret+8(FP) 248 RET 249 250 TEXT runtime·sigfwd(SB),NOSPLIT,$0-16 251 MOVW sig+4(FP), R0 252 MOVW info+8(FP), R1 253 MOVW ctx+12(FP), R2 254 MOVW fn+0(FP), R11 255 MOVW R13, R4 256 SUB $24, R13 257 BIC $0x7, R13 // alignment for ELF ABI 258 BL (R11) 259 MOVW R4, R13 260 RET 261 262 TEXT runtime·sigtramp(SB),NOSPLIT,$0 263 // Reserve space for callee-save registers and arguments. 264 MOVM.DB.W [R4-R11], (R13) 265 SUB $16, R13 266 267 // If called from an external code context, g will not be set. 268 // Save R0, since runtime·load_g will clobber it. 269 MOVW R0, 4(R13) // signum 270 MOVB runtime·iscgo(SB), R0 271 CMP $0, R0 272 BL.NE runtime·load_g(SB) 273 274 MOVW R1, 8(R13) 275 MOVW R2, 12(R13) 276 BL runtime·sigtrampgo(SB) 277 278 // Restore callee-save registers. 279 ADD $16, R13 280 MOVM.IA.W (R13), [R4-R11] 281 282 RET 283 284 // int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void)); 285 TEXT runtime·tfork(SB),NOSPLIT,$0 286 287 // Copy mp, gp and fn off parent stack for use by child. 288 MOVW mm+8(FP), R4 289 MOVW gg+12(FP), R5 290 MOVW fn+16(FP), R6 291 292 MOVW param+0(FP), R0 // arg 1 - param 293 MOVW psize+4(FP), R1 // arg 2 - psize 294 MOVW $8, R12 // sys___tfork 295 INVOKE_SYSCALL 296 297 // Return if syscall failed. 298 B.CC 4(PC) 299 RSB $0, R0 300 MOVW R0, ret+20(FP) 301 RET 302 303 // In parent, return. 304 CMP $0, R0 305 BEQ 3(PC) 306 MOVW R0, ret+20(FP) 307 RET 308 309 // Initialise m, g. 310 MOVW R5, g 311 MOVW R4, g_m(g) 312 313 // Paranoia; check that stack splitting code works. 314 BL runtime·emptyfunc(SB) 315 316 // Call fn. 317 BL (R6) 318 319 // fn should never return. 320 MOVW $2, R8 // crash if reached 321 MOVW R8, (R8) 322 RET 323 324 TEXT runtime·sigaltstack(SB),NOSPLIT,$0 325 MOVW new+0(FP), R0 // arg 1 - new sigaltstack 326 MOVW old+4(FP), R1 // arg 2 - old sigaltstack 327 MOVW $288, R12 // sys_sigaltstack 328 INVOKE_SYSCALL 329 MOVW.CS $0, R8 // crash on syscall failure 330 MOVW.CS R8, (R8) 331 RET 332 333 TEXT runtime·osyield(SB),NOSPLIT,$0 334 MOVW $298, R12 // sys_sched_yield 335 INVOKE_SYSCALL 336 RET 337 338 TEXT runtime·thrsleep(SB),NOSPLIT,$4 339 MOVW ident+0(FP), R0 // arg 1 - ident 340 MOVW clock_id+4(FP), R1 // arg 2 - clock_id 341 MOVW tsp+8(FP), R2 // arg 3 - tsp 342 MOVW lock+12(FP), R3 // arg 4 - lock 343 MOVW abort+16(FP), R4 // arg 5 - abort (on stack) 344 MOVW R4, 4(R13) 345 ADD $4, R13 346 MOVW $94, R12 // sys___thrsleep 347 INVOKE_SYSCALL 348 SUB $4, R13 349 MOVW R0, ret+20(FP) 350 RET 351 352 TEXT runtime·thrwakeup(SB),NOSPLIT,$0 353 MOVW ident+0(FP), R0 // arg 1 - ident 354 MOVW n+4(FP), R1 // arg 2 - n 355 MOVW $301, R12 // sys___thrwakeup 356 INVOKE_SYSCALL 357 MOVW R0, ret+8(FP) 358 RET 359 360 TEXT runtime·sysctl(SB),NOSPLIT,$8 361 MOVW mib+0(FP), R0 // arg 1 - mib 362 MOVW miblen+4(FP), R1 // arg 2 - miblen 363 MOVW out+8(FP), R2 // arg 3 - out 364 MOVW size+12(FP), R3 // arg 4 - size 365 MOVW dst+16(FP), R4 // arg 5 - dest (on stack) 366 MOVW R4, 4(R13) 367 MOVW ndst+20(FP), R5 // arg 6 - newlen (on stack) 368 MOVW R5, 8(R13) 369 ADD $4, R13 370 MOVW $202, R12 // sys___sysctl 371 INVOKE_SYSCALL 372 SUB $4, R13 373 MOVW.CC $0, R0 374 RSB.CS $0, R0 375 MOVW R0, ret+24(FP) 376 RET 377 378 // int32 runtime·kqueue(void); 379 TEXT runtime·kqueue(SB),NOSPLIT,$0 380 MOVW $269, R12 // sys_kqueue 381 INVOKE_SYSCALL 382 RSB.CS $0, R0 383 MOVW R0, ret+0(FP) 384 RET 385 386 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); 387 TEXT runtime·kevent(SB),NOSPLIT,$8 388 MOVW kq+0(FP), R0 // arg 1 - kq 389 MOVW ch+4(FP), R1 // arg 2 - changelist 390 MOVW nch+8(FP), R2 // arg 3 - nchanges 391 MOVW ev+12(FP), R3 // arg 4 - eventlist 392 MOVW nev+16(FP), R4 // arg 5 - nevents (on stack) 393 MOVW R4, 4(R13) 394 MOVW ts+20(FP), R5 // arg 6 - timeout (on stack) 395 MOVW R5, 8(R13) 396 ADD $4, R13 397 MOVW $72, R12 // sys_kevent 398 INVOKE_SYSCALL 399 RSB.CS $0, R0 400 SUB $4, R13 401 MOVW R0, ret+24(FP) 402 RET 403 404 // func closeonexec(fd int32) 405 TEXT runtime·closeonexec(SB),NOSPLIT,$0 406 MOVW fd+0(FP), R0 // arg 1 - fd 407 MOVW $2, R1 // arg 2 - cmd (F_SETFD) 408 MOVW $1, R2 // arg 3 - arg (FD_CLOEXEC) 409 MOVW $92, R12 // sys_fcntl 410 INVOKE_SYSCALL 411 RET 412 413 // func runtime·setNonblock(fd int32) 414 TEXT runtime·setNonblock(SB),NOSPLIT,$0-4 415 MOVW fd+0(FP), R0 // fd 416 MOVW $3, R1 // F_GETFL 417 MOVW $0, R2 418 MOVW $92, R12 419 INVOKE_SYSCALL 420 ORR $0x4, R0, R2 // O_NONBLOCK 421 MOVW fd+0(FP), R0 // fd 422 MOVW $4, R1 // F_SETFL 423 MOVW $92, R12 424 INVOKE_SYSCALL 425 RET 426 427 TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0 428 B runtime·armPublicationBarrier(SB) 429 430 TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0 431 MOVM.WP [R1, R2, R3, R12], (R13) 432 MOVW $330, R12 // sys___get_tcb 433 INVOKE_SYSCALL 434 MOVM.IAW (R13), [R1, R2, R3, R12] 435 RET