arch/alpha/kernel/entry.S

   1 /*
   2  * arch/alpha/kernel/entry.S
   3  *
   4  * Kernel entry-points.
   5  */
   6
   7 #include <asm/asm-offsets.h>
   8 #include <asm/thread_info.h>
   9 #include <asm/pal.h>
  10 #include <asm/errno.h>
  11 #include <asm/unistd.h>
  12
  13         .text
  14         .set noat
  15
  16 /* Stack offsets.  */
  17 #define SP_OFF                  184
  18 #define SWITCH_STACK_SIZE       320
  19
  20 /*
  21  * This defines the normal kernel pt-regs layout.
  22  *
  23  * regs 9-15 preserved by C code
  24  * regs 16-18 saved by PAL-code
  25  * regs 29-30 saved and set up by PAL-code
  26  * JRP - Save regs 16-18 in a special area of the stack, so that
  27  * the palcode-provided values are available to the signal handler.
  28  */
  29
  30 #define SAVE_ALL                        \
  31         subq    $sp, SP_OFF, $sp;       \
  32         stq     $0, 0($sp);             \
  33         stq     $1, 8($sp);             \
  34         stq     $2, 16($sp);            \
  35         stq     $3, 24($sp);            \
  36         stq     $4, 32($sp);            \
  37         stq     $28, 144($sp);          \
  38         lda     $2, alpha_mv;           \
  39         stq     $5, 40($sp);            \
  40         stq     $6, 48($sp);            \
  41         stq     $7, 56($sp);            \
  42         stq     $8, 64($sp);            \
  43         stq     $19, 72($sp);           \
  44         stq     $20, 80($sp);           \
  45         stq     $21, 88($sp);           \
  46         ldq     $2, HAE_CACHE($2);      \
  47         stq     $22, 96($sp);           \
  48         stq     $23, 104($sp);          \
  49         stq     $24, 112($sp);          \
  50         stq     $25, 120($sp);          \
  51         stq     $26, 128($sp);          \
  52         stq     $27, 136($sp);          \
  53         stq     $2, 152($sp);           \
  54         stq     $16, 160($sp);          \
  55         stq     $17, 168($sp);          \
  56         stq     $18, 176($sp)
  57
  58 #define RESTORE_ALL                     \
  59         lda     $19, alpha_mv;          \
  60         ldq     $0, 0($sp);             \
  61         ldq     $1, 8($sp);             \
  62         ldq     $2, 16($sp);            \
  63         ldq     $3, 24($sp);            \
  64         ldq     $21, 152($sp);          \
  65         ldq     $20, HAE_CACHE($19);    \
  66         ldq     $4, 32($sp);            \
  67         ldq     $5, 40($sp);            \
  68         ldq     $6, 48($sp);            \
  69         ldq     $7, 56($sp);            \
  70         subq    $20, $21, $20;          \
  71         ldq     $8, 64($sp);            \
  72         beq     $20, 99f;               \
  73         ldq     $20, HAE_REG($19);      \
  74         stq     $21, HAE_CACHE($19);    \
  75         stq     $21, 0($20);            \
  76 99:;                                    \
  77         ldq     $19, 72($sp);           \
  78         ldq     $20, 80($sp);           \
  79         ldq     $21, 88($sp);           \
  80         ldq     $22, 96($sp);           \
  81         ldq     $23, 104($sp);          \
  82         ldq     $24, 112($sp);          \
  83         ldq     $25, 120($sp);          \
  84         ldq     $26, 128($sp);          \
  85         ldq     $27, 136($sp);          \
  86         ldq     $28, 144($sp);          \
  87         addq    $sp, SP_OFF, $sp
  88
  89 /*
  90  * Non-syscall kernel entry points.
  91  */
  92
  93         .align  4
  94         .globl  entInt
  95         .ent    entInt
  96 entInt:
  97         SAVE_ALL
  98         lda     $8, 0x3fff
  99         lda     $26, ret_from_sys_call
 100         bic     $sp, $8, $8
 101         mov     $sp, $19
 102         jsr     $31, do_entInt
 103 .end entInt
 104
 105         .align  4
 106         .globl  entArith
 107         .ent    entArith
 108 entArith:
 109         SAVE_ALL
 110         lda     $8, 0x3fff
 111         lda     $26, ret_from_sys_call
 112         bic     $sp, $8, $8
 113         mov     $sp, $18
 114         jsr     $31, do_entArith
 115 .end entArith
 116
 117         .align  4
 118         .globl  entMM
 119         .ent    entMM
 120 entMM:
 121         SAVE_ALL
 122 /* save $9 - $15 so the inline exception code can manipulate them.  */
 123         subq    $sp, 56, $sp
 124         stq     $9, 0($sp)
 125         stq     $10, 8($sp)
 126         stq     $11, 16($sp)
 127         stq     $12, 24($sp)
 128         stq     $13, 32($sp)
 129         stq     $14, 40($sp)
 130         stq     $15, 48($sp)
 131         addq    $sp, 56, $19
 132 /* handle the fault */
 133         lda     $8, 0x3fff
 134         bic     $sp, $8, $8
 135         jsr     $26, do_page_fault
 136 /* reload the registers after the exception code played.  */
 137         ldq     $9, 0($sp)
 138         ldq     $10, 8($sp)
 139         ldq     $11, 16($sp)
 140         ldq     $12, 24($sp)
 141         ldq     $13, 32($sp)
 142         ldq     $14, 40($sp)
 143         ldq     $15, 48($sp)
 144         addq    $sp, 56, $sp
 145 /* finish up the syscall as normal.  */
 146         br      ret_from_sys_call
 147 .end entMM
 148
 149         .align  4
 150         .globl  entIF
 151         .ent    entIF
 152 entIF:
 153         SAVE_ALL
 154         lda     $8, 0x3fff
 155         lda     $26, ret_from_sys_call
 156         bic     $sp, $8, $8
 157         mov     $sp, $17
 158         jsr     $31, do_entIF
 159 .end entIF
 160
 161         .align  4
 162         .globl  entUna
 163         .ent    entUna
 164 entUna:
 165         lda     $sp, -256($sp)
 166         stq     $0, 0($sp)
 167         ldq     $0, 256($sp)    /* get PS */
 168         stq     $1, 8($sp)
 169         stq     $2, 16($sp)
 170         stq     $3, 24($sp)
 171         and     $0, 8, $0               /* user mode? */
 172         stq     $4, 32($sp)
 173         bne     $0, entUnaUser  /* yup -> do user-level unaligned fault */
 174         stq     $5, 40($sp)
 175         stq     $6, 48($sp)
 176         stq     $7, 56($sp)
 177         stq     $8, 64($sp)
 178         stq     $9, 72($sp)
 179         stq     $10, 80($sp)
 180         stq     $11, 88($sp)
 181         stq     $12, 96($sp)
 182         stq     $13, 104($sp)
 183         stq     $14, 112($sp)
 184         stq     $15, 120($sp)
 185         /* 16-18 PAL-saved */
 186         stq     $19, 152($sp)
 187         stq     $20, 160($sp)
 188         stq     $21, 168($sp)
 189         stq     $22, 176($sp)
 190         stq     $23, 184($sp)
 191         stq     $24, 192($sp)
 192         stq     $25, 200($sp)
 193         stq     $26, 208($sp)
 194         stq     $27, 216($sp)
 195         stq     $28, 224($sp)
 196         mov     $sp, $19
 197         stq     $gp, 232($sp)
 198         lda     $8, 0x3fff
 199         stq     $31, 248($sp)
 200         bic     $sp, $8, $8
 201         jsr     $26, do_entUna
 202         ldq     $0, 0($sp)
 203         ldq     $1, 8($sp)
 204         ldq     $2, 16($sp)
 205         ldq     $3, 24($sp)
 206         ldq     $4, 32($sp)
 207         ldq     $5, 40($sp)
 208         ldq     $6, 48($sp)
 209         ldq     $7, 56($sp)
 210         ldq     $8, 64($sp)
 211         ldq     $9, 72($sp)
 212         ldq     $10, 80($sp)
 213         ldq     $11, 88($sp)
 214         ldq     $12, 96($sp)
 215         ldq     $13, 104($sp)
 216         ldq     $14, 112($sp)
 217         ldq     $15, 120($sp)
 218         /* 16-18 PAL-saved */
 219         ldq     $19, 152($sp)
 220         ldq     $20, 160($sp)
 221         ldq     $21, 168($sp)
 222         ldq     $22, 176($sp)
 223         ldq     $23, 184($sp)
 224         ldq     $24, 192($sp)
 225         ldq     $25, 200($sp)
 226         ldq     $26, 208($sp)
 227         ldq     $27, 216($sp)
 228         ldq     $28, 224($sp)
 229         ldq     $gp, 232($sp)
 230         lda     $sp, 256($sp)
 231         call_pal PAL_rti
 232 .end entUna
 233
 234         .align  4
 235         .ent    entUnaUser
 236 entUnaUser:
 237         ldq     $0, 0($sp)      /* restore original $0 */
 238         lda     $sp, 256($sp)   /* pop entUna's stack frame */
 239         SAVE_ALL                /* setup normal kernel stack */
 240         lda     $sp, -56($sp)
 241         stq     $9, 0($sp)
 242         stq     $10, 8($sp)
 243         stq     $11, 16($sp)
 244         stq     $12, 24($sp)
 245         stq     $13, 32($sp)
 246         stq     $14, 40($sp)
 247         stq     $15, 48($sp)
 248         lda     $8, 0x3fff
 249         addq    $sp, 56, $19
 250         bic     $sp, $8, $8
 251         jsr     $26, do_entUnaUser
 252         ldq     $9, 0($sp)
 253         ldq     $10, 8($sp)
 254         ldq     $11, 16($sp)
 255         ldq     $12, 24($sp)
 256         ldq     $13, 32($sp)
 257         ldq     $14, 40($sp)
 258         ldq     $15, 48($sp)
 259         lda     $sp, 56($sp)
 260         br      ret_from_sys_call
 261 .end entUnaUser
 262
 263         .align  4
 264         .globl  entDbg
 265         .ent    entDbg
 266 entDbg:
 267         SAVE_ALL
 268         lda     $8, 0x3fff
 269         lda     $26, ret_from_sys_call
 270         bic     $sp, $8, $8
 271         mov     $sp, $16
 272         jsr     $31, do_entDbg
 273 .end entDbg
 274 \f
 275 /*
 276  * The system call entry point is special.  Most importantly, it looks
 277  * like a function call to userspace as far as clobbered registers.  We
 278  * do preserve the argument registers (for syscall restarts) and $26
 279  * (for leaf syscall functions).
 280  *
 281  * So much for theory.  We don't take advantage of this yet.
 282  *
 283  * Note that a0-a2 are not saved by PALcode as with the other entry points.
 284  */
 285
 286         .align  4
 287         .globl  entSys
 288         .globl  ret_from_sys_call
 289         .ent    entSys
 290 entSys:
 291         SAVE_ALL
 292         lda     $8, 0x3fff
 293         bic     $sp, $8, $8
 294         lda     $4, NR_SYSCALLS($31)
 295         stq     $16, SP_OFF+24($sp)
 296         lda     $5, sys_call_table
 297         lda     $27, sys_ni_syscall
 298         cmpult  $0, $4, $4
 299         ldl     $3, TI_FLAGS($8)
 300         stq     $17, SP_OFF+32($sp)
 301         s8addq  $0, $5, $5
 302         stq     $18, SP_OFF+40($sp)
 303         blbs    $3, strace
 304         beq     $4, 1f
 305         ldq     $27, 0($5)
 306 1:      jsr     $26, ($27), alpha_ni_syscall
 307         ldgp    $gp, 0($26)
 308         blt     $0, $syscall_error      /* the call failed */
 309         stq     $0, 0($sp)
 310         stq     $31, 72($sp)            /* a3=0 => no error */
 311
 312         .align  4
 313 ret_from_sys_call:
 314         cmovne  $26, 0, $19             /* $19 = 0 => non-restartable */
 315         ldq     $0, SP_OFF($sp)
 316         and     $0, 8, $0
 317         beq     $0, ret_to_kernel
 318 ret_to_user:
 319         /* Make sure need_resched and sigpending don't change between
 320                 sampling and the rti.  */
 321         lda     $16, 7
 322         call_pal PAL_swpipl
 323         ldl     $5, TI_FLAGS($8)
 324         and     $5, _TIF_WORK_MASK, $2
 325         bne     $2, work_pending
 326 restore_all:
 327         RESTORE_ALL
 328         call_pal PAL_rti
 329
 330 ret_to_kernel:
 331         lda     $16, 7
 332         call_pal PAL_swpipl
 333         br restore_all
 334
 335         .align 3
 336 $syscall_error:
 337         /*
 338          * Some system calls (e.g., ptrace) can return arbitrary
 339          * values which might normally be mistaken as error numbers.
 340          * Those functions must zero $0 (v0) directly in the stack
 341          * frame to indicate that a negative return value wasn't an
 342          * error number..
 343          */
 344         ldq     $19, 0($sp)     /* old syscall nr (zero if success) */
 345         beq     $19, $ret_success
 346
 347         ldq     $20, 72($sp)    /* .. and this a3 */
 348         subq    $31, $0, $0     /* with error in v0 */
 349         addq    $31, 1, $1      /* set a3 for errno return */
 350         stq     $0, 0($sp)
 351         mov     $31, $26        /* tell "ret_from_sys_call" we can restart */
 352         stq     $1, 72($sp)     /* a3 for return */
 353         br      ret_from_sys_call
 354
 355 $ret_success:
 356         stq     $0, 0($sp)
 357         stq     $31, 72($sp)    /* a3=0 => no error */
 358         br      ret_from_sys_call
 359 .end entSys
 360
 361 /*
 362  * Do all cleanup when returning from all interrupts and system calls.
 363  *
 364  * Arguments:
 365  *       $5: TI_FLAGS.
 366  *       $8: current.
 367  *      $19: The old syscall number, or zero if this is not a return
 368  *           from a syscall that errored and is possibly restartable.
 369  *      $20: The old a3 value
 370  */
 371
 372         .align  4
 373         .ent    work_pending
 374 work_pending:
 375         and     $5, _TIF_NEED_RESCHED, $2
 376         beq     $2, $work_notifysig
 377
 378 $work_resched:
 379         subq    $sp, 16, $sp
 380         stq     $19, 0($sp)              /* save syscall nr */
 381         stq     $20, 8($sp)              /* and error indication (a3) */
 382         jsr     $26, schedule
 383         ldq     $19, 0($sp)
 384         ldq     $20, 8($sp)
 385         addq    $sp, 16, $sp
 386         /* Make sure need_resched and sigpending don't change between
 387                 sampling and the rti.  */
 388         lda     $16, 7
 389         call_pal PAL_swpipl
 390         ldl     $5, TI_FLAGS($8)
 391         and     $5, _TIF_WORK_MASK, $2
 392         beq     $2, restore_all
 393         and     $5, _TIF_NEED_RESCHED, $2
 394         bne     $2, $work_resched
 395
 396 $work_notifysig:
 397         mov     $sp, $16
 398         bsr     $1, do_switch_stack
 399         mov     $sp, $17
 400         mov     $5, $18
 401         mov     $19, $9         /* save old syscall number */
 402         mov     $20, $10        /* save old a3 */
 403         and     $5, _TIF_SIGPENDING, $2
 404         cmovne  $2, 0, $9       /* we don't want double syscall restarts */
 405         jsr     $26, do_notify_resume
 406         mov     $9, $19
 407         mov     $10, $20
 408         bsr     $1, undo_switch_stack
 409         br      ret_to_user
 410 .end work_pending
 411
 412 /*
 413  * PTRACE syscall handler
 414  */
 415
 416         .align  4
 417         .ent    strace
 418 strace:
 419         /* set up signal stack, call syscall_trace */
 420         bsr     $1, do_switch_stack
 421         jsr     $26, syscall_trace_enter /* returns the syscall number */
 422         bsr     $1, undo_switch_stack
 423
 424         /* get the arguments back.. */
 425         ldq     $16, SP_OFF+24($sp)
 426         ldq     $17, SP_OFF+32($sp)
 427         ldq     $18, SP_OFF+40($sp)
 428         ldq     $19, 72($sp)
 429         ldq     $20, 80($sp)
 430         ldq     $21, 88($sp)
 431
 432         /* get the system call pointer.. */
 433         lda     $1, NR_SYSCALLS($31)
 434         lda     $2, sys_call_table
 435         lda     $27, alpha_ni_syscall
 436         cmpult  $0, $1, $1
 437         s8addq  $0, $2, $2
 438         beq     $1, 1f
 439         ldq     $27, 0($2)
 440 1:      jsr     $26, ($27), sys_gettimeofday
 441 ret_from_straced:
 442         ldgp    $gp, 0($26)
 443
 444         /* check return.. */
 445         blt     $0, $strace_error       /* the call failed */
 446         stq     $31, 72($sp)            /* a3=0 => no error */
 447 $strace_success:
 448         stq     $0, 0($sp)              /* save return value */
 449
 450         bsr     $1, do_switch_stack
 451         jsr     $26, syscall_trace_leave
 452         bsr     $1, undo_switch_stack
 453         br      $31, ret_from_sys_call
 454
 455         .align  3
 456 $strace_error:
 457         ldq     $19, 0($sp)     /* old syscall nr (zero if success) */
 458         beq     $19, $strace_success
 459         ldq     $20, 72($sp)    /* .. and this a3 */
 460
 461         subq    $31, $0, $0     /* with error in v0 */
 462         addq    $31, 1, $1      /* set a3 for errno return */
 463         stq     $0, 0($sp)
 464         stq     $1, 72($sp)     /* a3 for return */
 465
 466         bsr     $1, do_switch_stack
 467         mov     $19, $9         /* save old syscall number */
 468         mov     $20, $10        /* save old a3 */
 469         jsr     $26, syscall_trace_leave
 470         mov     $9, $19
 471         mov     $10, $20
 472         bsr     $1, undo_switch_stack
 473
 474         mov     $31, $26        /* tell "ret_from_sys_call" we can restart */
 475         br      ret_from_sys_call
 476 .end strace
 477 \f
 478 /*
 479  * Save and restore the switch stack -- aka the balance of the user context.
 480  */
 481
 482         .align  4
 483         .ent    do_switch_stack
 484 do_switch_stack:
 485         lda     $sp, -SWITCH_STACK_SIZE($sp)
 486         stq     $9, 0($sp)
 487         stq     $10, 8($sp)
 488         stq     $11, 16($sp)
 489         stq     $12, 24($sp)
 490         stq     $13, 32($sp)
 491         stq     $14, 40($sp)
 492         stq     $15, 48($sp)
 493         stq     $26, 56($sp)
 494         stt     $f0, 64($sp)
 495         stt     $f1, 72($sp)
 496         stt     $f2, 80($sp)
 497         stt     $f3, 88($sp)
 498         stt     $f4, 96($sp)
 499         stt     $f5, 104($sp)
 500         stt     $f6, 112($sp)
 501         stt     $f7, 120($sp)
 502         stt     $f8, 128($sp)
 503         stt     $f9, 136($sp)
 504         stt     $f10, 144($sp)
 505         stt     $f11, 152($sp)
 506         stt     $f12, 160($sp)
 507         stt     $f13, 168($sp)
 508         stt     $f14, 176($sp)
 509         stt     $f15, 184($sp)
 510         stt     $f16, 192($sp)
 511         stt     $f17, 200($sp)
 512         stt     $f18, 208($sp)
 513         stt     $f19, 216($sp)
 514         stt     $f20, 224($sp)
 515         stt     $f21, 232($sp)
 516         stt     $f22, 240($sp)
 517         stt     $f23, 248($sp)
 518         stt     $f24, 256($sp)
 519         stt     $f25, 264($sp)
 520         stt     $f26, 272($sp)
 521         stt     $f27, 280($sp)
 522         mf_fpcr $f0             # get fpcr
 523         stt     $f28, 288($sp)
 524         stt     $f29, 296($sp)
 525         stt     $f30, 304($sp)
 526         stt     $f0, 312($sp)   # save fpcr in slot of $f31
 527         ldt     $f0, 64($sp)    # dont let "do_switch_stack" change fp state.
 528         ret     $31, ($1), 1
 529 .end do_switch_stack
 530
 531         .align  4
 532         .ent    undo_switch_stack
 533 undo_switch_stack:
 534         ldq     $9, 0($sp)
 535         ldq     $10, 8($sp)
 536         ldq     $11, 16($sp)
 537         ldq     $12, 24($sp)
 538         ldq     $13, 32($sp)
 539         ldq     $14, 40($sp)
 540         ldq     $15, 48($sp)
 541         ldq     $26, 56($sp)
 542         ldt     $f30, 312($sp)  # get saved fpcr
 543         ldt     $f0, 64($sp)
 544         ldt     $f1, 72($sp)
 545         ldt     $f2, 80($sp)
 546         ldt     $f3, 88($sp)
 547         mt_fpcr $f30            # install saved fpcr
 548         ldt     $f4, 96($sp)
 549         ldt     $f5, 104($sp)
 550         ldt     $f6, 112($sp)
 551         ldt     $f7, 120($sp)
 552         ldt     $f8, 128($sp)
 553         ldt     $f9, 136($sp)
 554         ldt     $f10, 144($sp)
 555         ldt     $f11, 152($sp)
 556         ldt     $f12, 160($sp)
 557         ldt     $f13, 168($sp)
 558         ldt     $f14, 176($sp)
 559         ldt     $f15, 184($sp)
 560         ldt     $f16, 192($sp)
 561         ldt     $f17, 200($sp)
 562         ldt     $f18, 208($sp)
 563         ldt     $f19, 216($sp)
 564         ldt     $f20, 224($sp)
 565         ldt     $f21, 232($sp)
 566         ldt     $f22, 240($sp)
 567         ldt     $f23, 248($sp)
 568         ldt     $f24, 256($sp)
 569         ldt     $f25, 264($sp)
 570         ldt     $f26, 272($sp)
 571         ldt     $f27, 280($sp)
 572         ldt     $f28, 288($sp)
 573         ldt     $f29, 296($sp)
 574         ldt     $f30, 304($sp)
 575         lda     $sp, SWITCH_STACK_SIZE($sp)
 576         ret     $31, ($1), 1
 577 .end undo_switch_stack
 578 \f
 579 /*
 580  * The meat of the context switch code.
 581  */
 582
 583         .align  4
 584         .globl  alpha_switch_to
 585         .ent    alpha_switch_to
 586 alpha_switch_to:
 587         .prologue 0
 588         bsr     $1, do_switch_stack
 589         call_pal PAL_swpctx
 590         lda     $8, 0x3fff
 591         bsr     $1, undo_switch_stack
 592         bic     $sp, $8, $8
 593         mov     $17, $0
 594         ret
 595 .end alpha_switch_to
 596
 597 /*
 598  * New processes begin life here.
 599  */
 600
 601         .globl  ret_from_fork
 602         .align  4
 603         .ent    ret_from_fork
 604 ret_from_fork:
 605         lda     $26, ret_from_sys_call
 606         mov     $17, $16
 607         jmp     $31, schedule_tail
 608 .end ret_from_fork
 609
 610 /*
 611  * ... and new kernel threads - here
 612  */
 613         .align 4
 614         .globl  ret_from_kernel_thread
 615         .ent    ret_from_kernel_thread
 616 ret_from_kernel_thread:
 617         mov     $17, $16
 618         jsr     $26, schedule_tail
 619         mov     $9, $27
 620         mov     $10, $16
 621         jsr     $26, ($9)
 622         ldgp    $gp, 0($26)
 623         mov     $0, $16
 624         mov     $31, $26
 625         jmp     $31, sys_exit
 626 .end ret_from_kernel_thread
 627
 628         .globl  ret_from_kernel_execve
 629         .align  4
 630         .ent    ret_from_kernel_execve
 631 ret_from_kernel_execve:
 632         mov     $16, $sp
 633         /* Avoid the HAE being gratuitously wrong, to avoid restoring it.  */
 634         ldq     $2, alpha_mv+HAE_CACHE
 635         stq     $2, 152($sp)            /* HAE */
 636         mov     $31, $19                /* to disable syscall restarts */
 637         br      $31, ret_to_user
 638
 639 .end    ret_from_kernel_execve
 640
 641 \f
 642 /*
 643  * Special system calls.  Most of these are special in that they either
 644  * have to play switch_stack games or in some way use the pt_regs struct.
 645  */
 646         .align  4
 647         .globl  sys_fork
 648         .ent    sys_fork
 649 sys_fork:
 650         .prologue 0
 651         mov     $sp, $21
 652         bsr     $1, do_switch_stack
 653         bis     $31, SIGCHLD, $16
 654         mov     $31, $17
 655         mov     $31, $18
 656         mov     $31, $19
 657         mov     $31, $20
 658         jsr     $26, alpha_clone
 659         bsr     $1, undo_switch_stack
 660         ret
 661 .end sys_fork
 662
 663         .align  4
 664         .globl  sys_clone
 665         .ent    sys_clone
 666 sys_clone:
 667         .prologue 0
 668         mov     $sp, $21
 669         bsr     $1, do_switch_stack
 670         /* $16, $17, $18, $19, $20 come from the user.  */
 671         jsr     $26, alpha_clone
 672         bsr     $1, undo_switch_stack
 673         ret
 674 .end sys_clone
 675
 676         .align  4
 677         .globl  sys_vfork
 678         .ent    sys_vfork
 679 sys_vfork:
 680         .prologue 0
 681         mov     $sp, $16
 682         bsr     $1, do_switch_stack
 683         jsr     $26, alpha_vfork
 684         bsr     $1, undo_switch_stack
 685         ret
 686 .end sys_vfork
 687
 688         .align  4
 689         .globl  sys_sigreturn
 690         .ent    sys_sigreturn
 691 sys_sigreturn:
 692         .prologue 0
 693         lda     $9, ret_from_straced
 694         cmpult  $26, $9, $9
 695         mov     $sp, $17
 696         lda     $18, -SWITCH_STACK_SIZE($sp)
 697         lda     $sp, -SWITCH_STACK_SIZE($sp)
 698         jsr     $26, do_sigreturn
 699         bne     $9, 1f
 700         jsr     $26, syscall_trace_leave
 701 1:      br      $1, undo_switch_stack
 702         br      ret_from_sys_call
 703 .end sys_sigreturn
 704
 705         .align  4
 706         .globl  sys_rt_sigreturn
 707         .ent    sys_rt_sigreturn
 708 sys_rt_sigreturn:
 709         .prologue 0
 710         lda     $9, ret_from_straced
 711         cmpult  $26, $9, $9
 712         mov     $sp, $17
 713         lda     $18, -SWITCH_STACK_SIZE($sp)
 714         lda     $sp, -SWITCH_STACK_SIZE($sp)
 715         jsr     $26, do_rt_sigreturn
 716         bne     $9, 1f
 717         jsr     $26, syscall_trace_leave
 718 1:      br      $1, undo_switch_stack
 719         br      ret_from_sys_call
 720 .end sys_rt_sigreturn
 721
 722         .align  4
 723         .globl  alpha_ni_syscall
 724         .ent    alpha_ni_syscall
 725 alpha_ni_syscall:
 726         .prologue 0
 727         /* Special because it also implements overflow handling via
 728            syscall number 0.  And if you recall, zero is a special
 729            trigger for "not an error".  Store large non-zero there.  */
 730         lda     $0, -ENOSYS
 731         unop
 732         stq     $0, 0($sp)
 733         ret
 734 .end alpha_ni_syscall