[deliverable/linux.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, $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:
	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	$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

$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:
 *       $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
	.ent	work_pending
work_pending:
	and	$17, _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 $18 and $19 burn.
	 */
	jsr	$26, schedule
	mov	0, $18
	br	ret_to_user

$work_notifysig:
	mov	$sp, $16
	bsr	$1, do_switch_stack
	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	$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 */

	bsr	$1, 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
	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)
	mov	$31, $19		/* to disable syscall restarts */
	br	$31, ret_to_user
.end ret_from_kernel_thread

\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
	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
fork_out:
	ldq	$26, 56($sp)
	lda	$sp, SWITCH_STACK_SIZE($sp)
	ret
.end sys_fork

	.align	4
	.globl	sys_clone
	.ent	sys_clone
sys_clone:
	.prologue 0
	bsr	$1, do_switch_stack
	/* $16, $17, $18, $19, $20 come from the user.  */
	lda	$26, fork_out
	jsr	$31, alpha_clone
.end sys_clone

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