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