1 /* Intel 387 floating point stuff.
3 Copyright 1988, 1989, 1991, 1992, 1993, 1994, 1998, 1999, 2000,
4 2001, 2002, 2003, 2004 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 2 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, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "floatformat.h"
33 #include "gdb_assert.h"
34 #include "gdb_string.h"
36 #include "i386-tdep.h"
37 #include "i387-tdep.h"
39 /* Implement the `info float' layout based on the register definitions
42 /* Print the floating point number specified by RAW. */
45 print_i387_value (char *raw
, struct ui_file
*file
)
49 /* Using extract_typed_floating here might affect the representation
50 of certain numbers such as NaNs, even if GDB is running natively.
51 This is fine since our caller already detects such special
52 numbers and we print the hexadecimal representation anyway. */
53 value
= extract_typed_floating (raw
, builtin_type_i387_ext
);
55 /* We try to print 19 digits. The last digit may or may not contain
56 garbage, but we'd better print one too many. We need enough room
57 to print the value, 1 position for the sign, 1 for the decimal
58 point, 19 for the digits and 6 for the exponent adds up to 27. */
59 #ifdef PRINTF_HAS_LONG_DOUBLE
60 fprintf_filtered (file
, " %-+27.19Lg", (long double) value
);
62 fprintf_filtered (file
, " %-+27.19g", (double) value
);
66 /* Print the classification for the register contents RAW. */
69 print_i387_ext (unsigned char *raw
, struct ui_file
*file
)
73 unsigned int exponent
;
74 unsigned long fraction
[2];
77 integer
= raw
[7] & 0x80;
78 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
79 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
80 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
81 | (raw
[5] << 8) | raw
[4]);
83 if (exponent
== 0x7fff && integer
)
85 if (fraction
[0] == 0x00000000 && fraction
[1] == 0x00000000)
87 fprintf_filtered (file
, " %cInf", (sign
? '-' : '+'));
88 else if (sign
&& fraction
[0] == 0x00000000 && fraction
[1] == 0x40000000)
89 /* Real Indefinite (QNaN). */
90 fputs_unfiltered (" Real Indefinite (QNaN)", file
);
91 else if (fraction
[1] & 0x40000000)
93 fputs_filtered (" QNaN", file
);
96 fputs_filtered (" SNaN", file
);
98 else if (exponent
< 0x7fff && exponent
> 0x0000 && integer
)
100 print_i387_value (raw
, file
);
101 else if (exponent
== 0x0000)
103 /* Denormal or zero. */
104 print_i387_value (raw
, file
);
107 /* Pseudo-denormal. */
108 fputs_filtered (" Pseudo-denormal", file
);
109 else if (fraction
[0] || fraction
[1])
111 fputs_filtered (" Denormal", file
);
115 fputs_filtered (" Unsupported", file
);
118 /* Print the status word STATUS. */
121 print_i387_status_word (unsigned int status
, struct ui_file
*file
)
123 fprintf_filtered (file
, "Status Word: %s",
124 hex_string_custom (status
, 4));
125 fputs_filtered (" ", file
);
126 fprintf_filtered (file
, " %s", (status
& 0x0001) ? "IE" : " ");
127 fprintf_filtered (file
, " %s", (status
& 0x0002) ? "DE" : " ");
128 fprintf_filtered (file
, " %s", (status
& 0x0004) ? "ZE" : " ");
129 fprintf_filtered (file
, " %s", (status
& 0x0008) ? "OE" : " ");
130 fprintf_filtered (file
, " %s", (status
& 0x0010) ? "UE" : " ");
131 fprintf_filtered (file
, " %s", (status
& 0x0020) ? "PE" : " ");
132 fputs_filtered (" ", file
);
133 fprintf_filtered (file
, " %s", (status
& 0x0080) ? "ES" : " ");
134 fputs_filtered (" ", file
);
135 fprintf_filtered (file
, " %s", (status
& 0x0040) ? "SF" : " ");
136 fputs_filtered (" ", file
);
137 fprintf_filtered (file
, " %s", (status
& 0x0100) ? "C0" : " ");
138 fprintf_filtered (file
, " %s", (status
& 0x0200) ? "C1" : " ");
139 fprintf_filtered (file
, " %s", (status
& 0x0400) ? "C2" : " ");
140 fprintf_filtered (file
, " %s", (status
& 0x4000) ? "C3" : " ");
142 fputs_filtered ("\n", file
);
144 fprintf_filtered (file
,
145 " TOP: %d\n", ((status
>> 11) & 7));
148 /* Print the control word CONTROL. */
151 print_i387_control_word (unsigned int control
, struct ui_file
*file
)
153 fprintf_filtered (file
, "Control Word: %s",
154 hex_string_custom (control
, 4));
155 fputs_filtered (" ", file
);
156 fprintf_filtered (file
, " %s", (control
& 0x0001) ? "IM" : " ");
157 fprintf_filtered (file
, " %s", (control
& 0x0002) ? "DM" : " ");
158 fprintf_filtered (file
, " %s", (control
& 0x0004) ? "ZM" : " ");
159 fprintf_filtered (file
, " %s", (control
& 0x0008) ? "OM" : " ");
160 fprintf_filtered (file
, " %s", (control
& 0x0010) ? "UM" : " ");
161 fprintf_filtered (file
, " %s", (control
& 0x0020) ? "PM" : " ");
163 fputs_filtered ("\n", file
);
165 fputs_filtered (" PC: ", file
);
166 switch ((control
>> 8) & 3)
169 fputs_filtered ("Single Precision (24-bits)\n", file
);
172 fputs_filtered ("Reserved\n", file
);
175 fputs_filtered ("Double Precision (53-bits)\n", file
);
178 fputs_filtered ("Extended Precision (64-bits)\n", file
);
182 fputs_filtered (" RC: ", file
);
183 switch ((control
>> 10) & 3)
186 fputs_filtered ("Round to nearest\n", file
);
189 fputs_filtered ("Round down\n", file
);
192 fputs_filtered ("Round up\n", file
);
195 fputs_filtered ("Round toward zero\n", file
);
200 /* Print out the i387 floating point state. Note that we ignore FRAME
201 in the code below. That's OK since floating-point registers are
202 never saved on the stack. */
205 i387_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
206 struct frame_info
*frame
, const char *args
)
208 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
221 gdb_assert (gdbarch
== get_frame_arch (frame
));
223 /* Define I387_ST0_REGNUM such that we use the proper definitions
224 for FRAME's architecture. */
225 #define I387_ST0_REGNUM tdep->st0_regnum
227 fctrl
= get_frame_register_unsigned (frame
, I387_FCTRL_REGNUM
);
228 fstat
= get_frame_register_unsigned (frame
, I387_FSTAT_REGNUM
);
229 ftag
= get_frame_register_unsigned (frame
, I387_FTAG_REGNUM
);
230 fiseg
= get_frame_register_unsigned (frame
, I387_FISEG_REGNUM
);
231 fioff
= get_frame_register_unsigned (frame
, I387_FIOFF_REGNUM
);
232 foseg
= get_frame_register_unsigned (frame
, I387_FOSEG_REGNUM
);
233 fooff
= get_frame_register_unsigned (frame
, I387_FOOFF_REGNUM
);
234 fop
= get_frame_register_unsigned (frame
, I387_FOP_REGNUM
);
236 top
= ((fstat
>> 11) & 7);
238 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
240 unsigned char raw
[I386_MAX_REGISTER_SIZE
];
241 int tag
= (ftag
>> (fpreg
* 2)) & 3;
244 fprintf_filtered (file
, "%sR%d: ", fpreg
== top
? "=>" : " ", fpreg
);
249 fputs_filtered ("Valid ", file
);
252 fputs_filtered ("Zero ", file
);
255 fputs_filtered ("Special ", file
);
258 fputs_filtered ("Empty ", file
);
262 get_frame_register (frame
, (fpreg
+ 8 - top
) % 8 + I387_ST0_REGNUM
, raw
);
264 fputs_filtered ("0x", file
);
265 for (i
= 9; i
>= 0; i
--)
266 fprintf_filtered (file
, "%02x", raw
[i
]);
269 print_i387_ext (raw
, file
);
271 fputs_filtered ("\n", file
);
274 fputs_filtered ("\n", file
);
276 print_i387_status_word (fstat
, file
);
277 print_i387_control_word (fctrl
, file
);
278 fprintf_filtered (file
, "Tag Word: %s\n",
279 hex_string_custom (ftag
, 4));
280 fprintf_filtered (file
, "Instruction Pointer: %s:",
281 hex_string_custom (fiseg
, 2));
282 fprintf_filtered (file
, "%s\n", hex_string_custom (fioff
, 8));
283 fprintf_filtered (file
, "Operand Pointer: %s:",
284 hex_string_custom (foseg
, 2));
285 fprintf_filtered (file
, "%s\n", hex_string_custom (fooff
, 8));
286 fprintf_filtered (file
, "Opcode: %s\n",
287 hex_string_custom (fop
? (fop
| 0xd800) : 0, 4));
289 #undef I387_ST0_REGNUM
293 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
294 return its contents in TO. */
297 i387_register_to_value (struct frame_info
*frame
, int regnum
,
298 struct type
*type
, void *to
)
300 char from
[I386_MAX_REGISTER_SIZE
];
302 gdb_assert (i386_fp_regnum_p (regnum
));
304 /* We only support floating-point values. */
305 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
307 warning (_("Cannot convert floating-point register value "
308 "to non-floating-point type."));
312 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
313 the extended floating-point format used by the FPU. */
314 get_frame_register (frame
, regnum
, from
);
315 convert_typed_floating (from
, builtin_type_i387_ext
, to
, type
);
318 /* Write the contents FROM of a value of type TYPE into register
319 REGNUM in frame FRAME. */
322 i387_value_to_register (struct frame_info
*frame
, int regnum
,
323 struct type
*type
, const void *from
)
325 char to
[I386_MAX_REGISTER_SIZE
];
327 gdb_assert (i386_fp_regnum_p (regnum
));
329 /* We only support floating-point values. */
330 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
332 warning (_("Cannot convert non-floating-point type "
333 "to floating-point register value."));
337 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
338 to the extended floating-point format used by the FPU. */
339 convert_typed_floating (from
, type
, to
, builtin_type_i387_ext
);
340 put_frame_register (frame
, regnum
, to
);
344 /* Handle FSAVE and FXSAVE formats. */
346 /* FIXME: kettenis/20030927: The functions below should accept a
347 `regcache' argument, but I don't want to change the function
348 signature just yet. There's some band-aid in the functions below
349 in the form of the `regcache' local variables. This will ease the
350 transition later on. */
352 /* At fsave_offset[REGNUM] you'll find the offset to the location in
353 the data structure used by the "fsave" instruction where GDB
354 register REGNUM is stored. */
356 static int fsave_offset
[] =
358 28 + 0 * 10, /* %st(0) ... */
365 28 + 7 * 10, /* ... %st(7). */
366 0, /* `fctrl' (16 bits). */
367 4, /* `fstat' (16 bits). */
368 8, /* `ftag' (16 bits). */
369 16, /* `fiseg' (16 bits). */
371 24, /* `foseg' (16 bits). */
373 18 /* `fop' (bottom 11 bits). */
376 #define FSAVE_ADDR(fsave, regnum) \
377 (fsave + fsave_offset[regnum - I387_ST0_REGNUM])
380 /* Fill register REGNUM in REGCACHE with the appropriate value from
381 *FSAVE. This function masks off any of the reserved bits in
385 i387_supply_fsave (struct regcache
*regcache
, int regnum
, const void *fsave
)
387 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
388 const char *regs
= fsave
;
391 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
393 /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
394 proper definitions for REGCACHE's architecture. */
396 #define I387_ST0_REGNUM tdep->st0_regnum
397 #define I387_NUM_XMM_REGS tdep->num_xmm_regs
399 for (i
= I387_ST0_REGNUM
; i
< I387_XMM0_REGNUM
; i
++)
400 if (regnum
== -1 || regnum
== i
)
404 regcache_raw_supply (regcache
, i
, NULL
);
408 /* Most of the FPU control registers occupy only 16 bits in the
409 fsave area. Give those a special treatment. */
410 if (i
>= I387_FCTRL_REGNUM
411 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
413 unsigned char val
[4];
415 memcpy (val
, FSAVE_ADDR (regs
, i
), 2);
417 if (i
== I387_FOP_REGNUM
)
418 val
[1] &= ((1 << 3) - 1);
419 regcache_raw_supply (regcache
, i
, val
);
422 regcache_raw_supply (regcache
, i
, FSAVE_ADDR (regs
, i
));
425 /* Provide dummy values for the SSE registers. */
426 for (i
= I387_XMM0_REGNUM
; i
< I387_MXCSR_REGNUM
; i
++)
427 if (regnum
== -1 || regnum
== i
)
428 regcache_raw_supply (regcache
, i
, NULL
);
429 if (regnum
== -1 || regnum
== I387_MXCSR_REGNUM
)
433 store_unsigned_integer (buf
, 4, 0x1f80);
434 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM
, buf
);
437 #undef I387_ST0_REGNUM
438 #undef I387_NUM_XMM_REGS
441 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
442 with the value from REGCACHE. If REGNUM is -1, do this for all
443 registers. This function doesn't touch any of the reserved bits in
447 i387_collect_fsave (const struct regcache
*regcache
, int regnum
, void *fsave
)
449 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
453 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
455 /* Define I387_ST0_REGNUM such that we use the proper definitions
456 for REGCACHE's architecture. */
457 #define I387_ST0_REGNUM tdep->st0_regnum
459 for (i
= I387_ST0_REGNUM
; i
< I387_XMM0_REGNUM
; i
++)
460 if (regnum
== -1 || regnum
== i
)
462 /* Most of the FPU control registers occupy only 16 bits in
463 the fsave area. Give those a special treatment. */
464 if (i
>= I387_FCTRL_REGNUM
465 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
467 unsigned char buf
[4];
469 regcache_raw_collect (regcache
, i
, buf
);
471 if (i
== I387_FOP_REGNUM
)
473 /* The opcode occupies only 11 bits. Make sure we
474 don't touch the other bits. */
475 buf
[1] &= ((1 << 3) - 1);
476 buf
[1] |= ((FSAVE_ADDR (regs
, i
))[1] & ~((1 << 3) - 1));
478 memcpy (FSAVE_ADDR (regs
, i
), buf
, 2);
481 regcache_raw_collect (regcache
, i
, FSAVE_ADDR (regs
, i
));
483 #undef I387_ST0_REGNUM
486 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
487 with the value in GDB's register cache. If REGNUM is -1, do this
488 for all registers. This function doesn't touch any of the reserved
492 i387_fill_fsave (void *fsave
, int regnum
)
494 i387_collect_fsave (current_regcache
, regnum
, fsave
);
498 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
499 the data structure used by the "fxsave" instruction where GDB
500 register REGNUM is stored. */
502 static int fxsave_offset
[] =
504 32, /* %st(0) through ... */
511 144, /* ... %st(7) (80 bits each). */
512 0, /* `fctrl' (16 bits). */
513 2, /* `fstat' (16 bits). */
514 4, /* `ftag' (16 bits). */
515 12, /* `fiseg' (16 bits). */
517 20, /* `foseg' (16 bits). */
519 6, /* `fop' (bottom 11 bits). */
520 160 + 0 * 16, /* %xmm0 through ... */
535 160 + 15 * 16, /* ... %xmm15 (128 bits each). */
538 #define FXSAVE_ADDR(fxsave, regnum) \
539 (fxsave + fxsave_offset[regnum - I387_ST0_REGNUM])
541 /* We made an unfortunate choice in putting %mxcsr after the SSE
542 registers %xmm0-%xmm7 instead of before, since it makes supporting
543 the registers %xmm8-%xmm15 on AMD64 a bit involved. Therefore we
544 don't include the offset for %mxcsr here above. */
546 #define FXSAVE_MXCSR_ADDR(fxsave) (fxsave + 24)
548 static int i387_tag (const unsigned char *raw
);
551 /* Fill register REGNUM in REGCACHE with the appropriate
552 floating-point or SSE register value from *FXSAVE. This function
553 masks off any of the reserved bits in *FXSAVE. */
556 i387_supply_fxsave (struct regcache
*regcache
, int regnum
, const void *fxsave
)
558 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
559 const char *regs
= fxsave
;
562 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
563 gdb_assert (tdep
->num_xmm_regs
> 0);
565 /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
566 proper definitions for REGCACHE's architecture. */
568 #define I387_ST0_REGNUM tdep->st0_regnum
569 #define I387_NUM_XMM_REGS tdep->num_xmm_regs
571 for (i
= I387_ST0_REGNUM
; i
< I387_MXCSR_REGNUM
; i
++)
572 if (regnum
== -1 || regnum
== i
)
576 regcache_raw_supply (regcache
, i
, NULL
);
580 /* Most of the FPU control registers occupy only 16 bits in
581 the fxsave area. Give those a special treatment. */
582 if (i
>= I387_FCTRL_REGNUM
&& i
< I387_XMM0_REGNUM
583 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
585 unsigned char val
[4];
587 memcpy (val
, FXSAVE_ADDR (regs
, i
), 2);
589 if (i
== I387_FOP_REGNUM
)
590 val
[1] &= ((1 << 3) - 1);
591 else if (i
== I387_FTAG_REGNUM
)
593 /* The fxsave area contains a simplified version of
594 the tag word. We have to look at the actual 80-bit
595 FP data to recreate the traditional i387 tag word. */
597 unsigned long ftag
= 0;
601 top
= ((FXSAVE_ADDR (regs
, I387_FSTAT_REGNUM
))[1] >> 3);
604 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
608 if (val
[0] & (1 << fpreg
))
610 int regnum
= (fpreg
+ 8 - top
) % 8 + I387_ST0_REGNUM
;
611 tag
= i387_tag (FXSAVE_ADDR (regs
, regnum
));
616 ftag
|= tag
<< (2 * fpreg
);
618 val
[0] = ftag
& 0xff;
619 val
[1] = (ftag
>> 8) & 0xff;
621 regcache_raw_supply (regcache
, i
, val
);
624 regcache_raw_supply (regcache
, i
, FXSAVE_ADDR (regs
, i
));
627 if (regnum
== I387_MXCSR_REGNUM
|| regnum
== -1)
630 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM
, NULL
);
632 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM
,
633 FXSAVE_MXCSR_ADDR (regs
));
636 #undef I387_ST0_REGNUM
637 #undef I387_NUM_XMM_REGS
640 /* Fill register REGNUM (if it is a floating-point or SSE register) in
641 *FXSAVE with the value from REGCACHE. If REGNUM is -1, do this for
642 all registers. This function doesn't touch any of the reserved
646 i387_collect_fxsave (const struct regcache
*regcache
, int regnum
, void *fxsave
)
648 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
652 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
653 gdb_assert (tdep
->num_xmm_regs
> 0);
655 /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the
656 proper definitions for REGCACHE's architecture. */
658 #define I387_ST0_REGNUM tdep->st0_regnum
659 #define I387_NUM_XMM_REGS tdep->num_xmm_regs
661 for (i
= I387_ST0_REGNUM
; i
< I387_MXCSR_REGNUM
; i
++)
662 if (regnum
== -1 || regnum
== i
)
664 /* Most of the FPU control registers occupy only 16 bits in
665 the fxsave area. Give those a special treatment. */
666 if (i
>= I387_FCTRL_REGNUM
&& i
< I387_XMM0_REGNUM
667 && i
!= I387_FIOFF_REGNUM
&& i
!= I387_FOOFF_REGNUM
)
669 unsigned char buf
[4];
671 regcache_raw_collect (regcache
, i
, buf
);
673 if (i
== I387_FOP_REGNUM
)
675 /* The opcode occupies only 11 bits. Make sure we
676 don't touch the other bits. */
677 buf
[1] &= ((1 << 3) - 1);
678 buf
[1] |= ((FXSAVE_ADDR (regs
, i
))[1] & ~((1 << 3) - 1));
680 else if (i
== I387_FTAG_REGNUM
)
682 /* Converting back is much easier. */
687 ftag
= (buf
[1] << 8) | buf
[0];
691 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
693 int tag
= (ftag
>> (fpreg
* 2)) & 3;
696 buf
[0] |= (1 << fpreg
);
699 memcpy (FXSAVE_ADDR (regs
, i
), buf
, 2);
702 regcache_raw_collect (regcache
, i
, FXSAVE_ADDR (regs
, i
));
705 if (regnum
== I387_MXCSR_REGNUM
|| regnum
== -1)
706 regcache_raw_collect (regcache
, I387_MXCSR_REGNUM
,
707 FXSAVE_MXCSR_ADDR (regs
));
709 #undef I387_ST0_REGNUM
710 #undef I387_NUM_XMM_REGS
713 /* Fill register REGNUM (if it is a floating-point or SSE register) in
714 *FXSAVE with the value in GDB's register cache. If REGNUM is -1, do
715 this for all registers. This function doesn't touch any of the
716 reserved bits in *FXSAVE. */
719 i387_fill_fxsave (void *fxsave
, int regnum
)
721 i387_collect_fxsave (current_regcache
, regnum
, fxsave
);
724 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
728 i387_tag (const unsigned char *raw
)
731 unsigned int exponent
;
732 unsigned long fraction
[2];
734 integer
= raw
[7] & 0x80;
735 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
736 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
737 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
738 | (raw
[5] << 8) | raw
[4]);
740 if (exponent
== 0x7fff)
745 else if (exponent
== 0x0000)
747 if (fraction
[0] == 0x0000 && fraction
[1] == 0x0000 && !integer
)
773 /* Prepare the FPU stack in REGCACHE for a function return. */
776 i387_return_value (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
778 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
781 /* Define I387_ST0_REGNUM such that we use the proper
782 definitions for the architecture. */
783 #define I387_ST0_REGNUM tdep->st0_regnum
785 /* Set the top of the floating-point register stack to 7. The
786 actual value doesn't really matter, but 7 is what a normal
787 function return would end up with if the program started out with
788 a freshly initialized FPU. */
789 regcache_raw_read_unsigned (regcache
, I387_FSTAT_REGNUM
, &fstat
);
791 regcache_raw_write_unsigned (regcache
, I387_FSTAT_REGNUM
, fstat
);
793 /* Mark %st(1) through %st(7) as empty. Since we set the top of the
794 floating-point register stack to 7, the appropriate value for the
795 tag word is 0x3fff. */
796 regcache_raw_write_unsigned (regcache
, I387_FTAG_REGNUM
, 0x3fff);
798 #undef I387_ST0_REGNUM
This page took 0.046286 seconds and 4 git commands to generate.