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)
335 fctrl = read_register (FCTRL_REGNUM);
336 fstat = read_register (FSTAT_REGNUM);
337 ftag = read_register (FTAG_REGNUM);
338 fiseg = read_register (FCS_REGNUM);
339 fioff = read_register (FCOFF_REGNUM);
340 foseg = read_register (FDS_REGNUM);
341 fooff = read_register (FDOFF_REGNUM);
342 fop = read_register (FOP_REGNUM);
344 top = ((fstat >> 11) & 7);
346 for (fpreg = 7; fpreg >= 0; fpreg--)
348 unsigned char raw[FPU_REG_RAW_SIZE];
349 int tag = (ftag >> (fpreg * 2)) & 3;
352 fprintf_filtered (file, "%sR%d: ", fpreg == top ? "=>" : " ", fpreg);
357 fputs_filtered ("Valid ", file);
360 fputs_filtered ("Zero ", file);
363 fputs_filtered ("Special ", file);
366 fputs_filtered ("Empty ", file);
370 read_register_gen ((fpreg + 8 - top) % 8 + FP0_REGNUM, raw);
372 fputs_filtered ("0x", file);
373 for (i = 9; i >= 0; i--)
374 fprintf_filtered (file, "%02x", raw[i]);
377 print_i387_ext (raw, file);
379 fputs_filtered ("\n", file);
382 puts_filtered ("\n");
384 print_i387_status_word (fstat, file);
385 print_i387_control_word (fctrl, file);
386 fprintf_filtered (file, "Tag Word: %s\n",
387 local_hex_string_custom (ftag, "04"));
388 fprintf_filtered (file, "Instruction Pointer: %s:",
389 local_hex_string_custom (fiseg, "02"));
390 fprintf_filtered (file, "%s\n", local_hex_string_custom (fioff, "08"));
391 fprintf_filtered (file, "Operand Pointer: %s:",
392 local_hex_string_custom (foseg, "02"));
393 fprintf_filtered (file, "%s\n", local_hex_string_custom (fooff, "08"));
394 fprintf_filtered (file, "Opcode: %s\n",
395 local_hex_string_custom (fop ? (fop | 0xd800) : 0, "04"));
398 /* FIXME: kettenis/2000-05-21: Right now more than a few i386 targets
399 define their own routines to manage the floating-point registers in
400 GDB's register array. Most (if not all) of these targets use the
401 format used by the "fsave" instruction in their communication with
402 the OS. They should all be converted to use the routines below. */
404 /* At fsave_offset[REGNUM] you'll find the offset to the location in
405 the data structure used by the "fsave" instruction where GDB
406 register REGNUM is stored. */
408 static int fsave_offset[] =
410 28 + 0 * FPU_REG_RAW_SIZE, /* FP0_REGNUM through ... */
411 28 + 1 * FPU_REG_RAW_SIZE,
412 28 + 2 * FPU_REG_RAW_SIZE,
413 28 + 3 * FPU_REG_RAW_SIZE,
414 28 + 4 * FPU_REG_RAW_SIZE,
415 28 + 5 * FPU_REG_RAW_SIZE,
416 28 + 6 * FPU_REG_RAW_SIZE,
417 28 + 7 * FPU_REG_RAW_SIZE, /* ... FP7_REGNUM. */
418 0, /* FCTRL_REGNUM (16 bits). */
419 4, /* FSTAT_REGNUM (16 bits). */
420 8, /* FTAG_REGNUM (16 bits). */
421 16, /* FISEG_REGNUM (16 bits). */
422 12, /* FIOFF_REGNUM. */
423 24, /* FOSEG_REGNUM. */
424 20, /* FOOFF_REGNUM. */
425 18 /* FOP_REGNUM (bottom 11 bits). */
428 #define FSAVE_ADDR(fsave, regnum) (fsave + fsave_offset[regnum - FP0_REGNUM])
431 /* Fill register REGNUM in GDB's register array with the appropriate
432 value from *FSAVE. This function masks off any of the reserved
436 i387_supply_register (int regnum, char *fsave)
438 /* Most of the FPU control registers occupy only 16 bits in
439 the fsave area. Give those a special treatment. */
440 if (regnum >= FPC_REGNUM
441 && regnum != FIOFF_REGNUM && regnum != FOOFF_REGNUM)
443 unsigned char val[4];
445 memcpy (val, FSAVE_ADDR (fsave, regnum), 2);
447 if (regnum == FOP_REGNUM)
448 val[1] &= ((1 << 3) - 1);
449 supply_register (regnum, val);
452 supply_register (regnum, FSAVE_ADDR (fsave, regnum));
455 /* Fill GDB's register array with the floating-point register values
456 in *FSAVE. This function masks off any of the reserved
460 i387_supply_fsave (char *fsave)
464 for (i = FP0_REGNUM; i < XMM0_REGNUM; i++)
465 i387_supply_register (i, fsave);
468 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
469 with the value in GDB's register array. If REGNUM is -1, do this
470 for all registers. This function doesn't touch any of the reserved
474 i387_fill_fsave (char *fsave, int regnum)
478 for (i = FP0_REGNUM; i < XMM0_REGNUM; i++)
479 if (regnum == -1 || regnum == i)
481 /* Most of the FPU control registers occupy only 16 bits in
482 the fsave area. Give those a special treatment. */
484 && i != FIOFF_REGNUM && i != FOOFF_REGNUM)
486 unsigned char buf[4];
488 regcache_collect (i, buf);
492 /* The opcode occupies only 11 bits. Make sure we
493 don't touch the other bits. */
494 buf[1] &= ((1 << 3) - 1);
495 buf[1] |= ((FSAVE_ADDR (fsave, i))[1] & ~((1 << 3) - 1));
497 memcpy (FSAVE_ADDR (fsave, i), buf, 2);
500 regcache_collect (i, FSAVE_ADDR (fsave, i));
505 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
506 the data structure used by the "fxsave" instruction where GDB
507 register REGNUM is stored. */
509 static int fxsave_offset[] =
511 32, /* FP0_REGNUM through ... */
518 144, /* ... FP7_REGNUM (80 bits each). */
519 0, /* FCTRL_REGNUM (16 bits). */
520 2, /* FSTAT_REGNUM (16 bits). */
521 4, /* FTAG_REGNUM (16 bits). */
522 12, /* FISEG_REGNUM (16 bits). */
523 8, /* FIOFF_REGNUM. */
524 20, /* FOSEG_REGNUM (16 bits). */
525 16, /* FOOFF_REGNUM. */
526 6, /* FOP_REGNUM (bottom 11 bits). */
527 160, /* XMM0_REGNUM through ... */
534 272, /* ... XMM7_REGNUM (128 bits each). */
535 24, /* MXCSR_REGNUM. */
538 #define FXSAVE_ADDR(fxsave, regnum) \
539 (fxsave + fxsave_offset[regnum - FP0_REGNUM])
541 static int i387_tag (unsigned char *raw);
544 /* Fill GDB's register array with the floating-point and SSE register
545 values in *FXSAVE. This function masks off any of the reserved
549 i387_supply_fxsave (char *fxsave)
551 int i, last_regnum = MXCSR_REGNUM;
553 if (gdbarch_tdep (current_gdbarch)->num_xmm_regs == 0)
554 last_regnum = FOP_REGNUM;
556 for (i = FP0_REGNUM; i <= last_regnum; i++)
558 /* Most of the FPU control registers occupy only 16 bits in
559 the fxsave area. Give those a special treatment. */
560 if (i >= FPC_REGNUM && i < XMM0_REGNUM
561 && i != FIOFF_REGNUM && i != FOOFF_REGNUM)
563 unsigned char val[4];
565 memcpy (val, FXSAVE_ADDR (fxsave, i), 2);
568 val[1] &= ((1 << 3) - 1);
569 else if (i== FTAG_REGNUM)
571 /* The fxsave area contains a simplified version of the
572 tag word. We have to look at the actual 80-bit FP
573 data to recreate the traditional i387 tag word. */
575 unsigned long ftag = 0;
579 top = (((FXSAVE_ADDR (fxsave, FSTAT_REGNUM))[1] >> 3) & 0x7);
581 for (fpreg = 7; fpreg >= 0; fpreg--)
585 if (val[0] & (1 << fpreg))
587 int regnum = (fpreg + 8 - top) % 8 + FP0_REGNUM;
588 tag = i387_tag (FXSAVE_ADDR (fxsave, regnum));
593 ftag |= tag << (2 * fpreg);
595 val[0] = ftag & 0xff;
596 val[1] = (ftag >> 8) & 0xff;
598 supply_register (i, val);
601 supply_register (i, FXSAVE_ADDR (fxsave, i));
605 /* Fill register REGNUM (if it is a floating-point or SSE register) in
606 *FXSAVE with the value in GDB's register array. If REGNUM is -1, do
607 this for all registers. This function doesn't touch any of the
608 reserved bits in *FXSAVE. */
611 i387_fill_fxsave (char *fxsave, int regnum)
613 int i, last_regnum = MXCSR_REGNUM;
615 if (gdbarch_tdep (current_gdbarch)->num_xmm_regs == 0)
616 last_regnum = FOP_REGNUM;
618 for (i = FP0_REGNUM; i <= last_regnum; i++)
619 if (regnum == -1 || regnum == i)
621 /* Most of the FPU control registers occupy only 16 bits in
622 the fxsave area. Give those a special treatment. */
623 if (i >= FPC_REGNUM && i < XMM0_REGNUM
624 && i != FIOFF_REGNUM && i != FDOFF_REGNUM)
626 unsigned char buf[4];
628 regcache_collect (i, buf);
632 /* The opcode occupies only 11 bits. Make sure we
633 don't touch the other bits. */
634 buf[1] &= ((1 << 3) - 1);
635 buf[1] |= ((FXSAVE_ADDR (fxsave, i))[1] & ~((1 << 3) - 1));
637 else if (i == FTAG_REGNUM)
639 /* Converting back is much easier. */
644 ftag = (buf[1] << 8) | buf[0];
648 for (fpreg = 7; fpreg >= 0; fpreg--)
650 int tag = (ftag >> (fpreg * 2)) & 3;
653 buf[0] |= (1 << fpreg);
656 memcpy (FXSAVE_ADDR (fxsave, i), buf, 2);
659 regcache_collect (i, FXSAVE_ADDR (fxsave, i));
663 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
667 i387_tag (unsigned char *raw)
670 unsigned int exponent;
671 unsigned long fraction[2];
673 integer = raw[7] & 0x80;
674 exponent = (((raw[9] & 0x7f) << 8) | raw[8]);
675 fraction[0] = ((raw[3] << 24) | (raw[2] << 16) | (raw[1] << 8) | raw[0]);
676 fraction[1] = (((raw[7] & 0x7f) << 24) | (raw[6] << 16)
677 | (raw[5] << 8) | raw[4]);
679 if (exponent == 0x7fff)
684 else if (exponent == 0x0000)
686 if (fraction[0] == 0x0000 && fraction[1] == 0x0000 && !integer)