github.com/mtsmfm/go/src@v0.0.0-20221020090648-44bdcb9f8fde/runtime/sys_linux_amd64.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 // 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 MOVQ SP, R12 // Save old SP; R12 unchanged by C code. 232 233 MOVQ g_m(R14), BX // BX unchanged by C code. 234 235 // Set vdsoPC and vdsoSP for SIGPROF traceback. 236 // Save the old values on stack and restore them on exit, 237 // so this function is reentrant. 238 MOVQ m_vdsoPC(BX), CX 239 MOVQ m_vdsoSP(BX), DX 240 MOVQ CX, 0(SP) 241 MOVQ DX, 8(SP) 242 243 LEAQ ret+0(FP), DX 244 MOVQ -8(DX), CX 245 MOVQ CX, m_vdsoPC(BX) 246 MOVQ DX, m_vdsoSP(BX) 247 248 CMPQ R14, m_curg(BX) // Only switch if on curg. 249 JNE noswitch 250 251 MOVQ m_g0(BX), DX 252 MOVQ (g_sched+gobuf_sp)(DX), SP // Set SP to g0 stack 253 254 noswitch: 255 SUBQ $16, SP // Space for results 256 ANDQ $~15, SP // Align for C code 257 258 MOVL $1, DI // CLOCK_MONOTONIC 259 LEAQ 0(SP), SI 260 MOVQ runtime·vdsoClockgettimeSym(SB), AX 261 CMPQ AX, $0 262 JEQ fallback 263 CALL AX 264 ret: 265 MOVQ 0(SP), AX // sec 266 MOVQ 8(SP), DX // nsec 267 MOVQ R12, SP // Restore real SP 268 // Restore vdsoPC, vdsoSP 269 // We don't worry about being signaled between the two stores. 270 // If we are not in a signal handler, we'll restore vdsoSP to 0, 271 // and no one will care about vdsoPC. If we are in a signal handler, 272 // we cannot receive another signal. 273 MOVQ 8(SP), CX 274 MOVQ CX, m_vdsoSP(BX) 275 MOVQ 0(SP), CX 276 MOVQ CX, m_vdsoPC(BX) 277 // sec is in AX, nsec in DX 278 // return nsec in AX 279 IMULQ $1000000000, AX 280 ADDQ DX, AX 281 MOVQ AX, ret+0(FP) 282 RET 283 fallback: 284 MOVQ $SYS_clock_gettime, AX 285 SYSCALL 286 JMP ret 287 288 TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-28 289 MOVL how+0(FP), DI 290 MOVQ new+8(FP), SI 291 MOVQ old+16(FP), DX 292 MOVL size+24(FP), R10 293 MOVL $SYS_rt_sigprocmask, AX 294 SYSCALL 295 CMPQ AX, $0xfffffffffffff001 296 JLS 2(PC) 297 MOVL $0xf1, 0xf1 // crash 298 RET 299 300 TEXT runtime·rt_sigaction(SB),NOSPLIT,$0-36 301 MOVQ sig+0(FP), DI 302 MOVQ new+8(FP), SI 303 MOVQ old+16(FP), DX 304 MOVQ size+24(FP), R10 305 MOVL $SYS_rt_sigaction, AX 306 SYSCALL 307 MOVL AX, ret+32(FP) 308 RET 309 310 // Call the function stored in _cgo_sigaction using the GCC calling convention. 311 TEXT runtime·callCgoSigaction(SB),NOSPLIT,$16 312 MOVQ sig+0(FP), DI 313 MOVQ new+8(FP), SI 314 MOVQ old+16(FP), DX 315 MOVQ _cgo_sigaction(SB), AX 316 MOVQ SP, BX // callee-saved 317 ANDQ $~15, SP // alignment as per amd64 psABI 318 CALL AX 319 MOVQ BX, SP 320 MOVL AX, ret+24(FP) 321 RET 322 323 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 324 MOVQ fn+0(FP), AX 325 MOVL sig+8(FP), DI 326 MOVQ info+16(FP), SI 327 MOVQ ctx+24(FP), DX 328 PUSHQ BP 329 MOVQ SP, BP 330 ANDQ $~15, SP // alignment for x86_64 ABI 331 CALL AX 332 MOVQ BP, SP 333 POPQ BP 334 RET 335 336 // Called using C ABI. 337 TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$0 338 // Transition from C ABI to Go ABI. 339 PUSH_REGS_HOST_TO_ABI0() 340 341 // Set up ABIInternal environment: g in R14, cleared X15. 342 get_tls(R12) 343 MOVQ g(R12), R14 344 PXOR X15, X15 345 346 // Reserve space for spill slots. 347 NOP SP // disable vet stack checking 348 ADJSP $24 349 350 // Call into the Go signal handler 351 MOVQ DI, AX // sig 352 MOVQ SI, BX // info 353 MOVQ DX, CX // ctx 354 CALL ·sigtrampgo<ABIInternal>(SB) 355 356 ADJSP $-24 357 358 POP_REGS_HOST_TO_ABI0() 359 RET 360 361 // Called using C ABI. 362 TEXT runtime·sigprofNonGoWrapper<>(SB),NOSPLIT,$0 363 // Transition from C ABI to Go ABI. 364 PUSH_REGS_HOST_TO_ABI0() 365 366 // Set up ABIInternal environment: g in R14, cleared X15. 367 get_tls(R12) 368 MOVQ g(R12), R14 369 PXOR X15, X15 370 371 // Reserve space for spill slots. 372 NOP SP // disable vet stack checking 373 ADJSP $24 374 375 // Call into the Go signal handler 376 MOVQ DI, AX // sig 377 MOVQ SI, BX // info 378 MOVQ DX, CX // ctx 379 CALL ·sigprofNonGo<ABIInternal>(SB) 380 381 ADJSP $-24 382 383 POP_REGS_HOST_TO_ABI0() 384 RET 385 386 // Used instead of sigtramp in programs that use cgo. 387 // Arguments from kernel are in DI, SI, DX. 388 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0 389 // If no traceback function, do usual sigtramp. 390 MOVQ runtime·cgoTraceback(SB), AX 391 TESTQ AX, AX 392 JZ sigtramp 393 394 // If no traceback support function, which means that 395 // runtime/cgo was not linked in, do usual sigtramp. 396 MOVQ _cgo_callers(SB), AX 397 TESTQ AX, AX 398 JZ sigtramp 399 400 // Figure out if we are currently in a cgo call. 401 // If not, just do usual sigtramp. 402 get_tls(CX) 403 MOVQ g(CX),AX 404 TESTQ AX, AX 405 JZ sigtrampnog // g == nil 406 MOVQ g_m(AX), AX 407 TESTQ AX, AX 408 JZ sigtramp // g.m == nil 409 MOVL m_ncgo(AX), CX 410 TESTL CX, CX 411 JZ sigtramp // g.m.ncgo == 0 412 MOVQ m_curg(AX), CX 413 TESTQ CX, CX 414 JZ sigtramp // g.m.curg == nil 415 MOVQ g_syscallsp(CX), CX 416 TESTQ CX, CX 417 JZ sigtramp // g.m.curg.syscallsp == 0 418 MOVQ m_cgoCallers(AX), R8 419 TESTQ R8, R8 420 JZ sigtramp // g.m.cgoCallers == nil 421 MOVL m_cgoCallersUse(AX), CX 422 TESTL CX, CX 423 JNZ sigtramp // g.m.cgoCallersUse != 0 424 425 // Jump to a function in runtime/cgo. 426 // That function, written in C, will call the user's traceback 427 // function with proper unwind info, and will then call back here. 428 // The first three arguments, and the fifth, are already in registers. 429 // Set the two remaining arguments now. 430 MOVQ runtime·cgoTraceback(SB), CX 431 MOVQ $runtime·sigtramp(SB), R9 432 MOVQ _cgo_callers(SB), AX 433 JMP AX 434 435 sigtramp: 436 JMP runtime·sigtramp(SB) 437 438 sigtrampnog: 439 // Signal arrived on a non-Go thread. If this is SIGPROF, get a 440 // stack trace. 441 CMPL DI, $27 // 27 == SIGPROF 442 JNZ sigtramp 443 444 // Lock sigprofCallersUse. 445 MOVL $0, AX 446 MOVL $1, CX 447 MOVQ $runtime·sigprofCallersUse(SB), R11 448 LOCK 449 CMPXCHGL CX, 0(R11) 450 JNZ sigtramp // Skip stack trace if already locked. 451 452 // Jump to the traceback function in runtime/cgo. 453 // It will call back to sigprofNonGo, via sigprofNonGoWrapper, to convert 454 // the arguments to the Go calling convention. 455 // First three arguments to traceback function are in registers already. 456 MOVQ runtime·cgoTraceback(SB), CX 457 MOVQ $runtime·sigprofCallers(SB), R8 458 MOVQ $runtime·sigprofNonGoWrapper<>(SB), R9 459 MOVQ _cgo_callers(SB), AX 460 JMP AX 461 462 // For cgo unwinding to work, this function must look precisely like 463 // the one in glibc. The glibc source code is: 464 // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/x86_64/sigaction.c 465 // The code that cares about the precise instructions used is: 466 // https://gcc.gnu.org/viewcvs/gcc/trunk/libgcc/config/i386/linux-unwind.h?revision=219188&view=markup 467 TEXT runtime·sigreturn(SB),NOSPLIT,$0 468 MOVQ $SYS_rt_sigreturn, AX 469 SYSCALL 470 INT $3 // not reached 471 472 TEXT runtime·sysMmap(SB),NOSPLIT,$0 473 MOVQ addr+0(FP), DI 474 MOVQ n+8(FP), SI 475 MOVL prot+16(FP), DX 476 MOVL flags+20(FP), R10 477 MOVL fd+24(FP), R8 478 MOVL off+28(FP), R9 479 480 MOVL $SYS_mmap, AX 481 SYSCALL 482 CMPQ AX, $0xfffffffffffff001 483 JLS ok 484 NOTQ AX 485 INCQ AX 486 MOVQ $0, p+32(FP) 487 MOVQ AX, err+40(FP) 488 RET 489 ok: 490 MOVQ AX, p+32(FP) 491 MOVQ $0, err+40(FP) 492 RET 493 494 // Call the function stored in _cgo_mmap using the GCC calling convention. 495 // This must be called on the system stack. 496 TEXT runtime·callCgoMmap(SB),NOSPLIT,$16 497 MOVQ addr+0(FP), DI 498 MOVQ n+8(FP), SI 499 MOVL prot+16(FP), DX 500 MOVL flags+20(FP), CX 501 MOVL fd+24(FP), R8 502 MOVL off+28(FP), R9 503 MOVQ _cgo_mmap(SB), AX 504 MOVQ SP, BX 505 ANDQ $~15, SP // alignment as per amd64 psABI 506 MOVQ BX, 0(SP) 507 CALL AX 508 MOVQ 0(SP), SP 509 MOVQ AX, ret+32(FP) 510 RET 511 512 TEXT runtime·sysMunmap(SB),NOSPLIT,$0 513 MOVQ addr+0(FP), DI 514 MOVQ n+8(FP), SI 515 MOVQ $SYS_munmap, AX 516 SYSCALL 517 CMPQ AX, $0xfffffffffffff001 518 JLS 2(PC) 519 MOVL $0xf1, 0xf1 // crash 520 RET 521 522 // Call the function stored in _cgo_munmap using the GCC calling convention. 523 // This must be called on the system stack. 524 TEXT runtime·callCgoMunmap(SB),NOSPLIT,$16-16 525 MOVQ addr+0(FP), DI 526 MOVQ n+8(FP), SI 527 MOVQ _cgo_munmap(SB), AX 528 MOVQ SP, BX 529 ANDQ $~15, SP // alignment as per amd64 psABI 530 MOVQ BX, 0(SP) 531 CALL AX 532 MOVQ 0(SP), SP 533 RET 534 535 TEXT runtime·madvise(SB),NOSPLIT,$0 536 MOVQ addr+0(FP), DI 537 MOVQ n+8(FP), SI 538 MOVL flags+16(FP), DX 539 MOVQ $SYS_madvise, AX 540 SYSCALL 541 MOVL AX, ret+24(FP) 542 RET 543 544 // int64 futex(int32 *uaddr, int32 op, int32 val, 545 // struct timespec *timeout, int32 *uaddr2, int32 val2); 546 TEXT runtime·futex(SB),NOSPLIT,$0 547 MOVQ addr+0(FP), DI 548 MOVL op+8(FP), SI 549 MOVL val+12(FP), DX 550 MOVQ ts+16(FP), R10 551 MOVQ addr2+24(FP), R8 552 MOVL val3+32(FP), R9 553 MOVL $SYS_futex, AX 554 SYSCALL 555 MOVL AX, ret+40(FP) 556 RET 557 558 // int32 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void)); 559 TEXT runtime·clone(SB),NOSPLIT,$0 560 MOVL flags+0(FP), DI 561 MOVQ stk+8(FP), SI 562 MOVQ $0, DX 563 MOVQ $0, R10 564 MOVQ $0, R8 565 // Copy mp, gp, fn off parent stack for use by child. 566 // Careful: Linux system call clobbers CX and R11. 567 MOVQ mp+16(FP), R13 568 MOVQ gp+24(FP), R9 569 MOVQ fn+32(FP), R12 570 CMPQ R13, $0 // m 571 JEQ nog1 572 CMPQ R9, $0 // g 573 JEQ nog1 574 LEAQ m_tls(R13), R8 575 #ifdef GOOS_android 576 // Android stores the TLS offset in runtime·tls_g. 577 SUBQ runtime·tls_g(SB), R8 578 #else 579 ADDQ $8, R8 // ELF wants to use -8(FS) 580 #endif 581 ORQ $0x00080000, DI //add flag CLONE_SETTLS(0x00080000) to call clone 582 nog1: 583 MOVL $SYS_clone, AX 584 SYSCALL 585 586 // In parent, return. 587 CMPQ AX, $0 588 JEQ 3(PC) 589 MOVL AX, ret+40(FP) 590 RET 591 592 // In child, on new stack. 593 MOVQ SI, SP 594 595 // If g or m are nil, skip Go-related setup. 596 CMPQ R13, $0 // m 597 JEQ nog2 598 CMPQ R9, $0 // g 599 JEQ nog2 600 601 // Initialize m->procid to Linux tid 602 MOVL $SYS_gettid, AX 603 SYSCALL 604 MOVQ AX, m_procid(R13) 605 606 // In child, set up new stack 607 get_tls(CX) 608 MOVQ R13, g_m(R9) 609 MOVQ R9, g(CX) 610 MOVQ R9, R14 // set g register 611 CALL runtime·stackcheck(SB) 612 613 nog2: 614 // Call fn. This is the PC of an ABI0 function. 615 CALL R12 616 617 // It shouldn't return. If it does, exit that thread. 618 MOVL $111, DI 619 MOVL $SYS_exit, AX 620 SYSCALL 621 JMP -3(PC) // keep exiting 622 623 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8 624 MOVQ new+0(FP), DI 625 MOVQ old+8(FP), SI 626 MOVQ $SYS_sigaltstack, AX 627 SYSCALL 628 CMPQ AX, $0xfffffffffffff001 629 JLS 2(PC) 630 MOVL $0xf1, 0xf1 // crash 631 RET 632 633 // set tls base to DI 634 TEXT runtime·settls(SB),NOSPLIT,$32 635 #ifdef GOOS_android 636 // Android stores the TLS offset in runtime·tls_g. 637 SUBQ runtime·tls_g(SB), DI 638 #else 639 ADDQ $8, DI // ELF wants to use -8(FS) 640 #endif 641 MOVQ DI, SI 642 MOVQ $0x1002, DI // ARCH_SET_FS 643 MOVQ $SYS_arch_prctl, AX 644 SYSCALL 645 CMPQ AX, $0xfffffffffffff001 646 JLS 2(PC) 647 MOVL $0xf1, 0xf1 // crash 648 RET 649 650 TEXT runtime·osyield(SB),NOSPLIT,$0 651 MOVL $SYS_sched_yield, AX 652 SYSCALL 653 RET 654 655 TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0 656 MOVQ pid+0(FP), DI 657 MOVQ len+8(FP), SI 658 MOVQ buf+16(FP), DX 659 MOVL $SYS_sched_getaffinity, AX 660 SYSCALL 661 MOVL AX, ret+24(FP) 662 RET 663 664 // int access(const char *name, int mode) 665 TEXT runtime·access(SB),NOSPLIT,$0 666 // This uses faccessat instead of access, because Android O blocks access. 667 MOVL $AT_FDCWD, DI // AT_FDCWD, so this acts like access 668 MOVQ name+0(FP), SI 669 MOVL mode+8(FP), DX 670 MOVL $0, R10 671 MOVL $SYS_faccessat, AX 672 SYSCALL 673 MOVL AX, ret+16(FP) 674 RET 675 676 // int connect(int fd, const struct sockaddr *addr, socklen_t addrlen) 677 TEXT runtime·connect(SB),NOSPLIT,$0-28 678 MOVL fd+0(FP), DI 679 MOVQ addr+8(FP), SI 680 MOVL len+16(FP), DX 681 MOVL $SYS_connect, AX 682 SYSCALL 683 MOVL AX, ret+24(FP) 684 RET 685 686 // int socket(int domain, int type, int protocol) 687 TEXT runtime·socket(SB),NOSPLIT,$0-20 688 MOVL domain+0(FP), DI 689 MOVL typ+4(FP), SI 690 MOVL prot+8(FP), DX 691 MOVL $SYS_socket, AX 692 SYSCALL 693 MOVL AX, ret+16(FP) 694 RET 695 696 // func sbrk0() uintptr 697 TEXT runtime·sbrk0(SB),NOSPLIT,$0-8 698 // Implemented as brk(NULL). 699 MOVQ $0, DI 700 MOVL $SYS_brk, AX 701 SYSCALL 702 MOVQ AX, ret+0(FP) 703 RET