Text file src/pkg/runtime/sys_darwin_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, 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)
14 TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
15 PUSHL BP
16 MOVL SP, BP
17 SUBL $8, SP // allocate space for callee args (must be 8 mod 16)
18 MOVL 16(SP), CX // arg ptr
19 MOVL 0(CX), AX // arg 1 exit status
20 MOVL AX, 0(SP)
21 CALL libc_exit(SB)
22 MOVL $0xf1, 0xf1 // crash
23 MOVL BP, SP
24 POPL BP
25 RET
26
27 TEXT runtime·open_trampoline(SB),NOSPLIT,$0
28 PUSHL BP
29 MOVL SP, BP
30 SUBL $24, SP
31 MOVL 32(SP), CX
32 MOVL 0(CX), AX // arg 1 name
33 MOVL AX, 0(SP)
34 MOVL 4(CX), AX // arg 2 mode
35 MOVL AX, 4(SP)
36 MOVL 8(CX), AX // arg 3 perm
37 MOVL AX, 8(SP)
38 CALL libc_open(SB)
39 MOVL BP, SP
40 POPL BP
41 RET
42
43 TEXT runtime·close_trampoline(SB),NOSPLIT,$0
44 PUSHL BP
45 MOVL SP, BP
46 SUBL $8, SP
47 MOVL 16(SP), CX
48 MOVL 0(CX), AX // arg 1 fd
49 MOVL AX, 0(SP)
50 CALL libc_close(SB)
51 MOVL BP, SP
52 POPL BP
53 RET
54
55 TEXT runtime·read_trampoline(SB),NOSPLIT,$0
56 PUSHL BP
57 MOVL SP, BP
58 SUBL $24, SP
59 MOVL 32(SP), CX
60 MOVL 0(CX), AX // arg 1 fd
61 MOVL AX, 0(SP)
62 MOVL 4(CX), AX // arg 2 buf
63 MOVL AX, 4(SP)
64 MOVL 8(CX), AX // arg 3 count
65 MOVL AX, 8(SP)
66 CALL libc_read(SB)
67 MOVL BP, SP
68 POPL BP
69 RET
70
71 TEXT runtime·write_trampoline(SB),NOSPLIT,$0
72 PUSHL BP
73 MOVL SP, BP
74 SUBL $24, SP
75 MOVL 32(SP), CX
76 MOVL 0(CX), AX // arg 1 fd
77 MOVL AX, 0(SP)
78 MOVL 4(CX), AX // arg 2 buf
79 MOVL AX, 4(SP)
80 MOVL 8(CX), AX // arg 3 count
81 MOVL AX, 8(SP)
82 CALL libc_write(SB)
83 MOVL BP, SP
84 POPL BP
85 RET
86
87 TEXT runtime·pipe_trampoline(SB),NOSPLIT,$0
88 PUSHL BP
89 MOVL SP, BP
90 SUBL $8, SP
91 MOVL 16(SP), AX // arg 1 pipefd
92 MOVL AX, 0(SP)
93 CALL libc_pipe(SB)
94 TESTL AX, AX
95 JEQ 3(PC)
96 CALL libc_error(SB) // return negative errno value
97 NEGL AX
98 MOVL BP, SP
99 POPL BP
100 RET
101
102 TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
103 PUSHL BP
104 MOVL SP, BP
105 SUBL $24, SP
106 MOVL 32(SP), CX
107 MOVL 0(CX), AX // arg 1 addr
108 MOVL AX, 0(SP)
109 MOVL 4(CX), AX // arg 2 len
110 MOVL AX, 4(SP)
111 MOVL 8(CX), AX // arg 3 prot
112 MOVL AX, 8(SP)
113 MOVL 12(CX), AX // arg 4 flags
114 MOVL AX, 12(SP)
115 MOVL 16(CX), AX // arg 5 fid
116 MOVL AX, 16(SP)
117 MOVL 20(CX), AX // arg 6 offset
118 MOVL AX, 20(SP)
119 CALL libc_mmap(SB)
120 XORL DX, DX
121 CMPL AX, $-1
122 JNE ok
123 CALL libc_error(SB)
124 MOVL (AX), DX // errno
125 XORL AX, AX
126 ok:
127 MOVL 32(SP), CX
128 MOVL AX, 24(CX) // result pointer
129 MOVL DX, 28(CX) // errno
130 MOVL BP, SP
131 POPL BP
132 RET
133
134 TEXT runtime·madvise_trampoline(SB),NOSPLIT,$0
135 PUSHL BP
136 MOVL SP, BP
137 SUBL $24, SP
138 MOVL 32(SP), CX
139 MOVL 0(CX), AX // arg 1 addr
140 MOVL AX, 0(SP)
141 MOVL 4(CX), AX // arg 2 len
142 MOVL AX, 4(SP)
143 MOVL 8(CX), AX // arg 3 advice
144 MOVL AX, 8(SP)
145 CALL libc_madvise(SB)
146 // ignore failure - maybe pages are locked
147 MOVL BP, SP
148 POPL BP
149 RET
150
151 TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
152 PUSHL BP
153 MOVL SP, BP
154 SUBL $8, SP
155 MOVL 16(SP), CX
156 MOVL 0(CX), AX // arg 1 addr
157 MOVL AX, 0(SP)
158 MOVL 4(CX), AX // arg 2 len
159 MOVL AX, 4(SP)
160 CALL libc_munmap(SB)
161 TESTL AX, AX
162 JEQ 2(PC)
163 MOVL $0xf1, 0xf1 // crash
164 MOVL BP, SP
165 POPL BP
166 RET
167
168 TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
169 PUSHL BP
170 MOVL SP, BP
171 SUBL $24, SP
172 MOVL 32(SP), CX
173 MOVL 0(CX), AX // arg 1 mode
174 MOVL AX, 0(SP)
175 MOVL 4(CX), AX // arg 2 new
176 MOVL AX, 4(SP)
177 MOVL 8(CX), AX // arg 3 old
178 MOVL AX, 8(SP)
179 CALL libc_setitimer(SB)
180 MOVL BP, SP
181 POPL BP
182 RET
183
184 TEXT runtime·walltime_trampoline(SB),NOSPLIT,$0
185 PUSHL BP
186 MOVL SP, BP
187 SUBL $8, SP
188 MOVL 16(SP), AX
189 MOVL AX, 0(SP) // *timeval
190 MOVL $0, 4(SP) // no timezone needed
191 CALL libc_gettimeofday(SB)
192 MOVL BP, SP
193 POPL BP
194 RET
195
196 GLOBL timebase<>(SB),NOPTR,$(machTimebaseInfo__size)
197
198 TEXT runtime·nanotime_trampoline(SB),NOSPLIT,$0
199 PUSHL BP
200 MOVL SP, BP
201 SUBL $8+(machTimebaseInfo__size+15)/16*16, SP
202 CALL libc_mach_absolute_time(SB)
203 MOVL 16+(machTimebaseInfo__size+15)/16*16(SP), CX
204 MOVL AX, 0(CX)
205 MOVL DX, 4(CX)
206 MOVL timebase<>+machTimebaseInfo_denom(SB), DI // atomic read
207 MOVL timebase<>+machTimebaseInfo_numer(SB), SI
208 TESTL DI, DI
209 JNE initialized
210
211 LEAL 4(SP), AX
212 MOVL AX, 0(SP)
213 CALL libc_mach_timebase_info(SB)
214 MOVL 4+machTimebaseInfo_numer(SP), SI
215 MOVL 4+machTimebaseInfo_denom(SP), DI
216
217 MOVL SI, timebase<>+machTimebaseInfo_numer(SB)
218 MOVL DI, AX
219 XCHGL AX, timebase<>+machTimebaseInfo_denom(SB) // atomic write
220 MOVL 16+(machTimebaseInfo__size+15)/16*16(SP), CX
221
222 initialized:
223 MOVL SI, 8(CX)
224 MOVL DI, 12(CX)
225 MOVL BP, SP
226 POPL BP
227 RET
228
229 TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
230 PUSHL BP
231 MOVL SP, BP
232 SUBL $24, SP
233 MOVL 32(SP), CX
234 MOVL 0(CX), AX // arg 1 sig
235 MOVL AX, 0(SP)
236 MOVL 4(CX), AX // arg 2 new
237 MOVL AX, 4(SP)
238 MOVL 8(CX), AX // arg 3 old
239 MOVL AX, 8(SP)
240 CALL libc_sigaction(SB)
241 TESTL AX, AX
242 JEQ 2(PC)
243 MOVL $0xf1, 0xf1 // crash
244 MOVL BP, SP
245 POPL BP
246 RET
247
248 TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
249 PUSHL BP
250 MOVL SP, BP
251 SUBL $24, SP
252 MOVL 32(SP), CX
253 MOVL 0(CX), AX // arg 1 how
254 MOVL AX, 0(SP)
255 MOVL 4(CX), AX // arg 2 new
256 MOVL AX, 4(SP)
257 MOVL 8(CX), AX // arg 3 old
258 MOVL AX, 8(SP)
259 CALL libc_pthread_sigmask(SB)
260 TESTL AX, AX
261 JEQ 2(PC)
262 MOVL $0xf1, 0xf1 // crash
263 MOVL BP, SP
264 POPL BP
265 RET
266
267 TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
268 PUSHL BP
269 MOVL SP, BP
270 SUBL $8, SP
271 MOVL 16(SP), CX
272 MOVL 0(CX), AX // arg 1 new
273 MOVL AX, 0(SP)
274 MOVL 4(CX), AX // arg 2 old
275 MOVL AX, 4(SP)
276 CALL libc_sigaltstack(SB)
277 TESTL AX, AX
278 JEQ 2(PC)
279 MOVL $0xf1, 0xf1 // crash
280 MOVL BP, SP
281 POPL BP
282 RET
283
284 TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
285 PUSHL BP
286 MOVL SP, BP
287 SUBL $8, SP
288 CALL libc_getpid(SB)
289 MOVL AX, 0(SP) // arg 1 pid
290 MOVL 16(SP), CX
291 MOVL 0(CX), AX
292 MOVL AX, 4(SP) // arg 2 signal
293 CALL libc_kill(SB)
294 MOVL BP, SP
295 POPL BP
296 RET
297
298 TEXT runtime·sigfwd(SB),NOSPLIT,$0-16
299 MOVL fn+0(FP), AX
300 MOVL sig+4(FP), BX
301 MOVL info+8(FP), CX
302 MOVL ctx+12(FP), DX
303 MOVL SP, SI
304 SUBL $32, SP
305 ANDL $~15, SP // align stack: handler might be a C function
306 MOVL BX, 0(SP)
307 MOVL CX, 4(SP)
308 MOVL DX, 8(SP)
309 MOVL SI, 12(SP) // save SI: handler might be a Go function
310 CALL AX
311 MOVL 12(SP), AX
312 MOVL AX, SP
313 RET
314
315 // Sigtramp's job is to call the actual signal handler.
316 // It is called with the C calling convention, and calls out
317 // to sigtrampgo with the Go calling convention.
318 TEXT runtime·sigtramp(SB),NOSPLIT,$0
319 SUBL $28, SP
320
321 // Save callee-save registers.
322 MOVL BP, 12(SP)
323 MOVL BX, 16(SP)
324 MOVL SI, 20(SP)
325 MOVL DI, 24(SP)
326
327 MOVL 32(SP), AX
328 MOVL AX, 0(SP) // arg 1 signal number
329 MOVL 36(SP), AX
330 MOVL AX, 4(SP) // arg 2 siginfo
331 MOVL 40(SP), AX
332 MOVL AX, 8(SP) // arg 3 ctxt
333 CALL runtime·sigtrampgo(SB)
334
335 // Restore callee-save registers.
336 MOVL 12(SP), BP
337 MOVL 16(SP), BX
338 MOVL 20(SP), SI
339 MOVL 24(SP), DI
340
341 ADDL $28, SP
342 RET
343
344 TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
345 JMP runtime·sigtramp(SB)
346
347 TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
348 PUSHL BP
349 MOVL SP, BP
350 SUBL $8, SP
351 MOVL 16(SP), CX
352 MOVL 0(CX), AX // arg 1 usec
353 MOVL AX, 0(SP)
354 CALL libc_usleep(SB)
355 MOVL BP, SP
356 POPL BP
357 RET
358
359 // func setldt(entry int, address int, limit int)
360 TEXT runtime·setldt(SB),NOSPLIT,$32
361 // Nothing to do on Darwin, pthread already set thread-local storage up.
362 RET
363
364 TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
365 PUSHL BP
366 MOVL SP, BP
367 SUBL $24, SP
368 MOVL 32(SP), CX
369 MOVL 0(CX), AX // arg 1 mib
370 MOVL AX, 0(SP)
371 MOVL 4(CX), AX // arg 2 miblen
372 MOVL AX, 4(SP)
373 MOVL 8(CX), AX // arg 3 out
374 MOVL AX, 8(SP)
375 MOVL 12(CX), AX // arg 4 size
376 MOVL AX, 12(SP)
377 MOVL 16(CX), AX // arg 5 dst
378 MOVL AX, 16(SP)
379 MOVL 20(CX), AX // arg 6 ndst
380 MOVL AX, 20(SP)
381 CALL libc_sysctl(SB)
382 MOVL BP, SP
383 POPL BP
384 RET
385
386 TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
387 PUSHL BP
388 MOVL SP, BP
389 SUBL $8, SP
390 CALL libc_kqueue(SB)
391 MOVL BP, SP
392 POPL BP
393 RET
394
395 TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
396 PUSHL BP
397 MOVL SP, BP
398 SUBL $24, SP
399 MOVL 32(SP), CX
400 MOVL 0(CX), AX // arg 1 kq
401 MOVL AX, 0(SP)
402 MOVL 4(CX), AX // arg 2 ch
403 MOVL AX, 4(SP)
404 MOVL 8(CX), AX // arg 3 nch
405 MOVL AX, 8(SP)
406 MOVL 12(CX), AX // arg 4 ev
407 MOVL AX, 12(SP)
408 MOVL 16(CX), AX // arg 5 nev
409 MOVL AX, 16(SP)
410 MOVL 20(CX), AX // arg 6 ts
411 MOVL AX, 20(SP)
412 CALL libc_kevent(SB)
413 CMPL AX, $-1
414 JNE ok
415 CALL libc_error(SB)
416 MOVL (AX), AX // errno
417 NEGL AX // caller wants it as a negative error code
418 ok:
419 MOVL BP, SP
420 POPL BP
421 RET
422
423 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
424 PUSHL BP
425 MOVL SP, BP
426 SUBL $24, SP
427 MOVL 32(SP), CX
428 MOVL 0(CX), AX // arg 1 fd
429 MOVL AX, 0(SP)
430 MOVL 4(CX), AX // arg 2 cmd
431 MOVL AX, 4(SP)
432 MOVL 8(CX), AX // arg 3 arg
433 MOVL AX, 8(SP)
434 CALL libc_fcntl(SB)
435 MOVL BP, SP
436 POPL BP
437 RET
438
439 // mstart_stub is the first function executed on a new thread started by pthread_create.
440 // It just does some low-level setup and then calls mstart.
441 // Note: called with the C calling convention.
442 TEXT runtime·mstart_stub(SB),NOSPLIT,$0
443 // The value at SP+4 points to the m.
444 // We are already on m's g0 stack.
445
446 // Save callee-save registers.
447 SUBL $16, SP
448 MOVL BP, 0(SP)
449 MOVL BX, 4(SP)
450 MOVL SI, 8(SP)
451 MOVL DI, 12(SP)
452
453 MOVL SP, AX // hide argument read from vet (vet thinks this function is using the Go calling convention)
454 MOVL 20(AX), DI // m
455 MOVL m_g0(DI), DX // g
456
457 // Initialize TLS entry.
458 // See cmd/link/internal/ld/sym.go:computeTLSOffset.
459 MOVL DX, 0x18(GS)
460
461 // Someday the convention will be D is always cleared.
462 CLD
463
464 CALL runtime·mstart(SB)
465
466 // Restore callee-save registers.
467 MOVL 0(SP), BP
468 MOVL 4(SP), BX
469 MOVL 8(SP), SI
470 MOVL 12(SP), DI
471
472 // Go is all done with this OS thread.
473 // Tell pthread everything is ok (we never join with this thread, so
474 // the value here doesn't really matter).
475 XORL AX, AX
476
477 ADDL $16, SP
478 RET
479
480 TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$0
481 PUSHL BP
482 MOVL SP, BP
483 SUBL $8, SP
484 MOVL 16(SP), CX
485 MOVL 0(CX), AX // arg 1 attr
486 MOVL AX, 0(SP)
487 CALL libc_pthread_attr_init(SB)
488 MOVL BP, SP
489 POPL BP
490 RET
491
492 TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$0
493 PUSHL BP
494 MOVL SP, BP
495 SUBL $8, SP
496 MOVL 16(SP), CX
497 MOVL 0(CX), AX // arg 1 attr
498 MOVL AX, 0(SP)
499 MOVL 4(CX), AX // arg 2 size
500 MOVL AX, 4(SP)
501 CALL libc_pthread_attr_getstacksize(SB)
502 MOVL BP, SP
503 POPL BP
504 RET
505
506 TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$0
507 PUSHL BP
508 MOVL SP, BP
509 SUBL $8, SP
510 MOVL 16(SP), CX
511 MOVL 0(CX), AX // arg 1 attr
512 MOVL AX, 0(SP)
513 MOVL 4(CX), AX // arg 2 state
514 MOVL AX, 4(SP)
515 CALL libc_pthread_attr_setdetachstate(SB)
516 MOVL BP, SP
517 POPL BP
518 RET
519
520 TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
521 PUSHL BP
522 MOVL SP, BP
523 SUBL $24, SP
524 MOVL 32(SP), CX
525 LEAL 16(SP), AX // arg "0" &threadid (which we throw away)
526 MOVL AX, 0(SP)
527 MOVL 0(CX), AX // arg 1 attr
528 MOVL AX, 4(SP)
529 MOVL 4(CX), AX // arg 2 start
530 MOVL AX, 8(SP)
531 MOVL 8(CX), AX // arg 3 arg
532 MOVL AX, 12(SP)
533 CALL libc_pthread_create(SB)
534 MOVL BP, SP
535 POPL BP
536 RET
537
538 TEXT runtime·raise_trampoline(SB),NOSPLIT,$0
539 PUSHL BP
540 MOVL SP, BP
541 SUBL $8, SP
542 MOVL 16(SP), CX
543 MOVL 0(CX), AX // arg 1 sig
544 MOVL AX, 0(SP)
545 CALL libc_raise(SB)
546 MOVL BP, SP
547 POPL BP
548 RET
549
550 TEXT runtime·pthread_mutex_init_trampoline(SB),NOSPLIT,$0
551 PUSHL BP
552 MOVL SP, BP
553 SUBL $8, SP
554 MOVL 16(SP), CX
555 MOVL 0(CX), AX // arg 1 mutex
556 MOVL AX, 0(SP)
557 MOVL 4(CX), AX // arg 2 attr
558 MOVL AX, 4(SP)
559 CALL libc_pthread_mutex_init(SB)
560 MOVL BP, SP
561 POPL BP
562 RET
563
564 TEXT runtime·pthread_mutex_lock_trampoline(SB),NOSPLIT,$0
565 PUSHL BP
566 MOVL SP, BP
567 SUBL $8, SP
568 MOVL 16(SP), CX
569 MOVL 0(CX), AX // arg 1 mutex
570 MOVL AX, 0(SP)
571 CALL libc_pthread_mutex_lock(SB)
572 MOVL BP, SP
573 POPL BP
574 RET
575
576 TEXT runtime·pthread_mutex_unlock_trampoline(SB),NOSPLIT,$0
577 PUSHL BP
578 MOVL SP, BP
579 SUBL $8, SP
580 MOVL 16(SP), CX
581 MOVL 0(CX), AX // arg 1 mutex
582 MOVL AX, 0(SP)
583 CALL libc_pthread_mutex_unlock(SB)
584 MOVL BP, SP
585 POPL BP
586 RET
587
588 TEXT runtime·pthread_cond_init_trampoline(SB),NOSPLIT,$0
589 PUSHL BP
590 MOVL SP, BP
591 SUBL $8, SP
592 MOVL 16(SP), CX
593 MOVL 0(CX), AX // arg 1 cond
594 MOVL AX, 0(SP)
595 MOVL 4(CX), AX // arg 2 attr
596 MOVL AX, 4(SP)
597 CALL libc_pthread_cond_init(SB)
598 MOVL BP, SP
599 POPL BP
600 RET
601
602 TEXT runtime·pthread_cond_wait_trampoline(SB),NOSPLIT,$0
603 PUSHL BP
604 MOVL SP, BP
605 SUBL $8, SP
606 MOVL 16(SP), CX
607 MOVL 0(CX), AX // arg 1 cond
608 MOVL AX, 0(SP)
609 MOVL 4(CX), AX // arg 2 mutex
610 MOVL AX, 4(SP)
611 CALL libc_pthread_cond_wait(SB)
612 MOVL BP, SP
613 POPL BP
614 RET
615
616 TEXT runtime·pthread_cond_timedwait_relative_np_trampoline(SB),NOSPLIT,$0
617 PUSHL BP
618 MOVL SP, BP
619 SUBL $24, SP
620 MOVL 32(SP), CX
621 MOVL 0(CX), AX // arg 1 cond
622 MOVL AX, 0(SP)
623 MOVL 4(CX), AX // arg 2 mutex
624 MOVL AX, 4(SP)
625 MOVL 8(CX), AX // arg 3 timeout
626 MOVL AX, 8(SP)
627 CALL libc_pthread_cond_timedwait_relative_np(SB)
628 MOVL BP, SP
629 POPL BP
630 RET
631
632 TEXT runtime·pthread_cond_signal_trampoline(SB),NOSPLIT,$0
633 PUSHL BP
634 MOVL SP, BP
635 SUBL $8, SP
636 MOVL 16(SP), CX
637 MOVL 0(CX), AX // arg 1 cond
638 MOVL AX, 0(SP)
639 CALL libc_pthread_cond_signal(SB)
640 MOVL BP, SP
641 POPL BP
642 RET
643
644 // syscall calls a function in libc on behalf of the syscall package.
645 // syscall takes a pointer to a struct like:
646 // struct {
647 // fn uintptr
648 // a1 uintptr
649 // a2 uintptr
650 // a3 uintptr
651 // r1 uintptr
652 // r2 uintptr
653 // err uintptr
654 // }
655 // syscall must be called on the g0 stack with the
656 // C calling convention (use libcCall).
657 TEXT runtime·syscall(SB),NOSPLIT,$0
658 PUSHL BP
659 MOVL SP, BP
660 SUBL $24, SP
661 MOVL 32(SP), CX
662 MOVL (0*4)(CX), AX // fn
663 MOVL (1*4)(CX), DX // a1
664 MOVL DX, 0(SP)
665 MOVL (2*4)(CX), DX // a2
666 MOVL DX, 4(SP)
667 MOVL (3*4)(CX), DX // a3
668 MOVL DX, 8(SP)
669
670 CALL AX
671
672 MOVL 32(SP), CX
673 MOVL AX, (4*4)(CX) // r1
674 MOVL DX, (5*4)(CX) // r2
675
676 // Standard libc functions return -1 on error
677 // and set errno.
678 CMPL AX, $-1
679 JNE ok
680
681 // Get error code from libc.
682 CALL libc_error(SB)
683 MOVL (AX), AX
684 MOVL 32(SP), CX
685 MOVL AX, (6*4)(CX) // err
686
687 ok:
688 XORL AX, AX // no error (it's ignored anyway)
689 MOVL BP, SP
690 POPL BP
691 RET
692
693 // syscallPtr is like syscall except the libc function reports an
694 // error by returning NULL and setting errno.
695 TEXT runtime·syscallPtr(SB),NOSPLIT,$0
696 PUSHL BP
697 MOVL SP, BP
698 SUBL $24, SP
699 MOVL 32(SP), CX
700 MOVL (0*4)(CX), AX // fn
701 MOVL (1*4)(CX), DX // a1
702 MOVL DX, 0(SP)
703 MOVL (2*4)(CX), DX // a2
704 MOVL DX, 4(SP)
705 MOVL (3*4)(CX), DX // a3
706 MOVL DX, 8(SP)
707
708 CALL AX
709
710 MOVL 32(SP), CX
711 MOVL AX, (4*4)(CX) // r1
712 MOVL DX, (5*4)(CX) // r2
713
714 // syscallPtr libc functions return NULL on error
715 // and set errno.
716 TESTL AX, AX
717 JNE ok
718
719 // Get error code from libc.
720 CALL libc_error(SB)
721 MOVL (AX), AX
722 MOVL 32(SP), CX
723 MOVL AX, (6*4)(CX) // err
724
725 ok:
726 XORL AX, AX // no error (it's ignored anyway)
727 MOVL BP, SP
728 POPL BP
729 RET
730
731 // syscall6 calls a function in libc on behalf of the syscall package.
732 // syscall6 takes a pointer to a struct like:
733 // struct {
734 // fn uintptr
735 // a1 uintptr
736 // a2 uintptr
737 // a3 uintptr
738 // a4 uintptr
739 // a5 uintptr
740 // a6 uintptr
741 // r1 uintptr
742 // r2 uintptr
743 // err uintptr
744 // }
745 // syscall6 must be called on the g0 stack with the
746 // C calling convention (use libcCall).
747 TEXT runtime·syscall6(SB),NOSPLIT,$0
748 PUSHL BP
749 MOVL SP, BP
750 SUBL $24, SP
751 MOVL 32(SP), CX
752 MOVL (0*4)(CX), AX // fn
753 MOVL (1*4)(CX), DX // a1
754 MOVL DX, 0(SP)
755 MOVL (2*4)(CX), DX // a2
756 MOVL DX, 4(SP)
757 MOVL (3*4)(CX), DX // a3
758 MOVL DX, 8(SP)
759 MOVL (4*4)(CX), DX // a4
760 MOVL DX, 12(SP)
761 MOVL (5*4)(CX), DX // a5
762 MOVL DX, 16(SP)
763 MOVL (6*4)(CX), DX // a6
764 MOVL DX, 20(SP)
765
766 CALL AX
767
768 MOVL 32(SP), CX
769 MOVL AX, (7*4)(CX) // r1
770 MOVL DX, (8*4)(CX) // r2
771
772 // Standard libc functions return -1 on error
773 // and set errno.
774 CMPL AX, $-1
775 JNE ok
776
777 // Get error code from libc.
778 CALL libc_error(SB)
779 MOVL (AX), AX
780 MOVL 32(SP), CX
781 MOVL AX, (9*4)(CX) // err
782
783 ok:
784 XORL AX, AX // no error (it's ignored anyway)
785 MOVL BP, SP
786 POPL BP
787 RET
788
789 // syscall6X calls a function in libc on behalf of the syscall package.
790 // syscall6X takes a pointer to a struct like:
791 // struct {
792 // fn uintptr
793 // a1 uintptr
794 // a2 uintptr
795 // a3 uintptr
796 // a4 uintptr
797 // a5 uintptr
798 // a6 uintptr
799 // r1 uintptr
800 // r2 uintptr
801 // err uintptr
802 // }
803 // syscall6X must be called on the g0 stack with the
804 // C calling convention (use libcCall).
805 TEXT runtime·syscall6X(SB),NOSPLIT,$0
806 PUSHL BP
807 MOVL SP, BP
808 SUBL $24, SP
809 MOVL 32(SP), CX
810 MOVL (0*4)(CX), AX // fn
811 MOVL (1*4)(CX), DX // a1
812 MOVL DX, 0(SP)
813 MOVL (2*4)(CX), DX // a2
814 MOVL DX, 4(SP)
815 MOVL (3*4)(CX), DX // a3
816 MOVL DX, 8(SP)
817 MOVL (4*4)(CX), DX // a4
818 MOVL DX, 12(SP)
819 MOVL (5*4)(CX), DX // a5
820 MOVL DX, 16(SP)
821 MOVL (6*4)(CX), DX // a6
822 MOVL DX, 20(SP)
823
824 CALL AX
825
826 MOVL 32(SP), CX
827 MOVL AX, (7*4)(CX) // r1
828 MOVL DX, (8*4)(CX) // r2
829
830 // Standard libc functions return -1 on error
831 // and set errno.
832 CMPL AX, $-1
833 JNE ok
834 CMPL DX, $-1
835 JNE ok
836
837 // Get error code from libc.
838 CALL libc_error(SB)
839 MOVL (AX), AX
840 MOVL 32(SP), CX
841 MOVL AX, (9*4)(CX) // err
842
843 ok:
844 XORL AX, AX // no error (it's ignored anyway)
845 MOVL BP, SP
846 POPL BP
847 RET
848
849 // syscall9 calls a function in libc on behalf of the syscall package.
850 // syscall9 takes a pointer to a struct like:
851 // struct {
852 // fn uintptr
853 // a1 uintptr
854 // a2 uintptr
855 // a3 uintptr
856 // a4 uintptr
857 // a5 uintptr
858 // a6 uintptr
859 // a7 uintptr
860 // a8 uintptr
861 // a9 uintptr
862 // r1 uintptr
863 // r2 uintptr
864 // err uintptr
865 // }
866 // syscall9 must be called on the g0 stack with the
867 // C calling convention (use libcCall).
868 TEXT runtime·syscall9(SB),NOSPLIT,$0
869 PUSHL BP
870 MOVL SP, BP
871 SUBL $40, SP
872 MOVL 48(SP), CX
873 MOVL (0*4)(CX), AX // fn
874 MOVL (1*4)(CX), DX // a1
875 MOVL DX, 0(SP)
876 MOVL (2*4)(CX), DX // a2
877 MOVL DX, 4(SP)
878 MOVL (3*4)(CX), DX // a3
879 MOVL DX, 8(SP)
880 MOVL (4*4)(CX), DX // a4
881 MOVL DX, 12(SP)
882 MOVL (5*4)(CX), DX // a5
883 MOVL DX, 16(SP)
884 MOVL (6*4)(CX), DX // a6
885 MOVL DX, 20(SP)
886 MOVL (7*4)(CX), DX // a7
887 MOVL DX, 24(SP)
888 MOVL (8*4)(CX), DX // a8
889 MOVL DX, 28(SP)
890 MOVL (9*4)(CX), DX // a9
891 MOVL DX, 32(SP)
892
893 CALL AX
894
895 MOVL 48(SP), CX
896 MOVL AX, (10*4)(CX) // r1
897 MOVL DX, (11*4)(CX) // r2
898
899 // Standard libc functions return -1 on error
900 // and set errno.
901 CMPL AX, $-1
902 JNE ok
903
904 // Get error code from libc.
905 CALL libc_error(SB)
906 MOVL (AX), AX
907 MOVL 48(SP), CX
908 MOVL AX, (12*4)(CX) // err
909
910 ok:
911 XORL AX, AX // no error (it's ignored anyway)
912 MOVL BP, SP
913 POPL BP
914 RET
View as plain text