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 arm, Linux 7// 8 9#include "go_asm.h" 10#include "go_tls.h" 11#include "textflag.h" 12 13#define CLOCK_REALTIME 0 14#define CLOCK_MONOTONIC 1 15 16// for EABI, as we don't support OABI 17#define SYS_BASE 0x0 18 19#define SYS_exit (SYS_BASE + 1) 20#define SYS_read (SYS_BASE + 3) 21#define SYS_write (SYS_BASE + 4) 22#define SYS_open (SYS_BASE + 5) 23#define SYS_close (SYS_BASE + 6) 24#define SYS_getpid (SYS_BASE + 20) 25#define SYS_kill (SYS_BASE + 37) 26#define SYS_pipe (SYS_BASE + 42) 27#define SYS_clone (SYS_BASE + 120) 28#define SYS_rt_sigreturn (SYS_BASE + 173) 29#define SYS_rt_sigaction (SYS_BASE + 174) 30#define SYS_rt_sigprocmask (SYS_BASE + 175) 31#define SYS_sigaltstack (SYS_BASE + 186) 32#define SYS_mmap2 (SYS_BASE + 192) 33#define SYS_futex (SYS_BASE + 240) 34#define SYS_exit_group (SYS_BASE + 248) 35#define SYS_munmap (SYS_BASE + 91) 36#define SYS_madvise (SYS_BASE + 220) 37#define SYS_setitimer (SYS_BASE + 104) 38#define SYS_mincore (SYS_BASE + 219) 39#define SYS_gettid (SYS_BASE + 224) 40#define SYS_tgkill (SYS_BASE + 268) 41#define SYS_sched_yield (SYS_BASE + 158) 42#define SYS_nanosleep (SYS_BASE + 162) 43#define SYS_sched_getaffinity (SYS_BASE + 242) 44#define SYS_clock_gettime (SYS_BASE + 263) 45#define SYS_epoll_create (SYS_BASE + 250) 46#define SYS_epoll_ctl (SYS_BASE + 251) 47#define SYS_epoll_wait (SYS_BASE + 252) 48#define SYS_epoll_create1 (SYS_BASE + 357) 49#define SYS_pipe2 (SYS_BASE + 359) 50#define SYS_fcntl (SYS_BASE + 55) 51#define SYS_access (SYS_BASE + 33) 52#define SYS_connect (SYS_BASE + 283) 53#define SYS_socket (SYS_BASE + 281) 54#define SYS_brk (SYS_BASE + 45) 55 56#define ARM_BASE (SYS_BASE + 0x0f0000) 57 58TEXT runtime·open(SB),NOSPLIT,$0 59 MOVW name+0(FP), R0 60 MOVW mode+4(FP), R1 61 MOVW perm+8(FP), R2 62 MOVW $SYS_open, R7 63 SWI $0 64 MOVW $0xfffff001, R1 65 CMP R1, R0 66 MOVW.HI $-1, R0 67 MOVW R0, ret+12(FP) 68 RET 69 70TEXT runtime·closefd(SB),NOSPLIT,$0 71 MOVW fd+0(FP), R0 72 MOVW $SYS_close, R7 73 SWI $0 74 MOVW $0xfffff001, R1 75 CMP R1, R0 76 MOVW.HI $-1, R0 77 MOVW R0, ret+4(FP) 78 RET 79 80TEXT runtime·write1(SB),NOSPLIT,$0 81 MOVW fd+0(FP), R0 82 MOVW p+4(FP), R1 83 MOVW n+8(FP), R2 84 MOVW $SYS_write, R7 85 SWI $0 86 MOVW R0, ret+12(FP) 87 RET 88 89TEXT runtime·read(SB),NOSPLIT,$0 90 MOVW fd+0(FP), R0 91 MOVW p+4(FP), R1 92 MOVW n+8(FP), R2 93 MOVW $SYS_read, R7 94 SWI $0 95 MOVW R0, ret+12(FP) 96 RET 97 98// func pipe() (r, w int32, errno int32) 99TEXT runtime·pipe(SB),NOSPLIT,$0-12 100 MOVW $r+0(FP), R0 101 MOVW $SYS_pipe, R7 102 SWI $0 103 MOVW R0, errno+8(FP) 104 RET 105 106// func pipe2(flags int32) (r, w int32, errno int32) 107TEXT runtime·pipe2(SB),NOSPLIT,$0-16 108 MOVW $r+4(FP), R0 109 MOVW flags+0(FP), R1 110 MOVW $SYS_pipe2, R7 111 SWI $0 112 MOVW R0, errno+12(FP) 113 RET 114 115TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0 116 MOVW code+0(FP), R0 117 MOVW $SYS_exit_group, R7 118 SWI $0 119 MOVW $1234, R0 120 MOVW $1002, R1 121 MOVW R0, (R1) // fail hard 122 123TEXT exit1<>(SB),NOSPLIT|NOFRAME,$0 124 MOVW code+0(FP), R0 125 MOVW $SYS_exit, R7 126 SWI $0 127 MOVW $1234, R0 128 MOVW $1003, R1 129 MOVW R0, (R1) // fail hard 130 131// func exitThread(wait *uint32) 132TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-4 133 MOVW wait+0(FP), R0 134 // We're done using the stack. 135 // Alas, there's no reliable way to make this write atomic 136 // without potentially using the stack. So it goes. 137 MOVW $0, R1 138 MOVW R1, (R0) 139 MOVW $0, R0 // exit code 140 MOVW $SYS_exit, R7 141 SWI $0 142 MOVW $1234, R0 143 MOVW $1004, R1 144 MOVW R0, (R1) // fail hard 145 JMP 0(PC) 146 147TEXT runtime·gettid(SB),NOSPLIT,$0-4 148 MOVW $SYS_gettid, R7 149 SWI $0 150 MOVW R0, ret+0(FP) 151 RET 152 153TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0 154 MOVW $SYS_getpid, R7 155 SWI $0 156 MOVW R0, R4 157 MOVW $SYS_gettid, R7 158 SWI $0 159 MOVW R0, R1 // arg 2 tid 160 MOVW R4, R0 // arg 1 pid 161 MOVW sig+0(FP), R2 // arg 3 162 MOVW $SYS_tgkill, R7 163 SWI $0 164 RET 165 166TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0 167 MOVW $SYS_getpid, R7 168 SWI $0 169 // arg 1 tid already in R0 from getpid 170 MOVW sig+0(FP), R1 // arg 2 - signal 171 MOVW $SYS_kill, R7 172 SWI $0 173 RET 174 175TEXT ·getpid(SB),NOSPLIT,$0-4 176 MOVW $SYS_getpid, R7 177 SWI $0 178 MOVW R0, ret+0(FP) 179 RET 180 181TEXT ·tgkill(SB),NOSPLIT,$0-12 182 MOVW tgid+0(FP), R0 183 MOVW tid+4(FP), R1 184 MOVW sig+8(FP), R2 185 MOVW $SYS_tgkill, R7 186 SWI $0 187 RET 188 189TEXT runtime·mmap(SB),NOSPLIT,$0 190 MOVW addr+0(FP), R0 191 MOVW n+4(FP), R1 192 MOVW prot+8(FP), R2 193 MOVW flags+12(FP), R3 194 MOVW fd+16(FP), R4 195 MOVW off+20(FP), R5 196 MOVW $SYS_mmap2, R7 197 SWI $0 198 MOVW $0xfffff001, R6 199 CMP R6, R0 200 MOVW $0, R1 201 RSB.HI $0, R0 202 MOVW.HI R0, R1 // if error, put in R1 203 MOVW.HI $0, R0 204 MOVW R0, p+24(FP) 205 MOVW R1, err+28(FP) 206 RET 207 208TEXT runtime·munmap(SB),NOSPLIT,$0 209 MOVW addr+0(FP), R0 210 MOVW n+4(FP), R1 211 MOVW $SYS_munmap, R7 212 SWI $0 213 MOVW $0xfffff001, R6 214 CMP R6, R0 215 MOVW.HI $0, R8 // crash on syscall failure 216 MOVW.HI R8, (R8) 217 RET 218 219TEXT runtime·madvise(SB),NOSPLIT,$0 220 MOVW addr+0(FP), R0 221 MOVW n+4(FP), R1 222 MOVW flags+8(FP), R2 223 MOVW $SYS_madvise, R7 224 SWI $0 225 MOVW R0, ret+12(FP) 226 RET 227 228TEXT runtime·setitimer(SB),NOSPLIT,$0 229 MOVW mode+0(FP), R0 230 MOVW new+4(FP), R1 231 MOVW old+8(FP), R2 232 MOVW $SYS_setitimer, R7 233 SWI $0 234 RET 235 236TEXT runtime·mincore(SB),NOSPLIT,$0 237 MOVW addr+0(FP), R0 238 MOVW n+4(FP), R1 239 MOVW dst+8(FP), R2 240 MOVW $SYS_mincore, R7 241 SWI $0 242 MOVW R0, ret+12(FP) 243 RET 244 245TEXT runtime·walltime1(SB),NOSPLIT,$0-12 246 // We don't know how much stack space the VDSO code will need, 247 // so switch to g0. 248 249 // Save old SP. Use R13 instead of SP to avoid linker rewriting the offsets. 250 MOVW R13, R4 // R4 is unchanged by C code. 251 252 MOVW g_m(g), R5 // R5 is unchanged by C code. 253 254 // Set vdsoPC and vdsoSP for SIGPROF traceback. 255 MOVW LR, m_vdsoPC(R5) 256 MOVW R13, m_vdsoSP(R5) 257 258 MOVW m_curg(R5), R0 259 260 CMP g, R0 // Only switch if on curg. 261 B.NE noswitch 262 263 MOVW m_g0(R5), R0 264 MOVW (g_sched+gobuf_sp)(R0), R13 // Set SP to g0 stack 265 266noswitch: 267 SUB $24, R13 // Space for results 268 BIC $0x7, R13 // Align for C code 269 270 MOVW $CLOCK_REALTIME, R0 271 MOVW $8(R13), R1 // timespec 272 MOVW runtime·vdsoClockgettimeSym(SB), R2 273 CMP $0, R2 274 B.EQ fallback 275 276 // Store g on gsignal's stack, so if we receive a signal 277 // during VDSO code we can find the g. 278 // If we don't have a signal stack, we won't receive signal, 279 // so don't bother saving g. 280 // When using cgo, we already saved g on TLS, also don't save 281 // g here. 282 // Also don't save g if we are already on the signal stack. 283 // We won't get a nested signal. 284 MOVB runtime·iscgo(SB), R6 285 CMP $0, R6 286 BNE nosaveg 287 MOVW m_gsignal(R5), R6 // g.m.gsignal 288 CMP $0, R6 289 BEQ nosaveg 290 CMP g, R6 291 BEQ nosaveg 292 MOVW (g_stack+stack_lo)(R6), R6 // g.m.gsignal.stack.lo 293 MOVW g, (R6) 294 295 BL (R2) 296 297 MOVW $0, R1 298 MOVW R1, (R6) // clear g slot, R6 is unchanged by C code 299 300 JMP finish 301 302nosaveg: 303 BL (R2) 304 JMP finish 305 306fallback: 307 MOVW $SYS_clock_gettime, R7 308 SWI $0 309 310finish: 311 MOVW 8(R13), R0 // sec 312 MOVW 12(R13), R2 // nsec 313 314 MOVW R4, R13 // Restore real SP 315 MOVW $0, R1 316 MOVW R1, m_vdsoSP(R5) 317 318 MOVW R0, sec_lo+0(FP) 319 MOVW R1, sec_hi+4(FP) 320 MOVW R2, nsec+8(FP) 321 RET 322 323// int64 nanotime1(void) 324TEXT runtime·nanotime1(SB),NOSPLIT,$0-8 325 // Switch to g0 stack. See comment above in runtime·walltime. 326 327 // Save old SP. Use R13 instead of SP to avoid linker rewriting the offsets. 328 MOVW R13, R4 // R4 is unchanged by C code. 329 330 MOVW g_m(g), R5 // R5 is unchanged by C code. 331 332 // Set vdsoPC and vdsoSP for SIGPROF traceback. 333 MOVW LR, m_vdsoPC(R5) 334 MOVW R13, m_vdsoSP(R5) 335 336 MOVW m_curg(R5), R0 337 338 CMP g, R0 // Only switch if on curg. 339 B.NE noswitch 340 341 MOVW m_g0(R5), R0 342 MOVW (g_sched+gobuf_sp)(R0), R13 // Set SP to g0 stack 343 344noswitch: 345 SUB $24, R13 // Space for results 346 BIC $0x7, R13 // Align for C code 347 348 MOVW $CLOCK_MONOTONIC, R0 349 MOVW $8(R13), R1 // timespec 350 MOVW runtime·vdsoClockgettimeSym(SB), R2 351 CMP $0, R2 352 B.EQ fallback 353 354 // Store g on gsignal's stack, so if we receive a signal 355 // during VDSO code we can find the g. 356 // If we don't have a signal stack, we won't receive signal, 357 // so don't bother saving g. 358 // When using cgo, we already saved g on TLS, also don't save 359 // g here. 360 // Also don't save g if we are already on the signal stack. 361 // We won't get a nested signal. 362 MOVB runtime·iscgo(SB), R6 363 CMP $0, R6 364 BNE nosaveg 365 MOVW m_gsignal(R5), R6 // g.m.gsignal 366 CMP $0, R6 367 BEQ nosaveg 368 CMP g, R6 369 BEQ nosaveg 370 MOVW (g_stack+stack_lo)(R6), R6 // g.m.gsignal.stack.lo 371 MOVW g, (R6) 372 373 BL (R2) 374 375 MOVW $0, R1 376 MOVW R1, (R6) // clear g slot, R6 is unchanged by C code 377 378 JMP finish 379 380nosaveg: 381 BL (R2) 382 JMP finish 383 384fallback: 385 MOVW $SYS_clock_gettime, R7 386 SWI $0 387 388finish: 389 MOVW 8(R13), R0 // sec 390 MOVW 12(R13), R2 // nsec 391 392 MOVW R4, R13 // Restore real SP 393 MOVW $0, R4 394 MOVW R4, m_vdsoSP(R5) 395 396 MOVW $1000000000, R3 397 MULLU R0, R3, (R1, R0) 398 ADD.S R2, R0 399 ADC R4, R1 400 401 MOVW R0, ret_lo+0(FP) 402 MOVW R1, ret_hi+4(FP) 403 RET 404 405// int32 futex(int32 *uaddr, int32 op, int32 val, 406// struct timespec *timeout, int32 *uaddr2, int32 val2); 407TEXT runtime·futex(SB),NOSPLIT,$0 408 MOVW addr+0(FP), R0 409 MOVW op+4(FP), R1 410 MOVW val+8(FP), R2 411 MOVW ts+12(FP), R3 412 MOVW addr2+16(FP), R4 413 MOVW val3+20(FP), R5 414 MOVW $SYS_futex, R7 415 SWI $0 416 MOVW R0, ret+24(FP) 417 RET 418 419// int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void)); 420TEXT runtime·clone(SB),NOSPLIT,$0 421 MOVW flags+0(FP), R0 422 MOVW stk+4(FP), R1 423 MOVW $0, R2 // parent tid ptr 424 MOVW $0, R3 // tls_val 425 MOVW $0, R4 // child tid ptr 426 MOVW $0, R5 427 428 // Copy mp, gp, fn off parent stack for use by child. 429 MOVW $-16(R1), R1 430 MOVW mp+8(FP), R6 431 MOVW R6, 0(R1) 432 MOVW gp+12(FP), R6 433 MOVW R6, 4(R1) 434 MOVW fn+16(FP), R6 435 MOVW R6, 8(R1) 436 MOVW $1234, R6 437 MOVW R6, 12(R1) 438 439 MOVW $SYS_clone, R7 440 SWI $0 441 442 // In parent, return. 443 CMP $0, R0 444 BEQ 3(PC) 445 MOVW R0, ret+20(FP) 446 RET 447 448 // Paranoia: check that SP is as we expect. Use R13 to avoid linker 'fixup' 449 NOP R13 // tell vet SP/R13 changed - stop checking offsets 450 MOVW 12(R13), R0 451 MOVW $1234, R1 452 CMP R0, R1 453 BEQ 2(PC) 454 BL runtime·abort(SB) 455 456 MOVW 0(R13), R8 // m 457 MOVW 4(R13), R0 // g 458 459 CMP $0, R8 460 BEQ nog 461 CMP $0, R0 462 BEQ nog 463 464 MOVW R0, g 465 MOVW R8, g_m(g) 466 467 // paranoia; check they are not nil 468 MOVW 0(R8), R0 469 MOVW 0(g), R0 470 471 BL runtime·emptyfunc(SB) // fault if stack check is wrong 472 473 // Initialize m->procid to Linux tid 474 MOVW $SYS_gettid, R7 475 SWI $0 476 MOVW g_m(g), R8 477 MOVW R0, m_procid(R8) 478 479nog: 480 // Call fn 481 MOVW 8(R13), R0 482 MOVW $16(R13), R13 483 BL (R0) 484 485 // It shouldn't return. If it does, exit that thread. 486 SUB $16, R13 // restore the stack pointer to avoid memory corruption 487 MOVW $0, R0 488 MOVW R0, 4(R13) 489 BL exit1<>(SB) 490 491 MOVW $1234, R0 492 MOVW $1005, R1 493 MOVW R0, (R1) 494 495TEXT runtime·sigaltstack(SB),NOSPLIT,$0 496 MOVW new+0(FP), R0 497 MOVW old+4(FP), R1 498 MOVW $SYS_sigaltstack, R7 499 SWI $0 500 MOVW $0xfffff001, R6 501 CMP R6, R0 502 MOVW.HI $0, R8 // crash on syscall failure 503 MOVW.HI R8, (R8) 504 RET 505 506TEXT runtime·sigfwd(SB),NOSPLIT,$0-16 507 MOVW sig+4(FP), R0 508 MOVW info+8(FP), R1 509 MOVW ctx+12(FP), R2 510 MOVW fn+0(FP), R11 511 MOVW R13, R4 512 SUB $24, R13 513 BIC $0x7, R13 // alignment for ELF ABI 514 BL (R11) 515 MOVW R4, R13 516 RET 517 518TEXT runtime·sigtramp(SB),NOSPLIT,$0 519 // Reserve space for callee-save registers and arguments. 520 MOVM.DB.W [R4-R11], (R13) 521 SUB $16, R13 522 523 // this might be called in external code context, 524 // where g is not set. 525 // first save R0, because runtime·load_g will clobber it 526 MOVW R0, 4(R13) 527 MOVB runtime·iscgo(SB), R0 528 CMP $0, R0 529 BL.NE runtime·load_g(SB) 530 531 MOVW R1, 8(R13) 532 MOVW R2, 12(R13) 533 MOVW $runtime·sigtrampgo(SB), R11 534 BL (R11) 535 536 // Restore callee-save registers. 537 ADD $16, R13 538 MOVM.IA.W (R13), [R4-R11] 539 540 RET 541 542TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0 543 MOVW $runtime·sigtramp(SB), R11 544 B (R11) 545 546TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0 547 MOVW how+0(FP), R0 548 MOVW new+4(FP), R1 549 MOVW old+8(FP), R2 550 MOVW size+12(FP), R3 551 MOVW $SYS_rt_sigprocmask, R7 552 SWI $0 553 RET 554 555TEXT runtime·rt_sigaction(SB),NOSPLIT,$0 556 MOVW sig+0(FP), R0 557 MOVW new+4(FP), R1 558 MOVW old+8(FP), R2 559 MOVW size+12(FP), R3 560 MOVW $SYS_rt_sigaction, R7 561 SWI $0 562 MOVW R0, ret+16(FP) 563 RET 564 565TEXT runtime·usleep(SB),NOSPLIT,$12 566 MOVW usec+0(FP), R0 567 CALL runtime·usplitR0(SB) 568 MOVW R0, 4(R13) 569 MOVW $1000, R0 // usec to nsec 570 MUL R0, R1 571 MOVW R1, 8(R13) 572 MOVW $4(R13), R0 573 MOVW $0, R1 574 MOVW $SYS_nanosleep, R7 575 SWI $0 576 RET 577 578// As for cas, memory barriers are complicated on ARM, but the kernel 579// provides a user helper. ARMv5 does not support SMP and has no 580// memory barrier instruction at all. ARMv6 added SMP support and has 581// a memory barrier, but it requires writing to a coprocessor 582// register. ARMv7 introduced the DMB instruction, but it's expensive 583// even on single-core devices. The kernel helper takes care of all of 584// this for us. 585 586TEXT kernelPublicationBarrier<>(SB),NOSPLIT,$0 587 // void __kuser_memory_barrier(void); 588 MOVW $0xffff0fa0, R11 589 CALL (R11) 590 RET 591 592TEXT ·publicationBarrier(SB),NOSPLIT,$0 593 MOVB ·goarm(SB), R11 594 CMP $7, R11 595 BLT 2(PC) 596 JMP ·armPublicationBarrier(SB) 597 JMP kernelPublicationBarrier<>(SB) // extra layer so this function is leaf and no SP adjustment on GOARM=7 598 599TEXT runtime·osyield(SB),NOSPLIT,$0 600 MOVW $SYS_sched_yield, R7 601 SWI $0 602 RET 603 604TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0 605 MOVW pid+0(FP), R0 606 MOVW len+4(FP), R1 607 MOVW buf+8(FP), R2 608 MOVW $SYS_sched_getaffinity, R7 609 SWI $0 610 MOVW R0, ret+12(FP) 611 RET 612 613// int32 runtime·epollcreate(int32 size) 614TEXT runtime·epollcreate(SB),NOSPLIT,$0 615 MOVW size+0(FP), R0 616 MOVW $SYS_epoll_create, R7 617 SWI $0 618 MOVW R0, ret+4(FP) 619 RET 620 621// int32 runtime·epollcreate1(int32 flags) 622TEXT runtime·epollcreate1(SB),NOSPLIT,$0 623 MOVW flags+0(FP), R0 624 MOVW $SYS_epoll_create1, R7 625 SWI $0 626 MOVW R0, ret+4(FP) 627 RET 628 629// func epollctl(epfd, op, fd int32, ev *epollEvent) int 630TEXT runtime·epollctl(SB),NOSPLIT,$0 631 MOVW epfd+0(FP), R0 632 MOVW op+4(FP), R1 633 MOVW fd+8(FP), R2 634 MOVW ev+12(FP), R3 635 MOVW $SYS_epoll_ctl, R7 636 SWI $0 637 MOVW R0, ret+16(FP) 638 RET 639 640// int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout) 641TEXT runtime·epollwait(SB),NOSPLIT,$0 642 MOVW epfd+0(FP), R0 643 MOVW ev+4(FP), R1 644 MOVW nev+8(FP), R2 645 MOVW timeout+12(FP), R3 646 MOVW $SYS_epoll_wait, R7 647 SWI $0 648 MOVW R0, ret+16(FP) 649 RET 650 651// void runtime·closeonexec(int32 fd) 652TEXT runtime·closeonexec(SB),NOSPLIT,$0 653 MOVW fd+0(FP), R0 // fd 654 MOVW $2, R1 // F_SETFD 655 MOVW $1, R2 // FD_CLOEXEC 656 MOVW $SYS_fcntl, R7 657 SWI $0 658 RET 659 660// func runtime·setNonblock(fd int32) 661TEXT runtime·setNonblock(SB),NOSPLIT,$0-4 662 MOVW fd+0(FP), R0 // fd 663 MOVW $3, R1 // F_GETFL 664 MOVW $0, R2 665 MOVW $SYS_fcntl, R7 666 SWI $0 667 ORR $0x800, R0, R2 // O_NONBLOCK 668 MOVW fd+0(FP), R0 // fd 669 MOVW $4, R1 // F_SETFL 670 MOVW $SYS_fcntl, R7 671 SWI $0 672 RET 673 674// b __kuser_get_tls @ 0xffff0fe0 675TEXT runtime·read_tls_fallback(SB),NOSPLIT|NOFRAME,$0 676 MOVW $0xffff0fe0, R0 677 B (R0) 678 679TEXT runtime·access(SB),NOSPLIT,$0 680 MOVW name+0(FP), R0 681 MOVW mode+4(FP), R1 682 MOVW $SYS_access, R7 683 SWI $0 684 MOVW R0, ret+8(FP) 685 RET 686 687TEXT runtime·connect(SB),NOSPLIT,$0 688 MOVW fd+0(FP), R0 689 MOVW addr+4(FP), R1 690 MOVW len+8(FP), R2 691 MOVW $SYS_connect, R7 692 SWI $0 693 MOVW R0, ret+12(FP) 694 RET 695 696TEXT runtime·socket(SB),NOSPLIT,$0 697 MOVW domain+0(FP), R0 698 MOVW typ+4(FP), R1 699 MOVW prot+8(FP), R2 700 MOVW $SYS_socket, R7 701 SWI $0 702 MOVW R0, ret+12(FP) 703 RET 704 705// func sbrk0() uintptr 706TEXT runtime·sbrk0(SB),NOSPLIT,$0-4 707 // Implemented as brk(NULL). 708 MOVW $0, R0 709 MOVW $SYS_brk, R7 710 SWI $0 711 MOVW R0, ret+0(FP) 712 RET 713 714TEXT runtime·sigreturn(SB),NOSPLIT,$0-0 715 RET 716