xref: /linux/arch/alpha/kernel/entry.S (revision 621cde16e49b3ecf7d59a8106a20aaebfb4a59a9)
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	64
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.endm
163
164.macro	UNDO_SWITCH_STACK
165	bsr	$1, undo_switch_stack
166	.cfi_restore	$9
167	.cfi_restore	$10
168	.cfi_restore	$11
169	.cfi_restore	$12
170	.cfi_restore	$13
171	.cfi_restore	$14
172	.cfi_restore	$15
173	.cfi_adjust_cfa_offset	-SWITCH_STACK_SIZE
174.endm
175
176/*
177 * Non-syscall kernel entry points.
178 */
179
180CFI_START_OSF_FRAME entInt
181	SAVE_ALL
182	lda	$8, 0x3fff
183	lda	$26, ret_from_sys_call
184	bic	$sp, $8, $8
185	mov	$sp, $19
186	jsr	$31, do_entInt
187CFI_END_OSF_FRAME entInt
188
189CFI_START_OSF_FRAME entArith
190	SAVE_ALL
191	lda	$8, 0x3fff
192	lda	$26, ret_from_sys_call
193	bic	$sp, $8, $8
194	mov	$sp, $18
195	jsr	$31, do_entArith
196CFI_END_OSF_FRAME entArith
197
198CFI_START_OSF_FRAME entMM
199	SAVE_ALL
200/* save $9 - $15 so the inline exception code can manipulate them.  */
201	subq	$sp, 56, $sp
202	.cfi_adjust_cfa_offset	56
203	stq	$9, 0($sp)
204	stq	$10, 8($sp)
205	stq	$11, 16($sp)
206	stq	$12, 24($sp)
207	stq	$13, 32($sp)
208	stq	$14, 40($sp)
209	stq	$15, 48($sp)
210	.cfi_rel_offset	$9, 0
211	.cfi_rel_offset	$10, 8
212	.cfi_rel_offset	$11, 16
213	.cfi_rel_offset	$12, 24
214	.cfi_rel_offset	$13, 32
215	.cfi_rel_offset	$14, 40
216	.cfi_rel_offset	$15, 48
217	addq	$sp, 56, $19
218/* handle the fault */
219	lda	$8, 0x3fff
220	bic	$sp, $8, $8
221	jsr	$26, do_page_fault
222/* reload the registers after the exception code played.  */
223	ldq	$9, 0($sp)
224	ldq	$10, 8($sp)
225	ldq	$11, 16($sp)
226	ldq	$12, 24($sp)
227	ldq	$13, 32($sp)
228	ldq	$14, 40($sp)
229	ldq	$15, 48($sp)
230	addq	$sp, 56, $sp
231	.cfi_restore	$9
232	.cfi_restore	$10
233	.cfi_restore	$11
234	.cfi_restore	$12
235	.cfi_restore	$13
236	.cfi_restore	$14
237	.cfi_restore	$15
238	.cfi_adjust_cfa_offset	-56
239/* finish up the syscall as normal.  */
240	br	ret_from_sys_call
241CFI_END_OSF_FRAME entMM
242
243CFI_START_OSF_FRAME entIF
244	SAVE_ALL
245	lda	$8, 0x3fff
246	lda	$26, ret_from_sys_call
247	bic	$sp, $8, $8
248	mov	$sp, $17
249	jsr	$31, do_entIF
250CFI_END_OSF_FRAME entIF
251
252CFI_START_OSF_FRAME entUna
253	lda	$sp, -256($sp)
254	.cfi_adjust_cfa_offset	256
255	stq	$0, 0($sp)
256	.cfi_rel_offset	$0, 0
257	.cfi_remember_state
258	ldq	$0, 256($sp)	/* get PS */
259	stq	$1, 8($sp)
260	stq	$2, 16($sp)
261	stq	$3, 24($sp)
262	and	$0, 8, $0		/* user mode? */
263	stq	$4, 32($sp)
264	bne	$0, entUnaUser	/* yup -> do user-level unaligned fault */
265	stq	$5, 40($sp)
266	stq	$6, 48($sp)
267	stq	$7, 56($sp)
268	stq	$8, 64($sp)
269	stq	$9, 72($sp)
270	stq	$10, 80($sp)
271	stq	$11, 88($sp)
272	stq	$12, 96($sp)
273	stq	$13, 104($sp)
274	stq	$14, 112($sp)
275	stq	$15, 120($sp)
276	/* 16-18 PAL-saved */
277	stq	$19, 152($sp)
278	stq	$20, 160($sp)
279	stq	$21, 168($sp)
280	stq	$22, 176($sp)
281	stq	$23, 184($sp)
282	stq	$24, 192($sp)
283	stq	$25, 200($sp)
284	stq	$26, 208($sp)
285	stq	$27, 216($sp)
286	stq	$28, 224($sp)
287	mov	$sp, $19
288	stq	$gp, 232($sp)
289	.cfi_rel_offset	$1, 1*8
290	.cfi_rel_offset	$2, 2*8
291	.cfi_rel_offset	$3, 3*8
292	.cfi_rel_offset	$4, 4*8
293	.cfi_rel_offset	$5, 5*8
294	.cfi_rel_offset	$6, 6*8
295	.cfi_rel_offset	$7, 7*8
296	.cfi_rel_offset	$8, 8*8
297	.cfi_rel_offset	$9, 9*8
298	.cfi_rel_offset	$10, 10*8
299	.cfi_rel_offset	$11, 11*8
300	.cfi_rel_offset	$12, 12*8
301	.cfi_rel_offset	$13, 13*8
302	.cfi_rel_offset	$14, 14*8
303	.cfi_rel_offset	$15, 15*8
304	.cfi_rel_offset	$19, 19*8
305	.cfi_rel_offset	$20, 20*8
306	.cfi_rel_offset	$21, 21*8
307	.cfi_rel_offset	$22, 22*8
308	.cfi_rel_offset	$23, 23*8
309	.cfi_rel_offset	$24, 24*8
310	.cfi_rel_offset	$25, 25*8
311	.cfi_rel_offset	$26, 26*8
312	.cfi_rel_offset	$27, 27*8
313	.cfi_rel_offset	$28, 28*8
314	.cfi_rel_offset	$29, 29*8
315	lda	$8, 0x3fff
316	stq	$31, 248($sp)
317	bic	$sp, $8, $8
318	jsr	$26, do_entUna
319	ldq	$0, 0($sp)
320	ldq	$1, 8($sp)
321	ldq	$2, 16($sp)
322	ldq	$3, 24($sp)
323	ldq	$4, 32($sp)
324	ldq	$5, 40($sp)
325	ldq	$6, 48($sp)
326	ldq	$7, 56($sp)
327	ldq	$8, 64($sp)
328	ldq	$9, 72($sp)
329	ldq	$10, 80($sp)
330	ldq	$11, 88($sp)
331	ldq	$12, 96($sp)
332	ldq	$13, 104($sp)
333	ldq	$14, 112($sp)
334	ldq	$15, 120($sp)
335	/* 16-18 PAL-saved */
336	ldq	$19, 152($sp)
337	ldq	$20, 160($sp)
338	ldq	$21, 168($sp)
339	ldq	$22, 176($sp)
340	ldq	$23, 184($sp)
341	ldq	$24, 192($sp)
342	ldq	$25, 200($sp)
343	ldq	$26, 208($sp)
344	ldq	$27, 216($sp)
345	ldq	$28, 224($sp)
346	ldq	$gp, 232($sp)
347	lda	$sp, 256($sp)
348	.cfi_restore	$1
349	.cfi_restore	$2
350	.cfi_restore	$3
351	.cfi_restore	$4
352	.cfi_restore	$5
353	.cfi_restore	$6
354	.cfi_restore	$7
355	.cfi_restore	$8
356	.cfi_restore	$9
357	.cfi_restore	$10
358	.cfi_restore	$11
359	.cfi_restore	$12
360	.cfi_restore	$13
361	.cfi_restore	$14
362	.cfi_restore	$15
363	.cfi_restore	$19
364	.cfi_restore	$20
365	.cfi_restore	$21
366	.cfi_restore	$22
367	.cfi_restore	$23
368	.cfi_restore	$24
369	.cfi_restore	$25
370	.cfi_restore	$26
371	.cfi_restore	$27
372	.cfi_restore	$28
373	.cfi_restore	$29
374	.cfi_adjust_cfa_offset	-256
375	call_pal PAL_rti
376
377	.align	4
378entUnaUser:
379	.cfi_restore_state
380	ldq	$0, 0($sp)	/* restore original $0 */
381	lda	$sp, 256($sp)	/* pop entUna's stack frame */
382	.cfi_restore	$0
383	.cfi_adjust_cfa_offset	-256
384	SAVE_ALL		/* setup normal kernel stack */
385	lda	$sp, -56($sp)
386	.cfi_adjust_cfa_offset	56
387	stq	$9, 0($sp)
388	stq	$10, 8($sp)
389	stq	$11, 16($sp)
390	stq	$12, 24($sp)
391	stq	$13, 32($sp)
392	stq	$14, 40($sp)
393	stq	$15, 48($sp)
394	.cfi_rel_offset	$9, 0
395	.cfi_rel_offset	$10, 8
396	.cfi_rel_offset	$11, 16
397	.cfi_rel_offset	$12, 24
398	.cfi_rel_offset	$13, 32
399	.cfi_rel_offset	$14, 40
400	.cfi_rel_offset	$15, 48
401	lda	$8, 0x3fff
402	addq	$sp, 56, $19
403	bic	$sp, $8, $8
404	jsr	$26, do_entUnaUser
405	ldq	$9, 0($sp)
406	ldq	$10, 8($sp)
407	ldq	$11, 16($sp)
408	ldq	$12, 24($sp)
409	ldq	$13, 32($sp)
410	ldq	$14, 40($sp)
411	ldq	$15, 48($sp)
412	lda	$sp, 56($sp)
413	.cfi_restore	$9
414	.cfi_restore	$10
415	.cfi_restore	$11
416	.cfi_restore	$12
417	.cfi_restore	$13
418	.cfi_restore	$14
419	.cfi_restore	$15
420	.cfi_adjust_cfa_offset	-56
421	br	ret_from_sys_call
422CFI_END_OSF_FRAME entUna
423
424CFI_START_OSF_FRAME entDbg
425	SAVE_ALL
426	lda	$8, 0x3fff
427	lda	$26, ret_from_sys_call
428	bic	$sp, $8, $8
429	mov	$sp, $16
430	jsr	$31, do_entDbg
431CFI_END_OSF_FRAME entDbg
432
433/*
434 * The system call entry point is special.  Most importantly, it looks
435 * like a function call to userspace as far as clobbered registers.  We
436 * do preserve the argument registers (for syscall restarts) and $26
437 * (for leaf syscall functions).
438 *
439 * So much for theory.  We don't take advantage of this yet.
440 *
441 * Note that a0-a2 are not saved by PALcode as with the other entry points.
442 */
443
444	.align	4
445	.globl	entSys
446	.type	entSys, @function
447	.cfi_startproc simple
448	.cfi_return_column 64
449	.cfi_def_cfa	$sp, 48
450	.cfi_rel_offset	64, 8
451	.cfi_rel_offset	$gp, 16
452entSys:
453	SAVE_ALL
454	lda	$8, 0x3fff
455	bic	$sp, $8, $8
456	lda	$4, NR_syscalls($31)
457	stq	$16, SP_OFF+24($sp)
458	lda	$5, sys_call_table
459	lda	$27, sys_ni_syscall
460	cmpult	$0, $4, $4
461	ldl	$3, TI_FLAGS($8)
462	stq	$17, SP_OFF+32($sp)
463	s8addq	$0, $5, $5
464	stq	$18, SP_OFF+40($sp)
465	.cfi_rel_offset	$16, SP_OFF+24
466	.cfi_rel_offset	$17, SP_OFF+32
467	.cfi_rel_offset	$18, SP_OFF+40
468#ifdef CONFIG_AUDITSYSCALL
469	lda     $6, _TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT
470	and     $3, $6, $3
471	bne     $3, strace
472#else
473	blbs    $3, strace		/* check for SYSCALL_TRACE in disguise */
474#endif
475	beq	$4, 1f
476	ldq	$27, 0($5)
4771:	jsr	$26, ($27), sys_ni_syscall
478	ldgp	$gp, 0($26)
479	blt	$0, $syscall_error	/* the call failed */
480$ret_success:
481	stq	$0, 0($sp)
482	stq	$31, 72($sp)		/* a3=0 => no error */
483
484	.align	4
485	.globl	ret_from_sys_call
486ret_from_sys_call:
487	cmovne	$26, 0, $18		/* $18 = 0 => non-restartable */
488	ldq	$0, SP_OFF($sp)
489	and	$0, 8, $0
490	beq	$0, ret_to_kernel
491ret_to_user:
492	/* Make sure need_resched and sigpending don't change between
493		sampling and the rti.  */
494	lda	$16, 7
495	call_pal PAL_swpipl
496	ldl	$17, TI_FLAGS($8)
497	and	$17, _TIF_WORK_MASK, $2
498	bne	$2, work_pending
499restore_all:
500	ldl	$2, TI_STATUS($8)
501	and	$2, TS_SAVED_FP | TS_RESTORE_FP, $3
502	bne	$3, restore_fpu
503restore_other:
504	.cfi_remember_state
505	RESTORE_ALL
506	call_pal PAL_rti
507
508ret_to_kernel:
509	.cfi_restore_state
510	lda	$16, 7
511	call_pal PAL_swpipl
512	br restore_other
513
514	.align 3
515$syscall_error:
516	/*
517	 * Some system calls (e.g., ptrace) can return arbitrary
518	 * values which might normally be mistaken as error numbers.
519	 * Those functions must zero $0 (v0) directly in the stack
520	 * frame to indicate that a negative return value wasn't an
521	 * error number..
522	 */
523	ldq	$18, 0($sp)	/* old syscall nr (zero if success) */
524	beq	$18, $ret_success
525
526	ldq	$19, 72($sp)	/* .. and this a3 */
527	subq	$31, $0, $0	/* with error in v0 */
528	addq	$31, 1, $1	/* set a3 for errno return */
529	stq	$0, 0($sp)
530	mov	$31, $26	/* tell "ret_from_sys_call" we can restart */
531	stq	$1, 72($sp)	/* a3 for return */
532	br	ret_from_sys_call
533
534/*
535 * Do all cleanup when returning from all interrupts and system calls.
536 *
537 * Arguments:
538 *       $8: current.
539 *      $17: TI_FLAGS.
540 *      $18: The old syscall number, or zero if this is not a return
541 *           from a syscall that errored and is possibly restartable.
542 *      $19: The old a3 value
543 */
544
545	.align	4
546	.type	work_pending, @function
547work_pending:
548	and	$17, _TIF_NOTIFY_RESUME | _TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL, $2
549	bne	$2, $work_notifysig
550
551$work_resched:
552	/*
553	 * We can get here only if we returned from syscall without SIGPENDING
554	 * or got through work_notifysig already.  Either case means no syscall
555	 * restarts for us, so let $18 and $19 burn.
556	 */
557	jsr	$26, schedule
558	mov	0, $18
559	br	ret_to_user
560
561$work_notifysig:
562	mov	$sp, $16
563	DO_SWITCH_STACK
564	jsr	$26, do_work_pending
565	UNDO_SWITCH_STACK
566	br	restore_all
567
568/*
569 * PTRACE syscall handler
570 */
571
572	.align	4
573	.type	strace, @function
574strace:
575	/* set up signal stack, call syscall_trace */
576	// NB: if anyone adds preemption, this block will need to be protected
577	ldl	$1, TI_STATUS($8)
578	and	$1, TS_SAVED_FP, $3
579	or	$1, TS_SAVED_FP, $2
580	bne	$3, 1f
581	stl	$2, TI_STATUS($8)
582	bsr	$26, __save_fpu
5831:
584	DO_SWITCH_STACK
585	jsr	$26, syscall_trace_enter /* returns the syscall number */
586	UNDO_SWITCH_STACK
587
588	/* get the arguments back.. */
589	ldq	$16, SP_OFF+24($sp)
590	ldq	$17, SP_OFF+32($sp)
591	ldq	$18, SP_OFF+40($sp)
592	ldq	$19, 72($sp)
593	ldq	$20, 80($sp)
594	ldq	$21, 88($sp)
595
596	/* get the system call pointer.. */
597	lda	$1, NR_syscalls($31)
598	lda	$2, sys_call_table
599	lda	$27, sys_ni_syscall
600	cmpult	$0, $1, $1
601	s8addq	$0, $2, $2
602	beq	$1, 1f
603	ldq	$27, 0($2)
6041:	jsr	$26, ($27), sys_gettimeofday
605ret_from_straced:
606	ldgp	$gp, 0($26)
607
608	/* check return.. */
609	blt	$0, $strace_error	/* the call failed */
610$strace_success:
611	stq	$31, 72($sp)		/* a3=0 => no error */
612	stq	$0, 0($sp)		/* save return value */
613
614	DO_SWITCH_STACK
615	jsr	$26, syscall_trace_leave
616	UNDO_SWITCH_STACK
617	br	$31, ret_from_sys_call
618
619	.align	3
620$strace_error:
621	ldq	$18, 0($sp)	/* old syscall nr (zero if success) */
622	beq	$18, $strace_success
623	ldq	$19, 72($sp)	/* .. and this a3 */
624
625	subq	$31, $0, $0	/* with error in v0 */
626	addq	$31, 1, $1	/* set a3 for errno return */
627	stq	$0, 0($sp)
628	stq	$1, 72($sp)	/* a3 for return */
629
630	DO_SWITCH_STACK
631	mov	$18, $9		/* save old syscall number */
632	mov	$19, $10	/* save old a3 */
633	jsr	$26, syscall_trace_leave
634	mov	$9, $18
635	mov	$10, $19
636	UNDO_SWITCH_STACK
637
638	mov	$31, $26	/* tell "ret_from_sys_call" we can restart */
639	br	ret_from_sys_call
640CFI_END_OSF_FRAME entSys
641
642/*
643 * Save and restore the switch stack -- aka the balance of the user context.
644 */
645
646	.align	4
647	.type	do_switch_stack, @function
648	.cfi_startproc simple
649	.cfi_return_column 64
650	.cfi_def_cfa $sp, 0
651	.cfi_register 64, $1
652do_switch_stack:
653	lda	$sp, -SWITCH_STACK_SIZE($sp)
654	.cfi_adjust_cfa_offset	SWITCH_STACK_SIZE
655	stq	$9, 0($sp)
656	stq	$10, 8($sp)
657	stq	$11, 16($sp)
658	stq	$12, 24($sp)
659	stq	$13, 32($sp)
660	stq	$14, 40($sp)
661	stq	$15, 48($sp)
662	stq	$26, 56($sp)
663	ret	$31, ($1), 1
664	.cfi_endproc
665	.size	do_switch_stack, .-do_switch_stack
666
667	.align	4
668	.type	undo_switch_stack, @function
669	.cfi_startproc simple
670	.cfi_def_cfa $sp, 0
671	.cfi_register 64, $1
672undo_switch_stack:
673	ldq	$9, 0($sp)
674	ldq	$10, 8($sp)
675	ldq	$11, 16($sp)
676	ldq	$12, 24($sp)
677	ldq	$13, 32($sp)
678	ldq	$14, 40($sp)
679	ldq	$15, 48($sp)
680	ldq	$26, 56($sp)
681	lda	$sp, SWITCH_STACK_SIZE($sp)
682	ret	$31, ($1), 1
683	.cfi_endproc
684	.size	undo_switch_stack, .-undo_switch_stack
685
686#define FR(n) n * 8 + TI_FP($8)
687	.align	4
688	.globl	__save_fpu
689	.type	__save_fpu, @function
690__save_fpu:
691#define V(n) stt	$f##n, FR(n)
692	V( 0); V( 1); V( 2); V( 3)
693	V( 4); V( 5); V( 6); V( 7)
694	V( 8); V( 9); V(10); V(11)
695	V(12); V(13); V(14); V(15)
696	V(16); V(17); V(18); V(19)
697	V(20); V(21); V(22); V(23)
698	V(24); V(25); V(26); V(27)
699	mf_fpcr	$f0		# get fpcr
700	V(28); V(29); V(30)
701	stt	$f0, FR(31)	# save fpcr in slot of $f31
702	ldt	$f0, FR(0)	# don't let "__save_fpu" change fp state.
703	ret
704#undef V
705	.size	__save_fpu, .-__save_fpu
706
707	.align	4
708restore_fpu:
709	and	$3, TS_RESTORE_FP, $3
710	bic	$2, TS_SAVED_FP | TS_RESTORE_FP, $2
711	beq	$3, 1f
712#define V(n) ldt	$f##n, FR(n)
713	ldt	$f30, FR(31)	# get saved fpcr
714	V( 0); V( 1); V( 2); V( 3)
715	mt_fpcr	$f30		# install saved fpcr
716	V( 4); V( 5); V( 6); V( 7)
717	V( 8); V( 9); V(10); V(11)
718	V(12); V(13); V(14); V(15)
719	V(16); V(17); V(18); V(19)
720	V(20); V(21); V(22); V(23)
721	V(24); V(25); V(26); V(27)
722	V(28); V(29); V(30)
7231:	stl $2, TI_STATUS($8)
724	br restore_other
725#undef V
726
727
728/*
729 * The meat of the context switch code.
730 */
731	.align	4
732	.globl	alpha_switch_to
733	.type	alpha_switch_to, @function
734	.cfi_startproc
735alpha_switch_to:
736	DO_SWITCH_STACK
737	ldl	$1, TI_STATUS($8)
738	and	$1, TS_RESTORE_FP, $3
739	bne	$3, 1f
740	or	$1, TS_RESTORE_FP | TS_SAVED_FP, $2
741	and	$1, TS_SAVED_FP, $3
742	stl	$2, TI_STATUS($8)
743	bne	$3, 1f
744	bsr	$26, __save_fpu
7451:
746	call_pal PAL_swpctx
747	lda	$8, 0x3fff
748	UNDO_SWITCH_STACK
749	bic	$sp, $8, $8
750	mov	$17, $0
751	ret
752	.cfi_endproc
753	.size	alpha_switch_to, .-alpha_switch_to
754
755/*
756 * New processes begin life here.
757 */
758
759	.globl	ret_from_fork
760	.align	4
761	.ent	ret_from_fork
762ret_from_fork:
763	lda	$26, ret_to_user
764	mov	$17, $16
765	jmp	$31, schedule_tail
766.end ret_from_fork
767
768/*
769 * ... and new kernel threads - here
770 */
771	.align 4
772	.globl	ret_from_kernel_thread
773	.ent	ret_from_kernel_thread
774ret_from_kernel_thread:
775	mov	$17, $16
776	jsr	$26, schedule_tail
777	mov	$9, $27
778	mov	$10, $16
779	jsr	$26, ($9)
780	br	$31, ret_to_user
781.end ret_from_kernel_thread
782
783
784/*
785 * Special system calls.  Most of these are special in that they either
786 * have to play switch_stack games.
787 */
788
789.macro	fork_like name
790	.align	4
791	.globl	alpha_\name
792	.ent	alpha_\name
793alpha_\name:
794	.prologue 0
795	bsr	$1, do_switch_stack
796	// NB: if anyone adds preemption, this block will need to be protected
797	ldl	$1, TI_STATUS($8)
798	and	$1, TS_SAVED_FP, $3
799	or	$1, TS_SAVED_FP, $2
800	bne	$3, 1f
801	stl	$2, TI_STATUS($8)
802	bsr	$26, __save_fpu
8031:
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
814fork_like clone3
815
816.macro	sigreturn_like name
817	.align	4
818	.globl	sys_\name
819	.ent	sys_\name
820sys_\name:
821	.prologue 0
822	lda	$9, ret_from_straced
823	cmpult	$26, $9, $9
824	lda	$sp, -SWITCH_STACK_SIZE($sp)
825	jsr	$26, do_\name
826	bne	$9, 1f
827	jsr	$26, syscall_trace_leave
8281:	br	$1, undo_switch_stack
829	br	ret_from_sys_call
830.end sys_\name
831.endm
832
833sigreturn_like sigreturn
834sigreturn_like rt_sigreturn
835
836	.align	4
837	.globl	alpha_syscall_zero
838	.ent	alpha_syscall_zero
839alpha_syscall_zero:
840	.prologue 0
841	/* Special because it needs to do something opposite to
842	   force_successful_syscall_return().  We use the saved
843	   syscall number for that, zero meaning "not an error".
844	   That works nicely, but for real syscall 0 we need to
845	   make sure that this logics doesn't get confused.
846	   Store a non-zero there - -ENOSYS we need in register
847	   for our return value will do just fine.
848	  */
849	lda	$0, -ENOSYS
850	unop
851	stq	$0, 0($sp)
852	ret
853.end alpha_syscall_zero
854