Text file src/runtime/sys_openbsd_arm64.s
1 // Copyright 2019 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 // System calls and other sys.stuff for arm64, OpenBSD
6 // /usr/src/sys/kern/syscalls.master for syscall numbers.
7 //
8
9 #include "go_asm.h"
10 #include "go_tls.h"
11 #include "textflag.h"
12
13 #define CLOCK_REALTIME $0
14 #define CLOCK_MONOTONIC $3
15
16 // Exit the entire program (like C exit)
17 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0
18 MOVW code+0(FP), R0 // arg 1 - status
19 MOVD $1, R8 // sys_exit
20 SVC
21 BCC 3(PC)
22 MOVD $0, R0 // crash on syscall failure
23 MOVD R0, (R0)
24 RET
25
26 // func exitThread(wait *uint32)
27 TEXT runtime·exitThread(SB),NOSPLIT,$0
28 MOVD wait+0(FP), R0 // arg 1 - notdead
29 MOVD $302, R8 // sys___threxit
30 SVC
31 MOVD $0, R0 // crash on syscall failure
32 MOVD R0, (R0)
33 JMP 0(PC)
34
35 TEXT runtime·open(SB),NOSPLIT|NOFRAME,$0
36 MOVD name+0(FP), R0 // arg 1 - path
37 MOVW mode+8(FP), R1 // arg 2 - mode
38 MOVW perm+12(FP), R2 // arg 3 - perm
39 MOVD $5, R8 // sys_open
40 SVC
41 BCC 2(PC)
42 MOVW $-1, R0
43 MOVW R0, ret+16(FP)
44 RET
45
46 TEXT runtime·closefd(SB),NOSPLIT|NOFRAME,$0
47 MOVW fd+0(FP), R0 // arg 1 - fd
48 MOVD $6, R8 // sys_close
49 SVC
50 BCC 2(PC)
51 MOVW $-1, R0
52 MOVW R0, ret+8(FP)
53 RET
54
55 TEXT runtime·read(SB),NOSPLIT|NOFRAME,$0
56 MOVW fd+0(FP), R0 // arg 1 - fd
57 MOVD p+8(FP), R1 // arg 2 - buf
58 MOVW n+16(FP), R2 // arg 3 - nbyte
59 MOVD $3, R8 // sys_read
60 SVC
61 BCC 2(PC)
62 MOVW $-1, R0
63 MOVW R0, ret+24(FP)
64 RET
65
66 TEXT runtime·write(SB),NOSPLIT|NOFRAME,$0
67 MOVW fd+0(FP), R0 // arg 1 - fd
68 MOVD p+8(FP), R1 // arg 2 - buf
69 MOVW n+16(FP), R2 // arg 3 - nbyte
70 MOVD $4, R8 // sys_write
71 SVC
72 BCC 2(PC)
73 MOVW $-1, R0
74 MOVW R0, ret+24(FP)
75 RET
76
77 TEXT runtime·usleep(SB),NOSPLIT,$24-4
78 MOVWU usec+0(FP), R3
79 MOVD R3, R5
80 MOVW $1000000, R4
81 UDIV R4, R3
82 MOVD R3, 8(RSP) // tv_sec
83 MUL R3, R4
84 SUB R4, R5
85 MOVW $1000, R4
86 MUL R4, R5
87 MOVD R5, 16(RSP) // tv_nsec
88
89 ADD $8, RSP, R0 // arg 1 - rqtp
90 MOVD $0, R1 // arg 2 - rmtp
91 MOVD $91, R8 // sys_nanosleep
92 SVC
93 RET
94
95 TEXT runtime·raise(SB),NOSPLIT,$0
96 MOVD $299, R8 // sys_getthrid
97 SVC
98 // arg 1 - tid, already in R0
99 MOVW sig+0(FP), R1 // arg 2 - signum
100 MOVW $0, R2 // arg 3 - tcb
101 MOVD $119, R8 // sys_thrkill
102 SVC
103 RET
104
105 TEXT runtime·raiseproc(SB),NOSPLIT,$0
106 MOVD $20, R8 // sys_getpid
107 SVC
108 // arg 1 - pid, already in R0
109 MOVW sig+0(FP), R1 // arg 2 - signum
110 MOVD $122, R8 // sys_kill
111 SVC
112 RET
113
114 TEXT runtime·mmap(SB),NOSPLIT,$0
115 MOVD addr+0(FP), R0 // arg 1 - addr
116 MOVD n+8(FP), R1 // arg 2 - len
117 MOVW prot+16(FP), R2 // arg 3 - prot
118 MOVW flags+20(FP), R3 // arg 4 - flags
119 MOVW fd+24(FP), R4 // arg 5 - fd
120 MOVW $0, R5 // arg 6 - pad
121 MOVW off+28(FP), R6 // arg 7 - offset
122 MOVD $197, R8 // sys_mmap
123 SVC
124 MOVD $0, R1
125 BCC 3(PC)
126 MOVD R0, R1 // if error, move to R1
127 MOVD $0, R0
128 MOVD R0, p+32(FP)
129 MOVD R1, err+40(FP)
130 RET
131
132 TEXT runtime·munmap(SB),NOSPLIT,$0
133 MOVD addr+0(FP), R0 // arg 1 - addr
134 MOVD n+8(FP), R1 // arg 2 - len
135 MOVD $73, R8 // sys_munmap
136 SVC
137 BCC 3(PC)
138 MOVD $0, R0 // crash on syscall failure
139 MOVD R0, (R0)
140 RET
141
142 TEXT runtime·madvise(SB),NOSPLIT,$0
143 MOVD addr+0(FP), R0 // arg 1 - addr
144 MOVD n+8(FP), R1 // arg 2 - len
145 MOVW flags+16(FP), R2 // arg 2 - flags
146 MOVD $75, R8 // sys_madvise
147 SVC
148 BCC 2(PC)
149 MOVW $-1, R0
150 MOVW R0, ret+24(FP)
151 RET
152
153 TEXT runtime·setitimer(SB),NOSPLIT,$0
154 MOVW mode+0(FP), R0 // arg 1 - mode
155 MOVD new+8(FP), R1 // arg 2 - new value
156 MOVD old+16(FP), R2 // arg 3 - old value
157 MOVD $69, R8 // sys_setitimer
158 SVC
159 RET
160
161 // func walltime() (sec int64, nsec int32)
162 TEXT runtime·walltime(SB), NOSPLIT, $32
163 MOVW CLOCK_REALTIME, R0 // arg 1 - clock_id
164 MOVD $8(RSP), R1 // arg 2 - tp
165 MOVD $87, R8 // sys_clock_gettime
166 SVC
167
168 MOVD 8(RSP), R0 // sec
169 MOVD 16(RSP), R1 // nsec
170 MOVD R0, sec+0(FP)
171 MOVW R1, nsec+8(FP)
172
173 RET
174
175 // int64 nanotime(void) so really
176 // void nanotime(int64 *nsec)
177 TEXT runtime·nanotime(SB),NOSPLIT,$32
178 MOVW CLOCK_MONOTONIC, R0 // arg 1 - clock_id
179 MOVD $8(RSP), R1 // arg 2 - tp
180 MOVD $87, R8 // sys_clock_gettime
181 SVC
182
183 MOVW 8(RSP), R3 // sec
184 MOVW 16(RSP), R5 // nsec
185
186 MOVD $1000000000, R4
187 MUL R4, R3
188 ADD R5, R3
189 MOVD R3, ret+0(FP)
190 RET
191
192 TEXT runtime·sigaction(SB),NOSPLIT,$0
193 MOVW sig+0(FP), R0 // arg 1 - signum
194 MOVD new+8(FP), R1 // arg 2 - new sigaction
195 MOVD old+16(FP), R2 // arg 3 - old sigaction
196 MOVD $46, R8 // sys_sigaction
197 SVC
198 BCC 3(PC)
199 MOVD $3, R0 // crash on syscall failure
200 MOVD R0, (R0)
201 RET
202
203 TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$0
204 MOVW how+0(FP), R0 // arg 1 - mode
205 MOVW new+4(FP), R1 // arg 2 - new
206 MOVD $48, R8 // sys_sigprocmask
207 SVC
208 BCC 3(PC)
209 MOVD $3, R8 // crash on syscall failure
210 MOVD R8, (R8)
211 MOVW R0, ret+8(FP)
212 RET
213
214 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
215 MOVW sig+8(FP), R0
216 MOVD info+16(FP), R1
217 MOVD ctx+24(FP), R2
218 MOVD fn+0(FP), R11
219 BL (R11) // Alignment for ELF ABI?
220 RET
221
222 TEXT runtime·sigtramp(SB),NOSPLIT,$192
223 // Save callee-save registers in the case of signal forwarding.
224 // Please refer to https://golang.org/issue/31827 .
225 MOVD R19, 8*4(RSP)
226 MOVD R20, 8*5(RSP)
227 MOVD R21, 8*6(RSP)
228 MOVD R22, 8*7(RSP)
229 MOVD R23, 8*8(RSP)
230 MOVD R24, 8*9(RSP)
231 MOVD R25, 8*10(RSP)
232 MOVD R26, 8*11(RSP)
233 MOVD R27, 8*12(RSP)
234 MOVD g, 8*13(RSP)
235 MOVD R29, 8*14(RSP)
236 FMOVD F8, 8*15(RSP)
237 FMOVD F9, 8*16(RSP)
238 FMOVD F10, 8*17(RSP)
239 FMOVD F11, 8*18(RSP)
240 FMOVD F12, 8*19(RSP)
241 FMOVD F13, 8*20(RSP)
242 FMOVD F14, 8*21(RSP)
243 FMOVD F15, 8*22(RSP)
244
245 // If called from an external code context, g will not be set.
246 // Save R0, since runtime·load_g will clobber it.
247 MOVW R0, 8(RSP) // signum
248 MOVB runtime·iscgo(SB), R0
249 CMP $0, R0
250 BEQ 2(PC)
251 BL runtime·load_g(SB)
252
253 MOVD R1, 16(RSP)
254 MOVD R2, 24(RSP)
255 BL runtime·sigtrampgo(SB)
256
257 // Restore callee-save registers.
258 MOVD 8*4(RSP), R19
259 MOVD 8*5(RSP), R20
260 MOVD 8*6(RSP), R21
261 MOVD 8*7(RSP), R22
262 MOVD 8*8(RSP), R23
263 MOVD 8*9(RSP), R24
264 MOVD 8*10(RSP), R25
265 MOVD 8*11(RSP), R26
266 MOVD 8*12(RSP), R27
267 MOVD 8*13(RSP), g
268 MOVD 8*14(RSP), R29
269 FMOVD 8*15(RSP), F8
270 FMOVD 8*16(RSP), F9
271 FMOVD 8*17(RSP), F10
272 FMOVD 8*18(RSP), F11
273 FMOVD 8*19(RSP), F12
274 FMOVD 8*20(RSP), F13
275 FMOVD 8*21(RSP), F14
276 FMOVD 8*22(RSP), F15
277
278 RET
279
280 // int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
281 TEXT runtime·tfork(SB),NOSPLIT,$0
282
283 // Copy mp, gp and fn off parent stack for use by child.
284 MOVD mm+16(FP), R4
285 MOVD gg+24(FP), R5
286 MOVD fn+32(FP), R6
287
288 MOVD param+0(FP), R0 // arg 1 - param
289 MOVD psize+8(FP), R1 // arg 2 - psize
290 MOVD $8, R8 // sys___tfork
291 SVC
292
293 // Return if syscall failed.
294 BCC 4(PC)
295 NEG R0, R0
296 MOVW R0, ret+40(FP)
297 RET
298
299 // In parent, return.
300 CMP $0, R0
301 BEQ 3(PC)
302 MOVW R0, ret+40(FP)
303 RET
304
305 // Initialise m, g.
306 MOVD R5, g
307 MOVD R4, g_m(g)
308
309 // Call fn.
310 BL (R6)
311
312 // fn should never return.
313 MOVD $2, R8 // crash if reached
314 MOVD R8, (R8)
315 RET
316
317 TEXT runtime·sigaltstack(SB),NOSPLIT,$0
318 MOVD new+0(FP), R0 // arg 1 - new sigaltstack
319 MOVD old+8(FP), R1 // arg 2 - old sigaltstack
320 MOVD $288, R8 // sys_sigaltstack
321 SVC
322 BCC 3(PC)
323 MOVD $0, R8 // crash on syscall failure
324 MOVD R8, (R8)
325 RET
326
327 TEXT runtime·osyield(SB),NOSPLIT,$0
328 MOVD $298, R8 // sys_sched_yield
329 SVC
330 RET
331
332 TEXT runtime·thrsleep(SB),NOSPLIT,$0
333 MOVD ident+0(FP), R0 // arg 1 - ident
334 MOVW clock_id+8(FP), R1 // arg 2 - clock_id
335 MOVD tsp+16(FP), R2 // arg 3 - tsp
336 MOVD lock+24(FP), R3 // arg 4 - lock
337 MOVD abort+32(FP), R4 // arg 5 - abort
338 MOVD $94, R8 // sys___thrsleep
339 SVC
340 MOVW R0, ret+40(FP)
341 RET
342
343 TEXT runtime·thrwakeup(SB),NOSPLIT,$0
344 MOVD ident+0(FP), R0 // arg 1 - ident
345 MOVW n+8(FP), R1 // arg 2 - n
346 MOVD $301, R8 // sys___thrwakeup
347 SVC
348 MOVW R0, ret+16(FP)
349 RET
350
351 TEXT runtime·sysctl(SB),NOSPLIT,$0
352 MOVD mib+0(FP), R0 // arg 1 - mib
353 MOVW miblen+8(FP), R1 // arg 2 - miblen
354 MOVD out+16(FP), R2 // arg 3 - out
355 MOVD size+24(FP), R3 // arg 4 - size
356 MOVD dst+32(FP), R4 // arg 5 - dest
357 MOVD ndst+40(FP), R5 // arg 6 - newlen
358 MOVD $202, R8 // sys___sysctl
359 SVC
360 BCC 2(PC)
361 NEG R0, R0
362 MOVW R0, ret+48(FP)
363 RET
364
365 // int32 runtime·kqueue(void);
366 TEXT runtime·kqueue(SB),NOSPLIT,$0
367 MOVD $269, R8 // sys_kqueue
368 SVC
369 BCC 2(PC)
370 NEG R0, R0
371 MOVW R0, ret+0(FP)
372 RET
373
374 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
375 TEXT runtime·kevent(SB),NOSPLIT,$0
376 MOVW kq+0(FP), R0 // arg 1 - kq
377 MOVD ch+8(FP), R1 // arg 2 - changelist
378 MOVW nch+16(FP), R2 // arg 3 - nchanges
379 MOVD ev+24(FP), R3 // arg 4 - eventlist
380 MOVW nev+32(FP), R4 // arg 5 - nevents
381 MOVD ts+40(FP), R5 // arg 6 - timeout
382 MOVD $72, R8 // sys_kevent
383 SVC
384 BCC 2(PC)
385 NEG R0, R0
386 MOVW R0, ret+48(FP)
387 RET
388
389 // func closeonexec(fd int32)
390 TEXT runtime·closeonexec(SB),NOSPLIT,$0
391 MOVW fd+0(FP), R0 // arg 1 - fd
392 MOVD $2, R1 // arg 2 - cmd (F_SETFD)
393 MOVD $1, R2 // arg 3 - arg (FD_CLOEXEC)
394 MOVD $92, R8 // sys_fcntl
395 SVC
396 RET
View as plain text