Text file
src/runtime/sys_darwin_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, Darwin
6// System calls are implemented in libSystem, this file contains
7// trampolines that convert from Go to C calling convention.
8
9#include "go_asm.h"
10#include "go_tls.h"
11#include "textflag.h"
12
13// Exit the entire program (like C exit)
14TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
15 PUSHQ BP
16 MOVQ SP, BP
17 MOVL 0(DI), DI // arg 1 exit status
18 CALL libc_exit(SB)
19 MOVL $0xf1, 0xf1 // crash
20 POPQ BP
21 RET
22
23TEXT runtime·open_trampoline(SB),NOSPLIT,$0
24 PUSHQ BP
25 MOVQ SP, BP
26 MOVL 8(DI), SI // arg 2 flags
27 MOVL 12(DI), DX // arg 3 mode
28 MOVQ 0(DI), DI // arg 1 pathname
29 XORL AX, AX // vararg: say "no float args"
30 CALL libc_open(SB)
31 POPQ BP
32 RET
33
34TEXT runtime·close_trampoline(SB),NOSPLIT,$0
35 PUSHQ BP
36 MOVQ SP, BP
37 MOVL 0(DI), DI // arg 1 fd
38 CALL libc_close(SB)
39 POPQ BP
40 RET
41
42TEXT runtime·read_trampoline(SB),NOSPLIT,$0
43 PUSHQ BP
44 MOVQ SP, BP
45 MOVQ 8(DI), SI // arg 2 buf
46 MOVL 16(DI), DX // arg 3 count
47 MOVL 0(DI), DI // arg 1 fd
48 CALL libc_read(SB)
49 POPQ BP
50 RET
51
52TEXT runtime·write_trampoline(SB),NOSPLIT,$0
53 PUSHQ BP
54 MOVQ SP, BP
55 MOVQ 8(DI), SI // arg 2 buf
56 MOVL 16(DI), DX // arg 3 count
57 MOVQ 0(DI), DI // arg 1 fd
58 CALL libc_write(SB)
59 POPQ BP
60 RET
61
62TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
63 PUSHQ BP
64 MOVQ SP, BP
65 MOVQ 8(DI), SI // arg 2 new
66 MOVQ 16(DI), DX // arg 3 old
67 MOVL 0(DI), DI // arg 1 which
68 CALL libc_setitimer(SB)
69 POPQ BP
70 RET
71
72TEXT runtime·madvise_trampoline(SB), NOSPLIT, $0
73 PUSHQ BP
74 MOVQ SP, BP
75 MOVQ 8(DI), SI // arg 2 len
76 MOVL 16(DI), DX // arg 3 advice
77 MOVQ 0(DI), DI // arg 1 addr
78 CALL libc_madvise(SB)
79 // ignore failure - maybe pages are locked
80 POPQ BP
81 RET
82
83GLOBL timebase<>(SB),NOPTR,$(machTimebaseInfo__size)
84
85TEXT runtime·nanotime_trampoline(SB),NOSPLIT,$0
86 PUSHQ BP
87 MOVQ SP, BP
88 MOVQ DI, BX
89 CALL libc_mach_absolute_time(SB)
90 MOVQ AX, 0(BX)
91 MOVL timebase<>+machTimebaseInfo_numer(SB), SI
92 MOVL timebase<>+machTimebaseInfo_denom(SB), DI // atomic read
93 TESTL DI, DI
94 JNE initialized
95
96 SUBQ $(machTimebaseInfo__size+15)/16*16, SP
97 MOVQ SP, DI
98 CALL libc_mach_timebase_info(SB)
99 MOVL machTimebaseInfo_numer(SP), SI
100 MOVL machTimebaseInfo_denom(SP), DI
101 ADDQ $(machTimebaseInfo__size+15)/16*16, SP
102
103 MOVL SI, timebase<>+machTimebaseInfo_numer(SB)
104 MOVL DI, AX
105 XCHGL AX, timebase<>+machTimebaseInfo_denom(SB) // atomic write
106
107initialized:
108 MOVL SI, 8(BX)
109 MOVL DI, 12(BX)
110 MOVQ BP, SP
111 POPQ BP
112 RET
113
114TEXT runtime·walltime_trampoline(SB),NOSPLIT,$0
115 PUSHQ BP // make a frame; keep stack aligned
116 MOVQ SP, BP
117 // DI already has *timeval
118 XORL SI, SI // no timezone needed
119 CALL libc_gettimeofday(SB)
120 POPQ BP
121 RET
122
123TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
124 PUSHQ BP
125 MOVQ SP, BP
126 MOVQ 8(DI), SI // arg 2 new
127 MOVQ 16(DI), DX // arg 3 old
128 MOVL 0(DI), DI // arg 1 sig
129 CALL libc_sigaction(SB)
130 TESTL AX, AX
131 JEQ 2(PC)
132 MOVL $0xf1, 0xf1 // crash
133 POPQ BP
134 RET
135
136TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
137 PUSHQ BP
138 MOVQ SP, BP
139 MOVQ 8(DI), SI // arg 2 new
140 MOVQ 16(DI), DX // arg 3 old
141 MOVL 0(DI), DI // arg 1 how
142 CALL libc_pthread_sigmask(SB)
143 TESTL AX, AX
144 JEQ 2(PC)
145 MOVL $0xf1, 0xf1 // crash
146 POPQ BP
147 RET
148
149TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
150 PUSHQ BP
151 MOVQ SP, BP
152 MOVQ 8(DI), SI // arg 2 old
153 MOVQ 0(DI), DI // arg 1 new
154 CALL libc_sigaltstack(SB)
155 TESTQ AX, AX
156 JEQ 2(PC)
157 MOVL $0xf1, 0xf1 // crash
158 POPQ BP
159 RET
160
161TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
162 PUSHQ BP
163 MOVQ SP, BP
164 MOVL 0(DI), BX // signal
165 CALL libc_getpid(SB)
166 MOVL AX, DI // arg 1 pid
167 MOVL BX, SI // arg 2 signal
168 CALL libc_kill(SB)
169 POPQ BP
170 RET
171
172TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
173 MOVQ fn+0(FP), AX
174 MOVL sig+8(FP), DI
175 MOVQ info+16(FP), SI
176 MOVQ ctx+24(FP), DX
177 PUSHQ BP
178 MOVQ SP, BP
179 ANDQ $~15, SP // alignment for x86_64 ABI
180 CALL AX
181 MOVQ BP, SP
182 POPQ BP
183 RET
184
185// This is the function registered during sigaction and is invoked when
186// a signal is received. It just redirects to the Go function sigtrampgo.
187TEXT runtime·sigtramp(SB),NOSPLIT,$0
188 // This runs on the signal stack, so we have lots of stack available.
189 // We allocate our own stack space, because if we tell the linker
190 // how much we're using, the NOSPLIT check fails.
191 PUSHQ BP
192 MOVQ SP, BP
193 SUBQ $64, SP
194
195 // Save callee-save registers.
196 MOVQ BX, 24(SP)
197 MOVQ R12, 32(SP)
198 MOVQ R13, 40(SP)
199 MOVQ R14, 48(SP)
200 MOVQ R15, 56(SP)
201
202 // Call into the Go signal handler
203 MOVL DI, 0(SP) // sig
204 MOVQ SI, 8(SP) // info
205 MOVQ DX, 16(SP) // ctx
206 CALL runtime·sigtrampgo(SB)
207
208 // Restore callee-save registers.
209 MOVQ 24(SP), BX
210 MOVQ 32(SP), R12
211 MOVQ 40(SP), R13
212 MOVQ 48(SP), R14
213 MOVQ 56(SP), R15
214
215 MOVQ BP, SP
216 POPQ BP
217 RET
218
219// Used instead of sigtramp in programs that use cgo.
220// Arguments from kernel are in DI, SI, DX.
221TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
222 // If no traceback function, do usual sigtramp.
223 MOVQ runtime·cgoTraceback(SB), AX
224 TESTQ AX, AX
225 JZ sigtramp
226
227 // If no traceback support function, which means that
228 // runtime/cgo was not linked in, do usual sigtramp.
229 MOVQ _cgo_callers(SB), AX
230 TESTQ AX, AX
231 JZ sigtramp
232
233 // Figure out if we are currently in a cgo call.
234 // If not, just do usual sigtramp.
235 get_tls(CX)
236 MOVQ g(CX),AX
237 TESTQ AX, AX
238 JZ sigtrampnog // g == nil
239 MOVQ g_m(AX), AX
240 TESTQ AX, AX
241 JZ sigtramp // g.m == nil
242 MOVL m_ncgo(AX), CX
243 TESTL CX, CX
244 JZ sigtramp // g.m.ncgo == 0
245 MOVQ m_curg(AX), CX
246 TESTQ CX, CX
247 JZ sigtramp // g.m.curg == nil
248 MOVQ g_syscallsp(CX), CX
249 TESTQ CX, CX
250 JZ sigtramp // g.m.curg.syscallsp == 0
251 MOVQ m_cgoCallers(AX), R8
252 TESTQ R8, R8
253 JZ sigtramp // g.m.cgoCallers == nil
254 MOVL m_cgoCallersUse(AX), CX
255 TESTL CX, CX
256 JNZ sigtramp // g.m.cgoCallersUse != 0
257
258 // Jump to a function in runtime/cgo.
259 // That function, written in C, will call the user's traceback
260 // function with proper unwind info, and will then call back here.
261 // The first three arguments, and the fifth, are already in registers.
262 // Set the two remaining arguments now.
263 MOVQ runtime·cgoTraceback(SB), CX
264 MOVQ $runtime·sigtramp(SB), R9
265 MOVQ _cgo_callers(SB), AX
266 JMP AX
267
268sigtramp:
269 JMP runtime·sigtramp(SB)
270
271sigtrampnog:
272 // Signal arrived on a non-Go thread. If this is SIGPROF, get a
273 // stack trace.
274 CMPL DI, $27 // 27 == SIGPROF
275 JNZ sigtramp
276
277 // Lock sigprofCallersUse.
278 MOVL $0, AX
279 MOVL $1, CX
280 MOVQ $runtime·sigprofCallersUse(SB), R11
281 LOCK
282 CMPXCHGL CX, 0(R11)
283 JNZ sigtramp // Skip stack trace if already locked.
284
285 // Jump to the traceback function in runtime/cgo.
286 // It will call back to sigprofNonGo, which will ignore the
287 // arguments passed in registers.
288 // First three arguments to traceback function are in registers already.
289 MOVQ runtime·cgoTraceback(SB), CX
290 MOVQ $runtime·sigprofCallers(SB), R8
291 MOVQ $runtime·sigprofNonGo(SB), R9
292 MOVQ _cgo_callers(SB), AX
293 JMP AX
294
295TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
296 PUSHQ BP // make a frame; keep stack aligned
297 MOVQ SP, BP
298 MOVQ DI, BX
299 MOVQ 0(BX), DI // arg 1 addr
300 MOVQ 8(BX), SI // arg 2 len
301 MOVL 16(BX), DX // arg 3 prot
302 MOVL 20(BX), CX // arg 4 flags
303 MOVL 24(BX), R8 // arg 5 fid
304 MOVL 28(BX), R9 // arg 6 offset
305 CALL libc_mmap(SB)
306 XORL DX, DX
307 CMPQ AX, $-1
308 JNE ok
309 CALL libc_error(SB)
310 MOVLQSX (AX), DX // errno
311 XORL AX, AX
312ok:
313 MOVQ AX, 32(BX)
314 MOVQ DX, 40(BX)
315 POPQ BP
316 RET
317
318TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
319 PUSHQ BP
320 MOVQ SP, BP
321 MOVQ 8(DI), SI // arg 2 len
322 MOVQ 0(DI), DI // arg 1 addr
323 CALL libc_munmap(SB)
324 TESTQ AX, AX
325 JEQ 2(PC)
326 MOVL $0xf1, 0xf1 // crash
327 POPQ BP
328 RET
329
330TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
331 PUSHQ BP
332 MOVQ SP, BP
333 MOVL 0(DI), DI // arg 1 usec
334 CALL libc_usleep(SB)
335 POPQ BP
336 RET
337
338TEXT runtime·settls(SB),NOSPLIT,$32
339 // Nothing to do on Darwin, pthread already set thread-local storage up.
340 RET
341
342TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
343 PUSHQ BP
344 MOVQ SP, BP
345 MOVL 8(DI), SI // arg 2 miblen
346 MOVQ 16(DI), DX // arg 3 out
347 MOVQ 24(DI), CX // arg 4 size
348 MOVQ 32(DI), R8 // arg 5 dst
349 MOVQ 40(DI), R9 // arg 6 ndst
350 MOVQ 0(DI), DI // arg 1 mib
351 CALL libc_sysctl(SB)
352 POPQ BP
353 RET
354
355TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
356 PUSHQ BP
357 MOVQ SP, BP
358 CALL libc_kqueue(SB)
359 POPQ BP
360 RET
361
362TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
363 PUSHQ BP
364 MOVQ SP, BP
365 MOVQ 8(DI), SI // arg 2 keventt
366 MOVL 16(DI), DX // arg 3 nch
367 MOVQ 24(DI), CX // arg 4 ev
368 MOVL 32(DI), R8 // arg 5 nev
369 MOVQ 40(DI), R9 // arg 6 ts
370 MOVL 0(DI), DI // arg 1 kq
371 CALL libc_kevent(SB)
372 CMPQ AX, $-1
373 JNE ok
374 CALL libc_error(SB)
375 MOVLQSX (AX), AX // errno
376 NEGQ AX // caller wants it as a negative error code
377ok:
378 POPQ BP
379 RET
380
381TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
382 PUSHQ BP
383 MOVQ SP, BP
384 MOVL 4(DI), SI // arg 2 cmd
385 MOVL 8(DI), DX // arg 3 arg
386 MOVL 0(DI), DI // arg 1 fd
387 XORL AX, AX // vararg: say "no float args"
388 CALL libc_fcntl(SB)
389 POPQ BP
390 RET
391
392// mstart_stub is the first function executed on a new thread started by pthread_create.
393// It just does some low-level setup and then calls mstart.
394// Note: called with the C calling convention.
395TEXT runtime·mstart_stub(SB),NOSPLIT,$0
396 // DI points to the m.
397 // We are already on m's g0 stack.
398
399 // Save callee-save registers.
400 SUBQ $40, SP
401 MOVQ BX, 0(SP)
402 MOVQ R12, 8(SP)
403 MOVQ R13, 16(SP)
404 MOVQ R14, 24(SP)
405 MOVQ R15, 32(SP)
406
407 MOVQ m_g0(DI), DX // g
408
409 // Initialize TLS entry.
410 // See cmd/link/internal/ld/sym.go:computeTLSOffset.
411 MOVQ DX, 0x30(GS)
412
413 // Someday the convention will be D is always cleared.
414 CLD
415
416 CALL runtime·mstart(SB)
417
418 // Restore callee-save registers.
419 MOVQ 0(SP), BX
420 MOVQ 8(SP), R12
421 MOVQ 16(SP), R13
422 MOVQ 24(SP), R14
423 MOVQ 32(SP), R15
424
425 // Go is all done with this OS thread.
426 // Tell pthread everything is ok (we never join with this thread, so
427 // the value here doesn't really matter).
428 XORL AX, AX
429
430 ADDQ $40, SP
431 RET
432
433// These trampolines help convert from Go calling convention to C calling convention.
434// They should be called with asmcgocall.
435// A pointer to the arguments is passed in DI.
436// A single int32 result is returned in AX.
437// (For more results, make an args/results structure.)
438TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
439 PUSHQ BP // make frame, keep stack 16-byte aligned.
440 MOVQ SP, BP
441 MOVQ 0(DI), DI // arg 1 attr
442 CALL libc_pthread_attr_init(SB)
443 POPQ BP
444 RET
445
446TEXT runtime·pthread_attr_setstacksize_trampoline(SB),NOSPLIT,$0
447 PUSHQ BP
448 MOVQ SP, BP
449 MOVQ 8(DI), SI // arg 2 size
450 MOVQ 0(DI), DI // arg 1 attr
451 CALL libc_pthread_attr_setstacksize(SB)
452 POPQ BP
453 RET
454
455TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
456 PUSHQ BP
457 MOVQ SP, BP
458 MOVQ 8(DI), SI // arg 2 state
459 MOVQ 0(DI), DI // arg 1 attr
460 CALL libc_pthread_attr_setdetachstate(SB)
461 POPQ BP
462 RET
463
464TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
465 PUSHQ BP
466 MOVQ SP, BP
467 SUBQ $16, SP
468 MOVQ 0(DI), SI // arg 2 attr
469 MOVQ 8(DI), DX // arg 3 start
470 MOVQ 16(DI), CX // arg 4 arg
471 MOVQ SP, DI // arg 1 &threadid (which we throw away)
472 CALL libc_pthread_create(SB)
473 MOVQ BP, SP
474 POPQ BP
475 RET
476
477TEXT runtime·raise_trampoline(SB),NOSPLIT,$0
478 PUSHQ BP
479 MOVQ SP, BP
480 MOVL 0(DI), DI // arg 1 signal
481 CALL libc_raise(SB)
482 POPQ BP
483 RET
484
485TEXT runtime·pthread_mutex_init_trampoline(SB),NOSPLIT,$0
486 PUSHQ BP
487 MOVQ SP, BP
488 MOVQ 8(DI), SI // arg 2 attr
489 MOVQ 0(DI), DI // arg 1 mutex
490 CALL libc_pthread_mutex_init(SB)
491 POPQ BP
492 RET
493
494TEXT runtime·pthread_mutex_lock_trampoline(SB),NOSPLIT,$0
495 PUSHQ BP
496 MOVQ SP, BP
497 MOVQ 0(DI), DI // arg 1 mutex
498 CALL libc_pthread_mutex_lock(SB)
499 POPQ BP
500 RET
501
502TEXT runtime·pthread_mutex_unlock_trampoline(SB),NOSPLIT,$0
503 PUSHQ BP
504 MOVQ SP, BP
505 MOVQ 0(DI), DI // arg 1 mutex
506 CALL libc_pthread_mutex_unlock(SB)
507 POPQ BP
508 RET
509
510TEXT runtime·pthread_cond_init_trampoline(SB),NOSPLIT,$0
511 PUSHQ BP
512 MOVQ SP, BP
513 MOVQ 8(DI), SI // arg 2 attr
514 MOVQ 0(DI), DI // arg 1 cond
515 CALL libc_pthread_cond_init(SB)
516 POPQ BP
517 RET
518
519TEXT runtime·pthread_cond_wait_trampoline(SB),NOSPLIT,$0
520 PUSHQ BP
521 MOVQ SP, BP
522 MOVQ 8(DI), SI // arg 2 mutex
523 MOVQ 0(DI), DI // arg 1 cond
524 CALL libc_pthread_cond_wait(SB)
525 POPQ BP
526 RET
527
528TEXT runtime·pthread_cond_timedwait_relative_np_trampoline(SB),NOSPLIT,$0
529 PUSHQ BP
530 MOVQ SP, BP
531 MOVQ 8(DI), SI // arg 2 mutex
532 MOVQ 16(DI), DX // arg 3 timeout
533 MOVQ 0(DI), DI // arg 1 cond
534 CALL libc_pthread_cond_timedwait_relative_np(SB)
535 POPQ BP
536 RET
537
538TEXT runtime·pthread_cond_signal_trampoline(SB),NOSPLIT,$0
539 PUSHQ BP
540 MOVQ SP, BP
541 MOVQ 0(DI), DI // arg 1 cond
542 CALL libc_pthread_cond_signal(SB)
543 POPQ BP
544 RET
545
546// syscall calls a function in libc on behalf of the syscall package.
547// syscall takes a pointer to a struct like:
548// struct {
549// fn uintptr
550// a1 uintptr
551// a2 uintptr
552// a3 uintptr
553// r1 uintptr
554// r2 uintptr
555// err uintptr
556// }
557// syscall must be called on the g0 stack with the
558// C calling convention (use libcCall).
559TEXT runtime·syscall(SB),NOSPLIT,$0
560 PUSHQ BP
561 MOVQ SP, BP
562 SUBQ $16, SP
563 MOVQ (0*8)(DI), CX // fn
564 MOVQ (2*8)(DI), SI // a2
565 MOVQ (3*8)(DI), DX // a3
566 MOVQ DI, (SP)
567 MOVQ (1*8)(DI), DI // a1
568 XORL AX, AX // vararg: say "no float args"
569
570 CALL CX
571
572 MOVQ (SP), DI
573 MOVQ AX, (4*8)(DI) // r1
574 MOVQ DX, (5*8)(DI) // r2
575
576 // Standard libc functions return -1 on error
577 // and set errno.
578 CMPL AX, $-1 // Note: high 32 bits are junk
579 JNE ok
580
581 // Get error code from libc.
582 CALL libc_error(SB)
583 MOVLQSX (AX), AX
584 MOVQ (SP), DI
585 MOVQ AX, (6*8)(DI) // err
586
587ok:
588 XORL AX, AX // no error (it's ignored anyway)
589 MOVQ BP, SP
590 POPQ BP
591 RET
592
593// syscallX calls a function in libc on behalf of the syscall package.
594// syscallX takes a pointer to a struct like:
595// struct {
596// fn uintptr
597// a1 uintptr
598// a2 uintptr
599// a3 uintptr
600// r1 uintptr
601// r2 uintptr
602// err uintptr
603// }
604// syscallX must be called on the g0 stack with the
605// C calling convention (use libcCall).
606TEXT runtime·syscallX(SB),NOSPLIT,$0
607 PUSHQ BP
608 MOVQ SP, BP
609 SUBQ $16, SP
610 MOVQ (0*8)(DI), CX // fn
611 MOVQ (2*8)(DI), SI // a2
612 MOVQ (3*8)(DI), DX // a3
613 MOVQ DI, (SP)
614 MOVQ (1*8)(DI), DI // a1
615 XORL AX, AX // vararg: say "no float args"
616
617 CALL CX
618
619 MOVQ (SP), DI
620 MOVQ AX, (4*8)(DI) // r1
621 MOVQ DX, (5*8)(DI) // r2
622
623 // Standard libc functions return -1 on error
624 // and set errno.
625 CMPQ AX, $-1
626 JNE ok
627
628 // Get error code from libc.
629 CALL libc_error(SB)
630 MOVLQSX (AX), AX
631 MOVQ (SP), DI
632 MOVQ AX, (6*8)(DI) // err
633
634ok:
635 XORL AX, AX // no error (it's ignored anyway)
636 MOVQ BP, SP
637 POPQ BP
638 RET
639
640// Not used on amd64.
641TEXT runtime·syscallXPtr(SB),NOSPLIT,$0
642 MOVL $0xf1, 0xf1 // crash
643 RET
644
645// syscall6 calls a function in libc on behalf of the syscall package.
646// syscall6 takes a pointer to a struct like:
647// struct {
648// fn uintptr
649// a1 uintptr
650// a2 uintptr
651// a3 uintptr
652// a4 uintptr
653// a5 uintptr
654// a6 uintptr
655// r1 uintptr
656// r2 uintptr
657// err uintptr
658// }
659// syscall6 must be called on the g0 stack with the
660// C calling convention (use libcCall).
661TEXT runtime·syscall6(SB),NOSPLIT,$0
662 PUSHQ BP
663 MOVQ SP, BP
664 SUBQ $16, SP
665 MOVQ (0*8)(DI), R11// fn
666 MOVQ (2*8)(DI), SI // a2
667 MOVQ (3*8)(DI), DX // a3
668 MOVQ (4*8)(DI), CX // a4
669 MOVQ (5*8)(DI), R8 // a5
670 MOVQ (6*8)(DI), R9 // a6
671 MOVQ DI, (SP)
672 MOVQ (1*8)(DI), DI // a1
673 XORL AX, AX // vararg: say "no float args"
674
675 CALL R11
676
677 MOVQ (SP), DI
678 MOVQ AX, (7*8)(DI) // r1
679 MOVQ DX, (8*8)(DI) // r2
680
681 CMPL AX, $-1
682 JNE ok
683
684 CALL libc_error(SB)
685 MOVLQSX (AX), AX
686 MOVQ (SP), DI
687 MOVQ AX, (9*8)(DI) // err
688
689ok:
690 XORL AX, AX // no error (it's ignored anyway)
691 MOVQ BP, SP
692 POPQ BP
693 RET
694
695// syscall6X calls a function in libc on behalf of the syscall package.
696// syscall6X takes a pointer to a struct like:
697// struct {
698// fn uintptr
699// a1 uintptr
700// a2 uintptr
701// a3 uintptr
702// a4 uintptr
703// a5 uintptr
704// a6 uintptr
705// r1 uintptr
706// r2 uintptr
707// err uintptr
708// }
709// syscall6X must be called on the g0 stack with the
710// C calling convention (use libcCall).
711TEXT runtime·syscall6X(SB),NOSPLIT,$0
712 PUSHQ BP
713 MOVQ SP, BP
714 SUBQ $16, SP
715 MOVQ (0*8)(DI), R11// fn
716 MOVQ (2*8)(DI), SI // a2
717 MOVQ (3*8)(DI), DX // a3
718 MOVQ (4*8)(DI), CX // a4
719 MOVQ (5*8)(DI), R8 // a5
720 MOVQ (6*8)(DI), R9 // a6
721 MOVQ DI, (SP)
722 MOVQ (1*8)(DI), DI // a1
723 XORL AX, AX // vararg: say "no float args"
724
725 CALL R11
726
727 MOVQ (SP), DI
728 MOVQ AX, (7*8)(DI) // r1
729 MOVQ DX, (8*8)(DI) // r2
730
731 CMPQ AX, $-1
732 JNE ok
733
734 CALL libc_error(SB)
735 MOVLQSX (AX), AX
736 MOVQ (SP), DI
737 MOVQ AX, (9*8)(DI) // err
738
739ok:
740 XORL AX, AX // no error (it's ignored anyway)
741 MOVQ BP, SP
742 POPQ BP
743 RET
View as plain text