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