src/runtime/sys_linux_riscv64.s

   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