Text file
src/runtime/sys_linux_amd64.s
Documentation: runtime
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 //
6 // System calls and other sys.stuff for AMD64, Linux
7 //
8
9 #include "go_asm.h"
10 #include "go_tls.h"
11 #include "textflag.h"
12 #include "cgo/abi_amd64.h"
13
14 #define AT_FDCWD -100
15
16 #define SYS_read 0
17 #define SYS_write 1
18 #define SYS_close 3
19 #define SYS_mmap 9
20 #define SYS_munmap 11
21 #define SYS_brk 12
22 #define SYS_rt_sigaction 13
23 #define SYS_rt_sigprocmask 14
24 #define SYS_rt_sigreturn 15
25 #define SYS_pipe 22
26 #define SYS_sched_yield 24
27 #define SYS_mincore 27
28 #define SYS_madvise 28
29 #define SYS_nanosleep 35
30 #define SYS_setittimer 38
31 #define SYS_getpid 39
32 #define SYS_socket 41
33 #define SYS_connect 42
34 #define SYS_clone 56
35 #define SYS_exit 60
36 #define SYS_kill 62
37 #define SYS_fcntl 72
38 #define SYS_sigaltstack 131
39 #define SYS_arch_prctl 158
40 #define SYS_gettid 186
41 #define SYS_futex 202
42 #define SYS_sched_getaffinity 204
43 #define SYS_epoll_create 213
44 #define SYS_clock_gettime 228
45 #define SYS_exit_group 231
46 #define SYS_epoll_ctl 233
47 #define SYS_tgkill 234
48 #define SYS_openat 257
49 #define SYS_faccessat 269
50 #define SYS_epoll_pwait 281
51 #define SYS_epoll_create1 291
52 #define SYS_pipe2 293
53
54 TEXT runtime·exit(SB),NOSPLIT,$0-4
55 MOVL code+0(FP), DI
56 MOVL $SYS_exit_group, AX
57 SYSCALL
58 RET
59
60 // func exitThread(wait *uint32)
61 TEXT runtime·exitThread(SB),NOSPLIT,$0-8
62 MOVQ wait+0(FP), AX
63 // We're done using the stack.
64 MOVL $0, (AX)
65 MOVL $0, DI // exit code
66 MOVL $SYS_exit, AX
67 SYSCALL
68 // We may not even have a stack any more.
69 INT $3
70 JMP 0(PC)
71
72 TEXT runtime·open(SB),NOSPLIT,$0-20
73 // This uses openat instead of open, because Android O blocks open.
74 MOVL $AT_FDCWD, DI // AT_FDCWD, so this acts like open
75 MOVQ name+0(FP), SI
76 MOVL mode+8(FP), DX
77 MOVL perm+12(FP), R10
78 MOVL $SYS_openat, AX
79 SYSCALL
80 CMPQ AX, $0xfffffffffffff001
81 JLS 2(PC)
82 MOVL $-1, AX
83 MOVL AX, ret+16(FP)
84 RET
85
86 TEXT runtime·closefd(SB),NOSPLIT,$0-12
87 MOVL fd+0(FP), DI
88 MOVL $SYS_close, AX
89 SYSCALL
90 CMPQ AX, $0xfffffffffffff001
91 JLS 2(PC)
92 MOVL $-1, AX
93 MOVL AX, ret+8(FP)
94 RET
95
96 TEXT runtime·write1(SB),NOSPLIT,$0-28
97 MOVQ fd+0(FP), DI
98 MOVQ p+8(FP), SI
99 MOVL n+16(FP), DX
100 MOVL $SYS_write, AX
101 SYSCALL
102 MOVL AX, ret+24(FP)
103 RET
104
105 TEXT runtime·read(SB),NOSPLIT,$0-28
106 MOVL fd+0(FP), DI
107 MOVQ p+8(FP), SI
108 MOVL n+16(FP), DX
109 MOVL $SYS_read, AX
110 SYSCALL
111 MOVL AX, ret+24(FP)
112 RET
113
114 // func pipe() (r, w int32, errno int32)
115 TEXT runtime·pipe(SB),NOSPLIT,$0-12
116 LEAQ r+0(FP), DI
117 MOVL $SYS_pipe, AX
118 SYSCALL
119 MOVL AX, errno+8(FP)
120 RET
121
122 // func pipe2(flags int32) (r, w int32, errno int32)
123 TEXT runtime·pipe2(SB),NOSPLIT,$0-20
124 LEAQ r+8(FP), DI
125 MOVL flags+0(FP), SI
126 MOVL $SYS_pipe2, AX
127 SYSCALL
128 MOVL AX, errno+16(FP)
129 RET
130
131 TEXT runtime·usleep(SB),NOSPLIT,$16
132 MOVL $0, DX
133 MOVL usec+0(FP), AX
134 MOVL $1000000, CX
135 DIVL CX
136 MOVQ AX, 0(SP)
137 MOVL $1000, AX // usec to nsec
138 MULL DX
139 MOVQ AX, 8(SP)
140
141 // nanosleep(&ts, 0)
142 MOVQ SP, DI
143 MOVL $0, SI
144 MOVL $SYS_nanosleep, AX
145 SYSCALL
146 RET
147
148 TEXT runtime·gettid(SB),NOSPLIT,$0-4
149 MOVL $SYS_gettid, AX
150 SYSCALL
151 MOVL AX, ret+0(FP)
152 RET
153
154 TEXT runtime·raise(SB),NOSPLIT,$0
155 MOVL $SYS_getpid, AX
156 SYSCALL
157 MOVL AX, R12
158 MOVL $SYS_gettid, AX
159 SYSCALL
160 MOVL AX, SI // arg 2 tid
161 MOVL R12, DI // arg 1 pid
162 MOVL sig+0(FP), DX // arg 3
163 MOVL $SYS_tgkill, AX
164 SYSCALL
165 RET
166
167 TEXT runtime·raiseproc(SB),NOSPLIT,$0
168 MOVL $SYS_getpid, AX
169 SYSCALL
170 MOVL AX, DI // arg 1 pid
171 MOVL sig+0(FP), SI // arg 2
172 MOVL $SYS_kill, AX
173 SYSCALL
174 RET
175
176 TEXT ·getpid(SB),NOSPLIT,$0-8
177 MOVL $SYS_getpid, AX
178 SYSCALL
179 MOVQ AX, ret+0(FP)
180 RET
181
182 TEXT ·tgkill(SB),NOSPLIT,$0
183 MOVQ tgid+0(FP), DI
184 MOVQ tid+8(FP), SI
185 MOVQ sig+16(FP), DX
186 MOVL $SYS_tgkill, AX
187 SYSCALL
188 RET
189
190 TEXT runtime·setitimer(SB),NOSPLIT,$0-24
191 MOVL mode+0(FP), DI
192 MOVQ new+8(FP), SI
193 MOVQ old+16(FP), DX
194 MOVL $SYS_setittimer, AX
195 SYSCALL
196 RET
197
198 TEXT runtime·mincore(SB),NOSPLIT,$0-28
199 MOVQ addr+0(FP), DI
200 MOVQ n+8(FP), SI
201 MOVQ dst+16(FP), DX
202 MOVL $SYS_mincore, AX
203 SYSCALL
204 MOVL AX, ret+24(FP)
205 RET
206
207 // func nanotime1() int64
208 TEXT runtime·nanotime1(SB),NOSPLIT,$16-8
209 // We don't know how much stack space the VDSO code will need,
210 // so switch to g0.
211 // In particular, a kernel configured with CONFIG_OPTIMIZE_INLINING=n
212 // and hardening can use a full page of stack space in gettime_sym
213 // due to stack probes inserted to avoid stack/heap collisions.
214 // See issue #20427.
215
216 MOVQ SP, R12 // Save old SP; R12 unchanged by C code.
217
218 #ifdef GOEXPERIMENT_regabig
219 MOVQ g_m(R14), BX // BX unchanged by C code.
220 #else
221 get_tls(CX)
222 MOVQ g(CX), AX
223 MOVQ g_m(AX), BX // BX unchanged by C code.
224 #endif
225
226 // Set vdsoPC and vdsoSP for SIGPROF traceback.
227 // Save the old values on stack and restore them on exit,
228 // so this function is reentrant.
229 MOVQ m_vdsoPC(BX), CX
230 MOVQ m_vdsoSP(BX), DX
231 MOVQ CX, 0(SP)
232 MOVQ DX, 8(SP)
233
234 LEAQ ret+0(FP), DX
235 MOVQ -8(DX), CX
236 MOVQ CX, m_vdsoPC(BX)
237 MOVQ DX, m_vdsoSP(BX)
238
239 #ifdef GOEXPERIMENT_regabig
240 CMPQ R14, m_curg(BX) // Only switch if on curg.
241 #else
242 CMPQ AX, m_curg(BX) // Only switch if on curg.
243 #endif
244 JNE noswitch
245
246 MOVQ m_g0(BX), DX
247 MOVQ (g_sched+gobuf_sp)(DX), SP // Set SP to g0 stack
248
249 noswitch:
250 SUBQ $16, SP // Space for results
251 ANDQ $~15, SP // Align for C code
252
253 MOVL $1, DI // CLOCK_MONOTONIC
254 LEAQ 0(SP), SI
255 MOVQ runtime·vdsoClockgettimeSym(SB), AX
256 CMPQ AX, $0
257 JEQ fallback
258 CALL AX
259 ret:
260 MOVQ 0(SP), AX // sec
261 MOVQ 8(SP), DX // nsec
262 MOVQ R12, SP // Restore real SP
263 // Restore vdsoPC, vdsoSP
264 // We don't worry about being signaled between the two stores.
265 // If we are not in a signal handler, we'll restore vdsoSP to 0,
266 // and no one will care about vdsoPC. If we are in a signal handler,
267 // we cannot receive another signal.
268 MOVQ 8(SP), CX
269 MOVQ CX, m_vdsoSP(BX)
270 MOVQ 0(SP), CX
271 MOVQ CX, m_vdsoPC(BX)
272 // sec is in AX, nsec in DX
273 // return nsec in AX
274 IMULQ $1000000000, AX
275 ADDQ DX, AX
276 MOVQ AX, ret+0(FP)
277 RET
278 fallback:
279 MOVQ $SYS_clock_gettime, AX
280 SYSCALL
281 JMP ret
282
283 TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-28
284 MOVL how+0(FP), DI
285 MOVQ new+8(FP), SI
286 MOVQ old+16(FP), DX
287 MOVL size+24(FP), R10
288 MOVL $SYS_rt_sigprocmask, AX
289 SYSCALL
290 CMPQ AX, $0xfffffffffffff001
291 JLS 2(PC)
292 MOVL $0xf1, 0xf1 // crash
293 RET
294
295 TEXT runtime·rt_sigaction(SB),NOSPLIT,$0-36
296 MOVQ sig+0(FP), DI
297 MOVQ new+8(FP), SI
298 MOVQ old+16(FP), DX
299 MOVQ size+24(FP), R10
300 MOVL $SYS_rt_sigaction, AX
301 SYSCALL
302 MOVL AX, ret+32(FP)
303 RET
304
305 // Call the function stored in _cgo_sigaction using the GCC calling convention.
306 TEXT runtime·callCgoSigaction(SB),NOSPLIT,$16
307 MOVQ sig+0(FP), DI
308 MOVQ new+8(FP), SI
309 MOVQ old+16(FP), DX
310 MOVQ _cgo_sigaction(SB), AX
311 MOVQ SP, BX // callee-saved
312 ANDQ $~15, SP // alignment as per amd64 psABI
313 CALL AX
314 MOVQ BX, SP
315 MOVL AX, ret+24(FP)
316 RET
317
318 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
319 MOVQ fn+0(FP), AX
320 MOVL sig+8(FP), DI
321 MOVQ info+16(FP), SI
322 MOVQ ctx+24(FP), DX
323 PUSHQ BP
324 MOVQ SP, BP
325 ANDQ $~15, SP // alignment for x86_64 ABI
326 CALL AX
327 MOVQ BP, SP
328 POPQ BP
329 RET
330
331 // Defined as ABIInternal since it does not use the stack-based Go ABI.
332 // Called using C ABI.
333 TEXT runtime·sigtramp<ABIInternal>(SB),NOSPLIT,$0
334 // Transition from C ABI to Go ABI.
335 PUSH_REGS_HOST_TO_ABI0()
336
337 // Call into the Go signal handler
338 NOP SP // disable vet stack checking
339 ADJSP $24
340 MOVQ DI, 0(SP) // sig
341 MOVQ SI, 8(SP) // info
342 MOVQ DX, 16(SP) // ctx
343 CALL ·sigtrampgo(SB)
344 ADJSP $-24
345
346 POP_REGS_HOST_TO_ABI0()
347 RET
348
349 // Used instead of sigtramp in programs that use cgo.
350 // Arguments from kernel are in DI, SI, DX.
351 // Defined as ABIInternal since it does not use the stack-based Go ABI.
352 TEXT runtime·cgoSigtramp<ABIInternal>(SB),NOSPLIT,$0
353 // If no traceback function, do usual sigtramp.
354 MOVQ runtime·cgoTraceback(SB), AX
355 TESTQ AX, AX
356 JZ sigtramp
357
358 // If no traceback support function, which means that
359 // runtime/cgo was not linked in, do usual sigtramp.
360 MOVQ _cgo_callers(SB), AX
361 TESTQ AX, AX
362 JZ sigtramp
363
364 // Figure out if we are currently in a cgo call.
365 // If not, just do usual sigtramp.
366 get_tls(CX)
367 MOVQ g(CX),AX
368 TESTQ AX, AX
369 JZ sigtrampnog // g == nil
370 MOVQ g_m(AX), AX
371 TESTQ AX, AX
372 JZ sigtramp // g.m == nil
373 MOVL m_ncgo(AX), CX
374 TESTL CX, CX
375 JZ sigtramp // g.m.ncgo == 0
376 MOVQ m_curg(AX), CX
377 TESTQ CX, CX
378 JZ sigtramp // g.m.curg == nil
379 MOVQ g_syscallsp(CX), CX
380 TESTQ CX, CX
381 JZ sigtramp // g.m.curg.syscallsp == 0
382 MOVQ m_cgoCallers(AX), R8
383 TESTQ R8, R8
384 JZ sigtramp // g.m.cgoCallers == nil
385 MOVL m_cgoCallersUse(AX), CX
386 TESTL CX, CX
387 JNZ sigtramp // g.m.cgoCallersUse != 0
388
389 // Jump to a function in runtime/cgo.
390 // That function, written in C, will call the user's traceback
391 // function with proper unwind info, and will then call back here.
392 // The first three arguments, and the fifth, are already in registers.
393 // Set the two remaining arguments now.
394 MOVQ runtime·cgoTraceback(SB), CX
395 MOVQ $runtime·sigtramp<ABIInternal>(SB), R9
396 MOVQ _cgo_callers(SB), AX
397 JMP AX
398
399 sigtramp:
400 JMP runtime·sigtramp<ABIInternal>(SB)
401
402 sigtrampnog:
403 // Signal arrived on a non-Go thread. If this is SIGPROF, get a
404 // stack trace.
405 CMPL DI, $27 // 27 == SIGPROF
406 JNZ sigtramp
407
408 // Lock sigprofCallersUse.
409 MOVL $0, AX
410 MOVL $1, CX
411 MOVQ $runtime·sigprofCallersUse(SB), R11
412 LOCK
413 CMPXCHGL CX, 0(R11)
414 JNZ sigtramp // Skip stack trace if already locked.
415
416 // Jump to the traceback function in runtime/cgo.
417 // It will call back to sigprofNonGo, which will ignore the
418 // arguments passed in registers.
419 // First three arguments to traceback function are in registers already.
420 MOVQ runtime·cgoTraceback(SB), CX
421 MOVQ $runtime·sigprofCallers(SB), R8
422 MOVQ $runtime·sigprofNonGo(SB), R9
423 MOVQ _cgo_callers(SB), AX
424 JMP AX
425
426 // For cgo unwinding to work, this function must look precisely like
427 // the one in glibc. The glibc source code is:
428 // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/x86_64/sigaction.c
429 // The code that cares about the precise instructions used is:
430 // https://gcc.gnu.org/viewcvs/gcc/trunk/libgcc/config/i386/linux-unwind.h?revision=219188&view=markup
431 // Defined as ABIInternal since it does not use the stack-based Go ABI.
432 TEXT runtime·sigreturn<ABIInternal>(SB),NOSPLIT,$0
433 MOVQ $SYS_rt_sigreturn, AX
434 SYSCALL
435 INT $3 // not reached
436
437 TEXT runtime·sysMmap(SB),NOSPLIT,$0
438 MOVQ addr+0(FP), DI
439 MOVQ n+8(FP), SI
440 MOVL prot+16(FP), DX
441 MOVL flags+20(FP), R10
442 MOVL fd+24(FP), R8
443 MOVL off+28(FP), R9
444
445 MOVL $SYS_mmap, AX
446 SYSCALL
447 CMPQ AX, $0xfffffffffffff001
448 JLS ok
449 NOTQ AX
450 INCQ AX
451 MOVQ $0, p+32(FP)
452 MOVQ AX, err+40(FP)
453 RET
454 ok:
455 MOVQ AX, p+32(FP)
456 MOVQ $0, err+40(FP)
457 RET
458
459 // Call the function stored in _cgo_mmap using the GCC calling convention.
460 // This must be called on the system stack.
461 TEXT runtime·callCgoMmap(SB),NOSPLIT,$16
462 MOVQ addr+0(FP), DI
463 MOVQ n+8(FP), SI
464 MOVL prot+16(FP), DX
465 MOVL flags+20(FP), CX
466 MOVL fd+24(FP), R8
467 MOVL off+28(FP), R9
468 MOVQ _cgo_mmap(SB), AX
469 MOVQ SP, BX
470 ANDQ $~15, SP // alignment as per amd64 psABI
471 MOVQ BX, 0(SP)
472 CALL AX
473 MOVQ 0(SP), SP
474 MOVQ AX, ret+32(FP)
475 RET
476
477 TEXT runtime·sysMunmap(SB),NOSPLIT,$0
478 MOVQ addr+0(FP), DI
479 MOVQ n+8(FP), SI
480 MOVQ $SYS_munmap, AX
481 SYSCALL
482 CMPQ AX, $0xfffffffffffff001
483 JLS 2(PC)
484 MOVL $0xf1, 0xf1 // crash
485 RET
486
487 // Call the function stored in _cgo_munmap using the GCC calling convention.
488 // This must be called on the system stack.
489 TEXT runtime·callCgoMunmap(SB),NOSPLIT,$16-16
490 MOVQ addr+0(FP), DI
491 MOVQ n+8(FP), SI
492 MOVQ _cgo_munmap(SB), AX
493 MOVQ SP, BX
494 ANDQ $~15, SP // alignment as per amd64 psABI
495 MOVQ BX, 0(SP)
496 CALL AX
497 MOVQ 0(SP), SP
498 RET
499
500 TEXT runtime·madvise(SB),NOSPLIT,$0
501 MOVQ addr+0(FP), DI
502 MOVQ n+8(FP), SI
503 MOVL flags+16(FP), DX
504 MOVQ $SYS_madvise, AX
505 SYSCALL
506 MOVL AX, ret+24(FP)
507 RET
508
509 // int64 futex(int32 *uaddr, int32 op, int32 val,
510 // struct timespec *timeout, int32 *uaddr2, int32 val2);
511 TEXT runtime·futex(SB),NOSPLIT,$0
512 MOVQ addr+0(FP), DI
513 MOVL op+8(FP), SI
514 MOVL val+12(FP), DX
515 MOVQ ts+16(FP), R10
516 MOVQ addr2+24(FP), R8
517 MOVL val3+32(FP), R9
518 MOVL $SYS_futex, AX
519 SYSCALL
520 MOVL AX, ret+40(FP)
521 RET
522
523 // int32 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
524 TEXT runtime·clone(SB),NOSPLIT,$0
525 MOVL flags+0(FP), DI
526 MOVQ stk+8(FP), SI
527 MOVQ $0, DX
528 MOVQ $0, R10
529 MOVQ $0, R8
530 // Copy mp, gp, fn off parent stack for use by child.
531 // Careful: Linux system call clobbers CX and R11.
532 MOVQ mp+16(FP), R13
533 MOVQ gp+24(FP), R9
534 MOVQ fn+32(FP), R12
535 CMPQ R13, $0 // m
536 JEQ nog1
537 CMPQ R9, $0 // g
538 JEQ nog1
539 LEAQ m_tls(R13), R8
540 #ifdef GOOS_android
541 // Android stores the TLS offset in runtime·tls_g.
542 SUBQ runtime·tls_g(SB), R8
543 #else
544 ADDQ $8, R8 // ELF wants to use -8(FS)
545 #endif
546 ORQ $0x00080000, DI //add flag CLONE_SETTLS(0x00080000) to call clone
547 nog1:
548 MOVL $SYS_clone, AX
549 SYSCALL
550
551 // In parent, return.
552 CMPQ AX, $0
553 JEQ 3(PC)
554 MOVL AX, ret+40(FP)
555 RET
556
557 // In child, on new stack.
558 MOVQ SI, SP
559
560 // If g or m are nil, skip Go-related setup.
561 CMPQ R13, $0 // m
562 JEQ nog2
563 CMPQ R9, $0 // g
564 JEQ nog2
565
566 // Initialize m->procid to Linux tid
567 MOVL $SYS_gettid, AX
568 SYSCALL
569 MOVQ AX, m_procid(R13)
570
571 // In child, set up new stack
572 get_tls(CX)
573 MOVQ R13, g_m(R9)
574 MOVQ R9, g(CX)
575 MOVQ R9, R14 // set g register
576 CALL runtime·stackcheck(SB)
577
578 nog2:
579 // Call fn. This is the PC of an ABI0 function.
580 CALL R12
581
582 // It shouldn't return. If it does, exit that thread.
583 MOVL $111, DI
584 MOVL $SYS_exit, AX
585 SYSCALL
586 JMP -3(PC) // keep exiting
587
588 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
589 MOVQ new+0(FP), DI
590 MOVQ old+8(FP), SI
591 MOVQ $SYS_sigaltstack, AX
592 SYSCALL
593 CMPQ AX, $0xfffffffffffff001
594 JLS 2(PC)
595 MOVL $0xf1, 0xf1 // crash
596 RET
597
598 // set tls base to DI
599 TEXT runtime·settls(SB),NOSPLIT,$32
600 #ifdef GOOS_android
601 // Android stores the TLS offset in runtime·tls_g.
602 SUBQ runtime·tls_g(SB), DI
603 #else
604 ADDQ $8, DI // ELF wants to use -8(FS)
605 #endif
606 MOVQ DI, SI
607 MOVQ $0x1002, DI // ARCH_SET_FS
608 MOVQ $SYS_arch_prctl, AX
609 SYSCALL
610 CMPQ AX, $0xfffffffffffff001
611 JLS 2(PC)
612 MOVL $0xf1, 0xf1 // crash
613 RET
614
615 TEXT runtime·osyield(SB),NOSPLIT,$0
616 MOVL $SYS_sched_yield, AX
617 SYSCALL
618 RET
619
620 TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
621 MOVQ pid+0(FP), DI
622 MOVQ len+8(FP), SI
623 MOVQ buf+16(FP), DX
624 MOVL $SYS_sched_getaffinity, AX
625 SYSCALL
626 MOVL AX, ret+24(FP)
627 RET
628
629 // int32 runtime·epollcreate(int32 size);
630 TEXT runtime·epollcreate(SB),NOSPLIT,$0
631 MOVL size+0(FP), DI
632 MOVL $SYS_epoll_create, AX
633 SYSCALL
634 MOVL AX, ret+8(FP)
635 RET
636
637 // int32 runtime·epollcreate1(int32 flags);
638 TEXT runtime·epollcreate1(SB),NOSPLIT,$0
639 MOVL flags+0(FP), DI
640 MOVL $SYS_epoll_create1, AX
641 SYSCALL
642 MOVL AX, ret+8(FP)
643 RET
644
645 // func epollctl(epfd, op, fd int32, ev *epollEvent) int
646 TEXT runtime·epollctl(SB),NOSPLIT,$0
647 MOVL epfd+0(FP), DI
648 MOVL op+4(FP), SI
649 MOVL fd+8(FP), DX
650 MOVQ ev+16(FP), R10
651 MOVL $SYS_epoll_ctl, AX
652 SYSCALL
653 MOVL AX, ret+24(FP)
654 RET
655
656 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
657 TEXT runtime·epollwait(SB),NOSPLIT,$0
658 // This uses pwait instead of wait, because Android O blocks wait.
659 MOVL epfd+0(FP), DI
660 MOVQ ev+8(FP), SI
661 MOVL nev+16(FP), DX
662 MOVL timeout+20(FP), R10
663 MOVQ $0, R8
664 MOVL $SYS_epoll_pwait, AX
665 SYSCALL
666 MOVL AX, ret+24(FP)
667 RET
668
669 // void runtime·closeonexec(int32 fd);
670 TEXT runtime·closeonexec(SB),NOSPLIT,$0
671 MOVL fd+0(FP), DI // fd
672 MOVQ $2, SI // F_SETFD
673 MOVQ $1, DX // FD_CLOEXEC
674 MOVL $SYS_fcntl, AX
675 SYSCALL
676 RET
677
678 // func runtime·setNonblock(int32 fd)
679 TEXT runtime·setNonblock(SB),NOSPLIT,$0-4
680 MOVL fd+0(FP), DI // fd
681 MOVQ $3, SI // F_GETFL
682 MOVQ $0, DX
683 MOVL $SYS_fcntl, AX
684 SYSCALL
685 MOVL fd+0(FP), DI // fd
686 MOVQ $4, SI // F_SETFL
687 MOVQ $0x800, DX // O_NONBLOCK
688 ORL AX, DX
689 MOVL $SYS_fcntl, AX
690 SYSCALL
691 RET
692
693 // int access(const char *name, int mode)
694 TEXT runtime·access(SB),NOSPLIT,$0
695 // This uses faccessat instead of access, because Android O blocks access.
696 MOVL $AT_FDCWD, DI // AT_FDCWD, so this acts like access
697 MOVQ name+0(FP), SI
698 MOVL mode+8(FP), DX
699 MOVL $0, R10
700 MOVL $SYS_faccessat, AX
701 SYSCALL
702 MOVL AX, ret+16(FP)
703 RET
704
705 // int connect(int fd, const struct sockaddr *addr, socklen_t addrlen)
706 TEXT runtime·connect(SB),NOSPLIT,$0-28
707 MOVL fd+0(FP), DI
708 MOVQ addr+8(FP), SI
709 MOVL len+16(FP), DX
710 MOVL $SYS_connect, AX
711 SYSCALL
712 MOVL AX, ret+24(FP)
713 RET
714
715 // int socket(int domain, int type, int protocol)
716 TEXT runtime·socket(SB),NOSPLIT,$0-20
717 MOVL domain+0(FP), DI
718 MOVL typ+4(FP), SI
719 MOVL prot+8(FP), DX
720 MOVL $SYS_socket, AX
721 SYSCALL
722 MOVL AX, ret+16(FP)
723 RET
724
725 // func sbrk0() uintptr
726 TEXT runtime·sbrk0(SB),NOSPLIT,$0-8
727 // Implemented as brk(NULL).
728 MOVQ $0, DI
729 MOVL $SYS_brk, AX
730 SYSCALL
731 MOVQ AX, ret+0(FP)
732 RET
733
View as plain text