1 /* Native-dependent code for the i387.
2 Copyright 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
27 #include "i386-tdep.h"
29 /* FIXME: kettenis/2000-05-21: Right now more than a few i386 targets
30 define their own routines to manage the floating-point registers in
31 GDB's register array. Most (if not all) of these targets use the
32 format used by the "fsave" instruction in their communication with
33 the OS. They should all be converted to use the routines below. */
35 /* At fsave_offset[REGNUM] you'll find the offset to the location in
36 the data structure used by the "fsave" instruction where GDB
37 register REGNUM is stored. */
39 static int fsave_offset
[] =
41 28 + 0 * FPU_REG_RAW_SIZE
, /* FP0_REGNUM through ... */
42 28 + 1 * FPU_REG_RAW_SIZE
,
43 28 + 2 * FPU_REG_RAW_SIZE
,
44 28 + 3 * FPU_REG_RAW_SIZE
,
45 28 + 4 * FPU_REG_RAW_SIZE
,
46 28 + 5 * FPU_REG_RAW_SIZE
,
47 28 + 6 * FPU_REG_RAW_SIZE
,
48 28 + 7 * FPU_REG_RAW_SIZE
, /* ... FP7_REGNUM. */
49 0, /* FCTRL_REGNUM (16 bits). */
50 4, /* FSTAT_REGNUM (16 bits). */
51 8, /* FTAG_REGNUM (16 bits). */
52 16, /* FISEG_REGNUM (16 bits). */
53 12, /* FIOFF_REGNUM. */
54 24, /* FOSEG_REGNUM. */
55 20, /* FOOFF_REGNUM. */
56 18 /* FOP_REGNUM (bottom 11 bits). */
59 #define FSAVE_ADDR(fsave, regnum) (fsave + fsave_offset[regnum - FP0_REGNUM])
62 /* Fill register REGNUM in GDB's register array with the appropriate
63 value from *FSAVE. This function masks off any of the reserved
67 i387_supply_register (int regnum
, char *fsave
)
69 /* Most of the FPU control registers occupy only 16 bits in
70 the fsave area. Give those a special treatment. */
71 if (regnum
>= FPC_REGNUM
72 && regnum
!= FIOFF_REGNUM
&& regnum
!= FOOFF_REGNUM
)
74 unsigned int val
= *(unsigned short *) (FSAVE_ADDR (fsave
, regnum
));
76 if (regnum
== FOP_REGNUM
)
78 val
&= ((1 << 11) - 1);
79 supply_register (regnum
, (char *) &val
);
82 supply_register (regnum
, (char *) &val
);
85 supply_register (regnum
, FSAVE_ADDR (fsave
, regnum
));
88 /* Fill GDB's register array with the floating-point register values
89 in *FSAVE. This function masks off any of the reserved
93 i387_supply_fsave (char *fsave
)
97 for (i
= FP0_REGNUM
; i
< XMM0_REGNUM
; i
++)
98 i387_supply_register (i
, fsave
);
101 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
102 with the value in GDB's register array. If REGNUM is -1, do this
103 for all registers. This function doesn't touch any of the reserved
107 i387_fill_fsave (char *fsave
, int regnum
)
111 for (i
= FP0_REGNUM
; i
< XMM0_REGNUM
; i
++)
112 if (regnum
== -1 || regnum
== i
)
114 /* Most of the FPU control registers occupy only 16 bits in
115 the fsave area. Give those a special treatment. */
117 && i
!= FIOFF_REGNUM
&& i
!= FOOFF_REGNUM
)
121 unsigned short oldval
, newval
;
123 /* The opcode occupies only 11 bits. */
124 oldval
= (*(unsigned short *) (FSAVE_ADDR (fsave
, i
)));
125 newval
= *(unsigned short *) ®isters
[REGISTER_BYTE (i
)];
126 newval
&= ((1 << 11) - 1);
127 newval
|= oldval
& ~((1 << 11) - 1);
128 memcpy (FSAVE_ADDR (fsave
, i
), &newval
, 2);
131 memcpy (FSAVE_ADDR (fsave
, i
), ®isters
[REGISTER_BYTE (i
)], 2);
134 memcpy (FSAVE_ADDR (fsave
, i
), ®isters
[REGISTER_BYTE (i
)],
135 REGISTER_RAW_SIZE (i
));
140 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
141 the data structure used by the "fxsave" instruction where GDB
142 register REGNUM is stored. */
144 static int fxsave_offset
[] =
146 32, /* FP0_REGNUM through ... */
153 144, /* ... FP7_REGNUM (80 bits each). */
154 0, /* FCTRL_REGNUM (16 bits). */
155 2, /* FSTAT_REGNUM (16 bits). */
156 4, /* FTAG_REGNUM (16 bits). */
157 12, /* FISEG_REGNUM (16 bits). */
158 8, /* FIOFF_REGNUM. */
159 20, /* FOSEG_REGNUM (16 bits). */
160 16, /* FOOFF_REGNUM. */
161 6, /* FOP_REGNUM (bottom 11 bits). */
162 160, /* XMM0_REGNUM through ... */
169 272, /* ... XMM7_REGNUM (128 bits each). */
170 24, /* MXCSR_REGNUM. */
173 #define FXSAVE_ADDR(fxsave, regnum) \
174 (fxsave + fxsave_offset[regnum - FP0_REGNUM])
176 static int i387_tag (unsigned char *raw
);
179 /* Fill GDB's register array with the floating-point and SSE register
180 values in *FXSAVE. This function masks off any of the reserved
184 i387_supply_fxsave (char *fxsave
)
188 for (i
= FP0_REGNUM
; i
<= MXCSR_REGNUM
; i
++)
190 /* Most of the FPU control registers occupy only 16 bits in
191 the fxsave area. Give those a special treatment. */
192 if (i
>= FPC_REGNUM
&& i
< XMM0_REGNUM
193 && i
!= FIOFF_REGNUM
&& i
!= FOOFF_REGNUM
)
195 unsigned long val
= *(unsigned short *) (FXSAVE_ADDR (fxsave
, i
));
199 val
&= ((1 << 11) - 1);
200 supply_register (i
, (char *) &val
);
202 else if (i
== FTAG_REGNUM
)
204 /* The fxsave area contains a simplified version of the
205 tag word. We have to look at the actual 80-bit FP
206 data to recreate the traditional i387 tag word. */
208 unsigned long ftag
= 0;
213 fstat
= *(unsigned short *) (FXSAVE_ADDR (fxsave
, FSTAT_REGNUM
));
214 top
= ((fstat
>> 11) & 0x7);
216 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
220 if (val
& (1 << fpreg
))
222 int regnum
= (fpreg
+ 8 - top
) % 8 + FP0_REGNUM
;
223 tag
= i387_tag (FXSAVE_ADDR (fxsave
, regnum
));
228 ftag
|= tag
<< (2 * fpreg
);
230 supply_register (i
, (char *) &ftag
);
233 supply_register (i
, (char *) &val
);
236 supply_register (i
, FXSAVE_ADDR (fxsave
, i
));
240 /* Fill register REGNUM (if it is a floating-point or SSE register) in
241 *FXSAVE with the value in GDB's register array. If REGNUM is -1, do
242 this for all registers. This function doesn't touch any of the
243 reserved bits in *FXSAVE. */
246 i387_fill_fxsave (char *fxsave
, int regnum
)
250 for (i
= FP0_REGNUM
; i
<= MXCSR_REGNUM
; i
++)
251 if (regnum
== -1 || regnum
== i
)
253 /* Most of the FPU control registers occupy only 16 bits in
254 the fxsave area. Give those a special treatment. */
255 if (i
>= FPC_REGNUM
&& i
< XMM0_REGNUM
256 && i
!= FIOFF_REGNUM
&& i
!= FDOFF_REGNUM
)
260 unsigned short oldval
, newval
;
262 /* The opcode occupies only 11 bits. */
263 oldval
= (*(unsigned short *) (FXSAVE_ADDR (fxsave
, i
)));
264 newval
= *(unsigned short *) ®isters
[REGISTER_BYTE (i
)];
265 newval
&= ((1 << 11) - 1);
266 newval
|= oldval
& ~((1 << 11) - 1);
267 memcpy (FXSAVE_ADDR (fxsave
, i
), &newval
, 2);
269 else if (i
== FTAG_REGNUM
)
271 /* Converting back is much easier. */
273 unsigned short val
= 0;
277 ftag
= *(unsigned short *) ®isters
[REGISTER_BYTE (i
)];
279 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
281 int tag
= (ftag
>> (fpreg
* 2)) & 3;
287 memcpy (FXSAVE_ADDR (fxsave
, i
), &val
, 2);
290 memcpy (FXSAVE_ADDR (fxsave
, i
),
291 ®isters
[REGISTER_BYTE (i
)], 2);
294 memcpy (FXSAVE_ADDR (fxsave
, i
), ®isters
[REGISTER_BYTE (i
)],
295 REGISTER_RAW_SIZE (i
));
299 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
303 i387_tag (unsigned char *raw
)
306 unsigned int exponent
;
307 unsigned long fraction
[2];
309 integer
= raw
[7] & 0x80;
310 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
311 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
312 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
313 | (raw
[5] << 8) | raw
[4]);
315 if (exponent
== 0x7fff)
320 else if (exponent
== 0x0000)
322 if (fraction
[0] == 0x0000 && fraction
[1] == 0x0000 && !integer
)
This page took 0.037364 seconds and 4 git commands to generate.