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