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