4999ff805a8f4654a770c71152392ce98a1a8598
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
)
447 /* Most of the FPU control registers occupy only 16 bits in
448 the fsave area. Give those a special treatment. */
449 if (regnum
>= FPC_REGNUM
450 && regnum
!= FIOFF_REGNUM
&& regnum
!= FOOFF_REGNUM
)
452 unsigned char val
[4];
454 memcpy (val
, FSAVE_ADDR (fsave
, regnum
), 2);
456 if (regnum
== FOP_REGNUM
)
457 val
[1] &= ((1 << 3) - 1);
458 supply_register (regnum
, val
);
461 supply_register (regnum
, FSAVE_ADDR (fsave
, regnum
));
464 /* Fill GDB's register array with the floating-point register values
465 in *FSAVE. This function masks off any of the reserved
469 i387_supply_fsave (char *fsave
)
473 for (i
= FP0_REGNUM
; i
< XMM0_REGNUM
; i
++)
474 i387_supply_register (i
, fsave
);
477 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
478 with the value in GDB's register array. If REGNUM is -1, do this
479 for all registers. This function doesn't touch any of the reserved
483 i387_fill_fsave (char *fsave
, int regnum
)
487 for (i
= FP0_REGNUM
; i
< XMM0_REGNUM
; i
++)
488 if (regnum
== -1 || regnum
== i
)
490 /* Most of the FPU control registers occupy only 16 bits in
491 the fsave area. Give those a special treatment. */
493 && i
!= FIOFF_REGNUM
&& i
!= FOOFF_REGNUM
)
495 unsigned char buf
[4];
497 regcache_collect (i
, buf
);
501 /* The opcode occupies only 11 bits. Make sure we
502 don't touch the other bits. */
503 buf
[1] &= ((1 << 3) - 1);
504 buf
[1] |= ((FSAVE_ADDR (fsave
, i
))[1] & ~((1 << 3) - 1));
506 memcpy (FSAVE_ADDR (fsave
, i
), buf
, 2);
509 regcache_collect (i
, FSAVE_ADDR (fsave
, i
));
514 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
515 the data structure used by the "fxsave" instruction where GDB
516 register REGNUM is stored. */
518 static int fxsave_offset
[] =
520 32, /* FP0_REGNUM through ... */
527 144, /* ... FP7_REGNUM (80 bits each). */
528 0, /* FCTRL_REGNUM (16 bits). */
529 2, /* FSTAT_REGNUM (16 bits). */
530 4, /* FTAG_REGNUM (16 bits). */
531 12, /* FISEG_REGNUM (16 bits). */
532 8, /* FIOFF_REGNUM. */
533 20, /* FOSEG_REGNUM (16 bits). */
534 16, /* FOOFF_REGNUM. */
535 6, /* FOP_REGNUM (bottom 11 bits). */
536 160, /* XMM0_REGNUM through ... */
543 272, /* ... XMM7_REGNUM (128 bits each). */
544 24, /* MXCSR_REGNUM. */
547 #define FXSAVE_ADDR(fxsave, regnum) \
548 (fxsave + fxsave_offset[regnum - FP0_REGNUM])
550 static int i387_tag (unsigned char *raw
);
553 /* Fill GDB's register array with the floating-point and SSE register
554 values in *FXSAVE. This function masks off any of the reserved
558 i387_supply_fxsave (char *fxsave
)
560 int i
, last_regnum
= MXCSR_REGNUM
;
562 if (gdbarch_tdep (current_gdbarch
)->num_xmm_regs
== 0)
563 last_regnum
= FOP_REGNUM
;
565 for (i
= FP0_REGNUM
; i
<= last_regnum
; i
++)
567 /* Most of the FPU control registers occupy only 16 bits in
568 the fxsave area. Give those a special treatment. */
569 if (i
>= FPC_REGNUM
&& i
< XMM0_REGNUM
570 && i
!= FIOFF_REGNUM
&& i
!= FOOFF_REGNUM
)
572 unsigned char val
[4];
574 memcpy (val
, FXSAVE_ADDR (fxsave
, i
), 2);
577 val
[1] &= ((1 << 3) - 1);
578 else if (i
== FTAG_REGNUM
)
580 /* The fxsave area contains a simplified version of the
581 tag word. We have to look at the actual 80-bit FP
582 data to recreate the traditional i387 tag word. */
584 unsigned long ftag
= 0;
588 top
= (((FXSAVE_ADDR (fxsave
, FSTAT_REGNUM
))[1] >> 3) & 0x7);
590 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
594 if (val
[0] & (1 << fpreg
))
596 int regnum
= (fpreg
+ 8 - top
) % 8 + FP0_REGNUM
;
597 tag
= i387_tag (FXSAVE_ADDR (fxsave
, regnum
));
602 ftag
|= tag
<< (2 * fpreg
);
604 val
[0] = ftag
& 0xff;
605 val
[1] = (ftag
>> 8) & 0xff;
607 supply_register (i
, val
);
610 supply_register (i
, FXSAVE_ADDR (fxsave
, i
));
614 /* Fill register REGNUM (if it is a floating-point or SSE register) in
615 *FXSAVE with the value in GDB's register array. If REGNUM is -1, do
616 this for all registers. This function doesn't touch any of the
617 reserved bits in *FXSAVE. */
620 i387_fill_fxsave (char *fxsave
, int regnum
)
622 int i
, last_regnum
= MXCSR_REGNUM
;
624 if (gdbarch_tdep (current_gdbarch
)->num_xmm_regs
== 0)
625 last_regnum
= FOP_REGNUM
;
627 for (i
= FP0_REGNUM
; i
<= last_regnum
; i
++)
628 if (regnum
== -1 || regnum
== i
)
630 /* Most of the FPU control registers occupy only 16 bits in
631 the fxsave area. Give those a special treatment. */
632 if (i
>= FPC_REGNUM
&& i
< XMM0_REGNUM
633 && i
!= FIOFF_REGNUM
&& i
!= FOOFF_REGNUM
)
635 unsigned char buf
[4];
637 regcache_collect (i
, buf
);
641 /* The opcode occupies only 11 bits. Make sure we
642 don't touch the other bits. */
643 buf
[1] &= ((1 << 3) - 1);
644 buf
[1] |= ((FXSAVE_ADDR (fxsave
, i
))[1] & ~((1 << 3) - 1));
646 else if (i
== FTAG_REGNUM
)
648 /* Converting back is much easier. */
653 ftag
= (buf
[1] << 8) | buf
[0];
657 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
659 int tag
= (ftag
>> (fpreg
* 2)) & 3;
662 buf
[0] |= (1 << fpreg
);
665 memcpy (FXSAVE_ADDR (fxsave
, i
), buf
, 2);
668 regcache_collect (i
, FXSAVE_ADDR (fxsave
, i
));
672 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
676 i387_tag (unsigned char *raw
)
679 unsigned int exponent
;
680 unsigned long fraction
[2];
682 integer
= raw
[7] & 0x80;
683 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
684 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
685 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
686 | (raw
[5] << 8) | raw
[4]);
688 if (exponent
== 0x7fff)
693 else if (exponent
== 0x0000)
695 if (fraction
[0] == 0x0000 && fraction
[1] == 0x0000 && !integer
)
This page took 0.045774 seconds and 4 git commands to generate.