1 // from http://vserver.13thfloor.at/Experimental/SYSCALL/syscall_shiny16.h
3 #ifndef __SYSCALL_NEW_H
4 #define __SYSCALL_NEW_H
6 /* Copyright (C) 2005-2007 Herbert Pƶtzl
10 __sysc_seterr ... set error value (def: errno)
11 __sysc_cid(N) ... syscall 'name' id (def: __NR_<N>)
15 __sysc_regs ... the syscall registers (asm load)
16 __sysc_cmd(n) ... the syscall
17 __sysc_reg_cid ... syscall id register (asm load)
18 __sysc_reg_ret ... syscall return register (asm out)
19 __sysc_reg_err ... syscall error register (asm out)
21 __sysc_clbrs ... the clobbered syscall registers
22 __sysc_clobber ... clobbered registers (def: memory)
23 __sysc_max_err ... maximum error number (def: separate)
24 __sysc_errc(r,e)... error condition (def: e)
26 __sysc_type ... type of syscall arguments (def: long)
27 __sysc_acon(n) ... argument constraint (def: "r")
28 __sysc_con_cid ... syscall id constraint (def: "i"/"r")
29 __sysc_con_ret ... return value contraint (def: "=r")
30 __sysc_con_err ... error value contraint (def: "=r")
32 hard core replacements
34 __sc_body(n,type,name,...)
43 /* some fallback defaults */
46 #define __sysc_seterr(e) do { errno = (e); } while(0)
50 #define __sysc_cid(N) __NR_##N
54 /* *****************************************
55 ALPHA ALPHA ALPHA ALPHA *
56 alpha kernel interface */
58 #if defined(__alpha__)
60 /* The Alpha calling convention doesn't use the stack until
61 after the first six arguments have been passed in registers.
64 args: a1($16), a2($17), a3($18), a4($19), a5($20), a6($21)
66 serr: e0($19) (!=0, err=sret)
70 picr: pr($29) do we need to save that?
73 #define __sysc_cmd(n) "callsys"
75 #define __sysc_reg_cid "$0"
76 #define __sysc_con_cid "v"
77 #define __sysc_reg_ret "$0"
78 #define __sysc_con_ret "=v"
79 #define __sysc_reg_err "$19"
81 #define __sysc_regs "$16", "$17", "$18", "$19", "$20", "$21"
82 #define __sysc_clbrs "$16", "$17", "$18", "memory", "$20", "$21"
83 #define __sysc_clobber "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \
84 "$22", "$23", "$24", "$25", "$27", "$28", "memory"
87 /* *****************************************
89 arm kernel interface */
91 #elif defined(__arm__)
93 /* The Arm calling convention uses stack args after four arguments
94 but the Linux kernel gets up to seven arguments in registers.
97 args: a1(r0), a2(r1), a3(r2), a4(r3), a5(r4), a6(r5),
99 serr: (sret >= (unsigned)-EMAXERRNO)
105 #define __sysc_max_err 125
107 #define __sysc_cmd(n) "swi %1"
109 #define __sysc_regs "r0", "r1", "r2", "r3", "r4", "r5"
110 #define __sysc_reg_ret "r0"
112 #warning syscall arch arm not tested yet
116 /* *****************************************
117 CRIS CRIS CRIS CRIS *
118 cris v10 kernel interface */
120 #elif defined(__cris__)
122 /* The Cris calling convention uses stack args after four arguments
123 but the Linux kernel gets up to six arguments in registers.
126 args: a1(r10), a2(r11), a3(r12), a4(r13), a5(mof), a6(srp),
128 serr: (sret >= (unsigned)-EMAXERRNO)
133 #error syscall arch cris not implemented yet
137 /* *****************************************
139 frv kernel interface */
141 #elif defined(__frv__)
143 /* The C calling convention on FR-V uses the gr8-gr13 registers
144 for the first six arguments, the remainder is spilled onto the
145 stack. the linux kernel syscall interface does so too.
148 args: a1(gr8), a2(gr9), a3(gr10), a4(gr11), a5(gr12), a6(gr13)
150 serr: (sret >= (unsigned)-EMAXERRNO)
155 #error syscall arch frv not implemented yet
159 /* *****************************************
160 H8300 H8300 H8300 H8300 *
161 h8/300 kernel interface */
163 #elif defined(__H8300__)
165 /* The H8/300 C calling convention passes the first three
166 arguments in registers. However the linux kernel calling
167 convention passes the first six arguments in registers
171 args: a1(er1), a2(er2), a3(er3), a4(er4), a5(er5), a6(er6)
173 serr: (sret >= (unsigned)-EMAXERRNO)
178 #error syscall arch h8300 not implemented yet
182 /* *****************************************
183 HPPA HPPA HPPA HPPA *
184 hppa/64 kernel interface */
186 #elif defined(__hppa__)
188 /* The hppa calling convention uses r26-r23 for the first 4
189 arguments, the rest is spilled onto the stack. However the
190 Linux kernel passes the first six arguments in the registers
193 The system call number MUST ALWAYS be loaded in the delay
194 slot of the ble instruction, or restarting system calls
198 args: a1(r26), a2(r25), a3(r24), a4(r23), a5(r22), a6(r21)
200 serr: (sret >= (unsigned)-EMAXERRNO)
201 call: ble 0x100(%%sr2, %%r0)
202 clob: r1, r2, (r4), r20, r29, r31, memory
203 picr: pr(r19) do we need to save that?
206 #define __sysc_max_err 4095
208 #define __sysc_cmd(n) \
209 __pasm(n,1,1, "copy %%r19, %%r4" ,)\
210 __casm(n,0,1, "ble 0x100(%%sr2,%%r0)" ,)\
211 __casm(n,0,1, "ldi %1,%%r20" ,)\
212 __pasm(n,1,1, "copy %%r4, %%r19" ,)
214 #define __sysc_regs "r26", "r25", "r24", "r23", "r22", "r21"
217 #define __sysc_clobber "r1", "r2", "r20", "r29", "r31", "memory"
219 #define __sysc_clobber "r1", "r2", "r4", "r20", "r29", "r31", "memory"
222 #warning syscall arch hppa not tested yet
226 /* *****************************************
227 I386 I386 I386 I386 *
228 i386 kernel interface */
230 #elif defined(__i386__)
232 /* The x86 calling convention uses stack args for all arguments,
233 but the Linux kernel passes the first six arguments in the
234 following registers: ebx, ecx, edx, esi, edi, ebp.
237 args: a1(ebx), a2(ecx), a3(edx), a4(esi), a5(edi), a6(ebp)
239 serr: (sret >= (unsigned)-EMAXERRNO)
246 #define __sysc_max_err 129
248 #define __sc_reg1(...) __sc_cast(__arg_1(__VA_ARGS__,,,,,,))
249 #define __sc_reg6(...) __sc_cast(__arg_6(__VA_ARGS__,,,,,,))
251 #define __scsd struct { __sc_ldef(__a); __sc_ldef(__b); } __scs
252 #define __scsa(n,...) \
253 __scs.__a = __sc_reg1(__VA_ARGS__); \
254 __scs.__b = __sc_reg6(__VA_ARGS__);
256 #define __sc_input(n,...) __casm(n,6,0, \
257 __scsd; __scsa(n,__VA_ARGS__), )
260 #define __sc_null(n) __arg_##n( \
261 __cm,__cm,__cm,__cm,__cm,__cm)
263 #define __sc_rvcs(r,v) r (__sc_cast(v))
265 #define __sc_rvrd(n,N) __arg_##n(, \
266 __cm __sc_rvcs("c", N), \
267 __cm __sc_rvcs("d", N), \
268 __cm __sc_rvcs("S", N), \
269 __cm __sc_rvcs("D", N),)
271 #define __sc_arg1(n,...) __Casm(n,1,6,0,, \
272 __sc_rvcs("ri", __sc_reg1(__VA_ARGS__)),\
273 __sc_rvcs("0", &__scs))
275 #define __sc_syscall(n,N,...) \
276 __sc_asm_vol (__sysc_cmd(n) \
278 : __sc_cidval(N) __sc_null(n) \
279 __sc_arg1(n,__VA_ARGS__) \
280 __con_##n(__sc_rvrd,__VA_ARGS__) \
281 : "memory" __nopic(__cm "ebx"))
283 #define __sysc_cmd(n) \
284 __pasm(n,1,1, "pushl %%ebx" ,)\
285 __Casm(n,1,6,1,,"movl %2, %%ebx" ,)\
286 __casm(n,6,1, "pushl %%ebp" ,)\
287 __casm(n,6,1, "movl 0(%2), %%ebx" ,)\
288 __casm(n,6,1, "movl 4(%2), %%ebp" ,)\
289 __casm(n,0,1, "movl %1, %%eax" ,)\
290 __casm(n,0,1, "int $0x80" ,)\
291 __casm(n,6,1, "popl %%ebp" ,)\
292 __pasm(n,1,1, "popl %%ebx" ,)
294 #define __sysc_reg_ret "eax"
295 #define __sysc_con_ret "=a"
299 /* *****************************************
300 IA64 IA64 IA64 IA64 *
301 ia64 kernel interface */
303 #elif defined(__ia64__)
305 /* The ia64 calling convention uses out0-out7 to pass the first
306 eight arguments (mapped via register windows).
309 args: a1(out0), a2(out1), ... a5(out4), a6(out5)
313 clob: out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
317 #define __sysc_errc(r,e) ((e) == -1)
319 #define __sysc_cmd(n) "break.i 0x100000"
321 #define __sysc_regs "out0", "out1", "out2", "out3", "out4", "out5"
322 #define __sysc_reg_cid "r15"
323 #define __sysc_reg_ret "r8"
324 #define __sysc_reg_err "r10"
326 #define __sysc_clobber \
327 "out6", "out7", "r2", "r3", "r9", "r11", "r12", "r13", \
328 "r14", "r16", "r17", "r18", "r19", "r20", "r21", "r22", \
329 "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", \
330 "r31", "p6", "p7", "p8", "p9", "p10", "p11", "p12", "p13", \
331 "p14", "p15", "f6", "f7", "f8", "f9", "f10", "f11", "f12", \
332 "f13", "f14", "f15", "f16", "b6", "b7", "cc", "memory"
334 #warning syscall arch ia64 not tested yet
338 /* *****************************************
339 M32R M32R M32R M32R *
340 m32r kernel interface */
342 #elif defined(__M32R__)
344 /* The m32r calling convention uses r0-r7 to pass the first
345 eight arguments (mapped via register windows).
348 args: a1(r1), a2(r2), a3(r3), a4(r4), a5(r5), a6(r6)
350 serr: (sret >= (unsigned)-EMAXERRNO)
352 clob: out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
356 #define __sysc_max_err 125
358 #define __sysc_cmd(n) "trap #2"
360 #define __sysc_regs "r0", "r1", "r2", "r3", "r4", "r5"
361 #define __sysc_reg_cid "r7"
362 #define __sysc_reg_ret "r0"
364 #warning syscall arch m32r not tested yet
368 /* *****************************************
369 M68K M68K M68K M68K *
370 m68k kernel interface */
372 #elif defined(__m68000__)
374 #error syscall arch m68k not implemented yet
378 /* *****************************************
379 MIPS MIPS MIPS MIPS *
380 mips kernel interface */
382 #elif defined(__mips__)
384 /* The ABIO32 calling convention uses a0-a3 to pass the first
385 four arguments, the rest is passed on the userspace stack.
386 The 5th arg starts at 16($sp). The new mips calling abi uses
387 registers a0-a5, restart requires a reload of v0 (#syscall)
389 ABIN32 and ABI64 pass 6 args in a0-a3, t0-t1.
392 args: a1(a0), a2(a1), a3(a2), a4(a3), a5(t0), a6(t1)
396 clob: at, v1, t2-t7, t8-t9
400 #define __sysc_cmd(n) \
401 __casm(n,0,1, "ori $v0,$0,%2" ,)\
402 __casm(n,0,1, "syscall" ,)
404 #define __sysc_regs "a0","a1","a2","a3", "t0", "t1"
405 #define __sysc_reg_ret "v0"
406 #define __sysc_reg_err "a3"
408 #define __sysc_clobber "$1", "$3", "$10", "$11", "$12", \
409 "$13", "$14", "$15", "$24", "$25", "memory"
411 #warning syscall arch mips not tested yet
415 /* *****************************************
417 ppc/64 kernel interface */
419 #elif defined(__powerpc__)
421 /* The powerpc calling convention uses r3-r10 to pass the first
422 eight arguments, the remainder is spilled onto the stack.
425 args: a1(r3), a2(r4), a3(r5), a4(r6), a5(r7), a6(r8)
429 clob: r9-r12, cr0, ctr
433 #define __sysc_errc(r,e) ((e) & 0x10000000)
435 #define __sysc_cmd(n) \
436 __casm(n,0,1, "sc" ,)\
437 __casm(n,0,1, "mfcr %1" ,)
439 #define __sysc_regs "r3", "r4", "r5", "r6", "r7", "r8"
440 #define __sysc_reg_cid "r0"
441 #define __sysc_reg_ret "r3"
443 #define __sysc_clobber "r9", "r10", "r11", "r12", "cr0", "ctr", "memory"
447 /* *****************************************
448 S390 S390 S390 S390 *
449 s390/x kernel interface */
451 #elif defined(__s390__)
453 /* The s390x calling convention passes the first five arguments
454 in r2-r6, the remainder is spilled onto the stack. However
455 the Linux kernel passes the first six arguments in r2-r7.
458 args: a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
460 serr: (sret >= (unsigned)-EMAXERRNO)
465 #define __sysc_max_err 4095
467 #define __sysc_cmd(n) "svc 0"
469 // #define __sysc_type unsigned long
471 #define __sysc_regs "r2", "r3", "r4", "r5", "r6", "r7"
472 #define __sysc_reg_cid "r1"
473 #define __sysc_reg_ret "r2"
475 #warning syscall arch s390 not tested yet
479 /* *****************************************
481 sh kernel interface */
483 #elif defined(__sh__) && !defined(__SH5__)
485 /* The SuperH calling convention passes the first four arguments
486 in r4-r7, the remainder is spilled onto the stack. However
487 the Linux kernel passes the remainder in r0-r1.
490 args: a1(r4), a2(r5), a3(r6), a4(r7), a5(r0), a6(r1)
492 serr: (sret >= (unsigned)-EMAXERRNO)
493 call: trapa #0x1x (x=#args)
499 #define __sysc_arch "trapa #0x2"
501 #define __sysc_arch "trapa #0x1"
504 #define __sysc_max_err 4095
506 #define __sysc_cmd(n) __sysc_arch #n
508 #define __sysc_regs "r4", "r5", "r6", "r7", "r0", "r1"
509 #define __sysc_reg_cid "r3"
510 #define __sysc_reg_ret "r0"
512 #warning syscall arch sh not tested yet
516 /* *****************************************
517 SH64 SH64 SH64 SH64 *
518 sh64 kernel interface */
520 #elif defined(__sh__) && defined(__SH5__)
522 /* The SuperH-5 calling convention passes the first eight
523 arguments in r2-r9. The Linux kernel uses only six of
524 them as arguments, and the last one for the syscall id.
527 args: a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
529 serr: (sret >= (unsigned)-EMAXERRNO)
530 call: trapa #0x1x (x=#args)
535 #define __sysc_max_err 4095
537 #define __sysc_cmd(n) \
538 __casm(n,0,1, "movi 0x1" #n ",r9" ,)\
539 __casm(n,0,1, "shori %1,r9" ,)\
540 __casm(n,0,1, "trapa r9" ,)
542 #define __sysc_regs "r2", "r3", "r4", "r5", "r6", "r7"
543 #define __sysc_reg_ret "r9"
545 #warning syscall arch sh64 not tested yet
549 /* *****************************************
550 SPARC64 SPARC64 SPARC64 SPARC64 *
551 sparc64 kernel interface */
553 #elif defined(__sparc__)
555 /* The sparc/64 calling convention uses o0-o5 to pass the first
556 six arguments (mapped via register windows).
559 args: a1(o0), a2(o1), a3(o2), a4(o3), a5(o4), a6(o5)
562 call: ta 0x6d, t 0x10
563 clob: g1-g6, g7?, o7?, f0-f31, cc
568 #define __sysc_arch "ta 0x6d"
570 #define __sysc_arch "ta 0x10"
573 #define __sysc_cmd(n) \
574 __casm(n,0,1, __sysc_arch ,)\
575 __casm(n,0,1, "addx %%g0,%%g0,%1" ,)
577 #define __sysc_regs "o0", "o1", "o2", "o3", "o4", "o5"
578 #define __sysc_reg_cid "g1"
579 #define __sysc_reg_ret "o0"
581 #define __sysc_clobber "g2", "g3", "g4", "g5", "g6", \
582 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", \
583 "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", \
584 "f17", "f18", "f19", "f20", "f21", "f22", "f23", "f24", \
585 "f25", "f26", "f27", "f28", "f29", "f30", "f31", "f32", \
586 "f34", "f36", "f38", "f40", "f42", "f44", "f46", "f48", \
587 "f50", "f52", "f54", "f56", "f58", "f60", "f62", \
592 /* *****************************************
593 V850 V850 V850 V850 *
594 v850 kernel interface */
596 #elif defined(__v850__)
598 /* The V850 calling convention passes the first four arguments
599 in registers r6-r9, the rest is spilled onto the stack.
600 but the Linux kernel interface uses r6-r9 and r13/14.
603 args: a1(r6), a2(r7), a3(r8), a4(r9), a5(r13), a6(r14)
605 serr: (sret >= (unsigned)-EMAXERRNO)
607 clob: r1, r5, r11, r15-r19
610 #define __sysc_max_err 515
612 #define __sysc_cmd(n) \
613 __casm(n,4,0, "trap 1" ,"trap 0" )
615 #define __sysc_regs "r6", "r7", "r8", "r9", "r13", "r14"
616 #define __sysc_reg_cid "r12"
617 #define __sysc_reg_ret "r10"
619 #define __sysc_clobber "r1", "r5", "r11", \
620 "r15", "r16", "r17", "r18", "r19", "memory"
622 #warning syscall arch v850 not tested yet
626 /* *****************************************
627 X86_64 X86_64 X86_64 X86_64 *
628 x86_64 kernel interface */
630 #elif defined(__x86_64__)
632 /* The x86_64 calling convention uses rdi, rsi, rdx, rcx, r8, r9
633 but the Linux kernel interface uses rdi, rsi, rdx, r10, r8, r9.
636 args: a1(rdi), a2(rsi), a3(rdx), a4(r10), a5(r8), a6(r9)
638 serr: (err= sret > (unsigned)-EMAXERRNO)
643 #define __sysc_max_err 4095
645 #define __sysc_cmd(n) "syscall"
647 #define __sysc_regs "rdi", "rsi", "rdx", "r10", "r8", "r9"
648 #define __sysc_reg_cid "rax"
649 #define __sysc_reg_ret "rax"
650 #define __sysc_con_ret "=a"
652 #define __sysc_clobber "cc", "r11", "rcx", "memory"
655 #error unknown kernel arch
659 /* implementation defaults */
663 #ifndef __sysc_clobber
664 #define __sysc_clobber "memory"
668 #define __sysc_acon(n) "r"
671 #ifndef __sysc_con_ret
672 #define __sysc_con_ret "=r"
675 #ifndef __sysc_con_err
676 #define __sysc_con_err "=r"
679 #ifndef __sysc_con_cid
680 #ifdef __sysc_reg_cid
681 #define __sysc_con_cid "r"
683 #define __sysc_con_cid "i"
688 #define __sysc_type long
692 #define __sysc_rega(n,...) __arg_##n(__VA_ARGS__)
694 #define __sysc_reg(n) __sysc_rega(n,__sysc_regs)
702 #define __lst_6(x,a1,a2,a3,a4,a5,a6) __lst_5(x,a1,a2,a3,a4,a5),x(6,a6)
703 #define __lst_5(x,a1,a2,a3,a4,a5) __lst_4(x,a1,a2,a3,a4),x(5,a5)
704 #define __lst_4(x,a1,a2,a3,a4) __lst_3(x,a1,a2,a3),x(4,a4)
705 #define __lst_3(x,a1,a2,a3) __lst_2(x,a1,a2),x(3,a3)
706 #define __lst_2(x,a1,a2) __lst_1(x,a1),x(2,a2)
707 #define __lst_1(x,a1) __lst_0(x,*),x(1,a1)
708 #define __lst_0(x,a0)
710 /* argument concatenation */
712 #define __con_6(x,a1,a2,a3,a4,a5,a6) __con_5(x,a1,a2,a3,a4,a5)x(6,a6)
713 #define __con_5(x,a1,a2,a3,a4,a5) __con_4(x,a1,a2,a3,a4)x(5,a5)
714 #define __con_4(x,a1,a2,a3,a4) __con_3(x,a1,a2,a3)x(4,a4)
715 #define __con_3(x,a1,a2,a3) __con_2(x,a1,a2)x(3,a3)
716 #define __con_2(x,a1,a2) __con_1(x,a1)x(2,a2)
717 #define __con_1(x,a1) __con_0(x,*)x(1,a1)
718 #define __con_0(x,a0)
720 /* argument selection */
723 #define __arg_1(a1,...) a1
724 #define __arg_2(a1,a2,...) a2
725 #define __arg_3(a1,a2,a3,...) a3
726 #define __arg_4(a1,a2,a3,a4,...) a4
727 #define __arg_5(a1,a2,a3,a4,a5,...) a5
728 #define __arg_6(a1,a2,a3,a4,a5,a6,...) a6
732 #define __rem_0(a1,a2,a3,a4,a5,a6) ,a1,a2,a3,a4,a5,a6
733 #define __rem_1(a1,a2,a3,a4,a5,a6) ,a2,a3,a4,a5,a6
734 #define __rem_2(a1,a2,a3,a4,a5,a6) ,a3,a4,a5,a6
735 #define __rem_3(a1,a2,a3,a4,a5,a6) ,a4,a5,a6
736 #define __rem_4(a1,a2,a3,a4,a5,a6) ,a5,a6
737 #define __rem_5(a1,a2,a3,a4,a5,a6) ,a6
741 /* conditional asm */
743 #define __casm_use(q,r,v) v __casm_use_##q##r(__casm_nl(""))
745 #define __casm_use_10(v)
746 #define __casm_use_11(v) v
747 #define __casm_use_12(v)
748 #define __casm_use_13(v) v
750 #define __casm_use_20(v)
751 #define __casm_use_21(v)
752 #define __casm_use_22(v) v
753 #define __casm_use_23(v) v
756 #define __casm_00(v,w,r) __casm_use(1,r,v)
757 #define __casm_01(v,w,r) __casm_use(2,r,w)
758 #define __casm_02(v,w,r) __casm_use(2,r,w)
759 #define __casm_03(v,w,r) __casm_use(2,r,w)
760 #define __casm_04(v,w,r) __casm_use(2,r,w)
761 #define __casm_05(v,w,r) __casm_use(2,r,w)
762 #define __casm_06(v,w,r) __casm_use(2,r,w)
764 #define __casm_10(v,w,r) __casm_use(1,r,v)
765 #define __casm_11(v,w,r) __casm_use(1,r,v)
766 #define __casm_12(v,w,r) __casm_use(2,r,w)
767 #define __casm_13(v,w,r) __casm_use(2,r,w)
768 #define __casm_14(v,w,r) __casm_use(2,r,w)
769 #define __casm_15(v,w,r) __casm_use(2,r,w)
770 #define __casm_16(v,w,r) __casm_use(2,r,w)
772 #define __casm_20(v,w,r) __casm_use(1,r,v)
773 #define __casm_21(v,w,r) __casm_use(1,r,v)
774 #define __casm_22(v,w,r) __casm_use(1,r,v)
775 #define __casm_23(v,w,r) __casm_use(2,r,w)
776 #define __casm_24(v,w,r) __casm_use(2,r,w)
777 #define __casm_25(v,w,r) __casm_use(2,r,w)
778 #define __casm_26(v,w,r) __casm_use(2,r,w)
780 #define __casm_30(v,w,r) __casm_use(1,r,v)
781 #define __casm_31(v,w,r) __casm_use(1,r,v)
782 #define __casm_32(v,w,r) __casm_use(1,r,v)
783 #define __casm_33(v,w,r) __casm_use(1,r,v)
784 #define __casm_34(v,w,r) __casm_use(2,r,w)
785 #define __casm_35(v,w,r) __casm_use(2,r,w)
786 #define __casm_36(v,w,r) __casm_use(2,r,w)
788 #define __casm_40(v,w,r) __casm_use(1,r,v)
789 #define __casm_41(v,w,r) __casm_use(1,r,v)
790 #define __casm_42(v,w,r) __casm_use(1,r,v)
791 #define __casm_43(v,w,r) __casm_use(1,r,v)
792 #define __casm_44(v,w,r) __casm_use(1,r,v)
793 #define __casm_45(v,w,r) __casm_use(2,r,w)
794 #define __casm_46(v,w,r) __casm_use(2,r,w)
796 #define __casm_50(v,w,r) __casm_use(1,r,v)
797 #define __casm_51(v,w,r) __casm_use(1,r,v)
798 #define __casm_52(v,w,r) __casm_use(1,r,v)
799 #define __casm_53(v,w,r) __casm_use(1,r,v)
800 #define __casm_54(v,w,r) __casm_use(1,r,v)
801 #define __casm_55(v,w,r) __casm_use(1,r,v)
802 #define __casm_56(v,w,r) __casm_use(2,r,w)
804 #define __casm_60(v,w,r) __casm_use(1,r,v)
805 #define __casm_61(v,w,r) __casm_use(1,r,v)
806 #define __casm_62(v,w,r) __casm_use(1,r,v)
807 #define __casm_63(v,w,r) __casm_use(1,r,v)
808 #define __casm_64(v,w,r) __casm_use(1,r,v)
809 #define __casm_65(v,w,r) __casm_use(1,r,v)
810 #define __casm_66(v,w,r) __casm_use(1,r,v)
813 /* special PIC handling */
823 #define __casm_nl(v) v "\n\t"
825 #define __casm(n,a,r,v,w) __casm_##n##a(v,w,r)
826 #define __Casm(n,a,b,r,u,v,w) __casm_##n##b(w,__casm_##n##a(v,u,r),r)
828 #define __pasm(n,a,r,v,w) __pic(__casm(n,a,r,v,w))
829 #define __Pasm(n,a,b,r,u,v,w) __pic(__Casm(n,a,b,r,u,v,w))
831 #define __nasm(n,a,r,v,w) __nopic(__casm(n,a,r,v,w))
832 #define __Nasm(n,a,b,r,u,v,w) __nopic(__Casm(n,a,b,r,u,v,w))
835 #define __sc_cast(v) (__sysc_type)(v)
836 #define __sc_ldef(N) __sysc_type N
837 #define __sc_rdef(N,R) register __sc_ldef(N) __sc_asm (R)
839 #define __sc_scid(N,v) __sc_ldef(N) = __sc_cast(v)
840 #define __sc_areg(N,R,v) __sc_rdef(N,R) = __sc_cast(v)
842 #define __sc_rval(n,v) "r"(__sc_a##n)
843 #define __sc_ival(n,v) __sysc_acon(n)(__sc_cast(v))
844 #define __sc_idef(n,v) __sc_areg(__sc_a##n, __sysc_reg(n), v);
847 #define __sc_cregs(n,...) __rem_##n(__VA_ARGS__)
849 #define __sc_cregs(n,...)
853 #define __sc_input(n,...) __con_##n(__sc_idef,__VA_ARGS__)
854 #define __sc_ivals(n,...) __lst_##n(__sc_rval,__VA_ARGS__)
856 #define __sc_ivals(n,...) __lst_##n(__sc_ival,__VA_ARGS__)
859 #ifdef __sysc_reg_cid
860 #define __sc_cidvar(N) __sc_areg(__sc_id, \
861 __sysc_reg_cid, __sysc_cid(N))
862 #define __sc_cidval(N) __sysc_con_cid (__sc_id)
866 #define __sc_input(n,...)
870 #define __sc_cidval(N) __sysc_con_cid (__sysc_cid(N))
874 #define __sc_cidvar(N)
878 #ifdef __sysc_reg_ret
879 #define __sc_ret __ret
880 #define __sc_def_ret __sc_ldef(__r); __sc_rdef(__sc_ret,__sysc_reg_ret)
883 #define __sc_def_ret __sc_ldef(__sc_ret)
886 #ifdef __sysc_reg_err
887 #define __sc_err __err
888 #define __sc_def_err __sc_ldef(__e); __sc_rdef(__sc_err,__sysc_reg_err)
891 #define __sc_def_err __sc_ldef(__sc_err)
895 #ifndef __sysc_max_err
899 #ifdef __sc_complex /* complex result */
902 #define __sc_results __sc_def_ret; __sc_def_err
906 #define __sysc_errc(ret, err) (err)
910 #define __sysc_retv(type, ret, err) \
911 if (__sysc_errc(ret, err)) { \
912 __sysc_seterr(ret); \
918 #define __sc_oregs __sysc_con_ret (__sc_ret), \
919 __sysc_con_err (__sc_err)
921 #define __sc_return(t) __r = __sc_ret; __e = __sc_err; \
922 __sysc_retv(t, __r, __e)
924 #else /* simple result */
927 #define __sc_results __sc_def_ret
931 #define __sysc_errc(ret) \
932 ((unsigned __sysc_type)(ret) >= \
933 (unsigned __sysc_type)(-(__sysc_max_err)))
937 #define __sysc_retv(type, ret) \
938 if (__sysc_errc(ret)) { \
939 __sysc_seterr(-ret); \
945 #define __sc_oregs __sysc_con_ret (__sc_ret)
947 #define __sc_return(t) __r = __sc_ret; __sysc_retv(t, __r)
949 #endif /* simple/complex */
953 /* the inline syscall */
955 #define __sc_asm __asm__
956 #define __sc_asm_vol __asm__ __volatile__
959 #define __sc_syscall(n,N,...) \
960 __sc_asm_vol (__sysc_cmd(n) \
962 : __sc_cidval(N) __sc_ivals(n,__VA_ARGS__) \
963 : __sysc_clobber __sc_cregs(n,__sysc_clbrs))
967 #define __sc_body(n, type, name, ...) \
969 __sc_results;__sc_cidvar(name); \
970 __sc_input(n,__VA_ARGS__) \
971 __sc_syscall(n,name,__VA_ARGS__); \
976 #define _syscall0(type, name) \
978 __sc_body(0, type, name, *)
980 #define _syscall1(type, name, type1, arg1) \
981 type name(type1 arg1) \
982 __sc_body(1, type, name, arg1)
984 #define _syscall2(type, name, type1, arg1, type2, arg2) \
985 type name(type1 arg1, type2 arg2) \
986 __sc_body(2, type, name, arg1, arg2)
988 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
989 type name(type1 arg1, type2 arg2, type3 arg3) \
990 __sc_body(3, type, name, arg1, arg2, arg3)
992 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
994 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
995 __sc_body(4, type, name, arg1, arg2, arg3, arg4)
997 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
998 type4, arg4, type5, arg5) \
999 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \
1000 __sc_body(5, type, name, arg1, arg2, arg3, arg4, arg5)
1002 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
1003 type4, arg4, type5, arg5, type6, arg6) \
1004 type name(type1 arg1, type2 arg2, type3 arg3, \
1005 type4 arg4, type5 arg5, type6 arg6) \
1006 __sc_body(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6)
1010 #endif /* __SYSCALL_NEW_H */