2 * arch/s390/kernel/traps.c
5 * Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
6 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
7 * Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
9 * Derived from "arch/i386/kernel/traps.c"
10 * Copyright (C) 1991, 1992 Linus Torvalds
14 * 'Traps.c' handles hardware traps and faults after we have saved some
17 #include <linux/sched.h>
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/errno.h>
21 #include <linux/tracehook.h>
22 #include <linux/timer.h>
24 #include <linux/smp.h>
25 #include <linux/init.h>
26 #include <linux/interrupt.h>
27 #include <linux/seq_file.h>
28 #include <linux/delay.h>
29 #include <linux/module.h>
30 #include <linux/kdebug.h>
31 #include <linux/kallsyms.h>
32 #include <linux/reboot.h>
33 #include <linux/kprobes.h>
34 #include <linux/bug.h>
35 #include <linux/utsname.h>
36 #include <asm/system.h>
37 #include <asm/uaccess.h>
39 #include <asm/atomic.h>
40 #include <asm/mathemu.h>
41 #include <asm/cpcmd.h>
42 #include <asm/s390_ext.h>
43 #include <asm/lowcore.h>
44 #include <asm/debug.h>
47 pgm_check_handler_t *pgm_check_table[128];
49 int show_unhandled_signals;
51 extern pgm_check_handler_t do_protection_exception;
52 extern pgm_check_handler_t do_dat_exception;
53 extern pgm_check_handler_t do_asce_exception;
55 #define stack_pointer ({ void **sp; asm("la %0,0(15)" : "=&d" (sp)); sp; })
59 #define FOURLONG "%08lx %08lx %08lx %08lx\n"
60 static int kstack_depth_to_print = 12;
61 #else /* CONFIG_64BIT */
62 #define LONG "%016lx "
63 #define FOURLONG "%016lx %016lx %016lx %016lx\n"
64 static int kstack_depth_to_print = 20;
65 #endif /* CONFIG_64BIT */
68 * For show_trace we have tree different stack to consider:
69 * - the panic stack which is used if the kernel stack has overflown
70 * - the asynchronous interrupt stack (cpu related)
71 * - the synchronous kernel stack (process related)
72 * The stack trace can start at any of the three stack and can potentially
73 * touch all of them. The order is: panic stack, async stack, sync stack.
76 __show_trace(unsigned long sp, unsigned long low, unsigned long high)
78 struct stack_frame *sf;
82 sp = sp & PSW_ADDR_INSN;
83 if (sp < low || sp > high - sizeof(*sf))
85 sf = (struct stack_frame *) sp;
86 printk("([<%016lx>] ", sf->gprs[8] & PSW_ADDR_INSN);
87 print_symbol("%s)\n", sf->gprs[8] & PSW_ADDR_INSN);
88 /* Follow the backchain. */
91 sp = sf->back_chain & PSW_ADDR_INSN;
94 if (sp <= low || sp > high - sizeof(*sf))
96 sf = (struct stack_frame *) sp;
97 printk(" [<%016lx>] ", sf->gprs[8] & PSW_ADDR_INSN);
98 print_symbol("%s\n", sf->gprs[8] & PSW_ADDR_INSN);
100 /* Zero backchain detected, check for interrupt frame. */
101 sp = (unsigned long) (sf + 1);
102 if (sp <= low || sp > high - sizeof(*regs))
104 regs = (struct pt_regs *) sp;
105 printk(" [<%016lx>] ", regs->psw.addr & PSW_ADDR_INSN);
106 print_symbol("%s\n", regs->psw.addr & PSW_ADDR_INSN);
112 static void show_trace(struct task_struct *task, unsigned long *stack)
114 register unsigned long __r15 asm ("15");
117 sp = (unsigned long) stack;
119 sp = task ? task->thread.ksp : __r15;
120 printk("Call Trace:\n");
121 #ifdef CONFIG_CHECK_STACK
122 sp = __show_trace(sp, S390_lowcore.panic_stack - 4096,
123 S390_lowcore.panic_stack);
125 sp = __show_trace(sp, S390_lowcore.async_stack - ASYNC_SIZE,
126 S390_lowcore.async_stack);
128 __show_trace(sp, (unsigned long) task_stack_page(task),
129 (unsigned long) task_stack_page(task) + THREAD_SIZE);
131 __show_trace(sp, S390_lowcore.thread_info,
132 S390_lowcore.thread_info + THREAD_SIZE);
135 debug_show_held_locks(task);
138 void show_stack(struct task_struct *task, unsigned long *sp)
140 register unsigned long * __r15 asm ("15");
141 unsigned long *stack;
145 stack = task ? (unsigned long *) task->thread.ksp : __r15;
149 for (i = 0; i < kstack_depth_to_print; i++) {
150 if (((addr_t) stack & (THREAD_SIZE-1)) == 0)
152 if (i && ((i * sizeof (long) % 32) == 0))
154 printk(LONG, *stack++);
157 show_trace(task, sp);
160 static void show_last_breaking_event(struct pt_regs *regs)
163 printk("Last Breaking-Event-Address:\n");
164 printk(" [<%016lx>] ", regs->args[0] & PSW_ADDR_INSN);
165 print_symbol("%s\n", regs->args[0] & PSW_ADDR_INSN);
170 * The architecture-independent dump_stack generator
172 void dump_stack(void)
174 printk("CPU: %d %s %s %.*s\n",
175 task_thread_info(current)->cpu, print_tainted(),
176 init_utsname()->release,
177 (int)strcspn(init_utsname()->version, " "),
178 init_utsname()->version);
179 printk("Process %s (pid: %d, task: %p, ksp: %p)\n",
180 current->comm, current->pid, current,
181 (void *) current->thread.ksp);
182 show_stack(NULL, NULL);
184 EXPORT_SYMBOL(dump_stack);
186 static inline int mask_bits(struct pt_regs *regs, unsigned long bits)
188 return (regs->psw.mask & bits) / ((~bits + 1) & bits);
191 void show_registers(struct pt_regs *regs)
195 mode = (regs->psw.mask & PSW_MASK_PSTATE) ? "User" : "Krnl";
196 printk("%s PSW : %p %p",
197 mode, (void *) regs->psw.mask,
198 (void *) regs->psw.addr);
199 print_symbol(" (%s)\n", regs->psw.addr & PSW_ADDR_INSN);
200 printk(" R:%x T:%x IO:%x EX:%x Key:%x M:%x W:%x "
201 "P:%x AS:%x CC:%x PM:%x", mask_bits(regs, PSW_MASK_PER),
202 mask_bits(regs, PSW_MASK_DAT), mask_bits(regs, PSW_MASK_IO),
203 mask_bits(regs, PSW_MASK_EXT), mask_bits(regs, PSW_MASK_KEY),
204 mask_bits(regs, PSW_MASK_MCHECK), mask_bits(regs, PSW_MASK_WAIT),
205 mask_bits(regs, PSW_MASK_PSTATE), mask_bits(regs, PSW_MASK_ASC),
206 mask_bits(regs, PSW_MASK_CC), mask_bits(regs, PSW_MASK_PM));
208 printk(" EA:%x", mask_bits(regs, PSW_BASE_BITS));
210 printk("\n%s GPRS: " FOURLONG, mode,
211 regs->gprs[0], regs->gprs[1], regs->gprs[2], regs->gprs[3]);
213 regs->gprs[4], regs->gprs[5], regs->gprs[6], regs->gprs[7]);
215 regs->gprs[8], regs->gprs[9], regs->gprs[10], regs->gprs[11]);
217 regs->gprs[12], regs->gprs[13], regs->gprs[14], regs->gprs[15]);
222 void show_regs(struct pt_regs *regs)
225 printk("CPU: %d %s %s %.*s\n",
226 task_thread_info(current)->cpu, print_tainted(),
227 init_utsname()->release,
228 (int)strcspn(init_utsname()->version, " "),
229 init_utsname()->version);
230 printk("Process %s (pid: %d, task: %p, ksp: %p)\n",
231 current->comm, current->pid, current,
232 (void *) current->thread.ksp);
233 show_registers(regs);
234 /* Show stack backtrace if pt_regs is from kernel mode */
235 if (!(regs->psw.mask & PSW_MASK_PSTATE))
236 show_trace(NULL, (unsigned long *) regs->gprs[15]);
237 show_last_breaking_event(regs);
240 /* This is called from fs/proc/array.c */
241 void task_show_regs(struct seq_file *m, struct task_struct *task)
243 struct pt_regs *regs;
245 regs = task_pt_regs(task);
246 seq_printf(m, "task: %p, ksp: %p\n",
247 task, (void *)task->thread.ksp);
248 seq_printf(m, "User PSW : %p %p\n",
249 (void *) regs->psw.mask, (void *)regs->psw.addr);
251 seq_printf(m, "User GPRS: " FOURLONG,
252 regs->gprs[0], regs->gprs[1],
253 regs->gprs[2], regs->gprs[3]);
254 seq_printf(m, " " FOURLONG,
255 regs->gprs[4], regs->gprs[5],
256 regs->gprs[6], regs->gprs[7]);
257 seq_printf(m, " " FOURLONG,
258 regs->gprs[8], regs->gprs[9],
259 regs->gprs[10], regs->gprs[11]);
260 seq_printf(m, " " FOURLONG,
261 regs->gprs[12], regs->gprs[13],
262 regs->gprs[14], regs->gprs[15]);
263 seq_printf(m, "User ACRS: %08x %08x %08x %08x\n",
264 task->thread.acrs[0], task->thread.acrs[1],
265 task->thread.acrs[2], task->thread.acrs[3]);
266 seq_printf(m, " %08x %08x %08x %08x\n",
267 task->thread.acrs[4], task->thread.acrs[5],
268 task->thread.acrs[6], task->thread.acrs[7]);
269 seq_printf(m, " %08x %08x %08x %08x\n",
270 task->thread.acrs[8], task->thread.acrs[9],
271 task->thread.acrs[10], task->thread.acrs[11]);
272 seq_printf(m, " %08x %08x %08x %08x\n",
273 task->thread.acrs[12], task->thread.acrs[13],
274 task->thread.acrs[14], task->thread.acrs[15]);
277 static DEFINE_SPINLOCK(die_lock);
279 void die(const char * str, struct pt_regs * regs, long err)
281 static int die_counter;
286 spin_lock_irq(&die_lock);
288 printk("%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
289 #ifdef CONFIG_PREEMPT
295 #ifdef CONFIG_DEBUG_PAGEALLOC
296 printk("DEBUG_PAGEALLOC");
299 notify_die(DIE_OOPS, str, regs, err, current->thread.trap_no, SIGSEGV);
302 add_taint(TAINT_DIE);
303 spin_unlock_irq(&die_lock);
305 panic("Fatal exception in interrupt");
307 panic("Fatal exception: panic_on_oops");
312 static void inline report_user_fault(struct pt_regs *regs, long int_code,
315 if ((task_pid_nr(current) > 1) && !show_unhandled_signals)
317 if (!unhandled_signal(current, signr))
319 if (!printk_ratelimit())
321 printk("User process fault: interruption code 0x%lX ", int_code);
322 print_vma_addr("in ", regs->psw.addr & PSW_ADDR_INSN);
327 int is_valid_bugaddr(unsigned long addr)
332 static inline void __kprobes do_trap(long pgm_int_code, int signr, char *str,
333 struct pt_regs *regs, siginfo_t *info)
335 if (notify_die(DIE_TRAP, str, regs, pgm_int_code,
336 pgm_int_code, signr) == NOTIFY_STOP)
339 if (regs->psw.mask & PSW_MASK_PSTATE) {
340 struct task_struct *tsk = current;
342 tsk->thread.trap_no = pgm_int_code & 0xffff;
343 force_sig_info(signr, info, tsk);
344 report_user_fault(regs, pgm_int_code, signr);
346 const struct exception_table_entry *fixup;
347 fixup = search_exception_tables(regs->psw.addr & PSW_ADDR_INSN);
349 regs->psw.addr = fixup->fixup | PSW_ADDR_AMODE;
351 enum bug_trap_type btt;
353 btt = report_bug(regs->psw.addr & PSW_ADDR_INSN, regs);
354 if (btt == BUG_TRAP_TYPE_WARN)
356 die(str, regs, pgm_int_code);
361 static inline void __user *get_psw_address(struct pt_regs *regs,
364 return (void __user *)
365 ((regs->psw.addr - (pgm_int_code >> 16)) & PSW_ADDR_INSN);
368 void __kprobes do_per_trap(struct pt_regs *regs)
370 if (notify_die(DIE_SSTEP, "sstep", regs, 0, 0, SIGTRAP) == NOTIFY_STOP)
372 if (tracehook_consider_fatal_signal(current, SIGTRAP))
373 force_sig(SIGTRAP, current);
376 static void default_trap_handler(struct pt_regs *regs, long pgm_int_code,
377 unsigned long trans_exc_code)
379 if (regs->psw.mask & PSW_MASK_PSTATE) {
380 report_user_fault(regs, pgm_int_code, SIGSEGV);
383 die("Unknown program exception", regs, pgm_int_code);
386 #define DO_ERROR_INFO(name, signr, sicode, str) \
387 static void name(struct pt_regs *regs, long pgm_int_code, \
388 unsigned long trans_exc_code) \
391 info.si_signo = signr; \
393 info.si_code = sicode; \
394 info.si_addr = get_psw_address(regs, pgm_int_code); \
395 do_trap(pgm_int_code, signr, str, regs, &info); \
398 DO_ERROR_INFO(addressing_exception, SIGILL, ILL_ILLADR,
399 "addressing exception")
400 DO_ERROR_INFO(execute_exception, SIGILL, ILL_ILLOPN,
402 DO_ERROR_INFO(divide_exception, SIGFPE, FPE_INTDIV,
403 "fixpoint divide exception")
404 DO_ERROR_INFO(overflow_exception, SIGFPE, FPE_INTOVF,
405 "fixpoint overflow exception")
406 DO_ERROR_INFO(hfp_overflow_exception, SIGFPE, FPE_FLTOVF,
407 "HFP overflow exception")
408 DO_ERROR_INFO(hfp_underflow_exception, SIGFPE, FPE_FLTUND,
409 "HFP underflow exception")
410 DO_ERROR_INFO(hfp_significance_exception, SIGFPE, FPE_FLTRES,
411 "HFP significance exception")
412 DO_ERROR_INFO(hfp_divide_exception, SIGFPE, FPE_FLTDIV,
413 "HFP divide exception")
414 DO_ERROR_INFO(hfp_sqrt_exception, SIGFPE, FPE_FLTINV,
415 "HFP square root exception")
416 DO_ERROR_INFO(operand_exception, SIGILL, ILL_ILLOPN,
418 DO_ERROR_INFO(privileged_op, SIGILL, ILL_PRVOPC,
419 "privileged operation")
420 DO_ERROR_INFO(special_op_exception, SIGILL, ILL_ILLOPN,
421 "special operation exception")
422 DO_ERROR_INFO(translation_exception, SIGILL, ILL_ILLOPN,
423 "translation exception")
425 static inline void do_fp_trap(struct pt_regs *regs, void __user *location,
426 int fpc, long pgm_int_code)
430 si.si_signo = SIGFPE;
432 si.si_addr = location;
434 /* FPC[2] is Data Exception Code */
435 if ((fpc & 0x00000300) == 0) {
436 /* bits 6 and 7 of DXC are 0 iff IEEE exception */
437 if (fpc & 0x8000) /* invalid fp operation */
438 si.si_code = FPE_FLTINV;
439 else if (fpc & 0x4000) /* div by 0 */
440 si.si_code = FPE_FLTDIV;
441 else if (fpc & 0x2000) /* overflow */
442 si.si_code = FPE_FLTOVF;
443 else if (fpc & 0x1000) /* underflow */
444 si.si_code = FPE_FLTUND;
445 else if (fpc & 0x0800) /* inexact */
446 si.si_code = FPE_FLTRES;
448 do_trap(pgm_int_code, SIGFPE,
449 "floating point exception", regs, &si);
452 static void __kprobes illegal_op(struct pt_regs *regs, long pgm_int_code,
453 unsigned long trans_exc_code)
457 __u16 __user *location;
460 location = get_psw_address(regs, pgm_int_code);
462 if (regs->psw.mask & PSW_MASK_PSTATE) {
463 if (get_user(*((__u16 *) opcode), (__u16 __user *) location))
465 if (*((__u16 *) opcode) == S390_BREAKPOINT_U16) {
466 if (tracehook_consider_fatal_signal(current, SIGTRAP))
467 force_sig(SIGTRAP, current);
470 #ifdef CONFIG_MATHEMU
471 } else if (opcode[0] == 0xb3) {
472 if (get_user(*((__u16 *) (opcode+2)), location+1))
474 signal = math_emu_b3(opcode, regs);
475 } else if (opcode[0] == 0xed) {
476 if (get_user(*((__u32 *) (opcode+2)),
477 (__u32 __user *)(location+1)))
479 signal = math_emu_ed(opcode, regs);
480 } else if (*((__u16 *) opcode) == 0xb299) {
481 if (get_user(*((__u16 *) (opcode+2)), location+1))
483 signal = math_emu_srnm(opcode, regs);
484 } else if (*((__u16 *) opcode) == 0xb29c) {
485 if (get_user(*((__u16 *) (opcode+2)), location+1))
487 signal = math_emu_stfpc(opcode, regs);
488 } else if (*((__u16 *) opcode) == 0xb29d) {
489 if (get_user(*((__u16 *) (opcode+2)), location+1))
491 signal = math_emu_lfpc(opcode, regs);
497 * If we get an illegal op in kernel mode, send it through the
498 * kprobes notifier. If kprobes doesn't pick it up, SIGILL
500 if (notify_die(DIE_BPT, "bpt", regs, pgm_int_code,
501 3, SIGTRAP) != NOTIFY_STOP)
505 #ifdef CONFIG_MATHEMU
506 if (signal == SIGFPE)
507 do_fp_trap(regs, location,
508 current->thread.fp_regs.fpc, pgm_int_code);
509 else if (signal == SIGSEGV) {
510 info.si_signo = signal;
512 info.si_code = SEGV_MAPERR;
513 info.si_addr = (void __user *) location;
514 do_trap(pgm_int_code, signal,
515 "user address fault", regs, &info);
519 info.si_signo = signal;
521 info.si_code = ILL_ILLOPC;
522 info.si_addr = (void __user *) location;
523 do_trap(pgm_int_code, signal,
524 "illegal operation", regs, &info);
529 #ifdef CONFIG_MATHEMU
530 asmlinkage void specification_exception(struct pt_regs *regs,
532 unsigned long trans_exc_code)
535 __u16 __user *location = NULL;
538 location = (__u16 __user *) get_psw_address(regs, pgm_int_code);
540 if (regs->psw.mask & PSW_MASK_PSTATE) {
541 get_user(*((__u16 *) opcode), location);
543 case 0x28: /* LDR Rx,Ry */
544 signal = math_emu_ldr(opcode);
546 case 0x38: /* LER Rx,Ry */
547 signal = math_emu_ler(opcode);
549 case 0x60: /* STD R,D(X,B) */
550 get_user(*((__u16 *) (opcode+2)), location+1);
551 signal = math_emu_std(opcode, regs);
553 case 0x68: /* LD R,D(X,B) */
554 get_user(*((__u16 *) (opcode+2)), location+1);
555 signal = math_emu_ld(opcode, regs);
557 case 0x70: /* STE R,D(X,B) */
558 get_user(*((__u16 *) (opcode+2)), location+1);
559 signal = math_emu_ste(opcode, regs);
561 case 0x78: /* LE R,D(X,B) */
562 get_user(*((__u16 *) (opcode+2)), location+1);
563 signal = math_emu_le(opcode, regs);
572 if (signal == SIGFPE)
573 do_fp_trap(regs, location,
574 current->thread.fp_regs.fpc, pgm_int_code);
577 info.si_signo = signal;
579 info.si_code = ILL_ILLOPN;
580 info.si_addr = location;
581 do_trap(pgm_int_code, signal,
582 "specification exception", regs, &info);
586 DO_ERROR_INFO(specification_exception, SIGILL, ILL_ILLOPN,
587 "specification exception");
590 static void data_exception(struct pt_regs *regs, long pgm_int_code,
591 unsigned long trans_exc_code)
593 __u16 __user *location;
596 location = get_psw_address(regs, pgm_int_code);
598 if (MACHINE_HAS_IEEE)
599 asm volatile("stfpc %0" : "=m" (current->thread.fp_regs.fpc));
601 #ifdef CONFIG_MATHEMU
602 else if (regs->psw.mask & PSW_MASK_PSTATE) {
604 get_user(*((__u16 *) opcode), location);
606 case 0x28: /* LDR Rx,Ry */
607 signal = math_emu_ldr(opcode);
609 case 0x38: /* LER Rx,Ry */
610 signal = math_emu_ler(opcode);
612 case 0x60: /* STD R,D(X,B) */
613 get_user(*((__u16 *) (opcode+2)), location+1);
614 signal = math_emu_std(opcode, regs);
616 case 0x68: /* LD R,D(X,B) */
617 get_user(*((__u16 *) (opcode+2)), location+1);
618 signal = math_emu_ld(opcode, regs);
620 case 0x70: /* STE R,D(X,B) */
621 get_user(*((__u16 *) (opcode+2)), location+1);
622 signal = math_emu_ste(opcode, regs);
624 case 0x78: /* LE R,D(X,B) */
625 get_user(*((__u16 *) (opcode+2)), location+1);
626 signal = math_emu_le(opcode, regs);
629 get_user(*((__u16 *) (opcode+2)), location+1);
630 signal = math_emu_b3(opcode, regs);
633 get_user(*((__u32 *) (opcode+2)),
634 (__u32 __user *)(location+1));
635 signal = math_emu_ed(opcode, regs);
638 if (opcode[1] == 0x99) {
639 get_user(*((__u16 *) (opcode+2)), location+1);
640 signal = math_emu_srnm(opcode, regs);
641 } else if (opcode[1] == 0x9c) {
642 get_user(*((__u16 *) (opcode+2)), location+1);
643 signal = math_emu_stfpc(opcode, regs);
644 } else if (opcode[1] == 0x9d) {
645 get_user(*((__u16 *) (opcode+2)), location+1);
646 signal = math_emu_lfpc(opcode, regs);
656 if (current->thread.fp_regs.fpc & FPC_DXC_MASK)
660 if (signal == SIGFPE)
661 do_fp_trap(regs, location,
662 current->thread.fp_regs.fpc, pgm_int_code);
665 info.si_signo = signal;
667 info.si_code = ILL_ILLOPN;
668 info.si_addr = location;
669 do_trap(pgm_int_code, signal, "data exception", regs, &info);
673 static void space_switch_exception(struct pt_regs *regs, long pgm_int_code,
674 unsigned long trans_exc_code)
678 /* Set user psw back to home space mode. */
679 if (regs->psw.mask & PSW_MASK_PSTATE)
680 regs->psw.mask |= PSW_ASC_HOME;
682 info.si_signo = SIGILL;
684 info.si_code = ILL_PRVOPC;
685 info.si_addr = get_psw_address(regs, pgm_int_code);
686 do_trap(pgm_int_code, SIGILL, "space switch event", regs, &info);
689 asmlinkage void __kprobes kernel_stack_overflow(struct pt_regs * regs)
692 printk("Kernel stack overflow.\n");
695 panic("Corrupt kernel stack, can't continue.");
698 /* init is done in lowcore.S and head.S */
700 void __init trap_init(void)
704 for (i = 0; i < 128; i++)
705 pgm_check_table[i] = &default_trap_handler;
706 pgm_check_table[1] = &illegal_op;
707 pgm_check_table[2] = &privileged_op;
708 pgm_check_table[3] = &execute_exception;
709 pgm_check_table[4] = &do_protection_exception;
710 pgm_check_table[5] = &addressing_exception;
711 pgm_check_table[6] = &specification_exception;
712 pgm_check_table[7] = &data_exception;
713 pgm_check_table[8] = &overflow_exception;
714 pgm_check_table[9] = ÷_exception;
715 pgm_check_table[0x0A] = &overflow_exception;
716 pgm_check_table[0x0B] = ÷_exception;
717 pgm_check_table[0x0C] = &hfp_overflow_exception;
718 pgm_check_table[0x0D] = &hfp_underflow_exception;
719 pgm_check_table[0x0E] = &hfp_significance_exception;
720 pgm_check_table[0x0F] = &hfp_divide_exception;
721 pgm_check_table[0x10] = &do_dat_exception;
722 pgm_check_table[0x11] = &do_dat_exception;
723 pgm_check_table[0x12] = &translation_exception;
724 pgm_check_table[0x13] = &special_op_exception;
726 pgm_check_table[0x38] = &do_asce_exception;
727 pgm_check_table[0x39] = &do_dat_exception;
728 pgm_check_table[0x3A] = &do_dat_exception;
729 pgm_check_table[0x3B] = &do_dat_exception;
730 #endif /* CONFIG_64BIT */
731 pgm_check_table[0x15] = &operand_exception;
732 pgm_check_table[0x1C] = &space_switch_exception;
733 pgm_check_table[0x1D] = &hfp_sqrt_exception;
734 /* Enable machine checks early. */