/* SPDX-License-Identifier: GPL-2.0 */
/*
 * arch/alpha/kernel/entry.S
 *
 * Kernel entry-points.
 */

#include <asm/asm-offsets.h>
#include <asm/thread_info.h>
#include <asm/pal.h>
#include <asm/errno.h>
#include <asm/unistd.h>

        .text
        .set noat
        .cfi_sections   .debug_frame

.macro  CFI_START_OSF_FRAME     func
        .align  4
        .globl  \func
        .type   \func,@function
\func:
        .cfi_startproc simple
        .cfi_return_column 64
        .cfi_def_cfa    $sp, 48
        .cfi_rel_offset 64, 8
        .cfi_rel_offset $gp, 16
        .cfi_rel_offset $16, 24
        .cfi_rel_offset $17, 32
        .cfi_rel_offset $18, 40
.endm

.macro  CFI_END_OSF_FRAME       func
        .cfi_endproc
        .size   \func, . - \func
.endm

/*
 * This defines the normal kernel pt-regs layout.
 *
 * regs 9-15 preserved by C code
 * regs 16-18 saved by PAL-code
 * regs 29-30 saved and set up by PAL-code
 * JRP - Save regs 16-18 in a special area of the stack, so that
 * the palcode-provided values are available to the signal handler.
 */

.macro  SAVE_ALL
        subq    $sp, SP_OFF, $sp
        .cfi_adjust_cfa_offset  SP_OFF
        stq     $0, 0($sp)
        stq     $1, 8($sp)
        stq     $2, 16($sp)
        stq     $3, 24($sp)
        stq     $4, 32($sp)
        stq     $28, 144($sp)
        .cfi_rel_offset $0, 0
        .cfi_rel_offset $1, 8
        .cfi_rel_offset $2, 16
        .cfi_rel_offset $3, 24
        .cfi_rel_offset $4, 32
        .cfi_rel_offset $28, 144
        lda     $2, alpha_mv
        stq     $5, 40($sp)
        stq     $6, 48($sp)
        stq     $7, 56($sp)
        stq     $8, 64($sp)
        stq     $19, 72($sp)
        stq     $20, 80($sp)
        stq     $21, 88($sp)
        ldq     $2, HAE_CACHE($2)
        stq     $22, 96($sp)
        stq     $23, 104($sp)
        stq     $24, 112($sp)
        stq     $25, 120($sp)
        stq     $26, 128($sp)
        stq     $27, 136($sp)
        stq     $2, 152($sp)
        stq     $16, 160($sp)
        stq     $17, 168($sp)
        stq     $18, 176($sp)
        .cfi_rel_offset $5, 40
        .cfi_rel_offset $6, 48
        .cfi_rel_offset $7, 56
        .cfi_rel_offset $8, 64
        .cfi_rel_offset $19, 72
        .cfi_rel_offset $20, 80
        .cfi_rel_offset $21, 88
        .cfi_rel_offset $22, 96
        .cfi_rel_offset $23, 104
        .cfi_rel_offset $24, 112
        .cfi_rel_offset $25, 120
        .cfi_rel_offset $26, 128
        .cfi_rel_offset $27, 136
.endm

.macro  RESTORE_ALL
        lda     $19, alpha_mv
        ldq     $0, 0($sp)
        ldq     $1, 8($sp)
        ldq     $2, 16($sp)
        ldq     $3, 24($sp)
        ldq     $21, 152($sp)
        ldq     $20, HAE_CACHE($19)
        ldq     $4, 32($sp)
        ldq     $5, 40($sp)
        ldq     $6, 48($sp)
        ldq     $7, 56($sp)
        subq    $20, $21, $20
        ldq     $8, 64($sp)
        beq     $20, 99f
        ldq     $20, HAE_REG($19)
        stq     $21, HAE_CACHE($19)
        stq     $21, 0($20)
99:     ldq     $19, 72($sp)
        ldq     $20, 80($sp)
        ldq     $21, 88($sp)
        ldq     $22, 96($sp)
        ldq     $23, 104($sp)
        ldq     $24, 112($sp)
        ldq     $25, 120($sp)
        ldq     $26, 128($sp)
        ldq     $27, 136($sp)
        ldq     $28, 144($sp)
        addq    $sp, SP_OFF, $sp
        .cfi_restore    $0
        .cfi_restore    $1
        .cfi_restore    $2
        .cfi_restore    $3
        .cfi_restore    $4
        .cfi_restore    $5
        .cfi_restore    $6
        .cfi_restore    $7
        .cfi_restore    $8
        .cfi_restore    $19
        .cfi_restore    $20
        .cfi_restore    $21
        .cfi_restore    $22
        .cfi_restore    $23
        .cfi_restore    $24
        .cfi_restore    $25
        .cfi_restore    $26
        .cfi_restore    $27
        .cfi_restore    $28
        .cfi_adjust_cfa_offset  -SP_OFF
.endm

.macro  DO_SWITCH_STACK
        bsr     $1, do_switch_stack
        .cfi_adjust_cfa_offset  SWITCH_STACK_SIZE
        .cfi_rel_offset $9, 0
        .cfi_rel_offset $10, 8
        .cfi_rel_offset $11, 16
        .cfi_rel_offset $12, 24
        .cfi_rel_offset $13, 32
        .cfi_rel_offset $14, 40
        .cfi_rel_offset $15, 48
.endm

.macro  UNDO_SWITCH_STACK
        bsr     $1, undo_switch_stack
        .cfi_restore    $9
        .cfi_restore    $10
        .cfi_restore    $11
        .cfi_restore    $12
        .cfi_restore    $13
        .cfi_restore    $14
        .cfi_restore    $15
        .cfi_adjust_cfa_offset  -SWITCH_STACK_SIZE
.endm

/*
 * Non-syscall kernel entry points.
 */

CFI_START_OSF_FRAME entInt
        SAVE_ALL
        lda     $8, 0x3fff
        lda     $26, ret_from_sys_call
        bic     $sp, $8, $8
        mov     $sp, $19
        jsr     $31, do_entInt
CFI_END_OSF_FRAME entInt

CFI_START_OSF_FRAME entArith
        SAVE_ALL
        lda     $8, 0x3fff
        lda     $26, ret_from_sys_call
        bic     $sp, $8, $8
        mov     $sp, $18
        jsr     $31, do_entArith
CFI_END_OSF_FRAME entArith

CFI_START_OSF_FRAME entMM
        SAVE_ALL
/* save $9 - $15 so the inline exception code can manipulate them.  */
        subq    $sp, 64, $sp
        .cfi_adjust_cfa_offset  64
        stq     $9, 0($sp)
        stq     $10, 8($sp)
        stq     $11, 16($sp)
        stq     $12, 24($sp)
        stq     $13, 32($sp)
        stq     $14, 40($sp)
        stq     $15, 48($sp)
        .cfi_rel_offset $9, 0
        .cfi_rel_offset $10, 8
        .cfi_rel_offset $11, 16
        .cfi_rel_offset $12, 24
        .cfi_rel_offset $13, 32
        .cfi_rel_offset $14, 40
        .cfi_rel_offset $15, 48
        addq    $sp, 64, $19
/* handle the fault */
        lda     $8, 0x3fff
        bic     $sp, $8, $8
        jsr     $26, do_page_fault
/* reload the registers after the exception code played.  */
        ldq     $9, 0($sp)
        ldq     $10, 8($sp)
        ldq     $11, 16($sp)
        ldq     $12, 24($sp)
        ldq     $13, 32($sp)
        ldq     $14, 40($sp)
        ldq     $15, 48($sp)
        addq    $sp, 64, $sp
        .cfi_restore    $9
        .cfi_restore    $10
        .cfi_restore    $11
        .cfi_restore    $12
        .cfi_restore    $13
        .cfi_restore    $14
        .cfi_restore    $15
        .cfi_adjust_cfa_offset  -64
/* finish up the syscall as normal.  */
        br      ret_from_sys_call
CFI_END_OSF_FRAME entMM

CFI_START_OSF_FRAME entIF
        SAVE_ALL
        lda     $8, 0x3fff
        lda     $26, ret_from_sys_call
        bic     $sp, $8, $8
        mov     $sp, $17
        jsr     $31, do_entIF
CFI_END_OSF_FRAME entIF

CFI_START_OSF_FRAME entUna
        lda     $sp, -256($sp)
        .cfi_adjust_cfa_offset  256
        stq     $0, 0($sp)
        .cfi_rel_offset $0, 0
        .cfi_remember_state
        ldq     $0, 256($sp)    /* get PS */
        stq     $1, 8($sp)
        stq     $2, 16($sp)
        stq     $3, 24($sp)
        and     $0, 8, $0               /* user mode? */
        stq     $4, 32($sp)
        bne     $0, entUnaUser  /* yup -> do user-level unaligned fault */
        stq     $5, 40($sp)
        stq     $6, 48($sp)
        stq     $7, 56($sp)
        stq     $8, 64($sp)
        stq     $9, 72($sp)
        stq     $10, 80($sp)
        stq     $11, 88($sp)
        stq     $12, 96($sp)
        stq     $13, 104($sp)
        stq     $14, 112($sp)
        stq     $15, 120($sp)
        /* 16-18 PAL-saved */
        stq     $19, 152($sp)
        stq     $20, 160($sp)
        stq     $21, 168($sp)
        stq     $22, 176($sp)
        stq     $23, 184($sp)
        stq     $24, 192($sp)
        stq     $25, 200($sp)
        stq     $26, 208($sp)
        stq     $27, 216($sp)
        stq     $28, 224($sp)
        mov     $sp, $19
        stq     $gp, 232($sp)
        .cfi_rel_offset $1, 1*8
        .cfi_rel_offset $2, 2*8
        .cfi_rel_offset $3, 3*8
        .cfi_rel_offset $4, 4*8
        .cfi_rel_offset $5, 5*8
        .cfi_rel_offset $6, 6*8
        .cfi_rel_offset $7, 7*8
        .cfi_rel_offset $8, 8*8
        .cfi_rel_offset $9, 9*8
        .cfi_rel_offset $10, 10*8
        .cfi_rel_offset $11, 11*8
        .cfi_rel_offset $12, 12*8
        .cfi_rel_offset $13, 13*8
        .cfi_rel_offset $14, 14*8
        .cfi_rel_offset $15, 15*8
        .cfi_rel_offset $19, 19*8
        .cfi_rel_offset $20, 20*8
        .cfi_rel_offset $21, 21*8
        .cfi_rel_offset $22, 22*8
        .cfi_rel_offset $23, 23*8
        .cfi_rel_offset $24, 24*8
        .cfi_rel_offset $25, 25*8
        .cfi_rel_offset $26, 26*8
        .cfi_rel_offset $27, 27*8
        .cfi_rel_offset $28, 28*8
        .cfi_rel_offset $29, 29*8
        lda     $8, 0x3fff
        stq     $31, 248($sp)
        bic     $sp, $8, $8
        jsr     $26, do_entUna
        ldq     $0, 0($sp)
        ldq     $1, 8($sp)
        ldq     $2, 16($sp)
        ldq     $3, 24($sp)
        ldq     $4, 32($sp)
        ldq     $5, 40($sp)
        ldq     $6, 48($sp)
        ldq     $7, 56($sp)
        ldq     $8, 64($sp)
        ldq     $9, 72($sp)
        ldq     $10, 80($sp)
        ldq     $11, 88($sp)
        ldq     $12, 96($sp)
        ldq     $13, 104($sp)
        ldq     $14, 112($sp)
        ldq     $15, 120($sp)
        /* 16-18 PAL-saved */
        ldq     $19, 152($sp)
        ldq     $20, 160($sp)
        ldq     $21, 168($sp)
        ldq     $22, 176($sp)
        ldq     $23, 184($sp)
        ldq     $24, 192($sp)
        ldq     $25, 200($sp)
        ldq     $26, 208($sp)
        ldq     $27, 216($sp)
        ldq     $28, 224($sp)
        ldq     $gp, 232($sp)
        lda     $sp, 256($sp)
        .cfi_restore    $1
        .cfi_restore    $2
        .cfi_restore    $3
        .cfi_restore    $4
        .cfi_restore    $5
        .cfi_restore    $6
        .cfi_restore    $7
        .cfi_restore    $8
        .cfi_restore    $9
        .cfi_restore    $10
        .cfi_restore    $11
        .cfi_restore    $12
        .cfi_restore    $13
        .cfi_restore    $14
        .cfi_restore    $15
        .cfi_restore    $19
        .cfi_restore    $20
        .cfi_restore    $21
        .cfi_restore    $22
        .cfi_restore    $23
        .cfi_restore    $24
        .cfi_restore    $25
        .cfi_restore    $26
        .cfi_restore    $27
        .cfi_restore    $28
        .cfi_restore    $29
        .cfi_adjust_cfa_offset  -256
        call_pal PAL_rti

        .align  4
entUnaUser:
        .cfi_restore_state
        ldq     $0, 0($sp)      /* restore original $0 */
        lda     $sp, 256($sp)   /* pop entUna's stack frame */
        .cfi_restore    $0
        .cfi_adjust_cfa_offset  -256
        SAVE_ALL                /* setup normal kernel stack */
        lda     $sp, -64($sp)
        .cfi_adjust_cfa_offset  64
        stq     $9, 0($sp)
        stq     $10, 8($sp)
        stq     $11, 16($sp)
        stq     $12, 24($sp)
        stq     $13, 32($sp)
        stq     $14, 40($sp)
        stq     $15, 48($sp)
        .cfi_rel_offset $9, 0
        .cfi_rel_offset $10, 8
        .cfi_rel_offset $11, 16
        .cfi_rel_offset $12, 24
        .cfi_rel_offset $13, 32
        .cfi_rel_offset $14, 40
        .cfi_rel_offset $15, 48
        lda     $8, 0x3fff
        addq    $sp, 64, $19
        bic     $sp, $8, $8
        jsr     $26, do_entUnaUser
        ldq     $9, 0($sp)
        ldq     $10, 8($sp)
        ldq     $11, 16($sp)
        ldq     $12, 24($sp)
        ldq     $13, 32($sp)
        ldq     $14, 40($sp)
        ldq     $15, 48($sp)
        lda     $sp, 64($sp)
        .cfi_restore    $9
        .cfi_restore    $10
        .cfi_restore    $11
        .cfi_restore    $12
        .cfi_restore    $13
        .cfi_restore    $14
        .cfi_restore    $15
        .cfi_adjust_cfa_offset  -64
        br      ret_from_sys_call
CFI_END_OSF_FRAME entUna

CFI_START_OSF_FRAME entDbg
        SAVE_ALL
        lda     $8, 0x3fff
        lda     $26, ret_from_sys_call
        bic     $sp, $8, $8
        mov     $sp, $16
        jsr     $31, do_entDbg
CFI_END_OSF_FRAME entDbg

/*
 * The system call entry point is special.  Most importantly, it looks
 * like a function call to userspace as far as clobbered registers.  We
 * do preserve the argument registers (for syscall restarts) and $26
 * (for leaf syscall functions).
 *
 * So much for theory.  We don't take advantage of this yet.
 *
 * Note that a0-a2 are not saved by PALcode as with the other entry points.
 */

        .align  4
        .globl  entSys
        .type   entSys, @function
        .cfi_startproc simple
        .cfi_return_column 64
        .cfi_def_cfa    $sp, 48
        .cfi_rel_offset 64, 8
        .cfi_rel_offset $gp, 16
entSys:
        SAVE_ALL
        lda     $8, 0x3fff
        bic     $sp, $8, $8
        lda     $4, NR_syscalls($31)
        stq     $16, SP_OFF+24($sp)
        lda     $5, sys_call_table
        lda     $27, sys_ni_syscall
        cmpult  $0, $4, $4
        ldl     $3, TI_FLAGS($8)
        stq     $17, SP_OFF+32($sp)
        s8addq  $0, $5, $5
        stq     $18, SP_OFF+40($sp)
        .cfi_rel_offset $16, SP_OFF+24
        .cfi_rel_offset $17, SP_OFF+32
        .cfi_rel_offset $18, SP_OFF+40
#ifdef CONFIG_AUDITSYSCALL
        lda     $6, _TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT
        and     $3, $6, $3
        bne     $3, strace
#else
        blbs    $3, strace              /* check for SYSCALL_TRACE in disguise */
#endif
        beq     $4, 1f
        ldq     $27, 0($5)
1:      jsr     $26, ($27), sys_ni_syscall
        ldgp    $gp, 0($26)
        blt     $0, $syscall_error      /* the call failed */
$ret_success:
        stq     $0, 0($sp)
        stq     $31, 72($sp)            /* a3=0 => no error */

        .align  4
        .globl  ret_from_sys_call
ret_from_sys_call:
        cmovne  $26, 0, $18             /* $18 = 0 => non-restartable */
        ldq     $0, SP_OFF($sp)
        and     $0, 8, $0
        beq     $0, ret_to_kernel
ret_to_user:
        /* Make sure need_resched and sigpending don't change between
                sampling and the rti.  */
        lda     $16, 7
        call_pal PAL_swpipl
        ldl     $17, TI_FLAGS($8)
        and     $17, _TIF_WORK_MASK, $2
        bne     $2, work_pending
restore_all:
        ldl     $2, TI_STATUS($8)
        and     $2, TS_SAVED_FP | TS_RESTORE_FP, $3
        bne     $3, restore_fpu
restore_other:
        .cfi_remember_state
        RESTORE_ALL
        call_pal PAL_rti

ret_to_kernel:
        .cfi_restore_state
        lda     $16, 7
        call_pal PAL_swpipl
        br restore_other

        .align 3
$syscall_error:
        /*
         * Some system calls (e.g., ptrace) can return arbitrary
         * values which might normally be mistaken as error numbers.
         * Those functions must zero $0 (v0) directly in the stack
         * frame to indicate that a negative return value wasn't an
         * error number..
         */
        ldq     $18, 0($sp)     /* old syscall nr (zero if success) */
        beq     $18, $ret_success

        ldq     $19, 72($sp)    /* .. and this a3 */
        subq    $31, $0, $0     /* with error in v0 */
        addq    $31, 1, $1      /* set a3 for errno return */
        stq     $0, 0($sp)
        mov     $31, $26        /* tell "ret_from_sys_call" we can restart */
        stq     $1, 72($sp)     /* a3 for return */
        br      ret_from_sys_call

/*
 * Do all cleanup when returning from all interrupts and system calls.
 *
 * Arguments:
 *       $8: current.
 *      $17: TI_FLAGS.
 *      $18: The old syscall number, or zero if this is not a return
 *           from a syscall that errored and is possibly restartable.
 *      $19: The old a3 value
 */

        .align  4
        .type   work_pending, @function
work_pending:
        and     $17, _TIF_NOTIFY_RESUME | _TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL, $2
        bne     $2, $work_notifysig

$work_resched:
        /*
         * We can get here only if we returned from syscall without SIGPENDING
         * or got through work_notifysig already.  Either case means no syscall
         * restarts for us, so let $18 and $19 burn.
         */
        jsr     $26, schedule
        mov     0, $18
        br      ret_to_user

$work_notifysig:
        mov     $sp, $16
        DO_SWITCH_STACK
        jsr     $26, do_work_pending
        UNDO_SWITCH_STACK
        br      restore_all

/*
 * PTRACE syscall handler
 */

        .align  4
        .type   strace, @function
strace:
        /* set up signal stack, call syscall_trace */
        // NB: if anyone adds preemption, this block will need to be protected
        ldl     $1, TI_STATUS($8)
        and     $1, TS_SAVED_FP, $3
        or      $1, TS_SAVED_FP, $2
        bne     $3, 1f
        stl     $2, TI_STATUS($8)
        bsr     $26, __save_fpu
1:
        DO_SWITCH_STACK
        jsr     $26, syscall_trace_enter /* returns the syscall number */
        UNDO_SWITCH_STACK

        /* get the arguments back.. */
        ldq     $16, SP_OFF+24($sp)
        ldq     $17, SP_OFF+32($sp)
        ldq     $18, SP_OFF+40($sp)
        ldq     $19, 72($sp)
        ldq     $20, 80($sp)
        ldq     $21, 88($sp)

        /* get the system call pointer.. */
        lda     $1, NR_syscalls($31)
        lda     $2, sys_call_table
        lda     $27, sys_ni_syscall
        cmpult  $0, $1, $1
        s8addq  $0, $2, $2
        beq     $1, 1f
        ldq     $27, 0($2)
1:      jsr     $26, ($27), sys_gettimeofday
ret_from_straced:
        ldgp    $gp, 0($26)

        /* check return.. */
        blt     $0, $strace_error       /* the call failed */
$strace_success:
        stq     $31, 72($sp)            /* a3=0 => no error */
        stq     $0, 0($sp)              /* save return value */

        DO_SWITCH_STACK
        jsr     $26, syscall_trace_leave
        UNDO_SWITCH_STACK
        br      $31, ret_from_sys_call

        .align  3
$strace_error:
        ldq     $18, 0($sp)     /* old syscall nr (zero if success) */
        beq     $18, $strace_success
        ldq     $19, 72($sp)    /* .. and this a3 */

        subq    $31, $0, $0     /* with error in v0 */
        addq    $31, 1, $1      /* set a3 for errno return */
        stq     $0, 0($sp)
        stq     $1, 72($sp)     /* a3 for return */

        DO_SWITCH_STACK
        mov     $18, $9         /* save old syscall number */
        mov     $19, $10        /* save old a3 */
        jsr     $26, syscall_trace_leave
        mov     $9, $18
        mov     $10, $19
        UNDO_SWITCH_STACK

        mov     $31, $26        /* tell "ret_from_sys_call" we can restart */
        br      ret_from_sys_call
CFI_END_OSF_FRAME entSys

/*
 * Save and restore the switch stack -- aka the balance of the user context.
 */

        .align  4
        .type   do_switch_stack, @function
        .cfi_startproc simple
        .cfi_return_column 64
        .cfi_def_cfa $sp, 0
        .cfi_register 64, $1
do_switch_stack:
        lda     $sp, -SWITCH_STACK_SIZE($sp)
        .cfi_adjust_cfa_offset  SWITCH_STACK_SIZE
        stq     $9, 0($sp)
        stq     $10, 8($sp)
        stq     $11, 16($sp)
        stq     $12, 24($sp)
        stq     $13, 32($sp)
        stq     $14, 40($sp)
        stq     $15, 48($sp)
        stq     $26, 56($sp)
        ret     $31, ($1), 1
        .cfi_endproc
        .size   do_switch_stack, .-do_switch_stack

        .align  4
        .type   undo_switch_stack, @function
        .cfi_startproc simple
        .cfi_def_cfa $sp, 0
        .cfi_register 64, $1
undo_switch_stack:
        ldq     $9, 0($sp)
        ldq     $10, 8($sp)
        ldq     $11, 16($sp)
        ldq     $12, 24($sp)
        ldq     $13, 32($sp)
        ldq     $14, 40($sp)
        ldq     $15, 48($sp)
        ldq     $26, 56($sp)
        lda     $sp, SWITCH_STACK_SIZE($sp)
        ret     $31, ($1), 1
        .cfi_endproc
        .size   undo_switch_stack, .-undo_switch_stack

#define FR(n) n * 8 + TI_FP($8)
        .align  4
        .globl  __save_fpu
        .type   __save_fpu, @function
__save_fpu:
#define V(n) stt        $f##n, FR(n)
        V( 0); V( 1); V( 2); V( 3)
        V( 4); V( 5); V( 6); V( 7)
        V( 8); V( 9); V(10); V(11)
        V(12); V(13); V(14); V(15)
        V(16); V(17); V(18); V(19)
        V(20); V(21); V(22); V(23)
        V(24); V(25); V(26); V(27)
        mf_fpcr $f0             # get fpcr
        V(28); V(29); V(30)
        stt     $f0, FR(31)     # save fpcr in slot of $f31
        ldt     $f0, FR(0)      # don't let "__save_fpu" change fp state.
        ret
#undef V
        .size   __save_fpu, .-__save_fpu

        .align  4
restore_fpu:
        and     $3, TS_RESTORE_FP, $3
        bic     $2, TS_SAVED_FP | TS_RESTORE_FP, $2
        beq     $3, 1f
#define V(n) ldt        $f##n, FR(n)
        ldt     $f30, FR(31)    # get saved fpcr
        V( 0); V( 1); V( 2); V( 3)
        mt_fpcr $f30            # install saved fpcr
        V( 4); V( 5); V( 6); V( 7)
        V( 8); V( 9); V(10); V(11)
        V(12); V(13); V(14); V(15)
        V(16); V(17); V(18); V(19)
        V(20); V(21); V(22); V(23)
        V(24); V(25); V(26); V(27)
        V(28); V(29); V(30)
1:      stl $2, TI_STATUS($8)
        br restore_other
#undef V


/*
 * The meat of the context switch code.
 */
        .align  4
        .globl  alpha_switch_to
        .type   alpha_switch_to, @function
        .cfi_startproc
alpha_switch_to:
        DO_SWITCH_STACK
        ldl     $1, TI_STATUS($8)
        and     $1, TS_RESTORE_FP, $3
        bne     $3, 1f
        or      $1, TS_RESTORE_FP | TS_SAVED_FP, $2
        and     $1, TS_SAVED_FP, $3
        stl     $2, TI_STATUS($8)
        bne     $3, 1f
        bsr     $26, __save_fpu
1:
        call_pal PAL_swpctx
        lda     $8, 0x3fff
        UNDO_SWITCH_STACK
        bic     $sp, $8, $8
        mov     $17, $0
        ret
        .cfi_endproc
        .size   alpha_switch_to, .-alpha_switch_to

/*
 * New processes begin life here.
 */

        .globl  ret_from_fork
        .align  4
        .ent    ret_from_fork
ret_from_fork:
        lda     $26, ret_to_user
        mov     $17, $16
        jmp     $31, schedule_tail
.end ret_from_fork

/*
 * ... and new kernel threads - here
 */
        .align 4
        .globl  ret_from_kernel_thread
        .ent    ret_from_kernel_thread
ret_from_kernel_thread:
        mov     $17, $16
        jsr     $26, schedule_tail
        mov     $9, $27
        mov     $10, $16
        jsr     $26, ($9)
        br      $31, ret_to_user
.end ret_from_kernel_thread


/*
 * Special system calls.  Most of these are special in that they either
 * have to play switch_stack games.
 */

.macro  fork_like name
        .align  4
        .globl  alpha_\name
        .ent    alpha_\name
alpha_\name:
        .prologue 0
        bsr     $1, do_switch_stack
        // NB: if anyone adds preemption, this block will need to be protected
        ldl     $1, TI_STATUS($8)
        and     $1, TS_SAVED_FP, $3
        or      $1, TS_SAVED_FP, $2
        bne     $3, 1f
        stl     $2, TI_STATUS($8)
        bsr     $26, __save_fpu
1:
        jsr     $26, sys_\name
        ldq     $26, 56($sp)
        lda     $sp, SWITCH_STACK_SIZE($sp)
        ret
.end    alpha_\name
.endm

fork_like fork
fork_like vfork
fork_like clone
fork_like clone3

.macro  sigreturn_like name
        .align  4
        .globl  sys_\name
        .ent    sys_\name
sys_\name:
        .prologue 0
        lda     $9, ret_from_straced
        cmpult  $26, $9, $9
        lda     $sp, -SWITCH_STACK_SIZE($sp)
        jsr     $26, do_\name
        bne     $9, 1f
        jsr     $26, syscall_trace_leave
1:      br      $1, undo_switch_stack
        br      ret_from_sys_call
.end sys_\name
.endm

sigreturn_like sigreturn
sigreturn_like rt_sigreturn

        .align  4
        .globl  alpha_syscall_zero
        .ent    alpha_syscall_zero
alpha_syscall_zero:
        .prologue 0
        /* Special because it needs to do something opposite to
           force_successful_syscall_return().  We use the saved
           syscall number for that, zero meaning "not an error".
           That works nicely, but for real syscall 0 we need to
           make sure that this logics doesn't get confused.
           Store a non-zero there - -ENOSYS we need in register
           for our return value will do just fine.
          */
        lda     $0, -ENOSYS
        unop
        stq     $0, 0($sp)
        ret
.end alpha_syscall_zero