Changeset 2495
- Timestamp:
- 02/11/07 21:16:05 (2 years ago)
- Files:
-
- trunk/lib/syscall-alternative.h (modified) (28 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/lib/syscall-alternative.h
r2297 r2495 1 // from http://vserver.13thfloor.at/Experimental/SYSCALL/syscall_shiny1 0.h1 // from http://vserver.13thfloor.at/Experimental/SYSCALL/syscall_shiny15.h 2 2 3 3 #ifndef __SYSCALL_NEW_H 4 4 #define __SYSCALL_NEW_H 5 5 6 /* Copyright (C) 2005-200 6Herbert Pötzl6 /* Copyright (C) 2005-2007 Herbert Pötzl 7 7 8 8 global config options 9 9 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>) 13 12 14 13 arch specific config 15 14 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 53 43 54 44 … … 68 58 call: callsys 69 59 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" 71 65 72 66 #define __sysc_reg_cid "$0" 67 #define __sysc_con_cid "v" 73 68 #define __sysc_reg_ret "$0" 69 #define __sysc_con_ret "=v" 74 70 #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" 84 76 85 77 … … 99 91 call: swi 100 92 clob: memory 93 move: mov $dR,$sR 101 94 */ 102 95 103 96 #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" 111 102 112 103 #warning syscall arch arm not tested yet … … 131 122 */ 132 123 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 147 125 148 126 … … 166 144 */ 167 145 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 179 147 180 148 … … 199 167 */ 200 168 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 224 170 225 171 … … 246 192 call: ble 0x100(%%sr2, %%r0) 247 193 clob: r1, r2, (r4), r20, r29, r31, memory 248 picr: pr(r19) 194 picr: pr(r19) do we need to save that? 249 195 */ 250 196 251 197 #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" 265 206 266 207 #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 273 215 274 216 … … 290 232 picr: pr(ebx) 291 233 clob: memory 234 move: movl $sR,$dR 292 235 */ 293 236 294 237 #define __sysc_max_err 129 295 #define __sysc_reg_res "eax"296 #define __sysc_cmd_sys "int $0x80"297 238 298 239 #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 327 264 328 265 … … 342 279 call: break 0x100000 343 280 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" 347 290 #define __sysc_reg_ret "r8" 348 291 #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 \ 358 294 "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", \ 360 296 "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", \ 361 297 "r31", "p6", "p7", "p8", "p9", "p10", "p11", "p12", "p13", \ … … 382 318 call: trap #2 383 319 clob: out6/7, r2/3/9, r11-r14, r16-r31, p6-p15, f6-f15, b6/7 320 move: mv %dR,%sR 384 321 */ 385 322 386 323 #define __sysc_max_err 125 324 325 #define __sysc_cmd(n) "trap #2" 326 327 #define __sysc_regs "r0", "r1", "r2", "r3", "r4", "r5" 387 328 #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" 395 330 396 331 #warning syscall arch m32r not tested yet … … 415 350 416 351 /* 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) 419 355 420 356 ABIN32 and ABI64 pass 6 args in a0-a3, t0-t1. 421 357 422 358 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) 424 360 sret: r0(v0) 425 361 serr: e0(a3) 426 362 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" 431 372 #define __sysc_reg_ret "v0" 432 373 #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 453 380 454 381 … … 467 394 serr: (carry) 468 395 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" 473 407 #define __sysc_reg_cid "r0" 474 408 #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" 487 411 488 412 … … 507 431 508 432 #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" 509 439 #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 519 443 520 444 … … 528 452 /* The SuperH calling convention passes the first four arguments 529 453 in r4-r7, the remainder is spilled onto the stack. However 530 the Linux kernel passes the remainder in r0-r 2.454 the Linux kernel passes the remainder in r0-r1. 531 455 532 456 scnr: id(r3) … … 536 460 call: trapa #0x1x (x=#args) 537 461 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 539 470 540 471 #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" 541 476 #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" 553 478 554 479 #warning syscall arch sh not tested yet … … 563 488 564 489 /* 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. 566 492 567 493 scnr: id(r9) … … 571 497 call: trapa #0x1x (x=#args) 572 498 clob: memory 499 move: ori %sR,0,%dR 573 500 */ 574 501 575 502 #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" 588 511 589 512 #warning syscall arch sh64 not tested yet … … 606 529 call: ta 0x6d, t 0x10 607 530 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" 611 545 #define __sysc_reg_cid "g1" 612 546 #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", \ 629 549 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", \ 630 550 "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", \ … … 635 555 "cc", "memory" 636 556 637 #warning syscall arch sparc not tested yet638 639 557 640 558 … … 658 576 659 577 #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" 660 583 #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" 670 588 671 589 #warning syscall arch v850 not tested yet … … 691 609 692 610 #define __sysc_max_err 4095 611 612 #define __sysc_cmd(n) "syscall" 613 614 #define __sysc_regs "rdi", "rsi", "rdx", "r10", "r8", "r9" 693 615 #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" 704 620 705 621 #else … … 707 623 #endif 708 624 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 710 664 711 665 … … 718 672 #define __lst_3(x,a1,a2,a3) __lst_2(x,a1,a2),x(3,a3) 719 673 #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) 721 675 #define __lst_0(x,a0) 722 676 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 */ 724 688 725 689 #define __con_6(x,a1,a2,a3,a4,a5,a6) __con_5(x,a1,a2,a3,a4,a5)x(6,a6) … … 731 695 #define __con_0(x,a0) 732 696 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 */ 759 709 760 710 #define __casm_use(q,r,v) v __casm_use_##q##r(__casm_nl("")) … … 827 777 #define __casm_66(v,w,r) __casm_use(1,r,v) 828 778 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 866 855 #define __sc_complex 867 856 #endif 868 857 869 870 #ifndef __sysc_type871 #define __sysc_type long872 #endif873 874 #define __sc_cast(v) (__sysc_type)(v)875 876 877 #define __sc_reg(n) register __sysc_type n878 #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_load882 #define __sc_inp_def(n,v) __sc_asm_val(__sc_a##n, __sysc_reg(n), v);883 #else884 #define __sc_inp_def(n,value)885 #endif886 887 #if !defined(__sysc_save) && !defined(__sysc_aout)888 #define __sc_res_def(n,r) __sc_asm_reg(n, r);889 #else890 #define __sc_res_def(n,r) __sc_reg(n);891 #endif892 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_trust898 #define __sc_iregs(n,...) __lst_##n(__sc_rreg,__VA_ARGS__)899 #define __sc_input(n,...) __con_##n(__sc_inp_def,__VA_ARGS__)900 #else901 #define __sc_iregs(n,...) __lst_##n(__sc_creg,__VA_ARGS__)902 #define __sc_input(n,...)903 #endif904 905 906 907 #define __sc_list(x) x(1), x(2), x(3), x(4), x(5), x(6)908 909 #ifndef __sysc_regs910 #define __sysc_regs __sc_list(__sysc_reg)911 #endif912 913 #ifndef __sysc_rcon914 #define __sysc_rcon(n) "g"915 #endif916 917 918 858 #ifdef __sc_complex /* complex result */ 859 860 #define __sc_results __sc_def_ret; __sc_def_err 919 861 920 862 #ifndef __sysc_errc … … 924 866 #ifndef __sysc_retv 925 867 #define __sysc_retv(type, ret, err) \ 926 __sysc_setret(ret); \927 868 if (__sysc_errc(ret, err)) { \ 928 int __err = (ret); \ 929 __sysc_seterr(__err); \ 869 __sysc_seterr(ret); \ 930 870 ret = -1; \ 931 871 } \ … … 933 873 #endif 934 874 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) 950 879 951 880 #else /* simple result */ 952 881 882 #define __sc_results __sc_def_ret 883 953 884 #ifndef __sysc_errc 954 #define __sysc_errc(re s) \955 ((unsigned __sysc_type)(re s) >= \885 #define __sysc_errc(ret) \ 886 ((unsigned __sysc_type)(ret) >= \ 956 887 (unsigned __sysc_type)(-(__sysc_max_err))) 957 888 #endif 958 889 959 890 #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; \ 966 895 } \ 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) 983 901 984 902 #endif /* simple/complex */ 985 903 986 904 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 #
