677 lines
14 KiB
ArmAsm
677 lines
14 KiB
ArmAsm
/*
|
||
* 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
|
||
|
||
/*
|
||
* 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
|
||
|
||
/*
|
||
* 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
|
||
|
||
/*
|
||
* 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
|
||
|
||
|
||
/*
|
||
* 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.
|
||
*/
|
||
|
||
.macro fork_like name
|
||
.align 4
|
||
.globl alpha_\name
|
||
.ent alpha_\name
|
||
alpha_\name:
|
||
.prologue 0
|
||
bsr $1, do_switch_stack
|
||
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
|
||
|
||
.align 4
|
||
.globl sys_sigreturn
|
||
.ent sys_sigreturn
|
||
sys_sigreturn:
|
||
.prologue 0
|
||
lda $9, ret_from_straced
|
||
cmpult $26, $9, $9
|
||
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
|
||
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
|