rsc.io/go@v0.0.0-20150416155037-e040fd465409/src/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 // Exit the entire program (like C exit) 17 TEXT runtime·exit(SB),NOSPLIT,$-4 18 MOVW status+0(FP), R0 // arg 1 - status 19 MOVW $1, R12 // sys_exit 20 SWI $0 21 MOVW.CS $0, R8 // crash on syscall failure 22 MOVW.CS R8, (R8) 23 RET 24 25 TEXT runtime·exit1(SB),NOSPLIT,$-4 26 MOVW $0, R0 // arg 1 - notdead 27 MOVW $302, R12 // sys___threxit 28 SWI $0 29 MOVW.CS $1, R8 // crash on syscall failure 30 MOVW.CS R8, (R8) 31 RET 32 33 TEXT runtime·open(SB),NOSPLIT,$-4 34 MOVW path+0(FP), R0 // arg 1 - path 35 MOVW flags+4(FP), R1 // arg 2 - flags 36 MOVW mode+8(FP), R2 // arg 3 - mode 37 MOVW $5, R12 // sys_open 38 SWI $0 39 MOVW.CS $-1, R0 40 MOVW R0, ret+12(FP) 41 RET 42 43 TEXT runtime·closefd(SB),NOSPLIT,$-4 44 MOVW path+0(FP), R0 // arg 1 - path 45 MOVW $6, R12 // sys_close 46 SWI $0 47 MOVW.CS $-1, R0 48 MOVW R0, ret+4(FP) 49 RET 50 51 TEXT runtime·read(SB),NOSPLIT,$-4 52 MOVW fd+0(FP), R0 // arg 1 - fd 53 MOVW buf+4(FP), R1 // arg 2 - buf 54 MOVW nbyte+8(FP), R2 // arg 3 - nbyte 55 MOVW $3, R12 // sys_read 56 SWI $0 57 MOVW.CS $-1, R0 58 MOVW R0, ret+12(FP) 59 RET 60 61 TEXT runtime·write(SB),NOSPLIT,$-4 62 MOVW fd+0(FP), R0 // arg 1 - fd 63 MOVW buf+4(FP), R1 // arg 2 - buf 64 MOVW nbyte+8(FP), R2 // arg 3 - nbyte 65 MOVW $4, R12 // sys_write 66 SWI $0 67 MOVW.CS $-1, R0 68 MOVW R0, ret+12(FP) 69 RET 70 71 TEXT runtime·usleep(SB),NOSPLIT,$16 72 MOVW usec+0(FP), R0 73 MOVW R0, R2 74 MOVW $1000000, R1 75 DIV R1, R0 76 MOVW R0, 4(R13) // tv_sec - l32 77 MOVW $0, R0 78 MOVW R0, 8(R13) // tv_sec - h32 79 MOD R1, R2 80 MOVW $1000, R1 81 MUL R1, R2 82 MOVW R2, 12(R13) // tv_nsec 83 84 MOVW $4(R13), R0 // arg 1 - rqtp 85 MOVW $0, R1 // arg 2 - rmtp 86 MOVW $91, R12 // sys_nanosleep 87 SWI $0 88 RET 89 90 TEXT runtime·raise(SB),NOSPLIT,$12 91 MOVW $0x12B, R12 92 SWI $0 // sys_getthrid 93 // arg 1 - pid, already in R0 94 MOVW sig+0(FP), R1 // arg 2 - signum 95 MOVW $37, R12 // sys_kill 96 SWI $0 97 RET 98 99 TEXT runtime·mmap(SB),NOSPLIT,$16 100 MOVW addr+0(FP), R0 // arg 1 - addr 101 MOVW len+4(FP), R1 // arg 2 - len 102 MOVW prot+8(FP), R2 // arg 3 - prot 103 MOVW flags+12(FP), R3 // arg 4 - flags 104 MOVW fd+16(FP), R4 // arg 5 - fd (on stack) 105 MOVW R4, 4(R13) 106 MOVW $0, R5 // arg 6 - pad (on stack) 107 MOVW R5, 8(R13) 108 MOVW offset+20(FP), R6 // arg 7 - offset (on stack) 109 MOVW R6, 12(R13) // lower 32 bits (from Go runtime) 110 MOVW $0, R7 111 MOVW R7, 16(R13) // high 32 bits 112 ADD $4, R13 113 MOVW $197, R12 // sys_mmap 114 SWI $0 115 SUB $4, R13 116 MOVW R0, ret+24(FP) 117 RET 118 119 TEXT runtime·munmap(SB),NOSPLIT,$0 120 MOVW addr+0(FP), R0 // arg 1 - addr 121 MOVW len+4(FP), R1 // arg 2 - len 122 MOVW $73, R12 // sys_munmap 123 SWI $0 124 MOVW.CS $0, R8 // crash on syscall failure 125 MOVW.CS R8, (R8) 126 RET 127 128 TEXT runtime·madvise(SB),NOSPLIT,$0 129 MOVW addr+0(FP), R0 // arg 1 - addr 130 MOVW len+4(FP), R1 // arg 2 - len 131 MOVW behav+8(FP), R2 // arg 2 - behav 132 MOVW $75, R12 // sys_madvise 133 SWI $0 134 MOVW.CS $0, R8 // crash on syscall failure 135 MOVW.CS R8, (R8) 136 RET 137 138 TEXT runtime·setitimer(SB),NOSPLIT,$0 139 MOVW which+0(FP), R0 // arg 1 - which 140 MOVW value+4(FP), R1 // arg 2 - value 141 MOVW ovalue+8(FP), R2 // arg 3 - ovalue 142 MOVW $69, R12 // sys_setitimer 143 SWI $0 144 RET 145 146 // func now() (sec int64, nsec int32) 147 TEXT time·now(SB), NOSPLIT, $32 148 MOVW CLOCK_REALTIME, R0 // arg 1 - clock_id 149 MOVW $8(R13), R1 // arg 2 - tp 150 MOVW $87, R12 // sys_clock_gettime 151 SWI $0 152 153 MOVW 8(R13), R0 // sec - l32 154 MOVW 12(R13), R1 // sec - h32 155 MOVW 16(R13), R2 // nsec 156 157 MOVW R0, sec_lo+0(FP) 158 MOVW R1, sec_hi+4(FP) 159 MOVW R2, nsec+8(FP) 160 161 RET 162 163 // int64 nanotime(void) so really 164 // void nanotime(int64 *nsec) 165 TEXT runtime·nanotime(SB),NOSPLIT,$32 166 MOVW CLOCK_MONOTONIC, R0 // arg 1 - clock_id 167 MOVW $8(R13), R1 // arg 2 - tp 168 MOVW $87, R12 // sys_clock_gettime 169 SWI $0 170 171 MOVW 8(R13), R0 // sec - l32 172 MOVW 12(R13), R4 // sec - h32 173 MOVW 16(R13), R2 // nsec 174 175 MOVW $1000000000, R3 176 MULLU R0, R3, (R1, R0) 177 MUL R3, R4 178 ADD.S R2, R0 179 ADC R4, R1 180 181 MOVW R0, ret_lo+0(FP) 182 MOVW R1, ret_hi+4(FP) 183 RET 184 185 TEXT runtime·sigaction(SB),NOSPLIT,$0 186 MOVW signum+0(FP), R0 // arg 1 - signum 187 MOVW nsa+4(FP), R1 // arg 2 - nsa 188 MOVW osa+8(FP), R2 // arg 3 - osa 189 MOVW $46, R12 // sys_sigaction 190 SWI $0 191 MOVW.CS $3, R8 // crash on syscall failure 192 MOVW.CS R8, (R8) 193 RET 194 195 TEXT runtime·sigprocmask(SB),NOSPLIT,$0 196 MOVW how+0(FP), R0 // arg 1 - how 197 MOVW mask+4(FP), R1 // arg 2 - mask 198 MOVW $48, R12 // sys_sigprocmask 199 SWI $0 200 MOVW.CS $3, R8 // crash on syscall failure 201 MOVW.CS R8, (R8) 202 MOVW R0, ret+8(FP) 203 RET 204 205 TEXT runtime·sigtramp(SB),NOSPLIT,$24 206 // If called from an external code context, g will not be set. 207 // Save R0, since runtime·load_g will clobber it. 208 MOVW R0, 4(R13) // signum 209 MOVB runtime·iscgo(SB), R0 210 CMP $0, R0 211 BL.NE runtime·load_g(SB) 212 213 CMP $0, g 214 BNE 4(PC) 215 // Signal number saved in 4(R13). 216 MOVW runtime·badsignal(SB), R11 217 BL (R11) 218 RET 219 220 // Save g. 221 MOVW g, R3 222 MOVW g, 20(R13) 223 224 // g = m->signal 225 MOVW g_m(g), R8 226 MOVW m_gsignal(R8), g 227 228 // R0 already saved. 229 MOVW R1, 8(R13) // info 230 MOVW R2, 12(R13) // context 231 MOVW R3, 16(R13) // gp (original g) 232 233 BL runtime·sighandler(SB) 234 235 // Restore g. 236 MOVW 20(R13), g 237 RET 238 239 // int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void)); 240 TEXT runtime·tfork(SB),NOSPLIT,$0 241 242 // Copy mp, gp and fn off parent stack for use by child. 243 MOVW mm+8(FP), R4 244 MOVW gg+12(FP), R5 245 MOVW fn+16(FP), R6 246 247 MOVW param+0(FP), R0 // arg 1 - param 248 MOVW psize+4(FP), R1 // arg 2 - psize 249 MOVW $8, R12 // sys___tfork 250 SWI $0 251 252 // Return if syscall failed. 253 B.CC 4(PC) 254 RSB $0, R0 255 MOVW R0, ret+20(FP) 256 RET 257 258 // In parent, return. 259 CMP $0, R0 260 BEQ 3(PC) 261 MOVW R0, ret+20(FP) 262 RET 263 264 // Initialise m, g. 265 MOVW R5, g 266 MOVW R4, g_m(g) 267 268 // Paranoia; check that stack splitting code works. 269 BL runtime·emptyfunc(SB) 270 271 // Call fn. 272 BL (R6) 273 274 BL runtime·exit1(SB) 275 MOVW $2, R8 // crash if reached 276 MOVW R8, (R8) 277 RET 278 279 TEXT runtime·sigaltstack(SB),NOSPLIT,$0 280 MOVW nss+0(FP), R0 // arg 1 - nss 281 MOVW oss+4(FP), R1 // arg 2 - oss 282 MOVW $288, R12 // sys_sigaltstack 283 SWI $0 284 MOVW.CS $0, R8 // crash on syscall failure 285 MOVW.CS R8, (R8) 286 RET 287 288 TEXT runtime·osyield(SB),NOSPLIT,$0 289 MOVW $298, R12 // sys_sched_yield 290 SWI $0 291 RET 292 293 TEXT runtime·thrsleep(SB),NOSPLIT,$4 294 MOVW ident+0(FP), R0 // arg 1 - ident 295 MOVW clock_id+4(FP), R1 // arg 2 - clock_id 296 MOVW tp+8(FP), R2 // arg 3 - tp 297 MOVW lock+12(FP), R3 // arg 4 - lock 298 MOVW abort+16(FP), R4 // arg 5 - abort (on stack) 299 MOVW R4, 4(R13) 300 ADD $4, R13 301 MOVW $94, R12 // sys___thrsleep 302 SWI $0 303 SUB $4, R13 304 MOVW R0, ret+20(FP) 305 RET 306 307 TEXT runtime·thrwakeup(SB),NOSPLIT,$0 308 MOVW ident+0(FP), R0 // arg 1 - ident 309 MOVW n+4(FP), R1 // arg 2 - n 310 MOVW $301, R12 // sys___thrwakeup 311 SWI $0 312 MOVW R0, ret+8(FP) 313 RET 314 315 TEXT runtime·sysctl(SB),NOSPLIT,$8 316 MOVW name+0(FP), R0 // arg 1 - name 317 MOVW namelen+4(FP), R1 // arg 2 - namelen 318 MOVW oldp+8(FP), R2 // arg 3 - oldp 319 MOVW oldlenp+12(FP), R3 // arg 4 - oldlenp 320 MOVW newp+16(FP), R4 // arg 5 - newp (on stack) 321 MOVW R4, 4(R13) 322 MOVW newlen+20(FP), R5 // arg 6 - newlen (on stack) 323 MOVW R5, 8(R13) 324 ADD $4, R13 325 MOVW $202, R12 // sys___sysctl 326 SWI $0 327 SUB $4, R13 328 MOVW.CC $0, R0 329 RSB.CS $0, R0 330 MOVW R0, ret+24(FP) 331 RET 332 333 // int32 runtime·kqueue(void); 334 TEXT runtime·kqueue(SB),NOSPLIT,$0 335 MOVW $269, R12 // sys_kqueue 336 SWI $0 337 RSB.CS $0, R0 338 MOVW R0, ret+0(FP) 339 RET 340 341 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); 342 TEXT runtime·kevent(SB),NOSPLIT,$8 343 MOVW fd+0(FP), R0 // arg 1 - fd 344 MOVW changelist+4(FP), R1 // arg 2 - changelist 345 MOVW nchanges+8(FP), R2 // arg 3 - nchanges 346 MOVW eventlist+12(FP), R3 // arg 4 - eventlist 347 MOVW nevents+16(FP), R4 // arg 5 - nevents (on stack) 348 MOVW R4, 4(R13) 349 MOVW timeout+20(FP), R5 // arg 6 - timeout (on stack) 350 MOVW R5, 8(R13) 351 ADD $4, R13 352 MOVW $72, R12 // sys_kevent 353 SWI $0 354 RSB.CS $0, R0 355 SUB $4, R13 356 MOVW R0, ret+24(FP) 357 RET 358 359 // int32 runtime·closeonexec(int32 fd); 360 TEXT runtime·closeonexec(SB),NOSPLIT,$0 361 MOVW fd+0(FP), R0 // arg 1 - fd 362 MOVW $2, R1 // arg 2 - cmd (F_SETFD) 363 MOVW $1, R2 // arg 3 - arg (FD_CLOEXEC) 364 MOVW $92, R12 // sys_fcntl 365 SWI $0 366 RSB.CS $0, R0 367 MOVW R0, ret+4(FP) 368 RET 369 370 TEXT runtime·casp1(SB),NOSPLIT,$0 371 //B runtime·armcas(SB) 372 B runtime·cas(SB) 373 374 TEXT runtime·cas(SB),NOSPLIT,$0 375 B runtime·armcas(SB) 376 377 // TODO(jsing): Implement. 378 TEXT runtime·read_tls_fallback(SB),NOSPLIT,$-4 379 MOVW $5, R0 380 MOVW R0, (R0) 381 RET