github.com/comwrg/go/src@v0.0.0-20220319063731-c238d0440370/runtime/sys_linux_riscv64.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 // 6 // System calls and other sys.stuff for riscv64, Linux 7 // 8 9 #include "textflag.h" 10 #include "go_asm.h" 11 12 #define AT_FDCWD -100 13 14 #define SYS_brk 214 15 #define SYS_clock_gettime 113 16 #define SYS_clone 220 17 #define SYS_close 57 18 #define SYS_connect 203 19 #define SYS_epoll_create1 20 20 #define SYS_epoll_ctl 21 21 #define SYS_epoll_pwait 22 22 #define SYS_exit 93 23 #define SYS_exit_group 94 24 #define SYS_faccessat 48 25 #define SYS_fcntl 25 26 #define SYS_futex 98 27 #define SYS_getpid 172 28 #define SYS_getrlimit 163 29 #define SYS_gettid 178 30 #define SYS_gettimeofday 169 31 #define SYS_kill 129 32 #define SYS_madvise 233 33 #define SYS_mincore 232 34 #define SYS_mmap 222 35 #define SYS_munmap 215 36 #define SYS_nanosleep 101 37 #define SYS_openat 56 38 #define SYS_pipe2 59 39 #define SYS_pselect6 72 40 #define SYS_read 63 41 #define SYS_rt_sigaction 134 42 #define SYS_rt_sigprocmask 135 43 #define SYS_rt_sigreturn 139 44 #define SYS_sched_getaffinity 123 45 #define SYS_sched_yield 124 46 #define SYS_setitimer 103 47 #define SYS_sigaltstack 132 48 #define SYS_socket 198 49 #define SYS_tgkill 131 50 #define SYS_tkill 130 51 #define SYS_write 64 52 53 // func exit(code int32) 54 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4 55 MOVW code+0(FP), A0 56 MOV $SYS_exit_group, A7 57 ECALL 58 RET 59 60 // func exitThread(wait *uint32) 61 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8 62 MOV wait+0(FP), A0 63 // We're done using the stack. 64 FENCE 65 MOVW ZERO, (A0) 66 FENCE 67 MOV $0, A0 // exit code 68 MOV $SYS_exit, A7 69 ECALL 70 JMP 0(PC) 71 72 // func open(name *byte, mode, perm int32) int32 73 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20 74 MOV $AT_FDCWD, A0 75 MOV name+0(FP), A1 76 MOVW mode+8(FP), A2 77 MOVW perm+12(FP), A3 78 MOV $SYS_openat, A7 79 ECALL 80 MOV $-4096, T0 81 BGEU T0, A0, 2(PC) 82 MOV $-1, A0 83 MOVW A0, ret+16(FP) 84 RET 85 86 // func closefd(fd int32) int32 87 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12 88 MOVW fd+0(FP), A0 89 MOV $SYS_close, A7 90 ECALL 91 MOV $-4096, T0 92 BGEU T0, A0, 2(PC) 93 MOV $-1, A0 94 MOVW A0, ret+8(FP) 95 RET 96 97 // func write1(fd uintptr, p unsafe.Pointer, n int32) int32 98 TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28 99 MOV fd+0(FP), A0 100 MOV p+8(FP), A1 101 MOVW n+16(FP), A2 102 MOV $SYS_write, A7 103 ECALL 104 MOVW A0, ret+24(FP) 105 RET 106 107 // func read(fd int32, p unsafe.Pointer, n int32) int32 108 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28 109 MOVW fd+0(FP), A0 110 MOV p+8(FP), A1 111 MOVW n+16(FP), A2 112 MOV $SYS_read, A7 113 ECALL 114 MOVW A0, ret+24(FP) 115 RET 116 117 // func pipe() (r, w int32, errno int32) 118 TEXT runtime·pipe(SB),NOSPLIT|NOFRAME,$0-12 119 MOV $r+0(FP), A0 120 MOV ZERO, A1 121 MOV $SYS_pipe2, A7 122 ECALL 123 MOVW A0, errno+8(FP) 124 RET 125 126 // func pipe2(flags int32) (r, w int32, errno int32) 127 TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20 128 MOV $r+8(FP), A0 129 MOVW flags+0(FP), A1 130 MOV $SYS_pipe2, A7 131 ECALL 132 MOVW A0, errno+16(FP) 133 RET 134 135 // func getrlimit(kind int32, limit unsafe.Pointer) int32 136 TEXT runtime·getrlimit(SB),NOSPLIT|NOFRAME,$0-20 137 MOVW kind+0(FP), A0 138 MOV limit+8(FP), A1 139 MOV $SYS_getrlimit, A7 140 ECALL 141 MOVW A0, ret+16(FP) 142 RET 143 144 // func usleep(usec uint32) 145 TEXT runtime·usleep(SB),NOSPLIT,$24-4 146 MOVWU usec+0(FP), A0 147 MOV $1000, A1 148 MUL A1, A0, A0 149 MOV $1000000000, A1 150 DIV A1, A0, A2 151 MOV A2, 8(X2) 152 REM A1, A0, A3 153 MOV A3, 16(X2) 154 ADD $8, X2, A0 155 MOV ZERO, A1 156 MOV $SYS_nanosleep, A7 157 ECALL 158 RET 159 160 // func gettid() uint32 161 TEXT runtime·gettid(SB),NOSPLIT,$0-4 162 MOV $SYS_gettid, A7 163 ECALL 164 MOVW A0, ret+0(FP) 165 RET 166 167 // func raise(sig uint32) 168 TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0 169 MOV $SYS_gettid, A7 170 ECALL 171 // arg 1 tid - already in A0 172 MOVW sig+0(FP), A1 // arg 2 173 MOV $SYS_tkill, A7 174 ECALL 175 RET 176 177 // func raiseproc(sig uint32) 178 TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0 179 MOV $SYS_getpid, A7 180 ECALL 181 // arg 1 pid - already in A0 182 MOVW sig+0(FP), A1 // arg 2 183 MOV $SYS_kill, A7 184 ECALL 185 RET 186 187 // func getpid() int 188 TEXT ·getpid(SB),NOSPLIT|NOFRAME,$0-8 189 MOV $SYS_getpid, A7 190 ECALL 191 MOV A0, ret+0(FP) 192 RET 193 194 // func tgkill(tgid, tid, sig int) 195 TEXT ·tgkill(SB),NOSPLIT|NOFRAME,$0-24 196 MOV tgid+0(FP), A0 197 MOV tid+8(FP), A1 198 MOV sig+16(FP), A2 199 MOV $SYS_tgkill, A7 200 ECALL 201 RET 202 203 // func setitimer(mode int32, new, old *itimerval) 204 TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24 205 MOVW mode+0(FP), A0 206 MOV new+8(FP), A1 207 MOV old+16(FP), A2 208 MOV $SYS_setitimer, A7 209 ECALL 210 RET 211 212 // func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32 213 TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28 214 MOV addr+0(FP), A0 215 MOV n+8(FP), A1 216 MOV dst+16(FP), A2 217 MOV $SYS_mincore, A7 218 ECALL 219 MOVW A0, ret+24(FP) 220 RET 221 222 // func walltime() (sec int64, nsec int32) 223 TEXT runtime·walltime(SB),NOSPLIT,$24-12 224 MOV $0, A0 // CLOCK_REALTIME 225 MOV $8(X2), A1 226 MOV $SYS_clock_gettime, A7 227 ECALL 228 MOV 8(X2), T0 // sec 229 MOV 16(X2), T1 // nsec 230 MOV T0, sec+0(FP) 231 MOVW T1, nsec+8(FP) 232 RET 233 234 // func nanotime1() int64 235 TEXT runtime·nanotime1(SB),NOSPLIT,$24-8 236 MOV $1, A0 // CLOCK_MONOTONIC 237 MOV $8(X2), A1 238 MOV $SYS_clock_gettime, A7 239 ECALL 240 MOV 8(X2), T0 // sec 241 MOV 16(X2), T1 // nsec 242 // sec is in T0, nsec in T1 243 // return nsec in T0 244 MOV $1000000000, T2 245 MUL T2, T0 246 ADD T1, T0 247 MOV T0, ret+0(FP) 248 RET 249 250 // func rtsigprocmask(how int32, new, old *sigset, size int32) 251 TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28 252 MOVW how+0(FP), A0 253 MOV new+8(FP), A1 254 MOV old+16(FP), A2 255 MOVW size+24(FP), A3 256 MOV $SYS_rt_sigprocmask, A7 257 ECALL 258 MOV $-4096, T0 259 BLTU A0, T0, 2(PC) 260 WORD $0 // crash 261 RET 262 263 // func rt_sigaction(sig uintptr, new, old *sigactiont, size uintptr) int32 264 TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36 265 MOV sig+0(FP), A0 266 MOV new+8(FP), A1 267 MOV old+16(FP), A2 268 MOV size+24(FP), A3 269 MOV $SYS_rt_sigaction, A7 270 ECALL 271 MOVW A0, ret+32(FP) 272 RET 273 274 // func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer) 275 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 276 MOVW sig+8(FP), A0 277 MOV info+16(FP), A1 278 MOV ctx+24(FP), A2 279 MOV fn+0(FP), T1 280 JALR RA, T1 281 RET 282 283 // func sigtramp(signo, ureg, ctxt unsafe.Pointer) 284 TEXT runtime·sigtramp(SB),NOSPLIT,$64 285 MOVW A0, 8(X2) 286 MOV A1, 16(X2) 287 MOV A2, 24(X2) 288 289 // this might be called in external code context, 290 // where g is not set. 291 MOVBU runtime·iscgo(SB), A0 292 BEQ A0, ZERO, 2(PC) 293 CALL runtime·load_g(SB) 294 295 MOV $runtime·sigtrampgo(SB), A0 296 JALR RA, A0 297 RET 298 299 // func cgoSigtramp() 300 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0 301 MOV $runtime·sigtramp(SB), T1 302 JALR ZERO, T1 303 304 // func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (p unsafe.Pointer, err int) 305 TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0 306 MOV addr+0(FP), A0 307 MOV n+8(FP), A1 308 MOVW prot+16(FP), A2 309 MOVW flags+20(FP), A3 310 MOVW fd+24(FP), A4 311 MOVW off+28(FP), A5 312 MOV $SYS_mmap, A7 313 ECALL 314 MOV $-4096, T0 315 BGEU T0, A0, 5(PC) 316 SUB A0, ZERO, A0 317 MOV ZERO, p+32(FP) 318 MOV A0, err+40(FP) 319 RET 320 ok: 321 MOV A0, p+32(FP) 322 MOV ZERO, err+40(FP) 323 RET 324 325 // func munmap(addr unsafe.Pointer, n uintptr) 326 TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0 327 MOV addr+0(FP), A0 328 MOV n+8(FP), A1 329 MOV $SYS_munmap, A7 330 ECALL 331 MOV $-4096, T0 332 BLTU A0, T0, 2(PC) 333 WORD $0 // crash 334 RET 335 336 // func madvise(addr unsafe.Pointer, n uintptr, flags int32) 337 TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0 338 MOV addr+0(FP), A0 339 MOV n+8(FP), A1 340 MOVW flags+16(FP), A2 341 MOV $SYS_madvise, A7 342 ECALL 343 MOVW A0, ret+24(FP) 344 RET 345 346 // func futex(addr unsafe.Pointer, op int32, val uint32, ts, addr2 unsafe.Pointer, val3 uint32) int32 347 TEXT runtime·futex(SB),NOSPLIT|NOFRAME,$0 348 MOV addr+0(FP), A0 349 MOVW op+8(FP), A1 350 MOVW val+12(FP), A2 351 MOV ts+16(FP), A3 352 MOV addr2+24(FP), A4 353 MOVW val3+32(FP), A5 354 MOV $SYS_futex, A7 355 ECALL 356 MOVW A0, ret+40(FP) 357 RET 358 359 // func clone(flags int32, stk, mp, gp, fn unsafe.Pointer) int32 360 TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0 361 MOVW flags+0(FP), A0 362 MOV stk+8(FP), A1 363 364 // Copy mp, gp, fn off parent stack for use by child. 365 MOV mp+16(FP), T0 366 MOV gp+24(FP), T1 367 MOV fn+32(FP), T2 368 369 MOV T0, -8(A1) 370 MOV T1, -16(A1) 371 MOV T2, -24(A1) 372 MOV $1234, T0 373 MOV T0, -32(A1) 374 375 MOV $SYS_clone, A7 376 ECALL 377 378 // In parent, return. 379 BEQ ZERO, A0, child 380 MOVW ZERO, ret+40(FP) 381 RET 382 383 child: 384 // In child, on new stack. 385 MOV -32(X2), T0 386 MOV $1234, A0 387 BEQ A0, T0, good 388 WORD $0 // crash 389 390 good: 391 // Initialize m->procid to Linux tid 392 MOV $SYS_gettid, A7 393 ECALL 394 395 MOV -24(X2), T2 // fn 396 MOV -16(X2), T1 // g 397 MOV -8(X2), T0 // m 398 399 BEQ ZERO, T0, nog 400 BEQ ZERO, T1, nog 401 402 MOV A0, m_procid(T0) 403 404 // In child, set up new stack 405 MOV T0, g_m(T1) 406 MOV T1, g 407 408 nog: 409 // Call fn 410 JALR RA, T2 411 412 // It shouldn't return. If it does, exit this thread. 413 MOV $111, A0 414 MOV $SYS_exit, A7 415 ECALL 416 JMP -3(PC) // keep exiting 417 418 // func sigaltstack(new, old *stackt) 419 TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0 420 MOV new+0(FP), A0 421 MOV old+8(FP), A1 422 MOV $SYS_sigaltstack, A7 423 ECALL 424 MOV $-4096, T0 425 BLTU A0, T0, 2(PC) 426 WORD $0 // crash 427 RET 428 429 // func osyield() 430 TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0 431 MOV $SYS_sched_yield, A7 432 ECALL 433 RET 434 435 // func sched_getaffinity(pid, len uintptr, buf *uintptr) int32 436 TEXT runtime·sched_getaffinity(SB),NOSPLIT|NOFRAME,$0 437 MOV pid+0(FP), A0 438 MOV len+8(FP), A1 439 MOV buf+16(FP), A2 440 MOV $SYS_sched_getaffinity, A7 441 ECALL 442 MOV A0, ret+24(FP) 443 RET 444 445 // func epollcreate(size int32) int32 446 TEXT runtime·epollcreate(SB),NOSPLIT|NOFRAME,$0 447 MOV $0, A0 448 MOV $SYS_epoll_create1, A7 449 ECALL 450 MOVW A0, ret+8(FP) 451 RET 452 453 // func epollcreate1(flags int32) int32 454 TEXT runtime·epollcreate1(SB),NOSPLIT|NOFRAME,$0 455 MOVW flags+0(FP), A0 456 MOV $SYS_epoll_create1, A7 457 ECALL 458 MOVW A0, ret+8(FP) 459 RET 460 461 // func epollctl(epfd, op, fd int32, ev *epollevent) int32 462 TEXT runtime·epollctl(SB),NOSPLIT|NOFRAME,$0 463 MOVW epfd+0(FP), A0 464 MOVW op+4(FP), A1 465 MOVW fd+8(FP), A2 466 MOV ev+16(FP), A3 467 MOV $SYS_epoll_ctl, A7 468 ECALL 469 MOVW A0, ret+24(FP) 470 RET 471 472 // func epollwait(epfd int32, ev *epollevent, nev, timeout int32) int32 473 TEXT runtime·epollwait(SB),NOSPLIT|NOFRAME,$0 474 MOVW epfd+0(FP), A0 475 MOV ev+8(FP), A1 476 MOVW nev+16(FP), A2 477 MOVW timeout+20(FP), A3 478 MOV $0, A4 479 MOV $SYS_epoll_pwait, A7 480 ECALL 481 MOVW A0, ret+24(FP) 482 RET 483 484 // func closeonexec(int32) 485 TEXT runtime·closeonexec(SB),NOSPLIT|NOFRAME,$0 486 MOVW fd+0(FP), A0 // fd 487 MOV $2, A1 // F_SETFD 488 MOV $1, A2 // FD_CLOEXEC 489 MOV $SYS_fcntl, A7 490 ECALL 491 RET 492 493 // func runtime·setNonblock(int32 fd) 494 TEXT runtime·setNonblock(SB),NOSPLIT|NOFRAME,$0-4 495 MOVW fd+0(FP), A0 // fd 496 MOV $3, A1 // F_GETFL 497 MOV $0, A2 498 MOV $SYS_fcntl, A7 499 ECALL 500 MOV $0x800, A2 // O_NONBLOCK 501 OR A0, A2 502 MOVW fd+0(FP), A0 // fd 503 MOV $4, A1 // F_SETFL 504 MOV $SYS_fcntl, A7 505 ECALL 506 RET 507 508 // func sbrk0() uintptr 509 TEXT runtime·sbrk0(SB),NOSPLIT,$0-8 510 // Implemented as brk(NULL). 511 MOV $0, A0 512 MOV $SYS_brk, A7 513 ECALL 514 MOVW A0, ret+0(FP) 515 RET