Text file
src/runtime/sys_freebsd_riscv64.s
1 // Copyright 2022 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, FreeBSD
7 // /usr/src/sys/kern/syscalls.master for syscall numbers.
8 //
9
10 #include "go_asm.h"
11 #include "go_tls.h"
12 #include "textflag.h"
13
14 #define CLOCK_REALTIME 0
15 #define CLOCK_MONOTONIC 4
16
17 #define SYS_exit 1
18 #define SYS_read 3
19 #define SYS_write 4
20 #define SYS_open 5
21 #define SYS_close 6
22 #define SYS_getpid 20
23 #define SYS_kill 37
24 #define SYS_sigaltstack 53
25 #define SYS_munmap 73
26 #define SYS_madvise 75
27 #define SYS_setitimer 83
28 #define SYS_fcntl 92
29 #define SYS___sysctl 202
30 #define SYS_nanosleep 240
31 #define SYS_issetugid 253
32 #define SYS_clock_gettime 232
33 #define SYS_sched_yield 331
34 #define SYS_sigprocmask 340
35 #define SYS_kqueue 362
36 #define SYS_sigaction 416
37 #define SYS_thr_exit 431
38 #define SYS_thr_self 432
39 #define SYS_thr_kill 433
40 #define SYS__umtx_op 454
41 #define SYS_thr_new 455
42 #define SYS_mmap 477
43 #define SYS_cpuset_getaffinity 487
44 #define SYS_pipe2 542
45 #define SYS_kevent 560
46
47 TEXT emptyfunc<>(SB),0,$0-0
48 RET
49
50 // func sys_umtx_op(addr *uint32, mode int32, val uint32, uaddr1 uintptr, ut *umtx_time) int32
51 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
52 MOV addr+0(FP), A0
53 MOVW mode+8(FP), A1
54 MOVW val+12(FP), A2
55 MOV uaddr1+16(FP), A3
56 MOV ut+24(FP), A4
57 MOV $SYS__umtx_op, T0
58 ECALL
59 BEQ T0, ZERO, ok
60 NEG A0, A0
61 ok:
62 MOVW A0, ret+32(FP)
63 RET
64
65 // func thr_new(param *thrparam, size int32) int32
66 TEXT runtime·thr_new(SB),NOSPLIT,$0
67 MOV param+0(FP), A0
68 MOVW size+8(FP), A1
69 MOV $SYS_thr_new, T0
70 ECALL
71 BEQ T0, ZERO, ok
72 NEG A0, A0
73 ok:
74 MOVW A0, ret+16(FP)
75 RET
76
77 // func thr_start()
78 TEXT runtime·thr_start(SB),NOSPLIT,$0
79 // set up g
80 MOV m_g0(A0), g
81 MOV A0, g_m(g)
82 CALL emptyfunc<>(SB) // fault if stack check is wrong
83 CALL runtime·mstart(SB)
84
85 WORD $0 // crash
86 RET
87
88 // func exit(code int32)
89 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
90 MOVW code+0(FP), A0
91 MOV $SYS_exit, T0
92 ECALL
93 WORD $0 // crash
94
95 // func exitThread(wait *atomic.Uint32)
96 TEXT runtime·exitThread(SB),NOSPLIT|NOFRAME,$0-8
97 MOV wait+0(FP), A0
98 // We're done using the stack.
99 FENCE
100 MOVW ZERO, (A0)
101 FENCE
102 MOV $0, A0 // exit code
103 MOV $SYS_thr_exit, T0
104 ECALL
105 JMP 0(PC)
106
107 // func open(name *byte, mode, perm int32) int32
108 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0-20
109 MOV name+0(FP), A0
110 MOVW mode+8(FP), A1
111 MOVW perm+12(FP), A2
112 MOV $SYS_open, T0
113 ECALL
114 BEQ T0, ZERO, ok
115 MOV $-1, A0
116 ok:
117 MOVW A0, ret+16(FP)
118 RET
119
120 // func closefd(fd int32) int32
121 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0-12
122 MOVW fd+0(FP), A0
123 MOV $SYS_close, T0
124 ECALL
125 BEQ T0, ZERO, ok
126 MOV $-1, A0
127 ok:
128 MOVW A0, ret+8(FP)
129 RET
130
131 // func pipe2(flags int32) (r, w int32, errno int32)
132 TEXT runtime·pipe2(SB),NOSPLIT|NOFRAME,$0-20
133 MOV $r+8(FP), A0
134 MOVW flags+0(FP), A1
135 MOV $SYS_pipe2, T0
136 ECALL
137 BEQ T0, ZERO, ok
138 NEG A0, A0
139 ok:
140 MOVW A0, errno+16(FP)
141 RET
142
143 // func write1(fd uintptr, p unsafe.Pointer, n int32) int32
144 TEXT runtime·write1(SB),NOSPLIT|NOFRAME,$0-28
145 MOV fd+0(FP), A0
146 MOV p+8(FP), A1
147 MOVW n+16(FP), A2
148 MOV $SYS_write, T0
149 ECALL
150 BEQ T0, ZERO, ok
151 NEG A0, A0
152 ok:
153 MOVW A0, ret+24(FP)
154 RET
155
156 // func read(fd int32, p unsafe.Pointer, n int32) int32
157 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0-28
158 MOVW fd+0(FP), A0
159 MOV p+8(FP), A1
160 MOVW n+16(FP), A2
161 MOV $SYS_read, T0
162 ECALL
163 BEQ T0, ZERO, ok
164 NEG A0, A0
165 ok:
166 MOVW A0, ret+24(FP)
167 RET
168
169 // func usleep(usec uint32)
170 TEXT runtime·usleep(SB),NOSPLIT,$24-4
171 MOVWU usec+0(FP), A0
172 MOV $1000, A1
173 MUL A1, A0, A0
174 MOV $1000000000, A1
175 DIV A1, A0, A2
176 MOV A2, 8(X2)
177 REM A1, A0, A3
178 MOV A3, 16(X2)
179 ADD $8, X2, A0
180 MOV ZERO, A1
181 MOV $SYS_nanosleep, T0
182 ECALL
183 RET
184
185 // func thr_self() thread
186 TEXT runtime·thr_self(SB),NOSPLIT,$8-8
187 MOV $ptr-8(SP), A0 // arg 1 &8(SP)
188 MOV $SYS_thr_self, T0
189 ECALL
190 MOV ptr-8(SP), A0
191 MOV A0, ret+0(FP)
192 RET
193
194 // func thr_kill(t thread, sig int)
195 TEXT runtime·thr_kill(SB),NOSPLIT,$0-16
196 MOV tid+0(FP), A0 // arg 1 pid
197 MOV sig+8(FP), A1 // arg 2 sig
198 MOV $SYS_thr_kill, T0
199 ECALL
200 RET
201
202 // func raiseproc(sig uint32)
203 TEXT runtime·raiseproc(SB),NOSPLIT|NOFRAME,$0
204 MOV $SYS_getpid, T0
205 ECALL
206 // arg 1 pid - already in A0
207 MOVW sig+0(FP), A1 // arg 2
208 MOV $SYS_kill, T0
209 ECALL
210 RET
211
212 // func setitimer(mode int32, new, old *itimerval)
213 TEXT runtime·setitimer(SB),NOSPLIT|NOFRAME,$0-24
214 MOVW mode+0(FP), A0
215 MOV new+8(FP), A1
216 MOV old+16(FP), A2
217 MOV $SYS_setitimer, T0
218 ECALL
219 RET
220
221 // func fallback_walltime() (sec int64, nsec int32)
222 TEXT runtime·fallback_walltime(SB),NOSPLIT,$24-12
223 MOV $CLOCK_REALTIME, A0
224 MOV $8(X2), A1
225 MOV $SYS_clock_gettime, T0
226 ECALL
227 MOV 8(X2), T0 // sec
228 MOVW 16(X2), T1 // nsec
229 MOV T0, sec+0(FP)
230 MOVW T1, nsec+8(FP)
231 RET
232
233 // func fallback_nanotime() int64
234 TEXT runtime·fallback_nanotime(SB),NOSPLIT,$24-8
235 MOV $CLOCK_MONOTONIC, A0
236 MOV $8(X2), A1
237 MOV $SYS_clock_gettime, T0
238 ECALL
239 MOV 8(X2), T0 // sec
240 MOV 16(X2), T1 // nsec
241
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
248 MOV T0, ret+0(FP)
249 RET
250
251 // func asmSigaction(sig uintptr, new, old *sigactiont) int32
252 TEXT runtime·asmSigaction(SB),NOSPLIT|NOFRAME,$0
253 MOV sig+0(FP), A0 // arg 1 sig
254 MOV new+8(FP), A1 // arg 2 act
255 MOV old+16(FP), A2 // arg 3 oact
256 MOV $SYS_sigaction, T0
257 ECALL
258 BEQ T0, ZERO, ok
259 MOV $-1, A0
260 ok:
261 MOVW A0, ret+24(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, ok
283 CALL runtime·load_g(SB)
284 ok:
285 MOV $runtime·sigtrampgo(SB), A0
286 JALR RA, A0
287 RET
288
289 // func mmap(addr uintptr, n uintptr, prot int, flags int, fd int, off int64) (ret uintptr, err error)
290 TEXT runtime·mmap(SB),NOSPLIT|NOFRAME,$0
291 MOV addr+0(FP), A0
292 MOV n+8(FP), A1
293 MOVW prot+16(FP), A2
294 MOVW flags+20(FP), A3
295 MOVW fd+24(FP), A4
296 MOVW off+28(FP), A5
297 MOV $SYS_mmap, T0
298 ECALL
299 BNE T0, ZERO, fail
300 MOV A0, p+32(FP)
301 MOV ZERO, err+40(FP)
302 RET
303 fail:
304 MOV ZERO, p+32(FP)
305 MOV A0, err+40(FP)
306 RET
307
308 // func munmap(addr uintptr, n uintptr) (err error)
309 TEXT runtime·munmap(SB),NOSPLIT|NOFRAME,$0
310 MOV addr+0(FP), A0
311 MOV n+8(FP), A1
312 MOV $SYS_munmap, T0
313 ECALL
314 BNE T0, ZERO, fail
315 RET
316 fail:
317 WORD $0 // crash
318
319 // func madvise(addr unsafe.Pointer, n uintptr, flags int32) int32
320 TEXT runtime·madvise(SB),NOSPLIT|NOFRAME,$0
321 MOV addr+0(FP), A0
322 MOV n+8(FP), A1
323 MOVW flags+16(FP), A2
324 MOV $SYS_madvise, T0
325 ECALL
326 BEQ T0, ZERO, ok
327 MOV $-1, A0
328 ok:
329 MOVW A0, ret+24(FP)
330 RET
331
332 // func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
333 TEXT runtime·sysctl(SB),NOSPLIT,$0
334 MOV mib+0(FP), A0
335 MOV miblen+8(FP), A1
336 MOV out+16(FP), A2
337 MOV size+24(FP), A3
338 MOV dst+32(FP), A4
339 MOV ndst+40(FP), A5
340 MOV $SYS___sysctl, T0
341 ECALL
342 BEQ T0, ZERO, ok
343 NEG A0, A0
344 ok:
345 MOVW A0, ret+48(FP)
346 RET
347
348 // func sigaltstack(new, old *stackt)
349 TEXT runtime·sigaltstack(SB),NOSPLIT|NOFRAME,$0
350 MOV new+0(FP), A0
351 MOV old+8(FP), A1
352 MOV $SYS_sigaltstack, T0
353 ECALL
354 BNE T0, ZERO, fail
355 RET
356 fail:
357 WORD $0 // crash
358
359 // func osyield()
360 TEXT runtime·osyield(SB),NOSPLIT|NOFRAME,$0
361 MOV $SYS_sched_yield, T0
362 ECALL
363 RET
364
365 // func sigprocmask(how int32, new, old *sigset)
366 TEXT runtime·sigprocmask(SB),NOSPLIT|NOFRAME,$0-24
367 MOVW how+0(FP), A0
368 MOV new+8(FP), A1
369 MOV old+16(FP), A2
370 MOV $SYS_sigprocmask, T0
371 ECALL
372 BNE T0, ZERO, fail
373 RET
374 fail:
375 WORD $0 // crash
376
377
378 // func cpuset_getaffinity(level int, which int, id int64, size int, mask *byte) int32
379 TEXT runtime·cpuset_getaffinity(SB),NOSPLIT|NOFRAME,$0-44
380 MOV level+0(FP), A0
381 MOV which+8(FP), A1
382 MOV id+16(FP), A2
383 MOV size+24(FP), A3
384 MOV mask+32(FP), A4
385 MOV $SYS_cpuset_getaffinity, T0
386 ECALL
387 BEQ T0, ZERO, ok
388 MOV $-1, A0
389 ok:
390 MOVW A0, ret+40(FP)
391 RET
392
393 // func kqueue() int32
394 TEXT runtime·kqueue(SB),NOSPLIT|NOFRAME,$0
395 MOV $SYS_kqueue, T0
396 ECALL
397 BEQ T0, ZERO, ok
398 MOV $-1, A0
399 ok:
400 MOVW A0, ret+0(FP)
401 RET
402
403 // func kevent(kq int, ch unsafe.Pointer, nch int, ev unsafe.Pointer, nev int, ts *Timespec) (n int, err error)
404 TEXT runtime·kevent(SB),NOSPLIT,$0
405 MOVW kq+0(FP), A0
406 MOV ch+8(FP), A1
407 MOVW nch+16(FP), A2
408 MOV ev+24(FP), A3
409 MOVW nev+32(FP), A4
410 MOV ts+40(FP), A5
411 MOV $SYS_kevent, T0
412 ECALL
413 BEQ T0, ZERO, ok
414 NEG A0, A0
415 ok:
416 MOVW A0, ret+48(FP)
417 RET
418
419 // func fcntl(fd, cmd, arg int32) (int32, int32)
420 TEXT runtime·fcntl(SB),NOSPLIT,$0
421 MOVW fd+0(FP), A0
422 MOVW cmd+4(FP), A1
423 MOVW arg+8(FP), A2
424 MOV $SYS_fcntl, T0
425 ECALL
426 BEQ T0, ZERO, noerr
427 MOV $-1, A1
428 MOVW A1, ret+16(FP)
429 MOVW A0, errno+20(FP)
430 RET
431 noerr:
432 MOVW A0, ret+16(FP)
433 MOVW ZERO, errno+20(FP)
434 RET
435
436 // func getCntxct() uint32
437 TEXT runtime·getCntxct(SB),NOSPLIT|NOFRAME,$0
438 RDTIME A0
439 MOVW A0, ret+0(FP)
440 RET
441
442 // func issetugid() int32
443 TEXT runtime·issetugid(SB),NOSPLIT|NOFRAME,$0
444 MOV $SYS_issetugid, T0
445 ECALL
446 MOVW A0, ret+0(FP)
447 RET
448
449
View as plain text