Changeset 2495

Show
Ignore:
Timestamp:
02/11/07 21:16:05 (2 years ago)
Author:
dhozac
Message:

Update to shiny15.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/lib/syscall-alternative.h

    r2297 r2495  
    1  // from http://vserver.13thfloor.at/Experimental/SYSCALL/syscall_shiny10.h 
     1 // from http://vserver.13thfloor.at/Experimental/SYSCALL/syscall_shiny15.h 
    22 
    33#ifndef __SYSCALL_NEW_H 
    44#define __SYSCALL_NEW_H 
    55 
    6 /*      Copyright (C) 2005-2006 Herbert Pötzl 
     6/*      Copyright (C) 2005-2007 Herbert Pötzl 
    77 
    88                global config options 
    99 
    10         __sysc_setret   ... set return value (default none) 
    11         __sysc_seterr   ... set error value (default errno) 
    12  
     10        __sysc_seterr   ... set error value (def: errno) 
     11        __sysc_cid(N)   ... syscall 'name' id (def: __NR_<N>) 
    1312 
    1413                arch specific config 
    1514 
    16         __sysc_reg_cid  ... the callid (if define), immediate otherwise 
    17  
    18         __sysc_reg(n)   ... syscall argument registers 
    19  
    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 
    23  
    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) 
    27  
    28         __sysc_clobber  ... clobbered registers (default memory) 
    29         __sysc_max_err  ... maximum error number (for simple result) 
    30  
    31         __sysc_errc(r,e)        ... error condition (e cmplx) 
    32         __sysc_retv(t,r,e)      ... syscall return value (e cmplx) 
    33  
    34                 if gcc cannot be trusted 
    35  
    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 
    42         __sysc_aout             ... asm code output constraint 
    43  
    44                 if all else fails 
    45  
    46         __sc_asmload(n,N,...)   ... asm code to prepare arguments 
    47         __sc_asmsysc(n,N)       ... asm code to execute syscall 
    48         __sc_asmsave(n)         ... asm code to store results 
    49  
    50 */ 
    51  
    52  
     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*/ 
     33 
     34        /* some fallback defaults */ 
     35 
     36#ifndef __sysc_seterr 
     37#define __sysc_seterr(e)        do { errno = (e); } while(0) 
     38#endif 
     39 
     40#ifndef __sysc_cid 
     41#define __sysc_cid(N)           __NR_##N 
     42#endif 
    5343 
    5444 
     
    6858        call:   callsys 
    6959        clob:   memory 
    70 */ 
     60        move:   mov $sR,$dR 
     61        picr:   pr($29) do we need to save that? 
     62*/ 
     63 
     64#define __sysc_cmd(n)   "callsys" 
    7165 
    7266#define __sysc_reg_cid  "$0" 
     67#define __sysc_con_cid  "v" 
    7368#define __sysc_reg_ret  "$0" 
     69#define __sysc_con_ret  "=v" 
    7470#define __sysc_reg_err  "$19" 
    75 #define __sysc_cmd_sys  "callsys" 
    76  
    77 #define __sysc_reg(n)   __arg_##n\ 
    78         ("$16", "$17", "$18", "$19", "$20", "$21") 
    79  
    80 #define __sysc_clobber  __sysc_regs,                                    \ 
    81         "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8",                 \ 
    82         "$22", "$23", "$24", "$25", "$27", "$28", "memory"              \ 
    83  
     71 
     72#define __sysc_regs     "$16", "$17", "$18", "$19", "$20", "$21" 
     73#define __sysc_clbrs    "$16", "$17", "$18", "memory", "$20", "$21" 
     74#define __sysc_clobber  "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \ 
     75                        "$22", "$23", "$24", "$25", "$27", "$28", "memory" 
    8476 
    8577 
     
    9991        call:   swi 
    10092        clob:   memory 
     93        move:   mov $dR,$sR 
    10194*/ 
    10295 
    10396#define __sysc_max_err  125 
    104 #define __sysc_reg_res  "r0" 
    105 #define __sysc_cmd_sys  "swi    %0" 
    106  
    107 #define __sysc_reg(n)   __arg_##n\ 
    108         ("r0", "r1", "r2", "r3", "r4", "r5") 
    109  
    110 #define __sysc_clobber  __sysc_regs, "memory" 
     97 
     98#define __sysc_cmd(n)   "swi    %1" 
     99 
     100#define __sysc_regs     "r0", "r1", "r2", "r3", "r4", "r5" 
     101#define __sysc_reg_ret  "r0" 
    111102 
    112103#warning syscall arch arm not tested yet 
     
    131122*/ 
    132123 
    133 #define __sysc_max_err  125 
    134 #define __sysc_reg_cid  "r9" 
    135 #define __sysc_reg_res  "r0" 
    136 #define __sysc_cmd_sys  "break 13" 
    137  
    138 #define __sysc_regs     "r10", "r11", "r12", "r13" 
    139 #define __sysc_reg(n)   __arg_##n\ 
    140         ("r10", "r11", "r12", "r13", "r0", "srp") 
    141  
    142 #define __sysc_pre(n)   __casm(n,5,0,"move r0,mof",) 
    143  
    144 #define __sysc_clobber  __sysc_regs, "memory" 
    145  
    146 #warning syscall arch cris not tested yet 
     124#error syscall arch cris not implemented yet 
    147125 
    148126 
     
    166144*/ 
    167145 
    168 #define __sysc_max_err  125 
    169 #define __sysc_reg_cid  "gr7" 
    170 #define __sysc_reg_res  "gr8" 
    171 #define __sysc_cmd_sys  "tira   gr0,#0" 
    172  
    173 #define __sysc_reg(n)   __arg_##n\ 
    174         ("gr8", "gr9", "gr10", "gr11", "gr12", "gr13") 
    175  
    176 #define __sysc_clobber  __sysc_regs, "memory" 
    177  
    178 #warning syscall arch frv not tested yet 
     146#error syscall arch frv not implemented yet 
    179147 
    180148 
     
    199167*/ 
    200168 
    201 #define __sysc_max_err  125 
    202 #define __sysc_reg_res  "er0" 
    203  
    204 #define __sysc_reg(n)   __arg_##n\ 
    205         ("er1", "er2", "er3", "er4", "er5", "er6") 
    206  
    207 #define __sysc_clobber  "memory" 
    208  
    209 #define __sc_asmload(n,N,...)   __sc_asm        (                       \ 
    210         __casm(n,1,1,   "mov.l  %0,er1"         ,                       )\ 
    211         __casm(n,2,1,   "mov.l  %1,er2"         ,                       )\ 
    212         __casm(n,3,1,   "mov.l  %2,er3"         ,                       )\ 
    213         __casm(n,4,1,   "mov.l  %3,er4"         ,                       )\ 
    214         __casm(n,5,1,   "mov.l  %4,er5"         ,                       )\ 
    215         __casm(n,6,1,   "mov.l  er6,@-sp"       ,                       )\ 
    216         __casm(n,6,1,   "mov.l  %5,er6"         ,                       )\ 
    217         ""::__sc_iregs(n,__VA_ARGS__):__sysc_regs) 
    218  
    219 #define __sysc_cmd_pre  "mov.l  %0,er0" 
    220 #define __sysc_cmd_sys  "trapa  #0" 
    221 #define __sysc_fin(n)   __casm(n,6,0,"mov.l     @sp+,er6",) 
    222  
    223 #warning syscall arch h8300 not tested yet 
     169#error syscall arch h8300 not implemented yet 
    224170 
    225171 
     
    246192        call:   ble  0x100(%%sr2, %%r0) 
    247193        clob:   r1, r2, (r4), r20, r29, r31, memory 
    248         picr:   pr(r19) 
     194        picr:   pr(r19) do we need to save that? 
    249195*/ 
    250196 
    251197#define __sysc_max_err  4095 
    252 #define __sysc_reg_res  "r28" 
    253  
    254 #define __sysc_reg(n)   __arg_##n\ 
    255         ("r26", "r25", "r24", "r23", "r22", "r21") 
    256  
    257 #define __sysc_cmd_sys  "ble 0x100(%%sr2,%%r0)" 
    258  
    259 #define __sysc_pre(n)                                                   \ 
    260         __pasm(n,1,1,   "copy %%r19, %%r4"      ,                       ) 
    261  
    262 #define __sysc_fin(n)                                                   \ 
    263         __casm(n,1,1,   "ldi %0,%%r20"          ,                       )\ 
    264         __pasm(n,1,1,   "copy %%r4, %%r19"      ,                       ) 
     198 
     199#define __sysc_cmd(n)   \ 
     200        __pasm(n,1,1,   "copy %%r19, %%r4"      ,)\ 
     201        __casm(n,0,1,   "ble 0x100(%%sr2,%%r0)" ,)\ 
     202        __casm(n,0,1,   "ldi %1,%%r20"          ,)\ 
     203        __pasm(n,1,1,   "copy %%r4, %%r19"      ,) 
     204 
     205#define __sysc_regs     "r26", "r25", "r24", "r23", "r22", "r21" 
    265206 
    266207#ifndef __PIC__ 
    267 #define __sysc_clobber  __sysc_regs,                                    \ 
    268         "r1", "r2", "r20", "r29", "r31", "memory" 
    269 #else 
    270 #define __sysc_clobber  __sysc_regs,                                    \ 
    271         "r1", "r2", "r4", "r20", "r29", "r31", "memory" 
    272 #endif 
     208#define __sysc_clobber  "r1", "r2", "r20", "r29", "r31", "memory" 
     209#else 
     210#define __sysc_clobber  "r1", "r2", "r4", "r20", "r29", "r31", "memory" 
     211#endif 
     212 
     213#warning syscall arch hppa not tested yet 
     214 
    273215 
    274216 
     
    290232        picr:   pr(ebx) 
    291233        clob:   memory 
     234        move:   movl $sR,$dR 
    292235*/ 
    293236 
    294237#define __sysc_max_err  129 
    295 #define __sysc_reg_res  "eax" 
    296 #define __sysc_cmd_sys  "int    $0x80" 
    297238 
    298239#ifndef __PIC__ 
    299 #define __sysc_regs     "ebx", "ecx", "edx", "esi", "edi" 
    300 #else 
    301 #define __sysc_regs     "ecx", "edx", "esi", "edi" 
    302 #endif 
    303  
    304 #define __sc_asmload(n,N,...)   __sc_asm        (                       \ 
    305         __casm(n,6,1,   "movl   %5,%%eax"       ,                       )\ 
    306         __casm(n,5,1,   "movl   %4,%%edi"       ,                       )\ 
    307         __casm(n,4,1,   "movl   %3,%%esi"       ,                       )\ 
    308         __casm(n,3,1,   "movl   %2,%%edx"       ,                       )\ 
    309         __casm(n,2,1,   "movl   %1,%%ecx"       ,                       )\ 
    310         __pasm(n,1,1,   "pushl  %%ebx"          ,                       )\ 
    311         __casm(n,1,1,   "movl   %0,%%ebx"       ,                       )\ 
    312         __casm(n,6,1,   "pushl  %%ebp"          ,                       )\ 
    313         ""::__sc_iregs(n,__VA_ARGS__):__sysc_clobber) 
    314  
    315 #define __sc_asmsave(n) 
    316  
    317 #define __sysc_pre(n)                                                   \ 
    318         __casm(n,6,1,   "movl   %%eax,%%ebp"    ,                       )\ 
    319         __casm(n,0,1,   "movl   %1,%%eax"       ,                       )\ 
    320  
    321 #define __sysc_fin(n)                                                   \ 
    322         __casm(n,6,1,   "popl   %%ebp"          ,                       )\ 
    323         __pasm(n,1,1,   "popl   %%ebx"          ,                       )\ 
    324  
    325 #define __sysc_aout     "=a"(__res) 
    326 #define __sysc_clobber  __sysc_regs, "memory" 
     240#define __sysc_clbrs    "memory", "ebx", "ecx", "edx", "esi", "edi" 
     241#else 
     242#define __sysc_clbrs    "memory", "memory", "ecx", "edx", "esi", "edi" 
     243#endif 
     244 
     245#define __sysc_cmd(n)   \ 
     246        __casm(n,6,1,   "movl   %7, %%eax"      ,)\ 
     247        __casm(n,5,1,   "movl   %6, %%edi"      ,)\ 
     248        __casm(n,4,1,   "movl   %5, %%esi"      ,)\ 
     249        __casm(n,3,1,   "movl   %4, %%edx"      ,)\ 
     250        __casm(n,2,1,   "movl   %3, %%ecx"      ,)\ 
     251        __pasm(n,1,1,   "pushl  %%ebx"          ,)\ 
     252        __casm(n,1,1,   "movl   %2, %%ebx"      ,)\ 
     253        __casm(n,6,1,   "pushl  %%ebp"          ,)\ 
     254        __casm(n,6,1,   "movl   %%eax, %%ebp"   ,)\ 
     255        __casm(n,0,1,   "movl   %1, %%eax"      ,)\ 
     256        __casm(n,0,1,   "int    $0x80"          ,)\ 
     257        __casm(n,6,1,   "popl   %%ebp"          ,)\ 
     258        __pasm(n,1,1,   "popl   %%ebx"          ,) 
     259 
     260#define __sysc_acon(n)  "g" 
     261#define __sysc_reg_ret  "eax" 
     262#define __sysc_con_ret  "=a" 
     263 
    327264 
    328265 
     
    342279        call:   break 0x100000 
    343280        clob:   out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7 
    344 */ 
    345  
    346  
     281        move:   mov %dR = %sR 
     282*/ 
     283 
     284#define __sysc_errc(r,e)        ((e) == -1) 
     285 
     286#define __sysc_cmd(n)   "break.i 0x100000" 
     287 
     288#define __sysc_regs     "out0", "out1", "out2", "out3", "out4", "out5" 
     289#define __sysc_reg_cid  "r15" 
    347290#define __sysc_reg_ret  "r8" 
    348291#define __sysc_reg_err  "r10" 
    349 #define __sysc_reg_cid  "r15" 
    350 #define __sysc_cmd_sys  "break.i        0x100000" 
    351  
    352 #define __sysc_errc(r,e)        ((e) == -1) 
    353  
    354 #define __sysc_reg(n)   __arg_##n\ 
    355         ("out0", "out1", "out2", "out3", "out4", "out5") 
    356  
    357 #define __sysc_clobber  __sysc_regs,                                    \ 
     292 
     293#define __sysc_clobber  \ 
    358294        "out6", "out7", "r2", "r3", "r9", "r11", "r12", "r13",          \ 
    359         "r14", "r16", "r17", "r18", "r19", "r20", "r21", "r22",       \ 
     295        "r14", "r16", "r17", "r18", "r19", "r20", "r21", "r22",               \ 
    360296        "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30",         \ 
    361297        "r31", "p6", "p7", "p8", "p9", "p10", "p11", "p12", "p13",      \ 
     
    382318        call:   trap #2 
    383319        clob:   out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7 
     320        move:   mv %dR,%sR 
    384321*/ 
    385322 
    386323#define __sysc_max_err  125 
     324 
     325#define __sysc_cmd(n)   "trap #2" 
     326 
     327#define __sysc_regs     "r0", "r1", "r2", "r3", "r4", "r5" 
    387328#define __sysc_reg_cid  "r7" 
    388 #define __sysc_reg_res  "r0" 
    389 #define __sysc_cmd_sys  "trap #2" 
    390  
    391 #define __sysc_reg(n)   __arg_##n\ 
    392         ("r0", "r1", "r2", "r3", "r4", "r5") 
    393  
    394 #define __sysc_clobber  __sysc_regs, "memory" 
     329#define __sysc_reg_ret  "r0" 
    395330 
    396331#warning syscall arch m32r not tested yet 
     
    415350 
    416351/*      The ABIO32 calling convention uses a0-a3  to pass the first 
    417         four arguments, the rest is passed on the userspace stack.  The 5th arg 
    418         starts at 16($sp). 
     352        four arguments, the rest is passed on the userspace stack.   
     353        The 5th arg starts at 16($sp). The new mips calling abi uses  
     354        registers a0-a5, restart requires a reload of v0 (#syscall) 
    419355 
    420356        ABIN32 and ABI64 pass 6 args in a0-a3, t0-t1. 
    421357 
    422358        scnr:   id(v0) 
    423         args:   a1(a0), a2(a1), a3(a2), a4(a3), a5(16($sp)), a6(20($sp)
     359        args:   a1(a0), a2(a1), a3(a2), a4(a3), a5(t0), a6(t1
    424360        sret:   r0(v0) 
    425361        serr:   e0(a3) 
    426362        call:   syscall 
    427         clob:   at, v0, t0-t7, t8-t9 
    428 */ 
    429  
    430 #define __sysc_reg_cid  "v0" 
     363        clob:   at, v1, t2-t7, t8-t9 
     364        move:   move    %dR,%sR 
     365*/ 
     366 
     367#define __sysc_cmd(n)   \ 
     368        __casm(n,0,1,   "ori    $v0,$0,%2"      ,)\ 
     369        __casm(n,0,1,   "syscall"               ,) 
     370 
     371#define __sysc_regs     "a0","a1","a2","a3", "t0", "t1" 
    431372#define __sysc_reg_ret  "v0" 
    432373#define __sysc_reg_err  "a3" 
    433 #define __sysc_cmd_sys  "syscall" 
    434  
    435 #define __sysc_reg(n) __arg_##n\ 
    436         ("a0","a1","a2","a3", "t0", "t1") 
    437  
    438 #define __sysc_clobber "$1", "$3", "$8", "$9", "$10", "$11", "$12",     \ 
    439         "$13", "$14", "$15", "$24", "$25", "memory" 
    440  
    441 #if _MIPS_SIM == _ABIO32 
    442 #define __sysc_pre(n)                                                   \ 
    443         __casm(n,5,1,"addiu $sp,$sp,-32",)                              \ 
    444         __casm(n,6,1,"sw $9,20($sp)",)                                  \ 
    445         __casm(n,5,1,"sw $8, 16($sp)",) 
    446 #define __sysc_fin(n)                                                   \ 
    447         __casm(n,5,1,"addiu $sp,$sp,32",) 
    448 #elif (_MIPS_SIM == _ABIN32) || (_MIPS_SIM == _ABI64) 
    449 #warning syscall arch mips with ABI N32 and 64 not tested yet 
    450 #else 
    451 #error unknown mips ABI version 
    452 #endif 
     374 
     375#define __sysc_clobber  "$1", "$3", "$10", "$11", "$12",                \ 
     376                        "$13", "$14", "$15", "$24", "$25", "memory" 
     377 
     378#warning syscall arch mips not tested yet 
     379 
    453380 
    454381 
     
    467394        serr:   (carry) 
    468395        call:   sc 
    469         clob:   cr0, ctr 
    470 */ 
    471  
    472  
     396        clob:   r9-r12, cr0, ctr 
     397        move:   mr %dR,%sR 
     398*/ 
     399 
     400#define __sysc_errc(r,e)        ((e) & 0x10000000) 
     401 
     402#define __sysc_cmd(n)   \ 
     403        __casm(n,0,1,   "sc"                    ,)\ 
     404        __casm(n,0,1,   "mfcr %1"               ,) 
     405 
     406#define __sysc_regs     "r3", "r4", "r5", "r6", "r7", "r8" 
    473407#define __sysc_reg_cid  "r0" 
    474408#define __sysc_reg_ret  "r3" 
    475 #define __sysc_reg_err  "r0" 
    476  
    477 #define __sysc_errc(r,e)        ((e) & 0x10000000) 
    478  
    479 #define __sysc_reg(n)   __arg_##n\ 
    480         ("r3", "r4", "r5", "r6", "r7", "r8") 
    481  
    482 #define __sysc_cmd_sys  "sc" 
    483 #define __sysc_cmd_fin  "mfcr 0" 
    484  
    485 #define __sysc_clobber  __sysc_regs,                                    \ 
    486         "r9", "r10", "r11", "r12", "cr0", "ctr", "memory" 
     409 
     410#define __sysc_clobber  "r9", "r10", "r11", "r12", "cr0", "ctr", "memory" 
    487411 
    488412 
     
    507431 
    508432#define __sysc_max_err  4095 
     433 
     434#define __sysc_cmd(n)   "svc    0" 
     435 
     436// #define      __sysc_type     unsigned long 
     437 
     438#define __sysc_regs     "r2", "r3", "r4", "r5", "r6", "r7" 
    509439#define __sysc_reg_cid  "r1" 
    510 #define __sysc_reg_res  "r2" 
    511 #define __sysc_cmd_sys  "svc    0" 
    512  
    513 #define __sysc_regtyp   unsigned long 
    514  
    515 #define __sysc_reg(n)   __arg_##n\ 
    516         ("r2", "r3", "r4", "r5", "r6", "r7") 
    517  
    518 #define __sysc_clobber  __sysc_regs, "memory" 
     440#define __sysc_reg_ret  "r2" 
     441 
     442#warning syscall arch s390 not tested yet 
    519443 
    520444 
     
    528452/*      The SuperH calling convention passes the first four arguments 
    529453        in r4-r7, the remainder is spilled onto the stack. However 
    530         the Linux kernel passes the remainder in r0-r2
     454        the Linux kernel passes the remainder in r0-r1
    531455 
    532456        scnr:   id(r3) 
     
    536460        call:   trapa #0x1x (x=#args) 
    537461        clob:   memory 
    538 */ 
     462        move:   ori     %sR,0,%dR 
     463*/ 
     464 
     465#ifdef  __sh2__ 
     466#define __sysc_arch     "trapa  #0x2" 
     467#else 
     468#define __sysc_arch     "trapa  #0x1" 
     469#endif 
    539470 
    540471#define __sysc_max_err  4095 
     472 
     473#define __sysc_cmd(n)   __sysc_arch #n 
     474 
     475#define __sysc_regs     "r4", "r5", "r6", "r7", "r0", "r1" 
    541476#define __sysc_reg_cid  "r3" 
    542 #define __sysc_reg_res  "r0" 
    543  
    544 #define __sysc_reg(n)   __arg_##n\ 
    545         ("r4", "r5", "r6", "r7", "r0", "r1") 
    546  
    547 #define __sysc_cmd(n)   "trapa  #0x1" __stringify(n) 
    548  
    549 #define __rep_6(x)      x x x x x x 
    550 #define __sysc_cmd_fin  __rep_6("or     r0,r0\n\t") 
    551  
    552 #define __sysc_clobber  __sysc_regs, "memory" 
     477#define __sysc_reg_ret  "r0" 
    553478 
    554479#warning syscall arch sh not tested yet 
     
    563488 
    564489/*      The SuperH-5 calling convention passes the first eight 
    565         arguments in r2-r9 
     490        arguments in r2-r9. The Linux kernel uses only six of 
     491        them as arguments, and the last one for the syscall id. 
    566492 
    567493        scnr:   id(r9) 
     
    571497        call:   trapa #0x1x (x=#args) 
    572498        clob:   memory 
     499        move:   ori     %sR,0,%dR 
    573500*/ 
    574501 
    575502#define __sysc_max_err  4095 
    576 #define __sysc_reg_res  "r9" 
    577 #define __sysc_cmd_sys  "trapa  r9" 
    578  
    579 #define __sysc_reg(n)   __arg_##n\ 
    580         ("r2", "r3", "r4", "r5", "r6", "r7") 
    581  
    582 #define __sc_asmsysc(n,N)       __sc_asm_vol    (                       \ 
    583         __casm(n,0,1,   "movi %0,r9"            ,                       )\ 
    584         __casm(n,0,1,   __sc_cmds(n,N)          ,                       )\ 
    585         ""::"i"(__sc_id(N) | 0x1##n << 16) : __sysc_clobber) 
    586  
    587 #define __sysc_clobber  __sysc_regs, "memory" 
     503 
     504#define __sysc_cmd(n)   \ 
     505        __casm(n,0,1,   "movi   0x1" #n ",r9"   ,)\ 
     506        __casm(n,0,1,   "shori  %1,r9"          ,)\ 
     507        __casm(n,0,1,   "trapa  r9"             ,) 
     508 
     509#define __sysc_regs     "r2", "r3", "r4", "r5", "r6", "r7" 
     510#define __sysc_reg_ret  "r9" 
    588511 
    589512#warning syscall arch sh64 not tested yet 
     
    606529        call:   ta 0x6d, t 0x10 
    607530        clob:   g1-g6, g7?, o7?, f0-f31, cc 
    608 */ 
    609  
    610 #define __sysc_max_err  515 
     531        move:   mov     %sR,%dR 
     532*/ 
     533 
     534#ifdef  __arch64__ 
     535#define __sysc_arch     "ta     0x6d" 
     536#else 
     537#define __sysc_arch     "ta     0x10" 
     538#endif 
     539 
     540#define __sysc_cmd(n)   \ 
     541        __casm(n,0,1,   __sysc_arch             ,)\ 
     542        __casm(n,0,1,   "addx   %%g0,%%g0,%1"   ,) 
     543 
     544#define __sysc_regs     "o0", "o1", "o2", "o3", "o4", "o5" 
    611545#define __sysc_reg_cid  "g1" 
    612546#define __sysc_reg_ret  "o0" 
    613 #define __sysc_reg_err  "l1" 
    614  
    615 #define __sysc_reg(n)   __arg_##n\ 
    616         ("o0", "o1", "o2", "o3", "o4", "o5") 
    617  
    618 #ifdef  __arch64__ 
    619 #define __sysc_cmd_sys  "ta     0x6d" 
    620 #else 
    621 #define __sysc_cmd_sys  "t      0x10" 
    622 #endif 
    623  
    624 #define __sysc_cmd_fin  "addx   %%g0,%%g0,%%l1" 
    625  
    626  
    627 #define __sysc_clobber  __sysc_regs,                                    \ 
    628         "g2", "g3", "g4", "g5", "g6",                                   \ 
     547 
     548#define __sysc_clobber  "g2", "g3", "g4", "g5", "g6",                   \ 
    629549        "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8",           \ 
    630550        "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16",          \ 
     
    635555        "cc", "memory" 
    636556 
    637 #warning syscall arch sparc not tested yet 
    638  
    639557 
    640558 
     
    658576 
    659577#define __sysc_max_err  515 
     578 
     579#define __sysc_cmd(n)   \ 
     580        __casm(n,4,0,   "trap 1"        ,"trap 0"       ) 
     581 
     582#define __sysc_regs     "r6", "r7", "r8", "r9", "r13", "r14" 
    660583#define __sysc_reg_cid  "r12" 
    661 #define __sysc_reg_res  "r10" 
    662  
    663 #define __sysc_reg(n)   __arg_##n\ 
    664         ("r6", "r7", "r8", "r9", "r13", "r14") 
    665  
    666 #define __sysc_cmd(n)   __casm(n,4,0,"trap 1","trap 0") 
    667  
    668 #define __sysc_clobber  __sysc_regs,                                    \ 
    669         "r1", "r5", "r11", "r15", "r16", "r17", "r18", "r19", "memory" 
     584#define __sysc_reg_ret  "r10" 
     585 
     586#define __sysc_clobber  "r1", "r5", "r11",                              \ 
     587                        "r15", "r16", "r17", "r18", "r19", "memory" 
    670588 
    671589#warning syscall arch v850 not tested yet 
     
    691609 
    692610#define __sysc_max_err  4095 
     611 
     612#define __sysc_cmd(n)   "syscall" 
     613 
     614#define __sysc_regs     "rdi", "rsi", "rdx", "r10", "r8", "r9" 
    693615#define __sysc_reg_cid  "rax" 
    694 #define __sysc_reg_res  "rax" 
    695 #define __sysc_cmd_sys  "syscall" 
    696  
    697 #define __sysc_reg(n)   __arg_##n\ 
    698         ("rdi", "rsi", "rdx", "r10", "r8", "r9") 
    699  
    700 #define __sysc_clobber  __sysc_regs,                                    \ 
    701         "cc", "r11", "rcx", "memory" 
    702  
    703 #define __sysc_aout     "=a"(__res) 
     616#define __sysc_reg_ret  "rax" 
     617#define __sysc_con_ret  "=a" 
     618 
     619#define __sysc_clobber  "cc", "r11", "rcx", "memory" 
    704620 
    705621#else 
     
    707623#endif 
    708624 
    709  
     625         
     626        /* implementation defaults */ 
     627 
     628 
     629 
     630#ifndef __sysc_clobber 
     631#define __sysc_clobber          "memory" 
     632#endif 
     633 
     634#ifndef __sysc_acon 
     635#define __sysc_acon(n)          "r" 
     636#endif 
     637 
     638#ifndef __sysc_con_ret 
     639#define __sysc_con_ret          "=r" 
     640#endif 
     641 
     642#ifndef __sysc_con_err 
     643#define __sysc_con_err          "=r" 
     644#endif 
     645 
     646#ifndef __sysc_con_cid 
     647#ifdef  __sysc_reg_cid 
     648#define __sysc_con_cid          "r" 
     649#else 
     650#define __sysc_con_cid          "i" 
     651#endif 
     652#endif 
     653 
     654#ifndef __sysc_type 
     655#define __sysc_type             long 
     656#endif 
     657 
     658#ifdef  __sysc_regs 
     659#define __sysc_rega(n,...)      __arg_##n(__VA_ARGS__) 
     660#ifndef __sysc_reg 
     661#define __sysc_reg(n)           __sysc_rega(n,__sysc_regs) 
     662#endif 
     663#endif 
    710664 
    711665 
     
    718672#define __lst_3(x,a1,a2,a3)             __lst_2(x,a1,a2),x(3,a3) 
    719673#define __lst_2(x,a1,a2)                __lst_1(x,a1),x(2,a2) 
    720 #define __lst_1(x,a1)                   __lst_0(x,*)x(1,a1) 
     674#define __lst_1(x,a1)                   __lst_0(x,*),x(1,a1) 
    721675#define __lst_0(x,a0) 
    722676 
    723         /* argument concat */ 
     677        /* argument selection */ 
     678 
     679#define __arg_0(...) 
     680#define __arg_1(a1,...)                 a1 
     681#define __arg_2(a1,a2,...)              a2 
     682#define __arg_3(a1,a2,a3,...)           a3 
     683#define __arg_4(a1,a2,a3,a4,...)        a4 
     684#define __arg_5(a1,a2,a3,a4,a5,...)     a5 
     685#define __arg_6(a1,a2,a3,a4,a5,a6)      a6 
     686 
     687        /* argument concatenation */ 
    724688 
    725689#define __con_6(x,a1,a2,a3,a4,a5,a6)    __con_5(x,a1,a2,a3,a4,a5)x(6,a6) 
     
    731695#define __con_0(x,a0) 
    732696 
    733         /* argument selection */ 
    734  
    735 #define __arg_0(...) 
    736 #define __arg_1(a1,...)                 a1 
    737 #define __arg_2(a1,a2,...)              a2 
    738 #define __arg_3(a1,a2,a3,...)           a3 
    739 #define __arg_4(a1,a2,a3,a4,...)        a4 
    740 #define __arg_5(a1,a2,a3,a4,a5,...)     a5 
    741 #define __arg_6(a1,a2,a3,a4,a5,a6)      a6 
    742  
    743  
    744  
    745 #ifdef  __PIC__ 
    746 #define __pic(v)                v 
    747 #define __nopic(v) 
    748 #else 
    749 #define __pic(v) 
    750 #define __nopic(v)              v 
    751 #endif 
    752  
    753 #define __casm_nl(v)            v "\n\t" 
    754  
    755 #define __casm(n,a,r,v,w)       __casm_##n##a(v,w,r) 
    756  
    757 #define __pasm(n,a,r,v,w)       __pic(__casm(n,a,r,v,w)) 
    758 #define __Pasm(n,a,r,v,w)       __nopic(__casm(n,a,r,v,w)) 
     697        /* list remainder */ 
     698 
     699#define __rem_0(a1,a2,a3,a4,a5,a6)      ,a1,a2,a3,a4,a5,a6 
     700#define __rem_1(a1,a2,a3,a4,a5,a6)      ,a2,a3,a4,a5,a6 
     701#define __rem_2(a1,a2,a3,a4,a5,a6)      ,a3,a4,a5,a6 
     702#define __rem_3(a1,a2,a3,a4,a5,a6)      ,a4,a5,a6 
     703#define __rem_4(a1,a2,a3,a4,a5,a6)      ,a5,a6 
     704#define __rem_5(a1,a2,a3,a4,a5,a6)      ,a6 
     705#define __rem_6(...) 
     706 
     707 
     708        /* conditional asm */ 
    759709 
    760710#define __casm_use(q,r,v)       v __casm_use_##q##r(__casm_nl("")) 
     
    827777#define __casm_66(v,w,r)        __casm_use(1,r,v) 
    828778 
    829 #define __casm_cn_0 
    830 #define __casm_cn_1             , 
    831 #define __casm_cn_2             , 
    832 #define __casm_cn_3             , 
    833 #define __casm_cn_4             , 
    834 #define __casm_cn_5             , 
    835 #define __casm_cn_6             , 
    836  
    837  
    838  
    839 #define __sc_asm                __asm__ 
    840 #define __sc_asm_vol            __asm__ __volatile__ 
    841  
    842 #ifndef __sysc_setret 
    843 #define __sysc_setret(v)        do { } while(0) 
    844 #endif 
    845  
    846 #ifndef __sysc_seterr 
    847 #define __sysc_seterr(e)        do { errno = (e); } while(0) 
    848 #endif 
    849  
    850 #ifndef __stringify0 
    851 #define __stringify0(val)       #val 
    852 #endif 
    853  
    854 #ifndef __stringify 
    855 #define __stringify(val)        __stringify0(val) 
    856 #endif 
    857  
    858  
    859 #if     !defined(__sysc_load) && !defined(__sysc_save) 
    860 #if     !defined(__sysc_limm) && !defined(__sc_asmload) 
    861 #define __sc_trust 
    862 #endif 
    863 #endif 
    864  
    865 #if     defined(__sysc_reg_ret) && defined(__sysc_reg_err) 
     779 
     780        /* special PIC handling */ 
     781 
     782#ifdef  __PIC__ 
     783#define __pic(v)                v 
     784#define __nopic(v) 
     785#else 
     786#define __pic(v) 
     787#define __nopic(v)              v 
     788#endif 
     789 
     790#define __casm_nl(v)            v "\n\t" 
     791 
     792#define __casm(n,a,r,v,w)       __casm_##n##a(v,w,r) 
     793 
     794#define __pasm(n,a,r,v,w)       __pic(__casm(n,a,r,v,w)) 
     795#define __nasm(n,a,r,v,w)       __nopic(__casm(n,a,r,v,w)) 
     796 
     797#define __sc_cast(v)            (__sysc_type)(v) 
     798#define __sc_ldef(N)            __sysc_type N 
     799#define __sc_rdef(N,R)          register __sc_ldef(N) __sc_asm (R) 
     800 
     801#define __sc_scid(N,v)          __sc_ldef(N) = __sc_cast(v) 
     802#define __sc_areg(N,R,v)        __sc_rdef(N,R) = __sc_cast(v) 
     803 
     804#define __sc_rval(n,v)          "r"(__sc_a##n) 
     805#define __sc_ival(n,v)          __sysc_acon(n)(__sc_cast(v)) 
     806#define __sc_idef(n,v)          __sc_areg(__sc_a##n, __sysc_reg(n), v); 
     807 
     808#ifdef  __sysc_clbrs 
     809#define __sc_cregs(n,...)       __rem_##n(__VA_ARGS__) 
     810#else 
     811#define __sc_cregs(n,...) 
     812#endif 
     813 
     814#ifdef  __sysc_regs 
     815#define __sc_input(n,...)       __con_##n(__sc_idef,__VA_ARGS__) 
     816#define __sc_ivals(n,...)       __lst_##n(__sc_rval,__VA_ARGS__) 
     817#else 
     818#define __sc_input(n,...) 
     819#define __sc_ivals(n,...)       __lst_##n(__sc_ival,__VA_ARGS__) 
     820#endif 
     821 
     822#ifdef  __sysc_reg_cid 
     823#define __sc_cidvar(N)          __sc_areg(__sc_id, \ 
     824                                __sysc_reg_cid, __sysc_cid(N)) 
     825#define __sc_cidval(N)          __sysc_con_cid (__sc_id) 
     826#endif 
     827 
     828#ifndef __sc_cidval 
     829#define __sc_cidval(N)          __sysc_con_cid (__sysc_cid(N)) 
     830#endif 
     831 
     832#ifndef __sc_cidvar 
     833#define __sc_cidvar(N) 
     834#endif 
     835 
     836 
     837#ifdef  __sysc_reg_ret 
     838#define __sc_ret        __ret 
     839#define __sc_def_ret    __sc_ldef(ret); __sc_rdef(__sc_ret,__sysc_reg_ret) 
     840#else 
     841#define __sc_ret        ret 
     842#define __sc_def_ret    __sc_ldef(__sc_ret) 
     843#endif 
     844 
     845#ifdef  __sysc_reg_err 
     846#define __sc_err        __err 
     847#define __sc_def_err    __sc_ldef(err); __sc_rdef(__sc_err,__sysc_reg_err) 
     848#else 
     849#define __sc_err        err 
     850#define __sc_def_err    __sc_ldef(__sc_err) 
     851#endif 
     852 
     853 
     854#ifndef __sysc_max_err 
    866855#define __sc_complex 
    867856#endif 
    868857 
    869  
    870 #ifndef __sysc_type 
    871 #define __sysc_type             long 
    872 #endif 
    873  
    874 #define __sc_cast(v)            (__sysc_type)(v) 
    875  
    876  
    877 #define __sc_reg(n)             register __sysc_type n 
    878 #define __sc_asm_reg(n,r)       register __sysc_type n __sc_asm (r) 
    879 #define __sc_asm_val(n,r,v)     __sc_asm_reg(n,r) = __sc_cast(v) 
    880  
    881 #ifndef __sysc_load 
    882 #define __sc_inp_def(n,v)       __sc_asm_val(__sc_a##n, __sysc_reg(n), v); 
    883 #else 
    884 #define __sc_inp_def(n,value) 
    885 #endif 
    886  
    887 #if     !defined(__sysc_save) && !defined(__sysc_aout) 
    888 #define __sc_res_def(n,r)       __sc_asm_reg(n, r); 
    889 #else 
    890 #define __sc_res_def(n,r)       __sc_reg(n); 
    891 #endif 
    892  
    893  
    894 #define __sc_rreg(n,v)          "r"(__sc_a##n) 
    895 #define __sc_creg(n,v)          __sysc_rcon(n)(__sc_cast(v)) 
    896  
    897 #ifdef  __sc_trust 
    898 #define __sc_iregs(n,...)       __lst_##n(__sc_rreg,__VA_ARGS__) 
    899 #define __sc_input(n,...)       __con_##n(__sc_inp_def,__VA_ARGS__) 
    900 #else 
    901 #define __sc_iregs(n,...)       __lst_##n(__sc_creg,__VA_ARGS__) 
    902 #define __sc_input(n,...) 
    903 #endif 
    904  
    905  
    906  
    907 #define __sc_list(x)            x(1), x(2), x(3), x(4), x(5), x(6) 
    908  
    909 #ifndef __sysc_regs 
    910 #define __sysc_regs             __sc_list(__sysc_reg) 
    911 #endif 
    912  
    913 #ifndef __sysc_rcon 
    914 #define __sysc_rcon(n)          "g" 
    915 #endif 
    916  
    917  
    918858#ifdef  __sc_complex    /* complex result */ 
     859 
     860#define __sc_results    __sc_def_ret; __sc_def_err 
    919861 
    920862#ifndef __sysc_errc 
     
    924866#ifndef __sysc_retv 
    925867#define __sysc_retv(type, ret, err)                                     \ 
    926         __sysc_setret(ret);                                             \ 
    927868        if (__sysc_errc(ret, err)) {                                    \ 
    928                 int __err = (ret);                                      \ 
    929                 __sysc_seterr(__err);                                   \ 
     869                __sysc_seterr(ret);                                     \ 
    930870                ret = -1;                                               \ 
    931871        }                                                               \ 
     
    933873#endif 
    934874 
    935 #define __sc_results                                                    \ 
    936         __sc_res_def(__err, __sysc_reg_err)                             \ 
    937         __sc_res_def(__ret, __sysc_reg_ret) 
    938  
    939 #define __sc_oregs      "=r"(__ret), "=r"(__err) 
    940  
    941 #if     defined(__sc_trust) || !defined(__sysc_save) 
    942 #define __sc_saveres    __sc_dummy_save(1) 
    943 #else 
    944 #define __sc_saveres                                                    \ 
    945         __casm_nl(__sysc_save(__sysc_reg_ret,"%0"))                     \ 
    946         __casm_nl(__sysc_save(__sysc_reg_err,"%1")) 
    947 #endif 
    948  
    949 #define __sc_return(t)  __sysc_retv(t, __ret, __err) 
     875#define __sc_oregs      __sysc_con_ret (__sc_ret),                      \ 
     876                        __sysc_con_err (__sc_err) 
     877#define __sc_return(t)  ret = __sc_ret; err = __sc_err;                 \ 
     878                        __sysc_retv(t, ret, err) 
    950879 
    951880#else                   /* simple result  */ 
    952881 
     882#define __sc_results    __sc_def_ret 
     883 
    953884#ifndef __sysc_errc 
    954 #define __sysc_errc(res)                                              \ 
    955         ((unsigned __sysc_type)(res) >=                               \ 
     885#define __sysc_errc(ret)                                              \ 
     886        ((unsigned __sysc_type)(ret) >=                               \ 
    956887                (unsigned __sysc_type)(-(__sysc_max_err))) 
    957888#endif 
    958889 
    959890#ifndef __sysc_retv 
    960 #define __sysc_retv(type, res)                                          \ 
    961         __sysc_setret(res);                                             \ 
    962         if (__sysc_errc(res)) {                                         \ 
    963                 int __err = -(res);                                     \ 
    964                 __sysc_seterr(__err);                                   \ 
    965                 res = -1;                                               \ 
     891#define __sysc_retv(type, ret)                                          \ 
     892        if (__sysc_errc(ret)) {                                         \ 
     893                __sysc_seterr(-ret);                                    \ 
     894                ret = -1;                                               \ 
    966895        }                                                               \ 
    967         return (type)(res) 
    968 #endif 
    969  
    970  
    971 #define __sc_results                                                    \ 
    972         __sc_res_def(__res, __sysc_reg_res) 
    973  
    974 #define __sc_oregs      "=r"(__res) 
    975  
    976 #if     defined(__sc_trust) || !defined(__sysc_save) 
    977 #define __sc_saveres    __sc_dummy_save(0) 
    978 #else 
    979 #define __sc_saveres    __casm_nl(__sysc_save(__sysc_reg_res,"%0")) 
    980 #endif 
    981  
    982 #define __sc_return(t)  __sysc_retv(t, __res) 
     896        return (type)(ret) 
     897#endif 
     898 
     899#define __sc_oregs      __sysc_con_ret (__sc_ret) 
     900#define __sc_return(t)  ret = __sc_ret; __sysc_retv(t, ret) 
    983901 
    984902#endif                  /* simple/complex */ 
    985903 
    986904 
    987 #define __sc_dummy_load(n)      "/* gcc dummy load "                    \ 
    988         __casm(n,0,0,"%0 ",) __casm(n,1,0,"%1 ",) __casm(n,2,0,"%2 ",)  \ 
    989         __casm(n,3,0,"%3 ",) __casm(n,4,0,"%4 ",) __casm(n,5,0,"%5 ",)  \ 
    990         __casm(n,6,0,"%6 ",) "*/" 
    991  
    992 #ifdef  __sysc_aout 
    993 #define __sc_dummy_save(n) 
    994 #define __sc_asmsave(n) 
    995 #else 
    996 #define __sc_dummy_save(n)      "/* gcc dummy save "                    \ 
    997         __casm(n,0,0,"%0 ",) __casm(n,1,0,"%1 ",) "*/" 
    998 #endif 
    999  
    1000 #define __comment(name)         "\t/* kernel sys_"                      \ 
    1001         #name "[" __stringify(__sc_id(name)) "] */" 
    1002  
    1003  
    1004 #define __sc_id(N)              __NR_##N 
    1005  
    1006 #ifndef __sysc_reg_cid 
    1007 #define __sc_cid(N)             "i"(__sc_id(N)) 
    1008 #define __sc_load_cid           "" 
    1009 #define __sc_callid(N) 
    1010 #else 
    1011 #define __sc_cid(N)             "r"(__cid) 
    1012 #define __sc_load_cid           __sysc_limm(__sysc_reg_cid,"%0") 
    1013 #define __sc_callid(N)                                                  \ 
    1014         __sc_asm_val(__cid, __sysc_reg_cid, __sc_id(N)); 
    1015 #endif 
    1016  
    1017 #ifndef __sysc_cmd_pre 
    1018 #