• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Ptrace interface test helper functions
3  *
4  * Copyright (C) 2015 Anshuman Khandual, IBM Corporation.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11 #include <inttypes.h>
12 #include <unistd.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <malloc.h>
16 #include <errno.h>
17 #include <time.h>
18 #include <sys/ptrace.h>
19 #include <sys/ioctl.h>
20 #include <sys/uio.h>
21 #include <sys/types.h>
22 #include <sys/wait.h>
23 #include <sys/signal.h>
24 #include <sys/ipc.h>
25 #include <sys/shm.h>
26 #include <sys/user.h>
27 #include <linux/elf.h>
28 #include <linux/types.h>
29 #include <linux/auxvec.h>
30 #include "reg.h"
31 #include "utils.h"
32 
33 #define TEST_PASS 0
34 #define TEST_FAIL 1
35 
36 struct fpr_regs {
37 	unsigned long fpr[32];
38 	unsigned long fpscr;
39 };
40 
41 struct tm_spr_regs {
42 	unsigned long tm_tfhar;
43 	unsigned long tm_texasr;
44 	unsigned long tm_tfiar;
45 };
46 
47 #ifndef NT_PPC_TAR
48 #define NT_PPC_TAR	0x103
49 #define NT_PPC_PPR	0x104
50 #define NT_PPC_DSCR	0x105
51 #define NT_PPC_EBB	0x106
52 #define NT_PPC_PMU	0x107
53 #define NT_PPC_TM_CGPR	0x108
54 #define NT_PPC_TM_CFPR	0x109
55 #define NT_PPC_TM_CVMX	0x10a
56 #define NT_PPC_TM_CVSX	0x10b
57 #define NT_PPC_TM_SPR	0x10c
58 #define NT_PPC_TM_CTAR	0x10d
59 #define NT_PPC_TM_CPPR	0x10e
60 #define NT_PPC_TM_CDSCR	0x10f
61 #endif
62 
63 /* Basic ptrace operations */
start_trace(pid_t child)64 int start_trace(pid_t child)
65 {
66 	int ret;
67 
68 	ret = ptrace(PTRACE_ATTACH, child, NULL, NULL);
69 	if (ret) {
70 		perror("ptrace(PTRACE_ATTACH) failed");
71 		return TEST_FAIL;
72 	}
73 	ret = waitpid(child, NULL, 0);
74 	if (ret != child) {
75 		perror("waitpid() failed");
76 		return TEST_FAIL;
77 	}
78 	return TEST_PASS;
79 }
80 
stop_trace(pid_t child)81 int stop_trace(pid_t child)
82 {
83 	int ret;
84 
85 	ret = ptrace(PTRACE_DETACH, child, NULL, NULL);
86 	if (ret) {
87 		perror("ptrace(PTRACE_DETACH) failed");
88 		return TEST_FAIL;
89 	}
90 	return TEST_PASS;
91 }
92 
cont_trace(pid_t child)93 int cont_trace(pid_t child)
94 {
95 	int ret;
96 
97 	ret = ptrace(PTRACE_CONT, child, NULL, NULL);
98 	if (ret) {
99 		perror("ptrace(PTRACE_CONT) failed");
100 		return TEST_FAIL;
101 	}
102 	return TEST_PASS;
103 }
104 
ptrace_read_regs(pid_t child,unsigned long type,unsigned long regs[],int n)105 int ptrace_read_regs(pid_t child, unsigned long type, unsigned long regs[],
106 		     int n)
107 {
108 	struct iovec iov;
109 	long ret;
110 
111 	FAIL_IF(start_trace(child));
112 
113 	iov.iov_base = regs;
114 	iov.iov_len = n * sizeof(unsigned long);
115 
116 	ret = ptrace(PTRACE_GETREGSET, child, type, &iov);
117 	if (ret)
118 		return ret;
119 
120 	FAIL_IF(stop_trace(child));
121 
122 	return TEST_PASS;
123 }
124 
ptrace_write_regs(pid_t child,unsigned long type,unsigned long regs[],int n)125 long ptrace_write_regs(pid_t child, unsigned long type, unsigned long regs[],
126 		       int n)
127 {
128 	struct iovec iov;
129 	long ret;
130 
131 	FAIL_IF(start_trace(child));
132 
133 	iov.iov_base = regs;
134 	iov.iov_len = n * sizeof(unsigned long);
135 
136 	ret = ptrace(PTRACE_SETREGSET, child, type, &iov);
137 
138 	FAIL_IF(stop_trace(child));
139 
140 	return ret;
141 }
142 
143 /* TAR, PPR, DSCR */
show_tar_registers(pid_t child,unsigned long * out)144 int show_tar_registers(pid_t child, unsigned long *out)
145 {
146 	struct iovec iov;
147 	unsigned long *reg;
148 	int ret;
149 
150 	reg = malloc(sizeof(unsigned long));
151 	if (!reg) {
152 		perror("malloc() failed");
153 		return TEST_FAIL;
154 	}
155 	iov.iov_base = (u64 *) reg;
156 	iov.iov_len = sizeof(unsigned long);
157 
158 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TAR, &iov);
159 	if (ret) {
160 		perror("ptrace(PTRACE_GETREGSET) failed");
161 		goto fail;
162 	}
163 	if (out)
164 		out[0] = *reg;
165 
166 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_PPR, &iov);
167 	if (ret) {
168 		perror("ptrace(PTRACE_GETREGSET) failed");
169 		goto fail;
170 	}
171 	if (out)
172 		out[1] = *reg;
173 
174 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_DSCR, &iov);
175 	if (ret) {
176 		perror("ptrace(PTRACE_GETREGSET) failed");
177 		goto fail;
178 	}
179 	if (out)
180 		out[2] = *reg;
181 
182 	free(reg);
183 	return TEST_PASS;
184 fail:
185 	free(reg);
186 	return TEST_FAIL;
187 }
188 
write_tar_registers(pid_t child,unsigned long tar,unsigned long ppr,unsigned long dscr)189 int write_tar_registers(pid_t child, unsigned long tar,
190 		unsigned long ppr, unsigned long dscr)
191 {
192 	struct iovec iov;
193 	unsigned long *reg;
194 	int ret;
195 
196 	reg = malloc(sizeof(unsigned long));
197 	if (!reg) {
198 		perror("malloc() failed");
199 		return TEST_FAIL;
200 	}
201 
202 	iov.iov_base = (u64 *) reg;
203 	iov.iov_len = sizeof(unsigned long);
204 
205 	*reg = tar;
206 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TAR, &iov);
207 	if (ret) {
208 		perror("ptrace(PTRACE_SETREGSET) failed");
209 		goto fail;
210 	}
211 
212 	*reg = ppr;
213 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_PPR, &iov);
214 	if (ret) {
215 		perror("ptrace(PTRACE_SETREGSET) failed");
216 		goto fail;
217 	}
218 
219 	*reg = dscr;
220 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_DSCR, &iov);
221 	if (ret) {
222 		perror("ptrace(PTRACE_SETREGSET) failed");
223 		goto fail;
224 	}
225 
226 	free(reg);
227 	return TEST_PASS;
228 fail:
229 	free(reg);
230 	return TEST_FAIL;
231 }
232 
show_tm_checkpointed_state(pid_t child,unsigned long * out)233 int show_tm_checkpointed_state(pid_t child, unsigned long *out)
234 {
235 	struct iovec iov;
236 	unsigned long *reg;
237 	int ret;
238 
239 	reg = malloc(sizeof(unsigned long));
240 	if (!reg) {
241 		perror("malloc() failed");
242 		return TEST_FAIL;
243 	}
244 
245 	iov.iov_base = (u64 *) reg;
246 	iov.iov_len = sizeof(unsigned long);
247 
248 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CTAR, &iov);
249 	if (ret) {
250 		perror("ptrace(PTRACE_GETREGSET) failed");
251 		goto fail;
252 	}
253 	if (out)
254 		out[0] = *reg;
255 
256 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CPPR, &iov);
257 	if (ret) {
258 		perror("ptrace(PTRACE_GETREGSET) failed");
259 		goto fail;
260 	}
261 	if (out)
262 		out[1] = *reg;
263 
264 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CDSCR, &iov);
265 	if (ret) {
266 		perror("ptrace(PTRACE_GETREGSET) failed");
267 		goto fail;
268 	}
269 	if (out)
270 		out[2] = *reg;
271 
272 	free(reg);
273 	return TEST_PASS;
274 
275 fail:
276 	free(reg);
277 	return TEST_FAIL;
278 }
279 
write_ckpt_tar_registers(pid_t child,unsigned long tar,unsigned long ppr,unsigned long dscr)280 int write_ckpt_tar_registers(pid_t child, unsigned long tar,
281 		unsigned long ppr, unsigned long dscr)
282 {
283 	struct iovec iov;
284 	unsigned long *reg;
285 	int ret;
286 
287 	reg = malloc(sizeof(unsigned long));
288 	if (!reg) {
289 		perror("malloc() failed");
290 		return TEST_FAIL;
291 	}
292 
293 	iov.iov_base = (u64 *) reg;
294 	iov.iov_len = sizeof(unsigned long);
295 
296 	*reg = tar;
297 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CTAR, &iov);
298 	if (ret) {
299 		perror("ptrace(PTRACE_GETREGSET) failed");
300 		goto fail;
301 	}
302 
303 	*reg = ppr;
304 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CPPR, &iov);
305 	if (ret) {
306 		perror("ptrace(PTRACE_GETREGSET) failed");
307 		goto fail;
308 	}
309 
310 	*reg = dscr;
311 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CDSCR, &iov);
312 	if (ret) {
313 		perror("ptrace(PTRACE_GETREGSET) failed");
314 		goto fail;
315 	}
316 
317 	free(reg);
318 	return TEST_PASS;
319 fail:
320 	free(reg);
321 	return TEST_FAIL;
322 }
323 
324 /* FPR */
show_fpr(pid_t child,unsigned long * fpr)325 int show_fpr(pid_t child, unsigned long *fpr)
326 {
327 	struct fpr_regs *regs;
328 	int ret, i;
329 
330 	regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs));
331 	ret = ptrace(PTRACE_GETFPREGS, child, NULL, regs);
332 	if (ret) {
333 		perror("ptrace(PTRACE_GETREGSET) failed");
334 		return TEST_FAIL;
335 	}
336 
337 	if (fpr) {
338 		for (i = 0; i < 32; i++)
339 			fpr[i] = regs->fpr[i];
340 	}
341 	return TEST_PASS;
342 }
343 
write_fpr(pid_t child,unsigned long val)344 int write_fpr(pid_t child, unsigned long val)
345 {
346 	struct fpr_regs *regs;
347 	int ret, i;
348 
349 	regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs));
350 	ret = ptrace(PTRACE_GETFPREGS, child, NULL, regs);
351 	if (ret) {
352 		perror("ptrace(PTRACE_GETREGSET) failed");
353 		return TEST_FAIL;
354 	}
355 
356 	for (i = 0; i < 32; i++)
357 		regs->fpr[i] = val;
358 
359 	ret = ptrace(PTRACE_SETFPREGS, child, NULL, regs);
360 	if (ret) {
361 		perror("ptrace(PTRACE_GETREGSET) failed");
362 		return TEST_FAIL;
363 	}
364 	return TEST_PASS;
365 }
366 
show_ckpt_fpr(pid_t child,unsigned long * fpr)367 int show_ckpt_fpr(pid_t child, unsigned long *fpr)
368 {
369 	struct fpr_regs *regs;
370 	struct iovec iov;
371 	int ret, i;
372 
373 	regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs));
374 	iov.iov_base = regs;
375 	iov.iov_len = sizeof(struct fpr_regs);
376 
377 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CFPR, &iov);
378 	if (ret) {
379 		perror("ptrace(PTRACE_GETREGSET) failed");
380 		return TEST_FAIL;
381 	}
382 
383 	if (fpr) {
384 		for (i = 0; i < 32; i++)
385 			fpr[i] = regs->fpr[i];
386 	}
387 
388 	return TEST_PASS;
389 }
390 
write_ckpt_fpr(pid_t child,unsigned long val)391 int write_ckpt_fpr(pid_t child, unsigned long val)
392 {
393 	struct fpr_regs *regs;
394 	struct iovec iov;
395 	int ret, i;
396 
397 	regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs));
398 	iov.iov_base = regs;
399 	iov.iov_len = sizeof(struct fpr_regs);
400 
401 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CFPR, &iov);
402 	if (ret) {
403 		perror("ptrace(PTRACE_GETREGSET) failed");
404 		return TEST_FAIL;
405 	}
406 
407 	for (i = 0; i < 32; i++)
408 		regs->fpr[i] = val;
409 
410 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CFPR, &iov);
411 	if (ret) {
412 		perror("ptrace(PTRACE_GETREGSET) failed");
413 		return TEST_FAIL;
414 	}
415 	return TEST_PASS;
416 }
417 
418 /* GPR */
show_gpr(pid_t child,unsigned long * gpr)419 int show_gpr(pid_t child, unsigned long *gpr)
420 {
421 	struct pt_regs *regs;
422 	int ret, i;
423 
424 	regs = (struct pt_regs *) malloc(sizeof(struct pt_regs));
425 	if (!regs) {
426 		perror("malloc() failed");
427 		return TEST_FAIL;
428 	}
429 
430 	ret = ptrace(PTRACE_GETREGS, child, NULL, regs);
431 	if (ret) {
432 		perror("ptrace(PTRACE_GETREGSET) failed");
433 		return TEST_FAIL;
434 	}
435 
436 	if (gpr) {
437 		for (i = 14; i < 32; i++)
438 			gpr[i-14] = regs->gpr[i];
439 	}
440 
441 	return TEST_PASS;
442 }
443 
write_gpr(pid_t child,unsigned long val)444 int write_gpr(pid_t child, unsigned long val)
445 {
446 	struct pt_regs *regs;
447 	int i, ret;
448 
449 	regs = (struct pt_regs *) malloc(sizeof(struct pt_regs));
450 	if (!regs) {
451 		perror("malloc() failed");
452 		return TEST_FAIL;
453 	}
454 
455 	ret = ptrace(PTRACE_GETREGS, child, NULL, regs);
456 	if (ret) {
457 		perror("ptrace(PTRACE_GETREGSET) failed");
458 		return TEST_FAIL;
459 	}
460 
461 	for (i = 14; i < 32; i++)
462 		regs->gpr[i] = val;
463 
464 	ret = ptrace(PTRACE_SETREGS, child, NULL, regs);
465 	if (ret) {
466 		perror("ptrace(PTRACE_GETREGSET) failed");
467 		return TEST_FAIL;
468 	}
469 	return TEST_PASS;
470 }
471 
show_ckpt_gpr(pid_t child,unsigned long * gpr)472 int show_ckpt_gpr(pid_t child, unsigned long *gpr)
473 {
474 	struct pt_regs *regs;
475 	struct iovec iov;
476 	int ret, i;
477 
478 	regs = (struct pt_regs *) malloc(sizeof(struct pt_regs));
479 	if (!regs) {
480 		perror("malloc() failed");
481 		return TEST_FAIL;
482 	}
483 
484 	iov.iov_base = (u64 *) regs;
485 	iov.iov_len = sizeof(struct pt_regs);
486 
487 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CGPR, &iov);
488 	if (ret) {
489 		perror("ptrace(PTRACE_GETREGSET) failed");
490 		return TEST_FAIL;
491 	}
492 
493 	if (gpr) {
494 		for (i = 14; i < 32; i++)
495 			gpr[i-14] = regs->gpr[i];
496 	}
497 
498 	return TEST_PASS;
499 }
500 
write_ckpt_gpr(pid_t child,unsigned long val)501 int write_ckpt_gpr(pid_t child, unsigned long val)
502 {
503 	struct pt_regs *regs;
504 	struct iovec iov;
505 	int ret, i;
506 
507 	regs = (struct pt_regs *) malloc(sizeof(struct pt_regs));
508 	if (!regs) {
509 		perror("malloc() failed\n");
510 		return TEST_FAIL;
511 	}
512 	iov.iov_base = (u64 *) regs;
513 	iov.iov_len = sizeof(struct pt_regs);
514 
515 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CGPR, &iov);
516 	if (ret) {
517 		perror("ptrace(PTRACE_GETREGSET) failed");
518 		return TEST_FAIL;
519 	}
520 
521 	for (i = 14; i < 32; i++)
522 		regs->gpr[i] = val;
523 
524 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CGPR, &iov);
525 	if (ret) {
526 		perror("ptrace(PTRACE_GETREGSET) failed");
527 		return TEST_FAIL;
528 	}
529 	return TEST_PASS;
530 }
531 
532 /* VMX */
show_vmx(pid_t child,unsigned long vmx[][2])533 int show_vmx(pid_t child, unsigned long vmx[][2])
534 {
535 	int ret;
536 
537 	ret = ptrace(PTRACE_GETVRREGS, child, 0, vmx);
538 	if (ret) {
539 		perror("ptrace(PTRACE_GETVRREGS) failed");
540 		return TEST_FAIL;
541 	}
542 	return TEST_PASS;
543 }
544 
show_vmx_ckpt(pid_t child,unsigned long vmx[][2])545 int show_vmx_ckpt(pid_t child, unsigned long vmx[][2])
546 {
547 	unsigned long regs[34][2];
548 	struct iovec iov;
549 	int ret;
550 
551 	iov.iov_base = (u64 *) regs;
552 	iov.iov_len = sizeof(regs);
553 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CVMX, &iov);
554 	if (ret) {
555 		perror("ptrace(PTRACE_GETREGSET, NT_PPC_TM_CVMX) failed");
556 		return TEST_FAIL;
557 	}
558 	memcpy(vmx, regs, sizeof(regs));
559 	return TEST_PASS;
560 }
561 
562 
write_vmx(pid_t child,unsigned long vmx[][2])563 int write_vmx(pid_t child, unsigned long vmx[][2])
564 {
565 	int ret;
566 
567 	ret = ptrace(PTRACE_SETVRREGS, child, 0, vmx);
568 	if (ret) {
569 		perror("ptrace(PTRACE_SETVRREGS) failed");
570 		return TEST_FAIL;
571 	}
572 	return TEST_PASS;
573 }
574 
write_vmx_ckpt(pid_t child,unsigned long vmx[][2])575 int write_vmx_ckpt(pid_t child, unsigned long vmx[][2])
576 {
577 	unsigned long regs[34][2];
578 	struct iovec iov;
579 	int ret;
580 
581 	memcpy(regs, vmx, sizeof(regs));
582 	iov.iov_base = (u64 *) regs;
583 	iov.iov_len = sizeof(regs);
584 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CVMX, &iov);
585 	if (ret) {
586 		perror("ptrace(PTRACE_SETREGSET, NT_PPC_TM_CVMX) failed");
587 		return TEST_FAIL;
588 	}
589 	return TEST_PASS;
590 }
591 
592 /* VSX */
show_vsx(pid_t child,unsigned long * vsx)593 int show_vsx(pid_t child, unsigned long *vsx)
594 {
595 	int ret;
596 
597 	ret = ptrace(PTRACE_GETVSRREGS, child, 0, vsx);
598 	if (ret) {
599 		perror("ptrace(PTRACE_GETVSRREGS) failed");
600 		return TEST_FAIL;
601 	}
602 	return TEST_PASS;
603 }
604 
show_vsx_ckpt(pid_t child,unsigned long * vsx)605 int show_vsx_ckpt(pid_t child, unsigned long *vsx)
606 {
607 	unsigned long regs[32];
608 	struct iovec iov;
609 	int ret;
610 
611 	iov.iov_base = (u64 *) regs;
612 	iov.iov_len = sizeof(regs);
613 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CVSX, &iov);
614 	if (ret) {
615 		perror("ptrace(PTRACE_GETREGSET, NT_PPC_TM_CVSX) failed");
616 		return TEST_FAIL;
617 	}
618 	memcpy(vsx, regs, sizeof(regs));
619 	return TEST_PASS;
620 }
621 
write_vsx(pid_t child,unsigned long * vsx)622 int write_vsx(pid_t child, unsigned long *vsx)
623 {
624 	int ret;
625 
626 	ret = ptrace(PTRACE_SETVSRREGS, child, 0, vsx);
627 	if (ret) {
628 		perror("ptrace(PTRACE_SETVSRREGS) failed");
629 		return TEST_FAIL;
630 	}
631 	return TEST_PASS;
632 }
633 
write_vsx_ckpt(pid_t child,unsigned long * vsx)634 int write_vsx_ckpt(pid_t child, unsigned long *vsx)
635 {
636 	unsigned long regs[32];
637 	struct iovec iov;
638 	int ret;
639 
640 	memcpy(regs, vsx, sizeof(regs));
641 	iov.iov_base = (u64 *) regs;
642 	iov.iov_len = sizeof(regs);
643 	ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CVSX, &iov);
644 	if (ret) {
645 		perror("ptrace(PTRACE_SETREGSET, NT_PPC_TM_CVSX) failed");
646 		return TEST_FAIL;
647 	}
648 	return TEST_PASS;
649 }
650 
651 /* TM SPR */
show_tm_spr(pid_t child,struct tm_spr_regs * out)652 int show_tm_spr(pid_t child, struct tm_spr_regs *out)
653 {
654 	struct tm_spr_regs *regs;
655 	struct iovec iov;
656 	int ret;
657 
658 	regs = (struct tm_spr_regs *) malloc(sizeof(struct tm_spr_regs));
659 	if (!regs) {
660 		perror("malloc() failed");
661 		return TEST_FAIL;
662 	}
663 
664 	iov.iov_base = (u64 *) regs;
665 	iov.iov_len = sizeof(struct tm_spr_regs);
666 
667 	ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_SPR, &iov);
668 	if (ret) {
669 		perror("ptrace(PTRACE_GETREGSET) failed");
670 		return TEST_FAIL;
671 	}
672 
673 	if (out)
674 		memcpy(out, regs, sizeof(struct tm_spr_regs));
675 
676 	return TEST_PASS;
677 }
678 
679 
680 
681 /* Analyse TEXASR after TM failure */
get_tfiar(void)682 inline unsigned long get_tfiar(void)
683 {
684 	unsigned long ret;
685 
686 	asm volatile("mfspr %0,%1" : "=r" (ret) : "i" (SPRN_TFIAR));
687 	return ret;
688 }
689 
analyse_texasr(unsigned long texasr)690 void analyse_texasr(unsigned long texasr)
691 {
692 	printf("TEXASR: %16lx\t", texasr);
693 
694 	if (texasr & TEXASR_FP)
695 		printf("TEXASR_FP  ");
696 
697 	if (texasr & TEXASR_DA)
698 		printf("TEXASR_DA  ");
699 
700 	if (texasr & TEXASR_NO)
701 		printf("TEXASR_NO  ");
702 
703 	if (texasr & TEXASR_FO)
704 		printf("TEXASR_FO  ");
705 
706 	if (texasr & TEXASR_SIC)
707 		printf("TEXASR_SIC  ");
708 
709 	if (texasr & TEXASR_NTC)
710 		printf("TEXASR_NTC  ");
711 
712 	if (texasr & TEXASR_TC)
713 		printf("TEXASR_TC  ");
714 
715 	if (texasr & TEXASR_TIC)
716 		printf("TEXASR_TIC  ");
717 
718 	if (texasr & TEXASR_IC)
719 		printf("TEXASR_IC  ");
720 
721 	if (texasr & TEXASR_IFC)
722 		printf("TEXASR_IFC  ");
723 
724 	if (texasr & TEXASR_ABT)
725 		printf("TEXASR_ABT  ");
726 
727 	if (texasr & TEXASR_SPD)
728 		printf("TEXASR_SPD  ");
729 
730 	if (texasr & TEXASR_HV)
731 		printf("TEXASR_HV  ");
732 
733 	if (texasr & TEXASR_PR)
734 		printf("TEXASR_PR  ");
735 
736 	if (texasr & TEXASR_FS)
737 		printf("TEXASR_FS  ");
738 
739 	if (texasr & TEXASR_TE)
740 		printf("TEXASR_TE  ");
741 
742 	if (texasr & TEXASR_ROT)
743 		printf("TEXASR_ROT  ");
744 
745 	printf("TFIAR :%lx\n", get_tfiar());
746 }
747 
748 void store_gpr(unsigned long *addr);
749 void store_fpr(float *addr);
750