Text file src/runtime/sys_darwin_amd64.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 //
6 // System calls and other sys.stuff for AMD64, Darwin
7 // See http://fxr.watson.org/fxr/source/bsd/kern/syscalls.c?v=xnu-1228
8 // or /usr/include/sys/syscall.h (on a Mac) for system call numbers.
9 //
10 // The low 24 bits are the system call number.
11 // The high 8 bits specify the kind of system call: 1=Mach, 2=BSD, 3=Machine-Dependent.
12 //
13
14 #include "go_asm.h"
15 #include "go_tls.h"
16 #include "textflag.h"
17
18 // Exit the entire program (like C exit)
19 TEXT runtime·exit(SB),NOSPLIT,$0
20 MOVL code+0(FP), DI // arg 1 exit status
21 MOVL $(0x2000000+1), AX // syscall entry
22 SYSCALL
23 MOVL $0xf1, 0xf1 // crash
24 RET
25
26 // Exit this OS thread (like pthread_exit, which eventually
27 // calls __bsdthread_terminate).
28 TEXT runtime·exit1(SB),NOSPLIT,$0
29 MOVL code+0(FP), DI // arg 1 exit status
30 MOVL $(0x2000000+361), AX // syscall entry
31 SYSCALL
32 MOVL $0xf1, 0xf1 // crash
33 RET
34
35 TEXT runtime·open(SB),NOSPLIT,$0
36 MOVQ name+0(FP), DI // arg 1 pathname
37 MOVL mode+8(FP), SI // arg 2 flags
38 MOVL perm+12(FP), DX // arg 3 mode
39 MOVL $(0x2000000+5), AX // syscall entry
40 SYSCALL
41 JCC 2(PC)
42 MOVL $-1, AX
43 MOVL AX, ret+16(FP)
44 RET
45
46 TEXT runtime·closefd(SB),NOSPLIT,$0
47 MOVL fd+0(FP), DI // arg 1 fd
48 MOVL $(0x2000000+6), AX // syscall entry
49 SYSCALL
50 JCC 2(PC)
51 MOVL $-1, AX
52 MOVL AX, ret+8(FP)
53 RET
54
55 TEXT runtime·read(SB),NOSPLIT,$0
56 MOVL fd+0(FP), DI // arg 1 fd
57 MOVQ p+8(FP), SI // arg 2 buf
58 MOVL n+16(FP), DX // arg 3 count
59 MOVL $(0x2000000+3), AX // syscall entry
60 SYSCALL
61 JCC 2(PC)
62 MOVL $-1, AX
63 MOVL AX, ret+24(FP)
64 RET
65
66 TEXT runtime·write(SB),NOSPLIT,$0
67 MOVQ fd+0(FP), DI // arg 1 fd
68 MOVQ p+8(FP), SI // arg 2 buf
69 MOVL n+16(FP), DX // arg 3 count
70 MOVL $(0x2000000+4), AX // syscall entry
71 SYSCALL
72 JCC 2(PC)
73 MOVL $-1, AX
74 MOVL AX, ret+24(FP)
75 RET
76
77 TEXT runtime·raise(SB),NOSPLIT,$0
78 // Ideally we'd send the signal to the current thread,
79 // not the whole process, but that's too hard on OS X.
80 JMP runtime·raiseproc(SB)
81
82 TEXT runtime·raiseproc(SB),NOSPLIT,$24
83 MOVL $(0x2000000+20), AX // getpid
84 SYSCALL
85 MOVQ AX, DI // arg 1 - pid
86 MOVL sig+0(FP), SI // arg 2 - signal
87 MOVL $1, DX // arg 3 - posix
88 MOVL $(0x2000000+37), AX // kill
89 SYSCALL
90 RET
91
92 TEXT runtime·setitimer(SB), NOSPLIT, $0
93 MOVL mode+0(FP), DI
94 MOVQ new+8(FP), SI
95 MOVQ old+16(FP), DX
96 MOVL $(0x2000000+83), AX // syscall entry
97 SYSCALL
98 RET
99
100 TEXT runtime·madvise(SB), NOSPLIT, $0
101 MOVQ addr+0(FP), DI // arg 1 addr
102 MOVQ n+8(FP), SI // arg 2 len
103 MOVL flags+16(FP), DX // arg 3 advice
104 MOVL $(0x2000000+75), AX // syscall entry madvise
105 SYSCALL
106 // ignore failure - maybe pages are locked
107 RET
108
109 // OS X comm page time offsets
110 // http://www.opensource.apple.com/source/xnu/xnu-1699.26.8/osfmk/i386/cpu_capabilities.h
111 #define nt_tsc_base 0x50
112 #define nt_scale 0x58
113 #define nt_shift 0x5c
114 #define nt_ns_base 0x60
115 #define nt_generation 0x68
116 #define gtod_generation 0x6c
117 #define gtod_ns_base 0x70
118 #define gtod_sec_base 0x78
119
120 TEXT nanotime<>(SB), NOSPLIT, $32
121 MOVQ $0x7fffffe00000, BP /* comm page base */
122 // Loop trying to take a consistent snapshot
123 // of the time parameters.
124 timeloop:
125 MOVL gtod_generation(BP), R8
126 TESTL R8, R8
127 JZ systime
128 MOVL nt_generation(BP), R9
129 TESTL R9, R9
130 JZ timeloop
131 RDTSC
132 MOVQ nt_tsc_base(BP), R10
133 MOVL nt_scale(BP), R11
134 MOVQ nt_ns_base(BP), R12
135 CMPL nt_generation(BP), R9
136 JNE timeloop
137 MOVQ gtod_ns_base(BP), R13
138 MOVQ gtod_sec_base(BP), R14
139 CMPL gtod_generation(BP), R8
140 JNE timeloop
141
142 // Gathered all the data we need. Compute time.
143 // ((tsc - nt_tsc_base) * nt_scale) >> 32 + nt_ns_base - gtod_ns_base + gtod_sec_base*1e9
144 // The multiply and shift extracts the top 64 bits of the 96-bit product.
145 SHLQ $32, DX
146 ADDQ DX, AX
147 SUBQ R10, AX
148 MULQ R11
149 SHRQ $32, AX:DX
150 ADDQ R12, AX
151 SUBQ R13, AX
152 IMULQ $1000000000, R14
153 ADDQ R14, AX
154 RET
155
156 systime:
157 // Fall back to system call (usually first call in this thread).
158 MOVQ SP, DI
159 MOVQ $0, SI
160 MOVQ $0, DX // required as of Sierra; Issue 16570
161 MOVL $(0x2000000+116), AX // gettimeofday
162 SYSCALL
163 CMPQ AX, $0
164 JNE inreg
165 MOVQ 0(SP), AX
166 MOVL 8(SP), DX
167 inreg:
168 // sec is in AX, usec in DX
169 // return nsec in AX
170 IMULQ $1000000000, AX
171 IMULQ $1000, DX
172 ADDQ DX, AX
173 RET
174
175 TEXT runtime·nanotime(SB),NOSPLIT,$0-8
176 CALL nanotime<>(SB)
177 MOVQ AX, ret+0(FP)
178 RET
179
180 // func now() (sec int64, nsec int32)
181 TEXT time·now(SB),NOSPLIT,$0-12
182 CALL nanotime<>(SB)
183
184 // generated code for
185 // func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
186 // adapted to reduce duplication
187 MOVQ AX, CX
188 MOVQ $1360296554856532783, AX
189 MULQ CX
190 ADDQ CX, DX
191 RCRQ $1, DX
192 SHRQ $29, DX
193 MOVQ DX, sec+0(FP)
194 IMULQ $1000000000, DX
195 SUBQ DX, CX
196 MOVL CX, nsec+8(FP)
197 RET
198
199 TEXT runtime·sigprocmask(SB),NOSPLIT,$0
200 MOVL how+0(FP), DI
201 MOVQ new+8(FP), SI
202 MOVQ old+16(FP), DX
203 MOVL $(0x2000000+329), AX // pthread_sigmask (on OS X, sigprocmask==entire process)
204 SYSCALL
205 JCC 2(PC)
206 MOVL $0xf1, 0xf1 // crash
207 RET
208
209 TEXT runtime·sigaction(SB),NOSPLIT,$0-24
210 MOVL mode+0(FP), DI // arg 1 sig
211 MOVQ new+8(FP), SI // arg 2 act
212 MOVQ old+16(FP), DX // arg 3 oact
213 MOVQ old+16(FP), CX // arg 3 oact
214 MOVQ old+16(FP), R10 // arg 3 oact
215 MOVL $(0x2000000+46), AX // syscall entry
216 SYSCALL
217 JCC 2(PC)
218 MOVL $0xf1, 0xf1 // crash
219 RET
220
221 TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
222 MOVQ fn+0(FP), AX
223 MOVL sig+8(FP), DI
224 MOVQ info+16(FP), SI
225 MOVQ ctx+24(FP), DX
226 PUSHQ BP
227 MOVQ SP, BP
228 ANDQ $~15, SP // alignment for x86_64 ABI
229 CALL AX
230 MOVQ BP, SP
231 POPQ BP
232 RET
233
234 TEXT runtime·sigtramp(SB),NOSPLIT,$32
235 MOVL SI, 24(SP) // save infostyle for sigreturn below
236 MOVL DX, 0(SP) // sig
237 MOVQ CX, 8(SP) // info
238 MOVQ R8, 16(SP) // ctx
239 MOVQ $runtime·sigtrampgo(SB), AX
240 CALL AX
241 MOVQ 16(SP), DI // ctx
242 MOVL 24(SP), SI // infostyle
243 MOVL $(0x2000000+184), AX
244 SYSCALL
245 INT $3 // not reached
246
247 TEXT runtime·mmap(SB),NOSPLIT,$0
248 MOVQ addr+0(FP), DI // arg 1 addr
249 MOVQ n+8(FP), SI // arg 2 len
250 MOVL prot+16(FP), DX // arg 3 prot
251 MOVL flags+20(FP), R10 // arg 4 flags
252 MOVL fd+24(FP), R8 // arg 5 fid
253 MOVL off+28(FP), R9 // arg 6 offset
254 MOVL $(0x2000000+197), AX // syscall entry
255 SYSCALL
256 MOVQ AX, ret+32(FP)
257 RET
258
259 TEXT runtime·munmap(SB),NOSPLIT,$0
260 MOVQ addr+0(FP), DI // arg 1 addr
261 MOVQ n+8(FP), SI // arg 2 len
262 MOVL $(0x2000000+73), AX // syscall entry
263 SYSCALL
264 JCC 2(PC)
265 MOVL $0xf1, 0xf1 // crash
266 RET
267
268 TEXT runtime·sigaltstack(SB),NOSPLIT,$0
269 MOVQ new+0(FP), DI
270 MOVQ old+8(FP), SI
271 MOVQ $(0x2000000+53), AX
272 SYSCALL
273 JCC 2(PC)
274 MOVL $0xf1, 0xf1 // crash
275 RET
276
277 TEXT runtime·usleep(SB),NOSPLIT,$16
278 MOVL $0, DX
279 MOVL usec+0(FP), AX
280 MOVL $1000000, CX
281 DIVL CX
282 MOVQ AX, 0(SP) // sec
283 MOVL DX, 8(SP) // usec
284
285 // select(0, 0, 0, 0, &tv)
286 MOVL $0, DI
287 MOVL $0, SI
288 MOVL $0, DX
289 MOVL $0, R10
290 MOVQ SP, R8
291 MOVL $(0x2000000+93), AX
292 SYSCALL
293 RET
294
295 // func bsdthread_create(stk, arg unsafe.Pointer, fn uintptr) int32
296 TEXT runtime·bsdthread_create(SB),NOSPLIT,$0
297 // Set up arguments to bsdthread_create system call.
298 // The ones in quotes pass through to the thread callback
299 // uninterpreted, so we can put whatever we want there.
300 MOVQ fn+16(FP), DI
301 MOVQ arg+8(FP), SI
302 MOVQ stk+0(FP), DX
303 MOVQ $0x01000000, R8 // flags = PTHREAD_START_CUSTOM
304 MOVQ $0, R9 // paranoia
305 MOVQ $0, R10 // paranoia, "pthread"
306 MOVQ $(0x2000000+360), AX // bsdthread_create
307 SYSCALL
308 JCC 4(PC)
309 NEGQ AX
310 MOVL AX, ret+24(FP)
311 RET
312 MOVL $0, AX
313 MOVL AX, ret+24(FP)
314 RET
315
316 // The thread that bsdthread_create creates starts executing here,
317 // because we registered this function using bsdthread_register
318 // at startup.
319 // DI = "pthread"
320 // SI = mach thread port
321 // DX = "func" (= fn)
322 // CX = "arg" (= m)
323 // R8 = stack
324 // R9 = flags (= 0)
325 // SP = stack - C_64_REDZONE_LEN (= stack - 128)
326 TEXT runtime·bsdthread_start(SB),NOSPLIT,$0
327 MOVQ R8, SP // empirically, SP is very wrong but R8 is right
328
329 PUSHQ DX
330 PUSHQ CX
331 PUSHQ SI
332
333 // set up thread local storage pointing at m->tls.
334 LEAQ m_tls(CX), DI
335 CALL runtime·settls(SB)
336
337 POPQ SI
338 POPQ CX
339 POPQ DX
340
341 get_tls(BX)
342 MOVQ SI, m_procid(CX) // thread port is m->procid
343 MOVQ m_g0(CX), AX
344 MOVQ AX, g(BX)
345 MOVQ CX, g_m(AX)
346 CALL runtime·stackcheck(SB) // smashes AX, CX
347 CALL DX // fn
348 CALL runtime·exit1(SB)
349 RET
350
351 // func bsdthread_register() int32
352 // registers callbacks for threadstart (see bsdthread_create above
353 // and wqthread and pthsize (not used). returns 0 on success.
354 TEXT runtime·bsdthread_register(SB),NOSPLIT,$0
355 MOVQ $runtime·bsdthread_start(SB), DI // threadstart
356 MOVQ $0, SI // wqthread, not used by us
357 MOVQ $0, DX // pthsize, not used by us
358 MOVQ $0, R10 // dummy_value [sic]
359 MOVQ $0, R8 // targetconc_ptr
360 MOVQ $0, R9 // dispatchqueue_offset
361 MOVQ $(0x2000000+366), AX // bsdthread_register
362 SYSCALL
363 JCC 4(PC)
364 NEGQ AX
365 MOVL AX, ret+0(FP)
366 RET
367 MOVL $0, AX
368 MOVL AX, ret+0(FP)
369 RET
370
371 // Mach system calls use 0x1000000 instead of the BSD's 0x2000000.
372
373 // func mach_msg_trap(h unsafe.Pointer, op int32, send_size, rcv_size, rcv_name, timeout, notify uint32) int32
374 TEXT runtime·mach_msg_trap(SB),NOSPLIT,$0
375 MOVQ h+0(FP), DI
376 MOVL op+8(FP), SI
377 MOVL send_size+12(FP), DX
378 MOVL rcv_size+16(FP), R10
379 MOVL rcv_name+20(FP), R8
380 MOVL timeout+24(FP), R9
381 MOVL notify+28(FP), R11
382 PUSHQ R11 // seventh arg, on stack
383 MOVL $(0x1000000+31), AX // mach_msg_trap
384 SYSCALL
385 POPQ R11
386 MOVL AX, ret+32(FP)
387 RET
388
389 TEXT runtime·mach_task_self(SB),NOSPLIT,$0
390 MOVL $(0x1000000+28), AX // task_self_trap
391 SYSCALL
392 MOVL AX, ret+0(FP)
393 RET
394
395 TEXT runtime·mach_thread_self(SB),NOSPLIT,$0
396 MOVL $(0x1000000+27), AX // thread_self_trap
397 SYSCALL
398 MOVL AX, ret+0(FP)
399 RET
400
401 TEXT runtime·mach_reply_port(SB),NOSPLIT,$0
402 MOVL $(0x1000000+26), AX // mach_reply_port
403 SYSCALL
404 MOVL AX, ret+0(FP)
405 RET
406
407 // Mach provides trap versions of the semaphore ops,
408 // instead of requiring the use of RPC.
409
410 // func mach_semaphore_wait(sema uint32) int32
411 TEXT runtime·mach_semaphore_wait(SB),NOSPLIT,$0
412 MOVL sema+0(FP), DI
413 MOVL $(0x1000000+36), AX // semaphore_wait_trap
414 SYSCALL
415 MOVL AX, ret+8(FP)
416 RET
417
418 // func mach_semaphore_timedwait(sema, sec, nsec uint32) int32
419 TEXT runtime·mach_semaphore_timedwait(SB),NOSPLIT,$0
420 MOVL sema+0(FP), DI
421 MOVL sec+4(FP), SI
422 MOVL nsec+8(FP), DX
423 MOVL $(0x1000000+38), AX // semaphore_timedwait_trap
424 SYSCALL
425 MOVL AX, ret+16(FP)
426 RET
427
428 // func mach_semaphore_signal(sema uint32) int32
429 TEXT runtime·mach_semaphore_signal(SB),NOSPLIT,$0
430 MOVL sema+0(FP), DI
431 MOVL $(0x1000000+33), AX // semaphore_signal_trap
432 SYSCALL
433 MOVL AX, ret+8(FP)
434 RET
435
436 // func mach_semaphore_signal_all(sema uint32) int32
437 TEXT runtime·mach_semaphore_signal_all(SB),NOSPLIT,$0
438 MOVL sema+0(FP), DI
439 MOVL $(0x1000000+34), AX // semaphore_signal_all_trap
440 SYSCALL
441 MOVL AX, ret+8(FP)
442 RET
443
444 // set tls base to DI
445 TEXT runtime·settls(SB),NOSPLIT,$32
446 /*
447 * Same as in sys_darwin_386.s:/ugliness, different constant.
448 * See cgo/gcc_darwin_amd64.c for the derivation
449 * of the constant.
450 */
451 SUBQ $0x8a0, DI
452
453 MOVL $(0x3000000+3), AX // thread_fast_set_cthread_self - machdep call #3
454 SYSCALL
455 RET
456
457 TEXT runtime·sysctl(SB),NOSPLIT,$0
458 MOVQ mib+0(FP), DI
459 MOVL miblen+8(FP), SI
460 MOVQ out+16(FP), DX
461 MOVQ size+24(FP), R10
462 MOVQ dst+32(FP), R8
463 MOVQ ndst+40(FP), R9
464 MOVL $(0x2000000+202), AX // syscall entry
465 SYSCALL
466 JCC 4(PC)
467 NEGQ AX
468 MOVL AX, ret+48(FP)
469 RET
470 MOVL $0, AX
471 MOVL AX, ret+48(FP)
472 RET
473
474 // func kqueue() int32
475 TEXT runtime·kqueue(SB),NOSPLIT,$0
476 MOVQ $0, DI
477 MOVQ $0, SI
478 MOVQ $0, DX
479 MOVL $(0x2000000+362), AX
480 SYSCALL
481 JCC 2(PC)
482 NEGQ AX
483 MOVL AX, ret+0(FP)
484 RET
485
486 // func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32
487 TEXT runtime·kevent(SB),NOSPLIT,$0
488 MOVL kq+0(FP), DI
489 MOVQ ch+8(FP), SI
490 MOVL nch+16(FP), DX
491 MOVQ ev+24(FP), R10
492 MOVL nev+32(FP), R8
493 MOVQ ts+40(FP), R9
494 MOVL $(0x2000000+363), AX
495 SYSCALL
496 JCC 2(PC)
497 NEGQ AX
498 MOVL AX, ret+48(FP)
499 RET
500
501 // func closeonexec(fd int32)
502 TEXT runtime·closeonexec(SB),NOSPLIT,$0
503 MOVL fd+0(FP), DI // fd
504 MOVQ $2, SI // F_SETFD
505 MOVQ $1, DX // FD_CLOEXEC
506 MOVL $(0x2000000+92), AX // fcntl
507 SYSCALL
508 RET
View as plain text