github.com/comwrg/go/src@v0.0.0-20220319063731-c238d0440370/runtime/sys_openbsd_386.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 386, 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·setldt(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,$28 25 NOP SP // tell vet SP changed - stop checking offsets 26 27 // We are already on m's g0 stack. 28 29 // Save callee-save registers. 30 MOVL BX, bx-4(SP) 31 MOVL BP, bp-8(SP) 32 MOVL SI, si-12(SP) 33 MOVL DI, di-16(SP) 34 35 MOVL 32(SP), AX // m 36 MOVL m_g0(AX), DX 37 get_tls(CX) 38 MOVL DX, g(CX) 39 40 CALL runtime·mstart(SB) 41 42 // Restore callee-save registers. 43 MOVL di-16(SP), DI 44 MOVL si-12(SP), SI 45 MOVL bp-8(SP), BP 46 MOVL bx-4(SP), BX 47 48 // Go is all done with this OS thread. 49 // Tell pthread everything is ok (we never join with this thread, so 50 // the value here doesn't really matter). 51 MOVL $0, AX 52 RET 53 54 TEXT runtime·sigfwd(SB),NOSPLIT,$0-16 55 MOVL fn+0(FP), AX 56 MOVL sig+4(FP), BX 57 MOVL info+8(FP), CX 58 MOVL ctx+12(FP), DX 59 MOVL SP, SI 60 SUBL $32, SP 61 ANDL $~15, SP // align stack: handler might be a C function 62 MOVL BX, 0(SP) 63 MOVL CX, 4(SP) 64 MOVL DX, 8(SP) 65 MOVL SI, 12(SP) // save SI: handler might be a Go function 66 CALL AX 67 MOVL 12(SP), AX 68 MOVL AX, SP 69 RET 70 71 // Called by OS using C ABI. 72 TEXT runtime·sigtramp(SB),NOSPLIT,$28 73 NOP SP // tell vet SP changed - stop checking offsets 74 // Save callee-saved C registers, since the caller may be a C signal handler. 75 MOVL BX, bx-4(SP) 76 MOVL BP, bp-8(SP) 77 MOVL SI, si-12(SP) 78 MOVL DI, di-16(SP) 79 // We don't save mxcsr or the x87 control word because sigtrampgo doesn't 80 // modify them. 81 82 MOVL 32(SP), BX // signo 83 MOVL BX, 0(SP) 84 MOVL 36(SP), BX // info 85 MOVL BX, 4(SP) 86 MOVL 40(SP), BX // context 87 MOVL BX, 8(SP) 88 CALL runtime·sigtrampgo(SB) 89 90 MOVL di-16(SP), DI 91 MOVL si-12(SP), SI 92 MOVL bp-8(SP), BP 93 MOVL bx-4(SP), BX 94 RET 95 96 // These trampolines help convert from Go calling convention to C calling convention. 97 // They should be called with asmcgocall - note that while asmcgocall does 98 // stack alignment, creation of a frame undoes it again. 99 // A pointer to the arguments is passed on the stack. 100 // A single int32 result is returned in AX. 101 // (For more results, make an args/results structure.) 102 TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0 103 PUSHL BP 104 MOVL SP, BP 105 SUBL $4, SP 106 MOVL 12(SP), DX // pointer to args 107 MOVL 0(DX), AX 108 MOVL AX, 0(SP) // arg 1 - attr 109 CALL libc_pthread_attr_init(SB) 110 MOVL BP, SP 111 POPL BP 112 RET 113 114 TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$0 115 PUSHL BP 116 MOVL SP, BP 117 SUBL $4, SP 118 MOVL 12(SP), DX // pointer to args 119 MOVL 0(DX), AX 120 MOVL AX, 0(SP) // arg 1 - attr 121 CALL libc_pthread_attr_destroy(SB) 122 MOVL BP, SP 123 POPL BP 124 RET 125 126 TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0 127 PUSHL BP 128 MOVL SP, BP 129 SUBL $8, SP 130 MOVL 16(SP), DX // pointer to args 131 MOVL 0(DX), AX 132 MOVL 4(DX), BX 133 MOVL AX, 0(SP) // arg 1 - attr 134 MOVL BX, 4(SP) // arg 2 - size 135 CALL libc_pthread_attr_getstacksize(SB) 136 MOVL BP, SP 137 POPL BP 138 RET 139 140 TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0 141 PUSHL BP 142 MOVL SP, BP 143 SUBL $8, SP 144 MOVL 16(SP), DX // pointer to args 145 MOVL 0(DX), AX 146 MOVL 4(DX), BX 147 MOVL AX, 0(SP) // arg 1 - attr 148 MOVL BX, 4(SP) // arg 2 - state 149 CALL libc_pthread_attr_setdetachstate(SB) 150 MOVL BP, SP 151 POPL BP 152 RET 153 154 TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0 155 PUSHL BP 156 MOVL SP, BP 157 SUBL $20, SP 158 MOVL 28(SP), DX // pointer to args 159 LEAL 16(SP), AX 160 MOVL AX, 0(SP) // arg 1 - &threadid (discarded) 161 MOVL 0(DX), AX 162 MOVL 4(DX), BX 163 MOVL 8(DX), CX 164 MOVL AX, 4(SP) // arg 2 - attr 165 MOVL BX, 8(SP) // arg 3 - start 166 MOVL CX, 12(SP) // arg 4 - arg 167 CALL libc_pthread_create(SB) 168 MOVL BP, SP 169 POPL BP 170 RET 171 172 TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0 173 PUSHL BP 174 MOVL SP, BP 175 SUBL $12, SP 176 MOVL 20(SP), DX // pointer to args 177 MOVL 0(DX), AX 178 MOVL 4(DX), BX 179 MOVL AX, 0(SP) // arg 1 - tid 180 MOVL BX, 4(SP) // arg 2 - signal 181 MOVL $0, 8(SP) // arg 3 - tcb 182 CALL libc_thrkill(SB) 183 MOVL BP, SP 184 POPL BP 185 RET 186 187 TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0 188 PUSHL BP 189 MOVL SP, BP 190 SUBL $20, SP 191 MOVL 28(SP), DX // pointer to args 192 MOVL 0(DX), AX 193 MOVL 4(DX), BX 194 MOVL 8(DX), CX 195 MOVL AX, 0(SP) // arg 1 - id 196 MOVL BX, 4(SP) // arg 2 - clock_id 197 MOVL CX, 8(SP) // arg 3 - abstime 198 MOVL 12(DX), AX 199 MOVL 16(DX), BX 200 MOVL AX, 12(SP) // arg 4 - lock 201 MOVL BX, 16(SP) // arg 5 - abort 202 CALL libc_thrsleep(SB) 203 MOVL BP, SP 204 POPL BP 205 RET 206 207 TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0 208 PUSHL BP 209 MOVL SP, BP 210 SUBL $8, SP 211 MOVL 16(SP), DX // pointer to args 212 MOVL 0(DX), AX 213 MOVL 4(DX), BX 214 MOVL AX, 0(SP) // arg 1 - id 215 MOVL BX, 4(SP) // arg 2 - count 216 CALL libc_thrwakeup(SB) 217 MOVL BP, SP 218 POPL BP 219 RET 220 221 TEXT runtime·exit_trampoline(SB),NOSPLIT,$0 222 PUSHL BP 223 MOVL SP, BP 224 SUBL $4, SP 225 MOVL 12(SP), DX // pointer to args 226 MOVL 0(DX), AX 227 MOVL AX, 0(SP) // arg 1 - status 228 CALL libc_exit(SB) 229 MOVL $0xf1, 0xf1 // crash on failure 230 MOVL BP, SP 231 POPL BP 232 RET 233 234 TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0 235 PUSHL BP 236 CALL libc_getthrid(SB) 237 NOP SP // tell vet SP changed - stop checking offsets 238 MOVL 8(SP), DX // pointer to return value 239 MOVL AX, 0(DX) 240 POPL BP 241 RET 242 243 TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0 244 PUSHL BP 245 MOVL SP, BP 246 SUBL $8, SP 247 MOVL 16(SP), DX 248 MOVL 0(DX), BX 249 CALL libc_getpid(SB) 250 MOVL AX, 0(SP) // arg 1 - pid 251 MOVL BX, 4(SP) // arg 2 - signal 252 CALL libc_kill(SB) 253 MOVL BP, SP 254 POPL BP 255 RET 256 257 TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0 258 PUSHL BP 259 MOVL SP, BP 260 CALL libc_sched_yield(SB) 261 MOVL BP, SP 262 POPL BP 263 RET 264 265 TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0 266 PUSHL BP 267 MOVL SP, BP 268 SUBL $32, SP 269 MOVL 40(SP), DX // pointer to args 270 MOVL 0(DX), AX 271 MOVL 4(DX), BX 272 MOVL 8(DX), CX 273 MOVL AX, 0(SP) // arg 1 - addr 274 MOVL BX, 4(SP) // arg 2 - len 275 MOVL CX, 8(SP) // arg 3 - prot 276 MOVL 12(DX), AX 277 MOVL 16(DX), BX 278 MOVL 20(DX), CX 279 MOVL AX, 12(SP) // arg 4 - flags 280 MOVL BX, 16(SP) // arg 5 - fid 281 MOVL $0, 20(SP) // pad 282 MOVL CX, 24(SP) // arg 6 - offset (low 32 bits) 283 MOVL $0, 28(SP) // offset (high 32 bits) 284 CALL libc_mmap(SB) 285 MOVL $0, BX 286 CMPL AX, $-1 287 JNE ok 288 CALL libc_errno(SB) 289 MOVL (AX), BX 290 MOVL $0, AX 291 ok: 292 MOVL 40(SP), DX 293 MOVL AX, 24(DX) 294 MOVL BX, 28(DX) 295 MOVL BP, SP 296 POPL BP 297 RET 298 299 TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0 300 PUSHL BP 301 MOVL SP, BP 302 SUBL $8, SP 303 MOVL 16(SP), DX // pointer to args 304 MOVL 0(DX), AX 305 MOVL 4(DX), BX 306 MOVL AX, 0(SP) // arg 1 - addr 307 MOVL BX, 4(SP) // arg 2 - len 308 CALL libc_munmap(SB) 309 CMPL AX, $-1 310 JNE 2(PC) 311 MOVL $0xf1, 0xf1 // crash on failure 312 MOVL BP, SP 313 POPL BP 314 RET 315 316 TEXT runtime·madvise_trampoline(SB),NOSPLIT,$0 317 PUSHL BP 318 MOVL SP, BP 319 SUBL $12, SP 320 MOVL 20(SP), DX // pointer to args 321 MOVL 0(DX), AX 322 MOVL 4(DX), BX 323 MOVL 8(DX), CX 324 MOVL AX, 0(SP) // arg 1 - addr 325 MOVL BX, 4(SP) // arg 2 - len 326 MOVL CX, 8(SP) // arg 3 - advice 327 CALL libc_madvise(SB) 328 // ignore failure - maybe pages are locked 329 MOVL BP, SP 330 POPL BP 331 RET 332 333 TEXT runtime·open_trampoline(SB),NOSPLIT,$0 334 PUSHL BP 335 MOVL SP, BP 336 SUBL $16, SP 337 MOVL 24(SP), DX // pointer to args 338 MOVL 0(DX), AX 339 MOVL 4(DX), BX 340 MOVL 8(DX), CX 341 MOVL AX, 0(SP) // arg 1 - path 342 MOVL BX, 4(SP) // arg 2 - flags 343 MOVL CX, 8(SP) // arg 3 - mode 344 MOVL $0, 12(SP) // vararg 345 CALL libc_open(SB) 346 MOVL BP, SP 347 POPL BP 348 RET 349 350 TEXT runtime·close_trampoline(SB),NOSPLIT,$0 351 PUSHL BP 352 MOVL SP, BP 353 SUBL $4, SP 354 MOVL 12(SP), DX 355 MOVL 0(DX), AX 356 MOVL AX, 0(SP) // arg 1 - fd 357 CALL libc_close(SB) 358 MOVL BP, SP 359 POPL BP 360 RET 361 362 TEXT runtime·read_trampoline(SB),NOSPLIT,$0 363 PUSHL BP 364 MOVL SP, BP 365 SUBL $12, SP 366 MOVL 20(SP), DX // pointer to args 367 MOVL 0(DX), AX 368 MOVL 4(DX), BX 369 MOVL 8(DX), CX 370 MOVL AX, 0(SP) // arg 1 - fd 371 MOVL BX, 4(SP) // arg 2 - buf 372 MOVL CX, 8(SP) // arg 3 - count 373 CALL libc_read(SB) 374 CMPL AX, $-1 375 JNE noerr 376 CALL libc_errno(SB) 377 MOVL (AX), AX 378 NEGL AX // caller expects negative errno 379 noerr: 380 MOVL BP, SP 381 POPL BP 382 RET 383 384 TEXT runtime·write_trampoline(SB),NOSPLIT,$0 385 PUSHL BP 386 MOVL SP, BP 387 SUBL $12, SP 388 MOVL 20(SP), DX // pointer to args 389 MOVL 0(DX), AX 390 MOVL 4(DX), BX 391 MOVL 8(DX), CX 392 MOVL AX, 0(SP) // arg 1 - fd 393 MOVL BX, 4(SP) // arg 2 - buf 394 MOVL CX, 8(SP) // arg 3 - count 395 CALL libc_write(SB) 396 CMPL AX, $-1 397 JNE noerr 398 CALL libc_errno(SB) 399 MOVL (AX), AX 400 NEGL AX // caller expects negative errno 401 noerr: 402 MOVL BP, SP 403 POPL BP 404 RET 405 406 TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0 407 PUSHL BP 408 MOVL SP, BP 409 SUBL $8, SP 410 MOVL 16(SP), DX // pointer to args 411 MOVL 0(DX), AX 412 MOVL 4(DX), BX 413 MOVL AX, 0(SP) // arg 1 - fds 414 MOVL BX, 4(SP) // arg 2 - flags 415 CALL libc_pipe2(SB) 416 CMPL AX, $-1 417 JNE noerr 418 CALL libc_errno(SB) 419 MOVL (AX), AX 420 NEGL AX // caller expects negative errno 421 noerr: 422 MOVL BP, SP 423 POPL BP 424 RET 425 426 TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0 427 PUSHL BP 428 MOVL SP, BP 429 SUBL $12, SP 430 MOVL 20(SP), DX // pointer to args 431 MOVL 0(DX), AX 432 MOVL 4(DX), BX 433 MOVL 8(DX), CX 434 MOVL AX, 0(SP) // arg 1 - which 435 MOVL BX, 4(SP) // arg 2 - new 436 MOVL CX, 8(SP) // arg 3 - old 437 CALL libc_setitimer(SB) 438 MOVL BP, SP 439 POPL BP 440 RET 441 442 TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0 443 PUSHL BP 444 MOVL SP, BP 445 SUBL $4, SP 446 MOVL 12(SP), DX // pointer to args 447 MOVL 0(DX), AX 448 MOVL AX, 0(SP) 449 CALL libc_usleep(SB) 450 MOVL BP, SP 451 POPL BP 452 RET 453 454 TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0 455 PUSHL BP 456 MOVL SP, BP 457 SUBL $24, SP 458 MOVL 32(SP), DX // pointer to args 459 MOVL 0(DX), AX 460 MOVL 4(DX), BX 461 MOVL 8(DX), CX 462 MOVL AX, 0(SP) // arg 1 - name 463 MOVL BX, 4(SP) // arg 2 - namelen 464 MOVL CX, 8(SP) // arg 3 - old 465 MOVL 12(DX), AX 466 MOVL 16(DX), BX 467 MOVL 20(DX), CX 468 MOVL AX, 12(SP) // arg 4 - oldlenp 469 MOVL BX, 16(SP) // arg 5 - newp 470 MOVL CX, 20(SP) // arg 6 - newlen 471 CALL libc_sysctl(SB) 472 MOVL BP, SP 473 POPL BP 474 RET 475 476 TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0 477 PUSHL BP 478 MOVL SP, BP 479 CALL libc_kqueue(SB) 480 MOVL BP, SP 481 POPL BP 482 RET 483 484 TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0 485 PUSHL BP 486 MOVL SP, BP 487 SUBL $24, SP 488 MOVL 32(SP), DX // pointer to args 489 MOVL 0(DX), AX 490 MOVL 4(DX), BX 491 MOVL 8(DX), CX 492 MOVL AX, 0(SP) // arg 1 - kq 493 MOVL BX, 4(SP) // arg 2 - keventt 494 MOVL CX, 8(SP) // arg 3 - nch 495 MOVL 12(DX), AX 496 MOVL 16(DX), BX 497 MOVL 20(DX), CX 498 MOVL AX, 12(SP) // arg 4 - ev 499 MOVL BX, 16(SP) // arg 5 - nev 500 MOVL CX, 20(SP) // arg 6 - ts 501 CALL libc_kevent(SB) 502 CMPL AX, $-1 503 JNE noerr 504 CALL libc_errno(SB) 505 MOVL (AX), AX 506 NEGL AX // caller expects negative errno 507 noerr: 508 MOVL BP, SP 509 POPL BP 510 RET 511 512 TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0 513 PUSHL BP 514 MOVL SP, BP 515 SUBL $8, SP 516 MOVL 16(SP), DX // pointer to args 517 MOVL 0(DX), AX 518 MOVL 4(DX), BX 519 MOVL AX, 0(SP) // arg 1 - tp 520 MOVL BX, 4(SP) // arg 2 - clock_id 521 CALL libc_clock_gettime(SB) 522 CMPL AX, $-1 523 JNE 2(PC) 524 MOVL $0xf1, 0xf1 // crash on failure 525 MOVL BP, SP 526 POPL BP 527 RET 528 529 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0 530 PUSHL BP 531 MOVL SP, BP 532 SUBL $16, SP 533 MOVL 24(SP), DX // pointer to args 534 MOVL 0(DX), AX 535 MOVL 4(DX), BX 536 MOVL 8(DX), CX 537 MOVL AX, 0(SP) // arg 1 - fd 538 MOVL BX, 4(SP) // arg 2 - cmd 539 MOVL CX, 8(SP) // arg 3 - arg 540 MOVL $0, 12(SP) // vararg 541 CALL libc_fcntl(SB) 542 MOVL BP, SP 543 POPL BP 544 RET 545 546 TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0 547 PUSHL BP 548 MOVL SP, BP 549 SUBL $12, SP 550 MOVL 20(SP), DX // pointer to args 551 MOVL 0(DX), AX 552 MOVL 4(DX), BX 553 MOVL 8(DX), CX 554 MOVL AX, 0(SP) // arg 1 - sig 555 MOVL BX, 4(SP) // arg 2 - new 556 MOVL CX, 8(SP) // arg 3 - old 557 CALL libc_sigaction(SB) 558 CMPL AX, $-1 559 JNE 2(PC) 560 MOVL $0xf1, 0xf1 // crash on failure 561 MOVL BP, SP 562 POPL BP 563 RET 564 565 TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0 566 PUSHL BP 567 MOVL SP, BP 568 SUBL $12, SP 569 MOVL 20(SP), DX // pointer to args 570 MOVL 0(DX), AX 571 MOVL 4(DX), BX 572 MOVL 8(DX), CX 573 MOVL AX, 0(SP) // arg 1 - how 574 MOVL BX, 4(SP) // arg 2 - new 575 MOVL CX, 8(SP) // arg 3 - old 576 CALL libc_pthread_sigmask(SB) 577 CMPL AX, $-1 578 JNE 2(PC) 579 MOVL $0xf1, 0xf1 // crash on failure 580 MOVL BP, SP 581 POPL BP 582 RET 583 584 TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0 585 PUSHL BP 586 MOVL SP, BP 587 SUBL $8, SP 588 MOVL 16(SP), DX // pointer to args 589 MOVL 0(DX), AX 590 MOVL 4(DX), BX 591 MOVL AX, 0(SP) // arg 1 - new 592 MOVL BX, 4(SP) // arg 2 - old 593 CALL libc_sigaltstack(SB) 594 CMPL AX, $-1 595 JNE 2(PC) 596 MOVL $0xf1, 0xf1 // crash on failure 597 MOVL BP, SP 598 POPL BP 599 RET 600 601 // syscall calls a function in libc on behalf of the syscall package. 602 // syscall takes a pointer to a struct like: 603 // struct { 604 // fn uintptr 605 // a1 uintptr 606 // a2 uintptr 607 // a3 uintptr 608 // r1 uintptr 609 // r2 uintptr 610 // err uintptr 611 // } 612 // syscall must be called on the g0 stack with the 613 // C calling convention (use libcCall). 614 // 615 // syscall expects a 32-bit result and tests for 32-bit -1 616 // to decide there was an error. 617 TEXT runtime·syscall(SB),NOSPLIT,$0 618 PUSHL BP 619 MOVL SP, BP 620 621 SUBL $12, SP 622 MOVL 20(SP), BX // pointer to args 623 624 MOVL (1*4)(BX), AX 625 MOVL (2*4)(BX), CX 626 MOVL (3*4)(BX), DX 627 MOVL AX, (0*4)(SP) // a1 628 MOVL CX, (1*4)(SP) // a2 629 MOVL DX, (2*4)(SP) // a3 630 631 MOVL (0*4)(BX), AX // fn 632 CALL AX 633 634 MOVL AX, (4*4)(BX) // r1 635 MOVL DX, (5*4)(BX) // r2 636 637 // Standard libc functions return -1 on error and set errno. 638 CMPL AX, $-1 639 JNE ok 640 641 // Get error code from libc. 642 CALL libc_errno(SB) 643 MOVL (AX), AX 644 MOVW AX, (6*4)(BX) // err 645 646 ok: 647 MOVL $0, AX // no error (it's ignored anyway) 648 MOVL BP, SP 649 POPL BP 650 RET 651 652 // syscallX calls a function in libc on behalf of the syscall package. 653 // syscallX takes a pointer to a struct like: 654 // struct { 655 // fn uintptr 656 // a1 uintptr 657 // a2 uintptr 658 // a3 uintptr 659 // r1 uintptr 660 // r2 uintptr 661 // err uintptr 662 // } 663 // syscallX must be called on the g0 stack with the 664 // C calling convention (use libcCall). 665 // 666 // syscallX is like syscall but expects a 64-bit result 667 // and tests for 64-bit -1 to decide there was an error. 668 TEXT runtime·syscallX(SB),NOSPLIT,$0 669 PUSHL BP 670 MOVL SP, BP 671 672 SUBL $12, SP 673 MOVL 20(SP), BX // pointer to args 674 675 MOVL (1*4)(BX), AX 676 MOVL (2*4)(BX), CX 677 MOVL (3*4)(BX), DX 678 MOVL AX, (0*4)(SP) // a1 679 MOVL CX, (1*4)(SP) // a2 680 MOVL DX, (2*4)(SP) // a3 681 682 MOVL (0*4)(BX), AX // fn 683 CALL AX 684 685 MOVL AX, (4*4)(BX) // r1 686 MOVL DX, (5*4)(BX) // r2 687 688 // Standard libc functions return -1 on error and set errno. 689 CMPL AX, $-1 690 JNE ok 691 CMPL DX, $-1 692 JNE ok 693 694 // Get error code from libc. 695 CALL libc_errno(SB) 696 MOVL (AX), AX 697 MOVW AX, (6*4)(BX) // err 698 699 ok: 700 MOVL $0, AX // no error (it's ignored anyway) 701 MOVL BP, SP 702 POPL BP 703 RET 704 705 // syscall6 calls a function in libc on behalf of the syscall package. 706 // syscall6 takes a pointer to a struct like: 707 // struct { 708 // fn uintptr 709 // a1 uintptr 710 // a2 uintptr 711 // a3 uintptr 712 // a4 uintptr 713 // a5 uintptr 714 // a6 uintptr 715 // r1 uintptr 716 // r2 uintptr 717 // err uintptr 718 // } 719 // syscall6 must be called on the g0 stack with the 720 // C calling convention (use libcCall). 721 // 722 // syscall6 expects a 32-bit result and tests for 32-bit -1 723 // to decide there was an error. 724 TEXT runtime·syscall6(SB),NOSPLIT,$0 725 PUSHL BP 726 MOVL SP, BP 727 728 SUBL $24, SP 729 MOVL 32(SP), BX // pointer to args 730 731 MOVL (1*4)(BX), AX 732 MOVL (2*4)(BX), CX 733 MOVL (3*4)(BX), DX 734 MOVL AX, (0*4)(SP) // a1 735 MOVL CX, (1*4)(SP) // a2 736 MOVL DX, (2*4)(SP) // a3 737 MOVL (4*4)(BX), AX 738 MOVL (5*4)(BX), CX 739 MOVL (6*4)(BX), DX 740 MOVL AX, (3*4)(SP) // a4 741 MOVL CX, (4*4)(SP) // a5 742 MOVL DX, (5*4)(SP) // a6 743 744 MOVL (0*4)(BX), AX // fn 745 CALL AX 746 747 MOVL AX, (7*4)(BX) // r1 748 MOVL DX, (8*4)(BX) // r2 749 750 // Standard libc functions return -1 on error and set errno. 751 CMPL AX, $-1 752 JNE ok 753 754 // Get error code from libc. 755 CALL libc_errno(SB) 756 MOVL (AX), AX 757 MOVW AX, (9*4)(BX) // err 758 759 ok: 760 MOVL $0, AX // no error (it's ignored anyway) 761 MOVL BP, SP 762 POPL BP 763 RET 764 765 // syscall6X calls a function in libc on behalf of the syscall package. 766 // syscall6X takes a pointer to a struct like: 767 // struct { 768 // fn uintptr 769 // a1 uintptr 770 // a2 uintptr 771 // a3 uintptr 772 // a4 uintptr 773 // a5 uintptr 774 // a6 uintptr 775 // r1 uintptr 776 // r2 uintptr 777 // err uintptr 778 // } 779 // syscall6X must be called on the g0 stack with the 780 // C calling convention (use libcCall). 781 // 782 // syscall6X is like syscall6 but expects a 64-bit result 783 // and tests for 64-bit -1 to decide there was an error. 784 TEXT runtime·syscall6X(SB),NOSPLIT,$0 785 PUSHL BP 786 MOVL SP, BP 787 788 SUBL $24, SP 789 MOVL 32(SP), BX // pointer to args 790 791 MOVL (1*4)(BX), AX 792 MOVL (2*4)(BX), CX 793 MOVL (3*4)(BX), DX 794 MOVL AX, (0*4)(SP) // a1 795 MOVL CX, (1*4)(SP) // a2 796 MOVL DX, (2*4)(SP) // a3 797 MOVL (4*4)(BX), AX 798 MOVL (5*4)(BX), CX 799 MOVL (6*4)(BX), DX 800 MOVL AX, (3*4)(SP) // a4 801 MOVL CX, (4*4)(SP) // a5 802 MOVL DX, (5*4)(SP) // a6 803 804 MOVL (0*4)(BX), AX // fn 805 CALL AX 806 807 MOVL AX, (7*4)(BX) // r1 808 MOVL DX, (8*4)(BX) // r2 809 810 // Standard libc functions return -1 on error and set errno. 811 CMPL AX, $-1 812 JNE ok 813 CMPL DX, $-1 814 JNE ok 815 816 // Get error code from libc. 817 CALL libc_errno(SB) 818 MOVL (AX), AX 819 MOVW AX, (9*4)(BX) // err 820 821 ok: 822 MOVL $0, AX // no error (it's ignored anyway) 823 MOVL BP, SP 824 POPL BP 825 RET 826 827 // syscall10 calls a function in libc on behalf of the syscall package. 828 // syscall10 takes a pointer to a struct like: 829 // struct { 830 // fn uintptr 831 // a1 uintptr 832 // a2 uintptr 833 // a3 uintptr 834 // a4 uintptr 835 // a5 uintptr 836 // a6 uintptr 837 // a7 uintptr 838 // a8 uintptr 839 // a9 uintptr 840 // a10 uintptr 841 // r1 uintptr 842 // r2 uintptr 843 // err uintptr 844 // } 845 // syscall10 must be called on the g0 stack with the 846 // C calling convention (use libcCall). 847 TEXT runtime·syscall10(SB),NOSPLIT,$0 848 PUSHL BP 849 MOVL SP, BP 850 851 SUBL $40, SP 852 MOVL 48(SP), BX // pointer to args 853 854 MOVL (1*4)(BX), AX 855 MOVL (2*4)(BX), CX 856 MOVL (3*4)(BX), DX 857 MOVL AX, (0*4)(SP) // a1 858 MOVL CX, (1*4)(SP) // a2 859 MOVL DX, (2*4)(SP) // a3 860 MOVL (4*4)(BX), AX 861 MOVL (5*4)(BX), CX 862 MOVL (6*4)(BX), DX 863 MOVL AX, (3*4)(SP) // a4 864 MOVL CX, (4*4)(SP) // a5 865 MOVL DX, (5*4)(SP) // a6 866 MOVL (7*4)(BX), AX 867 MOVL (8*4)(BX), CX 868 MOVL (9*4)(BX), DX 869 MOVL AX, (6*4)(SP) // a7 870 MOVL CX, (7*4)(SP) // a8 871 MOVL DX, (8*4)(SP) // a9 872 MOVL (10*4)(BX), AX 873 MOVL AX, (9*4)(SP) // a10 874 875 MOVL (0*4)(BX), AX // fn 876 CALL AX 877 878 MOVL AX, (11*4)(BX) // r1 879 MOVL DX, (12*4)(BX) // r2 880 881 // Standard libc functions return -1 on error and set errno. 882 CMPL AX, $-1 883 JNE ok 884 885 // Get error code from libc. 886 CALL libc_errno(SB) 887 MOVL (AX), AX 888 MOVW AX, (13*4)(BX) // err 889 890 ok: 891 MOVL $0, AX // no error (it's ignored anyway) 892 MOVL BP, SP 893 POPL BP 894 RET 895 896 // syscall10X calls a function in libc on behalf of the syscall package. 897 // syscall10X takes a pointer to a struct like: 898 // struct { 899 // fn uintptr 900 // a1 uintptr 901 // a2 uintptr 902 // a3 uintptr 903 // a4 uintptr 904 // a5 uintptr 905 // a6 uintptr 906 // a7 uintptr 907 // a8 uintptr 908 // a9 uintptr 909 // a10 uintptr 910 // r1 uintptr 911 // r2 uintptr 912 // err uintptr 913 // } 914 // syscall10X must be called on the g0 stack with the 915 // C calling convention (use libcCall). 916 // 917 // syscall10X is like syscall9 but expects a 64-bit result 918 // and tests for 64-bit -1 to decide there was an error. 919 TEXT runtime·syscall10X(SB),NOSPLIT,$0 920 PUSHL BP 921 MOVL SP, BP 922 923 SUBL $40, SP 924 MOVL 48(SP), BX // pointer to args 925 926 MOVL (1*4)(BX), AX 927 MOVL (2*4)(BX), CX 928 MOVL (3*4)(BX), DX 929 MOVL AX, (0*4)(SP) // a1 930 MOVL CX, (1*4)(SP) // a2 931 MOVL DX, (2*4)(SP) // a3 932 MOVL (4*4)(BX), AX 933 MOVL (5*4)(BX), CX 934 MOVL (6*4)(BX), DX 935 MOVL AX, (3*4)(SP) // a4 936 MOVL CX, (4*4)(SP) // a5 937 MOVL DX, (5*4)(SP) // a6 938 MOVL (7*4)(BX), AX 939 MOVL (8*4)(BX), CX 940 MOVL (9*4)(BX), DX 941 MOVL AX, (6*4)(SP) // a7 942 MOVL CX, (7*4)(SP) // a8 943 MOVL DX, (8*4)(SP) // a9 944 MOVL (10*4)(BX), AX 945 MOVL AX, (9*4)(SP) // a10 946 947 MOVL (0*4)(BX), AX // fn 948 CALL AX 949 950 MOVL AX, (11*4)(BX) // r1 951 MOVL DX, (12*4)(BX) // r2 952 953 // Standard libc functions return -1 on error and set errno. 954 CMPL AX, $-1 955 JNE ok 956 CMPL DX, $-1 957 JNE ok 958 959 // Get error code from libc. 960 CALL libc_errno(SB) 961 MOVL (AX), AX 962 MOVW AX, (13*4)(BX) // err 963 964 ok: 965 MOVL $0, AX // no error (it's ignored anyway) 966 MOVL BP, SP 967 POPL BP 968 RET