1 /* Intel 387 floating point stuff.
2 Copyright 1988, 1989, 1991, 1992, 1993, 1994, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
28 #include "floatformat.h"
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
34 #include "i386-tdep.h"
36 /* FIXME: Eliminate the next two functions when we have the time to
37 change all the callers. */
39 void i387_to_double (char *from
, char *to
);
40 void double_to_i387 (char *from
, char *to
);
43 i387_to_double (char *from
, char *to
)
45 floatformat_to_double (&floatformat_i387_ext
, from
, (double *) to
);
49 double_to_i387 (char *from
, char *to
)
51 floatformat_from_double (&floatformat_i387_ext
, (double *) from
, to
);
55 /* FIXME: The functions on this page are used by the old `info float'
56 implementations that a few of the i386 targets provide. These
57 functions should be removed if all of these have been converted to
58 use the generic implementation based on the new register file
61 static void print_387_control_bits (unsigned int control
);
62 static void print_387_status_bits (unsigned int status
);
65 print_387_control_bits (unsigned int control
)
67 switch ((control
>> 8) & 3)
70 puts_unfiltered (" 24 bit; ");
73 puts_unfiltered (" (bad); ");
76 puts_unfiltered (" 53 bit; ");
79 puts_unfiltered (" 64 bit; ");
82 switch ((control
>> 10) & 3)
85 puts_unfiltered ("NEAR; ");
88 puts_unfiltered ("DOWN; ");
91 puts_unfiltered ("UP; ");
94 puts_unfiltered ("CHOP; ");
99 puts_unfiltered ("mask");
100 if (control
& 0x0001)
101 puts_unfiltered (" INVAL");
102 if (control
& 0x0002)
103 puts_unfiltered (" DENOR");
104 if (control
& 0x0004)
105 puts_unfiltered (" DIVZ");
106 if (control
& 0x0008)
107 puts_unfiltered (" OVERF");
108 if (control
& 0x0010)
109 puts_unfiltered (" UNDER");
110 if (control
& 0x0020)
111 puts_unfiltered (" LOS");
112 puts_unfiltered (";");
115 if (control
& 0xe080)
116 warning ("\nreserved bits on: %s",
117 local_hex_string (control
& 0xe080));
121 print_387_control_word (unsigned int control
)
123 printf_filtered ("control %s:", local_hex_string(control
& 0xffff));
124 print_387_control_bits (control
);
125 puts_unfiltered ("\n");
129 print_387_status_bits (unsigned int status
)
131 printf_unfiltered (" flags %d%d%d%d; ",
132 (status
& 0x4000) != 0,
133 (status
& 0x0400) != 0,
134 (status
& 0x0200) != 0,
135 (status
& 0x0100) != 0);
136 printf_unfiltered ("top %d; ", (status
>> 11) & 7);
139 puts_unfiltered ("excep");
140 if (status
& 0x0001) puts_unfiltered (" INVAL");
141 if (status
& 0x0002) puts_unfiltered (" DENOR");
142 if (status
& 0x0004) puts_unfiltered (" DIVZ");
143 if (status
& 0x0008) puts_unfiltered (" OVERF");
144 if (status
& 0x0010) puts_unfiltered (" UNDER");
145 if (status
& 0x0020) puts_unfiltered (" LOS");
146 if (status
& 0x0040) puts_unfiltered (" STACK");
151 print_387_status_word (unsigned int status
)
153 printf_filtered ("status %s:", local_hex_string (status
& 0xffff));
154 print_387_status_bits (status
);
155 puts_unfiltered ("\n");
159 /* Implement the `info float' layout based on the register definitions
162 /* Print the floating point number specified by RAW. */
164 print_i387_value (char *raw
, struct ui_file
*file
)
168 /* Using extract_typed_floating here might affect the representation
169 of certain numbers such as NaNs, even if GDB is running natively.
170 This is fine since our caller already detects such special
171 numbers and we print the hexadecimal representation anyway. */
172 value
= extract_typed_floating (raw
, builtin_type_i387_ext
);
174 /* We try to print 19 digits. The last digit may or may not contain
175 garbage, but we'd better print one too many. We need enough room
176 to print the value, 1 position for the sign, 1 for the decimal
177 point, 19 for the digits and 6 for the exponent adds up to 27. */
178 #ifdef PRINTF_HAS_LONG_DOUBLE
179 fprintf_filtered (file
, " %-+27.19Lg", (long double) value
);
181 fprintf_filtered (file
, " %-+27.19g", (double) value
);
185 /* Print the classification for the register contents RAW. */
187 print_i387_ext (unsigned char *raw
, struct ui_file
*file
)
191 unsigned int exponent
;
192 unsigned long fraction
[2];
194 sign
= raw
[9] & 0x80;
195 integer
= raw
[7] & 0x80;
196 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
197 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
198 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
199 | (raw
[5] << 8) | raw
[4]);
201 if (exponent
== 0x7fff && integer
)
203 if (fraction
[0] == 0x00000000 && fraction
[1] == 0x00000000)
205 fprintf_filtered (file
, " %cInf", (sign
? '-' : '+'));
206 else if (sign
&& fraction
[0] == 0x00000000 && fraction
[1] == 0x40000000)
207 /* Real Indefinite (QNaN). */
208 fputs_unfiltered (" Real Indefinite (QNaN)", file
);
209 else if (fraction
[1] & 0x40000000)
211 fputs_filtered (" QNaN", file
);
214 fputs_filtered (" SNaN", file
);
216 else if (exponent
< 0x7fff && exponent
> 0x0000 && integer
)
218 print_i387_value (raw
, file
);
219 else if (exponent
== 0x0000)
221 /* Denormal or zero. */
222 print_i387_value (raw
, file
);
225 /* Pseudo-denormal. */
226 fputs_filtered (" Pseudo-denormal", file
);
227 else if (fraction
[0] || fraction
[1])
229 fputs_filtered (" Denormal", file
);
233 fputs_filtered (" Unsupported", file
);
236 /* Print the status word STATUS. */
238 print_i387_status_word (unsigned int status
, struct ui_file
*file
)
240 fprintf_filtered (file
, "Status Word: %s",
241 local_hex_string_custom (status
, "04"));
242 fputs_filtered (" ", file
);
243 fprintf_filtered (file
, " %s", (status
& 0x0001) ? "IE" : " ");
244 fprintf_filtered (file
, " %s", (status
& 0x0002) ? "DE" : " ");
245 fprintf_filtered (file
, " %s", (status
& 0x0004) ? "ZE" : " ");
246 fprintf_filtered (file
, " %s", (status
& 0x0008) ? "OE" : " ");
247 fprintf_filtered (file
, " %s", (status
& 0x0010) ? "UE" : " ");
248 fprintf_filtered (file
, " %s", (status
& 0x0020) ? "PE" : " ");
249 fputs_filtered (" ", file
);
250 fprintf_filtered (file
, " %s", (status
& 0x0080) ? "ES" : " ");
251 fputs_filtered (" ", file
);
252 fprintf_filtered (file
, " %s", (status
& 0x0040) ? "SF" : " ");
253 fputs_filtered (" ", file
);
254 fprintf_filtered (file
, " %s", (status
& 0x0100) ? "C0" : " ");
255 fprintf_filtered (file
, " %s", (status
& 0x0200) ? "C1" : " ");
256 fprintf_filtered (file
, " %s", (status
& 0x0400) ? "C2" : " ");
257 fprintf_filtered (file
, " %s", (status
& 0x4000) ? "C3" : " ");
259 fputs_filtered ("\n", file
);
261 fprintf_filtered (file
,
262 " TOP: %d\n", ((status
>> 11) & 7));
265 /* Print the control word CONTROL. */
267 print_i387_control_word (unsigned int control
, struct ui_file
*file
)
269 fprintf_filtered (file
, "Control Word: %s",
270 local_hex_string_custom (control
, "04"));
271 fputs_filtered (" ", file
);
272 fprintf_filtered (file
, " %s", (control
& 0x0001) ? "IM" : " ");
273 fprintf_filtered (file
, " %s", (control
& 0x0002) ? "DM" : " ");
274 fprintf_filtered (file
, " %s", (control
& 0x0004) ? "ZM" : " ");
275 fprintf_filtered (file
, " %s", (control
& 0x0008) ? "OM" : " ");
276 fprintf_filtered (file
, " %s", (control
& 0x0010) ? "UM" : " ");
277 fprintf_filtered (file
, " %s", (control
& 0x0020) ? "PM" : " ");
279 fputs_filtered ("\n", file
);
281 fputs_filtered (" PC: ", file
);
282 switch ((control
>> 8) & 3)
285 fputs_filtered ("Single Precision (24-bits)\n", file
);
288 fputs_filtered ("Reserved\n", file
);
291 fputs_filtered ("Double Precision (53-bits)\n", file
);
294 fputs_filtered ("Extended Precision (64-bits)\n", file
);
298 fputs_filtered (" RC: ", file
);
299 switch ((control
>> 10) & 3)
302 fputs_filtered ("Round to nearest\n", file
);
305 fputs_filtered ("Round down\n", file
);
308 fputs_filtered ("Round up\n", file
);
311 fputs_filtered ("Round toward zero\n", file
);
316 /* Print out the i387 floating point state. Note that we ignore FRAME
317 in the code below. That's OK since floating-point registers are
318 never saved on the stack. */
321 i387_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
322 struct frame_info
*frame
, const char *args
)
336 frame_register_read (frame
, FCTRL_REGNUM
, buf
);
337 fctrl
= extract_unsigned_integer (buf
, 4);
338 frame_register_read (frame
, FSTAT_REGNUM
, buf
);
339 fstat
= extract_unsigned_integer (buf
, 4);
340 frame_register_read (frame
, FTAG_REGNUM
, buf
);
341 ftag
= extract_unsigned_integer (buf
, 4);
342 frame_register_read (frame
, FISEG_REGNUM
, buf
);
343 fiseg
= extract_unsigned_integer (buf
, 4);
344 frame_register_read (frame
, FIOFF_REGNUM
, buf
);
345 fioff
= extract_unsigned_integer (buf
, 4);
346 frame_register_read (frame
, FOSEG_REGNUM
, buf
);
347 foseg
= extract_unsigned_integer (buf
, 4);
348 frame_register_read (frame
, FOOFF_REGNUM
, buf
);
349 fooff
= extract_unsigned_integer (buf
, 4);
350 frame_register_read (frame
, FOP_REGNUM
, buf
);
351 fop
= extract_unsigned_integer (buf
, 4);
353 top
= ((fstat
>> 11) & 7);
355 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
357 unsigned char raw
[FPU_REG_RAW_SIZE
];
358 int tag
= (ftag
>> (fpreg
* 2)) & 3;
361 fprintf_filtered (file
, "%sR%d: ", fpreg
== top
? "=>" : " ", fpreg
);
366 fputs_filtered ("Valid ", file
);
369 fputs_filtered ("Zero ", file
);
372 fputs_filtered ("Special ", file
);
375 fputs_filtered ("Empty ", file
);
379 frame_register_read (frame
, (fpreg
+ 8 - top
) % 8 + FP0_REGNUM
, raw
);
381 fputs_filtered ("0x", file
);
382 for (i
= 9; i
>= 0; i
--)
383 fprintf_filtered (file
, "%02x", raw
[i
]);
386 print_i387_ext (raw
, file
);
388 fputs_filtered ("\n", file
);
391 fputs_filtered ("\n", file
);
393 print_i387_status_word (fstat
, file
);
394 print_i387_control_word (fctrl
, file
);
395 fprintf_filtered (file
, "Tag Word: %s\n",
396 local_hex_string_custom (ftag
, "04"));
397 fprintf_filtered (file
, "Instruction Pointer: %s:",
398 local_hex_string_custom (fiseg
, "02"));
399 fprintf_filtered (file
, "%s\n", local_hex_string_custom (fioff
, "08"));
400 fprintf_filtered (file
, "Operand Pointer: %s:",
401 local_hex_string_custom (foseg
, "02"));
402 fprintf_filtered (file
, "%s\n", local_hex_string_custom (fooff
, "08"));
403 fprintf_filtered (file
, "Opcode: %s\n",
404 local_hex_string_custom (fop
? (fop
| 0xd800) : 0, "04"));
407 /* FIXME: kettenis/2000-05-21: Right now more than a few i386 targets
408 define their own routines to manage the floating-point registers in
409 GDB's register array. Most (if not all) of these targets use the
410 format used by the "fsave" instruction in their communication with
411 the OS. They should all be converted to use the routines below. */
413 /* At fsave_offset[REGNUM] you'll find the offset to the location in
414 the data structure used by the "fsave" instruction where GDB
415 register REGNUM is stored. */
417 static int fsave_offset
[] =
419 28 + 0 * FPU_REG_RAW_SIZE
, /* FP0_REGNUM through ... */
420 28 + 1 * FPU_REG_RAW_SIZE
,
421 28 + 2 * FPU_REG_RAW_SIZE
,
422 28 + 3 * FPU_REG_RAW_SIZE
,
423 28 + 4 * FPU_REG_RAW_SIZE
,
424 28 + 5 * FPU_REG_RAW_SIZE
,
425 28 + 6 * FPU_REG_RAW_SIZE
,
426 28 + 7 * FPU_REG_RAW_SIZE
, /* ... FP7_REGNUM. */
427 0, /* FCTRL_REGNUM (16 bits). */
428 4, /* FSTAT_REGNUM (16 bits). */
429 8, /* FTAG_REGNUM (16 bits). */
430 16, /* FISEG_REGNUM (16 bits). */
431 12, /* FIOFF_REGNUM. */
432 24, /* FOSEG_REGNUM. */
433 20, /* FOOFF_REGNUM. */
434 18 /* FOP_REGNUM (bottom 11 bits). */
437 #define FSAVE_ADDR(fsave, regnum) (fsave + fsave_offset[regnum - FP0_REGNUM])
440 /* Fill register REGNUM in GDB's register array with the appropriate
441 value from *FSAVE. This function masks off any of the reserved
445 i387_supply_register (int regnum
, char *fsave
)
449 supply_register (regnum
, NULL
);
453 /* Most of the FPU control registers occupy only 16 bits in
454 the fsave area. Give those a special treatment. */
455 if (regnum
>= FPC_REGNUM
456 && regnum
!= FIOFF_REGNUM
&& regnum
!= FOOFF_REGNUM
)
458 unsigned char val
[4];
460 memcpy (val
, FSAVE_ADDR (fsave
, regnum
), 2);
462 if (regnum
== FOP_REGNUM
)
463 val
[1] &= ((1 << 3) - 1);
464 supply_register (regnum
, val
);
467 supply_register (regnum
, FSAVE_ADDR (fsave
, regnum
));
470 /* Fill GDB's register array with the floating-point register values
471 in *FSAVE. This function masks off any of the reserved
475 i387_supply_fsave (char *fsave
)
479 for (i
= FP0_REGNUM
; i
< XMM0_REGNUM
; i
++)
480 i387_supply_register (i
, fsave
);
483 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
484 with the value in GDB's register array. If REGNUM is -1, do this
485 for all registers. This function doesn't touch any of the reserved
489 i387_fill_fsave (char *fsave
, int regnum
)
493 for (i
= FP0_REGNUM
; i
< XMM0_REGNUM
; i
++)
494 if (regnum
== -1 || regnum
== i
)
496 /* Most of the FPU control registers occupy only 16 bits in
497 the fsave area. Give those a special treatment. */
499 && i
!= FIOFF_REGNUM
&& i
!= FOOFF_REGNUM
)
501 unsigned char buf
[4];
503 regcache_collect (i
, buf
);
507 /* The opcode occupies only 11 bits. Make sure we
508 don't touch the other bits. */
509 buf
[1] &= ((1 << 3) - 1);
510 buf
[1] |= ((FSAVE_ADDR (fsave
, i
))[1] & ~((1 << 3) - 1));
512 memcpy (FSAVE_ADDR (fsave
, i
), buf
, 2);
515 regcache_collect (i
, FSAVE_ADDR (fsave
, i
));
520 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
521 the data structure used by the "fxsave" instruction where GDB
522 register REGNUM is stored. */
524 static int fxsave_offset
[] =
526 32, /* FP0_REGNUM through ... */
533 144, /* ... FP7_REGNUM (80 bits each). */
534 0, /* FCTRL_REGNUM (16 bits). */
535 2, /* FSTAT_REGNUM (16 bits). */
536 4, /* FTAG_REGNUM (16 bits). */
537 12, /* FISEG_REGNUM (16 bits). */
538 8, /* FIOFF_REGNUM. */
539 20, /* FOSEG_REGNUM (16 bits). */
540 16, /* FOOFF_REGNUM. */
541 6, /* FOP_REGNUM (bottom 11 bits). */
542 160, /* XMM0_REGNUM through ... */
549 272, /* ... XMM7_REGNUM (128 bits each). */
550 24, /* MXCSR_REGNUM. */
553 #define FXSAVE_ADDR(fxsave, regnum) \
554 (fxsave + fxsave_offset[regnum - FP0_REGNUM])
556 static int i387_tag (unsigned char *raw
);
559 /* Fill GDB's register array with the floating-point and SSE register
560 values in *FXSAVE. This function masks off any of the reserved
564 i387_supply_fxsave (char *fxsave
)
566 int i
, last_regnum
= MXCSR_REGNUM
;
568 if (gdbarch_tdep (current_gdbarch
)->num_xmm_regs
== 0)
569 last_regnum
= FOP_REGNUM
;
571 for (i
= FP0_REGNUM
; i
<= last_regnum
; i
++)
575 supply_register (i
, NULL
);
579 /* Most of the FPU control registers occupy only 16 bits in
580 the fxsave area. Give those a special treatment. */
581 if (i
>= FPC_REGNUM
&& i
< XMM0_REGNUM
582 && i
!= FIOFF_REGNUM
&& i
!= FOOFF_REGNUM
)
584 unsigned char val
[4];
586 memcpy (val
, FXSAVE_ADDR (fxsave
, i
), 2);
589 val
[1] &= ((1 << 3) - 1);
590 else if (i
== FTAG_REGNUM
)
592 /* The fxsave area contains a simplified version of the
593 tag word. We have to look at the actual 80-bit FP
594 data to recreate the traditional i387 tag word. */
596 unsigned long ftag
= 0;
600 top
= (((FXSAVE_ADDR (fxsave
, FSTAT_REGNUM
))[1] >> 3) & 0x7);
602 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
606 if (val
[0] & (1 << fpreg
))
608 int regnum
= (fpreg
+ 8 - top
) % 8 + FP0_REGNUM
;
609 tag
= i387_tag (FXSAVE_ADDR (fxsave
, regnum
));
614 ftag
|= tag
<< (2 * fpreg
);
616 val
[0] = ftag
& 0xff;
617 val
[1] = (ftag
>> 8) & 0xff;
619 supply_register (i
, val
);
622 supply_register (i
, FXSAVE_ADDR (fxsave
, i
));
626 /* Fill register REGNUM (if it is a floating-point or SSE register) in
627 *FXSAVE with the value in GDB's register array. If REGNUM is -1, do
628 this for all registers. This function doesn't touch any of the
629 reserved bits in *FXSAVE. */
632 i387_fill_fxsave (char *fxsave
, int regnum
)
634 int i
, last_regnum
= MXCSR_REGNUM
;
636 if (gdbarch_tdep (current_gdbarch
)->num_xmm_regs
== 0)
637 last_regnum
= FOP_REGNUM
;
639 for (i
= FP0_REGNUM
; i
<= last_regnum
; i
++)
640 if (regnum
== -1 || regnum
== i
)
642 /* Most of the FPU control registers occupy only 16 bits in
643 the fxsave area. Give those a special treatment. */
644 if (i
>= FPC_REGNUM
&& i
< XMM0_REGNUM
645 && i
!= FIOFF_REGNUM
&& i
!= FOOFF_REGNUM
)
647 unsigned char buf
[4];
649 regcache_collect (i
, buf
);
653 /* The opcode occupies only 11 bits. Make sure we
654 don't touch the other bits. */
655 buf
[1] &= ((1 << 3) - 1);
656 buf
[1] |= ((FXSAVE_ADDR (fxsave
, i
))[1] & ~((1 << 3) - 1));
658 else if (i
== FTAG_REGNUM
)
660 /* Converting back is much easier. */
665 ftag
= (buf
[1] << 8) | buf
[0];
669 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
671 int tag
= (ftag
>> (fpreg
* 2)) & 3;
674 buf
[0] |= (1 << fpreg
);
677 memcpy (FXSAVE_ADDR (fxsave
, i
), buf
, 2);
680 regcache_collect (i
, FXSAVE_ADDR (fxsave
, i
));
684 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
688 i387_tag (unsigned char *raw
)
691 unsigned int exponent
;
692 unsigned long fraction
[2];
694 integer
= raw
[7] & 0x80;
695 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
696 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
697 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
698 | (raw
[5] << 8) | raw
[4]);
700 if (exponent
== 0x7fff)
705 else if (exponent
== 0x0000)
707 if (fraction
[0] == 0x0000 && fraction
[1] == 0x0000 && !integer
)
This page took 0.044038 seconds and 4 git commands to generate.