github.com/rafaeltorres324/go/src@v0.0.0-20210519164414-9fdf653a9838/runtime/sys_openbsd_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 // System calls and other sys.stuff for AMD64, OpenBSD. 6 // System calls are implemented in libc/libpthread, this file 7 // contains trampolines that convert from Go to C calling convention. 8 // Some direct system call implementations currently remain. 9 // 10 11 #include "go_asm.h" 12 #include "go_tls.h" 13 #include "textflag.h" 14 15 #define CLOCK_MONOTONIC $3 16 17 TEXT runtime·settls(SB),NOSPLIT,$0 18 // Nothing to do, pthread already set thread-local storage up. 19 RET 20 21 // mstart_stub is the first function executed on a new thread started by pthread_create. 22 // It just does some low-level setup and then calls mstart. 23 // Note: called with the C calling convention. 24 TEXT runtime·mstart_stub(SB),NOSPLIT,$0 25 // DI points to the m. 26 // We are already on m's g0 stack. 27 28 // Save callee-save registers. 29 SUBQ $48, SP 30 MOVQ BX, 0(SP) 31 MOVQ BP, 8(SP) 32 MOVQ R12, 16(SP) 33 MOVQ R13, 24(SP) 34 MOVQ R14, 32(SP) 35 MOVQ R15, 40(SP) 36 37 // Load g and save to TLS entry. 38 // See cmd/link/internal/ld/sym.go:computeTLSOffset. 39 MOVQ m_g0(DI), DX // g 40 MOVQ DX, -8(FS) 41 42 // Someday the convention will be D is always cleared. 43 CLD 44 45 CALL runtime·mstart(SB) 46 47 // Restore callee-save registers. 48 MOVQ 0(SP), BX 49 MOVQ 8(SP), BP 50 MOVQ 16(SP), R12 51 MOVQ 24(SP), R13 52 MOVQ 32(SP), R14 53 MOVQ 40(SP), R15 54 55 // Go is all done with this OS thread. 56 // Tell pthread everything is ok (we never join with this thread, so 57 // the value here doesn't really matter). 58 XORL AX, AX 59 60 ADDQ $48, SP 61 RET 62 63 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 64 MOVQ fn+0(FP), AX 65 MOVL sig+8(FP), DI 66 MOVQ info+16(FP), SI 67 MOVQ ctx+24(FP), DX 68 PUSHQ BP 69 MOVQ SP, BP 70 ANDQ $~15, SP // alignment for x86_64 ABI 71 CALL AX 72 MOVQ BP, SP 73 POPQ BP 74 RET 75 76 TEXT runtime·sigtramp(SB),NOSPLIT,$72 77 // Save callee-saved C registers, since the caller may be a C signal handler. 78 MOVQ BX, bx-8(SP) 79 MOVQ BP, bp-16(SP) // save in case GOEXPERIMENT=noframepointer is set 80 MOVQ R12, r12-24(SP) 81 MOVQ R13, r13-32(SP) 82 MOVQ R14, r14-40(SP) 83 MOVQ R15, r15-48(SP) 84 // We don't save mxcsr or the x87 control word because sigtrampgo doesn't 85 // modify them. 86 87 MOVQ DX, ctx-56(SP) 88 MOVQ SI, info-64(SP) 89 MOVQ DI, signum-72(SP) 90 CALL runtime·sigtrampgo(SB) 91 92 MOVQ r15-48(SP), R15 93 MOVQ r14-40(SP), R14 94 MOVQ r13-32(SP), R13 95 MOVQ r12-24(SP), R12 96 MOVQ bp-16(SP), BP 97 MOVQ bx-8(SP), BX 98 RET 99 100 // 101 // These trampolines help convert from Go calling convention to C calling convention. 102 // They should be called with asmcgocall. 103 // A pointer to the arguments is passed in DI. 104 // A single int32 result is returned in AX. 105 // (For more results, make an args/results structure.) 106 TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0 107 PUSHQ BP 108 MOVQ SP, BP 109 MOVQ 0(DI), DI // arg 1 - attr 110 CALL libc_pthread_attr_init(SB) 111 POPQ BP 112 RET 113 114 TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0 115 PUSHQ BP 116 MOVQ SP, BP 117 MOVQ 0(DI), DI // arg 1 - attr 118 CALL libc_pthread_attr_destroy(SB) 119 POPQ BP 120 RET 121 122 TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0 123 PUSHQ BP 124 MOVQ SP, BP 125 MOVQ 8(DI), SI // arg 2 - stacksize 126 MOVQ 0(DI), DI // arg 1 - attr 127 CALL libc_pthread_attr_getstacksize(SB) 128 POPQ BP 129 RET 130 131 TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0 132 PUSHQ BP 133 MOVQ SP, BP 134 MOVQ 8(DI), SI // arg 2 - detachstate 135 MOVQ 0(DI), DI // arg 1 - attr 136 CALL libc_pthread_attr_setdetachstate(SB) 137 POPQ BP 138 RET 139 140 TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0 141 PUSHQ BP 142 MOVQ SP, BP 143 SUBQ $16, SP 144 MOVQ 0(DI), SI // arg 2 - attr 145 MOVQ 8(DI), DX // arg 3 - start 146 MOVQ 16(DI), CX // arg 4 - arg 147 MOVQ SP, DI // arg 1 - &thread (discarded) 148 CALL libc_pthread_create(SB) 149 MOVQ BP, SP 150 POPQ BP 151 RET 152 153 TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0 154 PUSHQ BP 155 MOVQ SP, BP 156 MOVL 8(DI), SI // arg 2 - signal 157 MOVQ $0, DX // arg 3 - tcb 158 MOVL 0(DI), DI // arg 1 - tid 159 CALL libc_thrkill(SB) 160 POPQ BP 161 RET 162 163 TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0 164 PUSHQ BP 165 MOVQ SP, BP 166 MOVL 8(DI), SI // arg 2 - clock_id 167 MOVQ 16(DI), DX // arg 3 - abstime 168 MOVQ 24(DI), CX // arg 4 - lock 169 MOVQ 32(DI), R8 // arg 5 - abort 170 MOVQ 0(DI), DI // arg 1 - id 171 CALL libc_thrsleep(SB) 172 POPQ BP 173 RET 174 175 TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0 176 PUSHQ BP 177 MOVQ SP, BP 178 MOVL 8(DI), SI // arg 2 - count 179 MOVQ 0(DI), DI // arg 1 - id 180 CALL libc_thrwakeup(SB) 181 POPQ BP 182 RET 183 184 TEXT runtime·exit_trampoline(SB),NOSPLIT,$0 185 PUSHQ BP 186 MOVQ SP, BP 187 MOVL 0(DI), DI // arg 1 exit status 188 CALL libc_exit(SB) 189 MOVL $0xf1, 0xf1 // crash 190 POPQ BP 191 RET 192 193 TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0 194 PUSHQ BP 195 MOVQ SP, BP 196 MOVQ DI, BX // BX is caller-save 197 CALL libc_getthrid(SB) 198 MOVL AX, 0(BX) // return value 199 POPQ BP 200 RET 201 202 TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0 203 PUSHQ BP 204 MOVQ SP, BP 205 MOVL 0(DI), BX // signal 206 CALL libc_getpid(SB) 207 MOVL AX, DI // arg 1 pid 208 MOVL BX, SI // arg 2 signal 209 CALL libc_kill(SB) 210 POPQ BP 211 RET 212 213 TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0 214 PUSHQ BP 215 MOVQ SP, BP 216 CALL libc_sched_yield(SB) 217 POPQ BP 218 RET 219 220 TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0 221 PUSHQ BP // make a frame; keep stack aligned 222 MOVQ SP, BP 223 MOVQ DI, BX 224 MOVQ 0(BX), DI // arg 1 addr 225 MOVQ 8(BX), SI // arg 2 len 226 MOVL 16(BX), DX // arg 3 prot 227 MOVL 20(BX), CX // arg 4 flags 228 MOVL 24(BX), R8 // arg 5 fid 229 MOVL 28(BX), R9 // arg 6 offset 230 CALL libc_mmap(SB) 231 XORL DX, DX 232 CMPQ AX, $-1 233 JNE ok 234 CALL libc_errno(SB) 235 MOVLQSX (AX), DX // errno 236 XORQ AX, AX 237 ok: 238 MOVQ AX, 32(BX) 239 MOVQ DX, 40(BX) 240 POPQ BP 241 RET 242 243 TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0 244 PUSHQ BP 245 MOVQ SP, BP 246 MOVQ 8(DI), SI // arg 2 len 247 MOVQ 0(DI), DI // arg 1 addr 248 CALL libc_munmap(SB) 249 TESTQ AX, AX 250 JEQ 2(PC) 251 MOVL $0xf1, 0xf1 // crash 252 POPQ BP 253 RET 254 255 TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0 256 PUSHQ BP 257 MOVQ SP, BP 258 MOVQ 8(DI), SI // arg 2 len 259 MOVL 16(DI), DX // arg 3 advice 260 MOVQ 0(DI), DI // arg 1 addr 261 CALL libc_madvise(SB) 262 // ignore failure - maybe pages are locked 263 POPQ BP 264 RET 265 266 TEXT runtime·open_trampoline(SB),NOSPLIT,$0 267 PUSHQ BP 268 MOVQ SP, BP 269 MOVL 8(DI), SI // arg 2 - flags 270 MOVL 12(DI), DX // arg 3 - mode 271 MOVQ 0(DI), DI // arg 1 - path 272 XORL AX, AX // vararg: say "no float args" 273 CALL libc_open(SB) 274 POPQ BP 275 RET 276 277 TEXT runtime·close_trampoline(SB),NOSPLIT,$0 278 PUSHQ BP 279 MOVQ SP, BP 280 MOVL 0(DI), DI // arg 1 - fd 281 CALL libc_close(SB) 282 POPQ BP 283 RET 284 285 TEXT runtime·read_trampoline(SB),NOSPLIT,$0 286 PUSHQ BP 287 MOVQ SP, BP 288 MOVQ 8(DI), SI // arg 2 - buf 289 MOVL 16(DI), DX // arg 3 - count 290 MOVL 0(DI), DI // arg 1 - fd 291 CALL libc_read(SB) 292 TESTL AX, AX 293 JGE noerr 294 CALL libc_errno(SB) 295 MOVL (AX), AX // errno 296 NEGL AX // caller expects negative errno value 297 noerr: 298 POPQ BP 299 RET 300 301 TEXT runtime·write_trampoline(SB),NOSPLIT,$0 302 PUSHQ BP 303 MOVQ SP, BP 304 MOVQ 8(DI), SI // arg 2 buf 305 MOVL 16(DI), DX // arg 3 count 306 MOVL 0(DI), DI // arg 1 fd 307 CALL libc_write(SB) 308 TESTL AX, AX 309 JGE noerr 310 CALL libc_errno(SB) 311 MOVL (AX), AX // errno 312 NEGL AX // caller expects negative errno value 313 noerr: 314 POPQ BP 315 RET 316 317 TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0 318 PUSHQ BP 319 MOVQ SP, BP 320 MOVL 8(DI), SI // arg 2 flags 321 MOVQ 0(DI), DI // arg 1 filedes 322 CALL libc_pipe2(SB) 323 TESTL AX, AX 324 JEQ 3(PC) 325 CALL libc_errno(SB) 326 MOVL (AX), AX // errno 327 NEGL AX // caller expects negative errno value 328 POPQ BP 329 RET 330 331 TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0 332 PUSHQ BP 333 MOVQ SP, BP 334 MOVQ 8(DI), SI // arg 2 new 335 MOVQ 16(DI), DX // arg 3 old 336 MOVL 0(DI), DI // arg 1 which 337 CALL libc_setitimer(SB) 338 POPQ BP 339 RET 340 341 TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0 342 PUSHQ BP 343 MOVQ SP, BP 344 MOVL 0(DI), DI // arg 1 usec 345 CALL libc_usleep(SB) 346 POPQ BP 347 RET 348 349 TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0 350 PUSHQ BP 351 MOVQ SP, BP 352 MOVL 8(DI), SI // arg 2 miblen 353 MOVQ 16(DI), DX // arg 3 out 354 MOVQ 24(DI), CX // arg 4 size 355 MOVQ 32(DI), R8 // arg 5 dst 356 MOVQ 40(DI), R9 // arg 6 ndst 357 MOVQ 0(DI), DI // arg 1 mib 358 CALL libc_sysctl(SB) 359 POPQ BP 360 RET 361 362 TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0 363 PUSHQ BP 364 MOVQ SP, BP 365 CALL libc_kqueue(SB) 366 POPQ BP 367 RET 368 369 TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0 370 PUSHQ BP 371 MOVQ SP, BP 372 MOVQ 8(DI), SI // arg 2 keventt 373 MOVL 16(DI), DX // arg 3 nch 374 MOVQ 24(DI), CX // arg 4 ev 375 MOVL 32(DI), R8 // arg 5 nev 376 MOVQ 40(DI), R9 // arg 6 ts 377 MOVL 0(DI), DI // arg 1 kq 378 CALL libc_kevent(SB) 379 CMPL AX, $-1 380 JNE ok 381 CALL libc_errno(SB) 382 MOVL (AX), AX // errno 383 NEGL AX // caller expects negative errno value 384 ok: 385 POPQ BP 386 RET 387 388 TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0 389 PUSHQ BP // make a frame; keep stack aligned 390 MOVQ SP, BP 391 MOVQ 8(DI), SI // arg 2 tp 392 MOVL 0(DI), DI // arg 1 clock_id 393 CALL libc_clock_gettime(SB) 394 TESTL AX, AX 395 JEQ 2(PC) 396 MOVL $0xf1, 0xf1 // crash 397 POPQ BP 398 RET 399 400 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0 401 PUSHQ BP 402 MOVQ SP, BP 403 MOVL 4(DI), SI // arg 2 cmd 404 MOVL 8(DI), DX // arg 3 arg 405 MOVL 0(DI), DI // arg 1 fd 406 XORL AX, AX // vararg: say "no float args" 407 CALL libc_fcntl(SB) 408 POPQ BP 409 RET 410 411 TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0 412 PUSHQ BP 413 MOVQ SP, BP 414 MOVQ 8(DI), SI // arg 2 new 415 MOVQ 16(DI), DX // arg 3 old 416 MOVL 0(DI), DI // arg 1 sig 417 CALL libc_sigaction(SB) 418 TESTL AX, AX 419 JEQ 2(PC) 420 MOVL $0xf1, 0xf1 // crash 421 POPQ BP 422 RET 423 424 TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0 425 PUSHQ BP 426 MOVQ SP, BP 427 MOVQ 8(DI), SI // arg 2 new 428 MOVQ 16(DI), DX // arg 3 old 429 MOVL 0(DI), DI // arg 1 how 430 CALL libc_pthread_sigmask(SB) 431 TESTL AX, AX 432 JEQ 2(PC) 433 MOVL $0xf1, 0xf1 // crash 434 POPQ BP 435 RET 436 437 TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0 438 PUSHQ BP 439 MOVQ SP, BP 440 MOVQ 8(DI), SI // arg 2 old 441 MOVQ 0(DI), DI // arg 1 new 442 CALL libc_sigaltstack(SB) 443 TESTQ AX, AX 444 JEQ 2(PC) 445 MOVL $0xf1, 0xf1 // crash 446 POPQ BP 447 RET 448 449 // syscall calls a function in libc on behalf of the syscall package. 450 // syscall takes a pointer to a struct like: 451 // struct { 452 // fn uintptr 453 // a1 uintptr 454 // a2 uintptr 455 // a3 uintptr 456 // r1 uintptr 457 // r2 uintptr 458 // err uintptr 459 // } 460 // syscall must be called on the g0 stack with the 461 // C calling convention (use libcCall). 462 // 463 // syscall expects a 32-bit result and tests for 32-bit -1 464 // to decide there was an error. 465 TEXT runtime·syscall(SB),NOSPLIT,$0 466 PUSHQ BP 467 MOVQ SP, BP 468 SUBQ $16, SP 469 MOVQ (0*8)(DI), CX // fn 470 MOVQ (2*8)(DI), SI // a2 471 MOVQ (3*8)(DI), DX // a3 472 MOVQ DI, (SP) 473 MOVQ (1*8)(DI), DI // a1 474 XORL AX, AX // vararg: say "no float args" 475 476 CALL CX 477 478 MOVQ (SP), DI 479 MOVQ AX, (4*8)(DI) // r1 480 MOVQ DX, (5*8)(DI) // r2 481 482 // Standard libc functions return -1 on error 483 // and set errno. 484 CMPL AX, $-1 // Note: high 32 bits are junk 485 JNE ok 486 487 // Get error code from libc. 488 CALL libc_errno(SB) 489 MOVLQSX (AX), AX 490 MOVQ (SP), DI 491 MOVQ AX, (6*8)(DI) // err 492 493 ok: 494 XORL AX, AX // no error (it's ignored anyway) 495 MOVQ BP, SP 496 POPQ BP 497 RET 498 499 // syscallX calls a function in libc on behalf of the syscall package. 500 // syscallX takes a pointer to a struct like: 501 // struct { 502 // fn uintptr 503 // a1 uintptr 504 // a2 uintptr 505 // a3 uintptr 506 // r1 uintptr 507 // r2 uintptr 508 // err uintptr 509 // } 510 // syscallX must be called on the g0 stack with the 511 // C calling convention (use libcCall). 512 // 513 // syscallX is like syscall but expects a 64-bit result 514 // and tests for 64-bit -1 to decide there was an error. 515 TEXT runtime·syscallX(SB),NOSPLIT,$0 516 PUSHQ BP 517 MOVQ SP, BP 518 SUBQ $16, SP 519 MOVQ (0*8)(DI), CX // fn 520 MOVQ (2*8)(DI), SI // a2 521 MOVQ (3*8)(DI), DX // a3 522 MOVQ DI, (SP) 523 MOVQ (1*8)(DI), DI // a1 524 XORL AX, AX // vararg: say "no float args" 525 526 CALL CX 527 528 MOVQ (SP), DI 529 MOVQ AX, (4*8)(DI) // r1 530 MOVQ DX, (5*8)(DI) // r2 531 532 // Standard libc functions return -1 on error 533 // and set errno. 534 CMPQ AX, $-1 535 JNE ok 536 537 // Get error code from libc. 538 CALL libc_errno(SB) 539 MOVLQSX (AX), AX 540 MOVQ (SP), DI 541 MOVQ AX, (6*8)(DI) // err 542 543 ok: 544 XORL AX, AX // no error (it's ignored anyway) 545 MOVQ BP, SP 546 POPQ BP 547 RET 548 549 // syscall6 calls a function in libc on behalf of the syscall package. 550 // syscall6 takes a pointer to a struct like: 551 // struct { 552 // fn uintptr 553 // a1 uintptr 554 // a2 uintptr 555 // a3 uintptr 556 // a4 uintptr 557 // a5 uintptr 558 // a6 uintptr 559 // r1 uintptr 560 // r2 uintptr 561 // err uintptr 562 // } 563 // syscall6 must be called on the g0 stack with the 564 // C calling convention (use libcCall). 565 // 566 // syscall6 expects a 32-bit result and tests for 32-bit -1 567 // to decide there was an error. 568 TEXT runtime·syscall6(SB),NOSPLIT,$0 569 PUSHQ BP 570 MOVQ SP, BP 571 SUBQ $16, SP 572 MOVQ (0*8)(DI), R11// fn 573 MOVQ (2*8)(DI), SI // a2 574 MOVQ (3*8)(DI), DX // a3 575 MOVQ (4*8)(DI), CX // a4 576 MOVQ (5*8)(DI), R8 // a5 577 MOVQ (6*8)(DI), R9 // a6 578 MOVQ DI, (SP) 579 MOVQ (1*8)(DI), DI // a1 580 XORL AX, AX // vararg: say "no float args" 581 582 CALL R11 583 584 MOVQ (SP), DI 585 MOVQ AX, (7*8)(DI) // r1 586 MOVQ DX, (8*8)(DI) // r2 587 588 CMPL AX, $-1 589 JNE ok 590 591 CALL libc_errno(SB) 592 MOVLQSX (AX), AX 593 MOVQ (SP), DI 594 MOVQ AX, (9*8)(DI) // err 595 596 ok: 597 XORL AX, AX // no error (it's ignored anyway) 598 MOVQ BP, SP 599 POPQ BP 600 RET 601 602 // syscall6X calls a function in libc on behalf of the syscall package. 603 // syscall6X takes a pointer to a struct like: 604 // struct { 605 // fn uintptr 606 // a1 uintptr 607 // a2 uintptr 608 // a3 uintptr 609 // a4 uintptr 610 // a5 uintptr 611 // a6 uintptr 612 // r1 uintptr 613 // r2 uintptr 614 // err uintptr 615 // } 616 // syscall6X must be called on the g0 stack with the 617 // C calling convention (use libcCall). 618 // 619 // syscall6X is like syscall6 but expects a 64-bit result 620 // and tests for 64-bit -1 to decide there was an error. 621 TEXT runtime·syscall6X(SB),NOSPLIT,$0 622 PUSHQ BP 623 MOVQ SP, BP 624 SUBQ $16, SP 625 MOVQ (0*8)(DI), R11// fn 626 MOVQ (2*8)(DI), SI // a2 627 MOVQ (3*8)(DI), DX // a3 628 MOVQ (4*8)(DI), CX // a4 629 MOVQ (5*8)(DI), R8 // a5 630 MOVQ (6*8)(DI), R9 // a6 631 MOVQ DI, (SP) 632 MOVQ (1*8)(DI), DI // a1 633 XORL AX, AX // vararg: say "no float args" 634 635 CALL R11 636 637 MOVQ (SP), DI 638 MOVQ AX, (7*8)(DI) // r1 639 MOVQ DX, (8*8)(DI) // r2 640 641 CMPQ AX, $-1 642 JNE ok 643 644 CALL libc_errno(SB) 645 MOVLQSX (AX), AX 646 MOVQ (SP), DI 647 MOVQ AX, (9*8)(DI) // err 648 649 ok: 650 XORL AX, AX // no error (it's ignored anyway) 651 MOVQ BP, SP 652 POPQ BP 653 RET 654 655 // syscall10 calls a function in libc on behalf of the syscall package. 656 // syscall10 takes a pointer to a struct like: 657 // struct { 658 // fn uintptr 659 // a1 uintptr 660 // a2 uintptr 661 // a3 uintptr 662 // a4 uintptr 663 // a5 uintptr 664 // a6 uintptr 665 // a7 uintptr 666 // a8 uintptr 667 // a9 uintptr 668 // a10 uintptr 669 // r1 uintptr 670 // r2 uintptr 671 // err uintptr 672 // } 673 // syscall10 must be called on the g0 stack with the 674 // C calling convention (use libcCall). 675 TEXT runtime·syscall10(SB),NOSPLIT,$0 676 PUSHQ BP 677 MOVQ SP, BP 678 SUBQ $48, SP 679 680 // Arguments a1 to a6 get passed in registers, with a7 onwards being 681 // passed via the stack per the x86-64 System V ABI 682 // (https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf). 683 MOVQ (7*8)(DI), R10 // a7 684 MOVQ (8*8)(DI), R11 // a8 685 MOVQ (9*8)(DI), R12 // a9 686 MOVQ (10*8)(DI), R13 // a10 687 MOVQ R10, (0*8)(SP) // a7 688 MOVQ R11, (1*8)(SP) // a8 689 MOVQ R12, (2*8)(SP) // a9 690 MOVQ R13, (3*8)(SP) // a10 691 MOVQ (0*8)(DI), R11 // fn 692 MOVQ (2*8)(DI), SI // a2 693 MOVQ (3*8)(DI), DX // a3 694 MOVQ (4*8)(DI), CX // a4 695 MOVQ (5*8)(DI), R8 // a5 696 MOVQ (6*8)(DI), R9 // a6 697 MOVQ DI, (4*8)(SP) 698 MOVQ (1*8)(DI), DI // a1 699 XORL AX, AX // vararg: say "no float args" 700 701 CALL R11 702 703 MOVQ (4*8)(SP), DI 704 MOVQ AX, (11*8)(DI) // r1 705 MOVQ DX, (12*8)(DI) // r2 706 707 CMPL AX, $-1 708 JNE ok 709 710 CALL libc_errno(SB) 711 MOVLQSX (AX), AX 712 MOVQ (4*8)(SP), DI 713 MOVQ AX, (13*8)(DI) // err 714 715 ok: 716 XORL AX, AX // no error (it's ignored anyway) 717 MOVQ BP, SP 718 POPQ BP 719 RET 720 721 // syscall10X calls a function in libc on behalf of the syscall package. 722 // syscall10X takes a pointer to a struct like: 723 // struct { 724 // fn uintptr 725 // a1 uintptr 726 // a2 uintptr 727 // a3 uintptr 728 // a4 uintptr 729 // a5 uintptr 730 // a6 uintptr 731 // a7 uintptr 732 // a8 uintptr 733 // a9 uintptr 734 // a10 uintptr 735 // r1 uintptr 736 // r2 uintptr 737 // err uintptr 738 // } 739 // syscall10X must be called on the g0 stack with the 740 // C calling convention (use libcCall). 741 // 742 // syscall10X is like syscall10 but expects a 64-bit result 743 // and tests for 64-bit -1 to decide there was an error. 744 TEXT runtime·syscall10X(SB),NOSPLIT,$0 745 PUSHQ BP 746 MOVQ SP, BP 747 SUBQ $48, SP 748 749 // Arguments a1 to a6 get passed in registers, with a7 onwards being 750 // passed via the stack per the x86-64 System V ABI 751 // (https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf). 752 MOVQ (7*8)(DI), R10 // a7 753 MOVQ (8*8)(DI), R11 // a8 754 MOVQ (9*8)(DI), R12 // a9 755 MOVQ (10*8)(DI), R13 // a10 756 MOVQ R10, (0*8)(SP) // a7 757 MOVQ R11, (1*8)(SP) // a8 758 MOVQ R12, (2*8)(SP) // a9 759 MOVQ R13, (3*8)(SP) // a10 760 MOVQ (0*8)(DI), R11 // fn 761 MOVQ (2*8)(DI), SI // a2 762 MOVQ (3*8)(DI), DX // a3 763 MOVQ (4*8)(DI), CX // a4 764 MOVQ (5*8)(DI), R8 // a5 765 MOVQ (6*8)(DI), R9 // a6 766 MOVQ DI, (4*8)(SP) 767 MOVQ (1*8)(DI), DI // a1 768 XORL AX, AX // vararg: say "no float args" 769 770 CALL R11 771 772 MOVQ (4*8)(SP), DI 773 MOVQ AX, (11*8)(DI) // r1 774 MOVQ DX, (12*8)(DI) // r2 775 776 CMPQ AX, $-1 777 JNE ok 778 779 CALL libc_errno(SB) 780 MOVLQSX (AX), AX 781 MOVQ (4*8)(SP), DI 782 MOVQ AX, (13*8)(DI) // err 783 784 ok: 785 XORL AX, AX // no error (it's ignored anyway) 786 MOVQ BP, SP 787 POPQ BP 788 RET