Text file
src/runtime/sys_freebsd_amd64.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 AMD64, 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 #include "cgo/abi_amd64.h"
13
14 TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
15 MOVQ addr+0(FP), DI
16 MOVL mode+8(FP), SI
17 MOVL val+12(FP), DX
18 MOVQ uaddr1+16(FP), R10
19 MOVQ ut+24(FP), R8
20 MOVL $454, AX
21 SYSCALL
22 JCC 2(PC)
23 NEGQ AX
24 MOVL AX, ret+32(FP)
25 RET
26
27 TEXT runtime·thr_new(SB),NOSPLIT,$0
28 MOVQ param+0(FP), DI
29 MOVL size+8(FP), SI
30 MOVL $455, AX
31 SYSCALL
32 JCC 2(PC)
33 NEGQ AX
34 MOVL AX, ret+16(FP)
35 RET
36
37 TEXT runtime·thr_start(SB),NOSPLIT,$0
38 MOVQ DI, R13 // m
39
40 // set up FS to point at m->tls
41 LEAQ m_tls(R13), DI
42 CALL runtime·settls(SB) // smashes DI
43
44 // set up m, g
45 get_tls(CX)
46 MOVQ m_g0(R13), DI
47 MOVQ R13, g_m(DI)
48 MOVQ DI, g(CX)
49
50 CALL runtime·stackcheck(SB)
51 CALL runtime·mstart(SB)
52
53 MOVQ 0, AX // crash (not reached)
54
55 // Exit the entire program (like C exit)
56 TEXT runtime·exit(SB),NOSPLIT,$-8
57 MOVL code+0(FP), DI // arg 1 exit status
58 MOVL $1, AX
59 SYSCALL
60 MOVL $0xf1, 0xf1 // crash
61 RET
62
63 // func exitThread(wait *uint32)
64 TEXT runtime·exitThread(SB),NOSPLIT,$0-8
65 MOVQ wait+0(FP), AX
66 // We're done using the stack.
67 MOVL $0, (AX)
68 MOVL $0, DI // arg 1 long *state
69 MOVL $431, AX // thr_exit
70 SYSCALL
71 MOVL $0xf1, 0xf1 // crash
72 JMP 0(PC)
73
74 TEXT runtime·open(SB),NOSPLIT,$-8
75 MOVQ name+0(FP), DI // arg 1 pathname
76 MOVL mode+8(FP), SI // arg 2 flags
77 MOVL perm+12(FP), DX // arg 3 mode
78 MOVL $5, AX
79 SYSCALL
80 JCC 2(PC)
81 MOVL $-1, AX
82 MOVL AX, ret+16(FP)
83 RET
84
85 TEXT runtime·closefd(SB),NOSPLIT,$-8
86 MOVL fd+0(FP), DI // arg 1 fd
87 MOVL $6, AX
88 SYSCALL
89 JCC 2(PC)
90 MOVL $-1, AX
91 MOVL AX, ret+8(FP)
92 RET
93
94 TEXT runtime·read(SB),NOSPLIT,$-8
95 MOVL fd+0(FP), DI // arg 1 fd
96 MOVQ p+8(FP), SI // arg 2 buf
97 MOVL n+16(FP), DX // arg 3 count
98 MOVL $3, AX
99 SYSCALL
100 JCC 2(PC)
101 NEGQ AX // caller expects negative errno
102 MOVL AX, ret+24(FP)
103 RET
104
105 // func pipe() (r, w int32, errno int32)
106 TEXT runtime·pipe(SB),NOSPLIT,$0-12
107 MOVL $42, AX
108 SYSCALL
109 JCC ok
110 MOVL $0, r+0(FP)
111 MOVL $0, w+4(FP)
112 MOVL AX, errno+8(FP)
113 RET
114 ok:
115 MOVL AX, r+0(FP)
116 MOVL DX, w+4(FP)
117 MOVL $0, errno+8(FP)
118 RET
119
120 // func pipe2(flags int32) (r, w int32, errno int32)
121 TEXT runtime·pipe2(SB),NOSPLIT,$0-20
122 LEAQ r+8(FP), DI
123 MOVL flags+0(FP), SI
124 MOVL $542, AX
125 SYSCALL
126 JCC 2(PC)
127 NEGQ AX
128 MOVL AX, errno+16(FP)
129 RET
130
131 TEXT runtime·write1(SB),NOSPLIT,$-8
132 MOVQ fd+0(FP), DI // arg 1 fd
133 MOVQ p+8(FP), SI // arg 2 buf
134 MOVL n+16(FP), DX // arg 3 count
135 MOVL $4, AX
136 SYSCALL
137 JCC 2(PC)
138 NEGQ AX // caller expects negative errno
139 MOVL AX, ret+24(FP)
140 RET
141
142 TEXT runtime·thr_self(SB),NOSPLIT,$0-8
143 // thr_self(&0(FP))
144 LEAQ ret+0(FP), DI // arg 1
145 MOVL $432, AX
146 SYSCALL
147 RET
148
149 TEXT runtime·thr_kill(SB),NOSPLIT,$0-16
150 // thr_kill(tid, sig)
151 MOVQ tid+0(FP), DI // arg 1 id
152 MOVQ sig+8(FP), SI // arg 2 sig
153 MOVL $433, AX
154 SYSCALL
155 RET
156
157 TEXT runtime·raiseproc(SB),NOSPLIT,$0
158 // getpid
159 MOVL $20, AX
160 SYSCALL
161 // kill(self, sig)
162 MOVQ AX, DI // arg 1 pid
163 MOVL sig+0(FP), SI // arg 2 sig
164 MOVL $37, AX
165 SYSCALL
166 RET
167
168 TEXT runtime·setitimer(SB), NOSPLIT, $-8
169 MOVL mode+0(FP), DI
170 MOVQ new+8(FP), SI
171 MOVQ old+16(FP), DX
172 MOVL $83, AX
173 SYSCALL
174 RET
175
176 // func fallback_walltime() (sec int64, nsec int32)
177 TEXT runtime·fallback_walltime(SB), NOSPLIT, $32-12
178 MOVL $232, AX // clock_gettime
179 MOVQ $0, DI // CLOCK_REALTIME
180 LEAQ 8(SP), SI
181 SYSCALL
182 MOVQ 8(SP), AX // sec
183 MOVQ 16(SP), DX // nsec
184
185 // sec is in AX, nsec in DX
186 MOVQ AX, sec+0(FP)
187 MOVL DX, nsec+8(FP)
188 RET
189
190 TEXT runtime·fallback_nanotime(SB), NOSPLIT, $32-8
191 MOVL $232, AX
192 MOVQ $4, DI // CLOCK_MONOTONIC
193 LEAQ 8(SP), SI
194 SYSCALL
195 MOVQ 8(SP), AX // sec
196 MOVQ 16(SP), DX // nsec
197
198 // sec is in AX, nsec in DX
199 // return nsec in AX
200 IMULQ $1000000000, AX
201 ADDQ DX, AX
202 MOVQ AX, ret+0(FP)
203 RET
204
205 TEXT runtime·asmSigaction(SB),NOSPLIT,$0
206 MOVQ sig+0(FP), DI // arg 1 sig
207 MOVQ new+8(FP), SI // arg 2 act
208 MOVQ old+16(FP), DX // arg 3 oact
209 MOVL $416, AX
210 SYSCALL
211 JCC 2(PC)
212 MOVL $-1, AX
213 MOVL AX, ret+24(FP)
214 RET
215
216 TEXT runtime·callCgoSigaction(SB),NOSPLIT,$16
217 MOVQ sig+0(FP), DI // arg 1 sig
218 MOVQ new+8(FP), SI // arg 2 act
219 MOVQ old+16(FP), DX // arg 3 oact
220 MOVQ _cgo_sigaction(SB), AX
221 MOVQ SP, BX // callee-saved
222 ANDQ $~15, SP // alignment as per amd64 psABI
223 CALL AX
224 MOVQ BX, SP
225 MOVL AX, ret+24(FP)
226 RET
227
228 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
229 MOVQ fn+0(FP), AX
230 MOVL sig+8(FP), DI
231 MOVQ info+16(FP), SI
232 MOVQ ctx+24(FP), DX
233 PUSHQ BP
234 MOVQ SP, BP
235 ANDQ $~15, SP // alignment for x86_64 ABI
236 CALL AX
237 MOVQ BP, SP
238 POPQ BP
239 RET
240
241 // Called using C ABI.
242 TEXT runtime·sigtramp(SB),NOSPLIT,$0
243 // Transition from C ABI to Go ABI.
244 PUSH_REGS_HOST_TO_ABI0()
245
246 // Call into the Go signal handler
247 NOP SP // disable vet stack checking
248 ADJSP $24
249 MOVQ DI, 0(SP) // sig
250 MOVQ SI, 8(SP) // info
251 MOVQ DX, 16(SP) // ctx
252 CALL ·sigtrampgo(SB)
253 ADJSP $-24
254
255 POP_REGS_HOST_TO_ABI0()
256 RET
257
258 // Used instead of sigtramp in programs that use cgo.
259 // Arguments from kernel are in DI, SI, DX.
260 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
261 // If no traceback function, do usual sigtramp.
262 MOVQ runtime·cgoTraceback(SB), AX
263 TESTQ AX, AX
264 JZ sigtramp
265
266 // If no traceback support function, which means that
267 // runtime/cgo was not linked in, do usual sigtramp.
268 MOVQ _cgo_callers(SB), AX
269 TESTQ AX, AX
270 JZ sigtramp
271
272 // Figure out if we are currently in a cgo call.
273 // If not, just do usual sigtramp.
274 get_tls(CX)
275 MOVQ g(CX),AX
276 TESTQ AX, AX
277 JZ sigtrampnog // g == nil
278 MOVQ g_m(AX), AX
279 TESTQ AX, AX
280 JZ sigtramp // g.m == nil
281 MOVL m_ncgo(AX), CX
282 TESTL CX, CX
283 JZ sigtramp // g.m.ncgo == 0
284 MOVQ m_curg(AX), CX
285 TESTQ CX, CX
286 JZ sigtramp // g.m.curg == nil
287 MOVQ g_syscallsp(CX), CX
288 TESTQ CX, CX
289 JZ sigtramp // g.m.curg.syscallsp == 0
290 MOVQ m_cgoCallers(AX), R8
291 TESTQ R8, R8
292 JZ sigtramp // g.m.cgoCallers == nil
293 MOVL m_cgoCallersUse(AX), CX
294 TESTL CX, CX
295 JNZ sigtramp // g.m.cgoCallersUse != 0
296
297 // Jump to a function in runtime/cgo.
298 // That function, written in C, will call the user's traceback
299 // function with proper unwind info, and will then call back here.
300 // The first three arguments, and the fifth, are already in registers.
301 // Set the two remaining arguments now.
302 MOVQ runtime·cgoTraceback(SB), CX
303 MOVQ $runtime·sigtramp(SB), R9
304 MOVQ _cgo_callers(SB), AX
305 JMP AX
306
307 sigtramp:
308 JMP runtime·sigtramp(SB)
309
310 sigtrampnog:
311 // Signal arrived on a non-Go thread. If this is SIGPROF, get a
312 // stack trace.
313 CMPL DI, $27 // 27 == SIGPROF
314 JNZ sigtramp
315
316 // Lock sigprofCallersUse.
317 MOVL $0, AX
318 MOVL $1, CX
319 MOVQ $runtime·sigprofCallersUse(SB), R11
320 LOCK
321 CMPXCHGL CX, 0(R11)
322 JNZ sigtramp // Skip stack trace if already locked.
323
324 // Jump to the traceback function in runtime/cgo.
325 // It will call back to sigprofNonGo, which will ignore the
326 // arguments passed in registers.
327 // First three arguments to traceback function are in registers already.
328 MOVQ runtime·cgoTraceback(SB), CX
329 MOVQ $runtime·sigprofCallers(SB), R8
330 MOVQ $runtime·sigprofNonGo(SB), R9
331 MOVQ _cgo_callers(SB), AX
332 JMP AX
333
334 TEXT runtime·mmap(SB),NOSPLIT,$0
335 MOVQ addr+0(FP), DI // arg 1 addr
336 MOVQ n+8(FP), SI // arg 2 len
337 MOVL prot+16(FP), DX // arg 3 prot
338 MOVL flags+20(FP), R10 // arg 4 flags
339 MOVL fd+24(FP), R8 // arg 5 fid
340 MOVL off+28(FP), R9 // arg 6 offset
341 MOVL $477, AX
342 SYSCALL
343 JCC ok
344 MOVQ $0, p+32(FP)
345 MOVQ AX, err+40(FP)
346 RET
347 ok:
348 MOVQ AX, p+32(FP)
349 MOVQ $0, err+40(FP)
350 RET
351
352 TEXT runtime·munmap(SB),NOSPLIT,$0
353 MOVQ addr+0(FP), DI // arg 1 addr
354 MOVQ n+8(FP), SI // arg 2 len
355 MOVL $73, AX
356 SYSCALL
357 JCC 2(PC)
358 MOVL $0xf1, 0xf1 // crash
359 RET
360
361 TEXT runtime·madvise(SB),NOSPLIT,$0
362 MOVQ addr+0(FP), DI
363 MOVQ n+8(FP), SI
364 MOVL flags+16(FP), DX
365 MOVQ $75, AX // madvise
366 SYSCALL
367 JCC 2(PC)
368 MOVL $-1, AX
369 MOVL AX, ret+24(FP)
370 RET
371
372 TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
373 MOVQ new+0(FP), DI
374 MOVQ old+8(FP), SI
375 MOVQ $53, AX
376 SYSCALL
377 JCC 2(PC)
378 MOVL $0xf1, 0xf1 // crash
379 RET
380
381 TEXT runtime·usleep(SB),NOSPLIT,$16
382 MOVL $0, DX
383 MOVL usec+0(FP), AX
384 MOVL $1000000, CX
385 DIVL CX
386 MOVQ AX, 0(SP) // tv_sec
387 MOVL $1000, AX
388 MULL DX
389 MOVQ AX, 8(SP) // tv_nsec
390
391 MOVQ SP, DI // arg 1 - rqtp
392 MOVQ $0, SI // arg 2 - rmtp
393 MOVL $240, AX // sys_nanosleep
394 SYSCALL
395 RET
396
397 // set tls base to DI
398 TEXT runtime·settls(SB),NOSPLIT,$8
399 ADDQ $8, DI // adjust for ELF: wants to use -8(FS) for g and m
400 MOVQ DI, 0(SP)
401 MOVQ SP, SI
402 MOVQ $129, DI // AMD64_SET_FSBASE
403 MOVQ $165, AX // sysarch
404 SYSCALL
405 JCC 2(PC)
406 MOVL $0xf1, 0xf1 // crash
407 RET
408
409 TEXT runtime·sysctl(SB),NOSPLIT,$0
410 MOVQ mib+0(FP), DI // arg 1 - name
411 MOVL miblen+8(FP), SI // arg 2 - namelen
412 MOVQ out+16(FP), DX // arg 3 - oldp
413 MOVQ size+24(FP), R10 // arg 4 - oldlenp
414 MOVQ dst+32(FP), R8 // arg 5 - newp
415 MOVQ ndst+40(FP), R9 // arg 6 - newlen
416 MOVQ $202, AX // sys___sysctl
417 SYSCALL
418 JCC 4(PC)
419 NEGQ AX
420 MOVL AX, ret+48(FP)
421 RET
422 MOVL $0, AX
423 MOVL AX, ret+48(FP)
424 RET
425
426 TEXT runtime·osyield(SB),NOSPLIT,$-4
427 MOVL $331, AX // sys_sched_yield
428 SYSCALL
429 RET
430
431 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
432 MOVL how+0(FP), DI // arg 1 - how
433 MOVQ new+8(FP), SI // arg 2 - set
434 MOVQ old+16(FP), DX // arg 3 - oset
435 MOVL $340, AX // sys_sigprocmask
436 SYSCALL
437 JAE 2(PC)
438 MOVL $0xf1, 0xf1 // crash
439 RET
440
441 // int32 runtime·kqueue(void);
442 TEXT runtime·kqueue(SB),NOSPLIT,$0
443 MOVQ $0, DI
444 MOVQ $0, SI
445 MOVQ $0, DX
446 MOVL $362, AX
447 SYSCALL
448 JCC 2(PC)
449 NEGQ AX
450 MOVL AX, ret+0(FP)
451 RET
452
453 // int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
454 TEXT runtime·kevent(SB),NOSPLIT,$0
455 MOVL kq+0(FP), DI
456 MOVQ ch+8(FP), SI
457 MOVL nch+16(FP), DX
458 MOVQ ev+24(FP), R10
459 MOVL nev+32(FP), R8
460 MOVQ ts+40(FP), R9
461 MOVL $363, AX
462 SYSCALL
463 JCC 2(PC)
464 NEGQ AX
465 MOVL AX, ret+48(FP)
466 RET
467
468 // void runtime·closeonexec(int32 fd);
469 TEXT runtime·closeonexec(SB),NOSPLIT,$0
470 MOVL fd+0(FP), DI // fd
471 MOVQ $2, SI // F_SETFD
472 MOVQ $1, DX // FD_CLOEXEC
473 MOVL $92, AX // fcntl
474 SYSCALL
475 RET
476
477 // func runtime·setNonblock(int32 fd)
478 TEXT runtime·setNonblock(SB),NOSPLIT,$0-4
479 MOVL fd+0(FP), DI // fd
480 MOVQ $3, SI // F_GETFL
481 MOVQ $0, DX
482 MOVL $92, AX // fcntl
483 SYSCALL
484 MOVL fd+0(FP), DI // fd
485 MOVQ $4, SI // F_SETFL
486 MOVQ $4, DX // O_NONBLOCK
487 ORL AX, DX
488 MOVL $92, AX // fcntl
489 SYSCALL
490 RET
491
492 // func cpuset_getaffinity(level int, which int, id int64, size int, mask *byte) int32
493 TEXT runtime·cpuset_getaffinity(SB), NOSPLIT, $0-44
494 MOVQ level+0(FP), DI
495 MOVQ which+8(FP), SI
496 MOVQ id+16(FP), DX
497 MOVQ size+24(FP), R10
498 MOVQ mask+32(FP), R8
499 MOVL $487, AX
500 SYSCALL
501 JCC 2(PC)
502 NEGQ AX
503 MOVL AX, ret+40(FP)
504 RET
505
View as plain text