Text file
src/runtime/sys_openbsd_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, 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|TOPFRAME,$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 noerr
524 CALL libc_errno(SB)
525 MOVL (AX), AX
526 NEGL AX // caller expects negative errno
527 noerr:
528 MOVL BP, SP
529 POPL BP
530 RET
531
532 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
533 PUSHL BP
534 MOVL SP, BP
535 SUBL $16, SP
536 MOVL 24(SP), DX // pointer to args
537 MOVL 0(DX), AX
538 MOVL 4(DX), BX
539 MOVL 8(DX), CX
540 MOVL AX, 0(SP) // arg 1 - fd
541 MOVL BX, 4(SP) // arg 2 - cmd
542 MOVL CX, 8(SP) // arg 3 - arg
543 MOVL $0, 12(SP) // vararg
544 CALL libc_fcntl(SB)
545 MOVL $0, BX
546 CMPL AX, $-1
547 JNE noerr
548 CALL libc_errno(SB)
549 MOVL (AX), BX
550 MOVL $-1, AX
551 noerr:
552 MOVL 24(SP), DX // pointer to args
553 MOVL AX, 12(DX)
554 MOVL BX, 16(DX)
555 MOVL BP, SP
556 POPL BP
557 RET
558
559 TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
560 PUSHL BP
561 MOVL SP, BP
562 SUBL $12, SP
563 MOVL 20(SP), DX // pointer to args
564 MOVL 0(DX), AX
565 MOVL 4(DX), BX
566 MOVL 8(DX), CX
567 MOVL AX, 0(SP) // arg 1 - sig
568 MOVL BX, 4(SP) // arg 2 - new
569 MOVL CX, 8(SP) // arg 3 - old
570 CALL libc_sigaction(SB)
571 CMPL AX, $-1
572 JNE 2(PC)
573 MOVL $0xf1, 0xf1 // crash on failure
574 MOVL BP, SP
575 POPL BP
576 RET
577
578 TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
579 PUSHL BP
580 MOVL SP, BP
581 SUBL $12, SP
582 MOVL 20(SP), DX // pointer to args
583 MOVL 0(DX), AX
584 MOVL 4(DX), BX
585 MOVL 8(DX), CX
586 MOVL AX, 0(SP) // arg 1 - how
587 MOVL BX, 4(SP) // arg 2 - new
588 MOVL CX, 8(SP) // arg 3 - old
589 CALL libc_pthread_sigmask(SB)
590 CMPL AX, $-1
591 JNE 2(PC)
592 MOVL $0xf1, 0xf1 // crash on failure
593 MOVL BP, SP
594 POPL BP
595 RET
596
597 TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
598 PUSHL BP
599 MOVL SP, BP
600 SUBL $8, SP
601 MOVL 16(SP), DX // pointer to args
602 MOVL 0(DX), AX
603 MOVL 4(DX), BX
604 MOVL AX, 0(SP) // arg 1 - new
605 MOVL BX, 4(SP) // arg 2 - old
606 CALL libc_sigaltstack(SB)
607 CMPL AX, $-1
608 JNE 2(PC)
609 MOVL $0xf1, 0xf1 // crash on failure
610 MOVL BP, SP
611 POPL BP
612 RET
613
614 // syscall calls a function in libc on behalf of the syscall package.
615 // syscall takes a pointer to a struct like:
616 // struct {
617 // fn uintptr
618 // a1 uintptr
619 // a2 uintptr
620 // a3 uintptr
621 // r1 uintptr
622 // r2 uintptr
623 // err uintptr
624 // }
625 // syscall must be called on the g0 stack with the
626 // C calling convention (use libcCall).
627 //
628 // syscall expects a 32-bit result and tests for 32-bit -1
629 // to decide there was an error.
630 TEXT runtime·syscall(SB),NOSPLIT,$0
631 PUSHL BP
632 MOVL SP, BP
633
634 SUBL $12, SP
635 MOVL 20(SP), BX // pointer to args
636
637 MOVL (1*4)(BX), AX
638 MOVL (2*4)(BX), CX
639 MOVL (3*4)(BX), DX
640 MOVL AX, (0*4)(SP) // a1
641 MOVL CX, (1*4)(SP) // a2
642 MOVL DX, (2*4)(SP) // a3
643
644 MOVL (0*4)(BX), AX // fn
645 CALL AX
646
647 MOVL AX, (4*4)(BX) // r1
648 MOVL DX, (5*4)(BX) // r2
649
650 // Standard libc functions return -1 on error and set errno.
651 CMPL AX, $-1
652 JNE ok
653
654 // Get error code from libc.
655 CALL libc_errno(SB)
656 MOVL (AX), AX
657 MOVW AX, (6*4)(BX) // err
658
659 ok:
660 MOVL $0, AX // no error (it's ignored anyway)
661 MOVL BP, SP
662 POPL BP
663 RET
664
665 // syscallX calls a function in libc on behalf of the syscall package.
666 // syscallX takes a pointer to a struct like:
667 // struct {
668 // fn uintptr
669 // a1 uintptr
670 // a2 uintptr
671 // a3 uintptr
672 // r1 uintptr
673 // r2 uintptr
674 // err uintptr
675 // }
676 // syscallX must be called on the g0 stack with the
677 // C calling convention (use libcCall).
678 //
679 // syscallX is like syscall but expects a 64-bit result
680 // and tests for 64-bit -1 to decide there was an error.
681 TEXT runtime·syscallX(SB),NOSPLIT,$0
682 PUSHL BP
683 MOVL SP, BP
684
685 SUBL $12, SP
686 MOVL 20(SP), BX // pointer to args
687
688 MOVL (1*4)(BX), AX
689 MOVL (2*4)(BX), CX
690 MOVL (3*4)(BX), DX
691 MOVL AX, (0*4)(SP) // a1
692 MOVL CX, (1*4)(SP) // a2
693 MOVL DX, (2*4)(SP) // a3
694
695 MOVL (0*4)(BX), AX // fn
696 CALL AX
697
698 MOVL AX, (4*4)(BX) // r1
699 MOVL DX, (5*4)(BX) // r2
700
701 // Standard libc functions return -1 on error and set errno.
702 CMPL AX, $-1
703 JNE ok
704 CMPL DX, $-1
705 JNE ok
706
707 // Get error code from libc.
708 CALL libc_errno(SB)
709 MOVL (AX), AX
710 MOVW AX, (6*4)(BX) // err
711
712 ok:
713 MOVL $0, AX // no error (it's ignored anyway)
714 MOVL BP, SP
715 POPL BP
716 RET
717
718 // syscall6 calls a function in libc on behalf of the syscall package.
719 // syscall6 takes a pointer to a struct like:
720 // struct {
721 // fn uintptr
722 // a1 uintptr
723 // a2 uintptr
724 // a3 uintptr
725 // a4 uintptr
726 // a5 uintptr
727 // a6 uintptr
728 // r1 uintptr
729 // r2 uintptr
730 // err uintptr
731 // }
732 // syscall6 must be called on the g0 stack with the
733 // C calling convention (use libcCall).
734 //
735 // syscall6 expects a 32-bit result and tests for 32-bit -1
736 // to decide there was an error.
737 TEXT runtime·syscall6(SB),NOSPLIT,$0
738 PUSHL BP
739 MOVL SP, BP
740
741 SUBL $24, SP
742 MOVL 32(SP), BX // pointer to args
743
744 MOVL (1*4)(BX), AX
745 MOVL (2*4)(BX), CX
746 MOVL (3*4)(BX), DX
747 MOVL AX, (0*4)(SP) // a1
748 MOVL CX, (1*4)(SP) // a2
749 MOVL DX, (2*4)(SP) // a3
750 MOVL (4*4)(BX), AX
751 MOVL (5*4)(BX), CX
752 MOVL (6*4)(BX), DX
753 MOVL AX, (3*4)(SP) // a4
754 MOVL CX, (4*4)(SP) // a5
755 MOVL DX, (5*4)(SP) // a6
756
757 MOVL (0*4)(BX), AX // fn
758 CALL AX
759
760 MOVL AX, (7*4)(BX) // r1
761 MOVL DX, (8*4)(BX) // r2
762
763 // Standard libc functions return -1 on error and set errno.
764 CMPL AX, $-1
765 JNE ok
766
767 // Get error code from libc.
768 CALL libc_errno(SB)
769 MOVL (AX), AX
770 MOVW AX, (9*4)(BX) // err
771
772 ok:
773 MOVL $0, AX // no error (it's ignored anyway)
774 MOVL BP, SP
775 POPL BP
776 RET
777
778 // syscall6X calls a function in libc on behalf of the syscall package.
779 // syscall6X takes a pointer to a struct like:
780 // struct {
781 // fn uintptr
782 // a1 uintptr
783 // a2 uintptr
784 // a3 uintptr
785 // a4 uintptr
786 // a5 uintptr
787 // a6 uintptr
788 // r1 uintptr
789 // r2 uintptr
790 // err uintptr
791 // }
792 // syscall6X must be called on the g0 stack with the
793 // C calling convention (use libcCall).
794 //
795 // syscall6X is like syscall6 but expects a 64-bit result
796 // and tests for 64-bit -1 to decide there was an error.
797 TEXT runtime·syscall6X(SB),NOSPLIT,$0
798 PUSHL BP
799 MOVL SP, BP
800
801 SUBL $24, SP
802 MOVL 32(SP), BX // pointer to args
803
804 MOVL (1*4)(BX), AX
805 MOVL (2*4)(BX), CX
806 MOVL (3*4)(BX), DX
807 MOVL AX, (0*4)(SP) // a1
808 MOVL CX, (1*4)(SP) // a2
809 MOVL DX, (2*4)(SP) // a3
810 MOVL (4*4)(BX), AX
811 MOVL (5*4)(BX), CX
812 MOVL (6*4)(BX), DX
813 MOVL AX, (3*4)(SP) // a4
814 MOVL CX, (4*4)(SP) // a5
815 MOVL DX, (5*4)(SP) // a6
816
817 MOVL (0*4)(BX), AX // fn
818 CALL AX
819
820 MOVL AX, (7*4)(BX) // r1
821 MOVL DX, (8*4)(BX) // r2
822
823 // Standard libc functions return -1 on error and set errno.
824 CMPL AX, $-1
825 JNE ok
826 CMPL DX, $-1
827 JNE ok
828
829 // Get error code from libc.
830 CALL libc_errno(SB)
831 MOVL (AX), AX
832 MOVW AX, (9*4)(BX) // err
833
834 ok:
835 MOVL $0, AX // no error (it's ignored anyway)
836 MOVL BP, SP
837 POPL BP
838 RET
839
840 // syscall10 calls a function in libc on behalf of the syscall package.
841 // syscall10 takes a pointer to a struct like:
842 // struct {
843 // fn uintptr
844 // a1 uintptr
845 // a2 uintptr
846 // a3 uintptr
847 // a4 uintptr
848 // a5 uintptr
849 // a6 uintptr
850 // a7 uintptr
851 // a8 uintptr
852 // a9 uintptr
853 // a10 uintptr
854 // r1 uintptr
855 // r2 uintptr
856 // err uintptr
857 // }
858 // syscall10 must be called on the g0 stack with the
859 // C calling convention (use libcCall).
860 TEXT runtime·syscall10(SB),NOSPLIT,$0
861 PUSHL BP
862 MOVL SP, BP
863
864 SUBL $40, SP
865 MOVL 48(SP), BX // pointer to args
866
867 MOVL (1*4)(BX), AX
868 MOVL (2*4)(BX), CX
869 MOVL (3*4)(BX), DX
870 MOVL AX, (0*4)(SP) // a1
871 MOVL CX, (1*4)(SP) // a2
872 MOVL DX, (2*4)(SP) // a3
873 MOVL (4*4)(BX), AX
874 MOVL (5*4)(BX), CX
875 MOVL (6*4)(BX), DX
876 MOVL AX, (3*4)(SP) // a4
877 MOVL CX, (4*4)(SP) // a5
878 MOVL DX, (5*4)(SP) // a6
879 MOVL (7*4)(BX), AX
880 MOVL (8*4)(BX), CX
881 MOVL (9*4)(BX), DX
882 MOVL AX, (6*4)(SP) // a7
883 MOVL CX, (7*4)(SP) // a8
884 MOVL DX, (8*4)(SP) // a9
885 MOVL (10*4)(BX), AX
886 MOVL AX, (9*4)(SP) // a10
887
888 MOVL (0*4)(BX), AX // fn
889 CALL AX
890
891 MOVL AX, (11*4)(BX) // r1
892 MOVL DX, (12*4)(BX) // r2
893
894 // Standard libc functions return -1 on error and set errno.
895 CMPL AX, $-1
896 JNE ok
897
898 // Get error code from libc.
899 CALL libc_errno(SB)
900 MOVL (AX), AX
901 MOVW AX, (13*4)(BX) // err
902
903 ok:
904 MOVL $0, AX // no error (it's ignored anyway)
905 MOVL BP, SP
906 POPL BP
907 RET
908
909 // syscall10X calls a function in libc on behalf of the syscall package.
910 // syscall10X takes a pointer to a struct like:
911 // struct {
912 // fn uintptr
913 // a1 uintptr
914 // a2 uintptr
915 // a3 uintptr
916 // a4 uintptr
917 // a5 uintptr
918 // a6 uintptr
919 // a7 uintptr
920 // a8 uintptr
921 // a9 uintptr
922 // a10 uintptr
923 // r1 uintptr
924 // r2 uintptr
925 // err uintptr
926 // }
927 // syscall10X must be called on the g0 stack with the
928 // C calling convention (use libcCall).
929 //
930 // syscall10X is like syscall9 but expects a 64-bit result
931 // and tests for 64-bit -1 to decide there was an error.
932 TEXT runtime·syscall10X(SB),NOSPLIT,$0
933 PUSHL BP
934 MOVL SP, BP
935
936 SUBL $40, SP
937 MOVL 48(SP), BX // pointer to args
938
939 MOVL (1*4)(BX), AX
940 MOVL (2*4)(BX), CX
941 MOVL (3*4)(BX), DX
942 MOVL AX, (0*4)(SP) // a1
943 MOVL CX, (1*4)(SP) // a2
944 MOVL DX, (2*4)(SP) // a3
945 MOVL (4*4)(BX), AX
946 MOVL (5*4)(BX), CX
947 MOVL (6*4)(BX), DX
948 MOVL AX, (3*4)(SP) // a4
949 MOVL CX, (4*4)(SP) // a5
950 MOVL DX, (5*4)(SP) // a6
951 MOVL (7*4)(BX), AX
952 MOVL (8*4)(BX), CX
953 MOVL (9*4)(BX), DX
954 MOVL AX, (6*4)(SP) // a7
955 MOVL CX, (7*4)(SP) // a8
956 MOVL DX, (8*4)(SP) // a9
957 MOVL (10*4)(BX), AX
958 MOVL AX, (9*4)(SP) // a10
959
960 MOVL (0*4)(BX), AX // fn
961 CALL AX
962
963 MOVL AX, (11*4)(BX) // r1
964 MOVL DX, (12*4)(BX) // r2
965
966 // Standard libc functions return -1 on error and set errno.
967 CMPL AX, $-1
968 JNE ok
969 CMPL DX, $-1
970 JNE ok
971
972 // Get error code from libc.
973 CALL libc_errno(SB)
974 MOVL (AX), AX
975 MOVW AX, (13*4)(BX) // err
976
977 ok:
978 MOVL $0, AX // no error (it's ignored anyway)
979 MOVL BP, SP
980 POPL BP
981 RET
982
983 TEXT runtime·issetugid_trampoline(SB),NOSPLIT,$0
984 PUSHL BP
985 CALL libc_issetugid(SB)
986 NOP SP // tell vet SP changed - stop checking offsets
987 MOVL 8(SP), DX // pointer to return value
988 MOVL AX, 0(DX)
989 POPL BP
990 RET
991
View as plain text