1 // from http://vserver.13thfloor.at/Experimental/SYSCALL/syscall_shiny17.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(__pic("ri") __nopic("b"), \
273 __sc_reg1(__VA_ARGS__)), \
274 __sc_rvcs("0", &__scs))
276 #define __sc_syscall(n,N,...) \
277 __sc_asm_vol (__sysc_cmd(n) \
279 : __sc_cidval(N) __sc_null(n) \
280 __sc_arg1(n,__VA_ARGS__) \
281 __con_##n(__sc_rvrd,__VA_ARGS__) \
284 #define __sysc_cmd(n) \
285 __pasm(n,1,1, "pushl %%ebx" ,)\
286 __Pasm(n,1,5,1,,"movl %2, %%ebx" ,)\
287 __casm(n,6,1, "pushl %%ebp" ,)\
288 __casm(n,6,1, "movl 0(%2), %%ebx" ,)\
289 __casm(n,6,1, "movl 4(%2), %%ebp" ,)\
290 __casm(n,0,1, "movl %1, %%eax" ,)\
291 __casm(n,0,1, "int $0x80" ,)\
292 __casm(n,6,1, "popl %%ebp" ,)\
293 __pasm(n,1,1, "popl %%ebx" ,)
295 #define __sysc_reg_ret "eax"
296 #define __sysc_con_ret "=a"
300 /* *****************************************
301 IA64 IA64 IA64 IA64 *
302 ia64 kernel interface */
304 #elif defined(__ia64__)
306 /* The ia64 calling convention uses out0-out7 to pass the first
307 eight arguments (mapped via register windows).
310 args: a1(out0), a2(out1), ... a5(out4), a6(out5)
314 clob: out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
318 #define __sysc_errc(r,e) ((e) == -1)
320 #define __sysc_cmd(n) "break.i 0x100000"
322 #define __sysc_regs "out0", "out1", "out2", "out3", "out4", "out5"
323 #define __sysc_reg_cid "r15"
324 #define __sysc_reg_ret "r8"
325 #define __sysc_reg_err "r10"
327 #define __sysc_clobber \
328 "out6", "out7", "r2", "r3", "r9", "r11", "r12", "r13", \
329 "r14", "r16", "r17", "r18", "r19", "r20", "r21", "r22", \
330 "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", \
331 "r31", "p6", "p7", "p8", "p9", "p10", "p11", "p12", "p13", \
332 "p14", "p15", "f6", "f7", "f8", "f9", "f10", "f11", "f12", \
333 "f13", "f14", "f15", "f16", "b6", "b7", "cc", "memory"
335 #warning syscall arch ia64 not tested yet
339 /* *****************************************
340 M32R M32R M32R M32R *
341 m32r kernel interface */
343 #elif defined(__M32R__)
345 /* The m32r calling convention uses r0-r7 to pass the first
346 eight arguments (mapped via register windows).
349 args: a1(r1), a2(r2), a3(r3), a4(r4), a5(r5), a6(r6)
351 serr: (sret >= (unsigned)-EMAXERRNO)
353 clob: out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
357 #define __sysc_max_err 125
359 #define __sysc_cmd(n) "trap #2"
361 #define __sysc_regs "r0", "r1", "r2", "r3", "r4", "r5"
362 #define __sysc_reg_cid "r7"
363 #define __sysc_reg_ret "r0"
365 #warning syscall arch m32r not tested yet
369 /* *****************************************
370 M68K M68K M68K M68K *
371 m68k kernel interface */
373 #elif defined(__m68000__)
375 #error syscall arch m68k not implemented yet
379 /* *****************************************
380 MIPS MIPS MIPS MIPS *
381 mips kernel interface */
383 #elif defined(__mips__)
385 /* The ABIO32 calling convention uses a0-a3 to pass the first
386 four arguments, the rest is passed on the userspace stack.
387 The 5th arg starts at 16($sp). The new mips calling abi uses
388 registers a0-a5, restart requires a reload of v0 (#syscall)
390 ABIN32 and ABI64 pass 6 args in a0-a3, t0-t1.
393 args: a1(a0), a2(a1), a3(a2), a4(a3), a5(t0), a6(t1)
397 clob: at, v1, t2-t7, t8-t9
401 #define __sysc_cmd(n) \
402 __casm(n,0,1, "ori $v0,$0,%2" ,)\
403 __casm(n,0,1, "syscall" ,)
405 #define __sysc_regs "a0","a1","a2","a3", "t0", "t1"
406 #define __sysc_reg_ret "v0"
407 #define __sysc_reg_err "a3"
409 #define __sysc_clobber "$1", "$3", "$10", "$11", "$12", \
410 "$13", "$14", "$15", "$24", "$25", "memory"
412 #warning syscall arch mips not tested yet
416 /* *****************************************
418 ppc/64 kernel interface */
420 #elif defined(__powerpc__)
422 /* The powerpc calling convention uses r3-r10 to pass the first
423 eight arguments, the remainder is spilled onto the stack.
426 args: a1(r3), a2(r4), a3(r5), a4(r6), a5(r7), a6(r8)
430 clob: r9-r12, cr0, ctr
434 #define __sysc_errc(r,e) ((e) & 0x10000000)
436 #define __sysc_cmd(n) \
437 __casm(n,0,1, "sc" ,)\
438 __casm(n,0,1, "mfcr %1" ,)
440 #define __sysc_regs "r3", "r4", "r5", "r6", "r7", "r8"
441 #define __sysc_reg_cid "r0"
442 #define __sysc_reg_ret "r3"
444 #define __sysc_clobber "r9", "r10", "r11", "r12", "cr0", "ctr", "memory"
448 /* *****************************************
449 S390 S390 S390 S390 *
450 s390/x kernel interface */
452 #elif defined(__s390__)
454 /* The s390x calling convention passes the first five arguments
455 in r2-r6, the remainder is spilled onto the stack. However
456 the Linux kernel passes the first six arguments in r2-r7.
459 args: a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
461 serr: (sret >= (unsigned)-EMAXERRNO)
466 #define __sysc_max_err 4095
468 #define __sysc_cmd(n) "svc 0"
470 // #define __sysc_type unsigned long
472 #define __sysc_regs "r2", "r3", "r4", "r5", "r6", "r7"
473 #define __sysc_reg_cid "r1"
474 #define __sysc_reg_ret "r2"
476 #warning syscall arch s390 not tested yet
480 /* *****************************************
482 sh kernel interface */
484 #elif defined(__sh__) && !defined(__SH5__)
486 /* The SuperH calling convention passes the first four arguments
487 in r4-r7, the remainder is spilled onto the stack. However
488 the Linux kernel passes the remainder in r0-r1.
491 args: a1(r4), a2(r5), a3(r6), a4(r7), a5(r0), a6(r1)
493 serr: (sret >= (unsigned)-EMAXERRNO)
494 call: trapa #0x1x (x=#args)
500 #define __sysc_arch "trapa #0x2"
502 #define __sysc_arch "trapa #0x1"
505 #define __sysc_max_err 4095
507 #define __sysc_cmd(n) __sysc_arch #n
509 #define __sysc_regs "r4", "r5", "r6", "r7", "r0", "r1"
510 #define __sysc_reg_cid "r3"
511 #define __sysc_reg_ret "r0"
513 #warning syscall arch sh not tested yet
517 /* *****************************************
518 SH64 SH64 SH64 SH64 *
519 sh64 kernel interface */
521 #elif defined(__sh__) && defined(__SH5__)
523 /* The SuperH-5 calling convention passes the first eight
524 arguments in r2-r9. The Linux kernel uses only six of
525 them as arguments, and the last one for the syscall id.
528 args: a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
530 serr: (sret >= (unsigned)-EMAXERRNO)
531 call: trapa #0x1x (x=#args)
536 #define __sysc_max_err 4095
538 #define __sysc_cmd(n) \
539 __casm(n,0,1, "movi 0x1" #n ",r9" ,)\
540 __casm(n,0,1, "shori %1,r9" ,)\
541 __casm(n,0,1, "trapa r9" ,)
543 #define __sysc_regs "r2", "r3", "r4", "r5", "r6", "r7"
544 #define __sysc_reg_ret "r9"
546 #warning syscall arch sh64 not tested yet
550 /* *****************************************
551 SPARC64 SPARC64 SPARC64 SPARC64 *
552 sparc64 kernel interface */
554 #elif defined(__sparc__)
556 /* The sparc/64 calling convention uses o0-o5 to pass the first
557 six arguments (mapped via register windows).
560 args: a1(o0), a2(o1), a3(o2), a4(o3), a5(o4), a6(o5)
563 call: ta 0x6d, t 0x10
564 clob: g1-g6, g7?, o7?, f0-f31, cc
569 #define __sysc_arch "ta 0x6d"
571 #define __sysc_arch "ta 0x10"
574 #define __sysc_cmd(n) \
575 __casm(n,0,1, __sysc_arch ,)\
576 __casm(n,0,1, "addx %%g0,%%g0,%1" ,)
578 #define __sysc_regs "o0", "o1", "o2", "o3", "o4", "o5"
579 #define __sysc_reg_cid "g1"
580 #define __sysc_reg_ret "o0"
582 #define __sysc_clobber "g2", "g3", "g4", "g5", "g6", \
583 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", \
584 "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", \
585 "f17", "f18", "f19", "f20", "f21", "f22", "f23", "f24", \
586 "f25", "f26", "f27", "f28", "f29", "f30", "f31", "f32", \
587 "f34", "f36", "f38", "f40", "f42", "f44", "f46", "f48", \
588 "f50", "f52", "f54", "f56", "f58", "f60", "f62", \
593 /* *****************************************
594 V850 V850 V850 V850 *
595 v850 kernel interface */
597 #elif defined(__v850__)
599 /* The V850 calling convention passes the first four arguments
600 in registers r6-r9, the rest is spilled onto the stack.
601 but the Linux kernel interface uses r6-r9 and r13/14.
604 args: a1(r6), a2(r7), a3(r8), a4(r9), a5(r13), a6(r14)
606 serr: (sret >= (unsigned)-EMAXERRNO)
608 clob: r1, r5, r11, r15-r19
611 #define __sysc_max_err 515
613 #define __sysc_cmd(n) \
614 __casm(n,4,0, "trap 1" ,"trap 0" )
616 #define __sysc_regs "r6", "r7", "r8", "r9", "r13", "r14"
617 #define __sysc_reg_cid "r12"
618 #define __sysc_reg_ret "r10"
620 #define __sysc_clobber "r1", "r5", "r11", \
621 "r15", "r16", "r17", "r18", "r19", "memory"
623 #warning syscall arch v850 not tested yet
627 /* *****************************************
628 X86_64 X86_64 X86_64 X86_64 *
629 x86_64 kernel interface */
631 #elif defined(__x86_64__)
633 /* The x86_64 calling convention uses rdi, rsi, rdx, rcx, r8, r9
634 but the Linux kernel interface uses rdi, rsi, rdx, r10, r8, r9.
637 args: a1(rdi), a2(rsi), a3(rdx), a4(r10), a5(r8), a6(r9)
639 serr: (err= sret > (unsigned)-EMAXERRNO)
644 #define __sysc_max_err 4095
646 #define __sysc_cmd(n) "syscall"
648 #define __sysc_regs "rdi", "rsi", "rdx", "r10", "r8", "r9"
649 #define __sysc_reg_cid "rax"
650 #define __sysc_reg_ret "rax"
651 #define __sysc_con_ret "=a"
653 #define __sysc_clobber "cc", "r11", "rcx", "memory"
656 #error unknown kernel arch
660 /* implementation defaults */
664 #ifndef __sysc_clobber
665 #define __sysc_clobber "memory"
669 #define __sysc_acon(n) "r"
672 #ifndef __sysc_con_ret
673 #define __sysc_con_ret "=r"
676 #ifndef __sysc_con_err
677 #define __sysc_con_err "=r"
680 #ifndef __sysc_con_cid
681 #ifdef __sysc_reg_cid
682 #define __sysc_con_cid "r"
684 #define __sysc_con_cid "i"
689 #define __sysc_type long
693 #define __sysc_rega(n,...) __arg_##n(__VA_ARGS__)
695 #define __sysc_reg(n) __sysc_rega(n,__sysc_regs)
703 #define __lst_6(x,a1,a2,a3,a4,a5,a6) __lst_5(x,a1,a2,a3,a4,a5),x(6,a6)
704 #define __lst_5(x,a1,a2,a3,a4,a5) __lst_4(x,a1,a2,a3,a4),x(5,a5)
705 #define __lst_4(x,a1,a2,a3,a4) __lst_3(x,a1,a2,a3),x(4,a4)
706 #define __lst_3(x,a1,a2,a3) __lst_2(x,a1,a2),x(3,a3)
707 #define __lst_2(x,a1,a2) __lst_1(x,a1),x(2,a2)
708 #define __lst_1(x,a1) __lst_0(x,*),x(1,a1)
709 #define __lst_0(x,a0)
711 /* argument concatenation */
713 #define __con_6(x,a1,a2,a3,a4,a5,a6) __con_5(x,a1,a2,a3,a4,a5)x(6,a6)
714 #define __con_5(x,a1,a2,a3,a4,a5) __con_4(x,a1,a2,a3,a4)x(5,a5)
715 #define __con_4(x,a1,a2,a3,a4) __con_3(x,a1,a2,a3)x(4,a4)
716 #define __con_3(x,a1,a2,a3) __con_2(x,a1,a2)x(3,a3)
717 #define __con_2(x,a1,a2) __con_1(x,a1)x(2,a2)
718 #define __con_1(x,a1) __con_0(x,*)x(1,a1)
719 #define __con_0(x,a0)
721 /* argument selection */
724 #define __arg_1(a1,...) a1
725 #define __arg_2(a1,a2,...) a2
726 #define __arg_3(a1,a2,a3,...) a3
727 #define __arg_4(a1,a2,a3,a4,...) a4
728 #define __arg_5(a1,a2,a3,a4,a5,...) a5
729 #define __arg_6(a1,a2,a3,a4,a5,a6,...) a6
733 #define __rem_0(a1,a2,a3,a4,a5,a6) ,a1,a2,a3,a4,a5,a6
734 #define __rem_1(a1,a2,a3,a4,a5,a6) ,a2,a3,a4,a5,a6
735 #define __rem_2(a1,a2,a3,a4,a5,a6) ,a3,a4,a5,a6
736 #define __rem_3(a1,a2,a3,a4,a5,a6) ,a4,a5,a6
737 #define __rem_4(a1,a2,a3,a4,a5,a6) ,a5,a6
738 #define __rem_5(a1,a2,a3,a4,a5,a6) ,a6
742 /* conditional asm */
744 #define __casm_use(q,r,v) v __casm_use_##q##r(__casm_nl(""))
746 #define __casm_use_10(v)
747 #define __casm_use_11(v) v
748 #define __casm_use_12(v)
749 #define __casm_use_13(v) v
751 #define __casm_use_20(v)
752 #define __casm_use_21(v)
753 #define __casm_use_22(v) v
754 #define __casm_use_23(v) v
757 #define __casm_00(v,w,r) __casm_use(1,r,v)
758 #define __casm_01(v,w,r) __casm_use(2,r,w)
759 #define __casm_02(v,w,r) __casm_use(2,r,w)
760 #define __casm_03(v,w,r) __casm_use(2,r,w)
761 #define __casm_04(v,w,r) __casm_use(2,r,w)
762 #define __casm_05(v,w,r) __casm_use(2,r,w)
763 #define __casm_06(v,w,r) __casm_use(2,r,w)
765 #define __casm_10(v,w,r) __casm_use(1,r,v)
766 #define __casm_11(v,w,r) __casm_use(1,r,v)
767 #define __casm_12(v,w,r) __casm_use(2,r,w)
768 #define __casm_13(v,w,r) __casm_use(2,r,w)
769 #define __casm_14(v,w,r) __casm_use(2,r,w)
770 #define __casm_15(v,w,r) __casm_use(2,r,w)
771 #define __casm_16(v,w,r) __casm_use(2,r,w)
773 #define __casm_20(v,w,r) __casm_use(1,r,v)
774 #define __casm_21(v,w,r) __casm_use(1,r,v)
775 #define __casm_22(v,w,r) __casm_use(1,r,v)
776 #define __casm_23(v,w,r) __casm_use(2,r,w)
777 #define __casm_24(v,w,r) __casm_use(2,r,w)
778 #define __casm_25(v,w,r) __casm_use(2,r,w)
779 #define __casm_26(v,w,r) __casm_use(2,r,w)
781 #define __casm_30(v,w,r) __casm_use(1,r,v)
782 #define __casm_31(v,w,r) __casm_use(1,r,v)
783 #define __casm_32(v,w,r) __casm_use(1,r,v)
784 #define __casm_33(v,w,r) __casm_use(1,r,v)
785 #define __casm_34(v,w,r) __casm_use(2,r,w)
786 #define __casm_35(v,w,r) __casm_use(2,r,w)
787 #define __casm_36(v,w,r) __casm_use(2,r,w)
789 #define __casm_40(v,w,r) __casm_use(1,r,v)
790 #define __casm_41(v,w,r) __casm_use(1,r,v)
791 #define __casm_42(v,w,r) __casm_use(1,r,v)
792 #define __casm_43(v,w,r) __casm_use(1,r,v)
793 #define __casm_44(v,w,r) __casm_use(1,r,v)
794 #define __casm_45(v,w,r) __casm_use(2,r,w)
795 #define __casm_46(v,w,r) __casm_use(2,r,w)
797 #define __casm_50(v,w,r) __casm_use(1,r,v)
798 #define __casm_51(v,w,r) __casm_use(1,r,v)
799 #define __casm_52(v,w,r) __casm_use(1,r,v)
800 #define __casm_53(v,w,r) __casm_use(1,r,v)
801 #define __casm_54(v,w,r) __casm_use(1,r,v)
802 #define __casm_55(v,w,r) __casm_use(1,r,v)
803 #define __casm_56(v,w,r) __casm_use(2,r,w)
805 #define __casm_60(v,w,r) __casm_use(1,r,v)
806 #define __casm_61(v,w,r) __casm_use(1,r,v)
807 #define __casm_62(v,w,r) __casm_use(1,r,v)
808 #define __casm_63(v,w,r) __casm_use(1,r,v)
809 #define __casm_64(v,w,r) __casm_use(1,r,v)
810 #define __casm_65(v,w,r) __casm_use(1,r,v)
811 #define __casm_66(v,w,r) __casm_use(1,r,v)
814 /* special PIC handling */
824 #define __casm_nl(v) v "\n\t"
826 #define __casm(n,a,r,v,w) __casm_##n##a(v,w,r)
827 #define __Casm(n,a,b,r,u,v,w) __casm_##n##b(w,__casm_##n##a(v,u,r),r)
829 #define __pasm(n,a,r,v,w) __pic(__casm(n,a,r,v,w))
830 #define __Pasm(n,a,b,r,u,v,w) __pic(__Casm(n,a,b,r,u,v,w))
832 #define __nasm(n,a,r,v,w) __nopic(__casm(n,a,r,v,w))
833 #define __Nasm(n,a,b,r,u,v,w) __nopic(__Casm(n,a,b,r,u,v,w))
836 #define __sc_cast(v) (__sysc_type)(v)
837 #define __sc_ldef(N) __sysc_type N
838 #define __sc_rdef(N,R) register __sc_ldef(N) __sc_asm (R)
840 #define __sc_scid(N,v) __sc_ldef(N) = __sc_cast(v)
841 #define __sc_areg(N,R,v) __sc_rdef(N,R) = __sc_cast(v)
843 #define __sc_rval(n,v) "r"(__sc_a##n)
844 #define __sc_ival(n,v) __sysc_acon(n)(__sc_cast(v))
845 #define __sc_idef(n,v) __sc_areg(__sc_a##n, __sysc_reg(n), v);
848 #define __sc_cregs(n,...) __rem_##n(__VA_ARGS__)
850 #define __sc_cregs(n,...)
854 #define __sc_input(n,...) __con_##n(__sc_idef,__VA_ARGS__)
855 #define __sc_ivals(n,...) __lst_##n(__sc_rval,__VA_ARGS__)
857 #define __sc_ivals(n,...) __lst_##n(__sc_ival,__VA_ARGS__)
860 #ifdef __sysc_reg_cid
861 #define __sc_cidvar(N) __sc_areg(__sc_id, \
862 __sysc_reg_cid, __sysc_cid(N))
863 #define __sc_cidval(N) __sysc_con_cid (__sc_id)
867 #define __sc_input(n,...)
871 #define __sc_cidval(N) __sysc_con_cid (__sysc_cid(N))
875 #define __sc_cidvar(N)
879 #ifdef __sysc_reg_ret
880 #define __sc_ret __ret
881 #define __sc_def_ret __sc_ldef(ret); __sc_rdef(__sc_ret,__sysc_reg_ret)
884 #define __sc_def_ret __sc_ldef(__sc_ret)
887 #ifdef __sysc_reg_err
888 #define __sc_err __err
889 #define __sc_def_err __sc_ldef(err); __sc_rdef(__sc_err,__sysc_reg_err)
892 #define __sc_def_err __sc_ldef(__sc_err)
896 #ifndef __sysc_max_err
900 #ifdef __sc_complex /* complex result */
903 #define __sc_results __sc_def_ret; __sc_def_err
907 #define __sysc_errc(ret, err) (err)
911 #define __sysc_retv(type, ret, err) \
912 if (__sysc_errc(ret, err)) { \
913 __sysc_seterr(ret); \
919 #define __sc_oregs __sysc_con_ret (__sc_ret), \
920 __sysc_con_err (__sc_err)
922 #define __sc_return(t) ret = __sc_ret; err = __sc_err; \
923 __sysc_retv(t, ret, err)
925 #else /* simple result */
928 #define __sc_results __sc_def_ret
932 #define __sysc_errc(ret) \
933 ((unsigned __sysc_type)(ret) >= \
934 (unsigned __sysc_type)(-(__sysc_max_err)))
938 #define __sysc_retv(type, ret) \
939 if (__sysc_errc(ret)) { \
940 __sysc_seterr(-ret); \
946 #define __sc_oregs __sysc_con_ret (__sc_ret)
948 #define __sc_return(t) ret = __sc_ret; __sysc_retv(t, ret)
950 #endif /* simple/complex */
954 /* the inline syscall */
956 #define __sc_asm __asm__
957 #define __sc_asm_vol __asm__ __volatile__
960 #define __sc_syscall(n,N,...) \
961 __sc_asm_vol (__sysc_cmd(n) \
963 : __sc_cidval(N) __sc_ivals(n,__VA_ARGS__) \
964 : __sysc_clobber __sc_cregs(n,__sysc_clbrs))
968 #define __sc_body(n, type, name, ...) \
970 __sc_results;__sc_cidvar(name); \
971 __sc_input(n,__VA_ARGS__) \
972 __sc_syscall(n,name,__VA_ARGS__); \
977 #define _syscall0(type, name) \
979 __sc_body(0, type, name, *)
981 #define _syscall1(type, name, type1, arg1) \
982 type name(type1 arg1) \
983 __sc_body(1, type, name, arg1)
985 #define _syscall2(type, name, type1, arg1, type2, arg2) \
986 type name(type1 arg1, type2 arg2) \
987 __sc_body(2, type, name, arg1, arg2)
989 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
990 type name(type1 arg1, type2 arg2, type3 arg3) \
991 __sc_body(3, type, name, arg1, arg2, arg3)
993 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
995 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
996 __sc_body(4, type, name, arg1, arg2, arg3, arg4)
998 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
999 type4, arg4, type5, arg5) \
1000 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \
1001 __sc_body(5, type, name, arg1, arg2, arg3, arg4, arg5)
1003 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
1004 type4, arg4, type5, arg5, type6, arg6) \
1005 type name(type1 arg1, type2 arg2, type3 arg3, \
1006 type4 arg4, type5 arg5, type6 arg6) \
1007 __sc_body(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6)
1011 #endif /* __SYSCALL_NEW_H */