Text file
src/runtime/sys_linux_amd64.s
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
51 TEXT 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)
58 TEXT 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
69 TEXT 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
83 TEXT 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
93 TEXT 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
102 TEXT 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)
112 TEXT 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
120 TEXT 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
137 TEXT runtime·gettid(SB),NOSPLIT,$0-4
138 MOVL $SYS_gettid, AX
139 SYSCALL
140 MOVL AX, ret+0(FP)
141 RET
142
143 TEXT 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
156 TEXT 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
165 TEXT ·getpid(SB),NOSPLIT,$0-8
166 MOVL $SYS_getpid, AX
167 SYSCALL
168 MOVQ AX, ret+0(FP)
169 RET
170
171 TEXT ·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
179 TEXT 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
187 TEXT 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
196 TEXT 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
206 TEXT 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
213 TEXT 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
223 TEXT 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
240 nosecret:
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
266 noswitch:
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
276 ret:
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
295 fallback:
296 MOVQ $SYS_clock_gettime, AX
297 SYSCALL
298 JMP ret
299
300 TEXT 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
312 TEXT 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.
323 TEXT 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
335 TEXT 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.
347 TEXT 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.
372 TEXT 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.
398 TEXT 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
445 sigtramp:
446 JMP runtime·sigtramp(SB)
447
448 sigtrampnog:
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
482 TEXT runtime·sigreturn__sigaction(SB),NOSPLIT,$0
483 // The 7-byte sign-extended "48 c7 c0 0f 00 00 00" form of
484 // "MOVQ $SYS_rt_sigreturn, AX" is required: gdb and libgcc match
485 // these exact bytes to recognize the signal trampoline. The Go
486 // assembler now emits the 5-byte zero-extended "b8 0f 00 00 00"
487 // form for positive imm32, so write the bytes by hand.
488 BYTE $0x48; BYTE $0xc7; BYTE $0xc0
489 BYTE $0x0f; BYTE $0x00; BYTE $0x00; BYTE $0x00
490 SYSCALL
491 INT $3 // not reached
492
493 TEXT runtime·sysMmap(SB),NOSPLIT,$0
494 MOVQ addr+0(FP), DI
495 MOVQ n+8(FP), SI
496 MOVL prot+16(FP), DX
497 MOVL flags+20(FP), R10
498 MOVL fd+24(FP), R8
499 MOVL off+28(FP), R9
500
501 MOVL $SYS_mmap, AX
502 SYSCALL
503 CMPQ AX, $0xfffffffffffff001
504 JLS ok
505 NOTQ AX
506 INCQ AX
507 MOVQ $0, p+32(FP)
508 MOVQ AX, err+40(FP)
509 RET
510 ok:
511 MOVQ AX, p+32(FP)
512 MOVQ $0, err+40(FP)
513 RET
514
515 // Call the function stored in _cgo_mmap using the GCC calling convention.
516 // This must be called on the system stack.
517 TEXT runtime·callCgoMmap(SB),NOSPLIT,$16
518 MOVQ addr+0(FP), DI
519 MOVQ n+8(FP), SI
520 MOVL prot+16(FP), DX
521 MOVL flags+20(FP), CX
522 MOVL fd+24(FP), R8
523 MOVL off+28(FP), R9
524 MOVQ _cgo_mmap(SB), AX
525 MOVQ SP, BX
526 ANDQ $~15, SP // alignment as per amd64 psABI
527 MOVQ BX, 0(SP)
528 CALL AX
529 MOVQ 0(SP), SP
530 MOVQ AX, ret+32(FP)
531 RET
532
533 TEXT runtime·sysMunmap(SB),NOSPLIT,$0
534 MOVQ addr+0(FP), DI
535 MOVQ n+8(FP), SI
536 MOVQ $SYS_munmap, AX
537 SYSCALL
538 CMPQ AX, $0xfffffffffffff001
539 JLS 2(PC)
540 MOVL $0xf1, 0xf1 // crash
541 RET
542
543 // Call the function stored in _cgo_munmap using the GCC calling convention.
544 // This must be called on the system stack.
545 TEXT runtime·callCgoMunmap(SB),NOSPLIT,$16-16
546 MOVQ addr+0(FP), DI
547 MOVQ n+8(FP), SI
548 MOVQ _cgo_munmap(SB), AX
549 MOVQ SP, BX
550 ANDQ $~15, SP // alignment as per amd64 psABI
551 MOVQ BX, 0(SP)
552 CALL AX
553 MOVQ 0(SP), SP
554 RET
555
556 TEXT runtime·madvise(SB),NOSPLIT,$0
557 MOVQ addr+0(FP), DI
558 MOVQ n+8(FP), SI
559 MOVL flags+16(FP), DX
560 MOVQ $SYS_madvise, AX
561 SYSCALL
562 MOVL AX, ret+24(FP)
563 RET
564
565 // int64 futex(int32 *uaddr, int32 op, int32 val,
566 // struct timespec *timeout, int32 *uaddr2, int32 val2);
567 TEXT runtime·futex(SB),NOSPLIT,$0
568 MOVQ addr+0(FP), DI
569 MOVL op+8(FP), SI
570 MOVL val+12(FP), DX
571 MOVQ ts+16(FP), R10
572 MOVQ addr2+24(FP), R8
573 MOVL val3+32(FP), R9
574 MOVL $SYS_futex, AX
575 SYSCALL
576 MOVL AX, ret+40(FP)
577 RET
578
579 // int32 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
580 TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0
581 MOVL flags+0(FP), DI
582 MOVQ stk+8(FP), SI
583 MOVQ $0, DX
584 MOVQ $0, R10
585 MOVQ $0, R8
586 // Copy mp, gp, fn off parent stack for use by child.
587 // Careful: Linux system call clobbers CX and R11.
588 MOVQ mp+16(FP), R13
589 MOVQ gp+24(FP), R9
590 MOVQ fn+32(FP), R12
591 CMPQ R13, $0 // m
592 JEQ nog1
593 CMPQ R9, $0 // g
594 JEQ nog1
595 LEAQ m_tls(R13), R8
596 #ifdef GOOS_android
597 // Android stores the TLS offset in runtime·tls_g.
598 SUBQ runtime·tls_g(SB), R8
599 #else
600 ADDQ $8, R8 // ELF wants to use -8(FS)
601 #endif
602 ORQ $0x00080000, DI //add flag CLONE_SETTLS(0x00080000) to call clone
603 nog1:
604 MOVL $SYS_clone, AX
605 SYSCALL
606
607 // In parent, return.
608 CMPQ AX, $0
609 JEQ 3(PC)
610 MOVL AX, ret+40(FP)
611 RET
612
613 // In child, on new stack.
614 MOVQ SI, SP
615
616 // If g or m are nil, skip Go-related setup.
617 CMPQ R13, $0 // m
618 JEQ nog2
619 CMPQ R9, $0 // g
620 JEQ nog2
621
622 // Initialize m->procid to Linux tid
623 MOVL $SYS_gettid, AX
624 SYSCALL
625 MOVQ AX, m_procid(R13)
626
627 // In child, set up new stack
628 get_tls(CX)
629 MOVQ R13, g_m(R9)
630 MOVQ R9, g(CX)
631 MOVQ R9, R14 // set g register
632 CALL runtime·stackcheck(SB)
633
634 nog2:
635 // Call fn. This is the PC of an ABI0 function.
636 CALL R12
637
638 // It shouldn't return. If it does, exit that thread.
639 MOVL $111, DI
640 MOVL $SYS_exit, AX
641 SYSCALL
642 JMP -3(PC) // keep exiting
643
644 TEXT runtime·sigaltstack(SB),NOSPLIT,$0
645 MOVQ new+0(FP), DI
646 MOVQ old+8(FP), SI
647 MOVQ $SYS_sigaltstack, AX
648 SYSCALL
649 CMPQ AX, $0xfffffffffffff001
650 JLS 2(PC)
651 MOVL $0xf1, 0xf1 // crash
652 RET
653
654 // set tls base to DI
655 TEXT runtime·settls(SB),NOSPLIT,$32
656 #ifdef GOOS_android
657 // Android stores the TLS offset in runtime·tls_g.
658 SUBQ runtime·tls_g(SB), DI
659 #else
660 ADDQ $8, DI // ELF wants to use -8(FS)
661 #endif
662 MOVQ DI, SI
663 MOVQ $0x1002, DI // ARCH_SET_FS
664 MOVQ $SYS_arch_prctl, AX
665 SYSCALL
666 CMPQ AX, $0xfffffffffffff001
667 JLS 2(PC)
668 MOVL $0xf1, 0xf1 // crash
669 RET
670
671 TEXT runtime·osyield(SB),NOSPLIT,$0
672 MOVL $SYS_sched_yield, AX
673 SYSCALL
674 RET
675
676 TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
677 MOVQ pid+0(FP), DI
678 MOVQ len+8(FP), SI
679 MOVQ buf+16(FP), DX
680 MOVL $SYS_sched_getaffinity, AX
681 SYSCALL
682 MOVL AX, ret+24(FP)
683 RET
684
685 // int access(const char *name, int mode)
686 TEXT runtime·access(SB),NOSPLIT,$0
687 // This uses faccessat instead of access, because Android O blocks access.
688 MOVL $AT_FDCWD, DI // AT_FDCWD, so this acts like access
689 MOVQ name+0(FP), SI
690 MOVL mode+8(FP), DX
691 MOVL $0, R10
692 MOVL $SYS_faccessat, AX
693 SYSCALL
694 MOVL AX, ret+16(FP)
695 RET
696
697 // int connect(int fd, const struct sockaddr *addr, socklen_t addrlen)
698 TEXT runtime·connect(SB),NOSPLIT,$0-28
699 MOVL fd+0(FP), DI
700 MOVQ addr+8(FP), SI
701 MOVL len+16(FP), DX
702 MOVL $SYS_connect, AX
703 SYSCALL
704 MOVL AX, ret+24(FP)
705 RET
706
707 // int socket(int domain, int type, int protocol)
708 TEXT runtime·socket(SB),NOSPLIT,$0-20
709 MOVL domain+0(FP), DI
710 MOVL typ+4(FP), SI
711 MOVL prot+8(FP), DX
712 MOVL $SYS_socket, AX
713 SYSCALL
714 MOVL AX, ret+16(FP)
715 RET
716
717 // func sbrk0() uintptr
718 TEXT runtime·sbrk0(SB),NOSPLIT,$0-8
719 // Implemented as brk(NULL).
720 MOVQ $0, DI
721 MOVL $SYS_brk, AX
722 SYSCALL
723 MOVQ AX, ret+0(FP)
724 RET
725
726 // func vgetrandom1(buf *byte, length uintptr, flags uint32, state uintptr, stateSize uintptr) int
727 TEXT runtime·vgetrandom1<ABIInternal>(SB),NOSPLIT,$16-48
728 MOVQ SI, R8 // stateSize
729 MOVL CX, DX // flags
730 MOVQ DI, CX // state
731 MOVQ BX, SI // length
732 MOVQ AX, DI // buf
733
734 MOVQ SP, R12
735
736 MOVQ runtime·vdsoGetrandomSym(SB), AX
737 MOVQ g_m(R14), BX
738
739 MOVQ m_vdsoPC(BX), R9
740 MOVQ R9, 0(SP)
741 MOVQ m_vdsoSP(BX), R9
742 MOVQ R9, 8(SP)
743 LEAQ buf+0(FP), R9
744 MOVQ R9, m_vdsoSP(BX)
745 MOVQ -8(R9), R9
746 MOVQ R9, m_vdsoPC(BX)
747
748 ANDQ $~15, SP
749
750 CALL AX
751
752 MOVQ R12, SP
753 MOVQ 8(SP), R9
754 MOVQ R9, m_vdsoSP(BX)
755 MOVQ 0(SP), R9
756 MOVQ R9, m_vdsoPC(BX)
757 RET
758
View as plain text