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