Text file
src/runtime/sys_linux_arm64.s
Documentation: runtime
1 // Copyright 2014 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, Linux
7 //
8
9 #include "go_asm.h"
10 #include "go_tls.h"
11 #include "textflag.h"
12
13 #define AT_FDCWD -100
14
15 #define CLOCK_REALTIME 0
16 #define CLOCK_MONOTONIC 1
17
18 #define SYS_exit 93
19 #define SYS_read 63
20 #define SYS_write 64
21 #define SYS_openat 56
22 #define SYS_close 57
23 #define SYS_pipe2 59
24 #define SYS_fcntl 25
25 #define SYS_nanosleep 101
26 #define SYS_mmap 222
27 #define SYS_munmap 215
28 #define SYS_setitimer 103
29 #define SYS_clone 220
30 #define SYS_sched_yield 124
31 #define SYS_rt_sigreturn 139
32 #define SYS_rt_sigaction 134
33 #define SYS_rt_sigprocmask 135
34 #define SYS_sigaltstack 132
35 #define SYS_madvise 233
36 #define SYS_mincore 232
37 #define SYS_getpid 172
38 #define SYS_gettid 178
39 #define SYS_kill 129
40 #define SYS_tgkill 131
41 #define SYS_futex 98
42 #define SYS_sched_getaffinity 123
43 #define SYS_exit_group 94
44 #define SYS_epoll_create1 20
45 #define SYS_epoll_ctl 21
46 #define SYS_epoll_pwait 22
47 #define SYS_clock_gettime 113
48 #define SYS_faccessat 48
49 #define SYS_socket 198
50 #define SYS_connect 203
51 #define SYS_brk 214
52
53 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
54 MOVW code+0(FP), R0
55 MOVD $SYS_exit_group, R8
56 SVC
57 RET
58
59 // func exitThread(wait *uint32)
60 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8
61 MOVD wait+0(FP), R0
62 // We're done using the stack.
63 MOVW $0, R1
64 STLRW R1, (R0)
65 MOVW $0, R0 // exit code
66 MOVD $SYS_exit, R8
67 SVC
68 JMP 0(PC)
69
70 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20
71 MOVD $AT_FDCWD, R0
72 MOVD name+0(FP), R1
73 MOVW mode+8(FP), R2
74 MOVW perm+12(FP), R3
75 MOVD $SYS_openat, R8
76 SVC
77 CMN $4095, R0
78 BCC done
79 MOVW $-1, R0
80 done:
81 MOVW R0, ret+16(FP)
82 RET
83
84 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12
85 MOVW fd+0(FP), R0
86 MOVD $SYS_close, R8
87 SVC
88 CMN $4095, R0
89 BCC done
90 MOVW $-1, R0
91 done:
92 MOVW R0, ret+8(FP)
93 RET
94
95 TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28
96 MOVD fd+0(FP), R0
97 MOVD p+8(FP), R1
98 MOVW n+16(FP), R2
99 MOVD $SYS_write, R8
100 SVC
101 MOVW R0, ret+24(FP)
102 RET
103
104 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28
105 MOVW fd+0(FP), R0
106 MOVD p+8(FP), R1
107 MOVW n+16(FP), R2
108 MOVD $SYS_read, R8
109 SVC
110 MOVW R0, ret+24(FP)
111 RET
112
113 // func pipe() (r, w int32, errno int32)
114 TEXT runtime·pipe(SB),NOSPLIT|NOFRAME,$0-12
115 MOVD $r+0(FP), R0
116 MOVW $0, R1
117 MOVW $SYS_pipe2, R8
118 SVC
119 MOVW R0, errno+8(FP)
120 RET
121
122 // func pipe2(flags int32) (r, w int32, errno int32)
123 TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20
124 MOVD $r+8(FP), R0
125 MOVW flags+0(FP), R1
126 MOVW $SYS_pipe2, R8
127 SVC
128 MOVW R0, errno+16(FP)
129 RET
130
131 TEXT runtime·usleep(SB),NOSPLIT,$24-4
132 MOVWU usec+0(FP), R3
133 MOVD R3, R5
134 MOVW $1000000, R4
135 UDIV R4, R3
136 MOVD R3, 8(RSP)
137 MUL R3, R4
138 SUB R4, R5
139 MOVW $1000, R4
140 MUL R4, R5
141 MOVD R5, 16(RSP)
142
143 // nanosleep(&ts, 0)
144 ADD $8, RSP, R0
145 MOVD $0, R1
146 MOVD $SYS_nanosleep, R8
147 SVC
148 RET
149
150 TEXT runtime·gettid(SB),NOSPLIT,$0-4
151 MOVD $SYS_gettid, R8
152 SVC
153 MOVW R0, ret+0(FP)
154 RET
155
156 TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0
157 MOVD $SYS_getpid, R8
158 SVC
159 MOVW R0, R19
160 MOVD $SYS_gettid, R8
161 SVC
162 MOVW R0, R1 // arg 2 tid
163 MOVW R19, R0 // arg 1 pid
164 MOVW sig+0(FP), R2 // arg 3
165 MOVD $SYS_tgkill, R8
166 SVC
167 RET
168
169 TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0
170 MOVD $SYS_getpid, R8
171 SVC
172 MOVW R0, R0 // arg 1 pid
173 MOVW sig+0(FP), R1 // arg 2
174 MOVD $SYS_kill, R8
175 SVC
176 RET
177
178 TEXT ·getpid(SB),NOSPLIT|NOFRAME,$0-8
179 MOVD $SYS_getpid, R8
180 SVC
181 MOVD R0, ret+0(FP)
182 RET
183
184 TEXT ·tgkill(SB),NOSPLIT,$0-24
185 MOVD tgid+0(FP), R0
186 MOVD tid+8(FP), R1
187 MOVD sig+16(FP), R2
188 MOVD $SYS_tgkill, R8
189 SVC
190 RET
191
192 TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24
193 MOVW mode+0(FP), R0
194 MOVD new+8(FP), R1
195 MOVD old+16(FP), R2
196 MOVD $SYS_setitimer, R8
197 SVC
198 RET
199
200 TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
201 MOVD addr+0(FP), R0
202 MOVD n+8(FP), R1
203 MOVD dst+16(FP), R2
204 MOVD $SYS_mincore, R8
205 SVC
206 MOVW R0, ret+24(FP)
207 RET
208
209 // func walltime() (sec int64, nsec int32)
210 TEXT runtime·walltime(SB),NOSPLIT,$24-12
211 MOVD RSP, R20 // R20 is unchanged by C code
212 MOVD RSP, R1
213
214 MOVD g_m(g), R21 // R21 = m
215
216 // Set vdsoPC and vdsoSP for SIGPROF traceback.
217 // Save the old values on stack and restore them on exit,
218 // so this function is reentrant.
219 MOVD m_vdsoPC(R21), R2
220 MOVD m_vdsoSP(R21), R3
221 MOVD R2, 8(RSP)
222 MOVD R3, 16(RSP)
223
224 MOVD LR, m_vdsoPC(R21)
225 MOVD R20, m_vdsoSP(R21)
226
227 MOVD m_curg(R21), R0
228 CMP g, R0
229 BNE noswitch
230
231 MOVD m_g0(R21), R3
232 MOVD (g_sched+gobuf_sp)(R3), R1 // Set RSP to g0 stack
233
234 noswitch:
235 SUB $16, R1
236 BIC $15, R1 // Align for C code
237 MOVD R1, RSP
238
239 MOVW $CLOCK_REALTIME, R0
240 MOVD runtime·vdsoClockgettimeSym(SB), R2
241 CBZ R2, fallback
242
243 // Store g on gsignal's stack, so if we receive a signal
244 // during VDSO code we can find the g.
245 // If we don't have a signal stack, we won't receive signal,
246 // so don't bother saving g.
247 // When using cgo, we already saved g on TLS, also don't save
248 // g here.
249 // Also don't save g if we are already on the signal stack.
250 // We won't get a nested signal.
251 MOVBU runtime·iscgo(SB), R22
252 CBNZ R22, nosaveg
253 MOVD m_gsignal(R21), R22 // g.m.gsignal
254 CBZ R22, nosaveg
255 CMP g, R22
256 BEQ nosaveg
257 MOVD (g_stack+stack_lo)(R22), R22 // g.m.gsignal.stack.lo
258 MOVD g, (R22)
259
260 BL (R2)
261
262 MOVD ZR, (R22) // clear g slot, R22 is unchanged by C code
263
264 B finish
265
266 nosaveg:
267 BL (R2)
268 B finish
269
270 fallback:
271 MOVD $SYS_clock_gettime, R8
272 SVC
273
274 finish:
275 MOVD 0(RSP), R3 // sec
276 MOVD 8(RSP), R5 // nsec
277
278 MOVD R20, RSP // restore SP
279 // Restore vdsoPC, vdsoSP
280 // We don't worry about being signaled between the two stores.
281 // If we are not in a signal handler, we'll restore vdsoSP to 0,
282 // and no one will care about vdsoPC. If we are in a signal handler,
283 // we cannot receive another signal.
284 MOVD 16(RSP), R1
285 MOVD R1, m_vdsoSP(R21)
286 MOVD 8(RSP), R1
287 MOVD R1, m_vdsoPC(R21)
288
289 MOVD R3, sec+0(FP)
290 MOVW R5, nsec+8(FP)
291 RET
292
293 TEXT runtime·nanotime1(SB),NOSPLIT,$24-8
294 MOVD RSP, R20 // R20 is unchanged by C code
295 MOVD RSP, R1
296
297 MOVD g_m(g), R21 // R21 = m
298
299 // Set vdsoPC and vdsoSP for SIGPROF traceback.
300 // Save the old values on stack and restore them on exit,
301 // so this function is reentrant.
302 MOVD m_vdsoPC(R21), R2
303 MOVD m_vdsoSP(R21), R3
304 MOVD R2, 8(RSP)
305 MOVD R3, 16(RSP)
306
307 MOVD LR, m_vdsoPC(R21)
308 MOVD R20, m_vdsoSP(R21)
309
310 MOVD m_curg(R21), R0
311 CMP g, R0
312 BNE noswitch
313
314 MOVD m_g0(R21), R3
315 MOVD (g_sched+gobuf_sp)(R3), R1 // Set RSP to g0 stack
316
317 noswitch:
318 SUB $32, R1
319 BIC $15, R1
320 MOVD R1, RSP
321
322 MOVW $CLOCK_MONOTONIC, R0
323 MOVD runtime·vdsoClockgettimeSym(SB), R2
324 CBZ R2, fallback
325
326 // Store g on gsignal's stack, so if we receive a signal
327 // during VDSO code we can find the g.
328 // If we don't have a signal stack, we won't receive signal,
329 // so don't bother saving g.
330 // When using cgo, we already saved g on TLS, also don't save
331 // g here.
332 // Also don't save g if we are already on the signal stack.
333 // We won't get a nested signal.
334 MOVBU runtime·iscgo(SB), R22
335 CBNZ R22, nosaveg
336 MOVD m_gsignal(R21), R22 // g.m.gsignal
337 CBZ R22, nosaveg
338 CMP g, R22
339 BEQ nosaveg
340 MOVD (g_stack+stack_lo)(R22), R22 // g.m.gsignal.stack.lo
341 MOVD g, (R22)
342
343 BL (R2)
344
345 MOVD ZR, (R22) // clear g slot, R22 is unchanged by C code
346
347 B finish
348
349 nosaveg:
350 BL (R2)
351 B finish
352
353 fallback:
354 MOVD $SYS_clock_gettime, R8
355 SVC
356
357 finish:
358 MOVD 0(RSP), R3 // sec
359 MOVD 8(RSP), R5 // nsec
360
361 MOVD R20, RSP // restore SP
362 // Restore vdsoPC, vdsoSP
363 // We don't worry about being signaled between the two stores.
364 // If we are not in a signal handler, we'll restore vdsoSP to 0,
365 // and no one will care about vdsoPC. If we are in a signal handler,
366 // we cannot receive another signal.
367 MOVD 16(RSP), R1
368 MOVD R1, m_vdsoSP(R21)
369 MOVD 8(RSP), R1
370 MOVD R1, m_vdsoPC(R21)
371
372 // sec is in R3, nsec in R5
373 // return nsec in R3
374 MOVD $1000000000, R4
375 MUL R4, R3
376 ADD R5, R3
377 MOVD R3, ret+0(FP)
378 RET
379
380 TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28
381 MOVW how+0(FP), R0
382 MOVD new+8(FP), R1
383 MOVD old+16(FP), R2
384 MOVW size+24(FP), R3
385 MOVD $SYS_rt_sigprocmask, R8
386 SVC
387 CMN $4095, R0
388 BCC done
389 MOVD $0, R0
390 MOVD R0, (R0) // crash
391 done:
392 RET
393
394 TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36
395 MOVD sig+0(FP), R0
396 MOVD new+8(FP), R1
397 MOVD old+16(FP), R2
398 MOVD size+24(FP), R3
399 MOVD $SYS_rt_sigaction, R8
400 SVC
401 MOVW R0, ret+32(FP)
402 RET
403
404 // Call the function stored in _cgo_sigaction using the GCC calling convention.
405 TEXT runtime·callCgoSigaction(SB),NOSPLIT,$0
406 MOVD sig+0(FP), R0
407 MOVD new+8(FP), R1
408 MOVD old+16(FP), R2
409 MOVD _cgo_sigaction(SB), R3
410 SUB $16, RSP // reserve 16 bytes for sp-8 where fp may be saved.
411 BL R3
412 ADD $16, RSP
413 MOVW R0, ret+24(FP)
414 RET
415
416 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
417 MOVW sig+8(FP), R0
418 MOVD info+16(FP), R1
419 MOVD ctx+24(FP), R2
420 MOVD fn+0(FP), R11
421 BL (R11)
422 RET
423
424 TEXT runtime·sigtramp(SB),NOSPLIT,$192
425 // Save callee-save registers in the case of signal forwarding.
426 // Please refer to https://golang.org/issue/31827 .
427 MOVD R19, 8*4(RSP)
428 MOVD R20, 8*5(RSP)
429 MOVD R21, 8*6(RSP)
430 MOVD R22, 8*7(RSP)
431 MOVD R23, 8*8(RSP)
432 MOVD R24, 8*9(RSP)
433 MOVD R25, 8*10(RSP)
434 MOVD R26, 8*11(RSP)
435 MOVD R27, 8*12(RSP)
436 MOVD g, 8*13(RSP)
437 MOVD R29, 8*14(RSP)
438 FMOVD F8, 8*15(RSP)
439 FMOVD F9, 8*16(RSP)
440 FMOVD F10, 8*17(RSP)
441 FMOVD F11, 8*18(RSP)
442 FMOVD F12, 8*19(RSP)
443 FMOVD F13, 8*20(RSP)
444 FMOVD F14, 8*21(RSP)
445 FMOVD F15, 8*22(RSP)
446
447 // this might be called in external code context,
448 // where g is not set.
449 // first save R0, because runtime·load_g will clobber it
450 MOVW R0, 8(RSP)
451 MOVBU runtime·iscgo(SB), R0
452 CBZ R0, 2(PC)
453 BL runtime·load_g(SB)
454
455 MOVD R1, 16(RSP)
456 MOVD R2, 24(RSP)
457 MOVD $runtime·sigtrampgo(SB), R0
458 BL (R0)
459
460 // Restore callee-save registers.
461 MOVD 8*4(RSP), R19
462 MOVD 8*5(RSP), R20
463 MOVD 8*6(RSP), R21
464 MOVD 8*7(RSP), R22
465 MOVD 8*8(RSP), R23
466 MOVD 8*9(RSP), R24
467 MOVD 8*10(RSP), R25
468 MOVD 8*11(RSP), R26
469 MOVD 8*12(RSP), R27
470 MOVD 8*13(RSP), g
471 MOVD 8*14(RSP), R29
472 FMOVD 8*15(RSP), F8
473 FMOVD 8*16(RSP), F9
474 FMOVD 8*17(RSP), F10
475 FMOVD 8*18(RSP), F11
476 FMOVD 8*19(RSP), F12
477 FMOVD 8*20(RSP), F13
478 FMOVD 8*21(RSP), F14
479 FMOVD 8*22(RSP), F15
480
481 RET
482
483 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
484 MOVD $runtime·sigtramp(SB), R3
485 B (R3)
486
487 TEXT runtime·sysMmap(SB),NOSPLIT|NOFRAME,$0
488 MOVD addr+0(FP), R0
489 MOVD n+8(FP), R1
490 MOVW prot+16(FP), R2
491 MOVW flags+20(FP), R3
492 MOVW fd+24(FP), R4
493 MOVW off+28(FP), R5
494
495 MOVD $SYS_mmap, R8
496 SVC
497 CMN $4095, R0
498 BCC ok
499 NEG R0,R0
500 MOVD $0, p+32(FP)
501 MOVD R0, err+40(FP)
502 RET
503 ok:
504 MOVD R0, p+32(FP)
505 MOVD $0, err+40(FP)
506 RET
507
508 // Call the function stored in _cgo_mmap using the GCC calling convention.
509 // This must be called on the system stack.
510 TEXT runtime·callCgoMmap(SB),NOSPLIT,$0
511 MOVD addr+0(FP), R0
512 MOVD n+8(FP), R1
513 MOVW prot+16(FP), R2
514 MOVW flags+20(FP), R3
515 MOVW fd+24(FP), R4
516 MOVW off+28(FP), R5
517 MOVD _cgo_mmap(SB), R9
518 SUB $16, RSP // reserve 16 bytes for sp-8 where fp may be saved.
519 BL R9
520 ADD $16, RSP
521 MOVD R0, ret+32(FP)
522 RET
523
524 TEXT runtime·sysMunmap(SB),NOSPLIT|NOFRAME,$0
525 MOVD addr+0(FP), R0
526 MOVD n+8(FP), R1
527 MOVD $SYS_munmap, R8
528 SVC
529 CMN $4095, R0
530 BCC cool
531 MOVD R0, 0xf0(R0)
532 cool:
533 RET
534
535 // Call the function stored in _cgo_munmap using the GCC calling convention.
536 // This must be called on the system stack.
537 TEXT runtime·callCgoMunmap(SB),NOSPLIT,$0
538 MOVD addr+0(FP), R0
539 MOVD n+8(FP), R1
540 MOVD _cgo_munmap(SB), R9
541 SUB $16, RSP // reserve 16 bytes for sp-8 where fp may be saved.
542 BL R9
543 ADD $16, RSP
544 RET
545
546 TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0
547 MOVD addr+0(FP), R0
548 MOVD n+8(FP), R1
549 MOVW flags+16(FP), R2
550 MOVD $SYS_madvise, R8
551 SVC
552 MOVW R0, ret+24(FP)
553 RET
554
555 // int64 futex(int32 *uaddr, int32 op, int32 val,
556 // struct timespec *timeout, int32 *uaddr2, int32 val2);
557 TEXT runtime·futex(SB),NOSPLIT|NOFRAME,$0
558 MOVD addr+0(FP), R0
559 MOVW op+8(FP), R1
560 MOVW val+12(FP), R2
561 MOVD ts+16(FP), R3
562 MOVD addr2+24(FP), R4
563 MOVW val3+32(FP), R5
564 MOVD $SYS_futex, R8
565 SVC
566 MOVW R0, ret+40(FP)
567 RET
568
569 // int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
570 TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0
571 MOVW flags+0(FP), R0
572 MOVD stk+8(FP), R1
573
574 // Copy mp, gp, fn off parent stack for use by child.
575 MOVD mp+16(FP), R10
576 MOVD gp+24(FP), R11
577 MOVD fn+32(FP), R12
578
579 MOVD R10, -8(R1)
580 MOVD R11, -16(R1)
581 MOVD R12, -24(R1)
582 MOVD $1234, R10
583 MOVD R10, -32(R1)
584
585 MOVD $SYS_clone, R8
586 SVC
587
588 // In parent, return.
589 CMP ZR, R0
590 BEQ child
591 MOVW R0, ret+40(FP)
592 RET
593 child:
594
595 // In child, on new stack.
596 MOVD -32(RSP), R10
597 MOVD $1234, R0
598 CMP R0, R10
599 BEQ good
600 MOVD $0, R0
601 MOVD R0, (R0) // crash
602
603 good:
604 // Initialize m->procid to Linux tid
605 MOVD $SYS_gettid, R8
606 SVC
607
608 MOVD -24(RSP), R12 // fn
609 MOVD -16(RSP), R11 // g
610 MOVD -8(RSP), R10 // m
611
612 CMP $0, R10
613 BEQ nog
614 CMP $0, R11
615 BEQ nog
616
617 MOVD R0, m_procid(R10)
618
619 // TODO: setup TLS.
620
621 // In child, set up new stack
622 MOVD R10, g_m(R11)
623 MOVD R11, g
624 //CALL runtime·stackcheck(SB)
625
626 nog:
627 // Call fn
628 MOVD R12, R0
629 BL (R0)
630
631 // It shouldn't return. If it does, exit that thread.
632 MOVW $111, R0
633 again:
634 MOVD $SYS_exit, R8
635 SVC
636 B again // keep exiting
637
638 TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0
639 MOVD new+0(FP), R0
640 MOVD old+8(FP), R1
641 MOVD $SYS_sigaltstack, R8
642 SVC
643 CMN $4095, R0
644 BCC ok
645 MOVD $0, R0
646 MOVD R0, (R0) // crash
647 ok:
648 RET
649
650 TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0
651 MOVD $SYS_sched_yield, R8
652 SVC
653 RET
654
655 TEXT runtime·sched_getaffinity(SB),NOSPLIT|NOFRAME,$0
656 MOVD pid+0(FP), R0
657 MOVD len+8(FP), R1
658 MOVD buf+16(FP), R2
659 MOVD $SYS_sched_getaffinity, R8
660 SVC
661 MOVW R0, ret+24(FP)
662 RET
663
664 // int32 runtime·epollcreate(int32 size);
665 TEXT runtime·epollcreate(SB),NOSPLIT|NOFRAME,$0
666 MOVW $0, R0
667 MOVD $SYS_epoll_create1, R8
668 SVC
669 MOVW R0, ret+8(FP)
670 RET
671
672 // int32 runtime·epollcreate1(int32 flags);
673 TEXT runtime·epollcreate1(SB),NOSPLIT|NOFRAME,$0
674 MOVW flags+0(FP), R0
675 MOVD $SYS_epoll_create1, R8
676 SVC
677 MOVW R0, ret+8(FP)
678 RET
679
680 // func epollctl(epfd, op, fd int32, ev *epollEvent) int
681 TEXT runtime·epollctl(SB),NOSPLIT|NOFRAME,$0
682 MOVW epfd+0(FP), R0
683 MOVW op+4(FP), R1
684 MOVW fd+8(FP), R2
685 MOVD ev+16(FP), R3
686 MOVD $SYS_epoll_ctl, R8
687 SVC
688 MOVW R0, ret+24(FP)
689 RET
690
691 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
692 TEXT runtime·epollwait(SB),NOSPLIT|NOFRAME,$0
693 MOVW epfd+0(FP), R0
694 MOVD ev+8(FP), R1
695 MOVW nev+16(FP), R2
696 MOVW timeout+20(FP), R3
697 MOVD $0, R4
698 MOVD $SYS_epoll_pwait, R8
699 SVC
700 MOVW R0, ret+24(FP)
701 RET
702
703 // void runtime·closeonexec(int32 fd);
704 TEXT runtime·closeonexec(SB),NOSPLIT|NOFRAME,$0
705 MOVW fd+0(FP), R0 // fd
706 MOVD $2, R1 // F_SETFD
707 MOVD $1, R2 // FD_CLOEXEC
708 MOVD $SYS_fcntl, R8
709 SVC
710 RET
711
712 // func runtime·setNonblock(int32 fd)
713 TEXT runtime·setNonblock(SB),NOSPLIT|NOFRAME,$0-4
714 MOVW fd+0(FP), R0 // fd
715 MOVD $3, R1 // F_GETFL
716 MOVD $0, R2
717 MOVD $SYS_fcntl, R8
718 SVC
719 MOVD $0x800, R2 // O_NONBLOCK
720 ORR R0, R2
721 MOVW fd+0(FP), R0 // fd
722 MOVD $4, R1 // F_SETFL
723 MOVD $SYS_fcntl, R8
724 SVC
725 RET
726
727 // int access(const char *name, int mode)
728 TEXT runtime·access(SB),NOSPLIT,$0-20
729 MOVD $AT_FDCWD, R0
730 MOVD name+0(FP), R1
731 MOVW mode+8(FP), R2
732 MOVD $SYS_faccessat, R8
733 SVC
734 MOVW R0, ret+16(FP)
735 RET
736
737 // int connect(int fd, const struct sockaddr *addr, socklen_t len)
738 TEXT runtime·connect(SB),NOSPLIT,$0-28
739 MOVW fd+0(FP), R0
740 MOVD addr+8(FP), R1
741 MOVW len+16(FP), R2
742 MOVD $SYS_connect, R8
743 SVC
744 MOVW R0, ret+24(FP)
745 RET
746
747 // int socket(int domain, int typ, int prot)
748 TEXT runtime·socket(SB),NOSPLIT,$0-20
749 MOVW domain+0(FP), R0
750 MOVW typ+4(FP), R1
751 MOVW prot+8(FP), R2
752 MOVD $SYS_socket, R8
753 SVC
754 MOVW R0, ret+16(FP)
755 RET
756
757 // func sbrk0() uintptr
758 TEXT runtime·sbrk0(SB),NOSPLIT,$0-8
759 // Implemented as brk(NULL).
760 MOVD $0, R0
761 MOVD $SYS_brk, R8
762 SVC
763 MOVD R0, ret+0(FP)
764 RET
765
766 TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
767 RET
768
View as plain text