github.com/lzhfromustc/gofuzz@v0.0.0-20211116160056-151b3108bbd1/runtime/sys_linux_ppc64x.s (about) 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 // +build linux 6 // +build ppc64 ppc64le 7 8 // 9 // System calls and other sys.stuff for ppc64, Linux 10 // 11 12 #include "go_asm.h" 13 #include "go_tls.h" 14 #include "textflag.h" 15 #include "asm_ppc64x.h" 16 17 #define SYS_exit 1 18 #define SYS_read 3 19 #define SYS_write 4 20 #define SYS_open 5 21 #define SYS_close 6 22 #define SYS_getpid 20 23 #define SYS_kill 37 24 #define SYS_pipe 42 25 #define SYS_brk 45 26 #define SYS_fcntl 55 27 #define SYS_mmap 90 28 #define SYS_munmap 91 29 #define SYS_setitimer 104 30 #define SYS_clone 120 31 #define SYS_sched_yield 158 32 #define SYS_nanosleep 162 33 #define SYS_rt_sigreturn 172 34 #define SYS_rt_sigaction 173 35 #define SYS_rt_sigprocmask 174 36 #define SYS_sigaltstack 185 37 #define SYS_madvise 205 38 #define SYS_mincore 206 39 #define SYS_gettid 207 40 #define SYS_futex 221 41 #define SYS_sched_getaffinity 223 42 #define SYS_exit_group 234 43 #define SYS_epoll_create 236 44 #define SYS_epoll_ctl 237 45 #define SYS_epoll_wait 238 46 #define SYS_clock_gettime 246 47 #define SYS_tgkill 250 48 #define SYS_epoll_create1 315 49 #define SYS_pipe2 317 50 51 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4 52 MOVW code+0(FP), R3 53 SYSCALL $SYS_exit_group 54 RET 55 56 // func exitThread(wait *uint32) 57 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8 58 MOVD wait+0(FP), R1 59 // We're done using the stack. 60 MOVW $0, R2 61 SYNC 62 MOVW R2, (R1) 63 MOVW $0, R3 // exit code 64 SYSCALL $SYS_exit 65 JMP 0(PC) 66 67 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20 68 MOVD name+0(FP), R3 69 MOVW mode+8(FP), R4 70 MOVW perm+12(FP), R5 71 SYSCALL $SYS_open 72 BVC 2(PC) 73 MOVW $-1, R3 74 MOVW R3, ret+16(FP) 75 RET 76 77 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12 78 MOVW fd+0(FP), R3 79 SYSCALL $SYS_close 80 BVC 2(PC) 81 MOVW $-1, R3 82 MOVW R3, ret+8(FP) 83 RET 84 85 TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28 86 MOVD fd+0(FP), R3 87 MOVD p+8(FP), R4 88 MOVW n+16(FP), R5 89 SYSCALL $SYS_write 90 BVC 2(PC) 91 NEG R3 // caller expects negative errno 92 MOVW R3, ret+24(FP) 93 RET 94 95 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28 96 MOVW fd+0(FP), R3 97 MOVD p+8(FP), R4 98 MOVW n+16(FP), R5 99 SYSCALL $SYS_read 100 BVC 2(PC) 101 NEG R3 // caller expects negative errno 102 MOVW R3, ret+24(FP) 103 RET 104 105 // func pipe() (r, w int32, errno int32) 106 TEXT runtime·pipe(SB),NOSPLIT|NOFRAME,$0-12 107 ADD $FIXED_FRAME, R1, R3 108 SYSCALL $SYS_pipe 109 MOVW R3, errno+8(FP) 110 RET 111 112 // func pipe2(flags int32) (r, w int32, errno int32) 113 TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20 114 ADD $FIXED_FRAME+8, R1, R3 115 MOVW flags+0(FP), R4 116 SYSCALL $SYS_pipe2 117 MOVW R3, errno+16(FP) 118 RET 119 120 TEXT runtime·usleep(SB),NOSPLIT,$16-4 121 MOVW usec+0(FP), R3 122 MOVD R3, R5 123 MOVW $1000000, R4 124 DIVD R4, R3 125 MOVD R3, 8(R1) 126 MOVW $1000, R4 127 MULLD R3, R4 128 SUB R4, R5 129 MOVD R5, 16(R1) 130 131 // nanosleep(&ts, 0) 132 ADD $8, R1, R3 133 MOVW $0, R4 134 SYSCALL $SYS_nanosleep 135 RET 136 137 TEXT runtime·gettid(SB),NOSPLIT,$0-4 138 SYSCALL $SYS_gettid 139 MOVW R3, ret+0(FP) 140 RET 141 142 TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0 143 SYSCALL $SYS_getpid 144 MOVW R3, R14 145 SYSCALL $SYS_gettid 146 MOVW R3, R4 // arg 2 tid 147 MOVW R14, R3 // arg 1 pid 148 MOVW sig+0(FP), R5 // arg 3 149 SYSCALL $SYS_tgkill 150 RET 151 152 TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0 153 SYSCALL $SYS_getpid 154 MOVW R3, R3 // arg 1 pid 155 MOVW sig+0(FP), R4 // arg 2 156 SYSCALL $SYS_kill 157 RET 158 159 TEXT ·getpid(SB),NOSPLIT|NOFRAME,$0-8 160 SYSCALL $SYS_getpid 161 MOVD R3, ret+0(FP) 162 RET 163 164 TEXT ·tgkill(SB),NOSPLIT|NOFRAME,$0-24 165 MOVD tgid+0(FP), R3 166 MOVD tid+8(FP), R4 167 MOVD sig+16(FP), R5 168 SYSCALL $SYS_tgkill 169 RET 170 171 TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24 172 MOVW mode+0(FP), R3 173 MOVD new+8(FP), R4 174 MOVD old+16(FP), R5 175 SYSCALL $SYS_setitimer 176 RET 177 178 TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28 179 MOVD addr+0(FP), R3 180 MOVD n+8(FP), R4 181 MOVD dst+16(FP), R5 182 SYSCALL $SYS_mincore 183 NEG R3 // caller expects negative errno 184 MOVW R3, ret+24(FP) 185 RET 186 187 // func walltime1() (sec int64, nsec int32) 188 TEXT runtime·walltime1(SB),NOSPLIT,$16-12 189 MOVD R1, R15 // R15 is unchanged by C code 190 MOVD g_m(g), R21 // R21 = m 191 192 MOVD $0, R3 // CLOCK_REALTIME 193 194 MOVD runtime·vdsoClockgettimeSym(SB), R12 // Check for VDSO availability 195 CMP R12, R0 196 BEQ fallback 197 198 // Set vdsoPC and vdsoSP for SIGPROF traceback. 199 // Save the old values on stack and restore them on exit, 200 // so this function is reentrant. 201 MOVD m_vdsoPC(R21), R4 202 MOVD m_vdsoSP(R21), R5 203 MOVD R4, 32(R1) 204 MOVD R5, 40(R1) 205 206 MOVD LR, R14 207 MOVD R14, m_vdsoPC(R21) 208 MOVD R15, m_vdsoSP(R21) 209 210 MOVD m_curg(R21), R6 211 CMP g, R6 212 BNE noswitch 213 214 MOVD m_g0(R21), R7 215 MOVD (g_sched+gobuf_sp)(R7), R1 // Set SP to g0 stack 216 217 noswitch: 218 SUB $16, R1 // Space for results 219 RLDICR $0, R1, $59, R1 // Align for C code 220 MOVD R12, CTR 221 MOVD R1, R4 222 BL (CTR) // Call from VDSO 223 MOVD $0, R0 // Restore R0 224 MOVD 0(R1), R3 // sec 225 MOVD 8(R1), R5 // nsec 226 MOVD R15, R1 // Restore SP 227 228 // Restore vdsoPC, vdsoSP 229 // We don't worry about being signaled between the two stores. 230 // If we are not in a signal handler, we'll restore vdsoSP to 0, 231 // and no one will care about vdsoPC. If we are in a signal handler, 232 // we cannot receive another signal. 233 MOVD 40(R1), R6 234 MOVD R6, m_vdsoSP(R21) 235 MOVD 32(R1), R6 236 MOVD R6, m_vdsoPC(R21) 237 238 finish: 239 MOVD R3, sec+0(FP) 240 MOVW R5, nsec+8(FP) 241 RET 242 243 // Syscall fallback 244 fallback: 245 ADD $32, R1, R4 246 SYSCALL $SYS_clock_gettime 247 MOVD 32(R1), R3 248 MOVD 40(R1), R5 249 JMP finish 250 251 TEXT runtime·nanotime1(SB),NOSPLIT,$16-8 252 MOVD $1, R3 // CLOCK_MONOTONIC 253 254 MOVD R1, R15 // R15 is unchanged by C code 255 MOVD g_m(g), R21 // R21 = m 256 257 MOVD runtime·vdsoClockgettimeSym(SB), R12 // Check for VDSO availability 258 CMP R12, R0 259 BEQ fallback 260 261 // Set vdsoPC and vdsoSP for SIGPROF traceback. 262 // Save the old values on stack and restore them on exit, 263 // so this function is reentrant. 264 MOVD m_vdsoPC(R21), R4 265 MOVD m_vdsoSP(R21), R5 266 MOVD R4, 32(R1) 267 MOVD R5, 40(R1) 268 269 MOVD LR, R14 // R14 is unchanged by C code 270 MOVD R14, m_vdsoPC(R21) 271 MOVD R15, m_vdsoSP(R21) 272 273 MOVD m_curg(R21), R6 274 CMP g, R6 275 BNE noswitch 276 277 MOVD m_g0(R21), R7 278 MOVD (g_sched+gobuf_sp)(R7), R1 // Set SP to g0 stack 279 280 noswitch: 281 SUB $16, R1 // Space for results 282 RLDICR $0, R1, $59, R1 // Align for C code 283 MOVD R12, CTR 284 MOVD R1, R4 285 BL (CTR) // Call from VDSO 286 MOVD $0, R0 // Restore R0 287 MOVD 0(R1), R3 // sec 288 MOVD 8(R1), R5 // nsec 289 MOVD R15, R1 // Restore SP 290 291 // Restore vdsoPC, vdsoSP 292 // We don't worry about being signaled between the two stores. 293 // If we are not in a signal handler, we'll restore vdsoSP to 0, 294 // and no one will care about vdsoPC. If we are in a signal handler, 295 // we cannot receive another signal. 296 MOVD 40(R1), R6 297 MOVD R6, m_vdsoSP(R21) 298 MOVD 32(R1), R6 299 MOVD R6, m_vdsoPC(R21) 300 301 finish: 302 // sec is in R3, nsec in R5 303 // return nsec in R3 304 MOVD $1000000000, R4 305 MULLD R4, R3 306 ADD R5, R3 307 MOVD R3, ret+0(FP) 308 RET 309 310 // Syscall fallback 311 fallback: 312 ADD $32, R1, R4 313 SYSCALL $SYS_clock_gettime 314 MOVD 32(R1), R3 315 MOVD 40(R1), R5 316 JMP finish 317 318 TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28 319 MOVW how+0(FP), R3 320 MOVD new+8(FP), R4 321 MOVD old+16(FP), R5 322 MOVW size+24(FP), R6 323 SYSCALL $SYS_rt_sigprocmask 324 BVC 2(PC) 325 MOVD R0, 0xf0(R0) // crash 326 RET 327 328 TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36 329 MOVD sig+0(FP), R3 330 MOVD new+8(FP), R4 331 MOVD old+16(FP), R5 332 MOVD size+24(FP), R6 333 SYSCALL $SYS_rt_sigaction 334 BVC 2(PC) 335 NEG R3 // caller expects negative errno 336 MOVW R3, ret+32(FP) 337 RET 338 339 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 340 MOVW sig+8(FP), R3 341 MOVD info+16(FP), R4 342 MOVD ctx+24(FP), R5 343 MOVD fn+0(FP), R12 344 MOVD R12, CTR 345 BL (CTR) 346 MOVD 24(R1), R2 347 RET 348 349 TEXT runtime·sigreturn(SB),NOSPLIT,$0-0 350 RET 351 352 #ifdef GOARCH_ppc64le 353 // ppc64le doesn't need function descriptors 354 TEXT runtime·sigtramp(SB),NOSPLIT,$64 355 #else 356 // function descriptor for the real sigtramp 357 TEXT runtime·sigtramp(SB),NOSPLIT|NOFRAME,$0 358 DWORD $sigtramp<>(SB) 359 DWORD $0 360 DWORD $0 361 TEXT sigtramp<>(SB),NOSPLIT,$64 362 #endif 363 // initialize essential registers (just in case) 364 BL runtime·reginit(SB) 365 366 // this might be called in external code context, 367 // where g is not set. 368 MOVBZ runtime·iscgo(SB), R6 369 CMP R6, $0 370 BEQ 2(PC) 371 BL runtime·load_g(SB) 372 373 MOVW R3, FIXED_FRAME+0(R1) 374 MOVD R4, FIXED_FRAME+8(R1) 375 MOVD R5, FIXED_FRAME+16(R1) 376 MOVD $runtime·sigtrampgo(SB), R12 377 MOVD R12, CTR 378 BL (CTR) 379 MOVD 24(R1), R2 380 RET 381 382 #ifdef GOARCH_ppc64le 383 // ppc64le doesn't need function descriptors 384 TEXT runtime·cgoSigtramp(SB),NOSPLIT|NOFRAME,$0 385 // The stack unwinder, presumably written in C, may not be able to 386 // handle Go frame correctly. So, this function is NOFRAME, and we 387 // save/restore LR manually. 388 MOVD LR, R10 389 390 // We're coming from C code, initialize essential registers. 391 CALL runtime·reginit(SB) 392 393 // If no traceback function, do usual sigtramp. 394 MOVD runtime·cgoTraceback(SB), R6 395 CMP $0, R6 396 BEQ sigtramp 397 398 // If no traceback support function, which means that 399 // runtime/cgo was not linked in, do usual sigtramp. 400 MOVD _cgo_callers(SB), R6 401 CMP $0, R6 402 BEQ sigtramp 403 404 // Set up g register. 405 CALL runtime·load_g(SB) 406 407 // Figure out if we are currently in a cgo call. 408 // If not, just do usual sigtramp. 409 CMP $0, g 410 BEQ sigtrampnog // g == nil 411 MOVD g_m(g), R6 412 CMP $0, R6 413 BEQ sigtramp // g.m == nil 414 MOVW m_ncgo(R6), R7 415 CMPW $0, R7 416 BEQ sigtramp // g.m.ncgo = 0 417 MOVD m_curg(R6), R7 418 CMP $0, R7 419 BEQ sigtramp // g.m.curg == nil 420 MOVD g_syscallsp(R7), R7 421 CMP $0, R7 422 BEQ sigtramp // g.m.curg.syscallsp == 0 423 MOVD m_cgoCallers(R6), R7 // R7 is the fifth arg in C calling convention. 424 CMP $0, R7 425 BEQ sigtramp // g.m.cgoCallers == nil 426 MOVW m_cgoCallersUse(R6), R8 427 CMPW $0, R8 428 BNE sigtramp // g.m.cgoCallersUse != 0 429 430 // Jump to a function in runtime/cgo. 431 // That function, written in C, will call the user's traceback 432 // function with proper unwind info, and will then call back here. 433 // The first three arguments, and the fifth, are already in registers. 434 // Set the two remaining arguments now. 435 MOVD runtime·cgoTraceback(SB), R6 436 MOVD $runtime·sigtramp(SB), R8 437 MOVD _cgo_callers(SB), R12 438 MOVD R12, CTR 439 MOVD R10, LR // restore LR 440 JMP (CTR) 441 442 sigtramp: 443 MOVD R10, LR // restore LR 444 JMP runtime·sigtramp(SB) 445 446 sigtrampnog: 447 // Signal arrived on a non-Go thread. If this is SIGPROF, get a 448 // stack trace. 449 CMPW R3, $27 // 27 == SIGPROF 450 BNE sigtramp 451 452 // Lock sigprofCallersUse (cas from 0 to 1). 453 MOVW $1, R7 454 MOVD $runtime·sigprofCallersUse(SB), R8 455 SYNC 456 LWAR (R8), R6 457 CMPW $0, R6 458 BNE sigtramp 459 STWCCC R7, (R8) 460 BNE -4(PC) 461 ISYNC 462 463 // Jump to the traceback function in runtime/cgo. 464 // It will call back to sigprofNonGo, which will ignore the 465 // arguments passed in registers. 466 // First three arguments to traceback function are in registers already. 467 MOVD runtime·cgoTraceback(SB), R6 468 MOVD $runtime·sigprofCallers(SB), R7 469 MOVD $runtime·sigprofNonGoWrapper<>(SB), R8 470 MOVD _cgo_callers(SB), R12 471 MOVD R12, CTR 472 MOVD R10, LR // restore LR 473 JMP (CTR) 474 #else 475 // function descriptor for the real sigtramp 476 TEXT runtime·cgoSigtramp(SB),NOSPLIT|NOFRAME,$0 477 DWORD $cgoSigtramp<>(SB) 478 DWORD $0 479 DWORD $0 480 TEXT cgoSigtramp<>(SB),NOSPLIT,$0 481 JMP sigtramp<>(SB) 482 #endif 483 484 TEXT runtime·sigprofNonGoWrapper<>(SB),NOSPLIT,$0 485 // We're coming from C code, set up essential register, then call sigprofNonGo. 486 CALL runtime·reginit(SB) 487 CALL runtime·sigprofNonGo(SB) 488 RET 489 490 TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0 491 MOVD addr+0(FP), R3 492 MOVD n+8(FP), R4 493 MOVW prot+16(FP), R5 494 MOVW flags+20(FP), R6 495 MOVW fd+24(FP), R7 496 MOVW off+28(FP), R8 497 498 SYSCALL $SYS_mmap 499 BVC ok 500 MOVD $0, p+32(FP) 501 MOVD R3, err+40(FP) 502 RET 503 ok: 504 MOVD R3, p+32(FP) 505 MOVD $0, err+40(FP) 506 RET 507 508 TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0 509 MOVD addr+0(FP), R3 510 MOVD n+8(FP), R4 511 SYSCALL $SYS_munmap 512 BVC 2(PC) 513 MOVD R0, 0xf0(R0) 514 RET 515 516 TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0 517 MOVD addr+0(FP), R3 518 MOVD n+8(FP), R4 519 MOVW flags+16(FP), R5 520 SYSCALL $SYS_madvise 521 MOVW R3, ret+24(FP) 522 RET 523 524 // int64 futex(int32 *uaddr, int32 op, int32 val, 525 // struct timespec *timeout, int32 *uaddr2, int32 val2); 526 TEXT runtime·futex(SB),NOSPLIT|NOFRAME,$0 527 MOVD addr+0(FP), R3 528 MOVW op+8(FP), R4 529 MOVW val+12(FP), R5 530 MOVD ts+16(FP), R6 531 MOVD addr2+24(FP), R7 532 MOVW val3+32(FP), R8 533 SYSCALL $SYS_futex 534 BVC 2(PC) 535 NEG R3 // caller expects negative errno 536 MOVW R3, ret+40(FP) 537 RET 538 539 // int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void)); 540 TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0 541 MOVW flags+0(FP), R3 542 MOVD stk+8(FP), R4 543 544 // Copy mp, gp, fn off parent stack for use by child. 545 // Careful: Linux system call clobbers ???. 546 MOVD mp+16(FP), R7 547 MOVD gp+24(FP), R8 548 MOVD fn+32(FP), R12 549 550 MOVD R7, -8(R4) 551 MOVD R8, -16(R4) 552 MOVD R12, -24(R4) 553 MOVD $1234, R7 554 MOVD R7, -32(R4) 555 556 SYSCALL $SYS_clone 557 BVC 2(PC) 558 NEG R3 // caller expects negative errno 559 560 // In parent, return. 561 CMP R3, $0 562 BEQ 3(PC) 563 MOVW R3, ret+40(FP) 564 RET 565 566 // In child, on new stack. 567 // initialize essential registers 568 BL runtime·reginit(SB) 569 MOVD -32(R1), R7 570 CMP R7, $1234 571 BEQ 2(PC) 572 MOVD R0, 0(R0) 573 574 // Initialize m->procid to Linux tid 575 SYSCALL $SYS_gettid 576 577 MOVD -24(R1), R12 // fn 578 MOVD -16(R1), R8 // g 579 MOVD -8(R1), R7 // m 580 581 CMP R7, $0 582 BEQ nog 583 CMP R8, $0 584 BEQ nog 585 586 MOVD R3, m_procid(R7) 587 588 // TODO: setup TLS. 589 590 // In child, set up new stack 591 MOVD R7, g_m(R8) 592 MOVD R8, g 593 //CALL runtime·stackcheck(SB) 594 595 nog: 596 // Call fn 597 MOVD R12, CTR 598 BL (CTR) 599 600 // It shouldn't return. If it does, exit that thread. 601 MOVW $111, R3 602 SYSCALL $SYS_exit 603 BR -2(PC) // keep exiting 604 605 TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0 606 MOVD new+0(FP), R3 607 MOVD old+8(FP), R4 608 SYSCALL $SYS_sigaltstack 609 BVC 2(PC) 610 MOVD R0, 0xf0(R0) // crash 611 RET 612 613 TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0 614 SYSCALL $SYS_sched_yield 615 RET 616 617 TEXT runtime·sched_getaffinity(SB),NOSPLIT|NOFRAME,$0 618 MOVD pid+0(FP), R3 619 MOVD len+8(FP), R4 620 MOVD buf+16(FP), R5 621 SYSCALL $SYS_sched_getaffinity 622 BVC 2(PC) 623 NEG R3 // caller expects negative errno 624 MOVW R3, ret+24(FP) 625 RET 626 627 // int32 runtime·epollcreate(int32 size); 628 TEXT runtime·epollcreate(SB),NOSPLIT|NOFRAME,$0 629 MOVW size+0(FP), R3 630 SYSCALL $SYS_epoll_create 631 BVC 2(PC) 632 NEG R3 // caller expects negative errno 633 MOVW R3, ret+8(FP) 634 RET 635 636 // int32 runtime·epollcreate1(int32 flags); 637 TEXT runtime·epollcreate1(SB),NOSPLIT|NOFRAME,$0 638 MOVW flags+0(FP), R3 639 SYSCALL $SYS_epoll_create1 640 BVC 2(PC) 641 NEG R3 // caller expects negative errno 642 MOVW R3, ret+8(FP) 643 RET 644 645 // func epollctl(epfd, op, fd int32, ev *epollEvent) int 646 TEXT runtime·epollctl(SB),NOSPLIT|NOFRAME,$0 647 MOVW epfd+0(FP), R3 648 MOVW op+4(FP), R4 649 MOVW fd+8(FP), R5 650 MOVD ev+16(FP), R6 651 SYSCALL $SYS_epoll_ctl 652 NEG R3 // caller expects negative errno 653 MOVW R3, ret+24(FP) 654 RET 655 656 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout); 657 TEXT runtime·epollwait(SB),NOSPLIT|NOFRAME,$0 658 MOVW epfd+0(FP), R3 659 MOVD ev+8(FP), R4 660 MOVW nev+16(FP), R5 661 MOVW timeout+20(FP), R6 662 SYSCALL $SYS_epoll_wait 663 BVC 2(PC) 664 NEG R3 // caller expects negative errno 665 MOVW R3, ret+24(FP) 666 RET 667 668 // void runtime·closeonexec(int32 fd); 669 TEXT runtime·closeonexec(SB),NOSPLIT|NOFRAME,$0 670 MOVW fd+0(FP), R3 // fd 671 MOVD $2, R4 // F_SETFD 672 MOVD $1, R5 // FD_CLOEXEC 673 SYSCALL $SYS_fcntl 674 RET 675 676 // func runtime·setNonblock(int32 fd) 677 TEXT runtime·setNonblock(SB),NOSPLIT|NOFRAME,$0-4 678 MOVW fd+0(FP), R3 // fd 679 MOVD $3, R4 // F_GETFL 680 MOVD $0, R5 681 SYSCALL $SYS_fcntl 682 OR $0x800, R3, R5 // O_NONBLOCK 683 MOVW fd+0(FP), R3 // fd 684 MOVD $4, R4 // F_SETFL 685 SYSCALL $SYS_fcntl 686 RET 687 688 // func sbrk0() uintptr 689 TEXT runtime·sbrk0(SB),NOSPLIT|NOFRAME,$0 690 // Implemented as brk(NULL). 691 MOVD $0, R3 692 SYSCALL $SYS_brk 693 MOVD R3, ret+0(FP) 694 RET 695 696 TEXT runtime·access(SB),$0-20 697 MOVD R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go 698 MOVW R0, ret+16(FP) // for vet 699 RET 700 701 TEXT runtime·connect(SB),$0-28 702 MOVD R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go 703 MOVW R0, ret+24(FP) // for vet 704 RET 705 706 TEXT runtime·socket(SB),$0-20 707 MOVD R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go 708 MOVW R0, ret+16(FP) // for vet 709 RET