Text file src/pkg/runtime/sys_openbsd_386.s
1 // Copyright 2009 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 386, 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_MONOTONIC $3
14
15 // Exit the entire program (like C exit)
16 TEXT runtime·exit(SB),NOSPLIT,$-4
17 MOVL $1, AX
18 INT $0x80
19 MOVL $0xf1, 0xf1 // crash
20 RET
21
22 // func exitThread(wait *uint32)
23 TEXT runtime·exitThread(SB),NOSPLIT,$0-4
24 MOVL $302, AX // sys___threxit
25 INT $0x80
26 MOVL $0xf1, 0xf1 // crash
27 JMP 0(PC)
28
29 TEXT runtime·open(SB),NOSPLIT,$-4
30 MOVL $5, AX
31 INT $0x80
32 JAE 2(PC)
33 MOVL $-1, AX
34 MOVL AX, ret+12(FP)
35 RET
36
37 TEXT runtime·closefd(SB),NOSPLIT,$-4
38 MOVL $6, AX
39 INT $0x80
40 JAE 2(PC)
41 MOVL $-1, AX
42 MOVL AX, ret+4(FP)
43 RET
44
45 TEXT runtime·read(SB),NOSPLIT,$-4
46 MOVL $3, AX
47 INT $0x80
48 JAE 2(PC)
49 MOVL $-1, AX
50 MOVL AX, ret+12(FP)
51 RET
52
53 TEXT runtime·write(SB),NOSPLIT,$-4
54 MOVL $4, AX // sys_write
55 INT $0x80
56 JAE 2(PC)
57 MOVL $-1, AX
58 MOVL AX, ret+12(FP)
59 RET
60
61 TEXT runtime·usleep(SB),NOSPLIT,$24
62 MOVL $0, DX
63 MOVL usec+0(FP), AX
64 MOVL $1000000, CX
65 DIVL CX
66 MOVL AX, 12(SP) // tv_sec - l32
67 MOVL $0, 16(SP) // tv_sec - h32
68 MOVL $1000, AX
69 MULL DX
70 MOVL AX, 20(SP) // tv_nsec
71
72 MOVL $0, 0(SP)
73 LEAL 12(SP), AX
74 MOVL AX, 4(SP) // arg 1 - rqtp
75 MOVL $0, 8(SP) // arg 2 - rmtp
76 MOVL $91, AX // sys_nanosleep
77 INT $0x80
78 RET
79
80 TEXT runtime·raise(SB),NOSPLIT,$16
81 MOVL $299, AX // sys_getthrid
82 INT $0x80
83 MOVL $0, 0(SP)
84 MOVL AX, 4(SP) // arg 1 - tid
85 MOVL sig+0(FP), AX
86 MOVL AX, 8(SP) // arg 2 - signum
87 MOVL $0, 12(SP) // arg 3 - tcb
88 MOVL $119, AX // sys_thrkill
89 INT $0x80
90 RET
91
92 TEXT runtime·raiseproc(SB),NOSPLIT,$12
93 MOVL $20, AX // sys_getpid
94 INT $0x80
95 MOVL $0, 0(SP)
96 MOVL AX, 4(SP) // arg 1 - pid
97 MOVL sig+0(FP), AX
98 MOVL AX, 8(SP) // arg 2 - signum
99 MOVL $122, AX // sys_kill
100 INT $0x80
101 RET
102
103 TEXT runtime·mmap(SB),NOSPLIT,$36
104 LEAL addr+0(FP), SI
105 LEAL 4(SP), DI
106 CLD
107 MOVSL // arg 1 - addr
108 MOVSL // arg 2 - len
109 MOVSL // arg 3 - prot
110 MOVSL // arg 4 - flags
111 MOVSL // arg 5 - fd
112 MOVL $0, AX
113 STOSL // arg 6 - pad
114 MOVSL // arg 7 - offset
115 MOVL $0, AX // top 32 bits of file offset
116 STOSL
117 MOVL $197, AX // sys_mmap
118 INT $0x80
119 JAE ok
120 MOVL $0, p+24(FP)
121 MOVL AX, err+28(FP)
122 RET
123 ok:
124 MOVL AX, p+24(FP)
125 MOVL $0, err+28(FP)
126 RET
127
128 TEXT runtime·munmap(SB),NOSPLIT,$-4
129 MOVL $73, AX // sys_munmap
130 INT $0x80
131 JAE 2(PC)
132 MOVL $0xf1, 0xf1 // crash
133 RET
134
135 TEXT runtime·madvise(SB),NOSPLIT,$-4
136 MOVL $75, AX // sys_madvise
137 INT $0x80
138 JAE 2(PC)
139 MOVL $-1, AX
140 MOVL AX, ret+12(FP)
141 RET
142
143 TEXT runtime·setitimer(SB),NOSPLIT,$-4
144 MOVL $69, AX
145 INT $0x80
146 RET
147
148 // func walltime() (sec int64, nsec int32)
149 TEXT runtime·walltime(SB), NOSPLIT, $32
150 LEAL 12(SP), BX
151 MOVL $0, 4(SP) // arg 1 - clock_id
152 MOVL BX, 8(SP) // arg 2 - tp
153 MOVL $87, AX // sys_clock_gettime
154 INT $0x80
155
156 MOVL 12(SP), AX // sec - l32
157 MOVL AX, sec_lo+0(FP)
158 MOVL 16(SP), AX // sec - h32
159 MOVL AX, sec_hi+4(FP)
160
161 MOVL 20(SP), BX // nsec
162 MOVL BX, nsec+8(FP)
163 RET
164
165 // int64 nanotime(void) so really
166 // void nanotime(int64 *nsec)
167 TEXT runtime·nanotime(SB),NOSPLIT,$32
168 LEAL 12(SP), BX
169 MOVL CLOCK_MONOTONIC, 4(SP) // arg 1 - clock_id
170 MOVL BX, 8(SP) // arg 2 - tp
171 MOVL $87, AX // sys_clock_gettime
172 INT $0x80
173
174 MOVL 16(SP), CX // sec - h32
175 IMULL $1000000000, CX
176
177 MOVL 12(SP), AX // sec - l32
178 MOVL $1000000000, BX
179 MULL BX // result in dx:ax
180
181 MOVL 20(SP), BX // nsec
182 ADDL BX, AX
183 ADCL CX, DX // add high bits with carry
184
185 MOVL AX, ret_lo+0(FP)
186 MOVL DX, ret_hi+4(FP)
187 RET
188
189 TEXT runtime·sigaction(SB),NOSPLIT,$-4
190 MOVL $46, AX // sys_sigaction
191 INT $0x80
192 JAE 2(PC)
193 MOVL $0xf1, 0xf1 // crash
194 RET
195
196 TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$-4
197 MOVL $48, AX // sys_sigprocmask
198 INT $0x80
199 JAE 2(PC)
200 MOVL $0xf1, 0xf1 // crash
201 MOVL AX, ret+8(FP)
202 RET
203
204 TEXT runtime·sigfwd(SB),NOSPLIT,$12-16
205 MOVL fn+0(FP), AX
206 MOVL sig+4(FP), BX
207 MOVL info+8(FP), CX
208 MOVL ctx+12(FP), DX
209 MOVL SP, SI
210 SUBL $32, SP
211 ANDL $~15, SP // align stack: handler might be a C function
212 MOVL BX, 0(SP)
213 MOVL CX, 4(SP)
214 MOVL DX, 8(SP)
215 MOVL SI, 12(SP) // save SI: handler might be a Go function
216 CALL AX
217 MOVL 12(SP), AX
218 MOVL AX, SP
219 RET
220
221 // Called by OS using C ABI.
222 TEXT runtime·sigtramp(SB),NOSPLIT,$28
223 NOP SP // tell vet SP changed - stop checking offsets
224 // Save callee-saved C registers, since the caller may be a C signal handler.
225 MOVL BX, bx-4(SP)
226 MOVL BP, bp-8(SP)
227 MOVL SI, si-12(SP)
228 MOVL DI, di-16(SP)
229 // We don't save mxcsr or the x87 control word because sigtrampgo doesn't
230 // modify them.
231
232 MOVL 32(SP), BX // signo
233 MOVL BX, 0(SP)
234 MOVL 36(SP), BX // info
235 MOVL BX, 4(SP)
236 MOVL 40(SP), BX // context
237 MOVL BX, 8(SP)
238 CALL runtime·sigtrampgo(SB)
239
240 MOVL di-16(SP), DI
241 MOVL si-12(SP), SI
242 MOVL bp-8(SP), BP
243 MOVL bx-4(SP), BX
244 RET
245
246 // int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
247 TEXT runtime·tfork(SB),NOSPLIT,$12
248
249 // Copy mp, gp and fn from the parent stack onto the child stack.
250 MOVL param+0(FP), AX
251 MOVL 8(AX), CX // tf_stack
252 SUBL $16, CX
253 MOVL CX, 8(AX)
254 MOVL mm+8(FP), SI
255 MOVL SI, 0(CX)
256 MOVL gg+12(FP), SI
257 MOVL SI, 4(CX)
258 MOVL fn+16(FP), SI
259 MOVL SI, 8(CX)
260 MOVL $1234, 12(CX)
261
262 MOVL $0, 0(SP) // syscall gap
263 MOVL param+0(FP), AX
264 MOVL AX, 4(SP) // arg 1 - param
265 MOVL psize+4(FP), AX
266 MOVL AX, 8(SP) // arg 2 - psize
267 MOVL $8, AX // sys___tfork
268 INT $0x80
269
270 // Return if tfork syscall failed.
271 JCC 4(PC)
272 NEGL AX
273 MOVL AX, ret+20(FP)
274 RET
275
276 // In parent, return.
277 CMPL AX, $0
278 JEQ 3(PC)
279 MOVL AX, ret+20(FP)
280 RET
281
282 // Paranoia: check that SP is as we expect.
283 MOVL 12(SP), BP
284 CMPL BP, $1234
285 JEQ 2(PC)
286 INT $3
287
288 // Reload registers.
289 MOVL 0(SP), BX // m
290 MOVL 4(SP), DX // g
291 MOVL 8(SP), SI // fn
292
293 // Set FS to point at m->tls.
294 LEAL m_tls(BX), BP
295 PUSHAL // save registers
296 PUSHL BP
297 CALL set_tcb<>(SB)
298 POPL AX
299 POPAL
300
301 // Now segment is established. Initialize m, g.
302 get_tls(AX)
303 MOVL DX, g(AX)
304 MOVL BX, g_m(DX)
305
306 CALL runtime·stackcheck(SB) // smashes AX, CX
307 MOVL 0(DX), DX // paranoia; check they are not nil
308 MOVL 0(BX), BX
309
310 // More paranoia; check that stack splitting code works.
311 PUSHAL
312 CALL runtime·emptyfunc(SB)
313 POPAL
314
315 // Call fn.
316 CALL SI
317
318 // fn should never return.
319 MOVL $0x1234, 0x1005
320 RET
321
322 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
323 MOVL $288, AX // sys_sigaltstack
324 MOVL new+0(FP), BX
325 MOVL old+4(FP), CX
326 INT $0x80
327 CMPL AX, $0xfffff001
328 JLS 2(PC)
329 INT $3
330 RET
331
332 TEXT runtime·setldt(SB),NOSPLIT,$4
333 // Under OpenBSD we set the GS base instead of messing with the LDT.
334 MOVL base+4(FP), AX
335 MOVL AX, 0(SP)
336 CALL set_tcb<>(SB)
337 RET
338
339 TEXT set_tcb<>(SB),NOSPLIT,$8
340 // adjust for ELF: wants to use -4(GS) for g
341 MOVL tlsbase+0(FP), CX
342 ADDL $4, CX
343 MOVL $0, 0(SP) // syscall gap
344 MOVL CX, 4(SP) // arg 1 - tcb
345 MOVL $329, AX // sys___set_tcb
346 INT $0x80
347 JCC 2(PC)
348 MOVL $0xf1, 0xf1 // crash
349 RET
350
351 TEXT runtime·osyield(SB),NOSPLIT,$-4
352 MOVL $298, AX // sys_sched_yield
353 INT $0x80
354 RET
355
356 TEXT runtime·thrsleep(SB),NOSPLIT,$-4
357 MOVL $94, AX // sys___thrsleep
358 INT $0x80
359 MOVL AX, ret+20(FP)
360 RET
361
362 TEXT runtime·thrwakeup(SB),NOSPLIT,$-4
363 MOVL $301, AX // sys___thrwakeup
364 INT $0x80
365 MOVL AX, ret+8(FP)
366 RET
367
368 TEXT runtime·sysctl(SB),NOSPLIT,$28
369 LEAL mib+0(FP), SI
370 LEAL 4(SP), DI
371 CLD
372 MOVSL // arg 1 - name
373 MOVSL // arg 2 - namelen
374 MOVSL // arg 3 - oldp
375 MOVSL // arg 4 - oldlenp
376 MOVSL // arg 5 - newp
377 MOVSL // arg 6 - newlen
378 MOVL $202, AX // sys___sysctl
379 INT $0x80
380 JCC 4(PC)
381 NEGL AX
382 MOVL AX, ret+24(FP)
383 RET
384 MOVL $0, AX
385 MOVL AX, ret+24(FP)
386 RET
387
388 // int32 runtime·kqueue(void);
389 TEXT runtime·kqueue(SB),NOSPLIT,$0
390 MOVL $269, AX
391 INT $0x80
392 JAE 2(PC)
393 NEGL AX
394 MOVL AX, ret+0(FP)
395 RET
396
397 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
398 TEXT runtime·kevent(SB),NOSPLIT,$0
399 MOVL $72, AX // sys_kevent
400 INT $0x80
401 JAE 2(PC)
402 NEGL AX
403 MOVL AX, ret+24(FP)
404 RET
405
406 // int32 runtime·closeonexec(int32 fd);
407 TEXT runtime·closeonexec(SB),NOSPLIT,$32
408 MOVL $92, AX // sys_fcntl
409 // 0(SP) is where the caller PC would be; kernel skips it
410 MOVL fd+0(FP), BX
411 MOVL BX, 4(SP) // fd
412 MOVL $2, 8(SP) // F_SETFD
413 MOVL $1, 12(SP) // FD_CLOEXEC
414 INT $0x80
415 JAE 2(PC)
416 NEGL AX
417 RET
418
419 GLOBL runtime·tlsoffset(SB),NOPTR,$4
View as plain text