github.com/lzhfromustc/gofuzz@v0.0.0-20211116160056-151b3108bbd1/runtime/sys_linux_mips64x.s (about) 1 // Copyright 2015 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 mips64 mips64le 7 8 // 9 // System calls and other sys.stuff for mips64, Linux 10 // 11 12 #include "go_asm.h" 13 #include "go_tls.h" 14 #include "textflag.h" 15 16 #define AT_FDCWD -100 17 18 #define SYS_exit 5058 19 #define SYS_read 5000 20 #define SYS_write 5001 21 #define SYS_close 5003 22 #define SYS_getpid 5038 23 #define SYS_kill 5060 24 #define SYS_fcntl 5070 25 #define SYS_mmap 5009 26 #define SYS_munmap 5011 27 #define SYS_setitimer 5036 28 #define SYS_clone 5055 29 #define SYS_nanosleep 5034 30 #define SYS_sched_yield 5023 31 #define SYS_rt_sigreturn 5211 32 #define SYS_rt_sigaction 5013 33 #define SYS_rt_sigprocmask 5014 34 #define SYS_sigaltstack 5129 35 #define SYS_madvise 5027 36 #define SYS_mincore 5026 37 #define SYS_gettid 5178 38 #define SYS_futex 5194 39 #define SYS_sched_getaffinity 5196 40 #define SYS_exit_group 5205 41 #define SYS_epoll_create 5207 42 #define SYS_epoll_ctl 5208 43 #define SYS_tgkill 5225 44 #define SYS_openat 5247 45 #define SYS_epoll_pwait 5272 46 #define SYS_clock_gettime 5222 47 #define SYS_epoll_create1 5285 48 #define SYS_brk 5012 49 #define SYS_pipe2 5287 50 51 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4 52 MOVW code+0(FP), R4 53 MOVV $SYS_exit_group, R2 54 SYSCALL 55 RET 56 57 // func exitThread(wait *uint32) 58 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8 59 MOVV wait+0(FP), R1 60 // We're done using the stack. 61 MOVW $0, R2 62 SYNC 63 MOVW R2, (R1) 64 SYNC 65 MOVW $0, R4 // exit code 66 MOVV $SYS_exit, R2 67 SYSCALL 68 JMP 0(PC) 69 70 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20 71 // This uses openat instead of open, because Android O blocks open. 72 MOVW $AT_FDCWD, R4 // AT_FDCWD, so this acts like open 73 MOVV name+0(FP), R5 74 MOVW mode+8(FP), R6 75 MOVW perm+12(FP), R7 76 MOVV $SYS_openat, R2 77 SYSCALL 78 BEQ R7, 2(PC) 79 MOVW $-1, R2 80 MOVW R2, ret+16(FP) 81 RET 82 83 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12 84 MOVW fd+0(FP), R4 85 MOVV $SYS_close, R2 86 SYSCALL 87 BEQ R7, 2(PC) 88 MOVW $-1, R2 89 MOVW R2, ret+8(FP) 90 RET 91 92 TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28 93 MOVV fd+0(FP), R4 94 MOVV p+8(FP), R5 95 MOVW n+16(FP), R6 96 MOVV $SYS_write, R2 97 SYSCALL 98 BEQ R7, 2(PC) 99 SUBVU R2, R0, R2 // caller expects negative errno 100 MOVW R2, ret+24(FP) 101 RET 102 103 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28 104 MOVW fd+0(FP), R4 105 MOVV p+8(FP), R5 106 MOVW n+16(FP), R6 107 MOVV $SYS_read, R2 108 SYSCALL 109 BEQ R7, 2(PC) 110 SUBVU R2, R0, R2 // caller expects negative errno 111 MOVW R2, ret+24(FP) 112 RET 113 114 // func pipe() (r, w int32, errno int32) 115 TEXT runtime·pipe(SB),NOSPLIT|NOFRAME,$0-12 116 MOVV $r+0(FP), R4 117 MOVV R0, R5 118 MOVV $SYS_pipe2, R2 119 SYSCALL 120 BEQ R7, 2(PC) 121 SUBVU R2, R0, R2 // caller expects negative errno 122 MOVW R2, errno+8(FP) 123 RET 124 125 // func pipe2(flags int32) (r, w int32, errno int32) 126 TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20 127 MOVV $r+8(FP), R4 128 MOVW flags+0(FP), R5 129 MOVV $SYS_pipe2, R2 130 SYSCALL 131 BEQ R7, 2(PC) 132 SUBVU R2, R0, R2 // caller expects negative errno 133 MOVW R2, errno+16(FP) 134 RET 135 136 TEXT runtime·usleep(SB),NOSPLIT,$16-4 137 MOVWU usec+0(FP), R3 138 MOVV R3, R5 139 MOVW $1000000, R4 140 DIVVU R4, R3 141 MOVV LO, R3 142 MOVV R3, 8(R29) 143 MOVW $1000, R4 144 MULVU R3, R4 145 MOVV LO, R4 146 SUBVU R4, R5 147 MOVV R5, 16(R29) 148 149 // nanosleep(&ts, 0) 150 ADDV $8, R29, R4 151 MOVW $0, R5 152 MOVV $SYS_nanosleep, R2 153 SYSCALL 154 RET 155 156 TEXT runtime·gettid(SB),NOSPLIT,$0-4 157 MOVV $SYS_gettid, R2 158 SYSCALL 159 MOVW R2, ret+0(FP) 160 RET 161 162 TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0 163 MOVV $SYS_getpid, R2 164 SYSCALL 165 MOVW R2, R16 166 MOVV $SYS_gettid, R2 167 SYSCALL 168 MOVW R2, R5 // arg 2 tid 169 MOVW R16, R4 // arg 1 pid 170 MOVW sig+0(FP), R6 // arg 3 171 MOVV $SYS_tgkill, R2 172 SYSCALL 173 RET 174 175 TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0 176 MOVV $SYS_getpid, R2 177 SYSCALL 178 MOVW R2, R4 // arg 1 pid 179 MOVW sig+0(FP), R5 // arg 2 180 MOVV $SYS_kill, R2 181 SYSCALL 182 RET 183 184 TEXT ·getpid(SB),NOSPLIT|NOFRAME,$0-8 185 MOVV $SYS_getpid, R2 186 SYSCALL 187 MOVV R2, ret+0(FP) 188 RET 189 190 TEXT ·tgkill(SB),NOSPLIT|NOFRAME,$0-24 191 MOVV tgid+0(FP), R4 192 MOVV tid+8(FP), R5 193 MOVV sig+16(FP), R6 194 MOVV $SYS_tgkill, R2 195 SYSCALL 196 RET 197 198 TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24 199 MOVW mode+0(FP), R4 200 MOVV new+8(FP), R5 201 MOVV old+16(FP), R6 202 MOVV $SYS_setitimer, R2 203 SYSCALL 204 RET 205 206 TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28 207 MOVV addr+0(FP), R4 208 MOVV n+8(FP), R5 209 MOVV dst+16(FP), R6 210 MOVV $SYS_mincore, R2 211 SYSCALL 212 SUBVU R2, R0, R2 // caller expects negative errno 213 MOVW R2, ret+24(FP) 214 RET 215 216 // func walltime1() (sec int64, nsec int32) 217 TEXT runtime·walltime1(SB),NOSPLIT,$16-12 218 MOVV R29, R16 // R16 is unchanged by C code 219 MOVV R29, R1 220 221 MOVV g_m(g), R17 // R17 = m 222 223 // Set vdsoPC and vdsoSP for SIGPROF traceback. 224 // Save the old values on stack and restore them on exit, 225 // so this function is reentrant. 226 MOVV m_vdsoPC(R17), R2 227 MOVV m_vdsoSP(R17), R3 228 MOVV R2, 8(R29) 229 MOVV R3, 16(R29) 230 231 MOVV R31, m_vdsoPC(R17) 232 MOVV R29, m_vdsoSP(R17) 233 234 MOVV m_curg(R17), R4 235 MOVV g, R5 236 BNE R4, R5, noswitch 237 238 MOVV m_g0(R17), R4 239 MOVV (g_sched+gobuf_sp)(R4), R1 // Set SP to g0 stack 240 241 noswitch: 242 SUBV $16, R1 243 AND $~15, R1 // Align for C code 244 MOVV R1, R29 245 246 MOVW $0, R4 // CLOCK_REALTIME 247 MOVV $0(R29), R5 248 249 MOVV runtime·vdsoClockgettimeSym(SB), R25 250 BEQ R25, fallback 251 252 JAL (R25) 253 // check on vdso call return for kernel compatibility 254 // see https://golang.org/issues/39046 255 // if we get any error make fallback permanent. 256 BEQ R2, R0, finish 257 MOVV R0, runtime·vdsoClockgettimeSym(SB) 258 MOVW $0, R4 // CLOCK_REALTIME 259 MOVV $0(R29), R5 260 JMP fallback 261 262 finish: 263 MOVV 0(R29), R3 // sec 264 MOVV 8(R29), R5 // nsec 265 266 MOVV R16, R29 // restore SP 267 // Restore vdsoPC, vdsoSP 268 // We don't worry about being signaled between the two stores. 269 // If we are not in a signal handler, we'll restore vdsoSP to 0, 270 // and no one will care about vdsoPC. If we are in a signal handler, 271 // we cannot receive another signal. 272 MOVV 16(R29), R1 273 MOVV R1, m_vdsoSP(R17) 274 MOVV 8(R29), R1 275 MOVV R1, m_vdsoPC(R17) 276 277 MOVV R3, sec+0(FP) 278 MOVW R5, nsec+8(FP) 279 RET 280 281 fallback: 282 MOVV $SYS_clock_gettime, R2 283 SYSCALL 284 JMP finish 285 286 TEXT runtime·nanotime1(SB),NOSPLIT,$16-8 287 MOVV R29, R16 // R16 is unchanged by C code 288 MOVV R29, R1 289 290 MOVV g_m(g), R17 // R17 = m 291 292 // Set vdsoPC and vdsoSP for SIGPROF traceback. 293 // Save the old values on stack and restore them on exit, 294 // so this function is reentrant. 295 MOVV m_vdsoPC(R17), R2 296 MOVV m_vdsoSP(R17), R3 297 MOVV R2, 8(R29) 298 MOVV R3, 16(R29) 299 300 MOVV R31, m_vdsoPC(R17) 301 MOVV R29, m_vdsoSP(R17) 302 303 MOVV m_curg(R17), R4 304 MOVV g, R5 305 BNE R4, R5, noswitch 306 307 MOVV m_g0(R17), R4 308 MOVV (g_sched+gobuf_sp)(R4), R1 // Set SP to g0 stack 309 310 noswitch: 311 SUBV $16, R1 312 AND $~15, R1 // Align for C code 313 MOVV R1, R29 314 315 MOVW $1, R4 // CLOCK_MONOTONIC 316 MOVV $0(R29), R5 317 318 MOVV runtime·vdsoClockgettimeSym(SB), R25 319 BEQ R25, fallback 320 321 JAL (R25) 322 // see walltime1 for detail 323 BEQ R2, R0, finish 324 MOVV R0, runtime·vdsoClockgettimeSym(SB) 325 MOVW $1, R4 // CLOCK_MONOTONIC 326 MOVV $0(R29), R5 327 JMP fallback 328 329 finish: 330 MOVV 0(R29), R3 // sec 331 MOVV 8(R29), R5 // nsec 332 333 MOVV R16, R29 // restore SP 334 // Restore vdsoPC, vdsoSP 335 // We don't worry about being signaled between the two stores. 336 // If we are not in a signal handler, we'll restore vdsoSP to 0, 337 // and no one will care about vdsoPC. If we are in a signal handler, 338 // we cannot receive another signal. 339 MOVV 16(R29), R1 340 MOVV R1, m_vdsoSP(R17) 341 MOVV 8(R29), R1 342 MOVV R1, m_vdsoPC(R17) 343 344 // sec is in R3, nsec in R5 345 // return nsec in R3 346 MOVV $1000000000, R4 347 MULVU R4, R3 348 MOVV LO, R3 349 ADDVU R5, R3 350 MOVV R3, ret+0(FP) 351 RET 352 353 fallback: 354 MOVV $SYS_clock_gettime, R2 355 SYSCALL 356 JMP finish 357 358 TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28 359 MOVW how+0(FP), R4 360 MOVV new+8(FP), R5 361 MOVV old+16(FP), R6 362 MOVW size+24(FP), R7 363 MOVV $SYS_rt_sigprocmask, R2 364 SYSCALL 365 BEQ R7, 2(PC) 366 MOVV R0, 0xf1(R0) // crash 367 RET 368 369 TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36 370 MOVV sig+0(FP), R4 371 MOVV new+8(FP), R5 372 MOVV old+16(FP), R6 373 MOVV size+24(FP), R7 374 MOVV $SYS_rt_sigaction, R2 375 SYSCALL 376 BEQ R7, 2(PC) 377 SUBVU R2, R0, R2 // caller expects negative errno 378 MOVW R2, ret+32(FP) 379 RET 380 381 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 382 MOVW sig+8(FP), R4 383 MOVV info+16(FP), R5 384 MOVV ctx+24(FP), R6 385 MOVV fn+0(FP), R25 386 JAL (R25) 387 RET 388 389 TEXT runtime·sigtramp(SB),NOSPLIT,$64 390 // initialize REGSB = PC&0xffffffff00000000 391 BGEZAL R0, 1(PC) 392 SRLV $32, R31, RSB 393 SLLV $32, RSB 394 395 // this might be called in external code context, 396 // where g is not set. 397 MOVB runtime·iscgo(SB), R1 398 BEQ R1, 2(PC) 399 JAL runtime·load_g(SB) 400 401 MOVW R4, 8(R29) 402 MOVV R5, 16(R29) 403 MOVV R6, 24(R29) 404 MOVV $runtime·sigtrampgo(SB), R1 405 JAL (R1) 406 RET 407 408 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0 409 JMP runtime·sigtramp(SB) 410 411 TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0 412 MOVV addr+0(FP), R4 413 MOVV n+8(FP), R5 414 MOVW prot+16(FP), R6 415 MOVW flags+20(FP), R7 416 MOVW fd+24(FP), R8 417 MOVW off+28(FP), R9 418 419 MOVV $SYS_mmap, R2 420 SYSCALL 421 BEQ R7, ok 422 MOVV $0, p+32(FP) 423 MOVV R2, err+40(FP) 424 RET 425 ok: 426 MOVV R2, p+32(FP) 427 MOVV $0, err+40(FP) 428 RET 429 430 TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0 431 MOVV addr+0(FP), R4 432 MOVV n+8(FP), R5 433 MOVV $SYS_munmap, R2 434 SYSCALL 435 BEQ R7, 2(PC) 436 MOVV R0, 0xf3(R0) // crash 437 RET 438 439 TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0 440 MOVV addr+0(FP), R4 441 MOVV n+8(FP), R5 442 MOVW flags+16(FP), R6 443 MOVV $SYS_madvise, R2 444 SYSCALL 445 MOVW R2, ret+24(FP) 446 RET 447 448 // int64 futex(int32 *uaddr, int32 op, int32 val, 449 // struct timespec *timeout, int32 *uaddr2, int32 val2); 450 TEXT runtime·futex(SB),NOSPLIT|NOFRAME,$0 451 MOVV addr+0(FP), R4 452 MOVW op+8(FP), R5 453 MOVW val+12(FP), R6 454 MOVV ts+16(FP), R7 455 MOVV addr2+24(FP), R8 456 MOVW val3+32(FP), R9 457 MOVV $SYS_futex, R2 458 SYSCALL 459 BEQ R7, 2(PC) 460 SUBVU R2, R0, R2 // caller expects negative errno 461 MOVW R2, ret+40(FP) 462 RET 463 464 // int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void)); 465 TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0 466 MOVW flags+0(FP), R4 467 MOVV stk+8(FP), R5 468 469 // Copy mp, gp, fn off parent stack for use by child. 470 // Careful: Linux system call clobbers ???. 471 MOVV mp+16(FP), R16 472 MOVV gp+24(FP), R17 473 MOVV fn+32(FP), R18 474 475 MOVV R16, -8(R5) 476 MOVV R17, -16(R5) 477 MOVV R18, -24(R5) 478 MOVV $1234, R16 479 MOVV R16, -32(R5) 480 481 MOVV $SYS_clone, R2 482 SYSCALL 483 BEQ R7, 2(PC) 484 SUBVU R2, R0, R2 // caller expects negative errno 485 486 // In parent, return. 487 BEQ R2, 3(PC) 488 MOVW R2, ret+40(FP) 489 RET 490 491 // In child, on new stack. 492 MOVV -32(R29), R16 493 MOVV $1234, R1 494 BEQ R16, R1, 2(PC) 495 MOVV R0, 0(R0) 496 497 // Initialize m->procid to Linux tid 498 MOVV $SYS_gettid, R2 499 SYSCALL 500 501 MOVV -24(R29), R18 // fn 502 MOVV -16(R29), R17 // g 503 MOVV -8(R29), R16 // m 504 505 BEQ R16, nog 506 BEQ R17, nog 507 508 MOVV R2, m_procid(R16) 509 510 // TODO: setup TLS. 511 512 // In child, set up new stack 513 MOVV R16, g_m(R17) 514 MOVV R17, g 515 //CALL runtime·stackcheck(SB) 516 517 nog: 518 // Call fn 519 JAL (R18) 520 521 // It shouldn't return. If it does, exit that thread. 522 MOVW $111, R4 523 MOVV $SYS_exit, R2 524 SYSCALL 525 JMP -3(PC) // keep exiting 526 527 TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0 528 MOVV new+0(FP), R4 529 MOVV old+8(FP), R5 530 MOVV $SYS_sigaltstack, R2 531 SYSCALL 532 BEQ R7, 2(PC) 533 MOVV R0, 0xf1(R0) // crash 534 RET 535 536 TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0 537 MOVV $SYS_sched_yield, R2 538 SYSCALL 539 RET 540 541 TEXT runtime·sched_getaffinity(SB),NOSPLIT|NOFRAME,$0 542 MOVV pid+0(FP), R4 543 MOVV len+8(FP), R5 544 MOVV buf+16(FP), R6 545 MOVV $SYS_sched_getaffinity, R2 546 SYSCALL 547 BEQ R7, 2(PC) 548 SUBVU R2, R0, R2 // caller expects negative errno 549 MOVW R2, ret+24(FP) 550 RET 551 552 // int32 runtime·epollcreate(int32 size); 553 TEXT runtime·epollcreate(SB),NOSPLIT|NOFRAME,$0 554 MOVW size+0(FP), R4 555 MOVV $SYS_epoll_create, R2 556 SYSCALL 557 BEQ R7, 2(PC) 558 SUBVU R2, R0, R2 // caller expects negative errno 559 MOVW R2, ret+8(FP) 560 RET 561 562 // int32 runtime·epollcreate1(int32 flags); 563 TEXT runtime·epollcreate1(SB),NOSPLIT|NOFRAME,$0 564 MOVW flags+0(FP), R4 565 MOVV $SYS_epoll_create1, R2 566 SYSCALL 567 BEQ R7, 2(PC) 568 SUBVU R2, R0, R2 // caller expects negative errno 569 MOVW R2, ret+8(FP) 570 RET 571 572 // func epollctl(epfd, op, fd int32, ev *epollEvent) int 573 TEXT runtime·epollctl(SB),NOSPLIT|NOFRAME,$0 574 MOVW epfd+0(FP), R4 575 MOVW op+4(FP), R5 576 MOVW fd+8(FP), R6 577 MOVV ev+16(FP), R7 578 MOVV $SYS_epoll_ctl, R2 579 SYSCALL 580 SUBVU R2, R0, R2 // caller expects negative errno 581 MOVW R2, ret+24(FP) 582 RET 583 584 // int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout); 585 TEXT runtime·epollwait(SB),NOSPLIT|NOFRAME,$0 586 // This uses pwait instead of wait, because Android O blocks wait. 587 MOVW epfd+0(FP), R4 588 MOVV ev+8(FP), R5 589 MOVW nev+16(FP), R6 590 MOVW timeout+20(FP), R7 591 MOVV $0, R8 592 MOVV $SYS_epoll_pwait, R2 593 SYSCALL 594 BEQ R7, 2(PC) 595 SUBVU R2, R0, R2 // caller expects negative errno 596 MOVW R2, ret+24(FP) 597 RET 598 599 // void runtime·closeonexec(int32 fd); 600 TEXT runtime·closeonexec(SB),NOSPLIT|NOFRAME,$0 601 MOVW fd+0(FP), R4 // fd 602 MOVV $2, R5 // F_SETFD 603 MOVV $1, R6 // FD_CLOEXEC 604 MOVV $SYS_fcntl, R2 605 SYSCALL 606 RET 607 608 // func runtime·setNonblock(int32 fd) 609 TEXT runtime·setNonblock(SB),NOSPLIT|NOFRAME,$0-4 610 MOVW fd+0(FP), R4 // fd 611 MOVV $3, R5 // F_GETFL 612 MOVV $0, R6 613 MOVV $SYS_fcntl, R2 614 SYSCALL 615 MOVW $0x80, R6 // O_NONBLOCK 616 OR R2, R6 617 MOVW fd+0(FP), R4 // fd 618 MOVV $4, R5 // F_SETFL 619 MOVV $SYS_fcntl, R2 620 SYSCALL 621 RET 622 623 // func sbrk0() uintptr 624 TEXT runtime·sbrk0(SB),NOSPLIT|NOFRAME,$0-8 625 // Implemented as brk(NULL). 626 MOVV $0, R4 627 MOVV $SYS_brk, R2 628 SYSCALL 629 MOVV R2, ret+0(FP) 630 RET 631 632 TEXT runtime·access(SB),$0-20 633 MOVV R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go 634 MOVW R0, ret+16(FP) // for vet 635 RET 636 637 TEXT runtime·connect(SB),$0-28 638 MOVV R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go 639 MOVW R0, ret+24(FP) // for vet 640 RET 641 642 TEXT runtime·socket(SB),$0-20 643 MOVV R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go 644 MOVW R0, ret+16(FP) // for vet 645 RET