Update to latest shiny.
[util-vserver.git] / lib / syscall-alternative.h
1  // from http://vserver.13thfloor.at/Experimental/SYSCALL/syscall_shiny16.h
2
3 #ifndef __SYSCALL_NEW_H
4 #define __SYSCALL_NEW_H
5
6 /*      Copyright (C) 2005-2007 Herbert Pƶtzl
7
8                 global config options
9
10         __sysc_seterr   ... set error value (def: errno)
11         __sysc_cid(N)   ... syscall 'name' id (def: __NR_<N>)
12
13                 arch specific config
14
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)
20
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)
25
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")
31
32                 hard core replacements
33
34         __sc_body(n,type,name,...)
35           __sc_results
36           __sc_cidvar(N)
37           __sc_input(n,...)
38           __sc_syscall(n,N,...)
39           __sc_return(t)
40
41 */
42
43         /* some fallback defaults */
44
45 #ifndef __sysc_seterr
46 #define __sysc_seterr(e)        do { errno = (e); } while(0)
47 #endif
48
49 #ifndef __sysc_cid
50 #define __sysc_cid(N)           __NR_##N
51 #endif
52
53
54 /*      *****************************************
55         ALPHA   ALPHA   ALPHA   ALPHA           *
56         alpha kernel interface                  */
57
58 #if     defined(__alpha__)
59
60 /*      The Alpha calling convention doesn't use the stack until
61         after the first six arguments have been passed in registers.
62
63         scnr:   v0($0)
64         args:   a1($16), a2($17), a3($18), a4($19), a5($20), a6($21)
65         sret:   r0($0)
66         serr:   e0($19) (!=0, err=sret)
67         call:   callsys
68         clob:   memory
69         move:   mov $sR,$dR
70         picr:   pr($29) do we need to save that?
71 */
72
73 #define __sysc_cmd(n)   "callsys"
74
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"
80
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"
85
86
87 /*      *****************************************
88         ARM     ARM     ARM     ARM             *
89         arm kernel interface                    */
90
91 #elif   defined(__arm__)
92
93 /*      The Arm calling convention uses stack args after four arguments
94         but the Linux kernel gets up to seven arguments in registers.
95         
96         scnr:   imm
97         args:   a1(r0), a2(r1), a3(r2), a4(r3), a5(r4), a6(r5),
98         sret:   r0(r0)
99         serr:   (sret >= (unsigned)-EMAXERRNO)
100         call:   swi
101         clob:   memory
102         move:   mov $dR,$sR
103 */
104
105 #define __sysc_max_err  125
106
107 #define __sysc_cmd(n)   "swi    %1"
108
109 #define __sysc_regs     "r0", "r1", "r2", "r3", "r4", "r5"
110 #define __sysc_reg_ret  "r0"
111
112 #warning syscall arch arm not tested yet
113
114
115
116 /*      *****************************************
117         CRIS    CRIS    CRIS    CRIS            *
118         cris v10 kernel interface               */
119
120 #elif   defined(__cris__)
121
122 /*      The Cris calling convention uses stack args after four arguments
123         but the Linux kernel gets up to six arguments in registers.
124
125         scnr:   id(r9)
126         args:   a1(r10), a2(r11), a3(r12), a4(r13), a5(mof), a6(srp),
127         sret:   r0(r10)
128         serr:   (sret >= (unsigned)-EMAXERRNO)
129         call:   break 13
130         clob:   memory
131 */
132
133 #error syscall arch cris not implemented yet
134
135
136
137 /*      *****************************************
138         FRV     FRV     FRV     FRV             *
139         frv kernel interface            */
140
141 #elif   defined(__frv__)
142
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.
146         
147         scnr:   id(gr7)
148         args:   a1(gr8), a2(gr9), a3(gr10), a4(gr11), a5(gr12), a6(gr13)
149         sret:   r0(gr8)
150         serr:   (sret >= (unsigned)-EMAXERRNO)
151         call:   tra gr0,gr0
152         clob:   memory
153 */
154
155 #error syscall arch frv not implemented yet
156
157
158
159 /*      *****************************************
160         H8300   H8300   H8300   H8300           *
161         h8/300 kernel interface                 */
162
163 #elif   defined(__H8300__)
164
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
168         er1-er6
169
170         scnr:   id(er0)
171         args:   a1(er1), a2(er2), a3(er3), a4(er4), a5(er5), a6(er6)
172         sret:   r0(er0)
173         serr:   (sret >= (unsigned)-EMAXERRNO)
174         call:   trapa #0
175         clob:   memory
176 */
177
178 #error syscall arch h8300 not implemented yet
179
180
181
182 /*      *****************************************
183         HPPA    HPPA    HPPA    HPPA            *
184         hppa/64 kernel interface                */
185
186 #elif   defined(__hppa__)
187
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
191         r26-r21.
192
193         The system call number MUST ALWAYS be loaded in the delay
194         slot of the ble instruction, or restarting system calls
195         WILL NOT WORK.
196
197         scnr:   id(r20)
198         args:   a1(r26), a2(r25), a3(r24), a4(r23), a5(r22), a6(r21)
199         sret:   r0(r28)
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?
204 */
205
206 #define __sysc_max_err  4095
207
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"      ,)
213
214 #define __sysc_regs     "r26", "r25", "r24", "r23", "r22", "r21"
215
216 #ifndef __PIC__
217 #define __sysc_clobber  "r1", "r2", "r20", "r29", "r31", "memory"
218 #else
219 #define __sysc_clobber  "r1", "r2", "r4", "r20", "r29", "r31", "memory"
220 #endif
221
222 #warning syscall arch hppa not tested yet
223
224
225
226 /*      *****************************************
227         I386    I386    I386    I386            *
228         i386 kernel interface                   */
229
230 #elif   defined(__i386__)
231
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.
235         
236         scnr:   id(eax)
237         args:   a1(ebx), a2(ecx), a3(edx), a4(esi), a5(edi), a6(ebp) 
238         sret:   r0(eax)
239         serr:   (sret >= (unsigned)-EMAXERRNO)
240         call:   int 0x80
241         picr:   pr(ebx)
242         clob:   memory
243         move:   movl $sR,$dR
244 */
245
246 #define __sysc_max_err  129
247
248 #define __sc_reg1(...) __sc_cast(__arg_1(__VA_ARGS__,,,,,,))
249 #define __sc_reg6(...) __sc_cast(__arg_6(__VA_ARGS__,,,,,,))
250
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__);
255
256 #define __sc_input(n,...) __casm(n,6,0,         \
257         __scsd; __scsa(n,__VA_ARGS__),  )
258
259 #define __cm    ,
260 #define __sc_null(n)    __arg_##n(              \
261         __cm,__cm,__cm,__cm,__cm,__cm)
262
263 #define __sc_rvcs(r,v)  r (__sc_cast(v))
264
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),)
270
271 #define __sc_arg1(n,...) __Casm(n,1,6,0,,       \
272         __sc_rvcs("ri", __sc_reg1(__VA_ARGS__)),\
273         __sc_rvcs("0", &__scs))
274
275 #define __sc_syscall(n,N,...) \
276         __sc_asm_vol (__sysc_cmd(n)             \
277           : __sc_oregs                          \
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"))
282
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"          ,)
293
294 #define __sysc_reg_ret  "eax"
295 #define __sysc_con_ret  "=a"
296
297
298
299 /*      *****************************************
300         IA64    IA64    IA64    IA64            *
301         ia64 kernel interface                   */
302
303 #elif   defined(__ia64__)
304
305 /*      The ia64 calling convention uses out0-out7 to pass the first
306         eight arguments (mapped via register windows).
307
308         scnr:   id(r15)
309         args:   a1(out0), a2(out1), ... a5(out4), a6(out5)
310         sret:   r0(r8)
311         serr:   e0(r10)
312         call:   break 0x100000
313         clob:   out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
314         move:   mov %dR = %sR
315 */
316
317 #define __sysc_errc(r,e)        ((e) == -1)
318
319 #define __sysc_cmd(n)   "break.i 0x100000"
320
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"
325
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"
333
334 #warning syscall arch ia64 not tested yet
335
336
337
338 /*      *****************************************
339         M32R    M32R    M32R    M32R            *
340         m32r kernel interface                   */
341
342 #elif   defined(__M32R__)
343
344 /*      The m32r calling convention uses r0-r7 to pass the first
345         eight arguments (mapped via register windows).
346
347         scnr:   id(r0)
348         args:   a1(r1), a2(r2), a3(r3), a4(r4), a5(r5), a6(r6)
349         sret:   r0(r0)
350         serr:   (sret >= (unsigned)-EMAXERRNO)
351         call:   trap #2
352         clob:   out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7
353         move:   mv %dR,%sR
354 */
355
356 #define __sysc_max_err  125
357
358 #define __sysc_cmd(n)   "trap #2"
359
360 #define __sysc_regs     "r0", "r1", "r2", "r3", "r4", "r5"
361 #define __sysc_reg_cid  "r7"
362 #define __sysc_reg_ret  "r0"
363
364 #warning syscall arch m32r not tested yet
365
366
367
368 /*      *****************************************
369         M68K    M68K    M68K    M68K            *
370         m68k kernel interface                   */
371
372 #elif   defined(__m68000__)
373
374 #error syscall arch m68k not implemented yet
375
376
377
378 /*      *****************************************
379         MIPS    MIPS    MIPS    MIPS            *
380         mips kernel interface                   */
381
382 #elif   defined(__mips__)
383
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)
388
389         ABIN32 and ABI64 pass 6 args in a0-a3, t0-t1.
390
391         scnr:   id(v0)
392         args:   a1(a0), a2(a1), a3(a2), a4(a3), a5(t0), a6(t1)
393         sret:   r0(v0)
394         serr:   e0(a3)
395         call:   syscall
396         clob:   at, v1, t2-t7, t8-t9
397         move:   move    %dR,%sR
398 */
399
400 #define __sysc_cmd(n)   \
401         __casm(n,0,1,   "ori    $v0,$0,%2"      ,)\
402         __casm(n,0,1,   "syscall"               ,)
403
404 #define __sysc_regs     "a0","a1","a2","a3", "t0", "t1"
405 #define __sysc_reg_ret  "v0"
406 #define __sysc_reg_err  "a3"
407
408 #define __sysc_clobber  "$1", "$3", "$10", "$11", "$12",                \
409                         "$13", "$14", "$15", "$24", "$25", "memory"
410
411 #warning syscall arch mips not tested yet
412
413
414
415 /*      *****************************************
416         PPC     PPC     PPC     PPC             *
417         ppc/64 kernel interface                 */
418
419 #elif   defined(__powerpc__)
420
421 /*      The powerpc calling convention uses r3-r10 to pass the first
422         eight arguments, the remainder is spilled onto the stack.
423         
424         scnr:   id(r0)
425         args:   a1(r3), a2(r4), a3(r5), a4(r6), a5(r7), a6(r8)
426         sret:   r0(r3)
427         serr:   (carry)
428         call:   sc
429         clob:   r9-r12, cr0, ctr
430         move:   mr %dR,%sR
431 */
432
433 #define __sysc_errc(r,e)        ((e) & 0x10000000)
434
435 #define __sysc_cmd(n)   \
436         __casm(n,0,1,   "sc"                    ,)\
437         __casm(n,0,1,   "mfcr %1"               ,)
438
439 #define __sysc_regs     "r3", "r4", "r5", "r6", "r7", "r8"
440 #define __sysc_reg_cid  "r0"
441 #define __sysc_reg_ret  "r3"
442
443 #define __sysc_clobber  "r9", "r10", "r11", "r12", "cr0", "ctr", "memory"
444
445
446
447 /*      *****************************************
448         S390    S390    S390    S390            *
449         s390/x kernel interface                 */
450
451 #elif   defined(__s390__)
452
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.
456         
457         scnr:   imm, id(r1)
458         args:   a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
459         sret:   r0(r2)
460         serr:   (sret >= (unsigned)-EMAXERRNO)
461         call:   svc
462         clob:   memory
463 */
464
465 #define __sysc_max_err  4095
466
467 #define __sysc_cmd(n)   "svc    0"
468
469 // #define      __sysc_type     unsigned long
470
471 #define __sysc_regs     "r2", "r3", "r4", "r5", "r6", "r7"
472 #define __sysc_reg_cid  "r1"
473 #define __sysc_reg_ret  "r2"
474
475 #warning syscall arch s390 not tested yet
476
477
478
479 /*      *****************************************
480         SH      SH      SH      SH              *
481         sh kernel interface                     */
482
483 #elif   defined(__sh__) && !defined(__SH5__)
484
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.
488
489         scnr:   id(r3)
490         args:   a1(r4), a2(r5), a3(r6), a4(r7), a5(r0), a6(r1)
491         sret:   r0(r0)
492         serr:   (sret >= (unsigned)-EMAXERRNO)
493         call:   trapa #0x1x (x=#args)
494         clob:   memory
495         move:   ori     %sR,0,%dR
496 */
497
498 #ifdef  __sh2__
499 #define __sysc_arch     "trapa  #0x2"
500 #else
501 #define __sysc_arch     "trapa  #0x1"
502 #endif
503
504 #define __sysc_max_err  4095
505
506 #define __sysc_cmd(n)   __sysc_arch #n
507
508 #define __sysc_regs     "r4", "r5", "r6", "r7", "r0", "r1"
509 #define __sysc_reg_cid  "r3"
510 #define __sysc_reg_ret  "r0"
511
512 #warning syscall arch sh not tested yet
513
514
515
516 /*      *****************************************
517         SH64    SH64    SH64    SH64            *
518         sh64 kernel interface                   */
519
520 #elif defined(__sh__) && defined(__SH5__)
521
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.
525
526         scnr:   id(r9)
527         args:   a1(r2), a2(r3), a3(r4), a4(r5), a5(r6), a6(r7)
528         sret:   r0(r9)
529         serr:   (sret >= (unsigned)-EMAXERRNO)
530         call:   trapa #0x1x (x=#args)
531         clob:   memory
532         move:   ori     %sR,0,%dR
533 */
534
535 #define __sysc_max_err  4095
536
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"             ,)
541
542 #define __sysc_regs     "r2", "r3", "r4", "r5", "r6", "r7"
543 #define __sysc_reg_ret  "r9"
544
545 #warning syscall arch sh64 not tested yet
546
547
548
549 /*      *****************************************
550         SPARC64 SPARC64 SPARC64 SPARC64         *
551         sparc64 kernel interface                */
552
553 #elif   defined(__sparc__)
554
555 /*      The sparc/64 calling convention uses o0-o5 to pass the first
556         six arguments (mapped via register windows).
557
558         scnr:   id(g1)
559         args:   a1(o0), a2(o1), a3(o2), a4(o3), a5(o4), a6(o5)
560         sret:   r0(o0)
561         serr:   (carry)
562         call:   ta 0x6d, t 0x10
563         clob:   g1-g6, g7?, o7?, f0-f31, cc
564         move:   mov     %sR,%dR
565 */
566
567 #ifdef  __arch64__
568 #define __sysc_arch     "ta     0x6d"
569 #else
570 #define __sysc_arch     "ta     0x10"
571 #endif
572
573 #define __sysc_cmd(n)   \
574         __casm(n,0,1,   __sysc_arch             ,)\
575         __casm(n,0,1,   "addx   %%g0,%%g0,%1"   ,)
576
577 #define __sysc_regs     "o0", "o1", "o2", "o3", "o4", "o5"
578 #define __sysc_reg_cid  "g1"
579 #define __sysc_reg_ret  "o0"
580
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",                \
588         "cc", "memory"
589
590
591
592 /*      *****************************************
593         V850    V850    V850    V850            *
594         v850 kernel interface                   */
595
596 #elif   defined(__v850__)
597
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.
601
602         scnr:   id(r12)
603         args:   a1(r6), a2(r7), a3(r8), a4(r9), a5(r13), a6(r14)
604         sret:   r0(r10)
605         serr:   (sret >= (unsigned)-EMAXERRNO)
606         call:   trap 0, trap 1
607         clob:   r1, r5, r11, r15-r19
608 */
609
610 #define __sysc_max_err  515
611
612 #define __sysc_cmd(n)   \
613         __casm(n,4,0,   "trap 1"        ,"trap 0"       )
614
615 #define __sysc_regs     "r6", "r7", "r8", "r9", "r13", "r14"
616 #define __sysc_reg_cid  "r12"
617 #define __sysc_reg_ret  "r10"
618
619 #define __sysc_clobber  "r1", "r5", "r11",                              \
620                         "r15", "r16", "r17", "r18", "r19", "memory"
621
622 #warning syscall arch v850 not tested yet
623
624
625
626 /*      *****************************************
627         X86_64  X86_64  X86_64  X86_64          *
628         x86_64 kernel interface                 */
629
630 #elif   defined(__x86_64__)
631
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.
634         
635         scnr:   id(rax)
636         args:   a1(rdi), a2(rsi), a3(rdx), a4(r10), a5(r8), a6(r9)
637         sret:   r0(rax)
638         serr:   (err= sret > (unsigned)-EMAXERRNO)
639         call:   syscall
640         clob:   rcx, r11
641 */
642
643 #define __sysc_max_err  4095
644
645 #define __sysc_cmd(n)   "syscall"
646
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"
651
652 #define __sysc_clobber  "cc", "r11", "rcx", "memory"
653
654 #else
655 #error unknown kernel arch
656 #endif
657
658         
659         /* implementation defaults */
660
661
662
663 #ifndef __sysc_clobber
664 #define __sysc_clobber          "memory"
665 #endif
666
667 #ifndef __sysc_acon
668 #define __sysc_acon(n)          "r"
669 #endif
670
671 #ifndef __sysc_con_ret
672 #define __sysc_con_ret          "=r"
673 #endif
674
675 #ifndef __sysc_con_err
676 #define __sysc_con_err          "=r"
677 #endif
678
679 #ifndef __sysc_con_cid
680 #ifdef  __sysc_reg_cid
681 #define __sysc_con_cid          "r"
682 #else
683 #define __sysc_con_cid          "i"
684 #endif
685 #endif
686
687 #ifndef __sysc_type
688 #define __sysc_type             long
689 #endif
690
691 #ifdef  __sysc_regs
692 #define __sysc_rega(n,...)      __arg_##n(__VA_ARGS__)
693 #ifndef __sysc_reg
694 #define __sysc_reg(n)           __sysc_rega(n,__sysc_regs)
695 #endif
696 #endif
697
698
699
700         /* argument list */
701
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)
709
710         /* argument concatenation */
711
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)
719
720         /* argument selection */
721
722 #define __arg_0(...)
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
729
730         /* list remainder */
731
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
738 #define __rem_6(...)
739
740
741         /* conditional asm */
742
743 #define __casm_use(q,r,v)       v __casm_use_##q##r(__casm_nl(""))
744
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
749
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
754
755
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)
763
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)
771
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)
779
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)
787
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)
795
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)
803
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)
811
812
813         /* special PIC handling */
814
815 #ifdef  __PIC__
816 #define __pic(v)                v
817 #define __nopic(v)
818 #else
819 #define __pic(v)
820 #define __nopic(v)              v
821 #endif
822
823 #define __casm_nl(v)            v "\n\t"
824
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)
827
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))
830
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))
833
834
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)
838
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)
841
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);
845
846 #ifdef  __sysc_clbrs
847 #define __sc_cregs(n,...)       __rem_##n(__VA_ARGS__)
848 #else
849 #define __sc_cregs(n,...)
850 #endif
851
852 #ifdef  __sysc_regs
853 #define __sc_input(n,...)       __con_##n(__sc_idef,__VA_ARGS__)
854 #define __sc_ivals(n,...)       __lst_##n(__sc_rval,__VA_ARGS__)
855 #else
856 #define __sc_ivals(n,...)       __lst_##n(__sc_ival,__VA_ARGS__)
857 #endif
858
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)
863 #endif
864
865 #ifndef __sc_input
866 #define __sc_input(n,...)
867 #endif
868
869 #ifndef __sc_cidval
870 #define __sc_cidval(N)          __sysc_con_cid (__sysc_cid(N))
871 #endif
872
873 #ifndef __sc_cidvar
874 #define __sc_cidvar(N)
875 #endif
876
877
878 #ifdef  __sysc_reg_ret
879 #define __sc_ret        __ret
880 #define __sc_def_ret    __sc_ldef(ret); __sc_rdef(__sc_ret,__sysc_reg_ret)
881 #else
882 #define __sc_ret        ret
883 #define __sc_def_ret    __sc_ldef(__sc_ret)
884 #endif
885
886 #ifdef  __sysc_reg_err
887 #define __sc_err        __err
888 #define __sc_def_err    __sc_ldef(err); __sc_rdef(__sc_err,__sysc_reg_err)
889 #else
890 #define __sc_err        err
891 #define __sc_def_err    __sc_ldef(__sc_err)
892 #endif
893
894
895 #ifndef __sysc_max_err
896 #define __sc_complex
897 #endif
898
899 #ifdef  __sc_complex    /* complex result */
900
901 #ifndef __sc_results
902 #define __sc_results    __sc_def_ret; __sc_def_err
903 #endif
904
905 #ifndef __sysc_errc
906 #define __sysc_errc(ret, err) (err)
907 #endif
908
909 #ifndef __sysc_retv
910 #define __sysc_retv(type, ret, err)                                     \
911         if (__sysc_errc(ret, err)) {                                    \
912                 __sysc_seterr(ret);                                     \
913                 ret = -1;                                               \
914         }                                                               \
915         return (type)(ret)
916 #endif
917
918 #define __sc_oregs      __sysc_con_ret (__sc_ret),                      \
919                         __sysc_con_err (__sc_err)
920 #ifndef __sc_return
921 #define __sc_return(t)  ret = __sc_ret; err = __sc_err;                 \
922                         __sysc_retv(t, ret, err)
923 #endif
924 #else                   /* simple result  */
925
926 #ifndef __sc_results
927 #define __sc_results    __sc_def_ret
928 #endif
929
930 #ifndef __sysc_errc
931 #define __sysc_errc(ret)                                                \
932         ((unsigned __sysc_type)(ret) >=                                 \
933                 (unsigned __sysc_type)(-(__sysc_max_err)))
934 #endif
935
936 #ifndef __sysc_retv
937 #define __sysc_retv(type, ret)                                          \
938         if (__sysc_errc(ret)) {                                         \
939                 __sysc_seterr(-ret);                                    \
940                 ret = -1;                                               \
941         }                                                               \
942         return (type)(ret)
943 #endif
944
945 #define __sc_oregs      __sysc_con_ret (__sc_ret)
946 #ifndef __sc_return
947 #define __sc_return(t)  ret = __sc_ret; __sysc_retv(t, ret)
948 #endif
949 #endif                  /* simple/complex */
950
951
952
953         /* the inline syscall */
954
955 #define __sc_asm        __asm__
956 #define __sc_asm_vol    __asm__ __volatile__
957
958 #ifndef __sc_syscall
959 #define __sc_syscall(n,N,...)                                           \
960         __sc_asm_vol (__sysc_cmd(n)                                     \
961           : __sc_oregs                                                  \
962           : __sc_cidval(N) __sc_ivals(n,__VA_ARGS__)                    \
963           : __sysc_clobber __sc_cregs(n,__sysc_clbrs))
964 #endif
965
966 #ifndef __sc_body
967 #define __sc_body(n, type, name, ...)                                   \
968 {                                                                       \
969         __sc_results;__sc_cidvar(name);                                 \
970         __sc_input(n,__VA_ARGS__)                                       \
971         __sc_syscall(n,name,__VA_ARGS__);                               \
972         __sc_return(type);                                              \
973 }
974 #endif
975
976 #define _syscall0(type, name)                                           \
977 type name(void)                                                         \
978 __sc_body(0, type, name, *)
979
980 #define _syscall1(type, name, type1, arg1)                              \
981 type name(type1 arg1)                                                   \
982 __sc_body(1, type, name, arg1)
983
984 #define _syscall2(type, name, type1, arg1, type2, arg2)                 \
985 type name(type1 arg1, type2 arg2)                                       \
986 __sc_body(2, type, name, arg1, arg2)
987
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)
991
992 #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,    \
993                               type4, arg4)                              \
994 type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4)               \
995 __sc_body(4, type, name, arg1, arg2, arg3, arg4)
996
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)
1001
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)
1007
1008
1009
1010 #endif  /* __SYSCALL_NEW_H */