1 /* Intel 387 floating point stuff.
3 Copyright (C) 1988, 1989, 1991, 1992, 1993, 1994, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "floatformat.h"
31 #include "gdb_assert.h"
32 #include "gdb_string.h"
34 #include "i386-tdep.h"
35 #include "i387-tdep.h"
37 /* Print the floating point number specified by RAW. */
40 print_i387_value (const gdb_byte
*raw
, struct ui_file
*file
)
44 /* Using extract_typed_floating here might affect the representation
45 of certain numbers such as NaNs, even if GDB is running natively.
46 This is fine since our caller already detects such special
47 numbers and we print the hexadecimal representation anyway. */
48 value
= extract_typed_floating (raw
, builtin_type_i387_ext
);
50 /* We try to print 19 digits. The last digit may or may not contain
51 garbage, but we'd better print one too many. We need enough room
52 to print the value, 1 position for the sign, 1 for the decimal
53 point, 19 for the digits and 6 for the exponent adds up to 27. */
54 #ifdef PRINTF_HAS_LONG_DOUBLE
55 fprintf_filtered (file
, " %-+27.19Lg", (long double) value
);
57 fprintf_filtered (file
, " %-+27.19g", (double) value
);
61 /* Print the classification for the register contents RAW. */
64 print_i387_ext (const gdb_byte
*raw
, struct ui_file
*file
)
68 unsigned int exponent
;
69 unsigned long fraction
[2];
72 integer
= raw
[7] & 0x80;
73 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
74 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
75 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
76 | (raw
[5] << 8) | raw
[4]);
78 if (exponent
== 0x7fff && integer
)
80 if (fraction
[0] == 0x00000000 && fraction
[1] == 0x00000000)
82 fprintf_filtered (file
, " %cInf", (sign
? '-' : '+'));
83 else if (sign
&& fraction
[0] == 0x00000000 && fraction
[1] == 0x40000000)
84 /* Real Indefinite (QNaN). */
85 fputs_unfiltered (" Real Indefinite (QNaN)", file
);
86 else if (fraction
[1] & 0x40000000)
88 fputs_filtered (" QNaN", file
);
91 fputs_filtered (" SNaN", file
);
93 else if (exponent
< 0x7fff && exponent
> 0x0000 && integer
)
95 print_i387_value (raw
, file
);
96 else if (exponent
== 0x0000)
98 /* Denormal or zero. */
99 print_i387_value (raw
, file
);
102 /* Pseudo-denormal. */
103 fputs_filtered (" Pseudo-denormal", file
);
104 else if (fraction
[0] || fraction
[1])
106 fputs_filtered (" Denormal", file
);
110 fputs_filtered (" Unsupported", file
);
113 /* Print the status word STATUS. */
116 print_i387_status_word (unsigned int status
, struct ui_file
*file
)
118 fprintf_filtered (file
, "Status Word: %s",
119 hex_string_custom (status
, 4));
120 fputs_filtered (" ", file
);
121 fprintf_filtered (file
, " %s", (status
& 0x0001) ? "IE" : " ");
122 fprintf_filtered (file
, " %s", (status
& 0x0002) ? "DE" : " ");
123 fprintf_filtered (file
, " %s", (status
& 0x0004) ? "ZE" : " ");
124 fprintf_filtered (file
, " %s", (status
& 0x0008) ? "OE" : " ");
125 fprintf_filtered (file
, " %s", (status
& 0x0010) ? "UE" : " ");
126 fprintf_filtered (file
, " %s", (status
& 0x0020) ? "PE" : " ");
127 fputs_filtered (" ", file
);
128 fprintf_filtered (file
, " %s", (status
& 0x0080) ? "ES" : " ");
129 fputs_filtered (" ", file
);
130 fprintf_filtered (file
, " %s", (status
& 0x0040) ? "SF" : " ");
131 fputs_filtered (" ", file
);
132 fprintf_filtered (file
, " %s", (status
& 0x0100) ? "C0" : " ");
133 fprintf_filtered (file
, " %s", (status
& 0x0200) ? "C1" : " ");
134 fprintf_filtered (file
, " %s", (status
& 0x0400) ? "C2" : " ");
135 fprintf_filtered (file
, " %s", (status
& 0x4000) ? "C3" : " ");
137 fputs_filtered ("\n", file
);
139 fprintf_filtered (file
,
140 " TOP: %d\n", ((status
>> 11) & 7));
143 /* Print the control word CONTROL. */
146 print_i387_control_word (unsigned int control
, struct ui_file
*file
)
148 fprintf_filtered (file
, "Control Word: %s",
149 hex_string_custom (control
, 4));
150 fputs_filtered (" ", file
);
151 fprintf_filtered (file
, " %s", (control
& 0x0001) ? "IM" : " ");
152 fprintf_filtered (file
, " %s", (control
& 0x0002) ? "DM" : " ");
153 fprintf_filtered (file
, " %s", (control
& 0x0004) ? "ZM" : " ");
154 fprintf_filtered (file
, " %s", (control
& 0x0008) ? "OM" : " ");
155 fprintf_filtered (file
, " %s", (control
& 0x0010) ? "UM" : " ");
156 fprintf_filtered (file
, " %s", (control
& 0x0020) ? "PM" : " ");
158 fputs_filtered ("\n", file
);
160 fputs_filtered (" PC: ", file
);
161 switch ((control
>> 8) & 3)
164 fputs_filtered ("Single Precision (24-bits)\n", file
);
167 fputs_filtered ("Reserved\n", file
);
170 fputs_filtered ("Double Precision (53-bits)\n", file
);
173 fputs_filtered ("Extended Precision (64-bits)\n", file
);
177 fputs_filtered (" RC: ", file
);
178 switch ((control
>> 10) & 3)
181 fputs_filtered ("Round to nearest\n", file
);
184 fputs_filtered ("Round down\n", file
);
187 fputs_filtered ("Round up\n", file
);
190 fputs_filtered ("Round toward zero\n", file
);
195 /* Print out the i387 floating point state. Note that we ignore FRAME
196 in the code below. That's OK since floating-point registers are
197 never saved on the stack. */
200 i387_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
201 struct frame_info
*frame
, const char *args
)
203 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
216 gdb_assert (gdbarch
== get_frame_arch (frame
));
218 /* Define I387_ST0_REGNUM such that we use the proper definitions
219 for FRAME's architecture. */
220 #define I387_ST0_REGNUM tdep->st0_regnum
222 fctrl
= get_frame_register_unsigned (frame
, I387_FCTRL_REGNUM
);
223 fstat
= get_frame_register_unsigned (frame
, I387_FSTAT_REGNUM
);
224 ftag
= get_frame_register_unsigned (frame
, I387_FTAG_REGNUM
);
225 fiseg
= get_frame_register_unsigned (frame
, I387_FISEG_REGNUM
);
226 fioff
= get_frame_register_unsigned (frame
, I387_FIOFF_REGNUM
);
227 foseg
= get_frame_register_unsigned (frame
, I387_FOSEG_REGNUM
);
228 fooff
= get_frame_register_unsigned (frame
, I387_FOOFF_REGNUM
);
229 fop
= get_frame_register_unsigned (frame
, I387_FOP_REGNUM
);
231 top
= ((fstat
>> 11) & 7);
233 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
235 gdb_byte raw
[I386_MAX_REGISTER_SIZE
];
236 int tag
= (ftag
>> (fpreg
* 2)) & 3;
239 fprintf_filtered (file
, "%sR%d: ", fpreg
== top
? "=>" : " ", fpreg
);
244 fputs_filtered ("Valid ", file
);
247 fputs_filtered ("Zero ", file
);
250 fputs_filtered ("Special ", file
);
253 fputs_filtered ("Empty ", file
);
257 get_frame_register (frame
, (fpreg
+ 8 - top
) % 8 + I387_ST0_REGNUM
, raw
);
259 fputs_filtered ("0x", file
);
260 for (i
= 9; i
>= 0; i
--)
261 fprintf_filtered (file
, "%02x", raw
[i
]);
264 print_i387_ext (raw
, file
);
266 fputs_filtered ("\n", file
);
269 fputs_filtered ("\n", file
);
271 print_i387_status_word (fstat
, file
);
272 print_i387_control_word (fctrl
, file
);
273 fprintf_filtered (file
, "Tag Word: %s\n",
274 hex_string_custom (ftag
, 4));
275 fprintf_filtered (file
, "Instruction Pointer: %s:",
276 hex_string_custom (fiseg
, 2));
277 fprintf_filtered (file
, "%s\n", hex_string_custom (fioff
, 8));
278 fprintf_filtered (file
, "Operand Pointer: %s:",
279 hex_string_custom (foseg
, 2));
280 fprintf_filtered (file
, "%s\n", hex_string_custom (fooff
, 8));
281 fprintf_filtered (file
, "Opcode: %s\n",
282 hex_string_custom (fop
? (fop
| 0xd800) : 0, 4));
284 #undef I387_ST0_REGNUM
288 /* Return nonzero if a value of type TYPE stored in register REGNUM
289 needs any special handling. */
292 i387_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
294 if (i386_fp_regnum_p (regnum
))
296 /* Floating point registers must be converted unless we are
297 accessing them in their hardware type. */
298 if (type
== builtin_type_i387_ext
)
307 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
308 return its contents in TO. */
311 i387_register_to_value (struct frame_info
*frame
, int regnum
,
312 struct type
*type
, gdb_byte
*to
)
314 gdb_byte from
[I386_MAX_REGISTER_SIZE
];
316 gdb_assert (i386_fp_regnum_p (regnum
));
318 /* We only support floating-point values. */
319 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
321 warning (_("Cannot convert floating-point register value "
322 "to non-floating-point type."));
326 /* Convert to TYPE. */
327 get_frame_register (frame
, regnum
, from
);
328 convert_typed_floating (from
, builtin_type_i387_ext
, to
, type
);
331 /* Write the contents FROM of a value of type TYPE into register
332 REGNUM in frame FRAME. */
335 i387_value_to_register (struct frame_info
*frame
, int regnum
,
336 struct type
*type
, const gdb_byte
*from
)
338 gdb_byte to
[I386_MAX_REGISTER_SIZE
];
340 gdb_assert (i386_fp_regnum_p (regnum
));
342 /* We only support floating-point values. */
343 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
345 warning (_("Cannot convert non-floating-point type "
346 "to floating-point register value."));
350 /* Convert from TYPE. */
351 convert_typed_floating (from
, type
, to
, builtin_type_i387_ext
);
352 put_frame_register (frame
, regnum
, to
);
356 /* Handle FSAVE and FXSAVE formats. */
358 /* At fsave_offset[REGNUM] you'll find the offset to the location in
359 the data structure used by the "fsave" instruction where GDB
360 register REGNUM is stored. */
362 static int fsave_offset
[] =
364 28 + 0 * 10, /* %st(0) ... */
371 28 + 7 * 10, /* ... %st(7). */
372 0, /* `fctrl' (16 bits). */
373 4, /* `fstat' (16 bits). */
374 8, /* `ftag' (16 bits). */
375 16, /* `fiseg' (16 bits). */
377 24, /* `foseg' (16 bits). */
379 18 /* `fop' (bottom 11 bits). */
382 #define FSAVE_ADDR(fsave, regnum) \
383 (fsave + fsave_offset[regnum - I387_ST0_REGNUM])
386 /* Fill register REGNUM in REGCACHE with the appropriate value from
387 *FSAVE. This function masks off any of the reserved bits in
391 i387_supply_fsave (struct regcache
*regcache
, int regnum
, const void *fsave
)
393 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
394 const gdb_byte
*regs
= fsave
;
397 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
399 /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
400 proper definitions for REGCACHE's architecture. */
402 #define I387_ST0_REGNUM tdep->st0_regnum
403 #define I387_NUM_XMM_REGS tdep->num_xmm_regs
405 for (i
= I387_ST0_REGNUM
; i
< I387_XMM0_REGNUM
; i
++)
406 if (regnum
== -1 || regnum
== i
)
410 regcache_raw_supply (regcache
, i
, NULL
);
414 /* Most of the FPU control registers occupy only 16 bits in the
415 fsave area. Give those a special treatment. */
416 if (i
>= I387_FCTRL_REGNUM
417 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
421 memcpy (val
, FSAVE_ADDR (regs
, i
), 2);
423 if (i
== I387_FOP_REGNUM
)
424 val
[1] &= ((1 << 3) - 1);
425 regcache_raw_supply (regcache
, i
, val
);
428 regcache_raw_supply (regcache
, i
, FSAVE_ADDR (regs
, i
));
431 /* Provide dummy values for the SSE registers. */
432 for (i
= I387_XMM0_REGNUM
; i
< I387_MXCSR_REGNUM
; i
++)
433 if (regnum
== -1 || regnum
== i
)
434 regcache_raw_supply (regcache
, i
, NULL
);
435 if (regnum
== -1 || regnum
== I387_MXCSR_REGNUM
)
439 store_unsigned_integer (buf
, 4, 0x1f80);
440 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM
, buf
);
443 #undef I387_ST0_REGNUM
444 #undef I387_NUM_XMM_REGS
447 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
448 with the value from REGCACHE. If REGNUM is -1, do this for all
449 registers. This function doesn't touch any of the reserved bits in
453 i387_collect_fsave (const struct regcache
*regcache
, int regnum
, void *fsave
)
455 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
456 gdb_byte
*regs
= fsave
;
459 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
461 /* Define I387_ST0_REGNUM such that we use the proper definitions
462 for REGCACHE's architecture. */
463 #define I387_ST0_REGNUM tdep->st0_regnum
465 for (i
= I387_ST0_REGNUM
; i
< I387_XMM0_REGNUM
; i
++)
466 if (regnum
== -1 || regnum
== i
)
468 /* Most of the FPU control registers occupy only 16 bits in
469 the fsave area. Give those a special treatment. */
470 if (i
>= I387_FCTRL_REGNUM
471 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
475 regcache_raw_collect (regcache
, i
, buf
);
477 if (i
== I387_FOP_REGNUM
)
479 /* The opcode occupies only 11 bits. Make sure we
480 don't touch the other bits. */
481 buf
[1] &= ((1 << 3) - 1);
482 buf
[1] |= ((FSAVE_ADDR (regs
, i
))[1] & ~((1 << 3) - 1));
484 memcpy (FSAVE_ADDR (regs
, i
), buf
, 2);
487 regcache_raw_collect (regcache
, i
, FSAVE_ADDR (regs
, i
));
489 #undef I387_ST0_REGNUM
493 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
494 the data structure used by the "fxsave" instruction where GDB
495 register REGNUM is stored. */
497 static int fxsave_offset
[] =
499 32, /* %st(0) through ... */
506 144, /* ... %st(7) (80 bits each). */
507 0, /* `fctrl' (16 bits). */
508 2, /* `fstat' (16 bits). */
509 4, /* `ftag' (16 bits). */
510 12, /* `fiseg' (16 bits). */
512 20, /* `foseg' (16 bits). */
514 6, /* `fop' (bottom 11 bits). */
515 160 + 0 * 16, /* %xmm0 through ... */
530 160 + 15 * 16, /* ... %xmm15 (128 bits each). */
533 #define FXSAVE_ADDR(fxsave, regnum) \
534 (fxsave + fxsave_offset[regnum - I387_ST0_REGNUM])
536 /* We made an unfortunate choice in putting %mxcsr after the SSE
537 registers %xmm0-%xmm7 instead of before, since it makes supporting
538 the registers %xmm8-%xmm15 on AMD64 a bit involved. Therefore we
539 don't include the offset for %mxcsr here above. */
541 #define FXSAVE_MXCSR_ADDR(fxsave) (fxsave + 24)
543 static int i387_tag (const gdb_byte
*raw
);
546 /* Fill register REGNUM in REGCACHE with the appropriate
547 floating-point or SSE register value from *FXSAVE. This function
548 masks off any of the reserved bits in *FXSAVE. */
551 i387_supply_fxsave (struct regcache
*regcache
, int regnum
, const void *fxsave
)
553 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
554 const gdb_byte
*regs
= fxsave
;
557 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
558 gdb_assert (tdep
->num_xmm_regs
> 0);
560 /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
561 proper definitions for REGCACHE's architecture. */
563 #define I387_ST0_REGNUM tdep->st0_regnum
564 #define I387_NUM_XMM_REGS tdep->num_xmm_regs
566 for (i
= I387_ST0_REGNUM
; i
< I387_MXCSR_REGNUM
; i
++)
567 if (regnum
== -1 || regnum
== i
)
571 regcache_raw_supply (regcache
, i
, NULL
);
575 /* Most of the FPU control registers occupy only 16 bits in
576 the fxsave area. Give those a special treatment. */
577 if (i
>= I387_FCTRL_REGNUM
&& i
< I387_XMM0_REGNUM
578 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
582 memcpy (val
, FXSAVE_ADDR (regs
, i
), 2);
584 if (i
== I387_FOP_REGNUM
)
585 val
[1] &= ((1 << 3) - 1);
586 else if (i
== I387_FTAG_REGNUM
)
588 /* The fxsave area contains a simplified version of
589 the tag word. We have to look at the actual 80-bit
590 FP data to recreate the traditional i387 tag word. */
592 unsigned long ftag
= 0;
596 top
= ((FXSAVE_ADDR (regs
, I387_FSTAT_REGNUM
))[1] >> 3);
599 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
603 if (val
[0] & (1 << fpreg
))
605 int regnum
= (fpreg
+ 8 - top
) % 8 + I387_ST0_REGNUM
;
606 tag
= i387_tag (FXSAVE_ADDR (regs
, regnum
));
611 ftag
|= tag
<< (2 * fpreg
);
613 val
[0] = ftag
& 0xff;
614 val
[1] = (ftag
>> 8) & 0xff;
616 regcache_raw_supply (regcache
, i
, val
);
619 regcache_raw_supply (regcache
, i
, FXSAVE_ADDR (regs
, i
));
622 if (regnum
== I387_MXCSR_REGNUM
|| regnum
== -1)
625 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM
, NULL
);
627 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM
,
628 FXSAVE_MXCSR_ADDR (regs
));
631 #undef I387_ST0_REGNUM
632 #undef I387_NUM_XMM_REGS
635 /* Fill register REGNUM (if it is a floating-point or SSE register) in
636 *FXSAVE with the value from REGCACHE. If REGNUM is -1, do this for
637 all registers. This function doesn't touch any of the reserved
641 i387_collect_fxsave (const struct regcache
*regcache
, int regnum
, void *fxsave
)
643 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
644 gdb_byte
*regs
= fxsave
;
647 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
648 gdb_assert (tdep
->num_xmm_regs
> 0);
650 /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
651 proper definitions for REGCACHE's architecture. */
653 #define I387_ST0_REGNUM tdep->st0_regnum
654 #define I387_NUM_XMM_REGS tdep->num_xmm_regs
656 for (i
= I387_ST0_REGNUM
; i
< I387_MXCSR_REGNUM
; i
++)
657 if (regnum
== -1 || regnum
== i
)
659 /* Most of the FPU control registers occupy only 16 bits in
660 the fxsave area. Give those a special treatment. */
661 if (i
>= I387_FCTRL_REGNUM
&& i
< I387_XMM0_REGNUM
662 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
666 regcache_raw_collect (regcache
, i
, buf
);
668 if (i
== I387_FOP_REGNUM
)
670 /* The opcode occupies only 11 bits. Make sure we
671 don't touch the other bits. */
672 buf
[1] &= ((1 << 3) - 1);
673 buf
[1] |= ((FXSAVE_ADDR (regs
, i
))[1] & ~((1 << 3) - 1));
675 else if (i
== I387_FTAG_REGNUM
)
677 /* Converting back is much easier. */
682 ftag
= (buf
[1] << 8) | buf
[0];
686 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
688 int tag
= (ftag
>> (fpreg
* 2)) & 3;
691 buf
[0] |= (1 << fpreg
);
694 memcpy (FXSAVE_ADDR (regs
, i
), buf
, 2);
697 regcache_raw_collect (regcache
, i
, FXSAVE_ADDR (regs
, i
));
700 if (regnum
== I387_MXCSR_REGNUM
|| regnum
== -1)
701 regcache_raw_collect (regcache
, I387_MXCSR_REGNUM
,
702 FXSAVE_MXCSR_ADDR (regs
));
704 #undef I387_ST0_REGNUM
705 #undef I387_NUM_XMM_REGS
708 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
712 i387_tag (const gdb_byte
*raw
)
715 unsigned int exponent
;
716 unsigned long fraction
[2];
718 integer
= raw
[7] & 0x80;
719 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
720 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
721 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
722 | (raw
[5] << 8) | raw
[4]);
724 if (exponent
== 0x7fff)
729 else if (exponent
== 0x0000)
731 if (fraction
[0] == 0x0000 && fraction
[1] == 0x0000 && !integer
)
757 /* Prepare the FPU stack in REGCACHE for a function return. */
760 i387_return_value (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
762 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
765 /* Define I387_ST0_REGNUM such that we use the proper
766 definitions for the architecture. */
767 #define I387_ST0_REGNUM tdep->st0_regnum
769 /* Set the top of the floating-point register stack to 7. The
770 actual value doesn't really matter, but 7 is what a normal
771 function return would end up with if the program started out with
772 a freshly initialized FPU. */
773 regcache_raw_read_unsigned (regcache
, I387_FSTAT_REGNUM
, &fstat
);
775 regcache_raw_write_unsigned (regcache
, I387_FSTAT_REGNUM
, fstat
);
777 /* Mark %st(1) through %st(7) as empty. Since we set the top of the
778 floating-point register stack to 7, the appropriate value for the
779 tag word is 0x3fff. */
780 regcache_raw_write_unsigned (regcache
, I387_FTAG_REGNUM
, 0x3fff);
782 #undef I387_ST0_REGNUM
This page took 0.045839 seconds and 4 git commands to generate.