Text file
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 #define CLOCK_REALTIME 0
14 #define CLOCK_MONOTONIC 1
15
16 #define SYS_brk 214
17 #define SYS_clock_gettime 113
18 #define SYS_clone 220
19 #define SYS_close 57
20 #define SYS_connect 203
21 #define SYS_epoll_create1 20
22 #define SYS_epoll_ctl 21
23 #define SYS_epoll_pwait 22
24 #define SYS_exit 93
25 #define SYS_exit_group 94
26 #define SYS_faccessat 48
27 #define SYS_fcntl 25
28 #define SYS_futex 98
29 #define SYS_getpid 172
30 #define SYS_gettid 178
31 #define SYS_gettimeofday 169
32 #define SYS_kill 129
33 #define SYS_madvise 233
34 #define SYS_mincore 232
35 #define SYS_mmap 222
36 #define SYS_munmap 215
37 #define SYS_nanosleep 101
38 #define SYS_openat 56
39 #define SYS_pipe2 59
40 #define SYS_pselect6 72
41 #define SYS_read 63
42 #define SYS_rt_sigaction 134
43 #define SYS_rt_sigprocmask 135
44 #define SYS_rt_sigreturn 139
45 #define SYS_sched_getaffinity 123
46 #define SYS_sched_yield 124
47 #define SYS_setitimer 103
48 #define SYS_sigaltstack 132
49 #define SYS_socket 198
50 #define SYS_tgkill 131
51 #define SYS_timer_create 107
52 #define SYS_timer_delete 111
53 #define SYS_timer_settime 110
54 #define SYS_tkill 130
55 #define SYS_write 64
56
57 // func exit(code int32)
58 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
59 MOVW code+0(FP), A0
60 MOV $SYS_exit_group, A7
61 ECALL
62 RET
63
64 // func exitThread(wait *uint32)
65 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8
66 MOV wait+0(FP), A0
67 // We're done using the stack.
68 FENCE
69 MOVW ZERO, (A0)
70 FENCE
71 MOV $0, A0 // exit code
72 MOV $SYS_exit, A7
73 ECALL
74 JMP 0(PC)
75
76 // func open(name *byte, mode, perm int32) int32
77 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20
78 MOV $AT_FDCWD, A0
79 MOV name+0(FP), A1
80 MOVW mode+8(FP), A2
81 MOVW perm+12(FP), A3
82 MOV $SYS_openat, A7
83 ECALL
84 MOV $-4096, T0
85 BGEU T0, A0, 2(PC)
86 MOV $-1, A0
87 MOVW A0, ret+16(FP)
88 RET
89
90 // func closefd(fd int32) int32
91 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12
92 MOVW fd+0(FP), A0
93 MOV $SYS_close, A7
94 ECALL
95 MOV $-4096, T0
96 BGEU T0, A0, 2(PC)
97 MOV $-1, A0
98 MOVW A0, ret+8(FP)
99 RET
100
101 // func write1(fd uintptr, p unsafe.Pointer, n int32) int32
102 TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28
103 MOV fd+0(FP), A0
104 MOV p+8(FP), A1
105 MOVW n+16(FP), A2
106 MOV $SYS_write, A7
107 ECALL
108 MOVW A0, ret+24(FP)
109 RET
110
111 // func read(fd int32, p unsafe.Pointer, n int32) int32
112 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28
113 MOVW fd+0(FP), A0
114 MOV p+8(FP), A1
115 MOVW n+16(FP), A2
116 MOV $SYS_read, A7
117 ECALL
118 MOVW A0, ret+24(FP)
119 RET
120
121 // func pipe2(flags int32) (r, w int32, errno int32)
122 TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20
123 MOV $r+8(FP), A0
124 MOVW flags+0(FP), A1
125 MOV $SYS_pipe2, A7
126 ECALL
127 MOVW A0, errno+16(FP)
128 RET
129
130 // func usleep(usec uint32)
131 TEXT runtime·usleep(SB),NOSPLIT,$24-4
132 MOVWU usec+0(FP), A0
133 MOV $1000, A1
134 MUL A1, A0, A0
135 MOV $1000000000, A1
136 DIV A1, A0, A2
137 MOV A2, 8(X2)
138 REM A1, A0, A3
139 MOV A3, 16(X2)
140 ADD $8, X2, A0
141 MOV ZERO, A1
142 MOV $SYS_nanosleep, A7
143 ECALL
144 RET
145
146 // func gettid() uint32
147 TEXT runtime·gettid(SB),NOSPLIT,$0-4
148 MOV $SYS_gettid, A7
149 ECALL
150 MOVW A0, ret+0(FP)
151 RET
152
153 // func raise(sig uint32)
154 TEXT runtime·raise(SB),NOSPLIT|NOFRAME,$0
155 MOV $SYS_gettid, A7
156 ECALL
157 // arg 1 tid - already in A0
158 MOVW sig+0(FP), A1 // arg 2
159 MOV $SYS_tkill, A7
160 ECALL
161 RET
162
163 // func raiseproc(sig uint32)
164 TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0
165 MOV $SYS_getpid, A7
166 ECALL
167 // arg 1 pid - already in A0
168 MOVW sig+0(FP), A1 // arg 2
169 MOV $SYS_kill, A7
170 ECALL
171 RET
172
173 // func getpid() int
174 TEXT ·getpid(SB),NOSPLIT|NOFRAME,$0-8
175 MOV $SYS_getpid, A7
176 ECALL
177 MOV A0, ret+0(FP)
178 RET
179
180 // func tgkill(tgid, tid, sig int)
181 TEXT ·tgkill(SB),NOSPLIT|NOFRAME,$0-24
182 MOV tgid+0(FP), A0
183 MOV tid+8(FP), A1
184 MOV sig+16(FP), A2
185 MOV $SYS_tgkill, A7
186 ECALL
187 RET
188
189 // func setitimer(mode int32, new, old *itimerval)
190 TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24
191 MOVW mode+0(FP), A0
192 MOV new+8(FP), A1
193 MOV old+16(FP), A2
194 MOV $SYS_setitimer, A7
195 ECALL
196 RET
197
198 // func timer_create(clockid int32, sevp *sigevent, timerid *int32) int32
199 TEXT runtime·timer_create(SB),NOSPLIT,$0-28
200 MOVW clockid+0(FP), A0
201 MOV sevp+8(FP), A1
202 MOV timerid+16(FP), A2
203 MOV $SYS_timer_create, A7
204 ECALL
205 MOVW A0, ret+24(FP)
206 RET
207
208 // func timer_settime(timerid int32, flags int32, new, old *itimerspec) int32
209 TEXT runtime·timer_settime(SB),NOSPLIT,$0-28
210 MOVW timerid+0(FP), A0
211 MOVW flags+4(FP), A1
212 MOV new+8(FP), A2
213 MOV old+16(FP), A3
214 MOV $SYS_timer_settime, A7
215 ECALL
216 MOVW A0, ret+24(FP)
217 RET
218
219 // func timer_delete(timerid int32) int32
220 TEXT runtime·timer_delete(SB),NOSPLIT,$0-12
221 MOVW timerid+0(FP), A0
222 MOV $SYS_timer_delete, A7
223 ECALL
224 MOVW A0, ret+8(FP)
225 RET
226
227 // func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
228 TEXT runtime·mincore(SB),NOSPLIT|NOFRAME,$0-28
229 MOV addr+0(FP), A0
230 MOV n+8(FP), A1
231 MOV dst+16(FP), A2
232 MOV $SYS_mincore, A7
233 ECALL
234 MOVW A0, ret+24(FP)
235 RET
236
237 // func walltime() (sec int64, nsec int32)
238 TEXT runtime·walltime(SB),NOSPLIT,$40-12
239 MOV $CLOCK_REALTIME, A0
240
241 MOV runtime·vdsoClockgettimeSym(SB), A7
242 BEQZ A7, fallback
243 MOV X2, S2 // S2,S3,S4 is unchanged by C code
244 MOV g_m(g), S3 // S3 = m
245
246 // Save the old values on stack for reentrant
247 MOV m_vdsoPC(S3), T0
248 MOV T0, 24(X2)
249 MOV m_vdsoSP(S3), T0
250 MOV T0, 32(X2)
251
252 MOV RA, m_vdsoPC(S3)
253 MOV $ret-8(FP), T1 // caller's SP
254 MOV T1, m_vdsoSP(S3)
255
256 MOV m_curg(S3), T1
257 BNE g, T1, noswitch
258
259 MOV m_g0(S3), T1
260 MOV (g_sched+gobuf_sp)(T1), X2
261
262 noswitch:
263 ADDI $-24, X2 // Space for result
264 ANDI $~7, X2 // Align for C code
265 MOV $8(X2), A1
266
267 // Store g on gsignal's stack, see sys_linux_arm64.s for detail
268 MOVBU runtime·iscgo(SB), S4
269 BNEZ S4, nosaveg
270 MOV m_gsignal(S3), S4 // g.m.gsignal
271 BEQZ S4, nosaveg
272 BEQ g, S4, nosaveg
273 MOV (g_stack+stack_lo)(S4), S4 // g.m.gsignal.stack.lo
274 MOV g, (S4)
275
276 JALR RA, A7
277
278 MOV ZERO, (S4)
279 JMP finish
280
281 nosaveg:
282 JALR RA, A7
283
284 finish:
285 MOV 8(X2), T0 // sec
286 MOV 16(X2), T1 // nsec
287
288 MOV S2, X2 // restore stack
289 MOV 24(X2), A2
290 MOV A2, m_vdsoPC(S3)
291
292 MOV 32(X2), A3
293 MOV A3, m_vdsoSP(S3)
294
295 MOV T0, sec+0(FP)
296 MOVW T1, nsec+8(FP)
297 RET
298
299 fallback:
300 MOV $8(X2), A1
301 MOV $SYS_clock_gettime, A7
302 ECALL
303 MOV 8(X2), T0 // sec
304 MOV 16(X2), T1 // nsec
305 MOV T0, sec+0(FP)
306 MOVW T1, nsec+8(FP)
307 RET
308
309 // func nanotime1() int64
310 TEXT runtime·nanotime1(SB),NOSPLIT,$40-8
311 MOV $CLOCK_MONOTONIC, A0
312
313 MOV runtime·vdsoClockgettimeSym(SB), A7
314 BEQZ A7, fallback
315
316 MOV X2, S2 // S2 = RSP, S2 is unchanged by C code
317 MOV g_m(g), S3 // S3 = m
318 // Save the old values on stack for reentrant
319 MOV m_vdsoPC(S3), T0
320 MOV T0, 24(X2)
321 MOV m_vdsoSP(S3), T0
322 MOV T0, 32(X2)
323
324 MOV RA, m_vdsoPC(S3)
325 MOV $ret-8(FP), T0 // caller's SP
326 MOV T0, m_vdsoSP(S3)
327
328 MOV m_curg(S3), T1
329 BNE g, T1, noswitch
330
331 MOV m_g0(S3), T1
332 MOV (g_sched+gobuf_sp)(T1), X2
333
334 noswitch:
335 ADDI $-24, X2 // Space for result
336 ANDI $~7, X2 // Align for C code
337 MOV $8(X2), A1
338
339 // Store g on gsignal's stack, see sys_linux_arm64.s for detail
340 MOVBU runtime·iscgo(SB), S4
341 BNEZ S4, nosaveg
342 MOV m_gsignal(S3), S4 // g.m.gsignal
343 BEQZ S4, nosaveg
344 BEQ g, S4, nosaveg
345 MOV (g_stack+stack_lo)(S4), S4 // g.m.gsignal.stack.lo
346 MOV g, (S4)
347
348 JALR RA, A7
349
350 MOV ZERO, (S4)
351 JMP finish
352
353 nosaveg:
354 JALR RA, A7
355
356 finish:
357 MOV 8(X2), T0 // sec
358 MOV 16(X2), T1 // nsec
359 // restore stack
360 MOV S2, X2
361 MOV 24(X2), T2
362 MOV T2, m_vdsoPC(S3)
363
364 MOV 32(X2), T2
365 MOV T2, m_vdsoSP(S3)
366 // sec is in T0, nsec in T1
367 // return nsec in T0
368 MOV $1000000000, T2
369 MUL T2, T0
370 ADD T1, T0
371 MOV T0, ret+0(FP)
372 RET
373
374 fallback:
375 MOV $8(X2), A1
376 MOV $SYS_clock_gettime, A7
377 ECALL
378 MOV 8(X2), T0 // sec
379 MOV 16(X2), T1 // nsec
380 MOV $1000000000, T2
381 MUL T2, T0
382 ADD T1, T0
383 MOV T0, ret+0(FP)
384 RET
385
386 // func rtsigprocmask(how int32, new, old *sigset, size int32)
387 TEXT runtime·rtsigprocmask(SB),NOSPLIT|NOFRAME,$0-28
388 MOVW how+0(FP), A0
389 MOV new+8(FP), A1
390 MOV old+16(FP), A2
391 MOVW size+24(FP), A3
392 MOV $SYS_rt_sigprocmask, A7
393 ECALL
394 MOV $-4096, T0
395 BLTU A0, T0, 2(PC)
396 WORD $0 // crash
397 RET
398
399 // func rt_sigaction(sig uintptr, new, old *sigactiont, size uintptr) int32
400 TEXT runtime·rt_sigaction(SB),NOSPLIT|NOFRAME,$0-36
401 MOV sig+0(FP), A0
402 MOV new+8(FP), A1
403 MOV old+16(FP), A2
404 MOV size+24(FP), A3
405 MOV $SYS_rt_sigaction, A7
406 ECALL
407 MOVW A0, ret+32(FP)
408 RET
409
410 // func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer)
411 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
412 MOVW sig+8(FP), A0
413 MOV info+16(FP), A1
414 MOV ctx+24(FP), A2
415 MOV fn+0(FP), T1
416 JALR RA, T1
417 RET
418
419 // func sigtramp(signo, ureg, ctxt unsafe.Pointer)
420 TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$64
421 MOVW A0, 8(X2)
422 MOV A1, 16(X2)
423 MOV A2, 24(X2)
424
425 // this might be called in external code context,
426 // where g is not set.
427 MOVBU runtime·iscgo(SB), A0
428 BEQ A0, ZERO, 2(PC)
429 CALL runtime·load_g(SB)
430
431 MOV $runtime·sigtrampgo(SB), A0
432 JALR RA, A0
433 RET
434
435 // func cgoSigtramp()
436 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
437 MOV $runtime·sigtramp(SB), T1
438 JALR ZERO, T1
439
440 // func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (p unsafe.Pointer, err int)
441 TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0
442 MOV addr+0(FP), A0
443 MOV n+8(FP), A1
444 MOVW prot+16(FP), A2
445 MOVW flags+20(FP), A3
446 MOVW fd+24(FP), A4
447 MOVW off+28(FP), A5
448 MOV $SYS_mmap, A7
449 ECALL
450 MOV $-4096, T0
451 BGEU T0, A0, 5(PC)
452 SUB A0, ZERO, A0
453 MOV ZERO, p+32(FP)
454 MOV A0, err+40(FP)
455 RET
456 ok:
457 MOV A0, p+32(FP)
458 MOV ZERO, err+40(FP)
459 RET
460
461 // func munmap(addr unsafe.Pointer, n uintptr)
462 TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0
463 MOV addr+0(FP), A0
464 MOV n+8(FP), A1
465 MOV $SYS_munmap, A7
466 ECALL
467 MOV $-4096, T0
468 BLTU A0, T0, 2(PC)
469 WORD $0 // crash
470 RET
471
472 // func madvise(addr unsafe.Pointer, n uintptr, flags int32)
473 TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0
474 MOV addr+0(FP), A0
475 MOV n+8(FP), A1
476 MOVW flags+16(FP), A2
477 MOV $SYS_madvise, A7
478 ECALL
479 MOVW A0, ret+24(FP)
480 RET
481
482 // func futex(addr unsafe.Pointer, op int32, val uint32, ts, addr2 unsafe.Pointer, val3 uint32) int32
483 TEXT runtime·futex(SB),NOSPLIT|NOFRAME,$0
484 MOV addr+0(FP), A0
485 MOVW op+8(FP), A1
486 MOVW val+12(FP), A2
487 MOV ts+16(FP), A3
488 MOV addr2+24(FP), A4
489 MOVW val3+32(FP), A5
490 MOV $SYS_futex, A7
491 ECALL
492 MOVW A0, ret+40(FP)
493 RET
494
495 // func clone(flags int32, stk, mp, gp, fn unsafe.Pointer) int32
496 TEXT runtime·clone(SB),NOSPLIT|NOFRAME,$0
497 MOVW flags+0(FP), A0
498 MOV stk+8(FP), A1
499
500 // Copy mp, gp, fn off parent stack for use by child.
501 MOV mp+16(FP), T0
502 MOV gp+24(FP), T1
503 MOV fn+32(FP), T2
504
505 MOV T0, -8(A1)
506 MOV T1, -16(A1)
507 MOV T2, -24(A1)
508 MOV $1234, T0
509 MOV T0, -32(A1)
510
511 MOV $SYS_clone, A7
512 ECALL
513
514 // In parent, return.
515 BEQ ZERO, A0, child
516 MOVW ZERO, ret+40(FP)
517 RET
518
519 child:
520 // In child, on new stack.
521 MOV -32(X2), T0
522 MOV $1234, A0
523 BEQ A0, T0, good
524 WORD $0 // crash
525
526 good:
527 // Initialize m->procid to Linux tid
528 MOV $SYS_gettid, A7
529 ECALL
530
531 MOV -24(X2), T2 // fn
532 MOV -16(X2), T1 // g
533 MOV -8(X2), T0 // m
534
535 BEQ ZERO, T0, nog
536 BEQ ZERO, T1, nog
537
538 MOV A0, m_procid(T0)
539
540 // In child, set up new stack
541 MOV T0, g_m(T1)
542 MOV T1, g
543
544 nog:
545 // Call fn
546 JALR RA, T2
547
548 // It shouldn't return. If it does, exit this thread.
549 MOV $111, A0
550 MOV $SYS_exit, A7
551 ECALL
552 JMP -3(PC) // keep exiting
553
554 // func sigaltstack(new, old *stackt)
555 TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0
556 MOV new+0(FP), A0
557 MOV old+8(FP), A1
558 MOV $SYS_sigaltstack, A7
559 ECALL
560 MOV $-4096, T0
561 BLTU A0, T0, 2(PC)
562 WORD $0 // crash
563 RET
564
565 // func osyield()
566 TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0
567 MOV $SYS_sched_yield, A7
568 ECALL
569 RET
570
571 // func sched_getaffinity(pid, len uintptr, buf *uintptr) int32
572 TEXT runtime·sched_getaffinity(SB),NOSPLIT|NOFRAME,$0
573 MOV pid+0(FP), A0
574 MOV len+8(FP), A1
575 MOV buf+16(FP), A2
576 MOV $SYS_sched_getaffinity, A7
577 ECALL
578 MOV A0, ret+24(FP)
579 RET
580
581 // func epollcreate(size int32) int32
582 TEXT runtime·epollcreate(SB),NOSPLIT|NOFRAME,$0
583 MOV $0, A0
584 MOV $SYS_epoll_create1, A7
585 ECALL
586 MOVW A0, ret+8(FP)
587 RET
588
589 // func epollcreate1(flags int32) int32
590 TEXT runtime·epollcreate1(SB),NOSPLIT|NOFRAME,$0
591 MOVW flags+0(FP), A0
592 MOV $SYS_epoll_create1, A7
593 ECALL
594 MOVW A0, ret+8(FP)
595 RET
596
597 // func epollctl(epfd, op, fd int32, ev *epollevent) int32
598 TEXT runtime·epollctl(SB),NOSPLIT|NOFRAME,$0
599 MOVW epfd+0(FP), A0
600 MOVW op+4(FP), A1
601 MOVW fd+8(FP), A2
602 MOV ev+16(FP), A3
603 MOV $SYS_epoll_ctl, A7
604 ECALL
605 MOVW A0, ret+24(FP)
606 RET
607
608 // func epollwait(epfd int32, ev *epollevent, nev, timeout int32) int32
609 TEXT runtime·epollwait(SB),NOSPLIT|NOFRAME,$0
610 MOVW epfd+0(FP), A0
611 MOV ev+8(FP), A1
612 MOVW nev+16(FP), A2
613 MOVW timeout+20(FP), A3
614 MOV $0, A4
615 MOV $SYS_epoll_pwait, A7
616 ECALL
617 MOVW A0, ret+24(FP)
618 RET
619
620 // func closeonexec(int32)
621 TEXT runtime·closeonexec(SB),NOSPLIT|NOFRAME,$0
622 MOVW fd+0(FP), A0 // fd
623 MOV $2, A1 // F_SETFD
624 MOV $1, A2 // FD_CLOEXEC
625 MOV $SYS_fcntl, A7
626 ECALL
627 RET
628
629 // func sbrk0() uintptr
630 TEXT runtime·sbrk0(SB),NOSPLIT,$0-8
631 // Implemented as brk(NULL).
632 MOV $0, A0
633 MOV $SYS_brk, A7
634 ECALL
635 MOVW A0, ret+0(FP)
636 RET
637
View as plain text