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 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
289 return its contents in TO. */
292 i387_register_to_value (struct frame_info
*frame
, int regnum
,
293 struct type
*type
, gdb_byte
*to
)
295 gdb_byte from
[I386_MAX_REGISTER_SIZE
];
297 gdb_assert (i386_fp_regnum_p (regnum
));
299 /* We only support floating-point values. */
300 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
302 warning (_("Cannot convert floating-point register value "
303 "to non-floating-point type."));
307 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
308 the extended floating-point format used by the FPU. */
309 get_frame_register (frame
, regnum
, from
);
310 convert_typed_floating (from
, builtin_type_i387_ext
, to
, type
);
313 /* Write the contents FROM of a value of type TYPE into register
314 REGNUM in frame FRAME. */
317 i387_value_to_register (struct frame_info
*frame
, int regnum
,
318 struct type
*type
, const gdb_byte
*from
)
320 gdb_byte to
[I386_MAX_REGISTER_SIZE
];
322 gdb_assert (i386_fp_regnum_p (regnum
));
324 /* We only support floating-point values. */
325 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
327 warning (_("Cannot convert non-floating-point type "
328 "to floating-point register value."));
332 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
333 to the extended floating-point format used by the FPU. */
334 convert_typed_floating (from
, type
, to
, builtin_type_i387_ext
);
335 put_frame_register (frame
, regnum
, to
);
339 /* Handle FSAVE and FXSAVE formats. */
341 /* At fsave_offset[REGNUM] you'll find the offset to the location in
342 the data structure used by the "fsave" instruction where GDB
343 register REGNUM is stored. */
345 static int fsave_offset
[] =
347 28 + 0 * 10, /* %st(0) ... */
354 28 + 7 * 10, /* ... %st(7). */
355 0, /* `fctrl' (16 bits). */
356 4, /* `fstat' (16 bits). */
357 8, /* `ftag' (16 bits). */
358 16, /* `fiseg' (16 bits). */
360 24, /* `foseg' (16 bits). */
362 18 /* `fop' (bottom 11 bits). */
365 #define FSAVE_ADDR(fsave, regnum) \
366 (fsave + fsave_offset[regnum - I387_ST0_REGNUM])
369 /* Fill register REGNUM in REGCACHE with the appropriate value from
370 *FSAVE. This function masks off any of the reserved bits in
374 i387_supply_fsave (struct regcache
*regcache
, int regnum
, const void *fsave
)
376 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
377 const gdb_byte
*regs
= fsave
;
380 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
382 /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
383 proper definitions for REGCACHE's architecture. */
385 #define I387_ST0_REGNUM tdep->st0_regnum
386 #define I387_NUM_XMM_REGS tdep->num_xmm_regs
388 for (i
= I387_ST0_REGNUM
; i
< I387_XMM0_REGNUM
; i
++)
389 if (regnum
== -1 || regnum
== i
)
393 regcache_raw_supply (regcache
, i
, NULL
);
397 /* Most of the FPU control registers occupy only 16 bits in the
398 fsave area. Give those a special treatment. */
399 if (i
>= I387_FCTRL_REGNUM
400 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
404 memcpy (val
, FSAVE_ADDR (regs
, i
), 2);
406 if (i
== I387_FOP_REGNUM
)
407 val
[1] &= ((1 << 3) - 1);
408 regcache_raw_supply (regcache
, i
, val
);
411 regcache_raw_supply (regcache
, i
, FSAVE_ADDR (regs
, i
));
414 /* Provide dummy values for the SSE registers. */
415 for (i
= I387_XMM0_REGNUM
; i
< I387_MXCSR_REGNUM
; i
++)
416 if (regnum
== -1 || regnum
== i
)
417 regcache_raw_supply (regcache
, i
, NULL
);
418 if (regnum
== -1 || regnum
== I387_MXCSR_REGNUM
)
422 store_unsigned_integer (buf
, 4, 0x1f80);
423 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM
, buf
);
426 #undef I387_ST0_REGNUM
427 #undef I387_NUM_XMM_REGS
430 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
431 with the value from REGCACHE. If REGNUM is -1, do this for all
432 registers. This function doesn't touch any of the reserved bits in
436 i387_collect_fsave (const struct regcache
*regcache
, int regnum
, void *fsave
)
438 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
439 gdb_byte
*regs
= fsave
;
442 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
444 /* Define I387_ST0_REGNUM such that we use the proper definitions
445 for REGCACHE's architecture. */
446 #define I387_ST0_REGNUM tdep->st0_regnum
448 for (i
= I387_ST0_REGNUM
; i
< I387_XMM0_REGNUM
; i
++)
449 if (regnum
== -1 || regnum
== i
)
451 /* Most of the FPU control registers occupy only 16 bits in
452 the fsave area. Give those a special treatment. */
453 if (i
>= I387_FCTRL_REGNUM
454 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
458 regcache_raw_collect (regcache
, i
, buf
);
460 if (i
== I387_FOP_REGNUM
)
462 /* The opcode occupies only 11 bits. Make sure we
463 don't touch the other bits. */
464 buf
[1] &= ((1 << 3) - 1);
465 buf
[1] |= ((FSAVE_ADDR (regs
, i
))[1] & ~((1 << 3) - 1));
467 memcpy (FSAVE_ADDR (regs
, i
), buf
, 2);
470 regcache_raw_collect (regcache
, i
, FSAVE_ADDR (regs
, i
));
472 #undef I387_ST0_REGNUM
476 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
477 the data structure used by the "fxsave" instruction where GDB
478 register REGNUM is stored. */
480 static int fxsave_offset
[] =
482 32, /* %st(0) through ... */
489 144, /* ... %st(7) (80 bits each). */
490 0, /* `fctrl' (16 bits). */
491 2, /* `fstat' (16 bits). */
492 4, /* `ftag' (16 bits). */
493 12, /* `fiseg' (16 bits). */
495 20, /* `foseg' (16 bits). */
497 6, /* `fop' (bottom 11 bits). */
498 160 + 0 * 16, /* %xmm0 through ... */
513 160 + 15 * 16, /* ... %xmm15 (128 bits each). */
516 #define FXSAVE_ADDR(fxsave, regnum) \
517 (fxsave + fxsave_offset[regnum - I387_ST0_REGNUM])
519 /* We made an unfortunate choice in putting %mxcsr after the SSE
520 registers %xmm0-%xmm7 instead of before, since it makes supporting
521 the registers %xmm8-%xmm15 on AMD64 a bit involved. Therefore we
522 don't include the offset for %mxcsr here above. */
524 #define FXSAVE_MXCSR_ADDR(fxsave) (fxsave + 24)
526 static int i387_tag (const gdb_byte
*raw
);
529 /* Fill register REGNUM in REGCACHE with the appropriate
530 floating-point or SSE register value from *FXSAVE. This function
531 masks off any of the reserved bits in *FXSAVE. */
534 i387_supply_fxsave (struct regcache
*regcache
, int regnum
, const void *fxsave
)
536 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
537 const gdb_byte
*regs
= fxsave
;
540 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
541 gdb_assert (tdep
->num_xmm_regs
> 0);
543 /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
544 proper definitions for REGCACHE's architecture. */
546 #define I387_ST0_REGNUM tdep->st0_regnum
547 #define I387_NUM_XMM_REGS tdep->num_xmm_regs
549 for (i
= I387_ST0_REGNUM
; i
< I387_MXCSR_REGNUM
; i
++)
550 if (regnum
== -1 || regnum
== i
)
554 regcache_raw_supply (regcache
, i
, NULL
);
558 /* Most of the FPU control registers occupy only 16 bits in
559 the fxsave area. Give those a special treatment. */
560 if (i
>= I387_FCTRL_REGNUM
&& i
< I387_XMM0_REGNUM
561 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
565 memcpy (val
, FXSAVE_ADDR (regs
, i
), 2);
567 if (i
== I387_FOP_REGNUM
)
568 val
[1] &= ((1 << 3) - 1);
569 else if (i
== I387_FTAG_REGNUM
)
571 /* The fxsave area contains a simplified version of
572 the tag word. We have to look at the actual 80-bit
573 FP data to recreate the traditional i387 tag word. */
575 unsigned long ftag
= 0;
579 top
= ((FXSAVE_ADDR (regs
, I387_FSTAT_REGNUM
))[1] >> 3);
582 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
586 if (val
[0] & (1 << fpreg
))
588 int regnum
= (fpreg
+ 8 - top
) % 8 + I387_ST0_REGNUM
;
589 tag
= i387_tag (FXSAVE_ADDR (regs
, regnum
));
594 ftag
|= tag
<< (2 * fpreg
);
596 val
[0] = ftag
& 0xff;
597 val
[1] = (ftag
>> 8) & 0xff;
599 regcache_raw_supply (regcache
, i
, val
);
602 regcache_raw_supply (regcache
, i
, FXSAVE_ADDR (regs
, i
));
605 if (regnum
== I387_MXCSR_REGNUM
|| regnum
== -1)
608 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM
, NULL
);
610 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM
,
611 FXSAVE_MXCSR_ADDR (regs
));
614 #undef I387_ST0_REGNUM
615 #undef I387_NUM_XMM_REGS
618 /* Fill register REGNUM (if it is a floating-point or SSE register) in
619 *FXSAVE with the value from REGCACHE. If REGNUM is -1, do this for
620 all registers. This function doesn't touch any of the reserved
624 i387_collect_fxsave (const struct regcache
*regcache
, int regnum
, void *fxsave
)
626 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
627 gdb_byte
*regs
= fxsave
;
630 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
631 gdb_assert (tdep
->num_xmm_regs
> 0);
633 /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
634 proper definitions for REGCACHE's architecture. */
636 #define I387_ST0_REGNUM tdep->st0_regnum
637 #define I387_NUM_XMM_REGS tdep->num_xmm_regs
639 for (i
= I387_ST0_REGNUM
; i
< I387_MXCSR_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
>= I387_FCTRL_REGNUM
&& i
< I387_XMM0_REGNUM
645 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
649 regcache_raw_collect (regcache
, i
, buf
);
651 if (i
== I387_FOP_REGNUM
)
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 (regs
, i
))[1] & ~((1 << 3) - 1));
658 else if (i
== I387_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 (regs
, i
), buf
, 2);
680 regcache_raw_collect (regcache
, i
, FXSAVE_ADDR (regs
, i
));
683 if (regnum
== I387_MXCSR_REGNUM
|| regnum
== -1)
684 regcache_raw_collect (regcache
, I387_MXCSR_REGNUM
,
685 FXSAVE_MXCSR_ADDR (regs
));
687 #undef I387_ST0_REGNUM
688 #undef I387_NUM_XMM_REGS
691 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
695 i387_tag (const gdb_byte
*raw
)
698 unsigned int exponent
;
699 unsigned long fraction
[2];
701 integer
= raw
[7] & 0x80;
702 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
703 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
704 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
705 | (raw
[5] << 8) | raw
[4]);
707 if (exponent
== 0x7fff)
712 else if (exponent
== 0x0000)
714 if (fraction
[0] == 0x0000 && fraction
[1] == 0x0000 && !integer
)
740 /* Prepare the FPU stack in REGCACHE for a function return. */
743 i387_return_value (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
745 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
748 /* Define I387_ST0_REGNUM such that we use the proper
749 definitions for the architecture. */
750 #define I387_ST0_REGNUM tdep->st0_regnum
752 /* Set the top of the floating-point register stack to 7. The
753 actual value doesn't really matter, but 7 is what a normal
754 function return would end up with if the program started out with
755 a freshly initialized FPU. */
756 regcache_raw_read_unsigned (regcache
, I387_FSTAT_REGNUM
, &fstat
);
758 regcache_raw_write_unsigned (regcache
, I387_FSTAT_REGNUM
, fstat
);
760 /* Mark %st(1) through %st(7) as empty. Since we set the top of the
761 floating-point register stack to 7, the appropriate value for the
762 tag word is 0x3fff. */
763 regcache_raw_write_unsigned (regcache
, I387_FTAG_REGNUM
, 0x3fff);
765 #undef I387_ST0_REGNUM
This page took 0.045073 seconds and 4 git commands to generate.