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. */
28 #if GDB_MULTI_ARCH > 0
29 #include "i386-tdep.h"
32 /* FIXME: kettenis/2000-05-21: Right now more than a few i386 targets
33 define their own routines to manage the floating-point registers in
34 GDB's register array. Most (if not all) of these targets use the
35 format used by the "fsave" instruction in their communication with
36 the OS. They should all be converted to use the routines below. */
38 /* At fsave_offset[REGNUM] you'll find the offset to the location in
39 the data structure used by the "fsave" instruction where GDB
40 register REGNUM is stored. */
42 static int fsave_offset
[] =
44 28 + 0 * FPU_REG_RAW_SIZE
, /* FP0_REGNUM through ... */
45 28 + 1 * FPU_REG_RAW_SIZE
,
46 28 + 2 * FPU_REG_RAW_SIZE
,
47 28 + 3 * FPU_REG_RAW_SIZE
,
48 28 + 4 * FPU_REG_RAW_SIZE
,
49 28 + 5 * FPU_REG_RAW_SIZE
,
50 28 + 6 * FPU_REG_RAW_SIZE
,
51 28 + 7 * FPU_REG_RAW_SIZE
, /* ... FP7_REGNUM. */
52 0, /* FCTRL_REGNUM (16 bits). */
53 4, /* FSTAT_REGNUM (16 bits). */
54 8, /* FTAG_REGNUM (16 bits). */
55 16, /* FCS_REGNUM (16 bits). */
56 12, /* FCOFF_REGNUM. */
58 20, /* FDOFF_REGNUM. */
59 18 /* FOP_REGNUM (bottom 11 bits). */
62 #define FSAVE_ADDR(fsave, regnum) (fsave + fsave_offset[regnum - FP0_REGNUM])
65 /* Fill register REGNUM in GDB's register array with the appropriate
66 value from *FSAVE. This function masks off any of the reserved
70 i387_supply_register (int regnum
, char *fsave
)
72 /* Most of the FPU control registers occupy only 16 bits in
73 the fsave area. Give those a special treatment. */
74 if (regnum
>= FIRST_FPU_CTRL_REGNUM
75 && regnum
!= FCOFF_REGNUM
&& regnum
!= FDOFF_REGNUM
)
77 unsigned int val
= *(unsigned short *) (FSAVE_ADDR (fsave
, regnum
));
79 if (regnum
== FOP_REGNUM
)
81 val
&= ((1 << 11) - 1);
82 supply_register (regnum
, (char *) &val
);
85 supply_register (regnum
, (char *) &val
);
88 supply_register (regnum
, FSAVE_ADDR (fsave
, regnum
));
91 /* Fill GDB's register array with the floating-point register values
92 in *FSAVE. This function masks off any of the reserved
96 i387_supply_fsave (char *fsave
)
100 for (i
= FP0_REGNUM
; i
<= LAST_FPU_CTRL_REGNUM
; i
++)
101 i387_supply_register (i
, fsave
);
104 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
105 with the value in GDB's register array. If REGNUM is -1, do this
106 for all registers. This function doesn't touch any of the reserved
110 i387_fill_fsave (char *fsave
, int regnum
)
114 for (i
= FP0_REGNUM
; i
<= LAST_FPU_CTRL_REGNUM
; i
++)
115 if (regnum
== -1 || regnum
== i
)
117 /* Most of the FPU control registers occupy only 16 bits in
118 the fsave area. Give those a special treatment. */
119 if (i
>= FIRST_FPU_CTRL_REGNUM
120 && i
!= FCOFF_REGNUM
&& i
!= FDOFF_REGNUM
)
124 unsigned short oldval
, newval
;
126 /* The opcode occupies only 11 bits. */
127 oldval
= (*(unsigned short *) (FSAVE_ADDR (fsave
, i
)));
128 newval
= *(unsigned short *) ®isters
[REGISTER_BYTE (i
)];
129 newval
&= ((1 << 11) - 1);
130 newval
|= oldval
& ~((1 << 11) - 1);
131 memcpy (FSAVE_ADDR (fsave
, i
), &newval
, 2);
134 memcpy (FSAVE_ADDR (fsave
, i
), ®isters
[REGISTER_BYTE (i
)], 2);
137 memcpy (FSAVE_ADDR (fsave
, i
), ®isters
[REGISTER_BYTE (i
)],
138 REGISTER_RAW_SIZE (i
));
143 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
144 the data structure used by the "fxsave" instruction where GDB
145 register REGNUM is stored. */
147 static int fxsave_offset
[] =
149 32, /* FP0_REGNUM through ... */
156 144, /* ... FP7_REGNUM (80 bits each). */
157 0, /* FCTRL_REGNUM (16 bits). */
158 2, /* FSTAT_REGNUM (16 bits). */
159 4, /* FTAG_REGNUM (16 bits). */
160 12, /* FCS_REGNUM (16 bits). */
161 8, /* FCOFF_REGNUM. */
162 20, /* FDS_REGNUM (16 bits). */
163 16, /* FDOFF_REGNUM. */
164 6, /* FOP_REGNUM (bottom 11 bits). */
165 160, /* XMM0_REGNUM through ... */
172 272, /* ... XMM7_REGNUM (128 bits each). */
173 24, /* MXCSR_REGNUM. */
176 #define FXSAVE_ADDR(fxsave, regnum) \
177 (fxsave + fxsave_offset[regnum - FP0_REGNUM])
179 static int i387_tag (unsigned char *raw
);
182 /* Fill GDB's register array with the floating-point and SSE register
183 values in *FXSAVE. This function masks off any of the reserved
187 i387_supply_fxsave (char *fxsave
)
191 for (i
= FP0_REGNUM
; i
<= MXCSR_REGNUM
; i
++)
193 /* Most of the FPU control registers occupy only 16 bits in
194 the fxsave area. Give those a special treatment. */
195 if (i
>= FIRST_FPU_CTRL_REGNUM
&& i
< XMM0_REGNUM
196 && i
!= FCOFF_REGNUM
&& i
!= FDOFF_REGNUM
)
198 unsigned long val
= *(unsigned short *) (FXSAVE_ADDR (fxsave
, i
));
202 val
&= ((1 << 11) - 1);
203 supply_register (i
, (char *) &val
);
205 else if (i
== FTAG_REGNUM
)
207 /* The fxsave area contains a simplified version of the
208 tag word. We have to look at the actual 80-bit FP
209 data to recreate the traditional i387 tag word. */
211 unsigned long ftag
= 0;
216 fstat
= *(unsigned short *) (FXSAVE_ADDR (fxsave
, FSTAT_REGNUM
));
217 top
= ((fstat
>> 11) & 0x7);
219 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
223 if (val
& (1 << fpreg
))
225 int regnum
= (fpreg
+ 8 - top
) % 8 + FP0_REGNUM
;
226 tag
= i387_tag (FXSAVE_ADDR (fxsave
, regnum
));
231 ftag
|= tag
<< (2 * fpreg
);
233 supply_register (i
, (char *) &ftag
);
236 supply_register (i
, (char *) &val
);
239 supply_register (i
, FXSAVE_ADDR (fxsave
, i
));
243 /* Fill register REGNUM (if it is a floating-point or SSE register) in
244 *FXSAVE with the value in GDB's register array. If REGNUM is -1, do
245 this for all registers. This function doesn't touch any of the
246 reserved bits in *FXSAVE. */
249 i387_fill_fxsave (char *fxsave
, int regnum
)
253 for (i
= FP0_REGNUM
; i
<= MXCSR_REGNUM
; i
++)
254 if (regnum
== -1 || regnum
== i
)
256 /* Most of the FPU control registers occupy only 16 bits in
257 the fxsave area. Give those a special treatment. */
258 if (i
>= FIRST_FPU_CTRL_REGNUM
&& i
< XMM0_REGNUM
259 && i
!= FCOFF_REGNUM
&& i
!= FDOFF_REGNUM
)
263 unsigned short oldval
, newval
;
265 /* The opcode occupies only 11 bits. */
266 oldval
= (*(unsigned short *) (FXSAVE_ADDR (fxsave
, i
)));
267 newval
= *(unsigned short *) ®isters
[REGISTER_BYTE (i
)];
268 newval
&= ((1 << 11) - 1);
269 newval
|= oldval
& ~((1 << 11) - 1);
270 memcpy (FXSAVE_ADDR (fxsave
, i
), &newval
, 2);
272 else if (i
== FTAG_REGNUM
)
274 /* Converting back is much easier. */
276 unsigned char val
= 0;
280 ftag
= *(unsigned short *) ®isters
[REGISTER_BYTE (i
)];
282 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
284 int tag
= (ftag
>> (fpreg
* 2)) & 3;
287 val
|= (1 << (fpreg
* 2));
290 memcpy (FXSAVE_ADDR (fxsave
, i
), &val
, 2);
293 memcpy (FXSAVE_ADDR (fxsave
, i
),
294 ®isters
[REGISTER_BYTE (i
)], 2);
297 memcpy (FXSAVE_ADDR (fxsave
, i
), ®isters
[REGISTER_BYTE (i
)],
298 REGISTER_RAW_SIZE (i
));
302 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
306 i387_tag (unsigned char *raw
)
309 unsigned int exponent
;
310 unsigned long fraction
[2];
312 integer
= raw
[7] & 0x80;
313 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
314 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
315 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
316 | (raw
[5] << 8) | raw
[4]);
318 if (exponent
== 0x7fff)
323 else if (exponent
== 0x0000)
325 if (fraction
[0] == 0x0000 && fraction
[1] == 0x0000 && !integer
)
This page took 0.036027 seconds and 4 git commands to generate.