[PATCH 22/57][Arm][GAS] Add support for MVE instructions: vmlaldav, vmlalv, vmlsldav...
[binutils-gdb.git] / sim / mips / cp1.c
blob3bb68ff9e4f61ea152c006055842419733c21101
1 /*> cp1.c <*/
2 /* MIPS Simulator FPU (CoProcessor 1) support.
3 Copyright (C) 2002-2019 Free Software Foundation, Inc.
4 Originally created by Cygnus Solutions. Extensive modifications,
5 including paired-single operation support and MIPS-3D support
6 contributed by Ed Satterthwaite and Chris Demetriou, of Broadcom
7 Corporation (SiByte).
9 This file is part of GDB, the GNU debugger.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 /* XXX: The following notice should be removed as soon as is practical: */
25 /* Floating Point Support for gdb MIPS simulators
27 This file is part of the MIPS sim
29 THIS SOFTWARE IS NOT COPYRIGHTED
30 (by Cygnus.)
32 Cygnus offers the following for use in the public domain. Cygnus
33 makes no warranty with regard to the software or it's performance
34 and the user accepts the software "AS IS" with all faults.
36 CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
37 THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
38 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
40 (Originally, this code was in interp.c)
43 #include "sim-main.h"
45 /* Within cp1.c we refer to sim_cpu directly. */
46 #define CPU cpu
47 #define SD CPU_STATE(cpu)
49 /*-- FPU support routines ---------------------------------------------------*/
51 /* Numbers are held in normalized form. The SINGLE and DOUBLE binary
52 formats conform to ANSI/IEEE Std 754-1985.
54 SINGLE precision floating:
55 seeeeeeeefffffffffffffffffffffff
56 s = 1bit = sign
57 e = 8bits = exponent
58 f = 23bits = fraction
60 SINGLE precision fixed:
61 siiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
62 s = 1bit = sign
63 i = 31bits = integer
65 DOUBLE precision floating:
66 seeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffff
67 s = 1bit = sign
68 e = 11bits = exponent
69 f = 52bits = fraction
71 DOUBLE precision fixed:
72 siiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
73 s = 1bit = sign
74 i = 63bits = integer
76 PAIRED SINGLE precision floating:
77 seeeeeeeefffffffffffffffffffffffseeeeeeeefffffffffffffffffffffff
78 | upper || lower |
79 s = 1bit = sign
80 e = 8bits = exponent
81 f = 23bits = fraction
82 Note: upper = [63..32], lower = [31..0]
85 /* Extract packed single values: */
86 #define FP_PS_upper(v) (((v) >> 32) & (unsigned)0xFFFFFFFF)
87 #define FP_PS_lower(v) ((v) & (unsigned)0xFFFFFFFF)
88 #define FP_PS_cat(u,l) (((unsigned64)((u) & (unsigned)0xFFFFFFFF) << 32) \
89 | (unsigned64)((l) & 0xFFFFFFFF))
91 /* Explicit QNaN values. */
92 #define FPQNaN_SINGLE (0x7FBFFFFF)
93 #define FPQNaN_WORD (0x7FFFFFFF)
94 #define FPQNaN_DOUBLE (UNSIGNED64 (0x7FF7FFFFFFFFFFFF))
95 #define FPQNaN_LONG (UNSIGNED64 (0x7FFFFFFFFFFFFFFF))
96 #define FPQNaN_PS (FP_PS_cat (FPQNaN_SINGLE, FPQNaN_SINGLE))
98 static const char *fpu_format_name (FP_formats fmt);
99 #ifdef DEBUG
100 static const char *fpu_rounding_mode_name (int rm);
101 #endif
103 uword64
104 value_fpr (sim_cpu *cpu,
105 address_word cia,
106 int fpr,
107 FP_formats fmt)
109 uword64 value = 0;
110 int err = 0;
112 /* Treat unused register values, as fixed-point 64bit values. */
113 if (fmt == fmt_unknown)
115 #if 1
116 /* If request to read data as "unknown", then use the current
117 encoding: */
118 fmt = FPR_STATE[fpr];
119 #else
120 fmt = fmt_long;
121 #endif
124 /* For values not yet accessed, set to the desired format. */
125 if (fmt < fmt_uninterpreted)
127 if (FPR_STATE[fpr] == fmt_uninterpreted)
129 FPR_STATE[fpr] = fmt;
130 #ifdef DEBUG
131 printf ("DBG: Register %d was fmt_uninterpreted. Now %s\n", fpr,
132 fpu_format_name (fmt));
133 #endif /* DEBUG */
135 else if (fmt != FPR_STATE[fpr])
137 sim_io_eprintf (SD, "FPR %d (format %s) being accessed with format %s - setting to unknown (PC = 0x%s)\n",
138 fpr, fpu_format_name (FPR_STATE[fpr]),
139 fpu_format_name (fmt), pr_addr (cia));
140 FPR_STATE[fpr] = fmt_unknown;
144 if (FPR_STATE[fpr] == fmt_unknown)
146 /* Set QNaN value: */
147 switch (fmt)
149 case fmt_single: value = FPQNaN_SINGLE; break;
150 case fmt_double: value = FPQNaN_DOUBLE; break;
151 case fmt_word: value = FPQNaN_WORD; break;
152 case fmt_long: value = FPQNaN_LONG; break;
153 case fmt_ps: value = FPQNaN_PS; break;
154 default: err = -1; break;
157 else if (SizeFGR () == 64)
159 switch (fmt)
161 case fmt_uninterpreted_32:
162 case fmt_single:
163 case fmt_word:
164 value = (FGR[fpr] & 0xFFFFFFFF);
165 break;
167 case fmt_uninterpreted_64:
168 case fmt_uninterpreted:
169 case fmt_double:
170 case fmt_long:
171 case fmt_ps:
172 value = FGR[fpr];
173 break;
175 default:
176 err = -1;
177 break;
180 else
182 switch (fmt)
184 case fmt_uninterpreted_32:
185 case fmt_single:
186 case fmt_word:
187 value = (FGR[fpr] & 0xFFFFFFFF);
188 break;
190 case fmt_uninterpreted_64:
191 case fmt_uninterpreted:
192 case fmt_double:
193 case fmt_long:
194 if ((fpr & 1) == 0)
196 /* Even register numbers only. */
197 #ifdef DEBUG
198 printf ("DBG: ValueFPR: FGR[%d] = %s, FGR[%d] = %s\n",
199 fpr + 1, pr_uword64 ((uword64) FGR[fpr+1]),
200 fpr, pr_uword64 ((uword64) FGR[fpr]));
201 #endif
202 value = ((((uword64) FGR[fpr+1]) << 32)
203 | (FGR[fpr] & 0xFFFFFFFF));
205 else
207 SignalException (ReservedInstruction, 0);
209 break;
211 case fmt_ps:
212 SignalException (ReservedInstruction, 0);
213 break;
215 default:
216 err = -1;
217 break;
221 if (err)
222 SignalExceptionSimulatorFault ("Unrecognised FP format in ValueFPR ()");
224 #ifdef DEBUG
225 printf ("DBG: ValueFPR: fpr = %d, fmt = %s, value = 0x%s : PC = 0x%s : SizeFGR () = %d\n",
226 fpr, fpu_format_name (fmt), pr_uword64 (value), pr_addr (cia),
227 SizeFGR ());
228 #endif /* DEBUG */
230 return (value);
233 void
234 store_fpr (sim_cpu *cpu,
235 address_word cia,
236 int fpr,
237 FP_formats fmt,
238 uword64 value)
240 int err = 0;
242 #ifdef DEBUG
243 printf ("DBG: StoreFPR: fpr = %d, fmt = %s, value = 0x%s : PC = 0x%s : SizeFGR () = %d, \n",
244 fpr, fpu_format_name (fmt), pr_uword64 (value), pr_addr (cia),
245 SizeFGR ());
246 #endif /* DEBUG */
248 if (SizeFGR () == 64)
250 switch (fmt)
252 case fmt_uninterpreted_32:
253 fmt = fmt_uninterpreted;
254 case fmt_single:
255 case fmt_word:
256 if (STATE_VERBOSE_P (SD))
257 sim_io_eprintf (SD,
258 "Warning: PC 0x%s: interp.c store_fpr DEADCODE\n",
259 pr_addr (cia));
260 FGR[fpr] = (((uword64) 0xDEADC0DE << 32) | (value & 0xFFFFFFFF));
261 FPR_STATE[fpr] = fmt;
262 break;
264 case fmt_uninterpreted_64:
265 fmt = fmt_uninterpreted;
266 case fmt_uninterpreted:
267 case fmt_double:
268 case fmt_long:
269 case fmt_ps:
270 FGR[fpr] = value;
271 FPR_STATE[fpr] = fmt;
272 break;
274 default:
275 FPR_STATE[fpr] = fmt_unknown;
276 err = -1;
277 break;
280 else
282 switch (fmt)
284 case fmt_uninterpreted_32:
285 fmt = fmt_uninterpreted;
286 case fmt_single:
287 case fmt_word:
288 FGR[fpr] = (value & 0xFFFFFFFF);
289 FPR_STATE[fpr] = fmt;
290 break;
292 case fmt_uninterpreted_64:
293 fmt = fmt_uninterpreted;
294 case fmt_uninterpreted:
295 case fmt_double:
296 case fmt_long:
297 if ((fpr & 1) == 0)
299 /* Even register numbers only. */
300 FGR[fpr+1] = (value >> 32);
301 FGR[fpr] = (value & 0xFFFFFFFF);
302 FPR_STATE[fpr + 1] = fmt;
303 FPR_STATE[fpr] = fmt;
305 else
307 FPR_STATE[fpr] = fmt_unknown;
308 FPR_STATE[fpr ^ 1] = fmt_unknown;
309 SignalException (ReservedInstruction, 0);
311 break;
313 case fmt_ps:
314 FPR_STATE[fpr] = fmt_unknown;
315 SignalException (ReservedInstruction, 0);
316 break;
318 default:
319 FPR_STATE[fpr] = fmt_unknown;
320 err = -1;
321 break;
325 if (err)
326 SignalExceptionSimulatorFault ("Unrecognised FP format in StoreFPR ()");
328 #ifdef DEBUG
329 printf ("DBG: StoreFPR: fpr[%d] = 0x%s (format %s)\n",
330 fpr, pr_uword64 (FGR[fpr]), fpu_format_name (fmt));
331 #endif /* DEBUG */
333 return;
337 /* CP1 control/status register access functions. */
339 void
340 test_fcsr (sim_cpu *cpu,
341 address_word cia)
343 unsigned int cause;
345 cause = (FCSR & fcsr_CAUSE_mask) >> fcsr_CAUSE_shift;
346 if ((cause & ((FCSR & fcsr_ENABLES_mask) >> fcsr_ENABLES_shift)) != 0
347 || (cause & (1 << UO)))
349 SignalExceptionFPE();
353 unsigned_word
354 value_fcr(sim_cpu *cpu,
355 address_word cia,
356 int fcr)
358 unsigned32 value = 0;
360 switch (fcr)
362 case 0: /* FP Implementation and Revision Register. */
363 value = FCR0;
364 break;
365 case 25: /* FP Condition Codes Register (derived from FCSR). */
366 value = (FCR31 & fcsr_FCC_mask) >> fcsr_FCC_shift;
367 value = (value & 0x1) | (value >> 1); /* Close FCC gap. */
368 break;
369 case 26: /* FP Exceptions Register (derived from FCSR). */
370 value = FCR31 & (fcsr_CAUSE_mask | fcsr_FLAGS_mask);
371 break;
372 case 28: /* FP Enables Register (derived from FCSR). */
373 value = FCR31 & (fcsr_ENABLES_mask | fcsr_RM_mask);
374 if ((FCR31 & fcsr_FS) != 0)
375 value |= fenr_FS;
376 break;
377 case 31: /* FP Control/Status Register (FCSR). */
378 value = FCR31 & ~fcsr_ZERO_mask;
379 break;
382 return (EXTEND32 (value));
385 void
386 store_fcr(sim_cpu *cpu,
387 address_word cia,
388 int fcr,
389 unsigned_word value)
391 unsigned32 v;
393 v = VL4_8(value);
394 switch (fcr)
396 case 25: /* FP Condition Codes Register (stored into FCSR). */
397 v = (v << 1) | (v & 0x1); /* Adjust for FCC gap. */
398 FCR31 &= ~fcsr_FCC_mask;
399 FCR31 |= ((v << fcsr_FCC_shift) & fcsr_FCC_mask);
400 break;
401 case 26: /* FP Exceptions Register (stored into FCSR). */
402 FCR31 &= ~(fcsr_CAUSE_mask | fcsr_FLAGS_mask);
403 FCR31 |= (v & (fcsr_CAUSE_mask | fcsr_FLAGS_mask));
404 test_fcsr(cpu, cia);
405 break;
406 case 28: /* FP Enables Register (stored into FCSR). */
407 if ((v & fenr_FS) != 0)
408 v |= fcsr_FS;
409 else
410 v &= ~fcsr_FS;
411 FCR31 &= (fcsr_FCC_mask | fcsr_CAUSE_mask | fcsr_FLAGS_mask);
412 FCR31 |= (v & (fcsr_FS | fcsr_ENABLES_mask | fcsr_RM_mask));
413 test_fcsr(cpu, cia);
414 break;
415 case 31: /* FP Control/Status Register (FCSR). */
416 FCR31 = v & ~fcsr_ZERO_mask;
417 test_fcsr(cpu, cia);
418 break;
422 void
423 update_fcsr (sim_cpu *cpu,
424 address_word cia,
425 sim_fpu_status status)
427 FCSR &= ~fcsr_CAUSE_mask;
429 if (status != 0)
431 unsigned int cause = 0;
433 /* map between sim_fpu codes and MIPS FCSR */
434 if (status & (sim_fpu_status_invalid_snan
435 | sim_fpu_status_invalid_isi
436 | sim_fpu_status_invalid_idi
437 | sim_fpu_status_invalid_zdz
438 | sim_fpu_status_invalid_imz
439 | sim_fpu_status_invalid_cmp
440 | sim_fpu_status_invalid_sqrt
441 | sim_fpu_status_invalid_cvi))
442 cause |= (1 << IO);
443 if (status & sim_fpu_status_invalid_div0)
444 cause |= (1 << DZ);
445 if (status & sim_fpu_status_overflow)
446 cause |= (1 << OF);
447 if (status & sim_fpu_status_underflow)
448 cause |= (1 << UF);
449 if (status & sim_fpu_status_inexact)
450 cause |= (1 << IR);
451 #if 0 /* Not yet. */
452 /* Implicit clearing of other bits by unimplemented done by callers. */
453 if (status & sim_fpu_status_unimplemented)
454 cause |= (1 << UO);
455 #endif
457 FCSR |= (cause << fcsr_CAUSE_shift);
458 test_fcsr (cpu, cia);
459 FCSR |= ((cause & ~(1 << UO)) << fcsr_FLAGS_shift);
461 return;
464 static sim_fpu_round
465 rounding_mode(int rm)
467 sim_fpu_round round;
469 switch (rm)
471 case FP_RM_NEAREST:
472 /* Round result to nearest representable value. When two
473 representable values are equally near, round to the value
474 that has a least significant bit of zero (i.e. is even). */
475 round = sim_fpu_round_near;
476 break;
477 case FP_RM_TOZERO:
478 /* Round result to the value closest to, and not greater in
479 magnitude than, the result. */
480 round = sim_fpu_round_zero;
481 break;
482 case FP_RM_TOPINF:
483 /* Round result to the value closest to, and not less than,
484 the result. */
485 round = sim_fpu_round_up;
486 break;
487 case FP_RM_TOMINF:
488 /* Round result to the value closest to, and not greater than,
489 the result. */
490 round = sim_fpu_round_down;
491 break;
492 default:
493 round = 0;
494 fprintf (stderr, "Bad switch\n");
495 abort ();
497 return round;
500 /* When the FS bit is set, MIPS processors return zero for
501 denormalized results and optionally replace denormalized inputs
502 with zero. When FS is clear, some implementation trap on input
503 and/or output, while other perform the operation in hardware. */
504 static sim_fpu_denorm
505 denorm_mode(sim_cpu *cpu)
507 sim_fpu_denorm denorm;
509 /* XXX: FIXME: Eventually should be CPU model dependent. */
510 if (GETFS())
511 denorm = sim_fpu_denorm_zero;
512 else
513 denorm = 0;
514 return denorm;
518 /* Comparison operations. */
520 static sim_fpu_status
521 fp_test(unsigned64 op1,
522 unsigned64 op2,
523 FP_formats fmt,
524 int abs,
525 int cond,
526 int *condition)
528 sim_fpu wop1;
529 sim_fpu wop2;
530 sim_fpu_status status = 0;
531 int less, equal, unordered;
533 /* The format type has already been checked: */
534 switch (fmt)
536 case fmt_single:
538 sim_fpu_32to (&wop1, op1);
539 sim_fpu_32to (&wop2, op2);
540 break;
542 case fmt_double:
544 sim_fpu_64to (&wop1, op1);
545 sim_fpu_64to (&wop2, op2);
546 break;
548 default:
549 fprintf (stderr, "Bad switch\n");
550 abort ();
553 if (sim_fpu_is_nan (&wop1) || sim_fpu_is_nan (&wop2))
555 if ((cond & (1 << 3)) ||
556 sim_fpu_is_snan (&wop1) || sim_fpu_is_snan (&wop2))
557 status = sim_fpu_status_invalid_snan;
558 less = 0;
559 equal = 0;
560 unordered = 1;
562 else
564 if (abs)
566 status |= sim_fpu_abs (&wop1, &wop1);
567 status |= sim_fpu_abs (&wop2, &wop2);
569 equal = sim_fpu_is_eq (&wop1, &wop2);
570 less = !equal && sim_fpu_is_lt (&wop1, &wop2);
571 unordered = 0;
573 *condition = (((cond & (1 << 2)) && less)
574 || ((cond & (1 << 1)) && equal)
575 || ((cond & (1 << 0)) && unordered));
576 return status;
579 void
580 fp_cmp(sim_cpu *cpu,
581 address_word cia,
582 unsigned64 op1,
583 unsigned64 op2,
584 FP_formats fmt,
585 int abs,
586 int cond,
587 int cc)
589 sim_fpu_status status = 0;
591 /* The format type should already have been checked. The FCSR is
592 updated before the condition codes so that any exceptions will
593 be signalled before the condition codes are changed. */
594 switch (fmt)
596 case fmt_single:
597 case fmt_double:
599 int result;
600 status = fp_test(op1, op2, fmt, abs, cond, &result);
601 update_fcsr (cpu, cia, status);
602 SETFCC (cc, result);
603 break;
605 case fmt_ps:
607 int result0, result1;
608 status = fp_test(FP_PS_lower (op1), FP_PS_lower (op2), fmt_single,
609 abs, cond, &result0);
610 status |= fp_test(FP_PS_upper (op1), FP_PS_upper (op2), fmt_single,
611 abs, cond, &result1);
612 update_fcsr (cpu, cia, status);
613 SETFCC (cc, result0);
614 SETFCC (cc+1, result1);
615 break;
617 default:
618 sim_io_eprintf (SD, "Bad switch\n");
619 abort ();
624 /* Basic arithmetic operations. */
626 static unsigned64
627 fp_unary(sim_cpu *cpu,
628 address_word cia,
629 int (*sim_fpu_op)(sim_fpu *, const sim_fpu *),
630 unsigned64 op,
631 FP_formats fmt)
633 sim_fpu wop;
634 sim_fpu ans;
635 sim_fpu_round round = rounding_mode (GETRM());
636 sim_fpu_denorm denorm = denorm_mode (cpu);
637 sim_fpu_status status = 0;
638 unsigned64 result = 0;
640 /* The format type has already been checked: */
641 switch (fmt)
643 case fmt_single:
645 unsigned32 res;
646 sim_fpu_32to (&wop, op);
647 status |= (*sim_fpu_op) (&ans, &wop);
648 status |= sim_fpu_round_32 (&ans, round, denorm);
649 sim_fpu_to32 (&res, &ans);
650 result = res;
651 break;
653 case fmt_double:
655 unsigned64 res;
656 sim_fpu_64to (&wop, op);
657 status |= (*sim_fpu_op) (&ans, &wop);
658 status |= sim_fpu_round_64 (&ans, round, denorm);
659 sim_fpu_to64 (&res, &ans);
660 result = res;
661 break;
663 case fmt_ps:
665 int status_u = 0, status_l = 0;
666 unsigned32 res_u, res_l;
667 sim_fpu_32to (&wop, FP_PS_upper(op));
668 status_u |= (*sim_fpu_op) (&ans, &wop);
669 sim_fpu_to32 (&res_u, &ans);
670 sim_fpu_32to (&wop, FP_PS_lower(op));
671 status_l |= (*sim_fpu_op) (&ans, &wop);
672 sim_fpu_to32 (&res_l, &ans);
673 result = FP_PS_cat(res_u, res_l);
674 status = status_u | status_l;
675 break;
677 default:
678 sim_io_eprintf (SD, "Bad switch\n");
679 abort ();
682 update_fcsr (cpu, cia, status);
683 return result;
686 static unsigned64
687 fp_binary(sim_cpu *cpu,
688 address_word cia,
689 int (*sim_fpu_op)(sim_fpu *, const sim_fpu *, const sim_fpu *),
690 unsigned64 op1,
691 unsigned64 op2,
692 FP_formats fmt)
694 sim_fpu wop1;
695 sim_fpu wop2;
696 sim_fpu ans;
697 sim_fpu_round round = rounding_mode (GETRM());
698 sim_fpu_denorm denorm = denorm_mode (cpu);
699 sim_fpu_status status = 0;
700 unsigned64 result = 0;
702 /* The format type has already been checked: */
703 switch (fmt)
705 case fmt_single:
707 unsigned32 res;
708 sim_fpu_32to (&wop1, op1);
709 sim_fpu_32to (&wop2, op2);
710 status |= (*sim_fpu_op) (&ans, &wop1, &wop2);
711 status |= sim_fpu_round_32 (&ans, round, denorm);
712 sim_fpu_to32 (&res, &ans);
713 result = res;
714 break;
716 case fmt_double:
718 unsigned64 res;
719 sim_fpu_64to (&wop1, op1);
720 sim_fpu_64to (&wop2, op2);
721 status |= (*sim_fpu_op) (&ans, &wop1, &wop2);
722 status |= sim_fpu_round_64 (&ans, round, denorm);
723 sim_fpu_to64 (&res, &ans);
724 result = res;
725 break;
727 case fmt_ps:
729 int status_u = 0, status_l = 0;
730 unsigned32 res_u, res_l;
731 sim_fpu_32to (&wop1, FP_PS_upper(op1));
732 sim_fpu_32to (&wop2, FP_PS_upper(op2));
733 status_u |= (*sim_fpu_op) (&ans, &wop1, &wop2);
734 sim_fpu_to32 (&res_u, &ans);
735 sim_fpu_32to (&wop1, FP_PS_lower(op1));
736 sim_fpu_32to (&wop2, FP_PS_lower(op2));
737 status_l |= (*sim_fpu_op) (&ans, &wop1, &wop2);
738 sim_fpu_to32 (&res_l, &ans);
739 result = FP_PS_cat(res_u, res_l);
740 status = status_u | status_l;
741 break;
743 default:
744 sim_io_eprintf (SD, "Bad switch\n");
745 abort ();
748 update_fcsr (cpu, cia, status);
749 return result;
752 /* Common MAC code for single operands (.s or .d), defers setting FCSR. */
753 static sim_fpu_status
754 inner_mac(int (*sim_fpu_op)(sim_fpu *, const sim_fpu *, const sim_fpu *),
755 unsigned64 op1,
756 unsigned64 op2,
757 unsigned64 op3,
758 int scale,
759 int negate,
760 FP_formats fmt,
761 sim_fpu_round round,
762 sim_fpu_denorm denorm,
763 unsigned64 *result)
765 sim_fpu wop1;
766 sim_fpu wop2;
767 sim_fpu ans;
768 sim_fpu_status status = 0;
769 sim_fpu_status op_status;
770 unsigned64 temp = 0;
772 switch (fmt)
774 case fmt_single:
776 unsigned32 res;
777 sim_fpu_32to (&wop1, op1);
778 sim_fpu_32to (&wop2, op2);
779 status |= sim_fpu_mul (&ans, &wop1, &wop2);
780 if (scale != 0 && sim_fpu_is_number (&ans)) /* number or denorm */
781 ans.normal_exp += scale;
782 status |= sim_fpu_round_32 (&ans, round, denorm);
783 wop1 = ans;
784 op_status = 0;
785 sim_fpu_32to (&wop2, op3);
786 op_status |= (*sim_fpu_op) (&ans, &wop1, &wop2);
787 op_status |= sim_fpu_round_32 (&ans, round, denorm);
788 status |= op_status;
789 if (negate)
791 wop1 = ans;
792 op_status = sim_fpu_neg (&ans, &wop1);
793 op_status |= sim_fpu_round_32 (&ans, round, denorm);
794 status |= op_status;
796 sim_fpu_to32 (&res, &ans);
797 temp = res;
798 break;
800 case fmt_double:
802 unsigned64 res;
803 sim_fpu_64to (&wop1, op1);
804 sim_fpu_64to (&wop2, op2);
805 status |= sim_fpu_mul (&ans, &wop1, &wop2);
806 if (scale != 0 && sim_fpu_is_number (&ans)) /* number or denorm */
807 ans.normal_exp += scale;
808 status |= sim_fpu_round_64 (&ans, round, denorm);
809 wop1 = ans;
810 op_status = 0;
811 sim_fpu_64to (&wop2, op3);
812 op_status |= (*sim_fpu_op) (&ans, &wop1, &wop2);
813 op_status |= sim_fpu_round_64 (&ans, round, denorm);
814 status |= op_status;
815 if (negate)
817 wop1 = ans;
818 op_status = sim_fpu_neg (&ans, &wop1);
819 op_status |= sim_fpu_round_64 (&ans, round, denorm);
820 status |= op_status;
822 sim_fpu_to64 (&res, &ans);
823 temp = res;
824 break;
826 default:
827 fprintf (stderr, "Bad switch\n");
828 abort ();
830 *result = temp;
831 return status;
834 /* Common implementation of madd, nmadd, msub, nmsub that does
835 intermediate rounding per spec. Also used for recip2 and rsqrt2,
836 which are transformed into equivalent nmsub operations. The scale
837 argument is an adjustment to the exponent of the intermediate
838 product op1*op2. It is currently non-zero for rsqrt2 (-1), which
839 requires an effective division by 2. */
840 static unsigned64
841 fp_mac(sim_cpu *cpu,
842 address_word cia,
843 int (*sim_fpu_op)(sim_fpu *, const sim_fpu *, const sim_fpu *),
844 unsigned64 op1,
845 unsigned64 op2,
846 unsigned64 op3,
847 int scale,
848 int negate,
849 FP_formats fmt)
851 sim_fpu_round round = rounding_mode (GETRM());
852 sim_fpu_denorm denorm = denorm_mode (cpu);
853 sim_fpu_status status = 0;
854 unsigned64 result = 0;
856 /* The format type has already been checked: */
857 switch (fmt)
859 case fmt_single:
860 case fmt_double:
861 status = inner_mac(sim_fpu_op, op1, op2, op3, scale,
862 negate, fmt, round, denorm, &result);
863 break;
864 case fmt_ps:
866 int status_u, status_l;
867 unsigned64 result_u, result_l;
868 status_u = inner_mac(sim_fpu_op, FP_PS_upper(op1), FP_PS_upper(op2),
869 FP_PS_upper(op3), scale, negate, fmt_single,
870 round, denorm, &result_u);
871 status_l = inner_mac(sim_fpu_op, FP_PS_lower(op1), FP_PS_lower(op2),
872 FP_PS_lower(op3), scale, negate, fmt_single,
873 round, denorm, &result_l);
874 result = FP_PS_cat(result_u, result_l);
875 status = status_u | status_l;
876 break;
878 default:
879 sim_io_eprintf (SD, "Bad switch\n");
880 abort ();
883 update_fcsr (cpu, cia, status);
884 return result;
887 /* Common rsqrt code for single operands (.s or .d), intermediate rounding. */
888 static sim_fpu_status
889 inner_rsqrt(unsigned64 op1,
890 FP_formats fmt,
891 sim_fpu_round round,
892 sim_fpu_denorm denorm,
893 unsigned64 *result)
895 sim_fpu wop1;
896 sim_fpu ans;
897 sim_fpu_status status = 0;
898 sim_fpu_status op_status;
899 unsigned64 temp = 0;
901 switch (fmt)
903 case fmt_single:
905 unsigned32 res;
906 sim_fpu_32to (&wop1, op1);
907 status |= sim_fpu_sqrt (&ans, &wop1);
908 status |= sim_fpu_round_32 (&ans, status, round);
909 wop1 = ans;
910 op_status = sim_fpu_inv (&ans, &wop1);
911 op_status |= sim_fpu_round_32 (&ans, round, denorm);
912 sim_fpu_to32 (&res, &ans);
913 temp = res;
914 status |= op_status;
915 break;
917 case fmt_double:
919 unsigned64 res;
920 sim_fpu_64to (&wop1, op1);
921 status |= sim_fpu_sqrt (&ans, &wop1);
922 status |= sim_fpu_round_64 (&ans, round, denorm);
923 wop1 = ans;
924 op_status = sim_fpu_inv (&ans, &wop1);
925 op_status |= sim_fpu_round_64 (&ans, round, denorm);
926 sim_fpu_to64 (&res, &ans);
927 temp = res;
928 status |= op_status;
929 break;
931 default:
932 fprintf (stderr, "Bad switch\n");
933 abort ();
935 *result = temp;
936 return status;
939 static unsigned64
940 fp_inv_sqrt(sim_cpu *cpu,
941 address_word cia,
942 unsigned64 op1,
943 FP_formats fmt)
945 sim_fpu_round round = rounding_mode (GETRM());
946 sim_fpu_round denorm = denorm_mode (cpu);
947 sim_fpu_status status = 0;
948 unsigned64 result = 0;
950 /* The format type has already been checked: */
951 switch (fmt)
953 case fmt_single:
954 case fmt_double:
955 status = inner_rsqrt (op1, fmt, round, denorm, &result);
956 break;
957 case fmt_ps:
959 int status_u, status_l;
960 unsigned64 result_u, result_l;
961 status_u = inner_rsqrt (FP_PS_upper(op1), fmt_single, round, denorm,
962 &result_u);
963 status_l = inner_rsqrt (FP_PS_lower(op1), fmt_single, round, denorm,
964 &result_l);
965 result = FP_PS_cat(result_u, result_l);
966 status = status_u | status_l;
967 break;
969 default:
970 sim_io_eprintf (SD, "Bad switch\n");
971 abort ();
974 update_fcsr (cpu, cia, status);
975 return result;
979 unsigned64
980 fp_abs(sim_cpu *cpu,
981 address_word cia,
982 unsigned64 op,
983 FP_formats fmt)
985 return fp_unary(cpu, cia, &sim_fpu_abs, op, fmt);
988 unsigned64
989 fp_neg(sim_cpu *cpu,
990 address_word cia,
991 unsigned64 op,
992 FP_formats fmt)
994 return fp_unary(cpu, cia, &sim_fpu_neg, op, fmt);
997 unsigned64
998 fp_add(sim_cpu *cpu,
999 address_word cia,
1000 unsigned64 op1,
1001 unsigned64 op2,
1002 FP_formats fmt)
1004 return fp_binary(cpu, cia, &sim_fpu_add, op1, op2, fmt);
1007 unsigned64
1008 fp_sub(sim_cpu *cpu,
1009 address_word cia,
1010 unsigned64 op1,
1011 unsigned64 op2,
1012 FP_formats fmt)
1014 return fp_binary(cpu, cia, &sim_fpu_sub, op1, op2, fmt);
1017 unsigned64
1018 fp_mul(sim_cpu *cpu,
1019 address_word cia,
1020 unsigned64 op1,
1021 unsigned64 op2,
1022 FP_formats fmt)
1024 return fp_binary(cpu, cia, &sim_fpu_mul, op1, op2, fmt);
1027 unsigned64
1028 fp_div(sim_cpu *cpu,
1029 address_word cia,
1030 unsigned64 op1,
1031 unsigned64 op2,
1032 FP_formats fmt)
1034 return fp_binary(cpu, cia, &sim_fpu_div, op1, op2, fmt);
1037 unsigned64
1038 fp_recip(sim_cpu *cpu,
1039 address_word cia,
1040 unsigned64 op,
1041 FP_formats fmt)
1043 return fp_unary(cpu, cia, &sim_fpu_inv, op, fmt);
1046 unsigned64
1047 fp_sqrt(sim_cpu *cpu,
1048 address_word cia,
1049 unsigned64 op,
1050 FP_formats fmt)
1052 return fp_unary(cpu, cia, &sim_fpu_sqrt, op, fmt);
1055 unsigned64
1056 fp_rsqrt(sim_cpu *cpu,
1057 address_word cia,
1058 unsigned64 op,
1059 FP_formats fmt)
1061 return fp_inv_sqrt(cpu, cia, op, fmt);
1064 unsigned64
1065 fp_madd(sim_cpu *cpu,
1066 address_word cia,
1067 unsigned64 op1,
1068 unsigned64 op2,
1069 unsigned64 op3,
1070 FP_formats fmt)
1072 return fp_mac(cpu, cia, &sim_fpu_add, op1, op2, op3, 0, 0, fmt);
1075 unsigned64
1076 fp_msub(sim_cpu *cpu,
1077 address_word cia,
1078 unsigned64 op1,
1079 unsigned64 op2,
1080 unsigned64 op3,
1081 FP_formats fmt)
1083 return fp_mac(cpu, cia, &sim_fpu_sub, op1, op2, op3, 0, 0, fmt);
1086 unsigned64
1087 fp_nmadd(sim_cpu *cpu,
1088 address_word cia,
1089 unsigned64 op1,
1090 unsigned64 op2,
1091 unsigned64 op3,
1092 FP_formats fmt)
1094 return fp_mac(cpu, cia, &sim_fpu_add, op1, op2, op3, 0, 1, fmt);
1097 unsigned64
1098 fp_nmsub(sim_cpu *cpu,
1099 address_word cia,
1100 unsigned64 op1,
1101 unsigned64 op2,
1102 unsigned64 op3,
1103 FP_formats fmt)
1105 return fp_mac(cpu, cia, &sim_fpu_sub, op1, op2, op3, 0, 1, fmt);
1109 /* MIPS-3D ASE operations. */
1111 /* Variant of fp_binary for *r.ps MIPS-3D operations. */
1112 static unsigned64
1113 fp_binary_r(sim_cpu *cpu,
1114 address_word cia,
1115 int (*sim_fpu_op)(sim_fpu *, const sim_fpu *, const sim_fpu *),
1116 unsigned64 op1,
1117 unsigned64 op2)
1119 sim_fpu wop1;
1120 sim_fpu wop2;
1121 sim_fpu ans;
1122 sim_fpu_round round = rounding_mode (GETRM ());
1123 sim_fpu_denorm denorm = denorm_mode (cpu);
1124 sim_fpu_status status_u, status_l;
1125 unsigned64 result;
1126 unsigned32 res_u, res_l;
1128 /* The format must be fmt_ps. */
1129 status_u = 0;
1130 sim_fpu_32to (&wop1, FP_PS_upper (op1));
1131 sim_fpu_32to (&wop2, FP_PS_lower (op1));
1132 status_u |= (*sim_fpu_op) (&ans, &wop1, &wop2);
1133 status_u |= sim_fpu_round_32 (&ans, round, denorm);
1134 sim_fpu_to32 (&res_u, &ans);
1135 status_l = 0;
1136 sim_fpu_32to (&wop1, FP_PS_upper (op2));
1137 sim_fpu_32to (&wop2, FP_PS_lower (op2));
1138 status_l |= (*sim_fpu_op) (&ans, &wop1, &wop2);
1139 status_l |= sim_fpu_round_32 (&ans, round, denorm);
1140 sim_fpu_to32 (&res_l, &ans);
1141 result = FP_PS_cat (res_u, res_l);
1143 update_fcsr (cpu, cia, status_u | status_l);
1144 return result;
1147 unsigned64
1148 fp_add_r(sim_cpu *cpu,
1149 address_word cia,
1150 unsigned64 op1,
1151 unsigned64 op2,
1152 FP_formats fmt)
1154 return fp_binary_r (cpu, cia, &sim_fpu_add, op1, op2);
1157 unsigned64
1158 fp_mul_r(sim_cpu *cpu,
1159 address_word cia,
1160 unsigned64 op1,
1161 unsigned64 op2,
1162 FP_formats fmt)
1164 return fp_binary_r (cpu, cia, &sim_fpu_mul, op1, op2);
1167 #define NR_FRAC_GUARD (60)
1168 #define IMPLICIT_1 LSBIT64 (NR_FRAC_GUARD)
1170 static int
1171 fpu_inv1(sim_fpu *f, const sim_fpu *l)
1173 static const sim_fpu sim_fpu_one = {
1174 sim_fpu_class_number, 0, IMPLICIT_1, 0
1176 int status = 0;
1177 sim_fpu t;
1179 if (sim_fpu_is_zero (l))
1181 *f = sim_fpu_maxfp;
1182 f->sign = l->sign;
1183 return sim_fpu_status_invalid_div0;
1185 if (sim_fpu_is_infinity (l))
1187 *f = sim_fpu_zero;
1188 f->sign = l->sign;
1189 return status;
1191 status |= sim_fpu_div (f, &sim_fpu_one, l);
1192 return status;
1195 static int
1196 fpu_inv1_32(sim_fpu *f, const sim_fpu *l)
1198 if (sim_fpu_is_zero (l))
1200 *f = sim_fpu_max32;
1201 f->sign = l->sign;
1202 return sim_fpu_status_invalid_div0;
1204 return fpu_inv1 (f, l);
1207 static int
1208 fpu_inv1_64(sim_fpu *f, const sim_fpu *l)
1210 if (sim_fpu_is_zero (l))
1212 *f = sim_fpu_max64;
1213 f->sign = l->sign;
1214 return sim_fpu_status_invalid_div0;
1216 return fpu_inv1 (f, l);
1219 unsigned64
1220 fp_recip1(sim_cpu *cpu,
1221 address_word cia,
1222 unsigned64 op,
1223 FP_formats fmt)
1225 switch (fmt)
1227 case fmt_single:
1228 case fmt_ps:
1229 return fp_unary (cpu, cia, &fpu_inv1_32, op, fmt);
1230 case fmt_double:
1231 return fp_unary (cpu, cia, &fpu_inv1_64, op, fmt);
1233 return 0;
1236 unsigned64
1237 fp_recip2(sim_cpu *cpu,
1238 address_word cia,
1239 unsigned64 op1,
1240 unsigned64 op2,
1241 FP_formats fmt)
1243 static const unsigned64 one_single = UNSIGNED64 (0x3F800000);
1244 static const unsigned64 one_double = UNSIGNED64 (0x3FF0000000000000);
1245 static const unsigned64 one_ps = (UNSIGNED64 (0x3F800000) << 32 | UNSIGNED64 (0x3F800000));
1246 unsigned64 one;
1248 /* Implemented as nmsub fd, 1, fs, ft. */
1249 switch (fmt)
1251 case fmt_single: one = one_single; break;
1252 case fmt_double: one = one_double; break;
1253 case fmt_ps: one = one_ps; break;
1254 default: one = 0; abort ();
1256 return fp_mac (cpu, cia, &sim_fpu_sub, op1, op2, one, 0, 1, fmt);
1259 static int
1260 fpu_inv_sqrt1(sim_fpu *f, const sim_fpu *l)
1262 static const sim_fpu sim_fpu_one = {
1263 sim_fpu_class_number, 0, IMPLICIT_1, 0
1265 int status = 0;
1266 sim_fpu t;
1268 if (sim_fpu_is_zero (l))
1270 *f = sim_fpu_maxfp;
1271 f->sign = l->sign;
1272 return sim_fpu_status_invalid_div0;
1274 if (sim_fpu_is_infinity (l))
1276 if (!l->sign)
1278 f->class = sim_fpu_class_zero;
1279 f->sign = 0;
1281 else
1283 *f = sim_fpu_qnan;
1284 status = sim_fpu_status_invalid_sqrt;
1286 return status;
1288 status |= sim_fpu_sqrt (&t, l);
1289 status |= sim_fpu_div (f, &sim_fpu_one, &t);
1290 return status;
1293 static int
1294 fpu_inv_sqrt1_32(sim_fpu *f, const sim_fpu *l)
1296 if (sim_fpu_is_zero (l))
1298 *f = sim_fpu_max32;
1299 f->sign = l->sign;
1300 return sim_fpu_status_invalid_div0;
1302 return fpu_inv_sqrt1 (f, l);
1305 static int
1306 fpu_inv_sqrt1_64(sim_fpu *f, const sim_fpu *l)
1308 if (sim_fpu_is_zero (l))
1310 *f = sim_fpu_max64;
1311 f->sign = l->sign;
1312 return sim_fpu_status_invalid_div0;
1314 return fpu_inv_sqrt1 (f, l);
1317 unsigned64
1318 fp_rsqrt1(sim_cpu *cpu,
1319 address_word cia,
1320 unsigned64 op,
1321 FP_formats fmt)
1323 switch (fmt)
1325 case fmt_single:
1326 case fmt_ps:
1327 return fp_unary (cpu, cia, &fpu_inv_sqrt1_32, op, fmt);
1328 case fmt_double:
1329 return fp_unary (cpu, cia, &fpu_inv_sqrt1_64, op, fmt);
1331 return 0;
1334 unsigned64
1335 fp_rsqrt2(sim_cpu *cpu,
1336 address_word cia,
1337 unsigned64 op1,
1338 unsigned64 op2,
1339 FP_formats fmt)
1341 static const unsigned64 half_single = UNSIGNED64 (0x3F000000);
1342 static const unsigned64 half_double = UNSIGNED64 (0x3FE0000000000000);
1343 static const unsigned64 half_ps = (UNSIGNED64 (0x3F000000) << 32 | UNSIGNED64 (0x3F000000));
1344 unsigned64 half;
1346 /* Implemented as (nmsub fd, 0.5, fs, ft)/2, where the divide is
1347 done by scaling the exponent during multiply. */
1348 switch (fmt)
1350 case fmt_single: half = half_single; break;
1351 case fmt_double: half = half_double; break;
1352 case fmt_ps: half = half_ps; break;
1353 default: half = 0; abort ();
1355 return fp_mac (cpu, cia, &sim_fpu_sub, op1, op2, half, -1, 1, fmt);
1359 /* Conversion operations. */
1361 uword64
1362 convert (sim_cpu *cpu,
1363 address_word cia,
1364 int rm,
1365 uword64 op,
1366 FP_formats from,
1367 FP_formats to)
1369 sim_fpu wop;
1370 sim_fpu_round round = rounding_mode (rm);
1371 sim_fpu_denorm denorm = denorm_mode (cpu);
1372 unsigned32 result32;
1373 unsigned64 result64;
1374 sim_fpu_status status = 0;
1376 /* Convert the input to sim_fpu internal format */
1377 switch (from)
1379 case fmt_double:
1380 sim_fpu_64to (&wop, op);
1381 break;
1382 case fmt_single:
1383 sim_fpu_32to (&wop, op);
1384 break;
1385 case fmt_word:
1386 status = sim_fpu_i32to (&wop, op, round);
1387 break;
1388 case fmt_long:
1389 status = sim_fpu_i64to (&wop, op, round);
1390 break;
1391 default:
1392 sim_io_eprintf (SD, "Bad switch\n");
1393 abort ();
1396 /* Convert sim_fpu format into the output */
1397 /* The value WOP is converted to the destination format, rounding
1398 using mode RM. When the destination is a fixed-point format, then
1399 a source value of Infinity, NaN or one which would round to an
1400 integer outside the fixed point range then an IEEE Invalid Operation
1401 condition is raised. Not used if destination format is PS. */
1402 switch (to)
1404 case fmt_single:
1405 status |= sim_fpu_round_32 (&wop, round, denorm);
1406 /* For a NaN, normalize mantissa bits (cvt.s.d can't preserve them) */
1407 if (sim_fpu_is_qnan (&wop))
1408 wop = sim_fpu_qnan;
1409 sim_fpu_to32 (&result32, &wop);
1410 result64 = result32;
1411 break;
1412 case fmt_double:
1413 status |= sim_fpu_round_64 (&wop, round, denorm);
1414 /* For a NaN, normalize mantissa bits (make cvt.d.s consistent) */
1415 if (sim_fpu_is_qnan (&wop))
1416 wop = sim_fpu_qnan;
1417 sim_fpu_to64 (&result64, &wop);
1418 break;
1419 case fmt_word:
1420 status |= sim_fpu_to32i (&result32, &wop, round);
1421 result64 = result32;
1422 break;
1423 case fmt_long:
1424 status |= sim_fpu_to64i (&result64, &wop, round);
1425 break;
1426 default:
1427 result64 = 0;
1428 sim_io_eprintf (SD, "Bad switch\n");
1429 abort ();
1432 update_fcsr (cpu, cia, status);
1433 return result64;
1436 unsigned64
1437 ps_lower(sim_cpu *cpu,
1438 address_word cia,
1439 unsigned64 op)
1441 return FP_PS_lower (op);
1444 unsigned64
1445 ps_upper(sim_cpu *cpu,
1446 address_word cia,
1447 unsigned64 op)
1449 return FP_PS_upper(op);
1452 unsigned64
1453 pack_ps(sim_cpu *cpu,
1454 address_word cia,
1455 unsigned64 op1,
1456 unsigned64 op2,
1457 FP_formats fmt)
1459 unsigned64 result = 0;
1461 /* The registers must specify FPRs valid for operands of type
1462 "fmt". If they are not valid, the result is undefined. */
1464 /* The format type should already have been checked: */
1465 switch (fmt)
1467 case fmt_single:
1469 sim_fpu wop;
1470 unsigned32 res_u, res_l;
1471 sim_fpu_32to (&wop, op1);
1472 sim_fpu_to32 (&res_u, &wop);
1473 sim_fpu_32to (&wop, op2);
1474 sim_fpu_to32 (&res_l, &wop);
1475 result = FP_PS_cat(res_u, res_l);
1476 break;
1478 default:
1479 sim_io_eprintf (SD, "Bad switch\n");
1480 abort ();
1483 return result;
1486 unsigned64
1487 convert_ps (sim_cpu *cpu,
1488 address_word cia,
1489 int rm,
1490 unsigned64 op,
1491 FP_formats from,
1492 FP_formats to)
1494 sim_fpu wop_u, wop_l;
1495 sim_fpu_round round = rounding_mode (rm);
1496 sim_fpu_denorm denorm = denorm_mode (cpu);
1497 unsigned32 res_u, res_l;
1498 unsigned64 result;
1499 sim_fpu_status status_u = 0, status_l = 0;
1501 /* As convert, but used only for paired values (formats PS, PW) */
1503 /* Convert the input to sim_fpu internal format */
1504 switch (from)
1506 case fmt_word: /* fmt_pw */
1507 sim_fpu_i32to (&wop_u, (op >> 32) & (unsigned)0xFFFFFFFF, round);
1508 sim_fpu_i32to (&wop_l, op & (unsigned)0xFFFFFFFF, round);
1509 break;
1510 case fmt_ps:
1511 sim_fpu_32to (&wop_u, FP_PS_upper(op));
1512 sim_fpu_32to (&wop_l, FP_PS_lower(op));
1513 break;
1514 default:
1515 sim_io_eprintf (SD, "Bad switch\n");
1516 abort ();
1519 /* Convert sim_fpu format into the output */
1520 switch (to)
1522 case fmt_word: /* fmt_pw */
1523 status_u |= sim_fpu_to32i (&res_u, &wop_u, round);
1524 status_l |= sim_fpu_to32i (&res_l, &wop_l, round);
1525 result = (((unsigned64)res_u) << 32) | (unsigned64)res_l;
1526 break;
1527 case fmt_ps:
1528 status_u |= sim_fpu_round_32 (&wop_u, 0, round);
1529 status_l |= sim_fpu_round_32 (&wop_l, 0, round);
1530 sim_fpu_to32 (&res_u, &wop_u);
1531 sim_fpu_to32 (&res_l, &wop_l);
1532 result = FP_PS_cat(res_u, res_l);
1533 break;
1534 default:
1535 result = 0;
1536 sim_io_eprintf (SD, "Bad switch\n");
1537 abort ();
1540 update_fcsr (cpu, cia, status_u | status_l);
1541 return result;
1544 static const char *
1545 fpu_format_name (FP_formats fmt)
1547 switch (fmt)
1549 case fmt_single:
1550 return "single";
1551 case fmt_double:
1552 return "double";
1553 case fmt_word:
1554 return "word";
1555 case fmt_long:
1556 return "long";
1557 case fmt_ps:
1558 return "ps";
1559 case fmt_unknown:
1560 return "<unknown>";
1561 case fmt_uninterpreted:
1562 return "<uninterpreted>";
1563 case fmt_uninterpreted_32:
1564 return "<uninterpreted_32>";
1565 case fmt_uninterpreted_64:
1566 return "<uninterpreted_64>";
1567 default:
1568 return "<format error>";
1572 #ifdef DEBUG
1573 static const char *
1574 fpu_rounding_mode_name (int rm)
1576 switch (rm)
1578 case FP_RM_NEAREST:
1579 return "Round";
1580 case FP_RM_TOZERO:
1581 return "Trunc";
1582 case FP_RM_TOPINF:
1583 return "Ceil";
1584 case FP_RM_TOMINF:
1585 return "Floor";
1586 default:
1587 return "<rounding mode error>";
1590 #endif /* DEBUG */