Text file
src/runtime/sys_linux_riscv64.s
Documentation: runtime
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
516
View as plain text