1 // from http://vserver.13thfloor.at/Experimental/SYSCALL/syscall_shiny7.h
3 #ifndef __SYSCALL_NEW_H
4 #define __SYSCALL_NEW_H
6 /* Copyright (C) 2005 Herbert Pƶtzl
10 __sysc_setret ... set return value (default none)
11 __sysc_seterr ... set error value (default errno)
16 __sysc_reg_cid ... the callid (if define), immediate otherwise
18 __sysc_reg(n) ... syscall argument registers
20 __sysc_reg_res ... simple result register (either that or)
21 __sysc_reg_ret ... complex result register (and)
22 __sysc_reg_err ... complex error register
24 __sysc_cmd_pre ... preparation command(s) __sysc_pre(n)
25 __sysc_cmd_sys ... the syscall __sysc_cmd(n)
26 __sysc_cmd_fin ... syscall finalization __sysc_fin(n)
28 __sysc_clobber ... clobbered registers (default memory)
29 __sysc_max_err ... maximum error number (for simple result)
31 __sysc_errc(r,e) ... error condition (e cmplx)
32 __sysc_retv(t,r,e) ... syscall return value (e cmplx)
34 if gcc cannot be trusted
36 __sysc_load(r,a) ... asm code for register load
37 __sysc_save(r,a) ... asm code to save result(s)
38 __sysc_limm(r,i) ... asm code to load immediate
39 __sysc_rcon(n) ... syscall register constraint
40 __sysc_regs ... list of input regs for clobber
41 __sysc_type ... register type
45 __sc_asmload(n,N,...) ... asm code to prepare arguments
46 __sc_asmsysc(n,N) ... asm code to execute syscall
47 __sc_asmsave(n,r,e) ... asm code to store results
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)
71 #define __sysc_reg_cid "$0"
72 #define __sysc_reg_ret "$0"
73 #define __sysc_reg_err "$19"
74 #define __sysc_cmd_sys "callsys"
76 #define __sysc_reg(n) __arg_##n\
77 ("$16", "$17", "$18", "$19", "$20", "$21")
79 #define __sysc_clobber __sysc_regs, \
80 "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \
81 "$22", "$23", "$24", "$25", "$27", "$28", "memory" \
85 /* *****************************************
87 arm kernel interface */
89 #elif defined(__arm__)
91 /* The Arm calling convention uses stack args after four arguments
92 but the Linux kernel gets up to seven arguments in registers.
95 args: a1(r0), a2(r1), a3(r2), a4(r3), a5(r4), a6(r5),
97 serr: (sret >= (unsigned)-EMAXERRNO)
102 #define __sysc_max_err 125
103 #define __sysc_reg_res "r0"
104 #define __sysc_cmd_sys "swi %0"
106 #define __sysc_reg(n) __arg_##n\
107 ("r0", "r1", "r2", "r3", "r4", "r5")
109 #define __sysc_clobber __sysc_regs, "memory"
111 #warning syscall arch arm not tested yet
115 /* *****************************************
116 CRIS CRIS CRIS CRIS *
117 cris v10 kernel interface */
119 #elif defined(__cris__)
121 /* The Cris calling convention uses stack args after four arguments
122 but the Linux kernel gets up to six arguments in registers.
125 args: a1(r10), a2(r11), a3(r12), a4(r13), a5(mof), a6(srp),
127 serr: (sret >= (unsigned)-EMAXERRNO)
132 #define __sysc_max_err 125
133 #define __sysc_reg_cid "r9"
134 #define __sysc_reg_res "r0"
135 #define __sysc_cmd_sys "break 13"
137 #define __sysc_regs "r10", "r11", "r12", "r13"
138 #define __sysc_reg(n) __arg_##n\
139 ("r10", "r11", "r12", "r13", "r0", "srp")
141 #define __sysc_pre(n) __casm(n,5,0,"move r0,mof",)
143 #define __sysc_clobber __sysc_regs, "memory"
145 #warning syscall arch cris not tested yet
149 /* *****************************************
151 frv kernel interface */
153 #elif defined(__frv__)
155 /* The C calling convention on FR-V uses the gr8-gr13 registers
156 for the first six arguments, the remainder is spilled onto the
157 stack. the linux kernel syscall interface does so too.
160 args: a1(gr8), a2(gr9), a3(gr10), a4(gr11), a5(gr12), a6(gr13)
162 serr: (sret >= (unsigned)-EMAXERRNO)
167 #define __sysc_max_err 125
168 #define __sysc_reg_cid "gr7"
169 #define __sysc_reg_res "gr8"
170 #define __sysc_cmd_sys "tira gr0,#0"
172 #define __sysc_reg(n) __arg_##n\
173 ("gr8", "gr9", "gr10", "gr11", "gr12", "gr13")
175 #define __sysc_clobber __sysc_regs, "memory"
177 #warning syscall arch frv not tested yet
181 /* *****************************************
182 H8300 H8300 H8300 H8300 *
183 h8/300 kernel interface */
185 #elif defined(__H8300__)
187 /* The H8/300 C calling convention passes the first three
188 arguments in registers. However the linux kernel calling
189 convention passes the first six arguments in registers
193 args: a1(er1), a2(er2), a3(er3), a4(er4), a5(er5), a6(er6)
195 serr: (sret >= (unsigned)-EMAXERRNO)
200 #define __sysc_max_err 125
201 #define __sysc_reg_res "er0"
203 #define __sysc_reg(n) __arg_##n\
204 ("er1", "er2", "er3", "er4", "er5", "er6")
206 #define __sysc_clobber "memory"
208 #define __sc_asmload(n,N,...) __sc_asm ( \
209 __casm(n,1,1, "mov.l %0,er1" , )\
210 __casm(n,2,1, "mov.l %1,er2" , )\
211 __casm(n,3,1, "mov.l %2,er3" , )\
212 __casm(n,4,1, "mov.l %3,er4" , )\
213 __casm(n,5,1, "mov.l %4,er5" , )\
214 __casm(n,6,1, "mov.l er6,@-sp" , )\
215 __casm(n,6,1, "mov.l %5,er6" , )\
216 ""::__sc_iregs(n,__VA_ARGS__):__sysc_regs)
218 #define __sysc_cmd_pre "mov.l %0,er0"
219 #define __sysc_cmd_sys "trapa #0"
220 #define __sysc_fin(n) __casm(n,6,0,"mov.l @sp+,er6",)
222 #warning syscall arch h8300 not tested yet
226 /* *****************************************
227 HPPA HPPA HPPA HPPA *
228 hppa/64 kernel interface */
230 #elif defined(__hppa__)
232 /* The hppa calling convention uses r26-r23 for the first 4
233 arguments, the rest is spilled onto the stack. However the
234 Linux kernel passes the first six arguments in the registers
237 The system call number MUST ALWAYS be loaded in the delay
238 slot of the ble instruction, or restarting system calls
242 args: a1(r26), a2(r25), a3(r24), a4(r23), a5(r22), a6(r21)
244 serr: (sret >= (unsigned)-EMAXERRNO)
245 call: ble 0x100(%%sr2, %%r0)
246 clob: r1, r2, r4, r20, r29, r31, memory
249 #define __sysc_max_err 4095
250 #define __sysc_reg_res "r28"
252 #define __sysc_reg(n) __arg_##n\
253 ("r26", "r25", "r24", "r23", "r22", "r21")
255 #define __sysc_cmd_sys "ble 0x100(%%sr2,%%r0)"
256 #define __sysc_cmd_fin "ldi %0,%%r20"
258 #define __sysc_clobber __sysc_regs, \
259 "r1", "r2", "r4", "r20", "r29", "r31", "memory"
261 #warning syscall arch hppa not tested yet
265 /* *****************************************
266 I386 I386 I386 I386 *
267 i386 kernel interface */
269 #elif defined(__i386__)
271 /* The x86 calling convention uses stack args for all arguments,
272 but the Linux kernel passes the first six arguments in the
273 following registers: ebx, ecx, edx, esi, edi, ebp.
276 args: a1(ebx), a2(ecx), a3(edx), a4(esi), a5(edi), a6(ebp)
278 serr: (sret >= (unsigned)-EMAXERRNO)
283 #define __sysc_max_err 129
284 #define __sysc_reg_res "eax"
285 #define __sysc_cmd_sys "int $0x80"
288 #define __sysc_regs "ebx", "ecx", "edx", "esi", "edi"
290 #define __sysc_regs "ecx", "edx", "esi", "edi"
293 #define __sc_asmload(n,N,...) __sc_asm ( \
294 __casm(n,6,1, "movl %5,%%eax" , )\
295 __casm(n,5,1, "movl %4,%%edi" , )\
296 __casm(n,4,1, "movl %3,%%esi" , )\
297 __casm(n,3,1, "movl %2,%%edx" , )\
298 __casm(n,2,1, "movl %1,%%ecx" , )\
299 __pasm(n,1,1, "pushl %%ebx" , )\
300 __casm(n,1,1, "movl %0,%%ebx" , )\
301 __casm(n,6,1, "pushl %%ebp" , )\
302 ""::__sc_iregs(n,__VA_ARGS__):__sysc_clobber)
304 #define __sysc_pre(n) \
305 __casm(n,6,1, "movl %%eax,%%ebp" , )\
306 __casm(n,0,1, "movl %0,%%eax" , )\
308 #define __sysc_fin(n) \
309 __casm(n,6,1, "popl %%ebp" , )\
310 __pasm(n,1,1, "popl %%ebx" , )\
312 #define __sysc_clobber __sysc_regs, "eax", "memory"
315 /* *****************************************
316 IA64 IA64 IA64 IA64 *
317 ia64 kernel interface */
319 #elif defined(__ia64__)
321 /* The ia64 calling convention uses out0-out7 to pass the first
322 eight arguments (mapped via register windows).
325 args: a1(out0), a2(out1), ... a5(out4), a6(out5)
329 clob: out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
333 #define __sysc_reg_ret "r8"
334 #define __sysc_reg_err "r10"
335 #define __sysc_reg_cid "r15"
336 #define __sysc_cmd_sys "break.i 0x100000"
338 #define __sysc_errc(r,e) ((e) == -1)
340 #define __sysc_reg(n) __arg_##n\
341 ("out0", "out1", "out2", "out3", "out4", "out5")
343 #define __sysc_clobber __sysc_regs, \
344 "out6", "out7", "r2", "r3", "r9", "r11", "r12", "r13", \
345 "r14", "r16", "r17", "r18", "r19", "r20", "r21", "r22", \
346 "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", \
347 "r31", "p6", "p7", "p8", "p9", "p10", "p11", "p12", "p13", \
348 "p14", "p15", "f6", "f7", "f8", "f9", "f10", "f11", "f12", \
349 "f13", "f14", "f15", "f16", "b6", "b7", "cc", "memory"
351 #warning syscall arch ia64 not tested yet
355 /* *****************************************
356 M32R M32R M32R M32R *
357 m32r kernel interface */
359 #elif defined(__M32R__)
361 /* The m32r calling convention uses r0-r7 to pass the first
362 eight arguments (mapped via register windows).
365 args: a1(r1), a2(r2), a3(r3), a4(r4), a5(r5), a6(r6)
367 serr: (sret >= (unsigned)-EMAXERRNO)
369 clob: out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
372 #define __sysc_max_err 125
373 #define __sysc_reg_cid "r7"
374 #define __sysc_reg_res "r0"
375 #define __sysc_cmd_sys "trap #2"
377 #define __sysc_reg(n) __arg_##n\
378 ("r0", "r1", "r2", "r3", "r4", "r5")
380 #define __sysc_clobber __sysc_regs, "memory"
382 #warning syscall arch m32r not tested yet
386 /* *****************************************
387 M68K M68K M68K M68K *
388 m68k kernel interface */
390 #elif defined(__m68000__)
392 #error syscall arch m68k not implemented yet
396 /* *****************************************
397 MIPS MIPS MIPS MIPS *
398 mips kernel interface */
400 #elif defined(__mips__)
402 #error syscall arch mips not implemented yet
406 /* *****************************************
408 ppc/64 kernel interface */
410 #elif defined(__powerpc__)
412 /* The powerpc calling convention uses r3-r10 to pass the first
413 eight arguments, the remainder is spilled onto the stack.
416 args: a1(r3), a2(r4), a3(r5), a4(r6), a5(r7), a6(r8)
424 #define __sysc_reg_cid "r0"
425 #define __sysc_reg_ret "r3"
426 #define __sysc_reg_err "r0"
428 #define __sysc_errc(r,e) ((e) & 0x10000000)
430 #define __sysc_reg(n) __arg_##n\
431 ("r3", "r4", "r5", "r6", "r7", "r8")
433 #define __sysc_cmd_sys "sc"
434 #define __sysc_cmd_fin "mfcr 0"
436 #define __sysc_clobber __sysc_regs, \
437 "r9", "r10", "r11", "r12", "cr0", "ctr", "memory"
441 /* *****************************************
442 S390 S390 S390 S390 *
443 s390/x kernel interface */
445 #elif defined(__s390__)
447 /* The s390x calling convention passes the first five arguments
448 in r2-r6, the remainder is spilled onto the stack. However
449 the Linux kernel passes the first six arguments in r2-r7.
452 args: a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
454 serr: (sret >= (unsigned)-EMAXERRNO)
459 #define __sysc_max_err 4095
460 #define __sysc_reg_cid "r1"
461 #define __sysc_reg_res "r2"
462 #define __sysc_cmd_sys "svc 0"
464 #define __sysc_regtyp unsigned long
466 #define __sysc_reg(n) __arg_##n\
467 ("r2", "r3", "r4", "r5", "r6", "r7")
469 #define __sysc_clobber __sysc_regs, "memory"
473 /* *****************************************
475 sh kernel interface */
477 #elif defined(__sh__) && !defined(__SH5__)
479 /* The SuperH calling convention passes the first four arguments
480 in r4-r7, the remainder is spilled onto the stack. However
481 the Linux kernel passes the remainder in r0-r2.
484 args: a1(r4), a2(r5), a3(r6), a4(r7), a5(r0), a6(r1)
486 serr: (sret >= (unsigned)-EMAXERRNO)
487 call: trapa #0x1x (x=#args)
491 #define __sysc_max_err 4095
492 #define __sysc_reg_cid "r3"
493 #define __sysc_reg_res "r0"
495 #define __sysc_reg(n) __arg_##n\
496 ("r4", "r5", "r6", "r7", "r0", "r1")
498 #define __sysc_cmd(n) "trapa #0x1" __stringify(n)
500 #define __rep_6(x) x x x x x x
501 #define __sysc_cmd_fin __rep_6("or r0,r0\n\t")
503 #define __sysc_clobber __sysc_regs, "memory"
505 #warning syscall arch sh not tested yet
509 /* *****************************************
510 SH64 SH64 SH64 SH64 *
511 sh64 kernel interface */
513 #elif defined(__sh__) && defined(__SH5__)
515 /* The SuperH-5 calling convention passes the first eight
519 args: a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
521 serr: (sret >= (unsigned)-EMAXERRNO)
522 call: trapa #0x1x (x=#args)
526 #define __sysc_max_err 4095
527 #define __sysc_reg_res "r9"
528 #define __sysc_cmd_sys "trapa r9"
530 #define __sysc_reg(n) __arg_##n\
531 ("r2", "r3", "r4", "r5", "r6", "r7")
533 #define __sc_asmsysc(n,N) __sc_asm_vol ( \
534 __casm(n,0,1, "movi %0,r9" , )\
535 __casm(n,0,1, __sc_cmds(n,N) , )\
536 ""::"i"(__sc_id(N) | 0x1##n << 16) : __sysc_clobber)
538 #define __sysc_clobber __sysc_regs, "memory"
540 #warning syscall arch sh64 not tested yet
544 /* *****************************************
545 SPARC64 SPARC64 SPARC64 SPARC64 *
546 sparc64 kernel interface */
548 #elif defined(__sparc__)
550 /* The sparc/64 calling convention uses o0-o5 to pass the first
551 six arguments (mapped via register windows).
554 args: a1(o0), a2(o1), a3(o2), a4(o3), a5(o4), a6(o5)
557 call: ta 0x6d, t 0x10
558 clob: g1-g6, g7?, o7?, f0-f31, cc
561 #define __sysc_max_err 515
562 #define __sysc_reg_cid "g1"
563 #define __sysc_reg_ret "o0"
564 #define __sysc_reg_err "l1"
566 #define __sysc_reg(n) __arg_##n\
567 ("o0", "o1", "o2", "o3", "o4", "o5")
570 #define __sysc_cmd_sys "ta 0x6d"
572 #define __sysc_cmd_sys "t 0x10"
575 #define __sysc_cmd_fin "addx %%g0,%%g0,%%l1"
578 #define __sysc_clobber __sysc_regs, \
579 "g2", "g3", "g4", "g5", "g6", \
580 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", \
581 "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", \
582 "f17", "f18", "f19", "f20", "f21", "f22", "f23", "f24", \
583 "f25", "f26", "f27", "f28", "f29", "f30", "f31", "f32", \
584 "f34", "f36", "f38", "f40", "f42", "f44", "f46", "f48", \
585 "f50", "f52", "f54", "f56", "f58", "f60", "f62", \
588 #warning syscall arch sparc not tested yet
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
611 #define __sysc_reg_cid "r12"
612 #define __sysc_reg_res "r10"
614 #define __sysc_reg(n) __arg_##n\
615 ("r6", "r7", "r8", "r9", "r13", "r14")
617 #define __sysc_cmd(n) __casm(n,4,0,"trap 1","trap 0")
619 #define __sysc_clobber __sysc_regs, \
620 "r1", "r5", "r11", "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
644 #define __sysc_reg_cid "rax"
645 #define __sysc_reg_res "rax"
646 #define __sysc_cmd_sys "syscall"
648 #define __sysc_reg(n) __arg_##n\
649 ("rdi", "rsi", "rdx", "r10", "r8", "r9")
651 #define __sysc_clobber __sysc_regs, \
652 "cc", "r11", "rcx", "memory"
656 #error unknown kernel arch
665 #define __lst_6(x,a1,a2,a3,a4,a5,a6) __lst_5(x,a1,a2,a3,a4,a5),x(6,a6)
666 #define __lst_5(x,a1,a2,a3,a4,a5) __lst_4(x,a1,a2,a3,a4),x(5,a5)
667 #define __lst_4(x,a1,a2,a3,a4) __lst_3(x,a1,a2,a3),x(4,a4)
668 #define __lst_3(x,a1,a2,a3) __lst_2(x,a1,a2),x(3,a3)
669 #define __lst_2(x,a1,a2) __lst_1(x,a1),x(2,a2)
670 #define __lst_1(x,a1) __lst_0(x,*)x(1,a1)
671 #define __lst_0(x,a0)
673 /* argument concat */
675 #define __con_6(x,a1,a2,a3,a4,a5,a6) __con_5(x,a1,a2,a3,a4,a5)x(6,a6)
676 #define __con_5(x,a1,a2,a3,a4,a5) __con_4(x,a1,a2,a3,a4)x(5,a5)
677 #define __con_4(x,a1,a2,a3,a4) __con_3(x,a1,a2,a3)x(4,a4)
678 #define __con_3(x,a1,a2,a3) __con_2(x,a1,a2)x(3,a3)
679 #define __con_2(x,a1,a2) __con_1(x,a1)x(2,a2)
680 #define __con_1(x,a1) __con_0(x,*)x(1,a1)
681 #define __con_0(x,a0)
683 /* argument selection */
686 #define __arg_1(a1,...) a1
687 #define __arg_2(a1,a2,...) a2
688 #define __arg_3(a1,a2,a3,...) a3
689 #define __arg_4(a1,a2,a3,a4,...) a4
690 #define __arg_5(a1,a2,a3,a4,a5,...) a5
691 #define __arg_6(a1,a2,a3,a4,a5,a6) a6
703 #define __casm_nl(v) v "\n\t"
705 #define __casm(n,a,r,v,w) __casm_##n##a(v,w,r)
707 #define __pasm(n,a,r,v,w) __pic(__casm(n,a,r,v,w))
708 #define __Pasm(n,a,r,v,w) __nopic(__casm(n,a,r,v,w))
710 #define __casm_use(q,r,v) v __casm_use_##q##r(__casm_nl(""))
712 #define __casm_use_10(v)
713 #define __casm_use_11(v) v
714 #define __casm_use_12(v)
715 #define __casm_use_13(v) v
717 #define __casm_use_20(v)
718 #define __casm_use_21(v)
719 #define __casm_use_22(v) v
720 #define __casm_use_23(v) v
723 #define __casm_00(v,w,r) __casm_use(1,r,v)
724 #define __casm_01(v,w,r) __casm_use(2,r,w)
725 #define __casm_02(v,w,r) __casm_use(2,r,w)
726 #define __casm_03(v,w,r) __casm_use(2,r,w)
727 #define __casm_04(v,w,r) __casm_use(2,r,w)
728 #define __casm_05(v,w,r) __casm_use(2,r,w)
729 #define __casm_06(v,w,r) __casm_use(2,r,w)
731 #define __casm_10(v,w,r) __casm_use(1,r,v)
732 #define __casm_11(v,w,r) __casm_use(1,r,v)
733 #define __casm_12(v,w,r) __casm_use(2,r,w)
734 #define __casm_13(v,w,r) __casm_use(2,r,w)
735 #define __casm_14(v,w,r) __casm_use(2,r,w)
736 #define __casm_15(v,w,r) __casm_use(2,r,w)
737 #define __casm_16(v,w,r) __casm_use(2,r,w)
739 #define __casm_20(v,w,r) __casm_use(1,r,v)
740 #define __casm_21(v,w,r) __casm_use(1,r,v)
741 #define __casm_22(v,w,r) __casm_use(1,r,v)
742 #define __casm_23(v,w,r) __casm_use(2,r,w)
743 #define __casm_24(v,w,r) __casm_use(2,r,w)
744 #define __casm_25(v,w,r) __casm_use(2,r,w)
745 #define __casm_26(v,w,r) __casm_use(2,r,w)
747 #define __casm_30(v,w,r) __casm_use(1,r,v)
748 #define __casm_31(v,w,r) __casm_use(1,r,v)
749 #define __casm_32(v,w,r) __casm_use(1,r,v)
750 #define __casm_33(v,w,r) __casm_use(1,r,v)
751 #define __casm_34(v,w,r) __casm_use(2,r,w)
752 #define __casm_35(v,w,r) __casm_use(2,r,w)
753 #define __casm_36(v,w,r) __casm_use(2,r,w)
755 #define __casm_40(v,w,r) __casm_use(1,r,v)
756 #define __casm_41(v,w,r) __casm_use(1,r,v)
757 #define __casm_42(v,w,r) __casm_use(1,r,v)
758 #define __casm_43(v,w,r) __casm_use(1,r,v)
759 #define __casm_44(v,w,r) __casm_use(1,r,v)
760 #define __casm_45(v,w,r) __casm_use(2,r,w)
761 #define __casm_46(v,w,r) __casm_use(2,r,w)
763 #define __casm_50(v,w,r) __casm_use(1,r,v)
764 #define __casm_51(v,w,r) __casm_use(1,r,v)
765 #define __casm_52(v,w,r) __casm_use(1,r,v)
766 #define __casm_53(v,w,r) __casm_use(1,r,v)
767 #define __casm_54(v,w,r) __casm_use(1,r,v)
768 #define __casm_55(v,w,r) __casm_use(1,r,v)
769 #define __casm_56(v,w,r) __casm_use(2,r,w)
771 #define __casm_60(v,w,r) __casm_use(1,r,v)
772 #define __casm_61(v,w,r) __casm_use(1,r,v)
773 #define __casm_62(v,w,r) __casm_use(1,r,v)
774 #define __casm_63(v,w,r) __casm_use(1,r,v)
775 #define __casm_64(v,w,r) __casm_use(1,r,v)
776 #define __casm_65(v,w,r) __casm_use(1,r,v)
777 #define __casm_66(v,w,r) __casm_use(1,r,v)
780 #define __casm_cn_1 ,
781 #define __casm_cn_2 ,
782 #define __casm_cn_3 ,
783 #define __casm_cn_4 ,
784 #define __casm_cn_5 ,
785 #define __casm_cn_6 ,
789 #define __sc_asm __asm__
790 #define __sc_asm_vol __asm__ __volatile__
792 #ifndef __sysc_setret
793 #define __sysc_setret(v) do { } while(0)
796 #ifndef __sysc_seterr
797 #define __sysc_seterr(e) do { errno = (e); } while(0)
801 #define __stringify0(val) #val
805 #define __stringify(val) __stringify0(val)
809 #if !defined(__sysc_load) && !defined(__sysc_save)
810 #if !defined(__sysc_limm) && !defined(__sc_asmload)
815 #if defined(__sysc_reg_ret) && defined(__sysc_reg_err)
821 #define __sysc_type long
824 #define __sc_cast(v) (__sysc_type)(v)
827 #define __sc_reg(n) register __sysc_type n
828 #define __sc_asm_reg(n,r) register __sysc_type n __sc_asm (r)
829 #define __sc_asm_val(n,r,v) __sc_asm_reg(n,r) = __sc_cast(v)
832 #define __sc_inp_def(n,v) __sc_asm_val(__sc_a##n, __sysc_reg(n), v);
834 #define __sc_inp_def(n,value)
838 #define __sc_res_def(n,r) __sc_asm_reg(n, r);
840 #define __sc_res_def(n,r) __sc_reg(n);
844 #define __sc_rreg(n,v) "r"(__sc_a##n)
845 #define __sc_creg(n,v) __sysc_rcon(n)(__sc_cast(v))
848 #define __sc_iregs(n,...) __lst_##n(__sc_rreg,__VA_ARGS__)
849 #define __sc_input(n,...) __con_##n(__sc_inp_def,__VA_ARGS__)
851 #define __sc_iregs(n,...) __lst_##n(__sc_creg,__VA_ARGS__)
852 #define __sc_input(n,...)
857 #define __sc_list(x) x(1), x(2), x(3), x(4), x(5), x(6)
860 #define __sysc_regs __sc_list(__sysc_reg)
864 #define __sysc_rcon(n) "g"
869 #ifdef __sc_complex /* complex result */
872 #define __sysc_errc(ret, err) (err)
876 #define __sysc_retv(type, ret, err) \
877 __sysc_setret(ret); \
878 if (__sysc_errc(ret, err)) { \
880 __sysc_seterr(__err); \
886 #define __sc_results \
887 __sc_res_def(__err, __sysc_reg_err) \
888 __sc_res_def(__ret, __sysc_reg_ret)
890 #define __sc_oregs "=r"(__ret), "=r"(__err)
892 #if defined(__sc_trust) || !defined(__sysc_save)
893 #define __sc_saveres __sc_dummy_save(1)
895 #define __sc_saveres \
896 __casm_nl(__sysc_save(__sysc_reg_ret,"%0")) \
897 __casm_nl(__sysc_save(__sysc_reg_err,"%1"))
900 #define __sc_return(t) __sysc_retv(t, __ret, __err)
902 #else /* simple result */
905 #define __sysc_errc(res) \
906 ((unsigned __sysc_type)(res) >= \
907 (unsigned __sysc_type)(-(__sysc_max_err)))
911 #define __sysc_retv(type, res) \
912 __sysc_setret(res); \
913 if (__sysc_errc(res)) { \
914 int __err = -(res); \
915 __sysc_seterr(__err); \
921 #define __sc_results \
922 __sc_res_def(__res, __sysc_reg_res)
924 #define __sc_oregs "=r"(__res)
926 #if defined(__sc_trust) || !defined(__sysc_save)
927 #define __sc_saveres __sc_dummy_save(0)
929 #define __sc_saveres __casm_nl(__sysc_save(__sysc_reg_res,"%0"))
932 #define __sc_return(t) __sysc_retv(t, __res)
934 #endif /* simple/complex */
937 #define __sc_dummy_load(n) "/* gcc dummy load " \
938 __casm(n,0,0,"%0 ",) __casm(n,1,0,"%1 ",) __casm(n,2,0,"%2 ",) \
939 __casm(n,3,0,"%3 ",) __casm(n,4,0,"%4 ",) __casm(n,5,0,"%5 ",) \
940 __casm(n,6,0,"%6 ",) "*/"
942 #define __sc_dummy_save(n) "/* gcc dummy save " \
943 __casm(n,0,0,"%0 ",) __casm(n,1,0,"%1 ",) "*/"
945 #define __comment(name) "\t/* kernel sys_" \
946 #name "[" __stringify(__sc_id(name)) "] */"
949 #define __sc_id(N) __NR_##N
951 #ifndef __sysc_reg_cid
952 #define __sc_cid(N) "i"(__sc_id(N))
953 #define __sc_load_cid ""
954 #define __sc_callid(N)
956 #define __sc_cid(N) "r"(__cid)
957 #define __sc_load_cid __sysc_limm(__sysc_reg_cid,"%0")
958 #define __sc_callid(N) \
959 __sc_asm_val(__cid, __sysc_reg_cid, __sc_id(N));
962 #ifndef __sysc_cmd_pre
963 #define __sc_cmd_pre ""
965 #define __sc_cmd_pre __casm_nl(__sysc_cmd_pre)
968 #ifndef __sysc_cmd_fin
969 #define __sc_cmd_fin ""
971 #define __sc_cmd_fin __sysc_cmd_fin
975 #define __sysc_pre(n) __sc_cmd_pre
979 #define __sysc_cmd(n) __sysc_cmd_sys
983 #define __sysc_fin(n) __sc_cmd_fin
986 #define __sc_cmds(n,name) \
988 __casm_nl(__sysc_cmd(n) __comment(name)) \
993 #define __sc_asmload(n,N,...) __sc_asm( \
995 ::__sc_cid(N) __casm_cn_##n __sc_iregs(n,__VA_ARGS__))
997 #define __sc_asmload(n,N,...) __sc_asm( \
998 __casm(n,1,1, __sysc_load(__sysc_reg(1),"%1"), )\
999 __casm(n,2,1, __sysc_load(__sysc_reg(2),"%2"), )\
1000 __casm(n,3,1, __sysc_load(__sysc_reg(3),"%3"), )\
1001 __casm(n,4,1, __sysc_load(__sysc_reg(4),"%4"), )\
1002 __casm(n,5,1, __sysc_load(__sysc_reg(5),"%5"), )\
1003 __casm(n,6,1, __sysc_load(__sysc_reg(6),"%6"), )\
1004 __sc_load_cid ::__sc_cid(N) __casm_cn_##n \
1005 __sc_iregs(n,__VA_ARGS__):__sysc_regs)
1009 #ifndef __sc_asmsysc
1010 #define __sc_asmsysc(n,N) __sc_asm_vol( \
1011 __casm(n,0,0, __sc_cmds(n,N) , )\
1012 ::"i"(__sc_id(N)) : __sysc_clobber)
1015 #ifndef __sc_asmsave
1016 #define __sc_asmsave(n) __sc_asm( \
1017 __sc_saveres :__sc_oregs)
1023 #define __sc_body(n, type, name, ...) \
1025 __sc_results __sc_callid(name) __sc_input(n, __VA_ARGS__) \
1026 __sc_asmload(n, name, __VA_ARGS__); \
1027 __sc_asmsysc(n, name); \
1029 __sc_return(type); \
1034 #define _syscall0(type, name) \
1036 __sc_body(0, type, name, *)
1038 #define _syscall1(type, name, type1, arg1) \
1039 type name(type1 arg1) \
1040 __sc_body(1, type, name, arg1)
1042 #define _syscall2(type, name, type1, arg1, type2, arg2) \
1043 type name(type1 arg1, type2 arg2) \
1044 __sc_body(2, type, name, arg1, arg2)
1046 #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
1047 type name(type1 arg1, type2 arg2, type3 arg3) \
1048 __sc_body(3, type, name, arg1, arg2, arg3)
1050 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
1052 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
1053 __sc_body(4, type, name, arg1, arg2, arg3, arg4)
1055 #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
1056 type4, arg4, type5, arg5) \
1057 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \
1058 __sc_body(5, type, name, arg1, arg2, arg3, arg4, arg5)
1060 #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
1061 type4, arg4, type5, arg5, type6, arg6) \
1062 type name(type1 arg1, type2 arg2, type3 arg3, \
1063 type4 arg4, type5 arg5, type6 arg6) \
1064 __sc_body(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6)
1067 #endif /* __SYSCALL_NEW_H */