[mirror_ubuntu-artful-kernel.git] / arch / alpha / kernel / entry.S

/*
 * 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

/* Stack offsets.  */
#define SP_OFF			184
#define SWITCH_STACK_SIZE	320

/*
 * 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.
 */

#define SAVE_ALL			\
	subq	$sp, SP_OFF, $sp;	\
	stq	$0, 0($sp);		\
	stq	$1, 8($sp);		\
	stq	$2, 16($sp);		\
	stq	$3, 24($sp);		\
	stq	$4, 32($sp);		\
	stq	$28, 144($sp);		\
	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)

#define 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

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

	.align	4
	.globl	entInt
	.ent	entInt
entInt:
	SAVE_ALL
	lda	$8, 0x3fff
	lda	$26, ret_from_sys_call
	bic	$sp, $8, $8
	mov	$sp, $19
	jsr	$31, do_entInt
.end entInt

	.align	4
	.globl	entArith
	.ent	entArith
entArith:
	SAVE_ALL
	lda	$8, 0x3fff
	lda	$26, ret_from_sys_call
	bic	$sp, $8, $8
	mov	$sp, $18
	jsr	$31, do_entArith
.end entArith

	.align	4
	.globl	entMM
	.ent	entMM
entMM:
	SAVE_ALL
/* save $9 - $15 so the inline exception code can manipulate them.  */
	subq	$sp, 56, $sp
	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)
	addq	$sp, 56, $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, 56, $sp
/* finish up the syscall as normal.  */
	br	ret_from_sys_call
.end entMM

	.align	4
	.globl	entIF
	.ent	entIF
entIF:
	SAVE_ALL
	lda	$8, 0x3fff
	lda	$26, ret_from_sys_call
	bic	$sp, $8, $8
	mov	$sp, $17
	jsr	$31, do_entIF
.end entIF

	.align	4
	.globl	entUna
	.ent	entUna
entUna:
	lda	$sp, -256($sp)
	stq	$0, 0($sp)
	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)
	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)
	call_pal PAL_rti
.end entUna

	.align	4
	.ent	entUnaUser
entUnaUser:
	ldq	$0, 0($sp)	/* restore original $0 */
	lda	$sp, 256($sp)	/* pop entUna's stack frame */
	SAVE_ALL		/* setup normal kernel stack */
	lda	$sp, -56($sp)
	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)
	lda	$8, 0x3fff
	addq	$sp, 56, $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, 56($sp)
	br	ret_from_sys_call
.end entUnaUser

	.align	4
	.globl	entDbg
	.ent	entDbg
entDbg:
	SAVE_ALL
	lda	$8, 0x3fff
	lda	$26, ret_from_sys_call
	bic	$sp, $8, $8
	mov	$sp, $16
	jsr	$31, do_entDbg
.end entDbg
\f
/*
 * 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
	.globl	ret_from_sys_call
	.ent	entSys
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)
	blbs	$3, strace
	beq	$4, 1f
	ldq	$27, 0($5)
1:	jsr	$26, ($27), alpha_ni_syscall
	ldgp	$gp, 0($26)
	blt	$0, $syscall_error	/* the call failed */
	stq	$0, 0($sp)
	stq	$31, 72($sp)		/* a3=0 => no error */

	.align	4
ret_from_sys_call:
	cmovne	$26, 0, $19		/* $19 = 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	$5, TI_FLAGS($8)
	and	$5, _TIF_WORK_MASK, $2
	bne	$2, work_pending
restore_all:
	RESTORE_ALL
	call_pal PAL_rti

ret_to_kernel:
	lda	$16, 7
	call_pal PAL_swpipl
	br restore_all

	.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	$19, 0($sp)	/* old syscall nr (zero if success) */
	beq	$19, $ret_success

	ldq	$20, 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

$ret_success:
	stq	$0, 0($sp)
	stq	$31, 72($sp)	/* a3=0 => no error */
	br	ret_from_sys_call
.end entSys

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

	.align	4
	.ent	work_pending
work_pending:
	and	$5, _TIF_NOTIFY_RESUME | _TIF_SIGPENDING, $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 $19 and $20 burn.
	 */
	jsr	$26, schedule
	mov	0, $19
	br	ret_to_user

$work_notifysig:
	mov	$sp, $16
	bsr	$1, do_switch_stack
	mov	$sp, $17
	mov	$5, $18
	jsr	$26, do_work_pending
	bsr	$1, undo_switch_stack
	br	restore_all
.end work_pending

/*
 * PTRACE syscall handler
 */

	.align	4
	.ent	strace
strace:
	/* set up signal stack, call syscall_trace */
	bsr	$1, do_switch_stack
	jsr	$26, syscall_trace_enter /* returns the syscall number */
	bsr	$1, 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, alpha_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 */
	stq	$31, 72($sp)		/* a3=0 => no error */
$strace_success:
	stq	$0, 0($sp)		/* save return value */

	bsr	$1, do_switch_stack
	jsr	$26, syscall_trace_leave
	bsr	$1, undo_switch_stack
	br	$31, ret_from_sys_call

	.align	3
$strace_error:
	ldq	$19, 0($sp)	/* old syscall nr (zero if success) */
	beq	$19, $strace_success
	ldq	$20, 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 */

	bsr	$1, do_switch_stack
	mov	$19, $9		/* save old syscall number */
	mov	$20, $10	/* save old a3 */
	jsr	$26, syscall_trace_leave
	mov	$9, $19
	mov	$10, $20
	bsr	$1, undo_switch_stack

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

	.align	4
	.ent	do_switch_stack
do_switch_stack:
	lda	$sp, -SWITCH_STACK_SIZE($sp)
	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)
	stt	$f0, 64($sp)
	stt	$f1, 72($sp)
	stt	$f2, 80($sp)
	stt	$f3, 88($sp)
	stt	$f4, 96($sp)
	stt	$f5, 104($sp)
	stt	$f6, 112($sp)
	stt	$f7, 120($sp)
	stt	$f8, 128($sp)
	stt	$f9, 136($sp)
	stt	$f10, 144($sp)
	stt	$f11, 152($sp)
	stt	$f12, 160($sp)
	stt	$f13, 168($sp)
	stt	$f14, 176($sp)
	stt	$f15, 184($sp)
	stt	$f16, 192($sp)
	stt	$f17, 200($sp)
	stt	$f18, 208($sp)
	stt	$f19, 216($sp)
	stt	$f20, 224($sp)
	stt	$f21, 232($sp)
	stt	$f22, 240($sp)
	stt	$f23, 248($sp)
	stt	$f24, 256($sp)
	stt	$f25, 264($sp)
	stt	$f26, 272($sp)
	stt	$f27, 280($sp)
	mf_fpcr	$f0		# get fpcr
	stt	$f28, 288($sp)
	stt	$f29, 296($sp)
	stt	$f30, 304($sp)
	stt	$f0, 312($sp)	# save fpcr in slot of $f31
	ldt	$f0, 64($sp)	# dont let "do_switch_stack" change fp state.
	ret	$31, ($1), 1
.end do_switch_stack

	.align	4
	.ent	undo_switch_stack
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)
	ldt	$f30, 312($sp)	# get saved fpcr
	ldt	$f0, 64($sp)
	ldt	$f1, 72($sp)
	ldt	$f2, 80($sp)
	ldt	$f3, 88($sp)
	mt_fpcr	$f30		# install saved fpcr
	ldt	$f4, 96($sp)
	ldt	$f5, 104($sp)
	ldt	$f6, 112($sp)
	ldt	$f7, 120($sp)
	ldt	$f8, 128($sp)
	ldt	$f9, 136($sp)
	ldt	$f10, 144($sp)
	ldt	$f11, 152($sp)
	ldt	$f12, 160($sp)
	ldt	$f13, 168($sp)
	ldt	$f14, 176($sp)
	ldt	$f15, 184($sp)
	ldt	$f16, 192($sp)
	ldt	$f17, 200($sp)
	ldt	$f18, 208($sp)
	ldt	$f19, 216($sp)
	ldt	$f20, 224($sp)
	ldt	$f21, 232($sp)
	ldt	$f22, 240($sp)
	ldt	$f23, 248($sp)
	ldt	$f24, 256($sp)
	ldt	$f25, 264($sp)
	ldt	$f26, 272($sp)
	ldt	$f27, 280($sp)
	ldt	$f28, 288($sp)
	ldt	$f29, 296($sp)
	ldt	$f30, 304($sp)
	lda	$sp, SWITCH_STACK_SIZE($sp)
	ret	$31, ($1), 1
.end undo_switch_stack
\f
/*
 * The meat of the context switch code.
 */

	.align	4
	.globl	alpha_switch_to
	.ent	alpha_switch_to
alpha_switch_to:
	.prologue 0
	bsr	$1, do_switch_stack
	call_pal PAL_swpctx
	lda	$8, 0x3fff
	bsr	$1, undo_switch_stack
	bic	$sp, $8, $8
	mov	$17, $0
	ret
.end alpha_switch_to

/*
 * New processes begin life here.
 */

	.globl	ret_from_fork
	.align	4
	.ent	ret_from_fork
ret_from_fork:
	lda	$26, ret_from_sys_call
	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)
	ldgp	$gp, 0($26)
	mov	$0, $16
	mov	$31, $26
	jmp	$31, sys_exit
.end ret_from_kernel_thread

	.globl	ret_from_kernel_execve
	.align	4
	.ent	ret_from_kernel_execve
ret_from_kernel_execve:
	mov	$16, $sp
	/* Avoid the HAE being gratuitously wrong, to avoid restoring it.  */
	ldq	$2, alpha_mv+HAE_CACHE
	stq	$2, 152($sp)		/* HAE */
	mov	$31, $19		/* to disable syscall restarts */
	br	$31, ret_to_user

.end	ret_from_kernel_execve

\f
/*
 * Special system calls.  Most of these are special in that they either
 * have to play switch_stack games or in some way use the pt_regs struct.
 */
	.align	4
	.globl	sys_fork
	.ent	sys_fork
sys_fork:
	.prologue 0
	mov	$sp, $21
	bsr	$1, do_switch_stack
	bis	$31, SIGCHLD, $16
	mov	$31, $17
	mov	$31, $18
	mov	$31, $19
	mov	$31, $20
	jsr	$26, alpha_clone
	bsr	$1, undo_switch_stack
	ret
.end sys_fork

	.align	4
	.globl	sys_clone
	.ent	sys_clone
sys_clone:
	.prologue 0
	mov	$sp, $21
	bsr	$1, do_switch_stack
	/* $16, $17, $18, $19, $20 come from the user.  */
	jsr	$26, alpha_clone
	bsr	$1, undo_switch_stack
	ret
.end sys_clone

	.align	4
	.globl	sys_vfork
	.ent	sys_vfork
sys_vfork:
	.prologue 0
	mov	$sp, $16
	bsr	$1, do_switch_stack
	jsr	$26, alpha_vfork
	bsr	$1, undo_switch_stack
	ret
.end sys_vfork

	.align	4
	.globl	sys_sigreturn
	.ent	sys_sigreturn
sys_sigreturn:
	.prologue 0
	lda	$9, ret_from_straced
	cmpult	$26, $9, $9
	mov	$sp, $17
	lda	$18, -SWITCH_STACK_SIZE($sp)
	lda	$sp, -SWITCH_STACK_SIZE($sp)
	jsr	$26, do_sigreturn
	bne	$9, 1f
	jsr	$26, syscall_trace_leave
1:	br	$1, undo_switch_stack
	br	ret_from_sys_call
.end sys_sigreturn

	.align	4
	.globl	sys_rt_sigreturn
	.ent	sys_rt_sigreturn
sys_rt_sigreturn:
	.prologue 0
	lda	$9, ret_from_straced
	cmpult	$26, $9, $9
	mov	$sp, $17
	lda	$18, -SWITCH_STACK_SIZE($sp)
	lda	$sp, -SWITCH_STACK_SIZE($sp)
	jsr	$26, do_rt_sigreturn
	bne	$9, 1f
	jsr	$26, syscall_trace_leave
1:	br	$1, undo_switch_stack
	br	ret_from_sys_call
.end sys_rt_sigreturn

	.align	4
	.globl	alpha_ni_syscall
	.ent	alpha_ni_syscall
alpha_ni_syscall:
	.prologue 0
	/* Special because it also implements overflow handling via
	   syscall number 0.  And if you recall, zero is a special
	   trigger for "not an error".  Store large non-zero there.  */
	lda	$0, -ENOSYS
	unop
	stq	$0, 0($sp)
	ret
.end alpha_ni_syscall
Commit	Line	Data
1da177e4 LT	1	/*
	2	* arch/alpha/kernel/entry.S
	3	*
	4	* Kernel entry-points.
	5	*/
	6
e2d5df93	7	#include <asm/asm-offsets.h>
1da177e4 LT	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); \
1da177e4 LT	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)
d70ddac1	196	mov $sp, $19
1da177e4 LT	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
77edffb6	317	beq $0, ret_to_kernel
494486a1	318	ret_to_user:
1da177e4 LT	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
494486a1	325	bne $2, work_pending
1da177e4 LT	326	restore_all:
	327	RESTORE_ALL
	328	call_pal PAL_rti
	329
77edffb6 AV	330	ret_to_kernel:
	331	lda $16, 7
	332	call_pal PAL_swpipl
	333	br restore_all
	334
1da177e4 LT	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.
494486a1	369	* $20: The old a3 value
1da177e4 LT	370	*/
	371
	372	.align 4
	373	.ent work_pending
	374	work_pending:
7721d3c2 AV	375	and $5, _TIF_NOTIFY_RESUME \| _TIF_SIGPENDING, $2
7721d3c2 AV	376	bne $2, $work_notifysig
1da177e4 LT	377
1da177e4 LT	378	$work_resched:
7721d3c2 AV	379	/*
	380	* We can get here only if we returned from syscall without SIGPENDING
	381	* or got through work_notifysig already. Either case means no syscall
	382	* restarts for us, so let $19 and $20 burn.
	383	*/
1da177e4	384	jsr $26, schedule
7721d3c2 AV	385	mov 0, $19
7721d3c2 AV	386	br ret_to_user
1da177e4 LT	387
1da177e4 LT	388	$work_notifysig:
b927b3e2	389	mov $sp, $16
494486a1	390	bsr $1, do_switch_stack
b927b3e2 RH	391	mov $sp, $17
b927b3e2 RH	392	mov $5, $18
6972d6f2	393	jsr $26, do_work_pending
1da177e4	394	bsr $1, undo_switch_stack
6972d6f2	395	br restore_all
1da177e4 LT	396	.end work_pending
	397
	398	/*
	399	* PTRACE syscall handler
	400	*/
	401
	402	.align 4
	403	.ent strace
	404	strace:
	405	/* set up signal stack, call syscall_trace */
	406	bsr $1, do_switch_stack
12f79be9	407	jsr $26, syscall_trace_enter /* returns the syscall number */
1da177e4 LT	408	bsr $1, undo_switch_stack
1da177e4 LT	409
12f79be9	410	/* get the arguments back.. */
1da177e4 LT	411	ldq $16, SP_OFF+24($sp)
	412	ldq $17, SP_OFF+32($sp)
	413	ldq $18, SP_OFF+40($sp)
	414	ldq $19, 72($sp)
	415	ldq $20, 80($sp)
	416	ldq $21, 88($sp)
	417
	418	/* get the system call pointer.. */
	419	lda $1, NR_SYSCALLS($31)
	420	lda $2, sys_call_table
	421	lda $27, alpha_ni_syscall
	422	cmpult $0, $1, $1
	423	s8addq $0, $2, $2
	424	beq $1, 1f
	425	ldq $27, 0($2)
	426	1: jsr $26, ($27), sys_gettimeofday
53293638	427	ret_from_straced:
1da177e4 LT	428	ldgp $gp, 0($26)
	429
	430	/* check return.. */
	431	blt $0, $strace_error /* the call failed */
	432	stq $31, 72($sp) /* a3=0 => no error */
	433	$strace_success:
	434	stq $0, 0($sp) /* save return value */
	435
	436	bsr $1, do_switch_stack
12f79be9	437	jsr $26, syscall_trace_leave
1da177e4 LT	438	bsr $1, undo_switch_stack
	439	br $31, ret_from_sys_call
	440
	441	.align 3
	442	$strace_error:
	443	ldq $19, 0($sp) /* old syscall nr (zero if success) */
	444	beq $19, $strace_success
	445	ldq $20, 72($sp) /* .. and this a3 */
	446
	447	subq $31, $0, $0 /* with error in v0 */
	448	addq $31, 1, $1 /* set a3 for errno return */
	449	stq $0, 0($sp)
	450	stq $1, 72($sp) /* a3 for return */
	451
	452	bsr $1, do_switch_stack
	453	mov $19, $9 /* save old syscall number */
	454	mov $20, $10 /* save old a3 */
12f79be9	455	jsr $26, syscall_trace_leave
1da177e4 LT	456	mov $9, $19
	457	mov $10, $20
	458	bsr $1, undo_switch_stack
	459
	460	mov $31, $26 /* tell "ret_from_sys_call" we can restart */
	461	br ret_from_sys_call
	462	.end strace
	463	\f
	464	/*
	465	* Save and restore the switch stack -- aka the balance of the user context.
	466	*/
	467
	468	.align 4
	469	.ent do_switch_stack
	470	do_switch_stack:
	471	lda $sp, -SWITCH_STACK_SIZE($sp)
	472	stq $9, 0($sp)
	473	stq $10, 8($sp)
	474	stq $11, 16($sp)
	475	stq $12, 24($sp)
	476	stq $13, 32($sp)
	477	stq $14, 40($sp)
	478	stq $15, 48($sp)
	479	stq $26, 56($sp)
	480	stt $f0, 64($sp)
	481	stt $f1, 72($sp)
	482	stt $f2, 80($sp)
	483	stt $f3, 88($sp)
	484	stt $f4, 96($sp)
	485	stt $f5, 104($sp)
	486	stt $f6, 112($sp)
	487	stt $f7, 120($sp)
	488	stt $f8, 128($sp)
	489	stt $f9, 136($sp)
	490	stt $f10, 144($sp)
	491	stt $f11, 152($sp)
	492	stt $f12, 160($sp)
	493	stt $f13, 168($sp)
	494	stt $f14, 176($sp)
	495	stt $f15, 184($sp)
	496	stt $f16, 192($sp)
	497	stt $f17, 200($sp)
	498	stt $f18, 208($sp)
	499	stt $f19, 216($sp)
	500	stt $f20, 224($sp)
	501	stt $f21, 232($sp)
	502	stt $f22, 240($sp)
	503	stt $f23, 248($sp)
	504	stt $f24, 256($sp)
	505	stt $f25, 264($sp)
	506	stt $f26, 272($sp)
	507	stt $f27, 280($sp)
	508	mf_fpcr $f0 # get fpcr
	509	stt $f28, 288($sp)
	510	stt $f29, 296($sp)
	511	stt $f30, 304($sp)
	512	stt $f0, 312($sp) # save fpcr in slot of $f31
	513	ldt $f0, 64($sp) # dont let "do_switch_stack" change fp state.
	514	ret $31, ($1), 1
	515	.end do_switch_stack
	516
	517	.align 4
	518	.ent undo_switch_stack
	519	undo_switch_stack:
520	ldq $9, 0($sp)
521	ldq $10, 8($sp)
522	ldq $11, 16($sp)
523	ldq $12, 24($sp)
524	ldq $13, 32($sp)
525	ldq $14, 40($sp)
526	ldq $15, 48($sp)
527	ldq $26, 56($sp)
528	ldt $f30, 312($sp) # get saved fpcr
529	ldt $f0, 64($sp)
530	ldt $f1, 72($sp)
531	ldt $f2, 80($sp)
532	ldt $f3, 88($sp)
533	mt_fpcr $f30 # install saved fpcr
534	ldt $f4, 96($sp)
535	ldt $f5, 104($sp)
536	ldt $f6, 112($sp)
537	ldt $f7, 120($sp)
538	ldt $f8, 128($sp)
539	ldt $f9, 136($sp)
540	ldt $f10, 144($sp)
541	ldt $f11, 152($sp)
542	ldt $f12, 160($sp)
543	ldt $f13, 168($sp)
544	ldt $f14, 176($sp)
545	ldt $f15, 184($sp)
546	ldt $f16, 192($sp)
547	ldt $f17, 200($sp)
548	ldt $f18, 208($sp)
549	ldt $f19, 216($sp)
550	ldt $f20, 224($sp)
551	ldt $f21, 232($sp)
552	ldt $f22, 240($sp)
553	ldt $f23, 248($sp)
554	ldt $f24, 256($sp)
555	ldt $f25, 264($sp)
556	ldt $f26, 272($sp)
557	ldt $f27, 280($sp)
558	ldt $f28, 288($sp)
559	ldt $f29, 296($sp)
560	ldt $f30, 304($sp)
561	lda $sp, SWITCH_STACK_SIZE($sp)
562	ret $31, ($1), 1
563	.end undo_switch_stack
564	\f
565	/*
566	* The meat of the context switch code.
567	*/
568
569	.align 4
570	.globl alpha_switch_to
571	.ent alpha_switch_to
572	alpha_switch_to:
573	.prologue 0
574	bsr $1, do_switch_stack
575	call_pal PAL_swpctx
576	lda $8, 0x3fff
577	bsr $1, undo_switch_stack
578	bic $sp, $8, $8
579	mov $17, $0
580	ret
581	.end alpha_switch_to
582
583	/*
584	* New processes begin life here.
585	*/
586
587	.globl ret_from_fork
588	.align 4
589	.ent ret_from_fork
590	ret_from_fork:
591	lda $26, ret_from_sys_call
592	mov $17, $16
593	jmp $31, schedule_tail
594	.end ret_from_fork
595
596	/*
cba1ec7e	597	* ... and new kernel threads - here
1da177e4 LT	598	*/
1da177e4 LT	599	.align 4
cba1ec7e AV	600	.globl ret_from_kernel_thread
	601	.ent ret_from_kernel_thread
	602	ret_from_kernel_thread:
	603	mov $17, $16
	604	jsr $26, schedule_tail
	605	mov $9, $27
	606	mov $10, $16
	607	jsr $26, ($9)
1da177e4 LT	608	ldgp $gp, 0($26)
	609	mov $0, $16
	610	mov $31, $26
	611	jmp $31, sys_exit
cba1ec7e	612	.end ret_from_kernel_thread
1da177e4	613
44f4b56b AV	614	.globl ret_from_kernel_execve
	615	.align 4
	616	.ent ret_from_kernel_execve
	617	ret_from_kernel_execve:
	618	mov $16, $sp
	619	/* Avoid the HAE being gratuitously wrong, to avoid restoring it. */
	620	ldq $2, alpha_mv+HAE_CACHE
	621	stq $2, 152($sp) /* HAE */
	622	mov $31, $19 /* to disable syscall restarts */
	623	br $31, ret_to_user
	624
	625	.end ret_from_kernel_execve
	626
1da177e4 LT	627	\f
	628	/*
	629	* Special system calls. Most of these are special in that they either
	630	* have to play switch_stack games or in some way use the pt_regs struct.
	631	*/
	632	.align 4
	633	.globl sys_fork
	634	.ent sys_fork
	635	sys_fork:
	636	.prologue 0
	637	mov $sp, $21
	638	bsr $1, do_switch_stack
	639	bis $31, SIGCHLD, $16
	640	mov $31, $17
	641	mov $31, $18
	642	mov $31, $19
	643	mov $31, $20
	644	jsr $26, alpha_clone
	645	bsr $1, undo_switch_stack
	646	ret
	647	.end sys_fork
	648
	649	.align 4
	650	.globl sys_clone
	651	.ent sys_clone
	652	sys_clone:
	653	.prologue 0
	654	mov $sp, $21
	655	bsr $1, do_switch_stack
	656	/* $16, $17, $18, $19, $20 come from the user. */
	657	jsr $26, alpha_clone
	658	bsr $1, undo_switch_stack
	659	ret
	660	.end sys_clone
	661
	662	.align 4
	663	.globl sys_vfork
	664	.ent sys_vfork
	665	sys_vfork:
	666	.prologue 0
	667	mov $sp, $16
	668	bsr $1, do_switch_stack
	669	jsr $26, alpha_vfork
	670	bsr $1, undo_switch_stack
	671	ret
	672	.end sys_vfork
	673
	674	.align 4
	675	.globl sys_sigreturn
	676	.ent sys_sigreturn
	677	sys_sigreturn:
	678	.prologue 0
53293638 AV	679	lda $9, ret_from_straced
53293638 AV	680	cmpult $26, $9, $9
1da177e4 LT	681	mov $sp, $17
	682	lda $18, -SWITCH_STACK_SIZE($sp)
	683	lda $sp, -SWITCH_STACK_SIZE($sp)
	684	jsr $26, do_sigreturn
53293638	685	bne $9, 1f
12f79be9	686	jsr $26, syscall_trace_leave
53293638	687	1: br $1, undo_switch_stack
1da177e4 LT	688	br ret_from_sys_call
	689	.end sys_sigreturn
	690
	691	.align 4
	692	.globl sys_rt_sigreturn
	693	.ent sys_rt_sigreturn
	694	sys_rt_sigreturn:
	695	.prologue 0
53293638 AV	696	lda $9, ret_from_straced
53293638 AV	697	cmpult $26, $9, $9
1da177e4 LT	698	mov $sp, $17
	699	lda $18, -SWITCH_STACK_SIZE($sp)
	700	lda $sp, -SWITCH_STACK_SIZE($sp)
	701	jsr $26, do_rt_sigreturn
53293638	702	bne $9, 1f
12f79be9	703	jsr $26, syscall_trace_leave
53293638	704	1: br $1, undo_switch_stack
1da177e4 LT	705	br ret_from_sys_call
	706	.end sys_rt_sigreturn
	707
1da177e4 LT	708	.align 4
	709	.globl alpha_ni_syscall
	710	.ent alpha_ni_syscall
	711	alpha_ni_syscall:
	712	.prologue 0
	713	/* Special because it also implements overflow handling via
	714	syscall number 0. And if you recall, zero is a special
	715	trigger for "not an error". Store large non-zero there. */
	716	lda $0, -ENOSYS
	717	unop
	718	stq $0, 0($sp)
	719	ret
	720	.end alpha_ni_syscall