Merge branch 'x86-fpu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[firefly-linux-kernel-4.4.55.git] / arch / tile / kernel / intvec_64.S
1 /*
2  * Copyright 2011 Tilera Corporation. All Rights Reserved.
3  *
4  *   This program is free software; you can redistribute it and/or
5  *   modify it under the terms of the GNU General Public License
6  *   as published by the Free Software Foundation, version 2.
7  *
8  *   This program is distributed in the hope that it will be useful, but
9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11  *   NON INFRINGEMENT.  See the GNU General Public License for
12  *   more details.
13  *
14  * Linux interrupt vectors.
15  */
16
17 #include <linux/linkage.h>
18 #include <linux/errno.h>
19 #include <linux/unistd.h>
20 #include <asm/ptrace.h>
21 #include <asm/thread_info.h>
22 #include <asm/irqflags.h>
23 #include <asm/asm-offsets.h>
24 #include <asm/types.h>
25 #include <asm/signal.h>
26 #include <hv/hypervisor.h>
27 #include <arch/abi.h>
28 #include <arch/interrupts.h>
29 #include <arch/spr_def.h>
30
31 #ifdef CONFIG_PREEMPT
32 # error "No support for kernel preemption currently"
33 #endif
34
35 #define PTREGS_PTR(reg, ptreg) addli reg, sp, C_ABI_SAVE_AREA_SIZE + (ptreg)
36
37 #define PTREGS_OFFSET_SYSCALL PTREGS_OFFSET_REG(TREG_SYSCALL_NR)
38
39
40         .macro  push_reg reg, ptr=sp, delta=-8
41         {
42          st     \ptr, \reg
43          addli  \ptr, \ptr, \delta
44         }
45         .endm
46
47         .macro  pop_reg reg, ptr=sp, delta=8
48         {
49          ld     \reg, \ptr
50          addli  \ptr, \ptr, \delta
51         }
52         .endm
53
54         .macro  pop_reg_zero reg, zreg, ptr=sp, delta=8
55         {
56          move   \zreg, zero
57          ld     \reg, \ptr
58          addi   \ptr, \ptr, \delta
59         }
60         .endm
61
62         .macro  push_extra_callee_saves reg
63         PTREGS_PTR(\reg, PTREGS_OFFSET_REG(51))
64         push_reg r51, \reg
65         push_reg r50, \reg
66         push_reg r49, \reg
67         push_reg r48, \reg
68         push_reg r47, \reg
69         push_reg r46, \reg
70         push_reg r45, \reg
71         push_reg r44, \reg
72         push_reg r43, \reg
73         push_reg r42, \reg
74         push_reg r41, \reg
75         push_reg r40, \reg
76         push_reg r39, \reg
77         push_reg r38, \reg
78         push_reg r37, \reg
79         push_reg r36, \reg
80         push_reg r35, \reg
81         push_reg r34, \reg, PTREGS_OFFSET_BASE - PTREGS_OFFSET_REG(34)
82         .endm
83
84         .macro  panic str
85         .pushsection .rodata, "a"
86 1:
87         .asciz  "\str"
88         .popsection
89         {
90          moveli r0, hw2_last(1b)
91         }
92         {
93          shl16insli r0, r0, hw1(1b)
94         }
95         {
96          shl16insli r0, r0, hw0(1b)
97          jal    panic
98         }
99         .endm
100
101
102 #ifdef __COLLECT_LINKER_FEEDBACK__
103         .pushsection .text.intvec_feedback,"ax"
104 intvec_feedback:
105         .popsection
106 #endif
107
108         /*
109          * Default interrupt handler.
110          *
111          * vecnum is where we'll put this code.
112          * c_routine is the C routine we'll call.
113          *
114          * The C routine is passed two arguments:
115          * - A pointer to the pt_regs state.
116          * - The interrupt vector number.
117          *
118          * The "processing" argument specifies the code for processing
119          * the interrupt. Defaults to "handle_interrupt".
120          */
121         .macro  int_hand vecnum, vecname, c_routine, processing=handle_interrupt
122         .org    (\vecnum << 8)
123 intvec_\vecname:
124         /* Temporarily save a register so we have somewhere to work. */
125
126         mtspr   SPR_SYSTEM_SAVE_K_1, r0
127         mfspr   r0, SPR_EX_CONTEXT_K_1
128
129         andi    r0, r0, SPR_EX_CONTEXT_1_1__PL_MASK  /* mask off ICS */
130
131         .ifc    \vecnum, INT_DOUBLE_FAULT
132         /*
133          * For double-faults from user-space, fall through to the normal
134          * register save and stack setup path.  Otherwise, it's the
135          * hypervisor giving us one last chance to dump diagnostics, and we
136          * branch to the kernel_double_fault routine to do so.
137          */
138         beqz    r0, 1f
139         j       _kernel_double_fault
140 1:
141         .else
142         /*
143          * If we're coming from user-space, then set sp to the top of
144          * the kernel stack.  Otherwise, assume sp is already valid.
145          */
146         {
147          bnez   r0, 0f
148          move   r0, sp
149         }
150         .endif
151
152         .ifc    \c_routine, do_page_fault
153         /*
154          * The page_fault handler may be downcalled directly by the
155          * hypervisor even when Linux is running and has ICS set.
156          *
157          * In this case the contents of EX_CONTEXT_K_1 reflect the
158          * previous fault and can't be relied on to choose whether or
159          * not to reinitialize the stack pointer.  So we add a test
160          * to see whether SYSTEM_SAVE_K_2 has the high bit set,
161          * and if so we don't reinitialize sp, since we must be coming
162          * from Linux.  (In fact the precise case is !(val & ~1),
163          * but any Linux PC has to have the high bit set.)
164          *
165          * Note that the hypervisor *always* sets SYSTEM_SAVE_K_2 for
166          * any path that turns into a downcall to one of our TLB handlers.
167          *
168          * FIXME: if we end up never using this path, perhaps we should
169          * prevent the hypervisor from generating downcalls in this case.
170          * The advantage of getting a downcall is we can panic in Linux.
171          */
172         mfspr   r0, SPR_SYSTEM_SAVE_K_2
173         {
174          bltz   r0, 0f    /* high bit in S_S_1_2 is for a PC to use */
175          move   r0, sp
176         }
177         .endif
178
179
180         /*
181          * SYSTEM_SAVE_K_0 holds the cpu number in the low bits, and
182          * the current stack top in the higher bits.  So we recover
183          * our stack top by just masking off the low bits, then
184          * point sp at the top aligned address on the actual stack page.
185          */
186         mfspr   r0, SPR_SYSTEM_SAVE_K_0
187         mm      r0, zero, LOG2_THREAD_SIZE, 63
188
189 0:
190         /*
191          * Align the stack mod 64 so we can properly predict what
192          * cache lines we need to write-hint to reduce memory fetch
193          * latency as we enter the kernel.  The layout of memory is
194          * as follows, with cache line 0 at the lowest VA, and cache
195          * line 8 just below the r0 value this "andi" computes.
196          * Note that we never write to cache line 8, and we skip
197          * cache lines 1-3 for syscalls.
198          *
199          *    cache line 8: ptregs padding (two words)
200          *    cache line 7: sp, lr, pc, ex1, faultnum, orig_r0, flags, cmpexch
201          *    cache line 6: r46...r53 (tp)
202          *    cache line 5: r38...r45
203          *    cache line 4: r30...r37
204          *    cache line 3: r22...r29
205          *    cache line 2: r14...r21
206          *    cache line 1: r6...r13
207          *    cache line 0: 2 x frame, r0..r5
208          */
209         andi    r0, r0, -64
210
211         /*
212          * Push the first four registers on the stack, so that we can set
213          * them to vector-unique values before we jump to the common code.
214          *
215          * Registers are pushed on the stack as a struct pt_regs,
216          * with the sp initially just above the struct, and when we're
217          * done, sp points to the base of the struct, minus
218          * C_ABI_SAVE_AREA_SIZE, so we can directly jal to C code.
219          *
220          * This routine saves just the first four registers, plus the
221          * stack context so we can do proper backtracing right away,
222          * and defers to handle_interrupt to save the rest.
223          * The backtracer needs pc, ex1, lr, sp, r52, and faultnum.
224          */
225         addli   r0, r0, PTREGS_OFFSET_LR - (PTREGS_SIZE + KSTK_PTREGS_GAP)
226         wh64    r0   /* cache line 7 */
227         {
228          st     r0, lr
229          addli  r0, r0, PTREGS_OFFSET_SP - PTREGS_OFFSET_LR
230         }
231         {
232          st     r0, sp
233          addli  sp, r0, PTREGS_OFFSET_REG(52) - PTREGS_OFFSET_SP
234         }
235         wh64    sp   /* cache line 6 */
236         {
237          st     sp, r52
238          addli  sp, sp, PTREGS_OFFSET_REG(1) - PTREGS_OFFSET_REG(52)
239         }
240         wh64    sp   /* cache line 0 */
241         {
242          st     sp, r1
243          addli  sp, sp, PTREGS_OFFSET_REG(2) - PTREGS_OFFSET_REG(1)
244         }
245         {
246          st     sp, r2
247          addli  sp, sp, PTREGS_OFFSET_REG(3) - PTREGS_OFFSET_REG(2)
248         }
249         {
250          st     sp, r3
251          addli  sp, sp, PTREGS_OFFSET_PC - PTREGS_OFFSET_REG(3)
252         }
253         mfspr   r0, SPR_EX_CONTEXT_K_0
254         .ifc \processing,handle_syscall
255         /*
256          * Bump the saved PC by one bundle so that when we return, we won't
257          * execute the same swint instruction again.  We need to do this while
258          * we're in the critical section.
259          */
260         addi    r0, r0, 8
261         .endif
262         {
263          st     sp, r0
264          addli  sp, sp, PTREGS_OFFSET_EX1 - PTREGS_OFFSET_PC
265         }
266         mfspr   r0, SPR_EX_CONTEXT_K_1
267         {
268          st     sp, r0
269          addi   sp, sp, PTREGS_OFFSET_FAULTNUM - PTREGS_OFFSET_EX1
270         /*
271          * Use r0 for syscalls so it's a temporary; use r1 for interrupts
272          * so that it gets passed through unchanged to the handler routine.
273          * Note that the .if conditional confusingly spans bundles.
274          */
275          .ifc \processing,handle_syscall
276          movei  r0, \vecnum
277         }
278         {
279          st     sp, r0
280          .else
281          movei  r1, \vecnum
282         }
283         {
284          st     sp, r1
285          .endif
286          addli  sp, sp, PTREGS_OFFSET_REG(0) - PTREGS_OFFSET_FAULTNUM
287         }
288         mfspr   r0, SPR_SYSTEM_SAVE_K_1    /* Original r0 */
289         {
290          st     sp, r0
291          addi   sp, sp, -PTREGS_OFFSET_REG(0) - 8
292         }
293         {
294          st     sp, zero        /* write zero into "Next SP" frame pointer */
295          addi   sp, sp, -8      /* leave SP pointing at bottom of frame */
296         }
297         .ifc \processing,handle_syscall
298         j       handle_syscall
299         .else
300         /* Capture per-interrupt SPR context to registers. */
301         .ifc \c_routine, do_page_fault
302         mfspr   r2, SPR_SYSTEM_SAVE_K_3   /* address of page fault */
303         mfspr   r3, SPR_SYSTEM_SAVE_K_2   /* info about page fault */
304         .else
305         .ifc \vecnum, INT_ILL_TRANS
306         mfspr   r2, ILL_TRANS_REASON
307         .else
308         .ifc \vecnum, INT_DOUBLE_FAULT
309         mfspr   r2, SPR_SYSTEM_SAVE_K_2   /* double fault info from HV */
310         .else
311         .ifc \c_routine, do_trap
312         mfspr   r2, GPV_REASON
313         .else
314         .ifc \c_routine, op_handle_perf_interrupt
315         mfspr   r2, PERF_COUNT_STS
316 #if CHIP_HAS_AUX_PERF_COUNTERS()
317         .else
318         .ifc \c_routine, op_handle_aux_perf_interrupt
319         mfspr   r2, AUX_PERF_COUNT_STS
320         .endif
321 #endif
322         .endif
323         .endif
324         .endif
325         .endif
326         .endif
327         /* Put function pointer in r0 */
328         moveli  r0, hw2_last(\c_routine)
329         shl16insli r0, r0, hw1(\c_routine)
330         {
331          shl16insli r0, r0, hw0(\c_routine)
332          j       \processing
333         }
334         .endif
335         ENDPROC(intvec_\vecname)
336
337 #ifdef __COLLECT_LINKER_FEEDBACK__
338         .pushsection .text.intvec_feedback,"ax"
339         .org    (\vecnum << 5)
340         FEEDBACK_ENTER_EXPLICIT(intvec_\vecname, .intrpt1, 1 << 8)
341         jrp     lr
342         .popsection
343 #endif
344
345         .endm
346
347
348         /*
349          * Save the rest of the registers that we didn't save in the actual
350          * vector itself.  We can't use r0-r10 inclusive here.
351          */
352         .macro  finish_interrupt_save, function
353
354         /* If it's a syscall, save a proper orig_r0, otherwise just zero. */
355         PTREGS_PTR(r52, PTREGS_OFFSET_ORIG_R0)
356         {
357          .ifc \function,handle_syscall
358          st     r52, r0
359          .else
360          st     r52, zero
361          .endif
362          PTREGS_PTR(r52, PTREGS_OFFSET_TP)
363         }
364         st      r52, tp
365         {
366          mfspr  tp, CMPEXCH_VALUE
367          PTREGS_PTR(r52, PTREGS_OFFSET_CMPEXCH)
368         }
369
370         /*
371          * For ordinary syscalls, we save neither caller- nor callee-
372          * save registers, since the syscall invoker doesn't expect the
373          * caller-saves to be saved, and the called kernel functions will
374          * take care of saving the callee-saves for us.
375          *
376          * For interrupts we save just the caller-save registers.  Saving
377          * them is required (since the "caller" can't save them).  Again,
378          * the called kernel functions will restore the callee-save
379          * registers for us appropriately.
380          *
381          * On return, we normally restore nothing special for syscalls,
382          * and just the caller-save registers for interrupts.
383          *
384          * However, there are some important caveats to all this:
385          *
386          * - We always save a few callee-save registers to give us
387          *   some scratchpad registers to carry across function calls.
388          *
389          * - fork/vfork/etc require us to save all the callee-save
390          *   registers, which we do in PTREGS_SYSCALL_ALL_REGS, below.
391          *
392          * - We always save r0..r5 and r10 for syscalls, since we need
393          *   to reload them a bit later for the actual kernel call, and
394          *   since we might need them for -ERESTARTNOINTR, etc.
395          *
396          * - Before invoking a signal handler, we save the unsaved
397          *   callee-save registers so they are visible to the
398          *   signal handler or any ptracer.
399          *
400          * - If the unsaved callee-save registers are modified, we set
401          *   a bit in pt_regs so we know to reload them from pt_regs
402          *   and not just rely on the kernel function unwinding.
403          *   (Done for ptrace register writes and SA_SIGINFO handler.)
404          */
405         {
406          st     r52, tp
407          PTREGS_PTR(r52, PTREGS_OFFSET_REG(33))
408         }
409         wh64    r52    /* cache line 4 */
410         push_reg r33, r52
411         push_reg r32, r52
412         push_reg r31, r52
413         .ifc \function,handle_syscall
414         push_reg r30, r52, PTREGS_OFFSET_SYSCALL - PTREGS_OFFSET_REG(30)
415         push_reg TREG_SYSCALL_NR_NAME, r52, \
416           PTREGS_OFFSET_REG(5) - PTREGS_OFFSET_SYSCALL
417         .else
418
419         push_reg r30, r52, PTREGS_OFFSET_REG(29) - PTREGS_OFFSET_REG(30)
420         wh64    r52   /* cache line 3 */
421         push_reg r29, r52
422         push_reg r28, r52
423         push_reg r27, r52
424         push_reg r26, r52
425         push_reg r25, r52
426         push_reg r24, r52
427         push_reg r23, r52
428         push_reg r22, r52
429         wh64    r52   /* cache line 2 */
430         push_reg r21, r52
431         push_reg r20, r52
432         push_reg r19, r52
433         push_reg r18, r52
434         push_reg r17, r52
435         push_reg r16, r52
436         push_reg r15, r52
437         push_reg r14, r52
438         wh64    r52   /* cache line 1 */
439         push_reg r13, r52
440         push_reg r12, r52
441         push_reg r11, r52
442         push_reg r10, r52
443         push_reg r9, r52
444         push_reg r8, r52
445         push_reg r7, r52
446         push_reg r6, r52
447
448         .endif
449
450         push_reg r5, r52
451         st      r52, r4
452
453         /* Load tp with our per-cpu offset. */
454 #ifdef CONFIG_SMP
455         {
456          mfspr  r20, SPR_SYSTEM_SAVE_K_0
457          moveli r21, hw2_last(__per_cpu_offset)
458         }
459         {
460          shl16insli r21, r21, hw1(__per_cpu_offset)
461          bfextu r20, r20, 0, LOG2_THREAD_SIZE-1
462         }
463         shl16insli r21, r21, hw0(__per_cpu_offset)
464         shl3add r20, r20, r21
465         ld      tp, r20
466 #else
467         move    tp, zero
468 #endif
469
470         /*
471          * If we will be returning to the kernel, we will need to
472          * reset the interrupt masks to the state they had before.
473          * Set DISABLE_IRQ in flags iff we came from PL1 with irqs disabled.
474          */
475         mfspr   r32, SPR_EX_CONTEXT_K_1
476         {
477          andi   r32, r32, SPR_EX_CONTEXT_1_1__PL_MASK  /* mask off ICS */
478          PTREGS_PTR(r21, PTREGS_OFFSET_FLAGS)
479         }
480         beqzt   r32, 1f       /* zero if from user space */
481         IRQS_DISABLED(r32)    /* zero if irqs enabled */
482 #if PT_FLAGS_DISABLE_IRQ != 1
483 # error Value of IRQS_DISABLED used to set PT_FLAGS_DISABLE_IRQ; fix
484 #endif
485 1:
486         .ifnc \function,handle_syscall
487         /* Record the fact that we saved the caller-save registers above. */
488         ori     r32, r32, PT_FLAGS_CALLER_SAVES
489         .endif
490         st      r21, r32
491
492 #ifdef __COLLECT_LINKER_FEEDBACK__
493         /*
494          * Notify the feedback routines that we were in the
495          * appropriate fixed interrupt vector area.  Note that we
496          * still have ICS set at this point, so we can't invoke any
497          * atomic operations or we will panic.  The feedback
498          * routines internally preserve r0..r10 and r30 up.
499          */
500         .ifnc \function,handle_syscall
501         shli    r20, r1, 5
502         .else
503         moveli  r20, INT_SWINT_1 << 5
504         .endif
505         moveli  r21, hw2_last(intvec_feedback)
506         shl16insli r21, r21, hw1(intvec_feedback)
507         shl16insli r21, r21, hw0(intvec_feedback)
508         add     r20, r20, r21
509         jalr    r20
510
511         /* And now notify the feedback routines that we are here. */
512         FEEDBACK_ENTER(\function)
513 #endif
514
515         /*
516          * we've captured enough state to the stack (including in
517          * particular our EX_CONTEXT state) that we can now release
518          * the interrupt critical section and replace it with our
519          * standard "interrupts disabled" mask value.  This allows
520          * synchronous interrupts (and profile interrupts) to punch
521          * through from this point onwards.
522          */
523         .ifc \function,handle_nmi
524         IRQ_DISABLE_ALL(r20)
525         .else
526         IRQ_DISABLE(r20, r21)
527         .endif
528         mtspr   INTERRUPT_CRITICAL_SECTION, zero
529
530         /*
531          * Prepare the first 256 stack bytes to be rapidly accessible
532          * without having to fetch the background data.
533          */
534         addi    r52, sp, -64
535         {
536          wh64   r52
537          addi   r52, r52, -64
538         }
539         {
540          wh64   r52
541          addi   r52, r52, -64
542         }
543         {
544          wh64   r52
545          addi   r52, r52, -64
546         }
547         wh64    r52
548
549 #ifdef CONFIG_TRACE_IRQFLAGS
550         .ifnc \function,handle_nmi
551         /*
552          * We finally have enough state set up to notify the irq
553          * tracing code that irqs were disabled on entry to the handler.
554          * The TRACE_IRQS_OFF call clobbers registers r0-r29.
555          * For syscalls, we already have the register state saved away
556          * on the stack, so we don't bother to do any register saves here,
557          * and later we pop the registers back off the kernel stack.
558          * For interrupt handlers, save r0-r3 in callee-saved registers.
559          */
560         .ifnc \function,handle_syscall
561         { move r30, r0; move r31, r1 }
562         { move r32, r2; move r33, r3 }
563         .endif
564         TRACE_IRQS_OFF
565         .ifnc \function,handle_syscall
566         { move r0, r30; move r1, r31 }
567         { move r2, r32; move r3, r33 }
568         .endif
569         .endif
570 #endif
571
572         .endm
573
574         /*
575          * Redispatch a downcall.
576          */
577         .macro  dc_dispatch vecnum, vecname
578         .org    (\vecnum << 8)
579 intvec_\vecname:
580         j       hv_downcall_dispatch
581         ENDPROC(intvec_\vecname)
582         .endm
583
584         /*
585          * Common code for most interrupts.  The C function we're eventually
586          * going to is in r0, and the faultnum is in r1; the original
587          * values for those registers are on the stack.
588          */
589         .pushsection .text.handle_interrupt,"ax"
590 handle_interrupt:
591         finish_interrupt_save handle_interrupt
592
593         /* Jump to the C routine; it should enable irqs as soon as possible. */
594         {
595          jalr   r0
596          PTREGS_PTR(r0, PTREGS_OFFSET_BASE)
597         }
598         FEEDBACK_REENTER(handle_interrupt)
599         {
600          movei  r30, 0   /* not an NMI */
601          j      interrupt_return
602         }
603         STD_ENDPROC(handle_interrupt)
604
605 /*
606  * This routine takes a boolean in r30 indicating if this is an NMI.
607  * If so, we also expect a boolean in r31 indicating whether to
608  * re-enable the oprofile interrupts.
609  *
610  * Note that .Lresume_userspace is jumped to directly in several
611  * places, and we need to make sure r30 is set correctly in those
612  * callers as well.
613  */
614 STD_ENTRY(interrupt_return)
615         /* If we're resuming to kernel space, don't check thread flags. */
616         {
617          bnez   r30, .Lrestore_all  /* NMIs don't special-case user-space */
618          PTREGS_PTR(r29, PTREGS_OFFSET_EX1)
619         }
620         ld      r29, r29
621         andi    r29, r29, SPR_EX_CONTEXT_1_1__PL_MASK  /* mask off ICS */
622         {
623          beqzt  r29, .Lresume_userspace
624          PTREGS_PTR(r29, PTREGS_OFFSET_PC)
625         }
626
627         /* If we're resuming to _cpu_idle_nap, bump PC forward by 8. */
628         moveli  r27, hw2_last(_cpu_idle_nap)
629         {
630          ld     r28, r29
631          shl16insli r27, r27, hw1(_cpu_idle_nap)
632         }
633         {
634          shl16insli r27, r27, hw0(_cpu_idle_nap)
635         }
636         {
637          cmpeq  r27, r27, r28
638         }
639         {
640          blbc   r27, .Lrestore_all
641          addi   r28, r28, 8
642         }
643         st      r29, r28
644         j       .Lrestore_all
645
646 .Lresume_userspace:
647         FEEDBACK_REENTER(interrupt_return)
648
649         /*
650          * Use r33 to hold whether we have already loaded the callee-saves
651          * into ptregs.  We don't want to do it twice in this loop, since
652          * then we'd clobber whatever changes are made by ptrace, etc.
653          */
654         {
655          movei  r33, 0
656          move   r32, sp
657         }
658
659         /* Get base of stack in r32. */
660         EXTRACT_THREAD_INFO(r32)
661
662 .Lretry_work_pending:
663         /*
664          * Disable interrupts so as to make sure we don't
665          * miss an interrupt that sets any of the thread flags (like
666          * need_resched or sigpending) between sampling and the iret.
667          * Routines like schedule() or do_signal() may re-enable
668          * interrupts before returning.
669          */
670         IRQ_DISABLE(r20, r21)
671         TRACE_IRQS_OFF  /* Note: clobbers registers r0-r29 */
672
673
674         /* Check to see if there is any work to do before returning to user. */
675         {
676          addi   r29, r32, THREAD_INFO_FLAGS_OFFSET
677          moveli r1, hw1_last(_TIF_ALLWORK_MASK)
678         }
679         {
680          ld     r29, r29
681          shl16insli r1, r1, hw0(_TIF_ALLWORK_MASK)
682         }
683         and     r1, r29, r1
684         beqzt   r1, .Lrestore_all
685
686         /*
687          * Make sure we have all the registers saved for signal
688          * handling or notify-resume.  Call out to C code to figure out
689          * exactly what we need to do for each flag bit, then if
690          * necessary, reload the flags and recheck.
691          */
692         {
693          PTREGS_PTR(r0, PTREGS_OFFSET_BASE)
694          bnez   r33, 1f
695         }
696         push_extra_callee_saves r0
697         movei   r33, 1
698 1:      jal     do_work_pending
699         bnez    r0, .Lretry_work_pending
700
701         /*
702          * In the NMI case we
703          * omit the call to single_process_check_nohz, which normally checks
704          * to see if we should start or stop the scheduler tick, because
705          * we can't call arbitrary Linux code from an NMI context.
706          * We always call the homecache TLB deferral code to re-trigger
707          * the deferral mechanism.
708          *
709          * The other chunk of responsibility this code has is to reset the
710          * interrupt masks appropriately to reset irqs and NMIs.  We have
711          * to call TRACE_IRQS_OFF and TRACE_IRQS_ON to support all the
712          * lockdep-type stuff, but we can't set ICS until afterwards, since
713          * ICS can only be used in very tight chunks of code to avoid
714          * tripping over various assertions that it is off.
715          */
716 .Lrestore_all:
717         PTREGS_PTR(r0, PTREGS_OFFSET_EX1)
718         {
719          ld      r0, r0
720          PTREGS_PTR(r32, PTREGS_OFFSET_FLAGS)
721         }
722         {
723          andi   r0, r0, SPR_EX_CONTEXT_1_1__PL_MASK
724          ld     r32, r32
725         }
726         bnez    r0, 1f
727         j       2f
728 #if PT_FLAGS_DISABLE_IRQ != 1
729 # error Assuming PT_FLAGS_DISABLE_IRQ == 1 so we can use blbct below
730 #endif
731 1:      blbct   r32, 2f
732         IRQ_DISABLE(r20,r21)
733         TRACE_IRQS_OFF
734         movei   r0, 1
735         mtspr   INTERRUPT_CRITICAL_SECTION, r0
736         beqzt   r30, .Lrestore_regs
737         j       3f
738 2:      TRACE_IRQS_ON
739         movei   r0, 1
740         mtspr   INTERRUPT_CRITICAL_SECTION, r0
741         IRQ_ENABLE(r20, r21)
742         beqzt   r30, .Lrestore_regs
743 3:
744
745
746         /*
747          * We now commit to returning from this interrupt, since we will be
748          * doing things like setting EX_CONTEXT SPRs and unwinding the stack
749          * frame.  No calls should be made to any other code after this point.
750          * This code should only be entered with ICS set.
751          * r32 must still be set to ptregs.flags.
752          * We launch loads to each cache line separately first, so we can
753          * get some parallelism out of the memory subsystem.
754          * We start zeroing caller-saved registers throughout, since
755          * that will save some cycles if this turns out to be a syscall.
756          */
757 .Lrestore_regs:
758         FEEDBACK_REENTER(interrupt_return)   /* called from elsewhere */
759
760         /*
761          * Rotate so we have one high bit and one low bit to test.
762          * - low bit says whether to restore all the callee-saved registers,
763          *   or just r30-r33, and r52 up.
764          * - high bit (i.e. sign bit) says whether to restore all the
765          *   caller-saved registers, or just r0.
766          */
767 #if PT_FLAGS_CALLER_SAVES != 2 || PT_FLAGS_RESTORE_REGS != 4
768 # error Rotate trick does not work :-)
769 #endif
770         {
771          rotli  r20, r32, 62
772          PTREGS_PTR(sp, PTREGS_OFFSET_REG(0))
773         }
774
775         /*
776          * Load cache lines 0, 4, 6 and 7, in that order, then use
777          * the last loaded value, which makes it likely that the other
778          * cache lines have also loaded, at which point we should be
779          * able to safely read all the remaining words on those cache
780          * lines without waiting for the memory subsystem.
781          */
782         pop_reg r0, sp, PTREGS_OFFSET_REG(30) - PTREGS_OFFSET_REG(0)
783         pop_reg r30, sp, PTREGS_OFFSET_REG(52) - PTREGS_OFFSET_REG(30)
784         pop_reg_zero r52, r3, sp, PTREGS_OFFSET_CMPEXCH - PTREGS_OFFSET_REG(52)
785         pop_reg_zero r21, r27, sp, PTREGS_OFFSET_EX1 - PTREGS_OFFSET_CMPEXCH
786         pop_reg_zero lr, r2, sp, PTREGS_OFFSET_PC - PTREGS_OFFSET_EX1
787         {
788          mtspr  CMPEXCH_VALUE, r21
789          move   r4, zero
790         }
791         pop_reg r21, sp, PTREGS_OFFSET_REG(31) - PTREGS_OFFSET_PC
792         {
793          mtspr  SPR_EX_CONTEXT_K_1, lr
794          andi   lr, lr, SPR_EX_CONTEXT_1_1__PL_MASK  /* mask off ICS */
795         }
796         {
797          mtspr  SPR_EX_CONTEXT_K_0, r21
798          move   r5, zero
799         }
800
801         /* Restore callee-saveds that we actually use. */
802         pop_reg_zero r31, r6
803         pop_reg_zero r32, r7
804         pop_reg_zero r33, r8, sp, PTREGS_OFFSET_REG(29) - PTREGS_OFFSET_REG(33)
805
806         /*
807          * If we modified other callee-saveds, restore them now.
808          * This is rare, but could be via ptrace or signal handler.
809          */
810         {
811          move   r9, zero
812          blbs   r20, .Lrestore_callees
813         }
814 .Lcontinue_restore_regs:
815
816         /* Check if we're returning from a syscall. */
817         {
818          move   r10, zero
819          bltzt  r20, 1f  /* no, so go restore callee-save registers */
820         }
821
822         /*
823          * Check if we're returning to userspace.
824          * Note that if we're not, we don't worry about zeroing everything.
825          */
826         {
827          addli  sp, sp, PTREGS_OFFSET_LR - PTREGS_OFFSET_REG(29)
828          bnez   lr, .Lkernel_return
829         }
830
831         /*
832          * On return from syscall, we've restored r0 from pt_regs, but we
833          * clear the remainder of the caller-saved registers.  We could
834          * restore the syscall arguments, but there's not much point,
835          * and it ensures user programs aren't trying to use the
836          * caller-saves if we clear them, as well as avoiding leaking
837          * kernel pointers into userspace.
838          */
839         pop_reg_zero lr, r11, sp, PTREGS_OFFSET_TP - PTREGS_OFFSET_LR
840         pop_reg_zero tp, r12, sp, PTREGS_OFFSET_SP - PTREGS_OFFSET_TP
841         {
842          ld     sp, sp
843          move   r13, zero
844          move   r14, zero
845         }
846         { move r15, zero; move r16, zero }
847         { move r17, zero; move r18, zero }
848         { move r19, zero; move r20, zero }
849         { move r21, zero; move r22, zero }
850         { move r23, zero; move r24, zero }
851         { move r25, zero; move r26, zero }
852
853         /* Set r1 to errno if we are returning an error, otherwise zero. */
854         {
855          moveli r29, 4096
856          sub    r1, zero, r0
857         }
858         {
859          move   r28, zero
860          cmpltu r29, r1, r29
861         }
862         {
863          mnz    r1, r29, r1
864          move   r29, zero
865         }
866         iret
867
868         /*
869          * Not a syscall, so restore caller-saved registers.
870          * First kick off loads for cache lines 1-3, which we're touching
871          * for the first time here.
872          */
873         .align 64
874 1:      pop_reg r29, sp, PTREGS_OFFSET_REG(21) - PTREGS_OFFSET_REG(29)
875         pop_reg r21, sp, PTREGS_OFFSET_REG(13) - PTREGS_OFFSET_REG(21)
876         pop_reg r13, sp, PTREGS_OFFSET_REG(1) - PTREGS_OFFSET_REG(13)
877         pop_reg r1
878         pop_reg r2
879         pop_reg r3
880         pop_reg r4
881         pop_reg r5
882         pop_reg r6
883         pop_reg r7
884         pop_reg r8
885         pop_reg r9
886         pop_reg r10
887         pop_reg r11
888         pop_reg r12, sp, 16
889         /* r13 already restored above */
890         pop_reg r14
891         pop_reg r15
892         pop_reg r16
893         pop_reg r17
894         pop_reg r18
895         pop_reg r19
896         pop_reg r20, sp, 16
897         /* r21 already restored above */
898         pop_reg r22
899         pop_reg r23
900         pop_reg r24
901         pop_reg r25
902         pop_reg r26
903         pop_reg r27
904         pop_reg r28, sp, PTREGS_OFFSET_LR - PTREGS_OFFSET_REG(28)
905         /* r29 already restored above */
906         bnez    lr, .Lkernel_return
907         pop_reg lr, sp, PTREGS_OFFSET_TP - PTREGS_OFFSET_LR
908         pop_reg tp, sp, PTREGS_OFFSET_SP - PTREGS_OFFSET_TP
909         ld      sp, sp
910         iret
911
912         /*
913          * We can't restore tp when in kernel mode, since a thread might
914          * have migrated from another cpu and brought a stale tp value.
915          */
916 .Lkernel_return:
917         pop_reg lr, sp, PTREGS_OFFSET_SP - PTREGS_OFFSET_LR
918         ld      sp, sp
919         iret
920
921         /* Restore callee-saved registers from r34 to r51. */
922 .Lrestore_callees:
923         addli  sp, sp, PTREGS_OFFSET_REG(34) - PTREGS_OFFSET_REG(29)
924         pop_reg r34
925         pop_reg r35
926         pop_reg r36
927         pop_reg r37
928         pop_reg r38
929         pop_reg r39
930         pop_reg r40
931         pop_reg r41
932         pop_reg r42
933         pop_reg r43
934         pop_reg r44
935         pop_reg r45
936         pop_reg r46
937         pop_reg r47
938         pop_reg r48
939         pop_reg r49
940         pop_reg r50
941         pop_reg r51, sp, PTREGS_OFFSET_REG(29) - PTREGS_OFFSET_REG(51)
942         j .Lcontinue_restore_regs
943         STD_ENDPROC(interrupt_return)
944
945         /*
946          * "NMI" interrupts mask ALL interrupts before calling the
947          * handler, and don't check thread flags, etc., on the way
948          * back out.  In general, the only things we do here for NMIs
949          * are register save/restore and dataplane kernel-TLB management.
950          * We don't (for example) deal with start/stop of the sched tick.
951          */
952         .pushsection .text.handle_nmi,"ax"
953 handle_nmi:
954         finish_interrupt_save handle_nmi
955         {
956          jalr   r0
957          PTREGS_PTR(r0, PTREGS_OFFSET_BASE)
958         }
959         FEEDBACK_REENTER(handle_nmi)
960         {
961          movei  r30, 1
962          move   r31, r0
963         }
964         j       interrupt_return
965         STD_ENDPROC(handle_nmi)
966
967         /*
968          * Parallel code for syscalls to handle_interrupt.
969          */
970         .pushsection .text.handle_syscall,"ax"
971 handle_syscall:
972         finish_interrupt_save handle_syscall
973
974         /* Enable irqs. */
975         TRACE_IRQS_ON
976         IRQ_ENABLE(r20, r21)
977
978         /* Bump the counter for syscalls made on this tile. */
979         moveli r20, hw2_last(irq_stat + IRQ_CPUSTAT_SYSCALL_COUNT_OFFSET)
980         shl16insli r20, r20, hw1(irq_stat + IRQ_CPUSTAT_SYSCALL_COUNT_OFFSET)
981         shl16insli r20, r20, hw0(irq_stat + IRQ_CPUSTAT_SYSCALL_COUNT_OFFSET)
982         add     r20, r20, tp
983         ld4s    r21, r20
984         {
985          addi   r21, r21, 1
986          move   r31, sp
987         }
988         {
989          st4    r20, r21
990          EXTRACT_THREAD_INFO(r31)
991         }
992
993         /* Trace syscalls, if requested. */
994         addi    r31, r31, THREAD_INFO_FLAGS_OFFSET
995         ld      r30, r31
996         andi    r30, r30, _TIF_SYSCALL_TRACE
997         {
998          addi   r30, r31, THREAD_INFO_STATUS_OFFSET - THREAD_INFO_FLAGS_OFFSET
999          beqzt  r30, .Lrestore_syscall_regs
1000         }
1001         jal     do_syscall_trace
1002         FEEDBACK_REENTER(handle_syscall)
1003
1004         /*
1005          * We always reload our registers from the stack at this
1006          * point.  They might be valid, if we didn't build with
1007          * TRACE_IRQFLAGS, and this isn't a dataplane tile, and we're not
1008          * doing syscall tracing, but there are enough cases now that it
1009          * seems simplest just to do the reload unconditionally.
1010          */
1011 .Lrestore_syscall_regs:
1012         {
1013          ld     r30, r30
1014          PTREGS_PTR(r11, PTREGS_OFFSET_REG(0))
1015         }
1016         pop_reg r0,  r11
1017         pop_reg r1,  r11
1018         pop_reg r2,  r11
1019         pop_reg r3,  r11
1020         pop_reg r4,  r11
1021         pop_reg r5,  r11, PTREGS_OFFSET_SYSCALL - PTREGS_OFFSET_REG(5)
1022         {
1023          ld     TREG_SYSCALL_NR_NAME, r11
1024          moveli r21, __NR_syscalls
1025         }
1026
1027         /* Ensure that the syscall number is within the legal range. */
1028         {
1029          moveli r20, hw2(sys_call_table)
1030          blbs   r30, .Lcompat_syscall
1031         }
1032         {
1033          cmpltu r21, TREG_SYSCALL_NR_NAME, r21
1034          shl16insli r20, r20, hw1(sys_call_table)
1035         }
1036         {
1037          blbc   r21, .Linvalid_syscall
1038          shl16insli r20, r20, hw0(sys_call_table)
1039         }
1040 .Lload_syscall_pointer:
1041         shl3add r20, TREG_SYSCALL_NR_NAME, r20
1042         ld      r20, r20
1043
1044         /* Jump to syscall handler. */
1045         jalr    r20
1046 .Lhandle_syscall_link: /* value of "lr" after "jalr r20" above */
1047
1048         /*
1049          * Write our r0 onto the stack so it gets restored instead
1050          * of whatever the user had there before.
1051          * In compat mode, sign-extend r0 before storing it.
1052          */
1053         {
1054          PTREGS_PTR(r29, PTREGS_OFFSET_REG(0))
1055          blbct  r30, 1f
1056         }
1057         addxi   r0, r0, 0
1058 1:      st      r29, r0
1059
1060 .Lsyscall_sigreturn_skip:
1061         FEEDBACK_REENTER(handle_syscall)
1062
1063         /* Do syscall trace again, if requested. */
1064         ld      r30, r31
1065         andi    r0, r30, _TIF_SYSCALL_TRACE
1066         {
1067          andi    r0, r30, _TIF_SINGLESTEP
1068          beqzt   r0, 1f
1069         }
1070         jal     do_syscall_trace
1071         FEEDBACK_REENTER(handle_syscall)
1072         andi    r0, r30, _TIF_SINGLESTEP
1073
1074 1:      beqzt   r0, 2f
1075
1076         /* Single stepping -- notify ptrace. */
1077         {
1078          movei   r0, SIGTRAP
1079          jal     ptrace_notify
1080         }
1081         FEEDBACK_REENTER(handle_syscall)
1082
1083 2:      {
1084          movei  r30, 0               /* not an NMI */
1085          j      .Lresume_userspace   /* jump into middle of interrupt_return */
1086         }
1087
1088 .Lcompat_syscall:
1089         /*
1090          * Load the base of the compat syscall table in r20, and
1091          * range-check the syscall number (duplicated from 64-bit path).
1092          * Sign-extend all the user's passed arguments to make them consistent.
1093          * Also save the original "r(n)" values away in "r(11+n)" in
1094          * case the syscall table entry wants to validate them.
1095          */
1096         moveli  r20, hw2(compat_sys_call_table)
1097         {
1098          cmpltu r21, TREG_SYSCALL_NR_NAME, r21
1099          shl16insli r20, r20, hw1(compat_sys_call_table)
1100         }
1101         {
1102          blbc   r21, .Linvalid_syscall
1103          shl16insli r20, r20, hw0(compat_sys_call_table)
1104         }
1105         { move r11, r0; addxi r0, r0, 0 }
1106         { move r12, r1; addxi r1, r1, 0 }
1107         { move r13, r2; addxi r2, r2, 0 }
1108         { move r14, r3; addxi r3, r3, 0 }
1109         { move r15, r4; addxi r4, r4, 0 }
1110         { move r16, r5; addxi r5, r5, 0 }
1111         j .Lload_syscall_pointer
1112
1113 .Linvalid_syscall:
1114         /* Report an invalid syscall back to the user program */
1115         {
1116          PTREGS_PTR(r29, PTREGS_OFFSET_REG(0))
1117          movei  r28, -ENOSYS
1118         }
1119         st      r29, r28
1120         {
1121          movei  r30, 0               /* not an NMI */
1122          j      .Lresume_userspace   /* jump into middle of interrupt_return */
1123         }
1124         STD_ENDPROC(handle_syscall)
1125
1126         /* Return the address for oprofile to suppress in backtraces. */
1127 STD_ENTRY_SECTION(handle_syscall_link_address, .text.handle_syscall)
1128         lnk     r0
1129         {
1130          addli  r0, r0, .Lhandle_syscall_link - .
1131          jrp    lr
1132         }
1133         STD_ENDPROC(handle_syscall_link_address)
1134
1135 STD_ENTRY(ret_from_fork)
1136         jal     sim_notify_fork
1137         jal     schedule_tail
1138         FEEDBACK_REENTER(ret_from_fork)
1139         {
1140          movei  r30, 0               /* not an NMI */
1141          j      .Lresume_userspace   /* jump into middle of interrupt_return */
1142         }
1143         STD_ENDPROC(ret_from_fork)
1144
1145 /* Various stub interrupt handlers and syscall handlers */
1146
1147 STD_ENTRY_LOCAL(_kernel_double_fault)
1148         mfspr   r1, SPR_EX_CONTEXT_K_0
1149         move    r2, lr
1150         move    r3, sp
1151         move    r4, r52
1152         addi    sp, sp, -C_ABI_SAVE_AREA_SIZE
1153         j       kernel_double_fault
1154         STD_ENDPROC(_kernel_double_fault)
1155
1156 STD_ENTRY_LOCAL(bad_intr)
1157         mfspr   r2, SPR_EX_CONTEXT_K_0
1158         panic   "Unhandled interrupt %#x: PC %#lx"
1159         STD_ENDPROC(bad_intr)
1160
1161 /* Put address of pt_regs in reg and jump. */
1162 #define PTREGS_SYSCALL(x, reg)                          \
1163         STD_ENTRY(_##x);                                \
1164         {                                               \
1165          PTREGS_PTR(reg, PTREGS_OFFSET_BASE);           \
1166          j      x                                       \
1167         };                                              \
1168         STD_ENDPROC(_##x)
1169
1170 /*
1171  * Special-case sigreturn to not write r0 to the stack on return.
1172  * This is technically more efficient, but it also avoids difficulties
1173  * in the 64-bit OS when handling 32-bit compat code, since we must not
1174  * sign-extend r0 for the sigreturn return-value case.
1175  */
1176 #define PTREGS_SYSCALL_SIGRETURN(x, reg)                \
1177         STD_ENTRY(_##x);                                \
1178         addli   lr, lr, .Lsyscall_sigreturn_skip - .Lhandle_syscall_link; \
1179         {                                               \
1180          PTREGS_PTR(reg, PTREGS_OFFSET_BASE);           \
1181          j      x                                       \
1182         };                                              \
1183         STD_ENDPROC(_##x)
1184
1185 PTREGS_SYSCALL(sys_execve, r3)
1186 PTREGS_SYSCALL(sys_sigaltstack, r2)
1187 PTREGS_SYSCALL_SIGRETURN(sys_rt_sigreturn, r0)
1188 #ifdef CONFIG_COMPAT
1189 PTREGS_SYSCALL(compat_sys_execve, r3)
1190 PTREGS_SYSCALL(compat_sys_sigaltstack, r2)
1191 PTREGS_SYSCALL_SIGRETURN(compat_sys_rt_sigreturn, r0)
1192 #endif
1193
1194 /* Save additional callee-saves to pt_regs, put address in r4 and jump. */
1195 STD_ENTRY(_sys_clone)
1196         push_extra_callee_saves r4
1197         j       sys_clone
1198         STD_ENDPROC(_sys_clone)
1199
1200 /* The single-step support may need to read all the registers. */
1201 int_unalign:
1202         push_extra_callee_saves r0
1203         j       do_trap
1204
1205 /* Fill the return address stack with nonzero entries. */
1206 STD_ENTRY(fill_ra_stack)
1207         {
1208          move   r0, lr
1209          jal    1f
1210         }
1211 1:      jal     2f
1212 2:      jal     3f
1213 3:      jal     4f
1214 4:      jrp     r0
1215         STD_ENDPROC(fill_ra_stack)
1216
1217 /* Include .intrpt1 array of interrupt vectors */
1218         .section ".intrpt1", "ax"
1219
1220 #define op_handle_perf_interrupt bad_intr
1221 #define op_handle_aux_perf_interrupt bad_intr
1222
1223 #ifndef CONFIG_HARDWALL
1224 #define do_hardwall_trap bad_intr
1225 #endif
1226
1227         int_hand     INT_MEM_ERROR, MEM_ERROR, do_trap
1228         int_hand     INT_SINGLE_STEP_3, SINGLE_STEP_3, bad_intr
1229 #if CONFIG_KERNEL_PL == 2
1230         int_hand     INT_SINGLE_STEP_2, SINGLE_STEP_2, gx_singlestep_handle
1231         int_hand     INT_SINGLE_STEP_1, SINGLE_STEP_1, bad_intr
1232 #else
1233         int_hand     INT_SINGLE_STEP_2, SINGLE_STEP_2, bad_intr
1234         int_hand     INT_SINGLE_STEP_1, SINGLE_STEP_1, gx_singlestep_handle
1235 #endif
1236         int_hand     INT_SINGLE_STEP_0, SINGLE_STEP_0, bad_intr
1237         int_hand     INT_IDN_COMPLETE, IDN_COMPLETE, bad_intr
1238         int_hand     INT_UDN_COMPLETE, UDN_COMPLETE, bad_intr
1239         int_hand     INT_ITLB_MISS, ITLB_MISS, do_page_fault
1240         int_hand     INT_ILL, ILL, do_trap
1241         int_hand     INT_GPV, GPV, do_trap
1242         int_hand     INT_IDN_ACCESS, IDN_ACCESS, do_trap
1243         int_hand     INT_UDN_ACCESS, UDN_ACCESS, do_trap
1244         int_hand     INT_SWINT_3, SWINT_3, do_trap
1245         int_hand     INT_SWINT_2, SWINT_2, do_trap
1246         int_hand     INT_SWINT_1, SWINT_1, SYSCALL, handle_syscall
1247         int_hand     INT_SWINT_0, SWINT_0, do_trap
1248         int_hand     INT_ILL_TRANS, ILL_TRANS, do_trap
1249         int_hand     INT_UNALIGN_DATA, UNALIGN_DATA, int_unalign
1250         int_hand     INT_DTLB_MISS, DTLB_MISS, do_page_fault
1251         int_hand     INT_DTLB_ACCESS, DTLB_ACCESS, do_page_fault
1252         int_hand     INT_IDN_FIREWALL, IDN_FIREWALL, bad_intr
1253         int_hand     INT_UDN_FIREWALL, UDN_FIREWALL, do_hardwall_trap
1254         int_hand     INT_TILE_TIMER, TILE_TIMER, do_timer_interrupt
1255         int_hand     INT_IDN_TIMER, IDN_TIMER, bad_intr
1256         int_hand     INT_UDN_TIMER, UDN_TIMER, bad_intr
1257         int_hand     INT_IDN_AVAIL, IDN_AVAIL, bad_intr
1258         int_hand     INT_UDN_AVAIL, UDN_AVAIL, bad_intr
1259         int_hand     INT_IPI_3, IPI_3, bad_intr
1260 #if CONFIG_KERNEL_PL == 2
1261         int_hand     INT_IPI_2, IPI_2, tile_dev_intr
1262         int_hand     INT_IPI_1, IPI_1, bad_intr
1263 #else
1264         int_hand     INT_IPI_2, IPI_2, bad_intr
1265         int_hand     INT_IPI_1, IPI_1, tile_dev_intr
1266 #endif
1267         int_hand     INT_IPI_0, IPI_0, bad_intr
1268         int_hand     INT_PERF_COUNT, PERF_COUNT, \
1269                      op_handle_perf_interrupt, handle_nmi
1270         int_hand     INT_AUX_PERF_COUNT, AUX_PERF_COUNT, \
1271                      op_handle_perf_interrupt, handle_nmi
1272         int_hand     INT_INTCTRL_3, INTCTRL_3, bad_intr
1273 #if CONFIG_KERNEL_PL == 2
1274         dc_dispatch  INT_INTCTRL_2, INTCTRL_2
1275         int_hand     INT_INTCTRL_1, INTCTRL_1, bad_intr
1276 #else
1277         int_hand     INT_INTCTRL_2, INTCTRL_2, bad_intr
1278         dc_dispatch  INT_INTCTRL_1, INTCTRL_1
1279 #endif
1280         int_hand     INT_INTCTRL_0, INTCTRL_0, bad_intr
1281         int_hand     INT_MESSAGE_RCV_DWNCL, MESSAGE_RCV_DWNCL, \
1282                      hv_message_intr
1283         int_hand     INT_DEV_INTR_DWNCL, DEV_INTR_DWNCL, bad_intr
1284         int_hand     INT_I_ASID, I_ASID, bad_intr
1285         int_hand     INT_D_ASID, D_ASID, bad_intr
1286         int_hand     INT_DOUBLE_FAULT, DOUBLE_FAULT, do_trap
1287
1288         /* Synthetic interrupt delivered only by the simulator */
1289         int_hand     INT_BREAKPOINT, BREAKPOINT, do_breakpoint