Text file
src/runtime/sys_freebsd_386.s
Documentation: runtime
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, FreeBSD
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 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$-4
14 MOVL $454, AX
15 INT $0x80
16 JAE 2(PC)
17 NEGL AX
18 MOVL AX, ret+20(FP)
19 RET
20
21 TEXT runtime·thr_new(SB),NOSPLIT,$-4
22 MOVL $455, AX
23 INT $0x80
24 JAE 2(PC)
25 NEGL AX
26 MOVL AX, ret+8(FP)
27 RET
28
29 // Called by OS using C ABI.
30 TEXT runtime·thr_start(SB),NOSPLIT,$0
31 NOP SP // tell vet SP changed - stop checking offsets
32 MOVL 4(SP), AX // m
33 MOVL m_g0(AX), BX
34 LEAL m_tls(AX), BP
35 MOVL m_id(AX), DI
36 ADDL $7, DI
37 PUSHAL
38 PUSHL $32
39 PUSHL BP
40 PUSHL DI
41 CALL runtime·setldt(SB)
42 POPL AX
43 POPL AX
44 POPL AX
45 POPAL
46 get_tls(CX)
47 MOVL BX, g(CX)
48
49 MOVL AX, g_m(BX)
50 CALL runtime·stackcheck(SB) // smashes AX
51 CALL runtime·mstart(SB)
52
53 MOVL 0, AX // crash (not reached)
54
55 // Exit the entire program (like C exit)
56 TEXT runtime·exit(SB),NOSPLIT,$-4
57 MOVL $1, AX
58 INT $0x80
59 MOVL $0xf1, 0xf1 // crash
60 RET
61
62 GLOBL exitStack<>(SB),RODATA,$8
63 DATA exitStack<>+0x00(SB)/4, $0
64 DATA exitStack<>+0x04(SB)/4, $0
65
66 // func exitThread(wait *uint32)
67 TEXT runtime·exitThread(SB),NOSPLIT,$0-4
68 MOVL wait+0(FP), AX
69 // We're done using the stack.
70 MOVL $0, (AX)
71 // thr_exit takes a single pointer argument, which it expects
72 // on the stack. We want to pass 0, so switch over to a fake
73 // stack of 0s. It won't write to the stack.
74 MOVL $exitStack<>(SB), SP
75 MOVL $431, AX // thr_exit
76 INT $0x80
77 MOVL $0xf1, 0xf1 // crash
78 JMP 0(PC)
79
80 TEXT runtime·open(SB),NOSPLIT,$-4
81 MOVL $5, AX
82 INT $0x80
83 JAE 2(PC)
84 MOVL $-1, AX
85 MOVL AX, ret+12(FP)
86 RET
87
88 TEXT runtime·closefd(SB),NOSPLIT,$-4
89 MOVL $6, AX
90 INT $0x80
91 JAE 2(PC)
92 MOVL $-1, AX
93 MOVL AX, ret+4(FP)
94 RET
95
96 TEXT runtime·read(SB),NOSPLIT,$-4
97 MOVL $3, AX
98 INT $0x80
99 JAE 2(PC)
100 NEGL AX // caller expects negative errno
101 MOVL AX, ret+12(FP)
102 RET
103
104 // func pipe() (r, w int32, errno int32)
105 TEXT runtime·pipe(SB),NOSPLIT,$8-12
106 MOVL $42, AX
107 INT $0x80
108 JAE ok
109 MOVL $0, r+0(FP)
110 MOVL $0, w+4(FP)
111 MOVL AX, errno+8(FP)
112 RET
113 ok:
114 MOVL AX, r+0(FP)
115 MOVL DX, w+4(FP)
116 MOVL $0, errno+8(FP)
117 RET
118
119 // func pipe2(flags int32) (r, w int32, errno int32)
120 TEXT runtime·pipe2(SB),NOSPLIT,$12-16
121 MOVL $542, AX
122 LEAL r+4(FP), BX
123 MOVL BX, 4(SP)
124 MOVL flags+0(FP), BX
125 MOVL BX, 8(SP)
126 INT $0x80
127 JAE 2(PC)
128 NEGL AX
129 MOVL AX, errno+12(FP)
130 RET
131
132 TEXT runtime·write1(SB),NOSPLIT,$-4
133 MOVL $4, AX
134 INT $0x80
135 JAE 2(PC)
136 NEGL AX // caller expects negative errno
137 MOVL AX, ret+12(FP)
138 RET
139
140 TEXT runtime·thr_self(SB),NOSPLIT,$8-4
141 // thr_self(&0(FP))
142 LEAL ret+0(FP), AX
143 MOVL AX, 4(SP)
144 MOVL $432, AX
145 INT $0x80
146 RET
147
148 TEXT runtime·thr_kill(SB),NOSPLIT,$-4
149 // thr_kill(tid, sig)
150 MOVL $433, AX
151 INT $0x80
152 RET
153
154 TEXT runtime·raiseproc(SB),NOSPLIT,$16
155 // getpid
156 MOVL $20, AX
157 INT $0x80
158 // kill(self, sig)
159 MOVL AX, 4(SP)
160 MOVL sig+0(FP), AX
161 MOVL AX, 8(SP)
162 MOVL $37, AX
163 INT $0x80
164 RET
165
166 TEXT runtime·mmap(SB),NOSPLIT,$32
167 LEAL addr+0(FP), SI
168 LEAL 4(SP), DI
169 CLD
170 MOVSL
171 MOVSL
172 MOVSL
173 MOVSL
174 MOVSL
175 MOVSL
176 MOVL $0, AX // top 32 bits of file offset
177 STOSL
178 MOVL $477, AX
179 INT $0x80
180 JAE ok
181 MOVL $0, p+24(FP)
182 MOVL AX, err+28(FP)
183 RET
184 ok:
185 MOVL AX, p+24(FP)
186 MOVL $0, err+28(FP)
187 RET
188
189 TEXT runtime·munmap(SB),NOSPLIT,$-4
190 MOVL $73, AX
191 INT $0x80
192 JAE 2(PC)
193 MOVL $0xf1, 0xf1 // crash
194 RET
195
196 TEXT runtime·madvise(SB),NOSPLIT,$-4
197 MOVL $75, AX // madvise
198 INT $0x80
199 JAE 2(PC)
200 MOVL $-1, AX
201 MOVL AX, ret+12(FP)
202 RET
203
204 TEXT runtime·setitimer(SB), NOSPLIT, $-4
205 MOVL $83, AX
206 INT $0x80
207 RET
208
209 // func fallback_walltime() (sec int64, nsec int32)
210 TEXT runtime·fallback_walltime(SB), NOSPLIT, $32-12
211 MOVL $232, AX // clock_gettime
212 LEAL 12(SP), BX
213 MOVL $0, 4(SP) // CLOCK_REALTIME
214 MOVL BX, 8(SP)
215 INT $0x80
216 MOVL 12(SP), AX // sec
217 MOVL 16(SP), BX // nsec
218
219 // sec is in AX, nsec in BX
220 MOVL AX, sec_lo+0(FP)
221 MOVL $0, sec_hi+4(FP)
222 MOVL BX, nsec+8(FP)
223 RET
224
225 // func fallback_nanotime() int64
226 TEXT runtime·fallback_nanotime(SB), NOSPLIT, $32-8
227 MOVL $232, AX
228 LEAL 12(SP), BX
229 MOVL $4, 4(SP) // CLOCK_MONOTONIC
230 MOVL BX, 8(SP)
231 INT $0x80
232 MOVL 12(SP), AX // sec
233 MOVL 16(SP), BX // nsec
234
235 // sec is in AX, nsec in BX
236 // convert to DX:AX nsec
237 MOVL $1000000000, CX
238 MULL CX
239 ADDL BX, AX
240 ADCL $0, DX
241
242 MOVL AX, ret_lo+0(FP)
243 MOVL DX, ret_hi+4(FP)
244 RET
245
246
247 TEXT runtime·asmSigaction(SB),NOSPLIT,$-4
248 MOVL $416, AX
249 INT $0x80
250 MOVL AX, ret+12(FP)
251 RET
252
253 TEXT runtime·sigfwd(SB),NOSPLIT,$12-16
254 MOVL fn+0(FP), AX
255 MOVL sig+4(FP), BX
256 MOVL info+8(FP), CX
257 MOVL ctx+12(FP), DX
258 MOVL SP, SI
259 SUBL $32, SP
260 ANDL $~15, SP // align stack: handler might be a C function
261 MOVL BX, 0(SP)
262 MOVL CX, 4(SP)
263 MOVL DX, 8(SP)
264 MOVL SI, 12(SP) // save SI: handler might be a Go function
265 CALL AX
266 MOVL 12(SP), AX
267 MOVL AX, SP
268 RET
269
270 // Called by OS using C ABI.
271 TEXT runtime·sigtramp(SB),NOSPLIT,$12
272 NOP SP // tell vet SP changed - stop checking offsets
273 MOVL 16(SP), BX // signo
274 MOVL BX, 0(SP)
275 MOVL 20(SP), BX // info
276 MOVL BX, 4(SP)
277 MOVL 24(SP), BX // context
278 MOVL BX, 8(SP)
279 CALL runtime·sigtrampgo(SB)
280
281 // call sigreturn
282 MOVL 24(SP), AX // context
283 MOVL $0, 0(SP) // syscall gap
284 MOVL AX, 4(SP)
285 MOVL $417, AX // sigreturn(ucontext)
286 INT $0x80
287 MOVL $0xf1, 0xf1 // crash
288 RET
289
290 TEXT runtime·sigaltstack(SB),NOSPLIT,$0
291 MOVL $53, AX
292 INT $0x80
293 JAE 2(PC)
294 MOVL $0xf1, 0xf1 // crash
295 RET
296
297 TEXT runtime·usleep(SB),NOSPLIT,$20
298 MOVL $0, DX
299 MOVL usec+0(FP), AX
300 MOVL $1000000, CX
301 DIVL CX
302 MOVL AX, 12(SP) // tv_sec
303 MOVL $1000, AX
304 MULL DX
305 MOVL AX, 16(SP) // tv_nsec
306
307 MOVL $0, 0(SP)
308 LEAL 12(SP), AX
309 MOVL AX, 4(SP) // arg 1 - rqtp
310 MOVL $0, 8(SP) // arg 2 - rmtp
311 MOVL $240, AX // sys_nanosleep
312 INT $0x80
313 RET
314
315 /*
316 descriptor entry format for system call
317 is the native machine format, ugly as it is:
318
319 2-byte limit
320 3-byte base
321 1-byte: 0x80=present, 0x60=dpl<<5, 0x1F=type
322 1-byte: 0x80=limit is *4k, 0x40=32-bit operand size,
323 0x0F=4 more bits of limit
324 1 byte: 8 more bits of base
325
326 int i386_get_ldt(int, union ldt_entry *, int);
327 int i386_set_ldt(int, const union ldt_entry *, int);
328
329 */
330
331 // setldt(int entry, int address, int limit)
332 TEXT runtime·setldt(SB),NOSPLIT,$32
333 MOVL base+4(FP), BX
334 // see comment in sys_linux_386.s; freebsd is similar
335 ADDL $0x4, BX
336
337 // set up data_desc
338 LEAL 16(SP), AX // struct data_desc
339 MOVL $0, 0(AX)
340 MOVL $0, 4(AX)
341
342 MOVW BX, 2(AX)
343 SHRL $16, BX
344 MOVB BX, 4(AX)
345 SHRL $8, BX
346 MOVB BX, 7(AX)
347
348 MOVW $0xffff, 0(AX)
349 MOVB $0xCF, 6(AX) // 32-bit operand, 4k limit unit, 4 more bits of limit
350
351 MOVB $0xF2, 5(AX) // r/w data descriptor, dpl=3, present
352
353 // call i386_set_ldt(entry, desc, 1)
354 MOVL $0xffffffff, 0(SP) // auto-allocate entry and return in AX
355 MOVL AX, 4(SP)
356 MOVL $1, 8(SP)
357 CALL i386_set_ldt<>(SB)
358
359 // compute segment selector - (entry*8+7)
360 SHLL $3, AX
361 ADDL $7, AX
362 MOVW AX, GS
363 RET
364
365 TEXT i386_set_ldt<>(SB),NOSPLIT,$16
366 LEAL args+0(FP), AX // 0(FP) == 4(SP) before SP got moved
367 MOVL $0, 0(SP) // syscall gap
368 MOVL $1, 4(SP)
369 MOVL AX, 8(SP)
370 MOVL $165, AX
371 INT $0x80
372 JAE 2(PC)
373 INT $3
374 RET
375
376 TEXT runtime·sysctl(SB),NOSPLIT,$28
377 LEAL mib+0(FP), SI
378 LEAL 4(SP), DI
379 CLD
380 MOVSL // arg 1 - name
381 MOVSL // arg 2 - namelen
382 MOVSL // arg 3 - oldp
383 MOVSL // arg 4 - oldlenp
384 MOVSL // arg 5 - newp
385 MOVSL // arg 6 - newlen
386 MOVL $202, AX // sys___sysctl
387 INT $0x80
388 JAE 4(PC)
389 NEGL AX
390 MOVL AX, ret+24(FP)
391 RET
392 MOVL $0, AX
393 MOVL AX, ret+24(FP)
394 RET
395
396 TEXT runtime·osyield(SB),NOSPLIT,$-4
397 MOVL $331, AX // sys_sched_yield
398 INT $0x80
399 RET
400
401 TEXT runtime·sigprocmask(SB),NOSPLIT,$16
402 MOVL $0, 0(SP) // syscall gap
403 MOVL how+0(FP), AX // arg 1 - how
404 MOVL AX, 4(SP)
405 MOVL new+4(FP), AX
406 MOVL AX, 8(SP) // arg 2 - set
407 MOVL old+8(FP), AX
408 MOVL AX, 12(SP) // arg 3 - oset
409 MOVL $340, AX // sys_sigprocmask
410 INT $0x80
411 JAE 2(PC)
412 MOVL $0xf1, 0xf1 // crash
413 RET
414
415 // int32 runtime·kqueue(void);
416 TEXT runtime·kqueue(SB),NOSPLIT,$0
417 MOVL $362, AX
418 INT $0x80
419 JAE 2(PC)
420 NEGL AX
421 MOVL AX, ret+0(FP)
422 RET
423
424 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
425 TEXT runtime·kevent(SB),NOSPLIT,$0
426 MOVL $363, AX
427 INT $0x80
428 JAE 2(PC)
429 NEGL AX
430 MOVL AX, ret+24(FP)
431 RET
432
433 // int32 runtime·closeonexec(int32 fd);
434 TEXT runtime·closeonexec(SB),NOSPLIT,$32
435 MOVL $92, AX // fcntl
436 // 0(SP) is where the caller PC would be; kernel skips it
437 MOVL fd+0(FP), BX
438 MOVL BX, 4(SP) // fd
439 MOVL $2, 8(SP) // F_SETFD
440 MOVL $1, 12(SP) // FD_CLOEXEC
441 INT $0x80
442 JAE 2(PC)
443 NEGL AX
444 RET
445
446 // func runtime·setNonblock(fd int32)
447 TEXT runtime·setNonblock(SB),NOSPLIT,$16-4
448 MOVL $92, AX // fcntl
449 MOVL fd+0(FP), BX // fd
450 MOVL BX, 4(SP)
451 MOVL $3, 8(SP) // F_GETFL
452 MOVL $0, 12(SP)
453 INT $0x80
454 MOVL fd+0(FP), BX // fd
455 MOVL BX, 4(SP)
456 MOVL $4, 8(SP) // F_SETFL
457 ORL $4, AX // O_NONBLOCK
458 MOVL AX, 12(SP)
459 MOVL $92, AX // fcntl
460 INT $0x80
461 RET
462
463 // func cpuset_getaffinity(level int, which int, id int64, size int, mask *byte) int32
464 TEXT runtime·cpuset_getaffinity(SB), NOSPLIT, $0-28
465 MOVL $487, AX
466 INT $0x80
467 JAE 2(PC)
468 NEGL AX
469 MOVL AX, ret+24(FP)
470 RET
471
472 GLOBL runtime·tlsoffset(SB),NOPTR,$4
473
View as plain text